rake-db 2.11.3 → 2.12.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import * as orchid_core from 'orchid-core';
-import { ColumnTypesBase, EmptyObject, RawSQLBase, MaybeArray } from 'orchid-core';
-import { ColumnsShape, Db as Db$1, ColumnType, EnumColumn, raw, Adapter, DefaultColumnTypes, DbResult, TransactionAdapter, QueryLogObject, IndexColumnOptions, IndexOptions, ForeignKeyOptions, TextColumn, NoPrimaryKeyOption, TableData, SingleColumnIndexOptions, AdapterOptions, QueryLogOptions } from 'pqb';
+import * as pqb from 'pqb';
+import { ColumnsShape, Db as Db$1, ColumnType, EnumColumn, raw, Adapter, DbResult, TransactionAdapter, QueryLogObject, IndexColumnOptions, IndexOptions, ForeignKeyOptions, TextColumn, NoPrimaryKeyOption, TableData, SingleColumnIndexOptions, DefaultColumnTypes, AdapterOptions, QueryLogOptions } from 'pqb';
+import { EmptyObject, RawSQLBase, ColumnSchemaConfig, MaybeArray, ColumnTypeBase } from 'orchid-core';
 
 type CreateTableResult<Table extends string, Shape extends ColumnsShape> = {
     table: Db$1<Table, Shape>;
@@ -20,18 +20,18 @@ type ChangeOptions = {
 };
 type TableChangeMethods = typeof tableChangeMethods;
 declare const tableChangeMethods: {
-    name(this: ColumnTypesBase, name: string): any;
+    name(this: RakeDbColumnTypes, name: string): any;
     add: typeof add;
     drop: typeof add;
-    change(this: ColumnTypesBase, from: ColumnType | Change, to: ColumnType | Change, options?: ChangeOptions): Change;
+    change(from: ColumnType | Change, to: ColumnType | Change, options?: ChangeOptions): Change;
     default(value: unknown | RawSQLBase): Change;
     nullable(): Change;
     nonNullable(): Change;
     comment(comment: string | null): Change;
     rename(name: string): RakeDbAst.ChangeTableItem.Rename;
-    enum(name: string): EnumColumn<string, [string, ...string[]]>;
+    enum(name: string): EnumColumn<pqb.DefaultSchemaConfig, undefined, string, [string, ...string[]]>;
 };
-type TableChanger<CT extends ColumnTypesBase> = MigrationColumnTypes<CT> & TableChangeMethods;
+type TableChanger<CT> = MigrationColumnTypes<CT> & TableChangeMethods;
 type TableChangeData = Record<string, RakeDbAst.ChangeTableItem.Column | RakeDbAst.ChangeTableItem.Rename | Change | EmptyObject>;
 
 type DropMode = 'CASCADE' | 'RESTRICT';
@@ -44,14 +44,14 @@ type TableOptions = {
     snakeCase?: boolean;
     language?: string;
 };
-type TextColumnCreator = () => TextColumn;
-type MigrationColumnTypes<CT extends ColumnTypesBase> = Omit<CT, 'text' | 'string' | 'enum'> & {
+type TextColumnCreator = (min?: number, max?: number) => TextColumn<ColumnSchemaConfig>;
+type MigrationColumnTypes<CT> = Omit<CT, 'text' | 'string' | 'enum'> & {
     text: TextColumnCreator;
     string: TextColumnCreator;
     citext: TextColumnCreator;
-    enum: (name: string) => EnumColumn;
+    enum: (name: string) => EnumColumn<ColumnSchemaConfig, unknown>;
 };
-type ColumnsShapeCallback<CT extends ColumnTypesBase, Shape extends ColumnsShape = ColumnsShape> = (t: MigrationColumnTypes<CT> & {
+type ColumnsShapeCallback<CT, Shape extends ColumnsShape = ColumnsShape> = (t: MigrationColumnTypes<CT> & {
     raw: typeof raw;
 }) => Shape;
 type ChangeTableOptions = {
@@ -59,7 +59,7 @@ type ChangeTableOptions = {
     language?: string;
     comment?: string | [string, string] | null;
 };
-type ChangeTableCallback<CT extends ColumnTypesBase> = (t: TableChanger<CT>) => TableChangeData;
+type ChangeTableCallback<CT> = (t: TableChanger<CT>) => TableChangeData;
 type ColumnComment = {
     column: string;
     comment: string | null;
@@ -68,20 +68,9 @@ type SilentQueries = {
     silentQuery: Adapter['query'];
     silentArrays: Adapter['arrays'];
 };
-type DbMigration<CT extends ColumnTypesBase = DefaultColumnTypes> = DbResult<CT> & Migration<CT> & {
+type DbMigration<CT extends RakeDbColumnTypes> = DbResult<CT> & Migration<CT> & {
     adapter: SilentQueries;
 };
-type ConstraintArg = {
-    name?: string;
-    references?: [
-        columns: [string, ...string[]],
-        table: string,
-        foreignColumn: [string, ...string[]],
-        options: Omit<ForeignKeyOptions, 'name' | 'dropMode'>
-    ];
-    check?: RawSQLBase;
-    dropMode?: DropMode;
-};
 /**
  * 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.
@@ -91,12 +80,12 @@ type ConstraintArg = {
  * @param config - config of `rakeDb`
  * @param asts - array of migration ASTs to collect changes into
  */
-declare const createMigrationInterface: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(tx: TransactionAdapter, up: boolean, config: RakeDbConfig<CT>, asts: RakeDbAst[]) => DbMigration<CT>;
-declare class Migration<CT extends ColumnTypesBase> {
+declare const createMigrationInterface: <SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColumnTypes>(tx: TransactionAdapter, up: boolean, config: RakeDbConfig<SchemaConfig, CT>, asts: RakeDbAst[]) => DbMigration<CT>;
+declare class Migration<CT extends RakeDbColumnTypes> {
     adapter: TransactionAdapter;
     log?: QueryLogObject;
     up: boolean;
-    options: RakeDbConfig;
+    options: RakeDbConfig<ColumnSchemaConfig>;
     migratedAsts: RakeDbAst[];
     columnTypes: CT;
     /**
@@ -890,7 +879,7 @@ declare namespace RakeDbAst {
         action: 'create' | 'drop';
         schema?: string;
         name: string;
-        baseType: ColumnType;
+        baseType: ColumnTypeBase;
         notNull?: boolean;
         collation?: string;
         default?: RawSQLBase;
@@ -947,8 +936,28 @@ declare namespace RakeDbAst {
     };
 }
 
-type Db = DbResult<DefaultColumnTypes>;
-type BaseTable<CT extends ColumnTypesBase> = {
+type RakeDbColumnTypes = {
+    index(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): EmptyObject;
+    foreignKey(columns: [string, ...string[]], foreignTable: string, foreignColumns: [string, ...string[]], options?: ForeignKeyOptions): EmptyObject;
+    primaryKey(columns: string[], options?: {
+        name?: string;
+    }): EmptyObject;
+    check(check: RawSQLBase): EmptyObject;
+    constraint(arg: ConstraintArg): EmptyObject;
+};
+type ConstraintArg = {
+    name?: string;
+    references?: [
+        columns: [string, ...string[]],
+        table: string,
+        foreignColumn: [string, ...string[]],
+        options: Omit<ForeignKeyOptions, 'name' | 'dropMode'>
+    ];
+    check?: RawSQLBase;
+    dropMode?: DropMode;
+};
+type Db = DbResult<RakeDbColumnTypes>;
+type BaseTable<CT> = {
     exportAs: string;
     getFilePath(): string;
     nowSQL?: string;
@@ -958,12 +967,13 @@ type BaseTable<CT extends ColumnTypesBase> = {
         language?: string;
     };
 };
-type InputRakeDbConfig<CT extends ColumnTypesBase> = Partial<Omit<RakeDbConfig<CT>, 'columnTypes'>> & ({
-    columnTypes?: CT | ((t: DefaultColumnTypes) => CT);
+type InputRakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT> = Partial<Omit<RakeDbConfig<SchemaConfig, CT>, 'columnTypes'>> & ({
+    columnTypes?: CT | ((t: DefaultColumnTypes<ColumnSchemaConfig>) => CT);
 } | {
     baseTable?: BaseTable<CT>;
 });
-type RakeDbConfig<CT extends ColumnTypesBase = DefaultColumnTypes> = {
+type RakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<ColumnSchemaConfig>> = {
+    schemaConfig: SchemaConfig;
     columnTypes: CT;
     basePath: string;
     dbScript: string;
@@ -973,7 +983,7 @@ type RakeDbConfig<CT extends ColumnTypesBase = DefaultColumnTypes> = {
     migrationsTable: string;
     snakeCase: boolean;
     language?: string;
-    commands: Record<string, (options: AdapterOptions[], config: RakeDbConfig<CT>, args: string[]) => void | Promise<void>>;
+    commands: Record<string, (options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>, args: string[]) => void | Promise<void>>;
     noPrimaryKey?: NoPrimaryKeyOption;
     baseTable?: BaseTable<CT>;
     appCodeUpdater?: AppCodeUpdater;
@@ -1014,18 +1024,18 @@ type MigrationItem = {
     load(): Promise<unknown>;
 };
 
-declare const createDb: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>) => Promise<void>;
-declare const dropDb: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>) => Promise<void>;
-declare const resetDb: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>) => Promise<void>;
+declare const createDb: <SchemaConfig extends ColumnSchemaConfig, CT>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
+declare const dropDb: <SchemaConfig extends ColumnSchemaConfig, CT>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
+declare const resetDb: <SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColumnTypes>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
 
-declare const writeMigrationFile: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(config: RakeDbConfig<CT>, version: string, name: string, content: (importPath: string, name: string) => string) => Promise<void>;
-declare const generate: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(config: RakeDbConfig<CT>, [name]: string[]) => Promise<void>;
+declare const writeMigrationFile: <SchemaConfig extends ColumnSchemaConfig, CT>(config: RakeDbConfig<SchemaConfig, CT>, version: string, name: string, content: (importPath: string, name: string) => string) => Promise<void>;
+declare const generate: <SchemaConfig extends ColumnSchemaConfig, CT>(config: RakeDbConfig<SchemaConfig, CT>, [name]: string[]) => Promise<void>;
 declare const makeFileTimeStamp: () => string;
 
-type ChangeCallback<CT extends ColumnTypesBase = ColumnTypesBase> = (db: DbMigration<CT>, up: boolean) => Promise<void>;
+type ChangeCallback<CT extends RakeDbColumnTypes> = (db: DbMigration<CT>, up: boolean) => Promise<void>;
 
 declare const RAKE_DB_LOCK_KEY = "8582141715823621641";
-type MigrateFn = <CT extends ColumnTypesBase>(options: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>, args?: string[]) => Promise<void>;
+type MigrateFn = <SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColumnTypes>(options: MaybeArray<AdapterOptions>, config: RakeDbConfig<SchemaConfig, CT>, args?: string[]) => Promise<void>;
 /**
  * Will run all pending yet migrations, sequentially in order,
  * will apply `change` functions top-to-bottom.
@@ -1048,13 +1058,13 @@ declare const rollback: MigrateFn;
  * Takes the same options as {@link migrate}.
  */
 declare const redo: MigrateFn;
-declare const migrateOrRollback: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(trx: TransactionAdapter, config: RakeDbConfig<CT>, files: MigrationItem[], count: number, asts: RakeDbAst[], up: boolean) => Promise<void>;
-declare const changeCache: Record<string, ChangeCallback[] | undefined>;
+declare const migrateOrRollback: (trx: TransactionAdapter, config: RakeDbConfig<ColumnSchemaConfig, RakeDbColumnTypes>, files: MigrationItem[], count: number, asts: RakeDbAst[], up: boolean) => Promise<void>;
+declare const changeCache: Record<string, ChangeCallback<RakeDbColumnTypes>[] | undefined>;
 
 /**
  * Type of {@link rakeDb} function
  */
-type RakeDbFn = (<C extends ColumnTypesBase = DefaultColumnTypes>(options: MaybeArray<AdapterOptions>, partialConfig?: InputRakeDbConfig<C>, args?: string[]) => RakeDbChangeFn<C> & {
+type RakeDbFn = (<SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColumnTypes>(options: MaybeArray<AdapterOptions>, partialConfig?: InputRakeDbConfig<SchemaConfig, CT>, args?: string[]) => RakeDbChangeFn<CT> & {
     promise: Promise<void>;
 }) & {
     /**
@@ -1070,16 +1080,16 @@ type RakeDbFn = (<C extends ColumnTypesBase = DefaultColumnTypes>(options: Maybe
 /**
  * Type of {@link rakeDb.lazy} function
  */
-type RakeDbLazyFn = <C extends ColumnTypesBase = DefaultColumnTypes>(options: MaybeArray<AdapterOptions>, partialConfig?: InputRakeDbConfig<C>) => {
-    change: RakeDbChangeFn<C>;
-    run(args: string[], config?: Partial<RakeDbConfig<C>>): Promise<void>;
+type RakeDbLazyFn = <SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColumnTypes>(options: MaybeArray<AdapterOptions>, partialConfig?: InputRakeDbConfig<SchemaConfig, CT>) => {
+    change: RakeDbChangeFn<CT>;
+    run(args: string[], config?: Partial<RakeDbConfig<SchemaConfig, CT>>): Promise<void>;
 };
 /**
  * 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.
  */
-type RakeDbChangeFn<C extends ColumnTypesBase> = (fn: ChangeCallback<C>) => ChangeCallback<C>;
+type RakeDbChangeFn<CT extends RakeDbColumnTypes> = (fn: ChangeCallback<CT>) => ChangeCallback<CT>;
 /**
  * Function to configure and run `rakeDb`.
  *
@@ -1089,8 +1099,8 @@ type RakeDbChangeFn<C extends ColumnTypesBase> = (fn: ChangeCallback<C>) => Chan
  */
 declare const rakeDb: RakeDbFn;
 
-declare const saveMigratedVersion: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(db: SilentQueries, version: string, config: RakeDbConfig<CT>) => Promise<void>;
-declare const removeMigratedVersion: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(db: SilentQueries, version: string, config: RakeDbConfig<CT>) => Promise<void>;
-declare const getMigratedVersionsMap: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(db: TransactionAdapter, config: RakeDbConfig<CT>) => Promise<Record<string, boolean>>;
+declare const saveMigratedVersion: <SchemaConfig extends ColumnSchemaConfig, CT>(db: SilentQueries, version: string, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
+declare const removeMigratedVersion: <SchemaConfig extends ColumnSchemaConfig, CT>(db: SilentQueries, version: string, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
+declare const getMigratedVersionsMap: <SchemaConfig extends ColumnSchemaConfig, CT>(db: TransactionAdapter, config: RakeDbConfig<SchemaConfig, CT>) => Promise<Record<string, boolean>>;
 
 export { AppCodeUpdater, AppCodeUpdaterParams, ChangeTableCallback, ChangeTableOptions, ColumnComment, ColumnsShapeCallback, DbMigration, DropMode, Migration, MigrationColumnTypes, RAKE_DB_LOCK_KEY, RakeDbAst, RakeDbConfig, SilentQueries, TableOptions, changeCache, createDb, createMigrationInterface, dropDb, generate, getMigratedVersionsMap, makeFileTimeStamp, migrate, migrateOrRollback, rakeDb, redo, removeMigratedVersion, resetDb, rollback, saveMigratedVersion, writeMigrationFile };

package/dist/index.js

@@ -39,6 +39,7 @@ var __objRest$2 = (source, exclude) => {
   return target;
 };
 const migrationConfigDefaults = {
+  schemaConfig: pqb.defaultSchemaConfig,
   migrationsPath: path.join("src", "db", "migrations"),
   migrationsTable: "schemaMigrations",
   snakeCase: false,
@@ -100,13 +101,16 @@ const processRakeDbConfig = (config) => {
   }
   if ("baseTable" in config) {
     const proto = (_b = config.baseTable) == null ? void 0 : _b.prototype;
-    result.columnTypes = proto.types || pqb.columnTypes;
+    result.columnTypes = proto.types || pqb.makeColumnTypes(pqb.defaultSchemaConfig);
     if (proto.snakeCase)
       result.snakeCase = true;
     if (proto.language)
       result.language = proto.language;
   } else {
-    result.columnTypes = "columnTypes" in config && (typeof config.columnTypes === "function" ? config.columnTypes(pqb.columnTypes) : config.columnTypes) || pqb.columnTypes;
+    const ct = "columnTypes" in config && config.columnTypes;
+    result.columnTypes = (typeof ct === "function" ? ct(
+      pqb.makeColumnTypes(pqb.defaultSchemaConfig)
+    ) : ct) || pqb.makeColumnTypes;
   }
   return result;
 };
@@ -616,7 +620,12 @@ const primaryKeyToSql = (primaryKey) => {
 
 const tableMethods = {
   enum(name) {
-    return new pqb.EnumColumn(name, []);
+    return new pqb.EnumColumn(
+      pqb.defaultSchemaConfig,
+      name,
+      [],
+      void 0
+    );
   }
 };
 
@@ -686,14 +695,10 @@ const createTable$1 = async (migration, up, tableName, options, fn) => {
   let table;
   return {
     get table() {
-      return table != null ? table : table = migration(
-        tableName,
-        shape,
-        {
-          noPrimaryKey: options.noPrimaryKey ? "ignore" : void 0,
-          snakeCase: options.snakeCase
-        }
-      );
+      return table != null ? table : table = migration(tableName, shape, {
+        noPrimaryKey: options.noPrimaryKey ? "ignore" : void 0,
+        snakeCase: options.snakeCase
+      });
     }
   };
 };
@@ -956,7 +961,8 @@ const columnTypeToColumnChange = (item) => {
 const nameKey = Symbol("name");
 const tableChangeMethods = __spreadProps$2(__spreadValues$4({}, tableMethods), {
   name(name) {
-    const types = Object.create(pqb.columnTypes.name.call(this, name));
+    orchidCore.setCurrentColumnName(name);
+    const types = Object.create(this);
     types[nameKey] = name;
     return types;
   },
@@ -1001,7 +1007,9 @@ const changeTable = async (migration, up, tableName, options, fn) => {
   orchidCore.setDefaultLanguage(language);
   pqb.resetTableData();
   resetChangeTableData();
-  const tableChanger = Object.create(migration.columnTypes);
+  const tableChanger = Object.create(
+    migration.columnTypes
+  );
   Object.assign(tableChanger, tableChangeMethods);
   tableChanger[orchidCore.snakeCaseKey] = snakeCase;
   const changeData = (fn == null ? void 0 : fn(tableChanger)) || {};
@@ -2271,7 +2279,7 @@ function makeMigrateFn(defaultCount, up, fn) {
 const migrate = makeMigrateFn(
   Infinity,
   true,
-  (trx, configs, files, count, asts) => migrateOrRollback(trx, configs, files, count, asts, true)
+  (trx, config, files, count, asts) => migrateOrRollback(trx, config, files, count, asts, true)
 );
 const rollback = makeMigrateFn(
   1,
@@ -3159,28 +3167,38 @@ const getColumn = (ctx, data, domains, _a) => {
   ]);
   var _a2, _b2;
   let column;
-  const klass = pqb.columnsByType[getColumnType(type, isSerial)];
-  if (klass) {
-    column = pqb.instantiateColumn(klass, params);
+  const columnType = getColumnType(type, isSerial);
+  const typeFn = ctx.columnsByType[columnType];
+  if (typeFn) {
+    column = pqb.instantiateColumn(typeFn, params);
   } else {
     const domainColumn = domains[`${typeSchema}.${type}`];
     if (domainColumn) {
-      column = new pqb.DomainColumn(type).as(domainColumn);
+      column = new pqb.DomainColumn(ctx.columnSchemaConfig, type).as(domainColumn);
     } else {
       const enumType = data.enums.find(
         (item) => item.name === type && item.schemaName === typeSchema
       );
       if (enumType) {
-        column = new pqb.EnumColumn(type, enumType.values);
+        column = new pqb.EnumColumn(
+          ctx.columnSchemaConfig,
+          type,
+          enumType.values,
+          ctx.columnSchemaConfig.type
+        );
       } else {
-        column = new pqb.CustomTypeColumn(type);
+        column = new pqb.CustomTypeColumn(ctx.columnSchemaConfig, type);
         ((_b2 = (_a2 = ctx.unsupportedTypes)[type]) != null ? _b2 : _a2[type] = []).push(
           `${schemaName}${tableName ? `.${tableName}` : ""}.${name}`
         );
       }
     }
   }
-  return isArray ? new pqb.ArrayColumn(column) : column;
+  return isArray ? new pqb.ArrayColumn(
+    ctx.columnSchemaConfig,
+    column,
+    ctx.columnSchemaConfig.type
+  ) : column;
 };
 const getColumnType = (type, isSerial) => {
   if (!isSerial)
@@ -3682,9 +3700,11 @@ const pullDbStructure = async (options, config) => {
   const currentSchema = adapter.schema || "public";
   const db = new DbStructure(adapter);
   const ctx = {
-    unsupportedTypes: {},
     snakeCase: config.snakeCase,
-    currentSchema
+    unsupportedTypes: {},
+    currentSchema,
+    columnSchemaConfig: config.schemaConfig,
+    columnsByType: pqb.makeColumnsByType(config.schemaConfig)
   };
   const ast = await structureToAst(ctx, db);
   await adapter.close();
@@ -3801,7 +3821,11 @@ var __spreadValues = (a, b) => {
 };
 const rakeDb = (options, partialConfig = {}, args = process.argv.slice(2)) => {
   const config = processRakeDbConfig(partialConfig);
-  const promise = runCommand(options, config, args).catch((err) => {
+  const promise = runCommand(
+    options,
+    config,
+    args
+  ).catch((err) => {
     var _a;
     if (err instanceof RakeDbError) {
       (_a = config.logger) == null ? void 0 : _a.error(err.message);