rake-db 2.15.8 → 2.15.10

package/dist/index.d.ts

@@ -101,9 +101,12 @@ type DbMigration<CT extends RakeDbColumnTypes> = DbResult<CT> & Migration<CT> &
  * @param config - config of `rakeDb`
  * @param asts - array of migration ASTs to collect changes into
  */
-declare const createMigrationInterface: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.BaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT extends RakeDbColumnTypes>(tx: TransactionAdapter, up: boolean, config: RakeDbConfig<SchemaConfig, CT>, asts: RakeDbAst[]) => DbMigration<CT>;
+declare const createMigrationInterface: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT extends RakeDbColumnTypes>(tx: TransactionAdapter, up: boolean, config: RakeDbConfig<SchemaConfig, CT>, asts: RakeDbAst[]) => DbMigration<CT>;
+interface MigrationAdapter extends TransactionAdapter {
+    schema: string;
+}
 declare class Migration<CT extends RakeDbColumnTypes> {
-    adapter: TransactionAdapter;
+    adapter: MigrationAdapter;
     log?: QueryLogObject;
     up: boolean;
     options: RakeDbConfig<ColumnSchemaConfig>;
@@ -253,10 +256,36 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      * });
      * ```
      *
+     * Prefix table name with a schema to set a different schema:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.renameTable('fromSchema.oldTable', 'toSchema.newTable');
+     * });
+     * ```
+     *
      * @param from - rename the table from
      * @param to - rename the table to
      */
     renameTable(from: string, to: string): Promise<void>;
+    /**
+     * Set a different schema to the table:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.changeTableSchema('tableName', 'fromSchema', 'toSchema');
+     * });
+     * ```
+     *
+     * @param table - table name
+     * @param from - current table schema
+     * @param to - desired table schema
+     */
+    changeTableSchema(table: string, from: string, to: string): Promise<void>;
     /**
      * Add a column to the table on migrating, and remove it on rollback.
      *
@@ -1050,15 +1079,15 @@ declare const migrationConfigDefaults: {
     logger: Console;
     useCodeUpdater: true;
 };
-declare const processRakeDbConfig: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.BaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(config: InputRakeDbConfig<SchemaConfig, CT>) => RakeDbConfig<SchemaConfig, CT>;
+declare const processRakeDbConfig: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(config: InputRakeDbConfig<SchemaConfig, CT>) => RakeDbConfig<SchemaConfig, CT>;
 declare const getDatabaseAndUserFromOptions: (options: AdapterOptions) => {
     database: string;
     user: string;
 };
 
-declare const createDb: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.BaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
-declare const dropDb: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.BaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
-declare const resetDb: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.BaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT extends RakeDbColumnTypes>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
+declare const createDb: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
+declare const dropDb: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
+declare const resetDb: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT extends RakeDbColumnTypes>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
 
 interface MigrationItem {
     path: string;
@@ -1079,22 +1108,22 @@ interface RakeDbCtx {
     migrationsPromise?: Promise<MigrationsSet>;
 }
 
-declare const writeMigrationFile: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.BaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(config: RakeDbConfig<SchemaConfig, CT>, version: string, name: string, content: (importPath: string, name: string) => string) => Promise<void>;
+declare const writeMigrationFile: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(config: RakeDbConfig<SchemaConfig, CT>, version: string, name: string, content: (importPath: string, name: string) => string) => Promise<void>;
 declare const generate: (config: AnyRakeDbConfig, [name]: string[]) => Promise<void>;
 declare const makeFileVersion: (ctx: RakeDbCtx, config: AnyRakeDbConfig) => Promise<string>;
 declare const generateTimeStamp: () => string;
 
 type ChangeCallback<CT extends RakeDbColumnTypes> = (db: DbMigration<CT>, up: boolean) => Promise<void>;
 
-declare const saveMigratedVersion: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.BaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(db: SilentQueries, version: string, name: string, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
-declare const deleteMigratedVersion: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.BaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(db: SilentQueries, version: string, name: string, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
+declare const saveMigratedVersion: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(db: SilentQueries, version: string, name: string, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
+declare const deleteMigratedVersion: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(db: SilentQueries, version: string, name: string, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
 declare class NoMigrationsTableError extends Error {
 }
 type RakeDbAppliedVersions = {
     map: RecordOptionalString;
     sequence: number[];
 };
-declare const getMigratedVersionsMap: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.BaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(ctx: RakeDbCtx, adapter: Adapter | TransactionAdapter, config: RakeDbConfig<SchemaConfig, CT>, renameTo?: RakeDbMigrationId) => Promise<RakeDbAppliedVersions>;
+declare const getMigratedVersionsMap: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(ctx: RakeDbCtx, adapter: Adapter | TransactionAdapter, config: RakeDbConfig<SchemaConfig, CT>, renameTo?: RakeDbMigrationId) => Promise<RakeDbAppliedVersions>;
 
 declare const RAKE_DB_LOCK_KEY = "8582141715823621641";
 type MigrateFn = <SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColumnTypes>(ctx: RakeDbCtx, options: MaybeArray<AdapterOptions>, config: RakeDbConfig<SchemaConfig, CT>, args?: string[]) => Promise<void>;
@@ -1126,9 +1155,7 @@ declare const changeCache: Record<string, ChangeCallback<RakeDbColumnTypes>[] |
 /**
  * Type of {@link rakeDb} function
  */
