@mikro-orm/core 7.1.0-dev.37 → 7.1.0-dev.38

package/EntityManager.js

@@ -1,4 +1,4 @@
-import { getOnConflictReturningFields, getWhereCondition } from './utils/upsert-utils.js';
+import { getOnConflictReturningFields, getWhereCondition, resetUntouchedCollections } from './utils/upsert-utils.js';
 import { Utils } from './utils/Utils.js';
 import { Cursor } from './utils/Cursor.js';
 import { QueryHelper } from './utils/QueryHelper.js';
@@ -322,13 +322,13 @@ export class EntityManager {
         }
         const types = Object.values(meta.root.discriminatorMap).map(cls => this.metadata.get(cls));
         const children = [];
-        const lookUpChildren = (ret, type) => {
-            const children = types.filter(meta2 => meta2.extends === type);
-            children.forEach(m => lookUpChildren(ret, m.class));
+        const lookUpChildren = (ret, parent) => {
+            const children = types.filter(meta2 => meta2.extends && this.metadata.find(meta2.extends) === parent);
+            children.forEach(m => lookUpChildren(ret, m));
             ret.push(...children.filter(c => c.discriminatorValue));
             return children;
         };
-        lookUpChildren(children, meta.class);
+        lookUpChildren(children, meta);
         /* v8 ignore next */
         where[meta.root.discriminatorColumn] =
             children.length > 0
@@ -363,6 +363,13 @@ export class EntityManager {
             if (!joined && !hint.filter) {
                 continue;
             }
+            // Polymorphic to-one relations are already filtered via per-target LEFT JOINs created
+            // for the `:ref filter` hint; emitting a populate-filter entry here would auto-join only
+            // the first target meta and either drop rows pointing to other targets or reference
+            // parent-table-only columns on the child sub-table alias for TPT children.
+            if (prop.polymorphic && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+                continue;
+            }
             const filters = QueryHelper.mergePropertyFilters(prop.filters, options.filters);
             const where = await this.applyFilters(prop.targetMeta.class, {}, filters, 'read', {
                 ...options,
@@ -448,7 +455,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);
+                            }
+                        }
+                    }
+                }
             }
         }
     }
@@ -849,6 +872,7 @@ export class EntityManager {
             em.getHydrator().hydrate(entity, meta, data2, em.#entityFactory, 'full', false, true);
         }
         // recompute the data as there might be some values missing (e.g. those with db column defaults)
+        resetUntouchedCollections(meta, entity);
         const snapshot = this.#comparator.prepareEntity(entity);
         em.#unitOfWork.register(entity, snapshot, { refresh: true });
         if (em.eventManager.hasListeners(EventType.afterUpsert, meta)) {
@@ -1080,6 +1104,7 @@ export class EntityManager {
         }
         for (const [entity] of entities) {
             // recompute the data as there might be some values missing (e.g. those with db column defaults)
+            resetUntouchedCollections(meta, entity);
             const snapshot = this.#comparator.prepareEntity(entity);
             em.#unitOfWork.register(entity, snapshot, { refresh: true });
         }
@@ -1872,9 +1897,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;
@@ -1918,8 +1947,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

@@ -319,7 +319,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);
@@ -337,10 +337,10 @@ export class EntityLoader {
                 fk = ownerProp.name;
             }
         }
-        if (prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner && !ref) {
+        if (prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner && (!ref || (!prop.mapToPk && !populate.filter))) {
             children.length = 0;
             fk = meta.properties[prop.mappedBy].name;
-            children.push(...this.filterByReferences(entities, prop.name, options.refresh));
+            children.push(...this.filterByReferences(entities, prop, options, ref));
         }
         if (children.length === 0) {
             return { items: [], partial };
@@ -707,7 +707,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);
@@ -723,7 +723,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) {
@@ -749,7 +749,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 [];
         }
@@ -758,13 +758,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));
             });
         }
@@ -772,12 +778,39 @@ export class EntityLoader {
             .filter(e => !e[field].__helper.__initialized)
             .map(e => Reference.unwrapReference(e[field]));
     }
