uql-orm 0.54.0 → 0.56.0

package/dist/maria/mariadbQuerier.js

@@ -1,23 +1,22 @@
 import { AbstractPoolQuerier } from '../querier/abstractPoolQuerier.js';
+import { decodeBigInts } from '../util/wideNumber.js';
 export class MariadbQuerier extends AbstractPoolQuerier {
-    constructor(connect, dialect, extra) {
-        super(dialect, connect, extra);
-    }
     async internalAll(query, values) {
-        const res = await this.getConn().query(query, values);
-        return res;
+        const rows = await this.getConn().query(query, values);
+        return Array.from(rows, decodeBigInts);
     }
     async internalRun(query, values) {
         const res = await this.getConn().query(query, values);
         // MariaDB may not set `affectedRows` when RETURNING is used; fall back to row count.
         const changes = res.affectedRows ?? res.length ?? 0;
-        return this.buildUpdateResult({ rows: res.length ? res : [], changes, upsertStatus: res.affectedRows });
+        const rows = res.length ? Array.from(res, decodeBigInts) : [];
+        return this.buildUpdateResult({ rows, changes, upsertStatus: res.affectedRows });
     }
     async *internalStream(query, values) {
         const stream = this.getConn().queryStream(query, values);
         try {
             for await (const row of stream) {
-                yield row;
+                yield decodeBigInts(row);
             }
         }
         finally {

package/dist/maria/mariadbQuerierPool.js

@@ -8,19 +8,16 @@ export class MariadbQuerierPool extends AbstractSqlQuerierPool {
     pool;
     constructor(opts, extra) {
         super(new MariaDialect(dialectOptionsFrom(extra)), extra);
-        // `mariadb` defaults to handing BIGINT back as a BigInt, and uql maps `type: Number` to BIGINT
-        // (see `schema/canonicalType.ts`), so every auto-increment id reached a field declared `number`
-        // as `9n` without this. Same trade as the pg pools: exact to 2^53, and `...opts` wins for a
-        // caller who needs more. This belongs to the pool, not to the suites - it lived in
-        // `mariadbQuerier.test.ts`, which meant the tests passed on behaviour the library never shipped.
-        this.pool = createPool({ bigIntAsNumber: true, ...opts });
+        // BIGINT stays the driver's `bigint`, which `MariadbQuerier` decodes by the rule every driver here
+        // shares (`decodeWideNumber`) - not `bigIntAsNumber`, which rounds past 2^53 without a word.
+        this.pool = createPool(opts);
         // `mariadb`'s own `createPool` already attaches a silent no-op 'error'
         // listener (so a dropped connection can't crash the process), but its
         // `Pool` type only declares `on` for 'acquire' | 'connection' | 'enqueue'
         // | 'release' - 'error' genuinely fires at runtime (see `lib/pool.js`)
         // but isn't in the declaration, hence the cast. Re-attaching our own
         // listener here just makes the error visible instead of a silent no-op.
-        attachPoolErrorHandler(this.pool, 'Idle MariaDB pool connection encountered an error');
+        attachPoolErrorHandler(this.pool, 'Idle MariaDB pool connection encountered an error', extra?.logger);
     }
     async getQuerier() {
         return new MariadbQuerier(() => this.pool.getConnection(), this.dialect, this.extra);

package/dist/migrate/builder/splitSqlStatements.js

@@ -26,11 +26,11 @@ export function splitSqlStatements(sql) {
     const masterRegex = /'(?:''|\\['\\]|[^'])*(?:'|(?=$))|"(?:""|\\["\\]|[^"])*(?:"|(?=$))|`(?:``|\\[`\\]|[^`])*(?:`|(?=$))|\$(?<tag>[a-zA-Z0-9_]*)\$[\s\S]*?(?:\$\k<tag>|(?=$))|--.*|\/\*[\s\S]*?(?:\*\/|(?=$))|;/g;
     for (const match of sql.matchAll(masterRegex)) {
         if (match[0] === ';') {
-            const stmt = sql.substring(lastIndex, match.index ?? 0).trim();
+            const stmt = sql.substring(lastIndex, match.index).trim();
             if (stmt) {
                 statements.push(stmt);
             }
-            lastIndex = (match.index ?? 0) + match[0].length;
+            lastIndex = match.index + match[0].length;
         }
     }
     const lastStmt = sql.substring(lastIndex).trim();

package/dist/migrate/cli.js

@@ -34,7 +34,6 @@ export async function main(args = process.argv.slice(2)) {
     try {
         const config = await loadConfig(customPath);
         assertCliConfig(config);
-        const dialectName = config.pool.dialect.dialectName ?? 'postgres';
         const options = {
             migrationsPath: config.migrationsPath ?? './migrations',
             tableName: config.tableName,
@@ -43,13 +42,7 @@ export async function main(args = process.argv.slice(2)) {
             defaultForeignKeyAction: config.defaultForeignKeyAction,
         };
         const migrator = new Migrator(config.pool, options);
-        if (!migrator.schemaGenerator) {
-            const generator = await createSchemaGeneratorAsync(config.pool.dialect, config.defaultForeignKeyAction);
-            if (!generator) {
-                throw new TypeError(`Could not find a schema generator for dialect: ${dialectName}`);
-            }
-            migrator.setSchemaGenerator(generator);
-        }
+        await migrator.ensureSchemaGenerator();
         switch (command) {
             case 'up':
                 await runUp(migrator, filteredArgs.slice(1));
@@ -314,7 +307,7 @@ function printDriftGroup(title, drifts, icon, showSuggestion) {
             if (drift.expected && drift.actual) {
                 console.log(`    Expected: ${drift.expected}, Actual: ${drift.actual}`);
             }
-            if (showSuggestion && drift.suggestion) {
+            if (showSuggestion) {
                 console.log(`    → ${drift.suggestion}`);
             }
         }

package/dist/migrate/codegen/fieldOptionsSource.js

@@ -16,7 +16,7 @@ const OPTION_SOURCE = {
     type: (col) => {
         const columnType = canonicalToColumnType(col.type);
         return [
-            ...(columnType ? [`columnType: ${quoted(columnType)}`] : []),
+            `columnType: ${quoted(columnType)}`,
             ...(col.type.length && col.type.category === 'string' ? [`length: ${col.type.length}`] : []),
             ...(col.type.precision === undefined ? [] : [`precision: ${col.type.precision}`]),
             ...(col.type.precision !== undefined && col.type.scale !== undefined ? [`scale: ${col.type.scale}`] : []),

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

@@ -7,9 +7,9 @@ export { MariaIndexDdl, MySqlIndexDdl, MysqlLikeIndexDdl } from './mysqlIndexDdl
 export { CockroachIndexDdl, PgIndexDdl } from './pgIndexDdl.js';
 export { TableDdl } from './tableDdl.js';
 /**
- * The index DDL a dialect gets, most specific first. `instanceof` rather than `dialectName` so a
- * dialect subclassed by a user keeps its family's DDL, which is what overriding gave it while this
- * lived on the dialect itself. Anything else gets the portable form, which is SQLite's.
+ * The index DDL a dialect gets, most specific first. `instanceof` rather than the `dialectName`
+ * {@link tableDdlFor} reads, because each family's index DDL is typed to its dialect and the narrowing
+ * is what hands it one. Anything else gets the portable form, which is SQLite's.
  */
 export declare function indexDdlFor(dialect: AbstractSqlDialect): IndexDdl;
 /**

package/dist/migrate/ddl/index.js

@@ -14,9 +14,9 @@ export { MariaIndexDdl, MySqlIndexDdl, MysqlLikeIndexDdl } from './mysqlIndexDdl
 export { CockroachIndexDdl, PgIndexDdl } from './pgIndexDdl.js';
 export { TableDdl } from './tableDdl.js';
 /**
- * The index DDL a dialect gets, most specific first. `instanceof` rather than `dialectName` so a
- * dialect subclassed by a user keeps its family's DDL, which is what overriding gave it while this
- * lived on the dialect itself. Anything else gets the portable form, which is SQLite's.
+ * The index DDL a dialect gets, most specific first. `instanceof` rather than the `dialectName`
+ * {@link tableDdlFor} reads, because each family's index DDL is typed to its dialect and the narrowing
+ * is what hands it one. Anything else gets the portable form, which is SQLite's.
  */
 export function indexDdlFor(dialect) {
     if (dialect instanceof CockroachDialect) {

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

@@ -6,6 +6,11 @@ export declare class PgIndexDdl extends IndexDdl<PgLikeSqlDialect> {
     protected readonly indexFeatures: Set<"expression" | "include" | "jsonArray" | "jsonPath" | "nullsOrder" | "opsClass" | "partial" | "prefixLength">;
     /** pgvector's own index types; CockroachDB's native one widens this. */
     protected isVectorIndex(index: IndexSchema): boolean;
+    /**
+     * ` USING <method>`. `fulltext` is refused rather than compiled into a ` USING fulltext` the server
+     * can only answer with a syntax error: `$text` computes its `TO_TSVECTOR` per row, which no index
+     * over the raw columns serves.
+     */
     protected indexAccessMethod(index: IndexSchema): string;
     /**
      * A vector index's operator class is named `{type}_{metric}_ops`: an index on a `halfvec` column

package/dist/migrate/ddl/pgIndexDdl.js

@@ -14,7 +14,16 @@ export class PgIndexDdl extends IndexDdl {
     isVectorIndex(index) {
         return index.type === 'hnsw' || index.type === 'ivfflat';
     }
+    /**
+     * ` USING <method>`. `fulltext` is refused rather than compiled into a ` USING fulltext` the server
+     * can only answer with a syntax error: `$text` computes its `TO_TSVECTOR` per row, which no index
+     * over the raw columns serves.
+     */
     indexAccessMethod(index) {
+        if (index.type === 'fulltext') {
+            throw new TypeError(`${this.dialect.dialectName} has no fulltext index (index "${index.name}"). $text needs none there; ` +
+                'name the columns it searches with $fields.');
+        }
         return index.type ? ` USING ${index.type}` : '';
     }
     /**

package/dist/migrate/drift/driftDetector.js

@@ -5,7 +5,7 @@
  * actual database schema.
  */
 import { canonicalToSql, engineType } from '../../schema/canonicalType.js';
-import { diffSchemas } from '../../schema/schemaASTDiffer.js';
+import { diffSchemas, referentialActions } from '../../schema/schemaASTDiffer.js';
 function resolveOptions(options) {
     return {
         checkTypes: options.checkTypes ?? true,
@@ -114,7 +114,7 @@ function detectColumnDrifts(diff, opts) {
                 suggestion: 'Add to entity or create migration to drop',
             });
         }
-        else if (colDiff.type === 'alter') {
+        else {
             addAlterColumnDrifts(colDiff, drifts, opts);
         }
     }
@@ -124,10 +124,6 @@ function detectColumnDrifts(diff, opts) {
  * Add drifts for column alterations (type/nullable mismatches).
  */
 function addAlterColumnDrifts(colDiff, drifts, opts) {
-    // Every check below compares the two sides, so there is nothing to report without both.
-    if (!colDiff.expected || !colDiff.actual) {
-        return;
-    }
     // An auto-increment key is created through the dialect's `serialPrimaryKey`, whose spelling the
     // entity never states - `BIGINT UNSIGNED AUTO_INCREMENT` on the MySQL family, where the column then
     // reads back as `BIGINT UNSIGNED` against an entity that can only say `BIGINT`. Comparing the two
@@ -206,7 +202,7 @@ function detectIndexDrifts(diff) {
                 suggestion: 'Add @Field({ index }) or create migration to drop',
             });
         }
-        else if (idxDiff.type === 'alter') {
+        else {
             // No `expected`/`actual` here: the CLI prints those by interpolation, where an `IndexNode`
             // renders as `[object Object]`. What differs is already spelled out in `description`.
             drifts.push({
@@ -247,9 +243,26 @@ function detectRelationshipDrifts(diff) {
                 suggestion: 'Add relation to entity or drop FK',
             });
         }
+        else {
+            drifts.push({
+                type: 'relationship_mismatch',
+                severity: 'warning',
+                table: relDiff.fromTable,
+                relationship: relDiff.name,
+                expected: formatActions(relDiff.expected),
+                actual: formatActions(relDiff.actual),
+                details: `FK "${relDiff.name}" has other referential actions in the database than in the entity`,
+                suggestion: 'Generate a migration, which drops and re-adds the constraint',
+            });
+        }
     }
     return drifts;
 }
+/** Both actions spelled out, so a side that left one unstated reads the same as one that stated the default. */
+function formatActions(rel) {
+    const { onDelete, onUpdate } = referentialActions(rel);
+    return `ON DELETE ${onDelete} ON UPDATE ${onUpdate}`;
+}
 /**
  * Calculate overall status based on drifts.
  */
@@ -275,7 +288,7 @@ function createSummary(drifts) {
  * Format type for display.
  */
 function formatType(type, dialect) {
-    if (!type || !dialect)
+    if (!dialect)
         return 'unknown';
     return canonicalToSql(type, dialect);
 }

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -147,7 +147,7 @@ export class MongoSchemaGenerator extends AbstractDialect {
         if (!currentTable) {
             return { tableName: collectionName, type: 'create' };
         }
-        const existingIndexes = new Set(currentTable.indexes?.map((i) => i.name) ?? []);
+        const existingIndexes = new Set(currentTable.indexes.map((i) => i.name));
         const indexesToAdd = this.fieldIndexes(meta, collectionName).filter((index) => !existingIndexes.has(index.name));
         if (indexesToAdd.length === 0) {
             return undefined;

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

@@ -29,7 +29,7 @@ export declare abstract class BaseSqlIntrospector {
      * Build SchemaAST from table schemas.
      */
     protected buildAST(tableSchemas: TableSchema[]): SchemaAST;
-    private buildTables;
+    private buildTable;
     private buildRelationships;
     private buildIndexes;
 }

package/dist/migrate/introspection/baseSqlIntrospector.js

@@ -43,90 +43,79 @@ export class BaseSqlIntrospector {
      */
     buildAST(tableSchemas) {
         const ast = new SchemaAST();
-        const tableNodes = new Map();
-        this.buildTables(ast, tableNodes, tableSchemas);
-        this.buildRelationships(ast, tableNodes, tableSchemas);
-        this.buildIndexes(ast, tableNodes, tableSchemas);
+        // Every table first, so a foreign key reaches a table introspected after the one it leaves from.
+        const tables = tableSchemas.map((schema) => ({ schema, table: this.buildTable(schema) }));
+        const tableNodes = new Map(tables.map(({ schema, table }) => [schema.name, table]));
+        for (const { table } of tables) {
+            ast.addTable(table);
+        }
+        for (const { schema, table } of tables) {
+            this.buildRelationships(ast, tableNodes, schema, table);
+            this.buildIndexes(ast, schema, table);
+        }
         return ast;
     }
-    buildTables(ast, tableNodes, tableSchemas) {
-        for (const schema of tableSchemas) {
-            const table = createTableNode(schema.name, this.schema);
-            const { columns } = table;
-            for (const col of schema.columns) {
-                // Spread, not field by field: a `ColumnSchema` is a `ColumnNode` minus the graph links, so
-                // everything but the type crosses unchanged and a field either shape gains cannot be dropped
-                // here. Listed by hand this had already lost `enum` and `generatedAs`.
-                const { type, length: _length, precision: _precision, scale: _scale, ...rest } = col;
-                const column = {
-                    ...rest,
-                    type: canonicalColumnType(type, col),
-                    table,
-                    referencedBy: [],
-                };
-                columns.set(col.name, column);
-            }
-            // From the ordered list the query returned, not from the per-column flags: `(a, b)` is a
-            // different key from `(b, a)`, and a flag says only that a column is *in* the key. Falls back
-            // to the flags for an introspector that reports no key of its own.
-            const keyColumns = schema.primaryKey ?? schema.columns.filter((col) => col.isPrimaryKey).map((col) => col.name);
-            table.primaryKey.push(...keyColumns.flatMap((name) => columns.get(name) ?? []));
-            table.primaryKeyName = schema.primaryKeyName;
-            tableNodes.set(schema.name, table);
-            ast.addTable(table);
+    buildTable(schema) {
+        const table = createTableNode(schema.name, this.schema);
+        const { columns } = table;
+        for (const col of schema.columns) {
+            // Spread, not field by field: a `ColumnSchema` is a `ColumnNode` minus the graph links, so
+            // everything but the type crosses unchanged and a field either shape gains cannot be dropped
+            // here. Listed by hand this had already lost `enum` and `generatedAs`.
+            const { type, length: _length, precision: _precision, scale: _scale, ...rest } = col;
+            const column = {
+                ...rest,
+                type: canonicalColumnType(type, col),
+                table,
+                referencedBy: [],
+            };
+            columns.set(col.name, column);
         }
+        // From the ordered list the query returned, not from the per-column flags: `(a, b)` is a
+        // different key from `(b, a)`, and a flag says only that a column is *in* the key. Falls back
+        // to the flags for an introspector that reports no key of its own.
+        const keyColumns = schema.primaryKey ?? schema.columns.filter((col) => col.isPrimaryKey).map((col) => col.name);
+        table.primaryKey.push(...keyColumns.flatMap((name) => columns.get(name) ?? []));
+        table.primaryKeyName = schema.primaryKeyName;
+        return table;
     }
-    buildRelationships(ast, tableNodes, tableSchemas) {
-        for (const schema of tableSchemas) {
-            if (!schema.foreignKeys)
+    buildRelationships(ast, tableNodes, schema, fromTable) {
+        for (const fk of schema.foreignKeys ?? []) {
+            const toTable = tableNodes.get(fk.references.table);
+            if (!toTable)
                 continue;
-            const fromTable = tableNodes.get(schema.name);
-            if (!fromTable)
-                continue;
-            for (const fk of schema.foreignKeys) {
-                const toTable = tableNodes.get(fk.references.table);
-                if (!toTable)
-                    continue;
-                const fromColumns = fk.columns.flatMap((name) => fromTable.columns.get(name) ?? []);
-                const toColumns = fk.references.columns.flatMap((name) => toTable.columns.get(name) ?? []);
-                if (fromColumns.length > 0 && toColumns.length > 0) {
-                    const rel = {
-                        name: fk.name ?? derivedForeignKeyName(schema.name, fk.columns),
-                        type: fromColumns[0].isUnique ? 'OneToOne' : 'ManyToOne',
-                        from: { table: fromTable, columns: fromColumns },
-                        to: { table: toTable, columns: toColumns },
-                        onDelete: fk.onDelete || 'NO ACTION',
-                        onUpdate: fk.onUpdate || 'NO ACTION',
-                    };
-                    ast.addRelationship(rel);
-                }
+            const fromColumns = fk.columns.flatMap((name) => fromTable.columns.get(name) ?? []);
+            const toColumns = fk.references.columns.flatMap((name) => toTable.columns.get(name) ?? []);
+            if (fromColumns.length > 0 && toColumns.length > 0) {
+                const rel = {
+                    name: fk.name ?? derivedForeignKeyName(schema.name, fk.columns),
+                    type: fromColumns[0].isUnique ? 'OneToOne' : 'ManyToOne',
+                    from: { table: fromTable, columns: fromColumns },
+                    to: { table: toTable, columns: toColumns },
+                    onDelete: fk.onDelete || 'NO ACTION',
+                    onUpdate: fk.onUpdate || 'NO ACTION',
+                };
+                ast.addRelationship(rel);
             }
         }
     }
-    buildIndexes(ast, tableNodes, tableSchemas) {
-        for (const schema of tableSchemas) {
-            if (!schema.indexes)
-                continue;
-            const table = tableNodes.get(schema.name);
-            if (!table)
-                continue;
-            for (const idx of schema.indexes) {
-                // An expression has no column to resolve. Dropping the entries that name a column this table
-                // does not have, and the index if that leaves none, is what the entity side does too.
-                const entries = idx.entries.filter((entry) => entry.expression || table.columns.has(entry.column));
-                if (entries.length > 0) {
-                    const index = {
-                        name: idx.name,
-                        table,
-                        entries,
-                        unique: idx.unique,
-                        type: idx.type,
-                        where: idx.where,
-                        include: idx.include,
-                        source: 'database',
-                    };
-                    ast.addIndex(index);
-                }
+    buildIndexes(ast, schema, table) {
+        for (const idx of schema.indexes ?? []) {
+            // An expression has no column to resolve. Dropping the entries that name a column this table
+            // does not have, and the index if that leaves none, is what the entity side does too.
+            const entries = idx.entries.filter((entry) => entry.expression || table.columns.has(entry.column));
+            if (entries.length > 0) {
+                const index = {
+                    name: idx.name,
+                    table,
+                    entries,
+                    unique: idx.unique,
+                    type: idx.type,
+                    where: idx.where,
+                    include: idx.include,
+                    source: 'database',
+                };
+                ast.addIndex(index);
             }
         }
     }

package/dist/migrate/introspection/mssqlIntrospector.js

@@ -27,7 +27,8 @@ export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     `;
     }
     parseTableExistsResult(results) {
-        return (this.toNumber(results[0]?.count) ?? 0) > 0;
+        // No row, or no count in it, reads as `NaN`, which is not above zero.
+        return Number(results[0]?.count) > 0;
     }
     /**
      * From `sys` rather than `INFORMATION_SCHEMA`, which has no identity flag and no per-column view of

package/dist/migrate/introspection/mysqlIntrospector.js

@@ -24,11 +24,8 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     `;
     }
     parseTableExistsResult(results) {
-        const row = results[0];
-        if (row?.count !== undefined) {
-            return (this.toNumber(row.count) ?? 0) > 0;
-        }
-        return false;
+        // No row, or no count in it, reads as `NaN`, which is not above zero.
+        return Number(results[0]?.count) > 0;
     }
     getColumnsQuery(_tableName) {
         return /*sql*/ `
@@ -97,7 +94,7 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     async mapColumnsResult(_read, _tableName, results) {
         return results.map((row) => ({
             name: row.column_name,
-            type: (row.column_type || '').toUpperCase(),
+            type: row.column_type.toUpperCase(),
             nullable: row.is_nullable === 'YES',
             defaultValue: this.parseDefaultValue(row.column_default),
             isPrimaryKey: row.column_key === 'PRI',
@@ -122,8 +119,8 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     async mapForeignKeysResult(_read, _tableName, results) {
         return results.map((row) => ({
             name: row.constraint_name,
-            columns: (row.columns || '').split(','),
-            references: { table: row.referenced_table, columns: (row.referenced_columns || '').split(',') },
+            columns: row.columns.split(','),
+            references: { table: row.referenced_table, columns: row.referenced_columns.split(',') },
             onDelete: this.normalizeReferentialAction(row.delete_rule),
             onUpdate: this.normalizeReferentialAction(row.update_rule),
         }));

package/dist/migrate/introspection/sqliteIntrospector.js

@@ -22,11 +22,8 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     `;
     }
     parseTableExistsResult(results) {
-        const row = results[0];
-        if (row?.count !== undefined) {
-            return (this.toNumber(row.count) ?? 0) > 0;
-        }
-        return false;
+        // No row, or no count in it, reads as `NaN`, which is not above zero.
+        return Number(results[0]?.count) > 0;
     }
     /**
      * `table_xinfo`, not `table_info`: the latter omits generated columns entirely, so a table carrying

package/dist/migrate/migrator.d.ts

@@ -19,8 +19,11 @@ export declare class Migrator {
     private readonly _defaultForeignKeyAction?;
     private _mongoSchemaLoadPromise?;
     constructor(pool: QuerierPool, options?: MigratorOptions);
-    /** Loads MongoDB schema generator on first use; SQL generators are set in the constructor (or via {@link setSchemaGenerator}). */
-    private ensureSchemaGenerator;
+    /**
+     * 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
      */

package/dist/migrate/migrator.js

@@ -10,7 +10,6 @@ import { buildSqlQuerierMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPT
 import { runMongoCommand } from './generator/mongoCommand.js';
 import { introspectorFor } from './introspection/registry.js';
 import { createSchemaGenerator } from './schemaGenerator.js';
-import { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
 import { DatabaseMigrationStorage } from './storage/databaseStorage.js';
 /**
  * Main class for managing database migrations
@@ -37,7 +36,7 @@ export class Migrator {
     _mongoSchemaLoadPromise;
     constructor(pool, options = {}) {
         this.pool = pool;
-        this.dialectName = pool.dialect.dialectName ?? 'postgres';
+        this.dialectName = pool.dialect.dialectName;
         this._defaultForeignKeyAction = options.defaultForeignKeyAction;
         this.storage =
             options.storage ??
@@ -51,18 +50,17 @@ export class Migrator {
         this.schemaGenerator =
             options.schemaGenerator ?? (this.dialectName === 'mongodb' ? undefined : this.createGenerator());
     }
-    /** Loads MongoDB schema generator on first use; SQL generators are set in the constructor (or via {@link setSchemaGenerator}). */
+    /**
+     * 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}).
+     */
     async ensureSchemaGenerator() {
         if (this.schemaGenerator || this.dialectName !== 'mongodb') {
             return;
         }
-        if (!this._mongoSchemaLoadPromise) {
-            this._mongoSchemaLoadPromise = createSchemaGeneratorAsync(this.pool.dialect, this._defaultForeignKeyAction).then((gen) => {
-                if (gen) {
-                    this.schemaGenerator = gen;
-                }
-            });
-        }
+        this._mongoSchemaLoadPromise ??= import('./generator/mongoSchemaGenerator.js').then(({ MongoSchemaGenerator }) => {
+            this.schemaGenerator = new MongoSchemaGenerator(this.pool.dialect.namingStrategy, this._defaultForeignKeyAction);
+        });
         await this._mongoSchemaLoadPromise;
     }
     /**
@@ -302,12 +300,9 @@ export class Migrator {
     }
     async findEntityForTable(tableName) {
         await this.ensureSchemaGenerator();
-        if (!this.schemaGenerator) {
-            return undefined;
-        }
         for (const entity of this.entities) {
             const meta = getMeta(entity);
-            const name = this.schemaGenerator.resolveTableName(meta);
+            const name = this.generator.resolveTableName(meta);
             if (name === tableName) {
                 return entity;
             }

package/dist/migrate/schemaGenerator.js

@@ -474,8 +474,6 @@ export class SqlSchemaGenerator {
         if (current == null || desired == null)
             return current == null && desired == null;
         const normalize = (value) => {
-            if (value === null)
-                return 'null';
             // Render first: the desired side may be a symbolic expression, the current side is always the
             // engine's own text, and `{"kind":"now"}` matches no spelling of `CURRENT_TIMESTAMP`.
             const val = SqlExpression.isExpression(value) ? formatDefaultValue(value, this.dialect) : value;
@@ -518,10 +516,8 @@ export class SqlSchemaGenerator {
             constraints.push(`CONSTRAINT ${this.escapeId(name)} CHECK (${check.expression})`);
         });
         for (const rel of table.outgoingRelations) {
-            if (rel.from.columns.length > 0) {
-                const refTable = this.dialect.escapeQualifiedId(rel.to.table.name, rel.to.table.schema);
-                constraints.push(this.foreignKeyConstraint(table.name, foreignKeyOf(rel), refTable));
-            }
+            const refTable = this.dialect.escapeQualifiedId(rel.to.table.name, rel.to.table.schema);
+            constraints.push(this.foreignKeyConstraint(table.name, foreignKeyOf(rel), refTable));
         }
         const ifNotExists = options.ifNotExists && this.features.ifNotExists ? 'IF NOT EXISTS ' : '';
         let createSql = `CREATE TABLE ${ifNotExists}${this.dialect.escapeQualifiedId(table.name, table.schema)} (\n`;

package/dist/mongo/index.d.ts

@@ -1,5 +1,4 @@
 export { MongoSchemaGenerator } from '../migrate/generator/mongoSchemaGenerator.js';
 export * from './mongoDialect.js';
-export * from './mongodbNativeDialect.js';
 export * from './mongodbQuerier.js';
 export * from './mongodbQuerierPool.js';

package/dist/mongo/index.js

@@ -1,5 +1,4 @@
 export { MongoSchemaGenerator } from '../migrate/generator/mongoSchemaGenerator.js';
 export * from './mongoDialect.js';
-export * from './mongodbNativeDialect.js';
 export * from './mongodbQuerier.js';
 export * from './mongodbQuerierPool.js';

package/dist/mongo/mongoDialect.d.ts

@@ -20,7 +20,6 @@ export declare class MongoDialect extends AbstractDialect {
     private static readonly ID_KEY;
     /** Atlas rejects a `$vectorSearch` asking for more candidates than this. */
     private static readonly MAX_NUM_CANDIDATES;
-    private static readonly AGGREGATE_OP_MAP;
     /**
      * MongoDB stores the primary key as `_id`; everything else resolves as usual. Projections, sorts,
      * `$group` refs and `$where` keys all map through here, so no read path can address a property name
@@ -188,7 +187,7 @@ export declare class MongoDialect extends AbstractDialect {
     /** `[column, key]` for the fields whose stored name differs from their property name, memoized per entity. */
     private renamedColumns;
     private referenceKeys;
-    normalizeIds<E extends Document>(meta: EntityMeta<E>, docs: Document[] | undefined): E[] | undefined;
+    normalizeIds<E extends Document>(meta: EntityMeta<E>, docs: Document[]): E[];
     /** `doc` is the wire shape - `_id`, stored names, `ObjectId`s - and what comes back is the code's. */
     normalizeId<E extends Document>(meta: EntityMeta<E>, doc: Document | undefined): E | undefined;
     /**