Add ShadowJar compatibility and Query file can be define name with comment

Add Migration and Query definition class
Add Docker DB for tests

.github/workflows/gradle.yml

@@ -1,76 +0,0 @@
-name: Tests
-
-on:
-  push:
-    branches:
-      - 'master'
-  pull_request:
-    branches:
-      - 'master'
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up JDK 11
-        uses: actions/setup-java@v1
-        with:
-          java-version: 11
-
-      - name: Cache Gradle packages
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.gradle/caches
-            ~/.gradle/wrapper
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
-          restore-keys: |
-            ${{ runner.os }}-gradle-
-
-      - name: Build
-        uses: eskatos/gradle-command-action@v1
-        with:
-          gradle-version: '7.1'
-          arguments: build -x test -x ktlintKotlinScriptCheck -x ktlintTestSourceSetCheck -x ktlintMainSourceSetCheck
-      - name: Cleanup Gradle Cache
-        # Remove some files from the Gradle cache, so they aren't cached by GitHub Actions.
-        # Restoring these files from a GitHub Actions cache might cause problems for future builds.
-        run: |
-          rm -f ~/.gradle/caches/modules-2/modules-2.lock
-          rm -f ~/.gradle/caches/modules-2/gc.properties
-
-      - name: Lint
-        uses: eskatos/gradle-command-action@v1
-        with:
-          gradle-version: '7.1'
-          arguments: ktlintCheck
-
-      - name: Test
-        uses: eskatos/gradle-command-action@v1
-        with:
-          gradle-version: '7.1'
-          arguments: test
-
-      - name: Coverage
-        uses: eskatos/gradle-command-action@v1
-        with:
-          gradle-version: '7.1'
-          arguments: jacocoTestReport
-
-      - name: Cache SonarCloud packages
-        uses: actions/cache@v1
-        with:
-          path: ~/.sonar/cache
-          key: ${{ runner.os }}-sonar
-          restore-keys: ${{ runner.os }}-sonar
-
-      - name: Push analyse to sonarqube
-        uses: eskatos/gradle-command-action@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}  # Needed to get PR information, if any
-          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
-        with:
-          gradle-version: '7.1'
-          arguments: sonarqube --info

.github/workflows/publish.yml

@@ -1,53 +0,0 @@
-name: Publish
-
-on:
-  release:
-    types: [ published ]
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up JDK 11
-      uses: actions/setup-java@v1
-      with:
-        java-version: 11
-
-    - name: Cache Gradle packages
-      uses: actions/cache@v2
-      with:
-        path: |
-          ~/.gradle/caches
-          ~/.gradle/wrapper
-        key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
-        restore-keys: |
-          ${{ runner.os }}-gradle-
-
-    - name: Build
-      uses: eskatos/gradle-command-action@v1
-      with:
-        gradle-version: '7.1'
-        arguments: build -x test -x ktlintKotlinScriptCheck -x ktlintTestSourceSetCheck -x ktlintMainSourceSetCheck
-    - name: Cleanup Gradle Cache
-      # Remove some files from the Gradle cache, so they aren't cached by GitHub Actions.
-      # Restoring these files from a GitHub Actions cache might cause problems for future builds.
-      run: |
-        rm -f ~/.gradle/caches/modules-2/modules-2.lock
-        rm -f ~/.gradle/caches/modules-2/gc.properties
-
-    - name: Test
-      uses: eskatos/gradle-command-action@v1
-      with:
-        gradle-version: '7.1'
-        arguments: test
-
-    - name: Publish
-      uses: eskatos/gradle-command-action@v1
-      with:
-        gradle-version: '7.1'
-        arguments: publish
-      env:
-        GITHUB_ACTOR: ${{ secrets.GITHUB_ACTOR }}
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.idea/.gitignore

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

.idea/codeStyles/Project.xml

@@ -2,30 +2,14 @@
   <code_scheme name="Project" version="173">
     <JetCodeStyleSettings>
       <option name="PACKAGES_TO_USE_STAR_IMPORTS">
-        <value />
-      </option>
-      <option name="PACKAGES_IMPORT_LAYOUT">
         <value>
-          <package name="" alias="false" withSubpackages="true" />
-          <package name="" alias="true" withSubpackages="true" />
+          <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="NAME_COUNT_TO_USE_STAR_IMPORT_FOR_MEMBERS" value="2147483647" />
-      <option name="IMPORT_NESTED_CLASSES" value="true" />
-      <option name="ALLOW_TRAILING_COMMA" value="true" />
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
     </JetCodeStyleSettings>
-    <SqlCodeStyleSettings version="6">
-      <option name="KEYWORD_CASE" value="1" />
-      <option name="IDENTIFIER_CASE" value="1" />
-      <option name="TYPE_CASE" value="1" />
-      <option name="CUSTOM_TYPE_CASE" value="1" />
-      <option name="ALIAS_CASE" value="1" />
-      <option name="BUILT_IN_CASE" value="1" />
-      <option name="QUOTE_IDENTIFIER" value="1" />
-    </SqlCodeStyleSettings>
     <codeStyleSettings language="kotlin">
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
       <indentOptions>

.idea/dataSources.xml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="DataSourceManagerImpl" format="xml" multifile-model="true">
-    <data-source source="LOCAL" name="PostgreSQL - json_test@localhost" uuid="1191ff9a-6823-4b18-af90-483ddf0e4b69">
-      <driver-ref>postgresql</driver-ref>
-      <synchronize>true</synchronize>
-      <jdbc-driver>org.postgresql.Driver</jdbc-driver>
-      <jdbc-url>jdbc:postgresql://localhost:35555/json_test</jdbc-url>
-      <working-dir>$ProjectFileDir$</working-dir>
-    </data-source>
-  </component>
-</project>

.idea/kotlinc.xml

@@ -3,7 +3,4 @@
   <component name="Kotlin2JvmCompilerArguments">
     <option name="jvmTarget" value="11" />
   </component>
-  <component name="KotlinJpsPluginSettings">
-    <option name="version" value="1.7.20" />
-  </component>
 </project>

.idea/misc.xml

@@ -3,7 +3,7 @@
   <component name="FrameworkDetectionExcludesConfiguration">
     <file type="web" url="file://$PROJECT_DIR$" />
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="openjdk-17" project-jdk-type="JavaSDK">
+  <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/runConfigurations/Check.xml

@@ -1,6 +1,5 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Check" type="CompoundRunConfigurationType">
-    <toRun name="run DB" type="docker-deploy" />
     <toRun name="Lint" type="GradleRunConfiguration" />
     <toRun name="tests" type="JUnit" />
     <method v="2" />

.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

@@ -2,12 +2,6 @@
   <configuration default="false" name="tests" type="JUnit" factoryName="JUnit" singleton="false">
     <module name="postgres-json.test" />
     <useClassPathOnly />
-    <extension name="coverage">
-      <pattern>
-        <option name="PATTERN" value="fr.postgresjson.*" />
-        <option name="ENABLED" value="true" />
-      </pattern>
-    </extension>
     <extension name="net.ashald.envfile">
       <option name="IS_ENABLED" value="false" />
       <option name="IS_SUBST" value="false" />

README.md

