rake-db 2.6.0 → 2.7.1

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-import { ColumnsShape, Db as Db$1, ColumnType, EnumColumn, ColumnTypes, Adapter, DbResult, DefaultColumnTypes, TransactionAdapter, QueryLogObject, IndexColumnOptions, IndexOptions, ForeignKeyOptions, TextColumn, NoPrimaryKeyOption, TableData, SingleColumnIndexOptions, AdapterOptions, QueryLogOptions } from 'pqb';
-import { EmptyObject, RawExpression, ColumnTypesBase, raw, MaybeArray } from 'orchid-core';
+import * as pqb from 'pqb';
+import { ColumnsShape, Db as Db$1, ColumnType, EnumColumn, Adapter, DefaultColumnTypes, DbResult, TransactionAdapter, QueryLogObject, IndexColumnOptions, IndexOptions, ForeignKeyOptions, TextColumn, NoPrimaryKeyOption, TableData, SingleColumnIndexOptions, AdapterOptions, QueryLogOptions } from 'pqb';
+import * as orchid_core from 'orchid-core';
+import { ColumnTypesBase, EmptyObject, RawExpression, raw, MaybeArray } from 'orchid-core';
 
 type CreateTableResult<Table extends string, Shape extends ColumnsShape> = {
     table: Db$1<Table, Shape>;
@@ -29,7 +31,7 @@ declare const tableChangeMethods: {
     rename(name: string): RakeDbAst.ChangeTableItem.Rename;
     enum(this: ColumnTypesBase, name: string): EnumColumn<string, [string, ...string[]]>;
 };
-type TableChanger = MigrationColumnTypes & TableChangeMethods;
+type TableChanger<CT extends ColumnTypesBase> = MigrationColumnTypes<CT> & TableChangeMethods;
 type TableChangeData = Record<string, RakeDbAst.ChangeTableItem.Column | RakeDbAst.ChangeTableItem.Rename | Change | EmptyObject>;
 
 type DropMode = 'CASCADE' | 'RESTRICT';
@@ -40,20 +42,20 @@ type TableOptions = {
     snakeCase?: boolean;
 };
 type TextColumnCreator = () => TextColumn;
-type MigrationColumnTypes = Omit<ColumnTypes, 'text' | 'string' | 'enum'> & {
+type MigrationColumnTypes<CT extends ColumnTypesBase> = Omit<CT, 'text' | 'string' | 'enum'> & {
     text: TextColumnCreator;
     string: TextColumnCreator;
     citext: TextColumnCreator;
     enum: (name: string) => EnumColumn;
 };
-type ColumnsShapeCallback<Shape extends ColumnsShape = ColumnsShape> = (t: MigrationColumnTypes & {
+type ColumnsShapeCallback<CT extends ColumnTypesBase, Shape extends ColumnsShape = ColumnsShape> = (t: MigrationColumnTypes<CT> & {
     raw: typeof raw;
 }) => Shape;
 type ChangeTableOptions = {
     snakeCase?: boolean;
     comment?: string | [string, string] | null;
 };
-type ChangeTableCallback = (t: TableChanger) => TableChangeData;
+type ChangeTableCallback<CT extends ColumnTypesBase> = (t: TableChanger<CT>) => TableChangeData;
 type ColumnComment = {
     column: string;
     comment: string | null;
@@ -62,7 +64,7 @@ type SilentQueries = {
     silentQuery: Adapter['query'];
     silentArrays: Adapter['arrays'];
 };
-type Migration = DbResult<DefaultColumnTypes> & MigrationBase & {
+type Migration<CT extends ColumnTypesBase = DefaultColumnTypes> = DbResult<CT> & MigrationBase<CT> & {
     adapter: SilentQueries;
 };
 type ConstraintArg = {
@@ -76,22 +78,23 @@ type ConstraintArg = {
     check?: RawExpression;
     dropMode?: DropMode;
 };
-declare const createMigrationInterface: (tx: TransactionAdapter, up: boolean, options: RakeDbConfig) => Migration;
-declare class MigrationBase {
+declare const createMigrationInterface: <CT extends ColumnTypesBase>(tx: TransactionAdapter, up: boolean, config: RakeDbConfig<CT>) => Migration;
+declare class MigrationBase<CT extends ColumnTypesBase> {
     adapter: TransactionAdapter;
     log?: QueryLogObject;
     up: boolean;
     options: RakeDbConfig;
     migratedAsts: RakeDbAst[];
-    createTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, options: TableOptions, fn: ColumnsShapeCallback<Shape>): Promise<CreateTableResult<Table, Shape>>;
-    createTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, fn: ColumnsShapeCallback<Shape>): Promise<CreateTableResult<Table, Shape>>;
-    dropTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, options: TableOptions, fn: ColumnsShapeCallback<Shape>): Promise<CreateTableResult<Table, Shape>>;
-    dropTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, fn: ColumnsShapeCallback<Shape>): Promise<CreateTableResult<Table, Shape>>;
-    changeTable(tableName: string, options: ChangeTableOptions, fn?: ChangeTableCallback): Promise<void>;
-    changeTable(tableName: string, fn: ChangeTableCallback): Promise<void>;
+    columnTypes: CT;
+    createTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, options: TableOptions, fn: ColumnsShapeCallback<CT, Shape>): Promise<CreateTableResult<Table, Shape>>;
+    createTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, fn: ColumnsShapeCallback<CT, Shape>): Promise<CreateTableResult<Table, Shape>>;
+    dropTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, options: TableOptions, fn: ColumnsShapeCallback<CT, Shape>): Promise<CreateTableResult<Table, Shape>>;
+    dropTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, fn: ColumnsShapeCallback<CT, Shape>): Promise<CreateTableResult<Table, Shape>>;
+    changeTable(tableName: string, options: ChangeTableOptions, fn?: ChangeTableCallback<CT>): Promise<void>;
+    changeTable(tableName: string, fn: ChangeTableCallback<CT>): Promise<void>;
     renameTable(from: string, to: string): Promise<void>;
-    addColumn(tableName: string, columnName: string, fn: (t: MigrationColumnTypes) => ColumnType): Promise<void>;
-    dropColumn(tableName: string, columnName: string, fn: (t: MigrationColumnTypes) => ColumnType): Promise<void>;
+    addColumn(tableName: string, columnName: string, fn: (t: MigrationColumnTypes<CT>) => ColumnType): Promise<void>;
+    dropColumn(tableName: string, columnName: string, fn: (t: MigrationColumnTypes<CT>) => ColumnType): Promise<void>;
     addIndex(tableName: string, columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): Promise<void>;
     dropIndex(tableName: string, columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): Promise<void>;
     addForeignKey(tableName: string, columns: [string, ...string[]], foreignTable: string, foreignColumns: [string, ...string[]], options?: ForeignKeyOptions): Promise<void>;
@@ -113,8 +116,8 @@ declare class MigrationBase {
     dropExtension(name: string, options?: Omit<RakeDbAst.Extension, 'type' | 'action' | 'name' | 'values'>): Promise<void>;
     createEnum(name: string, values: [string, ...string[]], options?: Omit<RakeDbAst.Enum, 'type' | 'action' | 'name' | 'values' | 'schema'>): Promise<void>;
     dropEnum(name: string, values: [string, ...string[]], options?: Omit<RakeDbAst.Enum, 'type' | 'action' | 'name' | 'values' | 'schema'>): Promise<void>;
-    createDomain(name: string, fn: (t: ColumnTypes) => ColumnType, options?: Omit<RakeDbAst.Domain, 'type' | 'action' | 'schema' | 'name' | 'baseType'>): Promise<void>;
-    dropDomain(name: string, fn: (t: ColumnTypes) => ColumnType, options?: Omit<RakeDbAst.Domain, 'type' | 'action' | 'schema' | 'name' | 'baseType'>): Promise<void>;
+    createDomain(name: string, fn: (t: CT) => ColumnType, options?: Omit<RakeDbAst.Domain, 'type' | 'action' | 'schema' | 'name' | 'baseType'>): Promise<void>;
+    dropDomain(name: string, fn: (t: CT) => ColumnType, options?: Omit<RakeDbAst.Domain, 'type' | 'action' | 'schema' | 'name' | 'baseType'>): Promise<void>;
     createView(name: string, options: RakeDbAst.ViewOptions, sql: string | RawExpression): Promise<void>;
     createView(name: string, sql: string | RawExpression): Promise<void>;
     dropView(name: string, options: RakeDbAst.ViewOptions, sql: string | RawExpression): Promise<void>;
@@ -259,12 +262,22 @@ declare namespace RakeDbAst {
 }
 
 type Db = DbResult<DefaultColumnTypes>;
-type RakeDbConfig = {
+type InputRakeDbConfig<CT extends ColumnTypesBase> = Partial<Omit<RakeDbConfig<CT>, 'columnTypes'>> & ({
+    columnTypes?: CT | ((t: DefaultColumnTypes) => CT);
+} | {
+    baseTable?: new () => {
+        columnTypes: CT;
+        snakeCase?: boolean;
+    };
+});
+type RakeDbConfig<CT extends ColumnTypesBase = DefaultColumnTypes> = {
+    columnTypes: CT;
     basePath: string;
+    dbScript: string;
     migrationsPath: string;
     migrationsTable: string;
     snakeCase: boolean;
-    commands: Record<string, (options: AdapterOptions[], config: RakeDbConfig, args: string[]) => Promise<void>>;
+    commands: Record<string, (options: AdapterOptions[], config: RakeDbConfig<CT>, args: string[]) => Promise<void>>;
     import(path: string): Promise<void>;
     noPrimaryKey?: NoPrimaryKeyOption;
     appCodeUpdater?: AppCodeUpdater;
@@ -282,27 +295,144 @@ type AppCodeUpdater = (params: {
     logger: QueryLogOptions['logger'];
 }) => Promise<void>;
 
-declare const createDb: (arg: MaybeArray<AdapterOptions>, config: RakeDbConfig) => Promise<void>;
+declare const createDb: <CT extends ColumnTypesBase>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>) => Promise<void>;
 declare const dropDb: (arg: MaybeArray<AdapterOptions>) => Promise<void>;
-declare const resetDb: (arg: MaybeArray<AdapterOptions>, config: RakeDbConfig) => Promise<void>;
+declare const resetDb: <CT extends ColumnTypesBase>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>) => Promise<void>;
 
-declare const writeMigrationFile: (config: RakeDbConfig, version: string, name: string, content: string) => Promise<void>;
-declare const generate: (config: RakeDbConfig, [name]: string[]) => Promise<void>;
+declare const writeMigrationFile: <CT extends ColumnTypesBase>(config: RakeDbConfig<CT>, version: string, name: string, content: (importPath: string, name: string) => string) => Promise<void>;
+declare const generate: <CT extends ColumnTypesBase>(config: RakeDbConfig<CT>, [name]: string[]) => Promise<void>;
 declare const makeFileTimeStamp: () => string;
 
-type ChangeCallback = (db: Migration, up: boolean) => Promise<void>;
-declare const change: (fn: ChangeCallback) => void;
+type ChangeCallback<CT extends ColumnTypesBase = ColumnTypesBase> = (db: Migration<CT>, up: boolean) => Promise<void>;
 
-declare const migrateOrRollback: (options: MaybeArray<AdapterOptions>, config: RakeDbConfig, args: string[], up: boolean) => Promise<void>;
+declare const migrateOrRollback: <CT extends ColumnTypesBase>(options: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>, args: string[], up: boolean) => Promise<void>;
 declare const changeCache: Record<string, ChangeCallback[] | undefined>;
-declare const migrate: (options: MaybeArray<AdapterOptions>, config: RakeDbConfig, args?: string[]) => Promise<void>;
-declare const rollback: (options: MaybeArray<AdapterOptions>, config: RakeDbConfig, args?: string[]) => Promise<void>;
-declare const redo: (options: MaybeArray<AdapterOptions>, config: RakeDbConfig, args?: string[]) => Promise<void>;
+declare const migrate: <CT extends ColumnTypesBase>(options: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>, args?: string[]) => Promise<void>;
+declare const rollback: <CT extends ColumnTypesBase>(options: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>, args?: string[]) => Promise<void>;
+declare const redo: <CT extends ColumnTypesBase>(options: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>, args?: string[]) => Promise<void>;
 
-declare const rakeDb: (options: MaybeArray<AdapterOptions>, partialConfig?: Partial<RakeDbConfig>, args?: string[]) => Promise<void>;
+declare const rakeDb: <CT extends ColumnTypesBase = {
+    timestamps: <T extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
+        name(name: string): {
+            timestamp(): T;
+        };
+        timestamp(): T;
+    }) => {
+        createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression>;
+        updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression>;
+    };
+    timestampsSnakeCase: <T_1 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
+        name(name: string): {
+            timestamp(): T_1;
+        };
+        timestamp(): T_1;
+    }) => {
+        createdAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression>;
+        updatedAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression>;
+    };
+    name: typeof orchid_core.name;
+    raw: (sql: string, values?: false | Record<string, unknown> | undefined) => orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>;
+    smallint(this: ColumnTypesBase): pqb.SmallIntColumn;
+    integer(this: ColumnTypesBase): pqb.IntegerColumn;
+    bigint(this: ColumnTypesBase): pqb.BigIntColumn;
+    numeric<Precision extends number | undefined = undefined, Scale extends number | undefined = undefined>(this: ColumnTypesBase, precision?: Precision | undefined, scale?: Scale | undefined): pqb.DecimalColumn<Precision, Scale>;
+    decimal<Precision_1 extends number | undefined = undefined, Scale_1 extends number | undefined = undefined>(this: ColumnTypesBase, precision?: Precision_1 | undefined, scale?: Scale_1 | undefined): pqb.DecimalColumn<Precision_1, Scale_1>;
+    real(this: ColumnTypesBase): pqb.RealColumn;
+    doublePrecision(this: ColumnTypesBase): pqb.DoublePrecisionColumn;
+    identity(this: ColumnTypesBase, options?: pqb.TableData.Identity | undefined): pqb.IntegerColumn;
+    smallSerial(this: ColumnTypesBase): pqb.SmallSerialColumn;
+    serial(this: ColumnTypesBase): pqb.SerialColumn;
+    bigSerial(this: ColumnTypesBase): pqb.BigSerialColumn;
+    money(this: ColumnTypesBase): pqb.MoneyColumn;
+    varchar<Limit extends number | undefined = undefined>(this: ColumnTypesBase, limit?: Limit | undefined): pqb.VarCharColumn<Limit>;
+    char<Limit_1 extends number | undefined = undefined>(this: ColumnTypesBase, limit?: Limit_1 | undefined): pqb.CharColumn<Limit_1>;
+    text: (this: ColumnTypesBase, min: number, max: number) => pqb.TextColumn;
+    string: (this: ColumnTypesBase, min: number, max: number) => pqb.TextColumn;
+    citext(this: ColumnTypesBase, min: number, max: number): pqb.CitextColumn;
+    bytea(this: ColumnTypesBase): pqb.ByteaColumn;
+    date(this: ColumnTypesBase): pqb.DateColumn;
+    timestampWithoutTimeZone<Precision_2 extends number>(this: ColumnTypesBase, precision?: Precision_2 | undefined): pqb.TimestampColumn<Precision_2>;
+    timestamp<Precision_3 extends number | undefined = undefined>(this: ColumnTypesBase, precision?: Precision_3 | undefined): pqb.TimestampTzColumn<number>;
+    time<Precision_4 extends number | undefined = undefined>(this: ColumnTypesBase, precision?: Precision_4 | undefined): pqb.TimeColumn<Precision_4>;
+    interval<Fields extends string | undefined = undefined, Precision_5 extends number | undefined = undefined>(this: ColumnTypesBase, fields?: Fields | undefined, precision?: Precision_5 | undefined): pqb.IntervalColumn<Fields, Precision_5>;
+    boolean(this: ColumnTypesBase): pqb.BooleanColumn;
+    enum<U extends string, T_2 extends [U, ...U[]]>(this: ColumnTypesBase, dataType: string, type: T_2): pqb.EnumColumn<U, T_2>;
+    point(this: ColumnTypesBase): pqb.PointColumn;
+    line(this: ColumnTypesBase): pqb.LineColumn;
+    lseg(this: ColumnTypesBase): pqb.LsegColumn;
+    box(this: ColumnTypesBase): pqb.BoxColumn;
+    path(this: ColumnTypesBase): pqb.PathColumn;
+    polygon(this: ColumnTypesBase): pqb.PolygonColumn;
+    circle(this: ColumnTypesBase): pqb.CircleColumn;
+    cidr(this: ColumnTypesBase): pqb.CidrColumn;
+    inet(this: ColumnTypesBase): pqb.InetColumn;
+    macaddr(this: ColumnTypesBase): pqb.MacAddrColumn;
+    macaddr8(this: ColumnTypesBase): pqb.MacAddr8Column;
+    bit<Length extends number>(this: ColumnTypesBase, length: Length): pqb.BitColumn<Length>;
+    bitVarying<Length_1 extends number | undefined = undefined>(this: ColumnTypesBase, length?: Length_1 | undefined): pqb.BitVaryingColumn<Length_1>;
+    tsvector(this: ColumnTypesBase): pqb.TsVectorColumn;
+    tsquery(this: ColumnTypesBase): pqb.TsQueryColumn;
+    uuid(this: ColumnTypesBase): pqb.UUIDColumn;
+    xml(this: ColumnTypesBase): pqb.XMLColumn;
+    json<Type extends orchid_core.JSONTypeAny>(this: ColumnTypesBase, schemaOrFn: Type | ((j: {
+        set: <Value extends orchid_core.JSONTypeAny>(valueType: Value) => orchid_core.JSONSet<Value>;
+        tuple: <T_3 extends [] | orchid_core.JSONTupleItems, Rest extends orchid_core.JSONTypeAny | null = null>(items: T_3, rest?: Rest) => orchid_core.JSONTuple<T_3, Rest>;
+        union: <T_4 extends [orchid_core.JSONTypeAny, orchid_core.JSONTypeAny, ...orchid_core.JSONTypeAny[]]>(types: T_4) => orchid_core.JSONUnion<T_4>;
+        any: () => orchid_core.JSONAny;
+        bigint: () => orchid_core.JSONBigInt;
+        boolean: () => orchid_core.JSONBoolean;
+        date: () => orchid_core.JSONDate;
+        nan: () => orchid_core.JSONNaN;
+        never: () => orchid_core.JSONNever;
+        null: () => orchid_core.JSONNull;
+        number: () => orchid_core.JSONNumber;
+        string: () => orchid_core.JSONString;
+        unknown: () => orchid_core.JSONUnknown;
+        array: <Type_1 extends orchid_core.JSONTypeAny>(element: Type_1) => orchid_core.JSONArray<Type_1, "many">;
+        discriminatedUnion: <Discriminator extends string, DiscriminatorValue extends orchid_core.Primitive, Types extends [orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, ...orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>[]]>(discriminator: Discriminator, options: Types) => orchid_core.JSONDiscriminatedUnion<Discriminator, DiscriminatorValue, Types>;
+        enum: <U_1 extends string, T_5 extends [U_1, ...U_1[]]>(options: T_5) => orchid_core.JSONEnum<U_1, T_5>;
+        instanceOf: <T_6 extends new (...args: any[]) => any>(cls: T_6) => orchid_core.JSONInstanceOf<T_6>;
+        intersection: <Left extends orchid_core.JSONTypeAny, Right extends orchid_core.JSONTypeAny>(left: Left, right: Right) => orchid_core.JSONIntersection<Left, Right>;
+        lazy: <T_7 extends orchid_core.JSONTypeAny>(fn: () => T_7) => orchid_core.JSONLazy<T_7>;
+        literal: <T_8 extends orchid_core.Primitive>(value: T_8) => orchid_core.JSONLiteral<T_8>;
+        map: <Key extends orchid_core.JSONTypeAny, Value_1 extends orchid_core.JSONTypeAny>(keyType: Key, valueType: Value_1) => orchid_core.JSONMap<Key, Value_1>;
+        nativeEnum: <T_9 extends orchid_core.EnumLike>(givenEnum: T_9) => orchid_core.JSONNativeEnum<T_9>;
+        nullable: <T_10 extends orchid_core.JSONTypeAny>(type: T_10) => orchid_core.JSONNullable<T_10>;
+        nullish: <T_11 extends orchid_core.JSONTypeAny>(type: T_11) => orchid_core.JSONNullish<T_11>;
+        object: <T_12 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends orchid_core.JSONTypeAny = orchid_core.JSONTypeAny>(shape: T_12) => orchid_core.JSONObject<T_12, UnknownKeys, Catchall, orchid_core.JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_16 extends object ? { [k in keyof T_16]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
+            [k: string]: Catchall["type"];
+        } extends infer T_14 extends object ? { [k_2 in keyof T_14]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_15 extends object ? { [k in keyof T_15]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
+            [k: string]: Catchall["type"];
+        })[k_2]; } : never>;
+        optional: <T_17 extends orchid_core.JSONTypeAny>(type: T_17) => orchid_core.JSONOptional<T_17>;
+        record: typeof orchid_core.record;
+    }) => Type)): pqb.JSONColumn<Type>;
+    jsonText(this: ColumnTypesBase): pqb.JSONTextColumn;
+    array<Item extends pqb.ColumnType<unknown, orchid_core.BaseOperators, unknown>>(this: ColumnTypesBase, item: Item): pqb.ArrayColumn<Item>;
+    type(this: ColumnTypesBase, dataType: string): pqb.CustomTypeColumn;
+    domain(this: ColumnTypesBase, dataType: string): pqb.DomainColumn;
+    primaryKey(columns: string[], options?: {
+        name?: string | undefined;
+    } | undefined): {};
+    index(columns: MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions): {};
+    unique(columns: MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions): {};
+    constraint<Table extends string | (() => pqb.ForeignKeyTable), Columns extends Table extends () => pqb.ForeignKeyTable ? [pqb.ColumnNameOfTable<ReturnType<Table>>, ...pqb.ColumnNameOfTable<ReturnType<Table>>[]] : [string, ...string[]]>({ name, references, check, dropMode, }: {
+        name?: string | undefined;
+        references?: [columns: string[], fnOrTable: Table, foreignColumns: Columns, options?: pqb.ForeignKeyOptions | undefined] | undefined;
+        check?: orchid_core.RawExpression | undefined;
+        dropMode?: pqb.DropMode | undefined;
+    }): {};
+    foreignKey<Table_1 extends string | (() => pqb.ForeignKeyTable), Columns_1 extends Table_1 extends () => pqb.ForeignKeyTable ? [pqb.ColumnNameOfTable<ReturnType<Table_1>>, ...pqb.ColumnNameOfTable<ReturnType<Table_1>>[]] : [string, ...string[]]>(columns: string[], fnOrTable: Table_1, foreignColumns: Columns_1, options?: (pqb.ForeignKeyOptions & {
+        name?: string | undefined;
+        dropMode?: pqb.DropMode | undefined;
+    }) | undefined): {};
+    check(check: orchid_core.RawExpression): {};
+}>(options: MaybeArray<AdapterOptions>, partialConfig?: InputRakeDbConfig<CT>, args?: string[]) => ((fn: ChangeCallback<CT>) => void) & {
+    promise: Promise<void>;
+};
 
