uql-orm 0.62.0 → 0.64.0

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;
 }

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 { 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';
 // 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/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 dialect. */
+export type MigrationTarget = {
+    readonly source: MigrationSource;
+    storage(pool: QuerierPool, tableName: string | undefined): MigrationStorage;
+    /** The schema generator, `undefined` for a dialect with none. Async because MongoDB's loads its optional peer. */
+    generator(dialect: MigratorDialect, defaultForeignKeyAction?: ForeignKeyAction): Promise<SchemaGenerator | undefined>;
+    withSession<T>(pool: QuerierPool, task: (session: MigrationSession) => Promise<T>): Promise<T>;
+};
+export declare function migrationTargetFor(dialect: MigratorDialect): 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,48 @@
+import { isKnownMigratorDialect, 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 { createSchemaGenerator, 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);
+}
+const sqlTarget = {
+    source: migrationSource.SqlQuerier,
+    storage: (pool, tableName) => new DatabaseMigrationStorage(pool, { tableName }),
+    generator: async (dialect, defaultForeignKeyAction) => isKnownMigratorDialect(dialect.dialectName) ? createSchemaGenerator(dialect, defaultForeignKeyAction) : undefined,
+    withSession: (pool, task) => withSqlQuerierForMigrations(pool, 'Migrator', (querier) => task(sqlSession(querier))),
+};
+const mongoTarget = {
+    source: migrationSource.MongoQuerier,
+    storage: (pool, tableName) => new MongoMigrationStorage(pool, { tableName }),
+    generator: (dialect, defaultForeignKeyAction) => mongoSchemaGenerator(dialect.namingStrategy, defaultForeignKeyAction),
+    withSession: (pool, task) => withMongoQuerierForMigrations(pool, 'Migrator', (querier) => task(mongoSession(querier))),
+};
+export function migrationTargetFor(dialect) {
+    return dialect.dialectName === 'mongodb' ? mongoTarget : sqlTarget;
+}
+/** 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');
+}