@mikro-orm/core 7.0.0-dev.33 → 7.0.0-dev.331

package/entity/EntityLoader.js

@@ -4,16 +4,16 @@ import { ValidationError } from '../errors.js';
 import { LoadStrategy, PopulatePath, ReferenceKind, } from '../enums.js';
 import { Reference } from './Reference.js';
 import { helper } from './wrap.js';
-import { raw, RawQueryFragment } from '../utils/RawQueryFragment.js';
 import { expandDotPaths } from './utils.js';
+import { Raw } from '../utils/RawQueryFragment.js';
 export class EntityLoader {
-    em;
-    metadata;
-    driver;
+    #metadata;
+    #driver;
+    #em;
     constructor(em) {
-        this.em = em;
-        this.metadata = this.em.getMetadata();
-        this.driver = this.em.getDriver();
+        this.#em = em;
+        this.#metadata = this.#em.getMetadata();
+        this.#driver = this.#em.getDriver();
     }
     /**
      * Loads specified relations in batch.
@@ -23,16 +23,15 @@ export class EntityLoader {
         if (entities.length === 0 || Utils.isEmpty(populate)) {
             return this.setSerializationContext(entities, populate, options);
         }
-        const meta = this.metadata.find(entityName);
+        const meta = this.#metadata.find(entityName);
         if (entities.some(e => !e.__helper)) {
             const entity = entities.find(e => !Utils.isEntity(e));
             throw ValidationError.notDiscoveredEntity(entity, meta, 'populate');
         }
         const references = entities.filter(e => !helper(e).isInitialized());
-        const visited = options.visited ??= new Set();
+        const visited = (options.visited ??= new Set());
         options.where ??= {};
         options.orderBy ??= {};
-        options.filters ??= {};
         options.lookup ??= true;
         options.validate ??= true;
         options.refresh ??= false;
@@ -40,9 +39,9 @@ export class EntityLoader {
         if (references.length > 0) {
             await this.populateScalar(meta, references, { ...options, populateWhere: undefined });
         }
-        populate = this.normalizePopulate(entityName, populate, options.strategy, options.lookup);
-        const invalid = populate.find(({ field }) => !this.em.canPopulate(entityName, field));
-        /* v8 ignore next 3 */
+        populate = this.normalizePopulate(entityName, populate, options.strategy, options.lookup, options.exclude);
+        const invalid = populate.find(({ field }) => !this.#em.canPopulate(entityName, field));
+        /* v8 ignore next */
         if (options.validate && invalid) {
             throw ValidationError.invalidPropertyName(entityName, invalid.field);
         }
@@ -57,9 +56,10 @@ export class EntityLoader {
             visited.delete(entity);
         }
     }
-    normalizePopulate(entityName, populate, strategy, lookup = true) {
-        const meta = this.metadata.find(entityName);
+    normalizePopulate(entityName, populate, strategy, lookup = true, exclude) {
+        const meta = this.#metadata.find(entityName);
         let normalized = Utils.asArray(populate).map(field => {
+            // oxfmt-ignore
             return typeof field === 'boolean' || field.field === PopulatePath.ALL ? { all: !!field, field: meta.primaryKeys[0] } : field;
         });
         if (normalized.some(p => p.all)) {
@@ -68,7 +68,7 @@ export class EntityLoader {
         // convert nested `field` with dot syntax to PopulateOptions with `children` array
         expandDotPaths(meta, normalized, true);
         if (lookup && populate !== false) {
-            normalized = this.lookupEagerLoadedRelationships(entityName, normalized, strategy);
+            normalized = this.lookupEagerLoadedRelationships(entityName, normalized, strategy, '', [], exclude);
             // convert nested `field` with dot syntax produced by eager relations
             expandDotPaths(meta, normalized, true);
         }
@@ -90,6 +90,7 @@ export class EntityLoader {
      */
     mergeNestedPopulate(populate) {
         const tmp = populate.reduce((ret, item) => {
+            /* v8 ignore next */
             if (item.field === PopulatePath.ALL) {
                 return ret;
             }
@@ -117,16 +118,17 @@ export class EntityLoader {
      */
     async populateMany(entityName, entities, populate, options) {
         const [field, ref] = populate.field.split(':', 2);
-        const meta = this.metadata.find(entityName);
+        const meta = this.#metadata.find(entityName);
         const prop = meta.properties[field];
-        if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !this.driver.getPlatform().usesPivotTable()) {
+        if (prop.kind === 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, fields: [prop.name] });
             }
         }
         if (prop.kind === ReferenceKind.SCALAR && prop.lazy) {
-            const filtered = entities.filter(e => options.refresh || (prop.ref ? !e[prop.name]?.isInitialized() : e[prop.name] === undefined));
+            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;
             }
@@ -138,37 +140,107 @@ export class EntityLoader {
         }
         const filtered = this.filterCollections(entities, field, options, ref);
         const innerOrderBy = Utils.asArray(options.orderBy)
-            .filter(orderBy => (Array.isArray(orderBy[prop.name]) && orderBy[prop.name].length > 0) || Utils.isObject(orderBy[prop.name]))
+            .filter(orderBy => (Array.isArray(orderBy[prop.name]) && orderBy[prop.name].length > 0) ||
+            Utils.isObject(orderBy[prop.name]))
             .flatMap(orderBy => orderBy[prop.name]);
         const where = await this.extractChildCondition(options, prop);
-        if (prop.kind === ReferenceKind.MANY_TO_MANY && this.driver.getPlatform().usesPivotTable()) {
-            const res = await this.findChildrenFromPivotTable(filtered, prop, options, innerOrderBy, populate, !!ref);
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && this.#driver.getPlatform().usesPivotTable()) {
+            const pivotOrderBy = QueryHelper.mergeOrderBy(innerOrderBy, prop.orderBy, prop.targetMeta?.orderBy);
+            const res = await this.findChildrenFromPivotTable(filtered, prop, options, pivotOrderBy, populate, !!ref);
             return Utils.flatten(res);
         }
+        if (prop.polymorphic && prop.polymorphTargets) {
+            return this.populatePolymorphic(entities, prop, options, !!ref);
+        }
         const { items, partial } = await this.findChildren(options.filtered ?? entities, prop, populate, {
             ...options,
             where,
             orderBy: innerOrderBy,
         }, !!(ref || prop.mapToPk));
-        this.initializeCollections(filtered, prop, field, items, innerOrderBy.length > 0, partial);
+        const customOrder = innerOrderBy.length > 0 || !!prop.orderBy || !!prop.targetMeta?.orderBy;
+        this.initializeCollections(filtered, prop, field, items, customOrder, partial);
         return items;
     }
     async populateScalar(meta, filtered, options) {
         const pk = Utils.getPrimaryKeyHash(meta.primaryKeys);
         const ids = Utils.unique(filtered.map(e => Utils.getPrimaryKeyValues(e, meta, true)));
-        const where = this.mergePrimaryCondition(ids, pk, options, meta, this.metadata, this.driver.getPlatform());
+        const where = this.mergePrimaryCondition(ids, pk, options, meta, this.#metadata, this.#driver.getPlatform());
         const { filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging, fields } = options;
-        await this.em.find(meta.className, where, {
-            filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging,
+        await this.#em.find(meta.class, where, {
+            filters,
+            convertCustomTypes,
+            lockMode,
+            strategy,
+            populateWhere,
+            connectionType,
+            logging,
             fields: fields,
             populate: [],
         });
     }
+    async populatePolymorphic(entities, prop, options, ref) {
+        const ownerMeta = this.#metadata.get(entities[0].constructor);
+        // Separate entities: those with loaded refs vs those needing FK load
+        const toPopulate = [];
+        const needsFkLoad = [];
+        for (const entity of entities) {
+            const refValue = entity[prop.name];
+            if (refValue && helper(refValue).hasPrimaryKey()) {
+                if ((ref && !options.refresh) || // :ref hint - already have reference
+                    (!ref && helper(refValue).__initialized && !options.refresh) // already loaded
+                ) {
+                    continue;
+                }
+                toPopulate.push(entity);
+            }
+            else if (refValue == null && !helper(entity).__loadedProperties.has(prop.name)) {
+                // FK columns weren't loaded (partial loading) — need to re-fetch them.
+                // If the property IS in __loadedProperties, the FK was loaded and is genuinely null.
+                needsFkLoad.push(entity);
+            }
+        }
+        // Load FK columns using populateScalar pattern
+        if (needsFkLoad.length > 0) {
+            await this.populateScalar(ownerMeta, needsFkLoad, {
+                ...options,
+                fields: [...ownerMeta.primaryKeys, prop.name],
+            });
+            // After loading FKs, add to toPopulate if not using :ref hint
+            if (!ref) {
+                for (const entity of needsFkLoad) {
+                    const refValue = entity[prop.name];
+                    if (refValue && helper(refValue).hasPrimaryKey()) {
+                        toPopulate.push(entity);
+                    }
+                }
+            }
+        }
+        if (toPopulate.length === 0) {
+            return [];
+        }
+        // Group references by target class for batch loading
+        const groups = new Map();
+        for (const entity of toPopulate) {
+            const refValue = Reference.unwrapReference(entity[prop.name]);
+            const discriminator = QueryHelper.findDiscriminatorValue(prop.discriminatorMap, helper(refValue).__meta.class);
+            const group = groups.get(discriminator) ?? [];
+            group.push(refValue);
+            groups.set(discriminator, group);
+        }
+        // Load each group concurrently - identity map handles merging with existing references
+        const allItems = [];
+        await Promise.all([...groups].map(async ([discriminator, children]) => {
+            const targetMeta = this.#metadata.find(prop.discriminatorMap[discriminator]);
+            await this.populateScalar(targetMeta, children, options);
+            allItems.push(...children);
+        }));
+        return allItems;
+    }
     initializeCollections(filtered, prop, field, children, customOrder, partial) {
         if (prop.kind === ReferenceKind.ONE_TO_MANY) {
             this.initializeOneToMany(filtered, children, prop, field, partial);
         }
-        if (prop.kind === ReferenceKind.MANY_TO_MANY && !this.driver.getPlatform().usesPivotTable()) {
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && !this.#driver.getPlatform().usesPivotTable()) {
             this.initializeManyToMany(filtered, children, prop, field, customOrder, partial);
         }
     }
@@ -182,7 +254,7 @@ export class EntityLoader {
         for (const child of children) {
             const pk = child.__helper.__data[prop.mappedBy] ?? child[prop.mappedBy];
             if (pk) {
-                const key = helper(mapToPk ? this.em.getReference(prop.type, pk) : pk).getSerializedPrimaryKey();
+                const key = helper(mapToPk ? this.#em.getReference(prop.targetMeta.class, pk) : pk).getSerializedPrimaryKey();
                 map[key]?.push(child);
             }
         }
@@ -198,7 +270,8 @@ export class EntityLoader {
                 entity[field].hydrate(items, true, partial);
             }
         }
-        else { // owning side of M:N without pivot table needs to be reordered
+        else {
+            // owning side of M:N without pivot table needs to be reordered
             for (const entity of filtered) {
                 const order = !customOrder ? [...entity[prop.name].getItems(false)] : []; // copy order of references
                 const items = children.filter(child => entity[prop.name].contains(child, false));
@@ -210,13 +283,23 @@ export class EntityLoader {
         }
     }
     async findChildren(entities, prop, populate, options, ref) {
-        const children = this.getChildReferences(entities, prop, options, ref);
+        const children = Utils.unique(this.getChildReferences(entities, prop, options, ref));
         const meta = prop.targetMeta;
-        let fk = Utils.getPrimaryKeyHash(meta.primaryKeys);
+        // When targetKey is set, use it for FK lookup instead of the PK
+        let fk = prop.targetKey ?? Utils.getPrimaryKeyHash(meta.primaryKeys);
         let schema = options.schema;
         const partial = !Utils.isEmpty(prop.where) || !Utils.isEmpty(options.where);
+        let polymorphicOwnerProp;
         if (prop.kind === ReferenceKind.ONE_TO_MANY || (prop.kind === ReferenceKind.MANY_TO_MANY && !prop.owner)) {
-            fk = meta.properties[prop.mappedBy].name;
+            const ownerProp = meta.properties[prop.mappedBy];
+            if (ownerProp.polymorphic && ownerProp.fieldNames.length >= 2) {
+                const idColumns = ownerProp.fieldNames.slice(1);
+                fk = idColumns.length === 1 ? idColumns[0] : idColumns;
+                polymorphicOwnerProp = ownerProp;
+            }
+            else {
+                fk = ownerProp.name;
+            }
         }
         if (prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner && !ref) {
             children.length = 0;
@@ -229,8 +312,25 @@ export class EntityLoader {
         if (!schema && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind)) {
             schema = children.find(e => e.__helper.__schema)?.__helper.__schema;
         }
-        const ids = Utils.unique(children.map(e => e.__helper.getPrimaryKey()));
-        let where = this.mergePrimaryCondition(ids, fk, options, meta, this.metadata, this.driver.getPlatform());
+        const ids = Utils.unique(children.map(e => (prop.targetKey ? e[prop.targetKey] : e.__helper.getPrimaryKey())));
+        let where;
+        if (polymorphicOwnerProp && Array.isArray(fk)) {
+            const conditions = ids.map(id => {
+                const pkValues = Object.values(id);
+                return Object.fromEntries(fk.map((col, idx) => [col, pkValues[idx]]));
+            });
+            where = (conditions.length === 1 ? conditions[0] : { $or: conditions });
+        }
+        else {
+            where = this.mergePrimaryCondition(ids, fk, options, meta, this.#metadata, this.#driver.getPlatform());
+        }
+        if (polymorphicOwnerProp) {
+            const parentMeta = this.#metadata.find(entities[0].constructor);
+            const discriminatorValue = QueryHelper.findDiscriminatorValue(polymorphicOwnerProp.discriminatorMap, parentMeta.class) ??
+                parentMeta.tableName;
+            const discriminatorColumn = polymorphicOwnerProp.fieldNames[0];
+            where = { $and: [where, { [discriminatorColumn]: discriminatorValue }] };
+        }
         const fields = this.buildFields(options.fields, prop, ref);
         /* eslint-disable prefer-const */
         let { refresh, filters, convertCustomTypes, lockMode, strategy, populateWhere = 'infer', connectionType, logging, } = options;
@@ -238,61 +338,101 @@ export class EntityLoader {
         if (typeof populateWhere === 'object') {
             populateWhere = await this.extractChildCondition({ where: populateWhere }, prop);
         }
-        if (!Utils.isEmpty(prop.where)) {
+        if (!Utils.isEmpty(prop.where) || Raw.hasObjectFragments(prop.where)) {
             where = { $and: [where, prop.where] };
         }
-        const propOrderBy = [];
-        if (prop.orderBy) {
-            for (const item of Utils.asArray(prop.orderBy)) {
-                for (const field of Utils.keys(item)) {
-                    const rawField = RawQueryFragment.getKnownFragment(field, false);
-                    if (rawField) {
-                        const raw2 = raw(rawField.sql, rawField.params);
-                        propOrderBy.push({ [raw2.toString()]: item[field] });
-                        continue;
-                    }
-                    propOrderBy.push({ [field]: item[field] });
-                }
-            }
-        }
-        const orderBy = [...Utils.asArray(options.orderBy), ...propOrderBy].filter((order, idx, array) => {
-            // skip consecutive ordering with the same key to get around mongo issues
-            return idx === 0 || !Utils.equals(Object.keys(array[idx - 1]), Object.keys(order));
-        });
-        const items = await this.em.find(prop.type, where, {
-            filters, convertCustomTypes, lockMode, populateWhere, logging,
+        const orderBy = QueryHelper.mergeOrderBy(options.orderBy, prop.orderBy);
+        const items = await this.#em.find(meta.class, where, {
+            filters,
+            convertCustomTypes,
+            lockMode,
+            populateWhere,
+            logging,
             orderBy,
             populate: populate.children ?? populate.all ?? [],
-            exclude: Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude,
-            strategy, fields, schema, connectionType,
+            exclude: Array.isArray(options.exclude)
+                ? Utils.extractChildElements(options.exclude, prop.name)
+                : options.exclude,
+            strategy,
+            fields,
+            schema,
+            connectionType,
             // @ts-ignore not a public option, will be propagated to the populate call
             refresh: refresh && !children.every(item => options.visited.has(item)),
             // @ts-ignore not a public option, will be propagated to the populate call
             visited: options.visited,
         });
+        // For targetKey relations, wire up loaded entities to parent references
+        // This is needed because the references were created under alternate key,
+        // but loaded entities are stored under PK, so they don't automatically merge
+        if (prop.targetKey && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind)) {
+            const itemsByKey = new Map();
+            for (const item of items) {
+                itemsByKey.set('' + item[prop.targetKey], item);
+            }
+            for (const entity of entities) {
+                const ref = entity[prop.name];
+                /* v8 ignore next */
+                if (!ref) {
+                    continue;
+                }
+                // oxfmt-ignore
+                const keyValue = '' + (Reference.isReference(ref) ? ref.unwrap()[prop.targetKey] : ref[prop.targetKey]);
+                const loadedItem = itemsByKey.get(keyValue);
+                if (loadedItem) {
+                    entity[prop.name] = (Reference.isReference(ref) ? Reference.create(loadedItem) : loadedItem);
+                }
+            }
+        }
+        if ([ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && items.length !== children.length) {
+            const nullVal = this.#em.config.get('forceUndefined') ? undefined : null;
+            const itemsMap = new Set();
+            const childrenMap = new Set();
+            // Use targetKey value if set, otherwise use serialized PK
+            const getKey = (e) => (prop.targetKey ? '' + e[prop.targetKey] : helper(e).getSerializedPrimaryKey());
+            for (const item of items) {
+                /* v8 ignore next */
+                itemsMap.add(getKey(item));
+            }
+            for (const child of children) {
+                childrenMap.add(getKey(child));
+            }
+            for (const entity of entities) {
+                const ref = entity[prop.name] ?? {};
+                const key = helper(ref) ? getKey(ref) : undefined;
+                if (key && childrenMap.has(key) && !itemsMap.has(key)) {
+                    entity[prop.name] = nullVal;
+                    helper(entity).__originalEntityData[prop.name] = null;
+                }
+            }
+        }
         for (const item of items) {
             if (ref && !helper(item).__onLoadFired) {
                 helper(item).__initialized = false;
-                // eslint-disable-next-line dot-notation
-                this.em.getUnitOfWork()['loadedEntities'].delete(item);
+                this.#em.getUnitOfWork().unmarkAsLoaded(item);
             }
         }
         return { items, partial };
     }
     mergePrimaryCondition(ids, pk, options, meta, metadata, platform) {
-        const cond1 = QueryHelper.processWhere({ where: { [pk]: { $in: ids } }, entityName: meta.className, metadata, platform, convertCustomTypes: !options.convertCustomTypes });
+        const cond1 = QueryHelper.processWhere({
+            where: { [pk]: { $in: ids } },
+            entityName: meta.class,
+            metadata,
+            platform,
+            convertCustomTypes: !options.convertCustomTypes,
+        });
         const where = { ...options.where };
         Utils.dropUndefinedProperties(where);
-        return where[pk]
-            ? { $and: [cond1, where] }
-            : { ...cond1, ...where };
+        return where[pk] ? { $and: [cond1, where] } : { ...cond1, ...where };
     }
     async populateField(entityName, entities, populate, options) {
         const field = populate.field.split(':')[0];
-        const prop = this.metadata.find(entityName).properties[field];
+        const prop = this.#metadata.find(entityName).properties[field];
         if (prop.kind === ReferenceKind.SCALAR && !prop.lazy) {
             return;
         }
+        options = { ...options, filters: QueryHelper.mergePropertyFilters(prop.filters, options.filters) };
         const populated = await this.populateMany(entityName, entities, populate, options);
         if (!populate.children && !populate.all) {
             return;
@@ -321,6 +461,7 @@ export class EntityLoader {
             .filter(orderBy => Utils.isObject(orderBy[prop.name]))
             .map(orderBy => orderBy[prop.name]);
         const { refresh, filters, ignoreLazyScalarProperties, populateWhere, connectionType, logging, schema } = options;
+        // oxfmt-ignore
         const exclude = Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude;
         const visited = options.visited;
         for (const entity of entities) {
@@ -331,26 +472,42 @@ export class EntityLoader {
         for (const entity of entities) {
             visited.add(entity);
         }
-        await this.populate(prop.type, unique, populate.children ?? populate.all, {
-            where: await this.extractChildCondition(options, prop, false),
-            orderBy: innerOrderBy,
-            fields,
-            exclude,
-            validate: false,
-            lookup: false,
-            filters,
-            ignoreLazyScalarProperties,
-            populateWhere,
-            connectionType,
-            logging,
-            schema,
-            // @ts-ignore not a public option, will be propagated to the populate call
-            refresh: refresh && !filtered.every(item => options.visited.has(item)),
-            // @ts-ignore not a public option, will be propagated to the populate call
-            visited: options.visited,
-            // @ts-ignore not a public option
-            filtered,
-        });
+        if (!prop.targetMeta) {
+            return;
+        }
+        const populateChildren = async (targetMeta, items) => {
+            await this.populate(targetMeta.class, items, populate.children ?? populate.all, {
+                where: (await this.extractChildCondition(options, prop, false)),
+                orderBy: innerOrderBy,
+                fields,
+                exclude,
+                validate: false,
+                lookup: false,
+                filters,
+                ignoreLazyScalarProperties,
+                populateWhere,
+                connectionType,
+                logging,
+                schema,
+                // @ts-ignore not a public option, will be propagated to the populate call
+                refresh: refresh && !filtered.every(item => options.visited.has(item)),
+                // @ts-ignore not a public option, will be propagated to the populate call
+                visited: options.visited,
+                // @ts-ignore not a public option
+                filtered,
+            });
+        };
+        if (prop.polymorphic && prop.polymorphTargets) {
+            await Promise.all(prop.polymorphTargets.map(async (targetMeta) => {
+                const targetChildren = unique.filter(child => helper(child).__meta.className === targetMeta.className);
+                if (targetChildren.length > 0) {
+                    await populateChildren(targetMeta, targetChildren);
+                }
+            }));
+        }
+        else {
+            await populateChildren(prop.targetMeta, unique);
+        }
     }
     /** @internal */
     async findChildrenFromPivotTable(filtered, prop, options, orderBy, populate, pivotJoin) {
@@ -358,36 +515,33 @@ export class EntityLoader {
         const refresh = options.refresh;
         let where = await this.extractChildCondition(options, prop, true);
         const fields = this.buildFields(options.fields, prop);
+        // oxfmt-ignore
         const exclude = Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude;
-        const options2 = { ...options };
-        delete options2.limit;
-        delete options2.offset;
-        options2.fields = fields;
-        options2.exclude = exclude;
-        options2.populate = (populate?.children ?? []);
-        if (prop.customType) {
-            ids.forEach((id, idx) => ids[idx] = QueryHelper.processCustomType(prop, id, this.driver.getPlatform()));
-        }
+        const populateFilter = options.populateFilter?.[prop.name];
+        const options2 = { ...options, fields, exclude, populateFilter };
+        ['limit', 'offset', 'first', 'last', 'before', 'after', 'overfetch'].forEach(prop => delete options2[prop]);
+        options2.populate = populate?.children ?? [];
         if (!Utils.isEmpty(prop.where)) {
             where = { $and: [where, prop.where] };
         }
-        const map = await this.driver.loadFromPivotTable(prop, ids, where, orderBy, this.em.getTransactionContext(), options2, pivotJoin);
+        const map = await this.#driver.loadFromPivotTable(prop, ids, where, orderBy, this.#em.getTransactionContext(), options2, pivotJoin);
         const children = [];
-        for (const entity of filtered) {
-            const items = map[entity.__helper.getSerializedPrimaryKey()].map(item => {
+        for (let i = 0; i < filtered.length; i++) {
+            const entity = filtered[i];
+            const items = map[Utils.getPrimaryKeyHash(ids[i])].map(item => {
                 if (pivotJoin) {
-                    return this.em.getReference(prop.type, item, {
+                    return this.#em.getReference(prop.targetMeta.class, item, {
                         convertCustomTypes: true,
-                        schema: options.schema ?? this.em.config.get('schema'),
+                        schema: options.schema ?? this.#em.config.get('schema'),
                     });
                 }
-                const entity = this.em.getEntityFactory().create(prop.type, item, {
+                const entity = this.#em.getEntityFactory().create(prop.targetMeta.class, item, {
                     refresh,
                     merge: true,
                     convertCustomTypes: true,
-                    schema: options.schema ?? this.em.config.get('schema'),
+                    schema: options.schema ?? this.#em.config.get('schema'),
                 });
-                return this.em.getUnitOfWork().register(entity, item, { refresh, loaded: true });
+                return this.#em.getUnitOfWork().register(entity, item, { refresh, loaded: true });
             });
             entity[prop.name].hydrate(items, true);
             children.push(items);
@@ -397,16 +551,14 @@ export class EntityLoader {
     async extractChildCondition(options, prop, filters = false) {
         const where = options.where;
         const subCond = Utils.isPlainObject(where[prop.name]) ? where[prop.name] : {};
-        const meta2 = this.metadata.find(prop.type);
-        if (!meta2) {
-            return {};
-        }
+        const meta2 = prop.targetMeta;
         const pk = Utils.getPrimaryKeyHash(meta2.primaryKeys);
         ['$and', '$or'].forEach(op => {
             if (where[op]) {
                 const child = where[op]
                     .map((cond) => cond[prop.name])
-                    .filter((sub) => sub != null && !(Utils.isPlainObject(sub) && Object.keys(sub).every(key => Utils.isOperator(key, false))))
+                    .filter((sub) => sub != null &&
+                    !(Utils.isPlainObject(sub) && Utils.getObjectQueryKeys(sub).every(key => Utils.isOperator(key, false))))
                     .map((cond) => {
                     if (Utils.isPrimaryKey(cond)) {
                         return { [pk]: cond };
@@ -427,7 +579,7 @@ export class EntityLoader {
             });
         }
         if (filters) {
-            return this.em.applyFilters(prop.type, subCond, options.filters, 'read', options);
+            return this.#em.applyFilters(meta2.class, subCond, options.filters, 'read', options);
         }
         return subCond;
     }
@@ -445,23 +597,25 @@ export class EntityLoader {
                 const parts = f.toString().split('.');
                 const propName = parts.shift();
                 const childPropName = parts.join('.');
-                /* v8 ignore next 3 */
+                /* v8 ignore next */
                 if (propName === prop.name) {
                     ret.push(childPropName);
                 }
             }
             return ret;
         }, []);
-        if (ret.length === 0) {
-            return undefined;
-        }
         // we need to automatically select the FKs too, e.g. for 1:m relations to be able to wire them with the items
         if (prop.kind === ReferenceKind.ONE_TO_MANY || prop.kind === ReferenceKind.MANY_TO_MANY) {
             const owner = prop.targetMeta.properties[prop.mappedBy];
-            if (owner && !ret.includes(owner.name)) {
+            // when the owning FK is lazy, we need to explicitly select it even without user-provided fields,
+            // otherwise the driver will exclude it and we won't be able to map children to their parent collections
+            if (owner && !ret.includes(owner.name) && (ret.length > 0 || owner.lazy)) {
                 ret.push(owner.name);
             }
         }
+        if (ret.length === 0) {
+            return undefined;
+        }
         return ret;
     }
     getChildReferences(entities, prop, options, ref) {
@@ -475,7 +629,8 @@ export class EntityLoader {
                 return a;
             }, []);
         }
-        if (prop.kind === ReferenceKind.MANY_TO_MANY) { // inverse side
+        if (prop.kind === ReferenceKind.MANY_TO_MANY) {
+            // inverse side
             return filtered;
         }
         // MANY_TO_ONE or ONE_TO_ONE
@@ -496,7 +651,7 @@ export class EntityLoader {
             return wrapped.__loadedProperties.has(field);
         }
         const [f, ...r] = field.split('.');
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (!wrapped.__loadedProperties.has(f) || !wrapped.__meta.properties[f]?.targetMeta) {
             return false;
         }
@@ -529,7 +684,7 @@ export class EntityLoader {
             .map(e => Reference.unwrapReference(e[field]));
     }
     filterByReferences(entities, field, refresh) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (refresh) {
             return entities;
         }
@@ -537,7 +692,7 @@ export class EntityLoader {
     }
     lookupAllRelationships(entityName) {
         const ret = [];
-        const meta = this.metadata.find(entityName);
+        const meta = this.#metadata.find(entityName);
         meta.relations.forEach(prop => {
             ret.push({
                 field: this.getRelationName(meta, prop),
@@ -555,37 +710,43 @@ export class EntityLoader {
         }
         return `${this.getRelationName(meta, meta.properties[prop.embedded[0]])}.${prop.embedded[1]}`;
     }
-    lookupEagerLoadedRelationships(entityName, populate, strategy, prefix = '', visited = []) {
-        const meta = this.metadata.find(entityName);
+    lookupEagerLoadedRelationships(entityName, populate, strategy, prefix = '', visited = [], exclude) {
+        const meta = this.#metadata.find(entityName);
         if (!meta && !prefix) {
             return populate;
         }
-        if (visited.includes(entityName) || !meta) {
+        if (!meta || visited.includes(meta)) {
             return [];
         }
-        visited.push(entityName);
+        visited.push(meta);
         const ret = prefix === '' ? [...populate] : [];
         meta.relations
             .filter(prop => {
+            const field = this.getRelationName(meta, prop);
+            const prefixed = prefix ? `${prefix}.${field}` : field;
+            const isExcluded = exclude?.includes(prefixed);
             const eager = prop.eager && !populate.some(p => p.field === `${prop.name}:ref`);
             const populated = populate.some(p => p.field === prop.name);
             const disabled = populate.some(p => p.field === prop.name && p.all === false);
-            return !disabled && (eager || populated);
+            return !disabled && !isExcluded && (eager || populated);
         })
             .forEach(prop => {
             const field = this.getRelationName(meta, prop);
             const prefixed = prefix ? `${prefix}.${field}` : field;
-            const nestedPopulate = populate.filter(p => p.field === prop.name).flatMap(p => p.children).filter(Boolean);
-            const nested = this.lookupEagerLoadedRelationships(prop.type, nestedPopulate, strategy, prefixed, visited.slice());
+            const nestedPopulate = populate
+                .filter(p => p.field === prop.name)
+                .flatMap(p => p.children)
+                .filter(Boolean);
+            const nested = this.lookupEagerLoadedRelationships(prop.targetMeta.class, nestedPopulate, strategy, prefixed, visited.slice(), exclude);
             if (nested.length > 0) {
                 ret.push(...nested);
             }
             else {
-                const selfReferencing = [meta.className, meta.root.className, ...visited].includes(prop.type) && prop.eager;
+                const selfReferencing = [meta.tableName, ...visited.map(m => m.tableName)].includes(prop.targetMeta.tableName) && prop.eager;
                 ret.push({
                     field: prefixed,
                     // enforce select-in strategy for self-referencing relations
-                    strategy: selfReferencing ? LoadStrategy.SELECT_IN : strategy ?? prop.strategy,
+                    strategy: selfReferencing ? LoadStrategy.SELECT_IN : (strategy ?? prop.strategy),
                 });
             }
         });