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

package/entity/EntityAssigner.js

@@ -71,7 +71,10 @@ export class EntityAssigner {
             value = customType.convertToJSValue(value, options.platform);
         }
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop?.kind) && value != null) {
-            if (options.updateNestedEntities && Object.hasOwn(entity, propName) && Utils.isEntity(entity[propName], true) && Utils.isPlainObject(value)) {
+            if (options.updateNestedEntities &&
+                Object.hasOwn(entity, propName) &&
+                Utils.isEntity(entity[propName], true) &&
+                Utils.isPlainObject(value)) {
                 const unwrappedEntity = Reference.unwrapReference(entity[propName]);
                 const wrapped = helper(unwrappedEntity);
                 if (options.updateByPrimaryKey) {
@@ -95,12 +98,14 @@ export class EntityAssigner {
         }
         if (prop.kind === ReferenceKind.SCALAR && SCALAR_TYPES.has(prop.runtimeType) && (prop.setter || !prop.getter)) {
             validateProperty(prop, value, entity);
-            return entity[prop.name] = value;
+            return (entity[prop.name] = value);
         }
         if (prop.kind === ReferenceKind.EMBEDDED && EntityAssigner.validateEM(options.em)) {
             return EntityAssigner.assignEmbeddable(entity, value, prop, options.em, options);
         }
-        if (options.mergeObjectProperties && Utils.isPlainObject(entity[propName]) && Utils.isPlainObject(value)) {
+        if (options.mergeObjectProperties &&
+            Utils.isPlainObject(entity[propName]) &&
+            Utils.isPlainObject(value)) {
             entity[propName] ??= {};
             entity[propName] = Utils.merge({}, entity[propName], value);
         }
@@ -141,7 +146,9 @@ export class EntityAssigner {
             entity[prop.name] = Reference.wrapReference(value, prop);
         }
         else if (Utils.isPrimaryKey(value, true) && EntityAssigner.validateEM(em)) {
-            entity[prop.name] = prop.mapToPk ? value : Reference.wrapReference(em.getReference(prop.targetMeta.class, value, options), prop);
+            entity[prop.name] = prop.mapToPk
+                ? value
+                : Reference.wrapReference(em.getReference(prop.targetMeta.class, value, options), prop);
         }
         else if (Utils.isPlainObject(value) && options.merge && EntityAssigner.validateEM(em)) {
             entity[prop.name] = Reference.wrapReference(em.merge(prop.targetMeta.class, value, options), prop);
@@ -174,7 +181,10 @@ export class EntityAssigner {
                 return this.createCollectionItem(item, em, prop, invalid, options);
             }
             /* v8 ignore next */
-            if (options.updateNestedEntities && !options.updateByPrimaryKey && collection[idx] && helper(collection[idx])?.isInitialized()) {
+            if (options.updateNestedEntities &&
+                !options.updateByPrimaryKey &&
+                collection[idx] &&
+                helper(collection[idx])?.isInitialized()) {
                 return EntityAssigner.assign(collection[idx], item, options);
             }
             return this.createCollectionItem(item, em, prop, invalid, options);
@@ -186,7 +196,8 @@ export class EntityAssigner {
         if (Array.isArray(value)) {
             collection.set(items);
         }
-        else { // append to the collection in case of assigning a single value instead of array
+        else {
+            // append to the collection in case of assigning a single value instead of array
             collection.add(items);
         }
     }
@@ -207,11 +218,12 @@ export class EntityAssigner {
                 entity[propName].push(...Object.values(tmp));
             });
         }
-        const create = () => EntityAssigner.validateEM(em) && em.getEntityFactory().createEmbeddable(prop.targetMeta.class, value, {
-            convertCustomTypes: options.convertCustomTypes,
-            newEntity: options.mergeEmbeddedProperties ? !('propName' in entity) : true,
-        });
-        entity[propName] = (options.mergeEmbeddedProperties ? (entity[propName] || create()) : create());
+        const create = () => EntityAssigner.validateEM(em) &&
+            em.getEntityFactory().createEmbeddable(prop.targetMeta.class, value, {
+                convertCustomTypes: options.convertCustomTypes,
+                newEntity: options.mergeEmbeddedProperties ? !('propName' in entity) : true,
+            });
+        entity[propName] = (options.mergeEmbeddedProperties ? entity[propName] || create() : create());
         Object.keys(value).forEach(key => {
             EntityAssigner.assignProperty(entity[propName], key, prop.embeddedProps, value, options);
         });

package/entity/EntityFactory.d.ts

@@ -23,14 +23,7 @@ export interface FactoryOptions {
     key?: string;
 }
 export declare class EntityFactory {
-    private readonly em;
-    private readonly driver;
-    private readonly platform;
-    private readonly config;
-    private readonly metadata;
-    private readonly hydrator;
-    private readonly eventManager;
-    private readonly comparator;
+    #private;
     constructor(em: EntityManager);
     create<T extends object, P extends string = string>(entityName: EntityName<T>, data: EntityData<T>, options?: FactoryOptions): New<T, P>;
     mergeData<T extends object>(meta: EntityMetadata<T>, entity: T, data: EntityData<T>, options?: FactoryOptions): void;

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);
@@ -70,11 +70,15 @@ export class EntityFactory {
                         if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
                             continue;
                         }
-                        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
+                        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, true);
                         }
-                        if (prop.customType instanceof JsonType && this.platform.convertsJsonAutomatically()) {
-                            data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, { key: prop.name, mode: 'hydration' });
+                        if (prop.customType instanceof JsonType && this.#platform.convertsJsonAutomatically()) {
+                            data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.#platform, {
+                                key: prop.name,
+                                mode: 'hydration',
+                            });
                         }
                     }
                 }
