@mikro-orm/mssql 7.2.2-dev.2 → 7.2.2-dev.21

package/MsSqlConnection.js

@@ -143,19 +143,22 @@ export class MsSqlConnection extends AbstractSqlConnection {
         return super.commit(ctx, eventBroadcaster);
     }
     transformRawResult(res, method) {
+        const lastRow = res.rows.at(-1);
+        const hasOutputCount = lastRow && '__mikro_orm_row_count__' in lastRow && Object.keys(lastRow).length === 1;
+        const outputRows = hasOutputCount ? res.rows.slice(0, -1) : res.rows;
         if (method === 'get') {
-            return res.rows[0];
+            return outputRows[0];
         }
         if (method === 'all') {
-            return res.rows;
+            return outputRows;
         }
-        const rowCount = res.rows.length;
-        const hasEmptyCount = rowCount === 1 && '' in res.rows[0];
-        const emptyRow = hasEmptyCount && Number(res.rows[0]['']);
+        const hasEmptyCount = lastRow && Object.keys(lastRow).length === 1 && '' in lastRow;
+        const count = hasOutputCount ? lastRow.__mikro_orm_row_count__ : hasEmptyCount ? lastRow[''] : res.numAffectedRows;
+        const rows = hasEmptyCount ? outputRows.slice(0, -1) : outputRows;
         return {
-            affectedRows: hasEmptyCount ? emptyRow : Number(res.numAffectedRows),
-            row: res.rows[0],
-            rows: res.rows,
+            affectedRows: Number(count),
+            row: rows[0],
+            rows,
         };
     }
 }

package/MsSqlDriver.d.ts

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

package/MsSqlDriver.js

