@mikro-orm/mssql 6.4.7-dev.0 → 7.0.0-dev.0

package/MsSqlConnection.d.ts

@@ -1,14 +1,9 @@
-import { AbstractSqlConnection, type IsolationLevel, type Knex, type TransactionEventBroadcaster } from '@mikro-orm/knex';
+import { AbstractSqlConnection, type TransactionEventBroadcaster } from '@mikro-orm/knex';
+import { type ControlledTransaction, MssqlDialect } from 'kysely';
+import type { ConnectionConfiguration } from 'tedious';
 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>;
+    createKyselyDialect(overrides: ConnectionConfiguration): MssqlDialect;
+    private mapOptions;
+    commit(ctx: ControlledTransaction<any, any>, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
     protected transformRawResult<T>(res: any, method: 'all' | 'get' | 'run'): T;
 }

package/MsSqlConnection.js

@@ -1,69 +1,114 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MsSqlConnection = void 0;
 const knex_1 = require("@mikro-orm/knex");
+const kysely_1 = require("kysely");
+const Tedious = __importStar(require("tedious"));
+const Tarn = __importStar(require("tarn"));
 class MsSqlConnection extends knex_1.AbstractSqlConnection {
-    createKnex() {
-        this.client = this.createKnexClient(knex_1.MsSqlKnexDialect);
-        this.connected = true;
-    }
-    getDefaultClientUrl() {
-        return 'mssql://sa@localhost:1433';
+    createKyselyDialect(overrides) {
+        const options = this.mapOptions(overrides);
+        const poolOptions = knex_1.Utils.mergeConfig({
+            min: 0,
+            max: 10,
+        }, this.config.get('pool'));
+        const password = options.authentication?.options?.password;
+        const onCreateConnection = this.options.onCreateConnection ?? this.config.get('onCreateConnection');
+        return new kysely_1.MssqlDialect({
+            tarn: { ...Tarn, options: poolOptions },
+            tedious: {
+                ...Tedious,
+                connectionFactory: async () => {
+                    options.authentication.options.password = typeof password === 'function' ? await password() : password;
+                    const connection = new Tedious.Connection(options);
+                    await onCreateConnection?.(connection);
+                    return connection;
+                },
+            },
+        });
     }
-    getConnectionOptions() {
-        const config = super.getConnectionOptions();
-        const overrides = {
+    mapOptions(overrides) {
+        const options = this.getConnectionOptions();
+        const ret = {
+            authentication: {
+                options: {
+                    password: options.password,
+                    userName: options.user,
+                },
+                type: 'default',
+            },
             options: {
+                database: options.database,
+                port: options.port,
                 enableArithAbort: true,
                 fallbackToDefaultDb: true,
                 useUTC: this.config.get('forceUtcTimezone', false),
+                encrypt: false,
             },
+            server: options.host,
         };
         /* istanbul ignore next */
-        if (config.host?.includes('\\')) {
-            const [host, ...name] = config.host.split('\\');
-            overrides.server = host;
-            overrides.options.instanceName = name.join('\\');
-            delete config.host;
-            delete config.port;
+        if (ret.server.includes('\\')) {
+            const [host, ...name] = ret.server.split('\\');
+            ret.server = host;
+            ret.options.instanceName = name.join('\\');
+            delete ret.options.port;
         }
-        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);
+        return knex_1.Utils.mergeConfig(ret, overrides);
     }
     async commit(ctx, eventBroadcaster) {
-        this.logQuery('commit');
-        return super.commit(ctx, eventBroadcaster);
-    }
-    async rollback(ctx, eventBroadcaster) {
-        if (eventBroadcaster?.isTopLevel()) {
-            this.logQuery('rollback');
+        if ('savepointName' in ctx) {
+            return;
         }
-        return super.rollback(ctx, eventBroadcaster);
+        return super.commit(ctx, eventBroadcaster);
     }
     transformRawResult(res, method) {
         if (method === 'get') {
-            return res[0];
+            return res.rows[0];
         }
-        if (method === 'all' || !res) {
-            return res;
+        if (method === 'all') {
+            return res.rows;
         }
-        const rowCount = res.length;
-        const hasEmptyCount = (rowCount === 1) && ('' in res[0]);
-        const emptyRow = hasEmptyCount && res[0][''];
+        const rowCount = res.rows.length;
+        const hasEmptyCount = (rowCount === 1) && ('' in res.rows[0]);
+        const emptyRow = hasEmptyCount && Number(res.rows[0]['']);
         return {
-            affectedRows: hasEmptyCount ? emptyRow : res.length,
-            insertId: res[0] ? res[0].id : 0,
-            row: res[0],
-            rows: res,
+            affectedRows: hasEmptyCount ? emptyRow : Number(res.numAffectedRows),
+            row: res.rows[0],
+            rows: res.rows,
         };
     }
 }

package/MsSqlDriver.d.ts

@@ -1,9 +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 { AbstractSqlDriver, 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, any, any, any>;
+    createQueryBuilder<T extends AnyEntity<T>>(entityName: string, ctx?: Transaction, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): MsSqlQueryBuilder<T, any, any, any>;
 }

package/MsSqlDriver.js

@@ -8,7 +8,7 @@ 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']);
+        super(config, new MsSqlPlatform_1.MsSqlPlatform(), MsSqlConnection_1.MsSqlConnection, ['kysely', 'tedious']);
     }
     async nativeInsertMany(entityName, data, options = {}) {
         const meta = this.metadata.get(entityName);

package/MsSqlPlatform.d.ts

@@ -1,4 +1,4 @@
-import { AbstractSqlPlatform, type EntityMetadata, type IDatabaseDriver, type EntityManager, type MikroORM, Type, type Primary, type IPrimaryKey } from '@mikro-orm/knex';
+import { AbstractSqlPlatform, type EntityMetadata, type IDatabaseDriver, type EntityManager, type MikroORM, Type, type Primary, type IPrimaryKey, MsSqlNativeQueryBuilder } from '@mikro-orm/knex';
 import { MsSqlSchemaHelper } from './MsSqlSchemaHelper';
 import { MsSqlExceptionConverter } from './MsSqlExceptionConverter';
 import { MsSqlSchemaGenerator } from './MsSqlSchemaGenerator';
@@ -9,6 +9,10 @@ export declare class MsSqlPlatform extends AbstractSqlPlatform {
     lookupExtensions(orm: MikroORM): void;
     /** @inheritDoc */
     init(orm: MikroORM): void;
+    getRollbackToSavepointSQL(savepointName: string): string;
+    getSavepointSQL(savepointName: string): string;
+    /** @internal */
+    createNativeQueryBuilder(): MsSqlNativeQueryBuilder;
     usesOutputStatement(): boolean;
     convertDateToJSValue(value: string | Date): string;
     convertsJsonAutomatically(): boolean;
@@ -35,7 +39,7 @@ export declare class MsSqlPlatform extends AbstractSqlPlatform {
         unsigned?: boolean;
         autoincrement?: boolean;
     }): string;
-    normalizeColumnType(type: string, options?: {
+    normalizeColumnType(type: string, options: {
         length?: number;
         precision?: number;
         scale?: number;
@@ -48,10 +52,12 @@ export declare class MsSqlPlatform extends AbstractSqlPlatform {
     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;
+    usesEnumCheckConstraints(): boolean;
     supportsMultipleCascadePaths(): boolean;
     supportsMultipleStatements(): boolean;
     quoteIdentifier(id: string): string;
     escape(value: any): string;
     getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): MsSqlSchemaGenerator;
     allowsComparingTuples(): boolean;
+    getDefaultClientUrl(): string;
 }

package/MsSqlPlatform.js

@@ -23,7 +23,17 @@ class MsSqlPlatform extends knex_1.AbstractSqlPlatform {
     init(orm) {
         super.init(orm);
         // do not double escape backslash inside strings
-        tsqlstring_1.default.CHARS_GLOBAL_REGEXP = /[']/g;
+        tsqlstring_1.default.CHARS_GLOBAL_REGEXP = /'/g;
+    }
+    getRollbackToSavepointSQL(savepointName) {
+        return `rollback transaction ${this.quoteIdentifier(savepointName)}`;
+    }
+    getSavepointSQL(savepointName) {
+        return `save transaction ${this.quoteIdentifier(savepointName)}`;
+    }
+    /** @internal */
+    createNativeQueryBuilder() {
+        return new knex_1.MsSqlNativeQueryBuilder(this);
     }
     usesOutputStatement() {
         return true;
@@ -85,7 +95,7 @@ class MsSqlPlatform extends knex_1.AbstractSqlPlatform {
         /* istanbul ignore next */
         return this.getSmallIntTypeDeclarationSQL(column);
     }
-    normalizeColumnType(type, options = {}) {
+    normalizeColumnType(type, options) {
         const simpleType = this.extractSimpleType(type);
         if (['decimal', 'numeric'].includes(simpleType)) {
             return this.getDecimalTypeDeclarationSQL(options);
@@ -158,6 +168,9 @@ class MsSqlPlatform extends knex_1.AbstractSqlPlatform {
         }
         return data;
     }
+    usesEnumCheckConstraints() {
+        return true;
+    }
     supportsMultipleCascadePaths() {
         return false;
     }
@@ -165,6 +178,9 @@ class MsSqlPlatform extends knex_1.AbstractSqlPlatform {
         return true;
     }
     quoteIdentifier(id) {
+        if (knex_1.RawQueryFragment.isKnownFragment(id)) {
+            return super.quoteIdentifier(id);
+        }
         return `[${id.replace('.', `].[`)}]`;
     }
     escape(value) {
@@ -186,5 +202,8 @@ class MsSqlPlatform extends knex_1.AbstractSqlPlatform {
     allowsComparingTuples() {
         return false;
     }
+    getDefaultClientUrl() {
+        return 'mssql://sa@localhost:1433';
+    }
 }
 exports.MsSqlPlatform = MsSqlPlatform;

package/MsSqlQueryBuilder.d.ts

@@ -1,9 +1,6 @@
 import { type AnyEntity, type RequiredEntityData } from '@mikro-orm/core';
-import { type InsertQueryBuilder, type Knex, QueryBuilder } from '@mikro-orm/knex';
+import { type InsertQueryBuilder, QueryBuilder } from '@mikro-orm/knex';
 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>;
-    getKnex(): Knex.QueryBuilder;
-    getKnexQuery(processVirtualEntity?: boolean): Knex.QueryBuilder;
-    private appendIdentityInsert;
     private checkIdentityInsert;
 }

package/MsSqlQueryBuilder.js

@@ -8,36 +8,6 @@ class MsSqlQueryBuilder extends knex_1.QueryBuilder {
         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) {

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, type Knex, 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/knex';
 export declare class MsSqlSchemaHelper extends SchemaHelper {
     static readonly DEFAULT_VALUES: {
         true: string[];
@@ -16,23 +16,27 @@ export declare class MsSqlSchemaHelper extends SchemaHelper {
     getAllIndexes(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<IndexDef[]>>;
     mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;
     getAllForeignKeys(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<Dictionary<ForeignKey>>>;
-    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName?: string, schemaName?: string): Promise<Dictionary<string[]>>;
+    private getEnumDefinitions;
     private getChecksSQL;
     getAllChecks(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, 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;
+    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;
+    dropIndex(table: string, index: IndexDef, oldIndexName?: string): string;
     getDropColumnsSQL(tableName: string, columns: Column[], schemaName?: string): string;
+    private getDropDefaultsSQL;
     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;
+    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;
+    createIndex(index: IndexDef, table: DatabaseTable, createPrimary?: boolean): string;
+    dropForeignKey(tableName: string, constraintName: string): string;
+    dropTableIfExists(name: string, schema?: string): string;
+    getAddColumnsSQL(table: DatabaseTable, columns: Column[]): string[];
+    appendComments(table: DatabaseTable): string[];
     inferLengthFromColumnType(type: string): number | undefined;
     protected wrap(val: string | undefined, type: Type<unknown>): string | undefined;
-    /**
-     * MSSQL supports `\n` in SQL and stores `\\n` literally.
-     * This method overrides the parent behavior to prevent replacing `\n` with `\\n`.
-     */
-    handleMultilineComment(comment: string): string;
 }

package/MsSqlSchemaHelper.js

@@ -53,6 +53,7 @@ class MsSqlSchemaHelper extends knex_1.SchemaHelper {
       table_schema as schema_name,
       column_name as column_name,
       column_default as column_default,
+      t5.name as column_default_name,
       t4.value as column_comment,
       ic.is_nullable as is_nullable,
       data_type as data_type,
@@ -67,6 +68,7 @@ class MsSqlSchemaHelper extends knex_1.SchemaHelper {
       inner join sys.columns sc on sc.name = ic.column_name and sc.object_id = object_id(ic.table_schema + '.' + ic.table_name)
       left join sys.computed_columns cmp on cmp.name = ic.column_name and cmp.object_id = object_id(ic.table_schema + '.' + ic.table_name)
       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 ')})
       order by ordinal_position`;
         const allColumns = await connection.execute(sql);
@@ -103,6 +105,7 @@ class MsSqlSchemaHelper extends knex_1.SchemaHelper {
                 unsigned: col.data_type.endsWith(' unsigned'),
                 length: col.length,
                 default: this.wrap(defaultValue, mappedType),
+                defaultConstraint: col.column_default_name,
                 nullable: col.is_nullable === 'YES',
                 autoincrement: increments,
                 precision: col.numeric_precision,
@@ -184,10 +187,9 @@ class MsSqlSchemaHelper extends knex_1.SchemaHelper {
         });
         return ret;
     }
-    async getEnumDefinitions(connection, checks, tableName, schemaName) {
-        const found = [];
-        const enums = checks.reduce((o, item, index) => {
-            // check constraints are defined as one of:
+    getEnumDefinitions(checks) {
+        return checks.reduce((o, item, index) => {
+            // check constraints are defined as
             // `([type]='owner' OR [type]='manager' OR [type]='employee')`
             const m1 = item.definition?.match(/^check \((.*)\)/);
             let items = m1?.[1].split(' OR ');
@@ -197,13 +199,10 @@ class MsSqlSchemaHelper extends knex_1.SchemaHelper {
                 items = items.map(val => val.trim().replace(`[${item.columnName}]=`, '').match(/^\(?'(.*)'/)?.[1]).filter(Boolean);
                 if (items.length > 0) {
                     o[item.columnName] = items.reverse();
-                    found.push(index);
                 }
             }
             return o;
         }, {});
-        found.reverse().forEach(index => checks.splice(index, 1));
-        return enums;
     }
     getChecksSQL(tablesBySchemas) {
         return `select con.name as name,
@@ -224,11 +223,12 @@ class MsSqlSchemaHelper extends knex_1.SchemaHelper {
         for (const check of allChecks) {
             const key = this.getTableKey(check);
             ret[key] ??= [];
+            const expression = check.expression.replace(/^\((.*)\)$/, '$1');
             ret[key].push({
                 name: check.name,
                 columnName: check.column_name,
-                definition: 'check ' + check.expression,
-                expression: check.expression,
+                definition: `check (${expression})`,
+                expression,
             });
         }
         return ret;
@@ -246,7 +246,7 @@ class MsSqlSchemaHelper extends knex_1.SchemaHelper {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
             const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
-            const enums = await this.getEnumDefinitions(connection, checks[key] ?? []);
+            const enums = this.getEnumDefinitions(checks[key] ?? []);
             table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums);
         }
     }
@@ -258,17 +258,9 @@ class MsSqlSchemaHelper extends knex_1.SchemaHelper {
         const schemaName = parts.pop();
         /* istanbul ignore next */
         const name = (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
-        const quotedName = this.platform.quoteIdentifier(name);
+        const quotedName = this.quote(name);
         // indexes need to be first dropped to be able to change a column type
         const changedTypes = Object.values(tableDiff.changedColumns).filter(col => col.changedProperties.has('type'));
-        // detect that the column was an enum before and remove the check constraint in such case here
-        const changedEnums = Object.values(tableDiff.changedColumns).filter(col => col.fromColumn.mappedType instanceof knex_1.EnumType);
-        for (const col of changedEnums) {
-            if (col.changedProperties.has('enumItems')) {
-                const checkName = this.platform.getConfig().getNamingStrategy().indexName(tableName, [col.column.name], 'check');
-                ret.push(`alter table ${quotedName} drop constraint if exists [${checkName}]`);
-            }
-        }
         for (const col of changedTypes) {
             for (const index of indexes) {
                 if (index.columnNames.includes(col.column.name)) {
@@ -281,7 +273,7 @@ class MsSqlSchemaHelper extends knex_1.SchemaHelper {
                 ret.push(`alter table ${quotedName} alter column [${col.oldColumnName}] nvarchar(max)`);
             }
         }
-        return ret.join(';\n');
+        return ret;
     }
     getPostAlterTable(tableDiff, safe) {
         const ret = [];
@@ -296,38 +288,58 @@ class MsSqlSchemaHelper extends knex_1.SchemaHelper {
         for (const col of changedTypes) {
             for (const index of indexes) {
                 if (index.columnNames.includes(col.column.name)) {
-                    ret.push(this.getCreateIndexSQL(name, index));
+                    this.append(ret, this.getCreateIndexSQL(name, index));
                 }
             }
         }
-        return ret.join(';\n');
+        return ret;
     }
     getCreateNamespaceSQL(name) {
-        return `if (schema_id(${this.platform.quoteValue(name)}) is null) begin exec ('create schema ${this.platform.quoteIdentifier(name)} authorization [dbo]') end`;
+        return `if (schema_id(${this.platform.quoteValue(name)}) is null) begin exec ('create schema ${this.quote(name)} authorization [dbo]') end`;
     }
     getDropNamespaceSQL(name) {
-        return `drop schema if exists ${this.platform.quoteIdentifier(name)}`;
+        return `drop schema if exists ${this.quote(name)}`;
     }
     getDropIndexSQL(tableName, index) {
-        return `drop index ${this.platform.quoteIdentifier(index.keyName)} on ${this.platform.quoteIdentifier(tableName)}`;
+        return `drop index ${this.quote(index.keyName)} on ${this.quote(tableName)}`;
+    }
+    dropIndex(table, index, oldIndexName = index.keyName) {
+        if (index.primary) {
+            return `alter table ${this.quote(table)} drop constraint ${this.quote(oldIndexName)}`;
+        }
+        return `drop index ${this.quote(oldIndexName)} on ${this.quote(table)}`;
     }
     getDropColumnsSQL(tableName, columns, schemaName) {
         /* istanbul ignore next */
-        const tableNameRaw = this.platform.quoteIdentifier((schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName);
+        const tableNameRaw = this.quote((schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName);
         const drops = [];
+        const constraints = this.getDropDefaultsSQL(tableName, columns, schemaName);
+        for (const column of columns) {
+            drops.push(this.quote(column.name));
+        }
+        return `${constraints.join(';\n')};\nalter table ${tableNameRaw} drop column ${drops.join(', ')}`;
+    }
+    getDropDefaultsSQL(tableName, columns, schemaName) {
+        /* istanbul ignore next */
+        const tableNameRaw = this.quote((schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName);
         const constraints = [];
-        let i = 0;
+        schemaName ??= this.platform.getDefaultSchemaName();
         for (const column of columns) {
+            if (column.defaultConstraint) {
+                constraints.push(`alter table ${tableNameRaw} drop constraint ${this.quote(column.defaultConstraint)}`);
+                continue;
+            }
+            const i = globalThis.idx;
+            globalThis.idx++;
+            /* istanbul ignore next */
             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})`);
-            drops.push(this.platform.quoteIdentifier(column.name));
-            i++;
         }
-        return `${constraints.join(';\n')};\nalter table ${tableNameRaw} drop column ${drops.join(', ')}`;
+        return constraints;
     }
     getRenameColumnSQL(tableName, oldColumnName, to, schemaName) {
         /* istanbul ignore next */
@@ -335,22 +347,109 @@ class MsSqlSchemaHelper extends knex_1.SchemaHelper {
         const columnName = this.platform.quoteValue(to.name);
         return `exec sp_rename ${this.platform.quoteValue(oldName)}, ${columnName}, 'COLUMN'`;
     }
-    createTableColumn(table, column, fromTable, changedProperties, alter) {
-        if (changedProperties && column.mappedType instanceof knex_1.EnumType && column.enumItems?.every(item => knex_1.Utils.isString(item))) {
-            const checkName = this.platform.getConfig().getNamingStrategy().indexName(fromTable.name, [column.name], 'check');
-            if (changedProperties.has('enumItems')) {
-                table.check(`${this.platform.quoteIdentifier(column.name)} in ('${(column.enumItems.join("', '"))}')`, {}, this.platform.quoteIdentifier(checkName));
-            }
-            /* istanbul ignore next */
-            if (changedProperties.has('type')) {
-                return table.specificType(column.name, column.type);
-            }
-            return undefined;
+    createTableColumn(column, table, changedProperties) {
+        const compositePK = table.getPrimaryKey()?.composite;
+        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'))) {
+            col.push(column.mappedType.getColumnType({ autoincrement: true }, this.platform));
+        }
+        else {
+            col.push(columnType);
         }
-        if (column.generated) {
-            return table.specificType(column.name, `as ${column.generated}`);
+        knex_1.Utils.runIfNotEmpty(() => col.push('identity(1,1)'), column.autoincrement);
+        knex_1.Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
+        knex_1.Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable && !column.generated);
+        if (column.autoincrement && !column.generated && !compositePK && (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
+            knex_1.Utils.runIfNotEmpty(() => col.push('primary key'), primaryKey && column.primary);
         }
-        return super.createTableColumn(table, column, fromTable, changedProperties);
+        const useDefault = changedProperties ? false : column.default != null && column.default !== 'null' && !column.autoincrement;
+        const defaultName = this.platform.getConfig().getNamingStrategy().indexName(table.name, [column.name], 'default');
+        knex_1.Utils.runIfNotEmpty(() => col.push(`constraint ${this.quote(defaultName)} default ${column.default}`), useDefault);
+        return col.join(' ');
+    }
+    alterTableColumn(column, table, changedProperties) {
+        const parts = [];
+        if (changedProperties.has('default')) {
+            const [constraint] = this.getDropDefaultsSQL(table.name, [column], table.schema);
+            parts.push(constraint);
+        }
+        if (changedProperties.has('type') || changedProperties.has('nullable')) {
+            const col = this.createTableColumn(column, table, changedProperties);
+            parts.push(`alter table ${table.getQuotedName()} alter column ${col}`);
+        }
+        if (changedProperties.has('default') && column.default != null) {
+            const defaultName = this.platform.getConfig().getNamingStrategy().indexName(table.name, [column.name], 'default');
+            parts.push(`alter table ${table.getQuotedName()} add constraint ${this.quote(defaultName)} default ${column.default} for ${this.quote(column.name)}`);
+        }
+        return parts;
+    }
+    getCreateIndexSQL(tableName, index, partialExpression = false) {
+        /* istanbul ignore next */
+        if (index.expression && !partialExpression) {
+            return index.expression;
+        }
+        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)} `;
+        if (index.expression && partialExpression) {
+            return `${sql}(${index.expression})${defer}`;
+        }
+        return super.getCreateIndexSQL(tableName, index);
+    }
+    createIndex(index, table, createPrimary = false) {
+        if (index.primary) {
+            return '';
+        }
+        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}`;
+        }
+        return super.createIndex(index, table);
+    }
+    dropForeignKey(tableName, constraintName) {
+        return `alter table ${this.quote(tableName)} drop constraint ${this.quote(constraintName)}`;
+    }
+    dropTableIfExists(name, schema) {
+        if (schema === this.platform.getDefaultSchemaName()) {
+            schema = undefined;
+        }
+        return `if object_id('${this.quote(schema, name)}', 'U') is not null drop table ${this.quote(schema, name)}`;
+    }
+    getAddColumnsSQL(table, columns) {
+        const adds = columns.map(column => {
+            return `${this.createTableColumn(column, table)}`;
+        }).join(', ');
+        return [`alter table ${table.getQuotedName()} add ${adds}`];
+    }
+    appendComments(table) {
+        const sql = [];
+        const schema = this.platform.quoteValue(table.schema);
+        const tableName = this.platform.quoteValue(table.name);
+        if (table.comment) {
+            const comment = this.platform.quoteValue(table.comment);
+            sql.push(`if exists(select * from sys.fn_listextendedproperty(N'MS_Description', N'Schema', N${schema}, N'Table', N${tableName}, null, null))
+  exec sys.sp_updateextendedproperty N'MS_Description', N${comment}, N'Schema', N${schema}, N'Table', N${tableName}
+else
+  exec sys.sp_addextendedproperty N'MS_Description', N${comment}, N'Schema', N${schema}, N'Table', N${tableName}`);
+        }
+        for (const column of table.getColumns()) {
+            if (column.comment) {
+                const comment = this.platform.quoteValue(column.comment);
+                const columnName = this.platform.quoteValue(column.name);
+                sql.push(`if exists(select * from sys.fn_listextendedproperty(N'MS_Description', N'Schema', N${schema}, N'Table', N${tableName}, N'Column', N${columnName}))
+  exec sys.sp_updateextendedproperty N'MS_Description', N${comment}, N'Schema', N${schema}, N'Table', N${tableName}, N'Column', N${columnName}
+else
+  exec sys.sp_addextendedproperty N'MS_Description', N${comment}, N'Schema', N${schema}, N'Table', N${tableName}, N'Column', N${columnName}`);
+            }
+        }
+        return sql;
     }
     inferLengthFromColumnType(type) {
         const match = type.match(/^(\w+)\s*\(\s*(-?\d+|max)\s*\)/);
@@ -366,12 +465,5 @@ class MsSqlSchemaHelper extends knex_1.SchemaHelper {
         const stringType = type instanceof knex_1.StringType || type instanceof knex_1.TextType || type instanceof knex_1.EnumType || type instanceof UnicodeStringType_1.UnicodeStringType;
         return typeof val === 'string' && val.length > 0 && stringType ? this.platform.quoteValue(val) : val;
     }
-    /**
-     * MSSQL supports `\n` in SQL and stores `\\n` literally.
-     * This method overrides the parent behavior to prevent replacing `\n` with `\\n`.
-     */
-    handleMultilineComment(comment) {
-        return comment;
-    }
 }
 exports.MsSqlSchemaHelper = MsSqlSchemaHelper;

package/README.md

@@ -183,7 +183,6 @@ 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/sqlite        # for sqlite
-yarn add @mikro-orm/core @mikro-orm/better-sqlite # for better-sqlite
 yarn add @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
 
@@ -196,7 +195,6 @@ npm i -s @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
 npm i -s @mikro-orm/core @mikro-orm/postgresql    # for postgresql
 npm i -s @mikro-orm/core @mikro-orm/mssql         # for mssql
 npm i -s @mikro-orm/core @mikro-orm/sqlite        # for sqlite
-npm i -s @mikro-orm/core @mikro-orm/better-sqlite # for better-sqlite
 npm i -s @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
 

package/index.mjs

@@ -19,12 +19,10 @@ export const ArrayType = mod.ArrayType;
 export const BaseEntity = mod.BaseEntity;
 export const BaseSqliteConnection = mod.BaseSqliteConnection;
 export const BaseSqlitePlatform = mod.BaseSqlitePlatform;
-export const BaseSqliteSchemaHelper = mod.BaseSqliteSchemaHelper;
 export const BeforeCreate = mod.BeforeCreate;
 export const BeforeDelete = mod.BeforeDelete;
 export const BeforeUpdate = mod.BeforeUpdate;
 export const BeforeUpsert = mod.BeforeUpsert;
-export const BetterSqliteKnexDialect = mod.BetterSqliteKnexDialect;
 export const BigIntType = mod.BigIntType;
 export const BlobType = mod.BlobType;
 export const BooleanType = mod.BooleanType;
@@ -112,14 +110,12 @@ export const JSON_KEY_OPERATORS = mod.JSON_KEY_OPERATORS;
 export const JoinType = mod.JoinType;
 export const JsonProperty = mod.JsonProperty;
 export const JsonType = mod.JsonType;
-export const Knex = mod.Knex;
-export const LibSqlKnexDialect = mod.LibSqlKnexDialect;
+export const Kysely = mod.Kysely;
 export const LoadStrategy = mod.LoadStrategy;
 export const LockMode = mod.LockMode;
 export const LockWaitTimeoutException = mod.LockWaitTimeoutException;
 export const ManyToMany = mod.ManyToMany;
 export const ManyToOne = mod.ManyToOne;
-export const MariaDbKnexDialect = mod.MariaDbKnexDialect;
 export const MediumIntType = mod.MediumIntType;
 export const MemoryCacheAdapter = mod.MemoryCacheAdapter;
 export const MetadataDiscovery = mod.MetadataDiscovery;
@@ -129,18 +125,17 @@ export const MetadataStorage = mod.MetadataStorage;
 export const MetadataValidator = mod.MetadataValidator;
 export const MikroORM = mod.MikroORM;
 export const MongoNamingStrategy = mod.MongoNamingStrategy;
-export const MonkeyPatchable = mod.MonkeyPatchable;
 export const MsSqlConnection = mod.MsSqlConnection;
 export const MsSqlDriver = mod.MsSqlDriver;
 export const MsSqlExceptionConverter = mod.MsSqlExceptionConverter;
-export const MsSqlKnexDialect = mod.MsSqlKnexDialect;
+export const MsSqlNativeQueryBuilder = mod.MsSqlNativeQueryBuilder;
 export const MsSqlPlatform = mod.MsSqlPlatform;
 export const MsSqlSchemaHelper = mod.MsSqlSchemaHelper;
-export const MySqlConnection = mod.MySqlConnection;
 export const MySqlExceptionConverter = mod.MySqlExceptionConverter;
-export const MySqlKnexDialect = mod.MySqlKnexDialect;
+export const MySqlNativeQueryBuilder = mod.MySqlNativeQueryBuilder;
 export const MySqlPlatform = mod.MySqlPlatform;
 export const MySqlSchemaHelper = mod.MySqlSchemaHelper;
+export const NativeQueryBuilder = mod.NativeQueryBuilder;
 export const NodeState = mod.NodeState;
 export const NonUniqueFieldNameException = mod.NonUniqueFieldNameException;
 export const NotFoundError = mod.NotFoundError;
@@ -160,7 +155,7 @@ export const PlainObject = mod.PlainObject;
 export const Platform = mod.Platform;
 export const PopulateHint = mod.PopulateHint;
 export const PopulatePath = mod.PopulatePath;
-export const PostgreSqlKnexDialect = mod.PostgreSqlKnexDialect;
+export const PostgreSqlNativeQueryBuilder = mod.PostgreSqlNativeQueryBuilder;
 export const PrimaryKey = mod.PrimaryKey;
 export const PrimaryKeyProp = mod.PrimaryKeyProp;
 export const Property = mod.Property;
@@ -172,6 +167,7 @@ export const QueryOperator = mod.QueryOperator;
 export const QueryOrder = mod.QueryOrder;
 export const QueryOrderNumeric = mod.QueryOrderNumeric;
 export const QueryType = mod.QueryType;
+export const Raw = mod.Raw;
 export const RawQueryFragment = mod.RawQueryFragment;
 export const ReadOnlyException = mod.ReadOnlyException;
 export const Ref = mod.Ref;
@@ -193,8 +189,9 @@ export const SmallIntType = mod.SmallIntType;
 export const SqlEntityManager = mod.SqlEntityManager;
 export const SqlEntityRepository = mod.SqlEntityRepository;
 export const SqlSchemaGenerator = mod.SqlSchemaGenerator;
-export const SqliteKnexDialect = mod.SqliteKnexDialect;
-export const SqliteTableCompiler = mod.SqliteTableCompiler;
+export const SqliteExceptionConverter = mod.SqliteExceptionConverter;
+export const SqliteNativeQueryBuilder = mod.SqliteNativeQueryBuilder;
+export const SqliteSchemaHelper = mod.SqliteSchemaHelper;
 export const StringType = mod.StringType;
 export const SyntaxErrorException = mod.SyntaxErrorException;
 export const TableExistsException = mod.TableExistsException;
@@ -230,7 +227,7 @@ export const equals = mod.equals;
 export const getOnConflictFields = mod.getOnConflictFields;
 export const getOnConflictReturningFields = mod.getOnConflictReturningFields;
 export const helper = mod.helper;
-export const knex = mod.knex;
+export const isRaw = mod.isRaw;
 export const parseJsonSafe = mod.parseJsonSafe;
 export const raw = mod.raw;
 export const ref = mod.ref;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/mssql",
-  "version": "6.4.7-dev.0",
+  "version": "7.0.0-dev.0",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -46,7 +46,7 @@
   },
   "homepage": "https://mikro-orm.io",
   "engines": {
-    "node": ">= 18.12.0"
+    "node": ">= 22.11.0"
   },
   "scripts": {
     "build": "yarn clean && yarn compile && yarn copy && yarn run -T gen-esm-wrapper index.js index.mjs",
@@ -58,14 +58,15 @@
     "access": "public"
   },
   "dependencies": {
-    "@mikro-orm/knex": "6.4.7-dev.0",
+    "@mikro-orm/knex": "7.0.0-dev.0",
+    "tarn": "3.0.2",
     "tedious": "19.0.0",
     "tsqlstring": "1.0.1"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.4.6"
+    "@mikro-orm/core": "^6.4.5"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.4.7-dev.0"
+    "@mikro-orm/core": "7.0.0-dev.0"
   }
 }