@@ -1,39 +0,0 @@
-PostgresJson
-============
-_Kotlin library to request postgres with native SQL queries_
-
-[![Tests](https://github.com/flecomte/postgres-json/actions/workflows/gradle.yml/badge.svg)](https://github.com/flecomte/postgres-json/actions/workflows/gradle.yml)
-[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=postgres-json&metric=coverage)](https://sonarcloud.io/dashboard?id=postgres-json)
-
-[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=postgres-json&metric=alert_status)](https://sonarcloud.io/dashboard?id=postgres-json)
-[![Lines of Code](https://sonarcloud.io/api/project_badges/measure?project=postgres-json&metric=ncloc)](https://sonarcloud.io/dashboard?id=postgres-json)
-
----
-
-## What is this lib for?
-This library allows you to make sql requests and return the result in json format, then deserialize it into an entity.
-It also allows you to save an entity (INSERT) by serializing it and sending the json to the database, allowing you to insert several entities with their children, in a single request.
-
-It also manages the migrations of the schema of tables and stored procedures.
-
-All sql requests are handled manually for full control over what you do.
-
----
-
-## The best benefits
-
-* Total control of all Postgresql features and SQL language
-* More speed and flexible than an ORM
-* [Multi level request](./docs/usage/multi-level.md) (Can return multiple tables and these children in a single request)
-* Queries are written in separate native `.sql` files
-* Unit testing of SQL queries
-* Migrations are written in separate native `.sql` files
-* Automatic tested database migration and rollback
----
-## Documentation: Table of Contents
-
-* [Installation](./docs/installation.md)
-* [Migrations](./docs/migrations/migrations.md)
-* [Usage](./docs/usage/usage.md)
-* [How that works](./docs/call%20function.png) (Diagram)
-* [How to begin](./docs/checklist.md)

build.gradle.kts

@@ -1,83 +1,45 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-val containerAlwaysOn: String by project
-val disableLint: String by project
-val projectName: String by project
 
 plugins {
     jacoco
 
     id("maven-publish")
-    kotlin("jvm") version "1.7.20"
+    id("org.jetbrains.kotlin.jvm") version "1.3.50"
 
-    id("org.jlleitschuh.gradle.ktlint") version "11.0.0"
-    id("org.owasp.dependencycheck") version "7.2.0"
-    id("fr.coppernic.versioning") version "3.2.1"
-    id("com.avast.gradle.docker-compose") version "0.16.9"
-    id("org.sonarqube") version "+"
+    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 = "io.github.flecomte"
+group = "flecomte"
 version = versioning.info.tag
 
 repositories {
     mavenCentral()
+    jcenter()
 }
 
 tasks.withType<KotlinCompile> {
     kotlinOptions {
         jvmTarget = "11"
+        sourceCompatibility = "11"
+        targetCompatibility = "11"
     }
 }
 
-val compileKotlin: KotlinCompile by tasks
-compileKotlin.kotlinOptions {
-    jvmTarget = "11"
-}
-val compileTestKotlin: KotlinCompile by tasks
-compileTestKotlin.kotlinOptions {
-    jvmTarget = "11"
-}
-
-tasks.test {
-    useJUnit()
-    useJUnitPlatform()
-    systemProperty("junit.jupiter.execution.parallel.enabled", true)
-    if (!disableLint.toBoolean()) {
-        finalizedBy(tasks.ktlintCheck)
-    }
-}
-
-tasks.jacocoTestReport {
-    dependsOn(tasks.test)
-    reports {
-        xml.required.set(true)
-    }
-}
-
-tasks.sonarqube.configure {
-    dependsOn(tasks.jacocoTestReport)
-}
-
-tasks.publishToMavenLocal {
-    dependsOn(tasks.test)
-}
-
 dependencies {
-    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.7.20")
-    implementation("org.jetbrains.kotlin:kotlin-reflect:1.7.20")
-    implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.14.0-rc1")
-    implementation("com.fasterxml.jackson.datatype:jackson-datatype-joda:2.14.0-rc1")
-    implementation("com.github.jasync-sql:jasync-postgresql:2.1.7")
-    implementation("org.slf4j:slf4j-api:2.0.3")
+    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")
 
-    testImplementation("ch.qos.logback:logback-classic:1.4.3")
-    testImplementation("ch.qos.logback:logback-core:1.4.3")
-    testImplementation("io.mockk:mockk:1.13.2")
-    testImplementation("org.junit.jupiter:junit-jupiter:5.9.0")
-    testImplementation("org.jetbrains.kotlin:kotlin-test-junit:1.7.20")
-    testImplementation("org.amshove.kluent:kluent:1.68")
-    testImplementation("io.kotest:kotest-runner-junit5:5.5.5")
-    testImplementation("io.kotest:kotest-property:5.5.5")
+    testImplementation("ch.qos.logback:logback-classic:1.2.3")
+    testImplementation("ch.qos.logback:logback-core:1.2.3")
+    testImplementation("io.mockk:mockk:1.9")
+    testImplementation("org.junit.jupiter:junit-jupiter:5.4.2")
+    testImplementation("org.amshove.kluent:kluent:1.47")
 }
 
 val sourcesJar by tasks.creating(Jar::class) {
@@ -85,18 +47,10 @@ val sourcesJar by tasks.creating(Jar::class) {
     from(sourceSets.getByName("main").allSource)
 }
 
-apply(plugin = "docker-compose")
-dockerCompose {
-    setProjectName(projectName.toString())
-    setProperty("useComposeFiles", listOf("docker-compose.yml"))
-    setProperty("stopContainers", !containerAlwaysOn.toBoolean())
-    isRequiredBy(project.tasks.test)
-}
-
 publishing {
     repositories {
         maven {
-            name = projectName.toString()
+            name = "postgres-json"
             url = uri("https://maven.pkg.github.com/flecomte/postgres-json")
             credentials {
                 username = System.getenv("GITHUB_USERNAME")
@@ -106,19 +60,9 @@ publishing {
     }
 
     publications {
-        create<MavenPublication>(projectName.toString()) {
+        create<MavenPublication>("postgres-json") {
             from(components["java"])
             artifact(sourcesJar)
         }
     }
-}
-
-tasks.withType<PublishToMavenRepository>().configureEach {
-    onlyIf {
-        versioning.info.run {
-            !dirty && tag != null && tag.matches("""[0-9]+\.[0-9]+\.[0-9]+""".toRegex())
-        }
-    }
-
-    dependsOn(tasks.test)
-}
+}

docker-compose.yml

@@ -1,6 +1,6 @@
 # To execute this docker-compose yml file use docker-compose -f <file_name> up
 # Add the "-d" flag at the end for detached execution
-version: '3.8'
+version: '3.7'
 services:
   db:
     container_name: postgres_json
@@ -8,8 +8,18 @@ services:
       context: docker/postgresql
     restart: always
     ports:
-      - "35555:5432"
+      - 5555:5432
     environment:
       POSTGRES_DB: json_test
       POSTGRES_USER: test
       POSTGRES_PASSWORD: test
+
+  pgadmin:
+    container_name: pgadmin4_json
+    image: dpage/pgadmin4
+    restart: always
+    ports:
+      - 8585:80
+    environment:
+      PGADMIN_DEFAULT_EMAIL: rusk23@gmail.com
+      PGADMIN_DEFAULT_PASSWORD: azerty

docker/postgresql/Dockerfile

@@ -1,4 +1,4 @@
-FROM postgres:15
+FROM postgres:11
 
 COPY postgresql.conf /tmp/postgresql.conf
 COPY extension.sh    /docker-entrypoint-initdb.d/000-extension.sh

docker/postgresql/postgresql.conf

@@ -664,3 +664,5 @@ log_rotation_size = 100MB
 #------------------------------------------------------------------------------
 
 # Add settings for extensions here
+
+zdb.default_elasticsearch_url = 'http://elasticsearch:9200/'

docs/call function.puml

@@ -1,52 +0,0 @@
-@startuml
-
-participant  Gradle
-participant  App
-control  Migration
-control  Repository
-control  Requester
-control  Function
-control  Connection
-database Database
-
-== Migration ==
-
-[-> Gradle++ : run gradle
-    Gradle -> Migration** : Init Migration
-        Migration -> Migration : Read Schemas
-        Migration -> Migration : Read SQL Function
-    Gradle -> Migration++ : Run Migrations
-        Migration -> Migration : Run Migrations
-    return
-    Gradle -> Migration!!
-return
-
-== Application ==
-
-[-> App : run app
-    App -> Connection** : Create Connection
-        Connection -> Database : Connect to the database
-    App -> Requester** : Create Requester
-        Requester -> Requester: Read all Function file
-        Requester -> Function** : Create Function object
-            Function -> Function : Parse function
-            Function -> Function : Store parameters and function name
-    App -> Repository** : Create Repository
-
-... wait request ...
-
-[-> Repository++ : call repository with args
-    Repository -> Repository : Define function name
-    Repository -> Requester++ : get function
-        Requester -> Function++ : select()
-            Function -> Function : Compile args
-            Function -> Function : Compile SQL
-            Function -> Connection++ : select()
-                Connection -> Database++ : Send Prepared Statement
-                return
-                Connection -> Connection : Convert json to Entity
-            return entity
-        return entity
-    return entity
-return entity
-@enduml

docs/checklist.md

@@ -1,9 +0,0 @@
-# Checklist
-
-- [ ] Define schemas with migrations files (*.up.sql & *.down.sql)
-- [ ] Define query with sql function (*.sql)
-- [ ] Create Entity (*.kt)
-- [ ] Create repository (*.kt)
-- [ ] Configure migrations in gradle
-- [ ] Execute migrations functions
-- [ ] Call Repository

docs/installation.md

@@ -1,9 +0,0 @@
-# Installation
-
-## Gradle
-```kotlin
-// build.gradle.kts
-dependencies {
-    implementation("com.github.flecomte:postgres-json:+")
-}
-```

docs/migrations/migrations-application.md

@@ -1,16 +0,0 @@
-# Execute migration in application
-```kotlin
-import fr.postgresjson.migration.Migrations
-import fr.postgresjson.connexion.Connection
-
-val conn: Connection = TODO()
-val migrations = Migrations(
-    conn,
-    this::class.java.getResource("/sql/migrations")?.toURI() ?: error("No migrations found"),
-    this::class.java.getResource("/sql/functions")?.toURI() ?: error("No sql function found")
-)
-
-migrations.status() // Show executed and not executed migrations
-migrations.runDry() // Execute migration in transaction and rollback at the end
-migrations.run() // Execute migration in transaction and commit if no error
-```

docs/migrations/migrations-gradle.md

@@ -1,37 +0,0 @@
-# Execute Migrations with Gradle
-
-You can execute migration with a Gradle task like this:
-
-```kotlin
-// build.gradle.kts
-import fr.postgresjson.connexion.Connection
-import fr.postgresjson.connexion.Requester
-import fr.postgresjson.migration.Migrations
-
-buildscript {
-    dependencies {
-        classpath("com.github.flecomte:postgres-json:+")
-    }
-}
-
-val migration by tasks.registering {
-    doLast {
-        val connection = Connection(
-            host = "localhost",
-            port = 5432,
-            database = "database",
-            username = "username",
-            password = "password"
-        )
-        Migrations(
-            connection,
-            file("$buildDir/resources/main/sql/migrations").toURI(),
-            file("$buildDir/resources/main/sql/functions").toURI()
-        ).run()
-    }
-}
-```
-
-```shell
-$ gradle migration
-```

docs/migrations/migrations.md

@@ -1,71 +0,0 @@
-# Migration
-## Schemas migration
-Migrations are just manually written `*.sql` files that represent the database schemas.
-Each file is executed one after the other in alphabetical order.
-Each execution is stored in the `migration.history` table.
-
-A migration contains a `*.up.sql` file and a `*.down.sql` file to rollback the migration.
-The content of the `*.down.sql` file is also stored in the database.
-This allows the `*.down.sql` to be executed even if the code is already rollback.
-
-Example:
-```postgresql
--- resources/sql/migrations/0000-init_schema.up.sql
-create table "user"
-(
-    id         uuid        default uuid_generate_v4() not null primary key,
-    created_at timestamptz default now()              not null,
-    blocked_at timestamptz default null               null,
-    username   varchar(64)                            not null check ( username != '' and lower(username) = username) unique,
-    password   text                                   not null check ( password != '' ),
-    roles      text[]      default '{}'               not null
-);
-```
-
-```postgresql
--- resources/sql/migrations/0000-init_schema.down.sql
-drop table if exists "user";
-```
-## Stored procedure migrations
-
-Migrations are also stored procedures and other functions.
-Each function is updated with each migration.
-
-Example:
-```postgresql
--- resources/sql/functions/insert_user.sql
-create or replace function insert_user(inout resource json) language plpgsql as
-$$
-declare
-    new_id uuid;
-begin
-    insert into "user" (id, username, password, blocked_at, roles)
-    select
-        coalesce(t.id, uuid_generate_v4()),
-        t.username,
-        crypt(resource->>'password', gen_salt('bf', 8)),
-        case when t.blocked_at is not null then now() else null end,
-        t.roles
-    from json_populate_record(null::"user", resource) t
-    returning id into new_id;
-
-    select find_user_by_id(new_id) into resource;
-end;
-$$;
-```
-
-```postgresql
--- resources/sql/functions/find_user_by_id.sql
-create or replace function find_user_by_id(in _id uuid, out resource json) language plpgsql as
-$$
-begin
-    select to_jsonb(u) - 'password' into resource
-    from "user" as u
-    where u.id = _id;
-end;
-$$;
-```
-
-* [Execute migrations in application](./migrations-application.md)
-* [Execute migrations with gradle](./migrations-gradle.md)
-

docs/usage/init-connection.md

@@ -1,14 +0,0 @@
-# Init connection
-
-Before execute any query you must instantiate the connection.
-```kotlin
-import fr.postgresjson.connexion.Connection
-
-val connection = Connection(
-    host = "localhost",
-    port = 5432,
-    database = "mydb",
-    username = "john",
-    password = "azerty"
-)
-```

docs/usage/multi-level.md

@@ -1,93 +0,0 @@
-Multi Level Queries
-===================
-
-## Define schema, query and kotlin object
-1. Schema
-```postgresql
-create table parent (
-    id uuid primary key,
-    name text not null
-);
-
-create table child (
-    id uuid primary key,
-    name text not null,
-    parent_id uuid not null references parent
-)
-```
-2. Insert some data for tests
-```postgresql
-insert into parent (id, name) VALUES ('379e0687-9e4a-4781-b0e9-d94a62e4261f', 'Bernard');
-insert into child (id, name, parent_id) VALUES (uuid_generate_v4(), 'Noé', '379e0687-9e4a-4781-b0e9-d94a62e4261f');
-insert into child (id, name, parent_id) VALUES (uuid_generate_v4(), 'John', '379e0687-9e4a-4781-b0e9-d94a62e4261f');
-```
-3. Define Model
-```kotlin
-import java.util.UUID
-
-class Parent(val id: UUID, val name: String, val children: List<Child>)
-class Child(val id: UUID, val name: String)
-```
-
-4. Define request function
-```postgresql
--- resource/sql/functions/find_parent_by_id.sql
-create or replace function find_parent_by_id(in _id uuid, out resource json) language plpgsql as
-$$
-begin
-    select to_json(t) into resource
-    from (
-        select 
-            p.*,
-            json_agg(to_jsonb(c) - 'parent_id') as children   
-        from parent p
-        join child c on c.parent_id = p.id
-        where p.id = _id
-        group by p.id
-    ) t;
-end;
-$$;
-```
-
-## Execute the function
-
-You just to use `Requester` and set the sql function name, then pass arguments.
-
-If you need to return more than one entry, use `.select()` instead of `.selecteOne()`
-
-See the [Paginated example](./paginated.md)
-```kotlin
-import fr.postgresjson.connexion.Requester
-
-val requester: Requester = TODO()
-val result: Parent = requester
-    .getFunction("find_parent_by_id")
-    .execute("id" to "379e0687-9e4a-4781-b0e9-d94a62e4261f")
-```
-
-The requester create dynamically this request
-```postgresql
-select * from find_parent_by_id(_id => '379e0687-9e4a-4781-b0e9-d94a62e4261f');
-```
-*Watch the underscore as prefix is added if necessary.
-The requester known the parameters because it parses all SQL functions and reads the names of the parameters from them.*
-
-
-And the SQL return is a JSON like follow:
-```json
-{
-  "id": "379e0687-9e4a-4781-b0e9-d94a62e4261f",
-  "name": "Bernard",
-  "child": [
-    {
-      "id": "c2d0ec81-7cac-4689-8086-2644a3b309b5",
-      "name": "Noé"
-    },
-    {
-      "id": "255d911a-0cbc-4156-bf8c-0204e89494d9",
-      "name": "John"
-    }
-  ]
-}
-```
-But the requester deserialize the result automatically into a Kotlin object with their children objects. **And do that in only one request**.

docs/usage/raw-request.md

@@ -1,86 +0,0 @@
-# Raw request
-You can execute query directly from the code like this:
-(*see [Init connection](./init-connection.md) before*)
-
-```kotlin
-import fr.postgresjson.connexion.Connection
-
-val connection: Connection = TODO()
-
-val result: QueryResult = connection.exec(
-    "SELECT id FROM inventor WHERE name = :name",
-    mapOf("name" to "Nikola Tesla")
-)
-val id: String = result.rows[0].getString(0)
-```
-
-And if you must map the query result with an entity, you can do it like this:
-```kotlin
-import java.util.UUID
-import fr.postgresjson.entity.Serializable
-import fr.postgresjson.connexion.Connection
-
-val connection: Connection = TODO()
-
-data class Inventor(
-    val id: UUID = UUID.randomUUID(),
-    val name: String,
-    val roles: List<String> = listOf(),
-)
-
-// Select one entity
-val result: Inventor = connection.execute(
-    """
-    SELECT json_build_object(
-        'id', '9e65de49-712e-47ce-8bf2-dfffae53a82e', 
-        'name', :name
-    )
-    """,
-    mapOf("name" to "Nikola Tesla")
-)
-
-// Select multiple entities
-val result = connection.execute<List<Inventor>>(
-    """
-    SELECT json_build_array(
-        json_build_object(
-           'id', '9e65de49-712e-47ce-8bf2-dfffae53a82e',
-           'name', :name
-        ),
-        json_build_object(
-           'id', '32f67ed3-af6d-403b-a3b9-5fe3540c3412',
-           'name', :name2
-        )
-    )
-    """,
-    mapOf(
-        "name" to "Nikola Tesla",
-        "name2" to "Albert Einstein",
-    )
-)
-
-// Select multiple with real query
-val result: List<Inventor> = connection.execute(
-    """
-        select json_agg(i)
-        from inventor i
-        where roles @> ARRAY[:role];
-    """,
-    mapOf("role" to "ADMIN")
-)
-
-
-// Select multiple with only some rows
-val result: List<Inventor> = connection.execute(
-    """
-        select json_agg(i)
-        from (
-             select id, name
-             from inventor
-        ) i;
-    """
-)
-```
-
-
-See [ConnectionTest.kt](/src/test/kotlin/fr/postgresjson/ConnectionTest.kt) for more examples.

docs/usage/stored-procedure.md

@@ -1,80 +0,0 @@
-# Stored Procedure
-*Execute stored procedure with requester*
-
-You can execute a stored procedure (previously defined in a migration) via the Requester
-
-To do that:
-
-1. First, instantiate the requester
-```kotlin
-import fr.postgresjson.connexion.Requester
-import fr.postgresjson.connexion.Connection
-
-val connection: Connection = TODO()
-
-val requester = Requester(
-    connection = connection,
-    functionsDirectory = this::class.java.getResource("/sql/functions")?.toURI() ?: error("No sql function found")
-).createRequester()
-```
-
-2. then, define Entities
-```kotlin
-import java.util.UUID
-import org.joda.time.DateTime
-
-enum class Roles { ROLE_USER, ROLE_ADMIN }
-
-class User(
-    id: UUID = UUID.randomUUID(),
-    override var username: String,
-    var blockedAt: DateTime? = null,
-    var roles: List<Roles> = emptyList()
-)
-
-@SqlSerializable
-class UserForCreate(
-    id: UUID = UUID.randomUUID(),
-    username: String,
-    val password: String,
-    blockedAt: DateTime? = null,
-    roles: List<Roles> = emptyList()
-)
-```
-3. and, define Repositories
-[See SQL function](../migrations/migrations.md)
-
-```kotlin
-import fr.postgresjson.connexion.Requester
-import fr.postgresjson.repository.RepositoryI
-import java.util.UUID
-
-class UserRepository(override var requester: Requester): RepositoryI {
-    fun findById(id: UUID): User {
-        return requester
-            .getFunction("find_user_by_id") // Use the name of the function
-            .execute("id" to id) // You can pass parameters by their names. The underscore prefix on parameters is not required to be mapped. 
-            // Throw exception if user not found
-    }
-
-    fun insert(user: UserForCreate): User {
-        return requester
-            .getFunction("insert_user")
-            .execute("resource" to user)
-    }
-}
-```
-
-4. And at last, execute queries
-```kotlin
-import fr.postgresjson.connexion.Requester
-import java.util.UUID
-
-val requester: Requester = TODO()
-val userRepo = UserRepository(requester)
-
-val user: User = userRepo.findById(UUID.fromString(id))
-
-val newUser: UserForCreate = TODO()
-val userInserted: User = userRepo.insert(newUser)
-```

docs/usage/usage.md

@@ -1,6 +0,0 @@
-## Usage
-
-1. [Init connection](./init-connection.md)
-2. [Raw request](./raw-request.md)
-3. [Stored Procedure](./stored-procedure.md)
-4. [Multi level request](./multi-level.md)

gradle.properties

@@ -1,11 +1,2 @@
 kotlin.code.style=official
-systemProp.sonar.host.url=https://sonarcloud.io
-systemProp.sonar.projectKey=postgres-json
-systemProp.sonar.projectName=PostgresJson
-systemProp.sonar.organization=flecomte
-systemProp.sonar.java.coveragePlugin=jacoco
-systemProp.sonar.coverage.jacoco.xmlReportPaths=build/reports/jacoco/test/jacocoTestReport.xml
-org.gradle.jvmargs=-Xmx4096M
-containerAlwaysOn=false
-disableLint=false
-projectName=postgres-json
+kotlin_version=1.3.31

gradle/wrapper/gradle-wrapper.properties

@@ -1,4 +1,4 @@
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.6.2-all.zip
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStorePath=wrapper/dists

src/.editorconfig

@@ -1,9 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-indent_size = 4
-indent_style = space
-insert_final_newline = true
-tab_width = 4

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

@@ -1,18 +1,22 @@
 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.ResultSet
 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 kotlin.jvm.Throws
-import kotlin.random.Random
-import kotlin.reflect.full.hasAnnotation
+import java.util.concurrent.*
+
+typealias SelectOneCallback<T> = QueryResult.(T?) -> Unit
+typealias SelectCallback<T> = QueryResult.(List<T>) -> Unit
+typealias SelectPaginatedCallback<T> = QueryResult.(Paginated<T>) -> Unit
 
 class Connection(
     private val database: String,
@@ -20,80 +24,161 @@ class Connection(
     private val password: String,
     private val host: String = "localhost",
     private val port: Int = 5432
-) : ExecutableRaw {
-    private var connectionPool: ConnectionPool<PostgreSQLConnection>? = null
+) : Executable {
+    private lateinit var connection: ConnectionPool<PostgreSQLConnection>
     private val serializer = Serializer()
     private val logger: Logger? by LoggerDelegate()
 
     internal fun connect(): ConnectionPool<PostgreSQLConnection> {
-        return connectionPool.let { connectionPool ->
-            if (connectionPool == null || !connectionPool.isConnected()) {
-                PostgreSQLConnectionBuilder.createConnectionPool(
-                    "jdbc:postgresql://$host:$port/$database?user=$username&password=$password"
-                ).also {
-                    this.connectionPool = it
-                }
-            } else {
-                connectionPool
-            }
+        if (!::connection.isInitialized || !connection.isConnected()) {
+            connection = PostgreSQLConnectionBuilder.createConnectionPool(
+                "jdbc:postgresql://$host:$port/$database?user=$username&password=$password"
+            )
         }
+        return connection
     }
 
-    fun disconnect() {
-        connectionPool?.disconnect()
-    }
+    fun <A> inTransaction(f: (Connection) -> CompletableFuture<A>) = connect().inTransaction(f)
 
-    fun <A> inTransaction(block: Connection.() -> A?): A? = connect().run {
-        sendQuery("BEGIN")
-        try {
-            block().apply { sendQuery("COMMIT") }
-        } catch (e: Throwable) {
-            sendQuery("ROLLBACK")
-            throw e
-        }
-    }
-
-    /**
-     * Select with unnamed parameters
-     */
-    @Throws(DataNotFoundException::class)
-    override fun <R : Any> execute(
+    override fun <R : EntityI> select(
         sql: String,
         typeReference: TypeReference<R>,
         values: List<Any?>,
-        block: SelectCallback<R>
+        block: (QueryResult, R?) -> Unit
     ): R? {
-        val result: QueryResult = exec(sql, compileArgs(values))
-        if (result.rows.size == 0) throw DataNotFoundException(sql)
-
-        val json: String? = result.rows.firstOrNull()?.getString(0)
+        val primaryObject = values.firstOrNull {
+            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)
         return if (json === null) {
             null
         } else {
-            serializer.deserialize(json, typeReference)
+            if (primaryObject != null) {
+                serializer.deserialize(json, primaryObject)
+            } else {
+                serializer.deserialize(json, typeReference)
+            }
         }.also {
             block(result, it)
         }
     }
 
-    /**
-     * Select with named parameters
-     */
-    override fun <R : Any> execute(
+    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(
         sql: String,
         typeReference: TypeReference<R>,
         values: Map<String, Any?>,
-        block: SelectCallback<R>
+        block: (QueryResult, R?) -> Unit
     ): R? {
         return replaceArgs(sql, values) {
-            execute(this.sql, typeReference, parameters, block)
+            select(this.sql, typeReference, this.parameters, block)
         }
     }
 
+    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(
+        sql: String,
+        typeReference: TypeReference<List<R>>,
+        values: List<Any?>,
+        block: (QueryResult, List<R>) -> Unit
+    ): List<R> {
+        val result = exec(sql, compileArgs(values))
+        val json = result.rows[0].getString(0)
+        return if (json === null) {
+            listOf<EntityI>() as List<R>
+        } else {
+            serializer.deserializeList(json, typeReference)
+        }.also {
+            block(result, it)
+        }
+    }
+
+    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(
+        sql: String,
+        page: Int,
+        limit: Int,
+        typeReference: TypeReference<List<R>>,
+        values: Map<String, Any?>,
+        block: (QueryResult, Paginated<R>) -> Unit
+    ): Paginated<R> {
+        val offset = (page - 1) * limit
+        val newValues = values
+            .plus("offset" to offset)
+            .plus("limit" to limit)
+
+        val line = replaceArgs(sql, newValues) {
+            exec(this.sql, this.parameters)
+        }
+
+        return line.run {
+            val json = rows[0].getString(0)
+            val entities = if (json === null) {
+                listOf<EntityI>() as List<R>
+            } else {
+                serializer.deserializeList(json, typeReference)
+            }
+            Paginated(
+                entities,
+                offset,
+                limit,
+                rows[0].getInt("total") ?: error("The query not return total")
+            )
+        }.also {
+            block(line, it)
+        }
+    }
+
+    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)
+
+    override fun <R : EntityI> select(
+        sql: String,
+        typeReference: TypeReference<List<R>>,
+        values: Map<String, Any?>,
+        block: (QueryResult, List<R>) -> Unit
+    ): List<R> {
+        return replaceArgs(sql, values) {
+            select(this.sql, typeReference, this.parameters, block)
+        }
+    }
+
+    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 {
         val compiledValues = compileArgs(values)
         return stopwatchQuery(sql, compiledValues) {
-            connect().sendPreparedStatement(replaceNamedArgByQuestionMark(sql), compiledValues).join()
+            connect().sendPreparedStatement(sql, compiledValues).join()
         }
     }
 
@@ -103,22 +188,16 @@ class Connection(
         }
     }
 
-    /**
-     * Warning: this method not use prepared statement
-     */
-    override fun sendQuery(sql: String, values: List<Any?>): QueryResult {
+    override fun sendQuery(sql: String, values: List<Any?>): Int {
         val compiledValues = compileArgs(values)
         return stopwatchQuery(sql, compiledValues) {
             replaceArgsIntoSql(sql, compiledValues) {
-                connect().sendQuery(it).join()
+                connect().sendQuery(it).join().rowsAffected.toInt()
             }
         }
     }
 
-    /**
-     * Warning: this method not use prepared statement
-     */
-    override fun sendQuery(sql: String, values: Map<String, Any?>): QueryResult {
+    override fun sendQuery(sql: String, values: Map<String, Any?>): Int {
         return replaceArgs(sql, values) {
             sendQuery(this.sql, this.parameters)
         }
@@ -126,75 +205,45 @@ class Connection(
 
     private fun compileArgs(values: List<Any?>): List<Any?> {
         return values.map {
-            when {
-                it == null -> it
-                it is List<*> && it.isEmpty() -> it
-                it is List<*> && it.first()!!::class.hasAnnotation<SqlSerializable>() -> serializer.serialize(it)
-                it::class.hasAnnotation<SqlSerializable>() -> serializer.serialize(it)
-                else -> it
+            if (it is Serializable || (it is List<*> && it.firstOrNull() is Serializable)) {
+                serializer.serialize(it)
+            } else {
+                it
             }
         }
     }
 
     private fun <T> replaceArgs(sql: String, values: Map<String, Any?>, block: ParametersQuery.() -> T): T {
-        val paramRegex = "(?<!:):([a-z0-9_-]+)".toRegex(RegexOption.IGNORE_CASE)
-        val orderedArgs = paramRegex.findAll(sql).map { match ->
+        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('_')] ?: queryError("""Parameter "$name" missing""", sql, values)
+            values[name] ?: values[name.trimStart('_')] ?: error("Parameter $name missing")
         }.toList()
 
-        return block(ParametersQuery(replaceNamedArgByQuestionMark(sql), orderedArgs))
-    }
+        var newSql = sql
+        values.forEach { (key, _) ->
+            val regex = ":_?$key".toRegex()
+            newSql = newSql.replace(regex, "?")
+        }
 
-    private fun replaceNamedArgByQuestionMark(sql: String): String =
-        "(?<!:):([a-z0-9_-]+)"
-            .toRegex(RegexOption.IGNORE_CASE)
-            .replace(sql, "?")
-
-    private fun insertArgsValuesIntoSql(sql: String, values: List<Any?>): String {
-        var i = 0
-
-        /* The regular expression matches a question mark "?" alone, not preceded or followed by another question mark */
-        return """(?<!\?)(\?)(?!\?)"""
-            .toRegex(RegexOption.IGNORE_CASE)
-            .replace(sql) {
-                values.getOrNull(i)
-                    ?.toString()
-                    ?.also { ++i }
-                    ?.let(this::escapeParameter)
-                    ?: queryError("Parameter $i missing", sql, values)
-            }
+        return block(ParametersQuery(newSql, newArgs))
     }
 
     private fun <T> replaceArgsIntoSql(sql: String, values: List<Any?>, block: (String) -> T): T {
-        return if (values.isNotEmpty()) {
-            sql
-                .let(this::replaceNamedArgByQuestionMark)
-                .let { insertArgsValuesIntoSql(it, values) }
-                .let(block)
-        } else block(sql)
-    }
+        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'"
+            }
 
-    /**
-     * Escape parameter by generate a random tag to prevent SQL injection
-     */
-    private fun escapeParameter(parameter: String): String {
-        val escapeTag = escapeTag().let {
-            if (parameter.indexOf(it) >= 0) escapeParameter(parameter) else it
+            return block(newSql)
         }
-        return """$escapeTag$parameter$escapeTag"""
-    }
 
-    /**
-     * Generate a random alphaNum tag of 8 characters
-     */
-    private fun escapeTag(): String {
-        val charPool: List<Char> = ('a'..'z') + ('A'..'Z')
-        val tagName = (1..8)
-            .map { _ -> Random.nextInt(0, charPool.size) }
-            .map(charPool::get)
-            .joinToString("")
-        return "\$$tagName\$"
+        return block(sql)
     }
 
     data class ParametersQuery(val sql: String, val parameters: List<Any?>)
@@ -222,52 +271,12 @@ class Connection(
             logger?.debug("Query executed in $duration ms \n{}", args)
             return result
         } catch (e: Throwable) {
-            logger?.info(
-                """
-                |Query Error: 
-                |$sql, 
-                |Arguments (${values.length}):
-                |${values.joinToString(", ").ifBlank { "No arguments" }.prependIndent()}
-                """.trimMargin().prependIndent(" > "),
-                e
-            )
+            logger?.info("""
+                Query Error: 
+                ${sql.prependIndent()}, 
+                ${values.joinToString(", ").prependIndent()}
+            """.trimIndent(), e)
             throw e
         }
     }
-
-    class QueryError(msg: String) : Exception(msg)
-
-    private fun queryError(
-        msg: String,
-        sql: String,
-        parameters: List<Any?>,
-        result: ResultSet? = null
-    ): Nothing = throw QueryError(
-        """
-        |$msg
-        |
-        |${parameters.joinToString(", ") { it.toString() }.prependIndent("  > ")}
-        |${sql.prependIndent("  > ")}
-        |${result?.let { "-----" }?.prependIndent("  > ") ?: ""}
-        |${result?.columnNames()?.joinToString(" | ")?.prependIndent("  > ") ?: ""}
-        |${result?.map { it.joinToString(" | ") }?.joinToString("\n")?.prependIndent("  > ") ?: ""}
-        """.trimMargin().trim(' ', '\n')
-    )
-
-    private fun queryError(
-        msg: String,
-        sql: String,
-        parameters: Map<String, Any?>,
-        result: ResultSet? = null
-    ): Nothing = throw QueryError(
-        """
-        |$msg
-        |
-        |${parameters.map { ":" + it.key + " = " + it.value }.joinToString(", ").prependIndent("  > ")}
-        |${sql.prependIndent("  > ")}
-        |${result?.let { "-----" }?.prependIndent("  > ") ?: ""}
-        |${result?.columnNames()?.joinToString(" | ")?.prependIndent("  > ") ?: ""}
-        |${result?.map { it.joinToString(" | ") }?.joinToString("\n")?.prependIndent("  > ") ?: ""}
-        """.trimMargin().trim(' ', '\n')
-    )
 }

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

@@ -1,6 +0,0 @@
-package fr.postgresjson.connexion
-
-class DataNotFoundException(val queryExecuted: String) : Exception() {
-    override val message: String
-        get() = "No data return for the query"
-}

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

@@ -2,45 +2,61 @@ package fr.postgresjson.connexion
 
 import com.fasterxml.jackson.core.type.TypeReference
 import com.github.jasync.sql.db.QueryResult
-import kotlin.jvm.Throws
+import fr.postgresjson.entity.EntityI
 
-sealed interface EmbedExecutable : Executable {
+interface EmbedExecutable {
     val connection: Connection
     override fun toString(): String
     val name: String
 
+    /* Select One */
     /**
-     * Select with unnamed parameters
+     * Select One entity with list of parameters
      */
-    @Throws(DataNotFoundException::class)
-    fun <R : Any> execute(
+    fun <R : EntityI> select(
         typeReference: TypeReference<R>,
-        values: List<Any?>,
-        block: SelectCallback<R> = {}
+        values: List<Any?> = emptyList(),
+        block: SelectOneCallback<R> = {}
     ): R?
 
-    /**
-     * Select with named parameters
-     */
-    @Throws(DataNotFoundException::class)
-    fun <R : Any> execute(
+    fun <R : EntityI> select(
         typeReference: TypeReference<R>,
         values: Map<String, Any?>,
-        block: SelectCallback<R> = {}
+        block: SelectOneCallback<R> = {}
     ): R?
 
-    /**
-     * Select with named parameters
-     */
-    @Throws(DataNotFoundException::class)
-    fun <R : Any> execute(
-        typeReference: TypeReference<R>,
-        vararg values: Pair<String, Any?>,
+    /* Select Miltiples */
+    fun <R : EntityI> select(
+        typeReference: TypeReference<List<R>>,
+        values: List<Any?> = emptyList(),
         block: SelectCallback<R> = {}
-    ): R? =
-        execute(typeReference, values.toMap(), block)
+    ): List<R>
 
-    fun exec(values: List<Any?>): QueryResult
+    fun <R : EntityI> select(
+        typeReference: TypeReference<List<R>>,
+        values: Map<String, Any?>,
+        block: SelectCallback<R> = {}
+    ): List<R>
+
+    /* Select Paginated */
+    fun <R : EntityI> select(
+        page: Int,
+        limit: Int,
+        typeReference: TypeReference<List<R>>,
+        values: Map<String, Any?>,
+        block: SelectPaginatedCallback<R> = {}
+    ): Paginated<R>
+
+    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/EmbedExecutableReified.kt

@@ -1,25 +0,0 @@
-package fr.postgresjson.connexion
-
-import com.fasterxml.jackson.core.type.TypeReference
-import kotlin.jvm.Throws
-
-@Throws(DataNotFoundException::class)
-inline fun <reified R : Any> EmbedExecutable.execute(
-    values: List<Any?>,
-    noinline block: SelectCallback<R> = {}
-): R? =
-    execute(object : TypeReference<R>() {}, values, block)
-
-@Throws(DataNotFoundException::class)
-inline fun <reified R : Any> EmbedExecutable.execute(
-    values: Map<String, Any?>,
-    noinline block: SelectCallback<R> = {}
-): R? =
-    execute(object : TypeReference<R>() {}, values, block)
-
-@Throws(DataNotFoundException::class)
-inline fun <reified R : Any> EmbedExecutable.execute(
-    vararg values: Pair<String, Any?>,
-    noinline block: SelectCallback<R> = {}
-): R? =
-    execute(object : TypeReference<R>() {}, values = values, block)

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

@@ -1,3 +1,55 @@
 package fr.postgresjson.connexion
 
-sealed interface Executable
+import com.fasterxml.jackson.core.type.TypeReference
+import com.github.jasync.sql.db.QueryResult
+import fr.postgresjson.entity.EntityI
+
+interface Executable {
+    /* Select One */
+
+    fun <R : EntityI> select(
+        sql: String,
+        typeReference: TypeReference<R>,
+        values: List<Any?> = emptyList(),
+        block: SelectOneCallback<R> = {}
+    ): R?
+
+    fun <R : EntityI> select(
+        sql: String,
+        typeReference: TypeReference<R>,
+        values: Map<String, Any?>,
+        block: SelectOneCallback<R> = {}
+    ): R?
+
+    /* Select Miltiples */
+
+    fun <R : EntityI> select(
+        sql: String,
+        typeReference: TypeReference<List<R>>,
+        values: List<Any?> = emptyList(),
+        block: SelectCallback<R> = {}
+    ): List<R>
+
+    fun <R : EntityI> select(
+        sql: String,
+        typeReference: TypeReference<List<R>>,
+        values: Map<String, Any?>,
+        block: SelectCallback<R> = {}
+    ): List<R>
+
+    /* Select Paginated */
+
+    fun <R : EntityI> select(
+        sql: String,
+        page: Int,
+        limit: Int,
+        typeReference: TypeReference<List<R>>,
+        values: Map<String, Any?>,
+        block: SelectPaginatedCallback<R> = {}
+    ): Paginated<R>
+
+    fun exec(sql: String, values: List<Any?> = emptyList()): QueryResult
+    fun exec(sql: String, values: Map<String, Any?>): 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/ExecutableRaw.kt

@@ -1,64 +0,0 @@
-package fr.postgresjson.connexion
-
-import com.fasterxml.jackson.core.type.TypeReference
-import com.github.jasync.sql.db.QueryResult
-import kotlin.jvm.Throws
-
-typealias SelectCallback<R> = QueryResult.(R?) -> Unit
-
-sealed interface ExecutableRaw : Executable {
-    /**
-     * Select with [List] of parameters
-     */
-    @Throws(DataNotFoundException::class)
-    fun <R : Any> execute(
-        sql: String,
-        typeReference: TypeReference<R>,
-        values: List<Any?> = emptyList(),
-        block: SelectCallback<R> = {}
-    ): R?
-
-    /**
-     * Select with [Map] of parameters
-     */
-    @Throws(DataNotFoundException::class)
-    fun <R : Any> execute(
-        sql: String,
-        typeReference: TypeReference<R>,
-        values: Map<String, Any?>,
-        block: SelectCallback<R> = {}
-    ): R?
-
-    /**
-     * Select with multiple [Pair] of parameters
-     */
-    @Throws(DataNotFoundException::class)
-    fun <R : Any> execute(
-        sql: String,
-        typeReference: TypeReference<R>,
-        vararg values: Pair<String, Any?>,
-        block: SelectCallback<R> = {}
-    ): R? = execute(sql, typeReference, values.toMap(), block)
-
-    fun <R : Any?> exec(sql: String, value: R): QueryResult = exec(sql, listOf(value))
-    fun exec(sql: String, values: List<Any?>): QueryResult
-    fun exec(sql: String, values: Map<String, Any?>): QueryResult
-    fun exec(sql: String, vararg values: Pair<String, Any?>): QueryResult = exec(sql, values.toMap())
-
-    /**
-     * Warning: this method not use prepared statement
-     */
-    fun <R : Any?> sendQuery(sql: String, value: R): QueryResult = sendQuery(sql, listOf(value))
-    /**
-     * Warning: this method not use prepared statement
-     */
-    fun sendQuery(sql: String, values: List<Any?>): QueryResult
-    /**
-     * Warning: this method not use prepared statement
-     */
-    fun sendQuery(sql: String, values: Map<String, Any?>): QueryResult
-    /**
-     * Warning: this method not use prepared statement
-     */
-    fun sendQuery(sql: String, vararg values: Pair<String, Any?>): QueryResult = sendQuery(sql, values.toMap())
-}

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

@@ -1,37 +0,0 @@
-package fr.postgresjson.connexion
-
-import com.fasterxml.jackson.core.type.TypeReference
-import kotlin.jvm.Throws
-
-/**
- * Select with unnamed parameters
- */
-@Throws(DataNotFoundException::class)
-inline fun <reified R : Any> ExecutableRaw.execute(
-    sql: String,
-    values: List<Any?> = emptyList(),
-    noinline block: SelectCallback<R> = {}
-): R? =
-    execute(sql, object : TypeReference<R>() {}, values, block)
-
-/**
- * Select with named parameters
- */
-@Throws(DataNotFoundException::class)
-inline fun <reified R : Any> ExecutableRaw.execute(
-    sql: String,
-    values: Map<String, Any?>,
-    noinline block: SelectCallback<R> = {}
-): R? =
-    execute(sql, object : TypeReference<R>() {}, values, block)
-
-/**
- * Select with named parameters
- */
-@Throws(DataNotFoundException::class)
-inline fun <reified R : Any> ExecutableRaw.execute(
-    sql: String,
-    vararg values: Pair<String, Any?>,
-    noinline block: SelectCallback<R> = {}
-): R? =
-    execute(sql, object : TypeReference<R>() {}, values = values, block)

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

@@ -3,6 +3,7 @@ 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
 
 class Function(val definition: Function, override val connection: Connection) : EmbedExecutable {
     override fun toString(): String {
@@ -11,42 +12,174 @@ class Function(val definition: Function, override val connection: Connection) :
 
     override val name: String = definition.name
 
+    /* Select One */
+
     /**
-     * Select with [List] of parameters
+     * Select One entity with list of parameters
      */
-    override fun <R : Any> execute(
+    override fun <R : EntityI> select(
         typeReference: TypeReference<R>,
         values: List<Any?>,
-        block: SelectCallback<R>
+        block: (QueryResult, R?) -> Unit
+    ): R? {
+        val args = compileArgs(values)
+        val sql = "SELECT * FROM ${definition.name} ($args)"
+
+        return connection.select(sql, typeReference, values, block)
+    }
+
+    inline fun <reified R : EntityI> selectOne(
+        values: List<Any?> = emptyList(),
+        noinline block: SelectOneCallback<R> = {}
     ): R? =
-        connection.execute(compileSql(values), typeReference, values, block)
+        select(object : TypeReference<R>() {}, values, block)
+
+    inline fun <reified R : EntityI> selectOne(
+        value: R,
+        noinline block: SelectOneCallback<R> = {}
+    ): R? =
+        select(object : TypeReference<R>() {}, listOf(value), block)
 
     /**
-     * Select with named parameters
+     * Select One entity with named parameters
      */
-    override fun <R : Any> execute(
+    override fun <R : EntityI> select(
         typeReference: TypeReference<R>,
         values: Map<String, Any?>,
-        block: SelectCallback<R>
+        block: (QueryResult, R?) -> Unit
+    ): R? {
+        val args = compileArgs(values)
+        val sql = "SELECT * FROM ${definition.name} ($args)"
+
+        return connection.select(sql, typeReference, values, block)
+    }
+
+    inline fun <reified R : EntityI> selectOne(
+        values: Map<String, Any?>,
+        noinline block: SelectOneCallback<R> = {}
     ): R? =
-        connection.execute(compileSql(values), typeReference, values, block)
+        select(object : TypeReference<R>() {}, values, block)
+
+    inline fun <reified R : EntityI> selectOne(
+        vararg values: Pair<String, Any?>,
+        noinline block: SelectOneCallback<R> = {}
+    ): R? =
+        selectOne(values.toMap(), block)
+
+    /* Select Multiples */
 
     /**
-     * Execute function without treatments
+     * Select list of entities with list of parameters
      */
-    override fun exec(values: List<Any?>): QueryResult = connection.exec(compileSql(values), values)
+    override fun <R : EntityI> select(
+        typeReference: TypeReference<List<R>>,
+        values: List<Any?>,
+        block: (QueryResult, List<R>) -> Unit
+    ): List<R> {
+        val args = compileArgs(values)
+        val sql = "SELECT * FROM ${definition.name} ($args)"
+
+        return connection.select(sql, typeReference, values, block)
+    }
+
+    inline fun <reified R : EntityI> select(
+        values: List<Any?> = emptyList(),
+        noinline block: SelectCallback<R> = {}
+    ): List<R> =
+        select(object : TypeReference<List<R>>() {}, values, block)
 
     /**
-     * Execute function without treatments
+     * Select list of entities with named parameters
      */
-    override fun exec(values: Map<String, Any?>): QueryResult = connection.exec(compileSql(values), values)
+    override fun <R : EntityI> select(
+        typeReference: TypeReference<List<R>>,
+        values: Map<String, Any?>,
+        block: (QueryResult, List<R>) -> Unit
+    ): List<R> {
+        val args = compileArgs(values)
+        val sql = "SELECT * FROM ${definition.name} ($args)"
 
-    private fun <A : Any?> compileParameters(value: A): String = compileParameters(listOf(value))
+        return connection.select(sql, typeReference, values, block)
+    }
+
+    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(
+        vararg values: Pair<String, Any?>,
+        noinline block: SelectCallback<R> = {}
+    ): List<R> =
+        select(values.toMap(), block)
+
+    /* Select Paginated */
 
     /**
-     * Add cast to all parameters
+     * Select Multiple with pagination
      */
-    private fun compileParameters(values: List<Any?>): String {
+    override fun <R : EntityI> select(
+        page: Int,
+        limit: Int,
+        typeReference: TypeReference<List<R>>,
+        values: Map<String, Any?>,
+        block: (QueryResult, Paginated<R>) -> Unit
+    ): Paginated<R> {
+        val offset = (page - 1) * limit
+        val newValues = values
+            .plus("offset" to offset)
+            .plus("limit" to limit)
+
+        val args = compileArgs(newValues)
+        val sql = "SELECT * FROM ${definition.name} ($args)"
+
+        return connection.select(sql, page, limit, typeReference, values, block)
+    }
+
+    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)
+
+    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)
+
+    /* Execute function without traitements */
+
+    override fun exec(values: List<Any?>): QueryResult {
+        val args = compileArgs(values)
+        val sql = "SELECT * FROM ${definition.name} ($args)"
+
+        return connection.exec(sql, values)
+    }
+
+    override fun exec(values: Map<String, Any?>): QueryResult {
+        val args = compileArgs(values)
+        val sql = "SELECT * FROM ${definition.name} ($args)"
+
+        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, value ->
                 definition.parameters[index].default === null || value != null
@@ -58,10 +191,7 @@ class Function(val definition: Function, override val connection: Connection) :
         return placeholders.joinToString(separator = ", ")
     }
 
-    /**
-     * Cast and add named parameters
-     */
-    private fun compileParameters(values: Map<String, Any?>): String {
+    private fun compileArgs(values: Map<String, Any?>): String {
         val parameters = definition.getParametersIndexedByName()
         val placeholders = values
             .filter { entry ->
@@ -75,17 +205,4 @@ class Function(val definition: Function, override val connection: Connection) :
 
         return placeholders.joinToString(separator = ", ")
     }
-
-    /**
-     * Create SQL to call the function
-     */
-    private fun <A : Any?> compileSql(value: A): String = "SELECT * FROM ${definition.name} (${compileParameters(value)})"
-    /**
-     * Create SQL to call the function
-     */
-    private fun compileSql(values: List<Any?>): String = "SELECT * FROM ${definition.name} (${compileParameters(values)})"
-    /**
-     * Create SQL to call the function
-     */
-    private fun compileSql(values: Map<String, Any?>): String = "SELECT * FROM ${definition.name} (${compileParameters(values)})"
-}
+}

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

@@ -1,16 +0,0 @@
-package fr.postgresjson.connexion
-
-import fr.postgresjson.utils.searchSqlFiles
-import java.net.URI
-import fr.postgresjson.definition.Function as DefinitionFunction
-
-fun DefinitionFunction.toRunnable(connection: Connection): Function = Function(this, connection)
-
-fun Sequence<DefinitionFunction>.toRunnable(connection: Connection): Sequence<Function> = map { it.toRunnable(connection) }
-
-fun Sequence<Function>.toMutableMap(): MutableMap<String, Function> = map { it.name to it }.toMap().toMutableMap()
-
-internal fun URI.toFunction(connection: Connection): MutableMap<String, Function> = searchSqlFiles()
-    .filterIsInstance(DefinitionFunction::class.java)
-    .toRunnable(connection)
-    .toMutableMap()

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

@@ -0,0 +1,25 @@
+package fr.postgresjson.connexion
+
+import fr.postgresjson.entity.EntityI
+import kotlin.math.ceil
+
+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.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

@@ -2,54 +2,108 @@ package fr.postgresjson.connexion
 
 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 {
     override fun toString(): String {
         return sql
     }
 
-    /**
-     * Select with unnamed of parameters
-     */
-    override fun <R : Any> execute(
+    /* Select One */
+
+    override fun <R : EntityI> select(
         typeReference: TypeReference<R>,
         values: List<Any?>,
-        block: SelectCallback<R>
-    ): R? =
-        connection.execute(sql, typeReference, values, block)
+        block: (QueryResult, R?) -> Unit
+    ): R? {
+        return connection.select(this.toString(), typeReference, values, block)
+    }
 
-    /**
-     * Select with named parameters
-     */
-    override fun <R : Any> execute(
+    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(
         typeReference: TypeReference<R>,
         values: Map<String, Any?>,
-        block: SelectCallback<R>
+        block: (QueryResult, R?) -> Unit
+    ): R? {
+        return connection.select(this.toString(), typeReference, values, block)
+    }
+
+    inline fun <reified R : EntityI> selectOne(
+        values: Map<String, Any?>,
+        noinline block: SelectOneCallback<R> = {}
     ): R? =
-        connection.execute(sql, typeReference, values, block)
+        select(object : TypeReference<R>() {}, values, block)
 
-    /**
-     * Execute function without treatments
-     */
-    override fun exec(values: List<Any?>): QueryResult = connection.exec(sql, values)
+    /* Select Multiples */
 
-    /**
-     * Execute function without treatments
-     */
-    override fun exec(values: Map<String, Any?>): QueryResult = connection.exec(sql, values)
+    override fun <R : EntityI> select(
+        typeReference: TypeReference<List<R>>,
+        values: List<Any?>,
+        block: (QueryResult, List<R>) -> Unit
+    ): List<R> {
+        return connection.select(this.toString(), typeReference, values, block)
+    }
 
-    /**
-     * Warning: this method not use prepared statement
-     */
-    fun sendQuery(values: List<Any?>): QueryResult = connection.sendQuery(sql, values)
+    inline fun <reified R : EntityI> select(
+        values: List<Any?> = emptyList(),
+        noinline block: SelectCallback<R> = {}
+    ): List<R> =
+        select(object : TypeReference<List<R>>() {}, values, block)
 
-    /**
-     * Warning: this method not use prepared statement
-     */
-    fun sendQuery(values: Map<String, Any?>): QueryResult = connection.sendQuery(sql, values)
+    override fun <R : EntityI> select(
+        typeReference: TypeReference<List<R>>,
+        values: Map<String, Any?>,
+        block: (QueryResult, List<R>) -> Unit
+    ): List<R> {
+        return connection.select(this.toString(), typeReference, values, block)
+    }
 
-    /**
-     * Warning: this method not use prepared statement
-     */
-    fun sendQuery(vararg values: Pair<String, Any?>): QueryResult = sendQuery(values.toMap())
-}
+    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(
+        page: Int,
+        limit: Int,
+        typeReference: TypeReference<List<R>>,
+        values: Map<String, Any?>,
+        block: (QueryResult, Paginated<R>) -> Unit
+    ): Paginated<R> {
+        return connection.select(this.toString(), page, limit, typeReference, values, block)
+    }
+
+    /* Select Paginated */
+
+    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)
+
+    /* Execute function without traitements */
+
+    override fun exec(values: List<Any?>): QueryResult {
+        return connection.exec(sql, values)
+    }
+
+    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/QueryConverter.kt

@@ -1,28 +0,0 @@
-package fr.postgresjson.connexion
-
-import fr.postgresjson.utils.searchSqlFiles
-import java.net.URI
-import fr.postgresjson.definition.Query as QueryDefinition
-
-/**
- * Convert [QueryDefinition], to runnable [Query]
- */
-fun QueryDefinition.toRunnable(connection: Connection): Query = Query(name, script, connection)
-
-/**
- * Convert Sequence of [QueryDefinition], to runnable Sequence of [Query]
- */
-fun Sequence<QueryDefinition>.toRunnable(connection: Connection): Sequence<Query> = map { it.toRunnable(connection) }
-
-/**
- * Convert Sequence of [Query], to [Map] of [Query] with name as key
- */
-fun Sequence<Query>.toMutableMap(): MutableMap<String, Query> = map { it.name to it }.toMap().toMutableMap()
-
-/**
- * Create a [Map] of [Query] from a [URI] pointing to the queries folder
- */
-internal fun URI.toQuery(connection: Connection): MutableMap<String, Query> = searchSqlFiles()
-    .filterIsInstance(QueryDefinition::class.java)
-    .toRunnable(connection)
-    .toMutableMap()

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

@@ -1,9 +1,9 @@
 package fr.postgresjson.connexion
 
-import fr.postgresjson.definition.parse.parseFunction
 import fr.postgresjson.utils.searchSqlFiles
 import java.net.URI
 import fr.postgresjson.definition.Function as DefinitionFunction
+import fr.postgresjson.definition.Function as FunctionDefinition
 import fr.postgresjson.definition.Query as QueryDefinition
 
 class Requester(
@@ -11,59 +11,101 @@ class Requester(
     private val queries: MutableMap<String, Query> = mutableMapOf(),
     private val functions: MutableMap<String, Function> = mutableMapOf()
 ) {
-    constructor(connection: Connection) : this(connection, mutableMapOf(), mutableMapOf())
-
-    constructor(
-        connection: Connection,
-        queriesDirectory: URI? = null,
-        functionsDirectory: URI? = null
-    ) : this(
-        connection = connection,
-        queries = queriesDirectory?.toQuery(connection) ?: mutableMapOf(),
-        functions = functionsDirectory?.toFunction(connection) ?: mutableMapOf(),
-    )
-
-    fun addQuery(query: Query) {
+    fun addQuery(query: Query): Requester {
         queries[query.name] = query
+        return this
     }
 
-    fun addQuery(query: QueryDefinition) = addQuery(query.toRunnable(connection))
+    fun addQuery(query: QueryDefinition): Requester = addQuery(query.name, query.script)
 
-    fun addQuery(name: String, sql: String) {
+    fun addQuery(name: String, sql: String): Requester {
         addQuery(Query(name, sql, connection))
+        return this
     }
 
-    fun addQuery(queriesDirectory: URI) {
-        queriesDirectory
-            .searchSqlFiles()
-            .filterIsInstance(QueryDefinition::class.java)
-            .forEach(this::addQuery)
+    fun addQuery(queriesDirectory: URI): Requester {
+        queriesDirectory.searchSqlFiles()
+            .forEach {
+                if (it is QueryDefinition) {
+                    addQuery(it)
+                }
+            }
+        return this
     }
 
-    fun getQueries(): List<Query> = queries.map { it.value }
-
-    fun addFunction(definition: DefinitionFunction) {
-        definition
-            .run { toRunnable(connection) }
-            .run { functions[name] = this }
+    fun getQueries(): List<Query> {
+        return queries.map { it.value }
     }
 
-    fun addFunction(sql: String) {
-        parseFunction(sql)
-            .run { toRunnable(connection) }
-            .run { functions[name] = this }
+    fun addFunction(definition: DefinitionFunction): Requester {
+        functions[definition.name] = Function(definition, connection)
+        return this
     }
 
-    fun addFunctions(functionsDirectory: URI) {
+    fun addFunction(sql: String): Requester {
+        DefinitionFunction(sql).let {
+            functions[it.name] = Function(it, connection)
+        }
+        return this
+    }
+
+    fun addFunction(functionsDirectory: URI): Requester {
         functionsDirectory.searchSqlFiles()
-            .filterIsInstance(DefinitionFunction::class.java)
-            .forEach(this::addFunction)
+            .forEach {
+                if (it is FunctionDefinition) {
+                    addFunction(it)
+                }
+            }
+        return this
     }
 
-    fun getFunction(name: String): Function = functions[name] ?: throw NoFunctionDefined(name)
+    fun getFunction(name: String): Function {
+        if (functions[name] === null) {
+            throw Exception("No function defined for $name")
+        }
+        return functions[name]!!
+    }
 
-    fun getQuery(path: String): Query = queries[path] ?: throw NoQueryDefined(path)
+    fun getQuery(path: String): Query {
+        if (queries[path] === null) {
+            throw Exception("No query defined in $path")
+        }
+        return queries[path]!!
+    }
 
-    class NoFunctionDefined(name: String) : Exception("No function defined for $name")
-    class NoQueryDefined(path: String) : Exception("No query defined in $path")
+    class RequesterFactory(
+        private val connection: Connection,
+        private val queriesDirectory: URI? = null,
+        private val functionsDirectory: URI? = null
+    ) {
+        constructor(
+            host: String = "localhost",
+            port: Int = 5432,
+            database: String = "dc-project",
+            username: String = "dc-project",
+            password: String = "dc-project",
+            queriesDirectory: URI? = null,
+            functionsDirectory: URI? = null
+        ) : this(
+            Connection(host = host, port = port, database = database, username = username, password = password),
+            queriesDirectory,
+            functionsDirectory
+        )
+
+        fun createRequester(): Requester {
+            return initRequester(Requester(connection))
+        }
+
+        private fun initRequester(req: Requester): Requester {
+            if (queriesDirectory !== null) {
+                req.addQuery(queriesDirectory)
+            }
+
+            if (functionsDirectory !== null) {
+                req.addFunction(functionsDirectory)
+            }
+
+            return req
+        }
+    }
 }

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

@@ -1,4 +0,0 @@
-package fr.postgresjson.connexion
-
-@Target(AnnotationTarget.CLASS)
-annotation class SqlSerializable

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

@@ -1,26 +1,67 @@
 package fr.postgresjson.definition
 
-import fr.postgresjson.definition.Parameter.Direction.IN
+import java.io.File
 import java.nio.file.Path
 
 class Function(
-    override val name: String,
-    override val parameters: List<Parameter>,
-    val returns: Returns,
     override val script: String,
-    override val source: Path? = null,
+    override var source: Path? = null
 ) : Resource, ParametersInterface {
+    val returns: String
+    override val name: String
+    override val parameters: List<Parameter>
 
-    fun getDefinition(): String = parameters
-        .filter { it.direction == IN }
-        .joinToString(", ") { it.type.toString() }
-        .let { "$name ($it)" }
+    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]+)?"""
+                .toRegex(setOf(RegexOption.IGNORE_CASE, RegexOption.MULTILINE))
 
-    fun getParametersIndexedByName(): Map<String, Parameter> = parameters
-        .withIndex()
-        .associate { (key, param) -> Pair(param.name ?: "${key + 1}", param) }
+        val paramsRegex =
+            """\s*(?<param>((?<direction>IN|OUT|INOUT|VARIADIC)?\s+)?("?(?<name>[^\s,")]+)"?\s+)?(?<type>[^\s,)]+)(\s+(?<default>default\s|=)\s*[^\s,)]+)?)\s*(,|$)"""
+                .toRegex(setOf(RegexOption.IGNORE_CASE, RegexOption.MULTILINE))
 
-    operator fun get(name: String): Parameter? = parameters.firstOrNull { it.name == name }
+        val queryMatch = functionRegex.find(script)
+        if (queryMatch !== null) {
+            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() ?: ""
+
+            /* Create parameters definition */
+            val parameters = if (functionParameters !== null) {
+                val matchesParams = paramsRegex.findAll(functionParameters)
+                matchesParams.map { paramsMatch ->
+                    Parameter(
+                        paramsMatch.groups["name"]!!.value.trim(),
+                        paramsMatch.groups["type"]!!.value.trim(),
+                        paramsMatch.groups["direction"]?.value?.trim(),
+                        paramsMatch.groups["default"]?.value?.trim()
+                    )
+                }.toList()
+            } else {
+                listOf()
+            }
+            this.name = functionName
+            this.parameters = parameters
+        } else {
+            throw FunctionNotFound()
+        }
+    }
+
+    class FunctionNotFound(cause: Throwable? = null) : Resource.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)"
+            }
+    }
+
+    fun getParametersIndexedByName(): Map<String, Parameter> {
+        return parameters.map {
+            it.name to it
+        }.toMap()
+    }
 
     infix fun `has same definition`(other: Function): Boolean {
         return other.getDefinition() == this.getDefinition()
@@ -29,4 +70,21 @@ class Function(
     infix fun `is different from`(other: Function): Boolean {
         return other.script != this.script
     }
-}
+
+    companion object {
+        fun build(source: File): List<Function> {
+            return source.readText()
+                .split(
+                    "CREATE +(OR REPLACE +)?(PROCEDURE|FUNCTION)".toRegex(
+                        setOf(
+                            RegexOption.IGNORE_CASE,
+                            RegexOption.MULTILINE
+                        )
+                    )
+                )
+                .map {
+                    Function("CREATE OR REPLACE FUNCTION $it")
+                }
+        }
+    }
+}

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

@@ -4,12 +4,14 @@ import java.nio.file.Path
 
 class Migration(
     override val script: String,
-    override var source: Path
+    source: Path
 ) : Resource {
     override val name: String
     val direction: Direction
+    override var source: Path? = null
 
     init {
+        this.source = source
         this.direction = source.fileName.toString()
             .let {
                 when {
@@ -30,4 +32,4 @@ class Migration(
 
     class MigrationNotFound(cause: Throwable? = null) : Resource.ParseException("Migration not found in script", cause)
     enum class Direction { UP, DOWN }
-}
+}

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

@@ -1,66 +1,33 @@
 package fr.postgresjson.definition
 
-import java.util.Locale
+interface ParameterI {
+    val name: String
+    val type: String
+    val direction: Parameter.Direction
+    val default: String
+}
 
-class ParameterType(
-    val name: String,
-    val precision: Int? = null,
-    val scale: Int? = null,
-    val array: String? = null,
-) {
-    val isArray: Boolean
-        get() = array != null
+class Parameter(val name: String, val type: String, direction: Direction? = Direction.IN, val default: Any? = null) {
+    val direction: Direction
 
-    override fun toString(): String {
-        val type = if (precision == null && scale == null) {
-            name
-        } else if (scale == null) {
-            """$name($precision)"""
+    init {
+        if (direction === null) {
+            this.direction = Direction.IN
         } else {
-            """$name($precision, $scale)"""
+            this.direction = direction
         }
-
-        return type+array
     }
-}
 
-interface ParameterSimpleI {
-    val name: String?
-    val type: ParameterType
-}
-
-class Parameter(
-    override val name: String?,
-    override val type: ParameterType,
-    val direction: Direction = Direction.IN,
-    val default: String? = null,
-) : ParameterSimpleI {
-    constructor(name: String?, type: ParameterType, direction: String = "IN", default: String? = null) : this(
+    constructor(name: String, type: String, direction: String? = "IN", default: Any? = null) : this(
         name = name,
         type = type,
-        direction = direction.let { Direction.valueOf(direction.uppercase(Locale.getDefault())) },
+        direction = direction?.let { Direction.valueOf(direction.toUpperCase()) },
         default = default
     )
 
     enum class Direction { IN, OUT, INOUT }
-
-    override fun toString(): String {
-        return buildString {
-            append(direction.name.lowercase())
-            if (name?.isNotBlank() == true) {
-                append(" ")
-                append(name)
-            }
-            append(" ")
-            append(type.toString())
-            if (default?.isNotBlank() == true) {
-                append(" ")
-                append(default)
-            }
-        }
-    }
 }
 
 interface ParametersInterface {
     val parameters: List<Parameter>
-}
+}

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

@@ -4,8 +4,9 @@ import java.nio.file.Path
 
 class Query(
     override val script: String,
-    override var source: Path
+    source: Path
 ) : Resource {
+    override var source: Path? = source
     override val name: String = getNameFromComment(script) ?: getNameFromFile(source)
 
     /** Try to get name from comment in file */
@@ -13,12 +14,12 @@ class Query(
         """-- *name ?: ?(?<name>[^ \n]+)"""
             .toRegex(setOf(RegexOption.IGNORE_CASE, RegexOption.MULTILINE))
             .find(script)?.let {
-                it.groups["name"]?.value?.trim()
-            }
+            it.groups["name"]?.value?.trim()
+        }
 
     /** Try to get name from the filename */
     private fun getNameFromFile(source: Path): String = source
         .fileName.toString()
         .substringAfterLast("/")
         .substringBeforeLast(".sql")
-}
+}

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

@@ -1,14 +1,13 @@
 package fr.postgresjson.definition
 
-import fr.postgresjson.definition.parse.parseFunction
 import java.io.File
 import java.net.URL
 import java.nio.file.Path
 
-sealed interface Resource {
+interface Resource {
     val name: String
     val script: String
-    val source: Path?
+    var source: Path?
 
     open class ParseException(message: String, cause: Throwable? = null) : Exception(message, cause)
 
@@ -21,10 +20,10 @@ sealed interface Resource {
 
         fun build(resource: String, path: Path): Resource =
             try {
-                Migration(resource, path)
+                Function(resource, path)
             } catch (e: ParseException) {
                 try {
-                    parseFunction(resource, path)
+                    Migration(resource, path)
                 } catch (e: ParseException) {
                     try {
                         Query(resource, path)
@@ -35,3 +34,7 @@ sealed interface Resource {
             }
     }
 }
+
+interface ResourceCollection {
+    val parameters: List<Parameter>
+}

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

@@ -1,45 +0,0 @@
-package fr.postgresjson.definition
-
-sealed class Returns(
-    val definition: String,
-    val isSetOf: Boolean,
-) {
-    class Primitive(
-        definition: String,
-        isSetOf: Boolean,
-    ) : Returns(definition, isSetOf) {
-        val name = definition
-            .trim('"')
-    }
-
-    class PrimitiveList(
-        definition: String,
-        isSetOf: Boolean,
-    ) : Returns(definition, isSetOf) {
-        val name = definition
-            .drop(2)
-            .trim('"')
-    }
-
-    class Table(
-        definition: String,
-        isSetOf: Boolean,
-        val parameters: List<ParameterTable>,
-    ) : Returns(definition, isSetOf) {
-        class ParameterTable(
-            override val name: String,
-            override val type: ParameterType,
-        ) : ParameterSimpleI
-    }
-
-    class Any(
-        isSetOf: Boolean,
-    ) : Returns("any", isSetOf)
-
-    class Unknown(
-        definition: String,
-        isSetOf: Boolean,
-    ) : Returns(definition, isSetOf)
-
-    class Void : Returns("void", false)
-}

src/main/kotlin/fr/postgresjson/definition/parse/ParsingFunction.kt

@@ -1,217 +0,0 @@
-package fr.postgresjson.definition.parse
-
-import fr.postgresjson.definition.Function
-import fr.postgresjson.definition.Parameter
-import fr.postgresjson.definition.Parameter.Direction
-import fr.postgresjson.definition.Parameter.Direction.IN
-import fr.postgresjson.definition.Parameter.Direction.INOUT
-import fr.postgresjson.definition.Parameter.Direction.OUT
-import fr.postgresjson.definition.ParameterType
-import fr.postgresjson.definition.Resource.ParseException
-import fr.postgresjson.definition.Returns
-import fr.postgresjson.definition.Returns.Primitive
-import fr.postgresjson.definition.Returns.Unknown
-import fr.postgresjson.definition.Returns.Void
-import java.nio.file.Path
-import kotlin.text.RegexOption.IGNORE_CASE
-
-internal fun parseFunction(script: String, source: Path? = null): Function {
-    val name: String
-    val parameters: List<Parameter>
-    val returns: Returns
-    ScriptPart(script)
-        .getFunctionOrProcedure().trimSpace().nextScriptPart
-        .getFunctionName().apply { name = value }.nextScriptPart
-        .getParameters().apply { parameters = value }.nextScriptPart
-        .getReturns().apply { returns = value }
-
-    return Function(name, parameters, returns, script, source)
-}
-
-@Throws(FunctionNameMalformed::class)
-internal fun ScriptPart.getFunctionName(): NextScript<String> {
-    try {
-        return getNextScript { status.isNotEscaped() && afterBeginBy("(", " ", "\n") }
-            .changeValue(String::unescapeOrLowercase)
-    } catch (e: ParseException) {
-        throw FunctionNameMalformed(this, e)
-    }
-}
-
-internal class FunctionNameMalformed(val script: ScriptPart, cause: Throwable? = null) :
-    ParseException("Function name is malformed", cause)
-
-@Throws(FunctionNotFound::class)
-internal fun ScriptPart.getFunctionOrProcedure(): NextScript<String> {
-    val result = """create\s+(?:or\s+replace\s+)?(procedure|function)\s+"""
-        .toRegex()
-        .find(restOfScript)
-        ?: throw FunctionNotFound(this)
-
-    val rest = result.range.last
-        .let { cursor -> restOfScript.drop(cursor + 1) }
-
-    return NextScript(
-        result.groups[1]!!.value,
-        rest
-    )
-}
-
-internal class FunctionNotFound(val script: ScriptPart) :
-    ParseException("Function not found in script")
-
-internal fun ScriptPart.getParameters(): NextScript<List<Parameter>> {
-    val allParametersScript = this.getNextScript {
-        currentChar == ')' && status.isNotEscaped()
-    }
-    val parameterList: List<Parameter> = allParametersScript
-        .valueAsScriptPart()
-        .removeParentheses()
-        .split(",")
-        .map { it.toParameter() }
-
-    return NextScript(parameterList, allParametersScript.restOfScript)
-}
-
-private fun ScriptPart.toParameter(): Parameter {
-    var script: ScriptPart = this.trimSpace()
-    return Parameter(
-        direction = script.getParameterMode().apply { script = nextScriptPart }.value,
-        name = script.getParameterName().trimSpace().apply { script = nextScriptPart }.value.trim(),
-        type = script.getParameterType().trimSpace().apply { script = nextScriptPart }.value,
-        default = script.getParameterDefault().trimSpace().apply { script = nextScriptPart }.value,
-    )
-}
-
-private fun ScriptPart.getParameterMode(): NextScript<Direction> {
-    return when {
-        restOfScript.startsWith("inout ", true) -> NextScript(INOUT, restOfScript.drop("inout ".length))
-        restOfScript.startsWith("in ", true) -> NextScript(IN, restOfScript.drop("in ".length))
-        restOfScript.startsWith("out ", true) -> NextScript(OUT, restOfScript.drop("out ".length))
-        else -> NextScript(IN, restOfScript)
-    }
-}
-
-@Throws(ParameterNameMalformed::class)
-private fun ScriptPart.getParameterName(): NextScript<String> {
-    try {
-        return getNextScript { afterBeginBy(" ", "\n") && status.isNotEscaped() }
-            .changeValue(String::unescapeOrLowercase)
-    } catch (e: ParseException) {
-        throw ParameterNameMalformed(this, e)
-    }
-}
-
-private class ParameterNameMalformed(val script: ScriptPart, cause: Throwable) :
-    ParseException("Parameter name is malformed", cause)
-
-@Throws(ParameterTypeMalformed::class)
-private fun ScriptPart.getParameterType(): NextScript<ParameterType> {
-    val fullType = try {
-        val endTextList = arrayOf(" default ", "=")
-        getNextScript { afterBeginBy(texts = endTextList) }
-    } catch (e: ParseError) {
-        throw ParameterTypeMalformed(this, e)
-    }
-
-    var rest: ScriptPart = fullType.valueAsScriptPart()
-
-    val name = rest
-        .getNextScript { afterBeginBy("(", "[") }
-        .apply { rest = nextScriptPart }
-    rest = rest.trimStart(' ', '\n', '\t', ',', '(')
-    val precision = rest
-        .getNextInteger()
-        .apply { rest = nextScriptPart }
-    rest = rest.trimStart(' ', '\n', '\t', ',')
-    val scale = rest
-        .getNextInteger()
-        .apply { rest = nextScriptPart }
-    rest = rest.trimStart(' ', '\n', '\t', ')')
-
-    val arrayDef = rest.restOfScript.trim().takeIf(String::isNotBlank)
-
-    return NextScript(
-        ParameterType(
-            name = name.value.trim().trim('[', ']'),
-            precision = precision.value,
-            scale = scale.value,
-            array = arrayDef
-        ),
-        fullType.nextScriptPart.restOfScript
-    )
-}
-
-internal class ParameterTypeMalformed(val script: ScriptPart, cause: Throwable) :
-    ParseException("Parameter type is malformed", cause)
-
-@Throws(ParameterDefaultMalformed::class)
-private fun ScriptPart.getParameterDefault(): NextScript<String?> {
-    return if (this.isEmpty() || this.restOfScript == ")") {
-        NextScript(null, "")
-    } else {
-        """^(\s*=\s*|\s+default\s+)(.+)\s*$"""
-            .toRegex(IGNORE_CASE)
-            .find(restOfScript)
-            .let { it ?: throw ParameterDefaultMalformed(this) }
-            .let { it.groups[2]!!.value }
-            .let { NextScript(it.trim(), "") }
-    }
-}
-
-private class ParameterDefaultMalformed(val script: ScriptPart) :
-    ParseException("Parameter default is malformed")
-
-/**
- * TODO Finalize this
- */
-internal fun ScriptPart.getReturns(): NextScript<Returns> {
-    val rest = this.trimSpace()
-    if (!rest.restOfScript.startsWith("returns")) {
-        return NextScript(Void(), "")
-    }
-    var returns = ScriptPart(rest.restOfScript.drop("returns".length))
-        .getNextScript { this.afterBeginBy(Regex("\\s+language\\s+", IGNORE_CASE), Regex("\\s+as\\s+", IGNORE_CASE)) }
-        .trimSpace()
-        .value
-        .trimStart()
-
-    val isSetOf = returns.startsWith("SETOF", ignoreCase = true)
-
-    if (isSetOf) {
-        returns = returns.drop("SETOF".length).trimStart()
-    }
-
-    val returnsClass = if (returns.isBlank()) {
-        Void()
-    } else if (primitiveList.contains(ScriptPart(returns).getParameterType().value.name)) {
-        Primitive(returns, isSetOf)
-    } else {
-        Unknown(returns, isSetOf)
-    }
-
-    return NextScript(returnsClass, "")
-}
-
-private val primitiveList = listOf(
-    "text",
-    "varchar",
-    "character varying",
-    "character",
-    "char",
-    "int",
-    "smallint",
-    "integer",
-    "bigint",
-    "decimal",
-    "real",
-    "double precision",
-    "float",
-    "numeric",
-    "boolean",
-    "json",
-    "jsonb",
-)
-
-class ParseError(message: String? = null, cause: Throwable? = null) :
-    ParseException(message ?: "Parsing fail", cause)

src/main/kotlin/fr/postgresjson/definition/parse/ParsingHelper.kt

@@ -1,203 +0,0 @@
-package fr.postgresjson.definition.parse
-
-import kotlin.contracts.ExperimentalContracts
-import kotlin.contracts.InvocationKind.EXACTLY_ONCE
-import kotlin.contracts.contract
-
-@JvmInline
-internal value class ScriptPart(val restOfScript: String) {
-    fun copy(block: (String) -> String): ScriptPart {
-        return ScriptPart(block(restOfScript))
-    }
-
-    fun isEmpty() = restOfScript.isEmpty()
-}
-
-internal class NextScript<T>(val value: T, val restOfScript: String) {
-    val nextScriptPart: ScriptPart = ScriptPart(restOfScript)
-    fun isLast() = restOfScript == ""
-    fun isEmptyValue() = value == "" || value == null
-}
-
-internal fun ScriptPart.removeParentheses(): ScriptPart {
-    return if (restOfScript.take(1) == "(" && restOfScript.takeLast(1) == ")") {
-        this.copy {
-            it.drop(1).dropLast(1)
-        }
-    } else {
-        this
-    }
-}
-
-/**
- * Get next part of script.
- * You can define a list of characters that end the part of script. Like `(` or space.
- */
-@Throws(ParseError::class)
-internal fun ScriptPart.getNextScript(isEnd: Context.() -> Boolean = { false }): NextScript<String> {
-    val status = Status()
-
-    for ((index, c) in restOfScript.withIndex()) {
-        val prevChar = restOfScript.getOrNull(index - 1)
-        val nextChar = restOfScript.getOrNull(index + 1)
-        val nestedChars = listOf(prevChar, nextChar)
-
-        if (c == '"' && nestedChars.none { c == it }) {
-            status.doubleQuoted = !status.doubleQuoted
-        } else if (c == '\'' && nestedChars.none { c == it }) {
-            status.simpleQuoted = !status.simpleQuoted
-        }
-
-        if (status.isNotQuoted()) {
-            when (c) {
-                '(' -> status.parentheses++
-                ')' -> status.parentheses--
-                '[' -> status.brackets++
-                ']' -> status.brackets--
-                '{' -> status.braces++
-                '}' -> status.braces--
-            }
-        }
-
-        if (isEnd(Context(index, c, status.copy(), restOfScript))) {
-            return NextScript(
-                restOfScript.take(index + 1),
-                restOfScript.drop(index + 1),
-            )
-        }
-    }
-
-    if (status.isNotEscaped()) {
-        return NextScript(
-            restOfScript.trim(),
-            "",
-        )
-    }
-
-    throw ParseError()
-}
-
-internal fun ScriptPart.unescapeOrLowercase(): ScriptPart = restOfScript
-    .run(String::unescapeOrLowercase)
-    .let(::ScriptPart)
-
-internal fun String.unescapeOrLowercase(): String {
-    val first = take(1)
-    val last = takeLast(1)
-    return if (first == last && first == "'") {
-        drop(1).dropLast(1).replace("$first$first", first).lowercase()
-    } else if (first == last && first == "\"") {
-        drop(1).dropLast(1).replace("$first$first", first)
-    } else {
-        this.lowercase()
-    }
-}
-
-internal fun <T> NextScript<T>.trimSpace(): NextScript<T> {
-    val spaces = charArrayOf(' ', '\n', '\t')
-    return trim(chars = spaces)
-}
-
-internal fun ScriptPart.trimSpace(): ScriptPart {
-    for ((n, char) in restOfScript.withIndex()) {
-        if (char !in listOf(' ', '\n', '\t')) {
-            return ScriptPart(
-                restOfScript.drop(n)
-            )
-        }
-    }
-    return ScriptPart(restOfScript)
-}
-
-internal fun <T> NextScript<T>.trim(vararg chars: Char): NextScript<T> {
-    return NextScript(value, restOfScript.apply { dropWhile { it in chars } })
-}
-
-internal fun ScriptPart.trimStart(vararg chars: Char): ScriptPart {
-    return this.change { dropWhile { it in chars } }
-}
-
-internal fun ScriptPart.trimEnd(vararg chars: Char): ScriptPart {
-    return this.change { dropLastWhile { it in chars } }
-}
-
-internal fun ScriptPart.split(delimiter: String): List<ScriptPart> {
-    val parts: MutableList<ScriptPart> = mutableListOf()
-    var rest: ScriptPart = this
-    do {
-        rest = rest.trimSpace()
-            .getNextScript { status.isNotEscaped() && currentChar.toString() == delimiter }
-            .trimSpace()
-            .also { parts.add(it.valueAsScriptPart().trimSpace().trimEnd(',')) }
-            .nextScriptPart
-    } while (!rest.isEmpty())
-
-    return parts
-}
-
-/**
- * Return the value as ScriptPart
- */
-internal fun NextScript<String>.valueAsScriptPart(): ScriptPart = ScriptPart(value)
-
-@OptIn(ExperimentalContracts::class)
-internal inline fun ScriptPart.change(block: String.() -> String): ScriptPart {
-    contract {
-        callsInPlace(block, EXACTLY_ONCE)
-    }
-    return ScriptPart(restOfScript.run(block))
-}
-
-@OptIn(ExperimentalContracts::class)
-internal inline fun <T> NextScript<T>.changeValue(block: (T) -> T): NextScript<T> {
-    contract {
-        callsInPlace(block, EXACTLY_ONCE)
-    }
-    return NextScript(value.run(block), nextScriptPart.restOfScript)
-}
-
-internal fun <T> NextScript<T>.changeScript(block: (String) -> String): NextScript<T> {
-    return NextScript(value, block(restOfScript))
-}
-
-internal fun <T> NextScript<T>.dropOneOf(vararg endTextList: String): NextScript<T> {
-    return changeScript { script ->
-        endTextList
-            .filter { script.startsWith(it) }
-            .let { script.drop(it.size) }
-    }
-}
-
-internal fun ScriptPart.getNextInteger(): NextScript<Int?> {
-    val digits = restOfScript.takeWhile { it.isDigit() }
-    val restOfScript = restOfScript.trimStart { it.isDigit() }
-    return NextScript(digits.toIntOrNull(), restOfScript).trimSpace()
-}
-
-internal data class Status(
-    var doubleQuoted: Boolean = false, // "
-    var simpleQuoted: Boolean = false, // '
-    var parentheses: Int = 0, // ()
-    var brackets: Int = 0, // []
-    var braces: Int = 0, // {}
-) {
-    fun isQuoted(): Boolean = doubleQuoted || simpleQuoted
-    fun isNotQuoted(): Boolean = !isQuoted()
-    fun isNotEscaped(): Boolean = isNotQuoted() && parentheses == 0 && brackets == 0 && braces == 0
-}
-
-internal data class Context(
-    val index: Int,
-    val currentChar: Char,
-    val status: Status,
-    val script: String,
-) {
-    fun afterBeginBy(vararg texts: String): Boolean = texts.any {
-        script.drop(index + 1).take(it.length).lowercase() == it.lowercase()
-    }
-    fun afterBeginBy(vararg texts: Regex): Boolean = texts.any {
-        it.matchAt(script, index + 1) != null
-    }
-
-    val nextChar: Char? get() = script.substring(index + 1).getOrNull(0)
-}

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

@@ -0,0 +1,5 @@
+package fr.postgresjson.entity
+
+interface Serializable
+interface EntityI : Serializable
+interface Parameter : Serializable

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/functionGenerator/FunctionGenerator.kt

@@ -1,145 +0,0 @@
-package fr.postgresjson.functionGenerator
-
-import fr.postgresjson.definition.Function
-import fr.postgresjson.definition.Parameter
-import fr.postgresjson.definition.Parameter.Direction.IN
-import fr.postgresjson.definition.Parameter.Direction.INOUT
-import fr.postgresjson.definition.Parameter.Direction.OUT
-import fr.postgresjson.definition.Returns
-import fr.postgresjson.utils.searchSqlFiles
-import fr.postgresjson.utils.toCamelCase
-import org.slf4j.Logger
-import org.slf4j.LoggerFactory
-import java.io.File
-import java.net.URI
-
-class FunctionGenerator(private val functionsDirectories: List<URI>) {
-    constructor(functionsDirectories: URI) : this(listOf(functionsDirectories))
-
-    private val logger: Logger = LoggerFactory.getLogger("sqlFilesSearch")
-
-    private fun List<Parameter>.toKotlinArgs(): String {
-        return filter { it.direction == IN || it.direction == INOUT }
-            .mapIndexed { index, parameter -> index to parameter }
-            .joinToString(", ") { (idx, param) ->
-                val base = """${param.kotlinName ?: "arg$idx"}: ${param.kotlinType}"""
-                val default = if (param.default == null) {
-                    ""
-                } else {
-                    when (param.kotlinType) {
-                        "String" -> """ = "${param.default.trim('\'')}""""
-                        "Int" -> """ = ${param.default}"""
-                        "Boolean" -> """ = ${param.default.lowercase()}"""
-                        else -> ""
-                    }
-                }
-
-                base + default
-            }
-    }
-
-    private fun List<Parameter>.toMapOf(): String {
-        return filter { it.direction == IN || it.direction == INOUT }
-            .joinToString(", ", prefix = "mapOf(", postfix = ")") { """"${it.kotlinName}" to ${it.kotlinName}""" }
-    }
-
-    private val Parameter.kotlinType: String
-        get() {
-            return when (type.name.lowercase()) {
-                "text" -> "String"
-                "varchar" -> "String"
-                "character varying" -> "String"
-                "character" -> "String"
-                "char" -> "String"
-                "int" -> "Int"
-                "smallint" -> "Int"
-                "integer" -> "Int"
-                "bigint" -> "Int"
-                "decimal" -> "Float"
-                "real" -> "Float"
-                "double precision" -> "Float"
-                "float" -> "Float"
-                "numeric" -> "Number"
-                "boolean" -> "Boolean"
-                "json" -> "S"
-                "jsonb" -> "S"
-                "any" -> "Any"
-                "anyelement" -> "Any"
-                "anyarray" -> "List<*>"
-                else -> "String"
-            }
-        }
-
-    private val Parameter.kotlinName: String?
-        get() {
-            return name?.toCamelCase()?.trimStart('_')
-        }
-
-    private val Function.kotlinName: String
-        get() {
-            return name.toCamelCase().trimStart('_')
-        }
-
-    private val functions: List<Function>
-        get() = functionsDirectories
-            .flatMap { it.searchSqlFiles() }
-            .filterIsInstance<Function>()
-
-    fun generate(outputDirectory: URI) {
-        File(outputDirectory.path).apply {
-            logger.debug("Create Directory: $absolutePath")
-            mkdirs()
-        }
-
-        functions
-            .map { function ->
-                File("${outputDirectory.path}${function.kotlinName}.kt").apply {
-                    writeText(generate(function))
-                }
-            }
-    }
-
-    fun generate(functionName: String): String {
-        return functions
-            .first { it.name == functionName }
-            .let { generate(it) }
-    }
-
-    fun generate(function: Function): String = function.run {
-        val args = parameters.toKotlinArgs()
-
-        val hasInputArgs: Boolean = parameters.filter { it.direction != OUT }.any { it.kotlinType == "S" }
-        val hasReturn: Boolean = parameters.any { it.direction != IN } || (returns !is Returns.Void)
-
-        val generics = mutableListOf<String>()
-        if (hasReturn) generics.add("reified E: Any")
-        if (hasInputArgs) generics.add("S: Any?")
-
-        val functionDecl = if (generics.isNotEmpty()) "inline fun <${generics.joinToString(", ")}>" else "fun"
-
-        return if (hasReturn) {
-            """
-            |package fr.postgresjson.functionGenerator.generated
-            |
-            |import com.fasterxml.jackson.core.type.TypeReference
-            |import fr.postgresjson.connexion.Requester
-            |
-            |$functionDecl Requester.$kotlinName($args): E? {
-            |    return getFunction("$name")
-            |        .execute<E>(object : TypeReference<E>() {}, ${parameters.toMapOf()})
-            |}
-        """.trimMargin()
-        } else {
-            """
-            |package fr.postgresjson.functionGenerator.generated
-            |
-            |import fr.postgresjson.connexion.Requester
-            |
-            |$functionDecl Requester.$kotlinName($args): Unit {
-            |    getFunction("$name")
-            |        .exec(${parameters.toMapOf()})
-            |}
-        """.trimMargin()
-        }
-    }
-}

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

@@ -2,12 +2,10 @@ package fr.postgresjson.migration
 
 import com.github.jasync.sql.db.postgresql.exceptions.GenericDatabaseException
 import fr.postgresjson.connexion.Connection
-import fr.postgresjson.connexion.execute
-import fr.postgresjson.definition.parse.parseFunction
 import fr.postgresjson.migration.Migration.Action
 import fr.postgresjson.migration.Migration.Status
-import java.util.Date
-import java.util.concurrent.CompletionException
+import java.util.*
+import java.util.concurrent.*
 import fr.postgresjson.definition.Function as DefinitionFunction
 
 data class Function(
@@ -31,56 +29,68 @@ data class Function(
         connection: Connection,
         executedAt: Date? = null
     ) : this(
-        parseFunction(up),
-        parseFunction(down),
+        DefinitionFunction(up),
+        DefinitionFunction(down),
         connection,
         executedAt
     )
 
     override fun up(): Status {
-        return try {
-            try {
+        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)
-            } 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.execute<MigrationEntity>(it, listOf(up.name, up.getDefinition(), up.script, down.script)) }
-                ?.let { migration: MigrationEntity ->
-                    executedAt = migration.executedAt
-                    doExecute = Action.OK
-                } ?: error("No migration executed")
-
-            Status.OK
-        } catch (e: Throwable) {
-            Status.UP_FAIL
         }
+
+        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 ->
+                executedAt = function.executedAt
+                doExecute = Action.OK
+            }
+        }
+        return Status.OK
     }
 
     override fun down(): Status {
-        return try {
-            connection.sendQuery(down.script)
+        connection.sendQuery(down.script)
 
-            this::class.java.classLoader
-                .getResource("sql/migration/deleteFunction.sql")!!
-                .readText()
-                .let { connection.sendQuery(it, listOf(down.name)) }
+        this::class.java.classLoader.getResource("sql/migration/deleteFunction.sql")!!.readText().let {
+            connection.sendQuery(it, listOf(down.name))
+        }
+        return Status.OK
+    }
 
-            Status.OK
-        } catch (e: Throwable) {
-            Status.DOWN_FAIL
+    override fun test(): Status {
+        connection.inTransaction {
+            up()
+            down()
+            it.sendQuery("ROLLBACK")
+        }.join()
+
+        return Status.OK // TODO
+    }
+
+    override fun status(): Status {
+        connection.inTransaction {
+            up()
+            down()
+            it.sendQuery("ROLLBACK")
+        }.join()
+
+        return Status.OK // TODO
+    }
+
+    fun copy(): Function {
+        return this.copy(up = up, down = down, connection = connection, executedAt = executedAt).also {
+            it.doExecute = this.doExecute
         }
     }
 
-    fun copy(): Function = this
-        .copy(up = up, down = down, connection = connection, executedAt = executedAt)
-        .also { it.doExecute = this.doExecute }
-
-    infix fun `is different from`(other: DefinitionFunction): Boolean = other.script != this.up.script
-}
+    infix fun `is different from`(other: DefinitionFunction): Boolean {
+        return other.script != this.up.script
+    }
+}

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

@@ -1,50 +0,0 @@
-package fr.postgresjson.migration
-
-import fr.postgresjson.connexion.Connection
-import fr.postgresjson.connexion.execute
-import fr.postgresjson.migration.Migration.Action
-import fr.postgresjson.migration.Migration.Status
-import java.util.Date
-
-data class MigrationScript(
-    val name: String,
-    val up: String,
-    val down: String,
-    private val connection: Connection,
-    override var executedAt: Date? = null
-) : Migration {
-    override var doExecute: Action? = null
-
-    override fun up(): Status {
-        return try {
-            connection.sendQuery(up)
-
-            this::class.java.classLoader.getResource("sql/migration/insertHistory.sql")!!.readText().let { sqlScript ->
-                connection.execute<MigrationEntity>(sqlScript, listOf(name, up, down))?.let { query ->
-                    executedAt = query.executedAt
-                    doExecute = Action.OK
-                } ?: error("No migration executed")
-            }
-
-            Status.OK
-        } catch (e: Throwable) {
-            Status.UP_FAIL
-        }
-    }
-
-    override fun down(): Status {
-        connection.sendQuery(down)
-
-        this::class.java.classLoader.getResource("sql/migration/deleteHistory.sql")!!.readText().let {
-            connection.exec(it, listOf(name))
-        }
-
-        return Status.OK
-    }
-
-    fun copy(): MigrationScript {
-        return this.copy(name = name, up = up, down = down, connection = connection, executedAt = executedAt).also {
-            it.doExecute = this.doExecute
-        }
-    }
-}

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

@@ -2,7 +2,8 @@ package fr.postgresjson.migration
 
 import com.fasterxml.jackson.core.type.TypeReference
 import fr.postgresjson.connexion.Connection
-import fr.postgresjson.definition.parse.parseFunction
+import fr.postgresjson.definition.Migration as DefinitionMigration
+import fr.postgresjson.entity.mutable.Entity
 import fr.postgresjson.migration.Migration.Action
 import fr.postgresjson.migration.Migration.Status
 import fr.postgresjson.utils.LoggerDelegate
@@ -10,9 +11,8 @@ import fr.postgresjson.utils.searchSqlFiles
 import org.slf4j.Logger
 import java.io.FileNotFoundException
 import java.net.URI
-import java.util.Date
+import java.util.*
 import fr.postgresjson.definition.Function as DefinitionFunction
-import fr.postgresjson.definition.Migration as DefinitionMigration
 
 class MigrationEntity(
     val filename: String,
@@ -20,27 +20,28 @@ class MigrationEntity(
     val up: String,
     val down: String,
     val version: Int
-)
+) : Entity<String?>(filename)
 
 interface Migration {
     var executedAt: Date?
     var doExecute: Action?
     fun up(): Status
     fun down(): Status
+    fun test(): Status
+    fun status(): Status
 
-    enum class Status(val i: Int) { OK(2), UP_FAIL(0), DOWN_FAIL(1) }
+    enum class Status(i: Int) { OK(2), UP_FAIL(0), DOWN_FAIL(1) }
     enum class Action { OK, UP, DOWN }
 }
 
-class MigrationExecutor private constructor(
+data class Migrations private constructor(
     private val connection: Connection,
-    private val migrationsScripts: MutableMap<String, MigrationScript> = mutableMapOf(),
+    private val migrationsScripts: MutableMap<String, Query> = mutableMapOf(),
     private val functions: MutableMap<String, Function> = mutableMapOf()
 ) {
     private var directories: List<URI> = emptyList()
     private val logger: Logger? by LoggerDelegate()
     constructor(directory: URI, connection: Connection) : this(listOf(directory), connection)
-    constructor(connection: Connection, vararg directory: URI) : this(directory.toList(), connection)
 
     constructor(directories: List<URI>, connection: Connection) : this(connection) {
         initDB()
@@ -48,12 +49,12 @@ class MigrationExecutor private constructor(
         reset()
     }
 
-    private fun reset() {
+    fun reset() {
         migrationsScripts.clear()
         functions.clear()
 
-        addMigrationFromDB()
-        addMigrationFromDirectory(directories)
+        getMigrationFromDB()
+        getMigrationFromDirectory(directories)
 
         migrationsScripts.forEach { (_, query) ->
             if (query.doExecute === null) {
@@ -73,18 +74,18 @@ class MigrationExecutor private constructor(
     /**
      * Get all migration from DB
      */
-    private fun addMigrationFromDB() {
+    private fun getMigrationFromDB() {
         this::class.java.classLoader.getResource("sql/migration/findAllFunction.sql")!!.readText().let {
-            connection.execute(it, object : TypeReference<List<MigrationEntity>>() {})
-                ?.map { function ->
+            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.execute(it, object : TypeReference<List<MigrationEntity>>() {})
-                ?.map { query ->
-                    migrationsScripts[query.filename] = MigrationScript(query.filename, query.up, query.down, connection, query.executedAt)
+            connection.select<MigrationEntity>(it, object : TypeReference<List<MigrationEntity>>() {})
+                .map { query ->
+                    migrationsScripts[query.filename] = Query(query.filename, query.up, query.down, connection, query.executedAt)
                 }
         }
     }
@@ -92,20 +93,20 @@ class MigrationExecutor private constructor(
     /**
      * Get all migration from multiples Directories
      */
-    private fun addMigrationFromDirectory(directories: List<URI>) {
-        directories.forEach {
-            addMigrationFromDirectory(it)
+    private fun getMigrationFromDirectory(directory: List<URI>) {
+        directory.forEach {
+            getMigrationFromDirectory(it)
         }
     }
 
     /**
      * Get all migration from Directory
      */
-    private fun addMigrationFromDirectory(directory: URI) {
+    private fun getMigrationFromDirectory(directory: URI) {
         val downs: MutableMap<String, DefinitionMigration> = mutableMapOf()
 
+        /* Set Down Migration */
         directory.searchSqlFiles().apply {
-            /* Set Down Migration */
             forEach { migration ->
                 if (migration is DefinitionMigration && migration.direction == DefinitionMigration.Direction.DOWN) {
                     downs += migration.name to migration
@@ -118,7 +119,7 @@ class MigrationExecutor private constructor(
                     val down = downs[migration.name] ?: throw DownMigrationNotDefined(migration.name + ".down.sql")
                     downs -= migration.name
 
-                    addMigrationScript(migration, down)
+                    addQuery(migration, down)
                 } else if (migration is DefinitionFunction) {
                     addFunction(migration)
                 }
@@ -129,9 +130,9 @@ class MigrationExecutor private constructor(
     enum class Direction { UP, DOWN }
 
     internal class DownMigrationNotDefined(path: String, cause: FileNotFoundException? = null) :
-        Throwable("The file $path was not found", cause)
+        Throwable("The file $path whas not found", cause)
 
-    fun addFunction(newDefinition: DefinitionFunction, callback: (Function) -> Unit = {}): MigrationExecutor {
+    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
@@ -147,17 +148,17 @@ class MigrationExecutor private constructor(
         return this
     }
 
-    fun addFunction(sql: String): MigrationExecutor {
-        addFunction(parseFunction(sql))
+    fun addFunction(sql: String): Migrations {
+        addFunction(DefinitionFunction(sql))
         return this
     }
 
-    fun addMigrationScript(up: DefinitionMigration, down: DefinitionMigration, callback: (MigrationScript) -> Unit = {}): MigrationExecutor =
-        addMigrationScript(up.name, up.script, down.script, callback)
+    fun addQuery(up: DefinitionMigration, down: DefinitionMigration, callback: (Query) -> Unit = {}): Migrations =
+        addQuery(up.name, up.script, down.script, callback)
 
-    fun addMigrationScript(name: String, up: String, down: String, callback: (MigrationScript) -> Unit = {}): MigrationExecutor {
+    fun addQuery(name: String, up: String, down: String, callback: (Query) -> Unit = {}): Migrations {
         if (migrationsScripts[name] === null) {
-            migrationsScripts[name] = MigrationScript(name, up, down, connection).apply {
+            migrationsScripts[name] = Query(name, up, down, connection).apply {
                 doExecute = Action.UP
             }
         } else {
@@ -173,10 +174,10 @@ class MigrationExecutor private constructor(
 
     private fun initDB() {
         if (!initialized) {
-            this::class.java.classLoader.getResource("sql/migration/createHistorySchema.sql")!!.readText().let {
+            this::class.java.classLoader.getResource("sql/migration/createHistoryShema.sql")!!.readText().let {
                 connection.sendQuery(it)
             }
-            this::class.java.classLoader.getResource("sql/migration/createFunctionSchema.sql")!!.readText().let {
+            this::class.java.classLoader.getResource("sql/migration/createFunctionShema.sql")!!.readText().let {
                 connection.sendQuery(it)
             }
             initialized = true
@@ -296,7 +297,7 @@ class MigrationExecutor private constructor(
         return list.toMap()
     }
 
-    private fun copy(): MigrationExecutor {
+    fun copy(): Migrations {
         val queriesCopy = migrationsScripts.map {
             it.key to it.value.copy()
         }.toMap().toMutableMap()
@@ -305,6 +306,10 @@ class MigrationExecutor private constructor(
             it.key to it.value.copy()
         }.toMap().toMutableMap()
 
-        return MigrationExecutor(connection, queriesCopy, functionsCopy)
+        return Migrations(connection, queriesCopy, functionsCopy)
     }
-}
+
+    fun status(): Map<String, Int> {
+        TODO("not implemented")
+    }
+}

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

@@ -0,0 +1,65 @@
+package fr.postgresjson.migration
+
+import fr.postgresjson.connexion.Connection
+import fr.postgresjson.entity.mutable.Entity
+import fr.postgresjson.migration.Migration.Action
+import java.util.*
+
+data class Query(
+    val name: String,
+    val up: String,
+    val down: String,
+    private val connection: Connection,
+    override var executedAt: Date? = null
+) : Migration, Entity<String?>(name) {
+    override var doExecute: Action? = null
+
+    override fun up(): Migration.Status {
+        connection.sendQuery(up)
+
+        this::class.java.classLoader.getResource("sql/migration/insertHistory.sql")!!.readText().let {
+            connection.selectOne<MigrationEntity>(it, listOf(name, up, down))?.let { query ->
+                executedAt = query.executedAt
+                doExecute = Action.OK
+            }
+        }
+
+        return Migration.Status.OK
+    }
+
+    override fun down(): Migration.Status {
+        connection.sendQuery(down)
+
+        this::class.java.classLoader.getResource("sql/migration/deleteHistory.sql")!!.readText().let {
+            connection.exec(it, listOf(name))
+        }
+
+        return Migration.Status.OK
+    }
+
+    override fun test(): Migration.Status {
+        connection.inTransaction {
+            up()
+            down()
+            it.sendQuery("ROLLBACK")
+        }.join()
+
+        return Migration.Status.OK // TODO
+    }
+
+    override fun status(): Migration.Status {
+        connection.inTransaction {
+            up()
+            down()
+            it.sendQuery("ROLLBACK")
+        }.join()
+
+        return Migration.Status.OK // TODO
+    }
+
+    fun copy(): Query {
+        return this.copy(name = name, up = up, down = down, connection = connection, executedAt = executedAt).also {
+            it.doExecute = this.doExecute
+        }
+    }
+}

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

@@ -3,19 +3,19 @@ package fr.postgresjson.serializer
 import com.fasterxml.jackson.core.type.TypeReference
 import com.fasterxml.jackson.databind.DeserializationFeature
 import com.fasterxml.jackson.databind.ObjectMapper
-import com.fasterxml.jackson.databind.PropertyNamingStrategies
+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 com.github.jasync.sql.db.QueryResult
+import fr.postgresjson.entity.Serializable
 
 class Serializer(val mapper: ObjectMapper = jacksonObjectMapper()) {
     init {
         val module = SimpleModule()
         mapper.registerModule(module)
-        mapper.propertyNamingStrategy = PropertyNamingStrategies.SNAKE_CASE
+        mapper.propertyNamingStrategy = PropertyNamingStrategy.SNAKE_CASE
 
         mapper.registerModule(JodaModule())
         mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
@@ -28,21 +28,27 @@ class Serializer(val mapper: ObjectMapper = jacksonObjectMapper()) {
     }
 
     fun <E> deserialize(json: String, valueTypeRef: TypeReference<E>): E {
-        return mapper.readValue(json, valueTypeRef)
+        return this.mapper.readValue(json, valueTypeRef)
     }
 
     inline fun <reified E> deserialize(json: String): E? {
         return this.mapper.readValue(json)
     }
-}
 
-inline fun <reified E : Any?> QueryResult.deserialize(): E? {
-    val value = this.rows.firstOrNull()?.getString(0)
-    return if (value == null) {
-        null
-    } else {
-        Serializer().deserialize<E>(value)
+    fun <E> deserializeList(json: String, valueTypeRef: TypeReference<E>): E {
+        return mapper.readValue(json, valueTypeRef)
+    }
+
+    inline fun <reified E> deserializeList(json: String): E {
+        return deserializeList(json, object : TypeReference<E>() {})
+    }
+
+    fun <E> deserialize(json: String, target: E): E {
+        return mapper.readerForUpdating(target).readValue<E>(json)
     }
 }
 
-inline fun <reified T : Any> T.toTypeReference(): TypeReference<T> = object : TypeReference<T>() {}
+fun Serializable.serialize(pretty: Boolean = false) = Serializer().serialize(this, pretty)
+fun List<Serializable>.serialize(pretty: Boolean = false) = Serializer().serialize(this, pretty)
+inline fun <reified E : Serializable> E.deserialize(json: String) = Serializer().deserialize(json, this)
+inline fun <reified E : Serializable> String.deserialize() = Serializer().deserialize<E>(this)

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

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

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

@@ -1,7 +0,0 @@
-package fr.postgresjson.utils
-
-fun String.toCamelCase(): String {
-    return "_[a-zA-Z]".toRegex().replace(this) {
-        it.value.replace("_", "").uppercase()
-    }
-}

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

@@ -5,7 +5,6 @@ import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import java.net.URI
 import java.net.URL
-import java.nio.file.FileSystemNotFoundException
 import java.nio.file.FileSystems
 import java.nio.file.FileVisitOption
 import java.nio.file.Files
@@ -14,22 +13,18 @@ import kotlin.streams.asSequence
 
 fun URL.searchSqlFiles() = this.toURI().searchSqlFiles()
 
-fun URI.searchSqlFiles(): Sequence<Resource> = sequence {
+fun URI.searchSqlFiles() = sequence<Resource> {
     val logger: Logger = LoggerFactory.getLogger("sqlFilesSearch")
     val uri: URI = this@searchSqlFiles
-    logger.debug("""SQL files found in "${uri.toString().substringAfter('!')}" :""")
     if (uri.scheme == "jar") {
-        try {
-            FileSystems.getFileSystem(uri)
-        } catch (e: FileSystemNotFoundException) {
-            FileSystems.newFileSystem(uri, emptyMap<String, Any>())
-        }
-
-        uri
+        val relativePath = uri.toString().substringAfter('!')
+        FileSystems
+            .newFileSystem(uri, emptyMap<String, Any>())
+            .getPath(relativePath)
             .walk(5)
             .asSequence()
             .filter { it.fileName.toString().endsWith(".sql") }
-            .map { it.toUri().toURL() }
+            .map { this::class.java.getResource(path.toString()) }
             .forEach {
                 logger.debug(it.toString())
                 yield(Resource.build(it))
@@ -47,5 +42,5 @@ fun URI.searchSqlFiles(): Sequence<Resource> = sequence {
     }
 }
 
-private fun Path.walk(maxDepth: Int = 2147483647, vararg options: FileVisitOption) = Files.walk(this, maxDepth, *options).sorted()
-private fun URI.walk(maxDepth: Int = 2147483647, vararg options: FileVisitOption) = Files.walk(Path.of(this), maxDepth, *options).sorted()
+private fun Path.walk(maxDepth: Int = 2147483647, vararg options: FileVisitOption) = Files.walk(this, maxDepth, *options)
+private fun URI.walk(maxDepth: Int = 2147483647, vararg options: FileVisitOption) = Files.walk(Path.of(this), maxDepth, *options)

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

@@ -1,351 +1,182 @@
 package fr.postgresjson
 
-import com.fasterxml.jackson.core.type.TypeReference
-import fr.postgresjson.connexion.DataNotFoundException
-import fr.postgresjson.connexion.SqlSerializable
-import fr.postgresjson.connexion.execute
-import fr.postgresjson.serializer.deserialize
-import fr.postgresjson.serializer.toTypeReference
-import io.kotest.core.spec.style.StringSpec
-import io.kotest.matchers.nulls.shouldBeNull
-import io.kotest.matchers.nulls.shouldNotBeNull
-import org.amshove.kluent.`should be equal to`
-import org.junit.jupiter.api.assertThrows
-import java.util.UUID
-import kotlin.reflect.full.hasAnnotation
-import kotlin.test.assertEquals
-import kotlin.test.assertFalse
-import kotlin.test.assertNotNull
-import kotlin.test.assertTrue
+import fr.postgresjson.connexion.Paginated
+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.Test
+import org.junit.jupiter.api.TestInstance
 
-class ConnectionTest : StringSpec({
-    val connection = TestConnection()
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+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
 
-    @SqlSerializable
-    class ObjTest(val name: String, val id: UUID = UUID.fromString("2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00"))
-
-    @SqlSerializable
-    class ObjTest2(val id: UUID, val title: String, var test: ObjTest?)
-
-    @SqlSerializable
-    class ObjTest3(val id: UUID, val first: String, var second: String, var third: Int)
-
-    @SqlSerializable
-    class ParameterObject(var third: String)
-
-    @SqlSerializable
-    class ObjTestWithParameterObject(val id: UUID, var first: ParameterObject, var second: ParameterObject)
-    class ObjTest4
-
-    "serializable" {
-        assertTrue(ObjTest("plop")::class.hasAnnotation<SqlSerializable>())
-        assertFalse(ObjTest4()::class.hasAnnotation<SqlSerializable>())
+    @Test
+    fun getObject() {
+        val obj: ObjTest? = connection.selectOne("select to_json(a) from test a limit 1")
+        assertTrue(obj is ObjTest)
+        assertTrue(obj!!.id == 1)
     }
 
-    "getObject" {
-        val obj: ObjTest? = connection.rollbackAfter {
-            sendQuery(
-                """
-                create table test(
-                    id UUID primary key,
-                    name text
-                );
-                INSERT INTO test (id, name) VALUES ('1e5f5d41-6d14-4007-897b-0ed2616bec96', 'one');
-                INSERT INTO test (id, name) VALUES ('26fa76cf-7688-4a1d-b611-e3060b38bf58', 'two');
-                """.trimIndent()
-            )
-
-            execute("select to_json(a) from test a limit 1")
-        }
-
-        assertNotNull(obj)
-        assertEquals(UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"), obj.id)
-    }
-
-    "getExistingObject" {
-        val objs: List<ObjTest2>? = connection.rollbackAfter {
-            sendQuery(
-                """
-                create table test(
-                    id uuid primary key,
-                    name text
-                );
-                create table test2(
-                    id uuid primary key,
-                    title text,
-                    test_id uuid
-                );
-                INSERT INTO test VALUES ('1e5f5d41-6d14-4007-897b-0ed2616bec96', 'one');
-                INSERT INTO test2 VALUES ('a0214677-7332-4eec-8e9b-af0658ea72a6', 'two', '1e5f5d41-6d14-4007-897b-0ed2616bec96');
-                INSERT INTO test2 VALUES ('8545577e-2785-421f-bb7e-1ec3faa1d79a', 'three', null);
-                """.trimIndent()
-            )
-
-            execute<List<ObjTest2>>(
-                """
-                select json_agg(j)
-                from (
-                    select
-                        t.id, 
-                        t.title,
-                        t2 as test
-                    from test2 t
-                    join test t2 ON t.test_id = t2.id
-                ) j;
-                """.trimIndent()
-            )
-        }
-
-        objs.shouldNotBeNull()
-        objs.size `should be equal to` 1
-        objs.first().id `should be equal to` UUID.fromString("a0214677-7332-4eec-8e9b-af0658ea72a6")
-        objs.first().title `should be equal to` "two"
-        objs.first().test!!.id `should be equal to` UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96")
-        objs.first().test!!.name `should be equal to` "one"
-    }
-
-    "test call request with args" {
-        val result: ObjTest? = connection.execute(
-            "select json_build_object('id', '2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00', 'name', ?::text)",
-            listOf("myName")
+    @Test
+    fun getExistingObject() {
+        val objs: List<ObjTest2> = connection.select("""
+        select
+            json_agg(j)
+            FROM (
+            SELECT
+                t.id, t.title,
+                t2 as test
+            from test2 t
+            JOIN test t2 ON t.test_id = t2.id
+        ) j;
+        """.trimIndent()
         )
-        result.shouldNotBeNull()
-        result.name `should be equal to` "myName"
+        assertNotNull(objs)
+        assertEquals(objs.size, 2)
+        assertEquals(objs[0].id, 1)
+        assertEquals(objs[0].test!!.id, 1)
     }
 
-    "test call request without args" {
-        val result: ObjTest? = connection.execute(
-            "select json_build_object('id', '2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00', 'name', 'myName')",
-            object : TypeReference<ObjTest>() {}
-        ) {
-            assertEquals("myName", this.deserialize<ObjTest>()?.name)
-        }
-        result.shouldNotBeNull()
-        result.name `should be equal to` "myName"
+    @Test
+    fun callRequestWithArgs() {
+        val result: ObjTest? = connection.selectOne("select json_build_object('id', 1, 'name', ?::text)", listOf("myName"))
+        assertNotNull(result)
+        assertEquals("myName", result!!.name)
     }
 
-    "test call request return null" {
-        val result: ObjTest? = connection.execute("select null;", object : TypeReference<ObjTest>() {})
-        result.shouldBeNull()
-    }
-
-    "test call request return nothing" {
-        val e = connection.rollbackAfter {
-            sendQuery(
-                """
-                create table test(
-                    id UUID primary key,
-                    name text
-                );
-                """.trimIndent()
-            )
-
-            assertThrows<DataNotFoundException> {
-                execute("select * from test where false;", object : TypeReference<ObjTest>() {})
-            }
-        }
-
-        e.shouldNotBeNull()
-        e.message `should be equal to` "No data return for the query"
-        e.queryExecuted `should be equal to` "select * from test where false;"
-    }
-
-    "callRequestWithArgsEntity" {
-        val o = ObjTest("myName", id = UUID.fromString("2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00"))
-        val obj: ObjTest? = connection.execute(
-            "select json_build_object('id', id, 'name', name) FROM json_to_record(?::json) as o(id uuid, name text);",
-            listOf(o)
-        )
-        obj.shouldNotBeNull()
-        obj.id `should be equal to` UUID.fromString("2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00")
-        obj.name `should be equal to` "myName"
-    }
-
-    "test update Entity" {
-        val obj = ObjTest("before", id = UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"))
-        val objUpdated: ObjTest? = connection.execute(
-            "select ?::jsonb || jsonb_build_object('name', 'after');",
-            obj.toTypeReference(), listOf(obj)
-        )
-        objUpdated.shouldNotBeNull()
-        objUpdated.id `should be equal to` UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96")
-        objUpdated.name `should be equal to` "after"
-    }
-
-    "test update Entity with vararg" {
-        val obj = ObjTest("before", id = UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"))
-        val objUpdated: ObjTest? = connection.execute(
-            "select :obj::jsonb || jsonb_build_object('name', 'after');",
-            obj.toTypeReference(),
-            "obj" to obj
-        )
-        assertNotNull(objUpdated)
-        assertEquals(UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"), objUpdated.id)
-        assertEquals("after", objUpdated.name)
-    }
-
-    "callExec" {
+    @Test
+    fun callRequestWithArgsEntity() {
         val o = ObjTest("myName")
-        val result = connection.exec(
-            "select json_build_object('id', '2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00', 'name', ?::json->>'name')",
-            listOf(o)
-        )
-        assertEquals(1, result.rowsAffected)
+        o.id = 88
+        val obj: ObjTest? = connection.selectOne("select json_build_object('id', id, 'name', name) FROM json_to_record(?::json) as o(id int, name text);", listOf(o))
+        assertNotNull(obj)
+        assertTrue(obj is ObjTest)
+        assertEquals(obj!!.id, 88)
+        assertEquals(obj.name, "myName")
     }
 
-    "select one with named parameters" {
-        val result: ObjTest3? = connection.execute(
-            """
-            SELECT json_build_object(
-                'id', 'bf0e5605-3a8f-4db9-8b98-c8e0691dd576', 
-                'first', :first::text, 
-                'second', :second::text, 
-                'third', :third::int
-            )
-            """.trimIndent(),
+    @Test
+    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)
+    }
+
+    @Test
+    fun `select one with named parameters`() {
+        val result: ObjTest3? = connection.selectOne(
+            "SELECT json_build_object('first', :first::text, 'seconde', :seconde::text, 'third', :third::int)",
             mapOf(
                 "first" to "ff",
-                "second" to "sec",
+                "seconde" to "sec",
                 "third" to 123
             )
         )
-        assertNotNull(result)
-        assertEquals("ff", result.first)
-        assertEquals("sec", result.second)
-        assertEquals(123, result.third)
+        assertEquals(result!!.first, "ff")
+        assertEquals(result.seconde, "sec")
+        assertEquals(result.third, 123)
     }
 
-    "select one with named parameters object" {
-        val result: ObjTestWithParameterObject? = connection.execute(
-            """
-            SELECT json_build_object(
-                'id', 'bf0e5605-3a8f-4db9-8b98-c8e0691dd576', 
-                'first', :first::json, 
-                'second', :second::json
-            )
-            """.trimIndent(),
+    @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"),
-                "second" to ParameterObject("two")
+                "seconde" to ParameterObject("two")
             )
         )
-        assertNotNull(result)
-        assertEquals("bf0e5605-3a8f-4db9-8b98-c8e0691dd576", result.id.toString())
-        assertEquals("one", result.first.third)
-        assertEquals("two", result.second.third)
+        assertEquals("one", result!!.first.third)
+        assertEquals("two", result.seconde.third)
     }
 
-    "select with named parameters" {
-        val result: List<ObjTest3>? = connection.execute(
-            """
-            SELECT json_build_array(
-                json_build_object(
-                    'id', 'bf0e5605-3a8f-4db9-8b98-c8e0691dd576', 
-                    'first', :first::text, 
-                    'second', :second::text, 
-                    'third', :third::int
-                ),
-                json_build_object(
-                    'id', 'ce9ae3c9-dc0e-4561-a168-811b996d913e', 
-                    'first', :first::text, 
-                    'second', :second::text, 
-                    'third', :third::int
-                )
-            )
-            """.trimIndent(),
-            mapOf(
-                "first" to "ff",
-                "third" to 123,
-                "second" to "sec"
-            )
-        )
-        assertNotNull(result)
-        assertEquals("bf0e5605-3a8f-4db9-8b98-c8e0691dd576", result[0].id.toString())
-        assertEquals("ff", result[0].first)
-        assertEquals("sec", result[0].second)
-        assertEquals(123, result[0].third)
-    }
-
-    "select with named parameters as vararg of Pair" {
-        val result: List<ObjTest3>? = connection.execute(
-            """
-            SELECT json_build_array(
-                json_build_object('id', 'bf0e5605-3a8f-4db9-8b98-c8e0691dd576', 'first', :first::text, 'second', :second::text, 'third', :third::int),
-                json_build_object('id', '0c9d55d2-f69a-4750-a278-fac821774276', 'first', :first::text, 'second', :second::text, 'third', :third::int)
-            )
-            """.trimIndent(),
-            "first" to "ff",
-            "third" to 123,
-            "second" to "sec"
-        )
-        assertNotNull(result)
-        assertEquals("bf0e5605-3a8f-4db9-8b98-c8e0691dd576", result[0].id.toString())
-        assertEquals("ff", result[0].first)
-        assertEquals("sec", result[0].second)
-        assertEquals(123, result[0].third)
-    }
-
-    "execute with extra parameters" {
+    @Test
+    fun `select with named parameters`() {
         val params: Map<String, Any?> = mapOf(
             "first" to "ff",
             "third" to 123,
-            "second" to "sec"
+            "seconde" to "sec"
         )
-        val result: ObjTest3? = connection.execute(
+        val result: List<ObjTest3> = connection.select(
             """
-            SELECT json_build_object(
-                'id', 'bf0e5605-3a8f-4db9-8b98-c8e0691dd576', 
-                'first', :first::text, 
-                'second', :second::text, 
-                'third', :third::int
-            ), 'plop'::text as other
+            SELECT json_build_array(
+                json_build_object('first', :first::text, 'seconde', :seconde::text, 'third', :third::int),
+                json_build_object('first', :first::text, 'seconde', :seconde::text, 'third', :third::int)
+            )
+            """.trimIndent(),
+            params
+        )
+        assertEquals(result[0].first, "ff")
+        assertEquals(result[0].seconde, "sec")
+        assertEquals(result[0].third, 123)
+    }
+
+    @Test
+    fun `selectOne with named parameters`() {
+        val params: Map<String, Any?> = mapOf(
+            "first" to "ff",
+            "third" to 123,
+            "seconde" to "sec"
+        )
+        val result: ObjTest3? = connection.selectOne(
+            """
+            SELECT json_build_object('first', :first::text, 'seconde', :seconde::text, 'third', :third::int)
+            """.trimIndent(),
+            params
+        )
+        assertNotNull(result)
+        assertEquals(result!!.first, "ff")
+        assertEquals(result.seconde, "sec")
+        assertEquals(result.third, 123)
+    }
+
+    @Test
+    fun `select paginated`() {
+        val result: Paginated<ObjTest> = connection.select(
+            """
+            SELECT json_build_array(
+                json_build_object('id', 3, 'name', :name::text),
+                json_build_object('id', 4, 'name', :name::text || '-2')
+            ), 10 as total
+            LIMIT :limit OFFSET :offset
+            """.trimIndent(),
+            1,
+            2,
+            mapOf("name" to "ff")
+
+        )
+        assertNotNull(result)
+        assertEquals(result.result[0].name, "ff")
+        assertEquals(result.result[1].name, "ff-2")
+        assertEquals(result.total, 10)
+        assertEquals(result.offset, 0)
+    }
+
+    @Test
+    fun `selectOne with extra parameters`() {
+        val params: Map<String, Any?> = mapOf(
+            "first" to "ff",
+            "third" to 123,
+            "seconde" to "sec"
+        )
+        val result: ObjTest3? = connection.selectOne(
+            """
+            SELECT json_build_object('first', :first::text, 'seconde', :seconde::text, 'third', :third::int), 'plop'::text as other
             """.trimIndent(),
             params
         ) {
-            assertNotNull(it)
-            assertEquals("bf0e5605-3a8f-4db9-8b98-c8e0691dd576", it.id.toString())
-            assertEquals("ff", it.first)
+            assertEquals("ff", it!!.first)
             assertEquals("plop", rows[0].getString("other"))
         }
         assertNotNull(result)
-        assertEquals("ff", result.first)
-        assertEquals("sec", result.second)
+        assertEquals("ff", result!!.first)
+        assertEquals("sec", result.seconde)
         assertEquals(123, result.third)
     }
-
-    "test exec without parameters" {
-        connection.exec("select 42, 'hello';").run {
-            assertEquals(42, rows[0].getInt(0))
-            assertEquals("hello", rows[0].getString(1))
-        }
-    }
-
-    "test exec with one object as parameter" {
-        val obj = ObjTest("myName", UUID.fromString("c606e216-53b3-43c8-a900-e727cb4a017c"))
-        connection.exec("select ?::jsonb->>'name'", obj).run {
-            assertEquals("myName", rows[0].getString(0))
-        }
-    }
-
-    "select one in transaction" {
-        connection.inTransaction {
-            execute<ObjTestWithParameterObject>(
-                """
-                SELECT json_build_object(
-                    'id', 'bf0e5605-3a8f-4db9-8b98-c8e0691dd576', 
-                    'first', :first::json, 
-                    'second', :second::json
-                    )
-                """.trimIndent(),
-                mapOf(
-                    "first" to ParameterObject("one"),
-                    "second" to ParameterObject("two")
-                )
-            ).let { result ->
-                assertNotNull(result)
-                assertEquals("one", result.first.third)
-                assertEquals("two", result.second.third)
-            }
-        }
-    }
-})
+}

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

@@ -0,0 +1,27 @@
+package fr.postgresjson
+
+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(id: Int?) : Entity<Int?>(id)
+    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 UuidEntityExtended<Int?, User>)
+        assertTrue(obj is EntityI)
+        assertTrue(obj is Entity<Int?>)
+        assertTrue(obj is Published<User>)
+        assertTrue(obj is EntityCreatedBy<User>)
+        assertTrue(obj is EntityUpdatedBy<User>)
+        assertTrue(obj is EntityCreatedAt)
+        assertTrue(obj is EntityUpdatedAt)
+    }
+}

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

@@ -1,26 +1,22 @@
 package fr.postgresjson
 
 import fr.postgresjson.connexion.Requester
-import fr.postgresjson.connexion.execute
 import fr.postgresjson.migration.Migration
-import fr.postgresjson.migration.MigrationExecutor
-import org.amshove.kluent.invoking
+import fr.postgresjson.migration.Migrations
 import org.amshove.kluent.`should be equal to`
 import org.amshove.kluent.`should contain`
+import org.amshove.kluent.invoking
 import org.amshove.kluent.shouldThrow
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
-import java.util.UUID
-import kotlin.test.assertEquals
-import kotlin.test.assertNotNull
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
-class MigrationTest : TestAbstract() {
+class MigrationTest() : TestAbstract() {
     @Test
     fun `run up query`() {
-        val resources = this::class.java.getResource("/sql/migrations")!!.toURI()
-        val m = MigrationExecutor(connection, resources)
+        val resources = this::class.java.getResource("/sql/migrations").toURI()
+        val m = Migrations(resources, connection)
         m.up().apply {
             this `should contain` Pair("1", Migration.Status.OK)
             size `should be equal to` 1
@@ -31,16 +27,16 @@ class MigrationTest : TestAbstract() {
 
     @Test
     fun `migration up Query should throw error if no down`() {
-        val resources = this::class.java.getResource("/sql/migration_without_down")!!.toURI()
+        val resources = this::class.java.getResource("/sql/migration_without_down").toURI()
         invoking {
-            MigrationExecutor(resources, connection)
-        } shouldThrow MigrationExecutor.DownMigrationNotDefined::class
+            Migrations(resources, connection)
+        } shouldThrow Migrations.DownMigrationNotDefined::class
     }
 
     @Test
     fun `run forced down query`() {
-        val resources = this::class.java.getResource("/sql/migrations")!!.toURI()
-        val m = MigrationExecutor(resources, connection)
+        val resources = this::class.java.getResource("/sql/migrations").toURI()
+        val m = Migrations(resources, connection)
         repeat(3) {
             m.down(true).apply {
                 this `should contain` Pair("1", Migration.Status.OK)
@@ -51,19 +47,19 @@ class MigrationTest : TestAbstract() {
 
     @Test
     fun `run dry migrations`() {
-        val resources = this::class.java.getResource("/sql/real_migrations")!!.toURI()
-        MigrationExecutor(resources, connection).apply {
+        val resources = this::class.java.getResource("/sql/real_migrations").toURI()
+        Migrations(resources, connection).apply {
             runDry().size `should be equal to` 2
         }
-        MigrationExecutor(resources, connection).apply {
+        Migrations(resources, connection).apply {
             runDry().size `should be equal to` 2
         }
     }
 
     @Test
     fun `run dry migrations launch twice`() {
-        val resources = this::class.java.getResource("/sql/real_migrations")!!.toURI()
-        MigrationExecutor(resources, connection).apply {
+        val resources = this::class.java.getResource("/sql/real_migrations").toURI()
+        Migrations(resources, connection).apply {
             runDry().size `should be equal to` 2
             runDry().size `should be equal to` 2
         }
@@ -71,8 +67,8 @@ class MigrationTest : TestAbstract() {
 
     @Test
     fun `run migrations`() {
-        val resources = this::class.java.getResource("/sql/real_migrations")!!.toURI()
-        MigrationExecutor(resources, connection).apply {
+        val resources = this::class.java.getResource("/sql/real_migrations").toURI()
+        Migrations(resources, connection).apply {
             run().apply {
                 size `should be equal to` 1
             }
@@ -81,14 +77,14 @@ class MigrationTest : TestAbstract() {
 
     @Test
     fun `run migrations force down`() {
-        val resources = this::class.java.getResource("/sql/real_migrations")!!.toURI()
-        val resourcesFunctions = this::class.java.getResource("/sql/function/Test")!!.toURI()
-        MigrationExecutor(listOf(resources, resourcesFunctions), connection).apply {
+        val resources = this::class.java.getResource("/sql/real_migrations").toURI()
+        val resourcesFunctions = this::class.java.getResource("/sql/function/Test").toURI()
+        Migrations(listOf(resources, resourcesFunctions), connection).apply {
             up().apply {
                 size `should be equal to` 6
             }
         }
-        MigrationExecutor(listOf(resources, resourcesFunctions), connection).apply {
+        Migrations(listOf(resources, resourcesFunctions), connection).apply {
             forceAllDown().apply {
                 size `should be equal to` 6
             }
@@ -97,37 +93,38 @@ class MigrationTest : TestAbstract() {
 
     @Test
     fun `run functions migrations`() {
-        val resources = this::class.java.getResource("/sql/function/Test")!!.toURI()
-        MigrationExecutor(resources, connection).apply {
+        val resources = this::class.java.getResource("/sql/function/Test").toURI()
+        Migrations(resources, connection).apply {
             run().size `should be equal to` 5
         }
 
-        val objTest: RequesterTest.ObjTest? = Requester(connection, functionsDirectory = resources)
+        val objTest: RequesterTest.ObjTest? = Requester(connection)
+            .addFunction(resources)
             .getFunction("test_function")
-            .execute(listOf("test", "plip"))
+            .selectOne(listOf("test", "plip"))
 
-        assertNotNull(objTest)
-        assertEquals(objTest.id, UUID.fromString("457daad5-4f1b-4eb7-80ec-6882adb8cc7d"))
-        assertEquals(objTest.name, "test")
+        Assertions.assertEquals(objTest!!.id, 3)
+        Assertions.assertEquals(objTest.name, "test")
     }
 
     @Test
     fun `run functions migrations and drop if exist`() {
-        val resources = this::class.java.getResource("/sql/function/Test1")!!.toURI()
-        MigrationExecutor(resources, connection).apply {
+        val resources = 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, functionsDirectory = resources)
+        val objTest: RequesterTest.ObjTest? = Requester(connection)
+            .addFunction(resources)
             .getFunction("test_function_duplicate")
-            .execute(listOf("test"))
+            .selectOne(listOf("test"))
 
-        Assertions.assertEquals(objTest!!.id, UUID.fromString("457daad5-4f1b-4eb7-80ec-6882adb8cc7d"))
+        Assertions.assertEquals(objTest!!.id, 3)
         Assertions.assertEquals(objTest.name, "test")
 
-        val resources2 = this::class.java.getResource("/sql/function/Test2")!!.toURI()
-        MigrationExecutor(resources2, connection).apply {
+        val resources2 = 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

@@ -1,172 +1,55 @@
 package fr.postgresjson
 
-import com.fasterxml.jackson.core.type.TypeReference
-import fr.postgresjson.connexion.Connection.QueryError
+import fr.postgresjson.connexion.Paginated
 import fr.postgresjson.connexion.Requester
-import fr.postgresjson.connexion.Requester.NoFunctionDefined
-import fr.postgresjson.connexion.Requester.NoQueryDefined
-import fr.postgresjson.connexion.SqlSerializable
-import fr.postgresjson.connexion.execute
-import fr.postgresjson.serializer.deserialize
-import org.junit.jupiter.api.Assertions.assertThrows
+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.util.UUID
-import kotlin.test.assertEquals
-import kotlin.test.assertNotNull
 
 class RequesterTest : TestAbstract() {
-    @SqlSerializable
-    class ObjTest(val name: String, val id: UUID = UUID.fromString("5623d902-3067-42f3-bfd9-095dbb12c29f"))
-
-    @Test
-    fun `requester constructor empty`() {
-        val resources = this::class.java.getResource("/sql/function/Test")!!.toURI()
-        val name: String = Requester(connection)
-            .apply { addFunctions(resources) }
-            .getFunction("test_function")
-            .name
-
-        assertEquals("test_function", name)
-    }
-
-    @Test
-    fun `requester constructor function directory`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val name: String = Requester(connection, functionsDirectory = resources)
-            .getFunction("test_function")
-            .name
-
-        assertEquals("test_function", name)
-    }
-
-    @Test
-    fun `requester constructor query directory`() {
-        val resources = this::class.java.getResource("/sql/query/Test")?.toURI()
-        val name: String = Requester(connection, queriesDirectory = resources)
-            .getQuery("DeleteTest")
-            .name
-
-        assertEquals("DeleteTest", name)
-    }
-
-    @Test
-    fun `function toString`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val name: String = Requester(connection, functionsDirectory = resources)
-            .getFunction("test_function")
-            .toString()
-
-        assertEquals("test_function", name)
-    }
-
-    @Test
-    fun `add function as string`() {
-        val sql = """
-            CREATE OR REPLACE FUNCTION test_function (name text default 'plop', IN hi text default 'hello', out result json)
-            LANGUAGE plpgsql
-            AS
-            $$
-            BEGIN
-                result = json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', name);
-            END;
-            $$
-        """.trimIndent()
-        val name: String = Requester(connection)
-            .apply { addFunction(sql) }
-            .getFunction("test_function")
-            .name
-
-        assertEquals("test_function", name)
-    }
-
-    @Test
-    fun `add query from string`() {
-        val result: Int? = Requester(connection)
-            .apply { addQuery("simpleTest", "select 42;") }
-            .getQuery("simpleTest")
-            .exec()
-            .rows[0].getInt(0)
-
-        assertNotNull(result)
-        assertEquals(42, result)
-    }
+    class ObjTest(var name: String) : IdEntity(1)
 
     @Test
     fun `get query from file`() {
-        val resources = this::class.java.getResource("/sql/query")!!.toURI()
+        val resources = this::class.java.getResource("/sql/query").toURI()
         val objTest: ObjTest? = Requester(connection)
-            .apply { addQuery(resources) }
+            .addQuery(resources)
             .getQuery("selectOne")
-            .execute()
+            .selectOne()
 
-        assertNotNull(objTest)
-        assertEquals(objTest.id, UUID.fromString("829b1a29-5db8-47f9-9562-961c561ac528"))
-        assertEquals("test", objTest.name)
-    }
-
-    @Test
-    fun `get query from file with wrong name throw exception`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        assertThrows(NoQueryDefined::class.java) {
-            Requester(connection, queriesDirectory = resources)
-                .getQuery("wrongName")
-        }
-    }
-
-    @Test
-    fun `get queries from file`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        val name: String = Requester(connection, queriesDirectory = resources)
-            .getQueries()[0].name
-
-        assertEquals(name, "DeleteTest")
-    }
-
-    @Test
-    fun `get function from file with wrong name throw exception`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        assertThrows(NoFunctionDefined::class.java) {
-            Requester(connection, functionsDirectory = resources)
-                .getFunction("wrongName")
-        }
+        assertEquals(objTest!!.id, 2)
+        assertEquals(objTest.name, "test")
     }
 
     @Test
     fun `get function from file`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val objTest: ObjTest? = Requester(connection, functionsDirectory = resources)
+        val resources = this::class.java.getResource("/sql/function/Test").toURI()
+        val objTest: ObjTest? = Requester(connection)
+            .addFunction(resources)
             .getFunction("test_function")
-            .execute(listOf("test", "plip"))
+            .selectOne(listOf("test", "plip"))
 
-        assertNotNull(objTest)
-        assertEquals(objTest.id, UUID.fromString("457daad5-4f1b-4eb7-80ec-6882adb8cc7d"))
-        assertEquals("test", objTest.name)
+        assertEquals(objTest!!.id, 3)
+        assertEquals(objTest.name, "test")
     }
 
     @Test
     fun `call exec on query`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        val result = Requester(connection, queriesDirectory = resources)
+        val resources = this::class.java.getResource("/sql/query").toURI()
+        val result = Requester(connection)
+            .addQuery(resources)
             .getQuery("selectOne")
             .exec()
 
         assertEquals(1, result.rowsAffected)
     }
 
-    @Test
-    fun `call exec on query with a list of arguments`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        val result = Requester(connection, queriesDirectory = resources)
-            .getQuery("selectOneWithParameters")
-            .exec(listOf("myName"))
-
-        assertEquals("myName", result.deserialize<ObjTest>()?.name)
-    }
-
     @Test
     fun `call exec on function`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val result = Requester(connection, functionsDirectory = resources)
+        val resources = this::class.java.getResource("/sql/function/Test").toURI()
+        val result = Requester(connection)
+            .addFunction(resources)
             .getFunction("test_function")
             .exec(listOf("test", "plip"))
 
@@ -174,274 +57,112 @@ class RequesterTest : TestAbstract() {
     }
 
     @Test
-    fun `call exec on query with name`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        val result = Requester(connection, queriesDirectory = resources)
+    fun `call sendQuery on query with name`() {
+        val resources = this::class.java.getResource("/sql/query").toURI()
+        val result = Requester(connection)
+            .addQuery(resources)
             .getQuery("DeleteTest")
-            .exec()
+            .sendQuery()
 
-        assertEquals(0, result.rowsAffected)
+        assertEquals(0, result)
     }
 
     @Test
-    fun `call sendQuery with same name of arguments`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectMultipleWithSameArgs")
-            .sendQuery("name" to "myName").run {
-                assertEquals("myName", rows[0].getString("firstName"))
-                assertEquals("myName", rows[0].getString("secondName"))
-            }
+    fun `call sendQuery on function`() {
+        val resources = 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 sendQuery with same name of arguments as list`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectMultipleWithSameArgs")
-            .sendQuery(listOf("myName", "myName2")).run {
-                assertEquals("myName", rows[0].getString("firstName"))
-                assertEquals("myName2", rows[0].getString("secondName"))
-            }
-    }
-
-    @Test
-    fun `call sendQuery with arguments on not same orders`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectMultipleDifferentArgs")
-            .sendQuery("first" to "firstName", "second" to "secondName").run {
-                assertEquals("firstName", rows[0].getString("firstName"))
-                assertEquals("secondName", rows[0].getString("secondName"))
-            }
-
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectMultipleDifferentArgs")
-            .sendQuery("second" to "secondName", "first" to "firstName").run {
-                assertEquals("firstName", rows[0].getString("firstName"))
-                assertEquals("secondName", rows[0].getString("secondName"))
-            }
-
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectMultipleDifferentArgs")
-            .sendQuery("second" to "secondName", "first" to "firstName").run {
-                assertEquals("firstName", rows[0].getString(0))
-                assertEquals("secondName", rows[0].getString(1))
-            }
-    }
-
-    @Test
-    fun `call sendQuery with wrong number of arguments`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-
-        assertThrows(QueryError::class.java) {
-            Requester(connection, queriesDirectory = resources)
-                .getQuery("selectMultipleDifferentArgs")
-                .sendQuery("first" to "firstName")
-        }.let {
-            assertEquals(
-                """
-                Parameter "second" missing
-
-                  > :first = firstName
-                  > SELECT :first::text as "firstName", :second::text as "secondName";
-                """.trimIndent(),
-                it.message
-            )
-        }
-    }
-
-    @Test
-    fun `call sendQuery with wrong number of arguments as list`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-
-        assertThrows(QueryError::class.java) {
-            Requester(connection, queriesDirectory = resources)
-                .getQuery("selectMultipleDifferentArgs")
-                .sendQuery(listOf("firstName"))
-        }.let {
-            assertEquals(
-                """
-                Parameter 1 missing
-                
-                  > firstName
-                  > SELECT ?::text as "firstName", ?::text as "secondName";
-                """.trimIndent(),
-                it.message
-            )
-        }
-    }
-
-    @Test
-    fun `call exec on function with pair as arguments`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val result = Requester(connection, functionsDirectory = resources)
-            .getFunction("test_function_void")
-            .exec("name" to "test")
-
-        assertEquals(1, result.rowsAffected)
-    }
-
-    @Test
-    fun `call execute on function`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val obj: ObjTest? = Requester(connection, functionsDirectory = resources)
+    fun `call selectOne on function`() {
+        val resources = this::class.java.getResource("/sql/function/Test").toURI()
+        val obj: ObjTest = Requester(connection)
+            .addFunction(resources)
             .getFunction("test_function")
-            .execute(mapOf("name" to "myName"))
+            .selectOne(mapOf("name" to "myName"))!!
 
-        assertNotNull(obj)
         assertEquals("myName", obj.name)
     }
 
     @Test
-    fun `call execute on function with object and named argument`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
+    fun `call selectOne on function with object`() {
+        val resources = this::class.java.getResource("/sql/function/Test").toURI()
         val obj2 = ObjTest("original")
-        val obj: ObjTest? = Requester(connection, functionsDirectory = resources)
+        val obj: ObjTest = Requester(connection)
+            .addFunction(resources)
             .getFunction("test_function_object")
-            .execute("resource" to obj2)
+            .selectOne("resource" to obj2)!!
 
-        assertNotNull(obj)
         assertEquals("changedName", obj.name)
-        assertEquals("original", obj2.name)
+        assertEquals("changedName", obj2.name)
     }
 
     @Test
-    fun `call execute on function with object`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val obj2 = ObjTest("original")
-        val obj: ObjTest? = Requester(connection, functionsDirectory = resources)
-            .getFunction("test_function_object")
-            .execute(listOf(obj2))
-
-        assertNotNull(obj)
-        assertEquals("changedName", obj.name)
-        assertEquals("original", obj2.name)
-    }
-
-    @Test
-    fun `call execute on function with object and no arguments`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val obj: ObjTest? = Requester(connection, functionsDirectory = resources)
-            .getFunction("test_function")
-            .execute()
-
-        assertNotNull(obj)
-        assertEquals("plop", obj.name)
-    }
-
-    @Test
-    fun `call execute on query`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        val obj: ObjTest? = Requester(connection, queriesDirectory = resources)
+    fun `call selectOne on query`() {
+        val resources = this::class.java.getResource("/sql/query").toURI()
+        val obj: ObjTest = Requester(connection)
+            .addQuery(resources)
             .getQuery("selectOneWithParameters")
-            .execute(mapOf("name" to "myName"))
+            .selectOne(mapOf("name" to "myName"))!!
 
-        assertNotNull(obj)
         assertEquals("myName", obj.name)
     }
 
     @Test
-    fun `call select (multiple) on function with named argument`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val obj: List<ObjTest>? = Requester(connection, functionsDirectory = resources)
+    fun `call select (multiple) on function`() {
+        val resources = this::class.java.getResource("/sql/function/Test").toURI()
+        val obj: List<ObjTest>? = Requester(connection)
+            .addFunction(resources)
             .getFunction("test_function_multiple")
-            .execute(mapOf("name" to "myName"))
+            .select(mapOf("name" to "myName"))
 
-        assertNotNull(obj)
-        assertNotNull(obj[0])
-        assertEquals("myName", obj[0].name)
-        assertEquals("myName", obj[0].name)
+        assertEquals("myName", obj!![0].name)
     }
 
     @Test
-    fun `call select (multiple) on function with ordered arguments`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val obj: List<ObjTest>? = Requester(connection, functionsDirectory = resources)
-            .getFunction("test_function_multiple")
-            .execute(listOf("myName"))
-
-        assertNotNull(obj)
-        assertEquals("myName", obj[0].name)
+    fun `call select paginated on query`() {
+        val resources = this::class.java.getResource("/sql/query").toURI()
+        val result: Paginated<ObjTest> = Requester(connection)
+            .addQuery(resources)
+            .getQuery("selectPaginated")
+            .select(1, 2, mapOf("name" to "ff"))
+        Assert.assertNotNull(result)
+        Assert.assertEquals("ff", result.result[0].name)
+        Assert.assertEquals("ff-2", result.result[1].name)
+        Assert.assertEquals(10, result.total)
+        Assert.assertEquals(0, result.offset)
     }
 
     @Test
-    fun `call select multiple (named arguments)`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectMultiple").apply {
-                execute<List<ObjTest>>(mapOf("name" to "ff")).let { result ->
-                    assertNotNull(result)
-                    assertEquals("ff", result[0].name)
-                    assertEquals("ff-2", result[1].name)
-                }
-            }.apply {
-                execute(object : TypeReference<List<ObjTest>>() {}, mapOf("name" to "ff")).let { result ->
-                    assertNotNull(result)
-                    assertEquals("ff", result[0].name)
-                    assertEquals("ff-2", result[1].name)
-                }
-            }
+    fun `call select paginated on function`() {
+        val resources = this::class.java.getResource("/sql/function").toURI()
+        val result: Paginated<ObjTest> = Requester(connection)
+            .addFunction(resources)
+            .getFunction("test_function_paginated")
+            .select(1, 2, mapOf("name" to "ff"))
+        Assert.assertNotNull(result)
+        Assert.assertEquals("ff", result.result[0].name)
+        Assert.assertEquals("ff-2", result.result[1].name)
+        Assert.assertEquals(10, result.total)
+        Assert.assertEquals(0, result.offset)
     }
 
     @Test
-    fun `call select multiple (named arguments as pair)`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectMultiple").apply {
-                execute<List<ObjTest>>("name" to "ff").let { result ->
-                    assertNotNull(result)
-                    assertEquals("ff", result[0].name)
-                    assertEquals("ff-2", result[1].name)
-                }
-            }.apply {
-                execute(object : TypeReference<List<ObjTest>>() {}, "name" to "ff").let { result ->
-                    assertNotNull(result)
-                    assertEquals("ff", result[0].name)
-                    assertEquals("ff-2", result[1].name)
-                }
-            }
-    }
+    fun `call selectOne on query with extra parameter`() {
+        val resources = this::class.java.getResource("/sql/query").toURI()
+        val obj: ObjTest = Requester(connection)
+            .addQuery(resources)
+            .getQuery("selectOneWithParameters")
+            .selectOne(mapOf("name" to "myName")) {
+                assertEquals("myName", it!!.name)
+                Assert.assertEquals("plop", rows[0].getString("other"))
+            }!!
 
-    @Test
-    fun `call select multiple (ordered argument)`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectMultipleOrderedArgs").apply {
-                execute<List<ObjTest>>(listOf("ff", "aa")).let { result ->
-                    assertNotNull(result)
-                    assertEquals("ff", result[0].name)
-                    assertEquals("aa-2", result[1].name)
-                }
-            }.apply {
-                execute(object : TypeReference<List<ObjTest>>() {}, listOf("ff", "aa")).let { result ->
-                    assertNotNull(result)
-                    assertEquals("ff", result[0].name)
-                    assertEquals("aa-2", result[1].name)
-                }
-            }
+        assertEquals("myName", obj.name)
     }
-
-    @Test
-    fun `call execute on query with extra parameter`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectOneWithParameters").apply {
-                execute<ObjTest>(mapOf("name" to "myName")) {
-                    assertNotNull(it)
-                    assertEquals("myName", it.name)
-                    assertEquals("plop", rows[0].getString("other"))
-                }.run {
-                    assertEquals("selectOneWithParameters", name)
-                }
-            }.apply {
-                execute(typeReference = object : TypeReference<ObjTest>() {}, values = mapOf("name" to "myName")) {
-                    assertNotNull(it)
-                    assertEquals("myName", it.name)
-                    assertEquals("plop", rows[0].getString("other"))
-                }.run {
-                    assertEquals("selectOneWithParameters", name)
-                }
-            }
-    }
-}
+}

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

@@ -1,28 +1,32 @@
 package fr.postgresjson
 
+import fr.postgresjson.entity.mutable.IdEntity
 import fr.postgresjson.serializer.Serializer
+import fr.postgresjson.serializer.deserialize
+import fr.postgresjson.serializer.serialize
 import org.joda.time.DateTime
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
-import java.util.UUID
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 internal class SerializerTest {
-    private class ObjTest(var val1: String, var val2: Int, val id: UUID = UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"))
-    private class ObjTestDate(var val1: DateTime, val id: UUID = UUID.fromString("829b1a29-5db8-47f9-9562-961c561ac528"))
+    private class ObjTest(var val1: String, var val2: Int) : IdEntity(1)
+    private class ObjTestDate(var val1: DateTime) : IdEntity(2)
 
     private val serializer = Serializer()
 
-    private val objSerialized: String = """{"val1":"plop","val2":123,"id":"829b1a29-5db8-47f9-9562-961c561ac528"}"""
-    private val objSerializedWithExtra: String = """{"val1":"plop","val2":123,"id":"829b1a29-5db8-47f9-9562-961c561ac528","toto":"tata"}"""
+    private val objSerialized: String = """{"val1":"plop","val2":123,"id":2}"""
+    private val objSerializedWithExtra: String = """{"val1":"plop","val2":123,"id":2,"toto":"tata"}"""
+    private val objSerializedUpdate = """{"val1":"update","val2":123}"""
     private lateinit var obj: ObjTest
 
     @BeforeEach
     fun before() {
-        obj = ObjTest("plop", 123, UUID.fromString("829b1a29-5db8-47f9-9562-961c561ac528"))
+        obj = ObjTest("plop", 123)
+        obj.id = 2
     }
 
     @Test
@@ -31,10 +35,16 @@ internal class SerializerTest {
         assertTrue(json.contains(""""val1":"plop","val2":123"""))
     }
 
+    @Test
+    fun serialize2() {
+        val json = obj.serialize()
+        assertTrue(json.contains(""""val1":"plop","val2":123"""))
+    }
+
     @Test
     fun serializeList() {
         val list = listOf(ObjTest("one", 1), ObjTest("two", 2))
-        val json = serializer.serialize(list)
+        val json = list.serialize()
         assertTrue(json.contains(""""val1":"one","val2":1"""))
         assertTrue(json.contains(""""val1":"two","val2":2"""))
     }
@@ -42,7 +52,7 @@ internal class SerializerTest {
     @Test
     fun serializeDate() {
         val objDate = ObjTestDate(DateTime.parse("2019-07-30T14:08:51.420108+04:00"))
-        val json = serializer.serialize(objDate)
+        val json = objDate.serialize()
         assertTrue(json.contains(""""val1":"2019-07-30T10:08:51.420Z""""), json)
     }
 
@@ -59,4 +69,20 @@ internal class SerializerTest {
         assertEquals(obj.val1, objDeserialized!!.val1)
         assertEquals(obj.val2, objDeserialized.val2)
     }
-}
+
+    @Test
+    fun deserializeUpdate() {
+        val objDeserialized: ObjTest = serializer.deserialize(objSerializedUpdate, obj)
+        assertTrue(obj === objDeserialized)
+        assertEquals("update", objDeserialized.val1)
+        assertEquals(123, objDeserialized.val2)
+    }
+
+    @Test
+    fun deserializeUpdate2() {
+        val objDeserialized = obj.deserialize(objSerializedUpdate)
+        assertTrue(obj === objDeserialized)
+        assertEquals("update", objDeserialized.val1)
+        assertEquals(123, objDeserialized.val2)
+    }
+}

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

@@ -1,26 +0,0 @@
-package fr.postgresjson
-
-import fr.postgresjson.connexion.Connection
-import io.kotest.core.listeners.AfterSpecListener
-import io.kotest.core.listeners.BeforeSpecListener
-import io.kotest.core.spec.Spec
-import java.io.File
-
-open class SqlFixtureListener : BeforeSpecListener, AfterSpecListener {
-    private val connection = Connection(database = "json_test", username = "test", password = "test", port = 35555)
-
-    override suspend fun beforeSpec(spec: Spec) {
-        val initSQL = File(this::class.java.getResource("/fixtures/init.sql")!!.toURI())
-        connection
-            .connect()
-            .sendQuery(initSQL.readText())
-            .join()
-    }
-
-    override suspend fun afterSpec(spec: Spec) {
-        val downSQL = File(this::class.java.getResource("/fixtures/down.sql")!!.toURI())
-        connection
-            .apply { connect().sendQuery(downSQL.readText()).join() }
-            .disconnect()
-    }
-}

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

@@ -8,12 +8,12 @@ import org.junit.jupiter.api.TestInstance.Lifecycle.PER_CLASS
 import java.io.File
 
 @TestInstance(PER_CLASS)
-open class TestAbstract {
-    protected val connection = Connection(database = "json_test", username = "test", password = "test", port = 35555)
+abstract class TestAbstract {
+    protected val connection = Connection(database = "json_test", username = "test", password = "test", port = 5555)
 
     @BeforeEach
     fun beforeAll() {
-        val initSQL = File(this::class.java.getResource("/fixtures/init.sql")!!.toURI())
+        val initSQL = File(this::class.java.getResource("/fixtures/init.sql").toURI())
         connection
             .connect()
             .sendQuery(initSQL.readText())
@@ -22,9 +22,9 @@ open class TestAbstract {
 
     @AfterEach
     fun afterAll() {
-        val downSQL = File(this::class.java.getResource("/fixtures/down.sql")!!.toURI())
-        connection
-            .apply { connect().sendQuery(downSQL.readText()).join() }
-            .disconnect()
+        val downSQL = File(this::class.java.getResource("/fixtures/down.sql").toURI())
+        connection.connect().apply {
+            sendQuery(downSQL.readText()).join()
+        }.disconnect()
     }
-}
+}

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

@@ -1,16 +0,0 @@
-package fr.postgresjson
-
-import fr.postgresjson.connexion.Connection
-
-fun TestConnection(): Connection =
-    Connection(database = "json_test", username = "test", password = "test", port = 35555)
-
-fun <A> Connection.rollbackAfter(block: Connection.() -> A?) = connect().run {
-    sendQuery("BEGIN")
-    try {
-        block().apply { sendQuery("ROLLBACK") }
-    } catch (e: Throwable) {
-        sendQuery("ROLLBACK")
-        throw e
-    }
-}

src/test/kotlin/fr/postgresjson/definition/FunctionTest.kt

@@ -1,648 +0,0 @@
-package fr.postgresjson.definition
-
-import fr.postgresjson.definition.Parameter.Direction.IN
-import fr.postgresjson.definition.Parameter.Direction.INOUT
-import fr.postgresjson.definition.Parameter.Direction.OUT
-import fr.postgresjson.definition.Returns.Primitive
-import fr.postgresjson.definition.parse.parseFunction
-import io.kotest.core.spec.style.FreeSpec
-import io.kotest.matchers.collections.shouldHaveSize
-import io.kotest.matchers.shouldBe
-import org.amshove.kluent.shouldBeInstanceOf
-
-class FunctionTest : FreeSpec({
-    "Function name" - {
-        "all in lower" {
-            parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun() returns text language plpgsql as
-                $$ begin; end$$;
-                """.trimIndent()
-            ).apply {
-                name shouldBe "myfun"
-            }
-        }
-
-        "first letter caps without quoted" {
-            parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function Myfun() returns text language plpgsql as
-                $$ begin; end$$;
-                """.trimIndent()
-            ).apply {
-                name shouldBe "myfun"
-            }
-        }
-
-        "with numbers" {
-            parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun001() returns text language plpgsql as
-                $$ begin; end$$;
-                """.trimIndent()
-            ).apply {
-                name shouldBe "myfun001"
-            }
-        }
-
-        "escaped name with space" {
-            parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function "My fun"() returns text language plpgsql as
-                $$ begin; end$$;
-                """.trimIndent()
-            ).apply {
-                name shouldBe "My fun"
-            }
-        }
-
-        "quoted name with double quote in name" {
-            parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function "My""fun" () returns text language plpgsql as
-                $$ begin; end$$;
-                """.trimIndent()
-            ).apply {
-                name shouldBe "My\"fun"
-            }
-        }
-
-        "name with new line before and after" {
-            parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function 
-                myfun
-                () 
-                returns text language plpgsql as
-                $$ begin; end$$;
-                """.trimIndent()
-            ).apply {
-                name shouldBe "myfun"
-            }
-        }
-    }
-
-    "Parameters" - {
-        "One parameter text" - {
-            val param = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun(one text) returns text language plpgsql as
-                $$ begin end;$$;
-                """.trimIndent()
-            ).parameters
-
-            "should have one parameter" {
-                param shouldHaveSize 1
-            }
-
-            "should have first parameter name" {
-                param[0].name shouldBe "one"
-            }
-
-            "should have first parameter type name" {
-                param[0].type.name shouldBe "text"
-            }
-        }
-
-        "Two parameters" - {
-            val param = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun(one text, two int) returns text language plpgsql as
-                $$ begin end;$$;
-                """.trimIndent()
-            ).parameters
-
-            "should have 2 parameters" {
-                param shouldHaveSize 2
-            }
-
-            "should have names" {
-                param[0].name shouldBe "one"
-                param[1].name shouldBe "two"
-            }
-
-            "should have first parameter type name" {
-                param[0].type.name shouldBe "text"
-                param[1].type.name shouldBe "int"
-            }
-        }
-
-        "Escaped parameters name" - {
-            val param = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun("one""or two" text, "#@€" int) returns text language plpgsql as
-                $$ begin end;$$;
-                """.trimIndent()
-            ).parameters
-
-            "should have 2 parameters" {
-                param shouldHaveSize 2
-            }
-
-            "should have names" {
-                param[0].name shouldBe "one\"or two"
-                param[1].name shouldBe "#@€"
-            }
-        }
-        "Parameters with Caps" - {
-            val param = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun("One" text, Two text) returns text language plpgsql as
-                $$ begin end;$$;
-                """.trimIndent()
-            ).parameters
-
-            "should have first parameter name" {
-                param[0].name shouldBe "One"
-                param[1].name shouldBe "two"
-            }
-        }
-
-        "Parameters with type `character varying(255)`" - {
-            val param = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun(one character varying(255)) returns text language plpgsql as
-                $$ begin end;$$;
-                """.trimIndent()
-            ).parameters
-
-            "should have 1 parameters" {
-                param shouldHaveSize 1
-            }
-
-            "should have name" {
-                param[0].name shouldBe "one"
-            }
-
-            "should have type name" {
-                param[0].type.name shouldBe "character varying"
-            }
-
-            "should have type precision" {
-                param[0].type.precision shouldBe 255
-                param[0].type.scale shouldBe null
-            }
-        }
-
-        "Parameters with type `numeric(16, 8)`" - {
-            val param = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun(one numeric(16, 8)) returns text language plpgsql as
-                $$ begin end;$$;
-                """.trimIndent()
-            ).parameters
-
-            "should have 1 parameters" {
-                param shouldHaveSize 1
-            }
-
-            "should have name" {
-                param[0].name shouldBe "one"
-            }
-
-            "should have type name" {
-                param[0].type.name shouldBe "numeric"
-            }
-
-            "should have type precision" {
-                param[0].type.precision shouldBe 16
-            }
-
-            "should have type scale" {
-                param[0].type.scale shouldBe 8
-            }
-        }
-
-        "Parameters with default text" - {
-            val param = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun(one text default 'example') returns text language plpgsql as
-                $$ begin end;$$;
-                """.trimIndent()
-            ).parameters
-
-            "should have 1 parameters" {
-                param shouldHaveSize 1
-            }
-
-            "should have name" {
-                param[0].name shouldBe "one"
-            }
-
-            "should have type name" {
-                param[0].type.name shouldBe "text"
-            }
-
-            "should have default text" {
-                param[0].default shouldBe "'example'"
-            }
-        }
-
-        "Parameters with default int" - {
-            val param = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun(one int DEFAULT 123456 ) returns text language plpgsql as
-                $$ begin end;$$;
-                """.trimIndent()
-            ).parameters
-
-            "should have 1 parameters" {
-                param shouldHaveSize 1
-            }
-
-            "should have name" {
-                param[0].name shouldBe "one"
-            }
-
-            "should have type name" {
-                param[0].type.name shouldBe "int"
-            }
-
-            "should have default text" {
-                param[0].default shouldBe "123456"
-            }
-        }
-
-        "Parameters with multiple default and equal" - {
-            val param = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun(one int DEFAULT 123456 , two text default 'hello', three text = '654') returns text language plpgsql as
-                $$ begin end;$$;
-                """.trimIndent()
-            ).parameters
-
-            "should have 3 parameters" {
-                param shouldHaveSize 3
-            }
-
-            "should have name" {
-                param[0].name shouldBe "one"
-                param[1].name shouldBe "two"
-                param[2].name shouldBe "three"
-            }
-
-            "should have type name" {
-                param[0].type.name shouldBe "int"
-                param[1].type.name shouldBe "text"
-                param[2].type.name shouldBe "text"
-            }
-
-            "should have default text" {
-                param[0].default shouldBe "123456"
-                param[1].default shouldBe "'hello'"
-                param[2].default shouldBe "'654'"
-            }
-        }
-
-        "parameters with IN OUT INOUT" - {
-            val param = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun(in one text, inout two text, out three text, four text) language plpgsql as
-                $$ begin end;$$;
-                """.trimIndent()
-            ).parameters
-
-            "should have 4 parameters" {
-                param shouldHaveSize 4
-            }
-
-            "should have parameter name" {
-                param[0].name shouldBe "one"
-                param[1].name shouldBe "two"
-                param[2].name shouldBe "three"
-                param[3].name shouldBe "four"
-            }
-
-            "should have parameter type name" {
-                param[0].type.name shouldBe "text"
-                param[1].type.name shouldBe "text"
-                param[2].type.name shouldBe "text"
-            }
-
-            "should have parameter direction" {
-                param[0].direction shouldBe IN
-                param[1].direction shouldBe INOUT
-                param[2].direction shouldBe OUT
-                param[3].direction shouldBe IN
-            }
-        }
-
-        "Parameters with type array of numeric" - {
-            val param = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun(one numeric(10, 2)[]) language plpgsql as
-                $$ begin end;$$;
-                """.trimIndent()
-            ).parameters
-
-            "should have 1 parameters" {
-                param shouldHaveSize 1
-            }
-
-            "should have parameter name" {
-                param[0].name shouldBe "one"
-            }
-
-            "should have parameter type is array" {
-                param[0].type.isArray shouldBe true
-            }
-
-            "should have parameter type name" {
-                param[0].type.name shouldBe "numeric"
-            }
-
-            "should have parameter type precision" {
-                param[0].type.precision shouldBe 10
-            }
-
-            "should have parameter type scale" {
-                param[0].type.scale shouldBe 2
-            }
-        }
-
-        "Parameters with type array of text" - {
-            val param = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun(one text[], two int[], three text) language plpgsql as
-                $$ begin end;$$;
-                """.trimIndent()
-            ).parameters
-
-            "should have 2 parameters" {
-                param shouldHaveSize 3
-            }
-
-            "should have parameter name" {
-                param[0].name shouldBe "one"
-                param[1].name shouldBe "two"
-                param[2].name shouldBe "three"
-            }
-
-            "should have parameter type is array" {
-                param[0].type.isArray shouldBe true
-                param[1].type.isArray shouldBe true
-                param[2].type.isArray shouldBe false
-            }
-
-            "should have parameter type name" {
-                param[0].type.name shouldBe "text"
-                param[1].type.name shouldBe "int"
-                param[2].type.name shouldBe "text"
-            }
-
-            "should have parameter direction" {
-                param[0].direction shouldBe IN
-                param[1].direction shouldBe IN
-                param[2].direction shouldBe IN
-            }
-        }
-
-        "Parameters with type array multidimensional of text" - {
-            val param = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun(one text[][]) language plpgsql as
-                $$ begin end;$$;
-                """.trimIndent()
-            ).parameters
-
-            "should have parameter type is array" {
-                param[0].type.isArray shouldBe true
-            }
-
-            "should have parameter type name" {
-                param[0].type.name shouldBe "text"
-            }
-        }
-
-        "Parameters with type fixed size array" - {
-            val param = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun(one text[45], two text[1][]) language plpgsql as
-                $$ begin end;$$;
-                """.trimIndent()
-            ).parameters
-
-            "should have parameter type is array" {
-                param[0].type.isArray shouldBe true
-                param[1].type.isArray shouldBe true
-            }
-
-            "should have parameter type name" {
-                param[0].type.name shouldBe "text"
-                param[1].type.name shouldBe "text"
-            }
-
-            "should return the type with array" {
-                param[0].type.toString() shouldBe "text[45]"
-                param[1].type.toString() shouldBe "text[1][]"
-            }
-
-            "should return the type name" {
-                param[0].toString() shouldBe "in one text[45]"
-                param[1].toString() shouldBe "in two text[1][]"
-            }
-        }
-    }
-
-    "Function Returns" - {
-        "should return the type text" {
-            val returns = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun() returns text language plpgsql as 
-                $$ begin; end$$;
-                """.trimIndent()
-            ).returns
-
-            returns shouldBeInstanceOf Primitive::class
-            returns.definition shouldBe "text"
-            returns.isSetOf shouldBe false
-        }
-
-        "should return the type character varying" {
-            val returns = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun() returns character varying language plpgsql as 
-                $$ begin; end$$;
-                """.trimIndent()
-            ).returns
-
-            returns shouldBeInstanceOf Primitive::class
-            returns.definition shouldBe "character varying"
-            returns.isSetOf shouldBe false
-        }
-
-        "should return the type character varying(255)" {
-            val returns = parseFunction(
-                // language=PostgreSQL
-                """
-                create or replace function myfun() returns character varying(255) language plpgsql as 
-                $$ begin; end$$;
-                """.trimIndent()
-            ).returns
-
-            returns shouldBeInstanceOf Primitive::class
-            returns.definition shouldBe "character varying(255)"
-            returns.isSetOf shouldBe false
-        }
-    }
-
-//    "function returns" - {
-//        "should return the type text if function return text" {
-//            Function(
-//                // language=PostgreSQL
-//                """
-//                create or replace function test001() returns text language plpgsql as
-//                $$ begin; end$$;
-//                """.trimIndent()
-//            ).returns shouldBe "text"
-//        }
-//
-//        "return null if function return void" {
-//            Function(
-//                // language=PostgreSQL
-//                """
-//                create or replace function test001() returns void language plpgsql as
-//                $$ begin; end$$;
-//                """.trimIndent()
-//            ).returns shouldBe null
-//        }
-//    }
-//
-//    "Parameters" - {
-//        "One parameter text" - {
-//            val param = Function(
-//                // language=PostgreSQL
-//                """
-//                create or replace function myfun(
-//                    one text
-//                ) returns text language plpgsql as
-//                $$ begin end;$$;
-//                """.trimIndent()
-//            ).parameters
-//
-//            "Function must have one parameter" {
-//                param shouldHaveSize 1
-//            }
-//
-//            "The parameter must be in lower case" {
-//                param.getOrNull(0)?.name shouldBe "one"
-//            }
-//        }
-//    }
-//
-//    "parameters" - {
-//        val param = Function(
-//            // language=PostgreSQL
-//            """
-//            create or replace function myfun(
-//                one text,
-//                "Two" INTEGER default 5,
-//                "Three ""and"" half" character varying = 'Yes',
-//                Three_and_more character varying(255) default 'Hello',
-//                dot point default '(1, 2)'::point,
-//                num NUMERIC(10, 3) default 123.654,
-//                arr01 text[] default '{hello, world, "and others", and\ more, "with \", ], [ , ) and as $$ in text"}'::text[],
-//                arr02 "point"[] default array['(1, 2)'::point, '(7, 12)'::point]::point[],
-//                arr03 text[] default array[
-//                    'text01',
-//                    'text02"([,#-',
-//                    null
-//                    ],
-//                last "text" default 'Hi'
-//            ) returns text language plpgsql as
-//            $$ begin end;$$;
-//            """.trimIndent()
-//        ).parameters
-//
-//        "count must be correct" {
-//            param shouldHaveSize 10
-//        }
-//
-//        "name" - {
-//            "in lower case" {
-//                param.getOrNull(0)?.name shouldBe "one"
-//            }
-//            "in camel case with double quote" {
-//                param.getOrNull(1)?.name shouldBe "Two"
-//            }
-//            "with spaces and double quote" {
-//                param.getOrNull(2)?.name shouldBe "Three \"and\" half"
-//            }
-//            "in snake_case" {
-//                param.getOrNull(3)?.name shouldBe "three_and_more"
-//            }
-//            "with numbers" {
-//                param.getOrNull(5)?.name shouldBe "arr01"
-//            }
-//        }
-//
-//        "type" - {
-//            "text in lower case" {
-//                param.getOrNull(0)?.type shouldBe "text"
-//            }
-//            "integer in UPPER case" {
-//                param.getOrNull(1)?.type shouldBe "integer"
-//            }
-//            "character varying in two word" {
-//                param.getOrNull(2)?.type shouldBe "character varying"
-//            }
-//            "character varying with max size" - {
-//                "dont return the scale type in name" {
-//                    param.getOrNull(3)?.type shouldBe "character varying"
-//                }
-//                "return the correct size" {
-//                    param.getOrNull(3)?.type?.precision shouldBe 255
-//                }
-//            }
-//            "numeric with precision and scale" - {
-//                "dont return the precision and scale type in name" {
-//                    param.getOrNull(5)?.type shouldBe "numeric"
-//                }
-//                "return the correct precision" {
-//                    param.getOrNull(5)?.type?.precision shouldBe 10
-//                }
-//                "return the correct scale" {
-//                    param.getOrNull(5)?.type?.scale shouldBe 3
-//                }
-//            }
-//            "array of text" {
-//                param.getOrNull(7)?.type shouldBe "text[]"
-//            }
-//        }
-//        "default" - {
-//            "with array of composite type Point" - {
-//                """must return "arr02" at name""" {
-//                    param.getOrNull(7)?.name shouldBe "arr02"
-//                }
-//                """must return "point[]" at type""" {
-//                    param.getOrNull(7)?.type shouldBe "point[]"
-//                }
-//                """must return "array[(1, 2)::point, (7, 12)::point]::point[]" at default""" {
-//                    param.getOrNull(7)?.default shouldBe "array[(1, 2)::point, (7, 12)::point]::point[]"
-//                }
-//            }
-//        }
-//    }
-})

src/test/kotlin/fr/postgresjson/functionGenerator/FunctionGeneratorTest.kt

@@ -1,97 +0,0 @@
-package fr.postgresjson.functionGenerator
-
-import fr.postgresjson.definition.parse.parseFunction
-import io.kotest.core.Tag
-import io.kotest.core.annotation.Ignored
-import io.kotest.core.spec.style.StringSpec
-import org.amshove.kluent.`should be equal to`
-
-@Ignored
-class FunctionGeneratorTest : StringSpec({
-    tags(Tag("Generator"))
-    val functionDirectory = this::class.java.getResource("/sql/function/Test")!!.toURI()
-    val generator = FunctionGenerator(functionDirectory)
-
-    "generate function with input object and output object" {
-        val functionSql = """
-            |create or replace function test_function_object (inout resource json)
-            |language plpgsql
-            |as
-            |$$
-            |begin
-            |    resource = json_build_object('id', '1e5f5d41-6d14-4007-897b-0ed2616bec96', 'name', 'changedName');
-            |end;
-            |$$
-        """.trimMargin()
-
-        val expectedGenerated = """
-            |package fr.postgresjson.functionGenerator.generated
-            |
-            |import com.fasterxml.jackson.core.type.TypeReference
-            |import fr.postgresjson.connexion.Requester
-            |
-            |inline fun <reified E: Any, S: Any?> Requester.testFunctionObject(resource: S): E? {
-            |    return getFunction("test_function_object")
-            |        .execute<E>(object : TypeReference<E>() {}, mapOf("resource" to resource))
-            |}
-        """.trimMargin()
-
-        generator.generate(parseFunction(functionSql)) `should be equal to` expectedGenerated
-    }
-
-    "generate function with return void" {
-        val functionSql = """
-            |create or replace function test_function_void (name text default 'plop') returns void
-            |language plpgsql
-            |as
-            |$$
-            |begin
-            |    perform 1;
-            |end;
-            |$$;
-        """.trimMargin()
-
-        val expectedGenerated = """
-            |package fr.postgresjson.functionGenerator.generated
-            |
-            |import fr.postgresjson.connexion.Requester
-            |
-            |fun Requester.testFunctionVoid(name: String = "plop"): Unit {
-            |    getFunction("test_function_void")
-            |        .exec(mapOf("name" to name))
-            |}
-        """.trimMargin()
-
-        generator.generate(parseFunction(functionSql)) `should be equal to` expectedGenerated
-    }
-
-    "generate function with multiple args and defaults" {
-        val functionSql = """
-            |create or replace function test_function_multiple (name text default 'plop', in hi text default 'hello', out result json)
-            |language plpgsql
-            |as
-            |$$
-            |begin
-            |    result = json_build_array(
-            |        json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', name),
-            |        json_build_object('id', '8d20abb0-7f77-4b6c-9991-44acd3c88faa', 'name', hi)
-            |    );
-            |end;
-            |$$
-        """.trimMargin()
-
-        val expectedGenerated = """
-            |package fr.postgresjson.functionGenerator.generated
-            |
-            |import com.fasterxml.jackson.core.type.TypeReference
-            |import fr.postgresjson.connexion.Requester
-            |
-            |inline fun <reified E: Any> Requester.testFunctionMultiple(name: String = "plop", hi: String = "hello"): E? {
-            |    return getFunction("test_function_multiple")
-            |        .execute<E>(object : TypeReference<E>() {}, mapOf("name" to name, "hi" to hi))
-            |}
-        """.trimMargin()
-
-        generator.generate(parseFunction(functionSql)) `should be equal to` expectedGenerated
-    }
-})

src/test/resources/fixtures/init.sql

@@ -8,7 +8,7 @@ create schema if not exists public;
 
 create table if not exists test
 (
-    id uuid not null
+    id serial not null
         constraint test_pk
             primary key,
     name text
@@ -16,24 +16,24 @@ create table if not exists test
 
 create table if not exists test2
 (
-    id uuid not null,
+    id serial not null,
     title text,
-    test_id uuid
+    test_id integer
         constraint test2_test_id_fk
             references test
 );
 
-INSERT INTO test (id, name) VALUES ('1e5f5d41-6d14-4007-897b-0ed2616bec96', 'plop') ON CONFLICT DO NOTHING;
-INSERT INTO test2 (id, title, test_id) VALUES ('1e5f5d41-6d14-4007-897b-0ed2616bec96', 'plop', '1e5f5d41-6d14-4007-897b-0ed2616bec96') ON CONFLICT DO NOTHING;
-INSERT INTO test2 (id, title, test_id) VALUES ('829b1a29-5db8-47f9-9562-961c561ac528', 'plip', '1e5f5d41-6d14-4007-897b-0ed2616bec96') ON CONFLICT DO NOTHING;
-INSERT INTO test2 (id, title, test_id) VALUES ('457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'ttt', null) ON CONFLICT DO NOTHING;
+INSERT INTO test (id, name) VALUES (1, 'plop') ON CONFLICT DO NOTHING;
+INSERT INTO test2 (id, title, test_id) VALUES (1, 'plop', 1) ON CONFLICT DO NOTHING;
+INSERT INTO test2 (id, title, test_id) VALUES (2, 'plip', 1) ON CONFLICT DO NOTHING;
+INSERT INTO test2 (id, title, test_id) VALUES (3, 'ttt', null) ON CONFLICT DO NOTHING;
 
 CREATE OR REPLACE FUNCTION test_function (name text default 'plop', IN hi text default 'hello', out result json)
     LANGUAGE plpgsql
 AS
 $$
 BEGIN
-    result = json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', name);
+    result = json_build_object('id', 3, 'name', name);
 END;
 $$;
 
@@ -44,8 +44,8 @@ AS
 $$
 BEGIN
     result = json_build_array(
-            json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', name),
-            json_build_object('id', '8d20abb0-7f77-4b6c-9991-44acd3c88faa', 'name', hi)
+            json_build_object('id', 3, 'name', name),
+            json_build_object('id', 4, 'name', hi)
         );
 END;
 $$;
@@ -56,8 +56,8 @@ AS
 $$
 BEGIN
     SELECT json_build_array(
-                   json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', name::text),
-                   json_build_object('id', '8d20abb0-7f77-4b6c-9991-44acd3c88faa', 'name', name::text || '-2')
+                   json_build_object('id', 3, 'name', name::text),
+                   json_build_object('id', 4, 'name', name::text || '-2')
                ),
            10
     INTO result, total
@@ -70,11 +70,11 @@ CREATE OR REPLACE FUNCTION test_function_object (inout resource json)
 AS
 $$
 BEGIN
-    resource = json_build_object('id', '1e5f5d41-6d14-4007-897b-0ed2616bec96', 'name', 'changedName');
+    resource = json_build_object('id', 1, 'name', 'changedName');
 END;
 $$;
 
-CREATE OR REPLACE FUNCTION test_function_void (name text default 'plop') returns void
+CREATE OR REPLACE FUNCTION function_void (name text default 'plop') returns void
     LANGUAGE plpgsql
 AS
 $$

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

@@ -0,0 +1,8 @@
+CREATE OR REPLACE FUNCTION test_function (name text default 'plop', IN hi text default 'hello', out result json)
+LANGUAGE plpgsql
+AS
+$$
+BEGIN
+    result = json_build_object('id', 3, 'name', name);
+END;
+$$

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

@@ -0,0 +1,8 @@
+CREATE OR REPLACE FUNCTION test_function_object (inout resource json)
+LANGUAGE plpgsql
+AS
+$$
+BEGIN
+    resource = json_build_object('id', 1, 'name', 'changedName');
+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/Test/test_function.sql

@@ -1,8 +0,0 @@
-create or replace function test_function(name text default 'plop', in hi text default 'hello', out result json)
-    language plpgsql
-as
-$$
-begin
-    result = json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', name);
-end;
-$$

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

@@ -1,34 +0,0 @@
-create or replace function test_function_multiparam(
-    name varchar(45) default 'plop',
-    numeric(4, 5),
-    num float(5),
-    num2 timestamp without time zone default '2002-01-01T00:00:00'::timestamp,
-    num3 int,
-    num4 integer,
-    num5 smallint,
-    num6 bigint,
-    num7 decimal,
-    num8 decimal(4, 6),
-    num9 real,
-    num10 double precision,
-    num11 smallserial,
-    num12 serial,
-    num13 bigserial,
-    num14 serial,
-    num15 money,
-    num16 character varying(789),
-    num16b character varying(789) default 'abc',
-    num16c character varying default 'abc',
-    num17 character(56),
-    num18 char(2),
-    num19 any,
-    num20 anyelement,
-    num21 anyarray
-)
-    language plpgsql
-as
-$$
-begin
-    perform 1;
-end;
-$$;

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

@@ -1,11 +1,11 @@
-create or replace function test_function_multiple(name text default 'plop', in hi text default 'hello', out result json)
-    language plpgsql
-as
+CREATE OR REPLACE FUNCTION test_function_multiple (name text default 'plop', IN hi text default 'hello', out result json)
+LANGUAGE plpgsql
+AS
 $$
-begin
+BEGIN
     result = json_build_array(
-            json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', name),
-            json_build_object('id', '8d20abb0-7f77-4b6c-9991-44acd3c88faa', 'name', hi)
-        );
-end;
+        json_build_object('id', 3, 'name', name),
+        json_build_object('id', 4, 'name', hi)
+    );
+END;
 $$

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

@@ -1,8 +0,0 @@
-create or replace function test_function_object(inout resource json)
-    language plpgsql
-as
-$$
-begin
-    resource = json_build_object('id', '1e5f5d41-6d14-4007-897b-0ed2616bec96', 'name', 'changedName');
-end;
-$$

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

@@ -0,0 +1,14 @@
+CREATE OR REPLACE FUNCTION test_function_paginated (name text default 'plop', IN "limit" int default 10, IN "offset" int default 0, out result json, out total int)
+LANGUAGE plpgsql
+AS
+$$
+BEGIN
+    SELECT json_build_array(
+        json_build_object('id', 3, 'name', name::text),
+        json_build_object('id', 4, 'name', name::text || '-2')
+    ),
+    10
+    INTO result, total
+    LIMIT "limit" OFFSET "offset";
+END;
+$$

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

@@ -1,8 +0,0 @@
-create or replace function test_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

@@ -3,6 +3,6 @@ CREATE OR REPLACE FUNCTION test_function_duplicate (name text default 'plop') re
 AS
 $$
 BEGIN
-    return json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', name);
+    return json_build_object('id', 3, 'name', name);
 END;
 $$

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

@@ -1,4 +0,0 @@
-SELECT json_build_array(
-   json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', :name::text),
-   json_build_object('id', '6085c12e-e94d-4ae1-b7ad-23acc7a82a98', 'name', :name::text || '-2')
-)

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

@@ -1 +0,0 @@
-SELECT :first::text as "firstName", :second::text as "secondName";

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

@@ -1,4 +0,0 @@
-SELECT json_build_array(
-   json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', ?::text),
-   json_build_object('id', '6085c12e-e94d-4ae1-b7ad-23acc7a82a98', 'name', ?::text || '-2')
-)

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

@@ -1 +0,0 @@
-SELECT :name::text as "firstName", :name::text as "secondName";

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

@@ -1 +1 @@
-select json_build_object('id', '829b1a29-5db8-47f9-9562-961c561ac528', 'name', 'test');
+select json_build_object('id', 2, 'name', 'test');

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

@@ -1 +1 @@
-select json_build_object('id', '829b1a29-5db8-47f9-9562-961c561ac528', 'name', :name::text), 'plop'::text as other;
+select json_build_object('id', 2, 'name', :name::text), 'plop'::text as other;

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

@@ -1,5 +1,5 @@
 SELECT json_build_array(
-   json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', :name::text),
-   json_build_object('id', '6085c12e-e94d-4ae1-b7ad-23acc7a82a98', 'name', :name::text || '-2')
+   json_build_object('id', 3, 'name', :name::text),
+   json_build_object('id', 4, 'name', :name::text || '-2')
 ), 10 as total
 LIMIT :limit OFFSET :offset