rake-db 2.3.2 → 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.2",
+  "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/changeTable.test.ts

@@ -139,7 +139,7 @@ describe('changeTable', () => {
               WHERE column = 123
           `),
           toLine(`
-            CREATE UNIQUE INDEX "tableUniqueColumnIndex"
+            CREATE UNIQUE INDEX "table_uniqueColumn_idx"
               ON "table"
               ("uniqueColumn")
           `),
@@ -169,7 +169,7 @@ describe('changeTable', () => {
               DROP COLUMN "updatedAt"
           `,
           toLine(`DROP INDEX "indexName"`),
-          toLine(`DROP INDEX "tableUniqueColumnIndex" CASCADE`),
+          toLine(`DROP INDEX "table_uniqueColumn_idx" CASCADE`),
         ]);
       };
 
@@ -664,11 +664,11 @@ describe('changeTable', () => {
 
     await fn();
     expectSql([
-      `DROP INDEX "tableRemoveIndexIndex"`,
-      `DROP INDEX "tableRemoveIndexWithOptionsIndex" CASCADE`,
+      `DROP INDEX "table_removeIndex_idx"`,
+      `DROP INDEX "table_removeIndexWithOptions_idx" CASCADE`,
       `DROP INDEX "from" CASCADE`,
-      `CREATE INDEX "tableAddIndexIndex" ON "table" ("addIndex")`,
-      `CREATE UNIQUE INDEX "tableAddIndexWithOptionsIndex" ON "table" USING using ("addIndexWithOptions" COLLATE 'collate' opclass order) INCLUDE ("a", "b") WITH (with) TABLESPACE tablespace WHERE where`,
+      `CREATE INDEX "table_addIndex_idx" ON "table" ("addIndex")`,
+      `CREATE UNIQUE INDEX "table_addIndexWithOptions_idx" ON "table" USING using ("addIndexWithOptions" COLLATE 'collate' opclass order) INCLUDE ("a", "b") WITH (with) TABLESPACE tablespace WHERE where`,
       `CREATE UNIQUE INDEX "to" ON "table" USING to ("changeIndex" COLLATE 'to' to to) INCLUDE ("c", "d") WITH (to) TABLESPACE to WHERE to`,
     ]);
 
@@ -676,11 +676,11 @@ describe('changeTable', () => {
     db.up = false;
     await fn();
     expectSql([
-      `DROP INDEX "tableAddIndexIndex"`,
-      `DROP INDEX "tableAddIndexWithOptionsIndex" CASCADE`,
+      `DROP INDEX "table_addIndex_idx"`,
+      `DROP INDEX "table_addIndexWithOptions_idx" CASCADE`,
       `DROP INDEX "to" RESTRICT`,
-      `CREATE INDEX "tableRemoveIndexIndex" ON "table" ("removeIndex")`,
-      `CREATE UNIQUE INDEX "tableRemoveIndexWithOptionsIndex" ON "table" USING using ("removeIndexWithOptions" COLLATE 'collate' opclass order) INCLUDE ("a", "b") WITH (with) TABLESPACE tablespace WHERE where`,
+      `CREATE INDEX "table_removeIndex_idx" ON "table" ("removeIndex")`,
+      `CREATE UNIQUE INDEX "table_removeIndexWithOptions_idx" ON "table" USING using ("removeIndexWithOptions" COLLATE 'collate' opclass order) INCLUDE ("a", "b") WITH (with) TABLESPACE tablespace WHERE where`,
       `CREATE INDEX "from" ON "table" USING from ("changeIndex" COLLATE 'from' from from) INCLUDE ("a", "b") WITH (from) TABLESPACE from WHERE from`,
     ]);
   });

package/src/migration/createTable.test.ts

@@ -119,7 +119,7 @@ const db = getDb();
               WHERE column = 123
           `),
           toLine(`
-            CREATE UNIQUE INDEX "tableUniqueColumnIndex"
+            CREATE UNIQUE INDEX "table_uniqueColumn_idx"
               ON "table"
               ("uniqueColumn")
           `),

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/src/migration/migrationUtils.ts

@@ -13,7 +13,6 @@ import { ColumnComment, Migration } from './migration';
 import {
   getSchemaAndTableFromName,
   joinColumns,
-  joinWords,
   quoteWithSchema,
 } from '../common';
 
@@ -105,13 +104,17 @@ export const getForeignKeyTable = (
   return [item.schema, item.table];
 };
 
+export const getForeignKeyName = (table: string, columns: string[]) => {
+  return `${table}_${columns.join('_')}_fkey`;
+};
+
 export const constraintToSql = (
   { name }: { schema?: string; name: string },
   up: boolean,
   foreignKey: TableData['foreignKeys'][number],
 ) => {
   const constraintName =
-    foreignKey.options.name || `${name}_${foreignKey.columns.join('_')}_fkey`;
+    foreignKey.options.name || getForeignKeyName(name, foreignKey.columns);
 
   if (!up) {
     const { dropMode } = foreignKey.options;
@@ -156,21 +159,26 @@ export const referencesToSql = (
   return sql.join(' ');
 };
 
+export const getIndexName = (
+  table: string,
+  columns: TableData.Index['columns'],
+) => {
+  return `${table}_${columns
+    .map((it) =>
+      'column' in it
+        ? it.column
+        : it.expression.match(/\w+/g)?.join('_') || 'expression',
+    )
+    .join('_')}_idx`;
+};
+
 export const indexesToQuery = (
   up: boolean,
   { schema, name }: { schema?: string; name: string },
   indexes: TableData.Index[],
 ): Sql[] => {
   return indexes.map(({ columns, options }) => {
-    const indexName =
-      options.name ||
-      joinWords(
-        name,
-        ...columns
-          .filter((it): it is { column: string } => 'column' in it)
-          .map((it) => it.column),
-        'index',
-      );
+    const indexName = options.name || getIndexName(name, columns);
 
     if (!up) {
       return {

package/src/pull/structureToAst.test.ts

@@ -14,6 +14,7 @@ import {
 } from 'pqb';
 import { structureToAst } from './structureToAst';
 import { RakeDbAst } from '../ast';
+import { getIndexName } from '../migration/migrationUtils';
 
 const adapter = new Adapter({ databaseURL: 'file:path' });
 const query = jest.fn().mockImplementation(() => ({ rows: [] }));
@@ -361,6 +362,23 @@ describe('structureToAst', () => {
       expect(ast.indexes).toHaveLength(0);
     });
 
+    it('should ignore standard index name', async () => {
+      const db = new DbStructure(adapter);
+      db.getTables = async () => [table];
+      db.getColumns = async () => columns;
+      db.getIndexes = async () => [
+        { ...index, name: getIndexName(table.name, index.columns) },
+      ];
+
+      const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
+      expect(ast.shape.name.data.indexes).toEqual([
+        {
+          unique: false,
+        },
+      ]);
+      expect(ast.indexes).toHaveLength(0);
+    });
+
     it('should set index options to column index', async () => {
       const db = new DbStructure(adapter);
       db.getTables = async () => [table];
@@ -430,6 +448,30 @@ describe('structureToAst', () => {
       ]);
     });
 
+    it('should ignore standard index name in composite index', async () => {
+      const db = new DbStructure(adapter);
+      db.getTables = async () => [table];
+      db.getColumns = async () => columns;
+
+      const indexColumns = [{ column: 'id' }, { column: 'name' }];
+      db.getIndexes = async () => [
+        {
+          ...index,
+          columns: indexColumns,
+          name: getIndexName(table.name, indexColumns),
+        },
+      ];
+
+      const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
+      expect(ast.shape.name.data.indexes).toBe(undefined);
+      expect(ast.indexes).toEqual([
+        {
+          columns: indexColumns,
+          options: { unique: false },
+        },
+      ]);
+    });
+
     it('should add index with expression and options to the table', async () => {
       const db = new DbStructure(adapter);
       db.getTables = async () => [table];
@@ -503,6 +545,31 @@ describe('structureToAst', () => {
       expect(ast.foreignKeys).toHaveLength(0);
     });
 
+    it('should ignore standard foreign key name', async () => {
+      const db = new DbStructure(adapter);
+      db.getTables = async () => [table];
+      db.getColumns = async () => [
+        ...columns,
+        { ...intColumn, name: 'otherId' },
+      ];
+      db.getForeignKeys = async () => [
+        { ...foreignKey, name: `${table.name}_otherId_fkey` },
+      ];
+
+      const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
+
+      expect(ast.shape.otherId.data.foreignKeys).toEqual([
+        {
+          columns: ['id'],
+          table: 'otherTable',
+          match: 'FULL',
+          onUpdate: 'CASCADE',
+          onDelete: 'CASCADE',
+        },
+      ]);
+      expect(ast.foreignKeys).toHaveLength(0);
+    });
+
     it('should add composite foreign key', async () => {
       const db = new DbStructure(adapter);
       db.getTables = async () => [table];
@@ -535,6 +602,39 @@ describe('structureToAst', () => {
         },
       ]);
     });
+
+    it('should ignore standard foreign key name in a composite foreign key', async () => {
+      const db = new DbStructure(adapter);
+      db.getTables = async () => [table];
+      db.getColumns = async () => [
+        ...columns,
+        { ...intColumn, name: 'otherId' },
+      ];
+      db.getForeignKeys = async () => [
+        {
+          ...foreignKey,
+          columnNames: ['name', 'otherId'],
+          foreignColumnNames: ['name', 'id'],
+          name: 'table_name_otherId_fkey',
+        },
+      ];
+
+      const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
+
+      expect(ast.shape.otherId.data.foreignKeys).toBe(undefined);
+      expect(ast.foreignKeys).toEqual([
+        {
+          columns: ['name', 'otherId'],
+          fnOrTable: 'otherTable',
+          foreignColumns: ['name', 'id'],
+          options: {
+            match: 'FULL',
+            onUpdate: 'CASCADE',
+            onDelete: 'CASCADE',
+          },
+        },
+      ]);
+    });
   });
 
   describe('extension', () => {

package/src/pull/structureToAst.ts

@@ -7,6 +7,7 @@ import {
   instantiateColumn,
   singleQuote,
 } from 'pqb';
+import { getForeignKeyName, getIndexName } from '../migration/migrationUtils';
 
 const matchMap = {
   s: undefined,
@@ -98,7 +99,10 @@ export const structureToAst = async (db: DbStructure): Promise<RakeDbAst[]> => {
           collate: options.collate,
           opclass: options.opclass,
           order: options.order,
-          name: index.name,
+          name:
+            index.name !== getIndexName(name, index.columns)
+              ? index.name
+              : undefined,
           using: index.using === 'btree' ? undefined : index.using,
           unique: index.isUnique,
           include: index.include,
@@ -116,7 +120,12 @@ export const structureToAst = async (db: DbStructure): Promise<RakeDbAst[]> => {
           foreignKey.foreignTableName,
           foreignKey.foreignColumnNames[0],
           {
-            name: foreignKey.name,
+            name:
+              foreignKey.name &&
+              foreignKey.name !==
+                getForeignKeyName(name, foreignKey.columnNames)
+                ? foreignKey.name
+                : undefined,
             match: matchMap[foreignKey.match],
             onUpdate: fkeyActionMap[foreignKey.onUpdate],
             onDelete: fkeyActionMap[foreignKey.onDelete],
@@ -161,7 +170,10 @@ export const structureToAst = async (db: DbStructure): Promise<RakeDbAst[]> => {
             order: it.order,
           })),
           options: {
-            name: index.name,
+            name:
+              index.name !== getIndexName(name, index.columns)
+                ? index.name
+                : undefined,
             using: index.using === 'btree' ? undefined : index.using,
             unique: index.isUnique,
             include: index.include,
@@ -177,7 +189,10 @@ export const structureToAst = async (db: DbStructure): Promise<RakeDbAst[]> => {
           fnOrTable: it.foreignTableName,
           foreignColumns: it.foreignColumnNames,
           options: {
-            name: it.name,
+            name:
+              it.name && it.name !== getForeignKeyName(name, it.columnNames)
+                ? it.name
+                : undefined,
             match: matchMap[it.match],
             onUpdate: fkeyActionMap[it.onUpdate],
             onDelete: fkeyActionMap[it.onDelete],

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;
-  });
-};