rake-db 2.28.0 → 2.29.0

package/dist/index.d.ts

@@ -1,9 +1,5 @@
 import * as pqb from 'pqb';
-import { ColumnsShape, Db, TableData, NoPrimaryKeyOption, MaybeArray, Column, RawSqlBase, RecordString, EnumColumn, EmptyObject, ColumnSchemaConfig, DefaultColumnTypes, DefaultSchemaConfig, QueryLogOptions, AdapterBase, DbResult, MaybePromise, QueryLogObject, TableDataFn, TableDataItem, DbDomainArg, raw, SearchWeight, ColumnsByType, DbStructureDomainsMap, Query } from 'pqb';
-
-interface CreateTableResult<Table extends string, Shape extends ColumnsShape> {
-    table: Db<Table, Shape>;
-}
+import { TableData, ColumnsShape, NoPrimaryKeyOption, MaybeArray, Column, RawSqlBase, RecordString, EnumColumn, EmptyObject, AdapterBase, DbResult, DefaultColumnTypes, DefaultSchemaConfig, QueryLogObject, TableDataFn, TableDataItem, DbDomainArg, ColumnSchemaConfig, raw, Db, MaybePromise, QueryLogOptions, QuerySchema, Query, SearchWeight, ColumnsByType, DbStructureDomainsMap } from 'pqb';
 
 type RakeDbAst = RakeDbAst.Table | RakeDbAst.ChangeTable | RakeDbAst.RenameType | RakeDbAst.Schema | RakeDbAst.RenameSchema | RakeDbAst.Extension | RakeDbAst.Enum | RakeDbAst.EnumValues | RakeDbAst.RenameEnumValues | RakeDbAst.ChangeEnumValues | RakeDbAst.Domain | RakeDbAst.Collation | RakeDbAst.Constraint | RakeDbAst.RenameTableItem | RakeDbAst.View;
 declare namespace RakeDbAst {
@@ -273,234 +269,6 @@ declare const tableChangeMethods: {
 type TableChanger<CT> = MigrationColumnTypes<CT> & TableChangeMethods;
 type TableChangeData = Record<string, RakeDbAst.ChangeTableItem.Column | RakeDbAst.ChangeTableItem.Rename | Change | SpecialChange | Column.Pick.Data>;
 
-interface RakeDbCtx {
-    migrationsPromise?: Promise<MigrationsSet>;
-}
-declare const getSchemaAndTableFromName: (name: string) => [string | undefined, string];
-declare const concatSchemaAndName: ({ schema, name, }: {
-    schema?: string;
-    name: string;
-}, excludeCurrentSchema?: string) => string;
-
-interface MigrationItemHasLoad {
-    path?: 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 MigrationItem extends MigrationItemHasLoad {
-    path: string;
-    version: string;
-}
-interface MigrationsSet {
-    renameTo?: RakeDbRenameMigrations;
-    migrations: MigrationItem[];
-}
-
-interface CommandFn<SchemaConfig extends ColumnSchemaConfig, CT> {
-    (adapters: AdapterBase[], config: RakeDbConfig<SchemaConfig, CT>, args: string[]): void | Promise<void>;
-}
-interface PickBasePath {
-    basePath: string;
-}
-interface PickImport {
-    import(path: string): Promise<unknown>;
-}
-interface PickMigrationId {
-    migrationId: RakeDbMigrationId;
-}
-interface PickMigrations {
-    migrations?: ModuleExportsRecord;
-}
-interface PickMigrationsPath {
-    migrationsPath: string;
-}
-interface PickOptionalMigrationsPath {
-    migrationsPath?: string;
-}
-interface PickRenameMigrations {
-    renameMigrations?: RakeDbRenameMigrationsInput;
-}
-interface PickMigrationsTable {
-    schema?: string;
-    migrationsTable: string;
-}
-interface PickTransactionSetting {
-    transaction: 'single' | 'per-migration';
-}
-interface PickMigrationCallbacks {
-    beforeChange?: ChangeCallback$1;
-    afterChange?: ChangeCallback$1;
-    beforeMigrate?: MigrationCallback;
-    afterMigrate?: MigrationCallback;
-    beforeRollback?: MigrationCallback;
-    afterRollback?: MigrationCallback;
-}
-interface PickAfterChangeCommit {
-    afterChangeCommit?: ChangeCommitCallback;
-}
-interface PickForceDefaultExports {
-    forceDefaultExports?: boolean;
-}
-interface RakeDbBaseConfig<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>> extends QueryLogOptions, PickImport, PickMigrationId, PickMigrationsPath, PickMigrations, PickRenameMigrations, PickMigrationsTable, PickMigrationCallbacks, PickForceDefaultExports, PickAfterChangeCommit {
-    schema?: string;
-    schemaConfig: SchemaConfig;
-    snakeCase: boolean;
-    language?: string;
-    commands: Record<string, CommandFn<SchemaConfig, CT>>;
-    noPrimaryKey?: NoPrimaryKeyOption;
-    baseTable?: RakeDbBaseTable<CT>;
-}
-interface RakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>> extends RakeDbBaseConfig<SchemaConfig, CT>, PickBasePath, PickTransactionSetting {
-    columnTypes: CT;
-    dbScript: string;
-    recurrentPath: string;
-}
-interface InputRakeDbConfigBase<SchemaConfig extends ColumnSchemaConfig, CT> extends QueryLogOptions, PickOptionalMigrationsPath {
-    columnTypes?: CT | ((t: DefaultColumnTypes<DefaultSchemaConfig>) => CT);
-    baseTable?: RakeDbBaseTable<CT>;
-    schemaConfig?: SchemaConfig;
-    basePath?: string;
-    dbScript?: string;
-    migrationId?: 'serial' | RakeDbMigrationId;
-    recurrentPath?: string;
-    migrationsTable?: string;
-    snakeCase?: boolean;
-    language?: string;
-    commands?: Record<string, (adapter: AdapterBase[], config: RakeDbConfig<SchemaConfig, CT>, args: string[]) => void | Promise<void>>;
-    noPrimaryKey?: NoPrimaryKeyOption;
-    forceDefaultExports?: boolean;
-    /**
-     * 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;
-}
-interface InputRakeDbConfigFileBased<SchemaConfig extends ColumnSchemaConfig, CT> extends InputRakeDbConfigBase<SchemaConfig, CT> {
-    /**
-     * It may look odd, but it's required for `tsx` and other bundlers to have such `import` config specified explicitly.
-     */
-    import(path: string): Promise<unknown>;
-}
-interface InputRakeDbConfigCodeBased<SchemaConfig extends ColumnSchemaConfig, CT> extends InputRakeDbConfigBase<SchemaConfig, CT> {
-    /**
-     * To specify array of migrations explicitly, without loading them from files.
-     */
-    migrations: ModuleExportsRecord;
-    renameMigrations?: RakeDbRenameMigrationsInput;
-    /**
-     * It may look odd, but it's required for `tsx` and other bundlers to have such `import` config specified explicitly.
-     */
-    import?(path: string): Promise<unknown>;
-}
-type InputRakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT> = InputRakeDbConfigFileBased<SchemaConfig, CT> | InputRakeDbConfigCodeBased<SchemaConfig, CT>;
-interface ChangeCallback$1 {
-    (arg: {
-        db: DbResult<unknown>;
-        up: boolean;
-        redo: boolean;
-        migrations: MigrationItem[];
-    }): void | Promise<void>;
-}
-interface ChangeCommitCallback {
-    (arg: {
-        adapter: AdapterBase;
-        up: boolean;
-        migrations: MigrationItem[];
-    }): void | Promise<void>;
-}
-interface MigrationCallback {
-    (arg: {
-        db: DbResult<unknown>;
-        migrations: MigrationItem[];
-    }): void | Promise<void>;
-}
-type AnyRakeDbConfig = RakeDbConfig<any, any>;
-interface RakeDbBaseTable<CT> {
-    exportAs: string;
-    getFilePath(): string;
-    nowSQL?: string;
-    new (): {
-        types: CT;
-        snakeCase?: boolean;
-        language?: string;
-    };
-}
-interface ModuleExportsRecord {
-    [K: string]: () => Promise<unknown>;
-}
-type RakeDbMigrationId = 'timestamp' | {
-    serial: number;
-};
-interface RakeDbRenameMigrationsMap {
-    [K: string]: number;
-}
-interface RakeDbRenameMigrations {
-    to: RakeDbMigrationId;
-    map(): MaybePromise<RakeDbRenameMigrationsMap>;
-}
-interface RakeDbRenameMigrationsInput {
-    to: RakeDbMigrationId;
-    map: RakeDbRenameMigrationsMap;
-}
-declare const migrationConfigDefaults: RakeDbBaseConfig<ColumnSchemaConfig>;
-declare const processRakeDbConfig: <SchemaConfig extends ColumnSchemaConfig<pqb.Column.Pick.Data>, CT>(config: InputRakeDbConfig<SchemaConfig, CT>, args?: string[]) => RakeDbConfig<SchemaConfig, CT>;
-
 type DropMode = 'CASCADE' | 'RESTRICT';
 type TableOptions = {
     createIfNotExists?: boolean;
@@ -530,9 +298,6 @@ type SilentQueries = {
 type DbMigration<CT> = DbResult<CT> & Migration<CT> & {
     adapter: SilentQueries;
 };
-interface CreateMigrationInterfaceConfig<CT> extends QueryLogOptions {
-    columnTypes: CT;
-}
 /**
  * Creates a new `db` instance that is an instance of `pqb` with mixed in migration methods from the `Migration` class.
  * It overrides `query` and `array` db adapter methods to intercept SQL for the logging.
@@ -541,13 +306,13 @@ interface CreateMigrationInterfaceConfig<CT> extends QueryLogOptions {
  * @param up - migrate or rollback
  * @param config - config of `rakeDb`
  */
-declare const createMigrationInterface: <CT>(tx: AdapterBase, up: boolean, config: CreateMigrationInterfaceConfig<CT>) => DbMigration<CT>;
+declare const createMigrationInterface: (tx: AdapterBase, up: boolean, config: Pick<RakeDbConfig, 'log' | 'logger' | 'columnTypes'>) => DbMigration<DefaultColumnTypes<DefaultSchemaConfig>>;
 type MigrationAdapter = AdapterBase;
-declare class Migration<CT> {
+declare class Migration<CT = unknown> {
     adapter: MigrationAdapter;
     log?: QueryLogObject;
     up: boolean;
-    options: RakeDbConfig<ColumnSchemaConfig>;
+    options: RakeDbConfig;
     columnTypes: CT;
     /**
      * `createTable` accepts a string for a table name, optional options, and a callback to specify columns.
@@ -1452,35 +1217,242 @@ interface AddEnumValueOptions {
     after?: string;
 }
 
-interface MigrationChange {
-    fn: ChangeCallback<unknown>;
-    config: RakeDbConfig<ColumnSchemaConfig, unknown>;
+interface CreateTableResult<Table extends string, Shape extends ColumnsShape> {
+    table: Db<Table, Shape>;
 }
-type ChangeCallback<CT> = (db: DbMigration<CT>, up: boolean) => Promise<void>;
 
-/**
- * Type of {@link rakeDbWithAdapters} function
- */
-interface RakeDbFn<Options> {
-    <SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>>(options: Options, partialConfig: InputRakeDbConfig<SchemaConfig, CT>, args?: string[]): RakeDbChangeFnWithPromise<CT>;
+interface RakeDbCtx {
+    migrationsPromise?: Promise<MigrationsSet>;
+}
+declare const getSchemaAndTableFromName: (config: Pick<RakeDbConfig, 'schema'>, name: string) => [string | undefined, string];
+declare const concatSchemaAndName: ({ schema, name, }: {
+    schema?: string;
+    name: string;
+}, excludeCurrentSchema?: string) => string;
+
+interface MigrationItemHasLoad {
+    path?: 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(): MaybePromise<unknown>;
+}
+interface MigrationItem extends MigrationItemHasLoad {
+    path: string;
+    version: string;
+}
+interface MigrationsSet {
+    renameTo?: RakeDbRenameMigrations;
+    migrations: MigrationItem[];
+}
+
+interface RakeDbCliConfigInputBase<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>> extends QueryLogOptions {
+    columnTypes?: CT | ((t: DefaultColumnTypes<DefaultSchemaConfig>) => CT);
+    baseTable?: RakeDbBaseTable<CT>;
+    schemaConfig?: SchemaConfig;
+    basePath?: string;
+    dbScript?: string;
+    migrationId?: 'serial' | RakeDbMigrationId;
+    recurrentPath?: string;
+    migrationsTable?: string;
+    snakeCase?: boolean;
+    language?: string;
+    commands?: {
+        [commandName: string]: RakeDbCommandFn | RakeDbCommand;
+    };
+    noPrimaryKey?: NoPrimaryKeyOption;
+    forceDefaultExports?: boolean;
+    /**
+     * 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;
     /**
-     * Unlike the original `rakeDb` that executes immediately,
-     * `rakeDb.lazy` returns the `run` function to be later called programmatically.
+     * Is called once per db after migrating or rolling back a set of migrations.
+     * Runs **after** committing migrations transaction.
      *
-     * @param options - array of connection adapters for migrating multiple dbs
-     * @param config - {@link RakeDbConfig}
-     * @returns `change` is to be used in migrations, `run` takes an array cli args to execute a command
+     * @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
      */
-    lazy<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>>(options: Options, config: InputRakeDbConfig<SchemaConfig, CT>): {
-        change: RakeDbChangeFn<CT>;
-        run(args: string[], config?: Partial<RakeDbConfig<SchemaConfig, CT>>): Promise<RakeDbResult>;
+    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;
+    /**
+     * It may look odd, but it's required for `tsx` and other bundlers to have such `import` config specified explicitly.
+     */
+    import?(path: string): Promise<unknown>;
+}
+interface RakeDbCliConfigInputFileBased<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>> extends RakeDbCliConfigInputBase<SchemaConfig, CT> {
+    migrationsPath?: string;
+    /**
+     * required for `tsx` and other bundlers to have such `import` config specified explicitly.
+     */
+    import(path: string): Promise<unknown>;
+}
+interface RakeDbCliConfigInputCodeBased<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>> extends RakeDbCliConfigInputBase<SchemaConfig, CT> {
+    /**
+     * To specify array of migrations explicitly, without loading them from files.
+     */
+    migrations: ModuleExportsRecord;
+    renameMigrations?: RakeDbRenameMigrationsInput;
+}
+type RakeDbCliConfigInput<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>> = RakeDbCliConfigInputFileBased<SchemaConfig, CT> | RakeDbCliConfigInputCodeBased<SchemaConfig, CT>;
+interface RakeDbConfig<ColumnTypes = unknown> extends QueryLogOptions {
+    /**
+     * Set by makeRakeDbConfig to distinguish between the user-provided initial config from the processed one.
+     */
+    __rakeDbConfig: true;
+    migrationsTable: string;
+    /**
+     * by default, all the migrated tables and the special table for tracking migrations are created in `public`.
+     * set this `schema` setting to use create everything in this schema instead.
+     */
+    schema?: QuerySchema;
+    recurrentPath?: string;
+    columnTypes: ColumnTypes;
+    beforeChange?: ChangeCallback$1;
+    afterChange?: ChangeCallback$1;
+    beforeMigrate?: MigrationCallback;
+    afterMigrate?: MigrationCallback;
+    beforeRollback?: MigrationCallback;
+    afterRollback?: MigrationCallback;
+    migrationId: RakeDbMigrationId;
+    forceDefaultExports?: boolean;
+    afterChangeCommit?: ChangeCommitCallback;
+    basePath: string;
+    import(path: string): Promise<unknown>;
+    migrationsPath: string;
+    transaction: 'single' | 'per-migration';
+    snakeCase?: boolean;
+    schemaConfig: ColumnSchemaConfig;
+    migrations?: ModuleExportsRecord;
+    dbScript: string;
+    renameMigrations?: RakeDbRenameMigrationsInput;
+    language?: string;
+    noPrimaryKey?: NoPrimaryKeyOption;
+    baseTable?: RakeDbBaseTable<unknown>;
+    commands: RakeDbCommands;
+}
+declare const migrationConfigDefaults: {
+    schemaConfig: DefaultSchemaConfig;
+    migrationsPath: string;
+    migrationId: {
+        serial: number;
+    };
+    migrationsTable: string;
+    snakeCase: boolean;
+    commands: {};
+    log: boolean;
+    logger: Console;
+    import(): never;
+};
+interface RakeDbCommandFn {
+    (adapters: AdapterBase[], config: RakeDbConfig, args: string[]): MaybePromise<unknown>;
+}
+interface RakeDbCommand {
+    run: RakeDbCommandFn;
+    help?: string;
+    helpArguments?: RecordString;
+    helpAfter?: string;
+}
+interface RakeDbCommands {
+    [K: string]: RakeDbCommand;
+}
+interface ChangeCallback$1 {
+    (arg: {
+        db: DbResult<unknown>;
+        up: boolean;
+        redo: boolean;
+        migrations: MigrationItem[];
+    }): void | Promise<void>;
+}
+interface ChangeCommitCallback {
+    (arg: {
+        adapter: AdapterBase;
+        up: boolean;
+        migrations: MigrationItem[];
+    }): void | Promise<void>;
+}
+interface MigrationCallback {
+    (arg: {
+        db: DbResult<unknown>;
+        migrations: MigrationItem[];
+    }): void | Promise<void>;
+}
+interface RakeDbBaseTable<CT> {
+    exportAs: string;
+    getFilePath(): string;
+    nowSQL?: string;
+    new (): {
+        types: CT;
+        snakeCase?: boolean;
+        language?: string;
     };
 }
-interface RakeDbResult {
-    adapters: AdapterBase[];
-    config: AnyRakeDbConfig;
-    args: string[];
+interface ModuleExportsRecord {
+    [fileName: string]: () => Promise<unknown>;
+}
+type RakeDbMigrationId = 'timestamp' | {
+    serial: number;
+};
+interface RakeDbRenameMigrationsMap {
+    [K: string]: number;
+}
+interface RakeDbRenameMigrations {
+    to: RakeDbMigrationId;
+    map(): MaybePromise<RakeDbRenameMigrationsMap>;
+}
+interface RakeDbRenameMigrationsInput {
+    to: RakeDbMigrationId;
+    map: RakeDbRenameMigrationsMap;
 }
+declare const incrementIntermediateCaller: () => void;
+declare const makeRakeDbConfig: <ColumnTypes>(config: RakeDbCliConfigInput<ColumnSchemaConfig, ColumnTypes>, args?: string[]) => RakeDbConfig<ColumnTypes>;
+
 /**
  * Function to use in migrations to wrap database changes
  * Saves the given callback to an internal queue,
@@ -1489,18 +1461,23 @@ interface RakeDbResult {
 interface RakeDbChangeFn<CT> {
     (fn: ChangeCallback<CT>): MigrationChange;
 }
-interface RakeDbChangeFnWithPromise<CT> extends RakeDbChangeFn<CT> {
-    promise: Promise<RakeDbResult>;
+interface MigrationChange {
+    fn: ChangeCallback<unknown>;
+    config: RakeDbConfig;
 }
-/**
- * Function to configure and run `rakeDb`.
- *
- * @param options - {@link NodePostgresAdapterOptions} or an array of such options to migrate multiple dbs
- * @param config - {@link RakeDbConfig}
- * @param args - optionally provide an array of cli args. Default is `process.argv.slice(2)`.
- */
-declare const rakeDbWithAdapters: RakeDbFn<AdapterBase[]>;
-declare const makeChange: (config: RakeDbConfig<ColumnSchemaConfig, unknown>) => (fn: ChangeCallback<unknown>) => MigrationChange;
+type ChangeCallback<CT> = (db: DbMigration<CT>, up: boolean) => Promise<void>;
+
+interface RakeDbCliResult<ColumnTypes, Options> {
+    change: RakeDbChangeFn<ColumnTypes>;
+    run(options: Options, args?: string[]): Promise<void>;
+}
+interface RakeDbFn<Options> {
+    <SchemaConfig extends ColumnSchemaConfig, ColumnTypes = DefaultColumnTypes<DefaultSchemaConfig>>(config: RakeDbCliConfigInput<SchemaConfig, ColumnTypes> | RakeDbConfig<ColumnTypes>, args?: string[]): RakeDbCliResult<ColumnTypes, Options>;
+    run<SchemaConfig extends ColumnSchemaConfig, ColumnTypes = DefaultColumnTypes<DefaultSchemaConfig>>(options: Options, config: RakeDbCliConfigInput<SchemaConfig, ColumnTypes> | RakeDbConfig<ColumnTypes>, args?: string[]): RakeDbChangeFn<ColumnTypes>;
+}
+declare const rakeDbCliWithAdapter: RakeDbFn<MaybeArray<AdapterBase>>;
+declare const setRakeDbCliRunFn: <T>(rakeDbCli: RakeDbFn<T>, mapper: (options: T) => unknown) => void;
+declare const rakeDbCommands: RakeDbCommands;
 
 declare const encodeColumnDefault: (def: unknown, values: unknown[], column?: Column.Pick.Data) => string | null;
 declare const getConstraintName: (table: string, constraint: {
@@ -1519,7 +1496,10 @@ interface GetIndexOrExcludeName {
 }
 declare const getIndexName: GetIndexOrExcludeName;
 declare const getExcludeName: GetIndexOrExcludeName;
-declare const getMigrationsSchemaAndTable: (config: PickMigrationsTable) => {
+declare const getMigrationsSchemaAndTable: (config: {
+    schema?: QuerySchema;
+    migrationsTable: string;
+}) => {
     schema?: string;
     table: string;
 };
@@ -1531,18 +1511,22 @@ declare const promptSelect: ({ message, options, active, inactive, }: {
     inactive?: (s: string) => string;
 }) => Promise<number>;
 
-declare const saveMigratedVersion: (db: SilentQueries, version: string, name: string, config: PickMigrationsTable) => Promise<void>;
+declare const saveMigratedVersion: (db: SilentQueries, version: string, name: string, config: Pick<RakeDbConfig, 'migrationsTable'>) => Promise<void>;
 
-interface MigrateFnConfig extends MigrateOrRollbackConfig, PickAfterChangeCommit, PickBasePath, PickImport, PickMigrationsPath, PickTransactionSetting {
+interface OrmParam {
+    $qb: Query;
+    $adapter: AdapterBase;
 }
+type DbParam = OrmParam | AdapterBase;
+
 interface MigrateFnParams {
     ctx?: RakeDbCtx;
-    adapter: AdapterBase;
-    config: MigrateFnConfig;
     count?: number;
     force?: boolean;
 }
-type MigrateFn = (params: MigrateFnParams) => Promise<void>;
+interface MigrateFn {
+    (db: DbParam, config: RakeDbConfig, params?: MigrateFnParams): Promise<void>;
+}
 /**
  * Will run all pending yet migrations, sequentially in order,
  * will apply `change` functions top-to-bottom.
@@ -1553,9 +1537,20 @@ type MigrateFn = (params: MigrateFnParams) => Promise<void>;
  */
 declare const migrate: MigrateFn;
 declare const migrateAndClose: MigrateFn;
-interface MigrateOrRollbackConfig extends PickMigrationCallbacks, PickMigrationId, QueryLogOptions, PickForceDefaultExports, PickMigrationsTable, PickTransactionSetting {
-    columnTypes: unknown;
-}
+declare const runMigration: (db: DbParam, migration: () => MaybePromise<unknown>) => Promise<void>;
+/**
+ * Will roll back one latest applied migration,
+ * will apply `change` functions bottom-to-top.
+ *
+ * Takes the same options as {@link migrate}.
+ */
+declare const rollback: MigrateFn;
+/**
+ * Calls {@link rollback} and then {@link migrate}.
+ *
+ * Takes the same options as {@link migrate}.
+ */
+declare const redo: MigrateFn;
 
 declare namespace DbStructure {
     interface TableNameAndSchemaName {
@@ -1721,7 +1716,7 @@ interface IntrospectedStructure {
 }
 declare function introspectDbSchema(db: AdapterBase): Promise<IntrospectedStructure>;
 
-declare const astToMigration: (currentSchema: string, config: AnyRakeDbConfig, asts: RakeDbAst[]) => string | undefined;
+declare const astToMigration: (currentSchema: string, config: RakeDbConfig, asts: RakeDbAst[]) => string | undefined;
 
 interface StructureToAstCtx {
     snakeCase?: boolean;
@@ -1736,8 +1731,8 @@ interface StructureToAstTableData {
     excludes: DbStructure.Exclude[];
     constraints: DbStructure.Constraint[];
 }
-declare const makeStructureToAstCtx: (config: AnyRakeDbConfig, currentSchema: string) => StructureToAstCtx;
-declare const structureToAst: (ctx: StructureToAstCtx, adapter: AdapterBase, config: AnyRakeDbConfig) => Promise<RakeDbAst[]>;
+declare const makeStructureToAstCtx: (config: Pick<RakeDbConfig, 'snakeCase' | 'schemaConfig'>, currentSchema: string) => StructureToAstCtx;
+declare const structureToAst: (ctx: StructureToAstCtx, adapter: AdapterBase, config: Pick<RakeDbConfig, 'schema' | 'migrationsTable'>) => Promise<RakeDbAst[]>;
 declare const makeDomainsMap: (ctx: StructureToAstCtx, data: IntrospectedStructure) => DbStructureDomainsMap;
 declare const instantiateDbColumn: (ctx: StructureToAstCtx, data: IntrospectedStructure, domains: DbStructureDomainsMap, dbColumn: DbStructure.Column) => Column<pqb.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any>;
 declare const tableToAst: (ctx: StructureToAstCtx, data: IntrospectedStructure, table: DbStructure.Table, action: 'create' | 'drop', domains: DbStructureDomainsMap) => RakeDbAst.Table;
@@ -1748,32 +1743,10 @@ interface ColumnChecks {
 declare const getDbTableColumnsChecks: (tableData: StructureToAstTableData) => ColumnChecks;
 declare const dbColumnToAst: (ctx: StructureToAstCtx, data: IntrospectedStructure, domains: DbStructureDomainsMap, tableName: string, item: DbStructure.Column, table?: DbStructure.Table, tableData?: StructureToAstTableData, checks?: ColumnChecks) => [key: string, column: Column];
 
-declare const writeMigrationFile: (config: AnyRakeDbConfig, version: string, name: string, migrationCode: string) => Promise<void>;
-declare const makeFileVersion: (ctx: RakeDbCtx, config: AnyRakeDbConfig) => Promise<string>;
-
-interface OrmParam {
-    $qb: Query;
-}
-type UnknownPromiseFns = (() => Promise<unknown>)[];
-declare const migrateFiles: (db: OrmParam, files: UnknownPromiseFns) => Promise<void>;
-declare const makeMigrateAdapter: (config?: Partial<MigrateFnConfig>) => ((adapter: AdapterBase, params?: {
-    count?: number;
-    force?: boolean;
-}) => Promise<void>);
+declare const writeMigrationFile: (config: Pick<RakeDbConfig, 'migrationsPath' | 'basePath' | 'dbScript' | 'logger'>, version: string, name: string, migrationCode: string) => Promise<void>;
+declare const makeFileVersion: (ctx: RakeDbCtx, config: Pick<RakeDbConfig, 'migrationId' | 'renameMigrations' | 'migrations' | 'basePath' | 'import' | 'migrationsPath'>) => Promise<string>;
 
 declare class RakeDbError extends Error {
 }
 
-declare const runCommand: <SchemaConfig extends ColumnSchemaConfig<pqb.Column.Pick.Data>, CT>(adapters: AdapterBase[], config: RakeDbConfig<SchemaConfig, CT>, args?: string[]) => Promise<RakeDbResult>;
-interface RakeDbCommand {
-    run(adapters: AdapterBase[], config: AnyRakeDbConfig, args: string[]): MaybePromise<unknown>;
-    help: string;
-    helpArguments?: RecordString;
-    helpAfter?: string;
-}
-interface RakeDbCommands {
-    [K: string]: RakeDbCommand;
-}
-declare const rakeDbCommands: RakeDbCommands;
-
-export { type AnyRakeDbConfig, type ChangeCallback, type DbMigration, DbStructure, type InputRakeDbConfig, type InputRakeDbConfigBase, type IntrospectedStructure, type MigrateFnConfig, RakeDbAst, type RakeDbChangeFn, type RakeDbChangeFnWithPromise, type RakeDbConfig, RakeDbError, type RakeDbFn, type SilentQueries, type StructureToAstCtx, type StructureToAstTableData, astToMigration, concatSchemaAndName, createMigrationInterface, dbColumnToAst, encodeColumnDefault, getConstraintName, getDbStructureTableData, getDbTableColumnsChecks, getExcludeName, getIndexName, getMigrationsSchemaAndTable, getSchemaAndTableFromName, instantiateDbColumn, introspectDbSchema, makeChange, makeDomainsMap, makeFileVersion, makeMigrateAdapter, makeStructureToAstCtx, migrate, migrateAndClose, migrateFiles, migrationConfigDefaults, processRakeDbConfig, promptSelect, rakeDbCommands, rakeDbWithAdapters, runCommand, saveMigratedVersion, structureToAst, tableToAst, writeMigrationFile };
+export { type ChangeCallback, type DbMigration, DbStructure, type IntrospectedStructure, RakeDbAst, type RakeDbChangeFn, type RakeDbCliConfigInput, type RakeDbConfig, RakeDbError, type RakeDbFn, type SilentQueries, type StructureToAstCtx, type StructureToAstTableData, astToMigration, concatSchemaAndName, createMigrationInterface, dbColumnToAst, encodeColumnDefault, getConstraintName, getDbStructureTableData, getDbTableColumnsChecks, getExcludeName, getIndexName, getMigrationsSchemaAndTable, getSchemaAndTableFromName, incrementIntermediateCaller, instantiateDbColumn, introspectDbSchema, makeDomainsMap, makeFileVersion, makeRakeDbConfig, makeStructureToAstCtx, migrate, migrateAndClose, migrationConfigDefaults, promptSelect, rakeDbCliWithAdapter, rakeDbCommands, redo, rollback, runMigration, saveMigratedVersion, setRakeDbCliRunFn, structureToAst, tableToAst, writeMigrationFile };