@@ -19,14 +19,17 @@ export class MsSqlDriver extends AbstractSqlDriver {
         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 returningProps = this.getTableProps(meta).filter(prop => prop.returning || prop.primary || prop.defaultRaw);
             const returningFields = Utils.flatten(returningProps.map(prop => prop.fieldNames));
             const using2 = `select * from (values ${data.map((x, i) => `(${i})`).join(',')}) v (id) where 1 = 1`;
             /* v8 ignore next */
             const output = returningFields.length > 0
                 ? `output ${returningFields.map(field => 'inserted.' + this.platform.quoteIdentifier(field)).join(', ')}`
                 : '';
-            const sql = `merge into ${tableName} using (${using2}) s on 1 = 0 when not matched then insert default values ${output};`;
+            let sql = `merge into ${tableName} using (${using2}) s on 1 = 0 when not matched then insert default values ${output};`;
+            if (meta.hasTriggers) {
+                sql = this.appendOutputTable(entityName, returningFields, sql, sql.length - 1, options);
+            }
             const res = await this.execute(sql, [], 'run', options.ctx);
             const pks = this.getPrimaryKeyFields(meta);
             if (pks.length === 1) {
@@ -36,13 +39,30 @@ export class MsSqlDriver extends AbstractSqlDriver {
             }
             return res;
         }
-        // For TPT child entities, the parent table owns the identity column, not the child table
-        if (props.some(prop => prop.autoincrement && (!meta.ownProps || meta.ownProps.includes(prop)))) {
-            return super.nativeInsertMany(entityName, data, options, sql => {
-                return `set identity_insert ${tableName} on; ${sql}; set identity_insert ${tableName} off`;
-            });
-        }
-        return super.nativeInsertMany(entityName, data, options, sql => meta.hasTriggers ? this.appendOutputTable(entityName, data, sql) : sql);
+        return super.nativeInsertMany(entityName, data, options, sql => {
+            if (meta.hasTriggers) {
+                // must match the OUTPUT columns of the parent implementation, which resolves STI children to the root
+                const returning = this.getTableProps(meta.inheritanceType === 'tpt' ? meta : meta.root).filter(prop => prop.returning ||
+                    (((prop.persist !== false && prop.defaultRaw) || prop.autoincrement || prop.generated) &&
+                        (!(prop.name in data[0]) || isRaw(data[0][prop.name]))));
+                sql = this.appendOutputTable(entityName, returning.flatMap(p => p.fieldNames), sql, sql.indexOf(' values '), options);
+            }
+            // For TPT children, the parent table owns the identity column.
+            if (props.some(prop => prop.autoincrement && (!meta.ownProps || meta.ownProps.includes(prop)))) {
+                sql = `set identity_insert ${tableName} on; ${sql}; set identity_insert ${tableName} off`;
+            }
+            return sql;
+        });
+    }
+    async nativeUpdateMany(entityName, where, data, options = {}) {
+        const meta = this.metadata.get(entityName);
+        return super.nativeUpdateMany(entityName, where, data, options, sql => {
+            if (!meta.hasTriggers) {
+                return sql;
+            }
+            const fields = this.getUpdateReturningProperties(meta, data).flatMap(prop => prop.fieldNames);
+            return this.appendOutputTable(entityName, fields, sql, sql.lastIndexOf(' where '), 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
@@ -55,24 +75,19 @@ export class MsSqlDriver extends AbstractSqlDriver {
         }
         return qb;
     }
-    appendOutputTable(entityName, data, sql) {
+    appendOutputTable(entityName, returningFields, sql, position, options) {
         const meta = this.metadata.get(entityName);
-        const returningProps = meta.props
-            .filter(prop => (prop.persist !== false && prop.defaultRaw) || prop.autoincrement || prop.generated)
-            .filter(prop => !(prop.name in data[0]) || isRaw(data[0][prop.name]));
-        const returningFields = Utils.flatten(returningProps.map(prop => prop.fieldNames));
         /* v8 ignore next */
         if (returningFields.length === 0) {
             return sql;
         }
-        const tableName = this.getTableName(meta, {}, true);
+        const tableName = this.getTableName(meta, options, true);
         const selections = returningFields.map((field) => `[t].${this.platform.quoteIdentifier(field)}`).join(',');
-        const position = sql.indexOf(' values ');
         const sqlBeforeValues = sql.substring(0, position);
-        const sqlAfterValues = sql.substring(position + 1);
+        const sqlAfterValues = sql.substring(position);
         let outputSql = `select top(0) ${selections} into #out from ${tableName} as t left join ${tableName} on 0 = 1; `;
-        outputSql += `${sqlBeforeValues} into #out ${sqlAfterValues}; `;
-        outputSql += `select ${selections} from #out as t; `;
+        outputSql += `${sqlBeforeValues} into #out${sqlAfterValues}; `;
+        outputSql += `select ${selections} from #out as t; select @@rowcount as [__mikro_orm_row_count__]; `;
         outputSql += `drop table #out`;
         return outputSql;
     }

package/MsSqlQueryBuilder.d.ts

@@ -1,7 +1,9 @@
-import { type AnyEntity, type RequiredEntityData } from '@mikro-orm/core';
-import { type InsertQueryBuilder, QueryBuilder } from '@mikro-orm/sql';
+import { type AnyEntity, type EntityData, type RequiredEntityData } from '@mikro-orm/core';
+import { type InsertQueryBuilder, type UpdateQueryBuilder, QueryBuilder } from '@mikro-orm/sql';
 /** Query builder with MSSQL-specific behavior such as identity insert handling. */
 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, RootAlias, Context>;
+    update(data: EntityData<Entity>): UpdateQueryBuilder<Entity, RootAlias, Context>;
+    private applyInsertDefaults;
     private checkIdentityInsert;
 }

package/MsSqlQueryBuilder.js

@@ -1,21 +1,54 @@
-import { QueryFlag, Utils } from '@mikro-orm/core';
+import { QueryFlag, Utils, raw } from '@mikro-orm/core';
 import { QueryBuilder } from '@mikro-orm/sql';
 /** Query builder with MSSQL-specific behavior such as identity insert handling. */
 export class MsSqlQueryBuilder extends QueryBuilder {
     insert(data) {
+        data = this.applyInsertDefaults(data);
         this.checkIdentityInsert(data);
-        if (!this.hasFlag(QueryFlag.IDENTITY_INSERT) && this.metadata.has(this.mainAlias.entityName)) {
-            const meta = this.mainAlias.meta;
-            if (meta.hasTriggers) {
-                this.setFlag(QueryFlag.OUTPUT_TABLE);
-            }
+        if (this.mainAlias.meta?.hasTriggers) {
+            this.setFlag(QueryFlag.OUTPUT_TABLE);
         }
         return super.insert(data);
     }
+    update(data) {
+        if (this.mainAlias.meta?.hasTriggers) {
+            this.setFlag(QueryFlag.OUTPUT_TABLE);
+        }
+        return super.update(data);
+    }
+    applyInsertDefaults(data) {
+        if (!Array.isArray(data) || data.length < 2) {
+            return data;
+        }
+        const meta = this.mainAlias.meta;
+        const keys = Utils.unique(data.flatMap(row => Utils.keys(row))).filter(key => meta.properties[key]?.defaultRaw);
+        if (keys.length === 0) {
+            return data;
+        }
+        const schemaHelper = this.platform.getSchemaHelper();
+        // MERGE uses a derived VALUES table, where DEFAULT is not allowed.
+        return data.map(row => {
+            let copy = row;
+            for (const key of keys) {
+                if (row[key] === undefined) {
+                    if (copy === row) {
+                        copy = { ...row };
+                    }
+                    const prop = meta.properties[key];
+                    // same normalization as the DDL, e.g. `true` is not a valid MSSQL literal
+                    copy[key] = raw(`${schemaHelper.normalizeDefaultValue(prop.defaultRaw, prop.length)}`);
+                }
+            }
+            return copy;
+        });
+    }
     checkIdentityInsert(data) {
         const meta = this.mainAlias.meta;
         const dataKeys = Utils.unique(Utils.asArray(data).flatMap(d => Utils.keys(d)));
-        const hasAutoincrement = dataKeys.some(x => meta.properties[x]?.autoincrement);
+        const hasAutoincrement = dataKeys.some(x => {
+            const prop = meta.properties[x];
+            return prop?.autoincrement && (!meta.ownProps || meta.ownProps.includes(prop));
+        });
         if (hasAutoincrement) {
             this.setFlag(QueryFlag.IDENTITY_INSERT);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/mssql",
-  "version": "7.2.2-dev.2",
+  "version": "7.2.2-dev.21",
   "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.",
   "keywords": [
     "data-mapper",
@@ -47,7 +47,7 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "@mikro-orm/sql": "7.2.2-dev.2",
+    "@mikro-orm/sql": "7.2.2-dev.21",
     "kysely": "0.29.6",
     "tarn": "3.1.2",
     "tedious": "20.0.0",
@@ -57,7 +57,7 @@
     "@mikro-orm/core": "^7.2.1"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.2.2-dev.2"
+    "@mikro-orm/core": "7.2.2-dev.21"
   },
   "engines": {
     "node": ">= 22.17.0"