@mikro-orm/core 7.0.0-rc.2 → 7.0.0

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,13 +23,13 @@ export class EntityLoader {
         if (entities.length === 0 || Utils.isEmpty(populate)) {
             return this.setSerializationContext(entities, populate, options);
         }
-        const meta = this.metadata.find(entityName);
+        const meta = this.#metadata.find(entityName);
         if (entities.some(e => !e.__helper)) {
             const entity = entities.find(e => !Utils.isEntity(e));
             throw ValidationError.notDiscoveredEntity(entity, meta, 'populate');
         }
         const references = entities.filter(e => !helper(e).isInitialized());
-        const visited = options.visited ??= new Set();
+        const visited = (options.visited ??= new Set());
         options.where ??= {};
         options.orderBy ??= {};
         options.lookup ??= true;
@@ -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,8 +57,9 @@ 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;
         });
         if (normalized.some(p => p.all)) {
@@ -89,6 +90,7 @@ export class EntityLoader {
      */
     mergeNestedPopulate(populate) {
         const tmp = populate.reduce((ret, item) => {
+            /* v8 ignore next */
             if (item.field === PopulatePath.ALL) {
                 return ret;
             }
@@ -116,16 +118,17 @@ export class EntityLoader {
      */
     async populateMany(entityName, entities, populate, options) {
         const [field, ref] = populate.field.split(':', 2);
-        const meta = this.metadata.find(entityName);
+        const meta = this.#metadata.find(entityName);
         const prop = meta.properties[field];
-        if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !this.driver.getPlatform().usesPivotTable()) {
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !this.#driver.getPlatform().usesPivotTable()) {
             const filtered = entities.filter(e => !e[prop.name]?.isInitialized());
             if (filtered.length > 0) {
                 await this.populateScalar(meta, filtered, { ...options, fields: [prop.name] });
             }
         }
         if (prop.kind === ReferenceKind.SCALAR && prop.lazy) {
-            const filtered = entities.filter(e => options.refresh || (prop.ref ? !e[prop.name]?.isInitialized() : e[prop.name] === undefined));
+            const filtered = entities.filter(e => options.refresh ||
+                (prop.ref ? !e[prop.name]?.isInitialized() : e[prop.name] === undefined));
             if (options.ignoreLazyScalarProperties || filtered.length === 0) {
                 return entities;
             }
@@ -137,10 +140,11 @@ export class EntityLoader {
         }
         const filtered = this.filterCollections(entities, field, options, ref);
         const innerOrderBy = Utils.asArray(options.orderBy)
-            .filter(orderBy => (Array.isArray(orderBy[prop.name]) && orderBy[prop.name].length > 0) || Utils.isObject(orderBy[prop.name]))
+            .filter(orderBy => (Array.isArray(orderBy[prop.name]) && orderBy[prop.name].length > 0) ||
+            Utils.isObject(orderBy[prop.name]))
             .flatMap(orderBy => orderBy[prop.name]);
         const where = await this.extractChildCondition(options, prop);
-        if (prop.kind === ReferenceKind.MANY_TO_MANY && this.driver.getPlatform().usesPivotTable()) {
+        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);
@@ -160,16 +164,22 @@ 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, {
-            filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging,
+        await this.#em.find(meta.class, where, {
+            filters,
+            convertCustomTypes,
+            lockMode,
+            strategy,
+            populateWhere,
+            connectionType,
+            logging,
             fields: fields,
             populate: [],
         });
     }
     async populatePolymorphic(entities, prop, options, ref) {
-        const ownerMeta = this.metadata.get(entities[0].constructor);
+        const ownerMeta = this.#metadata.get(entities[0].constructor);
         // Separate entities: those with loaded refs vs those needing FK load
         const toPopulate = [];
         const needsFkLoad = [];
@@ -220,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);
         }));
@@ -230,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);
         }
     }
@@ -244,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);
             }
         }
