rake-db 2.15.11 → 2.17.0

package/dist/index.d.ts

@@ -986,6 +986,25 @@ declare namespace RakeDbAst {
     }
 }
 
+interface RakeDbCtx {
+    migrationsPromise?: Promise<MigrationsSet>;
+}
+
+interface MigrationItem {
+    path: string;
+    version: string;
+    /**
+     * Function that loads the migration content,
+     * can store lazy import of a migration file.
+     * Promise can return `{ default: x }` where `x` is a return of `change` or an array of such returns.
+     */
+    load(): Promise<unknown>;
+}
+interface MigrationsSet {
+    renameTo?: RakeDbMigrationId;
+    migrations: MigrationItem[];
+}
+
 interface RakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>> extends QueryLogOptions {
     schemaConfig: SchemaConfig;
     columnTypes: CT;
@@ -1005,10 +1024,13 @@ 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?: ChangeCallback$1;
+    afterChange?: ChangeCallback$1;
+    afterChangeCommit?: ChangeCommitCallback;
+    beforeMigrate?: MigrationCallback;
+    afterMigrate?: MigrationCallback;
+    beforeRollback?: MigrationCallback;
+    afterRollback?: MigrationCallback;
 }
 interface InputRakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT> extends QueryLogOptions {
     columnTypes?: CT | ((t: DefaultColumnTypes<DefaultSchemaConfig>) => CT);
@@ -1029,11 +1051,79 @@ 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 per db before migrating or rolling back a set of migrations.
+     *
+     * @param arg.db - query builder
+     * @param arg.up - whether it's migrating up or down
+     * @param arg.redo - whether it's migrating down and then up for `redo` command
+     * @param arg.migrations - array of executed (up or down) migrations
+     */
+    beforeChange?: ChangeCallback$1;
+    /**
+     * Is called once per db after migrating or rolling back a set of migrations.
+     * Runs inside the same transaction as migrations,
+     * for running after commit use {@link afterChangeCommit}.
+     *
+     * @param arg.db - query builder
+     * @param arg.up - whether it's migrating up or down
+     * @param arg.redo - whether it's migrating down and then up for `redo` command
+     * @param arg.migrations - array of executed (up or down) migrations
+     */
+    afterChange?: ChangeCallback$1;
+    /**
+     * Is called once per db after migrating or rolling back a set of migrations.
+     * Runs **after** committing migrations transaction.
+     *
+     * @param arg.options - database connection options
+     * @param arg.up - whether it's migrating up or down
+     * @param arg.migrations - array of executed (up or down) migrations
+     */
+    afterChangeCommit?: ChangeCommitCallback;
+    /**
+     * Is called once per db before migrating (up) a set of migrations.
+     *
+     * @param arg.db - query builder
+     * @param arg.migrations - applied migrations
+     */
+    beforeMigrate?: MigrationCallback;
+    /**
+     * Is called once per db after migrating (up) a set of migrations.
+     *
+     * @param arg.db - query builder
+     * @param arg.migrations - applied migrations
+     */
+    afterMigrate?: MigrationCallback;
+    /**
+     * Is called once per db before rolling back a set of migrations.
+     *
+     * @param arg.db - query builder
+     * @param arg.migrations - rolled back migrations
+     */
+    beforeRollback?: MigrationCallback;
+    /**
+     * Is called once per db before rolling back a set of migrations.
+     *
+     * @param arg.db - query builder
+     * @param arg.migrations - rolled back migrations
+     */
+    afterRollback?: MigrationCallback;
 }
