uql-orm 0.63.0 → 0.65.0

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -1,16 +1,18 @@
-import { AbstractDialect } from '../../dialect/abstractDialect.js';
 import { getMeta } from '../../entity/index.js';
-import { mongoDialectFeatures } from '../../mongo/mongoDialect.js';
-import { getKeys } from '../../util/index.js';
+import { MongoDialect } from '../../mongo/mongoDialect.js';
+import { QueryRaw, } from '../../type/index.js';
+import { declaredIndexes, indexNameParts, renderIndexColumn } from '../../util/ddlExpression.util.js';
 import { derivedIndexName } from '../../util/sql.util.js';
+import { assertIndexFeatures, assertIndexType } from '../ddl/indexDdl.js';
+import { assertIndexPredicate, refusedIndexPredicate } from '../indexPredicate.js';
 import { renderIndexDefinition } from './definitionToNode.js';
-import { indexNodeToSchema } from './indexNodeToSchema.js';
 import { serializeMongoCommand } from './mongoCommand.js';
-export class MongoSchemaGenerator extends AbstractDialect {
+/** The index types a key spec can say: a plain key, or `'text'`. */
+const MONGO_INDEX_TYPES = new Set(['btree', 'fulltext']);
+/** A key spec's one feature beyond its keys: a partial filter. */
+const MONGO_INDEX_FEATURES = new Set(['partial']);
+export class MongoSchemaGenerator extends MongoDialect {
     defaultForeignKeyAction;
-    dialectName = 'mongodb';
-    featureDefaults = mongoDialectFeatures;
-    insertIdSource = 'returning';
     constructor(namingStrategy, defaultForeignKeyAction) {
         super({ namingStrategy });
         this.defaultForeignKeyAction = defaultForeignKeyAction;
@@ -38,113 +40,117 @@ export class MongoSchemaGenerator extends AbstractDialect {
         return entities.filter((entity) => wanted.has(this.resolveTableName(getMeta(entity))));
     }
     /**
-     * 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.
      */
-    fieldIndexes(meta, collectionName) {
-        return getKeys(meta.fields).flatMap((key) => {
-            const field = meta.fields[key];
-            if (!field?.index) {
-                return [];
-            }
-            const columnName = this.resolveColumnName(key, field);
-            return [
-                {
-                    name: typeof field.index === 'string' ? field.index : derivedIndexName(collectionName, [columnName]),
-                    entries: [{ column: columnName }],
-                    unique: !!field.unique,
-                },
-            ];
-        });
+    indexesOf(meta, collectionName) {
+        return declaredIndexes(meta).map((index) => this.indexSchema(meta, collectionName, index));
+    }
+    /** One declared index, its members resolved to document paths and its `where` to a filter document. */
+    indexSchema(meta, collectionName, index) {
+        const entries = index.columns
+            .map((entry) => renderIndexColumn(entry, () => this.compileDdl()))
+            .map((entry) => ({ ...entry, column: this.columnOf(meta, entry.column) }));
+        const name = index.name ?? derivedIndexName(collectionName, indexNameParts(entries));
+        return {
+            name,
+            entries,
+            unique: index.unique ?? false,
+            type: index.type,
+            include: index.include,
+            where: index.where && this.compileIndexPredicate(index.where, meta.entity, name),
+        };
+    }
+    /**
+     * The JSON of the document `partialFilterExpression` takes, refused where the predicate reaches past
+     * what that holds or what a migration carries as JSON.
+     */
+    compileIndexPredicate(where, entity, indexName) {
+        if (where instanceof QueryRaw) {
+            throw new TypeError(`mongodb does not support partial indexes from a SQL predicate (index "${indexName}")`);
+        }
+        assertIndexPredicate(where, this.dialectName, indexName);
+        const filter = this.renderFilter(entity, where);
+        const refused = refusedFilterValue(filter);
+        if (refused) {
+            throw refusedIndexPredicate(this.dialectName, refused, indexName);
+        }
+        return JSON.stringify(filter);
     }
     generateCreateTable(entity, _options) {
         const meta = getMeta(entity);
         const collectionName = this.resolveTableName(meta);
-        const indexes = this.fieldIndexes(meta, collectionName);
         // One `createIndex` command each, mirroring the SQL generator's `[CREATE TABLE, ...CREATE INDEX]`,
         // so the key spec is built here and the migrator only executes it.
         return [
             serializeMongoCommand({ action: 'createCollection', name: collectionName }),
-            ...indexes.map((index) => this.generateCreateIndex(collectionName, index)),
+            ...this.indexesOf(meta, collectionName).map((index) => this.generateCreateIndex(collectionName, index)),
         ];
     }
     generateDropTable(tableName) {
         return serializeMongoCommand({ action: 'dropCollection', name: tableName });
     }
     generateAlterTable(diff) {
-        const statements = [];
-        if (diff.indexesToAdd?.length) {
-            for (const index of diff.indexesToAdd) {
-                statements.push(this.generateCreateIndex(diff.tableName, index));
-            }
-        }
-        return statements;
+        return (diff.indexesToAdd ?? []).map((index) => this.generateCreateIndex(diff.tableName, index));
     }
     generateAlterTableDown(diff) {
-        const statements = [];
-        if (diff.indexesToAdd?.length) {
-            for (const index of diff.indexesToAdd) {
-                statements.push(this.generateDropIndex(diff.tableName, index.name));
-            }
-        }
-        return statements;
+        return (diff.indexesToAdd ?? []).map((index) => this.generateDropIndex(diff.tableName, index.name));
     }
     /**
      * 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, index) {
+        assertIndexType(index, MONGO_INDEX_TYPES, this.dialectName);
+        assertIndexFeatures(index, MONGO_INDEX_FEATURES, this.dialectName);
         const key = {};
         for (const entry of index.entries) {
-            if (entry.expression || entry.jsonArray || entry.length !== undefined || entry.nulls || entry.opsClass) {
-                throw new TypeError(`mongodb does not support that index column option (index "${index.name}")`);
-            }
             key[entry.column] = index.type === 'fulltext' ? 'text' : entry.order === 'desc' ? -1 : 1;
         }
-        if (index.where) {
-            throw new TypeError(`mongodb does not support partial indexes from a SQL predicate (index "${index.name}")`);
-        }
         return serializeMongoCommand({
             action: 'createIndex',
             collection: tableName,
             name: index.name,
             key,
-            options: { unique: index.unique, name: index.name },
+            options: {
+                unique: index.unique,
+                name: index.name,
+                partialFilterExpression: index.where && JSON.parse(index.where),
+            },
         });
     }
     generateDropIndex(tableName, indexName) {
-        return serializeMongoCommand({
-            action: 'dropIndex',
-            collection: tableName,
-            name: indexName,
-        });
-    }
-    getSqlType(fieldOptions) {
-        return '';
-    }
-    generateCreateTableFromNode(table, _options) {
-        return [
-            serializeMongoCommand({ action: 'createCollection', name: table.name }),
-            ...table.indexes.map((index) => this.generateCreateIndexFromNode(index)),
-        ];
-    }
-    generateCreateIndexFromNode(index) {
-        return this.generateCreateIndex(index.table.name, indexNodeToSchema(index));
-    }
-    generateCreateTableFromDefinition(table, _options) {
-        return [
-            serializeMongoCommand({ action: 'createCollection', name: table.name }),
-            ...table.indexes.map((index) => this.generateCreateIndex(table.name, renderIndexDefinition(index, () => this.compileDdl()))),
-        ];
-    }
-    generateRenameTableSql(oldName, newName) {
-        return serializeMongoCommand({ action: 'renameCollection', from: oldName, to: newName });
+        return serializeMongoCommand({ action: 'dropIndex', collection: tableName, name: indexName });
+    }
+    /** A collection and its indexes, which is all a document store has: a column, a constraint or SQL throws. */
+    generateOperation(operation) {
+        const render = (index) => renderIndexDefinition(index, () => this.compileDdl());
+        switch (operation.type) {
+            case 'createTable': {
+                const { name, columns, indexes } = operation.table;
+                if (columns.length) {
+                    throw new TypeError(`mongodb does not support columns in a migration (collection "${name}")`);
+                }
+                return [
+                    serializeMongoCommand({ action: 'createCollection', name }),
+                    ...indexes.map((index) => this.generateCreateIndex(name, render(index))),
+                ];
+            }
+            case 'dropTable':
+                return [this.generateDropTable(operation.tableName)];
+            case 'renameTable':
+                return [serializeMongoCommand({ action: 'renameCollection', from: operation.oldName, to: operation.newName })];
+            case 'createIndex':
+                return [this.generateCreateIndex(operation.tableName, render(operation.index))];
+            case 'dropIndex':
+                return [this.generateDropIndex(operation.tableName, operation.indexName)];
+            default:
+                throw new TypeError(`mongodb does not support ${operation.type} in a migration`);
+        }
     }
     diffSchema(entity, currentTable) {
         const meta = getMeta(entity);
@@ -153,7 +159,7 @@ export class MongoSchemaGenerator extends AbstractDialect {
             return { tableName: collectionName, type: 'create' };
         }
         const existingIndexes = new Set(currentTable.indexes.map((i) => i.name));
-        const indexesToAdd = this.fieldIndexes(meta, collectionName).filter((index) => !existingIndexes.has(index.name));
+        const indexesToAdd = this.indexesOf(meta, collectionName).filter((index) => !existingIndexes.has(index.name));
         if (indexesToAdd.length === 0) {
             return undefined;
         }
@@ -164,3 +170,20 @@ export class MongoSchemaGenerator extends AbstractDialect {
         };
     }
 }
+/** The first value `partialFilterExpression` refuses, `null`, or a migration cannot carry as JSON, such as a `Date`. */
+function refusedFilterValue(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (Array.isArray(value)) {
+        return value.map(refusedFilterValue).find(Boolean);
+    }
+    if (typeof value !== 'object') {
+        return typeof value === 'bigint' ? 'a bigint' : undefined;
+    }
+    if (Object.getPrototypeOf(value) === Object.prototype) {
+        return Object.values(value).map(refusedFilterValue).find(Boolean);
+    }
+    const typeName = value.constructor.name;
+    return `${/^[aeiou]/i.test(typeName) ? 'an' : 'a'} ${typeName}`;
+}

package/dist/migrate/index.d.ts

@@ -8,9 +8,9 @@ export * from './codegen/index.js';
 export * from './ddl/index.js';
 export * from './drift/index.js';
 export * from './introspection/index.js';
+export { migrationBuilderFor } from './migrationTarget.js';
 export { type BuilderMigrationDefinition, defineBuilderMigration, defineMigration, Migrator } from './migrator.js';
-export { createSchemaGenerator, SqlSchemaGenerator } from './schemaGenerator.js';
-export { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
+export { SqlSchemaGenerator } from './schemaGenerator.js';
 export { DatabaseMigrationStorage } from './storage/databaseStorage.js';
 export { JsonMigrationStorage } from './storage/jsonStorage.js';
 export { MongoMigrationStorage } from './storage/mongoStorage.js';

package/dist/migrate/index.js

@@ -13,10 +13,10 @@ export * from './drift/index.js';
 // Schema introspection
 export * from './introspection/index.js';
 // Main migrator
+export { migrationBuilderFor } from './migrationTarget.js';
 export { defineBuilderMigration, defineMigration, Migrator } from './migrator.js';
 // Schema generators
-export { createSchemaGenerator, SqlSchemaGenerator } from './schemaGenerator.js';
-export { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
+export { SqlSchemaGenerator } from './schemaGenerator.js';
 // Storage implementations
 export { DatabaseMigrationStorage } from './storage/databaseStorage.js';
 export { JsonMigrationStorage } from './storage/jsonStorage.js';

package/dist/migrate/indexPredicate.d.ts

@@ -0,0 +1,8 @@
+import type { DialectName, EntityWhereMeta } from '../type/index.js';
+/**
+ * Refuses a partial index's predicate reaching past what the engine takes, before it compiles to what
+ * only the server would reject, naming the operator as its author wrote it. A `raw` one is left to the server.
+ */
+export declare function assertIndexPredicate<E>(where: EntityWhereMeta<E>, dialectName: DialectName, indexName: string): void;
+/** What refusing any part of a partial index's predicate reports. */
+export declare function refusedIndexPredicate(dialectName: string, part: string, indexName: string): TypeError;

package/dist/migrate/indexPredicate.js

@@ -0,0 +1,52 @@
+import { QueryRaw } from '../type/queryRaw.js';
+import { isOperatorObject } from '../util/object.util.js';
+/**
+ * The `$where` a partial index takes, on the engines where that is less than a query's: SQL Server's
+ * `CREATE INDEX` `<filter_predicate>` (comparisons and `IN` on plain columns, joined by `AND`), and
+ * MongoDB's `partialFilterExpression` (https://www.mongodb.com/docs/manual/core/index-partial/).
+ */
+const PREDICATE_GRAMMARS = {
+    mssql: {
+        rootOps: new Set(['$and']),
+        fieldOps: new Set(['$eq', '$ne', '$gt', '$gte', '$lt', '$lte', '$in', '$isNull', '$isNotNull']),
+        jsonPaths: false,
+    },
+    mongodb: {
+        rootOps: new Set(['$and', '$or']),
+        fieldOps: new Set(['$eq', '$gt', '$gte', '$lt', '$lte', '$between', '$in']),
+        jsonPaths: true,
+    },
+};
+/**
+ * Refuses a partial index's predicate reaching past what the engine takes, before it compiles to what
+ * only the server would reject, naming the operator as its author wrote it. A `raw` one is left to the server.
+ */
+export function assertIndexPredicate(where, dialectName, indexName) {
+    const grammar = PREDICATE_GRAMMARS[dialectName];
+    const refused = grammar && !(where instanceof QueryRaw) ? refusedOperator(where, grammar) : undefined;
+    if (refused) {
+        throw refusedIndexPredicate(dialectName, refused, indexName);
+    }
+}
+/** What refusing any part of a partial index's predicate reports. */
+export function refusedIndexPredicate(dialectName, part, indexName) {
+    return new TypeError(`${dialectName} does not support ${part} in a partial index predicate (index "${indexName}")`);
+}
+/** The first part of `where` outside `grammar`, depth-first; a `raw` clause is left alone. */
+function refusedOperator(where, grammar) {
+    return Object.entries(where)
+        .map(([key, value]) => {
+        if (key.includes('.') && !grammar.jsonPaths) {
+            return 'a JSON path';
+        }
+        if (!key.startsWith('$')) {
+            return isOperatorObject(value) ? Object.keys(value).find((op) => !grammar.fieldOps.has(op)) : undefined;
+        }
+        if (!grammar.rootOps.has(key)) {
+            return key;
+        }
+        const clauses = Array.isArray(value) ? value.filter((clause) => !(clause instanceof QueryRaw)) : [];
+        return clauses.map((clause) => refusedOperator(clause, grammar)).find(Boolean);
+    })
+        .find(Boolean);
+}

package/dist/migrate/introspection/registry.d.ts

@@ -1,3 +1,3 @@
 import type { QuerierPool, SchemaIntrospector } from '../../type/index.js';
-/** The introspector for `dialectName`, or `undefined` where the migrator has none for it. */
-export declare function introspectorFor(dialectName: string, pool: QuerierPool, schema?: string): SchemaIntrospector | undefined;
+/** The introspector for the engine `pool` runs on, reading `schema` where the engine has schemas to read. */
+export declare function introspectorFor(pool: QuerierPool, schema?: string): SchemaIntrospector;

package/dist/migrate/introspection/registry.js

@@ -4,12 +4,9 @@ import { MariadbSchemaIntrospector, MysqlSchemaIntrospector } from './mysqlIntro
 import { CockroachSchemaIntrospector, PostgresSchemaIntrospector } from './postgresIntrospector.js';
 import { SqliteSchemaIntrospector } from './sqliteIntrospector.js';
 /**
- * Which introspector each engine gets. A table rather than a `switch` so `Migrator` names no
- * constructor and adding an engine touches one line, not a control flow.
- *
- * Every entry is statically imported, so `uql-orm/migrate` still carries all of them; making the
- * table's values dynamic imports would shrink that entry, at the cost of an async
- * `createIntrospector` the constructor cannot await.
+ * Which introspector each engine gets; SQLite and MongoDB have no schemas, so they ignore the argument.
+ * Statically imported, so `uql-orm/migrate` carries every one: dynamic imports would shrink that entry,
+ * but `Migrator` builds its introspector in its constructor, which cannot await.
  */
 const INTROSPECTORS = {
     postgres: (pool, schema) => new PostgresSchemaIntrospector(pool, schema),
@@ -17,12 +14,10 @@ const INTROSPECTORS = {
     mysql: (pool, schema) => new MysqlSchemaIntrospector(pool, schema),
     mariadb: (pool, schema) => new MariadbSchemaIntrospector(pool, schema),
     mssql: (pool, schema) => new MsSqlSchemaIntrospector(pool, schema),
-    // Neither has schemas to read: SQLite attaches database files and MongoDB takes its database from
-    // the connection, so both ignore the argument rather than filtering on it.
     sqlite: (pool) => new SqliteSchemaIntrospector(pool),
     mongodb: (pool) => new MongoSchemaIntrospector(pool),
 };
-/** The introspector for `dialectName`, or `undefined` where the migrator has none for it. */
-export function introspectorFor(dialectName, pool, schema) {
-    return INTROSPECTORS[dialectName]?.(pool, schema);
+/** The introspector for the engine `pool` runs on, reading `schema` where the engine has schemas to read. */
+export function introspectorFor(pool, schema) {
+    return INTROSPECTORS[pool.dialect.dialectName](pool, schema);
 }

package/dist/migrate/migrationTarget.d.ts

@@ -0,0 +1,23 @@
+import type { ForeignKeyAction } from '../schema/types.js';
+import { type MigrationStorage, type MigratorDialect, type Querier, type QuerierPool, type SchemaGenerator } from '../type/index.js';
+import { MigrationBuilder } from './builder/migrationBuilder.js';
+import { type MigrationSource } from './codegen/migrationFile.js';
+/** A migration querier as its engine family drives it. */
+export type MigrationSession = {
+    readonly querier: Querier;
+    /** Runs one statement its generator wrote. */
+    run(statement: string): Promise<unknown>;
+    /** `work` in one transaction where the engine takes DDL in one; MongoDB creates collections outside any. */
+    transaction(work: () => Promise<void>): Promise<void>;
+};
+/** Everything a migrator does differently per engine family, chosen once from its pool. */
+export type MigrationTarget = {
+    readonly source: MigrationSource;
+    storage(tableName: string | undefined): MigrationStorage;
+    /** The dialect's schema generator. Async because MongoDB's loads its optional peer. */
+    generator(): Promise<SchemaGenerator>;
+    withSession<T>(task: (session: MigrationSession) => Promise<T>): Promise<T>;
+};
+export declare function migrationTargetFor(pool: QuerierPool<Querier, MigratorDialect>, defaultForeignKeyAction?: ForeignKeyAction): MigrationTarget;
+/** A builder running each operation on `querier`, as SQL or as MongoDB driver commands. */
+export declare function migrationBuilderFor(querier: Querier): Promise<MigrationBuilder>;

package/dist/migrate/migrationTarget.js

@@ -0,0 +1,50 @@
+import { isMongoQuerier, isSqlQuerier, } from '../type/index.js';
+import { withMongoQuerierForMigrations, withSqlQuerierForMigrations } from './acquireQuerierForMigrations.js';
+import { MigrationBuilder } from './builder/migrationBuilder.js';
+import { migrationSource } from './codegen/migrationFile.js';
+import { runMongoCommand } from './generator/mongoCommand.js';
+import { SqlSchemaGenerator } from './schemaGenerator.js';
+import { DatabaseMigrationStorage } from './storage/databaseStorage.js';
+import { MongoMigrationStorage } from './storage/mongoStorage.js';
+const sqlSession = (querier) => ({
+    querier,
+    run: (statement) => querier.run(statement),
+    transaction: (work) => querier.transaction(work),
+});
+const mongoSession = (querier) => ({
+    querier,
+    run: (statement) => runMongoCommand(querier.db, statement),
+    transaction: (work) => work(),
+});
+/** Imported on use, so the optional `mongodb` peer loads only on MongoDB. */
+async function mongoSchemaGenerator(namingStrategy, defaultForeignKeyAction) {
+    const { MongoSchemaGenerator } = await import('./generator/mongoSchemaGenerator.js');
+    return new MongoSchemaGenerator(namingStrategy, defaultForeignKeyAction);
+}
+export function migrationTargetFor(pool, defaultForeignKeyAction) {
+    const { dialect } = pool;
+    if (dialect.dialectName === 'mongodb') {
+        return {
+            source: migrationSource.MongoQuerier,
+            storage: (tableName) => new MongoMigrationStorage(pool, { tableName }),
+            generator: () => mongoSchemaGenerator(dialect.namingStrategy, defaultForeignKeyAction),
+            withSession: (task) => withMongoQuerierForMigrations(pool, 'Migrator', (querier) => task(mongoSession(querier))),
+        };
+    }
+    return {
+        source: migrationSource.SqlQuerier,
+        storage: (tableName) => new DatabaseMigrationStorage(pool, { tableName }),
+        generator: async () => new SqlSchemaGenerator(dialect, defaultForeignKeyAction),
+        withSession: (task) => withSqlQuerierForMigrations(pool, 'Migrator', (querier) => task(sqlSession(querier))),
+    };
+}
+/** A builder running each operation on `querier`, as SQL or as MongoDB driver commands. */
+export async function migrationBuilderFor(querier) {
+    if (isSqlQuerier(querier)) {
+        return new MigrationBuilder(new SqlSchemaGenerator(querier.dialect), sqlSession(querier).run);
+    }
+    if (isMongoQuerier(querier)) {
+        return new MigrationBuilder(await mongoSchemaGenerator(), mongoSession(querier).run);
+    }
+    throw new TypeError('A migration builder needs a SQL or a MongoDB querier');
+}

package/dist/migrate/migrator.d.ts

@@ -1,4 +1,4 @@
-import type { DialectName, LoggingOptions, Migration, MigrationDefinition, MigrationResult, MigrationStorage, MigratorDialect, MigratorOptions, MongoQuerier, Querier, QuerierPool, SchemaDiff, SchemaGenerator, SchemaIntrospector, SqlQuerier, SyncOptions, Type } from '../type/index.js';
+import type { LoggingOptions, Migration, MigrationDefinition, MigrationResult, MigrationStorage, MigratorDialect, MigratorOptions, Querier, QuerierPool, SchemaDiff, SchemaGenerator, SchemaIntrospector, SqlQuerier, SyncOptions, Type } from '../type/index.js';
 import { LoggerWrapper } from '../util/index.js';
 import type { IMigrationBuilder } from './builder/types.js';
 /**
@@ -13,24 +13,13 @@ export declare class Migrator {
     set logger(value: LoggingOptions);
     private readonly _entities?;
     get entities(): Type<object>[];
-    readonly dialectName: DialectName;
+    /** The generator given, or this dialect's once {@link getSchemaGenerator} has loaded it. */
     schemaGenerator?: SchemaGenerator;
-    schemaIntrospector?: SchemaIntrospector;
-    private readonly _defaultForeignKeyAction?;
-    private _mongoSchemaLoadPromise?;
+    schemaIntrospector: SchemaIntrospector;
+    private readonly target;
     constructor(pool: QuerierPool<Querier, MigratorDialect>, options?: MigratorOptions);
-    /**
-     * Loads MongoDB's schema generator on first use, so the optional `mongodb` peer loads only then. SQL
-     * generators are set in the constructor (or via {@link setSchemaGenerator}).
-     */
-    ensureSchemaGenerator(): Promise<void>;
-    /**
-     * Set the schema generator for DDL operations
-     */
-    setSchemaGenerator(generator: SchemaGenerator): void;
-    /** `schema` reads one namespace instead of the connection's own; see {@link BaseSqlIntrospector.schema}. */
-    protected createIntrospector(schema?: string): SchemaIntrospector | undefined;
-    protected createGenerator(): SchemaGenerator | undefined;
+    /** The schema generator, loaded on first use: MongoDB's needs its optional peer. */
+    getSchemaGenerator(): Promise<SchemaGenerator>;
     /**
      * Get all discovered migrations from the migrations directory
      */
@@ -69,14 +58,6 @@ export declare class Migrator {
      * Run a single migration, within a transaction where the dialect has one for it
      */
     runMigration(migration: Migration<Querier>, direction: 'up' | 'down'): Promise<MigrationResult>;
-    /**
-     * A migration querier, and how to run work in one transaction on it. MongoDB gets none: it creates
-     * collections and indexes outside any transaction. SQL asserts its querier before opening one, so a
-     * wrong querier reports which one the dialect needs rather than a missing `transaction`.
-     */
-    private withMigrationQuerier;
-    /** What this dialect's migration files are written against. */
-    private get migrationQuerier();
     /**
      * Generate a new migration file
      */
@@ -99,7 +80,6 @@ export declare class Migrator {
      * {@link schemaIntrospector} so a caller that replaced it still wins.
      */
     private introspectClaimedSchemas;
-    findEntityForTable(tableName: string): Promise<Type<object> | undefined>;
     /**
      * Applies the entity schema to the database: every registered entity, or the one `entity` names.
      *
@@ -123,14 +103,12 @@ export declare class Migrator {
      * settle instead of colliding; an existing one still pays for introspection, as a diff needs columns.
      */
     private planEntity;
-    /** An alter diff as statements, narrowed to what the caller allows. */
-    private alterFromDiff;
     /** The same for one entity against the table it already has, and nothing where the two agree. */
     private alterFromEntity;
     /** The configured entities, with `entity` among them however the migrator was built. */
     private entitiesWith;
     /** The introspector for a claimed schema, which is the connection's own where none is claimed. */
-    private introspectorFor;
+    private schemaIntrospectorFor;
     /**
      * The DDL {@link sync} would run, without running it. Separate so `--dry-run` shows the real
      * statements rather than a summary of a second, differently-computed diff.
@@ -146,30 +124,19 @@ export declare class Migrator {
      */
     private createSchema;
     /**
-     * Each pending diff with the entity it came from, since resolving that is async and every caller
-     * needs it. What to emit stays with the caller: a sync narrows the forward direction to what the
-     * caller allows and never asks for the rollback, which on SQLite cannot even be expressed (no
-     * `ALTER COLUMN`), so computing it eagerly for everyone would throw there.
-     */
-    private pendingDiffs;
-    /**
-     * The schema generator. A getter because MongoDB's loads lazily (see {@link ensureSchemaGenerator}),
-     * so every caller had to repeat the same assertion after awaiting it.
+     * The pending diffs a sync or a generated migration acts on: the tables to create and the tables to
+     * alter. What to emit for each stays with the caller: a sync narrows an alter to what it allows and
+     * never asks for the rollback, which on SQLite cannot even be expressed (no `ALTER COLUMN`).
      */
-    private get generator();
+    private pendingChanges;
     protected filterDiff(diff: SchemaDiff, options: {
         safe?: boolean;
         drop?: boolean;
     }): SchemaDiff;
+    /** Runs the statements a generator wrote, in one transaction where the engine takes DDL in one. */
     executeSyncStatements(statements: string[], options: {
         logging?: boolean;
     }): Promise<void>;
-    executeMongoSyncStatements(statements: string[], options: {
-        logging?: boolean;
-    }, querier: MongoQuerier): Promise<void>;
-    executeSqlSyncStatements(statements: string[], options: {
-        logging?: boolean;
-    }, querier: Querier): Promise<void>;
     /**
      * Get migration status
      */
@@ -208,12 +175,13 @@ export declare class Migrator {
 export declare function defineMigration<Q extends Querier = SqlQuerier>(migration: MigrationDefinition<Q>): MigrationDefinition<Q>;
 /**
  * Migration definition that uses the type-safe builder API. The querier is the builder's own, so a
- * data backfill it runs lands in the same transaction as the schema change.
+ * data backfill it runs lands in the same transaction as the schema change. On MongoDB, `Q` is
+ * `MongoQuerier` and the builder takes collections and their indexes.
  */
-export interface BuilderMigrationDefinition {
+export interface BuilderMigrationDefinition<Q extends Querier = SqlQuerier> {
     readonly name?: string;
-    up(builder: IMigrationBuilder, querier: SqlQuerier): Promise<void>;
-    down(builder: IMigrationBuilder, querier: SqlQuerier): Promise<void>;
+    up(builder: IMigrationBuilder, querier: Q): Promise<void>;
+    down(builder: IMigrationBuilder, querier: Q): Promise<void>;
 }
 /**
  * Define a migration using the type-safe builder API.
@@ -234,4 +202,4 @@ export interface BuilderMigrationDefinition {
  * });
  * ```
  */
-export declare function defineBuilderMigration(migration: BuilderMigrationDefinition): MigrationDefinition;
+export declare function defineBuilderMigration<Q extends Querier = SqlQuerier>(migration: BuilderMigrationDefinition<Q>): MigrationDefinition<Q>;