rake-db 2.25.17 → 2.26.0

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 * 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, AdapterOptions, DbResult, Adapter, TransactionAdapter, TableDataFn, TableDataItem, DbDomainArg, raw, SearchWeight, ColumnsByType, DbStructureDomainsMap } from 'pqb';
+import * as orchid_core from 'orchid-core';
+import { MaybeArray, RawSQLBase, ColumnDataCheckBase, RecordString, ColumnTypeBase, EmptyObject, ColumnSchemaConfig, QueryLogOptions, MaybePromise, QueryLogObject, QueryBase } from 'orchid-core';
+
+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,206 @@ 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> {
+    (options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>, args: string[]): void | Promise<void>;
+}
+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 ChangeCommitCallback {
+    (arg: {
+        options: AdapterOptions;
+        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,10 +492,6 @@ 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'];
@@ -1214,280 +1414,98 @@ 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 rakeDb} 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 {
+    <SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>>(options: MaybeArray<AdapterOptions>, 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 - {@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
      */
-    load(): Promise<unknown>;
-}
-interface MigrationsSet {
-    renameTo?: RakeDbRenameMigrations;
-    migrations: MigrationItem[];
+    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 CommandFn<SchemaConfig extends ColumnSchemaConfig, CT> {
-    (options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>, args: string[]): void | Promise<void>;
+interface RakeDbResult {
+    options: AdapterOptions[];
+    config: AnyRakeDbConfig;
+    args: string[];
 }
-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>;
+/**
+ * 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;
 }
-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 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;
+interface RakeDbCommand {
+    run(options: AdapterOptions[], 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 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 getIndexName: GetIndexOrExcludeName;
+declare const getExcludeName: GetIndexOrExcludeName;
 
-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 promptSelect: ({ message, options, active, inactive, }: {
+    message: string;
+    options: string[];
+    active?: (s: string) => string;
+    inactive?: (s: string) => string;
+}) => Promise<number>;
 
 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 {
-}
-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[]>;
 /**
  * Will run all pending yet migrations, sequentially in order,
@@ -1497,22 +1515,7 @@ type MigrateFn = <SchemaConfig extends ColumnSchemaConfig, CT>(ctx: RakeDbCtx, o
  * @param config - specifies how to load migrations, callbacks, and logger
  * @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 fullMigrate: MigrateFn;
 
 declare namespace DbStructure {
     interface TableNameAndSchemaName {
@@ -1678,6 +1681,8 @@ interface IntrospectedStructure {
 }
 declare function introspectDbSchema(db: Adapter): Promise<IntrospectedStructure>;
 
+declare const astToMigration: (currentSchema: string, config: AnyRakeDbConfig, asts: RakeDbAst[]) => string | undefined;
+
 interface StructureToAstCtx {
     snakeCase?: boolean;
     unsupportedTypes: Record<string, string[]>;
@@ -1697,151 +1702,19 @@ declare const makeDomainsMap: (ctx: StructureToAstCtx, data: IntrospectedStructu
 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[];
+interface OrmParam {
+    $qb: QueryBase;
 }
-/**
- * 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 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, fullMigrate, getConstraintName, getDbStructureTableData, getDbTableColumnsChecks, getExcludeName, getIndexName, getSchemaAndTableFromName, instantiateDbColumn, introspectDbSchema, makeDomainsMap, makeFileVersion, makeStructureToAstCtx, migrateFiles, migrationConfigDefaults, promptSelect, rakeDb, rakeDbCommands, saveMigratedVersion, structureToAst, tableToAst, writeMigrationFile };