rake-db 1.3.2 → 2.0.0

package/src/migration/changeTable.ts

@@ -0,0 +1,375 @@
+import {
+  ColumnTypes,
+  ColumnType,
+  columnTypes,
+  resetTableData,
+  quote,
+  getTableData,
+  EmptyObject,
+  emptyObject,
+  TableData,
+  RawExpression,
+  getRaw,
+  isRaw,
+} from 'pqb';
+import {
+  ChangeTableCallback,
+  ChangeTableOptions,
+  ColumnComment,
+  ColumnIndex,
+  DropMode,
+  Migration,
+} from './migration';
+import {
+  addColumnComment,
+  addColumnIndex,
+  columnToSql,
+  constraintToSql,
+  migrateComments,
+  migrateIndexes,
+  primaryKeyToSql,
+} from './migrationUtils';
+
+const newChangeTableData = () => ({
+  add: [],
+  drop: [],
+});
+
+let changeTableData: { add: TableData[]; drop: TableData[] } =
+  newChangeTableData();
+
+const resetChangeTableData = () => {
+  changeTableData = newChangeTableData();
+};
+
+function add(item: ColumnType, options?: { dropMode?: DropMode }): ChangeItem;
+function add(emptyObject: EmptyObject): EmptyObject;
+function add(
+  items: Record<string, ColumnType>,
+  options?: { dropMode?: DropMode },
+): Record<string, ChangeItem>;
+function add(
+  item: ColumnType | EmptyObject | Record<string, ColumnType>,
+  options?: { dropMode?: DropMode },
+): ChangeItem | EmptyObject | Record<string, ChangeItem> {
+  if (item instanceof ColumnType) {
+    return ['add', item, options];
+  } else if (item === emptyObject) {
+    changeTableData.add.push(getTableData());
+    resetTableData();
+    return emptyObject;
+  } else {
+    const result: Record<string, ChangeItem> = {};
+    for (const key in item) {
+      result[key] = ['add', (item as Record<string, ColumnType>)[key], options];
+    }
+    return result;
+  }
+}
+
+const drop = ((item, options) => {
+  if (item instanceof ColumnType) {
+    return ['drop', item, options];
+  } else if (item === emptyObject) {
+    changeTableData.drop.push(getTableData());
+    resetTableData();
+    return emptyObject;
+  } else {
+    const result: Record<string, ChangeItem> = {};
+    for (const key in item) {
+      result[key] = [
+        'drop',
+        (item as Record<string, ColumnType>)[key],
+        options,
+      ];
+    }
+    return result;
+  }
+}) as typeof add;
+
+type ChangeOptions = {
+  usingUp?: RawExpression;
+  usingDown?: RawExpression;
+};
+
+type ChangeArg =
+  | ColumnType
+  | ['default', unknown | RawExpression]
+  | ['nullable', boolean]
+  | ['comment', string | null];
+
+type TableChangeMethods = typeof tableChangeMethods;
+const tableChangeMethods = {
+  add,
+  drop,
+  change(from: ChangeArg, to: ChangeArg, options?: ChangeOptions): ChangeItem {
+    return ['change', from, to, options];
+  },
+  default(value: unknown | RawExpression): ChangeArg {
+    return ['default', value];
+  },
+  nullable(): ChangeArg {
+    return ['nullable', true];
+  },
+  nonNullable(): ChangeArg {
+    return ['nullable', false];
+  },
+  comment(name: string | null): ChangeArg {
+    return ['comment', name];
+  },
+  rename(name: string): ChangeItem {
+    return ['rename', name];
+  },
+};
+
+export type ChangeItem =
+  | [
+      action: 'add' | 'drop',
+      item: ColumnType,
+      options?: { dropMode?: DropMode },
+    ]
+  | [action: 'change', from: ChangeArg, to: ChangeArg, options?: ChangeOptions]
+  | ['rename', string];
+
+export type TableChanger = ColumnTypes & TableChangeMethods;
+
+export type TableChangeData = Record<string, ChangeItem | EmptyObject>;
+
+type ChangeTableState = {
+  migration: Migration;
+  up: boolean;
+  tableName: string;
+  alterTable: string[];
+  values: unknown[];
+  indexes: ColumnIndex[];
+  dropIndexes: ColumnIndex[];
+  comments: ColumnComment[];
+};
+
+export const changeTable = async (
+  migration: Migration,
+  up: boolean,
+  tableName: string,
+  options: ChangeTableOptions,
+  fn?: ChangeTableCallback,
+) => {
+  resetTableData();
+  resetChangeTableData();
+
+  const tableChanger = Object.create(columnTypes) as TableChanger;
+  Object.assign(tableChanger, tableChangeMethods);
+
+  const changeData = fn?.(tableChanger) || {};
+
+  const state: ChangeTableState = {
+    migration,
+    up,
+    tableName,
+    alterTable: [],
+    values: [],
+    indexes: [],
+    dropIndexes: [],
+    comments: [],
+  };
+
+  if (options.comment !== undefined) {
+    await changeActions.tableComment(state, tableName, options.comment);
+  }
+
+  for (const key in changeData) {
+    const result = changeData[key];
+    if (Array.isArray(result)) {
+      const [action] = result;
+      if (action === 'change') {
+        const [, from, to, options] = result;
+        changeActions.change(state, up, key, from, to, options);
+      } else if (action === 'rename') {
+        const [, name] = result;
+        changeActions.rename(state, up, key, name);
+      } else {
+        const [action, item, options] = result;
+        changeActions[action](state, up, key, item, options);
+      }
+    }
+  }
+
+  changeTableData.add.forEach((tableData) => {
+    handleTableData(state, up, tableName, tableData);
+  });
+
+  changeTableData.drop.forEach((tableData) => {
+    handleTableData(state, !up, tableName, tableData);
+  });
+
+  if (state.alterTable.length) {
+    await migration.query(
+      `ALTER TABLE "${tableName}"` + `\n  ${state.alterTable.join(',\n  ')}`,
+    );
+  }
+
+  const createIndexes = up ? state.indexes : state.dropIndexes;
+  const dropIndexes = up ? state.dropIndexes : state.indexes;
+  await migrateIndexes(state, createIndexes, up);
+  await migrateIndexes(state, dropIndexes, !up);
+  await migrateComments(state, state.comments);
+};
+
+const changeActions = {
+  tableComment(
+    { migration, up }: ChangeTableState,
+    tableName: string,
+    comment: Exclude<ChangeTableOptions['comment'], undefined>,
+  ) {
+    let value;
+    if (up) {
+      value = Array.isArray(comment) ? comment[1] : comment;
+    } else {
+      value = Array.isArray(comment) ? comment[0] : null;
+    }
+    return migration.query(
+      `COMMENT ON TABLE "${tableName}" IS ${quote(value)}`,
+    );
+  },
+
+  add(
+    state: ChangeTableState,
+    up: boolean,
+    key: string,
+    item: ColumnType,
+    options?: { dropMode?: DropMode },
+  ) {
+    addColumnIndex(state[up ? 'indexes' : 'dropIndexes'], key, item);
+
+    if (up) {
+      addColumnComment(state.comments, key, item);
+    }
+
+    if (up) {
+      state.alterTable.push(`ADD COLUMN ${columnToSql(key, item, state)}`);
+    } else {
+      state.alterTable.push(
+        `DROP COLUMN "${key}"${
+          options?.dropMode ? ` ${options.dropMode}` : ''
+        }`,
+      );
+    }
+  },
+
+  drop(
+    state: ChangeTableState,
+    up: boolean,
+    key: string,
+    item: ColumnType,
+    options?: { dropMode?: DropMode },
+  ) {
+    this.add(state, !up, key, item, options);
+  },
+
+  change(
+    state: ChangeTableState,
+    up: boolean,
+    key: string,
+    first: ChangeArg,
+    second: ChangeArg,
+    options?: ChangeOptions,
+  ) {
+    const [fromItem, toItem] = up ? [first, second] : [second, first];
+
+    const from = getChangeProperties(fromItem);
+    const to = getChangeProperties(toItem);
+
+    if (from.type !== to.type || from.collate !== to.collate) {
+      const using = up ? options?.usingUp : options?.usingDown;
+      state.alterTable.push(
+        `ALTER COLUMN "${key}" TYPE ${to.type}${
+          to.collate ? ` COLLATE ${quote(to.collate)}` : ''
+        }${using ? ` USING ${getRaw(using, state.values)}` : ''}`,
+      );
+    }
+
+    if (from.default !== to.default) {
+      const value = getRawOrValue(to.default, state.values);
+      const expr =
+        value === undefined ? `DROP DEFAULT` : `SET DEFAULT ${value}`;
+      state.alterTable.push(`ALTER COLUMN "${key}" ${expr}`);
+    }
+
+    if (from.nullable !== to.nullable) {
+      state.alterTable.push(
+        `ALTER COLUMN "${key}" ${to.nullable ? 'DROP' : 'SET'} NOT NULL`,
+      );
+    }
+
+    if (from.comment !== to.comment) {
+      state.comments.push({ column: key, comment: to.comment || null });
+    }
+  },
+
+  rename(state: ChangeTableState, up: boolean, key: string, name: string) {
+    const [from, to] = up ? [key, name] : [name, key];
+    state.alterTable.push(`RENAME COLUMN "${from}" TO "${to}"`);
+  },
+};
+
+const getChangeProperties = (
+  item: ChangeArg,
+): {
+  type?: string;
+  collate?: string;
+  default?: unknown | RawExpression;
+  nullable?: boolean;
+  comment?: string | null;
+} => {
+  if (item instanceof ColumnType) {
+    return {
+      type: item.toSQL(),
+      collate: item.data.collate,
+      default: item.data.default,
+      nullable: item.isNullable,
+      comment: item.data.comment,
+    };
+  } else {
+    return {
+      type: undefined,
+      collate: undefined,
+      default: item[0] === 'default' ? item[1] : undefined,
+      nullable: item[0] === 'nullable' ? item[1] : undefined,
+      comment: item[0] === 'comment' ? item[1] : undefined,
+    };
+  }
+};
+
+const handleTableData = (
+  state: ChangeTableState,
+  up: boolean,
+  tableName: string,
+  tableData: TableData,
+) => {
+  if (tableData.primaryKey) {
+    if (up) {
+      state.alterTable.push(`ADD ${primaryKeyToSql(tableData.primaryKey)}`);
+    } else {
+      const name = tableData.primaryKey.options?.name || `${tableName}_pkey`;
+      state.alterTable.push(`DROP CONSTRAINT "${name}"`);
+    }
+  }
+
+  if (tableData.indexes.length) {
+    state[up ? 'indexes' : 'dropIndexes'].push(...tableData.indexes);
+  }
+
+  if (tableData.foreignKeys.length) {
+    tableData.foreignKeys.forEach((foreignKey) => {
+      const action = up ? 'ADD' : 'DROP';
+      state.alterTable.push(
+        `\n  ${action} ${constraintToSql(state.tableName, up, foreignKey)}`,
+      );
+    });
+  }
+};
+
+const getRawOrValue = (item: unknown | RawExpression, values: unknown[]) => {
+  return typeof item === 'object' && item && isRaw(item)
+    ? getRaw(item, values)
+    : quote(item);
+};