-declare const saveMigratedVersion: (db: SilentQueries, version: string, config: RakeDbConfig) => Promise<void>;
-declare const removeMigratedVersion: (db: SilentQueries, version: string, config: RakeDbConfig) => Promise<void>;
-declare const getMigratedVersionsMap: (db: Adapter, config: RakeDbConfig) => Promise<Record<string, boolean>>;
+declare const saveMigratedVersion: <CT extends ColumnTypesBase>(db: SilentQueries, version: string, config: RakeDbConfig<CT>) => Promise<void>;
+declare const removeMigratedVersion: <CT extends ColumnTypesBase>(db: SilentQueries, version: string, config: RakeDbConfig<CT>) => Promise<void>;
+declare const getMigratedVersionsMap: <CT extends ColumnTypesBase>(db: Adapter, config: RakeDbConfig<CT>) => Promise<Record<string, boolean>>;
 
-export { AppCodeUpdater, ChangeTableCallback, ChangeTableOptions, ColumnComment, ColumnsShapeCallback, DropMode, Migration, MigrationBase, MigrationColumnTypes, RakeDbAst, RakeDbConfig, SilentQueries, TableOptions, change, changeCache, createDb, createMigrationInterface, dropDb, generate, getMigratedVersionsMap, makeFileTimeStamp, migrate, migrateOrRollback, rakeDb, redo, removeMigratedVersion, resetDb, rollback, saveMigratedVersion, writeMigrationFile };
+export { AppCodeUpdater, ChangeTableCallback, ChangeTableOptions, ColumnComment, ColumnsShapeCallback, DropMode, Migration, MigrationBase, MigrationColumnTypes, RakeDbAst, RakeDbConfig, SilentQueries, TableOptions, changeCache, createDb, createMigrationInterface, dropDb, generate, getMigratedVersionsMap, makeFileTimeStamp, migrate, migrateOrRollback, rakeDb, redo, removeMigratedVersion, resetDb, rollback, saveMigratedVersion, writeMigrationFile };

