rake-db 1.3.2 → 2.0.0

package/src/migration/migration.ts

@@ -0,0 +1,296 @@
+import {
+  ColumnsShape,
+  ColumnType,
+  ColumnTypes,
+  ForeignKeyOptions,
+  IndexColumnOptions,
+  IndexOptions,
+  MaybeArray,
+  TransactionAdapter,
+} from 'pqb';
+import { createJoinTable, createTable } from './createTable';
+import { changeTable, TableChangeData, TableChanger } from './changeTable';
+
+export type DropMode = 'CASCADE' | 'RESTRICT';
+
+export type TableOptions = { dropMode?: DropMode; comment?: string };
+export type ColumnsShapeCallback = (t: ColumnTypes) => ColumnsShape;
+
+export type ChangeTableOptions = { comment?: string | [string, string] | null };
+export type ChangeTableCallback = (t: TableChanger) => TableChangeData;
+
+export type ColumnIndex = {
+  columns: IndexColumnOptions[];
+  options: IndexOptions;
+};
+export type ColumnComment = { column: string; comment: string | null };
+
+export type JoinTableOptions = {
+  tableName?: string;
+  comment?: string;
+  dropMode?: DropMode;
+};
+
+export class Migration extends TransactionAdapter {
+  constructor(tx: TransactionAdapter, public up: boolean) {
+    super(tx.pool, tx.client, tx.types);
+  }
+
+  createTable(
+    tableName: string,
+    options: TableOptions,
+    fn: ColumnsShapeCallback,
+  ): Promise<void>;
+  createTable(tableName: string, fn: ColumnsShapeCallback): Promise<void>;
+  createTable(
+    tableName: string,
+    cbOrOptions: ColumnsShapeCallback | TableOptions,
+    cb?: ColumnsShapeCallback,
+  ): Promise<void> {
+    const options = typeof cbOrOptions === 'function' ? {} : cbOrOptions;
+    const fn = (cb || cbOrOptions) as ColumnsShapeCallback;
+
+    return createTable(this, this.up, tableName, options, fn);
+  }
+
+  dropTable(
+    tableName: string,
+    options: TableOptions,
+    fn: ColumnsShapeCallback,
+  ): Promise<void>;
+  dropTable(tableName: string, fn: ColumnsShapeCallback): Promise<void>;
+  dropTable(
+    tableName: string,
+    cbOrOptions: ColumnsShapeCallback | TableOptions,
+    cb?: ColumnsShapeCallback,
+  ) {
+    const options = typeof cbOrOptions === 'function' ? {} : cbOrOptions;
+    const fn = (cb || cbOrOptions) as ColumnsShapeCallback;
+
+    return createTable(this, !this.up, tableName, options, fn);
+  }
+
+  createJoinTable(
+    tables: string[],
+    options?: JoinTableOptions,
+    fn?: ColumnsShapeCallback,
+  ): Promise<void>;
+  createJoinTable(tables: string[], fn?: ColumnsShapeCallback): Promise<void>;
+  async createJoinTable(
+    tables: string[],
+    cbOrOptions?: ColumnsShapeCallback | JoinTableOptions,
+    cb?: ColumnsShapeCallback,
+  ): Promise<void> {
+    const options = typeof cbOrOptions === 'function' ? {} : cbOrOptions || {};
+    const fn = (cb || cbOrOptions) as ColumnsShapeCallback | undefined;
+
+    return createJoinTable(this, this.up, tables, options, fn);
+  }
+
+  dropJoinTable(
+    tables: string[],
+    options?: JoinTableOptions,
+    fn?: ColumnsShapeCallback,
+  ): Promise<void>;
+  dropJoinTable(tables: string[], fn?: ColumnsShapeCallback): Promise<void>;
+  async dropJoinTable(
+    tables: string[],
+    cbOrOptions?: ColumnsShapeCallback | JoinTableOptions,
+    cb?: ColumnsShapeCallback,
+  ): Promise<void> {
+    const options = typeof cbOrOptions === 'function' ? {} : cbOrOptions || {};
+    const fn = (cb || cbOrOptions) as ColumnsShapeCallback | undefined;
+
+    return createJoinTable(this, !this.up, tables, options, fn);
+  }
+
+  changeTable(
+    tableName: string,
+    options: ChangeTableOptions,
+    fn?: ChangeTableCallback,
+  ): Promise<void>;
+  changeTable(tableName: string, fn: ChangeTableCallback): Promise<void>;
+  changeTable(
+    tableName: string,
+    cbOrOptions: ChangeTableCallback | ChangeTableOptions,
+    cb?: ChangeTableCallback,
+  ) {
+    const [fn, options] =
+      typeof cbOrOptions === 'function' ? [cbOrOptions, {}] : [cb, cbOrOptions];
+
+    return changeTable(this, this.up, tableName, options, fn);
+  }
+
+  async renameTable(from: string, to: string): Promise<void> {
+    const [table, newName] = this.up ? [from, to] : [to, from];
+    await this.query(`ALTER TABLE "${table}" RENAME TO "${newName}"`);
+  }
+
+  addColumn(
+    tableName: string,
+    columnName: string,
+    fn: (t: ColumnTypes) => ColumnType,
+  ) {
+    return addColumn(this, this.up, tableName, columnName, fn);
+  }
+
+  dropColumn(
+    tableName: string,
+    columnName: string,
+    fn: (t: ColumnTypes) => ColumnType,
+  ) {
+    return addColumn(this, !this.up, tableName, columnName, fn);
+  }
+
+  addIndex(
+    tableName: string,
+    columns: MaybeArray<string | IndexColumnOptions>,
+    options?: IndexOptions,
+  ) {
+    return addIndex(this, this.up, tableName, columns, options);
+  }
+
+  dropIndex(
+    tableName: string,
+    columns: MaybeArray<string | IndexColumnOptions>,
+    options?: IndexOptions,
+  ) {
+    return addIndex(this, !this.up, tableName, columns, options);
+  }
+
+  addForeignKey(
+    tableName: string,
+    columns: [string, ...string[]],
+    foreignTable: string,
+    foreignColumns: [string, ...string[]],
+    options?: ForeignKeyOptions,
+  ) {
+    return addForeignKey(
+      this,
+      this.up,
+      tableName,
+      columns,
+      foreignTable,
+      foreignColumns,
+      options,
+    );
+  }
+
+  dropForeignKey(
+    tableName: string,
+    columns: [string, ...string[]],
+    foreignTable: string,
+    foreignColumns: [string, ...string[]],
+    options?: ForeignKeyOptions,
+  ) {
+    return addForeignKey(
+      this,
+      !this.up,
+      tableName,
+      columns,
+      foreignTable,
+      foreignColumns,
+      options,
+    );
+  }
+
+  addPrimaryKey(
+    tableName: string,
+    columns: string[],
+    options?: { name?: string },
+  ) {
+    return addPrimaryKey(this, this.up, tableName, columns, options);
+  }
+
+  dropPrimaryKey(
+    tableName: string,
+    columns: string[],
+    options?: { name?: string },
+  ) {
+    return addPrimaryKey(this, !this.up, tableName, columns, options);
+  }
+
+  renameColumn(tableName: string, from: string, to: string) {
+    return this.changeTable(tableName, (t) => ({
+      [from]: t.rename(to),
+    }));
+  }
+
+  async tableExists(tableName: string) {
+    return queryExists(this, {
+      text: `SELECT 1 FROM "information_schema"."tables" WHERE "table_name" = $1`,
+      values: [tableName],
+    });
+  }
+
+  async columnExists(tableName: string, columnName: string): Promise<boolean> {
+    return queryExists(this, {
+      text: `SELECT 1 FROM "information_schema"."columns" WHERE "table_name" = $1 AND "column_name" = $2`,
+      values: [tableName, columnName],
+    });
+  }
+
+  async constraintExists(constraintName: string): Promise<boolean> {
+    return queryExists(this, {
+      text: `SELECT 1 FROM "information_schema"."table_constraints" WHERE "constraint_name" = $1`,
+      values: [constraintName],
+    });
+  }
+}
+
+const addColumn = (
+  migration: Migration,
+  up: boolean,
+  tableName: string,
+  columnName: string,
+  fn: (t: ColumnTypes) => ColumnType,
+) => {
+  return changeTable(migration, up, tableName, {}, (t) => ({
+    [columnName]: t.add(fn(t)),
+  }));
+};
+
+const addIndex = (
+  migration: Migration,
+  up: boolean,
+  tableName: string,
+  columns: MaybeArray<string | IndexColumnOptions>,
+  options?: IndexOptions,
+) => {
+  return changeTable(migration, up, tableName, {}, (t) => ({
+    ...t.add(t.index(columns, options)),
+  }));
+};
+
+const addForeignKey = (
+  migration: Migration,
+  up: boolean,
+  tableName: string,
+  columns: [string, ...string[]],
+  foreignTable: string,
+  foreignColumns: [string, ...string[]],
+  options?: ForeignKeyOptions,
+) => {
+  return changeTable(migration, up, tableName, {}, (t) => ({
+    ...t.add(t.foreignKey(columns, foreignTable, foreignColumns, options)),
+  }));
+};
+
+const addPrimaryKey = (
+  migration: Migration,
+  up: boolean,
+  tableName: string,
+  columns: string[],
+  options?: { name?: string },
+) => {
+  return changeTable(migration, up, tableName, {}, (t) => ({
+    ...t.add(t.primaryKey(columns, options)),
+  }));
+};
+
+const queryExists = (
+  db: Migration,
+  sql: { text: string; values: unknown[] },
+) => {
+  return db.query(sql).then(({ rowCount }) => rowCount > 0);
+};

