rake-db 2.2.6 → 2.3.0

package/src/migration/changeTable.test.ts

@@ -78,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',
@@ -133,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
@@ -604,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',
@@ -620,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',
@@ -637,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',
@@ -651,9 +647,8 @@ describe('changeTable', () => {
           }),
           t.integer().index({
             name: 'to',
-            expression: 'to',
             collate: 'to',
-            operator: 'to',
+            opclass: 'to',
             order: 'to',
             unique: true,
             using: 'to',
@@ -673,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();
@@ -685,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

@@ -127,8 +127,8 @@ 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');
     }
 
@@ -138,7 +138,7 @@ const columnTypeToColumnChange = (
       nullable: item.data.isNullable,
       primaryKey: item.isPrimaryKey,
       ...item.data,
-      foreignKey,
+      foreignKeys: foreignKeys as RakeDbAst.ColumnChange['foreignKeys'],
     };
   }
 
@@ -395,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,
+            });
+          }
         }
       }
 

package/src/migration/createTable.test.ts

@@ -63,9 +63,8 @@ const db = getDb();
             name: 'indexName',
             unique: true,
             using: 'gin',
-            expression: 10,
             collate: 'utf-8',
-            operator: 'operator',
+            opclass: 'opclass',
             order: 'ASC',
             include: 'id',
             with: 'fillfactor = 70',
@@ -113,7 +112,7 @@ const db = getDb();
             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

package/src/migration/migrationUtils.ts

@@ -51,17 +51,19 @@ export const columnToSql = (
     }
   }
 
-  const { foreignKey } = item.data;
-  if (foreignKey) {
-    const [schema, table] = getForeignKeyTable(
-      'fn' in foreignKey ? foreignKey.fn : foreignKey.table,
-    );
+  const { foreignKeys } = item.data;
+  if (foreignKeys) {
+    for (const foreignKey of foreignKeys) {
+      const [schema, table] = getForeignKeyTable(
+        'fn' in foreignKey ? foreignKey.fn : foreignKey.table,
+      );
 
-    if (foreignKey.name) {
-      line.push(`CONSTRAINT "${foreignKey.name}"`);
-    }
+      if (foreignKey.name) {
+        line.push(`CONSTRAINT "${foreignKey.name}"`);
+      }
 
-    line.push(referencesToSql(schema, table, foreignKey.columns, foreignKey));
+      line.push(referencesToSql(schema, table, foreignKey.columns, foreignKey));
+    }
   }
 
   return line.join(' ');
@@ -72,13 +74,13 @@ export const addColumnIndex = (
   key: string,
   item: ColumnType,
 ) => {
-  if (item.data) {
-    if (item.data.index) {
-      indexes.push({
-        columns: [{ ...item.data.index, column: key }],
-        options: item.data.index,
-      });
-    }
+  if (item.data.indexes) {
+    indexes.push(
+      ...item.data.indexes.map((index) => ({
+        columns: [{ ...index, column: key }],
+        options: index,
+      })),
+    );
   }
 };
 
@@ -162,7 +164,13 @@ export const indexesToQuery = (
   return indexes.map(({ columns, options }) => {
     const indexName =
       options.name ||
-      joinWords(name, ...columns.map(({ column }) => column), 'index');
+      joinWords(
+        name,
+        ...columns
+          .filter((it): it is { column: string } => 'column' in it)
+          .map((it) => it.column),
+        'index',
+      );
 
     if (!up) {
       return {
@@ -191,17 +199,15 @@ export const indexesToQuery = (
 
     columns.forEach((column) => {
       const columnSql: string[] = [
-        `"${column.column}"${
-          column.expression ? `(${column.expression})` : ''
-        }`,
+        'column' in column ? `"${column.column}"` : `(${column.expression})`,
       ];
 
       if (column.collate) {
         columnSql.push(`COLLATE '${column.collate}'`);
       }
 
-      if (column.operator) {
-        columnSql.push(column.operator);
+      if (column.opclass) {
+        columnSql.push(column.opclass);
       }
 
       if (column.order) {

package/src/pull/dbStructure.test.ts

@@ -20,7 +20,7 @@ describe('dbStructure', () => {
 
   describe('getTables', () => {
     it('should return tables', async () => {
-      rows = [{ schemaName: 'schema', name: 'table' }];
+      rows = [{ schemaName: 'schema', name: 'table', comment: 'comment' }];
       const result = await db.getTables();
       expect(result).toEqual(rows);
     });
@@ -65,6 +65,9 @@ describe('dbStructure', () => {
           type: 'int4',
           default: '123',
           isNullable: false,
+          collation: 'en_US',
+          compression: 'p',
+          comment: 'column comment',
         },
       ];
       const result = await db.getColumns();
@@ -78,10 +81,13 @@ describe('dbStructure', () => {
         {
           schemaName: 'public',
           tableName: 'table',
-          columnNames: ['column'],
           name: 'indexName',
           isUnique: true,
-          isPrimary: true,
+          columns: [{ column: 'column' }],
+          include: null,
+          with: null,
+          tablespace: null,
+          where: null,
         },
       ];
       const result = await db.getIndexes();
@@ -100,6 +106,9 @@ describe('dbStructure', () => {
           name: 'name',
           columnNames: ['column'],
           foreignColumnNames: ['foreignColumn'],
+          match: 's',
+          onUpdate: 'a',
+          onDelete: 'a',
         },
       ];
       const result = await db.getForeignKeys();
@@ -107,18 +116,17 @@ describe('dbStructure', () => {
     });
   });
 
-  describe('getConstraints', () => {
+  describe('getPrimaryKeys', () => {
     it('should return constraints', async () => {
       rows = [
         {
           schemaName: 'public',
           tableName: 'table',
           name: 'name',
-          type: 'PRIMARY KEY',
           columnNames: ['id'],
         },
       ];
-      const result = await db.getConstraints();
+      const result = await db.getPrimaryKeys();
       expect(result).toEqual(rows);
     });
   });