rake-db 1.3.2 → 2.0.0

package/dist/lib/schema/column.js

@@ -1,201 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Column = void 0;
-class Column {
-    constructor(action, name, options = {}, _type) {
-        this.action = action;
-        this.name = name;
-        this.options = options;
-        this._type = _type;
-    }
-    primaryKey() {
-        this.options = { ...this.options, primaryKey: true };
-        return this;
-    }
-    type(type) {
-        this.options = { ...this.options, type };
-        return this;
-    }
-    default(value) {
-        this.options = { ...this.options, default: value };
-        return this;
-    }
-    required() {
-        this.options = { ...this.options, null: false };
-        return this;
-    }
-    optional() {
-        this.options = { ...this.options, null: true };
-        return this;
-    }
-    index(options) {
-        this.options = { ...this.options, index: options !== null && options !== void 0 ? options : true };
-        return this;
-    }
-    comment(comment) {
-        this.options = { ...this.options, comment };
-        return this;
-    }
-    mode(mode) {
-        this.options = { ...this.options, mode };
-        return this;
-    }
-    unique() {
-        if (typeof this.options.index === 'object') {
-            this.options = {
-                ...this.options,
-                index: { ...this.options.index, unique: true },
-            };
-        }
-        else {
-            this.options = { ...this.options, index: { unique: true } };
-        }
-        return this;
-    }
-    length(length) {
-        this.options = { ...this.options, length };
-        return this;
-    }
-    precision(precision) {
-        this.options = { ...this.options, precision };
-        return this;
-    }
-    scale(scale) {
-        this.options = { ...this.options, scale };
-        return this;
-    }
-    collate(collate) {
-        this.options = { ...this.options, collate };
-        return this;
-    }
-    using(using) {
-        this.options = { ...this.options, using };
-        return this;
-    }
-    references(table, column) {
-        this.options = { ...this.options, references: { table, column } };
-        return this;
-    }
-    column(column) {
-        if (!this.options.references) {
-            throw new Error('Please specify table for references');
-        }
-        this.options = {
-            ...this.options,
-            references: { ...this.options.references, column },
-        };
-        return this;
-    }
-    onUpdate(action) {
-        if (!this.options.references) {
-            throw new Error('Please specify table for references');
-        }
-        this.options = {
-            ...this.options,
-            references: { ...this.options.references, onUpdate: action },
-        };
-        return this;
-    }
-    onDelete(action) {
-        if (!this.options.references) {
-            throw new Error('Please specify table for references');
-        }
-        this.options = {
-            ...this.options,
-            references: { ...this.options.references, onDelete: action },
-        };
-        return this;
-    }
-    toSql(table) {
-        const { action, options, name } = this;
-        if (action === 'drop') {
-            const sql = ['DROP COLUMN', `"${name}"`];
-            let { mode } = options;
-            if (mode) {
-                mode = mode.toUpperCase();
-                sql.push(mode);
-            }
-            else {
-                sql.push('CASCADE');
-            }
-            return sql.join(' ');
-        }
-        if ('comment' in options && options.comment)
-            table.comments.push([name, options.comment]);
-        if (this.action === 'alter') {
-            const sql = [];
-            if ((this.options.type && options.default) || options.default === null)
-                this.alterColumn(sql, name, 'DROP DEFAULT');
-            if (options.type)
-                this.alterColumn(sql, name, `TYPE ${this.getTypeSql(options.type)}`);
-            if (options.default !== undefined && options.default !== null)
-                this.alterColumn(sql, name, `SET DEFAULT ${options.default}`);
-            if (options.null !== undefined)
-                this.alterColumn(sql, name, options.null ? 'DROP NOT NULL' : 'SET NOT NULL');
-            if ((!table.reverse && options.index) ||
-                (table.reverse && options.index === false)) {
-                table.index(name, options.index || options);
-            }
-            else if ((!table.reverse && options.index === false) ||
-                (table.reverse && options.index)) {
-                ;
-                table.dropIndex(name, options.index || options);
-            }
-            return sql;
-        }
-        const sql = [
-            this.action === 'create' ? `"${name}"` : `ADD COLUMN "${name}"`,
-        ];
-        const type = options.type || this._type;
-        if (!type)
-            throw new Error('Type is not specified');
-        sql.push(this.getTypeSql(type));
-        if (options.primaryKey)
-            sql.push('PRIMARY KEY');
-        if (options.null === false)
-            sql.push('NOT NULL');
-        if (options.default !== undefined)
-            sql.push(`DEFAULT ${options.default}`);
-        const { references } = options;
-        if (references) {
-            sql.push(`REFERENCES "${references.table}"`);
-            if (references.column)
-                sql.push(`("${references.column}")`);
-            if (references.onUpdate)
-                sql.push(`ON UPDATE ${references.onUpdate}`);
-            if (references.onDelete)
-                sql.push(`ON DELETE ${references.onDelete}`);
-        }
-        if (options.unique) {
-            if (options.index === true || !options.index)
-                options.index = { unique: true };
-            else
-                options.index.unique = true;
-        }
-        if (options.index) {
-            table.index(name, options.index);
-        }
-        return sql.join(' ');
-    }
-    alterColumn(arr, name, sql) {
-        arr.push(`ALTER COLUMN "${name}" ${sql}`);
-    }
-    getTypeSql(type) {
-        const { options } = this;
-        const sql = [type];
-        if (options.length)
-            sql.push(`(${options.length})`);
-        else if (options.precision !== undefined && options.scale === undefined)
-            sql.push(`(${options.precision})`);
-        else if (options.precision === undefined && options.scale !== undefined)
-            sql.push(`(${options.scale})`);
-        else if (options.precision !== undefined && options.scale !== undefined)
-            sql.push(`(${options.precision}, ${options.scale})`);
-        if (options.collate)
-            sql.push('COLLATE', options.collate);
-        if (options.using)
-            sql.push('USING', options.using);
-        return sql.join(' ');
-    }
-}
-exports.Column = Column;

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

