rake-db 2.3.2 → 2.3.3

package/migrations/20230124210600_pull.ts

@@ -0,0 +1,86 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rake-db",
-  "version": "2.3.2",
+  "version": "2.3.3",
   "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/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],