@mikro-orm/mssql 6.1.13-dev.28

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Martin Adámek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MsSqlConnection.d.ts

@@ -0,0 +1,14 @@
+import { AbstractSqlConnection, type IsolationLevel, type Knex, type TransactionEventBroadcaster } from '@mikro-orm/knex';
+export declare class MsSqlConnection extends AbstractSqlConnection {
+    createKnex(): void;
+    getDefaultClientUrl(): string;
+    getConnectionOptions(): Knex.MsSqlConnectionConfig;
+    begin(options?: {
+        isolationLevel?: IsolationLevel;
+        ctx?: Knex.Transaction;
+        eventBroadcaster?: TransactionEventBroadcaster;
+    }): Promise<Knex.Transaction>;
+    commit(ctx: Knex.Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
+    rollback(ctx: Knex.Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
+    protected transformRawResult<T>(res: any, method: 'all' | 'get' | 'run'): T;
+}

package/MsSqlConnection.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsSqlConnection = void 0;
+const knex_1 = require("@mikro-orm/knex");
+class MsSqlConnection extends knex_1.AbstractSqlConnection {
+    createKnex() {
+        this.client = this.createKnexClient(knex_1.MsSqlKnexDialect);
+        this.connected = true;
+    }
+    getDefaultClientUrl() {
+        return 'mssql://sa@localhost:1433';
+    }
+    getConnectionOptions() {
+        const config = super.getConnectionOptions();
+        const overrides = {
+            options: {
+                enableArithAbort: true,
+                fallbackToDefaultDb: true,
+            },
+        };
+        knex_1.Utils.mergeConfig(config, overrides);
+        return config;
+    }
+    async begin(options = {}) {
+        if (!options.ctx) {
+            if (options.isolationLevel) {
+                this.logQuery(`set transaction isolation level ${options.isolationLevel}`);
+            }
+            this.logQuery('begin');
+        }
+        return super.begin(options);
+    }
+    async commit(ctx, eventBroadcaster) {
+        this.logQuery('commit');
+        return super.commit(ctx, eventBroadcaster);
+    }
+    async rollback(ctx, eventBroadcaster) {
+        if (eventBroadcaster?.isTopLevel()) {
+            this.logQuery('rollback');
+        }
+        return super.rollback(ctx, eventBroadcaster);
+    }
+    transformRawResult(res, method) {
+        if (method === 'get') {
+            return res[0];
+        }
+        if (method === 'all' || !res) {
+            return res;
+        }
+        const rowCount = res.length;
+        const hasEmptyCount = (rowCount === 1) && ('' in res[0]);
+        const emptyRow = hasEmptyCount && res[0][''];
+        return {
+            affectedRows: hasEmptyCount ? emptyRow : res.length,
+            insertId: res[0] ? res[0].id : 0,
+            row: res[0],
+            rows: res,
+        };
+    }
+}
+exports.MsSqlConnection = MsSqlConnection;

package/MsSqlDriver.d.ts

@@ -0,0 +1,9 @@
+import { type AnyEntity, type Configuration, type ConnectionType, type EntityDictionary, type LoggingOptions, type NativeInsertUpdateManyOptions, type QueryResult, type Transaction } from '@mikro-orm/core';
+import { AbstractSqlDriver, type Knex, type SqlEntityManager } from '@mikro-orm/knex';
+import { MsSqlConnection } from './MsSqlConnection';
+import { MsSqlQueryBuilder } from './MsSqlQueryBuilder';
+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<Knex.Transaction>, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): MsSqlQueryBuilder<T>;
+}

