@mikro-orm/mssql 7.0.0-dev.33 → 7.0.0-dev.331

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 EntityName, type LoggingOptions, type NativeInsertUpdateManyOptions, type QueryResult, type Transaction, type Constructor } 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)[]> = Partial<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: Partial<Options<MsSqlDriver, EM, Entities>>): Partial<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: Partial<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: Partial<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);
+        if (!this.hasFlag(QueryFlag.IDENTITY_INSERT) && this.metadata.has(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;

package/MsSqlSchemaHelper.js

@@ -1,9 +1,9 @@
-import { EnumType, SchemaHelper, StringType, TextType, Utils, } from '@mikro-orm/knex';
+import { EnumType, SchemaHelper, StringType, TextType, Utils, } from '@mikro-orm/sql';
 import { UnicodeStringType } from './UnicodeStringType.js';
 export class MsSqlSchemaHelper extends SchemaHelper {
     static DEFAULT_VALUES = {
-        'true': ['1'],
-        'false': ['0'],
+        true: ['1'],
+        false: ['0'],
         'getdate()': ['current_timestamp'],
     };
     getManagementDbName() {
@@ -25,21 +25,39 @@ export class MsSqlSchemaHelper extends SchemaHelper {
       left join sys.extended_properties ep on ep.major_id = t.id and ep.name = 'MS_Description' and ep.minor_id = 0
       order by schema_name(t2.schema_id), t.name`;
     }
+    getListViewsSQL() {
+        return `select v.name as view_name, schema_name(v.schema_id) as schema_name, m.definition as view_definition
+      from sys.views v
+      inner join sys.sql_modules m on v.object_id = m.object_id
+      order by schema_name(v.schema_id), v.name`;
+    }
+    async loadViews(schema, connection) {
+        const views = await connection.execute(this.getListViewsSQL());
+        for (const view of views) {
+            // Extract SELECT statement from CREATE VIEW ... AS SELECT ...
+            const match = /\bAS\s+(.+)$/is.exec(view.view_definition);
+            const definition = match?.[1]?.trim();
+            if (definition) {
+                const schemaName = view.schema_name === this.platform.getDefaultSchemaName() ? undefined : view.schema_name;
+                schema.addView(view.view_name, schemaName, definition);
+            }
+        }
+    }
     async getNamespaces(connection) {
         const sql = `select name as schema_name from sys.schemas order by name`;
         const res = await connection.execute(sql);
         return res.map(row => row.schema_name);
     }
     normalizeDefaultValue(defaultValue, length, defaultValues = {}, stripQuotes = false) {
-        let match = defaultValue?.match(/^\((.*)\)$/);
+        let match = /^\((.*)\)$/.exec(defaultValue);
         if (match) {
             defaultValue = match[1];
         }
-        match = defaultValue?.match(/^\((.*)\)$/);
+        match = /^\((.*)\)$/.exec(defaultValue);
         if (match) {
             defaultValue = match[1];
         }
-        match = defaultValue?.match(/^'(.*)'$/);
+        match = /^'(.*)'$/.exec(defaultValue);
         if (stripQuotes && match) {
             defaultValue = match[1];
         }
@@ -66,10 +84,10 @@ export class MsSqlSchemaHelper extends SchemaHelper {
       left join sys.computed_columns cmp on cmp.name = ic.column_name and cmp.object_id = object_id(ic.table_schema + '.' + ic.table_name)
       left join sys.extended_properties t4 on t4.major_id = object_id(ic.table_schema + '.' + ic.table_name) and t4.name = 'MS_Description' and t4.minor_id = sc.column_id
       left join sys.default_constraints t5 on sc.default_object_id = t5.object_id
-      where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(ic.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}) and ic.table_schema = '${schema}')`).join(' OR ')})
+      where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(ic.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}) and ic.table_schema = '${schema}')`).join(' or ')})
       order by ordinal_position`;
         const allColumns = await connection.execute(sql);
