nesoi 3.0.0 → 3.0.6

package/README.md

@@ -0,0 +1,10 @@
+# Nesoi
+Zero-dependency Typescript framework for data-driven applications.
+
+![Logo](/docs/header.png)
+
+> :warning: This is a work-in-progress. Breaking changes happen frequently. Once it's production-ready this notice will be removed.
+
+## Getting Started
+
+Check out our [Hands-On Guide](/docs/HANDS-ON.md) for more details.

package/lib/adapters/postgres/src/migrator/bucket.d.ts

@@ -0,0 +1,20 @@
+import { $Bucket, $Space } from "../../../../elements";
+import postgres from 'postgres';
+import { AnyDaemon } from "../../../../engine/daemon";
+import { BucketAdapterConfig } from "../../../../elements/entities/bucket/adapters/bucket_adapter";
+import { Migration } from './migration';
+export declare class BucketMigrator<S extends $Space, D extends AnyDaemon, ModuleName extends NoInfer<keyof S['modules']>> {
+    private daemon;
+    private sql;
+    private module;
+    private bucket;
+    private tableName;
+    protected schema: $Bucket;
+    protected config?: BucketAdapterConfig;
+    constructor(daemon: D, sql: postgres.Sql<any>, module: ModuleName, bucket: NoInfer<keyof S['modules'][ModuleName]['buckets']>, tableName: string);
+    generate(): Promise<Migration | undefined>;
+    private getCurrentSchema;
+    private generateFieldOptions;
+    private generateField;
+    private fieldType;
+}

