@mikro-orm/core 7.2.2-dev.16 → 7.2.2-dev.17

package/EntityManager.js

@@ -1134,9 +1134,10 @@ export class EntityManager {
         const generatedFields = new Set();
         const allData = [];
         const allWhere = [];
+        const dataIndexes = [];
+        const result = [];
         const entities = new Map();
         const entitiesByData = new Map();
-        const entitiesByAllDataIdx = new Map();
         for (let i = 0; i < data.length; i++) {
             let row = data[i];
             let where;
@@ -1144,14 +1145,12 @@ export class EntityManager {
                 const entity = row;
                 if (helper(entity).__managed && helper(entity).__em === em && !this.config.get('upsertManaged')) {
                     em.#entityFactory.mergeData(meta, entity, row, { initialized: true });
-                    entities.set(entity, row);
-                    entitiesByData.set(row, entity);
+                    result[i] = entity;
                     continue;
                 }
                 where = helper(entity).getPrimaryKey();
                 getOnCreateGeneratedFields(meta, entity).forEach(field => generatedFields.add(field));
                 em.#entityFactory.assignDefaultValues(entity, meta);
-                entitiesByAllDataIdx.set(allData.length, entity);
                 row = em.#comparator.prepareEntity(entity);
             }
             else {
@@ -1161,8 +1160,7 @@ export class EntityManager {
                     const exists = em.#unitOfWork.getById(entityName, where, options.schema);
                     if (exists) {
                         em.assign(exists, row);
-                        entities.set(exists, row);
-                        entitiesByData.set(row, exists);
+                        result[i] = exists;
                         continue;
                     }
                 }
@@ -1195,22 +1193,25 @@ export class EntityManager {
             validateParams(row, 'insert data');
             allData.push(row);
             allWhere.push(where);
+            dataIndexes.push(i);
         }
-        if (entities.size === data.length) {
-            return [...entities.keys()];
+        if (allData.length === 0) {
+            return [...new Set(result)];
         }
         // `onCreate` generated values are for the insert clause only, they must not overwrite existing rows
         if (generatedFields.size > 0 && !options.onConflictMergeFields) {
             options.onConflictExcludeFields = [...(options.onConflictExcludeFields ?? []), ...generatedFields];
         }
         if (em.eventManager.hasListeners(EventType.beforeUpsert, meta)) {
-            for (const dto of data) {
-                const entity = entitiesByData.get(dto) ?? dto;
+            for (const index of dataIndexes) {
+                const entity = data[index];
                 await em.eventManager.dispatchEvent(EventType.beforeUpsert, { entity, em, meta }, meta);
             }
-            for (const [idx, entity] of entitiesByAllDataIdx) {
-                allData[idx] = em.#comparator.prepareEntity(entity);
-            }
+            dataIndexes.forEach((index, idx) => {
+                if (Utils.isEntity(data[index])) {
+                    allData[idx] = em.#comparator.prepareEntity(data[index]);
+                }
+            });
         }
         const res = await em.withSessionContext(options.ctx ?? em.#transactionContext, ctx => em.driver.nativeUpdateMany(entityName, allWhere, allData, {
             upsert: true,
@@ -1218,15 +1219,16 @@ export class EntityManager {
             ...options,
             ctx,
         }));
-        entities.clear();
-        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], 
+            // Managed inputs skipped by the SQL batch still occupy positions in `data`.
+            const index = dataIndexes[i];
+            const item = data[index];
+            em.#unitOfWork.getChangeSetPersister().mapReturnedValues(Utils.isEntity(item) ? item : null, Utils.isEntity(item) ? {} : item, 
             // 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]
+            const entity = Utils.isEntity(item)
+                ? item
                 : em.#entityFactory.create(entityName, row, {
                     refresh: true,
                     initialized: true,
@@ -1237,18 +1239,19 @@ export class EntityManager {
             }
             entities.set(entity, row);
             entitiesByData.set(row, entity);
+            result[index] = entity;
         });
         // skip the reload only when RETURNING brought back a row for every input
         // (onConflictWhere can suppress writes, leaving some rows out)
         // oxfmt-ignore
         const uniqueFields = options.onConflictFields ?? (Utils.isPlainObject(allWhere[0]) ? Object.keys(allWhere[0]).flatMap(key => Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
         const platform = this.getPlatform();
-        const returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options, platform);
+        const returning = getOnConflictReturningFields(meta, data[dataIndexes[0]], uniqueFields, options, platform);
         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 &&
-            !((platform.usesReturningStatement() || platform.usesOutputStatement()) && res.rows?.length === data.length);
+            !((platform.usesReturningStatement() || platform.usesOutputStatement()) && res.rows?.length === allData.length);
         if (options.onConflictAction === 'ignore' || (!res.rows?.length && loadPK.size > 0) || reloadFields) {
             const unique = meta.hydrateProps.filter(p => !p.lazy).map(p => p.name);
             const add = new Set(propIndex !== false && propIndex >= 0
@@ -1258,7 +1261,8 @@ export class EntityManager {
                 Utils.keys(cond).forEach(key => add.add(key));
             }
             const where = { $or: [] };
-            data.forEach((item, idx) => {
+            dataIndexes.forEach((index, idx) => {
+                const item = data[index];
                 where.$or[idx] = {};
                 const props = Array.isArray(uniqueFields) ? uniqueFields : Object.keys(item);
                 props.forEach(prop => {
@@ -1328,7 +1332,7 @@ export class EntityManager {
                 await em.eventManager.dispatchEvent(EventType.afterUpsert, { entity, em, meta }, meta);
             }
         }
-        return [...entities.keys()];
+        return [...new Set(result)];
     }
     /**
      * Runs your callback wrapped inside a database transaction.

package/package.json

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