rake-db 2.26.0 → 2.27.3

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import * as pqb 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';
+import { MaybeArray, RawSQLBase, ColumnDataCheckBase, RecordString, ColumnTypeBase, EmptyObject, ColumnSchemaConfig, QueryLogOptions, AdapterBase, MaybePromise, QueryLogObject, QueryBase } from 'orchid-core';
+import * as pqb 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>;
@@ -298,49 +298,71 @@ interface MigrationsSet {
 }
 
 interface CommandFn<SchemaConfig extends ColumnSchemaConfig, CT> {
-    (options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>, args: string[]): void | Promise<void>;
+    (adapters: AdapterBase[], config: RakeDbConfig<SchemaConfig, CT>, args: string[]): void | Promise<void>;
 }
-interface RakeDbBaseConfig<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>> extends QueryLogOptions {
-    schemaConfig: SchemaConfig;
-    migrationsPath: string;
+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;
-    snakeCase: boolean;
-    language?: string;
-    commands: Record<string, CommandFn<SchemaConfig, CT>>;
-    noPrimaryKey?: NoPrimaryKeyOption;
-    baseTable?: RakeDbBaseTable<CT>;
-    forceDefaultExports?: boolean;
-    import(path: string): Promise<unknown>;
+}
+interface PickMigrationCallbacks {
     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> {
+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;
-    basePath: string;
     dbScript: string;
     recurrentPath: string;
 }
-interface InputRakeDbConfigBase<SchemaConfig extends ColumnSchemaConfig, CT> extends QueryLogOptions {
+interface InputRakeDbConfigBase<SchemaConfig extends ColumnSchemaConfig, CT> extends QueryLogOptions, PickOptionalMigrationsPath {
     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>>;
+    commands?: Record<string, (adapter: AdapterBase[], config: RakeDbConfig<SchemaConfig, CT>, args: string[]) => void | Promise<void>>;
     noPrimaryKey?: NoPrimaryKeyOption;
     forceDefaultExports?: boolean;
     /**
@@ -429,7 +451,7 @@ interface ChangeCallback$1 {
 }
 interface ChangeCommitCallback {
     (arg: {
-        options: AdapterOptions;
+        adapter: AdapterBase;
         up: boolean;
         migrations: MigrationItem[];
     }): void | Promise<void>;
@@ -493,12 +515,15 @@ type ChangeTableOptions = {
 };
 type ChangeTableCallback<CT> = (t: TableChanger<CT>) => TableChangeData;
 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.
@@ -507,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> {
@@ -1427,25 +1452,25 @@ interface MigrationChange {
 type ChangeCallback<CT> = (db: DbMigration<CT>, up: boolean) => Promise<void>;
 
 /**
- * Type of {@link rakeDb} function
+ * Type of {@link rakeDbWithAdapters} function
  */
-interface RakeDbFn {
-    <SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>>(options: MaybeArray<AdapterOptions>, partialConfig: InputRakeDbConfig<SchemaConfig, CT>, args?: string[]): RakeDbChangeFnWithPromise<CT>;
+interface RakeDbFn<Options> {
+    <SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>>(options: Options, 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 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
      */
-    lazy<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>>(options: MaybeArray<AdapterOptions>, config: InputRakeDbConfig<SchemaConfig, CT>): {
+    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 RakeDbResult {
-    options: AdapterOptions[];
+    adapters: AdapterBase[];
     config: AnyRakeDbConfig;
     args: string[];
 }
@@ -1463,13 +1488,13 @@ interface RakeDbChangeFnWithPromise<CT> extends RakeDbChangeFn<CT> {
 /**
  * Function to configure and run `rakeDb`.
  *
- * @param options - {@link AdapterOptions} or an array of such options to migrate multiple dbs
+ * @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 rakeDb: RakeDbFn;
+declare const rakeDbWithAdapters: RakeDbFn<AdapterBase[]>;
 interface RakeDbCommand {
-    run(options: AdapterOptions[], config: AnyRakeDbConfig, args: string[]): MaybePromise<unknown>;
+    run(adapters: AdapterBase[], config: AnyRakeDbConfig, args: string[]): MaybePromise<unknown>;
     help: string;
     helpArguments?: RecordString;
     helpAfter?: string;
@@ -1504,9 +1529,17 @@ declare const promptSelect: ({ message, options, active, inactive, }: {
     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 saveMigratedVersion: (db: SilentQueries, version: string, name: string, config: PickMigrationsTable) => Promise<void>;
 
-type MigrateFn = <SchemaConfig extends ColumnSchemaConfig, CT>(ctx: RakeDbCtx, options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>, args?: string[], adapters?: Adapter[], dontClose?: boolean) => Promise<Adapter[]>;
+interface MigrateFnConfig extends MigrateOrRollbackConfig, PickAfterChangeCommit, PickBasePath, PickImport, PickMigrationsPath {
+}
+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.
@@ -1515,7 +1548,11 @@ 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 fullMigrate: MigrateFn;
+declare const migrate: MigrateFn;
+declare const migrateAndClose: MigrateFn;
+interface MigrateOrRollbackConfig extends PickMigrationCallbacks, PickMigrationId, QueryLogOptions, PickForceDefaultExports, PickMigrationsTable {
+    columnTypes: unknown;
+}
 
 declare namespace DbStructure {
     interface TableNameAndSchemaName {
@@ -1679,7 +1716,7 @@ 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;
 
@@ -1697,7 +1734,7 @@ 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;
@@ -1717,4 +1754,4 @@ interface OrmParam {
 type UnknownPromiseFns = (() => Promise<unknown>)[];
 declare const migrateFiles: (db: OrmParam, files: UnknownPromiseFns) => Promise<void>;
 
-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 };
+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 };