package/src/migration/createTable.test.ts

@@ -0,0 +1,269 @@
+import { raw } from 'pqb';
+import { expectSql, getDb, queryMock, resetDb, toLine } from '../test-utils';
+
+const db = getDb();
+
+(['createTable', 'dropTable'] as const).forEach((action) => {
+  describe(action, () => {
+    beforeEach(resetDb);
+
+    it(`should ${action} with comment`, async () => {
+      await db[action](
+        'name',
+        { comment: 'this is a table comment' },
+        () => ({}),
+      );
+
+      if (action === 'createTable') {
+        expectSql([
+          `
+            CREATE TABLE "name" (
+            )
+          `,
+          `COMMENT ON TABLE "name" IS 'this is a table comment'`,
+        ]);
+      } else {
+        expectSql(`
+          DROP TABLE "name"
+        `);
+      }
+    });
+
+    it(`should ${action} and revert on rollback`, async () => {
+      const fn = () => {
+        return db[action]('table', { dropMode: 'CASCADE' }, (t) => ({
+          id: t.serial().primaryKey(),
+          nullable: t.text().nullable(),
+          nonNullable: t.text(),
+          withDefault: t.boolean().default(false),
+          withDefaultRaw: t.date().default(raw(`now()`)),
+          withIndex: t.text().index({
+            name: 'indexName',
+            unique: true,
+            using: 'gin',
+            expression: 10,
+            collate: 'utf-8',
+            operator: 'operator',
+            order: 'ASC',
+            include: 'id',
+            with: 'fillfactor = 70',
+            tablespace: 'tablespace',
+            where: 'column = 123',
+          }),
+          uniqueColumn: t.text().unique(),
+          columnWithComment: t.text().comment('this is a column comment'),
+          varcharWithLength: t.varchar(20),
+          decimalWithPrecisionAndScale: t.decimal(10, 5),
+          columnWithCompression: t.text().compression('compression'),
+          columnWithCollate: t.text().collate('utf-8'),
+          columnWithForeignKey: t.integer().foreignKey('table', 'column', {
+            name: 'fkeyConstraint',
+            match: 'FULL',
+            onUpdate: 'CASCADE',
+            onDelete: 'CASCADE',
+          }),
+          ...t.timestamps(),
+        }));
+      };
+
+      const expectCreateTable = () => {
+        expectSql([
+          `
+            CREATE TABLE "table" (
+              "id" serial PRIMARY KEY,
+              "nullable" text,
+              "nonNullable" text NOT NULL,
+              "withDefault" boolean NOT NULL DEFAULT false,
+              "withDefaultRaw" date NOT NULL DEFAULT now(),
+              "withIndex" text NOT NULL,
+              "uniqueColumn" text NOT NULL,
+              "columnWithComment" text NOT NULL,
+              "varcharWithLength" varchar(20) NOT NULL,
+              "decimalWithPrecisionAndScale" decimal(10, 5) NOT NULL,
+              "columnWithCompression" text COMPRESSION compression NOT NULL,
+              "columnWithCollate" text COLLATE 'utf-8' NOT NULL,
+              "columnWithForeignKey" integer NOT NULL CONSTRAINT "fkeyConstraint" REFERENCES "table"("column") MATCH FULL ON DELETE CASCADE ON UPDATE CASCADE,
+              "createdAt" timestamp NOT NULL DEFAULT now(),
+              "updatedAt" timestamp NOT NULL DEFAULT now()
+            )
+          `,
+          toLine(`
+            CREATE UNIQUE INDEX "indexName"
+              ON "table"
+              USING gin
+              ("withIndex"(10) COLLATE 'utf-8' operator ASC)
+              INCLUDE ("id")
+              WITH (fillfactor = 70)
+              TABLESPACE tablespace
+              WHERE column = 123
+          `),
+          toLine(`
+            CREATE UNIQUE INDEX "tableUniqueColumnIndex"
+              ON "table"
+              ("uniqueColumn")
+          `),
+          `COMMENT ON COLUMN "table"."columnWithComment" IS 'this is a column comment'`,
+        ]);
+      };
+
+      const expectDropTable = () => {
+        expectSql(`
+          DROP TABLE "table" CASCADE
+        `);
+      };
+
+      await fn();
+      (action === 'createTable' ? expectCreateTable : expectDropTable)();
+
+      db.up = false;
+      queryMock.mockClear();
+      await fn();
+      (action === 'createTable' ? expectDropTable : expectCreateTable)();
+    });
+
+    it('should support composite primary key', async () => {
+      await db[action]('table', (t) => ({
+        id: t.integer(),
+        name: t.text(),
+        active: t.boolean(),
+        ...t.primaryKey(['id', 'name', 'active']),
+      }));
+
+      if (action === 'createTable') {
+        expectSql(`
+          CREATE TABLE "table" (
+            "id" integer NOT NULL,
+            "name" text NOT NULL,
+            "active" boolean NOT NULL,
+            PRIMARY KEY ("id", "name", "active")
+          )
+        `);
+      } else {
+        expectSql(`
+          DROP TABLE "table"
+        `);
+      }
+    });
+
+    it('should support composite primary key with constraint name', async () => {
+      await db[action]('table', (t) => ({
+        id: t.integer(),
+        name: t.text(),
+        active: t.boolean(),
+        ...t.primaryKey(['id', 'name', 'active'], { name: 'primaryKeyName' }),
+      }));
+
+      if (action === 'createTable') {
+        expectSql(`
+          CREATE TABLE "table" (
+            "id" integer NOT NULL,
+            "name" text NOT NULL,
+            "active" boolean NOT NULL,
+            CONSTRAINT "primaryKeyName" PRIMARY KEY ("id", "name", "active")
+          )
+        `);
+      } else {
+        expectSql(`
+          DROP TABLE "table"
+        `);
+      }
+    });
+
+    it('should support composite index', async () => {
+      await db[action]('table', (t) => ({
+        id: t.integer(),
+        name: t.text(),
+        ...t.index(['id', { column: 'name', order: 'DESC' }], {
+          name: 'compositeIndexOnTable',
+        }),
+      }));
+
+      if (action === 'createTable') {
+        expectSql([
+          `
+            CREATE TABLE "table" (
+              "id" integer NOT NULL,
+              "name" text NOT NULL
+            )
+          `,
+          `
+            CREATE INDEX "compositeIndexOnTable" ON "table" ("id", "name" DESC)
+          `,
+        ]);
+      } else {
+        expectSql(`
+          DROP TABLE "table"
+        `);
+      }
+    });
+
+    it('should support composite unique index', async () => {
+      await db[action]('table', (t) => ({
+        id: t.integer(),
+        name: t.text(),
+        ...t.unique(['id', { column: 'name', order: 'DESC' }], {
+          name: 'compositeIndexOnTable',
+        }),
+      }));
+
+      if (action === 'createTable') {
+        expectSql([
+          `
+            CREATE TABLE "table" (
+              "id" integer NOT NULL,
+              "name" text NOT NULL
+            )
+          `,
+          `
+            CREATE UNIQUE INDEX "compositeIndexOnTable" ON "table" ("id", "name" DESC)
+          `,
+        ]);
+      } else {
+        expectSql(`
+          DROP TABLE "table"
+        `);
+      }
+    });
+
+    it('should support composite foreign key', async () => {
+      await db[action]('table', (t) => ({
+        id: t.integer(),
+        name: t.text(),
+        ...t.foreignKey(
+          ['id', 'name'],
+          'otherTable',
+          ['foreignId', 'foreignName'],
+          {
+            name: 'constraintName',
+            match: 'FULL',
+            onUpdate: 'CASCADE',
+            onDelete: 'CASCADE',
+          },
+        ),
+      }));
+
+      if (action === 'createTable') {
+        const expectedConstraint = toLine(`
+          CONSTRAINT "constraintName"
+            FOREIGN KEY ("id", "name")
+            REFERENCES "otherTable"("foreignId", "foreignName")
+            MATCH FULL
+            ON DELETE CASCADE
+            ON UPDATE CASCADE
+        `);
+
+        expectSql(`
+          CREATE TABLE "table" (
+            "id" integer NOT NULL,
+            "name" text NOT NULL,
+            ${expectedConstraint}
+          )
+        `);
+      } else {
+        expectSql(`
+          DROP TABLE "table"
+        `);
+      }
+    });
+  });
+});