@@ -260,7 +270,8 @@ export class EntityLoader {
                 entity[field].hydrate(items, true, partial);
             }
         }
-        else { // owning side of M:N without pivot table needs to be reordered
+        else {
+            // owning side of M:N without pivot table needs to be reordered
             for (const entity of filtered) {
                 const order = !customOrder ? [...entity[prop.name].getItems(false)] : []; // copy order of references
                 const items = children.filter(child => entity[prop.name].contains(child, false));
@@ -301,7 +312,7 @@ export class EntityLoader {
         if (!schema && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind)) {
             schema = children.find(e => e.__helper.__schema)?.__helper.__schema;
         }
-        const ids = Utils.unique(children.map(e => prop.targetKey ? e[prop.targetKey] : e.__helper.getPrimaryKey()));
+        const ids = Utils.unique(children.map(e => (prop.targetKey ? e[prop.targetKey] : e.__helper.getPrimaryKey())));
         let where;
         if (polymorphicOwnerProp && Array.isArray(fk)) {
             const conditions = ids.map(id => {
@@ -311,11 +322,12 @@ 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 discriminatorValue = QueryHelper.findDiscriminatorValue(polymorphicOwnerProp.discriminatorMap, parentMeta.class) ?? parentMeta.tableName;
+            const parentMeta = this.#metadata.find(entities[0].constructor);
+            const discriminatorValue = QueryHelper.findDiscriminatorValue(polymorphicOwnerProp.discriminatorMap, parentMeta.class) ??
+                parentMeta.tableName;
             const discriminatorColumn = polymorphicOwnerProp.fieldNames[0];
             where = { $and: [where, { [discriminatorColumn]: discriminatorValue }] };
         }
@@ -330,12 +342,21 @@ 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, {
-            filters, convertCustomTypes, lockMode, populateWhere, logging,
+        const items = await this.#em.find(meta.class, where, {
+            filters,
+            convertCustomTypes,
+            lockMode,
+            populateWhere,
+            logging,
             orderBy,
             populate: populate.children ?? populate.all ?? [],
-            exclude: Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude,
-            strategy, fields, schema, connectionType,
+            exclude: Array.isArray(options.exclude)
+                ? Utils.extractChildElements(options.exclude, prop.name)
+                : options.exclude,
+            strategy,
+            fields,
+            schema,
+            connectionType,
             // @ts-ignore not a public option, will be propagated to the populate call
             refresh: refresh && !children.every(item => options.visited.has(item)),
             // @ts-ignore not a public option, will be propagated to the populate call
@@ -355,6 +376,7 @@ export class EntityLoader {
                 if (!ref) {
                     continue;
                 }
+                // oxfmt-ignore
                 const keyValue = '' + (Reference.isReference(ref) ? ref.unwrap()[prop.targetKey] : ref[prop.targetKey]);
                 const loadedItem = itemsByKey.get(keyValue);
                 if (loadedItem) {
@@ -363,11 +385,11 @@ 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
-            const getKey = (e) => prop.targetKey ? '' + e[prop.targetKey] : helper(e).getSerializedPrimaryKey();
+            const getKey = (e) => (prop.targetKey ? '' + e[prop.targetKey] : helper(e).getSerializedPrimaryKey());
             for (const item of items) {
                 /* v8 ignore next */
                 itemsMap.add(getKey(item));
@@ -387,23 +409,26 @@ 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 };
     }
     mergePrimaryCondition(ids, pk, options, meta, metadata, platform) {
-        const cond1 = QueryHelper.processWhere({ where: { [pk]: { $in: ids } }, entityName: meta.class, metadata, platform, convertCustomTypes: !options.convertCustomTypes });
+        const cond1 = QueryHelper.processWhere({
+            where: { [pk]: { $in: ids } },
+            entityName: meta.class,
+            metadata,
+            platform,
+            convertCustomTypes: !options.convertCustomTypes,
+        });
         const where = { ...options.where };
         Utils.dropUndefinedProperties(where);
-        return where[pk]
-            ? { $and: [cond1, where] }
-            : { ...cond1, ...where };
+        return where[pk] ? { $and: [cond1, where] } : { ...cond1, ...where };
     }
     async populateField(entityName, entities, populate, options) {
         const field = populate.field.split(':')[0];
-        const prop = this.metadata.find(entityName).properties[field];
+        const prop = this.#metadata.find(entityName).properties[field];
         if (prop.kind === ReferenceKind.SCALAR && !prop.lazy) {
             return;
         }
@@ -436,6 +461,7 @@ export class EntityLoader {
             .filter(orderBy => Utils.isObject(orderBy[prop.name]))
             .map(orderBy => orderBy[prop.name]);
         const { refresh, filters, ignoreLazyScalarProperties, populateWhere, connectionType, logging, schema } = options;
+        // oxfmt-ignore
         const exclude = Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude;
         const visited = options.visited;
         for (const entity of entities) {
@@ -451,7 +477,7 @@ export class EntityLoader {
         }
         const populateChildren = async (targetMeta, items) => {
             await this.populate(targetMeta.class, items, populate.children ?? populate.all, {
-                where: await this.extractChildCondition(options, prop, false),
+                where: (await this.extractChildCondition(options, prop, false)),
                 orderBy: innerOrderBy,
                 fields,
                 exclude,
@@ -489,34 +515,33 @@ export class EntityLoader {
         const refresh = options.refresh;
         let where = await this.extractChildCondition(options, prop, true);
         const fields = this.buildFields(options.fields, prop);
+        // oxfmt-ignore
         const exclude = Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude;
         const populateFilter = options.populateFilter?.[prop.name];
         const options2 = { ...options, fields, exclude, populateFilter };
         ['limit', 'offset', 'first', 'last', 'before', 'after', 'overfetch'].forEach(prop => delete options2[prop]);
-        options2.populate = (populate?.children ?? []);
-        if (prop.customType) {
-            ids.forEach((id, idx) => ids[idx] = QueryHelper.processCustomType(prop, id, this.driver.getPlatform()));
-        }
+        options2.populate = populate?.children ?? [];
         if (!Utils.isEmpty(prop.where)) {
             where = { $and: [where, prop.where] };
         }
-        const map = await this.driver.loadFromPivotTable(prop, ids, where, orderBy, this.em.getTransactionContext(), options2, pivotJoin);
+        const map = await this.#driver.loadFromPivotTable(prop, ids, where, orderBy, this.#em.getTransactionContext(), options2, pivotJoin);
         const children = [];
-        for (const entity of filtered) {
-            const items = map[entity.__helper.getSerializedPrimaryKey()].map(item => {
+        for (let i = 0; i < filtered.length; i++) {
+            const entity = filtered[i];
+            const items = map[Utils.getPrimaryKeyHash(ids[i])].map(item => {
                 if (pivotJoin) {
-                    return this.em.getReference(prop.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);
@@ -532,7 +557,8 @@ export class EntityLoader {
             if (where[op]) {
                 const child = where[op]
                     .map((cond) => cond[prop.name])
-                    .filter((sub) => sub != null && !(Utils.isPlainObject(sub) && Utils.getObjectQueryKeys(sub).every(key => Utils.isOperator(key, false))))
+                    .filter((sub) => sub != null &&
+                    !(Utils.isPlainObject(sub) && Utils.getObjectQueryKeys(sub).every(key => Utils.isOperator(key, false))))
                     .map((cond) => {
                     if (Utils.isPrimaryKey(cond)) {
                         return { [pk]: cond };
@@ -553,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;
     }
@@ -603,7 +629,8 @@ export class EntityLoader {
                 return a;
             }, []);
         }
-        if (prop.kind === ReferenceKind.MANY_TO_MANY) { // inverse side
+        if (prop.kind === ReferenceKind.MANY_TO_MANY) {
+            // inverse side
             return filtered;
         }
         // MANY_TO_ONE or ONE_TO_ONE
@@ -665,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),
@@ -684,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;
         }
@@ -706,7 +733,10 @@ export class EntityLoader {
             .forEach(prop => {
             const field = this.getRelationName(meta, prop);
             const prefixed = prefix ? `${prefix}.${field}` : field;
-            const nestedPopulate = populate.filter(p => p.field === prop.name).flatMap(p => p.children).filter(Boolean);
+            const nestedPopulate = populate
+                .filter(p => p.field === prop.name)
+                .flatMap(p => p.children)
+                .filter(Boolean);
             const nested = this.lookupEagerLoadedRelationships(prop.targetMeta.class, nestedPopulate, strategy, prefixed, visited.slice(), exclude);
             if (nested.length > 0) {
                 ret.push(...nested);
@@ -716,7 +746,7 @@ export class EntityLoader {
                 ret.push({
                     field: prefixed,
                     // enforce select-in strategy for self-referencing relations
-                    strategy: selfReferencing ? LoadStrategy.SELECT_IN : strategy ?? prop.strategy,
+                    strategy: selfReferencing ? LoadStrategy.SELECT_IN : (strategy ?? prop.strategy),
                 });
             }
         });

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).
@@ -73,7 +72,7 @@ export interface LoadReferenceOrFailOptions<T extends object, P extends string =
 /**
  * shortcut for `wrap(entity).toReference()`
  */
-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>;
+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)`
  */

package/entity/Reference.js

@@ -93,7 +93,8 @@ export class Reference {
             await wrapped.__em.populate(this.entity, options.populate, options);
         }
         if (!this.isInitialized() || options.refresh) {
-            if (options.dataloader ?? [DataloaderType.ALL, DataloaderType.REFERENCE].includes(wrapped.__em.config.getDataloaderType())) {
+            if (options.dataloader ??
+                [DataloaderType.ALL, DataloaderType.REFERENCE].includes(wrapped.__em.config.getDataloaderType())) {
                 const dataLoader = await wrapped.__em.getDataLoader('ref');
                 return dataLoader.load([this, options]);
             }
@@ -161,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).
@@ -174,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;
     }
@@ -192,43 +193,71 @@ 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, {
     __reference: { value: true, enumerable: false },
-    __meta: { get() { return this.entity.__meta; } },
-    __platform: { get() { return this.entity.__platform; } },
-    __helper: { get() { return this.entity.__helper; } },
-    $: { get() { return this.entity; } },
-    get: { get() { return () => this.entity; } },
+    __meta: {
+        get() {
+            return this.entity.__meta;
+        },
+    },
+    __platform: {
+        get() {
+            return this.entity.__platform;
+        },
+    },
+    __helper: {
+        get() {
+            return this.entity.__helper;
+        },
+    },
+    $: {
+        get() {
+            return this.entity;
+        },
+    },
+    get: {
+        get() {
+            return () => this.entity;
+        },
+    },
 });
 Object.defineProperties(ScalarReference.prototype, {
     __scalarReference: { value: true, enumerable: false },
-    $: { get() { return this.value; } },
-    get: { get() { return () => this.value; } },
+    $: {
+        get() {
+            return this.value;
+        },
+    },
+    get: {
+        get() {
+            return () => this.value;
+        },
+    },
 });
 /**
  * shortcut for `wrap(entity).toReference()`

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>[];
 }

package/entity/WrappedEntity.js

@@ -71,7 +71,11 @@ export class WrappedEntity {
         if (!this.__em) {
             throw ValidationError.entityNotManaged(this.entity);
         }
-        return this.__em.findOne(this.entity.constructor, this.entity, { ...options, refresh: true, schema: this.__schema });
+        return this.__em.findOne(this.entity.constructor, this.entity, {
+            ...options,
+            refresh: true,
+            schema: this.__schema,
+        });
     }
     async populate(populate, options = {}) {
         if (!this.__em) {