uql-orm 0.50.0 → 0.52.0

package/dist/dialect/pgLikeSqlDialect.js

@@ -10,7 +10,7 @@ import { jsonSetTarget } from './jsonSql.js';
 import { resolveVectorCast, toSparsevecLiteral } from './vectorCast.js';
 /**
  * Shared AST/quoting/JSONB/full-text-search/vector-search implementation between Postgres and
- * CockroachDB (wire- and SQL-compatible for everything below, including `to_tsvector`/`to_tsquery`
+ * CockroachDB (wire- and SQL-compatible for everything below, including `TO_TSVECTOR`/`TO_TSQUERY`
  * and pgvector's `<=>`/`<->`/`<#>` distance operators, which CockroachDB implements natively).
  * `xmax`-based upsert `created` detection is Postgres-only (CockroachDB has no `xmax`/`ctid`) and
  * stays in {@link PostgresDialect}, along with the `vectorExtension`/`vectorIndexStyle` values that
@@ -37,7 +37,10 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
         vectorIndexRequiresNotNull: false,
         vectorSupportsLength: true,
         supportsTimestamptz: true,
-        defaultStringAsText: true,
+        stringSizing: 'bounded-text',
+        supportsUnsigned: false,
+        multipleCascadePaths: true,
+        serverSideCursors: true,
     };
     escapeIdChar = '"';
     // Shared default for both dialects. CockroachDB docs flag sequential PKs as a hotspotting risk
@@ -66,7 +69,7 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
         const keys = this.escapeId(ctx.nextAlias(PER_PARENT_KEYS_ALIAS));
         const branch = this.escapeId(ctx.nextAlias(PER_PARENT_BRANCH_ALIAS));
         const column = (index) => `${keys}.k${index}`;
-        // `unnest` resolves an uncast parameter to `unknown` and refuses it ("function unnest(unknown) is
+        // `UNNEST` resolves an uncast parameter to `unknown` and refuses it ("function unnest(unknown) is
         // not unique"), so the array says its type. It comes from the parent's key column, which always
         // declares one, rather than the child's foreign key, which would have to be resolved through the
         // reference it takes its own type from.
@@ -78,7 +81,7 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
             const values = parents.map((it) => it[parent]);
             return `${this.addValue(ctx.values, values)}::${canonicalToSql(fieldOptionsToCanonical(field), this)}[]`;
         });
-        const rowSource = `unnest(${sources.join(', ')}) AS ${keys}(${joins.map((_, index) => `k${index}`).join(', ')})`;
+        const rowSource = `UNNEST(${sources.join(', ')}) AS ${keys}(${joins.map((_, index) => `k${index}`).join(', ')})`;
         // The keys come from the row source rather than as values, which is the whole point of correlating:
         // one branch, planned once, instead of one per parent.
         const correlated = Object.fromEntries(joins.map(({ joined }, index) => [joined, raw(({ ctx: inner }) => inner.append(column(index)))]));
@@ -141,8 +144,8 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
         return `$${index}`;
     }
     /**
-     * `to_tsvector(...) @@ websearch_to_tsquery(...)`. `websearch_to_tsquery` takes free-form user input
-     * (quoted phrases, `or`, `-negation`) and never raises a syntax error, unlike `to_tsquery`, which
+     * `TO_TSVECTOR(...) @@ WEBSEARCH_TO_TSQUERY(...)`. `WEBSEARCH_TO_TSQUERY` takes free-form user input
+     * (quoted phrases, `or`, `-negation`) and never raises a syntax error, unlike `TO_TSQUERY`, which
      * rejects anything unparseable - including a plain two-word search.
      */
     appendTextSearch(ctx, _entity, meta, search) {
@@ -151,7 +154,7 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
             .join(` || ' ' || `);
         // The config is bound once and its numbered placeholder reused by both calls.
         const config = search.$config ? `${this.addValue(ctx.values, search.$config)}::regconfig, ` : '';
-        ctx.append(`to_tsvector(${config}${fields}) @@ websearch_to_tsquery(${config}`);
+        ctx.append(`TO_TSVECTOR(${config}${fields}) @@ WEBSEARCH_TO_TSQUERY(${config}`);
         ctx.addValue(search.$value);
         ctx.append(')');
     }
