nesoi 3.0.9 → 3.0.10

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

@@ -1,22 +0,0 @@
-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 MigrationGenerator<S extends $Space, D extends AnyDaemon, ModuleName extends NoInfer<keyof S['modules']>> {
-    private sql;
-    private module;
-    private tableName;
-    protected schema: $Bucket;
-    protected config?: BucketAdapterConfig;
-    constructor(daemon: D, sql: postgres.Sql<any>, module: ModuleName, bucketName: NoInfer<keyof S['modules'][ModuleName]['buckets']>, tableName: string);
-    generate(): Promise<$Migration | undefined>;
-    private getCurrentSchema;
-    private generateDrops;
-    private generateSteps;
-    private generateFieldSteps;
-    private fieldUdt;
-    private fieldTypeFromUdt;
-    private fieldType;
-    private manualReview;
-}

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

@@ -1,326 +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.MigrationGenerator = void 0;
-const daemon_1 = require("../../../../../engine/daemon");
-const migration_1 = require("./migration");
-const string_1 = require("../../../../../engine/util/string");
-const ui_1 = __importDefault(require("../../../../../engine/cli/ui"));
-const log_1 = require("../../../../../engine/util/log");
-class MigrationOption {
-    constructor(schema) {
-        this.schema = schema;
-        this.selected = false;
-        this.excluded_by = [];
-    }
-}
-class MigrationGenerator {
-    constructor(daemon, sql, module, bucketName, tableName) {
-        this.sql = sql;
-        this.module = module;
-        this.tableName = tableName;
-        const bucket = daemon_1.Daemon.getModule(daemon, module).buckets[bucketName];
-        this.schema = bucket.schema;
-        this.config = bucket.adapter.config;
-    }
-    async generate() {
-        const current = await this.getCurrentSchema();
-        const drops = current ? this.generateDrops(current.columns) : {};
-        const steps = this.generateSteps(current?.mapped, drops);
-        steps.push(...Object.values(drops).map(d => ({
-            options: [d]
-        })));
-        if (!steps.length) {
-            return;
-        }
-        const type = current ? 'alter' : 'create';
-        const migration = await this.manualReview(type, steps);
-        return migration;
-    }
-    async getCurrentSchema() {
-        const rawColumns = await this.sql `
-            SELECT column_name, udt_name, is_nullable, numeric_precision, numeric_scale
-            FROM information_schema.columns 
-            WHERE table_name = ${this.tableName}`;
-        if (!rawColumns.length) {
-            return;
-        }
-        const columns = rawColumns.map(col => ({
-            column_name: col.column_name,
-            udt_name: col.udt_name,
-            data_type: this.fieldTypeFromUdt(col.udt_name, {
-                n0: col.numeric_precision,
-                n1: col.numeric_scale,
-            }),
-            nullable: col.is_nullable === 'YES',
-            field_exists: false
-        }));
-        // Map current columns by name, and flag if they already exist
-        const mapped = {};
-        columns.forEach(col => {
-            mapped[col.column_name] = col;
-            const created_by = this.config?.meta.created_by || 'created_by';
-            const created_at = this.config?.meta.created_at || 'created_at';
-            const updated_by = this.config?.meta.updated_by || 'updated_by';
-            const updated_at = this.config?.meta.updated_at || 'updated_at';
-            if (col.column_name === created_by
-                || col.column_name === created_at
-                || col.column_name === updated_by
-                || col.column_name === updated_at) {
-                mapped[col.column_name].field_exists = true;
-            }
-        });
-        Object.keys(this.schema.model.fields)
-            .forEach(name => {
-            if (mapped[name]) {
-                mapped[name].field_exists = true;
-            }
-        });
-        return { columns, mapped };
-    }
-    generateDrops(columns) {
-        const drops = {};
-        for (const col of columns) {
-            if (col.field_exists)
-                continue;
-            drops[col.column_name] = new MigrationOption(new migration_1.$MigrationField(col.column_name, {
-                drop: {
-                    type: col.data_type,
-                    nullable: col.nullable
-                }
-            }));
-        }
-        return drops;
-    }
-    generateSteps(current, drops = {}) {
-        const steps = [];
-        // Generate migration step for each field
-        Object.values(this.schema.model.fields)
-            .forEach(field => {
-            const fieldSteps = this.generateFieldSteps(field, current, drops);
-            if (fieldSteps.length) {
-                steps.push(...fieldSteps);
-            }
-        });
-        // Add meta fields when creating table
-        if (!current) {
-            const created_by = this.config?.meta.created_by || 'created_by';
-            const created_at = this.config?.meta.created_at || 'created_at';
-            const updated_by = this.config?.meta.updated_by || 'updated_by';
-            const updated_at = this.config?.meta.updated_at || 'updated_at';
-            steps.push({ options: [new MigrationOption(new migration_1.$MigrationField(created_by, {
-                        create: { type: 'character(64)', nullable: true }
-                    }))] });
-            steps.push({ options: [new MigrationOption(new migration_1.$MigrationField(created_at, {
-                        create: { type: 'timestamp without time zone' }
-                    }))] });
-            steps.push({ options: [new MigrationOption(new migration_1.$MigrationField(updated_by, {
-                        create: { type: 'character(64)', nullable: true }
-                    }))] });
-            steps.push({ options: [new MigrationOption(new migration_1.$MigrationField(updated_at, {
-                        create: { type: 'timestamp without time zone' }
-                    }))] });
-        }
-        return steps;
-    }
-    generateFieldSteps($, current, drops = {}) {
-        const type = this.fieldType($);
-        const pk = $.name === 'id';
-        const nullable = !$.required;
-        // Table doesn't exist yet, only option is to create the field
-        if (!current) {
-            const options = [
-                new MigrationOption(new migration_1.$MigrationField($.name, {
-                    create: { type, pk, nullable }
-                }))
-            ];
-            return [{ options }];
-        }
-        // Table exists, evaluate options
-        else {
-            const col = current[$.name];
-            // Field exists in columns, alter only what changed
-            if (col) {
-                if ($.name === 'id') {
-                    // Id can't be modified for now.
-                    return [];
-                }
-                // TODO: check details such as
-                // - changes in decimal precision
-                // - changes in maxLength
-                const typeChanged = !type.startsWith(col.data_type);
-                const nullableChanged = col.nullable !== nullable;
-                const steps = [];
-                if (typeChanged) {
-                    const options = [
-                        new MigrationOption(new migration_1.$MigrationField($.name, {
-                            alter_type: { from: col.data_type, to: type, using: {} }
-                        }))
-                    ];
-                    steps.push({ options });
-                }
-                if (nullableChanged) {
-                    const options = [
-                        new MigrationOption(new migration_1.$MigrationField($.name, {
-                            alter_null: { from: col.nullable, to: nullable }
-                        }))
-                    ];
-                    steps.push({ options });
-                }
-                return steps;
-            }
-            // Field doesn't exists in columns, it might:
-            //  - 1: be a new field
-            //  - 2: be a field of the same type being renamed
-            else {
-                const options = [];
-                // Option 1
-                const createOption = new MigrationOption(new migration_1.$MigrationField($.name, {
-                    create: { type, pk, nullable }
-                }));
-                options.push(createOption);
-                const deletedColumnsOfSameType = Object.values(current)
-                    .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
-                    deletedColumnsOfSameType.forEach(col => {
-                        // Option 2
-                        const renameOption = new MigrationOption(new migration_1.$MigrationField(col.column_name, {
-                            rename: { name: $.name }
-                        }));
-                        options.push(renameOption);
-                        // If this option is picked, the drop option for this column is no longer valid
-                        drops[col.column_name].excluded_by.push(renameOption);
-                    });
-                }
-                return [{ options }];
-            }
-        }
-    }
-    fieldUdt($) {
-        if ($.name === 'id') {
-            if ($.type === 'string') {
-                return 'bpchar';
-            }
-            return 'int4';
-        }
-        let type = {
-            'boolean': () => 'bool',
-            'date': () => 'date',
-            'datetime': () => 'timestamp',
-            'decimal': () => 'numeric',
-            'dict': () => 'jsonb',
-            'enum': () => 'bpchar', // TODO: read from schema maxLength
-            'file': () => 'jsonb',
-            'float': () => 'float8',
-            'int': () => 'int4',
-            'obj': () => 'jsonb',
-            'string': () => 'varchar', // TODO: char() if maxLength
-            'unknown': () => { throw new Error('An unknown field shouldn\'t be stored on SQL'); },
-        }[$.type]();
-        if ($.array) {
-            type = '_' + type;
-        }
-        return type;
-    }
-    fieldTypeFromUdt(udt, extra) {
-        const array = udt.startsWith('_');
-        if (array)
-            udt = udt.slice(1);
-        let type = {
-            'bool': () => 'boolean',
-            'date': () => 'date',
-            'timestamp': () => 'timestamp',
-            'numeric': () => `numeric(${extra.n0},${extra.n1})`,
-            'jsonb': () => 'jsonb',
-            'bpchar': () => 'character(64)', // TODO: read from schema maxLength
-            'float8': () => 'double precision',
-            'int4': () => 'integer',
-            'varchar': () => 'character varying', // TODO: char() if maxLength
-            'unknown': () => { throw new Error('An unknown field shouldn\'t be stored on SQL'); },
-        }[udt]();
-        if (array)
-            type += '[]';
-        return type;
-    }
-    fieldType($) {
-        const udt = this.fieldUdt($);
-        return this.fieldTypeFromUdt(udt, {
-            n0: ($.meta?.decimal?.left || 9) + ($.meta?.decimal?.right || 9),
-            n1: $.meta?.decimal?.right || 9
-        });
-    }
-    async manualReview(type, steps) {
-        let header_shown = false;
-        const header = () => {
-            if (header_shown)
-                return;
-            let str = '';
-            str += '┌\n';
-            str += `│ module: ${(0, string_1.colored)(this.module, 'cyan')}\n`;
-            str += `│ table: ${(0, string_1.colored)(this.tableName, 'lightcyan')}\n`;
-            str += `│ ${(0, string_1.colored)('⚠ Requires manual review.', 'red')}\n`;
-            str += '└\n\n';
-            console.clear();
-            console.log(str);
-            header_shown = true;
-        };
-        const fields = [];
-        for (const step of steps) {
-            const stepFields = step.options.filter(field => {
-                if (field.excluded_by.length === 0)
-                    return true;
-                return !field.excluded_by.some(field => field.selected);
-            });
-            let schema;
-            if (stepFields.length === 0) {
-                continue;
-            }
-            else if (stepFields.length === 1) {
-                schema = stepFields[0].schema;
-            }
-            else {
-                header();
-                const opt = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
-                const selected = await ui_1.default.select('Pick one of the options below:\n', stepFields.map((s, i) => `${(0, string_1.colored)(opt[i], 'lightcyan')} ${stepFields[i].schema.describe()}`));
-                console.log();
-                stepFields[selected.i].selected = true;
-                schema = stepFields[selected.i].schema;
-            }
-            if ('drop' in schema.operation && !schema.operation.drop.nullable) {
-                header();
-                const defaul = await ui_1.default.question(`Column '${schema.column}' is NOT NULL and is being deleted. What should be the default value on rollback?\n`);
-                schema.operation.drop.default = defaul;
-            }
-            if ('alter_type' in schema.operation) {
-                header();
-                const from = (0, string_1.colored)(schema.operation.alter_type.from, 'lightcyan');
-                const to = (0, string_1.colored)(schema.operation.alter_type.to, 'lightcyan');
-                const up = (0, string_1.colored)('▲ UP', 'lightgreen');
-                const down = (0, string_1.colored)('▼ DOWN', 'yellow');
-                const defaultUp = `${schema.column}::${schema.operation.alter_type.to}`;
-                const defaultDown = `${schema.column}::${schema.operation.alter_type.from}`;
-                const usingUp = await ui_1.default.question(`Column '${schema.column}' is changing from ${from} to ${to}. Write a cast expression for the ${up} migration.\n`, defaultUp);
-                const usingDown = await ui_1.default.question(`Column '${schema.column}' is changing from ${from} to ${to}. Write a cast expression for the ${down} migration.\n`, defaultDown);
-                schema.operation.alter_type.using.up = usingUp;
-                schema.operation.alter_type.using.down = usingDown;
-            }
-            fields.push(schema);
-        }
-        const migration = new migration_1.$Migration(this.module, type, this.tableName, fields);
-        console.clear();
-        console.log(migration.describe());
-        const proceed = await ui_1.default.yesOrNo('Is everything OK with the migration above?');
-        if (!proceed) {
-            log_1.Log.warn('migrator', 'generator', 'Migration rejected by manual review.');
-            return;
-        }
-        return migration;
-    }
-}
-exports.MigrationGenerator = MigrationGenerator;

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

