rake-db 2.17.8 → 2.18.1

package/dist/index.d.ts

@@ -1,30 +1,227 @@
 import * as orchid_core from 'orchid-core';
-import { EmptyObject, RawSQLBase, ColumnSchemaConfig, MaybeArray, RecordString, ColumnTypeBase, RecordOptionalString } from 'orchid-core';
+import { MaybeArray, RawSQLBase, ColumnDataCheckBase, RecordString, EmptyObject, ColumnSchemaConfig, RecordOptionalString, ColumnTypeBase, ForeignKeyTable, Sql, MaybePromise } from 'orchid-core';
 import * as pqb from 'pqb';
-import { ColumnsShape, Db as Db$1, ColumnType, EnumColumn, raw, Adapter, IndexColumnOptions, IndexOptions, ForeignKeyOptions, DbResult, TransactionAdapter, QueryLogObject, TextColumn, TableData, NoPrimaryKeyOption, SingleColumnIndexOptions, DefaultColumnTypes, DefaultSchemaConfig, QueryLogOptions, AdapterOptions } from 'pqb';
+import { QueryArraysResult, ColumnsShape, Db as Db$1, TableData, NoPrimaryKeyOption, ColumnType, ForeignKeyOptions, SingleColumnIndexOptions, EnumColumn, raw, Adapter, IndexColumnOptions, IndexOptions, DbResult, TransactionAdapter, QueryLogObject, DbDomainArg, TextColumn, AdapterOptions, DefaultColumnTypes, DefaultSchemaConfig, QueryLogOptions, SearchWeight, ColumnsByType, ArrayColumn } from 'pqb';
 
+interface TableQuery {
+    text: string;
+    values?: unknown[];
+    then?(result: QueryArraysResult): void;
+}
 interface CreateTableResult<Table extends string, Shape extends ColumnsShape> {
     table: Db$1<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 {
+    interface Table extends TableData {
+        type: 'table';
+        action: 'create' | 'drop';
+        schema?: string;
+        name: string;
+        shape: ColumnsShape;
+        noPrimaryKey: NoPrimaryKeyOption;
+        createIfNotExists?: boolean;
+        dropIfExists?: boolean;
+        dropMode?: DropMode;
+        comment?: string;
+    }
+    interface ChangeTable {
+        type: 'changeTable';
+        schema?: string;
+        name: string;
+        comment?: string | [string, string] | null;
+        shape: ChangeTableShape;
+        add: TableData;
+        drop: TableData;
+    }
+    type ChangeTableShape = Record<string, MaybeArray<ChangeTableItem>>;
+    type ChangeTableItem = ChangeTableItem.Column | ChangeTableItem.Change | ChangeTableItem.Rename;
+    namespace ChangeTableItem {
+        interface Column {
+            type: 'add' | 'drop';
+            item: ColumnType;
+            dropMode?: DropMode;
+        }
+        interface Change {
+            type: 'change';
+            name?: string;
+            from: ColumnChange;
+            to: ColumnChange;
+            using?: ChangeUsing;
+        }
+        interface ChangeUsing {
+            usingUp?: RawSQLBase;
+            usingDown?: RawSQLBase;
+        }
+        interface Rename {
+            type: 'rename';
+            name: string;
+        }
+    }
+    interface ColumnChange {
+        column?: ColumnType;
+        type?: string;
+        collate?: string;
+        default?: unknown | RawSQLBase;
+        nullable?: boolean;
+        comment?: string | null;
+        compression?: string;
+        primaryKey?: boolean;
+        check?: ColumnDataCheckBase;
+        foreignKeys?: ({
+            table: string;
+            columns: string[];
+        } & ForeignKeyOptions)[];
+        indexes?: Omit<SingleColumnIndexOptions, 'column' | 'expression'>[];
+        identity?: TableData.Identity;
+    }
+    interface RenameType {
+        type: 'renameType';
+        kind: 'TABLE' | 'TYPE' | 'DOMAIN';
+        fromSchema?: string;
+        from: string;
+        toSchema?: string;
+        to: string;
+    }
+    interface Schema {
+        type: 'schema';
+        action: 'create' | 'drop';
+        name: string;
+    }
+    interface RenameSchema {
+        type: 'renameSchema';
+        from: string;
+        to: string;
+    }
+    interface ExtensionArg {
+        version?: string;
+        cascade?: boolean;
+        createIfNotExists?: boolean;
+        dropIfExists?: boolean;
+    }
+    interface Extension extends ExtensionArg {
+        type: 'extension';
+        action: 'create' | 'drop';
+        schema?: string;
+        name: string;
+    }
+    interface Enum {
+        type: 'enum';
+        action: 'create' | 'drop';
+        schema?: string;
+        name: string;
+        values: [string, ...string[]];
+        cascade?: boolean;
+        dropIfExists?: boolean;
+    }
+    interface EnumValues {
+        type: 'enumValues';
+        action: 'add' | 'drop';
+        schema?: string;
+        name: string;
+        values: string[];
+        place?: 'before' | 'after';
+        relativeTo?: string;
+        ifNotExists?: boolean;
+    }
+    interface RenameEnumValues {
+        type: 'renameEnumValues';
+        schema?: string;
+        name: string;
+        values: RecordString;
+    }
+    interface ChangeEnumValues {
+        type: 'changeEnumValues';
+        schema?: string;
+        name: string;
+        fromValues: string[];
+        toValues: string[];
+    }
+    interface Domain {
+        type: 'domain';
+        action: 'create' | 'drop';
+        schema?: string;
+        name: string;
+        baseType: ColumnType;
+    }
+    interface Collation {
+        type: 'collation';
+        action: 'create' | 'drop';
+        schema?: string;
+        name: string;
+        locale?: string;
+        lcCollate?: string;
+        lcCType?: string;
+        provider?: string;
+        deterministic?: boolean;
+        version?: string;
+        fromExisting?: string;
+        createIfNotExists?: boolean;
+        dropIfExists?: boolean;
+        cascade?: boolean;
+    }
+    interface EnumOptions {
+        createIfNotExists?: boolean;
+        dropIfExists?: boolean;
+    }
+    interface Constraint extends TableData.Constraint {
+        type: 'constraint';
+        action: 'create' | 'drop';
+        tableSchema?: string;
+        tableName: string;
+    }
+    interface RenameTableItem {
+        type: 'renameTableItem';
+        kind: 'INDEX' | 'CONSTRAINT';
+        tableSchema?: string;
+        tableName: string;
+        from: string;
+        to: string;
+    }
+    interface View {
+        type: 'view';
+        action: 'create' | 'drop';
+        schema?: string;
+        name: string;
+        shape: ColumnsShape;
+        sql: RawSQLBase;
+        options: ViewOptions;
+        deps: {
+            schemaName: string;
+            name: string;
+        }[];
+    }
+    interface ViewOptions {
+        createOrReplace?: boolean;
+        dropIfExists?: boolean;
+        dropMode?: DropMode;
+        temporary?: boolean;
+        recursive?: boolean;
+        columns?: string[];
+        with?: {
+            checkOption?: 'LOCAL' | 'CASCADED';
+            securityBarrier?: boolean;
+            securityInvoker?: boolean;
+        };
+    }
+}
+
 declare function add(item: ColumnType, options?: {
     dropMode?: DropMode;
-}): RakeDbAst.ChangeTableItem.Column;
+}): number;
 declare function add(emptyObject: EmptyObject): EmptyObject;
 declare function add(items: Record<string, ColumnType>, options?: {
     dropMode?: DropMode;
 }): Record<string, RakeDbAst.ChangeTableItem.Column>;
 type Change = RakeDbAst.ChangeTableItem.Change & ChangeOptions;
