rake-db 2.1.0 → 2.1.2

package/src/migration/changeTable.test.ts

@@ -356,6 +356,7 @@ describe('changeTable', () => {
         changeDefault: t.change(t.default('from'), t.default(t.raw("'to'"))),
         changeNull: t.change(t.nonNullable(), t.nullable()),
         changeComment: t.change(t.comment('comment 1'), t.comment('comment 2')),
+        changeCompression: t.change(t.text(), t.text().compression('value')),
       }));
     };
 
@@ -367,7 +368,8 @@ describe('changeTable', () => {
         ALTER COLUMN "changeTypeUsing" TYPE text USING b::text,
         ALTER COLUMN "changeCollate" TYPE text COLLATE 'fr_FR',
         ALTER COLUMN "changeDefault" SET DEFAULT 'to',
-        ALTER COLUMN "changeNull" DROP NOT NULL
+        ALTER COLUMN "changeNull" DROP NOT NULL,
+        ALTER COLUMN "changeCompression" SET COMPRESSION value
       `,
       `COMMENT ON COLUMN "table"."changeComment" IS 'comment 2'`,
     ]);
@@ -382,12 +384,177 @@ describe('changeTable', () => {
         ALTER COLUMN "changeTypeUsing" TYPE integer USING b::int,
         ALTER COLUMN "changeCollate" TYPE text COLLATE 'de_DE',
         ALTER COLUMN "changeDefault" SET DEFAULT 'from',
-        ALTER COLUMN "changeNull" SET NOT NULL
+        ALTER COLUMN "changeNull" SET NOT NULL,
+        ALTER COLUMN "changeCompression" SET COMPRESSION DEFAULT
       `,
       `COMMENT ON COLUMN "table"."changeComment" IS 'comment 1'`,
     ]);
   });
 