@@ -1,10 +0,0 @@
-import Table from './table';
-import { ForeignKeyFunction, Migration, TableCallback, TableOptions } from '../../types';
-import { PrimaryKey } from './primaryKey';
-export declare class CreateTable extends Table {
-    constructor(tableName: string, reverse: boolean, options?: TableOptions);
-    foreignKey: ForeignKeyFunction;
-    constraint: (name: string, sql?: string | undefined) => void;
-    primaryKey: (columns: string[], name?: string | undefined) => PrimaryKey;
-    __commit: (db: Migration, fn?: TableCallback | undefined) => void;
-}

package/dist/lib/schema/createTable.js

@@ -1,53 +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.CreateTable = void 0;
-const table_1 = __importDefault(require("./table"));
-const index_1 = require("./index");
-const utils_1 = require("../utils");
-const foreignKey_1 = require("./foreignKey");
-const primaryKey_1 = require("./primaryKey");
-class CreateTable extends table_1.default {
-    constructor(tableName, reverse, options = {}) {
-        super(tableName, reverse, options);
-        this.foreignKey = (options) => {
-            const fkey = new foreignKey_1.ForeignKey('createTable', this, this.reverse, options);
-            this.lines.push(fkey);
-            return fkey;
-        };
-        this.constraint = (name, sql) => this.execute(`CONSTRAINT ${sql ? `"${name}" ${sql}` : name}`);
-        this.primaryKey = (columns, name) => {
-            const pkey = new primaryKey_1.PrimaryKey('create', columns, name);
-            this.lines.push(pkey);
-            return pkey;
-        };
-        this.__commit = (db, fn) => {
-            if (fn)
-                fn(this);
-            const sql = [];
-            sql.push(`CREATE TABLE "${this.tableName}" (`);
-            if (this.lines.length) {
-                sql.push('\n  ' +
-                    this.lines
-                        .map((item) => (typeof item === 'string' ? item : item.toSql(this)))
-                        .filter((string) => string)
-                        .join(',\n  '));
-            }
-            sql.push('\n)');
-            db.exec(sql.join('')).catch(utils_1.noop);
-            for (const args of this.indices) {
-                const [create, column, options] = args;
-                if (create)
-                    db.exec(index_1.addIndex(this.tableName, column, options)).catch(utils_1.noop);
-            }
-            this.addComments(db);
-        };
-        if (options.id !== false) {
-            this.reverse = false;
-            this.serial('id', { primaryKey: true });
-        }
-    }
-}
-exports.CreateTable = CreateTable;

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

