nesoi 3.0.6 → 3.0.9

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

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

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

@@ -1,57 +0,0 @@
-export type MigrationFieldOperation = {
-    create: {
-        type: string;
-        nullable?: boolean;
-        pk?: boolean;
-        fk?: string;
-    };
-} | {
-    alter: {
-        name?: string;
-        type?: string;
-        nullable?: boolean;
-        fk?: string;
-    };
-} | {
-    drop: {
-        cascade?: boolean;
-    };
-};
-export declare class MigrationField {
-    oldColumn: string | undefined;
-    newColumn: string;
-    operation: MigrationFieldOperation;
-    constructor(oldColumn: string | undefined, newColumn: string, operation: MigrationFieldOperation);
-    describe(): string;
-    sql(): string | undefined;
-}
-export declare class Migration {
-    module: string;
-    private type;
-    private tableName;
-    private options;
-    name: string;
-    private fields;
-    private needsReview;
-    constructor(module: string, type: 'create' | 'alter', tableName: string, options: Record<string, MigrationField[]>);
-    describe(): string;
-    sqlUp(): string;
-    sqlDown(): string;
-    save(dirpath?: string): void;
-    hash(): string;
-    /**
-     * Generates an encoded version of the migration, which is
-     * stored as a comment on the migration file. This can be
-     * used to recreate the `Migration` object in memory if needed.
-     * > **Attention** This encoded version is NOT used to run the migration.
-     * > The SQL is used to run the migration. This can be used
-     * > for analysis/display purposes only.
-     * > There's no guarantee that this will match the SQL if
-     * > the migration file is manually altered.
-     * @returns
-     */
-    private encode;
-    private decode;
-    private fnUp;
-    private fnDown;
-}

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

