rake-db 2.2.4 → 2.2.6

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,
@@ -48,6 +48,7 @@ describe('common', () => {
         requireTs: expect.any(Function),
         log: true,
         logger: console,
+        useCodeUpdater: true,
       });
     });
   });
@@ -284,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

@@ -30,7 +30,7 @@ export const migrationConfigDefaults = {
   requireTs: require,
   log: true,
   logger: console,
-  useCodeUpdaterByDefault: true,
+  useCodeUpdater: true,
 };
 
 export const getMigrationConfigWithDefaults = (
@@ -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' });

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,
@@ -135,7 +135,7 @@ const columnTypeToColumnChange = (
     return {
       column: item,
       type: item.toSQL(),
-      nullable: item.isNullable,
+      nullable: item.data.isNullable,
       primaryKey: item.isPrimaryKey,
       ...item.data,
       foreignKey,
@@ -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: [],
     });
   }
@@ -493,7 +496,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 +512,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),
       ),
     );

package/src/migration/createTable.test.ts

@@ -14,6 +14,22 @@ const db = getDb();
       expect(db.options.appCodeUpdater).toHaveBeenCalled();
     });
 
+    it(`should ${action} with schema`, async () => {
+      await db[action]('schema.name', (t) => ({ id: t.serial().primaryKey() }));
+
+      if (action === 'createTable') {
+        expectSql(`
+          CREATE TABLE "schema"."name" (
+            "id" serial PRIMARY KEY
+          )
+        `);
+      } else {
+        expectSql(`
+          DROP TABLE "schema"."name"
+        `);
+      }
+    });
+
     it(`should ${action} with comment`, async () => {
       await db[action]('name', { comment: 'this is a table comment' }, (t) => ({
         id: t.serial().primaryKey(),

package/src/migration/createTable.ts

@@ -25,7 +25,7 @@ import {
   indexesToQuery,
   primaryKeyToSql,
 } from './migrationUtils';
-import { quoteTable } from '../common';
+import { getSchemaAndTableFromName, quoteWithSchema } from '../common';
 import { RakeDbAst } from '../ast';
 
 const types = Object.assign(Object.create(columnTypes), {
@@ -77,10 +77,13 @@ const makeAst = (
 
   const primaryKey = tableData.primaryKey;
 
+  const [schema, table] = getSchemaAndTableFromName(tableName);
+
   return {
     type: 'table',
     action: up ? 'create' : 'drop',
-    name: tableName,
+    schema,
+    name: table,
     shape,
     ...tableData,
     primaryKey:
@@ -121,7 +124,7 @@ const astToQueries = (ast: RakeDbAst.Table): Sql[] => {
   if (ast.action === 'drop') {
     return [
       {
-        text: `DROP TABLE ${quoteTable(ast.name)}${
+        text: `DROP TABLE ${quoteWithSchema(ast)}${
           ast.dropMode ? ` ${ast.dropMode}` : ''
         }`,
         values: [],
@@ -146,23 +149,23 @@ const astToQueries = (ast: RakeDbAst.Table): Sql[] => {
   }
 
   ast.foreignKeys.forEach((foreignKey) => {
-    lines.push(`\n  ${constraintToSql(ast.name, true, foreignKey)}`);
+    lines.push(`\n  ${constraintToSql(ast, true, foreignKey)}`);
   });
 
   indexes.push(...ast.indexes);
 
   const result: Sql[] = [
     {
-      text: `CREATE TABLE ${quoteTable(ast.name)} (${lines.join(',')}\n)`,
+      text: `CREATE TABLE ${quoteWithSchema(ast)} (${lines.join(',')}\n)`,
       values,
     },
-    ...indexesToQuery(true, ast.name, indexes),
-    ...commentsToQuery(ast.name, comments),
+    ...indexesToQuery(true, ast, indexes),
+    ...commentsToQuery(ast, comments),
   ];
 
   if (ast.comment) {
     result.push({
-      text: `COMMENT ON TABLE ${quoteTable(ast.name)} IS ${quote(ast.comment)}`,
+      text: `COMMENT ON TABLE ${quoteWithSchema(ast)} IS ${quote(ast.comment)}`,
       values: [],
     });
   }

package/src/migration/migration.test.ts

@@ -1,5 +1,4 @@
 import { expectSql, getDb, queryMock, resetDb, toLine } from '../test-utils';
-import { getPrimaryKeysOfTable } from './migrationUtils';
 
 const db = getDb();
 
@@ -37,6 +36,24 @@ describe('migration', () => {
     });
   });
 
+  it('should rename table with schema', async () => {
+    const fn = () => {
+      return db.renameTable('one.from', 'two.to');
+    };
+
+    await fn();
+    expectSql(`
+        ALTER TABLE "one"."from" RENAME TO "two"."to"
+      `);
+
+    db.up = false;
+    queryMock.mockClear();
+    await fn();
+    expectSql(`
+        ALTER TABLE "two"."to" RENAME TO "one"."from"
+      `);
+  });
+
   (['addColumn', 'dropColumn'] as const).forEach((action) => {
     describe(action, () => {
       it(`should use changeTable to ${
@@ -249,91 +266,6 @@ describe('migration', () => {
     });
   });
 
-  (['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 () => {
-        if (action === 'dropJoinTable') {
-          db.up = false;
-        }
-
-        (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',
-        );
-      });
-    });
-  });
-
   (['createSchema', 'dropSchema'] as const).forEach((action) => {
     describe(action, () => {
       it('should call appCodeUpdater', async () => {

package/src/migration/migration.ts

@@ -21,7 +21,11 @@ import {
 } from 'pqb';
 import { createTable } from './createTable';
 import { changeTable, TableChangeData, TableChanger } from './changeTable';
-import { RakeDbConfig, quoteTable } from '../common';
+import {
+  RakeDbConfig,
+  quoteWithSchema,
+  getSchemaAndTableFromName,
+} from '../common';
 import { createJoinTable } from './createJoinTable';
 import { RakeDbAst } from '../ast';
 
@@ -179,14 +183,24 @@ export class Migration extends TransactionAdapter {
   }
 
   async renameTable(from: string, to: string): Promise<void> {
+    const [fromSchema, f] = getSchemaAndTableFromName(this.up ? from : to);
+    const [toSchema, t] = getSchemaAndTableFromName(this.up ? to : from);
     const ast: RakeDbAst.RenameTable = {
       type: 'renameTable',
-      from: this.up ? from : to,
-      to: this.up ? to : from,
+      fromSchema,
+      from: f,
+      toSchema,
+      to: t,
     };
 
     await this.query(
-      `ALTER TABLE ${quoteTable(ast.from)} RENAME TO "${ast.to}"`,
+      `ALTER TABLE ${quoteWithSchema({
+        schema: ast.fromSchema,
+        name: ast.from,
+      })} RENAME TO ${quoteWithSchema({
+        schema: ast.toSchema,
+        name: ast.to,
+      })}`,
     );
 
     await runCodeUpdater(this, ast);