uql-orm 0.20.2 → 0.22.0

package/dist/libsql/libsqlQuerierPool.js

@@ -1,5 +1,4 @@
-import { createClient } from '@libsql/client';
-import { AbstractSqlQuerierPool } from '../querier/index.js';
+import { AbstractHranaQuerierPool } from '../sqlite/hranaQuerierPool.js';
 import { LibsqlDialect } from './libsqlDialect.js';
 import { LibsqlQuerier } from './libsqlQuerier.js';
 /** Embedded replica: local `file:` DB + `syncUrl` remote - DDL should run on the remote (sqld). */
@@ -11,30 +10,32 @@ function remoteMigrationClientConfig(config) {
     const { syncUrl, url: _localUrl, ...rest } = config;
     return { ...rest, url: syncUrl };
 }
-export class LibsqlQuerierPool extends AbstractSqlQuerierPool {
-    client;
-    libsqlConfig;
+export class LibsqlQuerierPool extends AbstractHranaQuerierPool {
+    conf;
     constructor(conf, extra) {
         super(new LibsqlDialect({ namingStrategy: extra?.namingStrategy }), extra);
-        this.libsqlConfig = conf;
-        this.client = createClient(conf);
+        this.conf = conf;
     }
-    async getQuerier() {
-        return new LibsqlQuerier(this.client, this.dialect, this.extra);
+    openClient() {
+        return this.createClient(this.conf);
+    }
+    buildQuerier(client, connection) {
+        return new LibsqlQuerier(client, this.dialect, this.extra, connection);
     }
     /**
      * For embedded replicas (`file:` + `syncUrl`), returns a querier connected to `syncUrl` so migrations hit sqld.
-     * Otherwise same as {@link getQuerier}. The migrator calls this for `up`/`down`, `syncForce`, and `autoSync` DDL.
+     * Otherwise same as `getQuerier`. The migrator calls this for `up`/`down`, `syncForce`, and `autoSync` DDL.
      */
     async getMigrationQuerier() {
-        if (!libsqlUseRemoteForMigrations(this.libsqlConfig)) {
+        if (!libsqlUseRemoteForMigrations(this.conf)) {
             return this.getQuerier();
         }
-        const remote = createClient(remoteMigrationClientConfig(this.libsqlConfig));
-        return new LibsqlQuerier(remote, this.dialect, this.extra, { closeClientOnRelease: true });
+        const remote = await this.createClient(remoteMigrationClientConfig(this.conf));
+        return this.buildQuerier(remote, { closeClientOnRelease: true });
     }
-    async end() {
-        this.client.close();
+    /** Imported on use, so `uql-orm/libsql` loads without the optional `@libsql/client` peer installed. */
+    async createClient(conf) {
+        const { createClient } = await import('@libsql/client');
+        return createClient(conf);
     }
 }
-//# sourceMappingURL=libsqlQuerierPool.js.map

package/dist/maria/index.d.ts

@@ -1,4 +1,3 @@
 export * from './mariaDialect.js';
 export * from './mariadbQuerier.js';
 export * from './mariadbQuerierPool.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/maria/index.js

@@ -1,4 +1,3 @@
 export * from './mariaDialect.js';
 export * from './mariadbQuerier.js';
 export * from './mariadbQuerierPool.js';
-//# sourceMappingURL=index.js.map

package/dist/maria/mariaDialect.d.ts

@@ -1,11 +1,16 @@
-import type { DialectOptions } from '../dialect/abstractDialect.js';
 import { MysqlLikeSqlDialect } from '../dialect/mysqlLikeSqlDialect.js';
-import type { QueryConflictPaths, QueryContext, QueryOptions, Type, VectorDistance } from '../type/index.js';
+import type { DialectFeatures, FieldOptions, IndexFeature, IndexSchema, QueryConflictPaths, QueryContext, Type, VectorDistance } from '../type/index.js';
 export declare class MariaDialect extends MysqlLikeSqlDialect {
     readonly dialectName = "mariadb";
     readonly insertIdSource = "returning";
-    constructor(options?: DialectOptions);
-    insert<E>(ctx: QueryContext, entity: Type<E>, payload: E | E[], opts?: QueryOptions): void;
+    /**
+     * MariaDB has no functional indexes: `CREATE INDEX ... ((lower(col)))` is a syntax error even on
+     * 12.3, where the documented workaround is a generated column. So it keeps the prefix lengths the
+     * family shares and drops expressions.
+     */
+    protected readonly indexFeatures: Set<IndexFeature>;
+    /** Unlike MySQL: `VECTOR(n)` takes its dimension, and its vector index is declared inline. */
+    protected readonly featureOverrides: Partial<DialectFeatures>;
     upsert<E>(ctx: QueryContext, entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E | E[]): void;
     /**
      * MariaDB supports neither MySQL's `->`/`->>` shorthand nor the base's chained form. `JSON_VALUE`
@@ -22,7 +27,23 @@ export declare class MariaDialect extends MysqlLikeSqlDialect {
     protected jsonPullElem(alias: string): string;
     /** Text-backed JSON compares as text, so use JSON_EQUALS for key-order-independent equality. */
     protected jsonPullKeep(alias: string, operand: string): string;
+    /** MariaDB's own names for the metrics its vector index accepts. */
+    private static readonly INLINE_VECTOR_METRICS;
     /** MariaDB 11.7+ vector distance functions. */
     protected readonly vectorDistanceFns: ReadonlyMap<VectorDistance, string>;
+    /**
+     * A `VECTOR` column holds a packed little-endian float32 blob, and MariaDB refuses text where one
+     * belongs: inserting `'[1,2,3]'` fails with `Incorrect vector value`, and passing it to
+     * `VEC_DISTANCE_COSINE` with `Illegal parameter data type varchar`. `VEC_FromText` is the
+     * conversion, needed on both paths.
+     */
+    protected appendVectorValue(ctx: QueryContext, value: readonly unknown[]): void;
+    /**
+     * MariaDB declares a vector index inside `CREATE TABLE`: `VECTOR INDEX (col) M=n DISTANCE=metric`.
+     * Its metric names are its own (`euclidean`, not `l2`), and an unsupported one throws rather than
+     * being dropped, which would silently build the index on cosine instead.
+     */
+    getInlineVectorIndexDeclaration(index: IndexSchema): string;
+    /** The reverse: selecting a `VECTOR` column raw yields that blob, so it is read back as text. */
+    protected selectFieldExpr(escapedColumn: string, field: FieldOptions): string;
 }
-//# sourceMappingURL=mariaDialect.d.ts.map

package/dist/maria/mariaDialect.js

@@ -1,36 +1,35 @@
 import { jsonPath } from '../dialect/jsonSql.js';
 import { MysqlLikeSqlDialect } from '../dialect/mysqlLikeSqlDialect.js';
+import { isVectorFieldType } from '../dialect/vectorCast.js';
 import { getMeta } from '../entity/index.js';
 export class MariaDialect extends MysqlLikeSqlDialect {
     dialectName = 'mariadb';
     // MariaDB 10.5+ supports `INSERT ... RETURNING` (see `insert` below), so IDs are exact per row.
     insertIdSource = 'returning';
-    constructor(options = {}) {
-        super({
-            ...options,
-            driverCapabilities: {
-                vectorSupportsLength: true,
-                ...options.driverCapabilities,
-            },
-        });
-    }
-    insert(ctx, entity, payload, opts) {
-        super.insert(ctx, entity, payload, opts);
-        ctx.append(' ' + this.returningId(entity));
-    }
+    /**
+     * MariaDB has no functional indexes: `CREATE INDEX ... ((lower(col)))` is a syntax error even on
+     * 12.3, where the documented workaround is a generated column. So it keeps the prefix lengths the
+     * family shares and drops expressions.
+     */
+    indexFeatures = new Set(['prefixLength']);
+    /** Unlike MySQL: `VECTOR(n)` takes its dimension, and its vector index is declared inline. */
+    featureOverrides = {
+        vectorSupportsLength: true,
+        inlineVectorIndex: true,
+    };
     upsert(ctx, entity, conflictPaths, payload) {
         const meta = getMeta(entity);
         const updateCtx = this.createContext();
         const update = this.getUpsertUpdateAssignments(updateCtx, meta, conflictPaths, payload, (name) => `VALUES(${name})`);
         const returning = this.returningId(entity);
         if (update) {
-            super.insert(ctx, entity, payload);
+            this.appendInsertValues(ctx, entity, payload);
             ctx.append(` ON DUPLICATE KEY UPDATE ${update} ${returning}`);
             ctx.pushValue(...updateCtx.values);
         }
         else {
             const insertCtx = this.createContext();
-            super.insert(insertCtx, entity, payload);
+            this.appendInsertValues(insertCtx, entity, payload);
             ctx.append(insertCtx.sql.replace(/^INSERT/, 'INSERT IGNORE'));
             ctx.append(' ' + returning);
             ctx.pushValue(...insertCtx.values);
@@ -61,10 +60,49 @@ export class MariaDialect extends MysqlLikeSqlDialect {
     jsonPullKeep(alias, operand) {
         return `NOT JSON_EQUALS(${alias}.v, ${operand})`;
     }
+    /** MariaDB's own names for the metrics its vector index accepts. */
+    static INLINE_VECTOR_METRICS = new Map([
+        ['cosine', 'cosine'],
+        ['l2', 'euclidean'],
+    ]);
     /** MariaDB 11.7+ vector distance functions. */
     vectorDistanceFns = new Map([
         ['cosine', 'VEC_DISTANCE_COSINE'],
         ['l2', 'VEC_DISTANCE_EUCLIDEAN'],
     ]);
+    /**
+     * A `VECTOR` column holds a packed little-endian float32 blob, and MariaDB refuses text where one
+     * belongs: inserting `'[1,2,3]'` fails with `Incorrect vector value`, and passing it to
+     * `VEC_DISTANCE_COSINE` with `Illegal parameter data type varchar`. `VEC_FromText` is the
+     * conversion, needed on both paths.
+     */
+    appendVectorValue(ctx, value) {
+        ctx.append('VEC_FromText(');
+        super.appendVectorValue(ctx, value);
+        ctx.append(')');
+    }
+    /**
+     * MariaDB declares a vector index inside `CREATE TABLE`: `VECTOR INDEX (col) M=n DISTANCE=metric`.
+     * Its metric names are its own (`euclidean`, not `l2`), and an unsupported one throws rather than
+     * being dropped, which would silently build the index on cosine instead.
+     */
+    getInlineVectorIndexDeclaration(index) {
+        const columns = index.columns.map((entry) => this.indexColumnTarget(entry)).join(', ');
+        let clause = `VECTOR INDEX (${columns})`;
+        if (index.m !== undefined) {
+            clause += ` M=${index.m}`;
+        }
+        if (index.distance) {
+            const metric = MariaDialect.INLINE_VECTOR_METRICS.get(index.distance);
+            if (!metric) {
+                throw new TypeError(`${this.dialectName} does not support vector distance metric: ${index.distance} (index "${index.name}")`);
+            }
+            clause += ` DISTANCE=${metric}`;
+        }
+        return clause;
+    }
+    /** The reverse: selecting a `VECTOR` column raw yields that blob, so it is read back as text. */
+    selectFieldExpr(escapedColumn, field) {
+        return isVectorFieldType(field.type) ? `VEC_ToText(${escapedColumn})` : escapedColumn;
+    }
 }
-//# sourceMappingURL=mariaDialect.js.map

package/dist/maria/mariadbQuerier.d.ts

@@ -9,4 +9,3 @@ export declare class MariadbQuerier extends AbstractPoolQuerier<PoolConnection>
     internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, unknown>;
     protected releaseConn(conn: PoolConnection): Promise<void>;
 }
-//# sourceMappingURL=mariadbQuerier.d.ts.map

package/dist/maria/mariadbQuerier.js

@@ -28,4 +28,3 @@ export class MariadbQuerier extends AbstractPoolQuerier {
         await conn.release();
     }
 }
-//# sourceMappingURL=mariadbQuerier.js.map

package/dist/maria/mariadbQuerierPool.d.ts

@@ -11,4 +11,3 @@ export declare class MariadbQuerierPool extends AbstractSqlQuerierPool<MariadbQu
     end(): Promise<void>;
 }
 export {};
-//# sourceMappingURL=mariadbQuerierPool.d.ts.map

package/dist/maria/mariadbQuerierPool.js

@@ -23,4 +23,3 @@ export class MariadbQuerierPool extends AbstractSqlQuerierPool {
         await this.pool.end();
     }
 }
-//# sourceMappingURL=mariadbQuerierPool.js.map

package/dist/migrate/acquireQuerierForMigrations.d.ts

@@ -6,4 +6,3 @@ import type { Querier, QuerierPool } from '../type/index.js';
  * app traffic (e.g. LibSQL embedded replica: local `file:` + remote `syncUrl`).
  */
 export declare function acquireQuerierForMigrations(pool: QuerierPool): Promise<Querier>;
-//# sourceMappingURL=acquireQuerierForMigrations.d.ts.map

package/dist/migrate/acquireQuerierForMigrations.js

@@ -7,4 +7,3 @@
 export async function acquireQuerierForMigrations(pool) {
     return (await pool.getMigrationQuerier?.()) ?? (await pool.getQuerier());
 }
-//# sourceMappingURL=acquireQuerierForMigrations.js.map

package/dist/migrate/assertCliConfig.d.ts

@@ -3,4 +3,3 @@ import type { Config } from '../type/index.js';
  * Validates shape required for the migrations CLI (real `QuerierPool`, not config stubs).
  */
 export declare function assertCliConfig(config: unknown): asserts config is Config;
-//# sourceMappingURL=assertCliConfig.d.ts.map

package/dist/migrate/assertCliConfig.js

@@ -28,4 +28,3 @@ export function assertCliConfig(config) {
         throw new TypeError('Config.pool.dialect.dialectName must be a string');
     }
 }
-//# sourceMappingURL=assertCliConfig.js.map

package/dist/migrate/bin.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=bin.d.ts.map

package/dist/migrate/bin.js

@@ -4,4 +4,3 @@ main(process.argv.slice(2)).catch((err) => {
     console.error(err);
     process.exit(1);
 });
-//# sourceMappingURL=bin.js.map

package/dist/migrate/builder/columnBuilder.d.ts

@@ -76,4 +76,3 @@ export declare class ColumnBuilder implements IColumnBuilder, IForeignKeyBuilder
      */
     build(): FullColumnDefinition;
 }
-//# sourceMappingURL=columnBuilder.d.ts.map

package/dist/migrate/builder/columnBuilder.js

@@ -156,4 +156,3 @@ export class ColumnBuilder {
         };
     }
 }