-    filterByReferences(entities, field, refresh) {
+    filterByReferences(entities, prop, options, ref) {
         /* v8 ignore next */
-        if (refresh) {
+        if (options.refresh) {
             return entities;
         }
-        return entities.filter(e => e[field] !== null && !e[field]?.__helper?.__initialized);
+        const field = prop.name;
+        return entities.filter(e => {
+            const value = e[field];
+            if (value === null) {
+                return false;
+            }
+            if (value === undefined || !Utils.isEntity(value, true)) {
+                return true;
+            }
+            const target = Reference.unwrapReference(value);
+            const wrapped = helper(target);
+            if (!wrapped.__initialized) {
+                return true;
+            }
+            if (ref) {
+                return false;
+            }
+            if (options.fields) {
+                const childFields = options.fields
+                    .filter(f => f.startsWith(`${prop.name}.`))
+                    .map(f => f.substring(prop.name.length + 1));
+                return childFields.length > 0 && !childFields.every(f => this.isPropertyLoaded(target, f));
+            }
+            return prop.targetMeta.comparableProps.some(targetProp => {
+                const inlineEmbedded = targetProp.kind === ReferenceKind.EMBEDDED && !targetProp.object;
+                return !inlineEmbedded && !targetProp.lazy && !wrapped.__loadedProperties.has(targetProp.name);
+            });
+        });
     }
     lookupAllRelationships(entityName) {
         const ret = [];

package/metadata/MetadataDiscovery.js

@@ -605,6 +605,10 @@ export class MetadataDiscovery {
                 prop.pivotEntity = pivotMeta.class;
                 if (prop.inversedBy) {
                     prop.targetMeta.properties[prop.inversedBy].pivotEntity = pivotMeta.class;
+                    const targetRoot = prop.targetMeta.root;
+                    if (targetRoot !== prop.targetMeta && targetRoot.properties[prop.inversedBy]) {
+                        targetRoot.properties[prop.inversedBy].pivotEntity = pivotMeta.class;
+                    }
                 }
                 // Propagate pivotEntity to ALL inverse collections using mappedBy pointing at this
                 // owner prop. Covers three cases:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.1.0-dev.37",
+  "version": "7.1.0-dev.38",
   "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.1.0-dev.37';
+    static #ORM_VERSION = '7.1.0-dev.38';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */

package/utils/upsert-utils.d.ts

@@ -10,3 +10,5 @@ export declare function getWhereCondition<T extends object>(meta: EntityMetadata
     where: FilterQuery<T>;
     propIndex: number | false;
 };
+/** @internal */
+export declare function resetUntouchedCollections<Entity extends object>(meta: EntityMetadata<Entity>, entity: Entity): void;

package/utils/upsert-utils.js

@@ -1,5 +1,8 @@
 import { isRaw } from '../utils/RawQueryFragment.js';
 import { Utils } from './Utils.js';
+import { ReferenceKind } from '../enums.js';
+import { Collection } from '../entity/Collection.js';
+import { helper } from '../entity/wrap.js';
 function expandEmbeddedProperties(prop, key) {
     if (prop.object) {
         return [prop.name];
@@ -52,7 +55,9 @@ export function getOnConflictFields(meta, data, uniqueFields, options) {
         });
     }
     const keys = Object.keys(data).flatMap(f => {
-        if (!(Array.isArray(uniqueFields) && !uniqueFields.includes(f))) {
+        // skip explicitly listed unique fields; for raw onConflictFields we can't introspect the
+        // fragment, so merge all data keys (the user is responsible for not corrupting them).
+        if (Array.isArray(uniqueFields) && uniqueFields.includes(f)) {
             return [];
         }
         const prop = meta?.properties[f];
@@ -142,3 +147,23 @@ export function getWhereCondition(meta, onConflictFields, data, where) {
     }
     return { where, propIndex };
 }
+/** @internal */
+export function resetUntouchedCollections(meta, entity) {
+    // for entities passed in via `em.create()` and then upserted, collection-kind relations
+    // were initialized as empty-but-initialized by the hydrator (newEntity=true). once the
+    // upsert resolves the entity to a possibly existing row, that state is stale and would
+    // cause `em.populate()` to skip those collections. replace them with a fresh
+    // uninitialized collection so populate can load them.
+    if (helper(entity).__originalEntityData) {
+        return;
+    }
+    for (const prop of meta.relations) {
+        if (prop.kind !== ReferenceKind.MANY_TO_MANY && prop.kind !== ReferenceKind.ONE_TO_MANY) {
+            continue;
+        }
+        const collection = entity[prop.name];
+        if (Utils.isCollection(collection) && collection.isInitialized() && !collection.isDirty()) {
+            Collection.create(entity, prop.name, undefined, false);
+        }
+    }
+}