fix: migrations

src/main/kotlin/fr/postgresjson/definition/Function.kt

@@ -51,7 +51,12 @@ open class Function(
     class FunctionNotFound(cause: Throwable? = null): ParseException("Function not found in script", cause)
 
     fun getDefinition(): String {
-        return "$name (" + parameters.joinToString(", ") + ") $returns"
+        return parameters
+            .filter { it.direction == Parameter.Direction.IN }
+            .joinToString(", ") { "${it.name} ${it.type}" }.let {
+                "$name ($it) $returns"
+            }
+
     }
 
     fun getParametersIndexedByName(): Map<String, Parameter> {
@@ -64,8 +69,8 @@ open class Function(
         return other.getDefinition() == this.getDefinition()
     }
 
-    infix fun `is same`(other: Function): Boolean {
-        return other.script == this.script
+    infix fun `is different from`(other: Function): Boolean {
+        return other.script != this.script
     }
 
     companion object {

src/main/kotlin/fr/postgresjson/migration/Function.kt

@@ -16,8 +16,8 @@ data class Function(
     override var doExecute: Action? = null
 
     init {
-        if (up.name !== down.name) {
-            throw Exception("UP and DOWN migration must be the same")
+        if (up.name != down.name) {
+            throw Exception("UP and DOWN migration must have the same name [${up.name} !== ${down.name}]")
         }
     }
 
@@ -79,4 +79,8 @@ data class Function(
             it.doExecute = this.doExecute
         }
     }
+
+    infix fun `is different from`(other: DefinitionFunction): Boolean {
+        return other.script != this.up.script
+    }
 }

src/main/kotlin/fr/postgresjson/migration/Migrations.kt

@@ -122,23 +122,17 @@ data class Migrations private constructor(
     internal class DownMigrationNotDefined(path: String, cause: FileNotFoundException):
         Throwable("The file $path whas not found", cause)
 
-    fun addFunction(definition: DefinitionFunction, callback: (Function) -> Unit = {}): Migrations {
-        if (functions[definition.name] === null) {
-            // TODO define down migration
-            functions[definition.name] = Function(definition, definition, connection).apply {
+    fun addFunction(newDefinition: DefinitionFunction, callback: (Function) -> Unit = {}): Migrations {
+        val currentFunction = functions[newDefinition.name]
+        if (currentFunction === null || currentFunction `is different from` newDefinition) {
+            functions[newDefinition.name] = Function(newDefinition, newDefinition, connection).apply {
                 doExecute = Action.UP
             }
         } else {
-            functions[definition.name]!!.apply {
-                if (up `is same` definition) {
-                    doExecute = Action.OK
-                } else {
-                    doExecute = Action.UP
-                }
-            }
+            functions[newDefinition.name]?.doExecute = Action.OK
         }
 
-        callback(functions[definition.name]!!)
+        callback(functions[newDefinition.name]!!)
 
         return this
     }