clean code

.gitignore

@@ -3,4 +3,3 @@
 /build/
 .gradle
 /var/log/
-/.idea/*

.idea/.gitignore

@@ -7,4 +7,3 @@
 /uiDesigner.xml
 /dataSources.xml
 /sonarlint/
-/jarRepositories.xml

.idea/codeStyles/Project.xml

@@ -1,13 +1,7 @@
 <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,11 +8,13 @@
         <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

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

.idea/misc.xml

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

@@ -0,0 +1,8 @@
+<?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

@@ -0,0 +1,11 @@
+<?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

@@ -1,7 +0,0 @@
-<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

@@ -1,31 +0,0 @@
-<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

@@ -1,31 +0,0 @@
-<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

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

build.gradle.kts

@@ -1,39 +1,25 @@
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-
 plugins {
-    jacoco
-
     id("maven-publish")
-    id("org.jetbrains.kotlin.jvm") version "1.3.50"
+    id("org.jetbrains.kotlin.jvm") version "1.3.31"
-
-    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"
 }
 
-group = "flecomte"
+apply(plugin = "kotlin")
-version = versioning.info.tag
+
+group = "fr.postgresjson"
+version = "0.1"
 
 repositories {
     mavenCentral()
     jcenter()
 }
 
-tasks.withType<KotlinCompile> {
-    kotlinOptions {
-        jvmTarget = "11"
-        sourceCompatibility = "11"
-        targetCompatibility = "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:1.0.7")
     implementation("org.slf4j:slf4j-api:1.7.26")
+    implementation("org.postgresql:postgresql:42.2.6")
 
     testImplementation("ch.qos.logback:logback-classic:1.2.3")
     testImplementation("ch.qos.logback:logback-core:1.2.3")
@@ -42,27 +28,14 @@ dependencies {
     testImplementation("org.amshove.kluent:kluent:1.47")
 }
 
-val sourcesJar by tasks.creating(Jar::class) {
-    archiveClassifier.set("sources")
-    from(sourceSets.getByName("main").allSource)
-}
-
 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") {
+        create<MavenPublication>("maven") {
+            groupId = "fr.postgresjson"
+            artifactId = "postgresjson-jdbc"
+            version = "0.1"
+
             from(components["java"])
-            artifact(sourcesJar)
         }
     }
 }

gradle/wrapper/gradle-wrapper.properties

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

jitpack.yml

@@ -1,2 +0,0 @@
-jdk:
-  - openjdk11

settings.gradle

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

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

@@ -1,22 +1,17 @@
 package fr.postgresjson.connexion
 
 import com.fasterxml.jackson.core.type.TypeReference
-import com.github.jasync.sql.db.Connection
-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.*
+import java.sql.DriverManager
+import java.sql.ResultSet
+import java.sql.Connection as JDBCConnection
 
-typealias SelectOneCallback<T> = QueryResult.(T?) -> Unit
+typealias SelectOneCallback<T> = ResultSet.(T?) -> Unit
-typealias SelectCallback<T> = QueryResult.(List<T>) -> Unit
+typealias SelectCallback<T> = ResultSet.(List<T>) -> Unit
-typealias SelectPaginatedCallback<T> = QueryResult.(Paginated<T>) -> Unit
+typealias SelectPaginatedCallback<T> = ResultSet.(Paginated<T>) -> Unit
 
 class Connection(
     private val database: String,
@@ -25,32 +20,34 @@ class Connection(
     private val host: String = "localhost",
     private val port: Int = 5432
 ): Executable {
-    private lateinit var connection: ConnectionPool<PostgreSQLConnection>
+    private lateinit var connection: JDBCConnection
     private val serializer = Serializer()
     private val logger: Logger? by LoggerDelegate()
 
-    internal fun connect(): ConnectionPool<PostgreSQLConnection> {
+    internal fun connect(): JDBCConnection {
-        if (!::connection.isInitialized || !connection.isConnected()) {
+        if (!::connection.isInitialized || connection.isClosed) {
-            connection = PostgreSQLConnectionBuilder.createConnectionPool(
+            connection = DriverManager.getConnection("jdbc:postgresql://$host:$port/$database", username, password)
-                "jdbc:postgresql://$host:$port/$database?user=$username&password=$password"
-            )
         }
         return connection
     }
 
-    fun <A> inTransaction(f: (Connection) -> CompletableFuture<A>) = connect().inTransaction(f)
+    fun <T> inTransaction(f: (Connection) -> T) {
+        sendQuery("BEGIN")
+        f(this)
+        sendQuery("COMMIT")
+    }
 
-    override fun <R : EntityI> select(
+    override fun <R: EntityI<*>> select(
         sql: String,
         typeReference: TypeReference<R>,
         values: List<Any?>,
-        block: (QueryResult, R?) -> Unit
+        block: (ResultSet, 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)
+        val json = result.getString(1)
         return if (json === null) {
             null
         } else {
@@ -64,41 +61,41 @@ 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)
 
-    override fun <R : EntityI> select(
+    override fun <R: EntityI<*>> select(
         sql: String,
         typeReference: TypeReference<R>,
         values: Map<String, Any?>,
-        block: (QueryResult, R?) -> Unit
+        block: (ResultSet, R?) -> Unit
     ): R? {
         return replaceArgs(sql, values) {
             select(this.sql, typeReference, this.parameters, block)
         }
     }
 
-    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)
 
-    override fun <R : EntityI> select(
+    override fun <R: EntityI<*>> select(
         sql: String,
         typeReference: TypeReference<List<R>>,
         values: List<Any?>,
-        block: (QueryResult, List<R>) -> Unit
+        block: (ResultSet, List<R>) -> Unit
     ): List<R> {
         val result = exec(sql, compileArgs(values))
-        val json = result.rows[0].getString(0)
+        val json = result.getString(1)
         return if (json === null) {
-            listOf<EntityI>() as List<R>
+            listOf<EntityI<*>>() as List<R>
         } else {
             serializer.deserializeList(json, typeReference)
         }.also {
@@ -106,20 +103,20 @@ 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)
 
-    override fun <R : EntityI> select(
+    override fun <R: EntityI<*>> select(
         sql: String,
         page: Int,
         limit: Int,
         typeReference: TypeReference<List<R>>,
         values: Map<String, Any?>,
-        block: (QueryResult, Paginated<R>) -> Unit
+        block: (ResultSet, Paginated<R>) -> Unit
     ): Paginated<R> {
         val offset = (page - 1) * limit
         val newValues = values
@@ -131,9 +128,9 @@ class Connection(
         }
 
         return line.run {
-            val json = rows[0].getString(0)
+            val json = getString(1)
             val entities = if (json === null) {
-                listOf<EntityI>() as List<R>
+                listOf<EntityI<*>>() as List<R>
             } else {
                 serializer.deserializeList(json, typeReference)
             }
@@ -141,14 +138,14 @@ class Connection(
                 entities,
                 offset,
                 limit,
-                rows[0].getInt("total") ?: error("The query not return total")
+                getInt("total")
             )
         }.also {
             block(line, it)
         }
     }
 
-    inline fun <reified R : EntityI> select(
+    inline fun <reified R: EntityI<*>> select(
         sql: String,
         page: Int,
         limit: Int,
@@ -157,44 +154,56 @@ class Connection(
     ): Paginated<R> =
         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?>,
-        block: (QueryResult, List<R>) -> Unit
+        block: (ResultSet, List<R>) -> Unit
     ): List<R> {
         return replaceArgs(sql, values) {
             select(this.sql, typeReference, this.parameters, block)
         }
     }
 
-    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)
 
-    override fun exec(sql: String, values: List<Any?>): QueryResult {
+    override fun exec(sql: String, values: List<Any?>): ResultSet {
-        val compiledValues = compileArgs(values)
+        return stopwatchQuery(sql, values) {
-        return stopwatchQuery(sql, compiledValues) {
+            connect().prepareStatement(sql).apply {
-            connect().sendPreparedStatement(sql, compiledValues).join()
+                compileArgs(values).forEachIndexed { i, v ->
+                    when (v) {
+                        is String  -> setString(i+1, v)
+                        is Int  -> setInt(i+1, v)
+                        else -> setString(i+1, v.toString())
+                    }
+                }
+            }.executeQuery().apply { next() }
         }
     }
 
-    override fun exec(sql: String, values: Map<String, Any?>): QueryResult {
+    override fun exec(sql: String, values: Map<String, Any?>): ResultSet {
         return replaceArgs(sql, values) {
             exec(this.sql, this.parameters)
         }
     }
 
     override fun sendQuery(sql: String, values: List<Any?>): Int {
-        val compiledValues = compileArgs(values)
+        return stopwatchQuery(sql, values) {
-        return stopwatchQuery(sql, compiledValues) {
+            connect().prepareStatement(sql).apply {
-            replaceArgsIntoSql(sql, compiledValues) {
+                compileArgs(values).forEachIndexed { i, v ->
-                connect().sendQuery(it).join().rowsAffected.toInt()
+                    when (v) {
+                        is String  -> setString(i+1, v)
+                        is Int  -> setInt(i+1, v)
+                        else -> setString(i+1, v.toString())
                     }
                 }
+            }.executeUpdate()
+        }
     }
 
     override fun sendQuery(sql: String, values: Map<String, Any?>): Int {
@@ -205,8 +214,10 @@ class Connection(
 
     private fun compileArgs(values: List<Any?>): List<Any?> {
         return values.map {
-            if (it is Serializable || (it is List<*> && it.firstOrNull() is Serializable)) {
+            if (it is EntityI<*>) {
-                serializer.serialize(it)
+                serializer.serialize(it).apply {
+                    serializer.collection.set<Any?, EntityI<Any?>>(it as EntityI<Any?>)
+                }
             } else {
                 it
             }
@@ -217,66 +228,32 @@ 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] ?: values[name.trimStart('_')] ?: error("Parameter $name missing")
+            values[name] ?: 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)
-            val resultText = when (result) {
+            logger?.debug("$duration ms for query: $sqlForLog", values)
-                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("""
+            logger?.info("Query Error: $sqlForLog, $values", e)
-                Query Error: 
-                ${sql.prependIndent()}, 
-                ${values.joinToString(", ").prependIndent()}
-            """.trimIndent(), e)
             throw e
         }
+
     }
 }

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

@@ -1,8 +1,8 @@
 package fr.postgresjson.connexion
 
 import com.fasterxml.jackson.core.type.TypeReference
-import com.github.jasync.sql.db.QueryResult
 import fr.postgresjson.entity.EntityI
+import java.sql.ResultSet
 
 interface EmbedExecutable {
     val connection: Connection
@@ -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>>,
@@ -47,16 +47,8 @@ interface EmbedExecutable {
         block: SelectPaginatedCallback<R> = {}
     ): Paginated<R>
 
-    fun exec(values: List<Any?> = emptyList()): QueryResult
+    fun exec(values: List<Any?> = emptyList()): ResultSet
-    fun exec(values: Map<String, Any?>): QueryResult
+    fun exec(values: Map<String, Any?>): ResultSet
-    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

@@ -1,20 +1,20 @@
 package fr.postgresjson.connexion
 
 import com.fasterxml.jackson.core.type.TypeReference
-import com.github.jasync.sql.db.QueryResult
 import fr.postgresjson.entity.EntityI
+import java.sql.ResultSet
 
 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,
@@ -48,8 +48,8 @@ interface Executable {
         block: SelectPaginatedCallback<R> = {}
     ): Paginated<R>
 
-    fun exec(sql: String, values: List<Any?> = emptyList()): QueryResult
+    fun exec(sql: String, values: List<Any?> = emptyList()): ResultSet
-    fun exec(sql: String, values: Map<String, Any?>): QueryResult
+    fun exec(sql: String, values: Map<String, Any?>): ResultSet
     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

@@ -1,9 +1,9 @@
 package fr.postgresjson.connexion
 
 import com.fasterxml.jackson.core.type.TypeReference
-import com.github.jasync.sql.db.QueryResult
 import fr.postgresjson.definition.Function
 import fr.postgresjson.entity.EntityI
+import java.sql.ResultSet
 
 class Function(val definition: Function, override val connection: Connection): EmbedExecutable {
     override fun toString(): String {
@@ -17,10 +17,10 @@ class Function(val definition: Function, override val connection: Connection) :
     /**
      * 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
+        block: (ResultSet, R?) -> Unit
     ): R? {
         val args = compileArgs(values)
         val sql = "SELECT * FROM ${definition.name} ($args)"
@@ -28,13 +28,13 @@ class Function(val definition: Function, override val connection: Connection) :
         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)
 
-    inline fun <reified R : EntityI> selectOne(
+    inline fun <reified R: EntityI<*>> selectOne(
         value: R,
         noinline block: SelectOneCallback<R> = {}
     ): R? =
@@ -43,10 +43,10 @@ class Function(val definition: Function, override val connection: Connection) :
     /**
      * 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
+        block: (ResultSet, R?) -> Unit
     ): R? {
         val args = compileArgs(values)
         val sql = "SELECT * FROM ${definition.name} ($args)"
@@ -54,13 +54,13 @@ class Function(val definition: Function, override val connection: Connection) :
         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)
 
-    inline fun <reified R : EntityI> selectOne(
+    inline fun <reified R: EntityI<*>> selectOne(
         vararg values: Pair<String, Any?>,
         noinline block: SelectOneCallback<R> = {}
     ): R? =
@@ -71,10 +71,10 @@ class Function(val definition: Function, override val connection: Connection) :
     /**
      * 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
+        block: (ResultSet, List<R>) -> Unit
     ): List<R> {
         val args = compileArgs(values)
         val sql = "SELECT * FROM ${definition.name} ($args)"
@@ -82,7 +82,7 @@ class Function(val definition: Function, override val connection: Connection) :
         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> =
@@ -91,10 +91,10 @@ class Function(val definition: Function, override val connection: Connection) :
     /**
      * 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
+        block: (ResultSet, List<R>) -> Unit
     ): List<R> {
         val args = compileArgs(values)
         val sql = "SELECT * FROM ${definition.name} ($args)"
@@ -102,13 +102,13 @@ class Function(val definition: Function, override val connection: Connection) :
         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)
 
-    inline fun <reified R : EntityI> select(
+    inline fun <reified R: EntityI<*>> select(
         vararg values: Pair<String, Any?>,
         noinline block: SelectCallback<R> = {}
     ): List<R> =
@@ -119,12 +119,12 @@ class Function(val definition: Function, override val connection: Connection) :
     /**
      * Select Multiple with pagination
      */
