@mikro-orm/sql 7.2.2-dev.1 → 7.2.2-dev.11

package/AbstractSqlDriver.d.ts

@@ -17,7 +17,11 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     /** Evaluates a formula callback, handling both string and Raw return values. */
     evaluateFormula(formula: (...args: any[]) => string | Raw, columns: any, table: FormulaTable): string;
     /** For TPT entities, returns ownProps (columns in this table); otherwise returns all props. */
-    private getTableProps;
+    protected getTableProps<T extends object>(meta: EntityMetadata<T>): EntityProperty<T>[];
+    /** Columns reloaded by UPDATE: raw values, PKs, generated/version columns and explicit `returning` hints. */
+    protected getUpdateReturningProperties<T extends object>(meta: EntityMetadata<T>, data: EntityDictionary<T>[]): EntityProperty<T>[];
+    /** Column expression for the `returning` clause of batch updates, applying `convertToJSValueSQL` of custom types. */
+    protected getReturningFieldSQL(prop: EntityProperty, fieldName: string, index: number): string;
     /** Creates a FormulaTable object for use in formula callbacks. */
     private createFormulaTable;
     private validateSqlOptions;

package/AbstractSqlDriver.js

@@ -49,6 +49,32 @@ export class AbstractSqlDriver extends DatabaseDriver {
     getTableProps(meta) {
         return meta.inheritanceType === 'tpt' && meta.ownProps ? meta.ownProps : meta.props;
     }
+    /** Columns reloaded by UPDATE: raw values, PKs, generated/version columns and explicit `returning` hints. */
+    getUpdateReturningProperties(meta, data) {
+        const returning = new Set();
+        for (const row of data) {
+            for (const k of Utils.keys(row)) {
+                if (isRaw(row[k])) {
+                    returning.add(meta.properties[k] ?? meta.root.properties[k]);
+                }
+            }
+        }
+        meta.getPrimaryProps().forEach(prop => returning.add(prop));
+        // a mixed STI batch shares one table, so the child columns live on the root
+        this.getTableProps(meta.root.discriminatorColumn ? meta.root : meta)
+            .filter(prop => prop.generated || prop.version || prop.returning)
+            .forEach(prop => returning.add(prop));
+        return [...returning];
+    }
+    /** Column expression for the `returning` clause of batch updates, applying `convertToJSValueSQL` of custom types. */
+    getReturningFieldSQL(prop, fieldName, index) {
+        const quoted = this.platform.quoteIdentifier(fieldName);
+        const customType = prop.customTypes?.[index] ?? prop.customType;
+        if (prop.hasConvertToJSValueSQL && customType?.convertToJSValueSQL) {
+            return `${customType.convertToJSValueSQL(quoted, this.platform)} as ${quoted}`;
+        }
+        return quoted;
+    }
     /** Creates a FormulaTable object for use in formula callbacks. */
     createFormulaTable(alias, meta, schema) {
         const effectiveSchema = schema ?? (meta.schema !== '*' ? meta.schema : undefined);
@@ -946,7 +972,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 /* v8 ignore next */
                 const uniqueFields = options.onConflictFields ??
                     (Utils.isPlainObject(where) ? Utils.keys(where) : meta.primaryKeys);
-                const returning = getOnConflictReturningFields(meta, data, uniqueFields, options);
+                const returning = getOnConflictReturningFields(meta, data, uniqueFields, options, this.platform);
                 qb.insert(data)
                     .onConflict(uniqueFields)
                     .returning(returning);
@@ -963,11 +989,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             else {
                 qb.update(data).where(where);
-                // reload generated columns and version fields
                 const returning = [];
                 this.getTableProps(meta)
-                    .filter(prop => (prop.generated && !prop.primary) || prop.version)
-                    .forEach(prop => returning.push(prop.name));
+                    .filter(prop => (prop.generated && !prop.primary) || prop.version || prop.returning || isRaw(data[prop.name]))
+                    .forEach(prop => returning.push(...prop.fieldNames));
                 qb.returning(returning);
             }
             res = await this.rethrow(qb.execute('run', false));
@@ -1003,7 +1028,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     : meta.primaryKeys);
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
             qb.setAbortOptions(pickAbortOptions(options));
-            let returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options);
+            let returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options, this.platform);
             if (meta.inheritanceType === 'tpt') {
                 // each TPT table only carries its own columns, the entity is reloaded instead of mapping the returned rows
                 const own = (key) => meta.primaryKeys.includes(key) ||
@@ -1032,20 +1057,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const collections = options.processCollections ? data.map(d => this.extractManyToMany(meta, d)) : [];
         const keys = new Set();
         const fields = new Set();
-        const returning = new Set();
+        const returning = this.getUpdateReturningProperties(meta, data);
         for (const row of data) {
             for (const k of Utils.keys(row)) {
                 keys.add(k);
-                if (isRaw(row[k])) {
-                    returning.add(k);
-                }
             }
         }
-        // reload generated columns and version fields
-        meta.getPrimaryProps().forEach(prop => returning.add(prop.name));
-        this.getTableProps(meta)
-            .filter(prop => prop.generated || prop.version)
-            .forEach(prop => returning.add(prop.name));
         const pkCond = Utils.flatten(meta.primaryKeys.map(pk => meta.properties[pk].fieldNames))
             .map(pk => `${this.platform.quoteIdentifier(pk)} = ?`)
             .join(' and ');
@@ -1115,7 +1132,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             sql += `, `;
         }
