rake-db 2.15.10 → 2.16.0

package/dist/index.d.ts

@@ -1005,10 +1005,12 @@ interface RakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColu
     useCodeUpdater?: boolean;
     forceDefaultExports?: boolean;
     import(path: string): Promise<unknown>;
-    beforeMigrate?(db: Db): Promise<void>;
-    afterMigrate?(db: Db): Promise<void>;
-    beforeRollback?(db: Db): Promise<void>;
-    afterRollback?(db: Db): Promise<void>;
+    beforeChange?(db: Db, up: boolean, redo: boolean): void | Promise<void>;
+    afterChange?(db: Db, up: boolean, redo: boolean): void | Promise<void>;
+    beforeMigrate?(db: Db): void | Promise<void>;
+    afterMigrate?(db: Db): void | Promise<void>;
+    beforeRollback?(db: Db): void | Promise<void>;
+    afterRollback?(db: Db): void | Promise<void>;
 }
 interface InputRakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT> extends QueryLogOptions {
     columnTypes?: CT | ((t: DefaultColumnTypes<DefaultSchemaConfig>) => CT);
@@ -1029,10 +1031,46 @@ interface InputRakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT> extends
     useCodeUpdater?: boolean;
     forceDefaultExports?: boolean;
     import?(path: string): Promise<unknown>;
-    beforeMigrate?(db: Db): Promise<void>;
-    afterMigrate?(db: Db): Promise<void>;
-    beforeRollback?(db: Db): Promise<void>;
-    afterRollback?(db: Db): Promise<void>;
+    /**
+     * Is called once before migrating (up) or rolling back one or more migrations.
+     *
+     * @param db - query builder
+     * @param up - whether it's migrating up or down
+     * @param redo - whether it's migrating down and then up for `redo` command
+     */
+    beforeChange?(db: Db, up: boolean, redo: boolean): void | Promise<void>;
+    /**
+     * Is called once after migrating (up) or rolling back one or more migrations.
+     *
+     * @param db - query builder
+     * @param up - whether it's migrating up or down
+     * @param redo - whether it's migrating down and then up for `redo` command
+     */
+    afterChange?(db: Db, up: boolean, redo: boolean): void | Promise<void>;
+    /**
+     * Is called once before migrating (up) one or more migrations.
+     *
+     * @param db - query builder
+     */
+    beforeMigrate?(db: Db): void | Promise<void>;
+    /**
+     * Is called once after migrating (up) one or more migrations.
+     *
+     * @param db - query builder
+     */
+    afterMigrate?(db: Db): void | Promise<void>;
+    /**
+     * Is called once before rolling back one or more migrations.
+     *
+     * @param db - query builder
+     */
+    beforeRollback?(db: Db): void | Promise<void>;
+    /**
+     * Is called once before rolling back one or more migrations.
+     *
+     * @param db - query builder
+     */
+    afterRollback?(db: Db): void | Promise<void>;
 }
 type AnyRakeDbConfig = RakeDbConfig<any, any>;
 type Db = DbResult<RakeDbColumnTypes>;
@@ -1085,9 +1123,9 @@ declare const getDatabaseAndUserFromOptions: (options: AdapterOptions) => {
     user: string;
 };
 