-    override fun <R : EntityI> select(
+    override fun <R: EntityI<*>> select(
         page: Int,
         limit: Int,
         typeReference: TypeReference<List<R>>,
         values: Map<String, Any?>,
-        block: (QueryResult, Paginated<R>) -> Unit
+        block: (ResultSet, Paginated<R>) -> Unit
     ): Paginated<R> {
         val offset = (page - 1) * limit
         val newValues = values
@@ -137,7 +137,7 @@ class Function(val definition: Function, override val connection: Connection) :
         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(),
@@ -145,7 +145,7 @@ class Function(val definition: Function, override val connection: Connection) :
     ): Paginated<R> =
         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?>,
@@ -155,14 +155,14 @@ class Function(val definition: Function, override val connection: Connection) :
 
     /* Execute function without traitements */
 
-    override fun exec(values: List<Any?>): QueryResult {
+    override fun exec(values: List<Any?>): ResultSet {
         val args = compileArgs(values)
         val sql = "SELECT * FROM ${definition.name} ($args)"
 
         return connection.exec(sql, values)
     }
 
-    override fun exec(values: Map<String, Any?>): QueryResult {
+    override fun exec(values: Map<String, Any?>): ResultSet {
         val args = compileArgs(values)
         val sql = "SELECT * FROM ${definition.name} ($args)"
 
@@ -195,11 +195,11 @@ class Function(val definition: Function, override val connection: Connection) :
         val parameters = definition.getParametersIndexedByName()
         val placeholders = values
             .filter { entry ->
-                val parameter = parameters[entry.key] ?: parameters["_" + entry.key] ?: error("Parameter ${entry.key} of function ${definition.name} not exist")
+                val parameter = parameters[entry.key] ?: error("Parameter ${entry.key} not exist")
                 parameter.default === null || entry.value !== null
             }
             .map { entry ->
-                val parameter = parameters[entry.key] ?: parameters["_" + entry.key] ?: error("Parameter ${entry.key} of function ${definition.name} not exist")
+                val parameter = parameters[entry.key]!!
                 """"${parameter.name}" := :${parameter.name}::${parameter.type}"""
             }
 

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

@@ -1,9 +1,8 @@
 package fr.postgresjson.connexion
 
 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,
@@ -11,15 +10,10 @@ data class Paginated<T : EntityI>(
 ) {
     val currentPage: Int = (offset / limit) + 1
     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

@@ -1,8 +1,9 @@
 package fr.postgresjson.connexion
 
 import com.fasterxml.jackson.core.type.TypeReference
-import com.github.jasync.sql.db.QueryResult
 import fr.postgresjson.entity.EntityI
+import java.sql.ResultSet
+
 
 class Query(override val name: String, private val sql: String, override val connection: Connection): EmbedExecutable {
     override fun toString(): String {
@@ -11,29 +12,29 @@ class Query(override val name: String, private val sql: String, override val con
 
     /* Select One */
 
-    override fun <R : EntityI> select(
+    override fun <R: EntityI<*>> select(
         typeReference: TypeReference<R>,
         values: List<Any?>,
-        block: (QueryResult, R?) -> Unit
+        block: (ResultSet, R?) -> Unit
     ): R? {
         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)
 
-    override fun <R : EntityI> select(
+    override fun <R: EntityI<*>> select(
         typeReference: TypeReference<R>,
         values: Map<String, Any?>,
-        block: (QueryResult, R?) -> Unit
+        block: (ResultSet, R?) -> Unit
     ): R? {
         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? =
@@ -41,47 +42,47 @@ class Query(override val name: String, private val sql: String, override val con
 
     /* Select Multiples */
 
-    override fun <R : EntityI> select(
+    override fun <R: EntityI<*>> select(
         typeReference: TypeReference<List<R>>,
         values: List<Any?>,
-        block: (QueryResult, List<R>) -> Unit
+        block: (ResultSet, List<R>) -> Unit
     ): List<R> {
         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)
 
-    override fun <R : EntityI> select(
+    override fun <R: EntityI<*>> select(
         typeReference: TypeReference<List<R>>,
         values: Map<String, Any?>,
-        block: (QueryResult, List<R>) -> Unit
+        block: (ResultSet, List<R>) -> Unit
     ): List<R> {
         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)
 
-    override fun <R : EntityI> select(
+    override fun <R: EntityI<*>> select(
         page: Int,
         limit: Int,
         typeReference: TypeReference<List<R>>,
         values: Map<String, Any?>,
-        block: (QueryResult, Paginated<R>) -> Unit
+        block: (ResultSet, Paginated<R>) -> Unit
     ): Paginated<R> {
         return connection.select(this.toString(), page, limit, typeReference, values, block)
     }
 
     /* Select Paginated */
 
-    inline fun <reified R : EntityI> select(
+    inline fun <reified R: EntityI<*>> select(
         page: Int,
         limit: Int,
         values: Map<String, Any?> = emptyMap(),
@@ -91,11 +92,11 @@ class Query(override val name: String, private val sql: String, override val con
 
     /* Execute function without traitements */
 
-    override fun exec(values: List<Any?>): QueryResult {
+    override fun exec(values: List<Any?>): ResultSet {
         return connection.exec(sql, values)
     }
 
-    override fun exec(values: Map<String, Any?>): QueryResult {
+    override fun exec(values: Map<String, Any?>): ResultSet {
         return connection.exec(sql, values)
     }
 

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

@@ -2,17 +2,18 @@ package fr.postgresjson.definition
 
 import java.io.File
 
+
 open class Function(
     override val script: String
 ): 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 *[^ \n]+)?"""
+            """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 *[^ ]+)?"""
                 .toRegex(setOf(RegexOption.IGNORE_CASE, RegexOption.MULTILINE))
 
         val paramsRegex =
@@ -21,9 +22,9 @@ open class Function(
 
         val queryMatch = functionRegex.find(script)
         if (queryMatch !== null) {
-            val functionName = queryMatch.groups.get("name")?.value?.trim() ?: error("Function name not found")
+            val functionName = queryMatch.groups.get("name")?.value?.trim()
             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) {
@@ -39,7 +40,7 @@ open class Function(
             } else {
                 listOf()
             }
-            this.name = functionName
+            this.name = functionName!!
             this.parameters = parameters
         } else {
             throw FunctionNotFound()
@@ -53,8 +54,9 @@ open class Function(
         return parameters
             .filter { it.direction == Parameter.Direction.IN }
             .joinToString(", ") { "${it.name} ${it.type}" }.let {
-                "$name ($it)"
+                "$name ($it) $returns"
             }
+
     }
 
     fun getParametersIndexedByName(): Map<String, Parameter> {

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

@@ -0,0 +1,42 @@
+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,5 +1,90 @@
 package fr.postgresjson.entity
 
-interface Serializable
+import com.fasterxml.jackson.annotation.JsonIgnore
-interface EntityI : Serializable
+import org.joda.time.DateTime
-interface Parameter : Serializable
+import java.util.*
+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

@@ -1,88 +0,0 @@
-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

@@ -1,135 +0,0 @@
-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,11 +1,9 @@
 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(
@@ -36,15 +34,7 @@ data class Function(
     )
 
     override fun up(): Status {
-        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 ->
@@ -59,7 +49,7 @@ data class Function(
         connection.sendQuery(down.script)
 
         this::class.java.classLoader.getResource("sql/migration/deleteFunction.sql")!!.readText().let {
-            connection.sendQuery(it, listOf(down.name))
+            connection.sendQuery(it, listOf(down))
         }
         return Status.OK
     }
@@ -69,17 +59,17 @@ data class Function(
             up()
             down()
             it.sendQuery("ROLLBACK")
-        }.join()
+        }
 
         return Status.OK // TODO
     }
 
     override fun status(): Status {
-        connection.inTransaction {
+        val result = connection.inTransaction {
             up()
             down()
             it.sendQuery("ROLLBACK")
-        }.join()
+        }
 
         return Status.OK // TODO
     }

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

@@ -3,7 +3,7 @@ package fr.postgresjson.migration
 import com.fasterxml.jackson.core.type.TypeReference
 import fr.postgresjson.connexion.Connection
 import fr.postgresjson.definition.Function.FunctionNotFound
-import fr.postgresjson.entity.mutable.Entity
+import fr.postgresjson.entity.Entity
 import fr.postgresjson.migration.Migration.Action
 import fr.postgresjson.migration.Migration.Status
 import fr.postgresjson.utils.LoggerDelegate
@@ -38,23 +38,13 @@ 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(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
@@ -137,8 +127,7 @@ data class Migrations private constructor(
     fun addFunction(newDefinition: DefinitionFunction, callback: (Function) -> Unit = {}): Migrations {
         val currentFunction = functions[newDefinition.name]
         if (currentFunction === null || currentFunction `is different from` newDefinition) {
-            val oldDefinition = functions[newDefinition.name]?.up ?: newDefinition
+            functions[newDefinition.name] = Function(newDefinition, newDefinition, connection).apply {
-            functions[newDefinition.name] = Function(newDefinition, oldDefinition, connection).apply {
                 doExecute = Action.UP
             }
         } else {
@@ -254,7 +243,6 @@ data class Migrations private constructor(
             sendQuery("COMMIT")
         }
         logger?.info("Migration done")
-        reset()
 
         return list.toMap()
     }
@@ -275,7 +263,6 @@ 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.mutable.Entity
+import fr.postgresjson.entity.Entity
 import fr.postgresjson.migration.Migration.Action
 import java.util.*
 
@@ -31,7 +31,7 @@ data class Query(
         connection.sendQuery(down)
 
         this::class.java.classLoader.getResource("sql/migration/deleteHistory.sql")!!.readText().let {
-            connection.exec(it, listOf(name))
+            connection.sendQuery(it, listOf(name))
         }
 
         return Migration.Status.OK
@@ -42,17 +42,17 @@ data class Query(
             up()
             down()
             it.sendQuery("ROLLBACK")
-        }.join()
+        }
 
         return Migration.Status.OK // TODO
     }
 
     override fun status(): Migration.Status {
-        connection.inTransaction {
+        val result = connection.inTransaction {
             up()
             down()
             it.sendQuery("ROLLBACK")
-        }.join()
+        }
 
         return Migration.Status.OK // TODO
     }

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

@@ -0,0 +1,13 @@
+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

@@ -1,12 +0,0 @@
-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,37 +1,47 @@
 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.DeserializationFeature
+import com.fasterxml.jackson.databind.*
-import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer
-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.Serializable
+import fr.postgresjson.entity.EntitiesCollections
+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 serialize(source: Any, pretty: Boolean = false): String {
+    fun <T> serialize(source: EntityI<T>, pretty: Boolean = false): String {
         return if (pretty) mapper.writerWithDefaultPrettyPrinter().writeValueAsString(source)
         else mapper.writeValueAsString(source)
     }
 
-    fun <E> deserialize(json: String, valueTypeRef: TypeReference<E>): E {
+    fun <E: EntityI<*>> deserialize(json: String, valueTypeRef: TypeReference<E>): E {
         return this.mapper.readValue(json, valueTypeRef)
     }
 
-    inline fun <reified E> deserialize(json: String): E? {
+    inline fun <reified E: EntityI<*>> deserialize(json: String): E? {
         return this.mapper.readValue(json)
     }
 
@@ -43,12 +53,50 @@ class Serializer(val mapper: ObjectMapper = jacksonObjectMapper()) {
         return deserializeList(json, object: TypeReference<E>() {})
     }
 
-    fun <E> deserialize(json: String, target: E): E {
+    fun <E: EntityI<*>> deserialize(json: String, target: E): E {
         return mapper.readerForUpdating(target).readValue<E>(json)
     }
 }
 
-fun Serializable.serialize(pretty: Boolean = false) = Serializer().serialize(this, pretty)
+fun <T> EntityI<T?>.serialize(pretty: Boolean = false) = Serializer().serialize(this, pretty)
-fun List<Serializable>.serialize(pretty: Boolean = false) = Serializer().serialize(this, pretty)
+inline fun <reified E: EntityI<*>> E.deserialize(json: String) = Serializer().deserialize(json, this)
-inline fun <reified E : Serializable> E.deserialize(json: String) = Serializer().deserialize(json, this)
+inline fun <reified E: EntityI<*>> String.deserialize() = Serializer().deserialize<E>(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/test/kotlin/fr/postgresjson/ConnectionTest.kt

@@ -1,8 +1,7 @@
 package fr.postgresjson
 
 import fr.postgresjson.connexion.Paginated
-import fr.postgresjson.entity.mutable.IdEntity
+import fr.postgresjson.entity.IdEntity
-import fr.postgresjson.entity.Parameter
 import org.junit.Assert.*
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
@@ -13,8 +12,6 @@ class ConnectionTest() : TestAbstract() {
     private class ObjTest(var name: String): 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 ObjTestWithParameterObject(var first: ParameterObject, var seconde: ParameterObject) : IdEntity()
-    private class ParameterObject(var third: String) : Parameter
 
     @Test
     fun getObject() {
@@ -38,7 +35,8 @@ class ConnectionTest() : TestAbstract() {
         """.trimIndent()
         )
         assertNotNull(objs)
-        assertEquals(objs.size, 2)
+        assertTrue(objs is List<ObjTest2>)
+        assertEquals(objs!!.size, 2)
         assertEquals(objs[0].id, 1)
         assertEquals(objs[0].test!!.id, 1)
     }
@@ -65,7 +63,7 @@ class ConnectionTest() : TestAbstract() {
     fun callExec() {
         val o = ObjTest("myName")
         val result = connection.exec("select json_build_object('id', 1, 'name', ?::json->>'name')", listOf(o))
-        Assertions.assertEquals(1, result.rowsAffected)
+        Assertions.assertNotNull(result.getString(1))
     }
 
     @Test
@@ -83,19 +81,6 @@ 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(
@@ -172,7 +157,7 @@ class ConnectionTest() : TestAbstract() {
             params
         ) {
             assertEquals("ff", it!!.first)
-            assertEquals("plop", rows[0].getString("other"))
+            assertEquals("plop", getString("other"))
         }
         assertNotNull(result)
         assertEquals("ff", result!!.first)

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

@@ -1,26 +1,25 @@
 package fr.postgresjson
 
-import fr.postgresjson.entity.EntityI
+import fr.postgresjson.entity.*
-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(id: Int?) : Entity<Int?>(id)
+    private class User(override var id: Int?): EntityI<Int?>
-    private class ObjTest(var name: String) : UuidEntityExtended<Int?, User>(User(1), User(2))
+    private class ObjTest(var name: String): EntityExtended<Int?, User>()
 
     @Test
     fun getObject() {
         val obj: ObjTest? = ObjTest("plop")
         assertTrue(obj is ObjTest)
-        assertTrue(obj is UuidEntityExtended<Int?, User>)
+        assertTrue(obj is EntityExtended<Int?, User>)
-        assertTrue(obj is EntityI)
+        assertTrue(obj is EntityI<Int?>)
         assertTrue(obj is Entity<Int?>)
         assertTrue(obj is Published<User>)
-        assertTrue(obj is EntityCreatedBy<User>)
+        assertTrue(obj is CreatedBy<User>)
-        assertTrue(obj is EntityUpdatedBy<User>)
+        assertTrue(obj is UpdatedBy<User>)
         assertTrue(obj is EntityCreatedAt)
         assertTrue(obj is EntityUpdatedAt)
     }

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

@@ -79,7 +79,7 @@ class MigrationTest() : TestAbstract() {
     @Test
     fun `run migrations force down`() {
         val resources = File(this::class.java.getResource("/sql/real_migrations").toURI())
-        val resourcesFunctions = File(this::class.java.getResource("/sql/function/Test").toURI())
+        val resourcesFunctions = File(this::class.java.getResource("/sql/function").toURI())
         Migrations(listOf(resources, resourcesFunctions), connection).apply {
             up().apply {
                 size `should be equal to` 6
@@ -94,7 +94,7 @@ class MigrationTest() : TestAbstract() {
 
     @Test
     fun `run functions migrations`() {
-        val resources = File(this::class.java.getResource("/sql/function/Test").toURI())
+        val resources = File(this::class.java.getResource("/sql/function").toURI())
         Migrations(resources, connection).apply {
             run().size `should be equal to` 5
         }
@@ -107,25 +107,4 @@ 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,9 +2,10 @@ package fr.postgresjson
 
 import fr.postgresjson.connexion.Paginated
 import fr.postgresjson.connexion.Requester
-import fr.postgresjson.entity.mutable.IdEntity
+import fr.postgresjson.entity.IdEntity
 import org.junit.Assert
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertNotNull
 import org.junit.jupiter.api.Test
 import java.io.File
 
@@ -25,7 +26,7 @@ class RequesterTest : TestAbstract() {
 
     @Test
     fun `get function from file`() {
-        val resources = File(this::class.java.getResource("/sql/function/Test").toURI())
+        val resources = File(this::class.java.getResource("/sql/function").toURI())
         val objTest: ObjTest? = Requester(connection)
             .addFunction(resources)
             .getFunction("test_function")
@@ -43,18 +44,18 @@ class RequesterTest : TestAbstract() {
             .getQuery("Test/selectOne")
             .exec()
 
-        assertEquals(1, result.rowsAffected)
+        assertNotNull(result.getString(1))
     }
 
     @Test
     fun `call exec on function`() {
-        val resources = File(this::class.java.getResource("/sql/function/Test").toURI())
+        val resources = File(this::class.java.getResource("/sql/function").toURI())
         val result = Requester(connection)
             .addFunction(resources)
             .getFunction("test_function")
             .exec(listOf("test", "plip"))
 
-        assertEquals(1, result.rowsAffected)
+        assertNotNull(result.getString(1))
     }
 
     @Test
@@ -70,7 +71,7 @@ class RequesterTest : TestAbstract() {
 
     @Test
     fun `call sendQuery on function`() {
-        val resources = File(this::class.java.getResource("/sql/function/Test").toURI())
+        val resources = File(this::class.java.getResource("/sql/function").toURI())
         val result = Requester(connection)
             .addFunction(resources)
             .getFunction("function_void")
@@ -81,7 +82,7 @@ class RequesterTest : TestAbstract() {
 
     @Test
     fun `call selectOne on function`() {
-        val resources = File(this::class.java.getResource("/sql/function/Test").toURI())
+        val resources = File(this::class.java.getResource("/sql/function").toURI())
         val obj: ObjTest = Requester(connection)
             .addFunction(resources)
             .getFunction("test_function")
@@ -92,7 +93,7 @@ class RequesterTest : TestAbstract() {
 
     @Test
     fun `call selectOne on function with object`() {
-        val resources = File(this::class.java.getResource("/sql/function/Test").toURI())
+        val resources = File(this::class.java.getResource("/sql/function").toURI())
         val obj2 = ObjTest("original")
         val obj: ObjTest = Requester(connection)
             .addFunction(resources)
@@ -116,7 +117,7 @@ class RequesterTest : TestAbstract() {
 
     @Test
     fun `call select (multiple) on function`() {
-        val resources = File(this::class.java.getResource("/sql/function/Test").toURI())
+        val resources = File(this::class.java.getResource("/sql/function").toURI())
         val obj: List<ObjTest>? = Requester(connection)
             .addFunction(resources)
             .getFunction("test_function_multiple")
@@ -133,10 +134,10 @@ class RequesterTest : TestAbstract() {
             .getQuery("Test/selectPaginated")
             .select(1, 2, mapOf("name" to "ff"))
         Assert.assertNotNull(result)
-        Assert.assertEquals("ff", result.result[0].name)
+        Assert.assertEquals(result.result[0].name, "ff")
-        Assert.assertEquals("ff-2", result.result[1].name)
+        Assert.assertEquals(result.result[1].name, "ff-2")
-        Assert.assertEquals(10, result.total)
+        Assert.assertEquals(result.total, 10)
-        Assert.assertEquals(0, result.offset)
+        Assert.assertEquals(result.offset, 0)
     }
 
     @Test
@@ -147,10 +148,10 @@ class RequesterTest : TestAbstract() {
             .getFunction("test_function_paginated")
             .select(1, 2, mapOf("name" to "ff"))
         Assert.assertNotNull(result)
-        Assert.assertEquals("ff", result.result[0].name)
+        Assert.assertEquals(result.result[0].name, "ff")
-        Assert.assertEquals("ff-2", result.result[1].name)
+        Assert.assertEquals(result.result[1].name, "ff-2")
-        Assert.assertEquals(10, result.total)
+        Assert.assertEquals(result.total, 10)
-        Assert.assertEquals(0, result.offset)
+        Assert.assertEquals(result.offset, 0)
     }
 
     @Test
@@ -161,7 +162,7 @@ class RequesterTest : TestAbstract() {
             .getQuery("Test/selectOneWithParameters")
             .selectOne(mapOf("name" to "myName")) {
                 assertEquals("myName", it!!.name)
-                Assert.assertEquals("plop", rows[0].getString("other"))
+                Assert.assertEquals("plop", getString("other"))
             }!!
 
         assertEquals("myName", obj.name)

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

@@ -1,6 +1,6 @@
 package fr.postgresjson
 
-import fr.postgresjson.entity.mutable.IdEntity
+import fr.postgresjson.entity.IdEntity
 import fr.postgresjson.serializer.Serializer
 import fr.postgresjson.serializer.deserialize
 import fr.postgresjson.serializer.serialize
@@ -41,14 +41,6 @@ internal class SerializerTest {
         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,22 +9,23 @@ import java.io.File
 
 @TestInstance(PER_CLASS)
 abstract class TestAbstract {
-    protected val connection = Connection(database = "test_json", username = "test", password = "test")
+    protected val connection = Connection(database = "test", username = "test", password = "test")
 
     @BeforeEach
     fun beforeAll() {
         val initSQL = File(this::class.java.getResource("/fixtures/init.sql").toURI())
         connection
             .connect()
-            .sendQuery(initSQL.readText())
+            .createStatement()
-            .join()
+            .executeUpdate(initSQL.readText())
     }
 
     @AfterEach
     fun afterAll() {
         val downSQL = File(this::class.java.getResource("/fixtures/down.sql").toURI())
         connection.connect().apply {
-            sendQuery(downSQL.readText()).join()
+            createStatement()
-        }.disconnect()
+                .executeUpdate(downSQL.readText())
+        }.close()
     }
 }

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

@@ -1,8 +0,0 @@
-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

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