@@ -95,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;
@@ -107,49 +111,60 @@ 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]) {
+        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).filter(key => {
+        Utils.keys(diff2)
+            .filter(key => {
             // ignore null values if there is already present non-null value
             if (existsData[key] != null) {
                 return diff2[key] == null;
             }
             return diff2[key] === undefined;
-        }).forEach(key => delete diff2[key]);
+        })
+            .forEach(key => delete diff2[key]);
         // but always add collection properties and formulas if they are part of the `data`
         Utils.keys(data)
-            .filter(key => meta.properties[key]?.formula || [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(meta.properties[key]?.kind))
-            .forEach(key => diff2[key] = data[key]);
+            .filter(key => meta.properties[key]?.formula ||
+            [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(meta.properties[key]?.kind))
+            .forEach(key => (diff2[key] = data[key]));
         // rehydrated with the new values, skip those changed by user
         // use full hydration if the entity is already initialized, even if the caller used `initialized: false`
         // (e.g. from createReference), otherwise scalar properties in diff2 won't be applied
         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) && Utils.isPlainObject(data[prop.name])) {
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+                Utils.isPlainObject(data[prop.name])) {
+                // oxfmt-ignore
                 diff2[key] = entity[prop.name] ? helper(entity[prop.name]).getPrimaryKey(options.convertCustomTypes) : null;
             }
-            if (!options.convertCustomTypes && [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 });
+            if (!options.convertCustomTypes &&
+                [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 });
             }
             originalEntityData[key] = diff2[key] === null ? nullVal : diff2[key];
             helper(entity).__loadedProperties.add(key);
         });
         // in case of joined loading strategy, we need to cascade the merging to possibly loaded relations manually
         meta.relations.forEach(prop => {
-            if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) && Array.isArray(data[prop.name])) {
+            if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) &&
+                Array.isArray(data[prop.name])) {
                 // instead of trying to match the collection items (which could easily fail if the collection was loaded with different ordering),
                 // we just create the entity from scratch, which will automatically pick the right one from the identity map and call `mergeData` on it
                 data[prop.name]
@@ -157,7 +172,10 @@ export class EntityFactory {
                     .forEach(child => this.create(prop.targetMeta.class, child, options)); // we can ignore the value, we just care about the `mergeData` call
                 return;
             }
-            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name]) && entity[prop.name] && helper(entity[prop.name]).__initialized) {
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+                Utils.isPlainObject(data[prop.name]) &&
+                entity[prop.name] &&
+                helper(entity[prop.name]).__initialized) {
                 this.create(prop.targetMeta.class, data[prop.name], options); // we can ignore the value, we just care about the `mergeData` call
             }
         });