package/MsSqlDriver.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsSqlDriver = void 0;
+const core_1 = require("@mikro-orm/core");
+const knex_1 = require("@mikro-orm/knex");
+const MsSqlConnection_1 = require("./MsSqlConnection");
+const MsSqlPlatform_1 = require("./MsSqlPlatform");
+const MsSqlQueryBuilder_1 = require("./MsSqlQueryBuilder");
+class MsSqlDriver extends knex_1.AbstractSqlDriver {
+    constructor(config) {
+        super(config, new MsSqlPlatform_1.MsSqlPlatform(), MsSqlConnection_1.MsSqlConnection, ['knex', 'tedious']);
+    }
+    async nativeInsertMany(entityName, data, options = {}) {
+        const meta = this.metadata.get(entityName);
+        const keys = new Set();
+        data.forEach(row => Object.keys(row).forEach(k => keys.add(k)));
+        const props = [...keys].map(name => meta.properties[name] ?? { name, fieldNames: [name] });
+        const fields = core_1.Utils.flatten(props.map(prop => prop.fieldNames));
+        const tableName = this.getTableName(meta, options);
+        const hasFields = fields.length > 0;
+        // Is this en empty insert... this is rather hard in mssql (especially with an insert many)
+        if (!hasFields) {
+            const returningProps = meta.props.filter(prop => prop.primary || prop.defaultRaw);
+            const returningFields = core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames));
+            const using2 = `select * from (values ${data.map((x, i) => `(${i})`).join(',')}) v (id) where 1 = 1`;
+            /* istanbul ignore next */
+            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);
+            let pk;
+            /* istanbul ignore next */
+            if (pks.length > 1) { // owner has composite pk
+                pk = data.map(d => core_1.Utils.getPrimaryKeyCond(d, pks));
+            }
+            else {
+                res.row ??= {};
+                res.rows ??= [];
+                pk = data.map((d, i) => d[pks[0]] ?? res.rows[i]?.[pks[0]]).map(d => [d]);
+                res.insertId = res.insertId || res.row[pks[0]];
+            }
+            return res;
+        }
+        if (props.some(prop => prop.autoincrement)) {
+            return super.nativeInsertMany(entityName, data, options, sql => {
+                return `set identity_insert ${tableName} on; ${sql}; set identity_insert ${tableName} off`;
+            });
+        }
+        return super.nativeInsertMany(entityName, data, options);
+    }
+    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 qb = new MsSqlQueryBuilder_1.MsSqlQueryBuilder(entityName, this.metadata, this, ctx, alias, connectionType, em, loggerContext);
+        if (!convertCustomTypes) {
+            qb.unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES);
+        }
+        return qb;
+    }
+}
+exports.MsSqlDriver = MsSqlDriver;

package/MsSqlExceptionConverter.d.ts

@@ -0,0 +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
+     */
+    convertException(exception: Error & Dictionary): DriverException;
+}

package/MsSqlExceptionConverter.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsSqlExceptionConverter = void 0;
+const core_1 = require("@mikro-orm/core");
+class MsSqlExceptionConverter extends core_1.ExceptionConverter {
+    /* istanbul ignore next */
+    /**
+     * @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
+     */
+    convertException(exception) {
+        let errno = exception.number;
+        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;
+        }
+        switch (errno) {
+            case 515:
+                return new core_1.NotNullConstraintViolationException(exception);
+            case 102:
+                return new core_1.SyntaxErrorException(exception);
+            case 207:
+                return new core_1.InvalidFieldNameException(exception);
+            case 208:
+                return new core_1.TableNotFoundException(exception);
+            case 209:
+                return new core_1.NonUniqueFieldNameException(exception);
+            case 2601:
+                return new core_1.UniqueConstraintViolationException(exception);
+            case 2714:
+                return new core_1.TableExistsException(exception);
+        }
+        return super.convertException(exception);
+    }
+}
+exports.MsSqlExceptionConverter = MsSqlExceptionConverter;

