@mikro-orm/core 6.3.10-dev.12 → 6.3.10-dev.14

package/EntityManager.js

@@ -1538,11 +1538,12 @@ class EntityManager {
             // we need to prune the `populate` hint from to-one relations, as partially loading them does not require their population, we want just the FK
             const pruneToOneRelations = (meta, fields) => {
                 const ret = [];
-                for (const field of fields) {
+                for (let field of fields) {
                     if (field === enums_1.PopulatePath.ALL || field.startsWith(`${enums_1.PopulatePath.ALL}.`)) {
                         ret.push(...meta.props.filter(prop => prop.lazy || [enums_1.ReferenceKind.SCALAR, enums_1.ReferenceKind.EMBEDDED].includes(prop.kind)).map(prop => prop.name));
                         continue;
                     }
+                    field = field.split(':')[0];
                     if (!field.includes('.') && ![enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(meta.properties[field].kind)) {
                         ret.push(field);
                         continue;

package/entity/EntityLoader.d.ts

@@ -42,6 +42,7 @@ export declare class EntityLoader {
      * preload everything in one call (this will update already existing references in IM)
      */
     private populateMany;
+    private populateScalar;
     private initializeCollections;
     private initializeOneToMany;
     private initializeManyToMany;

package/entity/EntityLoader.js

@@ -118,20 +118,18 @@ class EntityLoader {
         const [field, ref] = populate.field.split(':', 2);
         const meta = this.metadata.find(entityName);
         const prop = meta.properties[field];
+        if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && prop.owner && !this.driver.getPlatform().usesPivotTable()) {
+            const filtered = entities.filter(e => !e[prop.name]?.isInitialized());
+            if (filtered.length > 0) {
+                await this.populateScalar(meta, filtered, options, prop);
+            }
+        }
         if (prop.kind === enums_1.ReferenceKind.SCALAR && prop.lazy) {
             const filtered = entities.filter(e => options.refresh || (prop.ref ? !e[prop.name]?.isInitialized() : e[prop.name] === undefined));
             if (options.ignoreLazyScalarProperties || filtered.length === 0) {
                 return entities;
             }
-            const pk = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
-            const ids = Utils_1.Utils.unique(filtered.map(e => Utils_1.Utils.getPrimaryKeyValues(e, meta.primaryKeys, true)));
-            const where = this.mergePrimaryCondition(ids, pk, options, meta, this.metadata, this.driver.getPlatform());
-            const { filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging } = options;
-            await this.em.find(meta.className, where, {
-                filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging,
-                fields: [prop.name],
-                populate: [],
-            });
+            await this.populateScalar(meta, filtered, options, prop);
             return entities;
         }
         if (prop.kind === enums_1.ReferenceKind.EMBEDDED) {
@@ -149,6 +147,17 @@ class EntityLoader {
         this.initializeCollections(filtered, prop, field, data, innerOrderBy.length > 0);
         return data;
     }
+    async populateScalar(meta, filtered, options, prop) {
+        const pk = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
+        const ids = Utils_1.Utils.unique(filtered.map(e => Utils_1.Utils.getPrimaryKeyValues(e, meta.primaryKeys, true)));
+        const where = this.mergePrimaryCondition(ids, pk, options, meta, this.metadata, this.driver.getPlatform());
+        const { filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging } = options;
+        await this.em.find(meta.className, where, {
+            filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging,
+            fields: [prop.name],
+            populate: [],
+        });
+    }
     initializeCollections(filtered, prop, field, children, customOrder) {
         if (prop.kind === enums_1.ReferenceKind.ONE_TO_MANY) {
             this.initializeOneToMany(filtered, children, prop, field);

package/hydration/ObjectHydrator.js

@@ -165,9 +165,14 @@ class ObjectHydrator extends Hydrator_1.Hydrator {
             ret.push(`    }`);
             ret.push(`  } else if (!entity${entityKey} && data${dataKey} instanceof Collection) {`);
             ret.push(`    entity${entityKey} = data${dataKey};`);
+            if (!this.platform.usesPivotTable() && prop.owner && prop.kind === enums_1.ReferenceKind.MANY_TO_MANY) {
+                ret.push(`  } else if (!entity${entityKey} && Array.isArray(data${dataKey})) {`);
+                const items = this.platform.usesPivotTable() || !prop.owner ? 'undefined' : '[]';
+                ret.push(`    const coll = Collection.create(entity, '${prop.name}', ${items}, !!data${dataKey} || newEntity);`);
+                ret.push(`    coll.setDirty(false);`);
+            }
             ret.push(`  } else if (!entity${entityKey}) {`);
-            const items = this.platform.usesPivotTable() || !prop.owner ? 'undefined' : '[]';
-            ret.push(`    const coll = Collection.create(entity, '${prop.name}', ${items}, !!data${dataKey} || newEntity);`);
+            ret.push(`    const coll = Collection.create(entity, '${prop.name}', undefined, newEntity);`);
             ret.push(`    coll.setDirty(false);`);
             ret.push(`  }`);
             return ret;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.3.10-dev.12",
+  "version": "6.3.10-dev.14",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.2.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.3.10-dev.12",
+    "mikro-orm": "6.3.10-dev.14",
     "reflect-metadata": "0.2.2"
   }
 }

package/unit-of-work/ChangeSetComputer.js

@@ -141,14 +141,12 @@ class ChangeSetComputer {
     }
     processToMany(prop, changeSet) {
         const target = changeSet.entity[prop.name];
-        if (!target.isDirty()) {
+        if (!target.isDirty() && changeSet.type !== ChangeSet_1.ChangeSetType.CREATE) {
             return;
         }
         this.collectionUpdates.add(target);
-        if (prop.owner || target.getItems(false).filter(item => !item.__helper.__initialized).length > 0) {
-            if (!this.platform.usesPivotTable()) {
-                changeSet.payload[prop.name] = target.getItems(false).map((item) => item.__helper.__identifier ?? item.__helper.getPrimaryKey());
-            }
+        if (prop.owner && !this.platform.usesPivotTable()) {
+            changeSet.payload[prop.name] = target.getItems(false).map((item) => item.__helper.__identifier ?? item.__helper.getPrimaryKey());
         }
     }
 }

package/unit-of-work/ChangeSetPersister.js

@@ -185,12 +185,13 @@ class ChangeSetPersister {
             this.checkConcurrencyKeys(meta, changeSet, cond[idx]);
         });
         const res = await this.driver.nativeUpdateMany(meta.className, cond, changeSets.map(cs => cs.payload), options);
-        changeSets.forEach((changeSet, idx) => {
+        for (const changeSet of changeSets) {
             if (res.rows) {
-                this.mapReturnedValues(changeSet.entity, changeSet.payload, res.rows[idx], meta);
+                const row = res.rows.find(row => utils_1.Utils.equals(utils_1.Utils.extractPK(row, meta), changeSet.getPrimaryKey()));
+                this.mapReturnedValues(changeSet.entity, changeSet.payload, row, meta);
             }
             changeSet.persisted = true;
-        });
+        }
     }
     mapPrimaryKey(meta, value, changeSet) {
         const prop = meta.properties[meta.primaryKeys[0]];