set JVM to 11

.gitignore

@@ -2,4 +2,5 @@
 /out/
 /build/
 .gradle
-/var/log/
+/var/log/
+/.idea/*

.idea/.gitignore

@@ -6,4 +6,5 @@
 /compiler.xml
 /uiDesigner.xml
 /dataSources.xml
-/sonarlint/
+/sonarlint/
+/jarRepositories.xml

.idea/codeStyles/Project.xml

@@ -1,7 +1,13 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
     <JetCodeStyleSettings>
+      <option name="PACKAGES_TO_USE_STAR_IMPORTS">
+        <value>
+          <package name="java.util" withSubpackages="true" static="false" />
+        </value>
+      </option>
       <option name="SPACE_BEFORE_EXTEND_COLON" value="false" />
+      <option name="NAME_COUNT_TO_USE_STAR_IMPORT" value="2147483647" />
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
     </JetCodeStyleSettings>
     <codeStyleSettings language="kotlin">

.idea/gradle.xml

@@ -8,13 +8,11 @@
         <option name="testRunner" value="PLATFORM" />
         <option name="distributionType" value="DEFAULT_WRAPPED" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="gradleHome" value="$PROJECT_DIR$" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />
           </set>
         </option>
-        <option name="useAutoImport" value="true" />
         <option name="useQualifiedModuleNames" value="true" />
       </GradleProjectSettings>
     </option>

.idea/kotlinc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Kotlin2JvmCompilerArguments">
+    <option name="jvmTarget" value="11" />
+  </component>
+</project>

.idea/misc.xml

@@ -1,7 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <component name="FrameworkDetectionExcludesConfiguration">
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" project-jdk-name="11" project-jdk-type="JavaSDK">
+    <file type="web" url="file://$PROJECT_DIR$" />
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="adopt-openjdk-11" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
   <component name="TaskProjectConfiguration">

.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/postgres-json.iml" filepath="$PROJECT_DIR$/.idea/postgres-json.iml" />
-    </modules>
-  </component>
-</project>

.idea/postgres-json.iml

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <excludeFolder url="file://$MODULE_DIR$/var" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

.idea/runConfigurations/Check.xml

@@ -0,0 +1,7 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Check" type="CompoundRunConfigurationType">
+    <toRun name="tests" type="JUnit" />
+    <toRun name="Lint" type="GradleRunConfiguration" />
+    <method v="2" />
+  </configuration>
+</component>

.idea/runConfigurations/Lint.xml

@@ -0,0 +1,31 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Lint" type="GradleRunConfiguration" factoryName="Gradle" singleton="false">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value="ktlintCheck" />
+        </list>
+      </option>
+      <option name="vmOptions" value="" />
+    </ExternalSystemSettings>
+    <extension name="net.ashald.envfile">
+      <option name="IS_ENABLED" value="false" />
+      <option name="IS_SUBST" value="false" />
+      <option name="IS_PATH_MACRO_SUPPORTED" value="false" />
+      <option name="IS_IGNORE_MISSING_FILES" value="false" />
+      <option name="IS_ENABLE_EXPERIMENTAL_INTEGRATIONS" value="false" />
+      <ENTRIES>
+        <ENTRY IS_ENABLED="true" PARSER="runconfig" />
+      </ENTRIES>
+    </extension>
+    <GradleScriptDebugEnabled>true</GradleScriptDebugEnabled>
+    <method v="2" />
+  </configuration>
+</component>

.idea/runConfigurations/Publish_To_MavenLocal.xml

@@ -0,0 +1,31 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Publish To MavenLocal" type="GradleRunConfiguration" factoryName="Gradle" singleton="true">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value="publishToMavenLocal" />
+        </list>
+      </option>
+      <option name="vmOptions" value="" />
+    </ExternalSystemSettings>
+    <extension name="net.ashald.envfile">
+      <option name="IS_ENABLED" value="false" />
+      <option name="IS_SUBST" value="false" />
+      <option name="IS_PATH_MACRO_SUPPORTED" value="false" />
+      <option name="IS_IGNORE_MISSING_FILES" value="false" />
+      <option name="IS_ENABLE_EXPERIMENTAL_INTEGRATIONS" value="false" />
+      <ENTRIES>
+        <ENTRY IS_ENABLED="true" PARSER="runconfig" />
+      </ENTRIES>
+    </extension>
+    <GradleScriptDebugEnabled>true</GradleScriptDebugEnabled>
+    <method v="2" />
+  </configuration>
+</component>

.idea/runConfigurations/Test_and_Publish_To_MavenLocal.xml

@@ -0,0 +1,34 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Test and Publish To MavenLocal" type="GradleRunConfiguration" factoryName="Gradle" singleton="true">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value="publishToMavenLocal" />
+        </list>
+      </option>
+      <option name="vmOptions" value="" />
+    </ExternalSystemSettings>
+    <extension name="net.ashald.envfile">
+      <option name="IS_ENABLED" value="false" />
+      <option name="IS_SUBST" value="false" />
+      <option name="IS_PATH_MACRO_SUPPORTED" value="false" />
+      <option name="IS_IGNORE_MISSING_FILES" value="false" />
+      <option name="IS_ENABLE_EXPERIMENTAL_INTEGRATIONS" value="false" />
+      <ENTRIES>
+        <ENTRY IS_ENABLED="true" PARSER="runconfig" />
+      </ENTRIES>
+    </extension>
+    <GradleScriptDebugEnabled>true</GradleScriptDebugEnabled>
+    <method v="2">
+      <option name="RunConfigurationTask" enabled="true" run_configuration_name="Lint" run_configuration_type="GradleRunConfiguration" />
+      <option name="RunConfigurationTask" enabled="true" run_configuration_name="tests" run_configuration_type="JUnit" />
+    </method>
+  </configuration>
+</component>

.idea/runConfigurations/tests.xml

@@ -1,6 +1,7 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="tests" type="JUnit" factoryName="JUnit">
+  <configuration default="false" name="tests" type="JUnit" factoryName="JUnit" singleton="false">
     <module name="postgresjson.test" />
+    <useClassPathOnly />
     <extension name="net.ashald.envfile">
       <option name="IS_ENABLED" value="false" />
       <option name="IS_SUBST" value="false" />
@@ -12,7 +13,7 @@
       </ENTRIES>
     </extension>
     <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="true" />
-    <option name="ALTERNATIVE_JRE_PATH" value="11" />
+    <option name="ALTERNATIVE_JRE_PATH" value="$USER_HOME$/.jdks/adopt-openjdk-11.0.5" />
     <option name="MAIN_CLASS_NAME" value="" />
     <option name="METHOD_NAME" value="" />
     <option name="TEST_OBJECT" value="directory" />

build.gradle.kts

@@ -1,24 +1,36 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
 plugins {
+    jacoco
+
     id("maven-publish")
-    id("org.jetbrains.kotlin.jvm") version "1.3.31"
+    id("org.jetbrains.kotlin.jvm") version "1.3.50"
+
+    id("org.jlleitschuh.gradle.ktlint") version "8.2.0"
+    id("org.owasp.dependencycheck") version "5.1.0"
+    id("fr.coppernic.versioning") version "3.1.2"
 }
 
-apply(plugin = "kotlin")
+group = "flecomte"
-
+version = versioning.info.tag
-group = "fr.postgresjson"
-version = "0.1"
 
 repositories {
     mavenCentral()
     jcenter()
 }
 
+tasks.withType<KotlinCompile> {
+    kotlinOptions {
+        jvmTarget = "11"
+    }
+}
+
 dependencies {
     implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
     implementation("org.jetbrains.kotlin:kotlin-reflect:1.3.31")
     implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.9.9")
     implementation("com.fasterxml.jackson.datatype:jackson-datatype-joda:2.9.9")
-    implementation("com.github.jasync-sql:jasync-postgresql:0.9.53")
+    implementation("com.github.jasync-sql:jasync-postgresql:1.0.7")
     implementation("org.slf4j:slf4j-api:1.7.26")
 
     testImplementation("ch.qos.logback:logback-classic:1.2.3")
@@ -28,14 +40,27 @@ dependencies {
     testImplementation("org.amshove.kluent:kluent:1.47")
 }
 
-publishing {
+val sourcesJar by tasks.creating(Jar::class) {
-    publications {
+    archiveClassifier.set("sources")
-        create<MavenPublication>("maven") {
+    from(sourceSets.getByName("main").allSource)
-            groupId = "fr.postgresjson"
+}
-            artifactId = "postgresjson"
-            version = "0.1"
 
-            from(components["java"])
+publishing {
+    repositories {
+        maven {
+            name = "postgres-json"
+            url = uri("https://maven.pkg.github.com/flecomte/postgres-json")
+            credentials {
+                username = System.getenv("GITHUB_USERNAME")
+                password = System.getenv("GITHUB_TOKEN")
+            }
         }
     }
-}
+
+    publications {
+        create<MavenPublication>("postgres-json") {
+            from(components["java"])
+            artifact(sourcesJar)
+        }
+    }
+}

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,5 @@
-#Wed May 29 17:08:27 CEST 2019
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.6.2-all.zip
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.3-all.zip
+zipStoreBase=GRADLE_USER_HOME

settings.gradle

@@ -1 +1 @@
-rootProject.name = 'postgresjson'
+rootProject.name = 'postgres-json'

src/main/kotlin/fr/postgresjson/connexion/Connection.kt

@@ -6,11 +6,13 @@ import com.github.jasync.sql.db.QueryResult
 import com.github.jasync.sql.db.pool.ConnectionPool
 import com.github.jasync.sql.db.postgresql.PostgreSQLConnection
 import com.github.jasync.sql.db.postgresql.PostgreSQLConnectionBuilder
+import com.github.jasync.sql.db.util.length
 import fr.postgresjson.entity.EntityI
+import fr.postgresjson.entity.Serializable
 import fr.postgresjson.serializer.Serializer
 import fr.postgresjson.utils.LoggerDelegate
 import org.slf4j.Logger
-import java.util.concurrent.CompletableFuture
+import java.util.concurrent.*
 
 typealias SelectOneCallback<T> = QueryResult.(T?) -> Unit
 typealias SelectCallback<T> = QueryResult.(List<T>) -> Unit
@@ -22,7 +24,7 @@ class Connection(
     private val password: String,
     private val host: String = "localhost",
     private val port: Int = 5432
-): Executable {
+) : Executable {
     private lateinit var connection: ConnectionPool<PostgreSQLConnection>
     private val serializer = Serializer()
     private val logger: Logger? by LoggerDelegate()
@@ -38,14 +40,14 @@ class Connection(
 
     fun <A> inTransaction(f: (Connection) -> CompletableFuture<A>) = connect().inTransaction(f)
 
-    override fun <R: EntityI<*>> select(
+    override fun <R : EntityI> select(
         sql: String,
         typeReference: TypeReference<R>,
         values: List<Any?>,
         block: (QueryResult, R?) -> Unit
     ): R? {
         val primaryObject = values.firstOrNull {
-            it is EntityI<*> && typeReference.type.typeName == it::class.java.name
+            it is EntityI && typeReference.type.typeName == it::class.java.name
         } as R?
         val result = exec(sql, compileArgs(values))
         val json = result.rows[0].getString(0)
@@ -62,14 +64,14 @@ class Connection(
         }
     }
 
-    inline fun <reified R: EntityI<*>> selectOne(
+    inline fun <reified R : EntityI> selectOne(
         sql: String,
         values: List<Any?> = emptyList(),
         noinline block: SelectOneCallback<R> = {}
     ): R? =
-        select(sql, object: TypeReference<R>() {}, values, block)
+        select(sql, object : TypeReference<R>() {}, values, block)
 
-    override fun <R: EntityI<*>> select(
+    override fun <R : EntityI> select(
         sql: String,
         typeReference: TypeReference<R>,
         values: Map<String, Any?>,
@@ -80,14 +82,14 @@ class Connection(
         }
     }
 
-    inline fun <reified R: EntityI<*>> selectOne(
+    inline fun <reified R : EntityI> selectOne(
         sql: String,
         values: Map<String, Any?>,
         noinline block: SelectOneCallback<R> = {}
     ): R? =
-        select(sql, object: TypeReference<R>() {}, values, block)
+        select(sql, object : TypeReference<R>() {}, values, block)
 
-    override fun <R: EntityI<*>> select(
+    override fun <R : EntityI> select(
         sql: String,
         typeReference: TypeReference<List<R>>,
         values: List<Any?>,
@@ -96,7 +98,7 @@ class Connection(
         val result = exec(sql, compileArgs(values))
         val json = result.rows[0].getString(0)
         return if (json === null) {
-            listOf<EntityI<*>>() as List<R>
+            listOf<EntityI>() as List<R>
         } else {
             serializer.deserializeList(json, typeReference)
         }.also {
@@ -104,14 +106,14 @@ class Connection(
         }
     }
 
-    inline fun <reified R: EntityI<*>> select(
+    inline fun <reified R : EntityI> select(
         sql: String,
         values: List<Any?> = emptyList(),
         noinline block: SelectCallback<R> = {}
     ): List<R> =
-        select(sql, object: TypeReference<List<R>>() {}, values, block)
+        select(sql, object : TypeReference<List<R>>() {}, values, block)
 
-    override fun <R: EntityI<*>> select(
+    override fun <R : EntityI> select(
         sql: String,
         page: Int,
         limit: Int,
@@ -125,13 +127,13 @@ class Connection(
             .plus("limit" to limit)
 
         val line = replaceArgs(sql, newValues) {
-            exec(this.sql, compileArgs(this.parameters))
+            exec(this.sql, this.parameters)
         }
 
         return line.run {
             val json = rows[0].getString(0)
             val entities = if (json === null) {
-                listOf<EntityI<*>>() as List<R>
+                listOf<EntityI>() as List<R>
             } else {
                 serializer.deserializeList(json, typeReference)
             }
@@ -146,16 +148,16 @@ class Connection(
         }
     }
 
-    inline fun <reified R: EntityI<*>> select(
+    inline fun <reified R : EntityI> select(
         sql: String,
         page: Int,
         limit: Int,
         values: Map<String, Any?> = emptyMap(),
         noinline block: SelectPaginatedCallback<R> = {}
     ): Paginated<R> =
-        select(sql, page, limit, object: TypeReference<List<R>>() {}, values, block)
+        select(sql, page, limit, object : TypeReference<List<R>>() {}, values, block)
 
-    override fun <R: EntityI<*>> select(
+    override fun <R : EntityI> select(
         sql: String,
         typeReference: TypeReference<List<R>>,
         values: Map<String, Any?>,
@@ -166,16 +168,17 @@ class Connection(
         }
     }
 
-    inline fun <reified R: EntityI<*>> select(
+    inline fun <reified R : EntityI> select(
         sql: String,
         values: Map<String, Any?>,
         noinline block: SelectCallback<R> = {}
     ): List<R> =
-        select(sql, object: TypeReference<List<R>>() {}, values, block)
+        select(sql, object : TypeReference<List<R>>() {}, values, block)
 
     override fun exec(sql: String, values: List<Any?>): QueryResult {
-        return stopwatchQuery(sql, values) {
+        val compiledValues = compileArgs(values)
-            connect().sendPreparedStatement(sql, compileArgs(values)).join()
+        return stopwatchQuery(sql, compiledValues) {
+            connect().sendPreparedStatement(sql, compiledValues).join()
         }
     }
 
@@ -185,18 +188,25 @@ class Connection(
         }
     }
 
-    override fun sendQuery(sql: String): QueryResult {
+    override fun sendQuery(sql: String, values: List<Any?>): Int {
-        return stopwatchQuery(sql) {
+        val compiledValues = compileArgs(values)
-            connect().sendQuery(sql).join()
+        return stopwatchQuery(sql, compiledValues) {
+            replaceArgsIntoSql(sql, compiledValues) {
+                connect().sendQuery(it).join().rowsAffected.toInt()
+            }
+        }
+    }
+
+    override fun sendQuery(sql: String, values: Map<String, Any?>): Int {
+        return replaceArgs(sql, values) {
+            sendQuery(this.sql, this.parameters)
         }
     }
 
     private fun compileArgs(values: List<Any?>): List<Any?> {
         return values.map {
-            if (it is EntityI<*>) {
+            if (it is Serializable || (it is List<*> && it.firstOrNull() is Serializable)) {
-                serializer.serialize(it).apply {
+                serializer.serialize(it)
-                    serializer.collection.set<Any?, EntityI<Any?>>(it as EntityI<Any?>)
-                }
             } else {
                 it
             }
@@ -207,32 +217,66 @@ class Connection(
         val paramRegex = "(?<!:):([a-zA-Z0-9_-]+)".toRegex(RegexOption.IGNORE_CASE)
         val newArgs = paramRegex.findAll(sql).map { match ->
             val name = match.groups[1]!!.value
-            values[name] ?: error("Parameter $name missing")
+            values[name] ?: values[name.trimStart('_')] ?: error("Parameter $name missing")
         }.toList()
 
         var newSql = sql
         values.forEach { (key, _) ->
-            val regex = ":$key".toRegex()
+            val regex = ":_?$key".toRegex()
             newSql = newSql.replace(regex, "?")
         }
 
         return block(ParametersQuery(newSql, newArgs))
     }
 
+    private fun <T> replaceArgsIntoSql(sql: String, values: List<Any?>, block: (String) -> T): T {
+        val paramRegex = "(?<!\\?)(\\?)(?!\\?)".toRegex(RegexOption.IGNORE_CASE)
+        var i = 0
+        if (values.isNotEmpty()) {
+            val newSql = paramRegex.replace(sql) {
+                values[i] ?: error("Parameter $i missing")
+                val valToReplace = values[i].toString()
+                ++i
+                "'$valToReplace'"
+            }
+
+            return block(newSql)
+        }
+
+        return block(sql)
+    }
+
     data class ParametersQuery(val sql: String, val parameters: List<Any?>)
 
     private fun <T> stopwatchQuery(sql: String, values: List<Any?> = emptyList(), callback: () -> T): T {
-        val sqlForLog = "\n${sql.prependIndent()}"
         try {
             val start = System.currentTimeMillis()
             val result = callback()
             val duration = (System.currentTimeMillis() - start)
-            logger?.debug("$duration ms for query: $sqlForLog", values)
+            val resultText = when (result) {
+                null -> "with no result"
+                is QueryResult -> result.rows.firstOrNull()?.joinToString(", ")?.let { text ->
+                    if (text.length > 100) "${text.take(100)}... (size: ${text.length})" else text
+                } ?: "with no result"
+                else -> "unknown"
+            }
+            val args = """
+                |Query ($duration ms):
+                |${sql.trimIndent().prependIndent()}
+                |Arguments (${values.length}):
+                |${values.joinToString("\n").ifBlank { "No arguments" }.prependIndent()}
+                |Result:
+                |${resultText.trimIndent().prependIndent()}
+            """.trimMargin().prependIndent(" > ")
+            logger?.debug("Query executed in $duration ms \n{}", args)
             return result
         } catch (e: Throwable) {
-            logger?.info("Query Error: $sqlForLog, $values", e)
+            logger?.info("""
+                Query Error: 
+                ${sql.prependIndent()}, 
+                ${values.joinToString(", ").prependIndent()}
+            """.trimIndent(), e)
             throw e
         }
-
     }
 }

src/main/kotlin/fr/postgresjson/connexion/EmbedExecutable.kt

@@ -13,33 +13,33 @@ interface EmbedExecutable {
     /**
      * Select One entity with list of parameters
      */