@@ -159,14 +162,14 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
         return `${jsonField} @> ${this.jsonVal(ctx, value)}`;
     }
     jsonSize(ctx, jsonField, value) {
-        return this.buildFragment(ctx, (fragmentCtx) => this.buildSizeComparison(fragmentCtx, () => fragmentCtx.append(`jsonb_array_length(${jsonField})`), value));
+        return this.buildFragment(ctx, (fragmentCtx) => this.buildSizeComparison(fragmentCtx, () => fragmentCtx.append(`JSONB_ARRAY_LENGTH(${jsonField})`), value));
     }
     /**
      * Object elements stay `jsonb` so each field can pick `->` or `->>`. Scalar elements are exploded
      * as text unless they are compared as JSON, where `_text` would yield `text = jsonb`.
      */
     jsonElemFrom(jsonField, fields, alias, asJson = false) {
-        const fn = fields.length || asJson ? 'jsonb_array_elements' : 'jsonb_array_elements_text';
+        const fn = fields.length || asJson ? 'JSONB_ARRAY_ELEMENTS' : 'JSONB_ARRAY_ELEMENTS_TEXT';
         return `${fn}(${jsonField}) AS ${alias}`;
     }
     jsonElemRef(alias, field, asJson = false) {
@@ -209,8 +212,8 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
      */
     jsonPullKey(ctx, expr, escapedCol, key, value) {
         const escapedKey = escapeSingleQuotes(key);
-        const kept = `SELECT jsonb_agg(${JSON_PULL_ALIAS}.val ORDER BY ${JSON_PULL_ALIAS}.ord) FROM jsonb_array_elements(${escapedCol}->'${escapedKey}') WITH ORDINALITY AS ${JSON_PULL_ALIAS}(val, ord) WHERE ${JSON_PULL_ALIAS}.val <> ${this.jsonVal(ctx, value)}`;
-        return `jsonb_set(${expr}, '{${escapedKey}}', COALESCE((${kept}), '[]'::jsonb), false)`;
+        const kept = `SELECT JSONB_AGG(${JSON_PULL_ALIAS}.val ORDER BY ${JSON_PULL_ALIAS}.ord) FROM JSONB_ARRAY_ELEMENTS(${escapedCol}->'${escapedKey}') WITH ORDINALITY AS ${JSON_PULL_ALIAS}(val, ord) WHERE ${JSON_PULL_ALIAS}.val <> ${this.jsonVal(ctx, value)}`;
+        return `JSONB_SET(${expr}, '{${escapedKey}}', COALESCE((${kept}), '[]'::jsonb), false)`;
     }
     jsonSet(ctx, expr, set, field) {
         return `${jsonSetTarget(expr, field, `'{}'::jsonb`)} || ${this.jsonVal(ctx, set)}`;
@@ -220,7 +223,7 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
         return Object.entries(push).reduce((acc, [key, value]) => {
             const escapedKey = escapeSingleQuotes(key);
             const ph = this.jsonVal(ctx, value);
-            return `jsonb_set(${acc}, '{${escapedKey}}', COALESCE((${acc})->'${escapedKey}', '[]'::jsonb) || jsonb_build_array(${ph}))`;
+            return `JSONB_SET(${acc}, '{${escapedKey}}', COALESCE((${acc})->'${escapedKey}', '[]'::jsonb) || JSONB_BUILD_ARRAY(${ph}))`;
         }, expr);
     }
     jsonUnset(ctx, expr, unset) {

package/dist/migrate/builder/expressions.js

@@ -26,6 +26,11 @@ export const DIALECT_DEFAULTS = {
     mysql: { expressions: MYSQL, wrapTypes: MYSQL_LARGE_TYPES },
     mariadb: { expressions: { ...MYSQL, uuidv7: 'UUID_v7()' }, wrapTypes: MYSQL_LARGE_TYPES },
     sqlite: { expressions: ANSI },
+    // `SYSUTCDATETIME()` over `CURRENT_TIMESTAMP`, which is local time in the server's zone. No
+    // `uuidv7`: `NEWSEQUENTIALID()` is an ordered v4 GUID, so it carries no readable timestamp and
+    // does not sort the way a v7 does elsewhere - a `uuidv7()` default is refused rather than served
+    // something that only looks like one.
+    mssql: { expressions: { ...ANSI, now: 'SYSUTCDATETIME()', uuid: 'NEWID()' } },
 };
 /**
  * A DDL default that is SQL rather than a literal. A class, not a plain object, so a JSON default

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

@@ -1,5 +1,7 @@
 export * from './abstractSqlSchemaIntrospector.js';
 export * from './mongoIntrospector.js';
+export * from './mssqlIntrospector.js';
 export { MariadbSchemaIntrospector, MysqlSchemaIntrospector } from './mysqlIntrospector.js';
 export * from './postgresIntrospector.js';
 export * from './sqliteIntrospector.js';
+export { introspectorFor } from './registry.js';

package/dist/migrate/introspection/index.js

@@ -1,5 +1,7 @@
 export * from './abstractSqlSchemaIntrospector.js';
 export * from './mongoIntrospector.js';
+export * from './mssqlIntrospector.js';
 export { MariadbSchemaIntrospector, MysqlSchemaIntrospector } from './mysqlIntrospector.js';
 export * from './postgresIntrospector.js';
 export * from './sqliteIntrospector.js';
+export { introspectorFor } from './registry.js';

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

@@ -0,0 +1,63 @@
+import type { ColumnSchema, ForeignKeySchema, IndexSchema } from '../../type/index.js';
+import { AbstractSqlSchemaIntrospector, type TableRowReader } from './abstractSqlSchemaIntrospector.js';
+/**
+ * SQL Server schema introspector.
+ *
+ * `INFORMATION_SCHEMA` answers columns and foreign keys, but not indexes: it has no view for them at
+ * all, and its `CONSTRAINT_COLUMN_USAGE` conflates a unique index with a unique constraint. Those
+ * come from `sys.indexes` instead, which is also the only place the filtered-index predicate and the
+ * included columns are readable.
+ */
+export declare class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
+    protected readonly defaultSchemaExpr = "SCHEMA_NAME()";
+    protected getTableNamesQuery(): string;
+    protected tableExistsQuery(): string;
+    protected parseTableExistsResult(results: {
+        count?: number;
+    }[]): boolean;
+    /**
+     * `is_identity` and the default come from `sys`, not `INFORMATION_SCHEMA`: the latter has no
+     * identity flag, and reports a default already wrapped in the parentheses the engine reprints it
+     * with, which is the same text either way but only nameable as a constraint through `sys`.
+     */
+    protected getColumnsQuery(_tableName: string): string;
+    /** `is_primary_key` is excluded: the key is read separately, the way every other engine reads it. */
+    protected getIndexesQuery(_tableName: string): string;
+    protected getForeignKeysQuery(_tableName: string): string;
+    protected getPrimaryKeyQuery(_tableName: string): string;
+    /**
+     * `max_length` is in bytes, so an `NVARCHAR` column reports twice its declared length and `MAX`
+     * reports `-1`. Read as characters, every Unicode column would drift to double its width the first
+     * time it was diffed against the entity that declared it.
+     */
+    protected mapColumnsResult(read: TableRowReader, tableName: string, results: MsSqlColumnRow[]): Promise<ColumnSchema[]>;
+    protected mapIndexesResult(_read: TableRowReader, _tableName: string, results: {
+        index_name: string;
+        columns: string;
+        is_unique: boolean;
+    }[]): Promise<IndexSchema[]>;
+    protected mapForeignKeysResult(_read: TableRowReader, _tableName: string, results: {
+        constraint_name: string;
+        columns: string;
+        referenced_table: string;
+        referenced_columns: string;
+        delete_rule: string;
+        update_rule: string;
+    }[]): Promise<ForeignKeySchema[]>;
+    /**
+     * A default is stored wrapped in at least one layer of parentheses - `((0))` for a number,
+     * `(N'x')` for a string - because the engine reprints it from its own parse tree.
+     */
+    protected parseDefaultValue(defaultValue: string | null): unknown;
+}
+type MsSqlColumnRow = {
+    column_name: string;
+    data_type: string;
+    max_length: number | null;
+    numeric_precision: number | null;
+    numeric_scale: number | null;
+    is_nullable: boolean;
+    is_identity: boolean;
+    column_default: string | null;
+};
+export {};

package/dist/migrate/introspection/mssqlIntrospector.js

@@ -0,0 +1,198 @@
+import { AbstractSqlSchemaIntrospector } from './abstractSqlSchemaIntrospector.js';
+/**
+ * SQL Server schema introspector.
+ *
+ * `INFORMATION_SCHEMA` answers columns and foreign keys, but not indexes: it has no view for them at
+ * all, and its `CONSTRAINT_COLUMN_USAGE` conflates a unique index with a unique constraint. Those
+ * come from `sys.indexes` instead, which is also the only place the filtered-index predicate and the
+ * included columns are readable.
+ */
+export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
+    defaultSchemaExpr = 'SCHEMA_NAME()';
+    getTableNamesQuery() {
+        return /*sql*/ `
+      SELECT TABLE_NAME as table_name
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_SCHEMA = ${this.schemaExpr}
+        AND TABLE_TYPE = 'BASE TABLE'
+      ORDER BY TABLE_NAME
+    `;
+    }
+    tableExistsQuery() {
+        return /*sql*/ `
+      SELECT COUNT(*) as count
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_SCHEMA = ${this.schemaExpr}
+        AND TABLE_NAME = @p1
+    `;
+    }
+    parseTableExistsResult(results) {
+        return (this.toNumber(results[0]?.count) ?? 0) > 0;
+    }
+    /**
+     * `is_identity` and the default come from `sys`, not `INFORMATION_SCHEMA`: the latter has no
+     * identity flag, and reports a default already wrapped in the parentheses the engine reprints it
+     * with, which is the same text either way but only nameable as a constraint through `sys`.
+     */
+    getColumnsQuery(_tableName) {
+        return /*sql*/ `
+      SELECT
+        c.name as column_name,
+        t.name as data_type,
+        c.max_length as max_length,
+        c.precision as numeric_precision,
+        c.scale as numeric_scale,
+        c.is_nullable as is_nullable,
+        c.is_identity as is_identity,
+        d.definition as column_default
+      FROM sys.columns c
+      JOIN sys.objects o ON o.object_id = c.object_id
+      JOIN sys.schemas s ON s.schema_id = o.schema_id
+      JOIN sys.types t ON t.user_type_id = c.user_type_id
+      LEFT JOIN sys.default_constraints d ON d.object_id = c.default_object_id
+      WHERE s.name = ${this.schemaExpr} AND o.name = @p1
+      ORDER BY c.column_id
+    `;
+    }
+    /** `is_primary_key` is excluded: the key is read separately, the way every other engine reads it. */
+    getIndexesQuery(_tableName) {
+        return /*sql*/ `
+      SELECT
+        i.name as index_name,
+        i.is_unique as is_unique,
+        STRING_AGG(c.name, ',') WITHIN GROUP (ORDER BY ic.key_ordinal) as columns
+      FROM sys.indexes i
+      JOIN sys.objects o ON o.object_id = i.object_id
+      JOIN sys.schemas s ON s.schema_id = o.schema_id
+      JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+      WHERE s.name = ${this.schemaExpr} AND o.name = @p1
+        AND i.is_primary_key = 0 AND i.name IS NOT NULL AND ic.is_included_column = 0
+      GROUP BY i.name, i.is_unique
+      ORDER BY i.name
+    `;
+    }
+    getForeignKeysQuery(_tableName) {
+        return /*sql*/ `
+      SELECT
+        fk.name as constraint_name,
+        STRING_AGG(pc.name, ',') WITHIN GROUP (ORDER BY fkc.constraint_column_id) as columns,
+        rt.name as referenced_table,
+        STRING_AGG(rc.name, ',') WITHIN GROUP (ORDER BY fkc.constraint_column_id) as referenced_columns,
+        fk.delete_referential_action_desc as delete_rule,
+        fk.update_referential_action_desc as update_rule
+      FROM sys.foreign_keys fk
+      JOIN sys.objects o ON o.object_id = fk.parent_object_id
+      JOIN sys.schemas s ON s.schema_id = o.schema_id
+      JOIN sys.foreign_key_columns fkc ON fkc.constraint_object_id = fk.object_id
+      JOIN sys.columns pc ON pc.object_id = fkc.parent_object_id AND pc.column_id = fkc.parent_column_id
+      JOIN sys.objects rt ON rt.object_id = fk.referenced_object_id
+      JOIN sys.columns rc ON rc.object_id = fkc.referenced_object_id AND rc.column_id = fkc.referenced_column_id
+      WHERE s.name = ${this.schemaExpr} AND o.name = @p1
+      GROUP BY fk.name, rt.name, fk.delete_referential_action_desc, fk.update_referential_action_desc
+      ORDER BY fk.name
+    `;
+    }
+    getPrimaryKeyQuery(_tableName) {
+        return /*sql*/ `
+      SELECT c.name as column_name, i.name as constraint_name
+      FROM sys.indexes i
+      JOIN sys.objects o ON o.object_id = i.object_id
+      JOIN sys.schemas s ON s.schema_id = o.schema_id
+      JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+      WHERE s.name = ${this.schemaExpr} AND o.name = @p1 AND i.is_primary_key = 1
+      ORDER BY ic.key_ordinal
+    `;
+    }
+    /**
+     * `max_length` is in bytes, so an `NVARCHAR` column reports twice its declared length and `MAX`
+     * reports `-1`. Read as characters, every Unicode column would drift to double its width the first
+     * time it was diffed against the entity that declared it.
+     */
+    async mapColumnsResult(read, tableName, results) {
+        // One extra statement for both flags, and the reader sends it once: a column is in the key or
+        // uniquely indexed on its own, and `sys` is the only place either is readable per column.
+        const flags = await read(
+        /*sql*/ `
+      SELECT c.name as column_name, MAX(CAST(i.is_primary_key AS INT)) as is_primary_key
+      FROM sys.indexes i
+      JOIN sys.objects o ON o.object_id = i.object_id
+      JOIN sys.schemas s ON s.schema_id = o.schema_id
+      JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+      WHERE s.name = ${this.schemaExpr} AND o.name = @p1
+        AND i.is_unique = 1 AND ic.is_included_column = 0
+        AND (SELECT COUNT(*) FROM sys.index_columns k
+             WHERE k.object_id = i.object_id AND k.index_id = i.index_id AND k.is_included_column = 0) = 1
+      GROUP BY c.name
+    `, [tableName]);
+        const unique = new Set(flags.map((row) => row.column_name));
+        const keys = new Set(flags.filter((row) => Boolean(row.is_primary_key)).map((row) => row.column_name));
+        return results.map((row) => {
+            const type = row.data_type.toUpperCase();
+            const wide = type.startsWith('N');
+            const bytes = this.toNumber(row.max_length);
+            const length = bytes === undefined || bytes < 0 || !CHARACTER_TYPES.has(type) ? undefined : wide ? bytes / 2 : bytes;
+            return {
+                name: row.column_name,
+                type: bytes === -1 && CHARACTER_TYPES.has(type) ? `${type}(MAX)` : type,
+                nullable: Boolean(row.is_nullable),
+                defaultValue: this.parseDefaultValue(row.column_default),
+                isAutoIncrement: Boolean(row.is_identity),
+                isPrimaryKey: keys.has(row.column_name),
+                isUnique: unique.has(row.column_name),
+                length,
+                precision: NUMERIC_TYPES.has(type) ? this.toNumber(row.numeric_precision) : undefined,
+                scale: NUMERIC_TYPES.has(type) ? this.toNumber(row.numeric_scale) : undefined,
+            };
+        });
+    }
+    async mapIndexesResult(_read, _tableName, results) {
+        return results.map((row) => ({
+            name: row.index_name,
+            entries: (row.columns ?? '').split(',').map((column) => ({ column })),
+            unique: Boolean(row.is_unique),
+        }));
+    }
+    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(',') },
+            // `sys` spells them with an underscore: `SET_NULL`, `NO_ACTION`.
+            onDelete: this.normalizeReferentialAction((row.delete_rule || '').replaceAll('_', ' ')),
+            onUpdate: this.normalizeReferentialAction((row.update_rule || '').replaceAll('_', ' ')),
+        }));
+    }
+    /**
+     * A default is stored wrapped in at least one layer of parentheses - `((0))` for a number,
+     * `(N'x')` for a string - because the engine reprints it from its own parse tree.
+     */
+    parseDefaultValue(defaultValue) {
+        if (defaultValue === null || defaultValue === undefined) {
+            return undefined;
+        }
+        let text = defaultValue.trim();
+        while (text.startsWith('(') && text.endsWith(')')) {
+            text = text.slice(1, -1).trim();
+        }
+        if (text.toUpperCase() === 'NULL') {
+            return null;
+        }
+        const unicode = text.startsWith("N'") ? text.slice(1) : text;
+        if (unicode.startsWith("'") && unicode.endsWith("'")) {
+            return unicode.slice(1, -1).replaceAll("''", "'");
+        }
+        if (/^-?\d+$/.test(text)) {
+            return Number.parseInt(text, 10);
+        }
+        if (/^-?\d+\.\d+$/.test(text)) {
+            return Number.parseFloat(text);
+        }
+        return text;
+    }
+}
+/** The types whose `max_length` is a width rather than a fixed storage size. */
+const CHARACTER_TYPES = new Set(['CHAR', 'NCHAR', 'VARCHAR', 'NVARCHAR', 'BINARY', 'VARBINARY']);
+const NUMERIC_TYPES = new Set(['DECIMAL', 'NUMERIC']);