@@ -1,66 +0,0 @@
-export type $MigrationFieldOperation = {
-    create: {
-        type: string;
-        nullable?: boolean;
-        pk?: boolean;
-    };
-} | {
-    rename: {
-        name: string;
-    };
-} | {
-    alter_type: {
-        from: string;
-        to: string;
-        using: {
-            up: string;
-            down: string;
-        };
-    };
-} | {
-    alter_null: {
-        from: boolean;
-        to: boolean;
-    };
-} | {
-    drop: {
-        type: string;
-        nullable: boolean;
-        default?: string;
-    };
-} | {
-    create_fk: {
-        table: string;
-        field: string;
-    };
-} | {
-    drop_fk: {
-        table: string;
-        field: string;
-    };
-};
-export declare class $MigrationField {
-    column: string;
-    operation: $MigrationFieldOperation;
-    constructor(column: string, operation: $MigrationFieldOperation);
-    describe(): string;
-    sqlUp(table_op: 'create' | 'alter'): string;
-    sqlDown(): string;
-}
-export declare class $Migration {
-    module: string;
-    private type;
-    private tableName;
-    private fields;
-    description?: string | undefined;
-    name: string;
-    constructor(module: string, type: 'create' | 'alter' | 'custom', tableName: string, fields: $MigrationField[], description?: string | undefined);
-    describe(): string;
-    sqlUp(): string[];
-    sqlDown(): string[];
-    save(dirpath?: string): string;
-    private fnUp;
-    private fnDown;
-    hash(): string;
-    static empty(module: string, name: string): $Migration;
-}

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

