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

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,31 +20,30 @@ 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 ??= {};
-        options.filters ??= {};
         options.lookup ??= true;
         options.validate ??= true;
         options.refresh ??= false;
         options.convertCustomTypes ??= true;
         if (references.length > 0) {
-            await this.populateScalar(meta, references, options);
+            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));
-        /* istanbul ignore next */
+        /* v8 ignore next */
         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 +58,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 +89,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 +118,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,24 +132,29 @@ 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()) {
-            return this.findChildrenFromPivotTable(filtered, prop, options, innerOrderBy, populate, !!ref);
-        }
         const where = await this.extractChildCondition(options, prop);
-        const data = await this.findChildren(entities, prop, populate, { ...options, where, orderBy: innerOrderBy }, !!(ref || prop.mapToPk));
-        this.initializeCollections(filtered, prop, field, data, innerOrderBy.length > 0);
-        return data;
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && this.driver.getPlatform().usesPivotTable()) {
+            const res = await this.findChildrenFromPivotTable(filtered, prop, options, innerOrderBy, populate, !!ref);
+            return Utils.flatten(res);
+        }
+        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);
+        return items;
     }
     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, 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, {
@@ -162,38 +163,38 @@ class EntityLoader {
             populate: [],
         });
     }
-    initializeCollections(filtered, prop, field, children, customOrder) {
-        if (prop.kind === enums_1.ReferenceKind.ONE_TO_MANY) {
-            this.initializeOneToMany(filtered, children, prop, field);
+    initializeCollections(filtered, prop, field, children, customOrder, partial) {
+        if (prop.kind === ReferenceKind.ONE_TO_MANY) {
+            this.initializeOneToMany(filtered, children, prop, field, partial);
         }
-        if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && !this.driver.getPlatform().usesPivotTable()) {
-            this.initializeManyToMany(filtered, children, prop, field, customOrder);
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && !this.driver.getPlatform().usesPivotTable()) {
+            this.initializeManyToMany(filtered, children, prop, field, customOrder, partial);
         }
     }
-    initializeOneToMany(filtered, children, prop, field) {
+    initializeOneToMany(filtered, children, prop, field, partial) {
         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();
-            entity[field].hydrate(map[key]);
+            const key = helper(entity).getSerializedPrimaryKey();
+            entity[field].hydrate(map[key], undefined, partial);
         }
     }
-    initializeManyToMany(filtered, children, prop, field, customOrder) {
+    initializeManyToMany(filtered, children, prop, field, customOrder, partial) {
         if (prop.mappedBy) {
             for (const entity of filtered) {
                 const items = children.filter(child => child[prop.mappedBy].contains(entity, false));
-                entity[field].hydrate(items, true);
+                entity[field].hydrate(items, true, partial);
             }
         }
         else { // owning side of M:N without pivot table needs to be reordered
@@ -203,48 +204,49 @@ class EntityLoader {
                 if (!customOrder) {
                     items.sort((a, b) => order.indexOf(a) - order.indexOf(b));
                 }
-                entity[field].hydrate(items, true);
+                entity[field].hydrate(items, true, partial);
             }
         }
     }
     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_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)) {
+        const partial = !Utils.isEmpty(prop.where) || !Utils.isEmpty(options.where);
+        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));
         }
         if (children.length === 0) {
-            return [];
+            return { items: [], partial };
         }
-        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 */
-        let { refresh, filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging, } = options;
+        let { refresh, filters, convertCustomTypes, lockMode, strategy, populateWhere = 'infer', connectionType, logging, } = options;
         /* eslint-enable prefer-const */
         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,30 +254,52 @@ 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)),
             // @ts-ignore not a public option, will be propagated to the populate call
             visited: options.visited,
         });
