nesoi 3.0.6 → 3.0.9

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

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

@@ -0,0 +1,19 @@
+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>;
+}

package/lib/adapters/postgres/src/migrator/{migrator.js → generator/provider.js}

@@ -1,36 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Migrator = void 0;
-const log_1 = require("../../../../engine/util/log");
-const runner_1 = require("./runner");
-const daemon_1 = require("../../../../engine/daemon");
-const string_1 = require("../../../../engine/util/string");
-const bucket_1 = require("./bucket");
-class Migrator {
+exports.MigrationProvider = void 0;
+const log_1 = require("../../../../../engine/util/log");
+const runner_1 = require("../runner/runner");
+const daemon_1 = require("../../../../../engine/daemon");
+const postgres_bucket_adapter_1 = require("../../postgres.bucket_adapter");
+const string_1 = require("../../../../../engine/util/string");
+const generator_1 = require("./generator");
+class MigrationProvider {
     constructor(daemon, sql, dirpath = './migrations') {
         this.daemon = daemon;
         this.sql = sql;
         this.dirpath = dirpath;
     }
-    static async prepare(daemon, sql) {
-        const migrator = new Migrator(daemon, sql);
-        const oldTable = await migrator.sql `
-            SELECT * FROM pg_catalog.pg_tables WHERE tablename = ${Migrator.MIGRATION_TABLE_NAME};
+    static async create(daemon, sql) {
+        const provider = new MigrationProvider(daemon, sql);
+        const oldTable = await provider.sql `
+            SELECT * FROM pg_catalog.pg_tables WHERE tablename = ${runner_1.MigrationRunner.MIGRATION_TABLE_NAME};
         `;
         if (!oldTable.length) {
-            await migrator.sql `CREATE TABLE ${migrator.sql(Migrator.MIGRATION_TABLE_NAME)} (
+            await provider.sql `CREATE TABLE ${provider.sql(runner_1.MigrationRunner.MIGRATION_TABLE_NAME)} (
                 id SERIAL PRIMARY KEY,
                 module VARCHAR NOT NULL,
                 name VARCHAR NOT NULL,
                 description VARCHAR,
                 batch INT4 NOT NULL,
                 timestamp TIMESTAMP NOT NULL,
-                hash VARCHAR NOT NULL,
-                filehash VARCHAR NOT NULL
+                hash VARCHAR
             )`;
         }
-        migrator.status = await runner_1.MigrationRunner.status(daemon, migrator.sql, migrator.dirpath);
-        return migrator;
+        provider.status = await runner_1.MigrationRunner.status(daemon, provider.sql, provider.dirpath);
+        return provider;
     }
     async generate() {
         const modules = daemon_1.Daemon.getModules(this.daemon);
@@ -39,10 +39,12 @@ class Migrator {
             const buckets = daemon_1.Daemon.getModule(this.daemon, module.name).buckets;
             for (const bucket in buckets) {
                 const schema = buckets[bucket].schema;
+                // Avoid external buckets
                 if (schema.module !== module.name)
                     continue;
+                // Avoid non-postgres buckets
                 const adapter = buckets[bucket].adapter;
-                if (!adapter?.tableName)
+                if (!(adapter instanceof postgres_bucket_adapter_1.PostgresBucketAdapter))
                     continue;
                 const migration = await this.generateForBucket(module.name, bucket, adapter.tableName);
                 if (migration) {
@@ -53,11 +55,11 @@ class Migrator {
         return migrations;
     }
     async generateForBucket(module, bucket, tableName) {
-        const migrator = new bucket_1.BucketMigrator(this.daemon, this.sql, module, bucket, tableName);
-        const migration = await migrator.generate();
+        const generator = new generator_1.MigrationGenerator(this.daemon, this.sql, module, bucket, tableName);
+        const migration = await generator.generate();
         const tag = (0, string_1.colored)(`${module}::bucket:${bucket}`, 'lightcyan');
         if (!migration) {
-            log_1.Log.info('migrator', 'bucket', `No changes detected on ${tag}.`);
+            log_1.Log.info('migrator', 'bucket', `No migrations for ${tag}.`);
             return undefined;
         }
         const hash = migration.hash();
@@ -68,9 +70,5 @@ class Migrator {
         }
         return migration;
     }
-    static migration(...$) {
-        return new runner_1.MigrationMethod(...$);
-    }
 }
-exports.Migrator = Migrator;
-Migrator.MIGRATION_TABLE_NAME = '__nesoi_migrations';
+exports.MigrationProvider = MigrationProvider;

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

@@ -1 +1,47 @@
-export { Migrator } from './migrator';
+import postgres from 'postgres';
+import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+type MigrationFn = ($: {
+    sql: postgres.Sql<any>;
+    trx: AnyTrxNode;
+}) => Promise<void>;
+/**
+ * An entry on a bucket adapter describing one migration.
+ */
+export type MigrationRow = {
+    id: number;
+    module: string;
+    name: string;
+    description?: string;
+    batch: number;
+    timestamp: string;
+    hash: string;
+};
+/**
+ * A file on disk describing one migration.
+ */
+export type MigrationFile = {
+    module: string;
+    name: string;
+    path: string;
+    routine: MigrationRoutine;
+};
+/**
+ * A migration routine, composed of up and down methods.
+ */
+export declare class MigrationRoutine {
+    hash?: string;
+    description?: string;
+    up: MigrationFn;
+    down: MigrationFn;
+    constructor($: {
+        hash?: string;
+        description?: string;
+        up: MigrationFn;
+        down: MigrationFn;
+    });
+}
+/**
+ * Function used on migration files to declare a routine
+ */
+export declare function migration(...$: ConstructorParameters<typeof MigrationRoutine>): MigrationRoutine;
+export {};

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

@@ -1,5 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Migrator = void 0;
-var migrator_1 = require("./migrator");
-Object.defineProperty(exports, "Migrator", { enumerable: true, get: function () { return migrator_1.Migrator; } });
+exports.MigrationRoutine = void 0;
+exports.migration = migration;
+/**
+ * A migration routine, composed of up and down methods.
+ */
+class MigrationRoutine {
+    constructor($) {
+        this.hash = $.hash;
+        this.description = $.description;
+        this.up = $.up;
+        this.down = $.down;
+    }
+}
+exports.MigrationRoutine = MigrationRoutine;
+/**
+ * Function used on migration files to declare a routine
+ */
+function migration(...$) {
+    return new MigrationRoutine(...$);
+}

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

@@ -0,0 +1,17 @@
+import postgres from 'postgres';
+import { AnyDaemon } from "../../../../../engine/daemon";
+import { MigrationRunnerStatus } from './status';
+import { $Migration } from '../generator/migration';
+export declare class MigrationRunner {
+    static MIGRATION_TABLE_NAME: string;
+    private static scanFiles;
+    private static scanRows;
+    static status(daemon: AnyDaemon, sql: postgres.Sql<any>, migrations_dir: string): Promise<MigrationRunnerStatus>;
+    static up(daemon: AnyDaemon, sql: postgres.Sql<any>, mode?: 'one' | 'batch', dirpath?: string): Promise<void>;
+    static down(daemon: AnyDaemon, sql: postgres.Sql<any>, mode?: 'one' | 'batch', dirpath?: string): Promise<void>;
+    static fromSchema: {
+        up: (daemon: AnyDaemon, sql: postgres.Sql<any>, migration: $Migration, dirpath?: string) => Promise<void>;
+    };
+    private static migrateUp;
+    private static migrateDown;
+}