uql-orm 0.62.0 → 0.64.0

package/dist/libsql/libsqlQuerierPool.js

@@ -1,39 +1,51 @@
 import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
+import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
 import { HranaQuerier } from '../sqlite/hranaQuerier.js';
-import { AbstractHranaQuerierPool } from '../sqlite/hranaQuerierPool.js';
 import { LibsqlDialect } from './libsqlDialect.js';
-/** Embedded replica: local `file:` DB + `syncUrl` remote - DDL should run on the remote (sqld). */
-export function libsqlUseRemoteForMigrations(config) {
-    return Boolean(config.syncUrl && config.url.startsWith('file:'));
-}
-/** Remote-only client: same options as the replica, but `url` is `syncUrl` and embedded-replica fields are dropped. */
-function remoteMigrationClientConfig(config) {
-    const { syncUrl, url: _localUrl, ...rest } = config;
-    return { ...rest, url: syncUrl };
-}
-export class LibsqlQuerierPool extends AbstractHranaQuerierPool {
+/**
+ * Pool for libSQL. One client serves every querier, since Hrana keeps no per-connection state: a
+ * transaction takes its own session handle. The pool builds that client from `@libsql/client`'s
+ * `Config`, or shares one the caller built (`@libsql/client/web`, `@libsql/client-wasm`), which stays
+ * theirs to close.
+ */
+export class LibsqlQuerierPool extends AbstractSharedHandleQuerierPool {
     conf;
     constructor(conf, extra) {
         super(new LibsqlDialect(dialectOptionsFrom(extra)), extra);
         this.conf = conf;
     }
-    openClient() {
-        return this.createClient(this.conf);
+    async openDb() {
+        return 'execute' in this.conf ? this.conf : this.createClient(this.conf);
+    }
+    buildQuerier(client) {
+        return new HranaQuerier(client, this.dialect, this.extra);
+    }
+    async end() {
+        if (!('execute' in this.conf)) {
+            await super.end();
+        }
     }
     /**
-     * For embedded replicas (`file:` + `syncUrl`), returns a querier connected to `syncUrl` so migrations hit sqld.
-     * Otherwise same as `getQuerier`. The migrator calls this for `up`/`down`, `syncForce`, and `autoSync` DDL.
+     * For an embedded replica - a `file:` url with a `syncUrl` - a querier on the sync url, so migrations
+     * reach sqld, its client closing with it. Anything else migrates like any other querier.
      */
     async getMigrationQuerier() {
-        if (!libsqlUseRemoteForMigrations(this.conf)) {
+        if ('execute' in this.conf) {
             return this.getQuerier();
         }
-        const remote = await this.createClient(remoteMigrationClientConfig(this.conf));
-        return new HranaQuerier(remote, this.dialect, this.extra, { closeClientOnRelease: true });
+        const { syncUrl, url, ...remote } = this.conf;
+        if (!syncUrl || !url.startsWith('file:')) {
+            return this.getQuerier();
+        }
+        const client = await this.createClient({ ...remote, url: syncUrl });
+        return new HranaQuerier(client, this.dialect, this.extra, { closeClientOnRelease: true });
     }
-    /** Imported on use, so `uql-orm/libsql` loads without the optional `@libsql/client` peer installed. */
+    /**
+     * Imported on use, so `uql-orm/libsql` loads without the optional `@libsql/client` peer installed.
+     * Integers read as `bigint` whatever the config asks, so the querier decodes one past 2^53 exactly.
+     */
     async createClient(conf) {
         const { createClient } = await import('@libsql/client');
-        return createClient(conf);
+        return createClient({ ...conf, intMode: 'bigint' });
     }
 }

package/dist/migrate/builder/expressions.js

@@ -99,21 +99,7 @@ function defaultLiteral(value, dialect) {
     if (typeof value === 'boolean') {
         return dialect.booleanLiteral === 'native' ? (value ? 'TRUE' : 'FALSE') : value ? '1' : '0';
     }
-    if (value instanceof Date) {
-        return dialect.escape(ddlTimestamp(value));
-    }
-    if (typeof value === 'object') {
-        return dialect.escape(JSON.stringify(value));
-    }
-    return dialect.escape(value);
-}
-/**
- * `YYYY-MM-DD HH:mm:ss.SSS` in UTC. Not `toISOString`, whose `T` and `Z` MySQL rejects outright
- * ("Invalid default value"), and not `escape`'s local-time form, which would make the DDL depend on
- * the machine that generated it.
- */
-function ddlTimestamp(date) {
-    return date.toISOString().replace('T', ' ').replace('Z', '');
+    return dialect.escape(typeof value === 'object' && !(value instanceof Date) ? JSON.stringify(value) : value);
 }
 function expressionSql(expression, dialect) {
     const { expressions } = DIALECT_DEFAULTS[dialect.dialectName];

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

@@ -1,13 +1,6 @@
-/**
- * Migration Builder
- *
- * Provides type-safe migration operations with two modes:
- * - OperationRecorder: Record operations only (for code generation)
- * - MigrationBuilder: Execute DDL operations (for integration tests/runtime)
- */
 import type { ForeignKeyAction } from '../../schema/types.js';
 import type { IndexColumnInput, IndexOptions } from '../../type/index.js';
-import type { SqlQuerier } from '../../type/querier.js';
+import type { SchemaGenerator } from '../../type/migration.js';
 import type { AnyMigrationOperation, IAlterTableBuilder, IColumnBuilder, IColumnFactory, IMigrationBuilder, ITableBuilder } from './types.js';
 type ForeignKeyTarget = {
     table: string;
@@ -49,28 +42,13 @@ export declare class OperationRecorder implements IMigrationBuilder {
     getOperations(): AnyMigrationOperation[];
 }
 /**
- * Executes DDL operations via a SQL querier.
- * Use for integration tests and runtime schema management.
- *
- * @example
- * ```typescript
- * const builder = new MigrationBuilder(querier);
- *
- * await builder.createTable('users', (t) => {
- *   t.id();
- *   t.string('name');
- *   t.timestamps();
- * });
- * ```
+ * Records each operation, then runs the statements `generator` writes for it through `run`. Build one
+ * for a querier with `migrationBuilderFor`.
  */
 export declare class MigrationBuilder extends OperationRecorder {
-    private readonly querier;
-    private readonly sqlGenerator;
-    constructor(querier: SqlQuerier);
-    /** The recorder's sink, plus the statements the operation turns into. */
+    private readonly generator;
+    private readonly run;
+    constructor(generator: SchemaGenerator, run: (statement: string) => Promise<unknown>);
     protected record(operation: AnyMigrationOperation): Promise<void>;
-    private getCreateTableStatements;
-    private execute;
-    private operationToSql;
 }
 export {};

package/dist/migrate/builder/migrationBuilder.js

@@ -1,14 +1,5 @@
-/**
- * Migration Builder
- *
- * Provides type-safe migration operations with two modes:
- * - OperationRecorder: Record operations only (for code generation)
- * - MigrationBuilder: Execute DDL operations (for integration tests/runtime)
- */
 import { indexNameParts, normalizeIndexColumn } from '../../util/index.js';
 import { derivedIndexName } from '../../util/sql.util.js';
-import { createSchemaGenerator } from '../schemaGenerator.js';
-import { splitSqlStatements } from './splitSqlStatements.js';
 import { TableBuilder } from './tableBuilder.js';
 /**
  * One `createIndex` operation. Shared because the alter-table builder, the recorder and the
@@ -239,86 +230,21 @@ export class OperationRecorder {
     }
 }
 /**
- * Executes DDL operations via a SQL querier.
- * Use for integration tests and runtime schema management.
- *
- * @example
- * ```typescript
- * const builder = new MigrationBuilder(querier);
- *
- * await builder.createTable('users', (t) => {
- *   t.id();
- *   t.string('name');
- *   t.timestamps();
- * });
- * ```
+ * Records each operation, then runs the statements `generator` writes for it through `run`. Build one
+ * for a querier with `migrationBuilderFor`.
  */
 export class MigrationBuilder extends OperationRecorder {
-    querier;
-    sqlGenerator;
-    constructor(querier) {
+    generator;
+    run;
+    constructor(generator, run) {
         super();
-        this.querier = querier;
-        const generator = createSchemaGenerator(querier.dialect);
-        if (!generator) {
-            throw new TypeError(`Could not find a schema generator for dialect: ${querier.dialect.dialectName}`);
-        }
-        this.sqlGenerator = generator;
+        this.generator = generator;
+        this.run = run;
     }
-    /** The recorder's sink, plus the statements the operation turns into. */
     async record(operation) {
         await super.record(operation);
-        await this.execute(operation);
-    }
-    getCreateTableStatements(operation) {
-        return this.sqlGenerator.generateCreateTableFromDefinition(operation.table);
-    }
-    async execute(operation) {
-        if (operation.type === 'createTable') {
-            for (const statement of this.getCreateTableStatements(operation)) {
-                await this.querier.run(statement);
-            }
-            return;
-        }
-        const sql = this.operationToSql(operation);
-        if (sql) {
-            for (const statement of splitSqlStatements(sql)) {
-                await this.querier.run(statement);
-            }
-        }
-    }
-    operationToSql(operation) {
-        switch (operation.type) {
-            case 'createTable':
-                // One line per statement in preview; execute() runs each separately (#87).
-                return this.getCreateTableStatements(operation).join('\n');
-            case 'dropTable':
-                return this.sqlGenerator.generateDropTable(operation.tableName, {
-                    ifExists: operation.ifExists,
-                    cascade: operation.cascade,
-                });
-            case 'renameTable':
-                return this.sqlGenerator.generateRenameTableSql(operation.oldName, operation.newName);
-            case 'addColumn':
-                return this.sqlGenerator.generateAddColumnSql(operation.tableName, operation.column);
-            case 'dropColumn':
-                return this.sqlGenerator.generateDropColumnSql(operation.tableName, operation.columnName);
-            case 'renameColumn':
-                return this.sqlGenerator.generateRenameColumnSql(operation.tableName, operation.oldName, operation.newName);
-            case 'alterColumn':
-                return this.sqlGenerator.generateAlterColumnSql(operation.tableName, operation.columnName, operation.changes);
-            case 'createIndex':
-                return this.sqlGenerator.generateCreateIndexFromDefinition(operation.tableName, operation.index);
-            case 'dropIndex':
-                return this.sqlGenerator.generateDropIndex(operation.tableName, operation.indexName);
-            case 'addForeignKey':
-                return this.sqlGenerator.generateAddForeignKeySql(operation.tableName, operation.foreignKey);
-            case 'dropForeignKey':
-                return this.sqlGenerator.generateDropForeignKeySql(operation.tableName, operation.constraintName);
-            case 'raw':
-                return operation.sql;
-            default:
-                return undefined;
+        for (const statement of this.generator.generateOperation(operation)) {
+            await this.run(statement);
         }
     }
 }

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

@@ -116,20 +116,10 @@ export interface TableDefinition {
     /** Table comment */
     comment?: string;
 }
-/**
- * Type of migration operation.
- */
-export type MigrationOperationType = 'createTable' | 'dropTable' | 'renameTable' | 'alterTable' | 'addColumn' | 'dropColumn' | 'alterColumn' | 'renameColumn' | 'createIndex' | 'dropIndex' | 'addForeignKey' | 'dropForeignKey' | 'raw';
-/**
- * Base migration operation.
- */
-export interface MigrationOperation {
-    type: MigrationOperationType;
-}
 /**
  * Create table operation.
  */
-export interface CreateTableOperation extends MigrationOperation {
+export interface CreateTableOperation {
     type: 'createTable';
     table: TableDefinition;
     ifNotExists?: boolean;
@@ -137,7 +127,7 @@ export interface CreateTableOperation extends MigrationOperation {
 /**
  * Drop table operation.
  */
-export interface DropTableOperation extends MigrationOperation {
+export interface DropTableOperation {
     type: 'dropTable';
     tableName: string;
     ifExists?: boolean;
@@ -146,7 +136,7 @@ export interface DropTableOperation extends MigrationOperation {
 /**
  * Rename table operation.
  */
-export interface RenameTableOperation extends MigrationOperation {
+export interface RenameTableOperation {
     type: 'renameTable';
     oldName: string;
     newName: string;
@@ -154,7 +144,7 @@ export interface RenameTableOperation extends MigrationOperation {
 /**
  * Add column operation.
  */
-export interface AddColumnOperation extends MigrationOperation {
+export interface AddColumnOperation {
     type: 'addColumn';
     tableName: string;
     column: FullColumnDefinition;
@@ -162,7 +152,7 @@ export interface AddColumnOperation extends MigrationOperation {
 /**
  * Drop column operation.
  */
-export interface DropColumnOperation extends MigrationOperation {
+export interface DropColumnOperation {
     type: 'dropColumn';
     tableName: string;
     columnName: string;
@@ -170,7 +160,7 @@ export interface DropColumnOperation extends MigrationOperation {
 /**
  * Alter column operation.
  */
-export interface AlterColumnOperation extends MigrationOperation {
+export interface AlterColumnOperation {
     type: 'alterColumn';
     tableName: string;
     columnName: string;
@@ -179,7 +169,7 @@ export interface AlterColumnOperation extends MigrationOperation {
 /**
  * Rename column operation.
  */
-export interface RenameColumnOperation extends MigrationOperation {
+export interface RenameColumnOperation {
     type: 'renameColumn';
     tableName: string;
     oldName: string;
@@ -188,7 +178,7 @@ export interface RenameColumnOperation extends MigrationOperation {
 /**
  * Create index operation.
  */
-export interface CreateIndexOperation extends MigrationOperation {
+export interface CreateIndexOperation {
     type: 'createIndex';
     tableName: string;
     index: IndexDefinition;
@@ -197,7 +187,7 @@ export interface CreateIndexOperation extends MigrationOperation {
 /**
  * Drop index operation.
  */
-export interface DropIndexOperation extends MigrationOperation {
+export interface DropIndexOperation {
     type: 'dropIndex';
     tableName: string;
     indexName: string;
@@ -206,7 +196,7 @@ export interface DropIndexOperation extends MigrationOperation {
 /**
  * Add foreign key operation.
  */
-export interface AddForeignKeyOperation extends MigrationOperation {
+export interface AddForeignKeyOperation {
     type: 'addForeignKey';
     tableName: string;
     foreignKey: ForeignKeySchema;
@@ -214,7 +204,7 @@ export interface AddForeignKeyOperation extends MigrationOperation {
 /**
  * Drop foreign key operation.
  */
-export interface DropForeignKeyOperation extends MigrationOperation {
+export interface DropForeignKeyOperation {
     type: 'dropForeignKey';
     tableName: string;
     constraintName: string;
@@ -222,7 +212,7 @@ export interface DropForeignKeyOperation extends MigrationOperation {
 /**
  * Raw SQL operation (escape hatch).
  */
-export interface RawSqlOperation extends MigrationOperation {
+export interface RawSqlOperation {
     type: 'raw';
     sql: string;
 }
@@ -387,7 +377,7 @@ export interface IAlterTableBuilder {
  * Interface for the main migration builder.
  */
 export interface IMigrationBuilder {
-    /** Create a new table */
+    /** Create a table as `callback` declares it; on MongoDB a collection, whose callback declares only indexes. */
     createTable(name: string, callback: (table: ITableBuilder) => void): Promise<void>;
     /** Drop a table */
     dropTable(name: string, options?: {
@@ -420,6 +410,6 @@ export interface IMigrationBuilder {
     }): Promise<void>;
     /** Drop a foreign key */
     dropForeignKey(tableName: string, constraintName: string): Promise<void>;
-    /** Execute raw SQL */
+    /** Execute raw SQL, the escape hatch for anything the builder does not model. */
     raw(sql: string): Promise<void>;
 }

package/dist/migrate/cli.d.ts

@@ -1,11 +1,6 @@
 #!/usr/bin/env node
-import type { ForeignKeyAction } from '../schema/types.js';
-import type { Config, MigratorDialect } from '../type/index.js';
+import type { Config } from '../type/index.js';
 import { Migrator } from './migrator.js';
-import { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
-/** Sync helper for SQL dialects only; returns `undefined` for MongoDB - use {@link createSchemaGeneratorAsync}. */
-export declare function getSchemaGenerator(dialect: MigratorDialect, defaultForeignKeyAction?: ForeignKeyAction): import("./schemaGenerator.js").SqlSchemaGenerator | undefined;
-export { createSchemaGeneratorAsync };
 export declare function main(args?: string[]): Promise<void>;
 export declare function runUp(migrator: Migrator, args: string[]): Promise<void>;
 export declare function runDown(migrator: Migrator, args: string[]): Promise<void>;

package/dist/migrate/cli.js

@@ -7,14 +7,8 @@ import { createEntityCodeGenerator } from './codegen/entityCodeGenerator.js';
 import { entityTypesSource } from './codegen/entityTypes.js';
 import { detectDrift } from './drift/driftDetector.js';
 import { Migrator } from './migrator.js';
-import { buildEntityAST, createSchemaGenerator } from './schemaGenerator.js';
-import { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
+import { buildEntityAST } from './schemaGenerator.js';
 import { DEFAULT_MIGRATIONS_TABLE } from './storage/databaseStorage.js';
-/** Sync helper for SQL dialects only; returns `undefined` for MongoDB - use {@link createSchemaGeneratorAsync}. */
-export function getSchemaGenerator(dialect, defaultForeignKeyAction) {
-    return createSchemaGenerator(dialect, defaultForeignKeyAction);
-}
-export { createSchemaGeneratorAsync };
 export async function main(args = process.argv.slice(2)) {
     let customPath;
     const filteredArgs = [];
@@ -42,7 +36,6 @@ export async function main(args = process.argv.slice(2)) {
             defaultForeignKeyAction: config.defaultForeignKeyAction,
         };
         const migrator = new Migrator(config.pool, options);
-        await migrator.ensureSchemaGenerator();
         switch (command) {
             case 'up':
                 await runUp(migrator, filteredArgs.slice(1));
@@ -259,13 +252,13 @@ export async function runDriftCheck(migrator, config) {
         console.error('No entities configured. Add entities to your uql config.');
         process.exit(1);
     }
-    else if (!migrator.schemaIntrospector || !migrator.schemaGenerator) {
+    else if (!migrator.schemaIntrospector) {
         console.error('No introspector available. Check your pool configuration.');
         process.exit(1);
     }
     else {
         console.log('\nChecking for schema drift...');
-        const expectedAST = buildEntityAST(migrator.schemaGenerator, config.entities);
+        const expectedAST = buildEntityAST(await migrator.getSchemaGenerator(), config.entities);
         // Build actual schema from database
         const actualAST = await migrator.schemaIntrospector.introspect();
         // Detect drift. The dialect renders canonical types as SQL - without it every type formats as

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

@@ -5,4 +5,4 @@
  */
 export { createEntityCodeGenerator, EntityCodeGenerator, type EntityCodeGeneratorOptions, type GeneratedEntity, } from './entityCodeGenerator.js';
 export { entityTypesSource } from './entityTypes.js';
-export { buildMigrationModule, buildSqlQuerierMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitMongoCommandCalls, emitSqlRunCall, emitSqlRunCalls, type MigrationModuleOptions, type MigrationQuerierType, type SqlMigrationModuleOptions, } from './migrationFile.js';
+export { buildMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitMongoCommandCalls, emitSqlRunCall, emitSqlRunCalls, type MigrationModuleOptions, type MigrationQuerierType, } from './migrationFile.js';

package/dist/migrate/codegen/index.js

@@ -6,4 +6,4 @@
 // Entity code generator
 export { createEntityCodeGenerator, EntityCodeGenerator, } from './entityCodeGenerator.js';
 export { entityTypesSource } from './entityTypes.js';
-export { buildMigrationModule, buildSqlQuerierMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitMongoCommandCalls, emitSqlRunCall, emitSqlRunCalls, } from './migrationFile.js';
+export { buildMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitMongoCommandCalls, emitSqlRunCall, emitSqlRunCalls, } from './migrationFile.js';

package/dist/migrate/codegen/indexDecoratorSource.d.ts

@@ -7,7 +7,7 @@ import type { IndexNode } from '../../schema/types.js';
 export declare function isPlainFieldIndex(index: IndexNode): boolean;
 /**
  * One `@Index((user) => [...])` as source, for an index no `@Field` can express, its columns read off the
- * key map `param` names. Emits `raw(...)` for an expression entry, so callers import `raw` when
+ * refs `param` names. Emits `raw` for an expression entry, so callers import `raw` when
  * {@link indexNeedsRaw} holds.
  */
 export declare function buildIndexDecoratorSource(index: IndexNode, propertyName: (column: string) => string, param: string): string;

package/dist/migrate/codegen/indexDecoratorSource.js

@@ -1,3 +1,4 @@
+import { isVectorIndexType } from '../../type/index.js';
 import { isIdentifierName, quoted, rawTag } from './sourceLiteral.js';
 /**
  * A vector index carries its metric in the operator class pgvector names after it
@@ -54,12 +55,12 @@ export function isPlainFieldIndex(index) {
 }
 /**
  * One `@Index((user) => [...])` as source, for an index no `@Field` can express, its columns read off the
- * key map `param` names. Emits `raw(...)` for an expression entry, so callers import `raw` when
+ * refs `param` names. Emits `raw` for an expression entry, so callers import `raw` when
  * {@link indexNeedsRaw} holds.
  */
 export function buildIndexDecoratorSource(index, propertyName, param) {
     const entries = index.entries.map((entry) => indexEntrySource(entry, propertyName, param)).join(', ');
-    const isVector = index.type === 'hnsw' || index.type === 'ivfflat';
+    const isVector = isVectorIndexType(index.type);
     const distance = isVector ? vectorDistance(index) : undefined;
     const options = [];
     if (index.name)
@@ -88,12 +89,7 @@ export function indexNeedsRaw(index) {
     return Boolean(index.where) || index.entries.some((entry) => entry.expression);
 }
 function indexEntrySource(entry, propertyName, param) {
-    if (entry.expression) {
-        const expression = `() => ${rawTag(entry.column)}`;
-        const modifiers = significantModifiers(entry);
-        return modifiers.length === 0 ? expression : `{ column: ${expression}, ${modifiers.join(', ')} }`;
-    }
-    const column = memberSource(param, propertyName(entry.column));
+    const column = entry.expression ? rawTag(entry.column) : memberSource(param, propertyName(entry.column));
     const modifiers = significantModifiers(entry);
     return modifiers.length === 0 ? column : `{ column: ${column}, ${modifiers.join(', ')} }`;
 }

package/dist/migrate/codegen/migrationFile.d.ts

@@ -15,8 +15,6 @@ export type MigrationModuleOptions = {
     /** Indented body inside `async down` (including newlines). */
     downInner: string;
 };
-/** @deprecated Use {@link MigrationModuleOptions}. */
-export type SqlMigrationModuleOptions = MigrationModuleOptions;
 /**
  * Emit one `await querier.run(...)` line for entity-generated migrations.
  * Uses `JSON.stringify` so SQL with backticks (SQLite/LibSQL), quotes, `${`, etc. stays valid TS source.
@@ -30,14 +28,22 @@ export declare function emitMongoCommandCalls(statements: string[]): string;
 export declare const EMPTY_MANUAL_MIGRATION_UP_INNER = "    // Add your migration logic here.\n    // Use one await querier.run(\"...\") per SQL statement when possible (same style as generate:entities).\n    // Example (Postgres):\n    // await querier.run(\"CREATE TABLE \\\"users\\\" (\\\"id\\\" SERIAL PRIMARY KEY);\");\n";
 /** Body for `down` in a manual (empty) migration scaffold. */
 export declare const EMPTY_MANUAL_MIGRATION_DOWN_INNER = "    // Add your rollback logic here.\n    // await querier.run(\"DROP TABLE IF EXISTS \\\"users\\\";\");\n";
-/** How a migration on each querier is scaffolded empty, and how a generated statement is spelled in it. */
+/** How a migration on one querier is scaffolded empty, and how a generated statement is spelled in it. */
+export type MigrationSource = {
+    readonly querier: MigrationQuerierType;
+    readonly emptyUp: string;
+    readonly emptyDown: string;
+    emit(statements: string[]): string;
+};
 export declare const migrationSource: {
     SqlQuerier: {
+        querier: "SqlQuerier";
         emptyUp: string;
         emptyDown: string;
         emit: typeof emitSqlRunCalls;
     };
     MongoQuerier: {
+        querier: "MongoQuerier";
         emptyUp: string;
         emptyDown: string;
         emit: typeof emitMongoCommandCalls;
@@ -47,5 +53,3 @@ export declare const migrationSource: {
  * Full contents of a `export default { async up/down(querier) { ... } }` migration module.
  */
 export declare function buildMigrationModule(options: MigrationModuleOptions): string;
-/** @deprecated Use {@link buildMigrationModule}. */
-export declare const buildSqlQuerierMigrationModule: typeof buildMigrationModule;

package/dist/migrate/codegen/migrationFile.js

@@ -24,14 +24,15 @@ export const EMPTY_MANUAL_MIGRATION_UP_INNER = `    // Add your migration logic
 export const EMPTY_MANUAL_MIGRATION_DOWN_INNER = `    // Add your rollback logic here.
     // await querier.run("DROP TABLE IF EXISTS \\"users\\";");
 `;
-/** How a migration on each querier is scaffolded empty, and how a generated statement is spelled in it. */
 export const migrationSource = {
     SqlQuerier: {
+        querier: 'SqlQuerier',
         emptyUp: EMPTY_MANUAL_MIGRATION_UP_INNER,
         emptyDown: EMPTY_MANUAL_MIGRATION_DOWN_INNER,
         emit: emitSqlRunCalls,
     },
     MongoQuerier: {
+        querier: 'MongoQuerier',
         emptyUp: `    // Add your migration logic here, through the database handle.
     // await querier.db.collection('users').updateMany({}, { $set: { active: true } });
 `,
@@ -65,5 +66,3 @@ ${options.downInner}
 };
 `;
 }
-/** @deprecated Use {@link buildMigrationModule}. */
-export const buildSqlQuerierMigrationModule = buildMigrationModule;

package/dist/migrate/ddl/indexDdl.d.ts

@@ -1,6 +1,10 @@
 import type { AbstractSqlDialect } from '../../dialect/abstractSqlDialect.js';
 import { type IndexType } from '../../schema/types.js';
 import { type IndexColumnSchema, type IndexFeature, type IndexJsonArray, type IndexSchema } from '../../type/index.js';
+/** Refuses an index of a type `types` lacks, `hints` naming what to declare instead. */
+export declare function assertIndexType(index: IndexSchema, types: ReadonlySet<IndexType>, dialectName: string, hints?: ReadonlyMap<IndexType, string>): void;
+/** Refuses an index asking for a feature `features` lacks. */
+export declare function assertIndexFeatures(index: IndexSchema, features: ReadonlySet<IndexFeature>, dialectName: string): void;
 /**
  * `CREATE INDEX` for SQL dialects: the statement and the fragments each engine spells differently.
  * The migrator's rather than the dialect's, since {@link SqlSchemaGenerator} is the only thing that
@@ -28,8 +32,6 @@ export declare class IndexDdl<D extends AbstractSqlDialect = AbstractSqlDialect>
     protected readonly indexTypes: ReadonlySet<IndexType>;
     /** What to declare instead of a type this dialect lacks, appended to its refusal. */
     protected readonly indexTypeHints: ReadonlyMap<IndexType, string>;
-    private assertIndexType;
-    private assertIndexFeatures;
     /**
      * Index types this dialect spells as a keyword of their own (`FULLTEXT INDEX`, `VECTOR INDEX`)
      * rather than as an access method after the table. One table drives both, so a type that is a

package/dist/migrate/ddl/indexDdl.js

@@ -17,6 +17,20 @@ const INDEX_FEATURE_PROBES = {
     opsClass: (index) => index.entries.some((entry) => entry.opsClass !== undefined),
     include: (index) => Boolean(index.include?.length),
 };
+/** Refuses an index of a type `types` lacks, `hints` naming what to declare instead. */
+export function assertIndexType(index, types, dialectName, hints = new Map()) {
+    if (index.type && !types.has(index.type)) {
+        throw new TypeError(`${dialectName} has no ${index.type} index (index "${index.name}")` + (hints.get(index.type) ?? ''));
+    }
+}
+/** Refuses an index asking for a feature `features` lacks. */
+export function assertIndexFeatures(index, features, dialectName) {
+    for (const feature of getKeys(INDEX_FEATURE_PROBES)) {
+        if (INDEX_FEATURE_PROBES[feature](index) && !features.has(feature)) {
+            throw new TypeError(`${dialectName} does not support ${INDEX_FEATURE_LABELS[feature]} (index "${index.name}")`);
+        }
+    }
+}
 /**
  * `CREATE INDEX` for SQL dialects: the statement and the fragments each engine spells differently.
  * The migrator's rather than the dialect's, since {@link SqlSchemaGenerator} is the only thing that
@@ -30,8 +44,8 @@ export class IndexDdl {
         this.dialect = dialect;
     }
     getCreateIndexStatement(tableName, index, opts = {}) {
-        this.assertIndexType(index);
-        this.assertIndexFeatures(index);
+        assertIndexType(index, this.indexTypes, this.dialect.dialectName, this.indexTypeHints);
+        assertIndexFeatures(index, this.indexFeatures, this.dialect.dialectName);
         const unique = index.unique ? 'UNIQUE ' : '';
         const ifNotExists = (opts.ifNotExists ?? this.dialect.features.indexIfNotExists) ? 'IF NOT EXISTS ' : '';
         const columns = index.entries.map((entry) => this.indexColumn(entry, index)).join(', ');
@@ -57,19 +71,6 @@ export class IndexDdl {
     indexTypes = new Set(INDEX_TYPES);
     /** What to declare instead of a type this dialect lacks, appended to its refusal. */
     indexTypeHints = new Map();
-    assertIndexType(index) {
-        if (index.type && !this.indexTypes.has(index.type)) {
-            throw new TypeError(`${this.dialect.dialectName} has no ${index.type} index (index "${index.name}")` +
-                (this.indexTypeHints.get(index.type) ?? ''));
-        }
-    }
-    assertIndexFeatures(index) {
-        for (const feature of getKeys(INDEX_FEATURE_PROBES)) {
-            if (INDEX_FEATURE_PROBES[feature](index) && !this.indexFeatures.has(feature)) {
-                throw new TypeError(`${this.dialect.dialectName} does not support ${INDEX_FEATURE_LABELS[feature]} (index "${index.name}")`);
-            }
-        }
-    }
     /**
      * Index types this dialect spells as a keyword of their own (`FULLTEXT INDEX`, `VECTOR INDEX`)
      * rather than as an access method after the table. One table drives both, so a type that is a