-type RakeDbFn = (<SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColumnTypes | undefined = undefined>(options: MaybeArray<AdapterOptions>, partialConfig?: InputRakeDbConfig<SchemaConfig, CT>, args?: string[]) => RakeDbChangeFn<CT extends undefined ? DefaultColumnTypes<DefaultSchemaConfig> : CT> & {
-    promise: Promise<void>;
-}) & {
+type RakeDbFn = (<SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColumnTypes | undefined = undefined>(options: MaybeArray<AdapterOptions>, partialConfig?: InputRakeDbConfig<SchemaConfig, CT>, args?: string[]) => RakeDbFnReturns<CT>) & {
     /**
      * Unlike the original `rakeDb` that executes immediately,
      * `rakeDb.lazy` returns the `run` function to be later called programmatically.
@@ -1139,6 +1166,9 @@ type RakeDbFn = (<SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColu
      */
     lazy: RakeDbLazyFn;
 };
+type RakeDbFnReturns<CT extends RakeDbColumnTypes | undefined> = RakeDbChangeFn<CT extends undefined ? DefaultColumnTypes<DefaultSchemaConfig> : CT> & {
+    promise: Promise<void>;
+};
 /**
  * Type of {@link rakeDb.lazy} function
  */
@@ -1161,4 +1191,4 @@ type RakeDbChangeFn<CT extends RakeDbColumnTypes> = (fn: ChangeCallback<CT>) =>
  */
 declare const rakeDb: RakeDbFn;
 
-export { AnyRakeDbConfig, AppCodeUpdater, AppCodeUpdaterParams, ChangeTableCallback, ChangeTableOptions, ColumnComment, ColumnsShapeCallback, ConstraintArg, DbMigration, DropMode, InputRakeDbConfig, Migration, MigrationColumnTypes, ModuleExportsRecord, NoMigrationsTableError, RAKE_DB_LOCK_KEY, RakeDbAppliedVersions, RakeDbAst, RakeDbBaseTable, RakeDbColumnTypes, RakeDbConfig, RakeDbMigrationId, SilentQueries, TableOptions, changeCache, createDb, createMigrationInterface, deleteMigratedVersion, dropDb, generate, generateTimeStamp, getDatabaseAndUserFromOptions, getMigratedVersionsMap, makeFileVersion, migrate, migrateOrRollback, migrationConfigDefaults, processRakeDbConfig, rakeDb, redo, resetDb, rollback, saveMigratedVersion, writeMigrationFile };
+export { AnyRakeDbConfig, AppCodeUpdater, AppCodeUpdaterParams, ChangeTableCallback, ChangeTableOptions, ColumnComment, ColumnsShapeCallback, ConstraintArg, DbMigration, DropMode, InputRakeDbConfig, Migration, MigrationAdapter, MigrationColumnTypes, ModuleExportsRecord, NoMigrationsTableError, RAKE_DB_LOCK_KEY, RakeDbAppliedVersions, RakeDbAst, RakeDbBaseTable, RakeDbChangeFn, RakeDbColumnTypes, RakeDbConfig, RakeDbFn, RakeDbFnReturns, RakeDbLazyFn, RakeDbMigrationId, SilentQueries, TableOptions, changeCache, createDb, createMigrationInterface, deleteMigratedVersion, dropDb, generate, generateTimeStamp, getDatabaseAndUserFromOptions, getMigratedVersionsMap, makeFileVersion, migrate, migrateOrRollback, migrationConfigDefaults, processRakeDbConfig, rakeDb, redo, resetDb, rollback, saveMigratedVersion, writeMigrationFile };

package/dist/index.js

@@ -41,16 +41,14 @@ const joinColumns = (columns) => {
 const quoteWithSchema = ({
   schema,
   name
-}) => {
-  return schema ? `"${schema}"."${name}"` : `"${name}"`;
-};
+}) => quoteTable(schema, name);
+const quoteTable = (schema, table) => schema ? `"${schema}"."${table}"` : `"${table}"`;
 const getSchemaAndTableFromName = (name) => {
   const index = name.indexOf(".");
   return index !== -1 ? [name.slice(0, index), name.slice(index + 1)] : [void 0, name];
 };
 const quoteNameFromString = (string) => {
-  const [schema, name] = getSchemaAndTableFromName(string);
-  return quoteWithSchema({ schema, name });
+  return quoteTable(...getSchemaAndTableFromName(string));
 };
 const quoteSchemaTable = ({
   schema,
@@ -61,10 +59,7 @@ const quoteSchemaTable = ({
 const makePopulateEnumQuery = (item) => {
   const [schema, name] = getSchemaAndTableFromName(item.enumName);
   return {
-    text: `SELECT unnest(enum_range(NULL::${quoteWithSchema({
-      schema,
-      name
-    })}))::text`,
+    text: `SELECT unnest(enum_range(NULL::${quoteTable(schema, name)}))::text`,
     then(result) {
       item.options.push(...result.rows.map(([value]) => value));
     }
@@ -191,7 +186,7 @@ const sequenceOptionsToSql = (item) => {
     line.push(`CYCLE`);
   if (item.ownedBy) {
     const [schema, table] = getSchemaAndTableFromName(item.ownedBy);
-    line.push(`OWNED BY ${quoteWithSchema({ schema, name: table })}`);
+    line.push(`OWNED BY ${quoteTable(schema, table)}`);
   }
   return line.join(" ");
 };
@@ -251,7 +246,7 @@ const foreignKeyToSql = (item, snakeCase) => {
 const referencesToSql = (references, snakeCase) => {
   const [schema, table] = getForeignKeyTable(references.fnOrTable);
   const sql = [
-    `REFERENCES ${quoteWithSchema({ schema, name: table })}(${joinColumns(
+    `REFERENCES ${quoteTable(schema, table)}(${joinColumns(
       snakeCase ? references.foreignColumns.map(orchidCore.toSnakeCase) : references.foreignColumns
     )})`
   ];
@@ -289,7 +284,7 @@ const indexesToQuery = (up, { schema, name }, indexes, language) => {
     if (options.unique) {
       sql.push("UNIQUE");
     }
-    sql.push(`INDEX "${indexName}" ON ${quoteWithSchema({ schema, name })}`);
+    sql.push(`INDEX "${indexName}" ON ${quoteTable(schema, name)}`);
     const using = options.using || options.tsVector && "GIN";
     if (using) {
       sql.push(`USING ${using}`);
@@ -1152,7 +1147,13 @@ var __spreadValues$7 = (a, b) => {
 };
 var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
 const createMigrationInterface = (tx, up, config, asts) => {
-  const adapter = new pqb.TransactionAdapter(tx, tx.client, tx.types);
+  var _a;
+  const adapter = new pqb.TransactionAdapter(
+    tx,
+    tx.client,
+    tx.types
+  );
+  adapter.schema = (_a = adapter.adapter.schema) != null ? _a : "public";
   const { query, arrays } = adapter;
   const log = pqb.logParamToLogObject(config.logger || console, config.log);
   adapter.query = (q, types) => {
@@ -1204,10 +1205,21 @@ class Migration {
    * });
    * ```
    *
+   * Prefix table name with a schema to set a different schema:
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.renameTable('fromSchema.oldTable', 'toSchema.newTable');
+   * });
+   * ```
+   *
    * @param from - rename the table from
    * @param to - rename the table to
    */
   async renameTable(from, to) {
+    var _a;
     const [fromSchema, f] = getSchemaAndTableFromName(this.up ? from : to);
     const [toSchema, t] = getSchemaAndTableFromName(this.up ? to : from);
     const ast = {
@@ -1217,17 +1229,36 @@ class Migration {
       toSchema,
       to: t
     };
-    await this.adapter.query(
-      `ALTER TABLE ${quoteWithSchema({
-        schema: ast.fromSchema,
-        name: ast.from
-      })} RENAME TO ${quoteWithSchema({
-        schema: ast.toSchema,
-        name: ast.to
-      })}`
-    );
+    if (ast.from !== ast.to) {
+      await this.adapter.query(
+        `ALTER TABLE ${quoteTable(ast.fromSchema, ast.from)} RENAME TO "${ast.to}"`
+      );
+    }
+    if (ast.fromSchema !== ast.toSchema) {
+      await this.adapter.query(
+        `ALTER TABLE ${quoteTable(ast.fromSchema, ast.to)} SET SCHEMA "${(_a = ast.toSchema) != null ? _a : this.adapter.schema}"`
+      );
+    }
     this.migratedAsts.push(ast);
   }
+  /**
+   * Set a different schema to the table:
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.changeTableSchema('tableName', 'fromSchema', 'toSchema');
+   * });
+   * ```
+   *
+   * @param table - table name
+   * @param from - current table schema
+   * @param to - desired table schema
+   */
+  changeTableSchema(table, from, to) {
+    return this.renameTable(`${from}.${table}`, `${to}.${table}`);
+  }
   /**
    * Add a column to the table on migrating, and remove it on rollback.
    *
@@ -2077,9 +2108,7 @@ const changeIds = async (options, config, [arg]) => {
 };
 const renameMigrationVersionsInDb = async (config, adapter, values) => {
   await adapter.arrays({
-    text: `UPDATE ${quoteWithSchema({
-      name: config.migrationsTable
-    })} AS t SET version = v.version FROM (VALUES ${values.map(
+    text: `UPDATE "${config.migrationsTable}" AS t SET version = v.version FROM (VALUES ${values.map(
       ([oldVersion, , newVersion], i) => `('${oldVersion}', $${i + 1}, '${newVersion}')`
     ).join(
       ", "
@@ -2232,17 +2261,13 @@ function getDigitsPrefix(name) {
 
 const saveMigratedVersion = async (db, version, name, config) => {
   await db.silentArrays({
-    text: `INSERT INTO ${quoteWithSchema({
-      name: config.migrationsTable
-    })}(version, name) VALUES ($1, $2)`,
+    text: `INSERT INTO "${config.migrationsTable}"(version, name) VALUES ($1, $2)`,
     values: [version, name]
   });
 };
 const deleteMigratedVersion = async (db, version, name, config) => {
   const res = await db.silentArrays({
-    text: `DELETE FROM ${quoteWithSchema({
-      name: config.migrationsTable
-    })} WHERE version = $1 AND name = $2`,
+    text: `DELETE FROM "${config.migrationsTable}" WHERE version = $1 AND name = $2`,
     values: [version, name]
   });
   if (res.rowCount === 0) {
@@ -2253,9 +2278,7 @@ class NoMigrationsTableError extends Error {
 }
 const getMigratedVersionsMap = async (ctx, adapter, config, renameTo) => {
   try {
-    const table = quoteWithSchema({
-      name: config.migrationsTable
-    });
+    const table = `"${config.migrationsTable}"`;
     const result = await adapter.arrays(
       `SELECT * FROM ${table} ORDER BY version`
     );
@@ -2359,9 +2382,7 @@ const createMigrationsTable = async (db, config) => {
   }
   try {
     await db.query(
-      `CREATE TABLE ${quoteWithSchema({
-        name: config.migrationsTable
-      })} ( version TEXT NOT NULL, name TEXT NOT NULL )`
+      `CREATE TABLE "${config.migrationsTable}" ( version TEXT NOT NULL, name TEXT NOT NULL )`
     );
     (_b = config.logger) == null ? void 0 : _b.log("Created versions table");
   } catch (err) {