rake-db 1.2.13 → 1.3.1

package/README.md

@@ -41,6 +41,18 @@ Has an option to generate names of columns, indices and foreign keys in camelCas
 
 ## Get started
 
+Install:
+
+```sh
+npm i rake-db
+```
+
+`rake-db` has peer dependencies on `ts-node` and `typescript`, if you don't have them already in your project need to install:
+
+```sh
+npm i ts-node typescript
+```
+
 Add a script into `package.json`:
 ```json
 {

package/dist/lib/migrate.d.ts

@@ -1,2 +1,4 @@
+import Migration from './migration';
+export declare const run: (db: Migration, fn: (t: Migration, up: boolean) => void | Promise<void>, version: string) => Promise<unknown[]>;
 export declare const migrate: () => Promise<void>;
 export declare const rollback: () => Promise<void>;

package/dist/lib/migrate.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rollback = exports.migrate = void 0;
+exports.rollback = exports.migrate = exports.run = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const utils_1 = require("./utils");
@@ -73,16 +73,37 @@ const getFiles = (migrationsPath, rollback) => new Promise((resolve, reject) =>
         resolve(files);
     });
 });
-const run = (db, fn, version) => db.wrapperTransaction(db, async (t) => {
-    fn(t, !db.reverse);
+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(undefined);
+            };
+            await fn(t, false);
+            t.exec = originalExec;
+            for (const args of argsList.reverse()) {
+                await t.exec(...args);
+            }
+        }
+    }
     await t.sync();
     if (t.failed)
         return;
     const sql = db.reverse
         ? `DELETE FROM "schemaMigrations" WHERE "version" = '${version}'`
         : `INSERT INTO "schemaMigrations" VALUES ('${version}')`;
-    t.exec(sql).catch(utils_1.noop);
+    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);
@@ -92,7 +113,7 @@ const migrateFile = async (db, migrationsPath, version, file) => {
         throw new Error(`Migration ${file} does not contain down or change exports`);
     for (const key in migration)
         if (key === (db.reverse ? 'down' : 'up') || key === 'change')
-            await run(db, migration[key], version);
+            await exports.run(db, migration[key], version);
     console.info(`${filePath} ${db.reverse ? 'rolled back' : 'migrated'}`);
 };
 const migrateDb = async (db, migrationsPath, files) => {

package/dist/lib/migration.d.ts

@@ -13,6 +13,8 @@ export default class Migration extends Adapter {
     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;

package/dist/lib/migration.js

@@ -83,6 +83,12 @@ class Migration extends pg_adapter_1.Adapter {
     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));
     }

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

@@ -1,6 +1,7 @@
 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;
@@ -16,5 +17,7 @@ export declare class ChangeTable extends Table {
     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

@@ -9,6 +9,7 @@ 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 {
@@ -69,6 +70,16 @@ class ChangeTable extends table_1.default {
             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)

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

@@ -11,6 +11,7 @@ export declare class Column {
     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;

package/dist/lib/schema/column.js

@@ -9,85 +9,101 @@ class Column {
         this._type = _type;
     }
     primaryKey() {
-        this.options.primaryKey = true;
+        this.options = { ...this.options, primaryKey: true };
         return this;
     }
     type(type) {
-        this.options.type = type;
+        this.options = { ...this.options, type };
         return this;
     }
     default(value) {
-        this.options.default = value;
+        this.options = { ...this.options, default: value };
         return this;
     }
     required() {
-        this.options.null = false;
+        this.options = { ...this.options, null: false };
+        return this;
+    }
+    optional() {
+        this.options = { ...this.options, null: true };
         return this;
     }
     index(options) {
-        this.options.index = options;
+        this.options = { ...this.options, index: options !== null && options !== void 0 ? options : true };
         return this;
     }
     comment(comment) {
-        this.options.comment = comment;
+        this.options = { ...this.options, comment };
         return this;
     }
     mode(mode) {
-        this.options.mode = mode;
+        this.options = { ...this.options, mode };
         return this;
     }
     unique() {
-        if (typeof this.options.index !== 'object') {
-            this.options.index = { unique: true };
+        if (typeof this.options.index === 'object') {
+            this.options = {
+                ...this.options,
+                index: { ...this.options.index, unique: true },
+            };
         }
         else {
-            this.options.index.unique = true;
+            this.options = { ...this.options, index: { unique: true } };
         }
         return this;
     }
     length(length) {
-        this.options.length = length;
+        this.options = { ...this.options, length };
         return this;
     }
     precision(precision) {
-        this.options.precision = precision;
+        this.options = { ...this.options, precision };
         return this;
     }
     scale(scale) {
-        this.options.scale = scale;
+        this.options = { ...this.options, scale };
         return this;
     }
     collate(collate) {
-        this.options.collate = collate;
+        this.options = { ...this.options, collate };
         return this;
     }
     using(using) {
-        this.options.using = using;
+        this.options = { ...this.options, using };
         return this;
     }
     references(table, column) {
-        this.options.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.references.column = column;
+        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.references.onUpdate = action;
+        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.references.onDelete = action;
+        this.options = {
+            ...this.options,
+            references: { ...this.options.references, onDelete: action },
+        };
         return this;
     }
     toSql(table) {

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

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

@@ -8,6 +8,7 @@ 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);
@@ -17,6 +18,11 @@ class CreateTable extends table_1.default {
             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);

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

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

@@ -0,0 +1,24 @@
+"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,6 +1,7 @@
 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;
 };
@@ -8,7 +9,7 @@ export default class Table implements ColumnMethods {
     tableName: string;
     reverse: boolean;
     options: TableOptions;
-    lines: (string | Column | ForeignKey)[];
+    lines: (string | Column | ForeignKey | PrimaryKey)[];
     indices: [boolean, string | string[], undefined | true | IndexOptions][];
     comments: [string, string][];
     constraint: (name: string, sql?: string) => void;
@@ -29,6 +30,7 @@ export default class Table implements ColumnMethods {
     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;

package/dist/lib/schema/table.js

@@ -79,6 +79,9 @@ class Table {
     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);
     }

package/dist/types.d.ts

@@ -70,6 +70,7 @@ export declare const ColumnTypes: {
     readonly decimal: "decimal";
     readonly float: "float8";
     readonly integer: "integer";
+    readonly varchar: "varchar";
     readonly text: "text";
     readonly smallint: "smallint";
     readonly smallserial: "smallserial";

package/dist/types.js

@@ -16,6 +16,7 @@ exports.ColumnTypes = {
     decimal: 'decimal',
     float: 'float8',
     integer: 'integer',
+    varchar: 'varchar',
     text: 'text',
     smallint: 'smallint',
     smallserial: 'smallserial',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rake-db",
-  "version": "1.2.13",
+  "version": "1.3.1",
   "description": "Postgresql migrations like in Ruby on Rails",
   "bin": {
     "rake-db": "dist/rake-db.js"
@@ -42,9 +42,12 @@
     "typescript": "^4.0.3"
   },
   "dependencies": {
-    "dotenv": "8.x",
+    "dotenv": "^16.0.1",
     "enquirer": "^2.3.6",
-    "pg-adapter": "^1.2.2",
-    "ts-node": "^9.1.1"
+    "pg-adapter": "^1.2.5"
+  },
+  "peerDependencies": {
+    "ts-node": "*",
+    "typescript": "*"
   }
 }

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

@@ -1,3 +0,0 @@
-import { ColumnChain, ReferencesChain } from 'types';
-export declare const columnChain: (sql: string[], addingColumn: boolean) => ColumnChain;
-export declare const referencesChain: (sql: string[], addingColumn: boolean) => ReferencesChain;

package/dist/lib/schema/chain.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.referencesChain = exports.columnChain = void 0;
-const columnChain = (sql, addingColumn) => {
-    const chain = {
-        required() {
-            if (addingColumn)
-                sql.push('NOT NULL');
-            return chain;
-        },
-        default(value) {
-            if (addingColumn)
-                sql.push(`DEFAULT ${value}`);
-            return chain;
-        },
-        references(table, column) {
-            const refChain = exports.referencesChain(sql, addingColumn);
-            if (addingColumn) {
-                sql.push(`REFERENCES "${table}"`);
-                if (column)
-                    return refChain.column(column);
-            }
-            return refChain;
-        },
-    };
-    return chain;
-};
-exports.columnChain = columnChain;
-const referencesChain = (sql, addingColumn) => {
-    const chain = {
-        column(column) {
-            if (addingColumn)
-                sql.push(`("${column}")`);
-            return chain;
-        },
-        onUpdate(action) {
-            if (addingColumn)
-                sql.push(`ON UPDATE ${action}`);
-            return chain;
-        },
-        onDelete(action) {
-            if (addingColumn)
-                sql.push(`ON DELETE ${action}`);
-            return chain;
-        },
-    };
-    return chain;
-};
-exports.referencesChain = referencesChain;

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

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

package/dist/lib/schema/typeSql.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = (type, options = {}) => {
-    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(' ');
-};

package/dist/lib/versionsTable.d.ts

@@ -1,5 +0,0 @@
-import { DbConfig } from '../types';
-import Migration from './migration';
-export declare const createSchemaMigrations: (db: Migration) => Promise<unknown>;
-export declare const createForConfig: (config: DbConfig) => Promise<void>;
-export declare const create: () => Promise<void>;

package/dist/lib/versionsTable.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.create = exports.createForConfig = exports.createSchemaMigrations = void 0;
-const utils_1 = require("./utils");
-const schemaMigrationsSQL = 'CREATE TABLE schema_migrations ( version TEXT NOT NULL )';
-exports.createSchemaMigrations = (db) => db.exec(schemaMigrationsSQL);
-exports.createForConfig = async (config) => {
-    const db = utils_1.adapter(config);
-    await db.exec(schemaMigrationsSQL);
-    db.close();
-};
-exports.create = async () => {
-    let config;
-    try {
-        config = await utils_1.getConfig();
-    }
-    catch (err) {
-        return;
-    }
-    for (const env in config) {
-        const envConfig = config[env];
-        exports.createForConfig(envConfig);
-    }
-};