package/src/migration/migrationUtils.ts

@@ -0,0 +1,281 @@
+import {
+  Adapter,
+  ColumnType,
+  ForeignKeyModel,
+  ForeignKeyOptions,
+  getRaw,
+  isRaw,
+  quote,
+  TableData,
+  toArray,
+} from 'pqb';
+import { ColumnComment, ColumnIndex, Migration } from './migration';
+import { joinColumns, joinWords } from '../common';
+
+export const columnToSql = (
+  key: string,
+  item: ColumnType,
+  { values }: { values: unknown[] },
+) => {
+  const line = [`"${key}" ${item.toSQL()}`];
+
+  if (item.data.compression) {
+    line.push(`COMPRESSION ${item.data.compression}`);
+  }
+
+  if (item.data.collate) {
+    line.push(`COLLATE ${quote(item.data.collate)}`);
+  }
+
+  if (item.isPrimaryKey) {
+    line.push('PRIMARY KEY');
+  } else if (!item.isNullable) {
+    line.push('NOT NULL');
+  }
+
+  if (item.data.default !== undefined) {
+    if (
+      typeof item.data.default === 'object' &&
+      item.data.default &&
+      isRaw(item.data.default)
+    ) {
+      line.push(`DEFAULT ${getRaw(item.data.default, values)}`);
+    } else {
+      line.push(`DEFAULT ${quote(item.data.default)}`);
+    }
+  }
+
+  const { foreignKey } = item.data;
+  if (foreignKey) {
+    const table = getForeignKeyTable(
+      'fn' in foreignKey ? foreignKey.fn : foreignKey.table,
+    );
+
+    if (foreignKey.name) {
+      line.push(`CONSTRAINT "${foreignKey.name}"`);
+    }
+
+    line.push(referencesToSql(table, foreignKey.columns, foreignKey));
+  }
+
+  return line.join(' ');
+};
+
+export const addColumnIndex = (
+  indexes: ColumnIndex[],
+  key: string,
+  item: ColumnType,
+) => {
+  if (item.data) {
+    if (item.data.index) {
+      indexes.push({
+        columns: [{ ...item.data.index, column: key }],
+        options: item.data.index,
+      });
+    }
+  }
+};
+
+export const addColumnComment = (
+  comments: ColumnComment[],
+  key: string,
+  item: ColumnType,
+) => {
+  if (item.data.comment) {
+    comments.push({ column: key, comment: item.data.comment });
+  }
+};
+
+export const getForeignKeyTable = (
+  fnOrTable: (() => ForeignKeyModel) | string,
+) => {
+  if (typeof fnOrTable === 'string') {
+    return fnOrTable;
+  }
+
+  const klass = fnOrTable();
+  return new klass().table;
+};
+
+export const constraintToSql = (
+  tableName: string,
+  up: boolean,
+  foreignKey: TableData['foreignKeys'][number],
+) => {
+  const table = getForeignKeyTable(foreignKey.fnOrTable);
+  const constraintName =
+    foreignKey.options.name || joinWords(tableName, 'to', table);
+
+  if (!up) {
+    const { dropMode } = foreignKey.options;
+    return `CONSTRAINT "${constraintName}"${dropMode ? ` ${dropMode}` : ''}`;
+  }
+
+  return `CONSTRAINT "${constraintName}" FOREIGN KEY (${joinColumns(
+    foreignKey.columns,
+  )}) ${referencesToSql(table, foreignKey.foreignColumns, foreignKey.options)}`;
+};
+
+export const referencesToSql = (
+  table: string,
+  columns: string[],
+  foreignKey: Pick<ForeignKeyOptions, 'match' | 'onDelete' | 'onUpdate'>,
+) => {
+  const sql: string[] = [`REFERENCES "${table}"(${joinColumns(columns)})`];
+
+  if (foreignKey.match) {
+    sql.push(`MATCH ${foreignKey.match.toUpperCase()}`);
+  }
+
+  if (foreignKey.onDelete) {
+    sql.push(`ON DELETE ${foreignKey.onDelete.toUpperCase()}`);
+  }
+
+  if (foreignKey.onUpdate) {
+    sql.push(`ON UPDATE ${foreignKey.onUpdate.toUpperCase()}`);
+  }
+
+  return sql.join(' ');
+};
+
+export const migrateIndexes = async (
+  state: {
+    migration: Migration;
+    tableName: string;
+  },
+  indexes: ColumnIndex[],
+  up: boolean,
+) => {
+  for (const item of indexes) {
+    await migrateIndex(state, up, item);
+  }
+};
+
+export const migrateIndex = (
+  state: { migration: Migration; tableName: string },
+  up: boolean,
+  { columns, options }: ColumnIndex,
+) => {
+  const indexName =
+    options.name ||
+    joinWords(state.tableName, ...columns.map(({ column }) => column), 'index');
+
+  if (!up) {
+    return state.migration.query(
+      `DROP INDEX "${indexName}"${
+        options.dropMode ? ` ${options.dropMode}` : ''
+      }`,
+    );
+  }
+
+  const values: unknown[] = [];
+
+  const sql: string[] = ['CREATE'];
+
+  if (options.unique) {
+    sql.push('UNIQUE');
+  }
+
+  sql.push(`INDEX "${indexName}" ON "${state.tableName}"`);
+
+  if (options.using) {
+    sql.push(`USING ${options.using}`);
+  }
+
+  const columnsSql: string[] = [];
+
+  columns.forEach((column) => {
+    const columnSql: string[] = [
+      `"${column.column}"${column.expression ? `(${column.expression})` : ''}`,
+    ];
+
+    if (column.collate) {
+      columnSql.push(`COLLATE '${column.collate}'`);
+    }
+
+    if (column.operator) {
+      columnSql.push(column.operator);
+    }
+
+    if (column.order) {
+      columnSql.push(column.order);
+    }
+
+    columnsSql.push(columnSql.join(' '));
+  });
+
+  sql.push(`(${columnsSql.join(', ')})`);
+
+  if (options.include) {
+    sql.push(
+      `INCLUDE (${toArray(options.include)
+        .map((column) => `"${column}"`)
+        .join(', ')})`,
+    );
+  }
+
+  if (options.with) {
+    sql.push(`WITH (${options.with})`);
+  }
+
+  if (options.tablespace) {
+    sql.push(`TABLESPACE ${options.tablespace}`);
+  }
+
+  if (options.where) {
+    sql.push(
+      `WHERE ${
+        typeof options.where === 'object' &&
+        options.where &&
+        isRaw(options.where)
+          ? getRaw(options.where, values)
+          : options.where
+      }`,
+    );
+  }
+
+  return state.migration.query({ text: sql.join(' '), values });
+};
+
+export const migrateComments = async (
+  state: { migration: Migration; tableName: string },
+  comments: ColumnComment[],
+) => {
+  for (const { column, comment } of comments) {
+    await state.migration.query(
+      `COMMENT ON COLUMN "${state.tableName}"."${column}" IS ${quote(comment)}`,
+    );
+  }
+};
+
+export const primaryKeyToSql = (
+  primaryKey: Exclude<TableData['primaryKey'], undefined>,
+) => {
+  const name = primaryKey.options?.name;
+  return `${name ? `CONSTRAINT "${name}" ` : ''}PRIMARY KEY (${joinColumns(
+    primaryKey.columns,
+  )})`;
+};
+
+export const getPrimaryKeysOfTable = async (
+  db: Adapter,
+  tableName: string,
+): Promise<{ name: string; type: string }[]> => {
+  const { rows } = await db.query<{ name: string; type: string }>({
+    text: `SELECT
+  pg_attribute.attname AS name,
+  format_type(pg_attribute.atttypid, pg_attribute.atttypmod) AS type
+FROM pg_index, pg_class, pg_attribute, pg_namespace
+WHERE
+  pg_class.oid = $1::regclass AND
+  indrelid = pg_class.oid AND
+  nspname = 'public' AND
+  pg_class.relnamespace = pg_namespace.oid AND
+  pg_attribute.attrelid = pg_class.oid AND
+  pg_attribute.attnum = any(pg_index.indkey) AND
+  indisprimary`,
+    values: [tableName],
+  });
+
+  return rows;
+};

