uql-orm 0.51.0 → 0.53.0

package/dist/migrate/introspection/mssqlIntrospector.js

@@ -0,0 +1,205 @@
+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;
+    }
+    /**
+     * From `sys` rather than `INFORMATION_SCHEMA`, which has no identity flag and no per-column view of
+     * the key or of a unique index. A key column is not also `isUnique`, as on MySQL: only a unique index
+     * of its own, other than the key's, makes it so.
+     */
+    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,
+        f.is_primary_key,
+        f.is_unique
+      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
+      OUTER APPLY (
+        SELECT
+          MAX(CAST(i.is_primary_key AS INT)) as is_primary_key,
+          MAX(CASE WHEN i.is_primary_key = 0 AND n.key_columns = 1 THEN 1 ELSE 0 END) as is_unique
+        FROM sys.index_columns ic
+        JOIN sys.indexes i ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+        CROSS APPLY (
+          SELECT COUNT(*) as key_columns 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
+        ) n
+        WHERE ic.object_id = c.object_id AND ic.column_id = c.column_id
+          AND ic.is_included_column = 0 AND i.is_unique = 1
+      ) f
+      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
+    `;
+    }
+    async mapColumnsResult(_read, _tableName, results) {
+        return results.map((row) => {
+            const type = row.data_type.toUpperCase();
+            const bytes = this.toNumber(row.max_length);
+            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: Boolean(row.is_primary_key),
+                isUnique: Boolean(row.is_unique),
+                length: widthOf(type, bytes),
+                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']);
+/**
+ * A column's declared width from `max_length`, which is bytes: an `N` type holds two a character, a
+ * `VECTOR` is an 8-byte header and four a dimension, and `MAX` is `-1`. Read as bytes, every Unicode
+ * column would drift to double its width against the entity that declared it.
+ */
+function widthOf(type, bytes) {
+    if (bytes === undefined || bytes < 0) {
+        return undefined;
+    }
+    if (type === 'VECTOR') {
+        return (bytes - 8) / 4;
+    }
+    if (!CHARACTER_TYPES.has(type)) {
+        return undefined;
+    }
+    return type.startsWith('N') ? bytes / 2 : bytes;
+}

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

@@ -4,7 +4,7 @@ import { type DiffOptions } from '../schema/schemaASTDiffer.js';
 import type { CanonicalType, ColumnNode, ForeignKeyAction, IndexNode, TableNode } from '../schema/types.js';
 import type { ColumnSchema, CreateSchemaOptions, DialectFeatures, DropSchemaOptions, EntityMeta, FieldMeta, FieldOptions, ForeignKeySchema, IndexSchema, NamingStrategy, SchemaDiff, SchemaGenerator, SqlDdlGenerator, Type } from '../type/index.js';
 import type { FullColumnDefinition, TableDefinition } from './builder/types.js';
-import { type IndexDdl } from './ddl/index.js';
+import { type IndexDdl, type TableDdl } from './ddl/index.js';
 /**
  * Unified SQL schema generator.
  * Parameterized by dialect to handle Postgres, MySQL, MariaDB, and SQLite.
@@ -14,6 +14,8 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
     protected readonly defaultForeignKeyAction: ForeignKeyAction;
     /** `CREATE INDEX` for this dialect: the migrator's, so a runtime import carries none of it. */
     protected readonly indexDdl: IndexDdl;
+    /** The `ALTER TABLE` statements this dialect spells its own way, the migrator's for the same reason. */
+    protected readonly tableDdl: TableDdl;
     constructor(dialect: AbstractSqlDialect, defaultForeignKeyAction?: ForeignKeyAction);
     get namingStrategy(): NamingStrategy | undefined;
     get features(): DialectFeatures;
@@ -97,18 +99,14 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
      */
     generateColumnDefinitionFromSchema(column: ColumnSchema): string;
     /**
-     * The one place a column definition is spelled. Both callers reach it - the `ColumnSchema` path above
-     * and the `ColumnNode` path below - because the clause order and the "no NOT NULL on a primary key"
-     * rules are the same everywhere, and having them written twice is how the two paths drifted.
+     * The one place a column definition is spelled, so the `ColumnSchema` and `ColumnNode` paths cannot
+     * drift. A key column states `NOT NULL` rather than leave it to the key: SQLite lets a key column hold
+     * NULL otherwise, and SQL Server adds no key over a nullable column. `UNIQUE` is left to the key. An
+     * enum's `CHECK` comes last, the only place MariaDB takes it.
      */
     private renderColumn;
-    /** ` DEFAULT <sql>`, or nothing where the column declares none. Empty rather than `DEFAULT NULL`
-     * so an absent default stays absent - `defaultValue: null` is the way to ask for one. */
-    private defaultClause;
     getSqlType(field: FieldMeta): string;
-    /**
-     * Generate ALTER COLUMN statements (database-specific)
-     */
+    /** The statements that alter `column` in place, as this dialect spells them. */
     generateAlterColumnStatements(tableName: string, column: ColumnSchema, newDefinition: string): string[];
     /** The inline ` COMMENT '...'` a column declaration carries, where the engine takes one there. */
     generateColumnComment(comment: string): string;

package/dist/migrate/schemaGenerator.js

@@ -4,10 +4,11 @@ import { areTypesEqual, canonicalToSql, engineType, fieldOptionsToCanonical, isV
 import { indexSignature } from '../schema/indexDifferences.js';
 import { buildSchemaAST } from '../schema/schemaASTBuilder.js';
 import { diffRelationshipNodes, diffTable } from '../schema/schemaASTDiffer.js';
-import { getKeys, isAutoIncrement, isSoleIdField, qualifyName } from '../util/index.js';
+import { isAutoIncrement, qualifyName } from '../util/index.js';
 import { derivedCheckName, derivedForeignKeyName, derivedPrimaryKeyName } from '../util/sql.util.js';
 import { formatDefaultValue, SqlExpression } from './builder/expressions.js';
-import { indexDdlFor } from './ddl/index.js';
+import { indexDdlFor, tableDdlFor } from './ddl/index.js';
+import { sizedType } from './ddl/tableDdl.js';
 import { columnForeignKey, columnIndex, fullColumnDefinitionToNode, tableDefinitionToNode, } from './generator/definitionToNode.js';
 import { indexNodeToSchema } from './generator/indexNodeToSchema.js';
 /**
@@ -19,10 +20,13 @@ export class SqlSchemaGenerator {
     defaultForeignKeyAction;
     /** `CREATE INDEX` for this dialect: the migrator's, so a runtime import carries none of it. */
     indexDdl;
+    /** The `ALTER TABLE` statements this dialect spells its own way, the migrator's for the same reason. */
+    tableDdl;
     constructor(dialect, defaultForeignKeyAction = 'NO ACTION') {
         this.dialect = dialect;
         this.defaultForeignKeyAction = defaultForeignKeyAction;
         this.indexDdl = indexDdlFor(dialect);
+        this.tableDdl = tableDdlFor(dialect);
     }
     get namingStrategy() {
         return this.dialect.namingStrategy;
@@ -138,7 +142,6 @@ export class SqlSchemaGenerator {
     }
     generateAlterTable(diff) {
         const statements = [];
-        const tableName = this.escapeId(diff.tableName);
         // Before the columns, because a key column being added cannot be part of the old key, and after
         // it is dropped the table is free to take the new one below.
         if (diff.primaryKey?.from.length) {
@@ -154,7 +157,7 @@ export class SqlSchemaGenerator {
         if (diff.columnsToAdd?.length) {
             for (const column of diff.columnsToAdd) {
                 this.assertColumnAddable(diff.tableName, column);
-                statements.push(`ALTER TABLE ${tableName} ADD COLUMN ${this.generateColumnDefinitionFromSchema(column)};`);
+                statements.push(this.tableDdl.addColumn(diff.tableName, this.generateColumnDefinitionFromSchema(column)));
                 statements.push(...this.generateColumnCommentStatement(diff.tableName, column, diff.schema));
             }
         }
@@ -169,7 +172,7 @@ export class SqlSchemaGenerator {
         // Drop columns
         if (diff.columnsToDrop?.length) {
             for (const columnName of diff.columnsToDrop) {
-                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(columnName)};`);
+                statements.push(...this.tableDdl.dropColumn(diff.tableName, columnName));
             }
         }
         // Add indexes
