nesoi 3.0.9 → 3.0.11

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

@@ -1,207 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-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_make_empty_migration = 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 provider_1 = require("./migrator/generator/provider");
-const ui_1 = __importDefault(require("../../../engine/cli/ui"));
-const daemon_1 = require("../../../engine/daemon");
-const postgres_bucket_adapter_1 = require("./postgres.bucket_adapter");
-const csv_1 = require("./migrator/csv");
-const runner_1 = require("./migrator/runner/runner");
-const migration_1 = require("./migrator/generator/migration");
-class cmd_check extends cli_adapter_1.CLICommand {
-    constructor(provider) {
-        super('any', 'check', 'check', 'Check if the connection to PostgreSQL is working properly');
-        this.provider = provider;
-    }
-    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 provider_1.MigrationProvider.create(daemon, this.provider.sql);
-    }
-}
-exports.cmd_check = cmd_check;
-class cmd_tables extends cli_adapter_1.CLICommand {
-    constructor(provider) {
-        super('any', 'tables', 'tables', 'List the tables present on the database');
-        this.provider = provider;
-    }
-    async run() {
-        const res = await database_1.Database.listTables(this.provider.sql);
-        ui_1.default.list(res);
-    }
-}
-exports.cmd_tables = cmd_tables;
-class cmd_create_db extends cli_adapter_1.CLICommand {
-    constructor(provider) {
-        super('any', 'create db', 'create db( NAME)', 'Create the database used by the application', /(\w*)/, ['name']);
-        this.provider = provider;
-    }
-    async run(daemon, $) {
-        let name = $.name;
-        const config = this.provider.config?.connection;
-        if (!name) {
-            if (!config?.db) {
-                ui_1.default.result('error', 'Database name not configured on PostgresConfig used', config);
-                return;
-            }
-            name = config.db;
-        }
-        try {
-            await database_1.Database.createDatabase(name, config);
-            ui_1.default.result('ok', `Database ${name} created`);
-        }
-        catch (e) {
-            ui_1.default.result('error', `Failed to create database ${name}`, e);
-        }
-        await provider_1.MigrationProvider.create(daemon, this.provider.sql);
-    }
-}
-exports.cmd_create_db = cmd_create_db;
-class cmd_status extends cli_adapter_1.CLICommand {
-    constructor(provider) {
-        super('any', 'status', 'status', 'Show the status of migrations on the current database');
-        this.provider = provider;
-    }
-    async run(daemon) {
-        const migrator = await provider_1.MigrationProvider.create(daemon, this.provider.sql);
-        console.log(migrator.status.describe());
-    }
-}
-exports.cmd_status = cmd_status;
-class cmd_make_empty_migration extends cli_adapter_1.CLICommand {
-    constructor(cli, provider) {
-        super('any', 'make empty migration', 'make empty migration( NAME)', 'Generate an empty migration to be filled by the user', /(\w*)/, ['name']);
-        this.cli = cli;
-        this.provider = provider;
-    }
-    async run(daemon, $) {
-        const module = await ui_1.default.select('Pick a module to create the migration into:', daemon_1.Daemon.getModules(daemon).map(m => m.name));
-        const name = $.name || await ui_1.default.question('Migration name');
-        const migration = migration_1.$Migration.empty(module.value, name);
-        const filepath = migration.save();
-        this.cli.openEditor(filepath);
-    }
-}
-exports.cmd_make_empty_migration = cmd_make_empty_migration;
-class cmd_make_migrations extends cli_adapter_1.CLICommand {
-    constructor(provider) {
-        super('any', 'make migrations', 'make migrations( TAG)', 'Generate migrations for the bucket(s) using PostgresBucketAdapter', /(\w*)/, ['tag']);
-        this.provider = provider;
-    }
-    async run(daemon, $) {
-        console.clear();
-        // TODO: restrict by tag
-        const migrator = await provider_1.MigrationProvider.create(daemon, this.provider.sql);
-        const migrations = await migrator.generate();
-        for (const migration of migrations) {
-            migration.save();
-        }
-        await runner_1.MigrationRunner.up(daemon, this.provider.sql, 'batch');
-    }
-}
-exports.cmd_make_migrations = cmd_make_migrations;
-class cmd_migrate_up extends cli_adapter_1.CLICommand {
-    constructor(provider) {
-        super('any', 'migrate up', 'migrate up', 'Run ALL the pending migrations up (batch)');
-        this.provider = provider;
-    }
-    async run(daemon) {
-        console.clear();
-        await runner_1.MigrationRunner.up(daemon, this.provider.sql, 'batch');
-    }
-}
-exports.cmd_migrate_up = cmd_migrate_up;
-class cmd_migrate_one_up extends cli_adapter_1.CLICommand {
-    constructor(provider) {
-        super('any', 'migrate one up', 'migrate one up', 'Run ONE pending migration up');
-        this.provider = provider;
-    }
-    async run(daemon) {
-        console.clear();
-        await runner_1.MigrationRunner.up(daemon, this.provider.sql, 'one');
-    }
-}
-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) {
-        console.clear();
-        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) {
-        console.clear();
-        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.value.tableName, input.path);
-    }
-}
-exports.cmd_import_csv = cmd_import_csv;
-class PostgresCLI extends cli_adapter_1.CLIAdapter {
-    constructor(cli, provider) {
-        super(cli);
-        this.cli = cli;
-        this.provider = provider;
-        this.commands = {
-            'check': new cmd_check(provider),
-            'tables': new cmd_tables(provider),
-            'create db': new cmd_create_db(provider),
-            'status': new cmd_status(provider),
-            'make migrations': new cmd_make_migrations(provider),
-            'make empty migration': new cmd_make_empty_migration(cli, 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),
-        };
-    }
-}
-exports.PostgresCLI = PostgresCLI;

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

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

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

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

