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

package/EntityManager.js

@@ -889,7 +889,7 @@ export class EntityManager {
             const name = Utils.className(entityName);
             /* v8 ignore next */
             where = Utils.isEntity(where) ? helper(where).getPrimaryKey() : where;
-            throw failHandler(name, where);
+            throw failHandler(name, QueryHelper.processParams(where));
         }
         return entity;
     }
@@ -995,6 +995,9 @@ export class EntityManager {
         const uniqueFields = options.onConflictFields ??
             (Utils.isPlainObject(where) ? Object.keys(where) : meta.primaryKeys);
         const returning = getOnConflictReturningFields(meta, data, uniqueFields, options);
+        if (options.onConflictWhere && !ret.row) {
+            returning.push(...Object.keys(data));
+        }
         if (options.onConflictAction === 'ignore' ||
             !helper(entity).hasPrimaryKey() ||
             (returning.length > 0 && !(this.getPlatform().usesReturningStatement() && ret.row))) {
@@ -1088,6 +1091,8 @@ export class EntityManager {
             }
             return ret;
         }
+        // the rows are replaced with their processed copies below, keep the caller's array intact
+        data = [...data];
         const meta = this.metadata.get(entityName);
         const convertCustomTypes = !Utils.isEntity(data[0]);
         const generatedFields = new Set();
@@ -1147,6 +1152,10 @@ export class EntityManager {
                 platform: this.getPlatform(),
             });
             row = QueryHelper.processObjectParams(row);
+            // hooks and the result merging need `data[i]` to be the same object as the processed row
+            if (!Utils.isEntity(data[i])) {
+                data[i] = row;
+            }
             validateParams(row, 'insert data');
             allData.push(row);
             allWhere.push(where);
@@ -1177,9 +1186,9 @@ export class EntityManager {
         entitiesByData.clear();
         const loadPK = new Map();
         allData.forEach((row, i) => {
-            em.#unitOfWork
-                .getChangeSetPersister()
-                .mapReturnedValues(Utils.isEntity(data[i]) ? data[i] : null, Utils.isEntity(data[i]) ? {} : data[i], res.rows?.[i], meta, true);
+            em.#unitOfWork.getChangeSetPersister().mapReturnedValues(Utils.isEntity(data[i]) ? data[i] : null, Utils.isEntity(data[i]) ? {} : data[i], 
+            // A suppressed conflict omits its row; positional mapping would hydrate a different entity.
+            res.rows?.length === allData.length ? res.rows[i] : undefined, meta, true);
             const entity = Utils.isEntity(data[i])
                 ? data[i]
                 : em.#entityFactory.create(entityName, row, {
@@ -1198,6 +1207,9 @@ export class EntityManager {
         // oxfmt-ignore
         const uniqueFields = options.onConflictFields ?? (Utils.isPlainObject(allWhere[0]) ? Object.keys(allWhere[0]).flatMap(key => Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
         const returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options);
+        if (options.onConflictWhere && res.rows?.length !== allData.length) {
+            returning.push(...meta.comparableProps.filter(p => !p.lazy && !p.embeddable).map(p => p.name));
+        }
         const reloadFields = returning.length > 0 && !(this.getPlatform().usesReturningStatement() && res.rows?.length === data.length);
         if (options.onConflictAction === 'ignore' || (!res.rows?.length && loadPK.size > 0) || reloadFields) {
             const unique = meta.hydrateProps.filter(p => !p.lazy).map(p => p.name);
@@ -1229,8 +1241,9 @@ export class EntityManager {
                 const row = data2.find(row => {
                     const tmp = {};
                     add.forEach(k => {
-                        if (!meta.properties[k]?.primary) {
-                            tmp[k] = row[k];
+                        const prop = meta.properties[k];
+                        if (!prop?.primary) {
+                            tmp[k] = prop?.customType ? prop.customType.convertToDatabaseValue(row[k], this.getPlatform()) : row[k];
                         }
                     });
                     return this.#comparator.matching(entityName, cond, tmp);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "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",

package/utils/QueryHelper.d.ts

@@ -35,6 +35,8 @@ export declare class QueryHelper {
      */
     static liftGroupOperators<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): string | undefined;
     static inlinePrimaryKeyObjects<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): boolean;
+    /** Copies the plain object and array structure of the condition, keeping the leaf values (e.g. entities) by reference. */
+    private static cloneWhere;
     static processWhere<T extends object>(options: ProcessWhereOptions<T>): FilterQuery<T>;
     static getActiveFilters<T>(meta: EntityMetadata<T>, options: FilterOptions | undefined, filters: Dictionary<FilterDef>): FilterDef[];
     /** @internal Sentinel wrapping for arguments accessed while statically resolving an `rls` filter condition. */

package/utils/QueryHelper.js

@@ -56,15 +56,16 @@ export class QueryHelper {
             return params.map(item => QueryHelper.processParams(item));
         }
         if (Utils.isPlainObject(params)) {
-            QueryHelper.processObjectParams(params);
+            return QueryHelper.processObjectParams(params);
         }
         return params;
     }
     static processObjectParams(params = {}) {
+        const ret = (Array.isArray(params) ? [...params] : { ...params });
         Utils.getObjectQueryKeys(params).forEach(k => {
-            params[k] = QueryHelper.processParams(params[k]);
+            ret[k] = QueryHelper.processParams(params[k]);
         });
-        return params;
+        return ret;
     }
     /**
      * converts `{ account: { $or: [ [Object], [Object] ] } }`
@@ -167,10 +168,26 @@ export class QueryHelper {
         });
         return false;
     }
+    /** Copies the plain object and array structure of the condition, keeping the leaf values (e.g. entities) by reference. */
+    static cloneWhere(where) {
+        if (Array.isArray(where)) {
+            return where.map(item => QueryHelper.cloneWhere(item));
+        }
+        if (!Utils.isPlainObject(where)) {
+            return where;
+        }
+        const ret = {};
+        Utils.getObjectQueryKeys(where).forEach(k => (ret[k] = QueryHelper.cloneWhere(where[k])));
+        return ret;
+    }
     static processWhere(options) {
         // eslint-disable-next-line prefer-const
         let { where, entityName, metadata, platform, aliased = true, convertCustomTypes = true, root = true } = options;
         const meta = metadata.find(entityName);
+        // the condition is normalized in place, so work on a copy to keep the one the caller passed in intact
+        if (root) {
+            where = QueryHelper.cloneWhere(where);
+        }
         // inline PK-only objects in M:N queries, so we don't join the target entity when not needed
         if (meta && root) {
             QueryHelper.liftGroupOperators(where, meta, metadata);

package/utils/Utils.js

@@ -153,7 +153,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.2.2-dev.1';
+    static #ORM_VERSION = '7.2.2-dev.3';
     /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
     static getRlsSettingName(filterName, argName) {
         return `mikro.${filterName}.${argName}`;