-//# sourceMappingURL=columnBuilder.js.map

package/dist/migrate/builder/expressions.d.ts

@@ -84,4 +84,3 @@ export declare const t: {
  * Handles SqlExpression vs literal values.
  */
 export declare function formatDefaultValue(value: unknown): string;
-//# sourceMappingURL=expressions.d.ts.map

package/dist/migrate/builder/expressions.js

@@ -147,4 +147,3 @@ export function formatDefaultValue(value) {
     }
     return String(value);
 }
-//# sourceMappingURL=expressions.js.map

package/dist/migrate/builder/index.d.ts

@@ -3,4 +3,3 @@ export * from './expressions.js';
 export * from './migrationBuilder.js';
 export * from './tableBuilder.js';
 export * from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/migrate/builder/index.js

@@ -3,4 +3,3 @@ export * from './expressions.js';
 export * from './migrationBuilder.js';
 export * from './tableBuilder.js';
 export * from './types.js';
-//# sourceMappingURL=index.js.map

package/dist/migrate/builder/migrationBuilder.d.ts

@@ -6,9 +6,9 @@
  * - MigrationBuilder: Execute DDL operations (for integration tests/runtime)
  */
 import type { ForeignKeyAction } from '../../schema/types.js';
-import type { NamingStrategy } from '../../type/namingStrategy.js';
+import type { IndexColumnInput, IndexOptions } from '../../type/index.js';
 import type { SqlQuerier } from '../../type/querier.js';