+type ChangeCallback$1 = (arg: {
+    db: Db;
+    up: boolean;
+    redo: boolean;
+    migrations: MigrationItem[];
+}) => void | Promise<void>;
+type ChangeCommitCallback = (arg: {
+    options: AdapterOptions;
+    up: boolean;
+    migrations: MigrationItem[];
+}) => void | Promise<void>;
+type MigrationCallback = (arg: {
+    db: Db;
+    migrations: MigrationItem[];
+}) => void | Promise<void>;
 type AnyRakeDbConfig = RakeDbConfig<any, any>;
 type Db = DbResult<RakeDbColumnTypes>;
 interface RakeDbBaseTable<CT> {
@@ -1085,28 +1175,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>;
-
-interface MigrationItem {
-    path: string;
-    version: string;
-    /**
-     * Function that loads the migration content,
-     * can store lazy import of a migration file.
-     * Promise can return `{ default: x }` where `x` is a return of `change` or an array of such returns.
-     */
-    load(): Promise<unknown>;
-}
-interface MigrationsSet {
-    renameTo?: RakeDbMigrationId;
-    migrations: MigrationItem[];
-}
-
-interface RakeDbCtx {
-    migrationsPromise?: Promise<MigrationsSet>;
-}
+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>;
 
 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>;
@@ -1126,7 +1197,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 +1220,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 +1238,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 +1266,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

@@ -2413,6 +2413,7 @@ var __spreadValues$5 = (a, b) => {
 const RAKE_DB_LOCK_KEY = "8582141715823621641";
 function makeMigrateFn(defaultCount, up, fn) {
   return async (ctx, options, config, args = []) => {
+    var _a;
     const set = await getMigrations(ctx, config, up);
     const arg = args[0];
     let force = arg === "force";
@@ -2428,9 +2429,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) => {
@@ -2478,9 +2478,14 @@ function makeMigrateFn(defaultCount, up, fn) {
         await adapter.close();
       }
       localAsts = [];
+      (_a = config.afterChangeCommit) == null ? void 0 : _a.call(config, {
+        options: opts,
+        up,
+        migrations: set.migrations
+      });
     }
     await runCodeUpdaterAfterAll(
-      arrOptions[0],
+      options[0],
       config,
       appCodeUpdater,
       asts,
@@ -2491,19 +2496,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 +2547,7 @@ const redo = makeMigrateFn(
       count,
       asts,
       true,
+      true,
       force,
       true
     );
@@ -2530,7 +2565,7 @@ function prepareConfig(config, args, hasArg) {
     delete config.appCodeUpdater;
   return config;
 }
-const migrateOrRollback = async (trx, config, set, versions, count, asts, up, force, skipLock) => {
+const migrateOrRollback = async (trx, config, set, versions, count, asts, up, redo2, force, skipLock) => {
   var _a, _b, _c;
   const { sequence, map: versionsMap } = versions;
   if (up) {
@@ -2553,7 +2588,8 @@ const migrateOrRollback = async (trx, config, set, versions, count, asts, up, fo
         versions,
         sequence.length - i,
         asts,
-        false
+        false,
+        redo2
       );
       set.migrations.reverse();
     }
@@ -2561,7 +2597,13 @@ const migrateOrRollback = async (trx, config, set, versions, count, asts, up, fo
   if (!skipLock)
     await queryLock(trx);
   let db;
-  await ((_a = config[up ? "beforeMigrate" : "beforeRollback"]) == null ? void 0 : _a.call(config, db != null ? db : db = getDb(trx)));
+  const beforeMigrate = config[up ? "beforeMigrate" : "beforeRollback"];
+  if (beforeMigrate || config.beforeChange) {
+    db != null ? db : db = getDb(trx);
+    const { migrations } = set;
+    await (beforeMigrate == null ? void 0 : beforeMigrate({ db, migrations }));
+    await ((_a = config.beforeChange) == null ? void 0 : _a.call(config, { db, migrations, up, redo: redo2 }));
+  }
   for (const file of set.migrations) {
     if (up && versionsMap[file.version] || !up && !versionsMap[file.version]) {
       continue;
@@ -2581,7 +2623,13 @@ const migrateOrRollback = async (trx, config, set, versions, count, asts, up, fo
       `${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)));
+  const afterMigrate = config[up ? "afterMigrate" : "afterRollback"];
+  if (config.afterChange || afterMigrate) {
+    db != null ? db : db = getDb(trx);
+    const { migrations } = set;
+    await ((_c = config.afterChange) == null ? void 0 : _c.call(config, { db, up, redo: redo2, migrations }));
+    await (afterMigrate == null ? void 0 : afterMigrate({ db, migrations }));
+  }
 };
 const checkMigrationOrder = (config, set, { sequence, map }, force) => {
   const last = sequence[sequence.length - 1];
@@ -2896,9 +2944,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 +2960,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 +2975,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 +4137,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 +4506,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 +4613,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;