-    fun <R: EntityI<*>> select(
+    fun <R : EntityI> select(
         typeReference: TypeReference<R>,
         values: List<Any?> = emptyList(),
         block: SelectOneCallback<R> = {}
     ): R?
 
-    fun <R: EntityI<*>> select(
+    fun <R : EntityI> select(
         typeReference: TypeReference<R>,
         values: Map<String, Any?>,
         block: SelectOneCallback<R> = {}
     ): R?
 
     /* Select Miltiples */
-    fun <R: EntityI<*>> select(
+    fun <R : EntityI> select(
         typeReference: TypeReference<List<R>>,
         values: List<Any?> = emptyList(),
         block: SelectCallback<R> = {}
     ): List<R>
 
-    fun <R: EntityI<*>> select(
+    fun <R : EntityI> select(
         typeReference: TypeReference<List<R>>,
         values: Map<String, Any?>,
         block: SelectCallback<R> = {}
     ): List<R>
 
     /* Select Paginated */
-    fun <R: EntityI<*>> select(
+    fun <R : EntityI> select(
         page: Int,
         limit: Int,
         typeReference: TypeReference<List<R>>,
@@ -49,4 +49,14 @@ interface EmbedExecutable {
 
     fun exec(values: List<Any?> = emptyList()): QueryResult
     fun exec(values: Map<String, Any?>): QueryResult
+    fun exec(vararg values: Pair<String, Any?>): QueryResult = exec(values.toMap())
+
+    fun perform(values: List<Any?>) { exec(values) }
+    fun perform(values: Map<String, Any?>) { exec(values) }
+    fun perform(vararg values: Pair<String, Any?>) = perform(values.toMap())
+
+    fun sendQuery(values: List<Any?> = emptyList()): Int
+    fun sendQuery(values: Map<String, Any?>): Int
+    fun sendQuery(vararg values: Pair<String, Any?>): Int =
+        sendQuery(values.toMap())
 }

src/main/kotlin/fr/postgresjson/connexion/Executable.kt

@@ -7,14 +7,14 @@ import fr.postgresjson.entity.EntityI
 interface Executable {
     /* Select One */
 
-    fun <R: EntityI<*>> select(
+    fun <R : EntityI> select(
         sql: String,
         typeReference: TypeReference<R>,
         values: List<Any?> = emptyList(),
         block: SelectOneCallback<R> = {}
     ): R?
 
-    fun <R: EntityI<*>> select(
+    fun <R : EntityI> select(
         sql: String,
         typeReference: TypeReference<R>,
         values: Map<String, Any?>,
@@ -23,14 +23,14 @@ interface Executable {
 
     /* Select Miltiples */
 
-    fun <R: EntityI<*>> select(
+    fun <R : EntityI> select(
         sql: String,
         typeReference: TypeReference<List<R>>,
         values: List<Any?> = emptyList(),
         block: SelectCallback<R> = {}
     ): List<R>
 
-    fun <R: EntityI<*>> select(
+    fun <R : EntityI> select(
         sql: String,
         typeReference: TypeReference<List<R>>,
         values: Map<String, Any?>,
@@ -39,7 +39,7 @@ interface Executable {
 
     /* Select Paginated */
 
-    fun <R: EntityI<*>> select(
+    fun <R : EntityI> select(
         sql: String,
         page: Int,
         limit: Int,
@@ -50,5 +50,6 @@ interface Executable {
 
     fun exec(sql: String, values: List<Any?> = emptyList()): QueryResult
     fun exec(sql: String, values: Map<String, Any?>): QueryResult
-    fun sendQuery(sql: String): QueryResult
+    fun sendQuery(sql: String, values: List<Any?> = emptyList()): Int
+    fun sendQuery(sql: String, values: Map<String, Any?>): Int
 }

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

@@ -5,7 +5,7 @@ import com.github.jasync.sql.db.QueryResult
 import fr.postgresjson.definition.Function
 import fr.postgresjson.entity.EntityI
 
-class Function(val definition: Function, override val connection: Connection): EmbedExecutable {
+class Function(val definition: Function, override val connection: Connection) : EmbedExecutable {
     override fun toString(): String {
         return definition.name
     }
@@ -17,7 +17,7 @@ class Function(val definition: Function, override val connection: Connection): E
     /**
      * Select One entity with list of parameters
      */
-    override fun <R: EntityI<*>> select(
+    override fun <R : EntityI> select(
         typeReference: TypeReference<R>,
         values: List<Any?>,
         block: (QueryResult, R?) -> Unit
@@ -28,22 +28,22 @@ class Function(val definition: Function, override val connection: Connection): E
         return connection.select(sql, typeReference, values, block)
     }
 
-    inline fun <reified R: EntityI<*>> selectOne(
+    inline fun <reified R : EntityI> selectOne(
         values: List<Any?> = emptyList(),
         noinline block: SelectOneCallback<R> = {}
     ): R? =
-        select(object: TypeReference<R>() {}, values, block)
+        select(object : TypeReference<R>() {}, values, block)
 
-    inline fun <reified R: EntityI<*>> selectOne(
+    inline fun <reified R : EntityI> selectOne(
         value: R,
         noinline block: SelectOneCallback<R> = {}
     ): R? =
-        select(object: TypeReference<R>() {}, listOf(value), block)
+        select(object : TypeReference<R>() {}, listOf(value), block)
 
     /**
      * Select One entity with named parameters
      */
-    override fun <R: EntityI<*>> select(
+    override fun <R : EntityI> select(
         typeReference: TypeReference<R>,
         values: Map<String, Any?>,
         block: (QueryResult, R?) -> Unit
@@ -54,13 +54,13 @@ class Function(val definition: Function, override val connection: Connection): E
         return connection.select(sql, typeReference, values, block)
     }
 
-    inline fun <reified R: EntityI<*>> selectOne(
+    inline fun <reified R : EntityI> selectOne(
         values: Map<String, Any?>,
         noinline block: SelectOneCallback<R> = {}
     ): R? =
-        select(object: TypeReference<R>() {}, values, block)
+        select(object : TypeReference<R>() {}, values, block)
 
-    inline fun <reified R: EntityI<*>> selectOne(
+    inline fun <reified R : EntityI> selectOne(
         vararg values: Pair<String, Any?>,
         noinline block: SelectOneCallback<R> = {}
     ): R? =
@@ -71,7 +71,7 @@ class Function(val definition: Function, override val connection: Connection): E
     /**
      * Select list of entities with list of parameters
      */
-    override fun <R: EntityI<*>> select(
+    override fun <R : EntityI> select(
         typeReference: TypeReference<List<R>>,
         values: List<Any?>,
         block: (QueryResult, List<R>) -> Unit
@@ -82,16 +82,16 @@ class Function(val definition: Function, override val connection: Connection): E
         return connection.select(sql, typeReference, values, block)
     }
 
-    inline fun <reified R: EntityI<*>> select(
+    inline fun <reified R : EntityI> select(
         values: List<Any?> = emptyList(),
         noinline block: SelectCallback<R> = {}
     ): List<R> =
-        select(object: TypeReference<List<R>>() {}, values, block)
+        select(object : TypeReference<List<R>>() {}, values, block)
 
     /**
      * Select list of entities with named parameters
      */
-    override fun <R: EntityI<*>> select(
+    override fun <R : EntityI> select(
         typeReference: TypeReference<List<R>>,
         values: Map<String, Any?>,
         block: (QueryResult, List<R>) -> Unit
@@ -102,13 +102,13 @@ class Function(val definition: Function, override val connection: Connection): E
         return connection.select(sql, typeReference, values, block)
     }
 
-    inline fun <reified R: EntityI<*>> select(
+    inline fun <reified R : EntityI> select(
         values: Map<String, Any?>,
         noinline block: SelectCallback<R> = {}
     ): List<R> =
-        select(object: TypeReference<List<R>>() {}, values, block)
+        select(object : TypeReference<List<R>>() {}, values, block)
 
-    inline fun <reified R: EntityI<*>> select(
+    inline fun <reified R : EntityI> select(
         vararg values: Pair<String, Any?>,
         noinline block: SelectCallback<R> = {}
     ): List<R> =
@@ -119,7 +119,7 @@ class Function(val definition: Function, override val connection: Connection): E
     /**
      * Select Multiple with pagination
      */
-    override fun <R: EntityI<*>> select(
+    override fun <R : EntityI> select(
         page: Int,
         limit: Int,
         typeReference: TypeReference<List<R>>,
@@ -137,21 +137,21 @@ class Function(val definition: Function, override val connection: Connection): E
         return connection.select(sql, page, limit, typeReference, values, block)
     }
 
-    inline fun <reified R: EntityI<*>> select(
+    inline fun <reified R : EntityI> select(
         page: Int,
         limit: Int,
         values: Map<String, Any?> = emptyMap(),
         noinline block: SelectPaginatedCallback<R> = {}
     ): Paginated<R> =
-        select(page, limit, object: TypeReference<List<R>>() {}, values, block)
+        select(page, limit, object : TypeReference<List<R>>() {}, values, block)
 
-    inline fun <reified R: EntityI<*>> select(
+    inline fun <reified R : EntityI> select(
         page: Int,
         limit: Int,
         vararg values: Pair<String, Any?>,
         noinline block: SelectPaginatedCallback<R> = {}
     ): Paginated<R> =
-        select(page, limit, object: TypeReference<List<R>>() {}, values.toMap(), block)
+        select(page, limit, object : TypeReference<List<R>>() {}, values.toMap(), block)
 
     /* Execute function without traitements */
 
@@ -169,12 +169,22 @@ class Function(val definition: Function, override val connection: Connection): E
         return connection.exec(sql, values)
     }
 
+    override fun sendQuery(values: List<Any?>): Int {
+        exec(values)
+        return 0
+    }
+
+    override fun sendQuery(values: Map<String, Any?>): Int {
+        exec(values)
+        return 0
+    }
+
     private fun compileArgs(values: List<Any?>): String {
         val placeholders = values
-            .filterIndexed { index, any ->
+            .filterIndexed { index, value ->
-                definition.parameters[index].default === null || any !== null
+                definition.parameters[index].default === null || value != null
             }
-            .mapIndexed { index, any ->
+            .mapIndexed { index, _ ->
                 "?::" + definition.parameters[index].type
             }
 
@@ -185,11 +195,11 @@ class Function(val definition: Function, override val connection: Connection): E
         val parameters = definition.getParametersIndexedByName()
         val placeholders = values
             .filter { entry ->
-                val parameter = parameters[entry.key] ?: error("Parameter ${entry.key} not exist")
+                val parameter = parameters[entry.key] ?: parameters["_" + entry.key] ?: error("Parameter ${entry.key} of function ${definition.name} not exist")
                 parameter.default === null || entry.value !== null
             }
             .map { entry ->
-                val parameter = parameters[entry.key]!!
+                val parameter = parameters[entry.key] ?: parameters["_" + entry.key] ?: error("Parameter ${entry.key} of function ${definition.name} not exist")
                 """"${parameter.name}" := :${parameter.name}::${parameter.type}"""
             }
 

src/main/kotlin/fr/postgresjson/connexion/Paginated.kt

@@ -1,20 +1,25 @@
 package fr.postgresjson.connexion
 
-import com.github.jasync.sql.db.util.length
 import fr.postgresjson.entity.EntityI
+import kotlin.math.ceil
 
-data class Paginated<T: EntityI<*>>(
+data class Paginated<T : EntityI>(
     val result: List<T>,
     val offset: Int,
     val limit: Int,
     val total: Int
 ) {
     val currentPage: Int = (offset / limit) + 1
-    val count: Int = result.length
+    val count: Int = result.size
+    val totalPages: Int = (total.toDouble() / limit.toDouble()).ceil()
 
     init {
         if (offset < 0) error("offset must be greather or equal than 0")
         if (limit < 1) error("limit must be greather or equal than 1")
         if (total < 0) error("total must be greather or equal than 0")
     }
+
+    fun isLastPage(): Boolean = currentPage >= totalPages
+
+    private fun Double.ceil(): Int = ceil(this).toInt()
 }

src/main/kotlin/fr/postgresjson/connexion/Query.kt

@@ -4,15 +4,14 @@ import com.fasterxml.jackson.core.type.TypeReference
 import com.github.jasync.sql.db.QueryResult
 import fr.postgresjson.entity.EntityI
 
-
+class Query(override val name: String, private val sql: String, override val connection: Connection) : EmbedExecutable {
-class Query(override val name: String, private val sql: String, override val connection: Connection): EmbedExecutable {
     override fun toString(): String {
         return sql
     }
 
     /* Select One */
 
-    override fun <R: EntityI<*>> select(
+    override fun <R : EntityI> select(
         typeReference: TypeReference<R>,
         values: List<Any?>,
         block: (QueryResult, R?) -> Unit
@@ -20,13 +19,13 @@ class Query(override val name: String, private val sql: String, override val con
         return connection.select(this.toString(), typeReference, values, block)
     }
 
-    inline fun <reified R: EntityI<*>> selectOne(
+    inline fun <reified R : EntityI> selectOne(
         values: List<Any?> = emptyList(),
         noinline block: SelectOneCallback<R> = {}
     ): R? =
-        select(object: TypeReference<R>() {}, values, block)
+        select(object : TypeReference<R>() {}, values, block)
 
-    override fun <R: EntityI<*>> select(
+    override fun <R : EntityI> select(
         typeReference: TypeReference<R>,
         values: Map<String, Any?>,
         block: (QueryResult, R?) -> Unit
@@ -34,15 +33,15 @@ class Query(override val name: String, private val sql: String, override val con
         return connection.select(this.toString(), typeReference, values, block)
     }
 
-    inline fun <reified R: EntityI<*>> selectOne(
+    inline fun <reified R : EntityI> selectOne(
         values: Map<String, Any?>,
         noinline block: SelectOneCallback<R> = {}
     ): R? =
-        select(object: TypeReference<R>() {}, values, block)
+        select(object : TypeReference<R>() {}, values, block)
 
     /* Select Multiples */
 
-    override fun <R: EntityI<*>> select(
+    override fun <R : EntityI> select(
         typeReference: TypeReference<List<R>>,
         values: List<Any?>,
         block: (QueryResult, List<R>) -> Unit
@@ -50,13 +49,13 @@ class Query(override val name: String, private val sql: String, override val con
         return connection.select(this.toString(), typeReference, values, block)
     }
 
-    inline fun <reified R: EntityI<*>> select(
+    inline fun <reified R : EntityI> select(
         values: List<Any?> = emptyList(),
         noinline block: SelectCallback<R> = {}
     ): List<R> =
-        select(object: TypeReference<List<R>>() {}, values, block)
+        select(object : TypeReference<List<R>>() {}, values, block)
 
-    override fun <R: EntityI<*>> select(
+    override fun <R : EntityI> select(
         typeReference: TypeReference<List<R>>,
         values: Map<String, Any?>,
         block: (QueryResult, List<R>) -> Unit
@@ -64,13 +63,13 @@ class Query(override val name: String, private val sql: String, override val con
         return connection.select(this.toString(), typeReference, values, block)
     }
 
-    inline fun <reified R: EntityI<*>> select(
+    inline fun <reified R : EntityI> select(
         values: Map<String, Any?>,
         noinline block: SelectCallback<R> = {}
     ): List<R> =
-        select(object: TypeReference<List<R>>() {}, values, block)
+        select(object : TypeReference<List<R>>() {}, values, block)
 
-    override fun <R: EntityI<*>> select(
+    override fun <R : EntityI> select(
         page: Int,
         limit: Int,
         typeReference: TypeReference<List<R>>,
@@ -82,13 +81,13 @@ class Query(override val name: String, private val sql: String, override val con
 
     /* Select Paginated */
 
-    inline fun <reified R: EntityI<*>> select(
+    inline fun <reified R : EntityI> select(
         page: Int,
         limit: Int,
         values: Map<String, Any?> = emptyMap(),
         noinline block: SelectPaginatedCallback<R> = {}
     ): Paginated<R> =
-        select(page, limit, object: TypeReference<List<R>>() {}, values, block)
+        select(page, limit, object : TypeReference<List<R>>() {}, values, block)
 
     /* Execute function without traitements */
 
@@ -99,4 +98,12 @@ class Query(override val name: String, private val sql: String, override val con
     override fun exec(values: Map<String, Any?>): QueryResult {
         return connection.exec(sql, values)
     }
+
+    override fun sendQuery(values: List<Any?>): Int {
+        return connection.sendQuery(sql, values)
+    }
+
+    override fun sendQuery(values: Map<String, Any?>): Int {
+        return connection.sendQuery(sql, values)
+    }
 }

src/main/kotlin/fr/postgresjson/connexion/Requester.kt

@@ -80,7 +80,7 @@ class Requester(
             password: String = "dc-project",
             queriesDirectory: File? = null,
             functionsDirectory: File? = null
-        ): this(
+        ) : this(
             Connection(host = host, port = port, database = database, username = username, password = password),
             queriesDirectory,
             functionsDirectory

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

@@ -2,18 +2,17 @@ package fr.postgresjson.definition
 
 import java.io.File
 
-
 open class Function(
     override val script: String
-): Resource, ParametersInterface {
+) : Resource, ParametersInterface {
-    val returns: String?
+    val returns: String
     override val name: String
     override val parameters: List<Parameter>
     override var source: File? = null
 
     init {
         val functionRegex =
-            """create (or replace )?(procedure|function) *(?<name>[^(\s]+)\s*\((?<params>(\s*((IN|OUT|INOUT|VARIADIC)?\s+)?([^\s,)]+\s+)?([^\s,)]+)(\s+(?:default\s|=)\s*[^\s,)]+)?\s*(,|(?=\))))*)\) *(?<return>RETURNS *[^ ]+)?"""
+            """create (or replace )?(procedure|function) *(?<name>[^(\s]+)\s*\((?<params>(\s*((IN|OUT|INOUT|VARIADIC)?\s+)?([^\s,)]+\s+)?([^\s,)]+)(\s+(?:default\s|=)\s*[^\s,)]+)?\s*(,|(?=\))))*)\) *(?<return>RETURNS *[^ \n]+)?"""
                 .toRegex(setOf(RegexOption.IGNORE_CASE, RegexOption.MULTILINE))
 
         val paramsRegex =
@@ -22,9 +21,9 @@ open class Function(
 
         val queryMatch = functionRegex.find(script)
         if (queryMatch !== null) {
-            val functionName = queryMatch.groups.get("name")?.value?.trim()
+            val functionName = queryMatch.groups.get("name")?.value?.trim() ?: error("Function name not found")
             val functionParameters = queryMatch.groups["params"]?.value?.trim()
-            this.returns = queryMatch.groups["return"]?.value?.trim()
+            this.returns = queryMatch.groups["return"]?.value?.trim() ?: ""
 
             /* Create parameters definition */
             val parameters = if (functionParameters !== null) {
@@ -40,23 +39,22 @@ open class Function(
             } else {
                 listOf()
             }
-            this.name = functionName!!
+            this.name = functionName
             this.parameters = parameters
         } else {
             throw FunctionNotFound()
         }
     }
 
-    abstract class ParseException(message: String, cause: Throwable? = null): Exception(message, cause)
+    abstract class ParseException(message: String, cause: Throwable? = null) : Exception(message, cause)
-    class FunctionNotFound(cause: Throwable? = null): ParseException("Function not found in script", cause)
+    class FunctionNotFound(cause: Throwable? = null) : ParseException("Function not found in script", cause)
 
     fun getDefinition(): String {
         return parameters
             .filter { it.direction == Parameter.Direction.IN }
             .joinToString(", ") { "${it.name} ${it.type}" }.let {
-                "$name ($it) $returns"
+                "$name ($it)"
             }
-
     }
 
     fun getParametersIndexedByName(): Map<String, Parameter> {

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

@@ -18,7 +18,7 @@ class Parameter(val name: String, val type: String, direction: Direction? = Dire
         }
     }
 
-    constructor(name: String, type: String, direction: String? = "IN", default: Any? = null): this(
+    constructor(name: String, type: String, direction: String? = "IN", default: Any? = null) : this(
         name = name,
         type = type,
         direction = direction?.let { Direction.valueOf(direction.toUpperCase()) },

src/main/kotlin/fr/postgresjson/entity/EntitiesCollections.kt

@@ -1,42 +0,0 @@
-package fr.postgresjson.entity
-
-import kotlin.reflect.KClass
-
-class EntitiesCollections {
-    private val collections: MutableMap<KClass<*>, EntityCollection<Any, EntityI<Any?>>> = mutableMapOf()
-
-    fun <I, R: EntityI<I?>> get(id: I, className: KClass<R>): R? {
-        val collection = collections[className]
-        val entity = collection?.get(id!!)
-        return entity as R?
-    }
-
-    inline fun <I, reified R: EntityI<I?>> get(id: I): R? {
-        return get(id, R::class)
-    }
-
-    fun <I, R: EntityI<out I?>> set(entity: R): EntitiesCollections {
-        if (collections[entity.className] == null) {
-            collections[entity.className] = EntityCollection()
-        }
-
-        collections[entity.className]!!.set(entity as EntityI<Any?>)
-
-        return this
-    }
-
-    class EntityCollection<T, E: EntityI<T?>> {
-        private var collection: MutableMap<T, E> = mutableMapOf()
-
-        fun get(id: T): E? {
-            return collection[id]
-        }
-
-        fun set(entity: E) {
-            val id = entity.id
-            if (id !== null) {
-                collection[id] = entity
-            }
-        }
-    }
-}

src/main/kotlin/fr/postgresjson/entity/Entity.kt

@@ -1,90 +1,5 @@
 package fr.postgresjson.entity
 
-import com.fasterxml.jackson.annotation.JsonIgnore
+interface Serializable
-import org.joda.time.DateTime
+interface EntityI : Serializable
-import java.util.*
+interface Parameter : Serializable
-import kotlin.reflect.KClass
-
-/* ID */
-interface EntityI<T> {
-    var id: T?
-    val className: KClass<EntityI<T?>>
-        @JsonIgnore() get() = this::class as KClass<EntityI<T?>>
-}
-
-abstract class Entity<T>(override var id: T? = null): EntityI<T?>
-abstract class UuidEntity(override var id: UUID? = UUID.randomUUID()): Entity<UUID?>(id)
-abstract class IdEntity(override var id: Int? = null): Entity<Int?>(id)
-
-/* Version */
-interface EntityVersioning<T> {
-    var version: T
-}
-
-interface EntityVersioningIncrement: EntityVersioning<Int?>
-class EntityVersioningIncrementImp: EntityVersioningIncrement {
-    override var version: Int? = null
-}
-
-interface EntityVersioningDate: EntityVersioning<DateTime?>
-class EntityVersioningDateImp: EntityVersioningDate {
-    override var version: DateTime? = null
-}
-
-/* Dates */
-interface EntityCreatedAt {
-    var createdAt: DateTime?
-}
-
-interface EntityUpdatedAt {
-    var updatedAt: DateTime?
-}
-
-class EntityCreatedAtImp: EntityCreatedAt {
-    override var createdAt: DateTime? = null
-}
-
-class EntityUpdatedAtImp: EntityUpdatedAt {
-    override var updatedAt: DateTime? = null
-}
-
-/* Author */
-interface CreatedBy<T: EntityI<*>> {
-    var createdBy: T?
-}
-
-interface UpdatedBy<T: EntityI<*>> {
-    var updatedBy: T?
-}
-
-class EntityCreatedByImp<UserT: EntityI<*>>: CreatedBy<UserT> {
-    override var createdBy: UserT? = null
-}
-
-class EntityUpdatedByImp<UserT: EntityI<*>>: UpdatedBy<UserT> {
-    override var updatedBy: UserT? = null
-}
-
-/* Published */
-interface Published<UserT: EntityI<*>> {
-    var publishedAt: DateTime?
-    var publishedBy: UserT?
-}
-
-class EntityPublishedImp<UserT: EntityI<*>>: Published<UserT> {
-    override var publishedAt: DateTime? = null
-    override var publishedBy: UserT? = null
-}
-
-/* Implementation */
-abstract class EntityImp<T, UserT: EntityI<*>>: Entity<T>(),
-    EntityCreatedAt by EntityCreatedAtImp(),
-    EntityUpdatedAt by EntityUpdatedAtImp(),
-    CreatedBy<UserT> by EntityCreatedByImp(),
-    UpdatedBy<UserT> by EntityUpdatedByImp()
-
-abstract class EntityExtended<T, UserT: EntityI<*>>:
-    EntityImp<T, UserT>(),
-    EntityVersioningIncrement by EntityVersioningIncrementImp(),
-    Published<UserT> by EntityPublishedImp()
-

src/main/kotlin/fr/postgresjson/entity/immutable/ImmutableEntity.kt

@@ -0,0 +1,88 @@
+package fr.postgresjson.entity.immutable
+
+import fr.postgresjson.entity.EntityI
+import fr.postgresjson.entity.mutable.EntityDeletedAt
+import fr.postgresjson.entity.mutable.EntityDeletedAtImp
+import fr.postgresjson.entity.mutable.EntityDeletedBy
+import fr.postgresjson.entity.mutable.EntityDeletedByImp
+import org.joda.time.DateTime
+import java.util.*
+
+interface EntityRefI<T> : EntityI {
+    val id: T
+}
+
+interface UuidEntityI : EntityRefI<UUID> {
+    override val id: UUID
+}
+
+abstract class Entity<T>(override val id: T) : EntityRefI<T>
+open class UuidEntity(override val id: UUID = UUID.randomUUID()) : UuidEntityI, Entity<UUID>(id)
+
+/* Version */
+interface EntityVersioning<ID, NUMBER> {
+    val versionNumber: NUMBER
+    val versionId: ID
+}
+
+class UuidEntityVersioning(
+    override var versionNumber: Int? = null,
+    override val versionId: UUID = UUID.randomUUID()
+) : EntityVersioning<UUID, Int?>
+
+/* Dates */
+interface EntityCreatedAt {
+    val createdAt: DateTime
+}
+interface EntityUpdatedAt {
+    var updatedAt: DateTime
+}
+
+class EntityCreatedAtImp(
+    override val createdAt: DateTime = DateTime.now()
+) : EntityCreatedAt
+
+class EntityUpdatedAtImp(
+    override var updatedAt: DateTime = DateTime.now()
+) : EntityUpdatedAt
+
+/* Author */
+interface EntityCreatedBy<T : EntityI> {
+    val createdBy: T
+}
+interface EntityUpdatedBy<T : EntityI> {
+    var updatedBy: T
+}
+
+class EntityCreatedByImp<UserT : EntityI>(
+    override val createdBy: UserT
+) : EntityCreatedBy<UserT>
+
+class EntityUpdatedByImp<UserT : EntityI>(
+    override var updatedBy: UserT
+) : EntityUpdatedBy<UserT>
+
+/* Mixed */
+class EntityCreatedImp<UserT : EntityI>(
+    override val createdAt: DateTime = DateTime.now(),
+    createdBy: UserT
+) : EntityCreatedBy<UserT> by EntityCreatedByImp(createdBy),
+    EntityCreatedAt by EntityCreatedAtImp()
+
+class EntityUpdatedImp<UserT : EntityI>(
+    updatedAt: DateTime = DateTime.now(),
+    override var updatedBy: UserT
+) : EntityUpdatedBy<UserT>,
+    EntityUpdatedAt by EntityUpdatedAtImp(updatedAt)
+
+/* Implementation */
+abstract class EntityImp<T, UserT : EntityI>(
+    updatedBy: UserT,
+    updatedAt: DateTime = DateTime.now()
+) : UuidEntity(),
+    EntityCreatedAt by EntityCreatedAtImp(updatedAt),
+    EntityUpdatedAt by EntityUpdatedAtImp(updatedAt),
+    EntityDeletedAt by EntityDeletedAtImp(),
+    EntityCreatedBy<UserT> by EntityCreatedByImp(updatedBy),
+    EntityUpdatedBy<UserT> by EntityUpdatedByImp(updatedBy),
+    EntityDeletedBy<UserT> by EntityDeletedByImp(updatedBy)

src/main/kotlin/fr/postgresjson/entity/mutable/MutableEntity.kt

@@ -0,0 +1,135 @@
+package fr.postgresjson.entity.mutable
+
+import fr.postgresjson.entity.EntityI
+import org.joda.time.DateTime
+import java.util.*
+
+interface EntityRefI<T> : EntityI {
+    var id: T?
+}
+
+interface UuidEntityI : EntityRefI<UUID> {
+    override var id: UUID?
+}
+
+interface IdEntityI : EntityRefI<Int> {
+    override var id: Int?
+}
+
+abstract class Entity<T>(override var id: T? = null) : EntityRefI<T>
+open class UuidEntity(override var id: UUID? = UUID.randomUUID()) : UuidEntityI, Entity<UUID>(id)
+open class IdEntity(override var id: Int? = null) : IdEntityI, Entity<Int>(id)
+
+/* Version */
+interface EntityVersioning<ID, NUMBER> {
+    var versionId: ID
+    var versionNumber: NUMBER?
+}
+
+class UuidEntityVersioning(
+    override var versionNumber: Int? = null,
+    override var versionId: UUID = UUID.randomUUID()
+) : EntityVersioning<UUID, Int>
+
+/* Dates */
+interface EntityCreatedAt {
+    var createdAt: DateTime?
+}
+
+interface EntityUpdatedAt {
+    var updatedAt: DateTime?
+}
+
+interface EntityDeletedAt {
+    var deletedAt: DateTime?
+    fun isDeleted(): Boolean {
+        val deletedAt = deletedAt
+        return deletedAt != null && deletedAt < DateTime.now()
+    }
+}
+
+class EntityCreatedAtImp : EntityCreatedAt {
+    override var createdAt: DateTime? = null
+}
+
+class EntityUpdatedAtImp : EntityUpdatedAt {
+    override var updatedAt: DateTime? = null
+}
+
+class EntityDeletedAtImp : EntityDeletedAt {
+    override var deletedAt: DateTime? = null
+}
+
+/* Author */
+interface EntityCreatedBy<T : EntityI> {
+    var createdBy: T?
+}
+
+interface EntityUpdatedBy<T : EntityI> {
+    var updatedBy: T?
+}
+
+interface EntityDeletedBy<T : EntityI> {
+    var deletedBy: T?
+}
+
+class EntityCreatedByImp<UserT : EntityI>(
+    override var createdBy: UserT?
+) : EntityCreatedBy<UserT>
+
+class EntityUpdatedByImp<UserT : EntityI>(
+    override var updatedBy: UserT?
+) : EntityUpdatedBy<UserT>
+
+class EntityDeletedByImp<UserT : EntityI>(
+    override var deletedBy: UserT?
+) : EntityDeletedBy<UserT>
+
+/* Mixed */
+class EntityDeletedImp<UserT : EntityI>(
+    override var deletedBy: UserT? = null
+) : EntityDeletedBy<UserT>,
+    EntityDeletedAt by EntityDeletedAtImp()
+
+class EntityUpdatedImp<UserT : EntityI>(
+    override var updatedAt: DateTime? = null,
+    override var updatedBy: UserT? = null
+) : EntityUpdatedBy<UserT>,
+    EntityUpdatedAt by EntityUpdatedAtImp()
+
+class EntityCreatedImp<UserT : EntityI>(
+    override var createdAt: DateTime? = null,
+    override var createdBy: UserT? = null
+) : EntityCreatedBy<UserT>,
+    EntityCreatedAt by EntityCreatedAtImp()
+
+/* Published */
+interface Published<UserT : EntityI> {
+    var publishedAt: DateTime?
+    var publishedBy: UserT?
+}
+
+class EntityPublishedImp<UserT : EntityI>(
+    override var publishedBy: UserT?
+) : Published<UserT> {
+    override var publishedAt: DateTime? = null
+}
+
+/* Implementation */
+abstract class EntityImp<T, UserT : EntityI>(
+    updatedBy: UserT?
+) : Entity<T>(),
+    EntityCreatedAt by EntityCreatedAtImp(),
+    EntityUpdatedAt by EntityUpdatedAtImp(),
+    EntityDeletedAt by EntityDeletedAtImp(),
+    EntityCreatedBy<UserT> by EntityCreatedByImp(updatedBy),
+    EntityUpdatedBy<UserT> by EntityUpdatedByImp(updatedBy),
+    EntityDeletedBy<UserT> by EntityDeletedByImp(updatedBy)
+
+abstract class UuidEntityExtended<T, UserT : EntityI>(
+    updatedBy: UserT?,
+    publishedBy: UserT?
+) :
+    EntityImp<T, UserT>(updatedBy),
+    EntityVersioning<UUID, Int> by UuidEntityVersioning(),
+    Published<UserT> by EntityPublishedImp(publishedBy)

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

@@ -1,9 +1,11 @@
 package fr.postgresjson.migration
 
+import com.github.jasync.sql.db.postgresql.exceptions.GenericDatabaseException
 import fr.postgresjson.connexion.Connection
 import fr.postgresjson.migration.Migration.Action
 import fr.postgresjson.migration.Migration.Status
 import java.util.*
+import java.util.concurrent.*
 import fr.postgresjson.definition.Function as DefinitionFunction
 
 data class Function(
@@ -11,13 +13,13 @@ data class Function(
     val down: DefinitionFunction,
     private val connection: Connection,
     override var executedAt: Date? = null
-): Migration {
+) : Migration {
     val name = up.name
     override var doExecute: Action? = null
 
     init {
         if (up.name != down.name) {
-            throw Exception("UP and DOWN migration must have the same name [${up.name} !== ${down.name}]")
+            throw Exception("UP and DOWN migration must have the same name [${up.name} != ${down.name}]")
         }
     }
 
@@ -26,7 +28,7 @@ data class Function(
         down: String,
         connection: Connection,
         executedAt: Date? = null
-    ): this(
+    ) : this(
         DefinitionFunction(up),
         DefinitionFunction(down),
         connection,
@@ -34,7 +36,15 @@ data class Function(
     )
 
     override fun up(): Status {
-        connection.sendQuery(up.script)
+        try {
+            connection.sendQuery(up.script)
+        } catch (e: CompletionException) {
+            val cause = e.cause
+            if (cause is GenericDatabaseException && cause.errorMessage.fields['C'] == "42P13") {
+                connection.sendQuery("drop function ${down.getDefinition()}")
+                connection.sendQuery(up.script)
+            }
+        }
 
         this::class.java.classLoader.getResource("sql/migration/insertFunction.sql")!!.readText().let {
             connection.selectOne<MigrationEntity>(it, listOf(up.name, up.getDefinition(), up.script, down.script))?.let { function ->
@@ -49,7 +59,7 @@ data class Function(
         connection.sendQuery(down.script)
 
         this::class.java.classLoader.getResource("sql/migration/deleteFunction.sql")!!.readText().let {
-            connection.exec(it, listOf(down))
+            connection.sendQuery(it, listOf(down.name))
         }
         return Status.OK
     }
@@ -65,7 +75,7 @@ data class Function(
     }
 
     override fun status(): Status {
-        val result = connection.inTransaction {
+        connection.inTransaction {
             up()
             down()
             it.sendQuery("ROLLBACK")

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

@@ -1,10 +1,9 @@
 package fr.postgresjson.migration
 
 import com.fasterxml.jackson.core.type.TypeReference
-import com.github.jasync.sql.db.util.size
 import fr.postgresjson.connexion.Connection
 import fr.postgresjson.definition.Function.FunctionNotFound
-import fr.postgresjson.entity.Entity
+import fr.postgresjson.entity.mutable.Entity
 import fr.postgresjson.migration.Migration.Action
 import fr.postgresjson.migration.Migration.Status
 import fr.postgresjson.utils.LoggerDelegate
@@ -20,7 +19,7 @@ class MigrationEntity(
     val up: String,
     val down: String,
     val version: Int
-): Entity<String?>(filename)
+) : Entity<String?>(filename)
 
 interface Migration {
     var executedAt: Date?
@@ -39,13 +38,23 @@ data class Migrations private constructor(
     private val queries: MutableMap<String, Query> = mutableMapOf(),
     private val functions: MutableMap<String, Function> = mutableMapOf()
 ) {
+    private var directories: List<File> = emptyList()
     private val logger: Logger? by LoggerDelegate()
-    constructor(directory: File, connection: Connection): this(listOf(directory), connection)
+    constructor(directory: File, connection: Connection) : this(listOf(directory), connection)
 
-    constructor(directories: List<File>, connection: Connection): this(connection) {
+    constructor(directories: List<File>, connection: Connection) : this(connection) {
         initDB()
+        this.directories = directories
+        reset()
+    }
+
+    fun reset() {
+        queries.clear()
+        functions.clear()
+
         getMigrationFromDB()
         getMigrationFromDirectory(directories)
+
         queries.forEach { (_, query) ->
             if (query.doExecute === null) {
                 query.doExecute = Action.DOWN
@@ -66,14 +75,14 @@ data class Migrations private constructor(
      */
     private fun getMigrationFromDB() {
         this::class.java.classLoader.getResource("sql/migration/findAllFunction.sql")!!.readText().let {
-            connection.select<MigrationEntity>(it, object: TypeReference<List<MigrationEntity>>() {})
+            connection.select<MigrationEntity>(it, object : TypeReference<List<MigrationEntity>>() {})
                 .map { function ->
                     functions[function.filename] = Function(function.up, function.down, connection, function.executedAt)
                 }
         }
 
         this::class.java.classLoader.getResource("sql/migration/findAllHistory.sql")!!.readText().let {
-            connection.select<MigrationEntity>(it, object: TypeReference<List<MigrationEntity>>() {})
+            connection.select<MigrationEntity>(it, object : TypeReference<List<MigrationEntity>>() {})
                 .map { query ->
                     queries[query.filename] = Query(query.filename, query.up, query.down, connection, query.executedAt)
                 }
@@ -97,11 +106,11 @@ data class Migrations private constructor(
             it.isFile
         }.forEach { file ->
             if (file.name.endsWith(".up.sql")) {
-                file.path.substring(0, file.path.size - 7).let {
+                file.path.substring(0, file.path.length - 7).let {
                     try {
                         val down = File("$it.down.sql").readText()
                         val up = file.readText()
-                        val name = file.name.substring(0, file.name.size - 7)
+                        val name = file.name.substring(0, file.name.length - 7)
                         addQuery(name, up, down)
                     } catch (e: FileNotFoundException) {
                         throw DownMigrationNotDefined("$it.down.sql", e)
@@ -113,7 +122,7 @@ data class Migrations private constructor(
                 val fileContent = file.readText()
                 try {
                     addFunction(fileContent)
-                } catch(e: FunctionNotFound) {
+                } catch (e: FunctionNotFound) {
                     // Nothing
                 }
             }
@@ -122,13 +131,14 @@ data class Migrations private constructor(
 
     enum class Direction { UP, DOWN }
 
-    internal class DownMigrationNotDefined(path: String, cause: FileNotFoundException):
+    internal class DownMigrationNotDefined(path: String, cause: FileNotFoundException) :
         Throwable("The file $path whas not found", cause)
 
     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 {
+            val oldDefinition = functions[newDefinition.name]?.up ?: newDefinition
+            functions[newDefinition.name] = Function(newDefinition, oldDefinition, connection).apply {
                 doExecute = Action.UP
             }
         } else {
@@ -244,6 +254,7 @@ data class Migrations private constructor(
             sendQuery("COMMIT")
         }
         logger?.info("Migration done")
+        reset()
 
         return list.toMap()
     }
@@ -264,6 +275,7 @@ data class Migrations private constructor(
             sendQuery("COMMIT")
         }
         logger?.info("Migration DOWN done")
+        reset()
 
         return list.toMap()
     }

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

@@ -1,7 +1,7 @@
 package fr.postgresjson.migration
 
 import fr.postgresjson.connexion.Connection
-import fr.postgresjson.entity.Entity
+import fr.postgresjson.entity.mutable.Entity
 import fr.postgresjson.migration.Migration.Action
 import java.util.*
 
@@ -11,7 +11,7 @@ data class Query(
     val down: String,
     private val connection: Connection,
     override var executedAt: Date? = null
-): Migration, Entity<String?>(name) {
+) : Migration, Entity<String?>(name) {
     override var doExecute: Action? = null
 
     override fun up(): Migration.Status {
@@ -48,7 +48,7 @@ data class Query(
     }
 
     override fun status(): Migration.Status {
-        val result = connection.inTransaction {
+        connection.inTransaction {
             up()
             down()
             it.sendQuery("ROLLBACK")

src/main/kotlin/fr/postgresjson/repository/Repository.kt

@@ -1,13 +0,0 @@
-package fr.postgresjson.repository
-
-import fr.postgresjson.connexion.Requester
-import fr.postgresjson.entity.EntityI
-import kotlin.reflect.KClass
-
-interface RepositoryI<E: EntityI<*>> {
-    val entityName: KClass<E>
-    var requester: Requester
-    fun getClassName(): String {
-        return entityName.simpleName!!
-    }
-}

src/main/kotlin/fr/postgresjson/repository/RepositoryI.kt

@@ -0,0 +1,12 @@
+package fr.postgresjson.repository
+
+import fr.postgresjson.connexion.Requester
+
+interface RepositoryI {
+    val requester: Requester
+
+    enum class Direction {
+        asc,
+        desc
+    }
+}

src/main/kotlin/fr/postgresjson/serializer/Serializer.kt

@@ -1,47 +1,37 @@
 package fr.postgresjson.serializer
 
-import com.fasterxml.jackson.core.JsonParser
-import com.fasterxml.jackson.core.JsonProcessingException
 import com.fasterxml.jackson.core.type.TypeReference
-import com.fasterxml.jackson.databind.*
+import com.fasterxml.jackson.databind.DeserializationFeature
-import com.fasterxml.jackson.databind.deser.std.StdDeserializer
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.databind.PropertyNamingStrategy
+import com.fasterxml.jackson.databind.SerializationFeature
 import com.fasterxml.jackson.databind.module.SimpleModule
 import com.fasterxml.jackson.datatype.joda.JodaModule
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import com.fasterxml.jackson.module.kotlin.readValue
-import fr.postgresjson.entity.EntitiesCollections
+import fr.postgresjson.entity.Serializable
-import fr.postgresjson.entity.EntityI
-import fr.postgresjson.entity.IdEntity
-import fr.postgresjson.entity.UuidEntity
-import java.io.IOException
-import java.util.*
 
 class Serializer(val mapper: ObjectMapper = jacksonObjectMapper()) {
-
-    var collection: EntitiesCollections = EntitiesCollections()
-
     init {
         val module = SimpleModule()
-        module.addDeserializer(UuidEntity::class.java, EntityUuidDeserializer(collection))
-        module.addDeserializer(IdEntity::class.java, EntityIdDeserializer(collection))
         mapper.registerModule(module)
         mapper.propertyNamingStrategy = PropertyNamingStrategy.SNAKE_CASE
 
         mapper.registerModule(JodaModule())
         mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
-        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
     }
 
-    fun <T> serialize(source: EntityI<T>, pretty: Boolean = false): String {
+    fun serialize(source: Any, pretty: Boolean = false): String {
         return if (pretty) mapper.writerWithDefaultPrettyPrinter().writeValueAsString(source)
         else mapper.writeValueAsString(source)
     }
 
-    fun <E: EntityI<*>> deserialize(json: String, valueTypeRef: TypeReference<E>): E {
+    fun <E> deserialize(json: String, valueTypeRef: TypeReference<E>): E {
         return this.mapper.readValue(json, valueTypeRef)
     }
 
-    inline fun <reified E: EntityI<*>> deserialize(json: String): E? {
+    inline fun <reified E> deserialize(json: String): E? {
         return this.mapper.readValue(json)
     }
 
@@ -50,53 +40,15 @@ class Serializer(val mapper: ObjectMapper = jacksonObjectMapper()) {
     }
 
     inline fun <reified E> deserializeList(json: String): E {
-        return deserializeList(json, object: TypeReference<E>() {})
+        return deserializeList(json, object : TypeReference<E>() {})
     }
 
-    fun <E: EntityI<*>> deserialize(json: String, target: E): E {
+    fun <E> deserialize(json: String, target: E): E {
         return mapper.readerForUpdating(target).readValue<E>(json)
     }
 }
 
-fun <T> EntityI<T?>.serialize(pretty: Boolean = false) = Serializer().serialize(this, pretty)
+fun Serializable.serialize(pretty: Boolean = false) = Serializer().serialize(this, pretty)
-inline fun <reified E: EntityI<*>> E.deserialize(json: String) = Serializer().deserialize(json, this)
+fun List<Serializable>.serialize(pretty: Boolean = false) = Serializer().serialize(this, pretty)
-inline fun <reified E: EntityI<*>> String.deserialize() = Serializer().deserialize<E>(this)
+inline fun <reified E : Serializable> E.deserialize(json: String) = Serializer().deserialize(json, this)
-
+inline fun <reified E : Serializable> String.deserialize() = Serializer().deserialize<E>(this)
-
-class EntityUuidDeserializer<T: UuidEntity> @JvmOverloads constructor(vc: Class<*>? = null): StdDeserializer<T>(vc) {
-    var collection: EntitiesCollections = EntitiesCollections()
-
-    constructor(collection: EntitiesCollections): this() {
-        this.collection = collection
-    }
-
-    @Throws(IOException::class, JsonProcessingException::class)
-    override fun deserialize(jp: JsonParser, ctxt: DeserializationContext): T {
-        val node = jp.codec.readTree<JsonNode>(jp)
-        val id = node.get("id").asText()
-        val entity = collection.get<UUID, UuidEntity>(UUID.fromString(id))
-
-        return (entity ?: ctxt.readValue(jp, UuidEntity::class.javaObjectType)) as T
-    }
-}
-
-
-class EntityIdDeserializer<T: IdEntity> @JvmOverloads constructor(vc: Class<*>? = null): StdDeserializer<T>(vc) {
-    var collection: EntitiesCollections = EntitiesCollections()
-
-    constructor(collection: EntitiesCollections): this() {
-        this.collection = collection
-    }
-
-    @Throws(IOException::class, JsonProcessingException::class)
-    override fun deserialize(jp: JsonParser, ctxt: DeserializationContext): T {
-        val node = jp.codec.readTree<JsonNode>(jp)
-        val id = node.get("id").asInt()
-        val entity = collection.get<Int?, IdEntity>(id)
-
-        val obj = (entity ?: ctxt.readValue(jp, UuidEntity::class.javaObjectType)) as EntityI<Int?>
-        collection.set(obj)
-
-        return obj as T
-    }
-}

src/main/kotlin/fr/postgresjson/utils/LoggerDelegate.kt

@@ -5,6 +5,6 @@ import org.slf4j.LoggerFactory
 import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty
 
-internal class LoggerDelegate<in R: Any>: ReadOnlyProperty<R, Logger> {
+internal class LoggerDelegate<in R : Any> : ReadOnlyProperty<R, Logger> {
     override fun getValue(thisRef: R, property: KProperty<*>) = LoggerFactory.getLogger(thisRef.javaClass.packageName)
 }

src/test/kotlin/fr/postgresjson/ConnectionTest.kt

@@ -1,26 +1,20 @@
 package fr.postgresjson
 
-import fr.postgresjson.connexion.Connection
 import fr.postgresjson.connexion.Paginated
-import fr.postgresjson.entity.IdEntity
+import fr.postgresjson.entity.mutable.IdEntity
+import fr.postgresjson.entity.Parameter
 import org.junit.Assert.*
 import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
-class ConnectionTest(): TestAbstract() {
+class ConnectionTest() : TestAbstract() {
-    private class ObjTest(var name: String): IdEntity()
+    private class ObjTest(var name: String) : IdEntity()
-    private class ObjTest2(var title: String, var test: ObjTest?): IdEntity()
+    private class ObjTest2(var title: String, var test: ObjTest?) : IdEntity()
-    private class ObjTest3(var first: String, var seconde: String, var third: Int): IdEntity()
+    private class ObjTest3(var first: String, var seconde: String, var third: Int) : IdEntity()
-
+    private class ObjTestWithParameterObject(var first: ParameterObject, var seconde: ParameterObject) : IdEntity()
-    private lateinit var connection: Connection
+    private class ParameterObject(var third: String) : Parameter
-
-    @BeforeEach
-    fun before() {
-        connection = getConnextion()
-    }
 
     @Test
     fun getObject() {
@@ -44,8 +38,7 @@ class ConnectionTest(): TestAbstract() {
         """.trimIndent()
         )
         assertNotNull(objs)
-        assertTrue(objs is List<ObjTest2>)
+        assertEquals(objs.size, 2)
-        assertEquals(objs!!.size, 2)
         assertEquals(objs[0].id, 1)
         assertEquals(objs[0].test!!.id, 1)
     }
@@ -90,6 +83,19 @@ class ConnectionTest(): TestAbstract() {
         assertEquals(result.third, 123)
     }
 
+    @Test
+    fun `select one with named parameters object`() {
+        val result: ObjTestWithParameterObject? = connection.selectOne(
+            "SELECT json_build_object('first', :first::json, 'seconde', :seconde::json)",
+            mapOf(
+                "first" to ParameterObject("one"),
+                "seconde" to ParameterObject("two")
+            )
+        )
+        assertEquals("one", result!!.first.third)
+        assertEquals("two", result.seconde.third)
+    }
+
     @Test
     fun `select with named parameters`() {
         val params: Map<String, Any?> = mapOf(

src/test/kotlin/fr/postgresjson/EntityTest.kt

@@ -1,25 +1,26 @@
 package fr.postgresjson
 
-import fr.postgresjson.entity.*
+import fr.postgresjson.entity.EntityI
+import fr.postgresjson.entity.mutable.*
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 class EntityTest() {
-    private class User(override var id: Int?): EntityI<Int?>
+    private class User(id: Int?) : Entity<Int?>(id)
-    private class ObjTest(var name: String): EntityExtended<Int?, User>()
+    private class ObjTest(var name: String) : UuidEntityExtended<Int?, User>(User(1), User(2))
 
     @Test
     fun getObject() {
         val obj: ObjTest? = ObjTest("plop")
         assertTrue(obj is ObjTest)
-        assertTrue(obj is EntityExtended<Int?, User>)
+        assertTrue(obj is UuidEntityExtended<Int?, User>)
-        assertTrue(obj is EntityI<Int?>)
+        assertTrue(obj is EntityI)
         assertTrue(obj is Entity<Int?>)
         assertTrue(obj is Published<User>)
-        assertTrue(obj is CreatedBy<User>)
+        assertTrue(obj is EntityCreatedBy<User>)
-        assertTrue(obj is UpdatedBy<User>)
+        assertTrue(obj is EntityUpdatedBy<User>)
         assertTrue(obj is EntityCreatedAt)
         assertTrue(obj is EntityUpdatedAt)
     }

src/test/kotlin/fr/postgresjson/MigrationTest.kt

@@ -13,11 +13,11 @@ import org.junit.jupiter.api.TestInstance
 import java.io.File
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
-class MigrationTest(): TestAbstract() {
+class MigrationTest() : TestAbstract() {
     @Test
     fun `run up query`() {
         val resources = File(this::class.java.getResource("/sql/migrations").toURI())
-        val m = Migrations(resources, getConnextion())
+        val m = Migrations(resources, connection)
         m.up().apply {
             this `should contain` Pair("1", Migration.Status.OK)
             size `should be equal to` 1
@@ -30,14 +30,14 @@ class MigrationTest(): TestAbstract() {
     fun `migration up Query should throw error if no down`() {
         val resources = File(this::class.java.getResource("/sql/migration_without_down").toURI())
         invoking {
-            Migrations(resources, getConnextion())
+            Migrations(resources, connection)
         } shouldThrow Migrations.DownMigrationNotDefined::class
     }
 
     @Test
     fun `run forced down query`() {
         val resources = File(this::class.java.getResource("/sql/migrations").toURI())
-        val m = Migrations(resources, getConnextion())
+        val m = Migrations(resources, connection)
         repeat(3) {
             m.down(true).apply {
                 this `should contain` Pair("1", Migration.Status.OK)
@@ -49,10 +49,10 @@ class MigrationTest(): TestAbstract() {
     @Test
     fun `run dry migrations`() {
         val resources = File(this::class.java.getResource("/sql/real_migrations").toURI())
-        Migrations(resources, getConnextion()).apply {
+        Migrations(resources, connection).apply {
             runDry().size `should be equal to` 2
         }
-        Migrations(resources, getConnextion()).apply {
+        Migrations(resources, connection).apply {
             runDry().size `should be equal to` 2
         }
     }
@@ -60,7 +60,7 @@ class MigrationTest(): TestAbstract() {
     @Test
     fun `run dry migrations launch twice`() {
         val resources = File(this::class.java.getResource("/sql/real_migrations").toURI())
-        Migrations(resources, getConnextion()).apply {
+        Migrations(resources, connection).apply {
             runDry().size `should be equal to` 2
             runDry().size `should be equal to` 2
         }
@@ -69,7 +69,7 @@ class MigrationTest(): TestAbstract() {
     @Test
     fun `run migrations`() {
         val resources = File(this::class.java.getResource("/sql/real_migrations").toURI())
-        Migrations(resources, getConnextion()).apply {
+        Migrations(resources, connection).apply {
             run().apply {
                 size `should be equal to` 1
             }
@@ -79,26 +79,27 @@ class MigrationTest(): TestAbstract() {
     @Test
     fun `run migrations force down`() {
         val resources = File(this::class.java.getResource("/sql/real_migrations").toURI())
-        Migrations(resources, getConnextion()).apply {
+        val resourcesFunctions = File(this::class.java.getResource("/sql/function/Test").toURI())
+        Migrations(listOf(resources, resourcesFunctions), connection).apply {
             up().apply {
-                size `should be equal to` 1
+                size `should be equal to` 6
             }
         }
-        Migrations(resources, getConnextion()).apply {
+        Migrations(listOf(resources, resourcesFunctions), connection).apply {
             forceAllDown().apply {
-                size `should be equal to` 1
+                size `should be equal to` 6
             }
         }
     }
 
     @Test
     fun `run functions migrations`() {
-        val resources = File(this::class.java.getResource("/sql/function").toURI())
+        val resources = File(this::class.java.getResource("/sql/function/Test").toURI())
-        Migrations(resources, getConnextion()).apply {
+        Migrations(resources, connection).apply {
-            run().size `should be equal to` 4
+            run().size `should be equal to` 5
         }
 
-        val objTest: RequesterTest.ObjTest? = Requester(getConnextion())
+        val objTest: RequesterTest.ObjTest? = Requester(connection)
             .addFunction(resources)
             .getFunction("test_function")
             .selectOne(listOf("test", "plip"))
@@ -106,4 +107,25 @@ class MigrationTest(): TestAbstract() {
         Assertions.assertEquals(objTest!!.id, 3)
         Assertions.assertEquals(objTest.name, "test")
     }
+
+    @Test
+    fun `run functions migrations and drop if exist`() {
+        val resources = File(this::class.java.getResource("/sql/function/Test1").toURI())
+        Migrations(resources, connection).apply {
+            run().size `should be equal to` 1
+        }
+
+        val objTest: RequesterTest.ObjTest? = Requester(connection)
+            .addFunction(resources)
+            .getFunction("test_function_duplicate")
+            .selectOne(listOf("test"))
+
+        Assertions.assertEquals(objTest!!.id, 3)
+        Assertions.assertEquals(objTest.name, "test")
+
+        val resources2 = File(this::class.java.getResource("/sql/function/Test2").toURI())
+        Migrations(resources2, connection).apply {
+            run().size `should be equal to` 1
+        }
+    }
 }

src/test/kotlin/fr/postgresjson/RequesterTest.kt

@@ -2,19 +2,19 @@ package fr.postgresjson
 
 import fr.postgresjson.connexion.Paginated
 import fr.postgresjson.connexion.Requester
-import fr.postgresjson.entity.IdEntity
+import fr.postgresjson.entity.mutable.IdEntity
 import org.junit.Assert
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 import java.io.File
 
-class RequesterTest: TestAbstract() {
+class RequesterTest : TestAbstract() {
-    class ObjTest(var name:String): IdEntity(1)
+    class ObjTest(var name: String) : IdEntity(1)
 
     @Test
     fun `get query from file`() {
         val resources = File(this::class.java.getResource("/sql/query").toURI())
-        val objTest: ObjTest? = Requester(getConnextion())
+        val objTest: ObjTest? = Requester(connection)
             .addQuery(resources)
             .getQuery("Test/selectOne")
             .selectOne()
@@ -25,8 +25,8 @@ class RequesterTest: TestAbstract() {
 
     @Test
     fun `get function from file`() {
-        val resources = File(this::class.java.getResource("/sql/function").toURI())
+        val resources = File(this::class.java.getResource("/sql/function/Test").toURI())
-        val objTest: ObjTest? = Requester(getConnextion())
+        val objTest: ObjTest? = Requester(connection)
             .addFunction(resources)
             .getFunction("test_function")
             .selectOne(listOf("test", "plip"))
@@ -38,7 +38,7 @@ class RequesterTest: TestAbstract() {
     @Test
     fun `call exec on query`() {
         val resources = File(this::class.java.getResource("/sql/query").toURI())
-        val result = Requester(getConnextion())
+        val result = Requester(connection)
             .addQuery(resources)
             .getQuery("Test/selectOne")
             .exec()
@@ -48,8 +48,8 @@ class RequesterTest: TestAbstract() {
 
     @Test
     fun `call exec on function`() {
-        val resources = File(this::class.java.getResource("/sql/function").toURI())
+        val resources = File(this::class.java.getResource("/sql/function/Test").toURI())
-        val result = Requester(getConnextion())
+        val result = Requester(connection)
             .addFunction(resources)
             .getFunction("test_function")
             .exec(listOf("test", "plip"))
@@ -57,10 +57,32 @@ class RequesterTest: TestAbstract() {
         assertEquals(1, result.rowsAffected)
     }
 
+    @Test
+    fun `call sendQuery on query`() {
+        val resources = File(this::class.java.getResource("/sql/query").toURI())
+        val result = Requester(connection)
+            .addQuery(resources)
+            .getQuery("Test/exec")
+            .sendQuery()
+
+        assertEquals(0, result)
+    }
+
+    @Test
+    fun `call sendQuery on function`() {
+        val resources = File(this::class.java.getResource("/sql/function/Test").toURI())
+        val result = Requester(connection)
+            .addFunction(resources)
+            .getFunction("function_void")
+            .sendQuery(listOf("test"))
+
+        assertEquals(0, result)
+    }
+
     @Test
     fun `call selectOne on function`() {
-        val resources = File(this::class.java.getResource("/sql/function").toURI())
+        val resources = File(this::class.java.getResource("/sql/function/Test").toURI())
-        val obj: ObjTest = Requester(getConnextion())
+        val obj: ObjTest = Requester(connection)
             .addFunction(resources)
             .getFunction("test_function")
             .selectOne(mapOf("name" to "myName"))!!
@@ -70,9 +92,9 @@ class RequesterTest: TestAbstract() {
 
     @Test
     fun `call selectOne on function with object`() {
-        val resources = File(this::class.java.getResource("/sql/function").toURI())
+        val resources = File(this::class.java.getResource("/sql/function/Test").toURI())
         val obj2 = ObjTest("original")
-        val obj: ObjTest = Requester(getConnextion())
+        val obj: ObjTest = Requester(connection)
             .addFunction(resources)
             .getFunction("test_function_object")
             .selectOne("resource" to obj2)!!
@@ -84,7 +106,7 @@ class RequesterTest: TestAbstract() {
     @Test
     fun `call selectOne on query`() {
         val resources = File(this::class.java.getResource("/sql/query").toURI())
-        val obj: ObjTest = Requester(getConnextion())
+        val obj: ObjTest = Requester(connection)
             .addQuery(resources)
             .getQuery("Test/selectOneWithParameters")
             .selectOne(mapOf("name" to "myName"))!!
@@ -94,8 +116,8 @@ class RequesterTest: TestAbstract() {
 
     @Test
     fun `call select (multiple) on function`() {
-        val resources = File(this::class.java.getResource("/sql/function").toURI())
+        val resources = File(this::class.java.getResource("/sql/function/Test").toURI())
-        val obj: List<ObjTest>? = Requester(getConnextion())
+        val obj: List<ObjTest>? = Requester(connection)
             .addFunction(resources)
             .getFunction("test_function_multiple")
             .select(mapOf("name" to "myName"))
@@ -106,35 +128,35 @@ class RequesterTest: TestAbstract() {
     @Test
     fun `call select paginated on query`() {
         val resources = File(this::class.java.getResource("/sql/query").toURI())
-        val result: Paginated<ObjTest> = Requester(getConnextion())
+        val result: Paginated<ObjTest> = Requester(connection)
             .addQuery(resources)
             .getQuery("Test/selectPaginated")
             .select(1, 2, mapOf("name" to "ff"))
         Assert.assertNotNull(result)
-        Assert.assertEquals(result.result[0].name, "ff")
+        Assert.assertEquals("ff", result.result[0].name)
-        Assert.assertEquals(result.result[1].name, "ff-2")
+        Assert.assertEquals("ff-2", result.result[1].name)
-        Assert.assertEquals(result.total, 10)
+        Assert.assertEquals(10, result.total)
-        Assert.assertEquals(result.offset, 0)
+        Assert.assertEquals(0, result.offset)
     }
 
     @Test
     fun `call select paginated on function`() {
         val resources = File(this::class.java.getResource("/sql/function").toURI())
-        val result: Paginated<ObjTest> = Requester(getConnextion())
+        val result: Paginated<ObjTest> = Requester(connection)
             .addFunction(resources)
             .getFunction("test_function_paginated")
             .select(1, 2, mapOf("name" to "ff"))
         Assert.assertNotNull(result)
-        Assert.assertEquals(result.result[0].name, "ff")
+        Assert.assertEquals("ff", result.result[0].name)
-        Assert.assertEquals(result.result[1].name, "ff-2")
+        Assert.assertEquals("ff-2", result.result[1].name)
-        Assert.assertEquals(result.total, 10)
+        Assert.assertEquals(10, result.total)
-        Assert.assertEquals(result.offset, 0)
+        Assert.assertEquals(0, result.offset)
     }
 
     @Test
     fun `call selectOne on query with extra parameter`() {
         val resources = File(this::class.java.getResource("/sql/query").toURI())
-        val obj: ObjTest = Requester(getConnextion())
+        val obj: ObjTest = Requester(connection)
             .addQuery(resources)
             .getQuery("Test/selectOneWithParameters")
             .selectOne(mapOf("name" to "myName")) {

src/test/kotlin/fr/postgresjson/SerializerTest.kt

@@ -1,6 +1,6 @@
 package fr.postgresjson
 
-import fr.postgresjson.entity.IdEntity
+import fr.postgresjson.entity.mutable.IdEntity
 import fr.postgresjson.serializer.Serializer
 import fr.postgresjson.serializer.deserialize
 import fr.postgresjson.serializer.serialize
@@ -12,7 +12,7 @@ import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
-internal class SerializerTest: TestAbstract() {
+internal class SerializerTest {
     private class ObjTest(var val1: String, var val2: Int) : IdEntity(1)
     private class ObjTestDate(var val1: DateTime) : IdEntity(2)
 
@@ -41,6 +41,14 @@ internal class SerializerTest: TestAbstract() {
         assertTrue(json.contains(""""val1":"plop","val2":123"""))
     }
 
+    @Test
+    fun serializeList() {
+        val list = listOf(ObjTest("one", 1), ObjTest("two", 2))
+        val json = list.serialize()
+        assertTrue(json.contains(""""val1":"one","val2":1"""))
+        assertTrue(json.contains(""""val1":"two","val2":2"""))
+    }
+
     @Test
     fun serializeDate() {
         val objDate = ObjTestDate(DateTime.parse("2019-07-30T14:08:51.420108+04:00"))

src/test/kotlin/fr/postgresjson/TestAbstract.kt

@@ -9,20 +9,22 @@ import java.io.File
 
 @TestInstance(PER_CLASS)
 abstract class TestAbstract {
-    protected fun getConnextion(): Connection {
+    protected val connection = Connection(database = "test_json", username = "test", password = "test")
-        return Connection(database = "test", username = "test", password = "test")
-    }
 
     @BeforeEach
     fun beforeAll() {
         val initSQL = File(this::class.java.getResource("/fixtures/init.sql").toURI())
-        val promise = getConnextion().connect().sendQuery(initSQL.readText())
+        connection
-        promise.join()
+            .connect()
+            .sendQuery(initSQL.readText())
+            .join()
     }
 
     @AfterEach
     fun afterAll() {
         val downSQL = File(this::class.java.getResource("/fixtures/down.sql").toURI())
-        getConnextion().connect().sendQuery(downSQL.readText()).join()
+        connection.connect().apply {
+            sendQuery(downSQL.readText()).join()
+        }.disconnect()
     }
 }

src/test/resources/fixtures/init.sql

@@ -72,4 +72,13 @@ $$
 BEGIN
     resource = json_build_object('id', 1, 'name', 'changedName');
 END;
-$$;
+$$;
+
+CREATE OR REPLACE FUNCTION function_void (name text default 'plop') returns void
+    LANGUAGE plpgsql
+AS
+$$
+BEGIN
+    PERFORM 1;
+END;
+$$

src/test/resources/sql/function/Test/function_void.sql

@@ -0,0 +1,8 @@
+CREATE OR REPLACE FUNCTION function_void (name text default 'plop') returns void
+LANGUAGE plpgsql
+AS
+$$
+BEGIN
+    PERFORM 1;
+END;
+$$;

src/test/resources/sql/function/Test1/function_test_duplicate.sql

@@ -0,0 +1,8 @@
+CREATE OR REPLACE FUNCTION test_function_duplicate (name text default 'plop') returns json
+    LANGUAGE plpgsql
+AS
+$$
+BEGIN
+    return json_build_object('id', 3, 'name', name);
+END;
+$$

src/test/resources/sql/function/Test2/function_test_duplicate.sql

@@ -0,0 +1,8 @@
+CREATE OR REPLACE FUNCTION test_function_duplicate (name text default 'plop', out result text)
+    LANGUAGE plpgsql
+AS
+$$
+BEGIN
+    result = name;
+END;
+$$

src/test/resources/sql/migration_without_down/1.up.sql

@@ -1 +1,5 @@
-SELECT 1;
+do $$
+    begin
+        PERFORM 1;
+    end;
+$$

src/test/resources/sql/migrations/1.down.sql

@@ -1 +1,5 @@
-SELECT 1;
+do $$
+    begin
+        PERFORM 1;
+    end;
+$$

src/test/resources/sql/migrations/1.up.sql

@@ -1 +1,5 @@
-SELECT 1;
+do $$
+    begin
+        PERFORM 1;
+    end;
+$$

src/test/resources/sql/query/Test/exec.sql

@@ -0,0 +1 @@
+delete FROM test where 2038538 = 2;