@@ -1,11 +0,0 @@
-import { ForeignKeyOptions } from '../../types';
-import { CreateTable } from './createTable';
-import { ChangeTable } from './changeTable';
-export declare class ForeignKey {
-    action: 'createTable' | 'changeTable';
-    table: CreateTable | ChangeTable;
-    reverse: boolean;
-    options: ForeignKeyOptions;
-    constructor(action: 'createTable' | 'changeTable', table: CreateTable | ChangeTable, reverse: boolean, options: ForeignKeyOptions);
-    toSql(): undefined | string;
-}

package/dist/lib/schema/foreignKey.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ForeignKey = void 0;
-const utils_1 = require("../utils");
-class ForeignKey {
-    constructor(action, table, reverse, options) {
-        this.action = action;
-        this.table = table;
-        this.reverse = reverse;
-        this.options = options;
-    }
-    toSql() {
-        const { action, table, reverse, options } = this;
-        if (action === 'createTable' && reverse) {
-            return;
-        }
-        else if (action === 'changeTable' &&
-            reverse &&
-            (Array.isArray(options.column)
-                ? options.column.some((col) => table.removedColumns.includes(col))
-                : table.removedColumns.includes(options.column))) {
-            return;
-        }
-        const name = options.name ||
-            (Array.isArray(options.column)
-                ? utils_1.join(table.tableName, ...options.column, 'fkey')
-                : utils_1.join(table.tableName, options.column, 'fkey'));
-        const columns = Array.isArray(options.column)
-            ? options.column.map((col) => `"${col}"`).join(', ')
-            : `"${options.column}"`;
-        const foreignColumns = Array.isArray(options.references)
-            ? options.references.map((col) => `"${col}"`).join(', ')
-            : `"${options.references}"`;
-        const onUpdate = options.onUpdate ? ` ON UPDATE ${options.onUpdate}` : '';
-        const onDelete = options.onDelete ? ` ON DELETE ${options.onDelete}` : '';
-        const prefix = action === 'createTable' ? '' : reverse ? 'DROP' : 'ADD';
-        const sql = [prefix, `CONSTRAINT "${name}"`];
-        if (action !== 'changeTable' || !reverse) {
-            sql.push(`FOREIGN KEY (${columns}) REFERENCES "${options.table}"(${foreignColumns})${onUpdate}${onDelete}`);
-        }
-        if (action === 'changeTable' && reverse) {
-            sql.push('CASCADE');
-        }
-        if (options.index) {
-            if (reverse !== table.reverse && table.dropIndex)
-                table.dropIndex(options.column, options.index);
-            else
-                table.index(options.column, options.index);
-        }
-        return sql.join(' ');
-    }
-}
-exports.ForeignKey = ForeignKey;

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

@@ -1,3 +0,0 @@
-import { IndexOptions } from '../../types';
-export declare const addIndex: (table: string, column: string | string[], options?: true | IndexOptions) => string;
-export declare const dropIndex: (table: string, column: string | string[], options?: true | IndexOptions) => string;

package/dist/lib/schema/index.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dropIndex = exports.addIndex = void 0;
-const utils_1 = require("../utils");
-const getIndexName = (table, column, options = {}) => (options !== true && options.name) ||
-    utils_1.join(table, Array.isArray(column) ? utils_1.join(...column) : column, 'index');
-const getIndexColumns = (table, column, options = {}) => {
-    if (Array.isArray(column))
-        return column.map((col) => getIndexColumns(table, col, options)).join(', ');
-    else {
-        let sql = `"${column}"`;
-        if (options.expression)
-            sql += `(${options.expression})`;
-        if (options.order)
-            sql += ` ${options.order}`;
-        return sql;
-    }
-};
-const addIndex = (table, column, options = {}) => {
-    if (options === true)
-        options = {};
-    const sql = ['CREATE'];
-    if (options.unique)
-        sql.push('UNIQUE');
-    sql.push('INDEX');
-    const indexName = getIndexName(table, column, options);
-    sql.push(`"${indexName}"`);
-    sql.push('ON', `"${table}"`);
-    if (options.using)
-        sql.push('USING', options.using);
-    sql.push(`(${getIndexColumns(table, column, options)})`);
-    if (options.including)
-        sql.push('INCLUDING', `(${Array.isArray(options.including)
-            ? options.including.join(', ')
-            : options.including})`);
-    if (options.with)
-        sql.push('WITH', `(${options.with})`);
-    if (options.tablespace)
-        sql.push('TABLESPACE', options.tablespace);
-    if (options.where)
-        sql.push('WHERE', options.where);
-    return sql.join(' ');
-};
-exports.addIndex = addIndex;
-const dropIndex = (table, column, options = {}) => {
-    const sql = ['DROP INDEX', `"${getIndexName(table, column, options)}"`];
-    let mode = options !== true && options.mode;
-    if (mode) {
-        mode = mode.toUpperCase();
-        sql.push(mode);
-    }
-    return sql.join(' ');
-};
-exports.dropIndex = dropIndex;

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