package/MsSqlMikroORM.d.ts

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineMsSqlConfig = exports.MsSqlMikroORM = void 0;
+const core_1 = require("@mikro-orm/core");
+const MsSqlDriver_1 = require("./MsSqlDriver");
+/**
+ * @inheritDoc
+ */
+class MsSqlMikroORM extends core_1.MikroORM {
+    static DRIVER = MsSqlDriver_1.MsSqlDriver;
+    /**
+     * @inheritDoc
+     */
+    static async init(options) {
+        return super.init(options);
+    }
+    /**
+     * @inheritDoc
+     */
+    static initSync(options) {
+        return super.initSync(options);
+    }
+}
+exports.MsSqlMikroORM = MsSqlMikroORM;
+/* istanbul ignore next */
+function defineMsSqlConfig(options) {
+    return (0, core_1.defineConfig)({ driver: MsSqlDriver_1.MsSqlDriver, ...options });
+}
+exports.defineMsSqlConfig = defineMsSqlConfig;

package/MsSqlPlatform.d.ts

@@ -0,0 +1,47 @@
+import { AbstractSqlPlatform, type EntityMetadata, type IDatabaseDriver, type EntityManager, type MikroORM, Type, type Primary, type IPrimaryKey } from '@mikro-orm/knex';
+import { MsSqlSchemaHelper } from './MsSqlSchemaHelper';
+import { MsSqlExceptionConverter } from './MsSqlExceptionConverter';
+import { MsSqlSchemaGenerator } from './MsSqlSchemaGenerator';
+export declare class MsSqlPlatform extends AbstractSqlPlatform {
+    protected readonly schemaHelper: MsSqlSchemaHelper;
+    protected readonly exceptionConverter: MsSqlExceptionConverter;
+    /** @inheritDoc */
+    lookupExtensions(orm: MikroORM): void;
+    usesOutputStatement(): boolean;
+    convertDateToJSValue(value: string | Date): string;
+    convertsJsonAutomatically(): boolean;
+    indexForeignKeys(): boolean;
+    supportsSchemas(): boolean;
+    getCurrentTimestampSQL(length: number): string;
+    getDateTimeTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    getTimeTypeDeclarationSQL(): string;
+    getFloatDeclarationSQL(): string;
+    getDoubleDeclarationSQL(): string;
+    getBooleanTypeDeclarationSQL(): string;
+    getRegExpOperator(): string;
+    getBlobDeclarationSQL(): string;
+    getJsonDeclarationSQL(): string;
+    getEnumTypeDeclarationSQL(column: {
+        fieldNames: string[];
+        items?: unknown[];
+        length?: number;
+    }): string;
+    getDefaultMappedType(type: string): Type<unknown>;
+    getDefaultSchemaName(): string | undefined;
+    getVarcharTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    getUuidTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    validateMetadata(meta: EntityMetadata): void;
+    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string;
+    normalizePrimaryKey<T extends number | string = number | string>(data: Primary<T> | IPrimaryKey | string): T;
+    supportsMultipleCascadePaths(): boolean;
+    supportsMultipleStatements(): boolean;
+    quoteIdentifier(id: string): string;
+    quoteValue(value: any): string;
+    getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): MsSqlSchemaGenerator;
+}

