@mikro-orm/mssql 7.2.2-dev.1 → 7.2.2-dev.3

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.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,20 @@ 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;
+        });
     }
     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 +65,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,8 @@
-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 checkIdentityInsert;
 }

package/MsSqlQueryBuilder.js

@@ -4,18 +4,24 @@ import { QueryBuilder } from '@mikro-orm/sql';
 export class MsSqlQueryBuilder extends QueryBuilder {
     insert(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);
+    }
     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.1",
+  "version": "7.2.2-dev.3",
   "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.1",
+    "@mikro-orm/sql": "7.2.2-dev.3",
     "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.1"
+    "@mikro-orm/core": "7.2.2-dev.3"
   },
   "engines": {
     "node": ">= 22.17.0"