-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>;
+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>(options: 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>(options: 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>(options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
 
 interface MigrationItem {
     path: string;
@@ -1126,7 +1164,7 @@ type 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>;
+type MigrateFn = <SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColumnTypes>(ctx: RakeDbCtx, options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>, args?: string[]) => Promise<void>;
 /**
  * Will run all pending yet migrations, sequentially in order,
  * will apply `change` functions top-to-bottom.
@@ -1149,7 +1187,7 @@ declare const rollback: MigrateFn;
  * Takes the same options as {@link migrate}.
  */
 declare const redo: MigrateFn;
-declare const migrateOrRollback: (trx: TransactionAdapter, config: RakeDbConfig<ColumnSchemaConfig, RakeDbColumnTypes>, set: MigrationsSet, versions: RakeDbAppliedVersions, count: number, asts: RakeDbAst[], up: boolean, force?: boolean, skipLock?: boolean) => Promise<void>;
+declare const migrateOrRollback: (trx: TransactionAdapter, config: RakeDbConfig<ColumnSchemaConfig, RakeDbColumnTypes>, set: MigrationsSet, versions: RakeDbAppliedVersions, count: number, asts: RakeDbAst[], up: boolean, redo: boolean, force?: boolean, skipLock?: boolean) => Promise<void>;
 declare const changeCache: Record<string, ChangeCallback<RakeDbColumnTypes>[] | undefined>;
 
 /**
@@ -1167,14 +1205,19 @@ 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>;
+    promise: Promise<RakeDbResult>;
 };
+interface RakeDbResult {
+    options: AdapterOptions[];
+    config: AnyRakeDbConfig;
+    args: string[];
+}
 /**
  * Type of {@link rakeDb.lazy} function
  */
 type RakeDbLazyFn = <SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColumnTypes>(options: MaybeArray<AdapterOptions>, partialConfig?: InputRakeDbConfig<SchemaConfig, CT>) => {
     change: RakeDbChangeFn<CT>;
-    run(args: string[], config?: Partial<RakeDbConfig<SchemaConfig, CT>>): Promise<void>;
+    run(args: string[], config?: Partial<RakeDbConfig<SchemaConfig, CT>>): Promise<RakeDbResult>;
 };
 /**
  * Function to use in migrations to wrap database changes
@@ -1190,5 +1233,6 @@ type RakeDbChangeFn<CT extends RakeDbColumnTypes> = (fn: ChangeCallback<CT>) =>
  * @param args - optionally provide an array of cli args. Default is `process.argv.slice(2)`.
  */
 declare const rakeDb: RakeDbFn;
+declare const rakeDbAliases: RecordOptionalString;
 
-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 };
+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, RakeDbResult, SilentQueries, TableOptions, changeCache, createDb, createMigrationInterface, deleteMigratedVersion, dropDb, generate, generateTimeStamp, getDatabaseAndUserFromOptions, getMigratedVersionsMap, makeFileVersion, migrate, migrateOrRollback, migrationConfigDefaults, processRakeDbConfig, rakeDb, rakeDbAliases, redo, resetDb, rollback, saveMigratedVersion, writeMigrationFile };

package/dist/index.js

@@ -2428,9 +2428,8 @@ function makeMigrateFn(defaultCount, up, fn) {
     const asts = [];
     const appCodeUpdaterCache = {};
     const { appCodeUpdater } = conf;
-    const arrOptions = orchidCore.toArray(options);
     let localAsts = asts;
-    for (const opts of arrOptions) {
+    for (const opts of options) {
       const adapter = new pqb.Adapter(opts);
       try {
         await transaction(adapter, async (trx) => {
@@ -2480,7 +2479,7 @@ function makeMigrateFn(defaultCount, up, fn) {
       localAsts = [];
     }
     await runCodeUpdaterAfterAll(
-      arrOptions[0],
+      options[0],
       config,
       appCodeUpdater,
       asts,
@@ -2491,19 +2490,48 @@ function makeMigrateFn(defaultCount, up, fn) {
 const migrate = makeMigrateFn(
   Infinity,
   true,
-  (trx, config, set, versions, count, asts, force) => migrateOrRollback(trx, config, set, versions, count, asts, true, force)
+  (trx, config, set, versions, count, asts, force) => migrateOrRollback(
+    trx,
+    config,
+    set,
+    versions,
+    count,
+    asts,
+    true,
+    false,
+    force
+  )
 );
 const rollback = makeMigrateFn(
   1,
   false,
-  (trx, config, set, versions, count, asts, force) => migrateOrRollback(trx, config, set, versions, count, asts, false, force)
+  (trx, config, set, versions, count, asts, force) => migrateOrRollback(
+    trx,
+    config,
+    set,
+    versions,
+    count,
+    asts,
+    false,
+    false,
+    force
+  )
 );
 const redo = makeMigrateFn(
   1,
   true,
   async (trx, config, set, versions, count, asts, force) => {
     set.migrations.reverse();
-    await migrateOrRollback(trx, config, set, versions, count, asts, false);
+    await migrateOrRollback(
+      trx,
+      config,
+      set,
+      versions,
+      count,
+      asts,
+      false,
+      true
+    );
     set.migrations.reverse();
     await migrateOrRollback(
       trx,
@@ -2513,6 +2541,7 @@ const redo = makeMigrateFn(
       count,
       asts,
       true,
+      true,
       force,
       true
     );
@@ -2530,8 +2559,8 @@ function prepareConfig(config, args, hasArg) {
     delete config.appCodeUpdater;
   return config;
 }
-const migrateOrRollback = async (trx, config, set, versions, count, asts, up, force, skipLock) => {
-  var _a, _b, _c;
+const migrateOrRollback = async (trx, config, set, versions, count, asts, up, redo2, force, skipLock) => {
+  var _a, _b, _c, _d, _e;
   const { sequence, map: versionsMap } = versions;
   if (up) {
     const rollbackTo = checkMigrationOrder(config, set, versions, force);
@@ -2553,7 +2582,8 @@ const migrateOrRollback = async (trx, config, set, versions, count, asts, up, fo
         versions,
         sequence.length - i,
         asts,
-        false
+        false,
+        redo2
       );
       set.migrations.reverse();
     }
@@ -2562,6 +2592,7 @@ const migrateOrRollback = async (trx, config, set, versions, count, asts, up, fo
     await queryLock(trx);
   let db;
   await ((_a = config[up ? "beforeMigrate" : "beforeRollback"]) == null ? void 0 : _a.call(config, db != null ? db : db = getDb(trx)));
+  await ((_b = config.beforeChange) == null ? void 0 : _b.call(config, db != null ? db : db = getDb(trx), up, redo2));
   for (const file of set.migrations) {
     if (up && versionsMap[file.version] || !up && !versionsMap[file.version]) {
       continue;
@@ -2577,11 +2608,12 @@ const migrateOrRollback = async (trx, config, set, versions, count, asts, up, fo
       versionsMap[file.version] = void 0;
       sequence.pop();
     }
-    (_b = config.logger) == null ? void 0 : _b.log(
+    (_c = config.logger) == null ? void 0 : _c.log(
       `${up ? "Migrated" : "Rolled back"} ${orchidCore.pathToLog(file.path)}`
     );
   }
-  await ((_c = config[up ? "afterMigrate" : "afterRollback"]) == null ? void 0 : _c.call(config, db != null ? db : db = getDb(trx)));
+  await ((_d = config.afterChange) == null ? void 0 : _d.call(config, db != null ? db : db = getDb(trx), up, redo2));
+  await ((_e = config[up ? "afterMigrate" : "afterRollback"]) == null ? void 0 : _e.call(config, db != null ? db : db = getDb(trx)));
 };
 const checkMigrationOrder = (config, set, { sequence, map }, force) => {
   const last = sequence[sequence.length - 1];
@@ -2896,9 +2928,9 @@ Don't use this command for database service providers, only for a local db.`;
   await createMigrationsTable(db, config);
   await db.close();
 };
-const createDb = async (arg, config) => {
-  for (const options of orchidCore.toArray(arg)) {
-    await createOrDrop(options, options, config, {
+const createDb = async (options, config) => {
+  for (const opts of options) {
+    await createOrDrop(opts, opts, config, {
       sql({ database, user }) {
         return `CREATE DATABASE "${database}"${user ? ` OWNER "${user}"` : ""}`;
       },
@@ -2912,9 +2944,9 @@ const createDb = async (arg, config) => {
     });
   }
 };
-const dropDb = async (arg, config) => {
-  for (const options of orchidCore.toArray(arg)) {
-    await createOrDrop(options, options, config, {
+const dropDb = async (options, config) => {
+  for (const opts of options) {
+    await createOrDrop(opts, opts, config, {
       sql({ database }) {
         return `DROP DATABASE "${database}"`;
       },
@@ -2927,10 +2959,10 @@ const dropDb = async (arg, config) => {
     });
   }
 };
-const resetDb = async (arg, config) => {
-  await dropDb(arg, config);
-  await createDb(arg, config);
-  await migrate({}, arg, config);
+const resetDb = async (options, config) => {
+  await dropDb(options, config);
+  await createDb(options, config);
+  await migrate({}, options, config);
 };
 
 const filterSchema = (table) => `${table} !~ '^pg_' AND ${table} != 'information_schema'`;
@@ -4089,9 +4121,7 @@ const runRecurrentMigrations = async (options, config) => {
   let files = 0;
   await readdirRecursive(config.recurrentPath, async (path) => {
     files++;
-    dbs != null ? dbs : dbs = orchidCore.toArray(options).map(
-      (opts) => pqb.createDb({ adapter: new pqb.Adapter(opts) })
-    );
+    dbs != null ? dbs : dbs = options.map((opts) => pqb.createDb({ adapter: new pqb.Adapter(opts) }));
     const sql = await fs.readFile(path, "utf-8");
     await Promise.all(
       dbs.map(async (db) => {
@@ -4460,39 +4490,55 @@ function change(fn) {
   pushChange(fn);
   return fn;
 }
-const runCommand = async (options, config, args = process.argv.slice(2)) => {
+const rakeDbAliases = {
+  migrate: "up",
+  rollback: "down",
+  s: "status",
+  rec: "recurrent"
+};
+const runCommand = async (opts, config, args = process.argv.slice(2)) => {
   var _a, _b;
-  const arg = (_a = args[0]) == null ? void 0 : _a.split(":")[0];
+  let arg = (_a = args[0]) == null ? void 0 : _a.split(":")[0];
+  if (rakeDbAliases[arg]) {
+    args = [...args];
+    arg = args[0] = rakeDbAliases[arg];
+  }
+  const options = orchidCore.toArray(opts);
   if (arg === "create") {
     await createDb(options, config);
   } else if (arg === "drop") {
     await dropDb(options, config);
   } else if (arg === "reset") {
     await resetDb(options, config);
-  } else if (arg === "up" || arg === "migrate") {
+  } else if (arg === "up") {
     await migrate({}, options, config, args.slice(1));
-  } else if (arg === "down" || arg === "rollback") {
+  } else if (arg === "down") {
     await rollback({}, options, config, args.slice(1));
   } else if (arg === "redo") {
     await redo({}, options, config, args.slice(1));
   } else if (arg === "new") {
     await generate(config, args.slice(1));
   } else if (arg === "pull") {
-    await pullDbStructure(orchidCore.toArray(options)[0], config);
-  } else if (arg === "status" || arg === "s") {
-    await listMigrationsStatuses(orchidCore.toArray(options), config, args.slice(1));
+    await pullDbStructure(options[0], config);
+  } else if (arg === "status") {
+    await listMigrationsStatuses(options, config, args.slice(1));
   } else if (arg === "rebase") {
-    await rebase(orchidCore.toArray(options), config);
+    await rebase(options, config);
   } else if (arg === "change-ids") {
-    await changeIds(orchidCore.toArray(options), config, args.slice(1));
+    await changeIds(options, config, args.slice(1));
   } else if (config.commands[arg]) {
-    await config.commands[arg](orchidCore.toArray(options), config, args.slice(1));
-  } else if (arg !== "rec" && arg !== "recurrent") {
+    await config.commands[arg](options, config, args.slice(1));
+  } else if (arg !== "recurrent") {
     (_b = config.logger) == null ? void 0 : _b.log(help);
   }
-  if (arg === "migrate" || arg === "rec" || arg === "recurrent" || arg === "redo") {
+  if (arg === "up" || arg === "recurrent" || arg === "redo") {
     await runRecurrentMigrations(options, config);
   }
+  return {
+    options,
+    config,
+    args
+  };
 };
 const help = `Usage: rake-db [command] [arguments]
 
@@ -4551,6 +4597,7 @@ exports.migrateOrRollback = migrateOrRollback;
 exports.migrationConfigDefaults = migrationConfigDefaults;
 exports.processRakeDbConfig = processRakeDbConfig;
 exports.rakeDb = rakeDb;
+exports.rakeDbAliases = rakeDbAliases;
 exports.redo = redo;
 exports.resetDb = resetDb;
 exports.rollback = rollback;