package/MsSqlPlatform.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsSqlPlatform = void 0;
+const knex_1 = require("@mikro-orm/knex");
+// @ts-expect-error no types available
+const tsqlstring_1 = __importDefault(require("tsqlstring"));
+const MsSqlSchemaHelper_1 = require("./MsSqlSchemaHelper");
+const MsSqlExceptionConverter_1 = require("./MsSqlExceptionConverter");
+const MsSqlSchemaGenerator_1 = require("./MsSqlSchemaGenerator");
+const UnicodeStringType_1 = require("./UnicodeStringType");
+class MsSqlPlatform extends knex_1.AbstractSqlPlatform {
+    schemaHelper = new MsSqlSchemaHelper_1.MsSqlSchemaHelper(this);
+    exceptionConverter = new MsSqlExceptionConverter_1.MsSqlExceptionConverter();
+    /** @inheritDoc */
+    lookupExtensions(orm) {
+        MsSqlSchemaGenerator_1.MsSqlSchemaGenerator.register(orm);
+    }
+    usesOutputStatement() {
+        return true;
+    }
+    convertDateToJSValue(value) {
+        /* istanbul ignore next */
+        if (typeof value === 'string') {
+            return value;
+        }
+        return value.toISOString().substring(0, 10);
+    }
+    convertsJsonAutomatically() {
+        return false;
+    }
+    indexForeignKeys() {
+        return false;
+    }
+    supportsSchemas() {
+        return true;
+    }
+    getCurrentTimestampSQL(length) {
+        return `current_timestamp`;
+    }
+    getDateTimeTypeDeclarationSQL(column) {
+        /* istanbul ignore next */
+        return 'datetime2' + (column.length != null ? `(${column.length})` : '');
+    }
+    getTimeTypeDeclarationSQL() {
+        return 'time';
+    }
+    getFloatDeclarationSQL() {
+        return 'float(24)';
+    }
+    getDoubleDeclarationSQL() {
+        return 'float(53)';
+    }
+    getBooleanTypeDeclarationSQL() {
+        return 'bit';
+    }
+    getRegExpOperator() {
+        throw new Error('Not supported');
+    }
+    getBlobDeclarationSQL() {
+        return 'varbinary(max)';
+    }
+    getJsonDeclarationSQL() {
+        return 'nvarchar(max)';
+    }
+    getEnumTypeDeclarationSQL(column) {
+        if (column.items?.every(item => knex_1.Utils.isString(item))) {
+            return this.getVarcharTypeDeclarationSQL({ length: 100, ...column });
+        }
+        /* istanbul ignore next */
+        return this.getSmallIntTypeDeclarationSQL(column);
+    }
+    getDefaultMappedType(type) {
+        const normalizedType = this.extractSimpleType(type);
+        if (normalizedType !== 'uuid' && ['string', 'nvarchar'].includes(normalizedType)) {
+            return knex_1.Type.getType(UnicodeStringType_1.UnicodeStringType);
+        }
+        const map = {
+            int: 'integer',
+            bit: 'boolean',
+            real: 'float',
+            uniqueidentifier: 'uuid',
+            varbinary: 'blob',
+            datetime2: 'datetime',
+        };
+        return super.getDefaultMappedType(map[normalizedType] ?? type);
+    }
+    getDefaultSchemaName() {
+        return 'dbo';
+    }
+    getVarcharTypeDeclarationSQL(column) {
+        return `nvarchar(${column.length ?? 255})`;
+    }
+    getUuidTypeDeclarationSQL(column) {
+        return 'uniqueidentifier';
+    }
+    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')) {
+                prop.customType ??= new UnicodeStringType_1.UnicodeStringType();
+                prop.customType.prop = prop;
+                prop.customType.platform = this;
+                prop.customType.meta = meta;
+            }
+        }
+    }
+    getSearchJsonPropertyKey(path, type, aliased, value) {
+        const [a, ...b] = path;
+        /* istanbul ignore next */
+        const root = this.quoteIdentifier(aliased ? `${knex_1.ALIAS_REPLACEMENT}.${a}` : a);
+        const types = {
+            boolean: 'bit',
+        };
+        const cast = (key) => (0, knex_1.raw)(type in types ? `cast(${key} as ${types[type]})` : key);
+        const quoteKey = (key) => key.match(/^[a-z]\w*$/i) ? key : `"${key}"`;
+        /* istanbul ignore if */
+        if (path.length === 0) {
+            return cast(`json_value(${root}, '$.${b.map(quoteKey).join('.')}')`);
+        }
+        return cast(`json_value(${root}, '$.${b.map(quoteKey).join('.')}')`);
+    }
+    normalizePrimaryKey(data) {
+        /* istanbul ignore if */
+        if (data instanceof UnicodeStringType_1.UnicodeString) {
+            return data.value;
+        }
+        return data;
+    }
+    supportsMultipleCascadePaths() {
+        return false;
+    }
+    supportsMultipleStatements() {
+        return true;
+    }
+    quoteIdentifier(id) {
+        return `[${id.replace('.', `].[`)}]`;
+    }
+    quoteValue(value) {
+        /* istanbul ignore if */
+        if (knex_1.Utils.isRawSql(value)) {
+            return this.formatQuery(value.sql, value.params ?? []);
+        }
+        /* istanbul ignore if */
+        if (this.isRaw(value)) {
+            return value;
+        }
+        if (value instanceof UnicodeStringType_1.UnicodeString) {
+            return `N${tsqlstring_1.default.escape(value.value)}`;
+        }
+        /* istanbul ignore if */
+        if (knex_1.Utils.isPlainObject(value) || value?.[knex_1.JsonProperty]) {
+            return tsqlstring_1.default.escape(JSON.stringify(value), true, this.timezone);
+        }
+        if (value instanceof Buffer) {
+            return `0x${value.toString('hex')}`;
+        }
+        if (value instanceof Date) {
+            return tsqlstring_1.default.dateToString(value.toISOString(), 'Z');
+        }
+        return tsqlstring_1.default.escape(value);
+    }
+    /* istanbul ignore next: kept for type inference only */
+    getSchemaGenerator(driver, em) {
+        return new MsSqlSchemaGenerator_1.MsSqlSchemaGenerator(em ?? driver);
+    }
+}
+exports.MsSqlPlatform = MsSqlPlatform;