-import type { AnyMigrationOperation, IAlterTableBuilder, IColumnBuilder, IMigrationBuilder, ITableBuilder } from './types.js';
+import type { AnyMigrationOperation, IAlterTableBuilder, IColumnBuilder, IColumnFactory, IMigrationBuilder, ITableBuilder } from './types.js';
 /**
  * Records migration operations without executing them.
  * Use for migration code generation and dry-run scenarios.
@@ -22,15 +22,11 @@ export declare class OperationRecorder implements IMigrationBuilder {
     }): Promise<void>;
     renameTable(oldName: string, newName: string): Promise<void>;
     alterTable(name: string, callback: (table: IAlterTableBuilder) => void): Promise<void>;
-    addColumn(tableName: string, columnName: string, callback: (column: IColumnBuilder) => void): Promise<void>;
+    addColumn(tableName: string, callback: (columns: IColumnFactory) => IColumnBuilder): Promise<void>;
     dropColumn(tableName: string, columnName: string): Promise<void>;
-    alterColumn(tableName: string, columnName: string, callback: (column: IColumnBuilder) => void): Promise<void>;
+    alterColumn(tableName: string, callback: (columns: IColumnFactory) => IColumnBuilder): Promise<void>;
     renameColumn(tableName: string, oldName: string, newName: string): Promise<void>;
-    createIndex(tableName: string, columns: string[], options?: {
-        name?: string;
-        unique?: boolean;
-        where?: string;
-    }): Promise<void>;
+    createIndex(tableName: string, columns: readonly IndexColumnInput[], options?: IndexOptions): Promise<void>;
     dropIndex(tableName: string, indexName: string): Promise<void>;
     addForeignKey(tableName: string, columns: string[], target: {
         table: string;
@@ -45,13 +41,6 @@ export declare class OperationRecorder implements IMigrationBuilder {
     getOperations(): AnyMigrationOperation[];
     recordOperationSync(operation: AnyMigrationOperation): void;
 }
-/**
- * Options for the migration builder.
- */
-export interface MigrationBuilderOptions {
-    /** Custom naming strategy for generated SQL */
-    namingStrategy?: NamingStrategy;
-}
 /**
  * Executes DDL operations via a SQL querier.
  * Use for integration tests and runtime schema management.
@@ -70,7 +59,7 @@ export interface MigrationBuilderOptions {
 export declare class MigrationBuilder extends OperationRecorder {
     private readonly querier;
     private readonly sqlGenerator;
-    constructor(querier: SqlQuerier, options?: MigrationBuilderOptions);
+    constructor(querier: SqlQuerier);
     recordOperationSync(operation: AnyMigrationOperation): void;
     raw(sql: string): Promise<void>;
     createTable(name: string, callback: (table: ITableBuilder) => void): Promise<void>;
@@ -79,15 +68,11 @@ export declare class MigrationBuilder extends OperationRecorder {
         cascade?: boolean;
     }): Promise<void>;
     renameTable(oldName: string, newName: string): Promise<void>;
-    addColumn(tableName: string, columnName: string, callback: (column: IColumnBuilder) => void): Promise<void>;
+    addColumn(tableName: string, callback: (columns: IColumnFactory) => IColumnBuilder): Promise<void>;
     dropColumn(tableName: string, columnName: string): Promise<void>;
-    alterColumn(tableName: string, columnName: string, callback: (column: IColumnBuilder) => void): Promise<void>;
+    alterColumn(tableName: string, callback: (columns: IColumnFactory) => IColumnBuilder): Promise<void>;
     renameColumn(tableName: string, oldName: string, newName: string): Promise<void>;
-    createIndex(tableName: string, columns: string[], options?: {
-        name?: string;
-        unique?: boolean;
-        where?: string;
-    }): Promise<void>;
+    createIndex(tableName: string, columns: readonly IndexColumnInput[], options?: IndexOptions): Promise<void>;
     dropIndex(tableName: string, indexName: string): Promise<void>;
     addForeignKey(tableName: string, columns: string[], target: {
         table: string;
@@ -102,9 +87,3 @@ export declare class MigrationBuilder extends OperationRecorder {
     private execute;
     private operationToSql;
 }
-/**
- * Create an operation recorder for dry-run (recording only).
- * @deprecated Use `new OperationRecorder()` directly
- */
-export declare function createDryRunBuilder(): OperationRecorder;
-//# sourceMappingURL=migrationBuilder.d.ts.map

