rake-db 2.2.5 → 2.3.0

package/src/commands/migrateOrRollback.ts

@@ -4,7 +4,7 @@ import {
   getMigrationFiles,
   RakeDbConfig,
   MigrationFile,
-  quoteTable,
+  quoteWithSchema,
 } from '../common';
 import {
   getCurrentPromise,
@@ -105,7 +105,9 @@ const saveMigratedVersion = async (
   config: RakeDbConfig,
 ) => {
   await db.query(
-    `INSERT INTO ${quoteTable(config.migrationsTable)} VALUES ('${version}')`,
+    `INSERT INTO ${quoteWithSchema({
+      name: config.migrationsTable,
+    })} VALUES ('${version}')`,
   );
 };
 
@@ -115,9 +117,9 @@ const removeMigratedVersion = async (
   config: RakeDbConfig,
 ) => {
   await db.query(
-    `DELETE FROM ${quoteTable(
-      config.migrationsTable,
-    )} WHERE version = '${version}'`,
+    `DELETE FROM ${quoteWithSchema({
+      name: config.migrationsTable,
+    })} WHERE version = '${version}'`,
   );
 };
 
@@ -127,7 +129,7 @@ const getMigratedVersionsMap = async (
 ): Promise<Record<string, boolean>> => {
   try {
     const result = await db.arrays<[string]>(
-      `SELECT * FROM ${quoteTable(config.migrationsTable)}`,
+      `SELECT * FROM ${quoteWithSchema({ name: config.migrationsTable })}`,
     );
     return Object.fromEntries(result.rows.map((row) => [row[0], true]));
   } catch (err) {

package/src/common.test.ts

@@ -8,7 +8,7 @@ import {
   joinColumns,
   joinWords,
   migrationConfigDefaults,
-  quoteTable,
+  quoteWithSchema,
   setAdapterOptions,
   setAdminCredentialsToOptions,
   sortAsc,
@@ -285,13 +285,15 @@ describe('common', () => {
     });
   });
 
-  describe('quoteTable', () => {
-    it('should quote a table', () => {
-      expect(quoteTable('table')).toBe('"table"');
+  describe('quoteWithSchema', () => {
+    it('should quote a name', () => {
+      expect(quoteWithSchema({ name: 'table' })).toBe('"table"');
     });
 
-    it('should quote a table with schema', () => {
-      expect(quoteTable('schema.table')).toBe('"schema"."table"');
+    it('should quote a name with schema', () => {
+      expect(quoteWithSchema({ schema: 'schema', name: 'table' })).toBe(
+        '"schema"."table"',
+      );
     });
   });
 });

package/src/common.ts

@@ -126,9 +126,9 @@ export const createSchemaMigrations = async (
 ) => {
   try {
     await db.query(
-      `CREATE TABLE ${quoteTable(
-        config.migrationsTable,
-      )} ( version TEXT NOT NULL )`,
+      `CREATE TABLE ${quoteWithSchema({
+        name: config.migrationsTable,
+      })} ( version TEXT NOT NULL )`,
     );
     console.log('Created versions table');
   } catch (err) {
@@ -235,11 +235,21 @@ export const joinColumns = (columns: string[]) => {
   return columns.map((column) => `"${column}"`).join(', ');
 };
 
-export const quoteTable = (table: string) => {
-  const index = table.indexOf('.');
-  if (index !== -1) {
-    return `"${table.slice(0, index)}"."${table.slice(index + 1)}"`;
-  } else {
-    return `"${table}"`;
-  }
+export const quoteWithSchema = ({
+  schema,
+  name,
+}: {
+  schema?: string;
+  name: string;
+}) => {
+  return schema ? `"${schema}"."${name}"` : `"${name}"`;
+};
+
+export const getSchemaAndTableFromName = (
+  name: string,
+): [string | undefined, string] => {
+  const index = name.indexOf('.');
+  return index !== -1
+    ? [name.slice(0, index), name.slice(index + 1)]
+    : [undefined, name];
 };

package/src/migration/changeTable.test.ts

@@ -18,6 +18,23 @@ describe('changeTable', () => {
     expect(db.options.appCodeUpdater).toHaveBeenCalled();
   });
 
+  it('should work for table with schema', async () => {
+    const fn = () => {
+      return db.changeTable('schema.table', (t) => ({
+        column: t.add(t.text()),
+      }));
+    };
+
+    await fn();
+    expectSql(
+      `ALTER TABLE "schema"."table"\nADD COLUMN "column" text NOT NULL`,
+    );
+
+    setDbDown();
+    await fn();
+    expectSql(`ALTER TABLE "schema"."table"\nDROP COLUMN "column"`);
+  });
+
   it('should set comment', async () => {
     const fn = () => {
       return db.changeTable('table', { comment: 'comment' });
@@ -61,9 +78,8 @@ describe('changeTable', () => {
               name: 'indexName',
               unique: true,
               using: 'gin',
-              expression: 10,
               collate: 'utf-8',
-              operator: 'operator',
+              opclass: 'opclass',
               order: 'ASC',
               include: 'id',
               with: 'fillfactor = 70',
@@ -116,7 +132,7 @@ describe('changeTable', () => {
             CREATE UNIQUE INDEX "indexName"
               ON "table"
               USING gin
-              ("withIndex"(10) COLLATE 'utf-8' operator ASC)
+              ("withIndex" COLLATE 'utf-8' opclass ASC)
               INCLUDE ("id")
               WITH (fillfactor = 70)
               TABLESPACE tablespace
@@ -587,9 +603,8 @@ describe('changeTable', () => {
         addIndexWithOptions: t.change(
           t.integer(),
           t.integer().index({
-            expression: 'expression',
             collate: 'collate',
-            operator: 'operator',
+            opclass: 'opclass',
             order: 'order',
             unique: true,
             using: 'using',
@@ -603,9 +618,8 @@ describe('changeTable', () => {
         removeIndex: t.change(t.integer().index(), t.integer()),
         removeIndexWithOptions: t.change(
           t.integer().index({
-            expression: 'expression',
             collate: 'collate',
-            operator: 'operator',
+            opclass: 'opclass',
             order: 'order',
             unique: true,
             using: 'using',
@@ -620,9 +634,8 @@ describe('changeTable', () => {
         changeIndex: t.change(
           t.integer().index({
             name: 'from',
-            expression: 'from',
             collate: 'from',
-            operator: 'from',
+            opclass: 'from',
             order: 'from',
             unique: false,
             using: 'from',
@@ -634,9 +647,8 @@ describe('changeTable', () => {
           }),
           t.integer().index({
             name: 'to',
-            expression: 'to',
             collate: 'to',
-            operator: 'to',
+            opclass: 'to',
             order: 'to',
             unique: true,
             using: 'to',
@@ -656,8 +668,8 @@ describe('changeTable', () => {
       `DROP INDEX "tableRemoveIndexWithOptionsIndex" CASCADE`,
       `DROP INDEX "from" CASCADE`,
       `CREATE INDEX "tableAddIndexIndex" ON "table" ("addIndex")`,
-      `CREATE UNIQUE INDEX "tableAddIndexWithOptionsIndex" ON "table" USING using ("addIndexWithOptions"(expression) COLLATE 'collate' operator order) INCLUDE ("a", "b") WITH (with) TABLESPACE tablespace WHERE where`,
-      `CREATE UNIQUE INDEX "to" ON "table" USING to ("changeIndex"(to) COLLATE 'to' to to) INCLUDE ("c", "d") WITH (to) TABLESPACE to WHERE to`,
+      `CREATE UNIQUE INDEX "tableAddIndexWithOptionsIndex" 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`,
     ]);
 
     queryMock.mockClear();
@@ -668,8 +680,8 @@ describe('changeTable', () => {
       `DROP INDEX "tableAddIndexWithOptionsIndex" CASCADE`,
       `DROP INDEX "to" RESTRICT`,
       `CREATE INDEX "tableRemoveIndexIndex" ON "table" ("removeIndex")`,
-      `CREATE UNIQUE INDEX "tableRemoveIndexWithOptionsIndex" ON "table" USING using ("removeIndexWithOptions"(expression) COLLATE 'collate' operator order) INCLUDE ("a", "b") WITH (with) TABLESPACE tablespace WHERE where`,
-      `CREATE INDEX "from" ON "table" USING from ("changeIndex"(from) COLLATE 'from' from from) INCLUDE ("a", "b") WITH (from) TABLESPACE from WHERE from`,
+      `CREATE UNIQUE INDEX "tableRemoveIndexWithOptionsIndex" 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/changeTable.ts

@@ -23,7 +23,7 @@ import {
   runCodeUpdater,
 } from './migration';
 import { RakeDbAst } from '../ast';
-import { quoteTable } from '../common';
+import { getSchemaAndTableFromName, quoteWithSchema } from '../common';
 import {
   addColumnComment,
   addColumnIndex,
@@ -127,18 +127,18 @@ const columnTypeToColumnChange = (
   item: ColumnType | Change,
 ): RakeDbAst.ColumnChange => {
   if (item instanceof ColumnType) {
-    const foreignKey = item.data.foreignKey;
-    if (foreignKey && 'fn' in foreignKey) {
+    const foreignKeys = item.data.foreignKeys;
+    if (foreignKeys?.some((it) => 'fn' in it)) {
       throw new Error('Callback in foreignKey is not allowed in migration');
     }
 
     return {
       column: item,
       type: item.toSQL(),
-      nullable: item.isNullable,
+      nullable: item.data.isNullable,
       primaryKey: item.isPrimaryKey,
       ...item.data,
-      foreignKey,
+      foreignKeys: foreignKeys as RakeDbAst.ColumnChange['foreignKeys'],
     };
   }
 
@@ -257,9 +257,12 @@ const makeAst = (
     }
   }
 
+  const [schema, table] = getSchemaAndTableFromName(name);
+
   return {
     type: 'changeTable',
-    name,
+    schema,
+    name: table,
     comment: comment
       ? up
         ? Array.isArray(comment)
@@ -287,7 +290,7 @@ const astToQueries = (ast: RakeDbAst.ChangeTable): Sql[] => {
 
   if (ast.comment !== undefined) {
     result.push({
-      text: `COMMENT ON TABLE ${quoteTable(ast.name)} IS ${quote(ast.comment)}`,
+      text: `COMMENT ON TABLE ${quoteWithSchema(ast)} IS ${quote(ast.comment)}`,
       values: [],
     });
   }
@@ -392,83 +395,96 @@ const astToQueries = (ast: RakeDbAst.ChangeTable): Sql[] => {
         );
       }
 
-      const fromFkey = from.foreignKey;
-      const toFkey = to.foreignKey;
-      if (
-        (fromFkey || toFkey) &&
-        (!fromFkey ||
-          !toFkey ||
-          fromFkey.name !== toFkey.name ||
-          fromFkey.match !== toFkey.match ||
-          fromFkey.onUpdate !== toFkey.onUpdate ||
-          fromFkey.onDelete !== toFkey.onDelete ||
-          fromFkey.dropMode !== toFkey.dropMode ||
-          fromFkey.table !== toFkey.table ||
-          fromFkey.columns.join(',') !== toFkey.columns.join(','))
-      ) {
-        if (fromFkey) {
-          dropForeignKeys.push({
-            columns: [key],
-            fnOrTable: fromFkey.table,
-            foreignColumns: fromFkey.columns,
-            options: fromFkey,
-          });
-        }
-
-        if (toFkey) {
-          addForeignKeys.push({
-            columns: [key],
-            fnOrTable: toFkey.table,
-            foreignColumns: toFkey.columns,
-            options: toFkey,
-          });
+      const foreignKeysLen = Math.max(
+        from.foreignKeys?.length || 0,
+        to.foreignKeys?.length || 0,
+      );
+      for (let i = 0; i < foreignKeysLen; i++) {
+        const fromFkey = from.foreignKeys?.[i];
+        const toFkey = to.foreignKeys?.[i];
+
+        if (
+          (fromFkey || toFkey) &&
+          (!fromFkey ||
+            !toFkey ||
+            fromFkey.name !== toFkey.name ||
+            fromFkey.match !== toFkey.match ||
+            fromFkey.onUpdate !== toFkey.onUpdate ||
+            fromFkey.onDelete !== toFkey.onDelete ||
+            fromFkey.dropMode !== toFkey.dropMode ||
+            fromFkey.table !== toFkey.table ||
+            fromFkey.columns.join(',') !== toFkey.columns.join(','))
+        ) {
+          if (fromFkey) {
+            dropForeignKeys.push({
+              columns: [key],
+              fnOrTable: fromFkey.table,
+              foreignColumns: fromFkey.columns,
+              options: fromFkey,
+            });
+          }
+
+          if (toFkey) {
+            addForeignKeys.push({
+              columns: [key],
+              fnOrTable: toFkey.table,
+              foreignColumns: toFkey.columns,
+              options: toFkey,
+            });
+          }
         }
       }
 
-      const fromIndex = from.index;
-      const toIndex = to.index;
-      if (
-        (fromIndex || toIndex) &&
-        (!fromIndex ||
-          !toIndex ||
-          fromIndex.expression !== toIndex.expression ||
-          fromIndex.collate !== toIndex.collate ||
-          fromIndex.operator !== toIndex.operator ||
-          fromIndex.order !== toIndex.order ||
-          fromIndex.name !== toIndex.name ||
-          fromIndex.unique !== toIndex.unique ||
-          fromIndex.using !== toIndex.using ||
-          fromIndex.include !== toIndex.include ||
-          (Array.isArray(fromIndex.include) &&
-            Array.isArray(toIndex.include) &&
-            fromIndex.include.join(',') !== toIndex.include.join(',')) ||
-          fromIndex.with !== toIndex.with ||
-          fromIndex.tablespace !== toIndex.tablespace ||
-          fromIndex.where !== toIndex.where ||
-          fromIndex.dropMode !== toIndex.dropMode)
-      ) {
-        if (fromIndex) {
-          dropIndexes.push({
-            columns: [
-              {
-                column: key,
-                ...fromIndex,
-              },
-            ],
-            options: fromIndex,
-          });
-        }
-
-        if (toIndex) {
-          addIndexes.push({
-            columns: [
-              {
-                column: key,
-                ...toIndex,
-              },
-            ],
-            options: toIndex,
-          });
+      const indexesLen = Math.max(
+        from.indexes?.length || 0,
+        to.indexes?.length || 0,
+      );
+      for (let i = 0; i < indexesLen; i++) {
+        const fromIndex = from.indexes?.[i];
+        const toIndex = to.indexes?.[i];
+
+        if (
+          (fromIndex || toIndex) &&
+          (!fromIndex ||
+            !toIndex ||
+            fromIndex.collate !== toIndex.collate ||
+            fromIndex.opclass !== toIndex.opclass ||
+            fromIndex.order !== toIndex.order ||
+            fromIndex.name !== toIndex.name ||
+            fromIndex.unique !== toIndex.unique ||
+            fromIndex.using !== toIndex.using ||
+            fromIndex.include !== toIndex.include ||
+            (Array.isArray(fromIndex.include) &&
+              Array.isArray(toIndex.include) &&
+              fromIndex.include.join(',') !== toIndex.include.join(',')) ||
+            fromIndex.with !== toIndex.with ||
+            fromIndex.tablespace !== toIndex.tablespace ||
+            fromIndex.where !== toIndex.where ||
+            fromIndex.dropMode !== toIndex.dropMode)
+        ) {
+          if (fromIndex) {
+            dropIndexes.push({
+              columns: [
+                {
+                  column: key,
+                  ...fromIndex,
+                },
+              ],
+              options: fromIndex,
+            });
+          }
+
+          if (toIndex) {
+            addIndexes.push({
+              columns: [
+                {
+                  column: key,
+                  ...toIndex,
+                },
+              ],
+              options: toIndex,
+            });
+          }
         }
       }
 
@@ -493,7 +509,7 @@ const astToQueries = (ast: RakeDbAst.ChangeTable): Sql[] => {
 
   prependAlterTable.push(
     ...dropForeignKeys.map(
-      (foreignKey) => `\n DROP ${constraintToSql(ast.name, false, foreignKey)}`,
+      (foreignKey) => `\n DROP ${constraintToSql(ast, false, foreignKey)}`,
     ),
   );
 
@@ -509,22 +525,22 @@ const astToQueries = (ast: RakeDbAst.ChangeTable): Sql[] => {
 
   alterTable.push(
     ...addForeignKeys.map(
-      (foreignKey) => `\n ADD ${constraintToSql(ast.name, true, foreignKey)}`,
+      (foreignKey) => `\n ADD ${constraintToSql(ast, true, foreignKey)}`,
     ),
   );
 
   if (alterTable.length) {
     result.push({
       text:
-        `ALTER TABLE ${quoteTable(ast.name)}` +
+        `ALTER TABLE ${quoteWithSchema(ast)}` +
         `\n  ${alterTable.join(',\n  ')}`,
       values,
     });
   }
 
-  result.push(...indexesToQuery(false, ast.name, dropIndexes));
-  result.push(...indexesToQuery(true, ast.name, addIndexes));
-  result.push(...commentsToQuery(ast.name, comments));
+  result.push(...indexesToQuery(false, ast, dropIndexes));
+  result.push(...indexesToQuery(true, ast, addIndexes));
+  result.push(...commentsToQuery(ast, comments));
 
   return result;
 };

package/src/migration/createJoinTable.test.ts

@@ -0,0 +1,96 @@
+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,6 +1,10 @@
 import { ColumnType, Operators } from 'pqb';
 import { ColumnsShapeCallback, JoinTableOptions, Migration } from './migration';
-import { joinWords, quoteTable } from '../common';
+import {
+  getSchemaAndTableFromName,
+  joinWords,
+  quoteWithSchema,
+} from '../common';
 import { getPrimaryKeysOfTable } from './migrationUtils';
 import { singular } from 'pluralize';
 import { createTable } from './createTable';
@@ -46,26 +50,33 @@ export const createJoinTable = async (
           })),
       );
 
+      const [schema, name] = getSchemaAndTableFromName(table);
       if (!primaryKeys.length) {
         throw new Error(
-          `Primary key for table ${quoteTable(table)} is not defined`,
+          `Primary key for table ${quoteWithSchema({
+            schema,
+            name,
+          })} is not defined`,
         );
       }
 
-      return [table, primaryKeys] as const;
+      return [schema, table, primaryKeys] as const;
     }),
   );
 
   return createTable(migration, up, tableName, options, (t) => {
     const result: Record<string, ColumnType> = {};
 
-    tablesWithPrimaryKeys.forEach(([table, primaryKeys]) => {
+    tablesWithPrimaryKeys.forEach(([schema, table, primaryKeys]) => {
       if (primaryKeys.length === 1) {
         const [{ type, joinedName, name }] = primaryKeys;
 
         const column = new UnknownColumn(type);
 
-        result[joinedName] = column.foreignKey(table, name);
+        result[joinedName] = column.foreignKey(
+          schema ? `${schema}.${table}` : table,
+          name,
+        );
 
         return;
       }
@@ -86,7 +97,7 @@ export const createJoinTable = async (
     }
 
     t.primaryKey(
-      tablesWithPrimaryKeys.flatMap(([, primaryKeys]) =>
+      tablesWithPrimaryKeys.flatMap(([, , primaryKeys]) =>
         primaryKeys.map((item) => item.joinedName),
       ),
     );