nesoi 3.0.0 → 3.0.3

package/lib/adapters/postgres/src/postgres.cli.js

@@ -3,29 +3,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresCLI = exports.cmd_migrate_one_up = exports.cmd_migrate_up = exports.cmd_make_migrations = exports.cmd_status = exports.cmd_create_db = exports.cmd_tables = exports.cmd_check = void 0;
+exports.PostgresCLI = exports.cmd_import_csv = exports.cmd_query = exports.cmd_migrate_one_down = exports.cmd_migrate_down = exports.cmd_migrate_one_up = exports.cmd_migrate_up = exports.cmd_make_migrations = exports.cmd_status = exports.cmd_create_db = exports.cmd_tables = exports.cmd_check = void 0;
 const cli_adapter_1 = require("../../../engine/cli/cli_adapter");
 const database_1 = require("./migrator/database");
 const ui_1 = __importDefault(require("../../../engine/cli/ui"));
 const migrator_1 = require("./migrator");
+const daemon_1 = require("../../../engine/daemon");
 const runner_1 = require("./migrator/runner");
+const postgres_bucket_adapter_1 = require("./postgres.bucket_adapter");
+const csv_1 = require("./migrator/csv");
 class cmd_check extends cli_adapter_1.CLICommand {
     constructor(provider) {
-        super('check', 'check', 'Check if the connection to PostgreSQL is working properly');
+        super('any', 'check', 'check', 'Check if the connection to PostgreSQL is working properly');
         this.provider = provider;
     }
-    async run() {
+    async run(daemon) {
         const res = await database_1.Database.checkConnection(this.provider.sql);
         if (res == true)
             ui_1.default.result('ok', 'Connection to PostgreSQL working.');
         else
             ui_1.default.result('error', 'Connection to PostgreSQL not working.', res);
+        await migrator_1.Migrator.prepare(daemon, this.provider.sql);
     }
 }
 exports.cmd_check = cmd_check;
 class cmd_tables extends cli_adapter_1.CLICommand {
     constructor(provider) {
-        super('tables', 'tables', 'List the tables present on the database');
+        super('any', 'tables', 'tables', 'List the tables present on the database');
         this.provider = provider;
     }
     async run() {
@@ -36,10 +40,10 @@ class cmd_tables extends cli_adapter_1.CLICommand {
 exports.cmd_tables = cmd_tables;
 class cmd_create_db extends cli_adapter_1.CLICommand {
     constructor(provider) {
-        super('create db', 'create db( NAME)', 'Create the database used by the application', /(\w*)/, ['name']);
+        super('any', 'create db', 'create db( NAME)', 'Create the database used by the application', /(\w*)/, ['name']);
         this.provider = provider;
     }
-    async run(_, $) {
+    async run(daemon, $) {
         let name = $.name;
         const config = this.provider.config?.connection;
         if (!name) {
@@ -56,12 +60,13 @@ class cmd_create_db extends cli_adapter_1.CLICommand {
         catch (e) {
             ui_1.default.result('error', `Failed to create database ${name}`, e);
         }
+        await migrator_1.Migrator.prepare(daemon, this.provider.sql);
     }
 }
 exports.cmd_create_db = cmd_create_db;
 class cmd_status extends cli_adapter_1.CLICommand {
     constructor(provider) {
-        super('status', 'status', 'Show the status of migrations on the current database');
+        super('any', 'status', 'status', 'Show the status of migrations on the current database');
         this.provider = provider;
     }
     async run(daemon) {
@@ -72,7 +77,7 @@ class cmd_status extends cli_adapter_1.CLICommand {
 exports.cmd_status = cmd_status;
 class cmd_make_migrations extends cli_adapter_1.CLICommand {
     constructor(provider) {
-        super('make migrations', 'make migrations( TAG)', 'Generate migrations for the bucket(s) using PostgresBucketAdapter', /(\w*)/, ['tag']);
+        super('any', 'make migrations', 'make migrations( TAG)', 'Generate migrations for the bucket(s) using PostgresBucketAdapter', /(\w*)/, ['tag']);
         this.provider = provider;
     }
     async run(daemon, $) {
@@ -88,7 +93,7 @@ class cmd_make_migrations extends cli_adapter_1.CLICommand {
 exports.cmd_make_migrations = cmd_make_migrations;
 class cmd_migrate_up extends cli_adapter_1.CLICommand {
     constructor(provider) {
-        super('migrate up', 'migrate up', 'Run ALL the pending migrations up (batch)');
+        super('any', 'migrate up', 'migrate up', 'Run ALL the pending migrations up (batch)');
         this.provider = provider;
     }
     async run(daemon) {
@@ -98,7 +103,7 @@ class cmd_migrate_up extends cli_adapter_1.CLICommand {
 exports.cmd_migrate_up = cmd_migrate_up;
 class cmd_migrate_one_up extends cli_adapter_1.CLICommand {
     constructor(provider) {
-        super('migrate one up', 'migrate one up', 'Run ONE pending migration up');
+        super('any', 'migrate one up', 'migrate one up', 'Run ONE pending migration up');
         this.provider = provider;
     }
     async run(daemon) {
@@ -106,6 +111,57 @@ class cmd_migrate_one_up extends cli_adapter_1.CLICommand {
     }
 }
 exports.cmd_migrate_one_up = cmd_migrate_one_up;
+class cmd_migrate_down extends cli_adapter_1.CLICommand {
+    constructor(provider) {
+        super('any', 'migrate down', 'migrate down', 'Rollback the last batch of migrations');
+        this.provider = provider;
+    }
+    async run(daemon) {
+        await runner_1.MigrationRunner.down(daemon, this.provider.sql, 'batch');
+    }
+}
+exports.cmd_migrate_down = cmd_migrate_down;
+class cmd_migrate_one_down extends cli_adapter_1.CLICommand {
+    constructor(provider) {
+        super('any', 'migrate one down', 'migrate one down', 'Rollback the last migration');
+        this.provider = provider;
+    }
+    async run(daemon) {
+        await runner_1.MigrationRunner.down(daemon, this.provider.sql, 'one');
+    }
+}
+exports.cmd_migrate_one_down = cmd_migrate_one_down;
+class cmd_query extends cli_adapter_1.CLICommand {
+    constructor(provider) {
+        super('any', 'query', 'query', 'Run a SQL query on the database server');
+        this.provider = provider;
+    }
+    async run() {
+        const query = await ui_1.default.question('SQL');
+        const res = await this.provider.sql.unsafe(query);
+        console.log(res);
+    }
+}
+exports.cmd_query = cmd_query;
+class cmd_import_csv extends cli_adapter_1.CLICommand {
+    constructor(provider) {
+        super('any', 'import csv', 'import csv PATH', 'Run a SQL query on the database server', /(.+)/, ['path']);
+        this.provider = provider;
+    }
+    async run(daemon, input) {
+        const buckets = daemon_1.Daemon.getModules(daemon)
+            .map(module => Object.values(module.buckets)
+            .filter(bucket => bucket.adapter instanceof postgres_bucket_adapter_1.PostgresBucketAdapter)
+            .map(bucket => ({
+            name: `${module.name}::${bucket.schema.name}`,
+            tableName: bucket.adapter.tableName
+        })))
+            .flat(1);
+        const bucket = await ui_1.default.select('Bucket', buckets, b => b.name);
+        await csv_1.CSV.import(this.provider.sql, bucket.tableName, input.path);
+    }
+}
+exports.cmd_import_csv = cmd_import_csv;
 class PostgresCLI extends cli_adapter_1.CLIAdapter {
     constructor(provider) {
         super();
@@ -118,6 +174,10 @@ class PostgresCLI extends cli_adapter_1.CLIAdapter {
             'make migrations': new cmd_make_migrations(provider),
             'migrate up': new cmd_migrate_up(provider),
             'migrate one up': new cmd_migrate_one_up(provider),
+            'migrate down': new cmd_migrate_down(provider),
+            'migrate one down': new cmd_migrate_one_down(provider),
+            'query': new cmd_query(provider),
+            'import csv': new cmd_import_csv(provider),
         };
     }
 }

package/lib/adapters/postgres/src/postgres.config.d.ts

@@ -0,0 +1,5 @@
+import { BucketAdapterConfig } from "../../../elements/entities/bucket/adapters/bucket_adapter";
+import postgres from 'postgres';
+export type PostgresConfig = BucketAdapterConfig & {
+    connection?: postgres.Options<any>;
+};

package/lib/adapters/postgres/src/postgres.config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/adapters/postgres/src/postgres.nql.d.ts

@@ -1,12 +1,16 @@
 import { AnyTrxNode } from "../../../engine/transaction/trx_node";
 import { NQLRunner } from "../../../elements/entities/bucket/query/nql_engine";
-import { NQL_Part } from "../../../elements/entities/bucket/query/nql.schema";
+import { NQL_Pagination, NQL_Part } from "../../../elements/entities/bucket/query/nql.schema";
 import postgres from 'postgres';
 type Obj = Record<string, any>;
 export declare class PostgresNQLRunner extends NQLRunner {
     protected sql?: postgres.Sql<any>;
     constructor();
-    private guard;
-    run(trx: AnyTrxNode, part: NQL_Part, params: Obj): Promise<any>;
+    run(trx: AnyTrxNode, part: NQL_Part, params: Obj, pagination?: NQL_Pagination): Promise<{
+        data: Obj[];
+        count: number | undefined;
+        page: number | undefined;
+        perPage: number | undefined;
+    }>;
 }
 export {};

package/lib/adapters/postgres/src/postgres.nql.js

@@ -9,52 +9,84 @@ class PostgresNQLRunner extends nql_engine_1.NQLRunner {
     constructor() {
         super();
     }
-    guard(sql) {
-        return (template, ...params) => {
-            return sql.call(sql, template, ...params).catch(e => {
-                log_1.Log.error('bucket', 'postgres', e.toString(), e);
-                throw new Error('Database error.');
-            });
-        };
-    }
-    async run(trx, part, params) {
+    async run(trx, part, params, pagination) {
         const sql = trx_1.Trx.get(trx, 'sql');
-        const tableName = postgres_bucket_adapter_1.PostgresBucketAdapter.getTableName(trx, part.union.meta);
-        // console.log(NQL_RuleTree.describe(part.union));
+        const { tableName, meta } = postgres_bucket_adapter_1.PostgresBucketAdapter.getTableMeta(trx, part.union.meta);
+        const sql_params = [];
         const _sql = (part) => {
-            return this.guard(sql) `SELECT * FROM ${sql(tableName)} WHERE ${sql.unsafe(_union(part.union))}`;
+            let where = _union(part.union);
+            if (where) {
+                where = 'WHERE ' + where;
+            }
+            const sql_str = `FROM ${tableName} ${where}`;
+            return sql_str;
         };
         const _union = (union) => {
-            return `(${union.inters.map(i => _inter(i)).join(' OR ')})`;
+            const inters = union.inters.map(i => _inter(i)).filter(r => !!r).join(' OR ');
+            if (!inters)
+                return '';
+            return `(${inters})`;
         };
         const _inter = (inter) => {
-            return `(${inter.rules.map(r => (('value' in r) ? _rule(r) : _union(r))).join(' AND ')})`;
+            const rules = inter.rules.map(r => (('value' in r) ? _rule(r) : _union(r))).filter(r => !!r).join(' AND ');
+            if (!rules)
+                return '';
+            return `(${rules})`;
         };
         const _rule = (rule) => {
             // Replace '.' of fieldpath with '->' (JSONB compatible)
-            // TODO: process '.*'
-            const column = rule.fieldpath.replace(/\./g, '->');
-            const op = {
+            let column = rule.fieldpath.replace(/\./g, '->');
+            // TODO: handle '.#'
+            // Special case: "present" operation
+            if (rule.op === 'present') {
+                if (rule.not) {
+                    return `"${column}" IS NULL`;
+                }
+                else {
+                    return `"${column}" IS NOT NULL`;
+                }
+            }
+            // Fetch value
+            let value;
+            if ('static' in rule.value) {
+                value = rule.value.static;
+            }
+            else if ('param' in rule.value) {
+                value = params[rule.value.param]; // TODO: deal with param[]
+            }
+            else {
+                throw new Error('Sub-queries not implemented yet.'); // TODO: subquery
+            }
+            // Don't add condition if value is null
+            if (value === undefined) {
+                return '';
+            }
+            // Translate operation
+            let op = {
                 '==': '=',
                 '<': '<',
                 '>': '>',
                 '<=': '<=',
                 '>=': '>=',
-                'in': 'in',
-                'contains': 'like',
-                'contains_any': 'like',
-                'present': ''
+                'in': 'IN',
+                'contains': 'LIKE',
+                'contains_any': '' // TODO
             }[rule.op];
-            let value;
-            if ('static' in rule.value)
-                value = rule.value.static;
-            else if ('param' in rule.value)
-                value = params[rule.value.param]; // TODO: deal with param[]
-            else {
-                // TODO: subquery
-                throw new Error('Sub-queries not implemented yet.');
+            // Apply case insensitive modifier
+            if (rule.case_i) {
+                if (rule.op === '==') {
+                    column = `LOWER(${column})`;
+                }
+                else if (rule.op === 'contains') {
+                    op = 'ILIKE';
+                }
             }
-            return `${column} ${op} ${value}`;
+            // Special case: "contains" operation
+            if (rule.op === 'contains') {
+                value = `%${value}%`;
+            }
+            sql_params.push(value);
+            return `${rule.not ? 'NOT ' : ''} "${column}" ${op} $${sql_params.length}`;
         };
         // Debug
         // const str = await _sql(part).describe().catch(e => {
@@ -62,8 +94,30 @@ class PostgresNQLRunner extends nql_engine_1.NQLRunner {
         // })
         // console.log((str as any).string);
         // End of Debug
-        const out = await _sql(part);
-        return Object.values(out);
+        const sql_str = await _sql(part);
+        const order = part.union.order;
+        const order_str = `ORDER BY ${order?.by || meta.updated_at} ${order?.dir === 'asc' ? 'ASC' : 'DESC'}`;
+        let limit_str = '';
+        if (pagination?.page || pagination?.perPage) {
+            const limit = pagination.perPage || 10;
+            const offset = ((pagination.page || 1) - 1) * limit;
+            limit_str = `OFFSET ${offset} LIMIT ${limit}`;
+        }
+        let count = undefined;
+        if (pagination?.count) {
+            const res_count = await sql.unsafe(`SELECT count(*) ${sql_str}`, sql_params);
+            count = parseInt(res_count[0].count);
+        }
+        const data = await sql.unsafe(`SELECT * ${sql_str} ${order_str} ${limit_str}`, sql_params).catch(e => {
+            log_1.Log.error('bucket', 'postgres', e.toString(), e);
+            throw new Error('Database error.');
+        });
+        return {
+            data,
+            count,
+            page: pagination?.page,
+            perPage: pagination?.perPage,
+        };
     }
 }
 exports.PostgresNQLRunner = PostgresNQLRunner;

package/lib/adapters/postgres/src/postgres.provider.d.ts

@@ -0,0 +1,18 @@
+import postgres from 'postgres';
+import { PostgresNQLRunner } from './postgres.nql';
+import { AnyTrx } from "../../../engine/transaction/trx";
+import { TrxEngineWrapFn } from "../../../engine/transaction/trx_engine.config";
+import { PostgresConfig } from './postgres.config';
+export declare class PostgresProvider {
+    config?: PostgresConfig | undefined;
+    static make<Name extends string>(name: Name, config?: PostgresConfig): {
+        name: Name;
+        libPaths: string[];
+        up: () => PostgresProvider;
+        down: () => void;
+    };
+    sql: postgres.Sql<any>;
+    nql: PostgresNQLRunner;
+    private constructor();
+    static wrap(provider: string): (trx: AnyTrx, fn: TrxEngineWrapFn<any, any>, providers: Record<string, any>) => Promise<import("../../../engine/transaction/trx_node").TrxNodeStatus>;
+}

package/lib/adapters/postgres/src/postgres.provider.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresProvider = void 0;
+const log_1 = require("../../../engine/util/log");
+const date_1 = require("../../../engine/data/date");
+const datetime_1 = require("../../../engine/data/datetime");
+const decimal_1 = require("../../../engine/data/decimal");
+const postgres_nql_1 = require("./postgres.nql");
+const trx_1 = require("../../../engine/transaction/trx");
+const database_1 = require("./migrator/database");
+class PostgresProvider {
+    static make(name, config) {
+        return {
+            name: name,
+            libPaths: [
+                'modules/*/migrations'
+            ],
+            up: () => new PostgresProvider(config),
+            down: () => { }
+        };
+    }
+    constructor(config) {
+        this.config = config;
+        log_1.Log.info('postgres', 'provider', 'Connecting to Postgres database');
+        this.sql = database_1.Database.connect({
+            ...(config?.connection || {}),
+            debug: true,
+            types: {
+                char: {
+                    to: 1042,
+                    from: [1042],
+                    serialize: (val) => val?.trim?.(),
+                    parse: (val) => val?.trim?.()
+                },
+                date: {
+                    to: 1082,
+                    from: [1082],
+                    serialize: (val) => val?.toISO(),
+                    parse: (val) => val ? date_1.NesoiDate.fromISO(val) : undefined
+                },
+                datetime: {
+                    to: 1114,
+                    from: [1114],
+                    serialize: (val) => typeof val === 'string'
+                        ? val
+                        : val?.toISO(),
+                    parse: (val) => datetime_1.NesoiDatetime.fromISO(val?.replace(' ', 'T') + 'Z')
+                },
+                datetime_z: {
+                    to: 1184,
+                    from: [1184],
+                    serialize: (val) => typeof val === 'string'
+                        ? val
+                        : val?.toISO(),
+                    parse: (val) => datetime_1.NesoiDatetime.fromISO(val?.replace(' ', 'T') + 'Z')
+                },
+                decimal: {
+                    to: 1700,
+                    from: [1700],
+                    serialize: (val) => val?.toString(),
+                    parse: (val) => val ? new decimal_1.NesoiDecimal(val) : undefined
+                }
+            }
+        });
+        this.nql = new postgres_nql_1.PostgresNQLRunner();
+    }
+    static wrap(provider) {
+        return (trx, fn, providers) => {
+            const postgres = providers[provider].sql;
+            return postgres.begin(sql => {
+                trx_1.Trx.set(trx.root, 'sql', sql);
+                return fn(trx.root);
+            });
+        };
+    }
+}
+exports.PostgresProvider = PostgresProvider;

package/lib/adapters/postgres/test/postgres.bucket_adapter.test.js

@@ -4,14 +4,20 @@ const mock_1 = require("../../../../tools/joaquin/mock");
 const bucket_builder_1 = require("../../../elements/entities/bucket/bucket.builder");
 const log_1 = require("../../../engine/util/log");
 const inline_app_1 = require("../../../engine/apps/inline.app");
+const postgres_provider_1 = require("../src/postgres.provider");
 const postgres_bucket_adapter_1 = require("../src/postgres.bucket_adapter");
 const migrator_1 = require("../src/migrator");
 const runner_1 = require("../src/migrator/runner");
-const database_1 = require("../src/migrator/database");
+const datetime_1 = require("../../../engine/data/datetime");
 log_1.Log.level = 'warn';
 // TODO: read this from env
 const PostgresConfig = {
-    updatedAtField: 'updated_at',
+    meta: {
+        created_at: 'created_at',
+        created_by: 'created_by',
+        updated_at: 'updated_at',
+        updated_by: 'updated_by',
+    },
     connection: {
         host: 'localhost',
         port: 5432,
@@ -47,7 +53,7 @@ async function setup() {
     const app = new inline_app_1.InlineApp('RUNTIME', [
         bucket
     ])
-        .provider(postgres_bucket_adapter_1.PostgresProvider.make('pg', PostgresConfig))
+        .provider(postgres_provider_1.PostgresProvider.make('pg', PostgresConfig))
         .config.buckets({
         'MODULE': {
             'BUCKET': {
@@ -57,22 +63,20 @@ async function setup() {
     })
         .config.trx({
         'MODULE': {
-            trx: {
-                wrap: postgres_bucket_adapter_1.PostgresProvider.wrap('pg')
-            }
+            wrap: postgres_provider_1.PostgresProvider.wrap('pg')
         }
     });
     // Run test daemon
     daemon = await app.daemon();
     // Prepare database using daemon
     // TODO: encapsulate this
-    // await Migrator.createDatabase('NESOI_TEST', PostgresConfig, { if_exists: 'delete' });
-    const sql = database_1.Database.connect(PostgresConfig.connection);
-    const migrator = await migrator_1.Migrator.prepare(daemon, sql);
+    // await Database.createDatabase('NESOI_TEST', PostgresConfig.connection, { if_exists: 'delete' });
+    const pg = postgres_provider_1.PostgresProvider.make('pg', PostgresConfig).up();
+    const migrator = await migrator_1.Migrator.prepare(daemon, pg.sql);
     const migration = await migrator.generateForBucket('MODULE', 'BUCKET', 'nesoi_test_table');
     if (migration) {
         migration.name = 'postgres.bucket_adapter.test';
-        await runner_1.MigrationRunner.oneUp(daemon, sql, migration);
+        await runner_1.MigrationRunner.injectUp(daemon, pg.sql, migration);
     }
     // migration?.save();
     // await MigrationRunner.up(daemon, 'one', PostgresConfig);
@@ -88,34 +92,50 @@ describe('Postgres Bucket Adapter', () => {
     // })
     describe('CRUD', () => {
         it('create should return unmodified object', async () => {
-            await daemon.trx('MODULE').run(async (trx) => {
+            const response = await daemon.trx('MODULE').run(async (trx) => {
                 // given
                 const BUCKET = trx.bucket('BUCKET');
                 const input = mock.bucket('MODULE', 'BUCKET')
                     .obj({ id: undefined }).raw(daemon);
                 // when
-                const { id, ...obj } = await BUCKET.create(input);
-                // then
-                expect(id).toBeTruthy();
-                expect(obj).toEqual(input);
+                const created = await BUCKET.create(input);
+                return { input, created };
+            });
+            const { input, created: { id, ...obj } } = response.output;
+            // then
+            expect(id).toBeTruthy();
+            expect(obj).toEqual({
+                ...input,
+                created_at: expect.any(datetime_1.NesoiDatetime),
+                updated_at: expect.any(datetime_1.NesoiDatetime),
+                created_by: null,
+                updated_by: null
             });
         });
         it('read should return unmodified object after create', async () => {
-            await daemon.trx('MODULE').run(async (trx) => {
+            const response = await daemon.trx('MODULE').run(async (trx) => {
                 // given
                 const BUCKET = trx.bucket('BUCKET');
                 const input = mock.bucket('MODULE', 'BUCKET')
                     .obj({ id: undefined }).raw(daemon);
                 // when
                 const created = await BUCKET.create(input);
-                const { id, ...obj } = await BUCKET.readOneOrFail(created.id);
-                // then
-                expect(id).toBeTruthy();
-                expect(obj).toEqual(input);
+                const updated = await BUCKET.readOneOrFail(created.id);
+                return { input, updated };
+            });
+            const { input, updated: { id, ...obj } } = response.output;
+            // then
+            expect(id).toBeTruthy();
+            expect(obj).toEqual({
+                ...input,
+                created_at: expect.any(datetime_1.NesoiDatetime),
+                updated_at: expect.any(datetime_1.NesoiDatetime),
+                created_by: null,
+                updated_by: null
             });
         });
         it('update should modify object after insert', async () => {
-            await daemon.trx('MODULE').run(async (trx) => {
+            const response = await daemon.trx('MODULE').run(async (trx) => {
                 // given
                 const BUCKET = trx.bucket('BUCKET');
                 const input1 = mock.bucket('MODULE', 'BUCKET')
@@ -123,20 +143,34 @@ describe('Postgres Bucket Adapter', () => {
                 const input2 = mock.bucket('MODULE', 'BUCKET')
                     .obj({ id: undefined }).raw(daemon);
                 // when
-                const { id: id_create, ...created } = await BUCKET.create(input1);
-                const { id: id_update, ...updated } = await BUCKET.put({
+                const created = await BUCKET.create(input1);
+                const updated = await BUCKET.patch({
                     ...input2,
-                    id: id_create
+                    id: created.id
                 });
-                // then
-                expect(id_create).toBeTruthy();
-                expect(id_update).toEqual(id_create);
-                expect(created).toEqual(input1);
-                expect(updated).toEqual(input2);
+                return { input1, input2, created, updated };
+            });
+            const { input1, input2, created: { id: id_create, ...created }, updated: { id: id_update, ...updated }, } = response.output;
+            // then
+            expect(id_create).toBeTruthy();
+            expect(id_update).toEqual(id_create);
+            expect(created).toEqual({
+                ...input1,
+                created_at: expect.any(datetime_1.NesoiDatetime),
+                updated_at: expect.any(datetime_1.NesoiDatetime),
+                created_by: null,
+                updated_by: null
+            });
+            expect(updated).toEqual({
+                ...input2,
+                created_at: expect.any(datetime_1.NesoiDatetime),
+                updated_at: expect.any(datetime_1.NesoiDatetime),
+                created_by: null,
+                updated_by: null
             });
         });
         it('delete should remove object from database', async () => {
-            await daemon.trx('MODULE').run(async (trx) => {
+            const response = await daemon.trx('MODULE').run(async (trx) => {
                 // given
                 const BUCKET = trx.bucket('BUCKET');
                 const input = mock.bucket('MODULE', 'BUCKET')
@@ -144,30 +178,33 @@ describe('Postgres Bucket Adapter', () => {
                 // when
                 const created = await BUCKET.create(input);
                 const read = await BUCKET.readOneOrFail(created.id);
-                await BUCKET.deleteOrFail(read.id);
+                await BUCKET.delete(read.id);
                 const read2 = await BUCKET.readOne(read.id);
-                // then
-                expect(read2).toBeUndefined();
+                return { read2 };
             });
+            const { read2 } = response.output;
+            // then
+            expect(read2).toBeUndefined();
         });
     });
     describe('Query', () => {
         it('query first by existing id should return object', async () => {
-            let queried;
-            await daemon.trx('MODULE').run(async (trx) => {
+            const response = await daemon.trx('MODULE').run(async (trx) => {
                 // given
                 const BUCKET = trx.bucket('BUCKET');
                 const input = mock.bucket('MODULE', 'BUCKET')
                     .obj({ id: undefined }).raw(daemon);
                 // when
                 const created = await BUCKET.create(input);
-                queried = await BUCKET.query({
+                const queried = await BUCKET.query({
                     'id': created.id
                 }).all();
-                // then
-                expect(queried.length).toEqual(1);
-                expect(queried[0].id).toEqual(created.id);
+                return { queried, created };
             });
+            const { queried, created } = response.output;
+            // then
+            expect(queried.length).toEqual(1);
+            expect(queried[0].id).toEqual(created.id);
         });
     });
 });

package/lib/compiler/apps/monolyth/monolyth_compiler.d.ts

@@ -1,4 +1,5 @@
 import { Compiler } from "../../compiler";
+import { AnyApp } from "../../../engine/apps/app";
 import { MonolythApp } from "../../../engine/apps/monolyth/monolyth.app";
 export type MonolythCompilerConfig = {
     libPaths?: string[];
@@ -17,5 +18,7 @@ export declare class MonolythCompiler {
     };
     constructor(compiler: Compiler, appPath: string, config?: MonolythCompilerConfig);
     run(): Promise<void>;
+    mergeProviderPaths(app: AnyApp): void;
+    expandLibPaths(): void;
     static scanAll(dir: string): Promise<MonolythApp<any, any, Record<string, any>>[] | undefined>;
 }