package/lib/adapters/postgres/src/migrator/bucket.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketMigrator = void 0;
+const daemon_1 = require("../../../../engine/daemon");
+const migration_1 = require("./migration");
+class BucketMigrator {
+    constructor(daemon, sql, module, bucket, tableName) {
+        this.daemon = daemon;
+        this.sql = sql;
+        this.module = module;
+        this.bucket = bucket;
+        this.tableName = tableName;
+        const daemonBucket = daemon_1.Daemon.getModule(daemon, module)
+            .buckets[bucket];
+        this.schema = daemonBucket.schema;
+        this.config = daemonBucket.adapter.config;
+    }
+    async generate() {
+        const current = await this.getCurrentSchema();
+        const options = this.generateFieldOptions(current);
+        if (!Object.keys(options).length) {
+            return;
+        }
+        const type = current ? 'alter' : 'create';
+        return new migration_1.Migration(this.module, type, this.tableName, options);
+    }
+    async getCurrentSchema() {
+        const columns = await this.sql `
+            SELECT column_name, data_type, is_nullable 
+            FROM information_schema.columns 
+            WHERE table_name = ${this.tableName}`;
+        if (!columns.length) {
+            return;
+        }
+        return columns.map(col => ({
+            ...col,
+            nullable: col.is_nullable === 'YES',
+            field_exists: false
+        }));
+    }
+    generateFieldOptions(current) {
+        let mappedCurrent;
+        if (current) {
+            mappedCurrent = {};
+            current.forEach(col => {
+                mappedCurrent[col.column_name] = col;
+            });
+            Object.keys(this.schema.model.fields)
+                .forEach(name => {
+                if (mappedCurrent[name]) {
+                    mappedCurrent[name].field_exists = true;
+                }
+            });
+        }
+        const fields = {};
+        Object.entries(this.schema.model.fields)
+            .forEach(([name, field]) => {
+            const options = this.generateField(name, field, mappedCurrent);
+            if (options.length) {
+                fields[name] = options;
+            }
+        });
+        // Add meta fields when creating table
+        if (!current) {
+            const created_by = this.config?.meta.created_by || 'created_by';
+            fields[created_by] = [
+                new migration_1.MigrationField(undefined, created_by, {
+                    create: { type: 'character(64)', nullable: true }
+                })
+            ];
+            const created_at = this.config?.meta.created_at || 'created_at';
+            fields[created_at] = [
+                new migration_1.MigrationField(undefined, created_at, {
+                    create: { type: 'timestamp without time zone' }
+                })
+            ];
+            const updated_by = this.config?.meta.updated_by || 'updated_by';
+            fields[updated_by] = [
+                new migration_1.MigrationField(undefined, updated_by, {
+                    create: { type: 'character(64)', nullable: true }
+                })
+            ];
+            const updated_at = this.config?.meta.updated_at || 'updated_at';
+            fields[updated_at] = [
+                new migration_1.MigrationField(undefined, updated_at, {
+                    create: { type: 'timestamp without time zone' }
+                })
+            ];
+        }
+        return fields;
+    }
+    generateField(name, $, columns) {
+        const type = this.fieldType($);
+        const pk = $.name === 'id';
+        const nullable = !$.required;
+        // Table doesn't exist yet, only option is to create the field
+        if (!columns) {
+            return [new migration_1.MigrationField(undefined, $.name, {
+                    create: { type, pk, nullable }
+                })];
+        }
+        // Table exists, evaluate options
+        else {
+            // Field exists, alter only what changed
+            const column = columns[$.name];
+            if (column) {
+                if ($.name === 'id') {
+                    // Id can't be modified for now.
+                    return [];
+                }
+                // TODO: check details such as
+                // - changes in decimal precision
+                // - changes in maxLength
+                // - changes in fk (!!!)
+                const _type = type.startsWith(column.data_type) ? undefined : column.data_type;
+                const _nullable = column.nullable !== nullable ? column.nullable : undefined;
+                if (_type !== undefined || _nullable !== undefined) {
+                    return [new migration_1.MigrationField(undefined, $.name, {
+                            alter: { type: _type, nullable: _nullable }
+                        })];
+                }
+                return [];
+            }
+            // If field doesn't exists in columns, it might:
+            //  - be a new field
+            //  - be a field of the same type being renamed
+            else {
+                const options = [];
+                options.push(new migration_1.MigrationField(undefined, $.name, {
+                    create: { type, pk, nullable }
+                }));
+                const deletedColumnsOfSameType = Object.values(columns)
+                    .filter(col => !col.field_exists)
+                    .filter(col => type.startsWith(col.data_type));
+                if (deletedColumnsOfSameType.length) {
+                    // TODO: check details such as
+                    // - changes in decimal precision
+                    // - changes in maxLength
+                    // - changes in fk (!!!)
+                    deletedColumnsOfSameType.forEach(col => {
+                        const _type = type.startsWith(col.data_type) ? undefined : col.data_type;
+                        const _nullable = col.nullable !== nullable ? col.nullable : undefined;
+                        if (_type !== undefined || _nullable !== undefined) {
+                            options.push(new migration_1.MigrationField(undefined, $.name, {
+                                alter: { name: col.column_name, type: _type, nullable: _nullable }
+                            }));
+                        }
+                    });
+                }
+                return options;
+            }
+        }
+    }
+    fieldType($) {
+        if ($.name === 'id') {
+            if ($.type === 'string') {
+                return 'character(64) PRIMARY KEY';
+            }
+            return 'serial4 PRIMARY KEY';
+        }
+        let type = {
+            'boolean': () => 'boolean',
+            'date': () => 'date',
+            'datetime': () => 'timestamp without time zone',
+            'decimal': () => 'numeric(18,9)', // TODO: read from schema (not stored yet)
+            'dict': () => 'jsonb',
+            'enum': () => 'character(64)', // TODO: read from schema maxLength
+            'file': () => 'jsonb',
+            'float': () => 'double precision',
+            'int': () => 'integer',
+            'obj': () => 'jsonb',
+            'string': () => 'character varying', // TODO: char() if maxLength
+            'unknown': () => { throw new Error('An unknown field shouldn\'t be stored on SQL'); },
+        }[$.type]();
+        if ($.array) {
+            type += '[]';
+        }
+        if ($.required) {
+            type += ' NOT NULL';
+        }
+        return type;
+    }
+}
+exports.BucketMigrator = BucketMigrator;

package/lib/adapters/postgres/src/migrator/csv.d.ts