package/src/rakeDb.ts

@@ -0,0 +1,29 @@
+import { AdapterOptions, MaybeArray } from 'pqb';
+import { createDb, dropDb } from './commands/createOrDrop';
+import { migrate, rollback } from './commands/migrateOrRollback';
+import { getMigrationConfigWithDefaults, MigrationConfig } from './common';
+import { generate } from './commands/generate';
+
+export const rakeDb = async (
+  options: MaybeArray<AdapterOptions>,
+  partialConfig: Partial<MigrationConfig> = {},
+  args: string[] = process.argv.slice(2),
+) => {
+  const config = getMigrationConfigWithDefaults(partialConfig);
+
+  const command = args[0].split(':')[0];
+
+  if (command === 'create') {
+    await createDb(options, config);
+  } else if (command === 'drop') {
+    await dropDb(options);
+  } else if (command === 'migrate') {
+    await migrate(options, config);
+  } else if (command === 'rollback') {
+    await rollback(options, config);
+  } else if (command === 'g' || command === 'generate') {
+    await generate(config, args.slice(1));
+  } else {
+    console.log(`Usage: rake-db [command] [arguments]`);
+  }
+};

package/src/test-utils.ts

@@ -0,0 +1,45 @@
+import { Migration } from './migration/migration';
+import { MaybeArray, toArray, TransactionAdapter } from 'pqb';
+
+let db: Migration | undefined;
+
+export const getDb = () => {
+  if (db) return db;
+
+  db = new Migration({} as unknown as TransactionAdapter, true);
+  db.query = queryMock;
+  return db;
+};
+
+export const queryMock = jest.fn();
+
+export const resetDb = () => {
+  queryMock.mockClear();
+  queryMock.mockResolvedValue(undefined);
+  getDb().up = true;
+};
+
+export const setDbDown = () => {
+  getDb().up = false;
+  queryMock.mockClear();
+};
+
+export const trim = (s: string) => {
+  return s.trim().replace(/\n\s+/g, '\n');
+};
+
+export const toLine = (s: string) => {
+  return s.trim().replace(/\n\s*/g, ' ');
+};
+
+export const expectSql = (sql: MaybeArray<string>) => {
+  expect(
+    queryMock.mock.calls.map((call) =>
+      trim(
+        typeof call[0] === 'string'
+          ? call[0]
+          : (call[0] as { text: string }).text,
+      ),
+    ),
+  ).toEqual(toArray(sql).map(trim));
+};

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["./src", "jest-setup.ts"],
+  "compilerOptions": {
+    "outDir": "./dist",
+    "noEmit": false,
+    "baseUrl": ".",
+    "paths": {
+      "pqb": ["../pqb/src"]
+    }
+  }
+}

package/dist/lib/createAndDrop.d.ts

@@ -1,2 +0,0 @@
-export declare const createDb: () => void;
-export declare const dropDb: () => void;