rake-db 2.2.4 → 2.2.6

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # rake-db
 
+## 2.2.6
+
+### Patch Changes
+
+- Change inner aspects of columns
+- Updated dependencies
+  - pqb@0.8.5
+
+## 2.2.5
+
+### Patch Changes
+
+- Fix useCodeUpdater option default
+
 ## 2.2.4
 
 ### 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>;
@@ -162,7 +164,9 @@ declare namespace RakeDbAst {
     };
     type RenameTable = {
         type: 'renameTable';
+        fromSchema?: string;
         from: string;
+        toSchema?: string;
         to: string;
     };
     type Schema = {

package/dist/index.esm.js

@@ -29,7 +29,7 @@ const migrationConfigDefaults = {
   requireTs: require,
   log: true,
   logger: console,
-  useCodeUpdaterByDefault: true
+  useCodeUpdater: true
 };
 const getMigrationConfigWithDefaults = (config) => {
   return __spreadValues$6(__spreadValues$6({}, migrationConfigDefaults), config);
@@ -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) {
@@ -242,13 +244,13 @@ const columnToSql = (key, item, values, hasMultiplePrimaryKeys) => {
   }
   const { foreignKey } = item.data;
   if (foreignKey) {
-    const table = getForeignKeyTable(
+    const [schema, table] = getForeignKeyTable(
       "fn" in foreignKey ? foreignKey.fn : foreignKey.table
     );
     if (foreignKey.name) {
       line.push(`CONSTRAINT "${foreignKey.name}"`);
     }
-    line.push(referencesToSql(table, foreignKey.columns, foreignKey));
+    line.push(referencesToSql(schema, table, foreignKey.columns, foreignKey));
   }
   return line.join(" ");
 };
@@ -269,25 +271,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 +309,9 @@ 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.map(({ column }) => column), "index");
     if (!up) {
       return {
         text: `DROP INDEX "${indexName}"${options.dropMode ? ` ${options.dropMode}` : ""}`,
@@ -314,7 +323,7 @@ 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}`);
     }
@@ -354,11 +363,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 +449,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 +488,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 +510,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: []
     });
   }
@@ -608,7 +619,7 @@ const columnTypeToColumnChange = (item) => {
     return __spreadProps$2(__spreadValues$3({
       column: item,
       type: item.toSQL(),
-      nullable: item.isNullable,
+      nullable: item.data.isNullable,
       primaryKey: item.isPrimaryKey
     }, item.data), {
       foreignKey
@@ -681,9 +692,11 @@ 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 });
@@ -693,7 +706,7 @@ const astToQueries = (ast) => {
   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: []
     });
   }
@@ -830,7 +843,7 @@ const astToQueries = (ast) => {
   prependAlterTable.push(
     ...dropForeignKeys.map(
       (foreignKey) => `
- DROP ${constraintToSql(ast.name, false, foreignKey)}`
+ DROP ${constraintToSql(ast, false, foreignKey)}`
     )
   );
   alterTable.unshift(...prependAlterTable);
@@ -840,19 +853,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 +916,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 +954,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 +1020,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 +1260,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) {