package/dist/index.js

@@ -56,12 +56,12 @@ const migrationConfigDefaults = {
   useCodeUpdater: true
 };
 const processRakeDbConfig = (config) => {
-  var _a;
+  var _a, _b;
   const result = __spreadValues$6(__spreadValues$6({}, migrationConfigDefaults), config);
   if (!result.log) {
     delete result.logger;
   }
-  if (!result.basePath) {
+  if (!result.basePath || !result.dbScript) {
     let stack;
     const original = Error.prepareStackTrace;
     Error.prepareStackTrace = (_, s) => stack = s;
@@ -84,6 +84,7 @@ const processRakeDbConfig = (config) => {
           }
         }
         result.basePath = path.dirname(file);
+        result.dbScript = path.basename(file);
         break;
       }
     }
@@ -99,6 +100,14 @@ const processRakeDbConfig = (config) => {
       result.migrationsPath
     );
   }
+  if ("baseTable" in config) {
+    const proto = (_b = config.baseTable) == null ? void 0 : _b.prototype;
+    result.columnTypes = proto.columnTypes || pqb.columnTypes;
+    if (proto.snakeCase)
+      result.snakeCase = true;
+  } else {
+    result.columnTypes = "columnTypes" in config && (typeof config.columnTypes === "function" ? config.columnTypes(pqb.columnTypes) : config.columnTypes) || pqb.columnTypes;
+  }
   return result;
 };
 const getDatabaseAndUserFromOptions = (options) => {
@@ -268,13 +277,11 @@ const makePopulateEnumQuery = (item) => {
 };
 
 let currentChanges = [];
-const change = (fn) => {
-  currentChanges.push(fn);
-};
 const clearChanges = () => {
   currentChanges = [];
 };
 const getCurrentChanges = () => currentChanges;
+const pushChange = (fn) => currentChanges.push(fn);
 
 var __defProp$5 = Object.defineProperty;
 var __defProps$4 = Object.defineProperties;
@@ -569,9 +576,12 @@ var __objRest$1 = (source, exclude) => {
     }
   return target;
 };