@@ -1,249 +0,0 @@
-"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.$Migration = exports.$MigrationField = void 0;
-const string_1 = require("../../../../../engine/util/string");
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs"));
-const datetime_1 = require("../../../../../engine/data/datetime");
-const crypto_1 = require("crypto");
-class $MigrationField {
-    constructor(column, operation) {
-        this.column = column;
-        this.operation = operation;
-    }
-    describe() {
-        const col_str = (0, string_1.colored)(this.column, 'lightblue');
-        if ('create' in this.operation) {
-            const type_str = (0, string_1.colored)(this.operation.create.type, 'purple');
-            return `Create column ${col_str} as ${type_str}`;
-        }
-        else if ('rename' in this.operation) {
-            const op = this.operation.rename;
-            const name_str = op.name ? (0, string_1.colored)(op.name, 'lightcyan') : undefined;
-            return `Rename column ${col_str} to ${name_str}`;
-        }
-        else if ('alter_type' in this.operation) {
-            const op = this.operation.alter_type;
-            const from_str = op.from ? (0, string_1.colored)(op.from, 'purple') : undefined;
-            const to_str = op.to ? (0, string_1.colored)(op.to, 'purple') : undefined;
-            return `Alter column ${col_str} type from ${from_str} to ${to_str};`;
-        }
-        else if ('alter_null' in this.operation) {
-            const op = this.operation.alter_null;
-            const from_str = (0, string_1.colored)(op.from ? 'NULL' : 'NOT NULL', 'purple');
-            const to_str = (0, string_1.colored)(op.to ? 'NULL' : 'NOT NULL', 'purple');
-            return `Alter column ${col_str} from ${from_str} to ${to_str};`;
-        }
-        else if ('drop' in this.operation) {
-            return `Drop column ${col_str}`;
-        }
-        else if ('create_fk' in this.operation) {
-            const op = this.operation.create_fk;
-            const table_str = (0, string_1.colored)(op.table, 'lightcyan');
-            const field_str = (0, string_1.colored)(op.field, 'purple');
-            return `Create foreign key from ${col_str} to ${table_str}.${field_str}`;
-        }
-        else if ('drop_fk' in this.operation) {
-            const op = this.operation.drop_fk;
-            const table_str = (0, string_1.colored)(op.table, 'lightcyan');
-            const field_str = (0, string_1.colored)(op.field, 'purple');
-            return `Drop foreign key from ${col_str} to ${table_str}.${field_str}`;
-        }
-        else {
-            return (0, string_1.colored)(`Unknown: ${this.operation}`, 'lightred');
-        }
-    }
-    sqlUp(table_op) {
-        if ('create' in this.operation) {
-            const notNull = this.operation.create.nullable ? '' : ' NOT NULL';
-            if (table_op === 'create') {
-                return `"${this.column}" ${this.operation.create.type} ${notNull}`;
-            }
-            else {
-                return `ADD "${this.column}" ${this.operation.create.type} ${notNull}`;
-            }
-        }
-        else if ('rename' in this.operation) {
-            return `RENAME COLUMN "${this.column}" TO "${this.operation.rename.name}"`;
-        }
-        else if ('alter_type' in this.operation) {
-            return `ALTER COLUMN "${this.column}" TYPE ${this.operation.alter_type.to} USING ${this.operation.alter_type.using.up}`;
-        }
-        else if ('alter_null' in this.operation) {
-            return `ALTER COLUMN "${this.column}" ${this.operation.alter_null.to ? 'DROP' : 'SET'} NOT NULL`;
-        }
-        else if ('drop' in this.operation) {
-            return `DROP COLUMN "${this.column}"`;
-        }
-        return '';
-    }
-    sqlDown() {
-        if ('create' in this.operation) {
-            return `DROP COLUMN "${this.column}"`;
-        }
-        else if ('rename' in this.operation) {
-            return `RENAME COLUMN "${this.operation.rename.name}" TO "${this.column}"`;
-        }
-        else if ('alter_type' in this.operation) {
-            return `ALTER COLUMN "${this.column}" TYPE ${this.operation.alter_type.from} USING ${this.operation.alter_type.using.down}`;
-        }
-        else if ('alter_null' in this.operation) {
-            return `ALTER COLUMN "${this.column}" ${this.operation.alter_null.from ? 'DROP' : 'SET'} NOT NULL`;
-        }
-        else if ('drop' in this.operation) {
-            const notNull = this.operation.drop.nullable ? '' : ' NOT NULL';
-            const defaul = this.operation.drop.default;
-            return `ADD COLUMN "${this.column}" ${this.operation.drop.type}${notNull}${defaul ? (' DEFAULT ' + defaul) : ''}`;
-        }
-        return '';
-    }
-}
-exports.$MigrationField = $MigrationField;
-class $Migration {
-    constructor(module, type, tableName, fields, description) {
-        this.module = module;
-        this.type = type;
-        this.tableName = tableName;
-        this.fields = fields;
-        this.description = description;
-        this.name = `${datetime_1.NesoiDatetime.now().epoch}_${this.tableName}`;
-    }
-    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 += '└\n\n';
-        if (this.type === 'create') {
-            str += `◆ Create table ${(0, string_1.colored)(this.tableName, 'lightblue')}\n`;
-        }
-        else if (this.type === 'alter') {
-            str += `◆ Alter table '${this.tableName}'\n`;
-        }
-        this.fields.forEach(field => {
-            str += `└ ${field.describe()}\n`;
-        });
-        str += '\n';
-        str += `${(0, string_1.colored)('▲ UP', 'lightgreen')}:\n`;
-        str += this.sqlUp().join('\n');
-        str += '\n';
-        str += `${(0, string_1.colored)('▼ DOWN', 'yellow')}:\n`;
-        str += this.sqlDown().join('\n');
-        return str;
-    }
-    sqlUp() {
-        if (this.type === 'create') {
-            return [`CREATE TABLE ${this.tableName} (\n` +
-                    this.fields.map(field => '\t' + field.sqlUp('create')).join(',\n')
-                    + '\n)'];
-        }
-        else if (this.type === 'alter') {
-            return this.fields.map(field => `ALTER TABLE ${this.tableName} ` + field.sqlUp('alter'));
-        }
-        return [];
-    }
-    sqlDown() {
-        if (this.type === 'create') {
-            return [`DROP TABLE ${this.tableName}`];
-        }
-        else if (this.type === 'alter') {
-            return this.fields.map(field => `ALTER TABLE ${this.tableName} ` + field.sqlDown());
-        }
-        return [];
-    }
-    save(dirpath = './migrations') {
-        const filedir = path.join('modules', this.module, dirpath);
-        fs.mkdirSync(filedir, { recursive: true });
-        const filepath = path.join(filedir, this.name + '.ts');
-        let str = '';
-        str += 'import { migration } from \'nesoi/lib/adapters/postgres/src/migrator\';\n';
-        str += '\n';
-        str += '/**\n';
-        str += ` * $migration[${this.name}]\n`;
-        str += ' *\n';
-        str += ` * $type[${this.type}]\n`;
-        if (this.type !== 'custom') {
-            str += ` * $table[${this.tableName}]\n`;
-            str += ' *\n';
-            str += ' * Migration auto-generated by @nesoi/postgres. Don\'t modify it manually.\n';
-        }
-        str += ' */\n';
-        str += '\n';
-        str += 'export default migration({\n';
-        if (this.type !== 'custom')
-            str += `\thash: '${this.hash()}',\n`;
-        str += `\tdescription: '${this.description || ''}',\n`;
-        str += '\tup: ' + this.fnUp().replace(/\n/g, '\n\t') + ',\n';
-        str += '\tdown: ' + this.fnDown().replace(/\n/g, '\n\t') + '\n';
-        str += '})';
-        fs.writeFileSync(filepath, str);
-        return filepath;
-    }
-    fnUp() {
-        let str = '';
-        str += 'async ({ sql }) => {\n';
-        this.sqlUp().forEach(sql => {
-            str += '\tawait sql`\n';
-            str += '\t\t' + sql.replace(/\n/g, '\n\t\t') + '\n';
-            str += '\t`\n';
-        });
-        str += '}';
-        return str;
-    }
-    fnDown() {
-        let str = '';
-        str += 'async ({ sql }) => {\n';
-        this.sqlDown().forEach(sql => {
-            str += '\tawait sql`\n';
-            str += '\t\t' + sql.replace(/\n/g, '\n\t\t') + '\n';
-            str += '\t`\n';
-        });
-        str += '}';
-        return str;
-    }
-    hash() {
-        const hash = (0, crypto_1.createHash)('md5');
-        const up = this.fnUp().replace(/\s*/g, '');
-        hash.update(up);
-        const down = this.fnDown().replace(/\s*/g, '');
-        hash.update(down);
-        return hash.digest('hex');
-    }
-    static empty(module, name) {
-        return new $Migration(module, 'custom', name, []);
-    }
-}
-exports.$Migration = $Migration;

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

@@ -1,19 +0,0 @@
-import postgres from 'postgres';
-import { $Space } from "../../../../../elements";
-import { AnyDaemon } from "../../../../../engine/daemon";
-import { MigrationRunnerStatus } from '../runner/status';
-import { $Migration } from './migration';
-export type MigratorConfig = {
-    dirpath?: string;
-    postgres?: postgres.Options<any>;
-};
-export declare class MigrationProvider<S extends $Space> {
-    protected daemon: AnyDaemon;
-    private sql;
-    dirpath: string;
-    status: MigrationRunnerStatus;
-    private constructor();
-    static create(daemon: AnyDaemon, sql: postgres.Sql<any>): Promise<MigrationProvider<$Space>>;
-    generate(): Promise<$Migration[]>;
-    generateForBucket<ModuleName extends keyof S['modules']>(module: ModuleName, bucket: keyof S['modules'][ModuleName]['buckets'], tableName: string): Promise<$Migration | undefined>;
-}