@mikro-orm/core 7.0.0-dev.3 → 7.0.0-dev.31

package/entity/EntityFactory.js

@@ -45,6 +45,7 @@ export class EntityFactory {
         let wrapped = exists && helper(exists);
         if (wrapped && !options.refresh) {
             wrapped.__processing = true;
+            Utils.dropUndefinedProperties(data);
             this.mergeData(meta2, exists, data, options);
             wrapped.__processing = false;
             if (wrapped.isInitialized()) {
@@ -70,7 +71,7 @@ export class EntityFactory {
                             continue;
                         }
                         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
-                            data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
+                            data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                         }
                         data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, { key: prop.name, mode: 'hydration' });
                     }
@@ -86,7 +87,9 @@ export class EntityFactory {
         }
         if (options.merge && wrapped.hasPrimaryKey()) {
             this.unitOfWork.register(entity, data, {
-                refresh: options.refresh && options.initialized,
+                // Always refresh to ensure the payload is in correct shape for joined strategy. When loading nested relations,
+                // they will be created early without `Type.ensureComparable` being properly handled, resulting in extra updates.
+                refresh: options.initialized,
                 newEntity: options.newEntity,
                 loaded: options.initialized,
             });
@@ -110,7 +113,7 @@ export class EntityFactory {
         if (meta.versionProperty && data[meta.versionProperty] && data[meta.versionProperty] !== originalEntityData[meta.versionProperty]) {
             diff[meta.versionProperty] = data[meta.versionProperty];
         }
-        const diff2 = this.comparator.diffEntities(meta.className, existsData, data);
+        const diff2 = this.comparator.diffEntities(meta.className, existsData, data, { includeInverseSides: true });
         // do not override values changed by user
         Utils.keys(diff).forEach(key => delete diff2[key]);
         Utils.keys(diff2).filter(key => {
@@ -168,8 +171,8 @@ export class EntityFactory {
         if (Array.isArray(id)) {
             id = Utils.getPrimaryKeyCondFromArray(id, meta);
         }
-        const pks = Utils.getOrderedPrimaryKeys(id, meta, this.platform, options.convertCustomTypes);
-        const exists = this.unitOfWork.getById(entityName, pks, schema);
+        const pks = Utils.getOrderedPrimaryKeys(id, meta, this.platform);
+        const exists = this.unitOfWork.getById(entityName, pks, schema, options.convertCustomTypes);
         if (exists) {
             return exists;
         }
@@ -228,6 +231,13 @@ export class EntityFactory {
         }
         return entity;
     }
+    assignDefaultValues(entity, meta) {
+        for (const prop of meta.props) {
+            if (prop.onCreate) {
+                entity[prop.name] ??= prop.onCreate(entity, this.em);
+            }
+        }
+    }
     hydrate(entity, meta, data, options) {
         if (options.initialized) {
             this.hydrator.hydrate(entity, meta, data, this, 'full', options.newEntity, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options));
@@ -239,6 +249,10 @@ export class EntityFactory {
             helper(entity)?.__loadedProperties.add(key);
             helper(entity)?.__serializationContext.fields?.add(key);
         });
+        const processOnCreateHooksEarly = options.processOnCreateHooksEarly ?? this.config.get('processOnCreateHooksEarly');
+        if (options.newEntity && processOnCreateHooksEarly) {
+            this.assignDefaultValues(entity, meta);
+        }
     }
     findEntity(data, meta, options) {
         const schema = this.driver.getSchemaName(meta, options);
@@ -248,7 +262,7 @@ export class EntityFactory {
         if (!Array.isArray(data) && meta.primaryKeys.some(pk => data[pk] == null)) {
             return undefined;
         }
-        const pks = Utils.getOrderedPrimaryKeys(data, meta, this.platform);
+        const pks = Utils.getOrderedPrimaryKeys(data, meta, this.platform, options.convertCustomTypes);
         return this.unitOfWork.getById(meta.className, pks, schema);
     }
     processDiscriminatorColumn(meta, data) {
@@ -282,7 +296,7 @@ export class EntityFactory {
         return meta.constructorParams.map(k => {
             if (meta.properties[k] && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(meta.properties[k].kind) && data[k]) {
                 const pk = Reference.unwrapReference(data[k]);
-                const entity = this.unitOfWork.getById(meta.properties[k].type, pk, options.schema);
+                const entity = this.unitOfWork.getById(meta.properties[k].type, pk, options.schema, true);
                 if (entity) {
                     return entity;
                 }

package/entity/EntityHelper.js

@@ -146,10 +146,13 @@ export class EntityHelper {
             set(val) {
                 const entity = Reference.unwrapReference(val ?? wrapped.__data[prop.name]);
                 const old = Reference.unwrapReference(wrapped.__data[prop.name]);
+                if (old && old !== entity && prop.kind === ReferenceKind.MANY_TO_ONE && prop.inversedBy && old[prop.inversedBy]) {
+                    old[prop.inversedBy].removeWithoutPropagation(this);
+                }
                 wrapped.__data[prop.name] = Reference.wrapReference(val, prop);
                 // when propagation from inside hydration, we set the FK to the entity data immediately
                 if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
-                    wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta.primaryKeys, true);
+                    wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta, true);
                 }
                 else {
                     wrapped.__touched = !hydrator.isRunning();
@@ -169,6 +172,9 @@ export class EntityHelper {
                 continue;
             }
             const inverse = value?.[prop2.name];
+            if (Utils.isCollection(inverse) && inverse.isPartial()) {
+                continue;
+            }
             if (prop.kind === ReferenceKind.MANY_TO_ONE && Utils.isCollection(inverse) && inverse.isInitialized()) {
                 inverse.addWithoutPropagation(owner);
                 helper(owner).__em?.getUnitOfWork().cancelOrphanRemoval(owner);
@@ -207,6 +213,7 @@ export class EntityHelper {
         }
         if (old?.[prop2.name] != null) {
             delete helper(old).__data[prop2.name];
+            old[prop2.name] = null;
         }
     }
     static ensurePropagation(entity) {

package/entity/EntityLoader.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionType, Dictionary, FilterQuery, PopulateOptions } from '../typings.js';
+import type { AnyEntity, ConnectionType, Dictionary, EntityProperty, FilterQuery, PopulateOptions } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
 import { LoadStrategy, type LockMode, type PopulateHint, PopulatePath, type QueryOrderMap } from '../enums.js';
 import type { EntityField } from '../drivers/IDatabaseDriver.js';
@@ -49,7 +49,8 @@ export declare class EntityLoader {
     private findChildren;
     private mergePrimaryCondition;
     private populateField;
-    private findChildrenFromPivotTable;
+    /** @internal */
+    findChildrenFromPivotTable<Entity extends object>(filtered: Entity[], prop: EntityProperty<Entity>, options: Required<EntityLoaderOptions<Entity>>, orderBy?: QueryOrderMap<Entity>[], populate?: PopulateOptions<Entity>, pivotJoin?: boolean): Promise<AnyEntity[][]>;
     private extractChildCondition;
     private buildFields;
     private getChildReferences;

package/entity/EntityLoader.js

@@ -38,7 +38,7 @@ export class EntityLoader {
         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));
@@ -140,17 +140,22 @@ export class EntityLoader {
         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]);
+        const where = await this.extractChildCondition(options, prop);
         if (prop.kind === ReferenceKind.MANY_TO_MANY && this.driver.getPlatform().usesPivotTable()) {
-            return this.findChildrenFromPivotTable(filtered, prop, options, innerOrderBy, populate, !!ref);
+            const res = await this.findChildrenFromPivotTable(filtered, prop, options, innerOrderBy, populate, !!ref);
+            return Utils.flatten(res);
         }
-        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;
+        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.getPrimaryKeyHash(meta.primaryKeys);
-        const ids = Utils.unique(filtered.map(e => Utils.getPrimaryKeyValues(e, meta.primaryKeys, true)));
+        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, {
@@ -159,15 +164,15 @@ export class EntityLoader {
             populate: [],
         });
     }
-    initializeCollections(filtered, prop, field, children, customOrder) {
+    initializeCollections(filtered, prop, field, children, customOrder, partial) {
         if (prop.kind === ReferenceKind.ONE_TO_MANY) {
-            this.initializeOneToMany(filtered, children, prop, field);
+            this.initializeOneToMany(filtered, children, prop, field, partial);
         }
         if (prop.kind === ReferenceKind.MANY_TO_MANY && !this.driver.getPlatform().usesPivotTable()) {
-            this.initializeManyToMany(filtered, children, prop, field, customOrder);
+            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) {
@@ -183,14 +188,14 @@ export class EntityLoader {
         }
         for (const entity of filtered) {
             const key = helper(entity).getSerializedPrimaryKey();
-            entity[field].hydrate(map[key]);
+            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
@@ -200,7 +205,7 @@ export 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);
             }
         }
     }
@@ -209,6 +214,7 @@ export class EntityLoader {
         const meta = prop.targetMeta;
         let fk = Utils.getPrimaryKeyHash(meta.primaryKeys);
         let schema = options.schema;
+        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;
         }
@@ -218,7 +224,7 @@ export class EntityLoader {
             children.push(...this.filterByReferences(entities, prop.name, options.refresh));
         }
         if (children.length === 0) {
-            return [];
+            return { items: [], partial };
         }
         if (!schema && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind)) {
             schema = children.find(e => e.__helper.__schema)?.__helper.__schema;
@@ -227,7 +233,7 @@ export class EntityLoader {
         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);
@@ -249,9 +255,13 @@ export 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.asArray(options.orderBy), ...propOrderBy],
+            orderBy,
             populate: populate.children ?? populate.all ?? [],
             exclude: Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude,
             strategy, fields, schema, connectionType,
@@ -267,7 +277,7 @@ export class EntityLoader {
                 this.em.getUnitOfWork()['loadedEntities'].delete(item);
             }
         }
-        return items;
+        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 });
@@ -310,10 +320,18 @@ export class EntityLoader {
         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 { refresh, filters, ignoreLazyScalarProperties, populateWhere, connectionType, logging, schema } = options;
         const exclude = Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude;
-        const filtered = Utils.unique(children.filter(e => !options.visited.has(e)));
-        await this.populate(prop.type, filtered, populate.children ?? populate.all, {
+        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,
@@ -325,12 +343,16 @@ export 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;
@@ -368,7 +390,7 @@ export 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;
     }
@@ -444,23 +466,20 @@ export class EntityLoader {
     }
     getChildReferences(entities, prop, options, ref) {
         const filtered = this.filterCollections(entities, prop.name, options, ref);
-        const children = [];
         if (prop.kind === ReferenceKind.ONE_TO_MANY) {
-            children.push(...filtered.map(e => e[prop.name].owner));
+            return filtered.map(e => e[prop.name].owner);
         }
-        else if (prop.kind === 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 === ReferenceKind.MANY_TO_MANY) { // inverse side
-            children.push(...filtered);
+        if (prop.kind === ReferenceKind.MANY_TO_MANY) { // inverse side
+            return filtered;
         }
-        else { // MANY_TO_ONE or ONE_TO_ONE
-            children.push(...this.filterReferences(entities, prop.name, options, ref));
-        }
-        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) {
@@ -514,7 +533,7 @@ export class EntityLoader {
         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 = [];

package/entity/EntityRepository.d.ts

@@ -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.
      */

package/entity/EntityValidator.js

@@ -11,7 +11,7 @@ export class EntityValidator {
     }
     validate(entity, payload, meta) {
         meta.props.forEach(prop => {
-            if (prop.inherited) {
+            if (prop.inherited || (prop.persist === false && prop.userDefined !== false)) {
                 return;
             }
             if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {

package/entity/Reference.d.ts

@@ -1,5 +1,5 @@
 import { inspect } from 'node:util';
-import type { AddEager, Dictionary, EntityClass, EntityKey, EntityProperty, Loaded, LoadedReference, Primary, Ref } from '../typings.js';
+import type { AddEager, AddOptional, Dictionary, EntityClass, EntityKey, EntityProperty, Loaded, LoadedReference, Primary, Ref } from '../typings.js';
 import type { FindOneOptions, FindOneOrFailOptions } from '../drivers/IDatabaseDriver.js';
 export declare class Reference<T extends object> {
     private entity;
@@ -56,6 +56,11 @@ export declare class ScalarReference<Value> {
      * Returns either the whole entity, or the requested property.
      */
     load(options?: Omit<LoadReferenceOptions<any, any>, 'populate' | 'fields' | 'exclude'>): Promise<Value | undefined>;
+    /**
+     * Ensures the underlying entity is loaded first (without reloading it if it already is loaded).
+     * Returns the entity or throws an error just like `em.findOneOrFail()` (and respects the same config options).
+     */
+    loadOrFail(options?: Omit<LoadReferenceOrFailOptions<any, any>, 'populate' | 'fields' | 'exclude'>): Promise<Value>;
     set(value: Value): void;
     bind<Entity extends object>(entity: Entity, property: EntityKey<Entity>): void;
     unwrap(): Value | undefined;
@@ -72,15 +77,11 @@ export interface LoadReferenceOrFailOptions<T extends object, P extends string =
 /**
  * shortcut for `wrap(entity).toReference()`
  */
-export declare function ref<T>(entity: T | Ref<T>): Ref<T> & LoadedReference<Loaded<T, AddEager<T>>>;
+export declare function ref<I extends unknown | Ref<unknown> | undefined | null, T extends I & {}>(entity: I): Ref<T> & LoadedReference<Loaded<T, AddEager<T>>> | AddOptional<typeof entity>;
 /**
  * shortcut for `Reference.createFromPK(entityType, pk)`
  */
-export declare function ref<T, PKV extends Primary<T> = Primary<T>>(entityType: EntityClass<T>, pk?: T | PKV): Ref<T>;
-/**
- * shortcut for `wrap(entity).toReference()`
- */
-export declare function ref<T>(value: T | Ref<T>): Ref<T> & LoadedReference<Loaded<T, AddEager<T>>>;
+export declare function ref<I extends unknown | undefined | null, T, PKV extends Primary<T> = Primary<T>>(entityType: EntityClass<T>, pk: I): Ref<T> | AddOptional<typeof pk>;
 /**
  * shortcut for `Reference.createNakedFromPK(entityType, pk)`
  */

package/entity/Reference.js

@@ -2,6 +2,7 @@ import { inspect } from 'node:util';
 import { DataloaderType } from '../enums.js';
 import { helper, wrap } from './wrap.js';
 import { Utils } from '../utils/Utils.js';
+import { NotFoundError } from '../errors.js';
 export class Reference {
     entity;
     constructor(entity) {
@@ -33,10 +34,15 @@ export class Reference {
     }
     static createFromPK(entityType, pk, options) {
         const ref = this.createNakedFromPK(entityType, pk, options);
-        return helper(ref).toReference();
+        return helper(ref)?.toReference() ?? ref;
     }
     static createNakedFromPK(entityType, pk, options) {
         const factory = entityType.prototype.__factory;
+        if (!factory) {
+            // this can happen only if `ref()` is used as a property initializer, and the value is important only for the
+            // inference of defaults, so it's fine to return it directly without wrapping with `Reference` class
+            return pk;
+        }
         const entity = factory.createReference(entityType, pk, {
             merge: false,
             convertCustomTypes: false,
@@ -171,6 +177,21 @@ export class ScalarReference {
         }
         return this.value;
     }
+    /**
+     * Ensures the underlying entity is loaded first (without reloading it if it already is loaded).
+     * Returns the entity or throws an error just like `em.findOneOrFail()` (and respects the same config options).
+     */
+    async loadOrFail(options = {}) {
+        const ret = await this.load(options);
+        if (!ret) {
+            const wrapped = helper(this.entity);
+            options.failHandler ??= wrapped.__em.config.get('findOneOrFailHandler');
+            const entityName = this.entity.constructor.name;
+            const where = wrapped.getPrimaryKey();
+            throw new NotFoundError(`${entityName} (${where}) failed to load property '${this.property}'`);
+        }
+        return ret;
+    }
     set(value) {
         this.value = value;
         this.initialized = true;

package/entity/WrappedEntity.js

@@ -150,7 +150,7 @@ export class WrappedEntity {
         return this.__em?.config ?? this.entity.__config;
     }
     get __primaryKeys() {
-        return Utils.getPrimaryKeyValues(this.entity, this.__meta.primaryKeys);
+        return Utils.getPrimaryKeyValues(this.entity, this.__meta);
     }
     /** @ignore */
     [inspect.custom]() {