@mikro-orm/mssql 7.0.0-dev.31 → 7.0.0-dev.311

package/MsSqlConnection.d.ts

@@ -1,4 +1,4 @@
-import { AbstractSqlConnection, type TransactionEventBroadcaster } from '@mikro-orm/knex';
+import { AbstractSqlConnection, type TransactionEventBroadcaster } from '@mikro-orm/sql';
 import { type ControlledTransaction, MssqlDialect } from 'kysely';
 import type { ConnectionConfiguration } from 'tedious';
 export declare class MsSqlConnection extends AbstractSqlConnection {

package/MsSqlConnection.js

@@ -1,4 +1,4 @@
-import { AbstractSqlConnection, Utils, } from '@mikro-orm/knex';
+import { AbstractSqlConnection, Utils } from '@mikro-orm/sql';
 import { MssqlDialect } from 'kysely';
 import * as Tedious from 'tedious';
 import * as Tarn from 'tarn';
@@ -45,7 +45,7 @@ export class MsSqlConnection extends AbstractSqlConnection {
             },
             server: options.host,
         };
-        /* v8 ignore next 6 */
+        /* v8 ignore next */
         if (ret.server.includes('\\')) {
             const [host, ...name] = ret.server.split('\\');
             ret.server = host;
@@ -68,7 +68,7 @@ export class MsSqlConnection extends AbstractSqlConnection {
             return res.rows;
         }
         const rowCount = res.rows.length;
-        const hasEmptyCount = (rowCount === 1) && ('' in res.rows[0]);
+        const hasEmptyCount = rowCount === 1 && '' in res.rows[0];
         const emptyRow = hasEmptyCount && Number(res.rows[0]['']);
         return {
             affectedRows: hasEmptyCount ? emptyRow : Number(res.numAffectedRows),

package/MsSqlDriver.d.ts

@@ -1,10 +1,13 @@
-import { type AnyEntity, type Configuration, type ConnectionType, type EntityDictionary, type LoggingOptions, type NativeInsertUpdateManyOptions, type QueryResult, type Transaction } from '@mikro-orm/core';
-import { AbstractSqlDriver, type SqlEntityManager } from '@mikro-orm/knex';
+import { type AnyEntity, type Configuration, type ConnectionType, type EntityDictionary, type LoggingOptions, type NativeInsertUpdateManyOptions, type QueryResult, type Transaction, type Constructor, type EntityName } from '@mikro-orm/core';
+import { AbstractSqlDriver, type SqlEntityManager } from '@mikro-orm/sql';
 import { MsSqlConnection } from './MsSqlConnection.js';
 import { MsSqlQueryBuilder } from './MsSqlQueryBuilder.js';
+import { MsSqlMikroORM } from './MsSqlMikroORM.js';
 export declare class MsSqlDriver extends AbstractSqlDriver<MsSqlConnection> {
     constructor(config: Configuration);
-    nativeInsertMany<T extends AnyEntity<T>>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
-    createQueryBuilder<T extends AnyEntity<T>>(entityName: string, ctx?: Transaction, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): MsSqlQueryBuilder<T, any, any, any>;
+    nativeInsertMany<T extends AnyEntity<T>>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    createQueryBuilder<T extends AnyEntity<T>>(entityName: EntityName<T>, ctx?: Transaction, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): MsSqlQueryBuilder<T, any, any, any>;
     private appendOutputTable;
+    /** @inheritDoc */
+    getORMClass(): Constructor<MsSqlMikroORM>;
 }

package/MsSqlDriver.js

@@ -1,8 +1,9 @@
 import { QueryFlag, Utils, isRaw, } from '@mikro-orm/core';
-import { AbstractSqlDriver } from '@mikro-orm/knex';
+import { AbstractSqlDriver } from '@mikro-orm/sql';
 import { MsSqlConnection } from './MsSqlConnection.js';
 import { MsSqlPlatform } from './MsSqlPlatform.js';
 import { MsSqlQueryBuilder } from './MsSqlQueryBuilder.js';
+import { MsSqlMikroORM } from './MsSqlMikroORM.js';
 export class MsSqlDriver extends AbstractSqlDriver {
     constructor(config) {
         super(config, new MsSqlPlatform(), MsSqlConnection, ['kysely', 'tedious']);
@@ -21,10 +22,12 @@ export class MsSqlDriver extends AbstractSqlDriver {
             const returningFields = Utils.flatten(returningProps.map(prop => prop.fieldNames));
             const using2 = `select * from (values ${data.map((x, i) => `(${i})`).join(',')}) v (id) where 1 = 1`;
             /* v8 ignore next */
-            const output = returningFields.length > 0 ? `output ${returningFields.map(field => 'inserted.' + this.platform.quoteIdentifier(field)).join(', ')}` : '';
+            const output = returningFields.length > 0
+                ? `output ${returningFields.map(field => 'inserted.' + this.platform.quoteIdentifier(field)).join(', ')}`
+                : '';
             const sql = `merge into ${tableName} using (${using2}) s on 1 = 0 when not matched then insert default values ${output};`;
             const res = await this.execute(sql, [], 'run', options.ctx);
-            const pks = this.getPrimaryKeyFields(entityName);
+            const pks = this.getPrimaryKeyFields(meta);
             if (pks.length === 1) {
                 res.row ??= {};
                 res.rows ??= [];
@@ -32,7 +35,8 @@ export class MsSqlDriver extends AbstractSqlDriver {
             }
             return res;
         }
-        if (props.some(prop => prop.autoincrement)) {
+        // For TPT child entities, the parent table owns the identity column, not the child table
+        if (props.some(prop => prop.autoincrement && (!meta.ownProps || meta.ownProps.includes(prop)))) {
             return super.nativeInsertMany(entityName, data, options, sql => {
                 return `set identity_insert ${tableName} on; ${sql}; set identity_insert ${tableName} off`;
             });
@@ -41,7 +45,9 @@ export class MsSqlDriver extends AbstractSqlDriver {
     }
     createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes, loggerContext, alias, em) {
         // do not compute the connectionType if EM is provided as it will be computed from it in the QB later on
-        const connectionType = em ? preferredConnectionType : this.resolveConnectionType({ ctx, connectionType: preferredConnectionType });
+        const connectionType = em
+            ? preferredConnectionType
+            : this.resolveConnectionType({ ctx, connectionType: preferredConnectionType });
         const qb = new MsSqlQueryBuilder(entityName, this.metadata, this, ctx, alias, connectionType, em, loggerContext);
         if (!convertCustomTypes) {
             qb.unsetFlag(QueryFlag.CONVERT_CUSTOM_TYPES);
@@ -51,17 +57,15 @@ export class MsSqlDriver extends AbstractSqlDriver {
     appendOutputTable(entityName, data, sql) {
         const meta = this.metadata.get(entityName);
         const returningProps = meta.props
-            .filter(prop => prop.persist !== false && prop.defaultRaw || prop.autoincrement || prop.generated)
+            .filter(prop => (prop.persist !== false && prop.defaultRaw) || prop.autoincrement || prop.generated)
             .filter(prop => !(prop.name in data[0]) || isRaw(data[0][prop.name]));
         const returningFields = Utils.flatten(returningProps.map(prop => prop.fieldNames));
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (returningFields.length === 0) {
             return sql;
         }
         const tableName = this.getTableName(meta, {}, true);
-        const selections = returningFields
-            .map((field) => `[t].${this.platform.quoteIdentifier(field)}`)
-            .join(',');
+        const selections = returningFields.map((field) => `[t].${this.platform.quoteIdentifier(field)}`).join(',');
         const position = sql.indexOf(' values ');
         const sqlBeforeValues = sql.substring(0, position);
         const sqlAfterValues = sql.substring(position + 1);
@@ -71,4 +75,8 @@ export class MsSqlDriver extends AbstractSqlDriver {
         outputSql += `drop table #out`;
         return outputSql;
     }
+    /** @inheritDoc */
+    getORMClass() {
+        return MsSqlMikroORM;
+    }
 }

package/MsSqlExceptionConverter.d.ts

@@ -1,8 +1,8 @@
 import { ExceptionConverter, type Dictionary, type DriverException } from '@mikro-orm/core';
 export declare class MsSqlExceptionConverter extends ExceptionConverter {
     /**
-     * @link https://docs.microsoft.com/en-us/sql/relational-databases/errors-events/mssqlserver-511-database-engine-error?view=sql-server-ver15
-     * @link https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractPostgreSQLDriver.php
+     * @see https://docs.microsoft.com/en-us/sql/relational-databases/errors-events/mssqlserver-511-database-engine-error?view=sql-server-ver15
+     * @see https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractPostgreSQLDriver.php
      */
     convertException(exception: Error & Dictionary): DriverException;
 }

package/MsSqlExceptionConverter.js

@@ -1,13 +1,16 @@
 import { ExceptionConverter, InvalidFieldNameException, NonUniqueFieldNameException, NotNullConstraintViolationException, SyntaxErrorException, TableExistsException, TableNotFoundException, UniqueConstraintViolationException, } from '@mikro-orm/core';
 export class MsSqlExceptionConverter extends ExceptionConverter {
     /**
-     * @link https://docs.microsoft.com/en-us/sql/relational-databases/errors-events/mssqlserver-511-database-engine-error?view=sql-server-ver15
-     * @link https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractPostgreSQLDriver.php
+     * @see https://docs.microsoft.com/en-us/sql/relational-databases/errors-events/mssqlserver-511-database-engine-error?view=sql-server-ver15
+     * @see https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractPostgreSQLDriver.php
      */
     convertException(exception) {
         let errno = exception.number;
-        /* v8 ignore next 5 */
-        if ('errors' in exception && Array.isArray(exception.errors) && typeof exception.errors[0] === 'object' && 'message' in exception.errors[0]) {
+        /* v8 ignore next */
+        if ('errors' in exception &&
+            Array.isArray(exception.errors) &&
+            typeof exception.errors[0] === 'object' &&
+            'message' in exception.errors[0]) {
             exception.message += '\n' + exception.errors.map(e => e.message).join('\n');
             errno ??= exception.errors[0].number;
             exception.lineNumber ??= exception.errors[0].lineNumber;

package/MsSqlMikroORM.d.ts

@@ -1,19 +1,18 @@
-import { MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from '@mikro-orm/core';
+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 { MsSqlDriver } from './MsSqlDriver.js';
-import type { SqlEntityManager } from '@mikro-orm/knex';
+export type MsSqlOptions<EM extends SqlEntityManager<MsSqlDriver> = SqlEntityManager<MsSqlDriver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = Options<MsSqlDriver, EM, Entities>;
+export declare function defineMsSqlConfig<EM extends SqlEntityManager<MsSqlDriver> = SqlEntityManager<MsSqlDriver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Options<MsSqlDriver, EM, Entities>): Options<MsSqlDriver, EM, Entities>;
 /**
  * @inheritDoc
  */
-export declare class MsSqlMikroORM<EM extends EntityManager = SqlEntityManager> extends MikroORM<MsSqlDriver, EM> {
-    private static DRIVER;
+export declare class MsSqlMikroORM<EM extends SqlEntityManager<MsSqlDriver> = SqlEntityManager<MsSqlDriver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends MikroORM<MsSqlDriver, EM, Entities> {
     /**
      * @inheritDoc
      */
-    static init<D extends IDatabaseDriver = MsSqlDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options?: Options<D, EM>): Promise<MikroORM<D, EM>>;
+    static init<D extends IDatabaseDriver = MsSqlDriver, EM extends EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): Promise<MikroORM<D, EM, Entities>>;
     /**
      * @inheritDoc
      */
-    static initSync<D extends IDatabaseDriver = MsSqlDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options: Options<D, EM>): MikroORM<D, EM>;
+    constructor(options: Options<MsSqlDriver, EM, Entities>);
 }
-export type MsSqlOptions = Options<MsSqlDriver>;
-export declare function defineMsSqlConfig(options: MsSqlOptions): Options<MsSqlDriver, SqlEntityManager<MsSqlDriver> & EntityManager<IDatabaseDriver<import("@mikro-orm/core").Connection>>>;

package/MsSqlMikroORM.js

@@ -1,24 +1,22 @@
 import { defineConfig, MikroORM, } from '@mikro-orm/core';
 import { MsSqlDriver } from './MsSqlDriver.js';
+export function defineMsSqlConfig(options) {
+    return defineConfig({ driver: MsSqlDriver, ...options });
+}
 /**
  * @inheritDoc
  */
 export class MsSqlMikroORM extends MikroORM {
-    static DRIVER = MsSqlDriver;
     /**
      * @inheritDoc
      */
     static async init(options) {
-        return super.init(options);
+        return super.init(defineMsSqlConfig(options));
     }
     /**
      * @inheritDoc
      */
-    static initSync(options) {
-        return super.initSync(options);
+    constructor(options) {
+        super(defineMsSqlConfig(options));
     }
 }
-/* v8 ignore next 3 */
-export function defineMsSqlConfig(options) {
-    return defineConfig({ driver: MsSqlDriver, ...options });
-}

package/MsSqlPlatform.d.ts

@@ -1,12 +1,13 @@
-import { AbstractSqlPlatform, type EntityMetadata, type IDatabaseDriver, type EntityManager, type MikroORM, Type, type Primary, type IPrimaryKey, QueryOrder, MsSqlNativeQueryBuilder } from '@mikro-orm/knex';
+import { AbstractSqlPlatform, type EntityManager, type EntityMetadata, type IDatabaseDriver, type IPrimaryKey, type MikroORM, MsSqlNativeQueryBuilder, type Primary, QueryOrder, RawQueryFragment, Type } from '@mikro-orm/sql';
 import { MsSqlSchemaHelper } from './MsSqlSchemaHelper.js';
 import { MsSqlExceptionConverter } from './MsSqlExceptionConverter.js';
 import { MsSqlSchemaGenerator } from './MsSqlSchemaGenerator.js';
+import type { MsSqlDriver } from './MsSqlDriver.js';
 export declare class MsSqlPlatform extends AbstractSqlPlatform {
     protected readonly schemaHelper: MsSqlSchemaHelper;
     protected readonly exceptionConverter: MsSqlExceptionConverter;
     /** @inheritDoc */
-    lookupExtensions(orm: MikroORM): void;
+    lookupExtensions(orm: MikroORM<MsSqlDriver>): void;
     /** @inheritDoc */
     init(orm: MikroORM): void;
     getRollbackToSavepointSQL(savepointName: string): string;
@@ -50,7 +51,7 @@ export declare class MsSqlPlatform extends AbstractSqlPlatform {
         length?: number;
     }): string;
     validateMetadata(meta: EntityMetadata): void;
-    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string;
+    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string | RawQueryFragment;
     normalizePrimaryKey<T extends number | string = number | string>(data: Primary<T> | IPrimaryKey | string): T;
     usesEnumCheckConstraints(): boolean;
     supportsMultipleCascadePaths(): boolean;
@@ -61,6 +62,8 @@ export declare class MsSqlPlatform extends AbstractSqlPlatform {
     escape(value: any): string;
     getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): MsSqlSchemaGenerator;
     allowsComparingTuples(): boolean;
-    getOrderByExpression(column: string, direction: QueryOrder): string[];
+    /** @internal MSSQL collation names are not quoted. */
+    quoteCollation(collation: string): string;
+    getOrderByExpression(column: string, direction: QueryOrder, collation?: string): string[];
     getDefaultClientUrl(): string;
 }

package/MsSqlPlatform.js

@@ -1,4 +1,4 @@
-import { AbstractSqlPlatform, raw, Type, Utils, ALIAS_REPLACEMENT, DoubleType, FloatType, QueryOrder, RawQueryFragment, MsSqlNativeQueryBuilder, } from '@mikro-orm/knex';
+import { AbstractSqlPlatform, ALIAS_REPLACEMENT, DoubleType, FloatType, MsSqlNativeQueryBuilder, QueryOrder, raw, RawQueryFragment, Type, } from '@mikro-orm/sql';
 // @ts-expect-error no types available
 import SqlString from 'tsqlstring';
 import { MsSqlSchemaHelper } from './MsSqlSchemaHelper.js';
@@ -33,7 +33,7 @@ export class MsSqlPlatform extends AbstractSqlPlatform {
         return true;
     }
     convertDateToJSValue(value) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (typeof value === 'string') {
             return value;
         }
@@ -83,7 +83,7 @@ export class MsSqlPlatform extends AbstractSqlPlatform {
         return super.getVarcharTypeDeclarationSQL(column);
     }
     getEnumTypeDeclarationSQL(column) {
-        if (column.items?.every(item => Utils.isString(item))) {
+        if (column.items?.every(item => typeof item === 'string')) {
             return Type.getType(UnicodeStringType).getColumnType({ length: 100, ...column }, this);
         }
         /* v8 ignore next */
@@ -101,7 +101,7 @@ export class MsSqlPlatform extends AbstractSqlPlatform {
     }
     getDefaultMappedType(type) {
         if (type.startsWith('float')) {
-            const len = type.match(/float\((\d+)\)/)?.[1] ?? 24;
+            const len = /float\((\d+)\)/.exec(type)?.[1] ?? 24;
             return +len > 24 ? Type.getType(DoubleType) : Type.getType(FloatType);
         }
         const normalizedType = this.extractSimpleType(type);
@@ -130,9 +130,9 @@ export class MsSqlPlatform extends AbstractSqlPlatform {
     }
     validateMetadata(meta) {
         for (const prop of meta.props) {
-            if ((prop.runtimeType === 'string' || ['string', 'nvarchar'].includes(prop.type))
-                && !['uuid'].includes(prop.type)
-                && !prop.columnTypes[0].startsWith('varchar')) {
+            if ((prop.runtimeType === 'string' || ['string', 'nvarchar'].includes(prop.type)) &&
+                !['uuid'].includes(prop.type) &&
+                !prop.columnTypes[0].startsWith('varchar')) {
                 prop.customType ??= new UnicodeStringType();
                 prop.customType.prop = prop;
                 prop.customType.platform = this;
@@ -148,15 +148,15 @@ export class MsSqlPlatform extends AbstractSqlPlatform {
             boolean: 'bit',
         };
         const cast = (key) => raw(type in types ? `cast(${key} as ${types[type]})` : key);
-        const quoteKey = (key) => key.match(/^[a-z]\w*$/i) ? key : `"${key}"`;
-        /* v8 ignore next 3 */
+        const quoteKey = (key) => (/^[a-z]\w*$/i.exec(key) ? key : `"${key}"`);
+        /* v8 ignore next */
         if (path.length === 0) {
             return cast(`json_value(${root}, '$.${b.map(quoteKey).join('.')}')`);
         }
         return cast(`json_value(${root}, '$.${b.map(quoteKey).join('.')}')`);
     }
     normalizePrimaryKey(data) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (data instanceof UnicodeString) {
             return data.value;
         }
@@ -189,25 +189,31 @@ export class MsSqlPlatform extends AbstractSqlPlatform {
         }
         return SqlString.escape(value);
     }
-    /* v8 ignore next 3: kept for type inference only */
+    /* v8 ignore next: kept for type inference only */
     getSchemaGenerator(driver, em) {
         return new MsSqlSchemaGenerator(em ?? driver);
     }
     allowsComparingTuples() {
         return false;
     }
-    getOrderByExpression(column, direction) {
+    /** @internal MSSQL collation names are not quoted. */
+    quoteCollation(collation) {
+        this.validateCollationName(collation);
+        return collation;
+    }
+    getOrderByExpression(column, direction, collation) {
+        const col = collation ? `${column} collate ${this.quoteCollation(collation)}` : column;
         switch (direction.toUpperCase()) {
             case QueryOrder.ASC_NULLS_FIRST:
-                return [`case when ${column} is null then 0 else 1 end, ${column} asc`];
+                return [`case when ${column} is null then 0 else 1 end, ${col} asc`];
             case QueryOrder.ASC_NULLS_LAST:
-                return [`case when ${column} is null then 1 else 0 end, ${column} asc`];
+                return [`case when ${column} is null then 1 else 0 end, ${col} asc`];
             case QueryOrder.DESC_NULLS_FIRST:
-                return [`case when ${column} is null then 0 else 1 end, ${column} desc`];
+                return [`case when ${column} is null then 0 else 1 end, ${col} desc`];
             case QueryOrder.DESC_NULLS_LAST:
-                return [`case when ${column} is null then 1 else 0 end, ${column} desc`];
+                return [`case when ${column} is null then 1 else 0 end, ${col} desc`];
             default:
-                return [`${column} ${direction.toLowerCase()}`];
+                return [`${col} ${direction.toLowerCase()}`];
         }
     }
     getDefaultClientUrl() {

package/MsSqlQueryBuilder.d.ts

@@ -1,6 +1,6 @@
 import { type AnyEntity, type RequiredEntityData } from '@mikro-orm/core';
-import { type InsertQueryBuilder, QueryBuilder } from '@mikro-orm/knex';
+import { type InsertQueryBuilder, QueryBuilder } from '@mikro-orm/sql';
 export declare class MsSqlQueryBuilder<Entity extends object = AnyEntity, RootAlias extends string = never, Hint extends string = never, Context extends object = never> extends QueryBuilder<Entity, RootAlias, Hint, Context> {
-    insert(data: RequiredEntityData<Entity> | RequiredEntityData<Entity>[]): InsertQueryBuilder<Entity>;
+    insert(data: RequiredEntityData<Entity> | RequiredEntityData<Entity>[]): InsertQueryBuilder<Entity, RootAlias, Context>;
     private checkIdentityInsert;
 }

package/MsSqlQueryBuilder.js

@@ -1,10 +1,10 @@
 import { QueryFlag, Utils } from '@mikro-orm/core';
-import { QueryBuilder } from '@mikro-orm/knex';
+import { QueryBuilder } from '@mikro-orm/sql';
 export class MsSqlQueryBuilder extends QueryBuilder {
     insert(data) {
         this.checkIdentityInsert(data);
         if (!this.flags.has(QueryFlag.IDENTITY_INSERT) && this.metadata.has(this.mainAlias.entityName)) {
-            const meta = this.metadata.find(this.mainAlias.entityName);
+            const meta = this.mainAlias.meta;
             if (meta.hasTriggers) {
                 this.setFlag(QueryFlag.OUTPUT_TABLE);
             }
@@ -12,11 +12,8 @@ export class MsSqlQueryBuilder extends QueryBuilder {
         return super.insert(data);
     }
     checkIdentityInsert(data) {
-        const meta = this.metadata.find(this.mainAlias.entityName);
-        if (!meta) {
-            return;
-        }
-        const dataKeys = Utils.unique(Utils.asArray(data).flatMap(Object.keys));
+        const meta = this.mainAlias.meta;
+        const dataKeys = Utils.unique(Utils.asArray(data).flatMap(d => Utils.keys(d)));
         const hasAutoincrement = dataKeys.some(x => meta.properties[x]?.autoincrement);
         if (hasAutoincrement) {
             this.setFlag(QueryFlag.IDENTITY_INSERT);

package/MsSqlSchemaGenerator.d.ts

@@ -1,6 +1,7 @@
-import { type ClearDatabaseOptions, type DropSchemaOptions, type MikroORM, SchemaGenerator } from '@mikro-orm/knex';
+import { type ClearDatabaseOptions, type DropSchemaOptions, type MikroORM, SchemaGenerator } from '@mikro-orm/sql';
+import type { MsSqlDriver } from './MsSqlDriver.js';
 export declare class MsSqlSchemaGenerator extends SchemaGenerator {
-    static register(orm: MikroORM): void;
-    clearDatabase(options?: ClearDatabaseOptions): Promise<void>;
+    static register(orm: MikroORM<MsSqlDriver>): void;
+    clear(options?: ClearDatabaseOptions): Promise<void>;
     getDropSchemaSQL(options?: Omit<DropSchemaOptions, 'dropDb'>): Promise<string>;
 }

package/MsSqlSchemaGenerator.js

@@ -1,17 +1,17 @@
-import { SchemaGenerator } from '@mikro-orm/knex';
+import { SchemaGenerator } from '@mikro-orm/sql';
 export class MsSqlSchemaGenerator extends SchemaGenerator {
     static register(orm) {
         orm.config.registerExtension('@mikro-orm/schema-generator', () => new MsSqlSchemaGenerator(orm.em));
     }
-    async clearDatabase(options) {
+    async clear(options) {
         // truncate by default, so no value is considered as true
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (options?.truncate === false) {
-            return super.clearDatabase(options);
+            return super.clear(options);
         }
         // https://stackoverflow.com/questions/253849/cannot-truncate-table-because-it-is-being-referenced-by-a-foreign-key-constraint
         for (const meta of this.getOrderedMetadata(options?.schema).reverse()) {
-            const res = await this.driver.nativeDelete(meta.className, {}, options);
+            const res = await this.driver.nativeDelete(meta.class, {}, options);
             if (meta.getPrimaryProps().some(pk => pk.autoincrement)) {
                 const tableName = this.driver.getTableName(meta, { schema: options?.schema }, false);
                 await this.execute(`dbcc checkident ('${tableName}', reseed, ${res.affectedRows > 0 ? 0 : 1})`, {

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 Type } from '@mikro-orm/knex';
+import { type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSchema, type DatabaseTable, type Dictionary, type ForeignKey, type IndexDef, SchemaHelper, type Table, type TableDifference, type Type } from '@mikro-orm/sql';
 export declare class MsSqlSchemaHelper extends SchemaHelper {
     static readonly DEFAULT_VALUES: {
         true: string[];
@@ -10,6 +10,8 @@ export declare class MsSqlSchemaHelper extends SchemaHelper {
     enableForeignKeysSQL(): string;
     getDatabaseExistsSQL(name: string): string;
     getListTablesSQL(): string;
+    getListViewsSQL(): string;
+    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection): Promise<void>;
     getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
     normalizeDefaultValue(defaultValue: string, length: number, defaultValues?: Dictionary<string[]>, stripQuotes?: boolean): string | number;
     getAllColumns(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<Column[]>>;
@@ -32,9 +34,18 @@ export declare class MsSqlSchemaHelper extends SchemaHelper {
     createTableColumn(column: Column, table: DatabaseTable, changedProperties?: Set<string>): string | undefined;
     alterTableColumn(column: Column, table: DatabaseTable, changedProperties: Set<string>): string[];
     getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
+    /**
+     * Build the column list for a MSSQL index.
+     */
+    protected getIndexColumns(index: IndexDef): string;
+    /**
+     * Get MSSQL-specific index WITH options like fill factor.
+     */
+    private getMsSqlIndexSuffix;
     createIndex(index: IndexDef, table: DatabaseTable, createPrimary?: boolean): string;
     dropForeignKey(tableName: string, constraintName: string): string;
     dropTableIfExists(name: string, schema?: string): string;
+    dropViewIfExists(name: string, schema?: string): string;
     getAddColumnsSQL(table: DatabaseTable, columns: Column[]): string[];
     appendComments(table: DatabaseTable): string[];
     inferLengthFromColumnType(type: string): number | undefined;