-        const str = (val) => val != null ? '' + val : val;
+        const str = (val) => (val != null ? '' + val : val);
         const ret = {};
         for (const col of allColumns) {
             const mappedType = this.platform.getMappedType(col.data_type);
@@ -77,7 +95,9 @@ export class MsSqlSchemaHelper extends SchemaHelper {
             const increments = col.is_identity === 1 && connection.getPlatform().isNumericColumn(mappedType);
             const key = this.getTableKey(col);
             /* v8 ignore next */
-            const generated = col.generation_expression ? `${col.generation_expression}${col.is_persisted ? ' persisted' : ''}` : undefined;
+            const generated = col.generation_expression
+                ? `${col.generation_expression}${col.is_persisted ? ' persisted' : ''}`
+                : undefined;
             let type = col.data_type;
             if (['varchar', 'nvarchar', 'char', 'nchar', 'varbinary'].includes(col.data_type)) {
                 col.length = col.character_maximum_length;
@@ -97,7 +117,9 @@ export class MsSqlSchemaHelper extends SchemaHelper {
             ret[key] ??= [];
             ret[key].push({
                 name: col.column_name,
-                type: this.platform.isNumericColumn(mappedType) ? col.data_type.replace(/ unsigned$/, '').replace(/\(\d+\)$/, '') : type,
+                type: this.platform.isNumericColumn(mappedType)
+                    ? col.data_type.replace(/ unsigned$/, '').replace(/\(\d+\)$/, '')
+                    : type,
                 mappedType,
                 unsigned: col.data_type.endsWith(' unsigned'),
                 length: col.length,
@@ -120,26 +142,52 @@ export class MsSqlSchemaHelper extends SchemaHelper {
       ind.is_primary_key as is_primary_key,
       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
+      (case when filter_definition is not null then concat('where ', filter_definition) else null end) as expression,
+      ind.is_disabled as is_disabled,
+      ind.type as index_type,
+      ind.fill_factor as fill_factor,
+      ic.is_included_column as is_included_column,
+      ic.is_descending_key as is_descending_key
       from sys.indexes ind
       inner join sys.index_columns ic on ind.object_id = ic.object_id and ind.index_id = ic.index_id
       inner join sys.columns col on ic.object_id = col.object_id and ic.column_id = col.column_id
       inner join sys.tables t on ind.object_id = t.object_id
       where
       (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(t.name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}) and schema_name(t.schema_id) = '${schema}')`).join(' OR ')})
-      order by t.name, ind.name, ind.index_id`;
+      order by t.name, ind.name, ic.is_included_column, ic.key_ordinal`;
         const allIndexes = await connection.execute(sql);
         const ret = {};
         for (const index of allIndexes) {
             const key = this.getTableKey(index);
+            const isIncluded = index.is_included_column;
             const indexDef = {
-                columnNames: [index.column_name],
+                columnNames: isIncluded ? [] : [index.column_name],
                 keyName: index.index_name,
                 unique: index.is_unique,
                 primary: index.is_primary_key,
                 constraint: index.is_unique,
             };
-            if (!index.column_name || index.column_name.match(/[(): ,"'`]/) || index.expression?.match(/where /i)) {
+            // Capture INCLUDE columns
+            if (isIncluded) {
+                indexDef.include = [index.column_name];
+            }
+            // Capture sort order for key columns
+            if (!isIncluded && index.is_descending_key) {
+                indexDef.columns = [{ name: index.column_name, sort: 'DESC' }];
+            }
+            // Capture disabled flag
+            if (index.is_disabled) {
+                indexDef.disabled = true;
+            }
+            // Capture clustered flag (type 1 = clustered)
+            if (index.index_type === 1 && !index.is_primary_key) {
+                indexDef.clustered = true;
+            }
+            // Capture fill factor (0 means default, so only set if non-zero)
+            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
                 indexDef.expression = this.getCreateIndexSQL(index.table_name, indexDef, !!index.expression);
             }
@@ -193,7 +241,9 @@ export class MsSqlSchemaHelper extends SchemaHelper {
             /* v8 ignore next */
             const hasItems = (items?.length ?? 0) > 0;
             if (item.columnName && hasItems) {
-                items = items.map(val => val.trim().replace(`[${item.columnName}]=`, '').match(/^\(?'(.*)'/)?.[1]).filter(Boolean);
+                items = items
+                    .map(val => /^\(?'(.*)'/.exec(val.trim().replace(`[${item.columnName}]=`, ''))?.[1])
+                    .filter(Boolean);
                 if (items.length > 0) {
                     o[item.columnName] = items.reverse();
                 }
@@ -266,7 +316,7 @@ export class MsSqlSchemaHelper extends SchemaHelper {
             }
             // convert to string first if it's not already a string or has a smaller length
             const type = this.platform.extractSimpleType(col.fromColumn.type);
-            if (!['varchar', 'nvarchar', 'varbinary'].includes(type) || (col.fromColumn.length < col.column.length)) {
+            if (!['varchar', 'nvarchar', 'varbinary'].includes(type) || col.fromColumn.length < col.column.length) {
                 ret.push(`alter table ${quotedName} alter column [${col.oldColumnName}] nvarchar(max)`);
             }
         }
@@ -328,18 +378,21 @@ export class MsSqlSchemaHelper extends SchemaHelper {
             }
             const i = globalThis.idx;
             globalThis.idx++;
-            constraints.push(`declare @constraint${i} varchar(100) = (select default_constraints.name from sys.all_columns`
-                + ' join sys.tables on all_columns.object_id = tables.object_id'
-                + ' join sys.schemas on tables.schema_id = schemas.schema_id'
-                + ' join sys.default_constraints on all_columns.default_object_id = default_constraints.object_id'
-                + ` where schemas.name = '${schemaName}' and tables.name = '${tableName}' and all_columns.name = '${column.name}')`
-                + ` if @constraint${i} is not null exec('alter table ${tableNameRaw} drop constraint ' + @constraint${i})`);
+            constraints.push(`declare @constraint${i} varchar(100) = (select default_constraints.name from sys.all_columns` +
+                ' join sys.tables on all_columns.object_id = tables.object_id' +
+                ' join sys.schemas on tables.schema_id = schemas.schema_id' +
+                ' join sys.default_constraints on all_columns.default_object_id = default_constraints.object_id' +
+                ` where schemas.name = '${schemaName}' and tables.name = '${tableName}' and all_columns.name = '${column.name}')` +
+                ` if @constraint${i} is not null exec('alter table ${tableNameRaw} drop constraint ' + @constraint${i})`);
         }
         return constraints;
     }
     getRenameColumnSQL(tableName, oldColumnName, to, schemaName) {
         /* v8 ignore next */
-        const oldName = (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName + '.' + oldColumnName;
+        const oldName = (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') +
+            tableName +
+            '.' +
+            oldColumnName;
         const columnName = this.platform.quoteValue(to.name);
         return `exec sp_rename ${this.platform.quoteValue(oldName)}, ${columnName}, 'COLUMN'`;
     }
@@ -348,7 +401,10 @@ export class MsSqlSchemaHelper extends SchemaHelper {
         const primaryKey = !changedProperties && !this.hasNonDefaultPrimaryKeyName(table);
         const columnType = column.generated ? `as ${column.generated}` : column.type;
         const col = [this.quote(column.name)];
-        if (column.autoincrement && !column.generated && !compositePK && (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
+        if (column.autoincrement &&
+            !column.generated &&
+            !compositePK &&
+            (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
             col.push(column.mappedType.getColumnType({ autoincrement: true }, this.platform));
         }
         else {
@@ -357,10 +413,15 @@ export class MsSqlSchemaHelper extends SchemaHelper {
         Utils.runIfNotEmpty(() => col.push('identity(1,1)'), column.autoincrement);
         Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
         Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable && !column.generated);
-        if (column.autoincrement && !column.generated && !compositePK && (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
+        if (column.autoincrement &&
+            !column.generated &&
+            !compositePK &&
+            (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
             Utils.runIfNotEmpty(() => col.push('primary key'), primaryKey && column.primary);
         }
-        const useDefault = changedProperties ? false : column.default != null && column.default !== 'null' && !column.autoincrement;
+        const useDefault = changedProperties
+            ? false
+            : column.default != null && column.default !== 'null' && !column.autoincrement;
         const defaultName = this.platform.getConfig().getNamingStrategy().indexName(table.name, [column.name], 'default');
         Utils.runIfNotEmpty(() => col.push(`constraint ${this.quote(defaultName)} default ${column.default}`), useDefault);
         return col.join(' ');
@@ -382,17 +443,64 @@ export class MsSqlSchemaHelper extends SchemaHelper {
         return parts;
     }
     getCreateIndexSQL(tableName, index, partialExpression = false) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (index.expression && !partialExpression) {
             return index.expression;
         }
+        if (index.fillFactor != null && (index.fillFactor < 0 || index.fillFactor > 100)) {
+            throw new Error(`fillFactor must be between 0 and 100, got ${index.fillFactor} for index '${index.keyName}'`);
+        }
         const keyName = this.quote(index.keyName);
-        const defer = index.deferMode ? ` deferrable initially ${index.deferMode}` : '';
-        const sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${this.quote(tableName)} `;
+        // Only add clustered keyword when explicitly requested, otherwise omit (defaults to nonclustered)
+        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})${defer}`;
+            return sql + `(${index.expression})` + this.getMsSqlIndexSuffix(index);
+        }
+        // Build column list with advanced options
+        const columns = this.getIndexColumns(index);
+        sql += `(${columns})`;
+        // Add INCLUDE clause for covering indexes
+        if (index.include?.length) {
+            sql += ` include (${index.include.map(c => this.quote(c)).join(', ')})`;
         }
-        return super.getCreateIndexSQL(tableName, index);
+        sql += this.getMsSqlIndexSuffix(index);
+        // Disabled indexes need to be created first, then disabled
+        if (index.disabled) {
+            sql += `;\nalter index ${keyName} on ${this.quote(tableName)} disable`;
+        }
+        return sql;
+    }
+    /**
+     * 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(', ');
+    }
+    /**
+     * Get MSSQL-specific index WITH options like fill factor.
+     */
+    getMsSqlIndexSuffix(index) {
+        const withOptions = [];
+        if (index.fillFactor != null) {
+            withOptions.push(`fillfactor = ${index.fillFactor}`);
+        }
+        if (withOptions.length > 0) {
+            return ` with (${withOptions.join(', ')})`;
+        }
+        return '';
     }
     createIndex(index, table, createPrimary = false) {
         if (index.primary) {
@@ -401,13 +509,17 @@ export class MsSqlSchemaHelper extends SchemaHelper {
         if (index.expression) {
             return index.expression;
         }
-        const quotedTableName = table.getQuotedName();
-        if (index.unique) {
-            const nullable = index.columnNames.some(column => table.getColumn(column)?.nullable);
-            const where = nullable ? ' where ' + index.columnNames.map(c => `${this.quote(c)} is not null`).join(' and ') : '';
-            return `create unique index ${this.quote(index.keyName)} on ${quotedTableName} (${index.columnNames.map(c => this.quote(c)).join(', ')})${where}`;
+        const needsWhereClause = index.unique && index.columnNames.some(column => table.getColumn(column)?.nullable);
+        if (!needsWhereClause) {
+            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 ');
+        if (index.disabled) {
+            sql += `;\nalter index ${this.quote(index.keyName)} on ${table.getQuotedName()} disable`;
         }
-        return super.createIndex(index, table);
+        return sql;
     }
     dropForeignKey(tableName, constraintName) {
         return `alter table ${this.quote(tableName)} drop constraint ${this.quote(constraintName)}`;
@@ -418,10 +530,16 @@ export class MsSqlSchemaHelper extends SchemaHelper {
         }
         return `if object_id('${this.quote(schema, name)}', 'U') is not null drop table ${this.quote(schema, name)}`;
     }
+    dropViewIfExists(name, schema) {
+        const viewName = this.quote(this.getTableName(name, schema));
+        return `if object_id('${viewName}', 'V') is not null drop view ${viewName}`;
+    }
     getAddColumnsSQL(table, columns) {
-        const adds = columns.map(column => {
-            return `${this.createTableColumn(column, table)}`;
-        }).join(', ');
+        const adds = columns
+            .map(column => {
+            return this.createTableColumn(column, table);
+        })
+            .join(', ');
         return [`alter table ${table.getQuotedName()} add ${adds}`];
     }
     appendComments(table) {
@@ -448,7 +566,7 @@ else
         return sql;
     }
     inferLengthFromColumnType(type) {
-        const match = type.match(/^(\w+)\s*\(\s*(-?\d+|max)\s*\)/);
+        const match = /^(\w+)\s*\(\s*(-?\d+|max)\s*\)/.exec(type);
         if (!match) {
             return;
         }
@@ -458,7 +576,10 @@ else
         return +match[2];
     }
     wrap(val, type) {
-        const stringType = type instanceof StringType || type instanceof TextType || type instanceof EnumType || type instanceof UnicodeStringType;
+        const stringType = type instanceof StringType ||
+            type instanceof TextType ||
+            type instanceof EnumType ||
+            type instanceof UnicodeStringType;
         return typeof val === 'string' && val.length > 0 && stringType ? this.platform.quoteValue(val) : val;
     }
 }

package/README.md

@@ -2,14 +2,14 @@
   <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 and SQLite (including libSQL) 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, SQLite (including libSQL), MSSQL and Oracle databases. 
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
-[![NPM version](https://img.shields.io/npm/v/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
-[![NPM dev version](https://img.shields.io/npm/v/@mikro-orm/core/next.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![NPM version](https://img.shields.io/npm/v/@mikro-orm/core.svg)](https://npmx.dev/package/@mikro-orm/core)
+[![NPM dev version](https://img.shields.io/npm/v/@mikro-orm/core/next.svg)](https://npmx.dev/package/@mikro-orm/core)
 [![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
-[![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://npmx.dev/package/@mikro-orm/core)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
 [![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
 
@@ -181,6 +181,7 @@ yarn add @mikro-orm/core @mikro-orm/mysql         # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/postgresql    # for postgresql
 yarn add @mikro-orm/core @mikro-orm/mssql         # for mssql
+yarn add @mikro-orm/core @mikro-orm/oracledb      # for oracle
 yarn add @mikro-orm/core @mikro-orm/sqlite        # for sqlite
 yarn add @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
@@ -381,6 +382,8 @@ See also the list of contributors who [participated](https://github.com/mikro-or
 
 Please ⭐️ this repository if this project helped you!
 
+> If you'd like to support my open-source work, consider sponsoring me directly at [github.com/sponsors/b4nan](https://github.com/sponsors/b4nan).
+
 ## 📝 License
 
 Copyright © 2018 [Martin Adámek](https://github.com/b4nan).

package/UnicodeStringType.js

@@ -23,7 +23,7 @@ export class UnicodeStringType extends Type {
         return `nvarchar(${length})`;
     }
     convertToJSValue(value) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (value instanceof UnicodeString) {
             return value.value;
         }

package/index.d.ts

@@ -1,8 +1,7 @@
-export * from '@mikro-orm/knex';
+export * from '@mikro-orm/sql';
 export * from './MsSqlConnection.js';
 export * from './MsSqlDriver.js';
 export * from './MsSqlPlatform.js';
 export * from './MsSqlSchemaHelper.js';
-export * from './MsSqlExceptionConverter.js';
 export * from './UnicodeStringType.js';
-export { MsSqlMikroORM as MikroORM, MsSqlOptions as Options, defineMsSqlConfig as defineConfig, } from './MsSqlMikroORM.js';
+export { MsSqlMikroORM as MikroORM, type MsSqlOptions as Options, defineMsSqlConfig as defineConfig, } from './MsSqlMikroORM.js';

package/index.js

@@ -1,8 +1,7 @@
-export * from '@mikro-orm/knex';
+export * from '@mikro-orm/sql';
 export * from './MsSqlConnection.js';
 export * from './MsSqlDriver.js';
 export * from './MsSqlPlatform.js';
 export * from './MsSqlSchemaHelper.js';
-export * from './MsSqlExceptionConverter.js';
 export * from './UnicodeStringType.js';
 export { MsSqlMikroORM as MikroORM, defineMsSqlConfig as defineConfig, } from './MsSqlMikroORM.js';

package/package.json

@@ -1,66 +1,65 @@
 {
   "name": "@mikro-orm/mssql",
-  "type": "module",
-  "version": "7.0.0-dev.33",
+  "version": "7.0.0-dev.331",
   "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.",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": "./index.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
-  },
   "keywords": [
-    "orm",
+    "data-mapper",
+    "ddd",
+    "entity",
+    "identity-map",
+    "javascript",
+    "js",
+    "mariadb",
+    "mikro-orm",
     "mongo",
     "mongodb",
     "mysql",
-    "mariadb",
+    "orm",
     "postgresql",
     "sqlite",
     "sqlite3",
     "ts",
     "typescript",
-    "js",
-    "javascript",
-    "entity",
-    "ddd",
-    "mikro-orm",
-    "unit-of-work",
-    "data-mapper",
-    "identity-map"
+    "unit-of-work"
   ],
-  "author": "Martin Adámek",
-  "license": "MIT",
+  "homepage": "https://mikro-orm.io",
   "bugs": {
     "url": "https://github.com/mikro-orm/mikro-orm/issues"
   },
-  "homepage": "https://mikro-orm.io",
-  "engines": {
-    "node": ">= 22.11.0"
+  "license": "MIT",
+  "author": "Martin Adámek",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./index.js"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
-    "build": "yarn clean && yarn compile && yarn copy",
+    "build": "yarn compile && yarn copy",
     "clean": "yarn run -T rimraf ./dist",
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
-    "@mikro-orm/knex": "7.0.0-dev.33",
+    "@mikro-orm/sql": "7.0.0-dev.331",
+    "kysely": "0.28.11",
     "tarn": "3.0.2",
-    "tedious": "19.0.0",
+    "tedious": "19.2.1",
     "tsqlstring": "1.0.1"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.5.7",
-    "kysely": "0.28.7"
+    "@mikro-orm/core": "^6.6.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.33",
-    "kysely": "*"
+    "@mikro-orm/core": "7.0.0-dev.331"
+  },
+  "engines": {
+    "node": ">= 22.17.0"
   }
 }