rake-db 2.25.17 → 2.27.2

package/dist/index.d.ts

@@ -1,7 +1,11 @@
 import * as orchid_core from 'orchid-core';
-import { MaybeArray, RawSQLBase, ColumnDataCheckBase, RecordString, ColumnTypeBase, EmptyObject, ColumnSchemaConfig, QueryLogObject, QueryLogOptions, MaybePromise, RecordOptionalString, ForeignKeyTable, SingleSql } from 'orchid-core';
+import { MaybeArray, RawSQLBase, ColumnDataCheckBase, RecordString, ColumnTypeBase, EmptyObject, ColumnSchemaConfig, QueryLogOptions, AdapterBase, MaybePromise, QueryLogObject, QueryBase } from 'orchid-core';
 import * as pqb from 'pqb';
-import { TableData, ColumnsShape, NoPrimaryKeyOption, ColumnType, EnumColumn, raw, Adapter, DbResult, TransactionAdapter, TableDataFn, TableDataItem, DbDomainArg, Db, QueryArraysResult, AdapterOptions, DefaultColumnTypes, DefaultSchemaConfig, SearchWeight, ColumnsByType, DbStructureDomainsMap } from 'pqb';
+import { ColumnsShape, Db, TableData, NoPrimaryKeyOption, ColumnType, EnumColumn, DefaultColumnTypes, DefaultSchemaConfig, DbResult, TableDataFn, TableDataItem, DbDomainArg, raw, SearchWeight, ColumnsByType, DbStructureDomainsMap } from 'pqb';
+
+interface CreateTableResult<Table extends string, Shape extends ColumnsShape> {
+    table: Db<Table, Shape>;
+}
 
 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 {
@@ -266,6 +270,228 @@ declare const tableChangeMethods: {
 type TableChanger<CT> = MigrationColumnTypes<CT> & TableChangeMethods;
 type TableChangeData = Record<string, RakeDbAst.ChangeTableItem.Column | RakeDbAst.ChangeTableItem.Rename | Change | SpecialChange | ColumnTypeBase>;
 
+interface RakeDbCtx {
+    migrationsPromise?: Promise<MigrationsSet>;
+}
+declare const getSchemaAndTableFromName: (name: string) => [string | undefined, string];
+declare const concatSchemaAndName: ({ schema, name, }: {
+    schema?: string;
+    name: 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 {
+    migrationsTable: string;
+}
+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 {
+    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 {
+    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>;
+
 type DropMode = 'CASCADE' | 'RESTRICT';
 type TableOptions = {
     createIfNotExists?: boolean;
@@ -288,17 +514,16 @@ type ChangeTableOptions = {
     comment?: string | [string, string] | null;
 };
 type ChangeTableCallback<CT> = (t: TableChanger<CT>) => TableChangeData;
-type ColumnComment = {
-    column: string;
-    comment: string | null;
-};
 type SilentQueries = {
-    silentQuery: Adapter['query'];
-    silentArrays: Adapter['arrays'];
+    silentQuery: AdapterBase['query'];
+    silentArrays: AdapterBase['arrays'];
 };
 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.
@@ -307,8 +532,8 @@ type DbMigration<CT> = DbResult<CT> & Migration<CT> & {
  * @param up - migrate or rollback
  * @param config - config of `rakeDb`
  */
-declare const createMigrationInterface: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(tx: TransactionAdapter, up: boolean, config: RakeDbConfig<SchemaConfig, CT>) => DbMigration<CT>;
-interface MigrationAdapter extends TransactionAdapter {
+declare const createMigrationInterface: <CT>(tx: AdapterBase, up: boolean, config: CreateMigrationInterfaceConfig<CT>) => DbMigration<CT>;
+interface MigrationAdapter extends AdapterBase {
     schema: string;
 }
 declare class Migration<CT> {
@@ -1214,281 +1439,107 @@ declare class Migration<CT> {
      */
     constraintExists(constraintName: string): Promise<boolean>;
 }
-declare const renameType: (migration: Migration<unknown>, from: string, to: string, kind: RakeDbAst.RenameType['kind']) => Promise<void>;
 interface AddEnumValueOptions {
     ifNotExists?: boolean;
     before?: string;
     after?: string;
 }
-declare const addOrDropEnumValues: (migration: Migration<unknown>, up: boolean, enumName: string, values: string[], options?: AddEnumValueOptions) => Promise<void>;
-declare const changeEnumValues: (migration: Migration<unknown>, enumName: string, fromValues: string[], toValues: string[]) => Promise<void>;
 
-interface TableQuery {
-    text: string;
-    values?: unknown[];
-    then?(result: QueryArraysResult): void;
-}
-interface CreateTableResult<Table extends string, Shape extends ColumnsShape> {
-    table: Db<Table, Shape>;
+interface MigrationChange {
+    fn: ChangeCallback<unknown>;
+    config: RakeDbConfig<ColumnSchemaConfig, unknown>;
 }
+type ChangeCallback<CT> = (db: DbMigration<CT>, up: boolean) => Promise<void>;
 
-interface RakeDbCtx {
-    migrationsPromise?: Promise<MigrationsSet>;
-}
-declare const getFirstWordAndRest: (input: string) => [
-    string
-] | [
-    string,
-    string
-];
-declare const getTextAfterTo: (input: string) => string | undefined;
-declare const getTextAfterFrom: (input: string) => string | undefined;
-declare const joinWords: (...words: string[]) => string;
-declare const joinColumns: (columns: string[]) => string;
-declare const quoteWithSchema: ({ schema, name, }: {
-    schema?: string;
-    name: string;
-}) => string;
-declare const quoteTable: (schema: string | undefined, table: string) => string;
-declare const getSchemaAndTableFromName: (name: string) => [string | undefined, string];
-declare const quoteNameFromString: (string: string) => string;
 /**
- * Do not quote the type itself because it can be an expression like `geography(point)` for postgis.
+ * Type of {@link rakeDbWithAdapters} function
  */
-declare const quoteCustomType: (s: string) => string;
-declare const quoteSchemaTable: (arg: {
-    schema?: string;
-    name: string;
-}) => string;
-declare const concatSchemaAndName: ({ schema, name, }: {
-    schema?: string;
-    name: string;
-}) => string;
-declare const makePopulateEnumQuery: (item: EnumColumn<ColumnSchemaConfig, unknown, readonly string[]>) => TableQuery;
-declare const transaction: <T>(adapter: Adapter, fn: (trx: TransactionAdapter) => Promise<T>) => Promise<T>;
-declare const queryLock: (trx: TransactionAdapter) => Promise<pqb.QueryResult<any>>;
-declare const exhaustive: (_: never) => never;
-declare const pluralize: (w: string, count: number, append?: string) => string;
-
-interface MigrationItem {
-    path: string;
-    version: string;
+interface RakeDbFn<Options> {
+    <SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>>(options: Options, partialConfig: InputRakeDbConfig<SchemaConfig, CT>, args?: string[]): RakeDbChangeFnWithPromise<CT>;
     /**
-     * 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.
+     * Unlike the original `rakeDb` that executes immediately,
+     * `rakeDb.lazy` returns the `run` function to be later called programmatically.
+     *
+     * @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
      */
-    load(): Promise<unknown>;
+    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>;
+    };
 }
-interface MigrationsSet {
-    renameTo?: RakeDbRenameMigrations;
-    migrations: MigrationItem[];
+interface RakeDbResult {
+    adapters: AdapterBase[];
+    config: AnyRakeDbConfig;
+    args: string[];
 }
-
-interface CommandFn<SchemaConfig extends ColumnSchemaConfig, CT> {
-    (options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>, args: string[]): void | Promise<void>;
+/**
+ * Function to use in migrations to wrap database changes
+ * Saves the given callback to an internal queue,
+ * and also returns the callback in case you want to export it from migration.
+ */
+interface RakeDbChangeFn<CT> {
+    (fn: ChangeCallback<CT>): MigrationChange;
 }
-interface RakeDbBaseConfig<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>> extends QueryLogOptions {
-    schemaConfig: SchemaConfig;
-    migrationsPath: string;
-    migrationId: RakeDbMigrationId;
-    migrations?: ModuleExportsRecord;
-    renameMigrations?: RakeDbRenameMigrationsInput;
-    migrationsTable: string;
-    snakeCase: boolean;
-    language?: string;
-    commands: Record<string, CommandFn<SchemaConfig, CT>>;
-    noPrimaryKey?: NoPrimaryKeyOption;
-    baseTable?: RakeDbBaseTable<CT>;
-    forceDefaultExports?: boolean;
-    import(path: string): Promise<unknown>;
-    beforeChange?: ChangeCallback$1;
-    afterChange?: ChangeCallback$1;
-    afterChangeCommit?: ChangeCommitCallback;
-    beforeMigrate?: MigrationCallback;
-    afterMigrate?: MigrationCallback;
-    beforeRollback?: MigrationCallback;
-    afterRollback?: MigrationCallback;
-}
-interface RakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>> extends RakeDbBaseConfig<SchemaConfig, CT> {
-    columnTypes: CT;
-    basePath: string;
-    dbScript: string;
-    recurrentPath: string;
-}
-interface InputRakeDbConfigBase<SchemaConfig extends ColumnSchemaConfig, CT> extends QueryLogOptions {
-    columnTypes?: CT | ((t: DefaultColumnTypes<DefaultSchemaConfig>) => CT);
-    baseTable?: RakeDbBaseTable<CT>;
-    schemaConfig?: SchemaConfig;
-    basePath?: string;
-    dbScript?: string;
-    migrationsPath?: string;
-    migrationId?: 'serial' | RakeDbMigrationId;
-    recurrentPath?: string;
-    migrationsTable?: string;
-    snakeCase?: boolean;
-    language?: string;
-    commands?: Record<string, (options: AdapterOptions[], 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 RakeDbChangeFnWithPromise<CT> extends RakeDbChangeFn<CT> {
+    promise: Promise<RakeDbResult>;
 }
-interface ChangeCommitCallback {
-    (arg: {
-        options: AdapterOptions;
-        up: boolean;
-        migrations: MigrationItem[];
-    }): void | Promise<void>;
+/**
+ * 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[]>;
+interface RakeDbCommand {
+    run(adapters: AdapterBase[], config: AnyRakeDbConfig, args: string[]): MaybePromise<unknown>;
+    help: string;
+    helpArguments?: RecordString;
+    helpAfter?: string;
 }
-interface MigrationCallback {
-    (arg: {
-        db: DbResult<unknown>;
-        migrations: MigrationItem[];
-    }): void | Promise<void>;
+interface RakeDbCommands {
+    [K: string]: RakeDbCommand;
 }
-type AnyRakeDbConfig = RakeDbConfig<any, any>;
-interface RakeDbBaseTable<CT> {
-    exportAs: string;
-    getFilePath(): string;
-    nowSQL?: string;
-    new (): {
-        types: CT;
-        snakeCase?: boolean;
-        language?: string;
+declare const rakeDbCommands: RakeDbCommands;
+
+declare const encodeColumnDefault: (def: unknown, values: unknown[], column?: ColumnTypeBase) => string | null;
+declare const getConstraintName: (table: string, constraint: {
+    references?: {
+        columns: string[];
     };
+    check?: unknown;
+    identity?: unknown;
+}, snakeCase: boolean | undefined) => string;
+interface GetIndexOrExcludeName {
+    (table: string, columns: ({
+        column?: string;
+    } | {
+        expression: string;
+    })[]): 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<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, any, 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, any, 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, any, 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, any, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
+declare const getIndexName: GetIndexOrExcludeName;
+declare const getExcludeName: GetIndexOrExcludeName;
 
-declare const writeMigrationFile: (config: AnyRakeDbConfig, version: string, name: string, migrationCode: string) => Promise<void>;
-declare const newMigration: (config: AnyRakeDbConfig, [name]: string[]) => Promise<void>;
-declare const makeFileVersion: (ctx: RakeDbCtx, config: AnyRakeDbConfig) => Promise<string>;
-declare const generateTimeStamp: () => string;
+declare const promptSelect: ({ message, options, active, inactive, }: {
+    message: string;
+    options: string[];
+    active?: (s: string) => string;
+    inactive?: (s: string) => string;
+}) => Promise<number>;
 
-type ChangeCallback<CT> = (db: DbMigration<CT>, up: boolean) => Promise<void>;
-declare const clearChanges: () => void;
-declare const getCurrentChanges: () => ChangeCallback<unknown>[];
-declare const pushChange: (fn: ChangeCallback<unknown>) => number;
+declare const saveMigratedVersion: (db: SilentQueries, version: string, name: string, config: PickMigrationsTable) => Promise<void>;
 
-declare const saveMigratedVersion: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, any, 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, any, 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 {
+interface MigrateFnConfig extends MigrateOrRollbackConfig, PickAfterChangeCommit, PickBasePath, PickImport, PickMigrationsPath {
 }
-type RakeDbAppliedVersions = {
-    map: RecordOptionalString;
-    sequence: number[];
-};
-declare const getMigratedVersionsMap: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(ctx: RakeDbCtx, adapter: Adapter | TransactionAdapter, config: RakeDbConfig<SchemaConfig, CT>, renameTo?: RakeDbRenameMigrations) => Promise<RakeDbAppliedVersions>;
-
-declare const RAKE_DB_LOCK_KEY = "8582141715823621641";
-type MigrateFn = <SchemaConfig extends ColumnSchemaConfig, CT>(ctx: RakeDbCtx, options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>, args?: string[], adapters?: Adapter[], dontClose?: boolean) => Promise<Adapter[]>;
+type MigrateFn = (params: {
+    ctx?: RakeDbCtx;
+    adapter: AdapterBase;
+    config: MigrateFnConfig;
+    count?: number;
+    force?: boolean;
+}) => Promise<void>;
 /**
  * Will run all pending yet migrations, sequentially in order,
  * will apply `change` functions top-to-bottom.
@@ -1498,21 +1549,10 @@ type MigrateFn = <SchemaConfig extends ColumnSchemaConfig, CT>(ctx: RakeDbCtx, o
  * @param args - pass none or `all` to run all migrations, pass int for how many to migrate
  */
 declare const migrate: MigrateFn;
-/**
- * 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 const migrateOrRollback: (trx: TransactionAdapter, config: RakeDbConfig<ColumnSchemaConfig, unknown>, set: MigrationsSet, versions: RakeDbAppliedVersions, count: number, up: boolean, redo: boolean, force?: boolean, skipLock?: boolean) => Promise<MigrationItem[]>;
-declare const changeCache: Record<string, ChangeCallback<unknown>[] | undefined>;
+declare const migrateAndClose: MigrateFn;
+interface MigrateOrRollbackConfig extends PickMigrationCallbacks, PickMigrationId, QueryLogOptions, PickForceDefaultExports, PickMigrationsTable {
+    columnTypes: unknown;
+}
 
 declare namespace DbStructure {
     interface TableNameAndSchemaName {
@@ -1676,7 +1716,9 @@ interface IntrospectedStructure {
     domains: DbStructure.Domain[];
     collations: DbStructure.Collation[];
 }
-declare function introspectDbSchema(db: Adapter): Promise<IntrospectedStructure>;
+declare function introspectDbSchema(db: AdapterBase): Promise<IntrospectedStructure>;
+
+declare const astToMigration: (currentSchema: string, config: AnyRakeDbConfig, asts: RakeDbAst[]) => string | undefined;
 
 interface StructureToAstCtx {
     snakeCase?: boolean;
@@ -1692,156 +1734,24 @@ interface StructureToAstTableData {
     constraints: DbStructure.Constraint[];
 }
 declare const makeStructureToAstCtx: (config: AnyRakeDbConfig, currentSchema: string) => StructureToAstCtx;
-declare const structureToAst: (ctx: StructureToAstCtx, adapter: Adapter, config: AnyRakeDbConfig) => Promise<RakeDbAst[]>;
+declare const structureToAst: (ctx: StructureToAstCtx, adapter: AdapterBase, config: AnyRakeDbConfig) => Promise<RakeDbAst[]>;
 declare const makeDomainsMap: (ctx: StructureToAstCtx, data: IntrospectedStructure) => DbStructureDomainsMap;
 declare const instantiateDbColumn: (ctx: StructureToAstCtx, data: IntrospectedStructure, domains: DbStructureDomainsMap, dbColumn: DbStructure.Column) => ColumnType<orchid_core.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;
 declare const getDbStructureTableData: (data: IntrospectedStructure, { name, schemaName }: DbStructure.Table) => StructureToAstTableData;
-declare const makeDbStructureColumnsShape: (ctx: StructureToAstCtx, data: IntrospectedStructure, domains: DbStructureDomainsMap, table: DbStructure.Table | DbStructure.View, tableData?: StructureToAstTableData) => ColumnsShape;
 interface ColumnChecks {
     [K: string]: string[];
 }
 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: ColumnType];
 
-declare const astToMigration: (currentSchema: string, config: AnyRakeDbConfig, asts: RakeDbAst[]) => string | undefined;
-
-declare const versionToString: (config: AnyRakeDbConfig, version: number) => string;
-declare const columnTypeToSql: (item: ColumnTypeBase) => string;
-declare const getColumnName: (item: {
-    data: {
-        name?: string;
-    };
-}, key: string, snakeCase: boolean | undefined) => string;
-declare const columnToSql: (name: string, item: ColumnType, values: unknown[], hasMultiplePrimaryKeys: boolean, snakeCase: boolean | undefined) => string;
-declare const encodeColumnDefault: (def: unknown, values: unknown[], column?: ColumnTypeBase) => string | null;
-declare const identityToSql: (identity: TableData.Identity) => string;
-declare const addColumnIndex: (indexes: TableData.Index[], name: string, item: ColumnType) => void;
-declare const addColumnExclude: (excludes: TableData.Exclude[], name: string, item: ColumnType) => void;
-declare const addColumnComment: (comments: ColumnComment[], name: string, item: ColumnType) => void;
-declare const getForeignKeyTable: (fnOrTable: (() => ForeignKeyTable) | string) => [string | undefined, string];
-declare const getConstraintName: (table: string, constraint: {
-    references?: {
-        columns: string[];
-    };
-    check?: unknown;
-    identity?: unknown;
-}, snakeCase: boolean | undefined) => string;
-declare const constraintToSql: ({ name }: {
-    schema?: string;
-    name: string;
-}, up: boolean, constraint: TableData.Constraint, values: unknown[], snakeCase: boolean | undefined) => string;
-declare const referencesToSql: (references: TableData.References, snakeCase: boolean | undefined) => string;
-interface GetIndexOrExcludeName {
-    (table: string, columns: ({
-        column?: string;
-    } | {
-        expression: string;
-    })[]): string;
-}
-declare const getIndexName: GetIndexOrExcludeName;
-declare const getExcludeName: GetIndexOrExcludeName;
-declare const indexesToQuery: (up: boolean, { schema, name: tableName }: {
-    schema?: string;
-    name: string;
-}, indexes: TableData.Index[], snakeCase: boolean | undefined, language?: string) => SingleSql[];
-declare const excludesToQuery: (up: boolean, { schema, name: tableName }: {
-    schema?: string;
-    name: string;
-}, excludes: TableData.Exclude[], snakeCase: boolean | undefined) => SingleSql[];
-declare const commentsToQuery: (schemaTable: {
-    schema?: string;
-    name: string;
-}, comments: ColumnComment[]) => SingleSql[];
-declare const primaryKeyToSql: (primaryKey: Exclude<TableData['primaryKey'], undefined>) => string;
-declare const interpolateSqlValues: ({ text, values }: TableQuery) => string;
-interface ColumnNamedCheck extends ColumnDataCheckBase {
-    name: string;
-}
-declare const nameColumnChecks: (table: string, column: string, checks: ColumnDataCheckBase[]) => ColumnNamedCheck[];
-declare const cmpRawSql: (a: RawSQLBase, b: RawSQLBase) => boolean;
+declare const writeMigrationFile: (config: AnyRakeDbConfig, version: string, name: string, migrationCode: string) => Promise<void>;
+declare const makeFileVersion: (ctx: RakeDbCtx, config: AnyRakeDbConfig) => Promise<string>;
 
-/**
- * Type of {@link rakeDb} function
- */
-interface RakeDbFn {
-    <SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>>(options: MaybeArray<AdapterOptions>, partialConfig: InputRakeDbConfig<SchemaConfig, CT>, args?: string[]): RakeDbChangeFnWithPromise<CT>;
-    /**
-     * Unlike the original `rakeDb` that executes immediately,
-     * `rakeDb.lazy` returns the `run` function to be later called programmatically.
-     *
-     * @param options - {@link AdapterOptions} or an array of such options to migrate multiple dbs
-     * @param config - {@link RakeDbConfig}
-     * @returns `change` is to be used in migrations, `run` takes an array cli args to execute a command
-     */
-    lazy<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>>(options: MaybeArray<AdapterOptions>, config: InputRakeDbConfig<SchemaConfig, CT>): {
-        change: RakeDbChangeFn<CT>;
-        run(args: string[], config?: Partial<RakeDbConfig<SchemaConfig, CT>>): Promise<RakeDbResult>;
-    };
-}
-interface RakeDbResult {
-    options: AdapterOptions[];
-    config: AnyRakeDbConfig;
-    args: string[];
-}
-/**
- * Function to use in migrations to wrap database changes
- * Saves the given callback to an internal queue,
- * and also returns the callback in case you want to export it from migration.
- */
-interface RakeDbChangeFn<CT> {
-    (fn: ChangeCallback<CT>): ChangeCallback<CT>;
+interface OrmParam {
+    $qb: QueryBase;
 }
-interface RakeDbChangeFnWithPromise<CT> extends RakeDbChangeFn<CT> {
-    promise: Promise<RakeDbResult>;
-}
-/**
- * Function to configure and run `rakeDb`.
- *
- * @param options - {@link AdapterOptions} 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 rakeDb: RakeDbFn;
-declare const rakeDbAliases: RecordOptionalString;
-interface RakeDbCommand {
-    run(options: AdapterOptions[], config: AnyRakeDbConfig, args: string[]): MaybePromise<unknown>;
-    help: string;
-    helpArguments?: RecordString;
-    helpAfter?: string;
-}
-interface RakeDbCommands {
-    [K: string]: RakeDbCommand;
-}
-declare const rakeDbCommands: RakeDbCommands;
-
-declare const colors: {
-    yellow: (s: string) => string;
-    green: (s: string) => string;
-    red: (s: string) => string;
-    blue: (s: string) => string;
-    bright: (s: string) => string;
-    blueBold: (s: string) => string;
-    yellowBold: (s: string) => string;
-    greenBold: (s: string) => string;
-    pale: (s: string) => string;
-};
-
-declare const promptSelect: ({ message, options, active, inactive, }: {
-    message: string;
-    options: string[];
-    active?: (s: string) => string;
-    inactive?: (s: string) => string;
-}) => Promise<number>;
-declare const promptConfirm: ({ message, }: {
-    message: string;
-    password?: boolean;
-}) => Promise<boolean>;
-declare const promptText: ({ message, default: def, password, min, }: {
-    message: string;
-    default?: string;
-    password?: boolean;
-    min?: number;
-}) => Promise<string>;
+type UnknownPromiseFns = (() => Promise<unknown>)[];
+declare const migrateFiles: (db: OrmParam, files: UnknownPromiseFns) => Promise<void>;
 
-export { type AnyRakeDbConfig, type ChangeCallback, type ChangeTableCallback, type ChangeTableOptions, type ColumnChecks, type ColumnComment, type ColumnNamedCheck, type ColumnsShapeCallback, type CommandFn, type DbMigration, DbStructure, type DropMode, type GetIndexOrExcludeName, type InputRakeDbConfig, type InputRakeDbConfigBase, type IntrospectedStructure, Migration, type MigrationAdapter, type MigrationColumnTypes, type ModuleExportsRecord, NoMigrationsTableError, RAKE_DB_LOCK_KEY, type RakeDbAppliedVersions, RakeDbAst, type RakeDbBaseTable, type RakeDbConfig, type RakeDbCtx, type RakeDbFn, type RakeDbMigrationId, type RakeDbRenameMigrations, type RakeDbRenameMigrationsInput, type RakeDbRenameMigrationsMap, type RakeDbResult, type SilentQueries, type StructureToAstCtx, type StructureToAstTableData, type TableOptions, addColumnComment, addColumnExclude, addColumnIndex, addOrDropEnumValues, astToMigration, changeCache, changeEnumValues, clearChanges, cmpRawSql, colors, columnToSql, columnTypeToSql, commentsToQuery, concatSchemaAndName, constraintToSql, createDb, createMigrationInterface, dbColumnToAst, deleteMigratedVersion, dropDb, encodeColumnDefault, excludesToQuery, exhaustive, generateTimeStamp, getColumnName, getConstraintName, getCurrentChanges, getDatabaseAndUserFromOptions, getDbStructureTableData, getDbTableColumnsChecks, getExcludeName, getFirstWordAndRest, getForeignKeyTable, getIndexName, getMigratedVersionsMap, getSchemaAndTableFromName, getTextAfterFrom, getTextAfterTo, identityToSql, indexesToQuery, instantiateDbColumn, interpolateSqlValues, introspectDbSchema, joinColumns, joinWords, makeDbStructureColumnsShape, makeDomainsMap, makeFileVersion, makePopulateEnumQuery, makeStructureToAstCtx, migrate, migrateOrRollback, migrationConfigDefaults, nameColumnChecks, newMigration, pluralize, primaryKeyToSql, processRakeDbConfig, promptConfirm, promptSelect, promptText, pushChange, queryLock, quoteCustomType, quoteNameFromString, quoteSchemaTable, quoteTable, quoteWithSchema, rakeDb, rakeDbAliases, rakeDbCommands, redo, referencesToSql, renameType, resetDb, rollback, saveMigratedVersion, structureToAst, tableToAst, transaction, versionToString, writeMigrationFile };
+export { type AnyRakeDbConfig, type ChangeCallback, type DbMigration, DbStructure, type InputRakeDbConfigBase, type IntrospectedStructure, RakeDbAst, type RakeDbChangeFn, type RakeDbChangeFnWithPromise, type RakeDbConfig, type SilentQueries, type StructureToAstCtx, type StructureToAstTableData, astToMigration, concatSchemaAndName, createMigrationInterface, dbColumnToAst, encodeColumnDefault, getConstraintName, getDbStructureTableData, getDbTableColumnsChecks, getExcludeName, getIndexName, getSchemaAndTableFromName, instantiateDbColumn, introspectDbSchema, makeDomainsMap, makeFileVersion, makeStructureToAstCtx, migrate, migrateAndClose, migrateFiles, migrationConfigDefaults, promptSelect, rakeDbCommands, rakeDbWithAdapters, saveMigratedVersion, structureToAst, tableToAst, writeMigrationFile };