package/dist/migrate/builder/migrationBuilder.js

@@ -5,14 +5,41 @@
  * - OperationRecorder: Record operations only (for code generation)
  * - MigrationBuilder: Execute DDL operations (for integration tests/runtime)
  */
+import { normalizeIndexColumn } from '../../util/index.js';
 import { createSchemaGenerator } from '../schemaGenerator.js';
-import { ColumnBuilder } from './columnBuilder.js';
-import { splitSqlStatementsOnSemicolons } from './splitSqlStatements.js';
+import { splitSqlStatements } from './splitSqlStatements.js';
 import { TableBuilder } from './tableBuilder.js';
 /**
  * Builder for altering a table.
  * Delegates to parent builder for operation recording.
  */
+/**
+ * One `createIndex` operation. Shared because the alter-table builder, the recorder and the
+ * executing builder all record the same thing, and an entry left unnormalized reaches the generator
+ * as a column literally named `[object Object]`.
+ */
+function createIndexOperation(tableName, columns, options = {}) {
+    const { name, unique, ...index } = options;
+    const entries = columns.map(normalizeIndexColumn);
+    return {
+        type: 'createIndex',
+        tableName,
+        index: {
+            ...index,
+            name: name ?? `idx_${tableName}_${entries.map((entry) => entry.column).join('_')}`,
+            columns: entries,
+            unique: unique ?? false,
+        },
+    };
+}
+/**
+ * Declare one column through the same vocabulary `createTable` uses. A throwaway {@link TableBuilder}
+ * is that vocabulary: `addColumn`/`alterColumn` used to take a bare {@link IColumnBuilder}, which
+ * cannot express a type, so every column they recorded was hard-coded `VARCHAR`.
+ */
+function buildOneColumn(callback) {
+    return callback(new TableBuilder('')).build();
+}
 class AlterTableBuilder {
     tableName;
     parentBuilder;
@@ -20,13 +47,11 @@ class AlterTableBuilder {
         this.tableName = tableName;
         this.parentBuilder = parentBuilder;
     }
-    addColumn(name, callback) {
-        const builder = new ColumnBuilder(name, { category: 'string' });
-        callback(builder);
+    addColumn(callback) {
         this.parentBuilder.recordOperationSync({
             type: 'addColumn',
             tableName: this.tableName,
-            column: builder.build(),
+            column: buildOneColumn(callback),
         });
         return this;
     }
@@ -47,28 +72,18 @@ class AlterTableBuilder {
         });
         return this;
     }
