@mikro-orm/mssql 7.1.0-dev.8 → 7.1.0

package/MsSqlConnection.d.ts

@@ -1,10 +1,12 @@
 import { AbstractSqlConnection, type TransactionEventBroadcaster } from '@mikro-orm/sql';
 import { type ControlledTransaction, MssqlDialect } from 'kysely';
+import { type Routine, type Transaction } from '@mikro-orm/core';
 import type { ConnectionConfiguration } from 'tedious';
 /** Microsoft SQL Server database connection using the `tedious` driver. */
 export declare class MsSqlConnection extends AbstractSqlConnection {
     createKyselyDialect(overrides: ConnectionConfiguration): MssqlDialect;
     private mapOptions;
+    callRoutine<T>(routine: Routine, args?: Record<string, unknown>, ctx?: Transaction): Promise<T>;
     commit(ctx: ControlledTransaction<any, any>, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
     protected transformRawResult<T>(res: any, method: 'all' | 'get' | 'run'): T;
 }

package/MsSqlConnection.js

@@ -1,4 +1,4 @@
-import { AbstractSqlConnection, Utils } from '@mikro-orm/sql';
+import { AbstractSqlConnection, DatabaseSchema, Utils, } from '@mikro-orm/sql';
 import { MssqlDialect } from 'kysely';
 import * as Tedious from 'tedious';
 import * as Tarn from 'tarn';
@@ -55,6 +55,53 @@ export class MsSqlConnection extends AbstractSqlConnection {
         }
         return Utils.mergeConfig(ret, overrides);
     }