@@ -1,9 +0,0 @@
-import { CreateTable } from './createTable';
-import { ChangeTable } from './changeTable';
-export declare class PrimaryKey {
-    action: 'create' | 'add' | 'drop';
-    columns: string[];
-    name?: string | undefined;
-    constructor(action: 'create' | 'add' | 'drop', columns: string[], name?: string | undefined);
-    toSql(table: CreateTable | ChangeTable): string;
-}

package/dist/lib/schema/primaryKey.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrimaryKey = void 0;
-class PrimaryKey {
-    constructor(action, columns, name) {
-        this.action = action;
-        this.columns = columns;
-        this.name = name;
-    }
-    toSql(table) {
-        const { action, name } = this;
-        const drop = (!table.reverse && action === 'drop') ||
-            (table.reverse && action === 'add');
-        if (drop) {
-            return `DROP CONSTRAINT "${name || `${table.tableName}_pkey`}"`;
-        }
-        const columns = `(${this.columns
-            .map((column) => `"${column}"`)
-            .join(', ')})`;
-        const constraint = name ? `CONSTRAINT "${name}" ` : '';
-        return `${action === 'create' ? '' : 'ADD '}${constraint}PRIMARY KEY ${columns}`;
-    }
-}
-exports.PrimaryKey = PrimaryKey;

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

@@ -1,43 +0,0 @@
-import { Column } from './column';
-import { Migration, ColumnFunction, ColumnOptions, IndexOptions, TableOptions, ColumnTypes } from '../../types';
-import { ForeignKey } from './foreignKey';
-import { PrimaryKey } from './primaryKey';
-declare type ColumnMethods = {
-    [key in keyof typeof ColumnTypes]: (name: string, options?: ColumnOptions) => Column;
-};
-export default class Table implements ColumnMethods {
-    tableName: string;
-    reverse: boolean;
-    options: TableOptions;
-    lines: (string | Column | ForeignKey | PrimaryKey)[];
-    indices: [boolean, string | string[], undefined | true | IndexOptions][];
-    comments: [string, string][];
-    constraint: (name: string, sql?: string) => void;
-    removedColumns: string[];
-    constructor(tableName: string, reverse: boolean, options?: TableOptions);
-    execute(sql: string): void;
-    column: ColumnFunction;
-    index: (column: string | string[], options?: true | IndexOptions | undefined) => void;
-    timestamps: (options?: ColumnOptions | undefined) => void;
-    addComments: (db: Migration) => void;
-    bigint(name: string, options?: ColumnOptions): Column;
-    bigserial(name: string, options?: ColumnOptions): Column;
-    boolean(name: string, options?: ColumnOptions): Column;
-    date(name: string, options?: ColumnOptions): Column;
-    decimal(name: string, options?: ColumnOptions): Column;
-    float(name: string, options?: ColumnOptions): Column;
-    integer(name: string, options?: ColumnOptions): Column;
-    text(name: string, options?: ColumnOptions): Column;
-    smallint(name: string, options?: ColumnOptions): Column;
-    smallserial(name: string, options?: ColumnOptions): Column;
-    varchar(name: string, options?: ColumnOptions): Column;
-    string(name: string, options?: ColumnOptions): Column;
-    time(name: string, options?: ColumnOptions): Column;
-    timestamp(name: string, options?: ColumnOptions): Column;
-    timestamptz(name: string, options?: ColumnOptions): Column;
-    binary(name: string, options?: ColumnOptions): Column;
-    serial(name: string, options?: ColumnOptions): Column;
-    json(name: string, options?: ColumnOptions): Column;
-    jsonb(name: string, options?: ColumnOptions): Column;
-}
-export {};

package/dist/lib/schema/table.js

