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

package/EntityManager.js

@@ -452,7 +452,23 @@ export class EntityManager {
             const prop = meta?.properties[field];
             if (prop && !ref) {
                 hint.children ??= [];
-                await this.autoJoinRefsForFilters(prop.targetMeta, { ...options, populate: hint.children }, { class: meta.root.class, propName: prop.name });
+                const targets = prop.polymorphic && prop.polymorphTargets?.length ? prop.polymorphTargets : [prop.targetMeta];
+                for (const targetMeta of targets) {
+                    const before = hint.children.length;
+                    await this.autoJoinRefsForFilters(targetMeta, { ...options, populate: hint.children }, { class: meta.root.class, propName: prop.name });
+                    // For polymorphic relations, `hint.children` is applied to every polymorph target during
+                    // population, so drop any auto-added hint whose field does not exist on every target —
+                    // otherwise the shared `:ref` would crash when applied to a target lacking it (GH #7722).
+                    if (targets.length > 1 && hint.children.length > before) {
+                        const added = hint.children.splice(before);
+                        for (const h of added) {
+                            const f = h.field.split(':')[0];
+                            if (targets.every(t => f in t.properties)) {
+                                hint.children.push(h);
+                            }
+                        }
+                    }
+                }
             }
         }
     }
@@ -1727,9 +1743,13 @@ export class EntityManager {
             return [];
         }
         const meta = this.metadata.find(entityName);
-        // infer populate hints from `fields` when present; merge with explicit `populate` if both are set
+        // infer populate hints from `fields` when present; merge with explicit `populate` if both are set.
+        // `populateArray` is only kept when the entries are user-provided strings — when this method runs a
+        // second time (e.g. from `lockAndPopulate`) the populate is already normalized and merging would be a no-op.
         const fields = options.fields ? this.buildFields(options.fields) : undefined;
-        const populateArray = Array.isArray(options.populate) ? options.populate : undefined;
+        const populateArray = Array.isArray(options.populate) && options.populate.every(p => typeof p === 'string')
+            ? options.populate
+            : undefined;
         const hasNestedFields = fields?.some(f => f.includes('.')) ?? false;
         const shouldInfer = fields !== undefined && options.populate === undefined;
         const shouldMerge = fields !== undefined && populateArray !== undefined && populateArray.length > 0 && hasNestedFields;
@@ -1773,8 +1793,11 @@ export class EntityManager {
             }
             else {
                 // with an explicit populate, only nested paths (e.g. `item.id`) need to be merged in — they
-                // require a JOIN to access sub-fields, whereas bare names are already handled by the driver
-                const extras = fromFields.filter(f => f.includes('.'));
+                // require a JOIN to access sub-fields, whereas bare names are already handled by the driver.
+                // skip paths already in user's `populate` (regardless of `:ref` modifier) to avoid producing
+                // both a `:ref` and a non-`:ref` entry for the same relation
+                const existing = new Set(populateArray.map(p => p.split(':')[0]));
+                const extras = fromFields.filter(f => f.includes('.') && !existing.has(f));
                 options.populate = [...populateArray, ...extras];
             }
         }

package/entity/EntityLoader.js

@@ -316,7 +316,7 @@ export class EntityLoader {
         }
     }
     async findChildren(entities, prop, populate, options, ref) {
-        const children = Utils.unique(this.getChildReferences(entities, prop, options, ref));
+        const children = Utils.unique(this.getChildReferences(entities, prop, options, ref, populate));
         const meta = prop.targetMeta;
         // When targetKey is set, use it for FK lookup instead of the PK
         let fk = prop.targetKey ?? Utils.getPrimaryKeyHash(meta.primaryKeys);
@@ -682,7 +682,7 @@ export class EntityLoader {
         }
         return ret;
     }
-    getChildReferences(entities, prop, options, ref) {
+    getChildReferences(entities, prop, options, ref, populate) {
         const filtered = this.filterCollections(entities, prop.name, options, ref);
         if (prop.kind === ReferenceKind.ONE_TO_MANY) {
             return filtered.map(e => e[prop.name].owner);
@@ -698,7 +698,7 @@ export class EntityLoader {
             return filtered;
         }
         // MANY_TO_ONE or ONE_TO_ONE
-        return this.filterReferences(entities, prop.name, options, ref);
+        return this.filterReferences(entities, prop.name, options, ref, populate);
     }
     filterCollections(entities, field, options, ref) {
         if (options.refresh) {
@@ -724,7 +724,7 @@ export class EntityLoader {
         }
         return this.isPropertyLoaded(entity[f], r.join('.'));
     }
-    filterReferences(entities, field, options, ref) {
+    filterReferences(entities, field, options, ref, populate) {
         if (ref) {
             return [];
         }
@@ -733,13 +733,19 @@ export class EntityLoader {
             return children.map(e => Reference.unwrapReference(e[field]));
         }
         if (options.fields) {
+            // `:ref` populate children are satisfied by FK/PK and will be loaded lazily — they don't force a parent reload
+            const refChildren = new Set((populate?.children ?? [])
+                .map(c => c.field.split(':'))
+                .filter(parts => parts[1] === 'ref')
+                .map(parts => parts[0]));
             return children
                 .map(e => Reference.unwrapReference(e[field]))
                 .filter(target => {
                 const wrapped = helper(target);
                 const childFields = options.fields
                     .filter(f => f.startsWith(`${field}.`))
-                    .map(f => f.substring(field.length + 1));
+                    .map(f => f.substring(field.length + 1))
+                    .filter(cf => !refChildren.has(cf.split('.')[0]));
                 return !wrapped.__initialized || !childFields.every(cf => this.isPropertyLoaded(target, cf));
             });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.17-dev.0",
+  "version": "7.0.17-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/Utils.js

@@ -141,7 +141,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.0.17-dev.0';
+    static #ORM_VERSION = '7.0.17-dev.2';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */