@mikro-orm/knex 6.1.13-dev.27 → 6.1.13-dev.28

package/AbstractSqlDriver.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import { type AnyEntity, type Collection, type Configuration, type ConnectionType, type Constructor, type CountOptions, DatabaseDriver, type DeleteOptions, type Dictionary, type DriverMethodOptions, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type LoggingOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type ObjectQuery, type Options, type OrderDefinition, type PopulateOptions, type Primary, type QueryOrderMap, type QueryResult, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
+import { type AnyEntity, type Collection, type Configuration, type ConnectionType, type Constructor, type CountOptions, DatabaseDriver, type DeleteOptions, type Dictionary, type DriverMethodOptions, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type LoggingOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type ObjectQuery, type Options, type OrderDefinition, type PopulateOptions, type PopulatePath, type Primary, type QueryOrderMap, type QueryResult, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from './AbstractSqlConnection';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform';
 import { QueryBuilder, QueryType } from './query';
@@ -13,8 +13,8 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected constructor(config: Configuration, platform: Platform, connection: Constructor<Connection>, connector: string[]);
     getPlatform(): Platform;
     createEntityManager<D extends IDatabaseDriver = IDatabaseDriver>(useContext?: boolean): D[typeof EntityManagerType];
-    find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
-    findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    find<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
     protected hasToManyJoins<T extends object>(hint: PopulateOptions<T>, meta: EntityMetadata<T>): boolean;
     findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
     countVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: CountOptions<T, any>): Promise<number>;
@@ -24,7 +24,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     private mapJoinedProps;
     count<T extends object>(entityName: string, where: any, options?: CountOptions<T>): Promise<number>;
     nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
-    nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
     nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
     nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
     nativeDelete<T extends object>(entityName: string, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
@@ -55,7 +55,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
      */
     mapPropToFieldNames<T extends object>(qb: QueryBuilder<T>, prop: EntityProperty<T>, tableAlias?: string): Field<T>[];
     /** @internal */
-    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, ctx?: Transaction<Knex.Transaction>, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions): QueryBuilder<T>;
+    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, ctx?: Transaction<Knex.Transaction>, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): QueryBuilder<T>;
     protected resolveConnectionType(args: {
         ctx?: Transaction<Knex.Transaction>;
         connectionType?: ConnectionType;

package/AbstractSqlDriver.js

@@ -321,7 +321,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         await this.processManyToMany(meta, pk, collections, false, options);
         return res;
     }
-    async nativeInsertMany(entityName, data, options = {}) {
+    async nativeInsertMany(entityName, data, options = {}, transform) {
         options.processCollections ??= true;
         options.convertCustomTypes ??= true;
         const meta = this.metadata.find(entityName)?.root;
@@ -340,6 +340,13 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const tableName = meta ? this.getTableName(meta, options) : this.platform.quoteIdentifier(entityName);
         let sql = `insert into ${tableName} `;
         sql += fields.length > 0 ? '(' + fields.map(k => this.platform.quoteIdentifier(k)).join(', ') + ')' : `(${this.platform.quoteIdentifier(pks[0])})`;
+        if (meta && this.platform.usesOutputStatement()) {
+            const returningProps = meta.props
+                .filter(prop => prop.persist !== false && prop.defaultRaw || prop.autoincrement || prop.generated)
+                .filter(prop => !(prop.name in data[0]) || core_1.Utils.isRawSql(data[0][prop.name]));
+            const returningFields = core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames));
+            sql += returningFields.length > 0 ? ` output ${returningFields.map(field => 'inserted.' + this.platform.quoteIdentifier(field)).join(', ')}` : '';
+        }
         if (fields.length > 0 || this.platform.usesDefaultKeyword()) {
             sql += ' values ';
         }
@@ -406,6 +413,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             /* istanbul ignore next */
             sql += returningFields.length > 0 ? ` returning ${returningFields.map(field => this.platform.quoteIdentifier(field)).join(', ')}` : '';
         }
+        if (transform) {
+            sql = transform(sql);
+        }
         const res = await this.execute(sql, params, 'run', options.ctx);
         let pk;
         /* istanbul ignore next */
@@ -949,9 +959,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         return prop.fieldNames;
     }
     /** @internal */
-    createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes, loggerContext) {
-        const connectionType = this.resolveConnectionType({ ctx, connectionType: preferredConnectionType });
-        const qb = new query_1.QueryBuilder(entityName, this.metadata, this, ctx, undefined, connectionType, undefined, loggerContext);
+    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 query_1.QueryBuilder(entityName, this.metadata, this, ctx, alias, connectionType, em, loggerContext);
         if (!convertCustomTypes) {
             qb.unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES);
         }

package/MonkeyPatchable.d.ts

@@ -4,6 +4,10 @@ export declare const MonkeyPatchable: {
     MySqlDialect: any;
     MySqlColumnCompiler: any;
     MySqlQueryCompiler: any;
+    MsSqlColumnCompiler: any;
+    MsSqlTableCompiler: any;
+    MsSqlQueryCompiler: any;
+    MsSqlDialect: any;
     PostgresDialectTableCompiler: any;
     Sqlite3Dialect: any;
     Sqlite3DialectTableCompiler: any;

package/MonkeyPatchable.js

@@ -15,6 +15,14 @@ const mysql_columncompiler_1 = __importDefault(require("knex/lib/dialects/mysql/
 // @ts-ignore
 const mysql_querycompiler_1 = __importDefault(require("knex/lib/dialects/mysql/query/mysql-querycompiler"));
 // @ts-ignore
+const mssql_columncompiler_1 = __importDefault(require("knex/lib/dialects/mssql/schema/mssql-columncompiler"));
+// @ts-ignore
+const mssql_tablecompiler_1 = __importDefault(require("knex/lib/dialects/mssql/schema/mssql-tablecompiler"));
+// @ts-ignore
+const mssql_querycompiler_1 = __importDefault(require("knex/lib/dialects/mssql/query/mssql-querycompiler"));
+// @ts-ignore
+const mssql_1 = __importDefault(require("knex/lib/dialects/mssql"));
+// @ts-ignore
 const pg_tablecompiler_1 = __importDefault(require("knex/lib/dialects/postgres/schema/pg-tablecompiler"));
 // @ts-ignore
 const sqlite3_1 = __importDefault(require("knex/lib/dialects/sqlite3"));
@@ -34,6 +42,10 @@ exports.MonkeyPatchable = {
     MySqlDialect: mysql_1.default,
     MySqlColumnCompiler: mysql_columncompiler_1.default,
     MySqlQueryCompiler: mysql_querycompiler_1.default,
+    MsSqlColumnCompiler: mssql_columncompiler_1.default,
+    MsSqlTableCompiler: mssql_tablecompiler_1.default,
+    MsSqlQueryCompiler: mssql_querycompiler_1.default,
+    MsSqlDialect: mssql_1.default,
     PostgresDialectTableCompiler: pg_tablecompiler_1.default,
     Sqlite3Dialect: sqlite3_1.default,
     Sqlite3DialectTableCompiler: sqlite_tablecompiler_1.default,

package/README.md

@@ -179,6 +179,7 @@ yarn add @mikro-orm/core @mikro-orm/mongodb       # for mongo
 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/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
@@ -191,6 +192,7 @@ npm i -s @mikro-orm/core @mikro-orm/mongodb       # for mongo
 npm i -s @mikro-orm/core @mikro-orm/mysql         # for mysql/mariadb
 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/SqlEntityManager.d.ts

@@ -1,7 +1,7 @@
 import type { Knex } from 'knex';
 import { EntityManager, type AnyEntity, type ConnectionType, type EntityData, type EntityName, type EntityRepository, type GetRepository, type QueryResult, type FilterQuery, type LoggingOptions } from '@mikro-orm/core';
 import type { AbstractSqlDriver } from './AbstractSqlDriver';
-import { QueryBuilder } from './query';
+import type { QueryBuilder } from './query';
 import type { SqlEntityRepository } from './SqlEntityRepository';
 /**
  * @inheritDoc

package/SqlEntityManager.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqlEntityManager = void 0;
 const core_1 = require("@mikro-orm/core");
-const query_1 = require("./query");
 /**
  * @inheritDoc
  */
@@ -12,7 +11,7 @@ class SqlEntityManager extends core_1.EntityManager {
      */
     createQueryBuilder(entityName, alias, type, loggerContext) {
         const context = this.getContext(false);
-        return new query_1.QueryBuilder(entityName, this.getMetadata(), this.getDriver(), context.getTransactionContext(), alias, type, context, loggerContext ?? context.loggerContext);
+        return this.driver.createQueryBuilder(entityName, context.getTransactionContext(), type, true, loggerContext ?? context.loggerContext, alias, this);
     }
     /**
      * Shortcut for `createQueryBuilder()`

package/dialects/index.d.ts

@@ -1 +1,2 @@
+export * from './mssql';
 export * from './sqlite';

package/dialects/index.js

@@ -14,4 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./mssql"), exports);
 __exportStar(require("./sqlite"), exports);

package/dialects/mssql/MsSqlColumnCompiler.d.ts

@@ -0,0 +1,4 @@
+import { MonkeyPatchable } from '../../MonkeyPatchable';
+export declare class MsSqlColumnCompiler extends MonkeyPatchable.MsSqlColumnCompiler {
+    enu(this: any, allowed: unknown[]): string;
+}

package/dialects/mssql/MsSqlColumnCompiler.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsSqlColumnCompiler = void 0;
+const MonkeyPatchable_1 = require("../../MonkeyPatchable");
+class MsSqlColumnCompiler extends MonkeyPatchable_1.MonkeyPatchable.MsSqlColumnCompiler {
+    enu(allowed) {
+        return `nvarchar(100) check (${this.formatter.wrap(this.args[0])} in ('${(allowed.join("', '"))}'))`;
+    }
+}
+exports.MsSqlColumnCompiler = MsSqlColumnCompiler;

package/dialects/mssql/MsSqlKnexDialect.d.ts

@@ -0,0 +1,6 @@
+import { MonkeyPatchable } from '../../MonkeyPatchable';
+export declare class MsSqlKnexDialect extends MonkeyPatchable.MsSqlDialect {
+    tableCompiler(): any;
+    columnCompiler(): any;
+    queryCompiler(): any;
+}

package/dialects/mssql/MsSqlKnexDialect.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsSqlKnexDialect = void 0;
+const MonkeyPatchable_1 = require("../../MonkeyPatchable");
+const MsSqlTableCompiler_1 = require("./MsSqlTableCompiler");
+const MsSqlColumnCompiler_1 = require("./MsSqlColumnCompiler");
+const MsSqlQueryCompiler_1 = require("./MsSqlQueryCompiler");
+class MsSqlKnexDialect extends MonkeyPatchable_1.MonkeyPatchable.MsSqlDialect {
+    tableCompiler() {
+        // eslint-disable-next-line prefer-rest-params
+        return new MsSqlTableCompiler_1.MsSqlTableCompiler(this, ...arguments);
+    }
+    columnCompiler() {
+        // eslint-disable-next-line prefer-rest-params
+        return new MsSqlColumnCompiler_1.MsSqlColumnCompiler(this, ...arguments);
+    }
+    queryCompiler() {
+        // eslint-disable-next-line prefer-rest-params
+        return new MsSqlQueryCompiler_1.MsSqlQueryCompiler(this, ...arguments);
+    }
+}
+exports.MsSqlKnexDialect = MsSqlKnexDialect;

package/dialects/mssql/MsSqlQueryCompiler.d.ts

@@ -0,0 +1,12 @@
+import { MonkeyPatchable } from '../../MonkeyPatchable';
+export declare class MsSqlQueryCompiler extends MonkeyPatchable.MsSqlQueryCompiler {
+    constructor(client: any, builder: any, formatter: any);
+    insert(this: any): any;
+    _mergeAnd(this: any): string;
+    _mergeWhenMatched(this: any, columns: any, updates: any): string;
+    _mergeWhenNotMatched(this: any, columns: any): string;
+    _getParameters(this: any, params: any): any;
+    _mergeInsertIsEmpty(this: any, insert: any): boolean;
+    _mergeOn(this: any, conflict: any): string;
+    _insertWithMerge(this: any): string;
+}

package/dialects/mssql/MsSqlQueryCompiler.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsSqlQueryCompiler = void 0;
+/* istanbul ignore file */
+const MonkeyPatchable_1 = require("../../MonkeyPatchable");
+const core_1 = require("@mikro-orm/core");
+// upsert support from https://github.com/knex/knex/pull/6050
+class MsSqlQueryCompiler extends MonkeyPatchable_1.MonkeyPatchable.MsSqlQueryCompiler {
+    constructor(client, builder, formatter) {
+        const onConflict = builder._single.onConflict;
+        delete builder._single.onConflict;
+        super(client, builder, formatter);
+        this.single.onConflict = onConflict;
+    }
+    // Compiles an "insert" query, allowing for multiple
+    // inserts using a single query statement.
+    insert() {
+        if (this.single.onConflict) {
+            return this._insertWithMerge();
+        }
+        return super.insert();
+    }
+    _mergeAnd() {
+        const wheres = this.where();
+        if (!wheres) {
+            return '';
+        }
+        return `and ${wheres.slice(6)} `;
+    }
+    _mergeWhenMatched(columns, updates) {
+        let columnsData = [];
+        if (!updates || Array.isArray(updates)) {
+            columnsData = columns
+                .map((column) => `${this.formatter.columnize(column)}=tsource.${this.formatter.columnize(column)}`)
+                .join(', ');
+        }
+        if (typeof updates === 'string') {
+            columnsData = `${this.formatter.columnize(updates)}=tsource.${this.formatter.columnize(updates)}`;
+        }
+        if (!Array.isArray(updates) && typeof updates === 'object') {
+            columnsData = Object.entries(updates)
+                .map(([key, value]) => `${this.tableName}.${this.formatter.columnize(key)}=(${this._getParameters([value])})`);
+        }
+        const sql = ` when matched ${this._mergeAnd()}then update set ${columnsData}`;
+        return sql;
+    }
+    _mergeWhenNotMatched(columns) {
+        const destinationColumns = this.formatter.columnize(columns);
+        const sourceColumns = this.formatter.columnizeWithPrefix('tsource.', columns);
+        const sql = ` when not matched then insert (${destinationColumns}) values (${sourceColumns})`;
+        return sql;
+    }
+    _getParameters(params) {
+        const sql = this.client.parameterize(params, this.client.valueForUndefined, this.builder, this.bindingsHolder);
+        return sql;
+    }
+    _mergeInsertIsEmpty(insert) {
+        return (Array.isArray(insert) && insert.length === 0)
+            || (typeof insert === 'object' && core_1.Utils.isEmpty(insert));
+    }
+    _mergeOn(conflict) {
+        let sql = 'on 1=1';
+        if (Array.isArray(conflict)) {
+            const conflictColumn = this.formatter.columnize(conflict[0]);
+            sql = `on ${this.tableName}.${conflictColumn} = tsource.${conflictColumn}`;
+        }
+        return sql;
+    }
+    _insertWithMerge() {
+        const { insert = [], onConflict, ignore, merge, returning, options = {} } = this.single;
+        if (this._mergeInsertIsEmpty(insert)) {
+            return '';
+        }
+        const insertData = this._prepInsert(insert);
+        const insertParameters = insertData.values.map((value) => `(${this._getParameters(value)})`).join(', ');
+        const sourceColumns = this.formatter.columnize(insertData.columns);
+        const returningSql = returning
+            ? ` ${this._returning('insert', returning, options.includeTriggerModifications)}`
+            : '';
+        let sql = `merge into ${this.tableName} using (values ${insertParameters}) as tsource(${sourceColumns}) `;
+        sql += this._mergeOn(onConflict);
+        sql += this._mergeWhenNotMatched(insertData.columns);
+        if (!ignore) {
+            sql += this._mergeWhenMatched(insertData.columns, merge.updates);
+        }
+        sql += returningSql;
+        if (options.includeTriggerModifications) {
+            sql = this._buildTempTable(returning) + sql + this._buildReturningSelect(returning);
+        }
+        sql = this.with() + sql + ';';
+        return sql;
+    }
+}
+exports.MsSqlQueryCompiler = MsSqlQueryCompiler;

package/dialects/mssql/MsSqlTableCompiler.d.ts

@@ -0,0 +1,9 @@
+import { MonkeyPatchable } from '../../MonkeyPatchable';
+export declare class MsSqlTableCompiler extends MonkeyPatchable.MsSqlTableCompiler {
+    lowerCase: boolean;
+    addColumnsPrefix: string;
+    dropColumnPrefix: string;
+    alterColumnPrefix: string;
+    alterColumns(this: any, columns: any, colBuilder: any): void;
+    dropForeign(this: any, columns: any, constraintName: any): void;
+}

package/dialects/mssql/MsSqlTableCompiler.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsSqlTableCompiler = void 0;
+const MonkeyPatchable_1 = require("../../MonkeyPatchable");
+class MsSqlTableCompiler extends MonkeyPatchable_1.MonkeyPatchable.MsSqlTableCompiler {
+    lowerCase = true;
+    addColumnsPrefix = 'add ';
+    dropColumnPrefix = 'drop column ';
+    alterColumnPrefix = 'alter column ';
+    alterColumns(columns, colBuilder) {
+        for (let i = 0, l = colBuilder.length; i < l; i++) {
+            const builder = colBuilder[i];
+            if (builder.modified.defaultTo) {
+                const schema = this.schemaNameRaw || 'dbo';
+                const baseQuery = `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 = '${schema}' and tables.name = '${this.tableNameRaw}' and all_columns.name = '${builder.getColumnName()}')`
+                    + ` if @constraint${i} is not null exec('alter table ${this.tableNameRaw} drop constraint ' + @constraint${i})`;
+                this.pushQuery(baseQuery);
+            }
+        }
+        // in SQL server only one column can be altered at a time
+        columns.sql.forEach((sql) => {
+            this.pushQuery({
+                sql: `alter table ${this.tableName()} ${this.alterColumnPrefix.toLowerCase()}${sql}`,
+                bindings: columns.bindings,
+            });
+        });
+    }
+    dropForeign(columns, constraintName) {
+        constraintName = constraintName
+            ? this.formatter.wrap(constraintName)
+            : this._indexCommand('foreign', this.tableNameRaw, columns);
+        this.pushQuery(`alter table ${this.tableName()} drop constraint ${constraintName}`);
+    }
+}
+exports.MsSqlTableCompiler = MsSqlTableCompiler;

package/dialects/mssql/index.d.ts

@@ -0,0 +1 @@
+export * from './MsSqlKnexDialect';

package/dialects/mssql/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./MsSqlKnexDialect"), exports);

package/index.mjs

@@ -128,6 +128,7 @@ export const MetadataValidator = mod.MetadataValidator;
 export const MikroORM = mod.MikroORM;
 export const MongoNamingStrategy = mod.MongoNamingStrategy;
 export const MonkeyPatchable = mod.MonkeyPatchable;
+export const MsSqlKnexDialect = mod.MsSqlKnexDialect;
 export const NodeState = mod.NodeState;
 export const NonUniqueFieldNameException = mod.NonUniqueFieldNameException;
 export const NotFoundError = mod.NotFoundError;
@@ -146,6 +147,7 @@ export const OptionalProps = mod.OptionalProps;
 export const PlainObject = mod.PlainObject;
 export const Platform = mod.Platform;
 export const PopulateHint = mod.PopulateHint;
+export const PopulatePath = mod.PopulatePath;
 export const PrimaryKey = mod.PrimaryKey;
 export const PrimaryKeyProp = mod.PrimaryKeyProp;
 export const Property = mod.Property;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.1.13-dev.27",
+  "version": "6.1.13-dev.28",
   "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",
@@ -66,6 +66,6 @@
     "@mikro-orm/core": "^6.1.12"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.1.13-dev.27"
+    "@mikro-orm/core": "6.1.13-dev.28"
   }
 }

package/query/QueryBuilder.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { inspect } from 'util';
 import type { Knex } from 'knex';
-import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityName, type EntityProperty, type FlushMode, type GroupOperator, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryResult, type RequiredEntityData } from '@mikro-orm/core';
+import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityName, type EntityProperty, type FlushMode, type GroupOperator, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryOrderMap, type QueryResult, type RequiredEntityData } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
 import { type Alias, QueryBuilderHelper } from './QueryBuilderHelper';
@@ -32,13 +32,12 @@ export interface ExecuteOptions {
  * ```
  */
 export declare class QueryBuilder<T extends object = AnyEntity> {
-    #private;
-    private readonly metadata;
-    private readonly driver;
-    private readonly context?;
-    private connectionType?;
-    private readonly em?;
-    private loggerContext?;
+    protected readonly metadata: MetadataStorage;
+    protected readonly driver: AbstractSqlDriver;
+    protected readonly context?: Knex.Transaction<any, any[]> | undefined;
+    protected connectionType?: ConnectionType | undefined;
+    protected em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection, AbstractSqlPlatform>> | undefined;
+    protected loggerContext?: (LoggingOptions & Dictionary) | undefined;
     get mainAlias(): Alias<T>;
     get alias(): string;
     get helper(): QueryBuilderHelper;
@@ -56,36 +55,47 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     _populateMap: Dictionary<string>;
     /** @internal */
     readonly rawFragments: Set<string>;
-    private aliasCounter;
-    private flags;
-    private finalized;
-    private _joins;
-    private _explicitAlias;
-    private _schema?;
-    private _cond;
-    private _data;
-    private _orderBy;
-    private _groupBy;
-    private _having;
-    private _returning?;
-    private _onConflict?;
-    private _limit?;
-    private _offset?;
-    private _distinctOn?;
-    private _joinedProps;
-    private _cache?;
-    private _indexHint?;
-    private _comments;
-    private _hintComments;
-    private flushMode?;
-    private lockMode?;
-    private lockTables?;
-    private subQueries;
-    private _mainAlias?;
-    private _aliases;
-    private _helper?;
-    private readonly platform;
-    private readonly knex;
+    protected aliasCounter: number;
+    protected flags: Set<QueryFlag>;
+    protected finalized: boolean;
+    protected _joins: Dictionary<JoinOptions>;
+    protected _explicitAlias: boolean;
+    protected _schema?: string;
+    protected _cond: Dictionary;
+    protected _data: Dictionary;
+    protected _orderBy: QueryOrderMap<T>[];
+    protected _groupBy: Field<T>[];
+    protected _having: Dictionary;
+    protected _returning?: Field<T>[];
+    protected _onConflict?: {
+        fields: string[];
+        ignore?: boolean;
+        merge?: EntityData<T> | Field<T>[];
+        where?: QBFilterQuery<T>;
+    }[];
+    protected _limit?: number;
+    protected _offset?: number;
+    protected _distinctOn?: string[];
+    protected _joinedProps: Map<string, PopulateOptions<any>>;
+    protected _cache?: boolean | number | [string, number];
+    protected _indexHint?: string;
+    protected _comments: string[];
+    protected _hintComments: string[];
+    protected flushMode?: FlushMode;
+    protected lockMode?: LockMode;
+    protected lockTables?: string[];
+    protected subQueries: Dictionary<string>;
+    protected _mainAlias?: Alias<T>;
+    protected _aliases: Dictionary<Alias<any>>;
+    protected _helper?: QueryBuilderHelper;
+    protected _query?: {
+        sql?: string;
+        _sql?: Knex.Sql;
+        params?: readonly unknown[];
+        qb: Knex.QueryBuilder<T>;
+    };
+    protected readonly platform: AbstractSqlPlatform;
+    protected readonly knex: Knex;
     /**
      * @internal
      */

package/query/QueryBuilder.js

@@ -85,6 +85,7 @@ class QueryBuilder {
     _mainAlias;
     _aliases = {};
     _helper;
+    _query;
     platform;
     knex;
     /**
@@ -459,10 +460,10 @@ class QueryBuilder {
         return this;
     }
     getKnexQuery(processVirtualEntity = true) {
-        if (this.#query) {
-            return this.#query.qb;
+        if (this._query?.qb) {
+            return this._query.qb;
         }
-        this.#query = {};
+        this._query = {};
         this.finalize();
         const qb = this.getQueryBase(processVirtualEntity);
         const type = this.type ?? enums_1.QueryType.SELECT;
@@ -484,14 +485,14 @@ class QueryBuilder {
         core_1.Utils.runIfNotEmpty(() => this._hintComments.forEach(comment => qb.hintComment(comment)), this._hintComments);
         core_1.Utils.runIfNotEmpty(() => this.helper.appendOnConflictClause(type, this._onConflict, qb), this._onConflict);
         if (this.type === enums_1.QueryType.TRUNCATE && this.platform.usesCascadeStatement()) {
-            return this.#query.qb = this.knex.raw(qb.toSQL().toNative().sql + ' cascade');
+            return this._query.qb = this.knex.raw(qb.toSQL().toNative().sql + ' cascade');
         }
         if (this.lockMode) {
             this.helper.getLockSQL(qb, this.lockMode, this.lockTables);
         }
         this.helper.finalize(type, qb, this.mainAlias.metadata, this._data, this._returning);
         this.clearRawFragmentsCache();
-        return this.#query.qb = qb;
+        return this._query.qb = qb;
     }
     /**
      * @internal
@@ -506,17 +507,16 @@ class QueryBuilder {
     getQuery() {
         return this.toQuery().sql;
     }
-    #query;
     toQuery() {
-        if (this.#query?.sql) {
-            return { sql: this.#query.sql, _sql: this.#query._sql, params: this.#query.params };
+        if (this._query?.sql) {
+            return { sql: this._query.sql, _sql: this._query._sql, params: this._query.params };
         }
         const sql = this.getKnexQuery().toSQL();
         const query = sql.toNative();
-        this.#query.sql = query.sql;
-        this.#query._sql = sql;
-        this.#query.params = query.bindings ?? [];
-        return { sql: this.#query.sql, _sql: this.#query._sql, params: this.#query.params };
+        this._query.sql = query.sql;
+        this._query._sql = sql;
+        this._query.params = query.bindings ?? [];
+        return { sql: this._query.sql, _sql: this._query._sql, params: this._query.params };
     }
     /**
      * Returns the list of all parameters for this query.

package/query/QueryBuilderHelper.js

@@ -518,7 +518,8 @@ class QueryBuilderHelper {
         return ret;
     }
     finalize(type, qb, meta, data, returning) {
-        if (!meta || !data || !this.platform.usesReturningStatement()) {
+        const usesReturningStatement = this.platform.usesReturningStatement() || this.platform.usesOutputStatement();
+        if (!meta || !data || !usesReturningStatement) {
             return;
         }
         // always respect explicit returning hint

package/schema/DatabaseTable.js

@@ -79,6 +79,9 @@ class DatabaseTable {
                     prop.length ??= this.platform.getDefaultDateTimeLength();
                 }
             }
+            if (prop.length == null && prop.columnTypes[idx]) {
+                prop.length = this.platform.getSchemaHelper().inferLengthFromColumnType(prop.columnTypes[idx]);
+            }
             const primary = !meta.compositePK && !!prop.primary && prop.kind === core_1.ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType);
             this.columns[field] = {
                 name: prop.fieldNames[idx],
@@ -120,9 +123,19 @@ class DatabaseTable {
             if (prop.deleteRule || cascade || prop.nullable) {
                 this.foreignKeys[constraintName].deleteRule = prop.deleteRule || (cascade ? 'cascade' : 'set null');
             }
-            if (prop.updateRule || prop.cascade.includes(core_1.Cascade.PERSIST) || prop.cascade.includes(core_1.Cascade.ALL)) {
+            if (prop.updateRule) {
                 this.foreignKeys[constraintName].updateRule = prop.updateRule || 'cascade';
             }
+            if ((prop.cascade.includes(core_1.Cascade.PERSIST) || prop.cascade.includes(core_1.Cascade.ALL))) {
+                const hasCascadePath = Object.values(this.foreignKeys).some(fk => {
+                    return fk.constraintName !== constraintName
+                        && ((fk.updateRule && fk.updateRule !== 'no action') || (fk.deleteRule && fk.deleteRule !== 'no action'))
+                        && fk.referencedTableName === this.foreignKeys[constraintName].referencedTableName;
+                });
+                if (!hasCascadePath || this.platform.supportsMultipleCascadePaths()) {
+                    this.foreignKeys[constraintName].updateRule ??= 'cascade';
+                }
+            }
             if (prop.deferMode) {
                 this.foreignKeys[constraintName].deferMode = prop.deferMode;
             }
@@ -589,7 +602,7 @@ class DatabaseTable {
             // The enum name will be a concatenation of the table name and the column name.
             return namingStrategy.getClassName(this.name + '_' + column.name, '_');
         }
-        return column.mappedType?.compareAsType() ?? 'unknown';
+        return column.mappedType?.runtimeType ?? 'unknown';
     }
     getPropertyDefaultValue(schemaHelper, column, propType, raw = false) {
         const empty = raw ? 'null' : undefined;

package/schema/SchemaComparator.js

@@ -358,6 +358,9 @@ class SchemaComparator {
         if (key1.deferMode !== key2.deferMode) {
             return true;
         }
+        if (key1.localTableName === key1.referencedTableName && !this.platform.supportsMultipleCascadePaths()) {
+            return false;
+        }
         const defaultRule = ['restrict', 'no action'];
         const rule = (key, method) => {
             return (key[method] ?? defaultRule[0]).toLowerCase().replace(defaultRule[1], defaultRule[0]);
@@ -383,8 +386,8 @@ class SchemaComparator {
             }
         };
         if (fromColumnType !== toColumnType &&
-            !(fromColumn.ignoreSchemaChanges?.includes('type') ||
-                toColumn.ignoreSchemaChanges?.includes('type'))) {
+            !(fromColumn.ignoreSchemaChanges?.includes('type') || toColumn.ignoreSchemaChanges?.includes('type')) &&
+            !fromColumn.generated && !toColumn.generated) {
             log(`'type' changed for column ${tableName}.${fromColumn.name}`, { fromColumnType, toColumnType });
             changedProperties.add('type');
         }

package/schema/SchemaHelper.d.ts

@@ -15,6 +15,7 @@ export declare abstract class SchemaHelper {
     finalizeTable(table: Knex.TableBuilder, charset: string, collate?: string): void;
     supportsSchemaConstraints(): boolean;
     getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[] | undefined, tableName: string, schemaName?: string): Promise<string[]>;
+    inferLengthFromColumnType(type: string): number | undefined;
     getForeignKeys(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Dictionary>;
     protected getTableKey(t: Table): string;
     getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
@@ -46,6 +47,8 @@ export declare abstract class SchemaHelper {
     normalizeDefaultValue(defaultValue: string, length?: number, defaultValues?: Dictionary<string[]>): string | number;
     getCreateDatabaseSQL(name: string): string;
     getDropDatabaseSQL(name: string): string;
+    getCreateNamespaceSQL(name: string): string;
+    getDropNamespaceSQL(name: string): string;
     getDatabaseExistsSQL(name: string): string;
     getDatabaseNotExistsError(dbName: string): string;
     getManagementDbName(): string;

package/schema/SchemaHelper.js

@@ -29,6 +29,9 @@ class SchemaHelper {
         const pks = indexes.filter(i => i.primary).map(pk => pk.columnNames);
         return core_1.Utils.flatten(pks);
     }
+    inferLengthFromColumnType(type) {
+        return undefined;
+    }
     async getForeignKeys(connection, tableName, schemaName) {
         const fks = await connection.execute(this.getForeignKeysSQL(tableName, schemaName));
         return this.mapForeignKeys(fks, tableName, schemaName);
@@ -232,6 +235,14 @@ class SchemaHelper {
     getDropDatabaseSQL(name) {
         return `drop database if exists ${this.platform.quoteIdentifier(name)}`;
     }
+    /* istanbul ignore next */
+    getCreateNamespaceSQL(name) {
+        return `create schema if not exists ${this.platform.quoteIdentifier(name)}`;
+    }
+    /* istanbul ignore next */
+    getDropNamespaceSQL(name) {
+        return `drop schema if exists ${this.platform.quoteIdentifier(name)}`;
+    }
     getDatabaseExistsSQL(name) {
         return `select 1 from information_schema.schemata where schema_name = '${name}'`;
     }

package/schema/SqlSchemaGenerator.d.ts

@@ -3,8 +3,13 @@ import type { SchemaDifference } from '../typings';
 import { DatabaseSchema } from './DatabaseSchema';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
 export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<AbstractSqlDriver> implements ISchemaGenerator {
-    private readonly helper;
-    private readonly options;
+    protected readonly helper: import("./SchemaHelper").SchemaHelper;
+    protected readonly options: {
+        disableForeignKeys?: boolean | undefined;
+        createForeignKeyConstraints?: boolean | undefined;
+        ignoreSchema?: string[] | undefined;
+        managementDbName?: string | undefined;
+    };
     protected lastEnsuredDatabase?: string;
     static register(orm: MikroORM): void;
     createSchema(options?: CreateSchemaOptions): Promise<void>;
@@ -15,6 +20,8 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     getTargetSchema(schema?: string): DatabaseSchema;
     getCreateSchemaSQL(options?: CreateSchemaOptions): Promise<string>;
     dropSchema(options?: DropSchemaOptions): Promise<void>;
+    createNamespace(name: string): Promise<void>;
+    dropNamespace(name: string): Promise<void>;
     clearDatabase(options?: ClearDatabaseOptions): Promise<void>;
     getDropSchemaSQL(options?: Omit<DropSchemaOptions, 'dropDb'>): Promise<string>;
     private getSchemaName;

package/schema/SqlSchemaGenerator.js

@@ -58,7 +58,8 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
             if (namespace === this.platform.getDefaultSchemaName()) {
                 continue;
             }
-            ret += await this.dump(this.knex.schema.createSchemaIfNotExists(namespace));
+            const sql = this.helper.getCreateNamespaceSQL(namespace);
+            ret += await this.dump(this.knex.schema.raw(sql), '\n');
         }
         if (this.platform.supportsNativeEnums()) {
             const created = [];
@@ -88,6 +89,14 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         const sql = await this.getDropSchemaSQL(options);
         await this.execute(sql);
     }
+    async createNamespace(name) {
+        const sql = await this.helper.getCreateNamespaceSQL(name);
+        await this.execute(sql);
+    }
+    async dropNamespace(name) {
+        const sql = await this.helper.getDropNamespaceSQL(name);
+        await this.execute(sql);
+    }
     async clearDatabase(options) {
         // truncate by default, so no value is considered as true
         /* istanbul ignore if */
@@ -101,12 +110,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 .truncate();
         }
         await this.execute(this.helper.enableForeignKeysSQL());
-        if (this.em) {
-            const allowGlobalContext = this.config.get('allowGlobalContext');
-            this.config.set('allowGlobalContext', true);
-            this.em.clear();
-            this.config.set('allowGlobalContext', allowGlobalContext);
-        }
+        this.clearIdentityMap();
     }
     async getDropSchemaSQL(options = {}) {
         await this.ensureDatabase();
@@ -186,8 +190,8 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         let ret = '';
         if (this.platform.supportsSchemas()) {
             for (const newNamespace of schemaDiff.newNamespaces) {
-                // schema might already exist, e.g. explicit usage of `public` in postgres
-                ret += await this.dump(this.knex.schema.createSchemaIfNotExists(newNamespace));
+                const sql = this.helper.getCreateNamespaceSQL(newNamespace);
+                ret += await this.dump(this.knex.schema.raw(sql), '\n');
             }
         }
         if (this.platform.supportsNativeEnums()) {
@@ -240,7 +244,8 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         }
         if (options.dropTables && !options.safe) {
             for (const removedNamespace of schemaDiff.removedNamespaces) {
-                ret += await this.dump(this.knex.schema.dropSchema(removedNamespace));
+                const sql = this.helper.getDropNamespaceSQL(removedNamespace);
+                ret += await this.dump(this.knex.schema.raw(sql), '\n');
             }
         }
         return this.wrapSchema(ret, options);
@@ -266,11 +271,13 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
             .references(foreignKey.referencedColumnNames)
             .inTable(this.getReferencedTableName(foreignKey.referencedTableName, schema))
             .withKeyName(foreignKey.constraintName);
-        if (foreignKey.updateRule) {
-            builder.onUpdate(foreignKey.updateRule);
-        }
-        if (foreignKey.deleteRule) {
-            builder.onDelete(foreignKey.deleteRule);
+        if (foreignKey.localTableName !== foreignKey.referencedTableName || this.platform.supportsMultipleCascadePaths()) {
+            if (foreignKey.updateRule) {
+                builder.onUpdate(foreignKey.updateRule);
+            }
+            if (foreignKey.deleteRule) {
+                builder.onDelete(foreignKey.deleteRule);
+            }
         }
         if (foreignKey.deferMode) {
             builder.deferrable(foreignKey.deferMode);