@@ -1,203 +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 crypto_1 = require("crypto");
-const datetime_1 = require("../../../../engine/data/datetime");
-class MigrationField {
-    constructor(oldColumn, newColumn, operation) {
-        this.oldColumn = oldColumn;
-        this.newColumn = newColumn;
-        this.operation = operation;
-    }
-    describe() {
-        const col_str = (0, string_1.colored)(this.newColumn, '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 ('alter' in this.operation) {
-            const op = this.operation.alter;
-            const name_str = op.name ? (0, string_1.colored)(op.name, 'lightcyan') : undefined;
-            const type_str = op.type ? (0, string_1.colored)(op.type, 'purple') : undefined;
-            const null_str = op.nullable ? (0, string_1.colored)('NOT NULL', 'purple') : undefined;
-            const props = (type_str ? `Alter column ${col_str} type to ${type_str};` : '') +
-                (null_str ? `Alter column ${col_str} nullable to ${null_str};` : '');
-            if (name_str) {
-                return `Rename column ${col_str} to ${name_str}.${props}`;
-            }
-            return props;
-        }
-        else {
-            return (0, string_1.colored)('Unknown', 'lightred');
-        }
-    }
-    sql() {
-        if ('create' in this.operation) {
-            return `"${this.newColumn}" ${this.operation.create.type}`;
-        }
-    }
-}
-exports.MigrationField = MigrationField;
-class Migration {
-    constructor(module, type, tableName, options) {
-        this.module = module;
-        this.type = type;
-        this.tableName = tableName;
-        this.options = options;
-        this.name = `${datetime_1.NesoiDatetime.now().epoch}_${this.tableName}`;
-        this.needsReview = Object.values(options).some(opts => opts.length > 1);
-        this.fields = Object.values(options).map(opts => opts[0]);
-    }
-    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')
-            : (0, string_1.colored)('✓ Only one option for each field.', 'lightgreen')}\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();
-        str += '\n';
-        str += `${(0, string_1.colored)('▼ DOWN', 'yellow')}:\n`;
-        str += this.sqlDown();
-        return str;
-    }
-    sqlUp() {
-        if (this.type === 'create') {
-            return `CREATE TABLE ${this.tableName} (\n` +
-                this.fields.map(field => '\t' + field.sql()).join(',\n')
-                + '\n)';
-        }
-        return '';
-    }
-    sqlDown() {
-        if (this.type === 'create') {
-            return `DROP TABLE ${this.tableName}`;
-        }
-        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');
-        const { encoded, hash } = this.encode();
-        let str = '';
-        str += 'import { Migrator } from \'nesoi/lib/adapters/postgres/src/migrator\';\n';
-        str += '\n';
-        str += '/**\n';
-        str += ` * ${this.name}\n`;
-        str += ` * $hash[${hash}]\n`;
-        str += ' *\n';
-        str += ` * $type[${this.type}]\n`;
-        str += ` * $table[${this.tableName}]\n`;
-        str += ` * $fields[${encoded}]\n`;
-        str += ' */\n';
-        str += '\n';
-        str += 'export default Migrator.migration({\n';
-        str += '\t' + this.fnUp().replace(/\n/g, '\n\t') + ',\n';
-        str += '\t' + this.fnDown().replace(/\n/g, '\n\t') + '\n';
-        str += '})';
-        fs.writeFileSync(filepath, str);
-    }
-    hash() {
-        const { hash } = this.encode();
-        return hash;
-    }
-    /**
-     * Generates an encoded version of the migration, which is
-     * stored as a comment on the migration file. This can be
-     * used to recreate the `Migration` object in memory if needed.
-     * > **Attention** This encoded version is NOT used to run the migration.
-     * > The SQL is used to run the migration. This can be used
-     * > for analysis/display purposes only.
-     * > There's no guarantee that this will match the SQL if
-     * > the migration file is manually altered.
-     * @returns
-     */
-    encode() {
-        const v0 = () => {
-            const f_str = this.fields.map(field => {
-                const [op_key, op] = Object.entries(field.operation)[0];
-                const op_str = `[${op_key};${op.type || ''};${op.nullable ? 1 : 0};${op.pk ? 1 : 0};${op.fk || ''};${op.cascade || ''}]`;
-                return `${field.oldColumn || ''}:${field.newColumn}:${op_str}`;
-            }).join('\n');
-            const encoded = btoa(f_str);
-            const hash = (0, crypto_1.createHash)('md5').update(encoded).digest('hex');
-            return {
-                encoded,
-                hash: 'v0.' + hash
-            };
-        };
-        return v0();
-    }
-    decode() {
-        // TODO
-    }
-    fnUp() {
-        let str = '';
-        str += 'up: async ({ sql }) => {\n';
-        str += '\tawait sql`\n';
-        str += '\t\t' + this.sqlUp().replace(/\n/g, '\n\t\t') + '\n';
-        str += '\t`\n';
-        str += '}';
-        return str;
-    }
-    fnDown() {
-        let str = '';
-        str += 'down: async ({ sql }) => {\n';
-        str += '\tawait sql`\n';
-        str += '\t\t' + this.sqlDown().replace(/\n/g, '\n\t\t') + '\n';
-        str += '\t`\n';
-        str += '}';
-        return str;
-    }
-}
-exports.Migration = Migration;

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

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

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

@@ -1,71 +0,0 @@
-import postgres from 'postgres';
-import { Migration } from './migration';
-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;
-    timestamp: string;
-    hash: string;
-    filehash: string;
-};
-export declare class MigrationMethod {
-    description?: string;
-    up: MigrationFn;
-    down: MigrationFn;
-    constructor($: {
-        description?: string;
-        up: MigrationFn;
-        down: MigrationFn;
-    });
-}
-export declare class MigrationStatus {
-    items: {
-        state: 'done' | 'pending' | 'lost';
-        id?: number;
-        module: string;
-        name: string;
-        description?: string;
-        batch?: number;
-        timestamp?: string;
-        hash: string;
-        filehash?: string;
-        method?: MigrationMethod;
-    }[];
-    batch: number;
-    constructor(fileMigrations: {
-        module: string;
-        name: string;
-        hash: string;
-        path: string;
-        method: MigrationMethod;
-    }[], dbMigrations: MigrationRow[]);
-    describe(): string;
-}
-export declare class MigrationRunner {
-    dirpath: string;
-    private migrations;
-    private constructor();
-    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(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 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 {};