@@ -165,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);
@@ -190,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;
@@ -202,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`);
@@ -221,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]);
@@ -241,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) {
@@ -252,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) {
@@ -289,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)
@@ -297,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;
@@ -312,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];
         }
     }
@@ -356,22 +374,24 @@ export class EntityFactory {
                     if (!options.convertCustomTypes || !prop.customType || tmp[prop.name] == null) {
                         continue;
                     }
-                    if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(tmp[prop.name]) && !Utils.extractPK(tmp[prop.name], prop.targetMeta, true)) {
+                    if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+                        Utils.isPlainObject(tmp[prop.name]) &&
+                        !Utils.extractPK(tmp[prop.name], prop.targetMeta, true)) {
                         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/EntityHelper.js

@@ -31,15 +31,21 @@ export class EntityHelper {
             EntityHelper.defineProperties(meta, fork);
         }
         const prototype = meta.prototype;
-        if (!prototype.toJSON) { // toJSON can be overridden
-            prototype.toJSON = function (...args) {
-                // Guard against being called on the prototype itself (e.g. by serializers
-                // walking the object graph and calling toJSON on prototype objects)
-                if (this === prototype) {
-                    return {};
-                }
-                return EntityTransformer.toObject(this, ...args);
-            };
+        if (!prototype.toJSON) {
+            // toJSON can be overridden
+            Object.defineProperty(prototype, 'toJSON', {
+                value: function (...args) {
+                    // Guard against being called on the prototype itself (e.g. by serializers
+                    // walking the object graph and calling toJSON on prototype objects)
+                    if (this === prototype) {
+                        return {};
+                    }
+                    return EntityTransformer.toObject(this, ...args);
+                },
+                writable: true,
+                configurable: true,
+                enumerable: false,
+            });
         }
     }
     /**
@@ -49,6 +55,7 @@ export class EntityHelper {
      * property on the entity instance, so shadowing the prototype setter.
      */
     static defineBaseProperties(meta, prototype, em) {
+        // oxfmt-ignore
         const helperParams = meta.embeddable || meta.virtual ? [] : [em.getComparator().getPkGetter(meta), em.getComparator().getPkSerializer(meta), em.getComparator().getPkGetterConverted(meta)];
         Object.defineProperties(prototype, {
             __entity: { value: !meta.embeddable, configurable: true },
@@ -78,10 +85,9 @@ export class EntityHelper {
      * than on its prototype. Thanks to this we still have those properties enumerable (e.g. part of `Object.keys(entity)`).
      */
     static defineProperties(meta, em) {
-        Object
-            .values(meta.properties)
-            .forEach(prop => {
+        Object.values(meta.properties).forEach(prop => {
             const isCollection = [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind);
+            // oxfmt-ignore
             const isReference = [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && (prop.inversedBy || prop.mappedBy) && !prop.mapToPk;
             if (isReference) {
                 Object.defineProperty(meta.prototype, prop.name, {
@@ -131,9 +137,7 @@ export class EntityHelper {
             }
             // ensure we dont have internal symbols in the POJO
             [OptionalProps, EntityRepositoryType, PrimaryKeyProp, EagerProps, HiddenProps, EntityName].forEach(sym => delete object[sym]);
-            meta.props
-                .filter(prop => object[prop.name] === undefined)
-                .forEach(prop => delete object[prop.name]);
+            meta.props.filter(prop => object[prop.name] === undefined).forEach(prop => delete object[prop.name]);
             const ret = inspect(object, { depth });
             let name = this.constructor.name;
             const showEM = ['true', 't', '1'].includes(getEnv('MIKRO_ORM_LOG_EM_ID')?.toLowerCase() ?? '');
@@ -161,6 +165,7 @@ export class EntityHelper {
             set(val) {
                 const entity = Reference.unwrapReference(val ?? wrapped.__data[prop.name]);
                 const old = Reference.unwrapReference(wrapped.__data[prop.name]);
+                // oxfmt-ignore
                 if (old && old !== entity && prop.kind === ReferenceKind.MANY_TO_ONE && prop.inversedBy && old[prop.inversedBy]) {
                     old[prop.inversedBy].removeWithoutPropagation(this);
                 }
@@ -192,6 +197,7 @@ export class EntityHelper {
             if ((prop2.inversedBy || prop2.mappedBy) !== prop.name) {
                 continue;
             }
+            // oxfmt-ignore
             if (prop2.targetMeta.abstract ? prop2.targetMeta.root.class !== meta.root.class : prop2.targetMeta.class !== meta.class) {
                 continue;
             }
@@ -223,7 +229,10 @@ export class EntityHelper {
     static propagateOneToOne(entity, owner, prop, prop2, value, old) {
         helper(entity).__pk = helper(entity).getPrimaryKey();
         // the inverse side will be changed on the `value` too, so we need to clean-up and schedule orphan removal there too
-        if (!prop.primary && !prop2.mapToPk && value?.[prop2.name] != null && Reference.unwrapReference(value[prop2.name]) !== entity) {
+        if (!prop.primary &&
+            !prop2.mapToPk &&
+            value?.[prop2.name] != null &&
+            Reference.unwrapReference(value[prop2.name]) !== entity) {
             const other = Reference.unwrapReference(value[prop2.name]);
             delete helper(other).__data[prop.name];
             if (prop2.orphanRemoval) {

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.