-type ChangeOptions = {
-    usingUp?: RawSQLBase;
-    usingDown?: RawSQLBase;
-};
+type ChangeOptions = RakeDbAst.ChangeTableItem.ChangeUsing;
 type TableChangeMethods = typeof tableChangeMethods;
 declare const tableChangeMethods: {
     name(this: RakeDbColumnTypes, name: string): any;
     add: typeof add;
     drop: typeof add;
-    change(from: ColumnType | Change, to: ColumnType | Change, options?: ChangeOptions): Change;
+    change(from: ColumnType | Change, to: ColumnType | Change, using?: ChangeOptions): Change;
     default(value: unknown | RawSQLBase): Change;
     nullable(): Change;
     nonNullable(): Change;
@@ -46,9 +243,8 @@ type TableOptions = {
     language?: string;
 };
 type TextColumnCreator = (min?: number, max?: number) => TextColumn<ColumnSchemaConfig>;
-type MigrationColumnTypes<CT> = Omit<CT, 'text' | 'string' | 'enum'> & {
+type MigrationColumnTypes<CT> = Omit<CT, 'text' | 'citext' | 'enum'> & {
     text: TextColumnCreator;
-    string: TextColumnCreator;
     citext: TextColumnCreator;
     enum: (name: string) => EnumColumn<ColumnSchemaConfig, unknown>;
 };
@@ -99,9 +295,8 @@ type DbMigration<CT extends RakeDbColumnTypes> = DbResult<CT> & Migration<CT> &
  * @param tx - database adapter that executes inside a transaction
  * @param up - migrate or rollback
  * @param config - config of `rakeDb`
- * @param asts - array of migration ASTs to collect changes into
  */
-declare const createMigrationInterface: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT extends RakeDbColumnTypes>(tx: TransactionAdapter, up: boolean, config: RakeDbConfig<SchemaConfig, CT>, asts: RakeDbAst[]) => DbMigration<CT>;
+declare const createMigrationInterface: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT extends RakeDbColumnTypes>(tx: TransactionAdapter, up: boolean, config: RakeDbConfig<SchemaConfig, CT>) => DbMigration<CT>;
 interface MigrationAdapter extends TransactionAdapter {
     schema: string;
 }
@@ -110,7 +305,6 @@ declare class Migration<CT extends RakeDbColumnTypes> {
     log?: QueryLogObject;
     up: boolean;
     options: RakeDbConfig<ColumnSchemaConfig>;
-    migratedAsts: RakeDbAst[];
     columnTypes: CT;
     /**
      * `createTable` accepts a string for a table name, optional options, and a callback to specify columns.
@@ -348,6 +542,23 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      * @param options - index options
      */
     dropIndex(tableName: string, columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): Promise<void>;
+    /**
+     * Rename index:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   // tableName can be prefixed with a schema
+     *   await db.renameIndex('tableName', 'oldIndexName', 'newIndexName');
+     * });
+     * ```
+     *
+     * @param tableName - table which this index belongs to
+     * @param from - rename the index from
+     * @param to - rename the index to
+     */
+    renameIndex(tableName: string, from: string, to: string): Promise<void>;
     /**
      * Add a foreign key to a table on migrating, and remove it on rollback.
      *
@@ -487,6 +698,26 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      * @param constraint - constraint config object
      */
     dropConstraint(tableName: string, constraint: ConstraintArg): Promise<void>;
+    /**
+     * Rename a table constraint, such as primary key, or check.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.renameConstraint(
+     *     'tableName', // may include schema: 'schema.table'
+     *     'oldConstraintName',
+     *     'newConstraintName',
+     *   );
+     * });
+     * ```
+     *
+     * @param tableName - name of the table containing the constraint, may include schema name, may include schema name
+     * @param from - current name of the constraint
+     * @param to - desired name
+     */
+    renameConstraint(tableName: string, from: string, to: string): Promise<void>;
     /**
      * Rename a column:
      *
@@ -519,6 +750,21 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      * @param schemaName - name of the schema
      */
     createSchema(schemaName: string): Promise<void>;
+    /**
+     * Renames a database schema, renames it backwards on roll back.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.renameSchema('from', 'to');
+     * });
+     * ```
+     *
+     * @param from - existing schema to rename
+     * @param to - desired schema name
+     */
+    renameSchema(from: string, to: string): Promise<void>;
     /**
      * Drop the schema, create it on rollback. See {@link createSchema}.
      *
@@ -541,14 +787,14 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      * @param name - name of the extension
      * @param options - extension options
      */
-    createExtension(name: string, options?: Omit<RakeDbAst.Extension, 'type' | 'action' | 'name'>): Promise<void>;
+    createExtension(name: string, options?: RakeDbAst.ExtensionArg): Promise<void>;
     /**
      * Drop the extension, create it on rollback. See {@link createExtension}.
      *
      * @param name - name of the extension
      * @param options - extension options
      */
-    dropExtension(name: string, options?: Omit<RakeDbAst.Extension, 'type' | 'action' | 'name' | 'values'>): Promise<void>;
+    dropExtension(name: string, options?: RakeDbAst.ExtensionArg): Promise<void>;
     /**
      * `createEnum` creates an enum on migrate, drops it on rollback.
      *
@@ -720,45 +966,62 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      */
     changeTypeSchema(name: string, from: string, to: string): Promise<void>;
     /**
-     * Domain is a custom database type that allows to predefine a `NOT NULL` and a `CHECK` (see [postgres tutorial](https://www.postgresqltutorial.com/postgresql-tutorial/postgresql-user-defined-data-types/)).
+     * Domain is a custom database type that is based on other type and can include `NOT NULL` and a `CHECK` (see [postgres tutorial](https://www.postgresqltutorial.com/postgresql-tutorial/postgresql-user-defined-data-types/)).
+     *
+     * Construct a column type in the function as the second argument.
      *
-     * `createDomain` and `dropDomain` take a domain name as first argument, callback returning inner column type as a second, and optional object with parameters as third.
+     * Specifiers [nullable](/guide/common-column-methods.html#nullable), [default](/guide/common-column-methods.html#default), [check](/guide/migration-column-methods.html#check), [collate](/guide/migration-column-methods.html#collate)
+     * will be saved to the domain type on database level.
      *
      * ```ts
      * import { change } from '../dbScript';
      *
      * change(async (db) => {
-     *   await db.createDomain('domainName', (t) => t.integer(), {
-     *     check: db.sql`value = 42`,
-     *   });
+     *   await db.createDomain('domainName', (t) =>
+     *     t.integer().check(db.sql`value = 42`),
+     *   );
      *
      *   // use `schemaName.domainName` format to specify a schema
-     *   await db.createDomain('schemaName.domainName', (t) => t.text(), {
-     *     // unlike columns, domain is nullable by default, use notNull when needed:
-     *     notNull: true,
-     *     collation: 'C',
-     *     default: db.sql`'default text'`,
-     *     check: db.sql`length(value) > 10`,
-     *
-     *     // cascade is used when dropping domain
-     *     cascade: true,
-     *   });
+     *   await db.createDomain('schemaName.domainName', (t) =>
+     *     t
+     *       .text()
+     *       .nullable()
+     *       .collate('C')
+     *       .default('default text')
+     *       .check(db.sql`length(value) > 10`),
+     *   );
      * });
      * ```
      *
      * @param name - name of the domain
-     * @param fn - function returning a column type for the domain
-     * @param options - domain options
+     * @param fn - function returning a column type. Options `nullable`, `collate`, `default`, `check` will be applied to domain
      */
-    createDomain(name: string, fn: (t: CT) => ColumnType, options?: Omit<RakeDbAst.Domain, 'type' | 'action' | 'schema' | 'name' | 'baseType'>): Promise<void>;
+    createDomain(name: string, fn: DbDomainArg<CT>): Promise<void>;
     /**
      * Drop the domain, create it on rollback. See {@link dropDomain}.
      *
      * @param name - name of the domain
-     * @param fn - function returning a column type for the domain
-     * @param options - domain options
+     * @param fn - function returning a column type. Options `nullable`, `collate`, `default`, `check` will be applied to domain
+     */
+    dropDomain(name: string, fn: DbDomainArg<CT>): Promise<void>;
+    /**
+     * To rename a domain:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.renameDomain('oldName', 'newName');
+     *
+     *   // to move domain to a different schema
+     *   await db.renameDomain('oldSchema.domain', 'newSchema.domain');
+     * });
+     * ```
+     *
+     * @param from - old domain name (can include schema)
+     * @param to - new domain name (can include schema)
      */
-    dropDomain(name: string, fn: (t: CT) => ColumnType, options?: Omit<RakeDbAst.Domain, 'type' | 'action' | 'schema' | 'name' | 'baseType'>): Promise<void>;
+    renameDomain(from: string, to: string): Promise<void>;
     /**
      * Create and drop a database collation, (see [Postgres docs](https://www.postgresql.org/docs/current/sql-createcollation.html)).
      *
@@ -968,7 +1231,7 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      */
     constraintExists(constraintName: string): Promise<boolean>;
 }
-declare const renameType: (migration: Migration<RakeDbColumnTypes>, from: string, to: string, table: boolean) => Promise<void>;
+declare const renameType: (migration: Migration<RakeDbColumnTypes>, from: string, to: string, kind: RakeDbAst.RenameType['kind']) => Promise<void>;
 interface AddEnumValueOptions {
     ifNotExists?: boolean;
     before?: string;
@@ -977,185 +1240,39 @@ interface AddEnumValueOptions {
 declare const addOrDropEnumValues: (migration: Migration<RakeDbColumnTypes>, up: boolean, enumName: string, values: string[], options?: AddEnumValueOptions) => Promise<void>;
 declare const changeEnumValues: (migration: Migration<RakeDbColumnTypes>, enumName: string, fromValues: string[], toValues: string[]) => Promise<void>;
 
-type RakeDbAst = RakeDbAst.Table | RakeDbAst.ChangeTable | RakeDbAst.RenameType | RakeDbAst.Schema | RakeDbAst.Extension | RakeDbAst.Enum | RakeDbAst.EnumValues | RakeDbAst.RenameEnumValues | RakeDbAst.ChangeEnumValues | RakeDbAst.Domain | RakeDbAst.Collation | RakeDbAst.Constraint | RakeDbAst.View;
-declare namespace RakeDbAst {
-    interface Table extends TableData {
-        type: 'table';
-        action: 'create' | 'drop';
-        schema?: string;
-        name: string;
-        shape: ColumnsShape;
-        noPrimaryKey: NoPrimaryKeyOption;
-        createIfNotExists?: boolean;
-        dropIfExists?: boolean;
-        dropMode?: DropMode;
-        comment?: string;
-    }
-    interface ChangeTable {
-        type: 'changeTable';
-        schema?: string;
-        name: string;
-        comment?: string | null;
-        shape: Record<string, ChangeTableItem>;
-        add: TableData;
-        drop: TableData;
-    }
-    type ChangeTableItem = ChangeTableItem.Column | ChangeTableItem.Change | ChangeTableItem.Rename;
-    namespace ChangeTableItem {
-        interface Column {
-            type: 'add' | 'drop';
-            item: ColumnType;
-            dropMode?: DropMode;
-        }
-        interface Change {
-            type: 'change';
-            name?: string;
-            from: ColumnChange;
-            to: ColumnChange;
-            using?: RawSQLBase;
-        }
-        interface Rename {
-            type: 'rename';
-            name: string;
-        }
-    }
-    interface ColumnChange {
-        column?: ColumnType;
-        type?: string;
-        collate?: string;
-        default?: unknown | RawSQLBase;
-        nullable?: boolean;
-        comment?: string | null;
-        compression?: string;
-        primaryKey?: boolean;
-        check?: RawSQLBase;
-        foreignKeys?: ({
-            table: string;
-            columns: string[];
-        } & ForeignKeyOptions)[];
-        indexes?: Omit<SingleColumnIndexOptions, 'column' | 'expression'>[];
-        identity?: TableData.Identity;
-    }
-    interface RenameType {
-        type: 'renameType';
-        table: boolean;
-        fromSchema?: string;
-        from: string;
-        toSchema?: string;
-        to: string;
-    }
-    interface Schema {
-        type: 'schema';
-        action: 'create' | 'drop';
-        name: string;
-    }
-    interface Extension {
-        type: 'extension';
-        action: 'create' | 'drop';
-        name: string;
-        schema?: string;
-        version?: string;
-        cascade?: boolean;
-        createIfNotExists?: boolean;
-        dropIfExists?: boolean;
-    }
-    interface Enum {
-        type: 'enum';
-        action: 'create' | 'drop';
-        schema?: string;
-        name: string;
-        values: [string, ...string[]];
-        cascade?: boolean;
-        dropIfExists?: boolean;
-    }
-    interface EnumValues {
-        type: 'enumValues';
-        action: 'add' | 'drop';
-        schema?: string;
-        name: string;
-        values: string[];
-        place?: 'before' | 'after';
-        relativeTo?: string;
-        ifNotExists?: boolean;
-    }
-    interface RenameEnumValues {
-        type: 'renameEnumValues';
-        schema?: string;
-        name: string;
-        values: RecordString;
-    }
-    interface ChangeEnumValues {
-        type: 'changeEnumValues';
-        schema?: string;
-        name: string;
-        fromValues: string[];
-        toValues: string[];
-    }
-    interface Domain {
-        type: 'domain';
-        action: 'create' | 'drop';
-        schema?: string;
-        name: string;
-        baseType: ColumnTypeBase;
-        notNull?: boolean;
-        collation?: string;
-        default?: RawSQLBase;
-        check?: RawSQLBase;
-        cascade?: boolean;
-    }
-    interface Collation {
-        type: 'collation';
-        action: 'create' | 'drop';
-        schema?: string;
-        name: string;
-        locale?: string;
-        lcCollate?: string;
-        lcCType?: string;
-        provider?: string;
-        deterministic?: boolean;
-        version?: string;
-        fromExisting?: string;
-        createIfNotExists?: boolean;
-        dropIfExists?: boolean;
-        cascade?: boolean;
-    }
-    interface EnumOptions {
-        createIfNotExists?: boolean;
-        dropIfExists?: boolean;
-    }
-    interface Constraint extends TableData.Constraint {
-        type: 'constraint';
-        action: 'create';
-        tableSchema?: string;
-        tableName: string;
-    }
-    interface View {
-        type: 'view';
-        action: 'create' | 'drop';
-        schema?: string;
-        name: string;
-        shape: ColumnsShape;
-        sql: RawSQLBase;
-        options: ViewOptions;
-    }
-    interface ViewOptions {
-        createOrReplace?: boolean;
-        dropIfExists?: boolean;
-        dropMode?: DropMode;
-        temporary?: boolean;
-        recursive?: boolean;
-        columns?: string[];
-        with?: {
-            checkOption?: 'LOCAL' | 'CASCADED';
-            securityBarrier?: boolean;
-            securityInvoker?: boolean;
-        };
-    }
-}
-
 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;
+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>) => 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;
@@ -1172,6 +1289,7 @@ interface MigrationsSet {
     migrations: MigrationItem[];
 }
 
+type CommandFn<SchemaConfig extends ColumnSchemaConfig, CT> = (options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>, args: string[]) => void | Promise<void>;
 interface RakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>> extends QueryLogOptions {
     schemaConfig: SchemaConfig;
     columnTypes: CT;
@@ -1184,11 +1302,9 @@ interface RakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColu
     migrationsTable: string;
     snakeCase: boolean;
     language?: string;
-    commands: Record<string, (options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>, args: string[]) => void | Promise<void>>;
+    commands: Record<string, CommandFn<SchemaConfig, CT>>;
     noPrimaryKey?: NoPrimaryKeyOption;
     baseTable?: RakeDbBaseTable<CT>;
-    appCodeUpdater?: AppCodeUpdater;
-    useCodeUpdater?: boolean;
     forceDefaultExports?: boolean;
     import(path: string): Promise<unknown>;
     beforeChange?: ChangeCallback$1;
@@ -1214,8 +1330,6 @@ interface InputRakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT> extends
     language?: string;
     commands?: Record<string, (options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT extends undefined ? DefaultColumnTypes<DefaultSchemaConfig> : CT>, args: string[]) => void | Promise<void>>;
     noPrimaryKey?: NoPrimaryKeyOption;
-    appCodeUpdater?: AppCodeUpdater;
-    useCodeUpdater?: boolean;
     forceDefaultExports?: boolean;
     import?(path: string): Promise<unknown>;
     /**
@@ -1307,23 +1421,6 @@ interface ModuleExportsRecord {
     [K: string]: () => Promise<unknown>;
 }
 type RakeDbMigrationId = 'serial' | 'timestamp';
-interface AppCodeUpdaterParams {
-    options: AdapterOptions;
-    basePath: string;
-    cache: object;
-    logger: QueryLogOptions['logger'];
-    baseTable: {
-        getFilePath(): string;
-        exportAs: string;
-    };
-    import(path: string): Promise<unknown>;
-}
-interface AppCodeUpdater {
-    process(params: AppCodeUpdaterParams & {
-        ast: RakeDbAst;
-    }): Promise<void>;
-    afterAll(params: AppCodeUpdaterParams): Promise<void>;
-}
 declare const migrationConfigDefaults: {
     schemaConfig: DefaultSchemaConfig;
     migrationsPath: string;
@@ -1334,7 +1431,6 @@ declare const migrationConfigDefaults: {
     import: (path: string) => Promise<any>;
     log: true;
     logger: Console;
-    useCodeUpdater: true;
 };
 declare const processRakeDbConfig: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(config: InputRakeDbConfig<SchemaConfig, CT>) => RakeDbConfig<SchemaConfig, CT>;
 declare const getDatabaseAndUserFromOptions: (options: AdapterOptions) => {
@@ -1346,12 +1442,15 @@ declare const createDb: <SchemaConfig extends ColumnSchemaConfig<orchid_core.Col
 declare const dropDb: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, 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, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT extends RakeDbColumnTypes>(options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
 
-declare const writeMigrationFile: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(config: RakeDbConfig<SchemaConfig, CT>, version: string, name: string, content: (importPath: string, name: string) => string) => Promise<void>;
-declare const generate: (config: AnyRakeDbConfig, [name]: string[]) => 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;
 
 type ChangeCallback<CT extends RakeDbColumnTypes> = (db: DbMigration<CT>, up: boolean) => Promise<void>;
+declare const clearChanges: () => void;
+declare const getCurrentChanges: () => ChangeCallback<RakeDbColumnTypes>[];
+declare const pushChange: (fn: ChangeCallback<RakeDbColumnTypes>) => number;
 
 declare const saveMigratedVersion: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, 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, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(db: SilentQueries, version: string, name: string, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
@@ -1364,14 +1463,14 @@ type RakeDbAppliedVersions = {
 declare const getMigratedVersionsMap: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(ctx: RakeDbCtx, adapter: Adapter | TransactionAdapter, config: RakeDbConfig<SchemaConfig, CT>, renameTo?: RakeDbMigrationId) => Promise<RakeDbAppliedVersions>;
 
 declare const RAKE_DB_LOCK_KEY = "8582141715823621641";
-type MigrateFn = <SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColumnTypes>(ctx: RakeDbCtx, options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>, args?: string[]) => Promise<void>;
+type MigrateFn = <SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColumnTypes>(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,
  * will apply `change` functions top-to-bottom.
  *
  * @param options - options to construct db adapter with
- * @param config - specifies how to load migrations, may have `appCodeUpdater`, callbacks, and logger.
- * @param args - pass none or `all` to run all migrations, pass int for how many to migrate, `--code` to enable and `--code false` to disable `useCodeUpdater`.
+ * @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;
 /**
@@ -1387,9 +1486,238 @@ declare const rollback: MigrateFn;
  * Takes the same options as {@link migrate}.
  */
 declare const redo: MigrateFn;
-declare const migrateOrRollback: (trx: TransactionAdapter, config: RakeDbConfig<ColumnSchemaConfig, RakeDbColumnTypes>, set: MigrationsSet, versions: RakeDbAppliedVersions, count: number, asts: RakeDbAst[], up: boolean, redo: boolean, force?: boolean, skipLock?: boolean) => Promise<void>;
+declare const migrateOrRollback: (trx: TransactionAdapter, config: RakeDbConfig<ColumnSchemaConfig, RakeDbColumnTypes>, set: MigrationsSet, versions: RakeDbAppliedVersions, count: number, up: boolean, redo: boolean, force?: boolean, skipLock?: boolean) => Promise<void>;
 declare const changeCache: Record<string, ChangeCallback<RakeDbColumnTypes>[] | undefined>;
 
+declare namespace DbStructure {
+    interface Table {
+        schemaName: string;
+        name: string;
+        comment?: string;
+        columns: Column[];
+    }
+    interface View {
+        schemaName: string;
+        name: string;
+        deps: RakeDbAst.View['deps'];
+        isRecursive: boolean;
+        with?: string[];
+        columns: Column[];
+        sql: string;
+    }
+    interface Procedure {
+        schemaName: string;
+        name: string;
+        returnSet: boolean;
+        returnType: string;
+        kind: string;
+        isTrigger: boolean;
+        types: string[];
+        argTypes: string[];
+        argModes: ('i' | 'o')[];
+        argNames?: string[];
+    }
+    interface Column {
+        schemaName: string;
+        tableName: string;
+        name: string;
+        typeSchema: string;
+        type: string;
+        isArray: boolean;
+        maxChars?: number;
+        numericPrecision?: number;
+        numericScale?: number;
+        dateTimePrecision?: number;
+        default?: string;
+        isNullable: boolean;
+        collate?: string;
+        compression?: 'pglz' | 'lz4';
+        comment?: string;
+        identity?: {
+            always: boolean;
+            start: number;
+            increment: number;
+            min?: number;
+            max?: number;
+            cache: number;
+            cycle: boolean;
+        };
+    }
+    interface Index {
+        schemaName: string;
+        tableName: string;
+        name: string;
+        using: string;
+        unique: boolean;
+        columns: (({
+            column: string;
+        } | {
+            expression: string;
+        }) & {
+            collate?: string;
+            opclass?: string;
+            order?: string;
+            weight?: SearchWeight;
+        })[];
+        include?: string[];
+        nullsNotDistinct?: boolean;
+        with?: string;
+        tablespace?: string;
+        where?: string;
+        tsVector?: boolean;
+        language?: string;
+        languageColumn?: string;
+    }
+    type ForeignKeyMatch = 'f' | 'p' | 's';
+    type ForeignKeyAction = 'a' | 'r' | 'c' | 'n' | 'd';
+    interface Constraint {
+        schemaName: string;
+        tableName: string;
+        name: string;
+        primaryKey?: string[];
+        references?: References;
+        check?: Check;
+    }
+    interface References {
+        foreignSchema: string;
+        foreignTable: string;
+        columns: string[];
+        foreignColumns: string[];
+        match: ForeignKeyMatch;
+        onUpdate: ForeignKeyAction;
+        onDelete: ForeignKeyAction;
+    }
+    interface Check {
+        columns?: string[];
+        expression: string;
+    }
+    interface Trigger {
+        schemaName: string;
+        tableName: string;
+        triggerSchema: string;
+        name: string;
+        events: string[];
+        activation: string;
+        condition?: string;
+        definition: string;
+    }
+    interface Extension {
+        schemaName: string;
+        name: string;
+        version?: string;
+    }
+    interface Enum {
+        schemaName: string;
+        name: string;
+        values: [string, ...string[]];
+    }
+    interface Domain {
+        schemaName: string;
+        name: string;
+        type: string;
+        typeSchema: string;
+        isArray: boolean;
+        isNullable: boolean;
+        maxChars?: number;
+        numericPrecision?: number;
+        numericScale?: number;
+        dateTimePrecision?: number;
+        collate?: string;
+        default?: string;
+        check?: string;
+    }
+    interface Collation {
+        schemaName: string;
+        name: string;
+        provider: string;
+        deterministic: boolean;
+        lcCollate?: string;
+        lcCType?: string;
+        locale?: string;
+        version?: string;
+    }
+}
+interface IntrospectedStructure {
+    schemas: string[];
+    tables: DbStructure.Table[];
+    views: DbStructure.View[];
+    indexes: DbStructure.Index[];
+    constraints: DbStructure.Constraint[];
+    triggers: DbStructure.Trigger[];
+    extensions: DbStructure.Extension[];
+    enums: DbStructure.Enum[];
+    domains: DbStructure.Domain[];
+    collations: DbStructure.Collation[];
+}
+declare function introspectDbSchema(db: Adapter): Promise<IntrospectedStructure>;
+
+interface DbStructureDomainsMap {
+    [K: string]: ColumnType;
+}
+interface StructureToAstCtx {
+    snakeCase?: boolean;
+    unsupportedTypes: Record<string, string[]>;
+    currentSchema: string;
+    columnSchemaConfig: ColumnSchemaConfig;
+    columnsByType: ColumnsByType;
+}
+interface StructureToAstTableData {
+    primaryKey?: TableData.PrimaryKey;
+    indexes: DbStructure.Index[];
+    constraints: DbStructure.Constraint[];
+}
+declare const makeStructureToAstCtx: (config: AnyRakeDbConfig, currentSchema: string) => StructureToAstCtx;
+declare const structureToAst: (ctx: StructureToAstCtx, adapter: Adapter) => 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, pqb.BaseOperators, unknown, unknown, any, unknown, any> | ArrayColumn<ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, ColumnType<orchid_core.ColumnTypeSchemaArg, unknown, any, pqb.BaseOperators, unknown, unknown, any, unknown, any>, unknown, unknown, unknown>;
+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;
+declare const getDbTableColumnsChecks: (tableData: StructureToAstTableData) => RecordString;
+declare const dbColumnToAst: (ctx: StructureToAstCtx, data: IntrospectedStructure, domains: DbStructureDomainsMap, tableName: string, item: DbStructure.Column, table?: DbStructure.Table, tableData?: StructureToAstTableData, checks?: RecordString) => [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 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;
+}) => 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;
+declare const getIndexName: (table: string, columns: ({
+    column?: string;
+} | {
+    expression: string;
+})[]) => string;
+declare const indexesToQuery: (up: boolean, { schema, name }: {
+    schema?: string;
+    name: string;
+}, indexes: TableData.Index[], language?: string) => Sql[];
+declare const commentsToQuery: (schemaTable: {
+    schema?: string;
+    name: string;
+}, comments: ColumnComment[]) => Sql[];
+declare const primaryKeyToSql: (primaryKey: Exclude<TableData['primaryKey'], undefined>) => string;
+
 /**
  * Type of {@link rakeDb} function
  */
@@ -1434,5 +1762,44 @@ type RakeDbChangeFn<CT extends RakeDbColumnTypes> = (fn: ChangeCallback<CT>) =>
  */
 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>;
 
-export { AnyRakeDbConfig, AppCodeUpdater, AppCodeUpdaterParams, ChangeTableCallback, ChangeTableOptions, ColumnComment, ColumnsShapeCallback, ConstraintArg, DbMigration, DropMode, InputRakeDbConfig, Migration, MigrationAdapter, MigrationColumnTypes, ModuleExportsRecord, NoMigrationsTableError, RAKE_DB_LOCK_KEY, RakeDbAppliedVersions, RakeDbAst, RakeDbBaseTable, RakeDbChangeFn, RakeDbColumnTypes, RakeDbConfig, RakeDbFn, RakeDbFnReturns, RakeDbLazyFn, RakeDbMigrationId, RakeDbResult, SilentQueries, TableOptions, addOrDropEnumValues, changeCache, changeEnumValues, createDb, createMigrationInterface, deleteMigratedVersion, dropDb, generate, generateTimeStamp, getDatabaseAndUserFromOptions, getMigratedVersionsMap, makeFileVersion, migrate, migrateOrRollback, migrationConfigDefaults, processRakeDbConfig, rakeDb, rakeDbAliases, redo, renameType, resetDb, rollback, saveMigratedVersion, writeMigrationFile };
+export { AnyRakeDbConfig, ChangeCallback, ChangeTableCallback, ChangeTableOptions, ColumnComment, ColumnsShapeCallback, CommandFn, ConstraintArg, DbMigration, DbStructure, DbStructureDomainsMap, DropMode, InputRakeDbConfig, IntrospectedStructure, Migration, MigrationAdapter, MigrationColumnTypes, ModuleExportsRecord, NoMigrationsTableError, RAKE_DB_LOCK_KEY, RakeDbAppliedVersions, RakeDbAst, RakeDbBaseTable, RakeDbChangeFn, RakeDbColumnTypes, RakeDbConfig, RakeDbCtx, RakeDbFn, RakeDbFnReturns, RakeDbLazyFn, RakeDbMigrationId, RakeDbResult, SilentQueries, StructureToAstCtx, StructureToAstTableData, TableOptions, addColumnComment, addColumnIndex, addOrDropEnumValues, astToMigration, changeCache, changeEnumValues, clearChanges, colors, columnToSql, columnTypeToSql, commentsToQuery, concatSchemaAndName, constraintToSql, createDb, createMigrationInterface, dbColumnToAst, deleteMigratedVersion, dropDb, encodeColumnDefault, exhaustive, generateTimeStamp, getColumnName, getConstraintName, getCurrentChanges, getDatabaseAndUserFromOptions, getDbStructureTableData, getDbTableColumnsChecks, getFirstWordAndRest, getForeignKeyTable, getIndexName, getMigratedVersionsMap, getSchemaAndTableFromName, getTextAfterFrom, getTextAfterTo, identityToSql, indexesToQuery, instantiateDbColumn, introspectDbSchema, joinColumns, joinWords, makeDbStructureColumnsShape, makeDomainsMap, makeFileVersion, makePopulateEnumQuery, makeStructureToAstCtx, migrate, migrateOrRollback, migrationConfigDefaults, newMigration, pluralize, primaryKeyToSql, processRakeDbConfig, promptConfirm, promptSelect, promptText, pushChange, queryLock, quoteNameFromString, quoteSchemaTable, quoteTable, quoteWithSchema, rakeDb, rakeDbAliases, rakeDbCommands, redo, referencesToSql, renameType, resetDb, rollback, saveMigratedVersion, structureToAst, tableToAst, transaction, versionToString, writeMigrationFile };