@@ -0,0 +1,7 @@
+import postgres from 'postgres';
+export declare class CSV {
+    /**
+     * Import a csv table into the database
+     */
+    static import(sql: postgres.Sql<any>, tableName: string, csvpath: string): Promise<void>;
+}

package/lib/adapters/postgres/src/migrator/csv.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSV = void 0;
+const fs = __importStar(require("fs"));
+const log_1 = require("../../../../engine/util/log");
+class CSV {
+    /**
+     * Import a csv table into the database
+     */
+    static async import(sql, tableName, csvpath) {
+        log_1.Log.info('csv', 'import', `Importing objects from csv file '${csvpath}' into table '${tableName}'`);
+        const lines = fs.readFileSync(csvpath).toString().split('\n');
+        const keys = lines[0]
+            .split(',')
+            .map(v => v.match(/"(.*)"/)?.[1] || v);
+        const objs = lines.slice(1).map(line => {
+            const rows = line
+                .split(',')
+                .map(v => v.match(/"(.*)"/)?.[1] || v);
+            const obj = {};
+            for (let i = 0; i < keys.length; i++) {
+                obj[keys[i]] = rows[i];
+            }
+            return obj;
+        });
+        sql.begin(async (sql) => {
+            for (const obj of objs) {
+                log_1.Log.info('csv', 'import', `Inserting object ${obj.id}`, obj);
+                await sql `
+                    INSERT INTO ${sql(tableName)}
+                    ${sql(obj, keys)}
+                `;
+            }
+        }).catch(e => {
+            log_1.Log.error('csv', 'import', 'CSV Import failed, rolling back changes', e);
+        });
+    }
+}
+exports.CSV = CSV;

package/lib/adapters/postgres/src/migrator/migration.d.ts