-        sql = sql.substring(0, sql.length - 2) + ' where ';
+        sql = sql.substring(0, sql.length - 2);
+        if (this.platform.usesOutputStatement() && returning.length > 0) {
+            const fields = returning.flatMap(prop => prop.fieldNames);
+            sql += ` output ${fields.map(field => 'inserted.' + this.platform.quoteIdentifier(field)).join(', ')}`;
+        }
+        sql += ' where ';
         const pkProps = meta.primaryKeys.concat(...meta.getOwnConcurrencyCheckKeys());
         const pks = Utils.flatten(pkProps.map(pk => meta.properties[pk].fieldNames));
         const useTupleIn = pks.length <= 1 || this.platform.allowsComparingTuples();
@@ -1151,13 +1173,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
         else {
             sql += conds.join(' or ');
         }
-        if (this.platform.usesReturningStatement() && returning.size > 0) {
-            const returningFields = Utils.flatten([...returning].map(prop => (meta.properties[prop] ?? meta.root.properties[prop]).fieldNames));
-            /* v8 ignore next */
-            sql +=
-                returningFields.length > 0
-                    ? ` returning ${returningFields.map(field => this.platform.quoteIdentifier(field)).join(', ')}`
-                    : '';
+        if (this.platform.usesReturningStatement() && returning.length > 0) {
+            const returningFields = returning.flatMap(prop => prop.fieldNames.map((field, idx) => this.getReturningFieldSQL(prop, field, idx)));
+            sql += ` returning ${returningFields.join(', ')}`;
         }
         if (transform) {
             sql = transform(sql, params);

package/dialects/mssql/MsSqlNativeQueryBuilder.d.ts

@@ -6,6 +6,7 @@ export declare class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
         params: unknown[];
     };
     protected compileInsert(): void;
+    protected addOutputClause(type: 'inserted' | 'deleted'): void;
     private appendOutputTable;
     private compileUpsert;
     protected compileSelect(): void;

package/dialects/mssql/MsSqlNativeQueryBuilder.js

@@ -22,6 +22,9 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
         this.compileCtes();
         if (this.options.onConflict && !Utils.isEmpty(Utils.asArray(this.options.data)[0])) {
             this.compileUpsert();
+            if (suffix) {
+                this.parts.push(suffix);
+            }
         }
         else {
             switch (this.type) {
@@ -72,31 +75,34 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
             return;
         }
         const parts = this.processInsertData();
-        if (this.options.flags?.has(QueryFlag.OUTPUT_TABLE)) {
-            this.parts[this.parts.length - 2] += ' into #out ';
-        }
         this.parts.push(parts.join(', '));
     }
+    addOutputClause(type) {
+        super.addOutputClause(type);
+        if (this.options.returning?.length && this.options.flags?.has(QueryFlag.OUTPUT_TABLE)) {
+            this.parts[this.parts.length - 1] += ' into #out';
+        }
+    }
     appendOutputTable() {
-        if (!this.options.flags?.has(QueryFlag.OUTPUT_TABLE)) {
+        if (!this.options.flags?.has(QueryFlag.OUTPUT_TABLE) || !this.options.returning?.length) {
             return { prefix: '', suffix: '' };
         }
         const returningFields = this.options.returning;
         const selections = returningFields.map(field => `[t].${this.platform.quoteIdentifier(field)}`).join(',');
         return {
             prefix: `select top(0) ${selections} into #out from ${this.getTableName()} as t left join ${this.getTableName()} on 0 = 1;`,
-            suffix: `select ${selections} from #out as t; drop table #out`,
+            suffix: `select ${selections} from #out as t; select @@rowcount as [__mikro_orm_row_count__]; drop table #out`,
         };
     }
     compileUpsert() {
         const clause = this.options.onConflict;
         const dataAsArray = Utils.asArray(this.options.data);
-        const keys = Object.keys(dataAsArray[0]);
+        const keys = [...new Set(dataAsArray.flatMap(data => Object.keys(data)))];
         const values = keys.map(() => '?');
         const parts = [];
         for (const data of dataAsArray) {
             for (const key of keys) {
-                this.params.push(data[key]);
+                this.params.push(data[key] ?? null);
             }
             parts.push(`(${values.join(', ')})`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.2.2-dev.1",
+  "version": "7.2.2-dev.11",
   "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",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.2.1"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.2.2-dev.1"
+    "@mikro-orm/core": "7.2.2-dev.11"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/QueryBuilder.js

@@ -916,18 +916,13 @@ export class QueryBuilder {
             return;
         }
         if (this.type === QueryType.UPDATE && data) {
-            const returningProps = meta.hydrateProps.filter(prop => prop.fieldNames && isRaw(data[prop.fieldNames[0]]));
+            const returningProps = meta.hydrateProps
+                .filter(prop => prop.returning || (prop.fieldNames && isRaw(data[prop.fieldNames[0]])))
+                // a TPT table can only return its own columns
+                .filter(prop => meta.inheritanceType !== 'tpt' || prop.primary || meta.ownProps.some(p => p.name === prop.name));
             if (returningProps.length > 0) {
-                qb.returning(returningProps.flatMap((prop) => {
-                    if (prop.hasConvertToJSValueSQL) {
-                        const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
-                        const sql = prop.customType.convertToJSValueSQL(aliased, this.platform) +
-                            ' as ' +
-                            this.platform.quoteIdentifier(prop.fieldNames[0]);
-                        return [raw(sql)];
-                    }
-                    return prop.fieldNames;
-                }));
+                const fields = returningProps.flatMap(prop => prop.fieldNames);
+                qb.returning(fields.map(field => this.helper.mapper(field, this.type)));
             }
         }
     }
@@ -2010,9 +2005,11 @@ export class QueryBuilder {
             }))
                 .forEach(field => this.#state.fields.push(raw(field)));
         }
-        QueryHelper.processObjectParams(this.#state.data);
-        QueryHelper.processObjectParams(this.#state.cond);
-        QueryHelper.processObjectParams(this.#state.having);
+        if (this.#state.data) {
+            this.#state.data = QueryHelper.processObjectParams(this.#state.data);
+        }
+        this.#state.cond = QueryHelper.processObjectParams(this.#state.cond);
+        this.#state.having = QueryHelper.processObjectParams(this.#state.having);
         // automatically enable paginate flag when we detect to-many joins, but only if there is no `group by` clause
         if (!this.#state.flags.has(QueryFlag.DISABLE_PAGINATE) &&
             this.#state.groupBy.length === 0 &&
@@ -2325,7 +2322,10 @@ export class QueryBuilder {
                     const fieldName = this.helper.mapper(field, this.type, undefined, null);
                     // virtual fields (e.g. `qb.as(...)`) have no column to reference inside `min()`; inline their
                     // expression instead, as a select alias is not resolvable there on some dialects (e.g. PostgreSQL)
-                    const virtual = !prop?.persist && !prop?.formula && !prop?.hasConvertToJSValueSQL && !pks.includes(fieldName)
+                    const virtual = (!prop || prop.persist === false) &&
+                        !prop?.formula &&
+                        !prop?.hasConvertToJSValueSQL &&
+                        !pks.includes(fieldName)
                         ? this.resolveVirtualField(f, fieldName)
                         : undefined;
                     const expr = virtual ? virtual.expr : this.platform.quoteIdentifier(fieldName);

package/query/QueryBuilderHelper.js

@@ -132,17 +132,10 @@ export class QueryBuilderHelper {
             }
             return raw(`${value}${as}`);
         }
-        if (prop?.hasConvertToJSValueSQL && type !== QueryType.UPSERT) {
-            let valueSQL;
-            if (prop.fieldNames.length > 1 && fkIdx !== -1) {
-                const fk = prop.targetMeta.getPrimaryProps()[fkIdx];
-                const prefixed = this.prefix(field, isTableNameAliasRequired, true, fkIdx);
-                valueSQL = fk.customType.convertToJSValueSQL(prefixed, this.#platform);
-            }
-            else {
-                const prefixed = this.prefix(field, isTableNameAliasRequired, true);
-                valueSQL = prop.customType.convertToJSValueSQL(prefixed, this.#platform);
-            }
+        const customType = prop?.customTypes?.[fkIdx] ?? prop?.customType;
+        if (prop?.hasConvertToJSValueSQL && customType?.convertToJSValueSQL && type !== QueryType.UPSERT) {
+            const prefixed = this.prefix(field, isTableNameAliasRequired, true, fkIdx);
+            const valueSQL = customType.convertToJSValueSQL(prefixed, this.#platform);
             if (alias === null) {
                 return raw(valueSQL);
             }