@@ -1,16 +0,0 @@
-import { AnyTrxNode } from "../../../engine/transaction/trx_node";
-import { NQLRunner } from "../../../elements/entities/bucket/query/nql_engine";
-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();
-    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

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresNQLRunner = void 0;
-const nql_engine_1 = require("../../../elements/entities/bucket/query/nql_engine");
-const trx_1 = require("../../../engine/transaction/trx");
-const postgres_bucket_adapter_1 = require("./postgres.bucket_adapter");
-const log_1 = require("../../../engine/util/log");
-class PostgresNQLRunner extends nql_engine_1.NQLRunner {
-    constructor() {
-        super();
-    }
-    async run(trx, part, params, pagination) {
-        const sql = trx_1.Trx.get(trx, 'sql');
-        const { tableName, meta } = postgres_bucket_adapter_1.PostgresBucketAdapter.getTableMeta(trx, part.union.meta);
-        const sql_params = [];
-        const _sql = (part) => {
-            let where = _union(part.union);
-            if (where) {
-                where = 'WHERE ' + where;
-            }
-            const sql_str = `FROM ${tableName} ${where}`;
-            return sql_str;
-        };
-        const _union = (union) => {
-            const inters = union.inters.map(i => _inter(i)).filter(r => !!r).join(' OR ');
-            if (!inters)
-                return '';
-            return `(${inters})`;
-        };
-        const _inter = (inter) => {
-            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)
-            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': '' // TODO
-            }[rule.op];
-            // Apply case insensitive modifier
-            if (rule.case_i) {
-                if (rule.op === '==') {
-                    column = `LOWER(${column})`;
-                }
-                else if (rule.op === 'contains') {
-                    op = 'ILIKE';
-                }
-            }
-            // 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 => {
-        //     Log.error('postgres' as any, 'nql', e.query, e);
-        // })
-        // console.log((str as any).string);
-        // End of Debug
-        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

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

@@ -1,77 +0,0 @@
-"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.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,210 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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 datetime_1 = require("../../../engine/data/datetime");
-const provider_1 = require("../src/migrator/generator/provider");
-const runner_1 = require("../src/migrator/runner/runner");
-log_1.Log.level = 'warn';
-// TODO: read this from env
-const PostgresConfig = {
-    meta: {
-        created_at: 'created_at',
-        created_by: 'created_by',
-        updated_at: 'updated_at',
-        updated_by: 'updated_by',
-    },
-    connection: {
-        host: 'localhost',
-        port: 5432,
-        user: 'postgres',
-        pass: 'postgres',
-        db: 'NESOI_TEST',
-    }
-};
-let daemon;
-async function setup() {
-    if (daemon) {
-        return daemon;
-    }
-    // Build bucket used for test
-    const bucket = new bucket_builder_1.BucketBuilder('MODULE', 'BUCKET')
-        .model($ => ({
-        id: $.int,
-        p_boolean: $.boolean,
-        p_date: $.date,
-        p_datetime: $.datetime,
-        p_decimal: $.decimal(),
-        p_enum: $.enum(['a', 'b', 'c']),
-        p_int: $.int,
-        p_float: $.float,
-        p_string: $.string,
-        p_obj: $.obj({
-            a: $.int,
-            b: $.string
-        }),
-        p_dict: $.dict($.boolean)
-    }));
-    // Build test app
-    const app = new inline_app_1.InlineApp('RUNTIME', [
-        bucket
-    ])
-        .provider(postgres_provider_1.PostgresProvider.make('pg', PostgresConfig))
-        .config.buckets({
-        'MODULE': {
-            'BUCKET': {
-                adapter: ($, { pg }) => new postgres_bucket_adapter_1.PostgresBucketAdapter($, pg, 'nesoi_test_table')
-            }
-        }
-    })
-        .config.trx({
-        'MODULE': {
-            wrap: postgres_provider_1.PostgresProvider.wrap('pg')
-        }
-    });
-    // Run test daemon
-    daemon = await app.daemon();
-    // Prepare database using daemon
-    // TODO: encapsulate this
-    // await Database.createDatabase('NESOI_TEST', PostgresConfig.connection, { if_exists: 'delete' });
-    const pg = postgres_provider_1.PostgresProvider.make('pg', PostgresConfig).up();
-    const migrator = await provider_1.MigrationProvider.create(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.fromSchema.up(daemon, pg.sql, migration);
-    }
-    // migration?.save();
-    // await MigrationRunner.up(daemon, 'one', PostgresConfig);
-    return daemon;
-}
-const mock = new mock_1.Mock();
-beforeAll(async () => {
-    await setup();
-}, 30000);
-describe('Postgres Bucket Adapter', () => {
-    // it ('!', () => {
-    //     expect(1+1).toEqual(2);
-    // })
-    describe('CRUD', () => {
-        it('create should return unmodified object', async () => {
-            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);
-                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 () => {
-            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 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 () => {
-            const response = await daemon.trx('MODULE').run(async (trx) => {
-                // given
-                const BUCKET = trx.bucket('BUCKET');
-                const input1 = mock.bucket('MODULE', 'BUCKET')
-                    .obj({ id: undefined }).raw(daemon);
-                const input2 = mock.bucket('MODULE', 'BUCKET')
-                    .obj({ id: undefined }).raw(daemon);
-                // when
-                const created = await BUCKET.create(input1);
-                const updated = await BUCKET.patch({
-                    ...input2,
-                    id: created.id
-                });
-                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 () => {
-            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 read = await BUCKET.readOneOrFail(created.id);
-                await BUCKET.delete(read.id);
-                const read2 = await BUCKET.readOne(read.id);
-                return { read2 };
-            });
-            const { read2 } = response.output;
-            // then
-            expect(read2).toBeUndefined();
-        });
-    });
-    describe('Query', () => {
-        it('query first by existing id should return object', async () => {
-            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 queried = await BUCKET.query({
-                    'id': created.id
-                }).all();
-                return { queried, created };
-            });
-            const { queried, created } = response.output;
-            // then
-            expect(queried.length).toEqual(1);
-            expect(queried[0].id).toEqual(created.id);
-        });
-    });
-});