@@ -206,7 +209,6 @@ export class SqlSchemaGenerator {
     }
     generateAlterTableDown(diff) {
         const statements = [];
-        const tableName = this.escapeId(diff.tableName);
         // Constraints first, mirroring the up direction: the up added them last, so the down drops them
         // first, and a column it is about to drop is then free of anything naming it.
         statements.push(...this.dropForeignKeyStatements(diff.tableName, [
@@ -222,7 +224,7 @@ export class SqlSchemaGenerator {
         // Reverse column additions by dropping them
         if (diff.columnsToAdd?.length) {
             for (const column of diff.columnsToAdd) {
-                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(column.name)};`);
+                statements.push(...this.tableDdl.dropColumn(diff.tableName, column.name));
             }
         }
         // Reverse column alterations by restoring original schema
@@ -273,53 +275,35 @@ export class SqlSchemaGenerator {
      * {@link renderColumn}, which is the part that must not be written twice.
      */
     generateColumnDefinitionFromSchema(column) {
-        let type = column.type;
-        if (!type.includes('(')) {
-            if (column.precision !== undefined) {
-                type += column.scale === undefined ? `(${column.precision})` : `(${column.precision}, ${column.scale})`;
-            }
-            else if (column.length !== undefined) {
-                type += `(${column.length})`;
-            }
-        }
-        return this.renderColumn({ ...column, type });
+        return this.renderColumn({ ...column, type: sizedType(column) });
     }
     /**
-     * The one place a column definition is spelled. Both callers reach it - the `ColumnSchema` path above
-     * and the `ColumnNode` path below - because the clause order and the "no NOT NULL on a primary key"
-     * rules are the same everywhere, and having them written twice is how the two paths drifted.
+     * The one place a column definition is spelled, so the `ColumnSchema` and `ColumnNode` paths cannot
+     * drift. A key column states `NOT NULL` rather than leave it to the key: SQLite lets a key column hold
+     * NULL otherwise, and SQL Server adds no key over a nullable column. `UNIQUE` is left to the key. An
+     * enum's `CHECK` comes last, the only place MariaDB takes it.
      */
     renderColumn(column) {
-        let def = `${this.escapeId(column.name)} ${column.type}`;
-        // Before the constraints, which every engine here accepts and is where each documents it. The
-        // clause takes the place of a `DEFAULT`, which is mutually exclusive with it; everything else -
-        // `NOT NULL`, `UNIQUE`, an enum `CHECK`, a comment - a generated column carries like any other.
-        if (column.generatedAs) {
-            def += ` GENERATED ALWAYS AS (${column.generatedAs}) STORED`;
-        }
-        if (!column.nullable && !column.isPrimaryKey) {
+        const type = column.generatedAs
+            ? this.tableDdl.storedGeneratedColumn(column.type, column.generatedAs)
+            : column.type;
+        let def = `${this.escapeId(column.name)} ${type}`;
+        if (!column.nullable) {
             def += ' NOT NULL';
         }
         if (column.isUnique && !column.isPrimaryKey) {
             def += ' UNIQUE';
         }
+        def += this.tableDdl.defaultClause(column);
+        if (column.comment) {
+            def += this.generateColumnComment(column.comment);
+        }
         if (column.enum?.length) {
             const values = column.enum.map((value) => this.dialect.escape(value)).join(', ');
             def += ` CHECK (${this.escapeId(column.name)} IN (${values}))`;
         }
-        def += this.defaultClause(column);
-        if (column.comment) {
-            def += this.generateColumnComment(column.comment);
-        }
         return def;
     }
-    /** ` DEFAULT <sql>`, or nothing where the column declares none. Empty rather than `DEFAULT NULL`
-     * so an absent default stays absent - `defaultValue: null` is the way to ask for one. */
-    defaultClause(column) {
-        return column.defaultValue === undefined
-            ? ''
-            : ` DEFAULT ${formatDefaultValue(column.defaultValue, this.dialect, column.type)}`;
-    }
     getSqlType(field) {
         // A foreign key takes the type of the key it points at. A `referencedKey` the target does not
         // have falls through to this column's own options, as the AST builder does with the same case.
@@ -338,35 +322,9 @@ export class SqlSchemaGenerator {
         }
         return this.canonicalTypeToSql(canonical);
     }
-    /**
-     * Generate ALTER COLUMN statements (database-specific)
-     */
+    /** The statements that alter `column` in place, as this dialect spells them. */
     generateAlterColumnStatements(tableName, column, newDefinition) {
-        const table = this.escapeId(tableName);
-        const colName = this.escapeId(column.name);
-        if (this.dialect.alterColumnSyntax === 'none') {
-            throw new TypeError(`${this.dialect}: Cannot alter column "${column.name}" - you must recreate the table. ` +
-                `This database does not support ALTER COLUMN.`);
-        }
-        if (this.dialect.alterColumnStrategy === 'separate-clauses') {
-            const statements = [];
-            // Separate ALTER COLUMN clauses for different changes (Postgres)
-            statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} TYPE ${column.type};`);
-            if (column.nullable) {
-                statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} DROP NOT NULL;`);
-            }
-            else {
-                statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} SET NOT NULL;`);
-            }
-            if (column.defaultValue !== undefined) {
-                statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} SET${this.defaultClause(column)};`);
-            }
-            else {
-                statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} DROP DEFAULT;`);
-            }
-            return statements;
-        }
-        return [`ALTER TABLE ${table} ${this.dialect.alterColumnSyntax} ${newDefinition};`];
+        return this.tableDdl.alterColumn(tableName, column, newDefinition);
     }
     /** The inline ` COMMENT '...'` a column declaration carries, where the engine takes one there. */
     generateColumnComment(comment) {
@@ -627,10 +585,7 @@ export class SqlSchemaGenerator {
         return this.generateCreateTableFromNode(tableNode, options);
     }
     generateRenameTableSql(oldName, newName) {
-        if (this.dialect.renameTableSyntax === 'rename-table') {
-            return `RENAME TABLE ${this.escapeId(oldName)} TO ${this.escapeId(newName)};`;
-        }
-        return `ALTER TABLE ${this.escapeId(oldName)} RENAME TO ${this.escapeId(newName)};`;
+        return this.tableDdl.renameTable(oldName, newName);
     }
     /**
      * `ADD COLUMN`, plus the constraint and index the column declares.
@@ -643,7 +598,7 @@ export class SqlSchemaGenerator {
     generateAddColumnSql(tableName, column) {
         this.assertColumnAddable(tableName, column);
         const colSql = this.generateColumnFromNode(fullColumnDefinitionToNode(column, tableName));
-        const statements = [`ALTER TABLE ${this.escapeId(tableName)} ADD COLUMN ${colSql};`];
+        const statements = [this.tableDdl.addColumn(tableName, colSql)];
         const foreignKey = columnForeignKey(column);
         if (foreignKey) {
             statements.push(...this.addForeignKeyStatements(tableName, [foreignKey]));
@@ -660,10 +615,10 @@ export class SqlSchemaGenerator {
         return this.generateAlterColumnStatements(tableName, { ...this.columnNodeToSchema(node), name: columnName }, this.generateColumnFromNode(node)).join('\n');
     }
     generateDropColumnSql(tableName, columnName) {
-        return `ALTER TABLE ${this.escapeId(tableName)} DROP COLUMN ${this.escapeId(columnName)};`;
+        return this.tableDdl.dropColumn(tableName, columnName).join('\n');
     }
     generateRenameColumnSql(tableName, oldName, newName) {
-        return `ALTER TABLE ${this.escapeId(tableName)} RENAME COLUMN ${this.escapeId(oldName)} TO ${this.escapeId(newName)};`;
+        return this.tableDdl.renameColumn(tableName, oldName, newName);
     }
     /**
      * `CONSTRAINT <name> FOREIGN KEY (...) REFERENCES ... ON DELETE ... ON UPDATE ...`.

package/dist/mongo/mongoDialect.js

@@ -4,7 +4,7 @@ import { COUNT_ALIAS, REL_NESTED_KEY, REL_TEMP_PREFIX, sortCountField } from '..
 import { resolveQueryJoins, resolveSortableJoin } from '../dialect/queryJoins.js';
 import { assertSoleId, getMeta, soleIdOf } from '../entity/index.js';
 import { QueryRaw } from '../type/queryRaw.js';
-import { asSelectMap, assertAggregateColumns, assertNonNegativeInteger, buildQueryWhereAsMap, columnFamily, entityName, fillOnFields, filterFieldKeys, findVectorIndex, findVectorSort, getKeys, getRelationRequestSummary, hasKeys, isJsonUpdateOp, isOperatorMap, isOperatorObject, isVectorSearch, normalizeScalarFieldSelection, parentJoins, parseGroupMap, parseRelationSize, parseSortByCount, someKey, targetKeyColumns, } from '../util/index.js';
+import { asSelectMap, assertAggregateColumns, assertNonNegativeInteger, columnFamily, entityName, fillOnFields, filterFieldKeys, findVectorIndex, findVectorSort, getKeys, getRelationRequestSummary, hasKeys, isJsonUpdateOp, isOperatorMap, isOperatorObject, isVectorSearch, normalizeScalarFieldSelection, parentJoins, parseGroupMap, parseRelationSize, parseSortByCount, someKey, targetKeyColumns, } from '../util/index.js';
 /** Default {@link DialectFeatures} for MongoDB; shared by {@link MongoDialect} and its schema generator. */
 export const mongoDialectFeatures = {
     explicitJsonCast: false,
@@ -14,7 +14,6 @@ export const mongoDialectFeatures = {
     indexIfNotExists: false,
     schemas: false, // the connection picks the database, and a collection name takes no dot
     dropTableCascade: false,
-    renameColumn: false,
     foreignKeyAlter: false,
     primaryKeyAlter: false,
     generatedColumnAdd: false,
@@ -22,7 +21,9 @@ export const mongoDialectFeatures = {
     vectorIndexRequiresNotNull: false,
     vectorSupportsLength: false,
     supportsTimestamptz: false,
-    defaultStringAsText: false,
+    stringSizing: 'bounded-text',
+    supportsUnsigned: false,
+    serverSideCursors: false,
 };
 /** What `toWireId` converts: the hex spelling of an `ObjectId`, and nothing looser. */
 const HEX_24 = /^[0-9a-f]{24}$/i;
@@ -67,7 +68,7 @@ export class MongoDialect extends AbstractDialect {
     where(entity, where = {}, opts = {}) {
         const meta = getMeta(entity);
         // Filters are applied once, here at the scope entry point; recursion uses `renderFilter`.
-        return this.renderFilter(entity, this.scopedWhereMap(meta, where, opts));
+        return this.renderFilter(entity, this.scopedWhere(meta, where, opts));
     }
     /**
      * A `$where` that may constrain relations, split into the `$lookup` stages it needs and the `$match`
@@ -79,7 +80,7 @@ export class MongoDialect extends AbstractDialect {
     whereWithRelations(entity, where = {}, opts = {}) {
         const meta = getMeta(entity);
         const lookups = { stages: [], temps: [] };
-        const filter = this.renderFilter(entity, this.scopedWhereMap(meta, where, opts), opts, lookups);
+        const filter = this.renderFilter(entity, this.scopedWhere(meta, where, opts), opts, lookups);
         return { stages: lookups.stages, filter, unset: lookups.temps };
     }
     /** Whether a `$where` constrains any relation, and so needs the aggregation path rather than a cursor. */
@@ -88,9 +89,9 @@ export class MongoDialect extends AbstractDialect {
             return false;
         }
         const meta = getMeta(entity);
-        const whereMap = buildQueryWhereAsMap(meta, where);
+        const whereMap = where;
         return someKey(whereMap, (key) => MongoDialect.isGroupOp(key)
-            ? (whereMap[key] ?? []).some((it) => this.constrainsRelations(entity, it))
+            ? (whereMap[key] ?? []).some((it) => !(it instanceof QueryRaw) && this.constrainsRelations(entity, it))
             : Boolean(meta.relations[key]));
     }
     /**
@@ -100,9 +101,8 @@ export class MongoDialect extends AbstractDialect {
      */
     renderFilter(entity, where = {}, opts, lookups) {
         const meta = getMeta(entity);
-        const whereMap = buildQueryWhereAsMap(meta, where);
         const filter = {};
-        for (const [rawKey, rawVal] of Object.entries(whereMap)) {
+        for (const [rawKey, rawVal] of Object.entries(where)) {
             let key = rawKey;
             let val = rawVal;
             if (MongoDialect.isGroupOp(key)) {
@@ -152,8 +152,6 @@ export class MongoDialect extends AbstractDialect {
         const { join, negate } = MongoDialect.GROUP_OPS[key];
         const parts = MongoDialect.groupClauses(key, val)
             .map((filterIt) => {
-            // A `QueryRaw` here would recurse forever: `buildQueryWhereAsMap` re-wraps it as
-            // `{ $and: [raw] }`, which lands back on this branch.
             this.assertNoRaw(filterIt);
             return this.renderFilter(entity, filterIt, opts, lookups);
         })
@@ -187,7 +185,7 @@ export class MongoDialect extends AbstractDialect {
         // `withDeleted()` or `hardDelete` on the parent must not un-hide trashed rows of the target, the
         // same rule the SQL dialects' relation subqueries follow.
         const targetCondition = (sizeVal === undefined ? val : {});
-        const targetScope = this.renderFilter(relEntity, this.scopedWhereMap(relMeta, targetCondition), opts);
+        const targetScope = this.renderFilter(relEntity, this.scopedWhere(relMeta, targetCondition), opts);
         lookups.temps.push(temp);
         lookups.stages.push(this.relationLookup(meta, relOpts, relMeta, relEntity, targetScope, temp, tail, opts));
         return sizeVal === undefined
@@ -218,7 +216,7 @@ export class MongoDialect extends AbstractDialect {
     junctionLookup(meta, relOpts, relMeta, targetScope, temp, tail, opts) {
         const throughEntity = relOpts.through();
         const throughMeta = getMeta(throughEntity);
-        const junctionScope = this.renderFilter(throughEntity, this.scopedWhereMap(throughMeta, {}), opts);
+        const junctionScope = this.renderFilter(throughEntity, this.scopedWhere(throughMeta, {}), opts);
         const nested = REL_NESTED_KEY;
         // Both ends are one column here - each `$lookup` matches one field against `_id` - so both sides
         // must be sole-keyed. Sliced rather than indexed positionally: `references[1]` is the parent's
@@ -490,7 +488,7 @@ export class MongoDialect extends AbstractDialect {
             const relEntity = relOpts.entity();
             const relMeta = getMeta(relEntity);
             const temp = sortCountField(key);
-            const targetScope = this.renderFilter(relEntity, this.scopedWhereMap(relMeta, {}), opts);
+            const targetScope = this.renderFilter(relEntity, this.scopedWhere(relMeta, {}), opts);
             const tail = [{ $count: COUNT_ALIAS }];
             stages.push(this.relationLookup(meta, relOpts, relMeta, relEntity, targetScope, temp, tail, opts), {
                 $addFields: { [temp]: { $ifNull: [{ $arrayElemAt: [`$${temp}.${COUNT_ALIAS}`, 0] }, 0] } },

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