rake-db 2.3.3 → 2.3.4

package/migrations/20221017200326_createChatUser.ts

@@ -1,7 +1,7 @@
 import { change } from '../src';
 
 change(async (db) => {
-  await db.createJoinTable(['chat', 'user'], (t) => ({
+  await db.createTable('chatUser', (t) => ({
     chatId: t.integer().foreignKey('chat', 'id'),
     userId: t.integer().foreignKey('user', 'id'),
     ...t.timestamps(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rake-db",
-  "version": "2.3.3",
+  "version": "2.3.4",
   "description": "Migrations tool for Postgresql DB",
   "homepage": "https://orchid-orm.netlify.app/guide/migration-setup-and-overview.html",
   "repository": {

package/src/migration/migration.ts

@@ -26,7 +26,6 @@ import {
   quoteWithSchema,
   getSchemaAndTableFromName,
 } from '../common';
-import { createJoinTable } from './createJoinTable';
 import { RakeDbAst } from '../ast';
 
 export type DropMode = 'CASCADE' | 'RESTRICT';
@@ -131,40 +130,6 @@ export class Migration extends TransactionAdapter {
     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,

package/migrations/20230124210600_pull.ts

@@ -1,86 +0,0 @@
-import { change } from '../src';
-
-change(async (db) => {
-  await db.createSchema('geo');
-
-  await db.createTable('chat', (t) => ({
-    id: t.serial().primaryKey(),
-    title: t.text(),
-    ...t.timestamps(),
-  }));
-
-  await db.createTable('chatUser', (t) => ({
-    chatId: t.integer().foreignKey('chat', 'id'),
-    userId: t.integer().foreignKey('user', 'id'),
-    ...t.timestamps(),
-    ...t.primaryKey(['chatId', 'userId']),
-  }));
-
-  await db.createTable('geo.city', (t) => ({
-    id: t.serial().primaryKey(),
-    name: t.text(),
-    countryId: t.integer().foreignKey('country', 'id'),
-  }));
-
-  await db.createTable('geo.country', (t) => ({
-    id: t.serial().primaryKey(),
-    name: t.text(),
-  }));
-
-  await db.createTable('message', (t) => ({
-    id: t.serial().primaryKey(),
-    chatId: t.integer().foreignKey('chat', 'id').index({
-      name: 'messageChatIdIndex',
-    }),
-    authorId: t.integer().foreignKey('user', 'id').nullable().index({
-      name: 'messageAuthorIdIndex',
-    }),
-    text: t.text(),
-    meta: t.json((t) => t.unknown()).nullable(),
-    ...t.timestamps(),
-  }));
-
-  await db.createTable('profile', (t) => ({
-    id: t.serial().primaryKey(),
-    userId: t.integer().foreignKey('user', 'id').nullable(),
-    bio: t.text().nullable(),
-    ...t.timestamps(),
-  }));
-
-  await db.createTable('uniqueTable', (t) => ({
-    id: t.serial().primaryKey(),
-    one: t.text().unique({
-      name: 'uniqueTableOneIndex',
-    }),
-    two: t.integer().unique({
-      name: 'uniqueTableTwoIndex',
-    }),
-    thirdColumn: t.text(),
-    fourthColumn: t.integer(),
-    ...t.index(
-      [
-        {
-          column: 'thirdColumn',
-        },
-        {
-          column: 'fourthColumn',
-        },
-      ],
-      {
-        name: 'uniqueTableThirdColumnFourthColumnIndex',
-        unique: true,
-      },
-    ),
-  }));
-
-  await db.createTable('user', (t) => ({
-    id: t.serial().primaryKey(),
-    name: t.text(),
-    password: t.text(),
-    picture: t.text().nullable(),
-    data: t.json((t) => t.unknown()).nullable(),
-    age: t.integer().nullable(),
-    active: t.boolean().nullable(),
-    ...t.timestamps(),
-  }));
-});

package/src/migration/createJoinTable.test.ts

@@ -1,96 +0,0 @@
-import { getPrimaryKeysOfTable } from './migrationUtils';
-import { expectSql, getDb, queryMock, resetDb } from '../test-utils';
-
-const db = getDb();
-
-jest.mock('./migrationUtils', () => ({
-  ...jest.requireActual('./migrationUtils'),
-  getPrimaryKeysOfTable: jest.fn(),
-}));
-
-describe('join table', () => {
-  beforeEach(resetDb);
-
-  (['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 "postsComments_commentId_commentAuthorName_fkey" 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)();
-      });
-
-      it('should throw error if table has no primary key', async () => {
-        db.up = action !== 'dropJoinTable';
-
-        (getPrimaryKeysOfTable as jest.Mock)
-          .mockResolvedValueOnce([
-            {
-              name: 'id',
-              type: 'integer',
-            },
-          ])
-          .mockResolvedValueOnce([]);
-
-        await expect(db[action](['posts', 'comments'])).rejects.toThrow(
-          'Primary key for table "comments" is not defined',
-        );
-      });
-    });
-  });
-});

package/src/migration/createJoinTable.ts

@@ -1,107 +0,0 @@
-import { ColumnType, Operators } from 'pqb';
-import { ColumnsShapeCallback, JoinTableOptions, Migration } from './migration';
-import {
-  getSchemaAndTableFromName,
-  joinWords,
-  quoteWithSchema,
-} from '../common';
-import { getPrimaryKeysOfTable } from './migrationUtils';
-import { singular } from 'pluralize';
-import { createTable } from './createTable';
-
-class UnknownColumn extends ColumnType {
-  operators = Operators.any;
-
-  constructor(public dataType: string) {
-    super();
-  }
-
-  toCode() {
-    return 'unknown';
-  }
-}
-
-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, noPrimaryKey: true },
-      () => ({}),
-    );
-  }
-
-  const tablesWithPrimaryKeys = await Promise.all(
-    tables.map(async (table) => {
-      const primaryKeys = await getPrimaryKeysOfTable(migration, table).then(
-        (items) =>
-          items.map((item) => ({
-            ...item,
-            joinedName: joinWords(singular(table), item.name),
-          })),
-      );
-
-      const [schema, name] = getSchemaAndTableFromName(table);
-      if (!primaryKeys.length) {
-        throw new Error(
-          `Primary key for table ${quoteWithSchema({
-            schema,
-            name,
-          })} is not defined`,
-        );
-      }
-
-      return [schema, table, primaryKeys] as const;
-    }),
-  );
-
-  return createTable(migration, up, tableName, options, (t) => {
-    const result: Record<string, ColumnType> = {};
-
-    tablesWithPrimaryKeys.forEach(([schema, table, primaryKeys]) => {
-      if (primaryKeys.length === 1) {
-        const [{ type, joinedName, name }] = primaryKeys;
-
-        const column = new UnknownColumn(type);
-
-        result[joinedName] = column.foreignKey(
-          schema ? `${schema}.${table}` : 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;
-  });
-};