+    async callRoutine(routine, args = {}, ctx) {
+        if (routine.type === 'function') {
+            return this.callRoutineFunction(routine, args, ctx);
+        }
+        // MSSQL scalar UDF calls must be schema-qualified — `select sql_hash(...)` fails to parse.
+        const schema = routine.schema ?? this.platform.getDefaultSchemaName() ?? 'dbo';
+        const qualified = `${this.platform.quoteIdentifier(schema)}.${this.platform.quoteIdentifier(routine.name)}`;
+        // T-SQL session variables don't persist across execute() calls (different pool connections),
+        // so DECLARE/SET/EXEC/SELECT must go through as a single batch.
+        const declareLines = [];
+        const setLines = [];
+        const setValues = [];
+        const callArgs = [];
+        const inValues = [];
+        const outVars = [];
+        routine.params.forEach((p, i) => {
+            if (p.direction === 'in') {
+                callArgs.push('?');
+                inValues.push(this.convertRoutineInbound(args[p.name], p));
+                return;
+            }
+            const varName = `@_mikro_orm_routine_${i}`;
+            // Logical aliases like `'string'`/`'number'` aren't valid T-SQL types — translate them
+            // through the platform's type system, matching the DDL side in `DatabaseSchema`.
+            const declType = DatabaseSchema.resolveRoutineColumnType(p.type, this.platform);
+            declareLines.push(`declare ${varName} ${declType}`);
+            outVars.push({ name: p.name, varName, param: p });
+            if (p.direction === 'inout') {
+                setLines.push(`set ${varName} = ?`);
+                setValues.push(this.convertRoutineInbound(args[p.name], p));
+            }
+            callArgs.push(`${varName} output`);
+        });
+        const allValues = [...setValues, ...inValues];
+        const batch = [...declareLines, ...setLines, `exec ${qualified} ${callArgs.join(', ')}`];
+        if (outVars.length > 0) {
+            const selectClause = outVars.map(o => `${o.varName} as ${this.platform.quoteIdentifier(o.name)}`).join(', ');
+            batch.push(`select ${selectClause}`);
+        }
+        const result = await this.execute(batch.join('; '), allValues, 'all', ctx);
+        if (outVars.length === 0) {
+            return undefined;
+        }
+        const rows = result;
+        this.applyRoutineOutParams(rows[0] ?? {}, outVars.map(o => o.param), args);
+        return undefined;
+    }
     async commit(ctx, eventBroadcaster) {
         if ('savepointName' in ctx) {
             return;

package/MsSqlMikroORM.d.ts

@@ -1,5 +1,5 @@
-import { type AnyEntity, type EntityClass, type EntitySchema, MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from '@mikro-orm/core';
-import type { SqlEntityManager } from '@mikro-orm/sql';
+import { type AnyEntity, type EntityClass, type EntitySchema, type MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from '@mikro-orm/core';
+import { SqlMikroORM, type SqlEntityManager } from '@mikro-orm/sql';
 import { MsSqlDriver } from './MsSqlDriver.js';
 /** Configuration options for the MSSQL driver. */
 export type MsSqlOptions<EM extends SqlEntityManager<MsSqlDriver> = SqlEntityManager<MsSqlDriver>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = Partial<Options<MsSqlDriver, EM, Entities>>;
@@ -8,7 +8,7 @@ export declare function defineMsSqlConfig<EM extends SqlEntityManager<MsSqlDrive
 /**
  * @inheritDoc
  */
-export declare class MsSqlMikroORM<EM extends SqlEntityManager<MsSqlDriver> = SqlEntityManager<MsSqlDriver>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends MikroORM<MsSqlDriver, EM, Entities> {
+export declare class MsSqlMikroORM<EM extends SqlEntityManager<MsSqlDriver> = SqlEntityManager<MsSqlDriver>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends SqlMikroORM<MsSqlDriver, EM, Entities> {
     /**
      * @inheritDoc
      */

package/MsSqlMikroORM.js

@@ -1,4 +1,5 @@
-import { defineConfig, MikroORM, } from '@mikro-orm/core';
+import { defineConfig, } from '@mikro-orm/core';
+import { SqlMikroORM } from '@mikro-orm/sql';
 import { MsSqlDriver } from './MsSqlDriver.js';
 /** Creates a type-safe configuration object for the MSSQL driver. */
 export function defineMsSqlConfig(options) {
@@ -7,7 +8,7 @@ export function defineMsSqlConfig(options) {
 /**
  * @inheritDoc
  */
-export class MsSqlMikroORM extends MikroORM {
+export class MsSqlMikroORM extends SqlMikroORM {
     /**
      * @inheritDoc
      */

package/MsSqlPlatform.d.ts

@@ -21,6 +21,8 @@ export declare class MsSqlPlatform extends AbstractSqlPlatform {
     convertDateToJSValue(value: string | Date): string;
     convertsJsonAutomatically(): boolean;
     indexForeignKeys(): boolean;
+    /** SQL Server identifier limit (sysname). */
+    getMaxIdentifierLength(): number;
     supportsSchemas(): boolean;
     getCurrentTimestampSQL(length: number): string;
     getDateTimeTypeDeclarationSQL(column: {

package/MsSqlPlatform.js

@@ -55,6 +55,10 @@ export class MsSqlPlatform extends AbstractSqlPlatform {
     indexForeignKeys() {
         return false;
     }
+    /** SQL Server identifier limit (sysname). */
+    getMaxIdentifierLength() {
+        return 128;
+    }
     supportsSchemas() {
         return true;
     }
@@ -139,6 +143,7 @@ export class MsSqlPlatform extends AbstractSqlPlatform {
         return 'uniqueidentifier';
     }
     validateMetadata(meta) {
+        super.validateMetadata(meta);
         for (const prop of meta.props) {
             if ((prop.runtimeType === 'string' || ['string', 'nvarchar'].includes(prop.type)) &&
                 !['uuid'].includes(prop.type) &&
@@ -153,16 +158,17 @@ export class MsSqlPlatform extends AbstractSqlPlatform {
     getSearchJsonPropertyKey(path, type, aliased, value) {
         const [a, ...b] = path;
         /* v8 ignore next */
-        const root = this.quoteIdentifier(aliased ? `${ALIAS_REPLACEMENT}.${a}` : a);
+        const root = aliased ? `[${ALIAS_REPLACEMENT}].${this.quoteIdentifier(a)}` : this.quoteIdentifier(a);
         const types = {
             boolean: 'bit',
         };
         const cast = (key) => raw(type in types ? `cast(${key} as ${types[type]})` : key);
+        const jsonPath = this.quoteValue(`$.${b.map(this.quoteJsonKey).join('.')}`);
         /* v8 ignore next */
         if (path.length === 0) {
-            return cast(`json_value(${root}, '$.${b.map(this.quoteJsonKey).join('.')}')`);
+            return cast(`json_value(${root}, ${jsonPath})`);
         }
-        return cast(`json_value(${root}, '$.${b.map(this.quoteJsonKey).join('.')}')`);
+        return cast(`json_value(${root}, ${jsonPath})`);
     }
     getJsonArrayFromSQL(column, alias, properties) {
         const columns = properties
@@ -190,7 +196,7 @@ export class MsSqlPlatform extends AbstractSqlPlatform {
         if (RawQueryFragment.isKnownFragment(id)) {
             return super.quoteIdentifier(id);
         }
-        return `[${id.toString().replace('.', `].[`)}]`;
+        return `[${id.toString().replaceAll(']', ']]').replace('.', `].[`)}]`;
     }
     escape(value) {
         if (value instanceof UnicodeString) {

package/MsSqlSchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import { type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSchema, type DatabaseTable, type Dictionary, type ForeignKey, type IndexDef, SchemaHelper, type Table, type TableDifference, type SqlTriggerDef, type Transaction, type Type } from '@mikro-orm/sql';
+import { type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSchema, type DatabaseTable, type Dictionary, type ForeignKey, type IndexDef, SchemaHelper, type Table, type TableDifference, type SqlTriggerDef, type SqlRoutineDef, type Transaction, type Type } from '@mikro-orm/sql';
 /** Schema introspection helper for Microsoft SQL Server. */
 export declare class MsSqlSchemaHelper extends SchemaHelper {
     static readonly DEFAULT_VALUES: {
@@ -6,6 +6,8 @@ export declare class MsSqlSchemaHelper extends SchemaHelper {
         false: string[];
         'getdate()': string[];
     };
+    private static readonly AUTO_NOT_NULL_RE;
+    protected get bracketQuotedIdentifiers(): boolean;
     getManagementDbName(): string;
     getDropDatabaseSQL(name: string): string;
     disableForeignKeysSQL(): string;
@@ -27,7 +29,16 @@ export declare class MsSqlSchemaHelper extends SchemaHelper {
     createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
     /** Generates SQL to drop an MSSQL trigger. */
     dropTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    routineParamReference(name: string): string;
+    /** T-SQL's `OUTPUT` covers both OUT and INOUT; `sys.parameters.is_output` is true for both. */
+    normaliseRoutineParamDirection(direction: 'in' | 'out' | 'inout'): 'in' | 'out' | 'inout';
+    createRoutine(routine: SqlRoutineDef): string;
+    dropRoutine(routine: SqlRoutineDef): string;
+    getAllRoutines(connection: AbstractSqlConnection): Promise<SqlRoutineDef[]>;
+    private getAllRoutineParams;
+    private unwrapMsSqlBody;
     private getSchemaQualifiedName;
+    getDatabaseCollation(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string | undefined>;
     getAllTriggers(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<SqlTriggerDef[]>>;
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[], ctx?: Transaction): Promise<void>;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];

package/MsSqlSchemaHelper.js

@@ -7,12 +7,43 @@ export class MsSqlSchemaHelper extends SchemaHelper {
         false: ['0'],
         'getdate()': ['current_timestamp'],
     };
+    // `stripAutoNotNullFilter` unwraps balanced per-clause parens before calling `.exec`, so we
+    // only need to match the bare form here — previously the pattern allowed independently
+    // optional leading/trailing parens, which accepted unbalanced strings like `([col] IS NOT NULL`.
+    static AUTO_NOT_NULL_RE = /^\[([^\]]+)\]\s+IS\s+NOT\s+NULL$/i;
+    // MSSQL `filter_definition` and `where` predicates use `[…]` bracket-quoting for identifiers,
+    // so `splitTopLevelAnd` must treat `[` as opening a quoted span (otherwise `[some and col]`
+    // would split mid-identifier).
+    get bracketQuotedIdentifiers() {
+        return true;
+    }
     getManagementDbName() {
         return 'master';
     }
     getDropDatabaseSQL(name) {
+        // `set offline` rejects all connections including the issuing session, so there is no
+        // single-user race window where a torn-down pool connection can reconnect between the
+        // mode switch and the drop (SQL Server error 3702 "currently in use"). Dropping an
+        // offline database leaves the underlying `.mdf`/`.ldf` files behind though, which
+        // makes a subsequent `create database` with the same name fail with error 5170
+        // ("file already exists"). Capture the physical paths up front and call
+        // `master.sys.xp_delete_files` after the drop to clean them up.
         const quoted = this.quote(name);
-        return `if db_id(${this.platform.quoteValue(name)}) is not null begin alter database ${quoted} set single_user with rollback immediate; drop database ${quoted}; end`;
+        const literal = this.platform.quoteValue(name);
+        return (`if db_id(${literal}) is not null begin ` +
+            `declare @drop_files table (path nvarchar(260)); ` +
+            `insert into @drop_files (path) select physical_name from sys.master_files where database_id = db_id(${literal}); ` +
+            `alter database ${quoted} set offline with rollback immediate; ` +
+            `drop database ${quoted}; ` +
+            `declare @drop_path nvarchar(260); ` +
+            `declare drop_files_cursor cursor local fast_forward for select path from @drop_files; ` +
+            `open drop_files_cursor; fetch next from drop_files_cursor into @drop_path; ` +
+            `while @@fetch_status = 0 begin ` +
+            `begin try exec master.sys.xp_delete_files @drop_path; end try begin catch end catch; ` +
+            `fetch next from drop_files_cursor into @drop_path; ` +
+            `end ` +
+            `close drop_files_cursor; deallocate drop_files_cursor; ` +
+            `end`);
     }
     disableForeignKeysSQL() {
         return `exec sp_MSforeachtable 'alter table ? nocheck constraint all';`;
@@ -83,7 +114,8 @@ export class MsSqlSchemaHelper extends SchemaHelper {
       numeric_scale as numeric_scale,
       datetime_precision as datetime_precision,
       character_maximum_length as character_maximum_length,
-      columnproperty(sc.object_id, column_name, 'IsIdentity') is_identity
+      columnproperty(sc.object_id, column_name, 'IsIdentity') is_identity,
+      nullif(ic.collation_name, convert(nvarchar(128), databasepropertyex(db_name(), 'Collation'))) as collation_name
       from information_schema.columns ic
       inner join sys.columns sc on sc.name = ic.column_name and sc.object_id = object_id(ic.table_schema + '.' + ic.table_name)
       left join sys.computed_columns cmp on cmp.name = ic.column_name and cmp.object_id = object_id(ic.table_schema + '.' + ic.table_name)
@@ -135,6 +167,7 @@ export class MsSqlSchemaHelper extends SchemaHelper {
                 precision: col.numeric_precision,
                 scale: col.numeric_scale,
                 comment: col.column_comment,
+                collation: col.collation_name ?? undefined,
                 generated,
             });
         }
@@ -148,6 +181,7 @@ export class MsSqlSchemaHelper extends SchemaHelper {
       col.name as column_name,
       schema_name(t.schema_id) as schema_name,
       (case when filter_definition is not null then concat('where ', filter_definition) else null end) as expression,
+      filter_definition as filter_definition,
       ind.is_disabled as is_disabled,
       ind.type as index_type,
       ind.fill_factor as fill_factor,
@@ -192,15 +226,31 @@ export class MsSqlSchemaHelper extends SchemaHelper {
             if (index.fill_factor > 0) {
                 indexDef.fillFactor = index.fill_factor;
             }
-            if (index.column_name?.match(/[(): ,"'`]/) || index.expression?.match(/where /i)) {
-                indexDef.expression = index.expression; // required for the `getCreateIndexSQL()` call
+            /* v8 ignore next: function-based / computed-column introspection path, same as pre-PR */
+            if (index.column_name?.match(/[(): ,"'`]/)) {
+                indexDef.expression = index.expression;
                 indexDef.expression = this.getCreateIndexSQL(index.table_name, indexDef, !!index.expression);
             }
+            else if (index.filter_definition) {
+                // Auto-NOT-NULL stripping runs post-mapIndexes (needs the consolidated column list).
+                indexDef.where = index.filter_definition;
+            }
             ret[key] ??= [];
             ret[key].push(indexDef);
         }
         for (const key of Object.keys(ret)) {
             ret[key] = await this.mapIndexes(ret[key]);
+            for (const idx of ret[key]) {
+                if (idx.where) {
+                    const stripped = this.stripAutoNotNullFilter(idx.where, idx.columnNames, MsSqlSchemaHelper.AUTO_NOT_NULL_RE);
+                    if (stripped === '') {
+                        delete idx.where;
+                    }
+                    else {
+                        idx.where = stripped;
+                    }
+                }
+            }
         }
         return ret;
     }
@@ -303,6 +353,113 @@ export class MsSqlSchemaHelper extends SchemaHelper {
     dropTrigger(table, trigger) {
         return `drop trigger if exists ${this.getSchemaQualifiedName(table, trigger.name)}`;
     }
+    routineParamReference(name) {
+        return `@${name}`;
+    }
+    /** T-SQL's `OUTPUT` covers both OUT and INOUT; `sys.parameters.is_output` is true for both. */
+    normaliseRoutineParamDirection(direction) {
+        return direction === 'out' ? 'inout' : direction;
+    }
+    createRoutine(routine) {
+        if (routine.expression) {
+            return routine.expression;
+        }
+        const qualifiedName = this.qualifiedRoutineName(routine);
+        const params = routine.params
+            .map(p => {
+            const dir = p.direction === 'out' || p.direction === 'inout' ? ' OUTPUT' : '';
+            return `@${p.name} ${p.type}${dir}`;
+        })
+            .join(', ');
+        const body = this.wrapRoutineBody(routine.body ?? '');
+        if (routine.type === 'procedure') {
+            return `create or alter procedure ${qualifiedName} ${params} as ${body}`;
+        }
+        const returnType = routine.returns?.type ?? 'nvarchar(max)';
+        return `create or alter function ${qualifiedName}(${params}) returns ${returnType} as ${body}`;
+    }
+    dropRoutine(routine) {
+        const kind = routine.type === 'procedure' ? 'procedure' : 'function';
+        return `drop ${kind} if exists ${this.qualifiedRoutineName(routine)}`;
+    }
+    async getAllRoutines(connection) {
+        const sql = `
+      select
+        s.name as schema_name,
+        o.name as name,
+        case
+          when o.type = 'P' then 'procedure'
+          when o.type in ('FN', 'IF', 'TF') then 'function'
+        end as kind,
+        m.definition as definition,
+        ep.value as comment
+      from sys.objects o
+      join sys.schemas s on s.schema_id = o.schema_id
+      join sys.sql_modules m on m.object_id = o.object_id
+      left join sys.extended_properties ep
+        on ep.major_id = o.object_id and ep.minor_id = 0 and ep.name = 'MS_Description'
+      where o.type in ('P', 'FN', 'IF', 'TF')
+        and o.is_ms_shipped = 0
+    `;
+        const [rows, paramsAndReturns] = await Promise.all([
+            connection.execute(sql),
+            this.getAllRoutineParams(connection),
+        ]);
+        const { params, returns } = paramsAndReturns;
+        return rows.map(row => ({
+            name: row.name,
+            schema: row.schema_name,
+            type: row.kind,
+            body: this.unwrapMsSqlBody(row.definition),
+            comment: row.comment ?? undefined,
+            params: params.get(`${row.schema_name}.${row.name}`) ?? [],
+            returns: row.kind === 'function'
+                ? (returns.get(`${row.schema_name}.${row.name}`) ?? { type: 'nvarchar(max)', nullable: true })
+                : undefined,
+        }));
+    }
+    async getAllRoutineParams(connection) {
+        // `parameter_id = 0` is the function's return type; positive IDs are formal parameters.
+        const sql = `
+      select
+        s.name as schema_name,
+        o.name as routine_name,
+        p.name as param_name,
+        type_name(p.user_type_id) as type,
+        p.is_output as is_output,
+        p.parameter_id as position
+      from sys.parameters p
+      join sys.objects o on o.object_id = p.object_id
+      join sys.schemas s on s.schema_id = o.schema_id
+      where o.type in ('P', 'FN', 'IF', 'TF')
+        and o.is_ms_shipped = 0
+      order by o.object_id, p.parameter_id
+    `;
+        const rows = await connection.execute(sql);
+        const params = new Map();
+        const returns = new Map();
+        for (const row of rows) {
+            const key = `${row.schema_name}.${row.routine_name}`;
+            if (row.position === 0) {
+                returns.set(key, { type: row.type, nullable: true });
+                continue;
+            }
+            if (!params.has(key)) {
+                params.set(key, []);
+            }
+            // is_output is true for both OUT and INOUT; we always report `inout`. See normaliseRoutineParamDirection.
+            params.get(key).push({
+                name: row.param_name.replace(/^@/, ''),
+                type: row.type,
+                direction: row.is_output ? 'inout' : 'in',
+            });
+        }
+        return { params, returns };
+    }
+    unwrapMsSqlBody(definition) {
+        const asMatch = /\bas\s+([\s\S]*)$/i.exec(definition);
+        return this.stripRoutineBody(asMatch ? asMatch[1] : definition);
+    }
     getSchemaQualifiedName(table, name) {
         const defaultSchema = this.platform.getDefaultSchemaName();
         if (table.schema && table.schema !== defaultSchema) {
@@ -310,6 +467,10 @@ export class MsSqlSchemaHelper extends SchemaHelper {
         }
         return this.quote(name);
     }
+    async getDatabaseCollation(connection, ctx) {
+        const [row] = await connection.execute(`select convert(nvarchar(128), databasepropertyex(db_name(), 'Collation')) as collation`, [], 'all', ctx);
+        return row?.collation;
+    }
     async getAllTriggers(connection, tablesBySchemas) {
         const conditions = [];
         for (const [schema, tables] of tablesBySchemas) {
@@ -371,9 +532,11 @@ export class MsSqlSchemaHelper extends SchemaHelper {
         const checks = await this.getAllChecks(connection, tablesBySchema, ctx);
         const fks = await this.getAllForeignKeys(connection, tablesBySchema, ctx);
         const triggers = await this.getAllTriggers(connection, tablesBySchema);
+        const dbCollation = await this.getDatabaseCollation(connection, ctx);
         for (const t of tables) {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
+            table.collation = dbCollation;
             const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
             const enums = this.getEnumDefinitions(checks[key] ?? []);
             table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums);
@@ -495,7 +658,11 @@ export class MsSqlSchemaHelper extends SchemaHelper {
         else {
             col.push(columnType);
         }
-        Utils.runIfNotEmpty(() => col.push('identity(1,1)'), column.autoincrement);
+        Utils.runIfNotEmpty(() => col.push(this.getCollateSQL(column.collation)), column.collation);
+        // `IDENTITY(1,1)` is rejected inside `ALTER COLUMN`, so it must only be emitted when the
+        // change actually involves the identity attribute or is a fresh column (no `changedProperties`).
+        Utils.runIfNotEmpty(() => col.push('identity(1,1)'), column.autoincrement &&
+            (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type')));
         Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
         Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable && !column.generated);
         if (column.autoincrement &&
@@ -517,7 +684,7 @@ export class MsSqlSchemaHelper extends SchemaHelper {
             const [constraint] = this.getDropDefaultsSQL(table.name, [column], table.schema);
             parts.push(constraint);
         }
-        if (changedProperties.has('type') || changedProperties.has('nullable')) {
+        if (changedProperties.has('type') || changedProperties.has('nullable') || changedProperties.has('collation')) {
             const col = this.createTableColumn(column, table, changedProperties);
             parts.push(`alter table ${table.getQuotedName()} alter column ${col}`);
         }
@@ -540,7 +707,7 @@ export class MsSqlSchemaHelper extends SchemaHelper {
         const clustered = index.clustered ? 'clustered ' : '';
         let sql = `create ${index.unique ? 'unique ' : ''}${clustered}index ${keyName} on ${this.quote(tableName)} `;
         if (index.expression && partialExpression) {
-            return sql + `(${index.expression})` + this.getMsSqlIndexSuffix(index);
+            return sql + `(${index.expression})` + this.getMsSqlIndexSuffix(index) + this.getIndexWhereClause(index);
         }
         // Build column list with advanced options
         const columns = this.getIndexColumns(index);
@@ -549,7 +716,7 @@ export class MsSqlSchemaHelper extends SchemaHelper {
         if (index.include?.length) {
             sql += ` include (${index.include.map(c => this.quote(c)).join(', ')})`;
         }
-        sql += this.getMsSqlIndexSuffix(index);
+        sql += this.getMsSqlIndexSuffix(index) + this.getIndexWhereClause(index);
         // Disabled indexes need to be created first, then disabled
         if (index.disabled) {
             sql += `;\nalter index ${keyName} on ${this.quote(tableName)} disable`;
@@ -560,19 +727,17 @@ export class MsSqlSchemaHelper extends SchemaHelper {
      * Build the column list for a MSSQL index.
      */
     getIndexColumns(index) {
-        if (index.columns?.length) {
-            return index.columns
-                .map(col => {
-                let colDef = this.quote(col.name);
-                // MSSQL supports sort order
-                if (col.sort) {
-                    colDef += ` ${col.sort}`;
-                }
-                return colDef;
-            })
-                .join(', ');
-        }
-        return index.columnNames.map(c => this.quote(c)).join(', ');
+        return index.columnNames
+            .map(name => {
+            const col = index.columns?.find(c => c.name === name);
+            let colDef = this.quote(name);
+            // MSSQL supports sort order
+            if (col?.sort) {
+                colDef += ` ${col.sort}`;
+            }
+            return colDef;
+        })
+            .join(', ');
     }
     /**
      * Get MSSQL-specific index WITH options like fill factor.
@@ -594,13 +759,16 @@ export class MsSqlSchemaHelper extends SchemaHelper {
         if (index.expression) {
             return index.expression;
         }
-        const needsWhereClause = index.unique && index.columnNames.some(column => table.getColumn(column)?.nullable);
-        if (!needsWhereClause) {
+        const needsAutoNotNull = index.unique && index.columnNames.some(column => table.getColumn(column)?.nullable);
+        if (!needsAutoNotNull) {
             return this.getCreateIndexSQL(table.getShortestName(), index);
         }
-        // Generate without disabled suffix, insert WHERE clause, then re-add disabled
-        let sql = this.getCreateIndexSQL(table.getShortestName(), { ...index, disabled: false });
-        sql += ' where ' + index.columnNames.map(c => `${this.quote(c)} is not null`).join(' and ');
+        // Strip `index.where` from the base SQL so we can combine it with the auto NOT-NULL guard
+        // ourselves, wrapping the user predicate in parens to defuse operator precedence
+        // (a bare `a = 1 or b = 2 and [col] is not null` would bind as `a = 1 or (b = 2 and …)`).
+        let sql = this.getCreateIndexSQL(table.getShortestName(), { ...index, where: undefined, disabled: false });
+        const autoNotNull = index.columnNames.map(c => `${this.quote(c)} is not null`).join(' and ');
+        sql += index.where ? ` where (${index.where}) and ${autoNotNull}` : ` where ${autoNotNull}`;
         if (index.disabled) {
             sql += `;\nalter index ${this.quote(index.keyName)} on ${table.getQuotedName()} disable`;
         }

package/README.md

@@ -2,7 +2,7 @@
   <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
 </h1>
 
-TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite (including libSQL), MSSQL and Oracle databases.
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL (including CockroachDB and PGlite), SQLite (including libSQL), MSSQL and Oracle databases.
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
@@ -19,6 +19,7 @@ Install a driver package for your database:
 
 ```sh
 npm install @mikro-orm/postgresql   # PostgreSQL
+npm install @mikro-orm/pglite       # PGlite (embedded PostgreSQL in WASM)
 npm install @mikro-orm/mysql        # MySQL
 npm install @mikro-orm/mariadb      # MariaDB
 npm install @mikro-orm/sqlite       # SQLite

package/index.d.ts

@@ -5,3 +5,7 @@ export * from './MsSqlPlatform.js';
 export * from './MsSqlSchemaHelper.js';
 export * from './UnicodeStringType.js';
 export { MsSqlMikroORM as MikroORM, type MsSqlOptions as Options, defineMsSqlConfig as defineConfig, } from './MsSqlMikroORM.js';
+import { type AbstractSqlDriver, SqlEntityManager } from '@mikro-orm/sql';
+import type { MsSqlDriver } from './MsSqlDriver.js';
+export type EntityManager<Driver extends AbstractSqlDriver = MsSqlDriver> = SqlEntityManager<Driver>;
+export declare const EntityManager: typeof SqlEntityManager;

package/index.js

@@ -5,3 +5,5 @@ export * from './MsSqlPlatform.js';
 export * from './MsSqlSchemaHelper.js';
 export * from './UnicodeStringType.js';
 export { MsSqlMikroORM as MikroORM, defineMsSqlConfig as defineConfig, } from './MsSqlMikroORM.js';
+import { SqlEntityManager } from '@mikro-orm/sql';
+export const EntityManager = SqlEntityManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/mssql",
-  "version": "7.1.0-dev.8",
+  "version": "7.1.0",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",
@@ -47,17 +47,17 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "@mikro-orm/sql": "7.1.0-dev.8",
-    "kysely": "0.28.16",
+    "@mikro-orm/sql": "7.1.0",
+    "kysely": "0.29.2",
     "tarn": "3.0.2",
     "tedious": "19.2.1",
     "tsqlstring": "1.0.1"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.11"
+    "@mikro-orm/core": "^7.1.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.8"
+    "@mikro-orm/core": "7.1.0"
   },
   "engines": {
     "node": ">= 22.17.0"