+        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();
+            for (const item of items) {
+                itemsMap.add(helper(item).getSerializedPrimaryKey());
+            }
+            for (const child of children) {
+                childrenMap.add(helper(child).getSerializedPrimaryKey());
+            }
+            for (const entity of entities) {
+                const key = helper(entity[prop.name] ?? {})?.getSerializedPrimaryKey();
+                if (childrenMap.has(key) && !itemsMap.has(key)) {
+                    entity[prop.name] = nullVal;
+                    helper(entity).__originalEntityData[prop.name] = null;
+                }
+            }
+        }
         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);
             }
         }
-        return items;
+        return { items, partial };
     }
     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,9 +307,10 @@ 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;
         }
+        options = { ...options, filters: QueryHelper.mergePropertyFilters(prop.filters, options.filters) };
         const populated = await this.populateMany(entityName, entities, populate, options);
         if (!populate.children && !populate.all) {
             return;
@@ -293,30 +318,38 @@ 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)));
-        await this.populate(prop.type, filtered, populate.children ?? populate.all, {
+        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 unique = Utils.unique(children);
+        const filtered = unique.filter(e => !visited.has(e));
+        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,
@@ -328,18 +361,22 @@ 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
             visited: options.visited,
+            // @ts-ignore not a public option
+            filtered,
         });
     }
+    /** @internal */
     async findChildrenFromPivotTable(filtered, prop, options, orderBy, populate, pivotJoin) {
         const ids = filtered.map(e => e.__helper.__primaryKeys);
         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 +384,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);
@@ -371,25 +408,25 @@ class EntityLoader {
                 return this.em.getUnitOfWork().register(entity, item, { refresh, loaded: true });
             });
             entity[prop.name].hydrate(items, true);
-            children.push(...items);
+            children.push(items);
         }
         return children;
     }
     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 +436,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 +454,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 +463,7 @@ class EntityLoader {
                 const parts = f.toString().split('.');
                 const propName = parts.shift();
                 const childPropName = parts.join('.');
-                /* istanbul ignore else */
+                /* v8 ignore next */
                 if (propName === prop.name) {
                     ret.push(childPropName);
                 }
@@ -437,7 +474,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);
@@ -447,61 +484,58 @@ 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) {
-            children.push(...filtered.map(e => e[prop.name].owner));
+        if (prop.kind === ReferenceKind.ONE_TO_MANY) {
+            return filtered.map(e => e[prop.name].owner);
         }
-        else if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && prop.owner) {
-            children.push(...filtered.reduce((a, b) => {
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner) {
+            return filtered.reduce((a, b) => {
                 a.push(...b[prop.name].getItems());
                 return a;
-            }, []));
-        }
-        else if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY) { // inverse side
-            children.push(...filtered);
+            }, []);
         }
-        else { // MANY_TO_ONE or ONE_TO_ONE
-            children.push(...this.filterReferences(entities, prop.name, options, ref));
+        if (prop.kind === ReferenceKind.MANY_TO_MANY) { // inverse side
+            return filtered;
         }
-        return children;
+        // MANY_TO_ONE or ONE_TO_ONE
+        return this.filterReferences(entities, prop.name, options, ref);
     }
     filterCollections(entities, field, options, ref) {
         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 */
+        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 +544,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 */
         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 +560,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 +603,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>;
@@ -80,7 +80,7 @@ export declare class EntityRepository<Entity extends object> {
     /**
      * @inheritDoc EntityManager.findByCursor
      */
-    findByCursor<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(where: FilterQuery<Entity>, options: FindByCursorOptions<Entity, Hint, Fields, Excludes>): Promise<Cursor<Entity, Hint, Fields, Excludes>>;
+    findByCursor<Hint extends string = never, Fields extends string = '*', Excludes extends string = never, IncludeCount extends boolean = true>(where: FilterQuery<Entity>, options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>): Promise<Cursor<Entity, Hint, Fields, Excludes, IncludeCount>>;
     /**
      * Finds all entities of given type. You can pass additional options via the `options` parameter.
      */