uql-orm 0.63.0 → 0.64.0

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/migrationFile.d.ts

@@ -28,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;

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 } });
 `,

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

package/dist/migrate/generator/mongoCommand.d.ts

@@ -1,12 +1,18 @@
 /** The direction, or `'text'`, of one field in a MongoDB index key spec. */
 export type MongoIndexKey = Record<string, 1 | -1 | 'text'>;
+/** What a `createIndex` command hands the driver beside its key spec. */
+export type MongoIndexOptions = {
+    readonly unique: boolean;
+    readonly name: string;
+    readonly partialFilterExpression?: Readonly<Record<string, unknown>>;
+};
 /**
  * `SchemaGenerator` yields one string per statement, so {@link MongoSchemaGenerator} emits its
  * commands as JSON and this is their schema.
  *
  * Declared next to the generator that writes them because the migrator used to restate the shape
  * inline from `JSON.parse`, with `cmd.name!` assertions and a bare `action: string` - where a command
- * it had no branch for (`renameCollection`) was silently a no-op.
+ * it had no branch for was silently a no-op.
  */
 export type MongoCommand = {
     readonly action: 'createCollection';
@@ -23,10 +29,7 @@ export type MongoCommand = {
     readonly collection: string;
     readonly name: string;
     readonly key: MongoIndexKey;
-    readonly options: {
-        readonly unique: boolean;
-        readonly name: string;
-    };
+    readonly options: MongoIndexOptions;
 } | {
     readonly action: 'dropIndex';
     readonly collection: string;
@@ -43,10 +46,7 @@ export type MongoCommandTarget = {
     renameCollection(from: string, to: string): Promise<unknown>;
     collection(name: string): {
         drop(): Promise<unknown>;
-        createIndex(key: MongoIndexKey, options: {
-            unique: boolean;
-            name: string;
-        }): Promise<unknown>;
+        createIndex(key: MongoIndexKey, options: MongoIndexOptions): Promise<unknown>;
         dropIndex(name: string): Promise<unknown>;
     };
 };

package/dist/migrate/generator/mongoCommand.js

@@ -27,7 +27,7 @@ export function runMongoCommand(db, statement) {
             return db.collection(command.collection).dropIndex(command.name);
         default:
             // Unreachable for a command this module produced; a hand-written statement lands here rather
-            // than being silently skipped, which is how `renameCollection` went unnoticed.
+            // than being silently skipped.
             throw unsupportedMongoCommand(statement);
     }
 }

package/dist/migrate/generator/mongoSchemaGenerator.d.ts

@@ -1,12 +1,9 @@
-import { AbstractDialect } from '../../dialect/abstractDialect.js';
-import type { ForeignKeyAction, IndexNode, TableNode } from '../../schema/types.js';
-import type { CreateSchemaOptions, FieldOptions, IndexSchema, InsertIdSource, NamingStrategy, SchemaDiff, SchemaGenerator, Type } from '../../type/index.js';
-import type { TableDefinition } from '../builder/types.js';
-export declare class MongoSchemaGenerator extends AbstractDialect implements SchemaGenerator {
+import { MongoDialect } from '../../mongo/mongoDialect.js';
+import type { ForeignKeyAction, TableNode } from '../../schema/types.js';
+import { type CreateSchemaOptions, type EntityWhereMeta, type IndexSchema, type NamingStrategy, type SchemaDiff, type SchemaGenerator, type Type } from '../../type/index.js';
+import type { AnyMigrationOperation } from '../builder/types.js';
+export declare class MongoSchemaGenerator extends MongoDialect implements SchemaGenerator {
     protected readonly defaultForeignKeyAction?: ForeignKeyAction | undefined;
-    readonly dialectName = "mongodb";
-    protected readonly featureDefaults: import("../../type/dialect.js").DialectFeatures;
-    readonly insertIdSource: InsertIdSource;
     constructor(namingStrategy?: NamingStrategy, defaultForeignKeyAction?: ForeignKeyAction | undefined);
     /** A collection has no SQL to render a check, a computed column or an index expression into. */
     compileDdl(): string;
@@ -19,13 +16,18 @@ export declare class MongoSchemaGenerator extends AbstractDialect implements Sch
     generateDropSchema(entities: readonly Type<object>[]): string[];
     private selected;
     /**
-     * The indexes `@Field({ index })` declares, as the collection would hold them.
-     *
-     * One owner because two paths need it: creating a collection, and working out which of its indexes
-     * are missing. Derived twice, they drifted the moment either changed how a name is settled.
+     * The indexes an entity declares, as the collection would hold them. One owner because two paths need
+     * it: creating a collection, and working out which of its indexes are missing.
+     */
+    private indexesOf;
+    /** One declared index, its members resolved to document paths and its `where` to a filter document. */
+    private indexSchema;
+    /**
+     * The JSON of the document `partialFilterExpression` takes, refused where the predicate reaches past
+     * what that holds or what a migration carries as JSON.
      */
-    private fieldIndexes;
-    generateCreateTable<E>(entity: Type<E>, _options?: {
+    compileIndexPredicate(where: EntityWhereMeta<object>, entity: Type<object>, indexName: string): string;
+    generateCreateTable<E extends object>(entity: Type<E>, _options?: {
         ifNotExists?: boolean;
     }): string[];
     generateDropTable(tableName: string): string;
@@ -35,20 +37,13 @@ export declare class MongoSchemaGenerator extends AbstractDialect implements Sch
      * MongoDB's key spec is where its index options live: `-1` for a descending entry and `'text'` for a
      * full-text index, which is what `$text` needs since a text index declares its own fields.
      *
-     * @remarks The SQL-only modifiers are refused rather than dropped, for the same reason the SQL
-     * dialects refuse each other's - a silently weaker index is worse than a clear failure. `where`
-     * included: MongoDB's partial indexes take a filter document, not a SQL predicate.
+     * @remarks The SQL-only options are refused by the checks the SQL dialects refuse each other's with - a
+     * silently weaker index is worse than a clear failure. `where` is the filter's JSON, as
+     * {@link compileIndexPredicate} writes it.
      */
     generateCreateIndex(tableName: string, index: IndexSchema): string;
     generateDropIndex(tableName: string, indexName: string): string;
-    getSqlType(fieldOptions: FieldOptions): string;
-    generateCreateTableFromNode(table: TableNode, _options?: {
-        ifNotExists?: boolean;
-    }): string[];
-    generateCreateIndexFromNode(index: IndexNode): string;
-    generateCreateTableFromDefinition(table: TableDefinition, _options?: {
-        ifNotExists?: boolean;
-    }): string[];
-    generateRenameTableSql(oldName: string, newName: string): string;
+    /** A collection and its indexes, which is all a document store has: a column, a constraint or SQL throws. */
+    generateOperation(operation: AnyMigrationOperation): string[];
     diffSchema(entity: Type<object>, currentTable: TableNode | undefined): SchemaDiff | undefined;
 }