-const types = Object.assign(Object.create(pqb.columnTypes), tableMethods);
 const createTable$1 = async (migration, up, tableName, options, fn) => {
   const snakeCase = "snakeCase" in options ? options.snakeCase : migration.options.snakeCase;
+  const types = Object.assign(
+    Object.create(migration.columnTypes),
+    tableMethods
+  );
   types[orchidCore.snakeCaseKey] = snakeCase;
   const shape = pqb.getColumnTypes(types, fn);
   const tableData = pqb.getTableData();
@@ -895,7 +905,7 @@ const changeTable = async (migration, up, tableName, options, fn) => {
   var _a;
   pqb.resetTableData();
   resetChangeTableData();
-  const tableChanger = Object.create(pqb.columnTypes);
+  const tableChanger = Object.create(migration.columnTypes);
   Object.assign(tableChanger, tableChangeMethods);
   const snakeCase = "snakeCase" in options ? options.snakeCase : migration.options.snakeCase;
   tableChanger[orchidCore.snakeCaseKey] = snakeCase;
@@ -1285,10 +1295,10 @@ var __spreadValues$2 = (a, b) => {
   return a;
 };
 var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
-const createMigrationInterface = (tx, up, options) => {
+const createMigrationInterface = (tx, up, config) => {
   const adapter = new pqb.TransactionAdapter(tx, tx.client, tx.types);
   const { query, arrays } = adapter;
-  const log = pqb.logParamToLogObject(options.logger || console, options.log);
+  const log = pqb.logParamToLogObject(config.logger || console, config.log);
   adapter.query = (q, types) => {
     return wrapWithLog(log, q, () => query.call(adapter, q, types));
   };
@@ -1296,7 +1306,10 @@ const createMigrationInterface = (tx, up, options) => {
     return wrapWithLog(log, q, () => arrays.call(adapter, q, types));
   };
   Object.assign(adapter, { silentQuery: query, silentArrays: arrays });
-  const db = pqb.createDb({ adapter });
+  const db = pqb.createDb({
+    adapter,
+    columnTypes: config.columnTypes
+  });
   const { prototype: proto } = MigrationBase;
   for (const key of Object.getOwnPropertyNames(proto)) {
     db[key] = proto[key];
@@ -1306,7 +1319,7 @@ const createMigrationInterface = (tx, up, options) => {
     adapter,
     log,
     up,
-    options
+    options: config
   });
 };
 class MigrationBase {
@@ -1553,7 +1566,7 @@ const createDomain$1 = async (migration, up, name, fn, options) => {
     action: up ? "create" : "drop",
     schema,
     name: domainName,
-    baseType: fn(pqb.columnTypes)
+    baseType: fn(migration.columnTypes)
   }, options);
   let query;
   const values = [];
@@ -1690,7 +1703,6 @@ const begin = {
 const processMigration = async (db, up, file, config, options, appCodeUpdaterCache) => {
   var _a;
   const asts = await db.transaction(begin, async (tx) => {
-    const db2 = createMigrationInterface(tx, up, config);
     clearChanges();
     let changes = changeCache[file.path];
     if (!changes) {
@@ -1704,6 +1716,7 @@ const processMigration = async (db, up, file, config, options, appCodeUpdaterCac
       changes = getCurrentChanges();
       changeCache[file.path] = changes;
     }
+    const db2 = createMigrationInterface(tx, up, config);
     for (const fn of up ? changes : changes.reverse()) {
       await fn(db2, up);
     }
@@ -1850,14 +1863,18 @@ const writeMigrationFile = async (config, version, name, content) => {
   var _a;
   await promises.mkdir(config.migrationsPath, { recursive: true });
   const filePath = path.resolve(config.migrationsPath, `${version}_${name}.ts`);
-  await promises.writeFile(filePath, content);
+  const importPath = orchidCore.getImportPath(
+    filePath,
+    path.join(config.basePath, config.dbScript)
+  );
+  await promises.writeFile(filePath, content(importPath, name));
   (_a = config.logger) == null ? void 0 : _a.log(`Created ${orchidCore.pathToLog(filePath)}`);
 };
 const generate = async (config, [name]) => {
   if (!name)
     throw new Error("Migration name is missing");
   const version = makeFileTimeStamp();
-  await writeMigrationFile(config, version, name, makeContent(name));
+  await writeMigrationFile(config, version, name, makeContent);
 };
 const makeFileTimeStamp = () => {
   const now = /* @__PURE__ */ new Date();
@@ -1870,8 +1887,8 @@ const makeFileTimeStamp = () => {
     now.getUTCSeconds()
   ].map((value) => value < 10 ? `0${value}` : value).join("");
 };
-const makeContent = (name) => {
-  let content = `import { change } from 'rake-db';
+const makeContent = (importPath, name) => {
+  let content = `import { change } from '${importPath}';
 
 change(async (db) => {`;
   const [first, rest] = getFirstWordAndRest(name);
@@ -2795,8 +2812,7 @@ const astToMigration = (config, ast) => {
   }
   if (!first.length && !tablesAndViews.length && !constraints.length)
     return;
-  let code = `import { change } from 'rake-db';
-`;
+  let code = "";
   if (first.length) {
     code += `
 change(async (db) => {
@@ -2820,7 +2836,8 @@ ${orchidCore.codeToString(constraints, "  ", "  ")}
 });
 `;
   }
-  return code;
+  return (importPath) => `import { change } from '${importPath}';
+${code}`;
 };
 const createSchema = (ast) => {
   return `await db.createSchema(${orchidCore.singleQuote(ast.name)});`;
@@ -3010,9 +3027,20 @@ Append \`as\` method manually to ${count > 1 ? "these" : "this"} column${count >
   adapter.close();
 };
 
-const rakeDb = async (options, partialConfig = {}, args = process.argv.slice(2)) => {
-  var _a, _b, _c;
+const rakeDb = (options, partialConfig = {}, args = process.argv.slice(2)) => {
   const config = processRakeDbConfig(partialConfig);
+  const promise = runCommand(options, config, args);
+  return Object.assign(
+    (fn) => {
+      pushChange(fn);
+    },
+    {
+      promise
+    }
+  );
+};
+const runCommand = async (options, config, args = process.argv.slice(2)) => {
+  var _a, _b, _c;
   const command = (_a = args[0]) == null ? void 0 : _a.split(":")[0];
   try {
     if (command === "create") {
@@ -3074,7 +3102,6 @@ Migrate and rollback common arguments:
 `;
 
 exports.MigrationBase = MigrationBase;
-exports.change = change;
 exports.changeCache = changeCache;
 exports.createDb = createDb;
 exports.createMigrationInterface = createMigrationInterface;