@@ -1,110 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const pg_adapter_1 = require("pg-adapter");
-const column_1 = require("./column");
-const timestamps_1 = __importDefault(require("./timestamps"));
-const utils_1 = require("../utils");
-class Table {
-    constructor(tableName, reverse, options = {}) {
-        this.removedColumns = [];
-        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('create', name, options, type);
-            this.lines.push(column);
-            return column;
-        };
-        this.index = (column, options) => {
-            if (this.reverse &&
-                (Array.isArray(column)
-                    ? column.some((col) => this.removedColumns.includes(col))
-                    : this.removedColumns.includes(column)))
-                return;
-            this.indices.push([!this.reverse, column, options]);
-        };
-        this.timestamps = (options) => timestamps_1.default(this.column, options);
-        this.addComments = (db) => {
-            if (this.reverse)
-                return;
-            const { tableName, comments } = this;
-            if ('comment' in this.options)
-                db.exec(`COMMENT ON TABLE "${tableName}" IS ${pg_adapter_1.quote(this.options.comment)}`).catch(utils_1.noop);
-            for (const [column, message] of comments)
-                db.exec(`COMMENT ON COLUMN "${tableName}"."${column}" IS ${pg_adapter_1.quote(message)}`).catch(utils_1.noop);
-        };
-        this.tableName = tableName;
-        this.reverse = reverse;
-        this.options = options;
-        this.lines = [];
-        this.indices = [];
-        this.comments = [];
-    }
-    execute(sql) {
-        this.lines.push(sql);
-    }
-    bigint(name, options) {
-        return this.column(name, 'bigint', options);
-    }
-    bigserial(name, options) {
-        return this.column(name, 'bigserial', options);
-    }
-    boolean(name, options) {
-        return this.column(name, 'boolean', options);
-    }
-    date(name, options) {
-        return this.column(name, 'date', options);
-    }
-    decimal(name, options) {
-        return this.column(name, 'decimal', options);
-    }
-    float(name, options) {
-        return this.column(name, 'float8', options);
-    }
-    integer(name, options) {
-        return this.column(name, 'integer', options);
-    }
-    text(name, options) {
-        return this.column(name, 'text', options);
-    }
-    smallint(name, options) {
-        return this.column(name, 'smallint', options);
-    }
-    smallserial(name, options) {
-        return this.column(name, 'smallserial', options);
-    }
-    varchar(name, options) {
-        return this.column(name, 'varchar', options);
-    }
-    string(name, options) {
-        return this.column(name, 'text', options);
-    }
-    time(name, options) {
-        return this.column(name, 'time', options);
-    }
-    timestamp(name, options) {
-        return this.column(name, 'timestamp', options);
-    }
-    timestamptz(name, options) {
-        return this.column(name, 'timestamptz', options);
-    }
-    binary(name, options) {
-        return this.column(name, 'bytea', options);
-    }
-    serial(name, options) {
-        return this.column(name, 'serial', options);
-    }
-    json(name, options) {
-        return this.column(name, 'json', options);
-    }
-    jsonb(name, options) {
-        return this.column(name, 'jsonb', options);
-    }
-}
-exports.default = Table;

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

@@ -1,3 +0,0 @@
-import { ColumnFunction, ColumnOptions } from '../../types';
-declare const _default: (column: ColumnFunction, options?: ColumnOptions) => void;
-export default _default;

package/dist/lib/schema/timestamps.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("../utils");
-exports.default = (column, options = {}) => {
-    if (options.default === undefined)
-        options.default = 'now()';
-    column(utils_1.join('created', 'at'), 'timestamp', options);
-    column(utils_1.join('updated', 'at'), 'timestamp', options);
-};

package/dist/lib/utils.d.ts

@@ -1,26 +0,0 @@
-import { Adapter } from 'pg-adapter';
-export declare type Creds = {
-    database: string;
-    user: string;
-    password: string;
-    host: string;
-    port: number;
-};
-declare let camelCase: boolean;
-export declare const noop: () => void;
-export declare const join: (...args: string[]) => string;
-export declare const mkdirRecursive: (inputPath: string) => void;
-export declare const getConfig: () => {
-    camelCase: boolean;
-    migrationsPath: string;
-    configs: Creds[];
-};
-export declare const askAdminCreds: ({ user, password }?: {
-    user: string;
-    password: string;
-}) => Promise<{
-    user: string;
-    password: string;
-}>;
-export declare const createSchemaMigrations: (db: Adapter) => Promise<void>;
-export {};