@mikro-orm/core 7.2.2-dev.0 → 7.2.2-dev.2

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;
     }
@@ -1088,6 +1088,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 +1149,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.2-dev.0",
+  "version": "7.2.2-dev.2",
   "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.0';
+    static #ORM_VERSION = '7.2.2-dev.2';
     /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
     static getRlsSettingName(filterName, argName) {
         return `mikro.${filterName}.${argName}`;