rake-db 1.3.2 → 2.0.0

package/src/migration/createTable.ts

@@ -0,0 +1,169 @@
+import {
+  ColumnType,
+  columnTypes,
+  getColumnTypes,
+  getTableData,
+  Operators,
+  quote,
+} from 'pqb';
+import {
+  TableOptions,
+  ColumnsShapeCallback,
+  Migration,
+  ColumnIndex,
+  ColumnComment,
+  JoinTableOptions,
+} from './migration';
+import {
+  addColumnComment,
+  addColumnIndex,
+  columnToSql,
+  constraintToSql,
+  getPrimaryKeysOfTable,
+  migrateComments,
+  migrateIndexes,
+  primaryKeyToSql,
+} from './migrationUtils';
+import { joinWords } from '../common';
+import { singular } from 'pluralize';
+
+class UnknownColumn extends ColumnType {
+  operators = Operators.any;
+
+  constructor(public dataType: string) {
+    super();
+  }
+}
+
+export const createJoinTable = async (
+  migration: Migration,
+  up: boolean,
+  tables: string[],
+  options: JoinTableOptions,
+  fn?: ColumnsShapeCallback,
+) => {
+  const tableName = options.tableName || joinWords(...tables);
+
+  if (!up) {
+    return createTable(migration, up, tableName, options, () => ({}));
+  }
+
+  const tablesWithPrimaryKeys = await Promise.all(
+    tables.map(
+      async (table) =>
+        [
+          table,
+          await getPrimaryKeysOfTable(migration, table).then((items) =>
+            items.map((item) => ({
+              ...item,
+              joinedName: joinWords(singular(table), item.name),
+            })),
+          ),
+        ] as const,
+    ),
+  );
+
+  return createTable(migration, up, tableName, options, (t) => {
+    const result: Record<string, ColumnType> = {};
+
+    tablesWithPrimaryKeys.forEach(([table, primaryKeys]) => {
+      if (primaryKeys.length === 1) {
+        const [{ type, joinedName, name }] = primaryKeys;
+
+        const column = new UnknownColumn(type);
+
+        result[joinedName] = column.foreignKey(table, name);
+
+        return;
+      }
+
+      primaryKeys.forEach(({ joinedName, type }) => {
+        result[joinedName] = new UnknownColumn(type);
+      });
+
+      t.foreignKey(
+        primaryKeys.map((key) => key.joinedName) as [string, ...string[]],
+        table,
+        primaryKeys.map((key) => key.name) as [string, ...string[]],
+      );
+    });
+
+    if (fn) {
+      Object.assign(result, fn(t));
+    }
+
+    t.primaryKey(
+      tablesWithPrimaryKeys.flatMap(([, primaryKeys]) =>
+        primaryKeys.map((item) => item.joinedName),
+      ),
+    );
+
+    return result;
+  });
+};
+
+export const createTable = async (
+  migration: Migration,
+  up: boolean,
+  tableName: string,
+  options: TableOptions,
+  fn: ColumnsShapeCallback,
+) => {
+  const shape = getColumnTypes(columnTypes, fn);
+
+  if (!up) {
+    const { dropMode } = options;
+    await migration.query(
+      `DROP TABLE "${tableName}"${dropMode ? ` ${dropMode}` : ''}`,
+    );
+    return;
+  }
+
+  const lines: string[] = [];
+
+  const state: {
+    migration: Migration;
+    tableName: string;
+    values: unknown[];
+    indexes: ColumnIndex[];
+    comments: ColumnComment[];
+  } = {
+    migration,
+    tableName,
+    values: [],
+    indexes: [],
+    comments: [],
+  };
+
+  for (const key in shape) {
+    const item = shape[key];
+    addColumnIndex(state.indexes, key, item);
+    addColumnComment(state.comments, key, item);
+    lines.push(`\n  ${columnToSql(key, item, state)}`);
+  }
+
+  const tableData = getTableData();
+  if (tableData.primaryKey) {
+    lines.push(`\n  ${primaryKeyToSql(tableData.primaryKey)}`);
+  }
+
+  tableData.foreignKeys.forEach((foreignKey) => {
+    lines.push(`\n  ${constraintToSql(state.tableName, up, foreignKey)}`);
+  });
+
+  await migration.query({
+    text: `CREATE TABLE "${tableName}" (${lines.join(',')}\n)`,
+    values: state.values,
+  });
+
+  state.indexes.push(...tableData.indexes);
+
+  await migrateIndexes(state, state.indexes, up);
+  await migrateComments(state, state.comments);
+
+  if (options.comment) {
+    await migration.query(
+      `COMMENT ON TABLE "${tableName}" IS ${quote(options.comment)}`,
+    );
+  }
+};

package/src/migration/migration.test.ts