+  it('should change column foreign key', async () => {
+    const fn = () => {
+      return db.changeTable('table', (t) => ({
+        addFkey: t.change(
+          t.integer(),
+          t.integer().foreignKey('otherTable', 'foreignId'),
+        ),
+        addFkeyWithOptions: t.change(
+          t.integer(),
+          t.integer().foreignKey('otherTable', 'foreignId', {
+            name: 'foreignKeyName',
+            match: 'FULL',
+            onUpdate: 'SET NULL',
+            onDelete: 'CASCADE',
+          }),
+        ),
+        removeFkey: t.change(
+          t.integer().foreignKey('otherTable', 'foreignId'),
+          t.integer(),
+        ),
+        removeFkeyWithOptions: t.change(
+          t.integer().foreignKey('otherTable', 'foreignId', {
+            name: 'foreignKeyName',
+            match: 'FULL',
+            onUpdate: 'SET NULL',
+            onDelete: 'CASCADE',
+          }),
+          t.integer(),
+        ),
+        changeForeignKey: t.change(
+          t.integer().foreignKey('a', 'aId', {
+            name: 'fromFkeyName',
+            match: 'PARTIAL',
+            onUpdate: 'RESTRICT',
+            onDelete: 'SET DEFAULT',
+          }),
+          t.integer().foreignKey('b', 'bId', {
+            name: 'toFkeyName',
+            match: 'FULL',
+            onUpdate: 'NO ACTION',
+            onDelete: 'CASCADE',
+          }),
+        ),
+      }));
+    };
+
+    await fn();
+    expectSql(`
+      ALTER TABLE "table"
+      DROP CONSTRAINT "table_removeFkey_fkey",
+      DROP CONSTRAINT "foreignKeyName",
+      DROP CONSTRAINT "fromFkeyName",
+      ADD CONSTRAINT "table_addFkey_fkey" FOREIGN KEY ("addFkey") REFERENCES "otherTable"("foreignId"),
+      ADD CONSTRAINT "foreignKeyName" FOREIGN KEY ("addFkeyWithOptions") REFERENCES "otherTable"("foreignId") MATCH FULL ON DELETE CASCADE ON UPDATE SET NULL,
+      ADD CONSTRAINT "toFkeyName" FOREIGN KEY ("changeForeignKey") REFERENCES "b"("bId") MATCH FULL ON DELETE CASCADE ON UPDATE NO ACTION
+    `);
+
+    queryMock.mockClear();
+    db.up = false;
+    await fn();
+    expectSql(`
+      ALTER TABLE "table"
+      DROP CONSTRAINT "table_addFkey_fkey",
+      DROP CONSTRAINT "foreignKeyName",
+      DROP CONSTRAINT "toFkeyName",
+      ADD CONSTRAINT "table_removeFkey_fkey" FOREIGN KEY ("removeFkey") REFERENCES "otherTable"("foreignId"),
+      ADD CONSTRAINT "foreignKeyName" FOREIGN KEY ("removeFkeyWithOptions") REFERENCES "otherTable"("foreignId") MATCH FULL ON DELETE CASCADE ON UPDATE SET NULL,
+      ADD CONSTRAINT "fromFkeyName" FOREIGN KEY ("changeForeignKey") REFERENCES "a"("aId") MATCH PARTIAL ON DELETE SET DEFAULT ON UPDATE RESTRICT
+    `);
+  });
+
+  it('should change index', async () => {
+    const fn = () => {
+      return db.changeTable('table', (t) => ({
+        addIndex: t.change(t.integer(), t.integer().index()),
+        addIndexWithOptions: t.change(
+          t.integer(),
+          t.integer().index({
+            expression: 'expression',
+            collate: 'collate',
+            operator: 'operator',
+            order: 'order',
+            unique: true,
+            using: 'using',
+            include: ['a', 'b'],
+            with: 'with',
+            tablespace: 'tablespace',
+            where: 'where',
+            dropMode: 'CASCADE',
+          }),
+        ),
+        removeIndex: t.change(t.integer().index(), t.integer()),
+        removeIndexWithOptions: t.change(
+          t.integer().index({
+            expression: 'expression',
+            collate: 'collate',
+            operator: 'operator',
+            order: 'order',
+            unique: true,
+            using: 'using',
+            include: ['a', 'b'],
+            with: 'with',
+            tablespace: 'tablespace',
+            where: 'where',
+            dropMode: 'CASCADE',
+          }),
+          t.integer(),
+        ),
+        changeIndex: t.change(
+          t.integer().index({
+            name: 'from',
+            expression: 'from',
+            collate: 'from',
+            operator: 'from',
+            order: 'from',
+            unique: false,
+            using: 'from',
+            include: ['a', 'b'],
+            with: 'from',
+            tablespace: 'from',
+            where: 'from',
+            dropMode: 'CASCADE',
+          }),
+          t.integer().index({
+            name: 'to',
+            expression: 'to',
+            collate: 'to',
+            operator: 'to',
+            order: 'to',
+            unique: true,
+            using: 'to',
+            include: ['c', 'd'],
+            with: 'to',
+            tablespace: 'to',
+            where: 'to',
+            dropMode: 'RESTRICT',
+          }),
+        ),
+      }));
+    };
+
+    await fn();
+    expectSql([
+      `DROP INDEX "tableRemoveIndexIndex"`,
+      `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`,
+    ]);
+
+    queryMock.mockClear();
+    db.up = false;
+    await fn();
+    expectSql([
+      `DROP INDEX "tableAddIndexIndex"`,
+      `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`,
+    ]);
+  });
+
   it('should rename a column', async () => {
     const fn = () => {
       return db.changeTable('table', (t) => ({

package/src/migration/changeTable.ts

@@ -12,6 +12,9 @@ import {
   getRaw,
   isRaw,
   raw,
+  ForeignKey,
+  newTableData,
+  SingleColumnIndexOptions,
 } from 'pqb';
 import {
   ChangeTableCallback,
@@ -98,7 +101,10 @@ type ChangeArg =
   | ColumnType
   | ['default', unknown | RawExpression]
   | ['nullable', boolean]
-  | ['comment', string | null];
+  | ['comment', string | null]
+  | ['compression', string]
+  | ['foreignKey', ForeignKey<string, string[]>]
+  | ['index', Omit<SingleColumnIndexOptions, 'column'>];
 
 type TableChangeMethods = typeof tableChangeMethods;
 const tableChangeMethods = {
@@ -201,12 +207,12 @@ export const changeTable = async (
     }
   }
 
-  changeTableData.add.forEach((tableData) => {
-    handleTableData(state, up, tableName, tableData);
+  changeTableData[up ? 'drop' : 'add'].forEach((tableData) => {
+    handleTableData(state, false, tableName, tableData);
   });
 
-  changeTableData.drop.forEach((tableData) => {
-    handleTableData(state, !up, tableName, tableData);
+  changeTableData[up ? 'add' : 'drop'].forEach((tableData) => {
+    handleTableData(state, true, tableName, tableData);
   });
 
   if (state.alterTable.length) {
@@ -216,10 +222,8 @@ export const changeTable = async (
     );
   }
 
-  const createIndexes = up ? state.indexes : state.dropIndexes;
-  const dropIndexes = up ? state.dropIndexes : state.indexes;
-  await migrateIndexes(state, createIndexes, up);
-  await migrateIndexes(state, dropIndexes, !up);
+  await migrateIndexes(state, state.dropIndexes, false);
+  await migrateIndexes(state, state.indexes, true);
   await migrateComments(state, state.comments);
 };
 
@@ -309,6 +313,79 @@ const changeActions = {
       );
     }
 
+    if (from.compression !== to.compression) {
+      state.alterTable.push(
+        `ALTER COLUMN "${key}" SET COMPRESSION ${to.compression || 'DEFAULT'}`,
+      );
+    }
+
+    const fromFkey = from.foreignKey;
+    const toFkey = to.foreignKey;
+    if (fromFkey || toFkey) {
+      if ((fromFkey && 'fn' in fromFkey) || (toFkey && 'fn' in toFkey)) {
+        throw new Error('Callback in foreignKey is not allowed in migration');
+      }
+
+      if (checkIfForeignKeysAreDifferent(fromFkey, toFkey)) {
+        if (fromFkey) {
+          const data = newTableData();
+          data.foreignKeys.push({
+            columns: [key],
+            fnOrTable: fromFkey.table,
+            foreignColumns: fromFkey.columns,
+            options: fromFkey,
+          });
+          changeTableData[up ? 'drop' : 'add'].push(data);
+        }
+
+        if (toFkey) {
+          const data = newTableData();
+          data.foreignKeys.push({
+            columns: [key],
+            fnOrTable: toFkey.table,
+            foreignColumns: toFkey.columns,
+            options: toFkey,
+          });
+          changeTableData[up ? 'add' : 'drop'].push(data);
+        }
+      }
+    }
+
+    const fromIndex = from.index;
+    const toIndex = to.index;
+    if (
+      (fromIndex || toIndex) &&
+      checkIfIndexesAreDifferent(fromIndex, toIndex)
+    ) {
+      if (fromIndex) {
+        const data = newTableData();
+        data.indexes.push({
+          columns: [
+            {
+              column: key,
+              ...fromIndex,
+            },
+          ],
+          options: fromIndex,
+        });
+        changeTableData[up ? 'drop' : 'add'].push(data);
+      }
+
+      if (toIndex) {
+        const data = newTableData();
+        data.indexes.push({
+          columns: [
+            {
+              column: key,
+              ...toIndex,
+            },
+          ],
+          options: toIndex,
+        });
+        changeTableData[up ? 'add' : 'drop'].push(data);
+      }
+    }
+
     if (from.comment !== to.comment) {
       state.comments.push({ column: key, comment: to.comment || null });
     }
@@ -320,15 +397,60 @@ const changeActions = {
   },
 };
 
-const getChangeProperties = (
-  item: ChangeArg,
-): {
+const checkIfForeignKeysAreDifferent = (
+  from?: ForeignKey<string, string[]> & { table: string },
+  to?: ForeignKey<string, string[]> & { table: string },
+) => {
+  return (
+    !from ||
+    !to ||
+    from.name !== to.name ||
+    from.match !== to.match ||
+    from.onUpdate !== to.onUpdate ||
+    from.onDelete !== to.onDelete ||
+    from.dropMode !== to.dropMode ||
+    from.table !== to.table ||
+    from.columns.join(',') !== to.columns.join(',')
+  );
+};
+
+const checkIfIndexesAreDifferent = (
+  from?: Omit<SingleColumnIndexOptions, 'column'>,
+  to?: Omit<SingleColumnIndexOptions, 'column'>,
+) => {
+  return (
+    !from ||
+    !to ||
+    from.expression !== to.expression ||
+    from.collate !== to.collate ||
+    from.operator !== to.operator ||
+    from.order !== to.order ||
+    from.name !== to.name ||
+    from.unique !== to.unique ||
+    from.using !== to.using ||
+    from.include !== to.include ||
+    (Array.isArray(from.include) &&
+      Array.isArray(to.include) &&
+      from.include.join(',') !== to.include.join(',')) ||
+    from.with !== to.with ||
+    from.tablespace !== to.tablespace ||
+    from.where !== to.where ||
+    from.dropMode !== to.dropMode
+  );
+};
+
+type ChangeProperties = {
   type?: string;
   collate?: string;
   default?: unknown | RawExpression;
   nullable?: boolean;
   comment?: string | null;
-} => {
+  compression?: string;
+  foreignKey?: ForeignKey<string, string[]>;
+  index?: Omit<SingleColumnIndexOptions, 'column'>;
+};
+
+const getChangeProperties = (item: ChangeArg): ChangeProperties => {
   if (item instanceof ColumnType) {
     return {
       type: item.toSQL(),
@@ -336,6 +458,9 @@ const getChangeProperties = (
       default: item.data.default,
       nullable: item.isNullable,
       comment: item.data.comment,
+      compression: item.data.compression,
+      foreignKey: item.data.foreignKey,
+      index: item.data.index,
     };
   } else {
     return {
@@ -344,6 +469,9 @@ const getChangeProperties = (
       default: item[0] === 'default' ? item[1] : undefined,
       nullable: item[0] === 'nullable' ? item[1] : undefined,
       comment: item[0] === 'comment' ? item[1] : undefined,
+      compression: item[0] === 'compression' ? item[1] : undefined,
+      foreignKey: item[0] === 'foreignKey' ? item[1] : undefined,
+      index: item[0] === 'index' ? item[1] : undefined,
     };
   }
 };

package/src/migration/migration.test.ts

@@ -283,7 +283,7 @@ describe('migration', () => {
               "createdAt" timestamp NOT NULL DEFAULT now(),
               "updatedAt" timestamp NOT NULL DEFAULT now(),
               PRIMARY KEY ("postUuid", "commentId", "commentAuthorName"),
-              CONSTRAINT "postsCommentsToComments" FOREIGN KEY ("commentId", "commentAuthorName") REFERENCES "comments"("id", "authorName")
+              CONSTRAINT "postsComments_commentId_commentAuthorName_fkey" FOREIGN KEY ("commentId", "commentAuthorName") REFERENCES "comments"("id", "authorName")
             )
           `);
         };

package/src/migration/migrationUtils.ts

@@ -101,15 +101,16 @@ export const constraintToSql = (
   up: boolean,
   foreignKey: TableData['foreignKeys'][number],
 ) => {
-  const table = getForeignKeyTable(foreignKey.fnOrTable);
   const constraintName =
-    foreignKey.options.name || joinWords(tableName, 'to', table);
+    foreignKey.options.name ||
+    `${tableName}_${foreignKey.columns.join('_')}_fkey`;
 
   if (!up) {
     const { dropMode } = foreignKey.options;
     return `CONSTRAINT "${constraintName}"${dropMode ? ` ${dropMode}` : ''}`;
   }
 
+  const table = getForeignKeyTable(foreignKey.fnOrTable);
   return `CONSTRAINT "${constraintName}" FOREIGN KEY (${joinColumns(
     foreignKey.columns,
   )}) ${referencesToSql(table, foreignKey.foreignColumns, foreignKey.options)}`;