rake-db 1.3.2 → 2.0.0

package/dist/lib/migrate.js

@@ -1,189 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (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 (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rollback = exports.migrate = exports.run = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const utils_1 = require("./utils");
-const migration_1 = __importDefault(require("./migration"));
-const errorCodes_1 = require("./errorCodes");
-const ts_node_1 = require("ts-node");
-ts_node_1.register({ compilerOptions: { module: 'CommonJS' } });
-const getMigratedVersionsQuery = (db) => db.value(`SELECT COALESCE(json_agg("schemaMigrations".version ORDER BY version), '[]')` +
-    `FROM "schemaMigrations"`);
-const getMigratedVersions = async (db) => {
-    try {
-        return await getMigratedVersionsQuery(db);
-    }
-    catch (err) {
-        if (errorCodes_1.errorCodes[err.code] === 'undefined_table') {
-            await utils_1.createSchemaMigrations(db);
-            return await getMigratedVersionsQuery(db);
-        }
-        else {
-            throw err;
-        }
-    }
-};
-const getFiles = (migrationsPath, rollback) => new Promise((resolve, reject) => {
-    fs.readdir(migrationsPath, (err, allFiles) => {
-        if (err)
-            return reject(err);
-        if (rollback)
-            allFiles.sort((a, b) => (a < b ? 1 : -1));
-        else
-            allFiles.sort();
-        const files = [];
-        allFiles.forEach((file) => {
-            const arr = file.split('_');
-            const match = file.match(/\..+$/);
-            if (!match)
-                return;
-            const ext = match[0];
-            if (ext !== '.ts')
-                return;
-            if (arr.length === 1)
-                return;
-            const version = arr[0];
-            if (version.length !== 14)
-                return;
-            files.push({ version, path: file });
-        });
-        resolve(files);
-    });
-});
-const run = async (db, fn, version) => {
-    await db.wrapperTransaction(db, async (t) => {
-        if (fn.toString().startsWith('async')) {
-            await fn(t, !db.reverse);
-        }
-        else {
-            if (!db.reverse) {
-                fn(t, true);
-            }
-            else {
-                const originalExec = t.exec;
-                const argsList = []; // eslint-disable-line
-                t.exec = (...args) => {
-                    argsList.push(args);
-                    return Promise.resolve();
-                };
-                await fn(t, false);
-                t.exec = originalExec;
-                for (const [sql, value] of argsList.reverse()) {
-                    await t.exec(sql, value);
-                }
-            }
-        }
-        await t.sync();
-        if (t.failed)
-            return;
-        const sql = db.reverse
-            ? `DELETE FROM "schemaMigrations" WHERE "version" = '${version}'`
-            : `INSERT INTO "schemaMigrations"
-         VALUES ('${version}')`;
-        await t.exec(sql).catch(utils_1.noop);
-    });
-};
-exports.run = run;
-const migrateFile = async (db, migrationsPath, version, file) => {
-    const filePath = path.resolve(migrationsPath, file);
-    const migration = require(filePath);
-    if (!db.reverse && !migration.up && !migration.change)
-        throw new Error(`Migration ${file} does not contain up or change exports`);
-    else if (!migration.down && !migration.change)
-        throw new Error(`Migration ${file} does not contain down or change exports`);
-    if (migration.before) {
-        await migration.before(db, !db.reverse);
-    }
-    for (const key in migration) {
-        if (key === (db.reverse ? 'down' : 'up') || key === 'change') {
-            await exports.run(db, migration[key], version);
-        }
-    }
-    if (migration.after) {
-        await migration.after(db, !db.reverse);
-    }
-    console.info(`${filePath} ${db.reverse ? 'rolled back' : 'migrated'}`);
-};
-const migrateDb = async (db, migrationsPath, files) => {
-    for (const { path, version } of files) {
-        try {
-            await migrateFile(db, migrationsPath, version, path);
-        }
-        catch (err) {
-            console.error(err);
-            break;
-        }
-    }
-};
-const migrateOrRollbackDatabase = async (rollback, db, migrationsPath) => {
-    await db.connect();
-    let [files, versions] = (await Promise.all([
-        getFiles(migrationsPath, rollback),
-        getMigratedVersions(db),
-    ]));
-    versions = JSON.parse(versions);
-    if (rollback) {
-        const lastVersion = versions[versions.length - 1];
-        if (!lastVersion) {
-            files = [];
-        }
-        else {
-            const lastFile = files.find(({ version }) => version === lastVersion);
-            files = [lastFile];
-        }
-    }
-    else {
-        files = files.filter((file) => !versions.includes(file.version));
-    }
-    if (files.length)
-        await migrateDb(db, migrationsPath, files);
-};
-const migrateOrRollback = async (rollback) => {
-    const { migrationsPath, configs } = await utils_1.getConfig();
-    for (const config of configs) {
-        const db = new migration_1.default({ ...config, reverse: rollback });
-        try {
-            await migrateOrRollbackDatabase(rollback, db, migrationsPath);
-        }
-        catch (err) {
-            if (errorCodes_1.errorCodes[err.code] ===
-                'invalid_catalog_name') {
-                console.error(err.message);
-            }
-            else {
-                console.error(err);
-            }
-            break;
-        }
-        finally {
-            db.close();
-        }
-    }
-};
-const migrate = () => migrateOrRollback(false);
-exports.migrate = migrate;
-const rollback = () => migrateOrRollback(true);
-exports.rollback = rollback;

package/dist/lib/migration.d.ts

@@ -1,37 +0,0 @@
-import { Adapter, AdapterProps } from 'pg-adapter';
-import { ChangeTableCallback } from './schema/changeTable';
-import { TableOptions, JoinTableOptions, ColumnOptions, TableCallback, ForeignKeyOptions, IndexOptions } from '../types';
-export default class Migration extends Adapter {
-    reverse: boolean;
-    constructor({ reverse, ...params }: AdapterProps & {
-        reverse: boolean;
-    });
-    createTable(name: string, options?: TableOptions | TableCallback, fn?: TableCallback): void | Promise<unknown>;
-    changeTable(name: string, options?: TableOptions | ChangeTableCallback, fn?: ChangeTableCallback): void;
-    dropTable(name: string, options?: TableOptions | TableCallback, fn?: TableCallback): void | Promise<unknown>;
-    renameTable(from: string, to: string): void;
-    addColumn(table: string, name: string, type: string, options?: ColumnOptions): void;
-    addForeignKey(table: string, params: ForeignKeyOptions): void;
-    dropForeignKey(table: string, params: ForeignKeyOptions): void;
-    addPrimaryKey(table: string, columns: string[], name?: string): void;
-    dropPrimaryKey(table: string, columns: string[], name?: string): void;
-    addIndex(table: string, name: string, options?: IndexOptions): void;
-    dropIndex(table: string, name: string, options?: IndexOptions): void;
-    addTimestamps(table: string, options?: ColumnOptions): void;
-    dropTimestamps(table: string, options?: ColumnOptions): void;
-    changeColumn(table: string, name: string, options: ColumnOptions): void;
-    changeColumnComment(table: string, column: string, comment: string): void;
-    changeColumnDefault(table: string, column: string, value: unknown): void;
-    changeColumnNull(table: string, column: string, value: boolean): void;
-    changeTableComment(table: string, comment: string): void;
-    renameColumn(table: string, from: string, to: string): void;
-    dropColumn(table: string, name: string, type: string, options?: ColumnOptions): void;
-    columnExists(table: string, column: string): false | Promise<unknown>;
-    createJoinTable(tableOne: string, tableTwo: string, options?: JoinTableOptions | TableCallback, cb?: TableCallback): void;
-    dropJoinTable(tableOne: string, tableTwo: string, options?: JoinTableOptions | TableCallback, cb?: TableCallback): void;
-    foreignKeyExists(fromTable: string, options: string | {
-        name?: string;
-        column: string;
-    }): false | Promise<unknown>;
-    tableExists(table: string): false | Promise<unknown>;
-}

package/dist/lib/migration.js

@@ -1,159 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const pg_adapter_1 = require("pg-adapter");
-const createTable_1 = require("./schema/createTable");
-const changeTable_1 = require("./schema/changeTable");
-const utils_1 = require("./utils");
-const createTable = (db, name, fn, options) => new createTable_1.CreateTable(name, db.reverse, options).__commit(db, fn);
-const dropTable = (db, name) => db.exec(`DROP TABLE "${name}" CASCADE`).catch(utils_1.noop);
-const renameTable = (db, from, to) => db.exec(`ALTER TABLE "${from}" RENAME TO "${to}"`);
-const createJoinTable = (db, tableOne, tableTwo, options, cb) => {
-    const { tableName, columnOptions, references = true, ...tableOptions } = (typeof options === 'object' ? options : {});
-    if (tableOptions.id === undefined)
-        tableOptions.id = false;
-    if (tableOptions.unique === undefined)
-        tableOptions.unique = true;
-    const name = tableName || utils_1.join(...[tableOne, tableTwo].sort());
-    const col = { type: 'integer', null: false, ...columnOptions };
-    const firstColumnName = utils_1.join(tableOne, 'id');
-    const secondColumnName = utils_1.join(tableTwo, 'id');
-    const fn = (t) => {
-        let column = t.column(firstColumnName, col.type, col);
-        if (references)
-            column.references(tableOne, 'id');
-        column = t.column(secondColumnName, col.type, col);
-        if (references)
-            column.references(tableTwo, 'id');
-        if (tableOptions.unique)
-            t.index([firstColumnName, secondColumnName], {
-                name: `${name}_unique_index`,
-                unique: true,
-            });
-        if (cb)
-            cb(t);
-    };
-    return createTable(db, name, fn, tableOptions);
-};
-const dropJoinTable = (db, tableOne, tableTwo, options) => {
-    const tableName = typeof options === 'object' ? options.tableName : undefined;
-    dropTable(db, tableName || utils_1.join(...[tableOne, tableTwo].sort()));
-};
-class Migration extends pg_adapter_1.Adapter {
-    constructor({ reverse, ...params }) {
-        super({ ...params, pool: 1 });
-        this.reverse = reverse;
-    }
-    createTable(name, options, fn) {
-        if (this.reverse)
-            return dropTable(this, name);
-        if (typeof options === 'function') {
-            fn = options;
-            options = {};
-        }
-        return createTable(this, name, fn, options);
-    }
-    changeTable(name, options, fn) {
-        if (typeof options === 'function') {
-            fn = options;
-            options = {};
-        }
-        return new changeTable_1.ChangeTable(name, this.reverse, options).__commit(this, fn);
-    }
-    dropTable(name, options, fn) {
-        if (this.reverse) {
-            if (typeof options === 'function')
-                return new createTable_1.CreateTable(name, this.reverse).__commit(this, options);
-            else
-                return new createTable_1.CreateTable(name, this.reverse, options).__commit(this, fn);
-        }
-        return dropTable(this, name);
-    }
-    renameTable(from, to) {
-        if (this.reverse)
-            renameTable(this, to, from);
-        else
-            renameTable(this, from, to);
-    }
-    addColumn(table, name, type, options) {
-        this.changeTable(table, (t) => t.column(name, type, options));
-    }
-    addForeignKey(table, params) {
-        this.changeTable(table, (t) => t.foreignKey(params));
-    }
-    dropForeignKey(table, params) {
-        this.changeTable(table, (t) => t.dropForeignKey(params));
-    }
-    addPrimaryKey(table, columns, name) {
-        this.changeTable(table, (t) => t.primaryKey(columns, name));
-    }
-    dropPrimaryKey(table, columns, name) {
-        this.changeTable(table, (t) => t.dropPrimaryKey(columns, name));
-    }
-    addIndex(table, name, options) {
-        this.changeTable(table, (t) => t.index(name, options));
-    }
-    dropIndex(table, name, options) {
-        this.changeTable(table, (t) => t.dropIndex(name, options));
-    }
-    addTimestamps(table, options) {
-        this.changeTable(table, (t) => t.timestamps(options));
-    }
-    dropTimestamps(table, options) {
-        this.changeTable(table, (t) => t.dropTimestamps(options));
-    }
-    changeColumn(table, name, options) {
-        this.changeTable(table, (t) => t.change(name, options));
-    }
-    changeColumnComment(table, column, comment) {
-        this.changeTable(table, (t) => t.comment(column, comment));
-    }
-    changeColumnDefault(table, column, value) {
-        this.changeTable(table, (t) => t.default(column, value));
-    }
-    changeColumnNull(table, column, value) {
-        this.changeTable(table, (t) => t.null(column, value));
-    }
-    changeTableComment(table, comment) {
-        this.changeTable(table, { comment });
-    }
-    renameColumn(table, from, to) {
-        this.changeTable(table, (t) => t.rename(from, to));
-    }
-    dropColumn(table, name, type, options) {
-        this.changeTable(table, (t) => t.drop(name, type, options));
-    }
-    columnExists(table, column) {
-        const value = this.value('SELECT 1 FROM "information_schema"."columns" ' +
-            `WHERE "table_name" = '${table}' AND "column_name" = '${column}'`);
-        return this.reverse ? !value : value;
-    }
-    createJoinTable(tableOne, tableTwo, options, cb) {
-        if (this.reverse)
-            return dropJoinTable(this, tableOne, tableTwo, options);
-        createJoinTable(this, tableOne, tableTwo, options, cb);
-    }
-    dropJoinTable(tableOne, tableTwo, options, cb) {
-        if (this.reverse) {
-            this.reverse = false;
-            createJoinTable(this, tableOne, tableTwo, options, cb);
-            this.reverse = true;
-        }
-        dropJoinTable(this, tableOne, tableTwo, options);
-    }
-    foreignKeyExists(fromTable, options) {
-        let name;
-        if (typeof options === 'string')
-            name = utils_1.join(fromTable, options, 'id', 'fkey');
-        else
-            name = options.name || utils_1.join(fromTable, options.column, 'fkey');
-        const value = this.value('SELECT 1 FROM "information_schema"."table_constraints" ' +
-            `WHERE "constraint_name" = '${name}'`);
-        return this.reverse ? !value : value;
-    }
-    tableExists(table) {
-        const value = this.value('SELECT FROM "information_schema"."tables" ' +
-            `WHERE "table_name" = '${table}'`);
-        return this.reverse ? !value : value;
-    }
-}
-exports.default = Migration;

package/dist/lib/schema/changeTable.d.ts

@@ -1,23 +0,0 @@
-import Table from './table';
-import { Column } from './column';
-import { Migration, ColumnOptions, IndexOptions, ForeignKeyFunction, ColumnFunction } from '../../types';
-import { PrimaryKey } from './primaryKey';
-export declare type ChangeTableCallback = (t: ChangeTable) => void;
-export declare class ChangeTable extends Table {
-    constraint: (name: string, sql?: string | undefined) => void;
-    removeConstraint: (name: string, sql?: string | undefined) => void;
-    dropTimestamps: (options?: ColumnOptions | undefined) => void;
-    column: ColumnFunction;
-    change: (name: string, options?: ColumnOptions | undefined) => Column;
-    rename: (from: string, to: string) => void;
-    comment: (column: string, message: string) => void;
-    default: (column: string, value: unknown) => void;
-    null: (column: string, value: boolean) => void;
-    drop: (name: string, type: string, options?: ColumnOptions | undefined) => Column;
-    dropIndex: (name: string | string[], options?: true | IndexOptions) => number;
-    foreignKey: ForeignKeyFunction;
-    dropForeignKey: ForeignKeyFunction;
-    primaryKey: (columns: string[], name?: string | undefined) => PrimaryKey;
-    dropPrimaryKey: (columns: string[], name?: string | undefined) => PrimaryKey;
-    __commit: (db: Migration, fn?: ChangeTableCallback | undefined) => void;
-}

package/dist/lib/schema/changeTable.js

@@ -1,109 +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.ChangeTable = void 0;
-const table_1 = __importDefault(require("./table"));
-const column_1 = require("./column");
-const index_1 = require("./index");
-const utils_1 = require("../utils");
-const foreignKey_1 = require("./foreignKey");
-const primaryKey_1 = require("./primaryKey");
-const addConstraint = (name, sql) => `ADD CONSTRAINT ${sql ? `"${name}" ${sql}` : name}`;
-const removeConstraint = (name) => `DROP CONSTRAINT "${name}"`;
-class ChangeTable extends table_1.default {
-    constructor() {
-        super(...arguments);
-        this.constraint = (name, sql) => {
-            this.execute(this.reverse ? removeConstraint(name) : addConstraint(name, sql));
-        };
-        this.removeConstraint = (name, sql) => this.execute(this.reverse ? addConstraint(name, sql) : removeConstraint(name));
-        this.dropTimestamps = (options) => {
-            this.reverse = !this.reverse;
-            this.timestamps(options);
-            this.reverse = !this.reverse;
-        };
-        this.column = (name, type, options = {}) => {
-            if (this.reverse) {
-                this.removedColumns.push(name);
-                const column = new column_1.Column('drop', name, options, type);
-                this.lines.push(column);
-                return column;
-            }
-            const column = new column_1.Column('add', name, options, type);
-            this.lines.push(column);
-            return column;
-        };
-        this.change = (name, options) => {
-            const column = new column_1.Column('alter', name, options);
-            this.lines.push(column);
-            return column;
-        };
-        this.rename = (from, to) => {
-            const f = this.reverse ? to : from;
-            const t = this.reverse ? from : to;
-            this.execute(`RENAME COLUMN "${f}" TO "${t}"`);
-        };
-        this.comment = (column, message) => {
-            this.comments.push([column, message]);
-        };
-        this.default = (column, value) => {
-            this.lines.push(new column_1.Column('alter', column, { default: value }));
-        };
-        this.null = (column, value) => {
-            this.lines.push(new column_1.Column('alter', column, { null: value }));
-        };
-        this.drop = (name, type, options) => {
-            const column = new column_1.Column(this.reverse ? 'add' : 'drop', name, options, type);
-            this.lines.push(column);
-            return column;
-        };
-        this.dropIndex = (name, options = {}) => this.indices.push([this.reverse, name, options]);
-        this.foreignKey = (options) => {
-            const fkey = new foreignKey_1.ForeignKey('changeTable', this, this.reverse, options);
-            this.lines.push(fkey);
-            return fkey;
-        };
-        this.dropForeignKey = (options) => {
-            const fkey = new foreignKey_1.ForeignKey('changeTable', this, !this.reverse, options);
-            this.lines.push(fkey);
-            return fkey;
-        };
-        this.primaryKey = (columns, name) => {
-            const pkey = new primaryKey_1.PrimaryKey('add', columns, name);
-            this.lines.push(pkey);
-            return pkey;
-        };
-        this.dropPrimaryKey = (columns, name) => {
-            const pkey = new primaryKey_1.PrimaryKey('drop', columns, name);
-            this.lines.push(pkey);
-            return pkey;
-        };
-        this.__commit = (db, fn) => {
-            this.reverse = db.reverse;
-            if (fn)
-                fn(this);
-            if (this.lines.length) {
-                const lines = [];
-                this.lines.forEach((line) => {
-                    const item = typeof line === 'string' ? line : line.toSql(this);
-                    if (!item)
-                        return;
-                    typeof item === 'string' ? lines.push(item) : lines.push(...item);
-                });
-                const sql = `ALTER TABLE "${this.tableName}"\n` + lines.join(',\n');
-                db.exec(sql).catch(utils_1.noop);
-            }
-            for (const args of this.indices) {
-                const [create, name, options] = args;
-                if (create)
-                    db.exec(index_1.addIndex(this.tableName, name, options)).catch(utils_1.noop);
-                else
-                    db.exec(index_1.dropIndex(this.tableName, name, options)).catch(utils_1.noop);
-            }
-            this.addComments(db);
-        };
-    }
-}
-exports.ChangeTable = ChangeTable;

package/dist/lib/schema/column.d.ts

@@ -1,31 +0,0 @@
-import { ColumnOptions, IndexOptions, OnUpdateOrDeleteAction } from '../../types';
-import { CreateTable } from './createTable';
-import { ChangeTable } from './changeTable';
-export declare class Column {
-    action: 'create' | 'add' | 'alter' | 'drop';
-    name: string;
-    options: ColumnOptions;
-    _type?: string | undefined;
-    constructor(action: 'create' | 'add' | 'alter' | 'drop', name: string, options?: ColumnOptions, _type?: string | undefined);
-    primaryKey(): this;
-    type(type: string): this;
-    default(value: any): this;
-    required(): this;
-    optional(): this;
-    index(options?: boolean | IndexOptions): this;
-    comment(comment: string): this;
-    mode(mode: string): this;
-    unique(): this;
-    length(length: number | string): this;
-    precision(precision: number | string): this;
-    scale(scale: number | string): this;
-    collate(collate: string): this;
-    using(using: string): this;
-    references(table: string, column?: string): this;
-    column(column: string): this;
-    onUpdate(action: OnUpdateOrDeleteAction): this;
-    onDelete(action: OnUpdateOrDeleteAction): this;
-    toSql(table: CreateTable | ChangeTable): string | string[];
-    private alterColumn;
-    private getTypeSql;
-}