@@ -0,0 +1,341 @@
+import { expectSql, getDb, queryMock, resetDb, toLine } from '../test-utils';
+import { getPrimaryKeysOfTable } from './migrationUtils';
+
+const db = getDb();
+
+jest.mock('./migrationUtils', () => ({
+  ...jest.requireActual('./migrationUtils'),
+  getPrimaryKeysOfTable: jest.fn(),
+}));
+
+describe('migration', () => {
+  beforeEach(resetDb);
+
+  describe('renameTable', () => {
+    it('should rename a table', async () => {
+      const fn = () => {
+        return db.renameTable('from', 'to');
+      };
+
+      await fn();
+      expectSql(`
+        ALTER TABLE "from" RENAME TO "to"
+      `);
+
+      db.up = false;
+      queryMock.mockClear();
+      await fn();
+      expectSql(`
+        ALTER TABLE "to" RENAME TO "from"
+      `);
+    });
+  });
+
+  (['addColumn', 'dropColumn'] as const).forEach((action) => {
+    describe(action, () => {
+      it(`should use changeTable to ${
+        action === 'addColumn' ? 'add' : 'drop'
+      } a column`, async () => {
+        const fn = () => {
+          return db[action]('table', 'column', (t) => t.text());
+        };
+
+        const expectAddColumn = () => {
+          expectSql(`
+            ALTER TABLE "table"
+            ADD COLUMN "column" text NOT NULL
+          `);
+        };
+
+        const expectDropColumn = () => {
+          expectSql(`
+            ALTER TABLE "table"
+            DROP COLUMN "column"
+          `);
+        };
+
+        await fn();
+        (action === 'addColumn' ? expectAddColumn : expectDropColumn)();
+
+        db.up = false;
+        queryMock.mockClear();
+        await fn();
+        (action === 'addColumn' ? expectDropColumn : expectAddColumn)();
+      });
+    });
+  });
+
+  (['addIndex', 'dropIndex'] as const).forEach((action) => {
+    describe(action, () => {
+      it(`should use changeTable to ${
+        action === 'addIndex' ? 'add' : 'drop'
+      } an index`, async () => {
+        const fn = () => {
+          return db[action](
+            'table',
+            ['id', { column: 'name', order: 'DESC' }],
+            {
+              name: 'indexName',
+            },
+          );
+        };
+
+        const expectAddIndex = () => {
+          expectSql(`
+            CREATE INDEX "indexName" ON "table" ("id", "name" DESC)
+          `);
+        };
+
+        const expectDropIndex = () => {
+          expectSql(`
+            DROP INDEX "indexName"
+          `);
+        };
+
+        await fn();
+        (action === 'addIndex' ? expectAddIndex : expectDropIndex)();
+
+        db.up = false;
+        queryMock.mockClear();
+        await fn();
+        (action === 'addIndex' ? expectDropIndex : expectAddIndex)();
+      });
+    });
+  });
+
+  (['addForeignKey', 'dropForeignKey'] as const).forEach((action) => {
+    describe(action, () => {
+      it(`should use changeTable to ${
+        action === 'addForeignKey' ? 'add' : 'drop'
+      } a foreignKey`, async () => {
+        const fn = () => {
+          return db[action](
+            'table',
+            ['id', 'name'],
+            'otherTable',
+            ['foreignId', 'foreignName'],
+            {
+              name: 'constraintName',
+              match: 'FULL',
+              onUpdate: 'CASCADE',
+              onDelete: 'CASCADE',
+              dropMode: 'CASCADE',
+            },
+          );
+        };
+
+        const expectAddForeignKey = () => {
+          const expectedConstraint = toLine(`
+            ADD CONSTRAINT "constraintName"
+              FOREIGN KEY ("id", "name")
+              REFERENCES "otherTable"("foreignId", "foreignName")
+              MATCH FULL
+              ON DELETE CASCADE
+              ON UPDATE CASCADE
+          `);
+          expectSql(`
+            ALTER TABLE "table"
+            ${expectedConstraint}
+          `);
+        };
+
+        const expectDropForeignKey = () => {
+          expectSql(`
+            ALTER TABLE "table"
+            DROP CONSTRAINT "constraintName" CASCADE
+          `);
+        };
+
+        await fn();
+        (action === 'addForeignKey'
+          ? expectAddForeignKey
+          : expectDropForeignKey)();
+
+        db.up = false;
+        queryMock.mockClear();
+        await fn();
+        (action === 'addForeignKey'
+          ? expectDropForeignKey
+          : expectAddForeignKey)();
+      });
+    });
+  });
+
+  (['addPrimaryKey', 'dropPrimaryKey'] as const).forEach((action) => {
+    describe(action, () => {
+      it(`should use changeTable to ${
+        action === 'addPrimaryKey' ? 'add' : 'drop'
+      } primary key`, async () => {
+        const fn = () => {
+          return db[action]('table', ['id', 'name']);
+        };
+
+        const expectAddPrimaryKey = () => {
+          expectSql(`
+            ALTER TABLE "table"
+            ADD PRIMARY KEY ("id", "name")
+          `);
+        };
+
+        const expectDropPrimaryKey = () => {
+          expectSql(`
+            ALTER TABLE "table"
+            DROP CONSTRAINT "table_pkey"
+          `);
+        };
+
+        await fn();
+        (action === 'addPrimaryKey'
+          ? expectAddPrimaryKey
+          : expectDropPrimaryKey)();
+
+        db.up = false;
+        queryMock.mockClear();
+        await fn();
+        (action === 'addPrimaryKey'
+          ? expectDropPrimaryKey
+          : expectAddPrimaryKey)();
+      });
+
+      it('should use changeTable to add primary key with constraint name', async () => {
+        const fn = () => {
+          return db.addPrimaryKey('table', ['id', 'name'], {
+            name: 'primaryKeyName',
+          });
+        };
+
+        await fn();
+        expectSql(`
+          ALTER TABLE "table"
+          ADD CONSTRAINT "primaryKeyName" PRIMARY KEY ("id", "name")
+        `);
+
+        db.up = false;
+        queryMock.mockClear();
+        await fn();
+        expectSql(`
+          ALTER TABLE "table"
+          DROP CONSTRAINT "primaryKeyName"
+        `);
+      });
+    });
+  });
+
+  describe('renameColumn', () => {
+    it('should use changeTable to rename a column', async () => {
+      const fn = () => {
+        return db.renameColumn('table', 'from', 'to');
+      };
+
+      await fn();
+      expectSql(`
+        ALTER TABLE "table"
+        RENAME COLUMN "from" TO "to"
+      `);
+
+      db.up = false;
+      queryMock.mockClear();
+      await fn();
+      expectSql(`
+        ALTER TABLE "table"
+        RENAME COLUMN "to" TO "from"
+      `);
+    });
+  });
+
+  (['createJoinTable', 'dropJoinTable'] as const).forEach((action) => {
+    describe(action, () => {
+      it(`should ${
+        action === 'createJoinTable' ? 'create' : 'drop'
+      } a join table`, async () => {
+        const fn = () => {
+          return db[action](['posts', 'comments'], (t) => ({
+            ...t.timestamps(),
+          }));
+        };
+
+        const expectCreateTable = async () => {
+          (getPrimaryKeysOfTable as jest.Mock)
+            .mockResolvedValueOnce([
+              {
+                name: 'uuid',
+                type: 'uuid',
+              },
+            ])
+            .mockResolvedValueOnce([
+              {
+                name: 'id',
+                type: 'integer',
+              },
+              {
+                name: 'authorName',
+                type: 'text',
+              },
+            ]);
+
+          await fn();
+
+          expectSql(`
+            CREATE TABLE "postsComments" (
+              "postUuid" uuid NOT NULL REFERENCES "posts"("uuid"),
+              "commentId" integer NOT NULL,
+              "commentAuthorName" text NOT NULL,
+              "createdAt" timestamp NOT NULL DEFAULT now(),
+              "updatedAt" timestamp NOT NULL DEFAULT now(),
+              PRIMARY KEY ("postUuid", "commentId", "commentAuthorName"),
+              CONSTRAINT "postsCommentsToComments" FOREIGN KEY ("commentId", "commentAuthorName") REFERENCES "comments"("id", "authorName")
+            )
+          `);
+        };
+
+        const expectDropTable = async () => {
+          await fn();
+
+          expectSql(`
+            DROP TABLE "postsComments"
+          `);
+        };
+
+        await (action === 'createJoinTable'
+          ? expectCreateTable
+          : expectDropTable)();
+
+        db.up = false;
+        queryMock.mockClear();
+        await (action === 'createJoinTable'
+          ? expectDropTable
+          : expectCreateTable)();
+      });
+    });
+  });
+
+  describe('tableExists', () => {
+    it('should return boolean', async () => {
+      queryMock.mockResolvedValueOnce({ rowCount: 1 });
+      expect(await db.tableExists('table')).toBe(true);
+
+      queryMock.mockResolvedValueOnce({ rowCount: 0 });
+      expect(await db.tableExists('table')).toBe(false);
+    });
+  });
+
+  describe('columnExists', () => {
+    it('should return boolean', async () => {
+      queryMock.mockResolvedValueOnce({ rowCount: 1 });
+      expect(await db.columnExists('table', 'colum')).toBe(true);
+
+      queryMock.mockResolvedValueOnce({ rowCount: 0 });
+      expect(await db.columnExists('table', 'colum')).toBe(false);
+    });
+  });
+
+  describe('constraintExists', () => {
+    it('should return boolean', async () => {
+      queryMock.mockResolvedValueOnce({ rowCount: 1 });
+      expect(await db.constraintExists('constraintName')).toBe(true);
+
+      queryMock.mockResolvedValueOnce({ rowCount: 0 });
+      expect(await db.constraintExists('constraintName')).toBe(false);
+    });
+  });
+});