package/MsSqlQueryBuilder.d.ts

@@ -0,0 +1,9 @@
+import { type AnyEntity, type RequiredEntityData } from '@mikro-orm/core';
+import { type InsertQueryBuilder, type Knex, QueryBuilder } from '@mikro-orm/knex';
+export declare class MsSqlQueryBuilder<T extends AnyEntity<T> = AnyEntity> extends QueryBuilder<T> {
+    insert(data: RequiredEntityData<T> | RequiredEntityData<T>[]): InsertQueryBuilder<T>;
+    getKnex(): Knex.QueryBuilder;
+    getKnexQuery(processVirtualEntity?: boolean): Knex.QueryBuilder;
+    private appendIdentityInsert;
+    private checkIdentityInsert;
+}

package/MsSqlQueryBuilder.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsSqlQueryBuilder = void 0;
+const core_1 = require("@mikro-orm/core");
+const knex_1 = require("@mikro-orm/knex");
+class MsSqlQueryBuilder extends knex_1.QueryBuilder {
+    insert(data) {
+        this.checkIdentityInsert(data);
+        return super.insert(data);
+    }
+    getKnex() {
+        const qb = super.getKnex();
+        if (this.flags.has(core_1.QueryFlag.IDENTITY_INSERT)) {
+            this.appendIdentityInsert(qb);
+        }
+        return qb;
+    }
+    getKnexQuery(processVirtualEntity = true) {
+        if (this.type === knex_1.QueryType.TRUNCATE) {
+            const tableName = this.driver.getTableName(this.mainAlias.metadata, { schema: this._schema }, false);
+            const tableNameQuoted = this.platform.quoteIdentifier(tableName);
+            const sql = `delete from ${tableNameQuoted}; declare @count int = case @@rowcount when 0 then 1 else 0 end; dbcc checkident ('${tableName}', reseed, @count)`;
+            this._query = {};
+            return this._query.qb = this.knex.raw(sql);
+        }
+        return super.getKnexQuery(processVirtualEntity);
+    }
+    appendIdentityInsert(qb) {
+        const meta = this.metadata.get(this.mainAlias.entityName);
+        const table = this.driver.getTableName(meta, { schema: this._schema });
+        const originalToSQL = qb.toSQL;
+        qb.toSQL = () => {
+            const res = originalToSQL.apply(qb);
+            return {
+                ...res,
+                sql: `set identity_insert ${table} on; ${res.sql}; set identity_insert ${table} off;`,
+                toNative: () => res.toNative(),
+            };
+        };
+    }
+    checkIdentityInsert(data) {
+        const meta = this.metadata.find(this.mainAlias.entityName);
+        if (!meta) {
+            return;
+        }
+        const dataKeys = core_1.Utils.unique(core_1.Utils.asArray(data).flatMap(Object.keys));
+        const hasAutoincrement = dataKeys.some(x => meta.properties[x]?.autoincrement);
+        if (hasAutoincrement) {
+            this.setFlag(core_1.QueryFlag.IDENTITY_INSERT);
+        }
+    }
+}
+exports.MsSqlQueryBuilder = MsSqlQueryBuilder;

