@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.11

package/entity/EntityLoader.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityLoader = void 0;
-const QueryHelper_1 = require("../utils/QueryHelper");
-const Utils_1 = require("../utils/Utils");
-const errors_1 = require("../errors");
-const enums_1 = require("../enums");
-const Reference_1 = require("./Reference");
-const wrap_1 = require("./wrap");
-const RawQueryFragment_1 = require("../utils/RawQueryFragment");
-const utils_1 = require("./utils");
-class EntityLoader {
+import { QueryHelper } from '../utils/QueryHelper.js';
+import { Utils } from '../utils/Utils.js';
+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';
+export class EntityLoader {
     em;
     metadata;
     driver;
@@ -23,15 +20,15 @@ class EntityLoader {
      * This will execute one query for each relation, that will populate it on all the specified entities.
      */
     async populate(entityName, entities, populate, options) {
-        if (entities.length === 0 || Utils_1.Utils.isEmpty(populate)) {
+        if (entities.length === 0 || Utils.isEmpty(populate)) {
             return this.setSerializationContext(entities, populate, options);
         }
         const meta = this.metadata.find(entityName);
         if (entities.some(e => !e.__helper)) {
-            const entity = entities.find(e => !Utils_1.Utils.isEntity(e));
-            throw errors_1.ValidationError.notDiscoveredEntity(entity, meta, 'populate');
+            const entity = entities.find(e => !Utils.isEntity(e));
+            throw ValidationError.notDiscoveredEntity(entity, meta, 'populate');
         }
-        const references = entities.filter(e => !(0, wrap_1.helper)(e).isInitialized());
+        const references = entities.filter(e => !helper(e).isInitialized());
         const visited = options.visited ??= new Set();
         options.where ??= {};
         options.orderBy ??= {};
@@ -45,9 +42,9 @@ class EntityLoader {
         }
         populate = this.normalizePopulate(entityName, populate, options.strategy, options.lookup);
         const invalid = populate.find(({ field }) => !this.em.canPopulate(entityName, field));
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (options.validate && invalid) {
-            throw errors_1.ValidationError.invalidPropertyName(entityName, invalid.field);
+            throw ValidationError.invalidPropertyName(entityName, invalid.field);
         }
         this.setSerializationContext(entities, populate, options);
         for (const entity of entities) {
@@ -62,25 +59,25 @@ class EntityLoader {
     }
     normalizePopulate(entityName, populate, strategy, lookup = true) {
         const meta = this.metadata.find(entityName);
-        let normalized = Utils_1.Utils.asArray(populate).map(field => {
-            return typeof field === 'boolean' || field.field === enums_1.PopulatePath.ALL ? { all: !!field, field: meta.primaryKeys[0] } : field;
+        let normalized = Utils.asArray(populate).map(field => {
+            return typeof field === 'boolean' || field.field === PopulatePath.ALL ? { all: !!field, field: meta.primaryKeys[0] } : field;
         });
         if (normalized.some(p => p.all)) {
             normalized = this.lookupAllRelationships(entityName);
         }
         // convert nested `field` with dot syntax to PopulateOptions with `children` array
-        (0, utils_1.expandDotPaths)(meta, normalized, true);
+        expandDotPaths(meta, normalized, true);
         if (lookup && populate !== false) {
             normalized = this.lookupEagerLoadedRelationships(entityName, normalized, strategy);
             // convert nested `field` with dot syntax produced by eager relations
-            (0, utils_1.expandDotPaths)(meta, normalized, true);
+            expandDotPaths(meta, normalized, true);
         }
         // merge same fields
         return this.mergeNestedPopulate(normalized);
     }
     setSerializationContext(entities, populate, options) {
         for (const entity of entities) {
-            (0, wrap_1.helper)(entity).setSerializationContext({
+            helper(entity).setSerializationContext({
                 populate,
                 fields: options.fields,
                 exclude: options.exclude,
@@ -93,7 +90,7 @@ class EntityLoader {
      */
     mergeNestedPopulate(populate) {
         const tmp = populate.reduce((ret, item) => {
-            if (item.field === enums_1.PopulatePath.ALL) {
+            if (item.field === PopulatePath.ALL) {
                 return ret;
             }
             if (!ret[item.field]) {
@@ -122,13 +119,13 @@ 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()) {
+        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 === enums_1.ReferenceKind.SCALAR && prop.lazy) {
+        if (prop.kind === 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;
@@ -136,14 +133,14 @@ class EntityLoader {
             await this.populateScalar(meta, filtered, { ...options, fields: [prop.name] });
             return entities;
         }
-        if (prop.kind === enums_1.ReferenceKind.EMBEDDED) {
+        if (prop.kind === ReferenceKind.EMBEDDED) {
             return [];
         }
         const filtered = this.filterCollections(entities, field, options, ref);
-        const innerOrderBy = Utils_1.Utils.asArray(options.orderBy)
-            .filter(orderBy => (Array.isArray(orderBy[prop.name]) && orderBy[prop.name].length > 0) || Utils_1.Utils.isObject(orderBy[prop.name]))
+        const innerOrderBy = Utils.asArray(options.orderBy)
+            .filter(orderBy => (Array.isArray(orderBy[prop.name]) && orderBy[prop.name].length > 0) || Utils.isObject(orderBy[prop.name]))
             .flatMap(orderBy => orderBy[prop.name]);
-        if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && this.driver.getPlatform().usesPivotTable()) {
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && this.driver.getPlatform().usesPivotTable()) {
             return this.findChildrenFromPivotTable(filtered, prop, options, innerOrderBy, populate, !!ref);
         }
         const where = await this.extractChildCondition(options, prop);
@@ -152,8 +149,8 @@ class EntityLoader {
         return data;
     }
     async populateScalar(meta, filtered, options) {
-        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 pk = Utils.getPrimaryKeyHash(meta.primaryKeys);
+        const ids = Utils.unique(filtered.map(e => 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, fields } = options;
         await this.em.find(meta.className, where, {
@@ -163,10 +160,10 @@ class EntityLoader {
         });
     }
     initializeCollections(filtered, prop, field, children, customOrder) {
-        if (prop.kind === enums_1.ReferenceKind.ONE_TO_MANY) {
+        if (prop.kind === ReferenceKind.ONE_TO_MANY) {
             this.initializeOneToMany(filtered, children, prop, field);
         }
-        if (prop.kind === enums_1.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);
         }
     }
@@ -174,18 +171,18 @@ class EntityLoader {
         const mapToPk = prop.targetMeta.properties[prop.mappedBy].mapToPk;
         const map = {};
         for (const entity of filtered) {
-            const key = (0, wrap_1.helper)(entity).getSerializedPrimaryKey();
+            const key = helper(entity).getSerializedPrimaryKey();
             map[key] = [];
         }
         for (const child of children) {
             const pk = child.__helper.__data[prop.mappedBy] ?? child[prop.mappedBy];
             if (pk) {
-                const key = (0, wrap_1.helper)(mapToPk ? this.em.getReference(prop.type, pk) : pk).getSerializedPrimaryKey();
+                const key = helper(mapToPk ? this.em.getReference(prop.type, pk) : pk).getSerializedPrimaryKey();
                 map[key]?.push(child);
             }
         }
         for (const entity of filtered) {
-            const key = (0, wrap_1.helper)(entity).getSerializedPrimaryKey();
+            const key = helper(entity).getSerializedPrimaryKey();
             entity[field].hydrate(map[key]);
         }
     }
@@ -210,12 +207,12 @@ class EntityLoader {
     async findChildren(entities, prop, populate, options, ref) {
         const children = this.getChildReferences(entities, prop, options, ref);
         const meta = prop.targetMeta;
-        let fk = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
+        let fk = Utils.getPrimaryKeyHash(meta.primaryKeys);
         let schema = options.schema;
-        if (prop.kind === enums_1.ReferenceKind.ONE_TO_MANY || (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && !prop.owner)) {
+        if (prop.kind === ReferenceKind.ONE_TO_MANY || (prop.kind === ReferenceKind.MANY_TO_MANY && !prop.owner)) {
             fk = meta.properties[prop.mappedBy].name;
         }
-        if (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE && !prop.owner && !ref) {
+        if (prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner && !ref) {
             children.length = 0;
             fk = meta.properties[prop.mappedBy].name;
             children.push(...this.filterByReferences(entities, prop.name, options.refresh));
@@ -223,10 +220,10 @@ class EntityLoader {
         if (children.length === 0) {
             return [];
         }
-        if (!schema && [enums_1.ReferenceKind.ONE_TO_ONE, enums_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind)) {
+        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_1.Utils.unique(children.map(e => e.__helper.getPrimaryKey()));
+        const ids = Utils.unique(children.map(e => e.__helper.getPrimaryKey()));
         let where = this.mergePrimaryCondition(ids, fk, options, meta, this.metadata, this.driver.getPlatform());
         const fields = this.buildFields(options.fields, prop, ref);
         /* eslint-disable prefer-const */
@@ -235,16 +232,16 @@ class EntityLoader {
         if (typeof populateWhere === 'object') {
             populateWhere = await this.extractChildCondition({ where: populateWhere }, prop);
         }
-        if (!Utils_1.Utils.isEmpty(prop.where)) {
+        if (!Utils.isEmpty(prop.where)) {
             where = { $and: [where, prop.where] };
         }
         const propOrderBy = [];
         if (prop.orderBy) {
-            for (const item of Utils_1.Utils.asArray(prop.orderBy)) {
-                for (const field of Utils_1.Utils.keys(item)) {
-                    const rawField = RawQueryFragment_1.RawQueryFragment.getKnownFragment(field, false);
+            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 = (0, RawQueryFragment_1.raw)(rawField.sql, rawField.params);
+                        const raw2 = raw(rawField.sql, rawField.params);
                         propOrderBy.push({ [raw2.toString()]: item[field] });
                         continue;
                     }
@@ -252,11 +249,15 @@ class EntityLoader {
                 }
             }
         }
+        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,
-            orderBy: [...Utils_1.Utils.asArray(options.orderBy), ...propOrderBy],
+            orderBy,
             populate: populate.children ?? populate.all ?? [],
-            exclude: Array.isArray(options.exclude) ? Utils_1.Utils.extractChildElements(options.exclude, prop.name) : options.exclude,
+            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)),
@@ -264,8 +265,8 @@ class EntityLoader {
             visited: options.visited,
         });
         for (const item of items) {
-            if (ref && !(0, wrap_1.helper)(item).__onLoadFired) {
-                (0, wrap_1.helper)(item).__initialized = false;
+            if (ref && !helper(item).__onLoadFired) {
+                helper(item).__initialized = false;
                 // eslint-disable-next-line dot-notation
                 this.em.getUnitOfWork()['loadedEntities'].delete(item);
             }
@@ -273,9 +274,9 @@ class EntityLoader {
         return items;
     }
     mergePrimaryCondition(ids, pk, options, meta, metadata, platform) {
-        const cond1 = QueryHelper_1.QueryHelper.processWhere({ where: { [pk]: { $in: ids } }, entityName: meta.className, metadata, platform, convertCustomTypes: !options.convertCustomTypes });
+        const cond1 = QueryHelper.processWhere({ where: { [pk]: { $in: ids } }, entityName: meta.className, metadata, platform, convertCustomTypes: !options.convertCustomTypes });
         const where = { ...options.where };
-        Utils_1.Utils.dropUndefinedProperties(where);
+        Utils.dropUndefinedProperties(where);
         return where[pk]
             ? { $and: [cond1, where] }
             : { ...cond1, ...where };
@@ -283,7 +284,7 @@ class EntityLoader {
     async populateField(entityName, entities, populate, options) {
         const field = populate.field.split(':')[0];
         const prop = this.metadata.find(entityName).properties[field];
-        if (prop.kind === enums_1.ReferenceKind.SCALAR && !prop.lazy) {
+        if (prop.kind === ReferenceKind.SCALAR && !prop.lazy) {
             return;
         }
         const populated = await this.populateMany(entityName, entities, populate, options);
@@ -293,29 +294,36 @@ class EntityLoader {
         const children = [];
         for (const entity of entities) {
             const ref = entity[field];
-            if (Utils_1.Utils.isEntity(ref)) {
+            if (Utils.isEntity(ref)) {
                 children.push(ref);
             }
-            else if (Reference_1.Reference.isReference(ref)) {
+            else if (Reference.isReference(ref)) {
                 children.push(ref.unwrap());
             }
-            else if (Utils_1.Utils.isCollection(ref)) {
+            else if (Utils.isCollection(ref)) {
                 children.push(...ref.getItems());
             }
-            else if (ref && prop.kind === enums_1.ReferenceKind.EMBEDDED) {
-                children.push(...Utils_1.Utils.asArray(ref));
+            else if (ref && prop.kind === ReferenceKind.EMBEDDED) {
+                children.push(...Utils.asArray(ref));
             }
         }
         if (populated.length === 0 && !populate.children) {
             return;
         }
         const fields = this.buildFields(options.fields, prop);
-        const innerOrderBy = Utils_1.Utils.asArray(options.orderBy)
-            .filter(orderBy => Utils_1.Utils.isObject(orderBy[prop.name]))
+        const innerOrderBy = Utils.asArray(options.orderBy)
+            .filter(orderBy => Utils.isObject(orderBy[prop.name]))
             .map(orderBy => orderBy[prop.name]);
-        const { refresh, filters, ignoreLazyScalarProperties, populateWhere, connectionType, logging } = options;
-        const exclude = Array.isArray(options.exclude) ? Utils_1.Utils.extractChildElements(options.exclude, prop.name) : options.exclude;
-        const filtered = Utils_1.Utils.unique(children.filter(e => !options.visited.has(e)));
+        const { refresh, filters, ignoreLazyScalarProperties, populateWhere, connectionType, logging, schema } = options;
+        const exclude = Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude;
+        const visited = options.visited;
+        for (const entity of entities) {
+            visited.delete(entity);
+        }
+        const filtered = Utils.unique(children.filter(e => !visited.has(e)));
+        for (const entity of entities) {
+            visited.add(entity);
+        }
         await this.populate(prop.type, filtered, populate.children ?? populate.all, {
             where: await this.extractChildCondition(options, prop, false),
             orderBy: innerOrderBy,
@@ -328,6 +336,7 @@ class EntityLoader {
             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
@@ -339,7 +348,7 @@ class EntityLoader {
         const refresh = options.refresh;
         let where = await this.extractChildCondition(options, prop, true);
         const fields = this.buildFields(options.fields, prop);
-        const exclude = Array.isArray(options.exclude) ? Utils_1.Utils.extractChildElements(options.exclude, prop.name) : options.exclude;
+        const exclude = Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude;
         const options2 = { ...options };
         delete options2.limit;
         delete options2.offset;
@@ -347,9 +356,9 @@ class EntityLoader {
         options2.exclude = exclude;
         options2.populate = (populate?.children ?? []);
         if (prop.customType) {
-            ids.forEach((id, idx) => ids[idx] = QueryHelper_1.QueryHelper.processCustomType(prop, id, this.driver.getPlatform()));
+            ids.forEach((id, idx) => ids[idx] = QueryHelper.processCustomType(prop, id, this.driver.getPlatform()));
         }
-        if (!Utils_1.Utils.isEmpty(prop.where)) {
+        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);
@@ -377,19 +386,19 @@ class EntityLoader {
     }
     async extractChildCondition(options, prop, filters = false) {
         const where = options.where;
-        const subCond = Utils_1.Utils.isPlainObject(where[prop.name]) ? where[prop.name] : {};
+        const subCond = Utils.isPlainObject(where[prop.name]) ? where[prop.name] : {};
         const meta2 = this.metadata.find(prop.type);
         if (!meta2) {
             return {};
         }
-        const pk = Utils_1.Utils.getPrimaryKeyHash(meta2.primaryKeys);
+        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_1.Utils.isPlainObject(sub) && Object.keys(sub).every(key => Utils_1.Utils.isOperator(key, false))))
+                    .filter((sub) => sub != null && !(Utils.isPlainObject(sub) && Object.keys(sub).every(key => Utils.isOperator(key, false))))
                     .map((cond) => {
-                    if (Utils_1.Utils.isPrimaryKey(cond)) {
+                    if (Utils.isPrimaryKey(cond)) {
                         return { [pk]: cond };
                     }
                     return cond;
@@ -399,7 +408,7 @@ class EntityLoader {
                 }
             }
         });
-        const operators = Object.keys(subCond).filter(key => Utils_1.Utils.isOperator(key, false));
+        const operators = Object.keys(subCond).filter(key => Utils.isOperator(key, false));
         if (operators.length > 0) {
             operators.forEach(op => {
                 subCond[pk] ??= {};
@@ -417,8 +426,8 @@ class EntityLoader {
             fields = prop.targetMeta.primaryKeys.map(targetPkName => `${prop.name}.${targetPkName}`);
         }
         const ret = fields.reduce((ret, f) => {
-            if (Utils_1.Utils.isPlainObject(f)) {
-                Utils_1.Utils.keys(f)
+            if (Utils.isPlainObject(f)) {
+                Utils.keys(f)
                     .filter(ff => ff === prop.name)
                     .forEach(ff => ret.push(...f[ff]));
             }
@@ -426,7 +435,7 @@ class EntityLoader {
                 const parts = f.toString().split('.');
                 const propName = parts.shift();
                 const childPropName = parts.join('.');
-                /* istanbul ignore else */
+                /* v8 ignore next 3 */
                 if (propName === prop.name) {
                     ret.push(childPropName);
                 }
@@ -437,7 +446,7 @@ class EntityLoader {
             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 === enums_1.ReferenceKind.ONE_TO_MANY || prop.kind === enums_1.ReferenceKind.MANY_TO_MANY) {
+        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)) {
                 ret.push(owner.name);
@@ -448,16 +457,16 @@ class EntityLoader {
     getChildReferences(entities, prop, options, ref) {
         const filtered = this.filterCollections(entities, prop.name, options, ref);
         const children = [];
-        if (prop.kind === enums_1.ReferenceKind.ONE_TO_MANY) {
+        if (prop.kind === ReferenceKind.ONE_TO_MANY) {
             children.push(...filtered.map(e => e[prop.name].owner));
         }
-        else if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && prop.owner) {
+        else if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner) {
             children.push(...filtered.reduce((a, b) => {
                 a.push(...b[prop.name].getItems());
                 return a;
             }, []));
         }
-        else if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY) { // inverse side
+        else if (prop.kind === ReferenceKind.MANY_TO_MANY) { // inverse side
             children.push(...filtered);
         }
         else { // MANY_TO_ONE or ONE_TO_ONE
@@ -469,39 +478,39 @@ class EntityLoader {
         if (options.refresh) {
             return entities.filter(e => e[field]);
         }
-        return entities.filter(e => Utils_1.Utils.isCollection(e[field]) && !e[field].isInitialized(!ref));
+        return entities.filter(e => Utils.isCollection(e[field]) && !e[field].isInitialized(!ref));
     }
     isPropertyLoaded(entity, field) {
         if (!entity || field === '*') {
             return true;
         }
-        const wrapped = (0, wrap_1.helper)(entity);
+        const wrapped = helper(entity);
         if (!field.includes('.')) {
             return wrapped.__loadedProperties.has(field);
         }
         const [f, ...r] = field.split('.');
-        if (wrapped.__loadedProperties.has(f) && wrapped.__meta.properties[f]?.targetMeta) {
-            if ([enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(wrapped.__meta.properties[f].kind)) {
-                return entity[f].getItems(false).every((item) => this.isPropertyLoaded(item, r.join('.')));
-            }
-            return this.isPropertyLoaded(entity[f], r.join('.'));
+        /* v8 ignore next 3 */
+        if (!wrapped.__loadedProperties.has(f) || !wrapped.__meta.properties[f]?.targetMeta) {
+            return false;
+        }
+        if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(wrapped.__meta.properties[f].kind)) {
+            return entity[f].getItems(false).every((item) => this.isPropertyLoaded(item, r.join('.')));
         }
-        /* istanbul ignore next */
-        return false;
+        return this.isPropertyLoaded(entity[f], r.join('.'));
     }
     filterReferences(entities, field, options, ref) {
         if (ref) {
             return [];
         }
-        const children = entities.filter(e => Utils_1.Utils.isEntity(e[field], true));
+        const children = entities.filter(e => Utils.isEntity(e[field], true));
         if (options.refresh) {
-            return children.map(e => Reference_1.Reference.unwrapReference(e[field]));
+            return children.map(e => Reference.unwrapReference(e[field]));
         }
         if (options.fields) {
             return children
-                .map(e => Reference_1.Reference.unwrapReference(e[field]))
+                .map(e => Reference.unwrapReference(e[field]))
                 .filter(target => {
-                const wrapped = (0, wrap_1.helper)(target);
+                const wrapped = helper(target);
                 const childFields = options.fields
                     .filter(f => f.startsWith(`${field}.`))
                     .map(f => f.substring(field.length + 1));
@@ -510,14 +519,14 @@ class EntityLoader {
         }
         return children
             .filter(e => !e[field].__helper.__initialized)
-            .map(e => Reference_1.Reference.unwrapReference(e[field]));
+            .map(e => Reference.unwrapReference(e[field]));
     }
     filterByReferences(entities, field, refresh) {
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (refresh) {
             return entities;
         }
-        return entities.filter(e => !e[field]?.__helper?.__initialized);
+        return entities.filter(e => e[field] !== null && !e[field]?.__helper?.__initialized);
     }
     lookupAllRelationships(entityName) {
         const ret = [];
@@ -526,7 +535,7 @@ class EntityLoader {
             ret.push({
                 field: this.getRelationName(meta, prop),
                 // force select-in strategy when populating all relations as otherwise we could cause infinite loops when self-referencing
-                strategy: enums_1.LoadStrategy.SELECT_IN,
+                strategy: LoadStrategy.SELECT_IN,
                 // no need to look up populate children recursively as we just pass `all: true` here
                 all: true,
             });
@@ -569,11 +578,10 @@ class EntityLoader {
                 ret.push({
                     field: prefixed,
                     // enforce select-in strategy for self-referencing relations
-                    strategy: selfReferencing ? enums_1.LoadStrategy.SELECT_IN : strategy ?? prop.strategy,
+                    strategy: selfReferencing ? LoadStrategy.SELECT_IN : strategy ?? prop.strategy,
                 });
             }
         });
         return ret;
     }
 }
-exports.EntityLoader = EntityLoader;

package/entity/EntityRepository.d.ts

@@ -1,10 +1,10 @@
-import type { PopulatePath } from '../enums';
-import type { CreateOptions, EntityManager, MergeOptions } from '../EntityManager';
-import type { AssignOptions } from './EntityAssigner';
-import type { EntityData, EntityName, Primary, Loaded, FilterQuery, EntityDictionary, AutoPath, RequiredEntityData, Ref, EntityType, EntityDTO, MergeSelected, FromEntityType, IsSubset, MergeLoaded, ArrayElement } from '../typings';
-import type { CountOptions, DeleteOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, NativeInsertUpdateOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from '../drivers/IDatabaseDriver';
-import type { EntityLoaderOptions } from './EntityLoader';
-import type { Cursor } from '../utils/Cursor';
+import type { PopulatePath } from '../enums.js';
+import type { CreateOptions, EntityManager, MergeOptions } from '../EntityManager.js';
+import type { AssignOptions } from './EntityAssigner.js';
+import type { EntityData, EntityName, Primary, Loaded, FilterQuery, EntityDictionary, AutoPath, RequiredEntityData, Ref, EntityType, EntityDTO, MergeSelected, FromEntityType, IsSubset, MergeLoaded, ArrayElement } from '../typings.js';
+import type { CountOptions, DeleteOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, NativeInsertUpdateOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from '../drivers/IDatabaseDriver.js';
+import type { EntityLoaderOptions } from './EntityLoader.js';
+import type { Cursor } from '../utils/Cursor.js';
 export declare class EntityRepository<Entity extends object> {
     protected readonly em: EntityManager;
     protected readonly entityName: EntityName<Entity>;

package/entity/EntityRepository.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityRepository = void 0;
-const errors_1 = require("../errors");
-const Utils_1 = require("../utils/Utils");
-class EntityRepository {
+import { ValidationError } from '../errors.js';
+import { Utils } from '../utils/Utils.js';
+export class EntityRepository {
     em;
     entityName;
     constructor(em, entityName) {
@@ -191,7 +188,7 @@ class EntityRepository {
         return this.getEntityManager().count(this.entityName, where, options);
     }
     getEntityName() {
-        return Utils_1.Utils.className(this.entityName);
+        return Utils.className(this.entityName);
     }
     /**
      * Returns the underlying EntityManager instance
@@ -200,15 +197,14 @@ class EntityRepository {
         return this.em;
     }
     validateRepositoryType(entities, method) {
-        entities = Utils_1.Utils.asArray(entities);
+        entities = Utils.asArray(entities);
         if (entities.length === 0) {
             return;
         }
         const entityName = entities[0].constructor.name;
-        const repoType = Utils_1.Utils.className(this.entityName);
+        const repoType = Utils.className(this.entityName);
         if (entityName && repoType !== entityName) {
-            throw errors_1.ValidationError.fromWrongRepositoryType(entityName, repoType, method);
+            throw ValidationError.fromWrongRepositoryType(entityName, repoType, method);
         }
     }
 }
-exports.EntityRepository = EntityRepository;

package/entity/EntityValidator.d.ts

@@ -1,4 +1,4 @@
-import type { EntityData, EntityMetadata, EntityProperty, FilterQuery } from '../typings';
+import type { EntityData, EntityMetadata, EntityProperty, FilterQuery } from '../typings.js';
 export declare class EntityValidator {
     private strict;
     KNOWN_TYPES: Set<string>;