package/dist/migrate/introspection/postgresIntrospector.js

@@ -109,7 +109,7 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
       JOIN pg_class i ON i.oid = ix.indexrelid
       JOIN pg_am am ON am.oid = i.relam
       JOIN pg_namespace n ON n.oid = t.relnamespace
-      CROSS JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, n)
+      CROSS JOIN LATERAL UNNEST(ix.indkey) WITH ORDINALITY AS k(attnum, n)
       LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum AND k.attnum > 0
       LEFT JOIN pg_opclass op ON op.oid = ix.indclass[k.n - 1]
       WHERE t.relname = $1
@@ -136,9 +136,9 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         return /*sql*/ `
       SELECT
         tc.constraint_name,
-        array_to_json(array_agg(kcu.column_name ORDER BY kcu.ordinal_position)) AS columns,
+        ARRAY_TO_JSON(ARRAY_AGG(kcu.column_name ORDER BY kcu.ordinal_position)) AS columns,
         ccu.table_name AS referenced_table,
-        array_to_json(array_agg(ccu.column_name ORDER BY kcu.ordinal_position)) AS referenced_columns,
+        ARRAY_TO_JSON(ARRAY_AGG(ccu.column_name ORDER BY kcu.ordinal_position)) AS referenced_columns,
         rc.delete_rule,
         rc.update_rule
       FROM information_schema.table_constraints tc

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

@@ -0,0 +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;

package/dist/migrate/introspection/registry.js

@@ -0,0 +1,28 @@
+import { MongoSchemaIntrospector } from './mongoIntrospector.js';
+import { MsSqlSchemaIntrospector } from './mssqlIntrospector.js';
+import { MariadbSchemaIntrospector, MysqlSchemaIntrospector } from './mysqlIntrospector.js';
+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.
+ */
+const INTROSPECTORS = {
+    postgres: (pool, schema) => new PostgresSchemaIntrospector(pool, schema),
+    cockroachdb: (pool, schema) => new CockroachSchemaIntrospector(pool, schema),
+    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);
+}

package/dist/migrate/migrator.js

@@ -8,7 +8,7 @@ import { LoggerWrapper } from '../util/index.js';
 import { withQuerierForMigrations, withSqlQuerierForMigrations } from './acquireQuerierForMigrations.js';
 import { buildSqlQuerierMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitSqlRunCalls, } from './codegen/migrationFile.js';
 import { runMongoCommand } from './generator/mongoCommand.js';
-import { CockroachSchemaIntrospector, MariadbSchemaIntrospector, MongoSchemaIntrospector, MysqlSchemaIntrospector, PostgresSchemaIntrospector, SqliteSchemaIntrospector, } from './introspection/index.js';
+import { introspectorFor } from './introspection/registry.js';
 import { createSchemaGenerator } from './schemaGenerator.js';
 import { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
 import { DatabaseMigrationStorage } from './storage/databaseStorage.js';
@@ -73,26 +73,7 @@ export class Migrator {
     }
     /** `schema` reads one namespace instead of the connection's own; see {@link BaseSqlIntrospector.schema}. */
     createIntrospector(schema) {
-        const d = this.dialectName;
-        if (!isKnownMigratorDialect(d)) {
-            return undefined;
-        }
-        switch (d) {
-            case 'postgres':
-                return new PostgresSchemaIntrospector(this.pool, schema);
-            case 'cockroachdb':
-                return new CockroachSchemaIntrospector(this.pool, schema);
-            case 'mysql':
-                return new MysqlSchemaIntrospector(this.pool, schema);
-            case 'mariadb':
-                return new MariadbSchemaIntrospector(this.pool, schema);
-            case 'sqlite':
-                return new SqliteSchemaIntrospector(this.pool);
-            case 'mongodb':
-                return new MongoSchemaIntrospector(this.pool);
-            default:
-                return undefined;
-        }
+        return introspectorFor(this.dialectName, this.pool, schema);
     }
     createGenerator() {
         if (!isKnownMigratorDialect(this.dialectName)) {

package/dist/mongo/mongoDialect.js

@@ -22,7 +22,10 @@ export const mongoDialectFeatures = {
     vectorIndexRequiresNotNull: false,
     vectorSupportsLength: false,
     supportsTimestamptz: false,
-    defaultStringAsText: false,
+    stringSizing: 'bounded-text',
+    supportsUnsigned: false,
+    multipleCascadePaths: true,
+    serverSideCursors: false,
 };
 /** What `toWireId` converts: the hex spelling of an `ObjectId`, and nothing looser. */
 const HEX_24 = /^[0-9a-f]{24}$/i;

package/dist/mongo/mongodbQuerier.d.ts

@@ -75,8 +75,8 @@ export declare class MongodbQuerier extends AbstractQuerier {
         firstId?: undefined;
     } | {
         changes: number;
-        ids: PrimaryKey[];
-        firstId: PrimaryKey;
+        ids: (PrimaryKey | undefined)[];
+        firstId: PrimaryKey | undefined;
     }>;
     protected internalDeleteMany<E extends Document>(entity: Type<E>, qm: QuerySearch<E>, opts?: QueryOptions): Promise<number>;
     get hasOpenTransaction(): boolean;

package/dist/mongo/mongodbQuerier.js

@@ -359,12 +359,14 @@ export class MongodbQuerier extends AbstractQuerier {
             });
             const res = await this.execute((session) => this.collection(entity).bulkWrite(operations, { session }));
             const changes = (res.upsertedCount ?? 0) + (res.modifiedCount ?? 0);
-            // `upsertedIds` only covers newly-inserted documents (keyed by operation index); a matched and
-            // updated document's `_id` isn't in the response, so it's simply not represented here - same
-            // "exact where knowable, absent otherwise" convention `RETURNING`-based SQL dialects use for
-            // rows that hit `DO NOTHING`.
-            const ids = Object.values(res.upsertedIds).map((id) => this.dialect.fromWireId(id));
-            return { changes, ids, firstId: ids[0] };
+            // `upsertedIds` only covers newly-inserted documents, keyed by operation index: a matched and
+            // updated document's `_id` is not in the response. Read by that index rather than flattened,
+            // so each id lands on the row it belongs to and the gaps stay gaps.
+            const ids = payload.map((_, index) => {
+                const id = res.upsertedIds[index];
+                return id === undefined ? undefined : this.dialect.fromWireId(id);
+            });
+            return { changes, ids, firstId: ids.find((id) => id !== undefined) };
         });
     }
     async internalDeleteMany(entity, qm, opts = {}) {

package/dist/mssql/index.d.ts

@@ -0,0 +1,3 @@
+export * from './mssqlDialect.js';
+export * from './mssqlQuerier.js';
+export * from './mssqlQuerierPool.js';

package/dist/mssql/index.js

@@ -0,0 +1,3 @@
+export * from './mssqlDialect.js';
+export * from './mssqlQuerier.js';
+export * from './mssqlQuerierPool.js';