-    alterColumn(name, callback) {
-        const builder = new ColumnBuilder(name, { category: 'string' });
-        callback(builder);
+    alterColumn(callback) {
+        const column = buildOneColumn(callback);
         this.parentBuilder.recordOperationSync({
             type: 'alterColumn',
             tableName: this.tableName,
-            columnName: name,
-            changes: builder.build(),
+            columnName: column.name,
+            changes: column,
         });
         return this;
     }
     addIndex(columns, options) {
-        const indexName = options?.name ?? `idx_${this.tableName}_${columns.join('_')}`;
-        this.parentBuilder.recordOperationSync({
-            type: 'createIndex',
-            tableName: this.tableName,
-            index: {
-                name: indexName,
-                columns,
-                unique: options?.unique ?? false,
-            },
-        });
+        this.parentBuilder.recordOperationSync(createIndexOperation(this.tableName, columns, options));
         return this;
     }
     dropIndex(name) {
@@ -142,13 +157,11 @@ export class OperationRecorder {
     // ============================================================================
     // Column Operations
     // ============================================================================
-    async addColumn(tableName, columnName, callback) {
-        const builder = new ColumnBuilder(columnName, { category: 'string' });
-        callback(builder);
+    async addColumn(tableName, callback) {
         this.recordOperationSync({
             type: 'addColumn',
             tableName,
-            column: builder.build(),
+            column: buildOneColumn(callback),
         });
     }
     async dropColumn(tableName, columnName) {
@@ -158,14 +171,13 @@ export class OperationRecorder {
             columnName,
         });
     }
-    async alterColumn(tableName, columnName, callback) {
-        const builder = new ColumnBuilder(columnName, { category: 'string' });
-        callback(builder);
+    async alterColumn(tableName, callback) {
+        const column = buildOneColumn(callback);
         this.recordOperationSync({
             type: 'alterColumn',
             tableName,
-            columnName,
-            changes: builder.build(),
+            columnName: column.name,
+            changes: column,
         });
     }
     async renameColumn(tableName, oldName, newName) {
@@ -179,18 +191,8 @@ export class OperationRecorder {
     // ============================================================================
     // Index Operations
     // ============================================================================
-    async createIndex(tableName, columns, options = {}) {
-        const indexName = options.name ?? `idx_${tableName}_${columns.join('_')}`;
-        this.recordOperationSync({
-            type: 'createIndex',
-            tableName,
-            index: {
-                name: indexName,
-                columns,
-                unique: options.unique ?? false,
-                where: options.where,
-            },
-        });
+    async createIndex(tableName, columns, options) {
+        this.recordOperationSync(createIndexOperation(tableName, columns, options));
     }
     async dropIndex(tableName, indexName) {
         this.recordOperationSync({
@@ -260,10 +262,10 @@ export class OperationRecorder {
 export class MigrationBuilder extends OperationRecorder {
     querier;
     sqlGenerator;
-    constructor(querier, options = {}) {
+    constructor(querier) {
         super();
         this.querier = querier;
-        const generator = createSchemaGenerator(querier.dialect, options.namingStrategy);
+        const generator = createSchemaGenerator(querier.dialect);
         if (!generator) {
             throw new TypeError(`Could not find a schema generator for dialect: ${querier.dialect.dialectName}`);
         }
@@ -314,13 +316,11 @@ export class MigrationBuilder extends OperationRecorder {
         this.operations.push(operation);
         await this.execute(operation);
     }
-    async addColumn(tableName, columnName, callback) {
-        const builder = new ColumnBuilder(columnName, { category: 'string' });
-        callback(builder);
+    async addColumn(tableName, callback) {
         const operation = {
             type: 'addColumn',
             tableName,
-            column: builder.build(),
+            column: buildOneColumn(callback),
         };
         this.operations.push(operation);
         await this.execute(operation);
@@ -334,14 +334,13 @@ export class MigrationBuilder extends OperationRecorder {
         this.operations.push(operation);
         await this.execute(operation);
     }
-    async alterColumn(tableName, columnName, callback) {
-        const builder = new ColumnBuilder(columnName, { category: 'string' });
-        callback(builder);
+    async alterColumn(tableName, callback) {
+        const column = buildOneColumn(callback);
         const operation = {
             type: 'alterColumn',
             tableName,
-            columnName,
-            changes: builder.build(),
+            columnName: column.name,
+            changes: column,
         };
         this.operations.push(operation);
         await this.execute(operation);
@@ -356,18 +355,8 @@ export class MigrationBuilder extends OperationRecorder {
         this.operations.push(operation);
         await this.execute(operation);
     }
-    async createIndex(tableName, columns, options = {}) {
-        const indexName = options.name ?? `idx_${tableName}_${columns.join('_')}`;
-        const operation = {
-            type: 'createIndex',
-            tableName,
-            index: {
-                name: indexName,
-                columns,
-                unique: options.unique ?? false,
-                where: options.where,
-            },
-        };
+    async createIndex(tableName, columns, options) {
+        const operation = createIndexOperation(tableName, columns, options);
         this.operations.push(operation);
         await this.execute(operation);
     }
@@ -420,7 +409,7 @@ export class MigrationBuilder extends OperationRecorder {
         }
         const sql = this.operationToSql(operation);
         if (sql) {
-            for (const statement of splitSqlStatementsOnSemicolons(sql)) {
+            for (const statement of splitSqlStatements(sql)) {
                 await this.querier.run(statement);
             }
         }
@@ -431,7 +420,7 @@ export class MigrationBuilder extends OperationRecorder {
                 // One line per statement in preview; execute() runs each separately (#87).
                 return this.getCreateTableStatements(operation).join('\n');
             case 'dropTable':
-                return this.sqlGenerator.generateDropTableSql(operation.tableName, {
+                return this.sqlGenerator.generateDropTable(operation.tableName, {
                     ifExists: operation.ifExists,
                     cascade: operation.cascade,
                 });
@@ -446,9 +435,9 @@ export class MigrationBuilder extends OperationRecorder {
             case 'alterColumn':
                 return this.sqlGenerator.generateAlterColumnSql(operation.tableName, operation.columnName, operation.changes);
             case 'createIndex':
-                return this.sqlGenerator.generateCreateIndexSql(operation.tableName, operation.index);
+                return this.sqlGenerator.generateCreateIndex(operation.tableName, operation.index);
             case 'dropIndex':
-                return this.sqlGenerator.generateDropIndexSql(operation.tableName, operation.indexName);
+                return this.sqlGenerator.generateDropIndex(operation.tableName, operation.indexName);
             case 'addForeignKey':
                 return this.sqlGenerator.generateAddForeignKeySql(operation.tableName, operation.foreignKey);
             case 'dropForeignKey':
@@ -460,11 +449,3 @@ export class MigrationBuilder extends OperationRecorder {
         }
     }
 }
-/**
- * Create an operation recorder for dry-run (recording only).
- * @deprecated Use `new OperationRecorder()` directly
- */
-export function createDryRunBuilder() {
-    return new OperationRecorder();
-}
-//# sourceMappingURL=migrationBuilder.js.map