package/MsSqlSchemaGenerator.d.ts

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

package/MsSqlSchemaGenerator.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsSqlSchemaGenerator = void 0;
+const knex_1 = require("@mikro-orm/knex");
+class MsSqlSchemaGenerator extends knex_1.SchemaGenerator {
+    static register(orm) {
+        orm.config.registerExtension('@mikro-orm/schema-generator', () => new MsSqlSchemaGenerator(orm.em));
+    }
+    async clearDatabase(options) {
+        // truncate by default, so no value is considered as true
+        /* istanbul ignore if */
+        if (options?.truncate === false) {
+            return super.clearDatabase(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);
+            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})`, {
+                    ctx: this.em?.getTransactionContext(),
+                });
+            }
+        }
+        this.clearIdentityMap();
+    }
+    async getDropSchemaSQL(options = {}) {
+        return super.getDropSchemaSQL({ dropForeignKeys: true, ...options });
+    }
+}
+exports.MsSqlSchemaGenerator = MsSqlSchemaGenerator;

package/MsSqlSchemaHelper.d.ts

@@ -0,0 +1,32 @@
+import { type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSchema, type DatabaseTable, type Dictionary, type ForeignKey, type IndexDef, type Knex, SchemaHelper, type Table, type TableDifference, type Type } from '@mikro-orm/knex';
+export declare class MsSqlSchemaHelper extends SchemaHelper {
+    static readonly DEFAULT_VALUES: {
+        true: string[];
+        false: string[];
+        'getdate()': string[];
+    };
+    getManagementDbName(): string;
+    disableForeignKeysSQL(): string;
+    enableForeignKeysSQL(): string;
+    getDatabaseExistsSQL(name: string): string;
+    getListTablesSQL(): string;
+    normalizeDefaultValue(defaultValue: string, length: number, defaultValues?: Dictionary<string[]>, stripQuotes?: boolean): string | number;
+    getAllColumns(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Column[]>>;
+    getAllIndexes(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<IndexDef[]>>;
+    mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;
+    getAllForeignKeys(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Dictionary<ForeignKey>>>;
+    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName?: string, schemaName?: string): Promise<Dictionary<string[]>>;
+    private getChecksSQL;
+    getAllChecks(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<CheckDef[]>>;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[]): Promise<void>;
+    getPreAlterTable(tableDiff: TableDifference, safe: boolean): string;
+    getPostAlterTable(tableDiff: TableDifference, safe: boolean): string;
+    getCreateNamespaceSQL(name: string): string;
+    getDropNamespaceSQL(name: string): string;
+    getDropIndexSQL(tableName: string, index: IndexDef): string;
+    getDropColumnsSQL(tableName: string, columns: Column[], schemaName?: string): string;
+    getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
+    createTableColumn(table: Knex.TableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>, alter?: boolean): Knex.ColumnBuilder | undefined;
+    inferLengthFromColumnType(type: string): number | undefined;
+    protected wrap(val: string | undefined, type: Type<unknown>): string | undefined;
+}