@mikro-orm/core 7.0.0-rc.3 → 7.0.1-dev.0

package/entity/EntityFactory.js

@@ -6,23 +6,23 @@ import { helper } from './wrap.js';
 import { EntityHelper } from './EntityHelper.js';
 import { JsonType } from '../types/JsonType.js';
 export class EntityFactory {
-    em;
-    driver;
-    platform;
-    config;
-    metadata;
-    hydrator;
-    eventManager;
-    comparator;
+    #driver;
+    #platform;
+    #config;
+    #metadata;
+    #hydrator;
+    #eventManager;
+    #comparator;
+    #em;
     constructor(em) {
-        this.em = em;
-        this.driver = this.em.getDriver();
-        this.platform = this.driver.getPlatform();
-        this.config = this.em.config;
-        this.metadata = this.em.getMetadata();
-        this.hydrator = this.config.getHydrator(this.metadata);
-        this.eventManager = this.em.getEventManager();
-        this.comparator = this.em.getComparator();
+        this.#em = em;
+        this.#driver = this.#em.getDriver();
+        this.#platform = this.#driver.getPlatform();
+        this.#config = this.#em.config;
+        this.#metadata = this.#em.getMetadata();
+        this.#hydrator = this.#config.getHydrator(this.#metadata);
+        this.#eventManager = this.#em.getEventManager();
+        this.#comparator = this.#em.getComparator();
     }
     create(entityName, data, options = {}) {
         data = Reference.unwrapReference(data);
@@ -30,7 +30,7 @@ export class EntityFactory {
         if (data.__entity) {
             return data;
         }
-        const meta = this.metadata.get(entityName);
+        const meta = this.#metadata.get(entityName);
         if (meta.virtual) {
             data = { ...data };
             const entity = this.createEntity(data, meta, options);
@@ -74,8 +74,8 @@ export class EntityFactory {
                             Utils.isPlainObject(data[prop.name])) {
                             data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                         }
-                        if (prop.customType instanceof JsonType && this.platform.convertsJsonAutomatically()) {
-                            data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, {
+                        if (prop.customType instanceof JsonType && this.#platform.convertsJsonAutomatically()) {
+                            data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.#platform, {
                                 key: prop.name,
                                 mode: 'hydration',
                             });
@@ -99,11 +99,11 @@ export class EntityFactory {
                 loaded: options.initialized,
             });
             if (options.recomputeSnapshot) {
-                wrapped.__originalEntityData = this.comparator.prepareEntity(entity);
+                wrapped.__originalEntityData = this.#comparator.prepareEntity(entity);
             }
         }
-        if (this.eventManager.hasListeners(EventType.onInit, meta2)) {
-            this.eventManager.dispatchEvent(EventType.onInit, { entity, meta: meta2, em: this.em });
+        if (this.#eventManager.hasListeners(EventType.onInit, meta2)) {
+            this.#eventManager.dispatchEvent(EventType.onInit, { entity, meta: meta2, em: this.#em });
         }
         wrapped.__processing = false;
         return entity;
@@ -111,16 +111,16 @@ export class EntityFactory {
     mergeData(meta, entity, data, options = {}) {
         // merge unchanged properties automatically
         data = QueryHelper.processParams(data);
-        const existsData = this.comparator.prepareEntity(entity);
+        const existsData = this.#comparator.prepareEntity(entity);
         const originalEntityData = helper(entity).__originalEntityData ?? {};
-        const diff = this.comparator.diffEntities(meta.class, originalEntityData, existsData);
+        const diff = this.#comparator.diffEntities(meta.class, originalEntityData, existsData);
         // version properties are not part of entity snapshots
         if (meta.versionProperty &&
             data[meta.versionProperty] &&
             data[meta.versionProperty] !== originalEntityData[meta.versionProperty]) {
             diff[meta.versionProperty] = data[meta.versionProperty];
         }
-        const diff2 = this.comparator.diffEntities(meta.class, existsData, data, { includeInverseSides: true });
+        const diff2 = this.#comparator.diffEntities(meta.class, existsData, data, { includeInverseSides: true });
         // do not override values changed by user
         Utils.keys(diff).forEach(key => delete diff2[key]);
         Utils.keys(diff2)
@@ -143,7 +143,7 @@ export class EntityFactory {
         const initialized = options.initialized || helper(entity).__initialized;
         this.hydrate(entity, meta, diff2, initialized ? { ...options, initialized } : options);
         // we need to update the entity data only with keys that were not present before
-        const nullVal = this.config.get('forceUndefined') ? undefined : null;
+        const nullVal = this.#config.get('forceUndefined') ? undefined : null;
         Utils.keys(diff2).forEach(key => {
             const prop = meta.properties[key];
             if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
@@ -155,8 +155,8 @@ export class EntityFactory {
                 [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE, ReferenceKind.SCALAR].includes(prop.kind) &&
                 prop.customType?.ensureComparable(meta, prop) &&
                 diff2[key] != null) {
-                const converted = prop.customType.convertToJSValue(diff2[key], this.platform, { force: true });
-                diff2[key] = prop.customType.convertToDatabaseValue(converted, this.platform, { fromQuery: true });
+                const converted = prop.customType.convertToJSValue(diff2[key], this.#platform, { force: true });
+                diff2[key] = prop.customType.convertToDatabaseValue(converted, this.#platform, { fromQuery: true });
             }
             originalEntityData[key] = diff2[key] === null ? nullVal : diff2[key];
             helper(entity).__loadedProperties.add(key);
@@ -183,8 +183,8 @@ export class EntityFactory {
     }
     createReference(entityName, id, options = {}) {
         options.convertCustomTypes ??= true;
-        const meta = this.metadata.get(entityName);
-        const schema = this.driver.getSchemaName(meta, options);
+        const meta = this.#metadata.get(entityName);
+        const schema = this.#driver.getSchemaName(meta, options);
         // Handle alternate key lookup
         if (options.key) {
             const value = '' + (Array.isArray(id) ? id[0] : Utils.isPlainObject(id) ? id[options.key] : id);
@@ -208,7 +208,7 @@ export class EntityFactory {
         if (Array.isArray(id)) {
             id = Utils.getPrimaryKeyCondFromArray(id, meta);
         }
-        const pks = Utils.getOrderedPrimaryKeys(id, meta, this.platform);
+        const pks = Utils.getOrderedPrimaryKeys(id, meta, this.#platform);
         const exists = this.unitOfWork.getById(entityName, pks, schema, options.convertCustomTypes);
         if (exists) {
             return exists;
@@ -220,15 +220,15 @@ export class EntityFactory {
     }
     createEmbeddable(entityName, data, options = {}) {
         data = { ...data };
-        const meta = this.metadata.get(entityName);
+        const meta = this.#metadata.get(entityName);
         const meta2 = this.processDiscriminatorColumn(meta, data);
         return this.createEntity(data, meta2, options);
     }
     getComparator() {
-        return this.comparator;
+        return this.#comparator;
     }
     createEntity(data, meta, options) {
-        const schema = this.driver.getSchemaName(meta, options);
+        const schema = this.#driver.getSchemaName(meta, options);
         if (options.newEntity || meta.forceConstructor || meta.virtual) {
             if (meta.polymorphs) {
                 throw new Error(`Cannot create entity ${meta.className}, class prototype is unknown`);
@@ -239,7 +239,7 @@ export class EntityFactory {
             const entity = new Entity(...params);
             // creating managed entity instance when `forceEntityConstructor` is enabled,
             // we need to wipe all the values as they would cause update queries on next flush
-            if (!options.newEntity && (meta.forceConstructor || this.config.get('forceEntityConstructor'))) {
+            if (!options.newEntity && (meta.forceConstructor || this.#config.get('forceEntityConstructor'))) {
                 meta.props
                     .filter(prop => prop.persist !== false && !prop.primary && data[prop.name] === undefined)
                     .forEach(prop => delete entity[prop.name]);
@@ -259,7 +259,7 @@ export class EntityFactory {
         helper(entity).__processing = !meta.embeddable && !meta.virtual;
         helper(entity).__schema = schema;
         if (options.merge && !options.newEntity) {
-            this.hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, options.schema, options.parentSchema);
+            this.#hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, options.schema, options.parentSchema);
             this.unitOfWork.register(entity);
         }
         if (options.initialized) {
@@ -270,35 +270,35 @@ export class EntityFactory {
     assignDefaultValues(entity, meta) {
         for (const prop of meta.props) {
             if (prop.onCreate) {
-                entity[prop.name] ??= prop.onCreate(entity, this.em);
+                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), options.normalizeAccessors);
+            this.#hydrator.hydrate(entity, meta, data, this, 'full', options.newEntity, options.convertCustomTypes, options.schema, this.#driver.getSchemaName(meta, options), options.normalizeAccessors);
         }
         else {
-            this.hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options), options.normalizeAccessors);
+            this.#hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, options.schema, this.#driver.getSchemaName(meta, options), options.normalizeAccessors);
         }
         Utils.keys(data).forEach(key => {
             helper(entity)?.__loadedProperties.add(key);
             helper(entity)?.__serializationContext.fields?.add(key);
         });
-        const processOnCreateHooksEarly = options.processOnCreateHooksEarly ?? this.config.get('processOnCreateHooksEarly');
+        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);
+        const schema = this.#driver.getSchemaName(meta, options);
         if (meta.simplePK) {
             return this.unitOfWork.getById(meta.class, data[meta.primaryKeys[0]], schema);
         }
         if (!Array.isArray(data) && meta.primaryKeys.some(pk => data[pk] == null)) {
             return undefined;
         }
-        const pks = Utils.getOrderedPrimaryKeys(data, meta, this.platform, options.convertCustomTypes);
+        const pks = Utils.getOrderedPrimaryKeys(data, meta, this.#platform, options.convertCustomTypes);
         return this.unitOfWork.getById(meta.class, pks, schema);
     }
     processDiscriminatorColumn(meta, data) {
@@ -307,7 +307,7 @@ export class EntityFactory {
             const prop = meta.properties[meta.root.discriminatorColumn];
             const value = data[prop.name];
             const type = meta.root.discriminatorMap[value];
-            meta = type ? this.metadata.get(type) : meta;
+            meta = type ? this.#metadata.get(type) : meta;
             return meta;
         }
         // Handle TPT discriminator (computed at query time)
@@ -315,7 +315,7 @@ export class EntityFactory {
             const value = data[meta.root.tptDiscriminatorColumn];
             if (value) {
                 const type = meta.root.discriminatorMap[value];
-                meta = type ? this.metadata.get(type) : meta;
+                meta = type ? this.#metadata.get(type) : meta;
             }
         }
         return meta;
@@ -330,7 +330,7 @@ export class EntityFactory {
             return;
         }
         if (pk.type === 'ObjectId' && (data[pk.name] != null || data[spk.name] != null)) {
-            data[pk.name] = this.platform.denormalizePrimaryKey((data[spk.name] || data[pk.name]));
+            data[pk.name] = this.#platform.denormalizePrimaryKey((data[spk.name] || data[pk.name]));
             delete data[spk.name];
         }
     }
@@ -380,18 +380,18 @@ export class EntityFactory {
                         tmp[prop.name] = Reference.wrapReference(this.create(prop.targetMeta.class, tmp[prop.name], options), prop);
                     }
                     else if (prop.kind === ReferenceKind.SCALAR) {
-                        tmp[prop.name] = prop.customType.convertToJSValue(tmp[prop.name], this.platform);
+                        tmp[prop.name] = prop.customType.convertToJSValue(tmp[prop.name], this.#platform);
                     }
                 }
                 return tmp;
             }
             if (options.convertCustomTypes && prop.customType && value != null) {
-                return prop.customType.convertToJSValue(value, this.platform);
+                return prop.customType.convertToJSValue(value, this.#platform);
             }
             return value;
         });
     }
     get unitOfWork() {
-        return this.em.getUnitOfWork(false);
+        return this.#em.getUnitOfWork(false);
     }
 }

package/entity/EntityLoader.d.ts

@@ -22,9 +22,7 @@ export interface EntityLoaderOptions<Entity, Fields extends string = PopulatePat
     logging?: LoggingOptions;
 }
 export declare class EntityLoader {
-    private readonly em;
-    private readonly metadata;
-    private readonly driver;
+    #private;
     constructor(em: EntityManager);
     /**
      * Loads specified relations in batch.

package/entity/EntityLoader.js

@@ -7,13 +7,13 @@ import { helper } from './wrap.js';
 import { expandDotPaths } from './utils.js';
 import { Raw } from '../utils/RawQueryFragment.js';
 export class EntityLoader {
-    em;
-    metadata;
-    driver;
+    #metadata;
+    #driver;
+    #em;
     constructor(em) {
-        this.em = em;
-        this.metadata = this.em.getMetadata();
-        this.driver = this.em.getDriver();
+        this.#em = em;
+        this.#metadata = this.#em.getMetadata();
+        this.#driver = this.#em.getDriver();
     }
     /**
      * Loads specified relations in batch.
@@ -23,7 +23,7 @@ export class EntityLoader {
         if (entities.length === 0 || Utils.isEmpty(populate)) {
             return this.setSerializationContext(entities, populate, options);
         }
-        const meta = this.metadata.find(entityName);
+        const meta = this.#metadata.find(entityName);
         if (entities.some(e => !e.__helper)) {
             const entity = entities.find(e => !Utils.isEntity(e));
             throw ValidationError.notDiscoveredEntity(entity, meta, 'populate');
@@ -40,7 +40,7 @@ export class EntityLoader {
             await this.populateScalar(meta, references, { ...options, populateWhere: undefined });
         }
         populate = this.normalizePopulate(entityName, populate, options.strategy, options.lookup, options.exclude);
-        const invalid = populate.find(({ field }) => !this.em.canPopulate(entityName, field));
+        const invalid = populate.find(({ field }) => !this.#em.canPopulate(entityName, field));
         /* v8 ignore next */
         if (options.validate && invalid) {
             throw ValidationError.invalidPropertyName(entityName, invalid.field);
@@ -57,7 +57,7 @@ export class EntityLoader {
         }
     }
     normalizePopulate(entityName, populate, strategy, lookup = true, exclude) {
-        const meta = this.metadata.find(entityName);
+        const meta = this.#metadata.find(entityName);
         let normalized = Utils.asArray(populate).map(field => {
             // oxfmt-ignore
             return typeof field === 'boolean' || field.field === PopulatePath.ALL ? { all: !!field, field: meta.primaryKeys[0] } : field;
@@ -118,9 +118,9 @@ export class EntityLoader {
      */
     async populateMany(entityName, entities, populate, options) {
         const [field, ref] = populate.field.split(':', 2);
-        const meta = this.metadata.find(entityName);
+        const meta = this.#metadata.find(entityName);
         const prop = meta.properties[field];
-        if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !this.driver.getPlatform().usesPivotTable()) {
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !this.#driver.getPlatform().usesPivotTable()) {
             const filtered = entities.filter(e => !e[prop.name]?.isInitialized());
             if (filtered.length > 0) {
                 await this.populateScalar(meta, filtered, { ...options, fields: [prop.name] });
@@ -144,7 +144,7 @@ export class EntityLoader {
             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()) {
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && this.#driver.getPlatform().usesPivotTable()) {
             const pivotOrderBy = QueryHelper.mergeOrderBy(innerOrderBy, prop.orderBy, prop.targetMeta?.orderBy);
             const res = await this.findChildrenFromPivotTable(filtered, prop, options, pivotOrderBy, populate, !!ref);
             return Utils.flatten(res);
@@ -164,9 +164,9 @@ export class EntityLoader {
     async populateScalar(meta, filtered, options) {
         const pk = Utils.getPrimaryKeyHash(meta.primaryKeys);
         const ids = Utils.unique(filtered.map(e => Utils.getPrimaryKeyValues(e, meta, true)));
-        const where = this.mergePrimaryCondition(ids, pk, options, meta, this.metadata, this.driver.getPlatform());
+        const where = this.mergePrimaryCondition(ids, pk, options, meta, this.#metadata, this.#driver.getPlatform());
         const { filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging, fields } = options;
-        await this.em.find(meta.class, where, {
+        await this.#em.find(meta.class, where, {
             filters,
             convertCustomTypes,
             lockMode,
@@ -179,7 +179,7 @@ export class EntityLoader {
         });
     }
     async populatePolymorphic(entities, prop, options, ref) {
-        const ownerMeta = this.metadata.get(entities[0].constructor);
+        const ownerMeta = this.#metadata.get(entities[0].constructor);
         // Separate entities: those with loaded refs vs those needing FK load
         const toPopulate = [];
         const needsFkLoad = [];
@@ -230,7 +230,7 @@ export class EntityLoader {
         // Load each group concurrently - identity map handles merging with existing references
         const allItems = [];
         await Promise.all([...groups].map(async ([discriminator, children]) => {
-            const targetMeta = this.metadata.find(prop.discriminatorMap[discriminator]);
+            const targetMeta = this.#metadata.find(prop.discriminatorMap[discriminator]);
             await this.populateScalar(targetMeta, children, options);
             allItems.push(...children);
         }));
@@ -240,7 +240,7 @@ export class EntityLoader {
         if (prop.kind === ReferenceKind.ONE_TO_MANY) {
             this.initializeOneToMany(filtered, children, prop, field, partial);
         }
-        if (prop.kind === ReferenceKind.MANY_TO_MANY && !this.driver.getPlatform().usesPivotTable()) {
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && !this.#driver.getPlatform().usesPivotTable()) {
             this.initializeManyToMany(filtered, children, prop, field, customOrder, partial);
         }
     }
@@ -254,7 +254,7 @@ export class EntityLoader {
         for (const child of children) {
             const pk = child.__helper.__data[prop.mappedBy] ?? child[prop.mappedBy];
             if (pk) {
-                const key = helper(mapToPk ? this.em.getReference(prop.targetMeta.class, pk) : pk).getSerializedPrimaryKey();
+                const key = helper(mapToPk ? this.#em.getReference(prop.targetMeta.class, pk) : pk).getSerializedPrimaryKey();
                 map[key]?.push(child);
             }
         }
@@ -322,10 +322,10 @@ export class EntityLoader {
             where = (conditions.length === 1 ? conditions[0] : { $or: conditions });
         }
         else {
-            where = this.mergePrimaryCondition(ids, fk, options, meta, this.metadata, this.driver.getPlatform());
+            where = this.mergePrimaryCondition(ids, fk, options, meta, this.#metadata, this.#driver.getPlatform());
         }
         if (polymorphicOwnerProp) {
-            const parentMeta = this.metadata.find(entities[0].constructor);
+            const parentMeta = this.#metadata.find(entities[0].constructor);
             const discriminatorValue = QueryHelper.findDiscriminatorValue(polymorphicOwnerProp.discriminatorMap, parentMeta.class) ??
                 parentMeta.tableName;
             const discriminatorColumn = polymorphicOwnerProp.fieldNames[0];
@@ -342,7 +342,7 @@ export class EntityLoader {
             where = { $and: [where, prop.where] };
         }
         const orderBy = QueryHelper.mergeOrderBy(options.orderBy, prop.orderBy);
-        const items = await this.em.find(meta.class, where, {
+        const items = await this.#em.find(meta.class, where, {
             filters,
             convertCustomTypes,
             lockMode,
@@ -385,7 +385,7 @@ export class EntityLoader {
             }
         }
         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 nullVal = this.#em.config.get('forceUndefined') ? undefined : null;
             const itemsMap = new Set();
             const childrenMap = new Set();
             // Use targetKey value if set, otherwise use serialized PK
@@ -409,8 +409,7 @@ export class EntityLoader {
         for (const item of items) {
             if (ref && !helper(item).__onLoadFired) {
                 helper(item).__initialized = false;
-                // eslint-disable-next-line dot-notation
-                this.em.getUnitOfWork()['loadedEntities'].delete(item);
+                this.#em.getUnitOfWork().unmarkAsLoaded(item);
             }
         }
         return { items, partial };
@@ -429,7 +428,7 @@ export class EntityLoader {
     }
     async populateField(entityName, entities, populate, options) {
         const field = populate.field.split(':')[0];
-        const prop = this.metadata.find(entityName).properties[field];
+        const prop = this.#metadata.find(entityName).properties[field];
         if (prop.kind === ReferenceKind.SCALAR && !prop.lazy) {
             return;
         }
@@ -522,29 +521,27 @@ export class EntityLoader {
         const options2 = { ...options, fields, exclude, populateFilter };
         ['limit', 'offset', 'first', 'last', 'before', 'after', 'overfetch'].forEach(prop => delete options2[prop]);
         options2.populate = populate?.children ?? [];
-        if (prop.customType) {
-            ids.forEach((id, idx) => (ids[idx] = QueryHelper.processCustomType(prop, id, this.driver.getPlatform())));
-        }
         if (!Utils.isEmpty(prop.where)) {
             where = { $and: [where, prop.where] };
         }
-        const map = await this.driver.loadFromPivotTable(prop, ids, where, orderBy, this.em.getTransactionContext(), options2, pivotJoin);
+        const map = await this.#driver.loadFromPivotTable(prop, ids, where, orderBy, this.#em.getTransactionContext(), options2, pivotJoin);
         const children = [];
-        for (const entity of filtered) {
-            const items = map[entity.__helper.getSerializedPrimaryKey()].map(item => {
+        for (let i = 0; i < filtered.length; i++) {
+            const entity = filtered[i];
+            const items = map[Utils.getPrimaryKeyHash(ids[i])].map(item => {
                 if (pivotJoin) {
-                    return this.em.getReference(prop.targetMeta.class, item, {
+                    return this.#em.getReference(prop.targetMeta.class, item, {
                         convertCustomTypes: true,
-                        schema: options.schema ?? this.em.config.get('schema'),
+                        schema: options.schema ?? this.#em.config.get('schema'),
                     });
                 }
-                const entity = this.em.getEntityFactory().create(prop.targetMeta.class, item, {
+                const entity = this.#em.getEntityFactory().create(prop.targetMeta.class, item, {
                     refresh,
                     merge: true,
                     convertCustomTypes: true,
-                    schema: options.schema ?? this.em.config.get('schema'),
+                    schema: options.schema ?? this.#em.config.get('schema'),
                 });
-                return this.em.getUnitOfWork().register(entity, item, { refresh, loaded: true });
+                return this.#em.getUnitOfWork().register(entity, item, { refresh, loaded: true });
             });
             entity[prop.name].hydrate(items, true);
             children.push(items);
@@ -582,7 +579,7 @@ export class EntityLoader {
             });
         }
         if (filters) {
-            return this.em.applyFilters(meta2.class, subCond, options.filters, 'read', options);
+            return this.#em.applyFilters(meta2.class, subCond, options.filters, 'read', options);
         }
         return subCond;
     }
@@ -695,7 +692,7 @@ export class EntityLoader {
     }
     lookupAllRelationships(entityName) {
         const ret = [];
-        const meta = this.metadata.find(entityName);
+        const meta = this.#metadata.find(entityName);
         meta.relations.forEach(prop => {
             ret.push({
                 field: this.getRelationName(meta, prop),
@@ -714,7 +711,7 @@ export class EntityLoader {
         return `${this.getRelationName(meta, meta.properties[prop.embedded[0]])}.${prop.embedded[1]}`;
     }
     lookupEagerLoadedRelationships(entityName, populate, strategy, prefix = '', visited = [], exclude) {
-        const meta = this.metadata.find(entityName);
+        const meta = this.#metadata.find(entityName);
         if (!meta && !prefix) {
             return populate;
         }

package/entity/Reference.d.ts

@@ -44,10 +44,9 @@ export declare class Reference<T extends object> {
     toJSON(...args: any[]): Dictionary;
 }
 export declare class ScalarReference<Value> {
+    #private;
     private value?;
-    private initialized;
     private entity?;
-    private property?;
     constructor(value?: Value | undefined, initialized?: boolean);
     /**
      * Ensures the underlying entity is loaded first (without reloading it if it already is loaded).

package/entity/Reference.js

@@ -162,12 +162,12 @@ export class Reference {
 }
 export class ScalarReference {
     value;
-    initialized;
     entity;
-    property;
+    #property;
+    #initialized;
     constructor(value, initialized = value != null) {
         this.value = value;
-        this.initialized = initialized;
+        this.#initialized = initialized;
     }
     /**
      * Ensures the underlying entity is loaded first (without reloading it if it already is loaded).
@@ -175,11 +175,11 @@ export class ScalarReference {
      */
     async load(options) {
         const opts = typeof options === 'object' ? options : { prop: options };
-        if (!this.initialized || opts.refresh) {
-            if (this.entity == null || this.property == null) {
+        if (!this.#initialized || opts.refresh) {
+            if (this.entity == null || this.#property == null) {
                 throw new Error('Cannot load scalar reference that is not bound to an entity property.');
             }
-            await helper(this.entity).populate([this.property], opts);
+            await helper(this.entity).populate([this.#property], opts);
         }
         return this.value;
     }
@@ -193,29 +193,29 @@ export class ScalarReference {
             const wrapped = helper(this.entity);
             options.failHandler ??= wrapped.__em.config.get('findOneOrFailHandler');
             const entityName = this.entity.constructor.name;
-            throw NotFoundError.failedToLoadProperty(entityName, this.property, wrapped.getPrimaryKey());
+            throw NotFoundError.failedToLoadProperty(entityName, this.#property, wrapped.getPrimaryKey());
         }
         return ret;
     }
     set(value) {
         this.value = value;
-        this.initialized = true;
+        this.#initialized = true;
     }
     bind(entity, property) {
         this.entity = entity;
-        this.property = property;
+        this.#property = property;
         Object.defineProperty(this, 'entity', { enumerable: false, value: entity });
     }
     unwrap() {
         return this.value;
     }
     isInitialized() {
-        return this.initialized;
+        return this.#initialized;
     }
     /** @ignore */
     /* v8 ignore next */
     [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.initialized ? `Ref<${inspect(this.value)}>` : `Ref<?>`;
+        return this.#initialized ? `Ref<${inspect(this.value)}>` : `Ref<?>`;
     }
 }
 Object.defineProperties(Reference.prototype, {

package/entity/WrappedEntity.d.ts

@@ -8,6 +8,8 @@ import type { EntityIdentifier } from './EntityIdentifier.js';
 import type { SerializationContext } from '../serialization/SerializationContext.js';
 import { type SerializeOptions } from '../serialization/EntitySerializer.js';
 import type { FindOneOptions, LoadHint } from '../drivers/IDatabaseDriver.js';
+import type { Platform } from '../platforms/Platform.js';
+import type { Configuration } from '../utils/Configuration.js';
 export declare class WrappedEntity<Entity extends object> {
     __initialized: boolean;
     __populated?: boolean;
@@ -58,7 +60,7 @@ export declare class WrappedEntity<Entity extends object> {
     setPrimaryKey(id: Primary<Entity> | null): void;
     getSerializedPrimaryKey(): string;
     get __meta(): EntityMetadata<Entity>;
-    get __platform(): import("../index.js").Platform;
-    get __config(): import("../index.js").Configuration<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("../index.js").Connection>, EntityManager<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("../index.js").Connection>>>;
+    get __platform(): Platform;
+    get __config(): Configuration;
     get __primaryKeys(): Primary<Entity>[];
 }