rake-db 2.2.5 → 2.3.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # rake-db
 
+## 2.3.0
+
+### Minor Changes
+
+- Change index options: column or expression is required, operator renamed to opclass
+
+### Patch Changes
+
+- f1cd5db: Handle multiple indexes and foreignKeys of the column
+- Updated dependencies
+- Updated dependencies [f1cd5db]
+  - pqb@0.9.0
+
+## 2.2.6
+
+### Patch Changes
+
+- Change inner aspects of columns
+- Updated dependencies
+  - pqb@0.8.5
+
 ## 2.2.5
 
 ### Patch Changes

package/db.ts

@@ -29,5 +29,5 @@ rakeDb(options, {
     baseTableName: 'BaseTable',
     mainFilePath: 'app/db.ts',
   }),
-  useCodeUpdaterByDefault: false,
+  useCodeUpdater: false,
 });

package/dist/index.d.ts

@@ -113,6 +113,7 @@ declare namespace RakeDbAst {
     type Table = {
         type: 'table';
         action: 'create' | 'drop';
+        schema?: string;
         name: string;
         shape: ColumnsShape;
         noPrimaryKey: NoPrimaryKeyOption;
@@ -121,6 +122,7 @@ declare namespace RakeDbAst {
     } & TableData;
     type ChangeTable = {
         type: 'changeTable';
+        schema?: string;
         name: string;
         comment?: string | null;
         shape: Record<string, ChangeTableItem>;
@@ -154,15 +156,17 @@ declare namespace RakeDbAst {
         comment?: string | null;
         compression?: string;
         primaryKey?: boolean;
-        foreignKey?: {
+        foreignKeys?: ({
             table: string;
             columns: string[];
-        } & ForeignKeyOptions;
-        index?: Omit<SingleColumnIndexOptions, 'column'>;
+        } & ForeignKeyOptions)[];
+        indexes?: Omit<SingleColumnIndexOptions, 'column' | 'expression'>[];
     };
     type RenameTable = {
         type: 'renameTable';
+        fromSchema?: string;
         from: string;
+        toSchema?: string;
         to: string;
     };
     type Schema = {

package/dist/index.esm.js

@@ -95,9 +95,9 @@ const setAdminCredentialsToOptions = async (options) => {
 const createSchemaMigrations = async (db, config) => {
   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) {
@@ -173,13 +173,15 @@ const joinWords = (...words) => {
 const joinColumns = (columns) => {
   return columns.map((column) => `"${column}"`).join(", ");
 };
-const quoteTable = (table) => {
-  const index = table.indexOf(".");
-  if (index !== -1) {
-    return `"${table.slice(0, index)}"."${table.slice(index + 1)}"`;
-  } else {
-    return `"${table}"`;
-  }
+const quoteWithSchema = ({
+  schema,
+  name
+}) => {
+  return schema ? `"${schema}"."${name}"` : `"${name}"`;
+};
+const getSchemaAndTableFromName = (name) => {
+  const index = name.indexOf(".");
+  return index !== -1 ? [name.slice(0, index), name.slice(index + 1)] : [void 0, name];
 };
 
 let currentMigration;
@@ -230,7 +232,7 @@ const columnToSql = (key, item, values, hasMultiplePrimaryKeys) => {
   }
   if (item.isPrimaryKey && !hasMultiplePrimaryKeys) {
     line.push("PRIMARY KEY");
-  } else if (!item.isNullable) {
+  } else if (!item.data.isNullable) {
     line.push("NOT NULL");
   }
   if (item.data.default !== void 0) {
@@ -240,26 +242,28 @@ const columnToSql = (key, item, values, hasMultiplePrimaryKeys) => {
       line.push(`DEFAULT ${quote(item.data.default)}`);
     }
   }
-  const { foreignKey } = item.data;
-  if (foreignKey) {
-    const table = getForeignKeyTable(
-      "fn" in foreignKey ? foreignKey.fn : foreignKey.table
-    );
-    if (foreignKey.name) {
-      line.push(`CONSTRAINT "${foreignKey.name}"`);
+  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}"`);
+      }
+      line.push(referencesToSql(schema, table, foreignKey.columns, foreignKey));
     }
-    line.push(referencesToSql(table, foreignKey.columns, foreignKey));
   }
   return line.join(" ");
 };
 const addColumnIndex = (indexes, key, item) => {
-  if (item.data) {
-    if (item.data.index) {
-      indexes.push({
-        columns: [__spreadProps$4(__spreadValues$5({}, item.data.index), { column: key })],
-        options: item.data.index
-      });
-    }
+  if (item.data.indexes) {
+    indexes.push(
+      ...item.data.indexes.map((index) => ({
+        columns: [__spreadProps$4(__spreadValues$5({}, index), { column: key })],
+        options: index
+      }))
+    );
   }
 };
 const addColumnComment = (comments, key, item) => {
@@ -269,25 +273,32 @@ const addColumnComment = (comments, key, item) => {
 };
 const getForeignKeyTable = (fnOrTable) => {
   if (typeof fnOrTable === "string") {
-    return fnOrTable;
+    return getSchemaAndTableFromName(fnOrTable);
   }
-  const klass = fnOrTable();
-  return new klass().table;
+  const item = new (fnOrTable())();
+  return [item.schema, item.table];
 };
-const constraintToSql = (tableName, up, foreignKey) => {
-  const constraintName = foreignKey.options.name || `${tableName}_${foreignKey.columns.join("_")}_fkey`;
+const constraintToSql = ({ name }, up, foreignKey) => {
+  const constraintName = foreignKey.options.name || `${name}_${foreignKey.columns.join("_")}_fkey`;
   if (!up) {
     const { dropMode } = foreignKey.options;
     return `CONSTRAINT "${constraintName}"${dropMode ? ` ${dropMode}` : ""}`;
   }
-  const table = getForeignKeyTable(foreignKey.fnOrTable);
+  const [schema, table] = getForeignKeyTable(foreignKey.fnOrTable);
   return `CONSTRAINT "${constraintName}" FOREIGN KEY (${joinColumns(
     foreignKey.columns
-  )}) ${referencesToSql(table, foreignKey.foreignColumns, foreignKey.options)}`;
-};
-const referencesToSql = (table, columns, foreignKey) => {
+  )}) ${referencesToSql(
+    schema,
+    table,
+    foreignKey.foreignColumns,
+    foreignKey.options
+  )}`;
+};
+const referencesToSql = (schema, table, columns, foreignKey) => {
   const sql = [
-    `REFERENCES ${quoteTable(table)}(${joinColumns(columns)})`
+    `REFERENCES ${quoteWithSchema({ schema, name: table })}(${joinColumns(
+      columns
+    )})`
   ];
   if (foreignKey.match) {
     sql.push(`MATCH ${foreignKey.match.toUpperCase()}`);
@@ -300,9 +311,13 @@ const referencesToSql = (table, columns, foreignKey) => {
   }
   return sql.join(" ");
 };
-const indexesToQuery = (up, tableName, indexes) => {
+const indexesToQuery = (up, { schema, name }, indexes) => {
   return indexes.map(({ columns, options }) => {
-    const indexName = options.name || joinWords(tableName, ...columns.map(({ column }) => column), "index");
+    const indexName = options.name || joinWords(
+      name,
+      ...columns.filter((it) => "column" in it).map((it) => it.column),
+      "index"
+    );
     if (!up) {
       return {
         text: `DROP INDEX "${indexName}"${options.dropMode ? ` ${options.dropMode}` : ""}`,
@@ -314,20 +329,20 @@ const indexesToQuery = (up, tableName, indexes) => {
     if (options.unique) {
       sql.push("UNIQUE");
     }
-    sql.push(`INDEX "${indexName}" ON ${quoteTable(tableName)}`);
+    sql.push(`INDEX "${indexName}" ON ${quoteWithSchema({ schema, name })}`);
     if (options.using) {
       sql.push(`USING ${options.using}`);
     }
     const columnsSql = [];
     columns.forEach((column) => {
       const columnSql = [
-        `"${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) {
         columnSql.push(column.order);
@@ -354,11 +369,11 @@ const indexesToQuery = (up, tableName, indexes) => {
     return { text: sql.join(" "), values };
   });
 };
-const commentsToQuery = (tableName, comments) => {
+const commentsToQuery = (schemaTable, comments) => {
   return comments.map(({ column, comment }) => ({
-    text: `COMMENT ON COLUMN ${quoteTable(tableName)}."${column}" IS ${quote(
-      comment
-    )}`,
+    text: `COMMENT ON COLUMN ${quoteWithSchema(
+      schemaTable
+    )}."${column}" IS ${quote(comment)}`,
     values: []
   }));
 };
@@ -440,10 +455,12 @@ const makeAst$1 = (up, tableName, shape, tableData, options, noPrimaryKey) => {
     }
   }
   const primaryKey = tableData.primaryKey;
+  const [schema, table] = getSchemaAndTableFromName(tableName);
   return __spreadProps$3(__spreadValues$4(__spreadProps$3(__spreadValues$4({
     type: "table",
     action: up ? "create" : "drop",
-    name: tableName,
+    schema,
+    name: table,
     shape
   }, tableData), {
     primaryKey: shapePKeys.length <= 1 ? primaryKey : primaryKey ? __spreadProps$3(__spreadValues$4({}, primaryKey), { columns: [...shapePKeys, ...primaryKey.columns] }) : { columns: shapePKeys }
@@ -477,7 +494,7 @@ const astToQueries$1 = (ast) => {
   if (ast.action === "drop") {
     return [
       {
-        text: `DROP TABLE ${quoteTable(ast.name)}${ast.dropMode ? ` ${ast.dropMode}` : ""}`,
+        text: `DROP TABLE ${quoteWithSchema(ast)}${ast.dropMode ? ` ${ast.dropMode}` : ""}`,
         values: []
       }
     ];
@@ -499,21 +516,21 @@ const astToQueries$1 = (ast) => {
   }
   ast.foreignKeys.forEach((foreignKey) => {
     lines.push(`
-  ${constraintToSql(ast.name, true, foreignKey)}`);
+  ${constraintToSql(ast, true, foreignKey)}`);
   });
   indexes.push(...ast.indexes);
   const result = [
     {
-      text: `CREATE TABLE ${quoteTable(ast.name)} (${lines.join(",")}
+      text: `CREATE TABLE ${quoteWithSchema(ast)} (${lines.join(",")}
 )`,
       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: []
     });
   }
@@ -601,17 +618,17 @@ const drop = (item, options) => {
 };
 const columnTypeToColumnChange = (item) => {
   if (item instanceof ColumnType) {
-    const foreignKey = item.data.foreignKey;
-    if (foreignKey && "fn" in foreignKey) {
+    const foreignKeys = item.data.foreignKeys;
+    if (foreignKeys == null ? void 0 : foreignKeys.some((it) => "fn" in it)) {
       throw new Error("Callback in foreignKey is not allowed in migration");
     }
     return __spreadProps$2(__spreadValues$3({
       column: item,
       type: item.toSQL(),
-      nullable: item.isNullable,
+      nullable: item.data.isNullable,
       primaryKey: item.isPrimaryKey
     }, item.data), {
-      foreignKey
+      foreignKeys
     });
   }
   return item.to;
@@ -681,19 +698,21 @@ const makeAst = (up, name, changeData, changeTableData2, options) => {
       }
     }
   }
+  const [schema, table] = getSchemaAndTableFromName(name);
   return __spreadValues$3({
     type: "changeTable",
-    name,
+    schema,
+    name: table,
     comment: comment ? up ? Array.isArray(comment) ? comment[1] : comment : Array.isArray(comment) ? comment[0] : null : void 0,
     shape
   }, up ? changeTableData2 : { add: changeTableData2.drop, drop: changeTableData2.add });
 };
 const astToQueries = (ast) => {
-  var _a;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
   const result = [];
   if (ast.comment !== void 0) {
     result.push({
-      text: `COMMENT ON TABLE ${quoteTable(ast.name)} IS ${quote(ast.comment)}`,
+      text: `COMMENT ON TABLE ${quoteWithSchema(ast)} IS ${quote(ast.comment)}`,
       values: []
     });
   }
@@ -771,48 +790,60 @@ const astToQueries = (ast) => {
           `ALTER COLUMN "${key}" SET COMPRESSION ${to.compression || "DEFAULT"}`
         );
       }
-      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(
+        ((_a = from.foreignKeys) == null ? void 0 : _a.length) || 0,
+        ((_b = to.foreignKeys) == null ? void 0 : _b.length) || 0
+      );
+      for (let i = 0; i < foreignKeysLen; i++) {
+        const fromFkey = (_c = from.foreignKeys) == null ? void 0 : _c[i];
+        const toFkey = (_d = to.foreignKeys) == null ? void 0 : _d[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: [
-              __spreadValues$3({
-                column: key
-              }, fromIndex)
-            ],
-            options: fromIndex
-          });
-        }
-        if (toIndex) {
-          addIndexes.push({
-            columns: [
-              __spreadValues$3({
-                column: key
-              }, toIndex)
-            ],
-            options: toIndex
-          });
+      const indexesLen = Math.max(
+        ((_e = from.indexes) == null ? void 0 : _e.length) || 0,
+        ((_f = to.indexes) == null ? void 0 : _f.length) || 0
+      );
+      for (let i = 0; i < indexesLen; i++) {
+        const fromIndex = (_g = from.indexes) == null ? void 0 : _g[i];
+        const toIndex = (_h = to.indexes) == null ? void 0 : _h[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: [
+                __spreadValues$3({
+                  column: key
+                }, fromIndex)
+              ],
+              options: fromIndex
+            });
+          }
+          if (toIndex) {
+            addIndexes.push({
+              columns: [
+                __spreadValues$3({
+                  column: key
+                }, toIndex)
+              ],
+              options: toIndex
+            });
+          }
         }
       }
       if (from.comment !== to.comment) {
@@ -824,13 +855,13 @@ const astToQueries = (ast) => {
   }
   const prependAlterTable = [];
   if (ast.drop.primaryKey || dropPrimaryKeys.change || dropPrimaryKeys.columns.length > 1) {
-    const name = ((_a = dropPrimaryKeys.options) == null ? void 0 : _a.name) || `${ast.name}_pkey`;
+    const name = ((_i = dropPrimaryKeys.options) == null ? void 0 : _i.name) || `${ast.name}_pkey`;
     prependAlterTable.push(`DROP CONSTRAINT "${name}"`);
   }
   prependAlterTable.push(
     ...dropForeignKeys.map(
       (foreignKey) => `
- DROP ${constraintToSql(ast.name, false, foreignKey)}`
+ DROP ${constraintToSql(ast, false, foreignKey)}`
     )
   );
   alterTable.unshift(...prependAlterTable);
@@ -840,19 +871,19 @@ const astToQueries = (ast) => {
   alterTable.push(
     ...addForeignKeys.map(
       (foreignKey) => `
- ADD ${constraintToSql(ast.name, true, foreignKey)}`
+ ADD ${constraintToSql(ast, true, foreignKey)}`
     )
   );
   if (alterTable.length) {
     result.push({
-      text: `ALTER TABLE ${quoteTable(ast.name)}
+      text: `ALTER TABLE ${quoteWithSchema(ast)}
   ${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;
 };
 
@@ -903,21 +934,28 @@ const createJoinTable = async (migration, up, tables, options, fn) => {
           joinedName: joinWords(singular(table), item.name)
         }))
       );
+      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];
+      return [schema, table, primaryKeys];
     })
   );
   return createTable(migration, up, tableName, options, (t) => {
     const result = {};
-    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;
       }
       primaryKeys.forEach(({ joinedName, type }) => {
@@ -934,7 +972,7 @@ const createJoinTable = async (migration, up, tables, options, fn) => {
     }
     t.primaryKey(
       tablesWithPrimaryKeys.flatMap(
-        ([, primaryKeys]) => primaryKeys.map((item) => item.joinedName)
+        ([, , primaryKeys]) => primaryKeys.map((item) => item.joinedName)
       )
     );
     return result;
@@ -1000,13 +1038,23 @@ class Migration extends TransactionAdapter {
     return changeTable(this, this.up, tableName, options, fn);
   }
   async renameTable(from, to) {
+    const [fromSchema, f] = getSchemaAndTableFromName(this.up ? from : to);
+    const [toSchema, t] = getSchemaAndTableFromName(this.up ? to : from);
     const ast = {
       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);
   }
@@ -1230,20 +1278,22 @@ const processMigration = async (db, up, file, config, options, appCodeUpdaterCac
 };
 const saveMigratedVersion = async (db, version, config) => {
   await db.query(
-    `INSERT INTO ${quoteTable(config.migrationsTable)} VALUES ('${version}')`
+    `INSERT INTO ${quoteWithSchema({
+      name: config.migrationsTable
+    })} VALUES ('${version}')`
   );
 };
 const removeMigratedVersion = async (db, version, config) => {
   await db.query(
-    `DELETE FROM ${quoteTable(
-      config.migrationsTable
-    )} WHERE version = '${version}'`
+    `DELETE FROM ${quoteWithSchema({
+      name: config.migrationsTable
+    })} WHERE version = '${version}'`
   );
 };
 const getMigratedVersionsMap = async (db, config) => {
   try {
     const result = await db.arrays(
-      `SELECT * FROM ${quoteTable(config.migrationsTable)}`
+      `SELECT * FROM ${quoteWithSchema({ name: config.migrationsTable })}`
     );
     return Object.fromEntries(result.rows.map((row) => [row[0], true]));
   } catch (err) {