@@ -1,6 +1,3 @@
-import { $Bucket, $Space } from "../../../../elements";
-import postgres from 'postgres';
-import { AnyDaemon } from "../../../../engine/daemon";
 export type MigrationFieldOperation = {
     create: {
         type: string;
@@ -29,13 +26,14 @@ export declare class MigrationField {
     sql(): string | undefined;
 }
 export declare class Migration {
+    module: string;
     private type;
     private tableName;
     private options;
     name: string;
     private fields;
     private needsReview;
-    constructor(type: 'create' | 'alter', tableName: string, options: Record<string, MigrationField[]>);
+    constructor(module: string, type: 'create' | 'alter', tableName: string, options: Record<string, MigrationField[]>);
     describe(): string;
     sqlUp(): string;
     sqlDown(): string;
@@ -57,17 +55,3 @@ export declare class Migration {
     private fnUp;
     private fnDown;
 }
-export declare class BucketMigrator<S extends $Space, D extends AnyDaemon, ModuleName extends NoInfer<keyof S['modules']>> {
-    private daemon;
-    private sql;
-    private module;
-    private bucket;
-    private tableName;
-    protected schema: $Bucket;
-    constructor(daemon: D, sql: postgres.Sql<any>, module: ModuleName, bucket: NoInfer<keyof S['modules'][ModuleName]['buckets']>, tableName: string);
-    generate(): Promise<Migration | undefined>;
-    private getCurrentSchema;
-    private generateFieldOptions;
-    private generateField;
-    private fieldType;
-}

package/lib/adapters/postgres/src/migrator/migration.js

@@ -33,13 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BucketMigrator = exports.Migration = exports.MigrationField = void 0;
+exports.Migration = exports.MigrationField = void 0;
 const string_1 = require("../../../../engine/util/string");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const crypto_1 = require("crypto");
 const datetime_1 = require("../../../../engine/data/datetime");
-const daemon_1 = require("../../../../engine/daemon");
 class MigrationField {
     constructor(oldColumn, newColumn, operation) {
         this.oldColumn = oldColumn;
@@ -70,13 +69,14 @@ class MigrationField {
     }
     sql() {
         if ('create' in this.operation) {
-            return `${this.newColumn} ${this.operation.create.type}`;
+            return `"${this.newColumn}" ${this.operation.create.type}`;
         }
     }
 }
 exports.MigrationField = MigrationField;
 class Migration {
-    constructor(type, tableName, options) {
+    constructor(module, type, tableName, options) {
+        this.module = module;
         this.type = type;
         this.tableName = tableName;
         this.options = options;
@@ -87,6 +87,7 @@ class Migration {
     describe() {
         let str = '';
         str += '┌\n';
+        str += `│ ${(0, string_1.colored)('module: ' + this.module, 'darkgray')}\n`;
         str += `│ ${(0, string_1.colored)(this.name, 'lightcyan')}\n`;
         str += `│ ${this.needsReview
             ? (0, string_1.colored)('⚠ More than one option for some fields. Requires review.', 'red')
@@ -124,7 +125,9 @@ class Migration {
         return '';
     }
     save(dirpath = './migrations') {
-        const filepath = path.join(dirpath, this.name + '.ts');
+        const filedir = path.join('modules', this.module, dirpath);
+        fs.mkdirSync(filedir, { recursive: true });
+        const filepath = path.join(filedir, this.name + '.ts');
         const { encoded, hash } = this.encode();
         let str = '';
         str += 'import { Migrator } from \'nesoi/lib/adapters/postgres/src/migrator\';\n';
@@ -180,7 +183,7 @@ class Migration {
     }
     fnUp() {
         let str = '';
-        str += 'up: async (daemon, sql) => {\n';
+        str += 'up: async ({ sql }) => {\n';
         str += '\tawait sql`\n';
         str += '\t\t' + this.sqlUp().replace(/\n/g, '\n\t\t') + '\n';
         str += '\t`\n';
@@ -189,7 +192,7 @@ class Migration {
     }
     fnDown() {
         let str = '';
-        str += 'down: async (daemon, sql) => {\n';
+        str += 'down: async ({ sql }) => {\n';
         str += '\tawait sql`\n';
         str += '\t\t' + this.sqlDown().replace(/\n/g, '\n\t\t') + '\n';
         str += '\t`\n';
@@ -198,154 +201,3 @@ class Migration {
     }
 }
 exports.Migration = Migration;
-class BucketMigrator {
-    constructor(daemon, sql, module, bucket, tableName) {
-        this.daemon = daemon;
-        this.sql = sql;
-        this.module = module;
-        this.bucket = bucket;
-        this.tableName = tableName;
-        this.schema = daemon_1.Daemon.getModule(daemon, module)
-            .buckets[bucket]
-            .schema;
-    }
-    async generate() {
-        const current = await this.getCurrentSchema();
-        const options = this.generateFieldOptions(current);
-        if (!Object.keys(options).length) {
-            return;
-        }
-        const type = current ? 'alter' : 'create';
-        return new Migration(type, this.tableName, options);
-    }
-    async getCurrentSchema() {
-        const columns = await this.sql `
-            SELECT column_name, data_type, is_nullable 
-            FROM information_schema.columns 
-            WHERE table_name = ${this.tableName}`;
-        if (!columns.length) {
-            return;
-        }
-        return columns.map(col => ({
-            ...col,
-            nullable: col.is_nullable === 'YES',
-            field_exists: false
-        }));
-    }
-    generateFieldOptions(current) {
-        let mappedCurrent;
-        if (current) {
-            mappedCurrent = {};
-            current.forEach(col => {
-                mappedCurrent[col.column_name] = col;
-            });
-            Object.keys(this.schema.model.fields)
-                .forEach(name => {
-                if (mappedCurrent[name]) {
-                    mappedCurrent[name].field_exists = true;
-                }
-            });
-        }
-        const fields = {};
-        Object.entries(this.schema.model.fields)
-            .forEach(([name, field]) => {
-            const options = this.generateField(name, field, mappedCurrent);
-            if (options.length) {
-                fields[name] = options;
-            }
-        });
-        return fields;
-    }
-    generateField(name, $, columns) {
-        const type = this.fieldType($);
-        const pk = $.name === 'id';
-        const nullable = !$.required;
-        // Table doesn't exist yet, only option is to create the field
-        if (!columns) {
-            return [new MigrationField(undefined, $.name, {
-                    create: { type, pk, nullable }
-                })];
-        }
-        // Table exists, evaluate options
-        else {
-            // Field exists, alter only what changed
-            const column = columns[$.name];
-            if (column) {
-                if ($.name === 'id') {
-                    // Id can't be modified for now.
-                    return [];
-                }
-                // TODO: check details such as
-                // - changes in decimal precision
-                // - changes in maxLength
-                // - changes in fk (!!!)
-                const _type = type.startsWith(column.data_type) ? undefined : column.data_type;
-                const _nullable = column.nullable !== nullable ? column.nullable : undefined;
-                if (_type !== undefined || _nullable !== undefined) {
-                    return [new MigrationField(undefined, $.name, {
-                            alter: { type: _type, nullable: _nullable }
-                        })];
-                }
-                return [];
-            }
-            // If field doesn't exists in columns, it might:
-            //  - be a new field
-            //  - be a field of the same type being renamed
-            else {
-                const options = [];
-                options.push(new MigrationField(undefined, $.name, {
-                    create: { type, pk, nullable }
-                }));
-                const deletedColumnsOfSameType = Object.values(columns)
-                    .filter(col => !col.field_exists)
-                    .filter(col => type.startsWith(col.data_type));
-                if (deletedColumnsOfSameType.length) {
-                    // TODO: check details such as
-                    // - changes in decimal precision
-                    // - changes in maxLength
-                    // - changes in fk (!!!)
-                    deletedColumnsOfSameType.forEach(col => {
-                        const _type = type.startsWith(col.data_type) ? undefined : col.data_type;
-                        const _nullable = col.nullable !== nullable ? col.nullable : undefined;
-                        if (_type !== undefined || _nullable !== undefined) {
-                            options.push(new MigrationField(undefined, $.name, {
-                                alter: { name: col.column_name, type: _type, nullable: _nullable }
-                            }));
-                        }
-                    });
-                }
-                return options;
-            }
-        }
-    }
-    fieldType($) {
-        if ($.name === 'id') {
-            if ($.type === 'string') {
-                return 'character(64) PRIMARY KEY';
-            }
-            return 'serial4 PRIMARY KEY';
-        }
-        let type = {
-            'boolean': () => 'boolean',
-            'date': () => 'date',
-            'datetime': () => 'timestamp without time zone',
-            'decimal': () => 'numeric(18,9)', // TODO: read from schema (not stored yet)
-            'dict': () => 'jsonb',
-            'enum': () => 'character(64)', // TODO: read from schema maxLength
-            'file': () => { throw new Error('A file field shouldn\'t be stored on SQL'); },
-            'float': () => 'double precision',
-            'int': () => 'integer',
-            'obj': () => 'jsonb',
-            'string': () => 'character varying', // TODO: char() if maxLength
-            'unknown': () => { throw new Error('An unknown field shouldn\'t be stored on SQL'); },
-        }[$.type]();
-        if ($.array) {
-            type += '[]';
-        }
-        if ($.required) {
-            type += ' NOT NULL';
-        }
-        return type;
-    }
-}
-exports.BucketMigrator = BucketMigrator;

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

@@ -2,11 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Migrator = void 0;
 const log_1 = require("../../../../engine/util/log");
-const migration_1 = require("./migration");
 const runner_1 = require("./runner");
 const daemon_1 = require("../../../../engine/daemon");
-const bucket_1 = require("../../../../elements/entities/bucket/bucket");
 const string_1 = require("../../../../engine/util/string");
+const bucket_1 = require("./bucket");
 class Migrator {
     constructor(daemon, sql, dirpath = './migrations') {
         this.daemon = daemon;
@@ -21,6 +20,7 @@ class Migrator {
         if (!oldTable.length) {
             await migrator.sql `CREATE TABLE ${migrator.sql(Migrator.MIGRATION_TABLE_NAME)} (
                 id SERIAL PRIMARY KEY,
+                module VARCHAR NOT NULL,
                 name VARCHAR NOT NULL,
                 description VARCHAR,
                 batch INT4 NOT NULL,
@@ -29,7 +29,7 @@ class Migrator {
                 filehash VARCHAR NOT NULL
             )`;
         }
-        migrator.status = await runner_1.MigrationRunner.status(migrator.sql, migrator.dirpath);
+        migrator.status = await runner_1.MigrationRunner.status(daemon, migrator.sql, migrator.dirpath);
         return migrator;
     }
     async generate() {
@@ -38,7 +38,10 @@ class Migrator {
         for (const module of modules) {
             const buckets = daemon_1.Daemon.getModule(this.daemon, module.name).buckets;
             for (const bucket in buckets) {
-                const adapter = bucket_1.Bucket.getAdapter(buckets[bucket]);
+                const schema = buckets[bucket].schema;
+                if (schema.module !== module.name)
+                    continue;
+                const adapter = buckets[bucket].adapter;
                 if (!adapter?.tableName)
                     continue;
                 const migration = await this.generateForBucket(module.name, bucket, adapter.tableName);
@@ -50,7 +53,7 @@ class Migrator {
         return migrations;
     }
     async generateForBucket(module, bucket, tableName) {
-        const migrator = new migration_1.BucketMigrator(this.daemon, this.sql, module, bucket, tableName);
+        const migrator = new bucket_1.BucketMigrator(this.daemon, this.sql, module, bucket, tableName);
         const migration = await migrator.generate();
         const tag = (0, string_1.colored)(`${module}::bucket:${bucket}`, 'lightcyan');
         if (!migration) {

package/lib/adapters/postgres/src/migrator/runner.d.ts

@@ -1,9 +1,14 @@
 import postgres from 'postgres';
 import { Migration } from './migration';
-import { AnyDaemon, Daemon } from "../../../../engine/daemon";
-type MigrationFn = (daemon: Daemon<any, any>, sql: postgres.Sql<any>) => Promise<void>;
+import { AnyDaemon } from "../../../../engine/daemon";
+import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+type MigrationFn = ($: {
+    sql: postgres.Sql<any>;
+    trx: AnyTrxNode;
+}) => Promise<void>;
 export type MigrationRow = {
     id: number;
+    module: string;
     name: string;
     description?: string;
     batch: number;
@@ -25,6 +30,7 @@ export declare class MigrationStatus {
     items: {
         state: 'done' | 'pending' | 'lost';
         id?: number;
+        module: string;
         name: string;
         description?: string;
         batch?: number;
@@ -33,8 +39,9 @@ export declare class MigrationStatus {
         filehash?: string;
         method?: MigrationMethod;
     }[];
-    nextBatch: number;
+    batch: number;
     constructor(fileMigrations: {
+        module: string;
         name: string;
         hash: string;
         path: string;
@@ -46,16 +53,19 @@ export declare class MigrationRunner {
     dirpath: string;
     private migrations;
     private constructor();
-    static scanFiles(dirpath: string): Promise<{
+    static scanFiles(daemon: AnyDaemon, dirpath: string): Promise<{
+        module: string;
         name: string;
         path: string;
         hash: string;
         method: MigrationMethod;
     }[]>;
     static scanDb(sql: postgres.Sql<any>): Promise<postgres.RowList<MigrationRow[]>>;
-    static status(sql: postgres.Sql<any>, dirpath: string): Promise<MigrationStatus>;
+    static status(daemon: AnyDaemon, sql: postgres.Sql<any>, dirpath: string): Promise<MigrationStatus>;
     static up(daemon: AnyDaemon, sql: postgres.Sql<any>, mode?: 'one' | 'batch', dirpath?: string): Promise<void>;
-    static oneUp(daemon: AnyDaemon, sql: postgres.Sql<any>, migration: Migration, dirpath?: string): Promise<void>;
+    static down(daemon: AnyDaemon, sql: postgres.Sql<any>, mode?: 'one' | 'batch', dirpath?: string): Promise<void>;
+    static injectUp(daemon: AnyDaemon, sql: postgres.Sql<any>, migration: Migration, dirpath?: string): Promise<void>;
     private static migrateUp;
+    private static migrateDown;
 }
 export {};