@mikro-orm/core 7.0.0-rc.1 → 7.0.0-rc.3

package/entity/BaseEntity.d.ts

@@ -1,5 +1,5 @@
 import { type Ref } from './Reference.js';
-import type { AutoPath, EntityData, EntityDTO, Loaded, LoadedReference, AddEager, EntityKey, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
+import type { AutoPath, EntityData, EntityDTO, Loaded, LoadedReference, AddEager, EntityKey, FromEntityType, IsSubset, MergeSelected, SerializeDTO } from '../typings.js';
 import { type AssignOptions } from './EntityAssigner.js';
 import type { EntityLoaderOptions } from './EntityLoader.js';
 import { type SerializeOptions } from '../serialization/EntitySerializer.js';
@@ -8,7 +8,7 @@ import type { PopulatePath } from '../enums.js';
 export declare abstract class BaseEntity {
     isInitialized(): boolean;
     populated(populated?: boolean): void;
-    populate<Entity extends this = this, Hint extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
+    populate<Entity extends this = this, Hint extends string = never, Fields extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity, Fields>): Promise<Loaded<Entity, Hint>>;
     toReference<Entity extends this = this>(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
     /**
      * Converts the entity to a plain object representation.
@@ -73,7 +73,7 @@ export declare abstract class BaseEntity {
      */
     toObject<Entity extends this = this, Ignored extends EntityKey<Entity> = never>(ignoreFields: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
     toPOJO<Entity extends this = this>(): EntityDTO<Entity>;
-    serialize<Entity extends this = this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): EntityDTO<Loaded<Naked, Hint>>;
+    serialize<Entity extends this = this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): SerializeDTO<Naked, Hint, Exclude>;
     assign<Entity extends this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(data: Data & IsSubset<EntityData<Naked>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
     init<Entity extends this = this, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
     getSchema(): string | undefined;

package/entity/Collection.js

@@ -22,7 +22,7 @@ export class Collection {
         if (items) {
             let i = 0;
             this.items = new Set(items);
-            this.items.forEach(item => this[i++] = item);
+            this.items.forEach(item => (this[i++] = item));
         }
         this.initialized = !!items || initialized;
     }
@@ -58,7 +58,7 @@ export class Collection {
         helper(this.owner).setSerializationContext({
             populate: Array.isArray(options.populate)
                 ? options.populate.map(hint => `${this.property.name}.${hint}`)
-                : options.populate ?? [this.property.name],
+                : (options.populate ?? [this.property.name]),
         });
     }
     /**
@@ -79,8 +79,10 @@ export class Collection {
             return this._count;
         }
         const em = this.getEntityManager();
-        if (!em.getPlatform().usesPivotTable() && this.property.kind === ReferenceKind.MANY_TO_MANY && this.property.owner) {
-            return this._count = this.length;
+        if (!em.getPlatform().usesPivotTable() &&
+            this.property.kind === ReferenceKind.MANY_TO_MANY &&
+            this.property.owner) {
+            return (this._count = this.length);
         }
         const cond = this.createLoadCountCondition(where ?? {});
         const count = await em.count(this.property.targetMeta.class, cond, countOptions);
@@ -96,16 +98,18 @@ export class Collection {
         if (this.property.kind === ReferenceKind.MANY_TO_MANY && em.getPlatform().usesPivotTable()) {
             // M:N via pivot table bypasses em.find(), so merge all 3 levels here
             opts.orderBy = QueryHelper.mergeOrderBy(opts.orderBy, this.property.orderBy, this.property.targetMeta?.orderBy);
-            options.populate = await em.preparePopulate(this.property.targetMeta.class, options);
-            const cond = await em.applyFilters(this.property.targetMeta.class, where, options.filters ?? {}, 'read');
-            const map = await em.getDriver().loadFromPivotTable(this.property, [helper(this.owner).__primaryKeys], cond, opts.orderBy, ctx, options);
+            options.populate = (await em.preparePopulate(this.property.targetMeta.class, options));
+            const cond = (await em.applyFilters(this.property.targetMeta.class, where, options.filters ?? {}, 'read'));
+            const map = await em
+                .getDriver()
+                .loadFromPivotTable(this.property, [helper(this.owner).__primaryKeys], cond, opts.orderBy, ctx, options);
             items = map[helper(this.owner).getSerializedPrimaryKey()].map((item) => em.merge(this.property.targetMeta.class, item, { convertCustomTypes: true }));
             await em.populate(items, options.populate, options);
         }
         else {
             // em.find() merges entity-level orderBy, so only merge runtime + relation here
             opts.orderBy = QueryHelper.mergeOrderBy(opts.orderBy, this.property.orderBy);
-            items = await em.find(this.property.targetMeta.class, this.createCondition(where), opts);
+            items = (await em.find(this.property.targetMeta.class, this.createCondition(where), opts));
         }
         if (options.store) {
             this.hydrate(items, true);
@@ -262,11 +266,9 @@ export class Collection {
             return this;
         }
         const populate = Array.isArray(options.populate)
-            ? options.populate.map(f => f === '*' ? f : `${this.property.name}.${f}`)
+            ? options.populate.map(f => (f === '*' ? f : `${this.property.name}.${f}`))
             : [`${this.property.name}${options.ref ? ':ref' : ''}`];
-        const schema = this.property.targetMeta.schema === '*'
-            ? helper(this.owner).__schema
-            : undefined;
+        const schema = this.property.targetMeta.schema === '*' ? helper(this.owner).__schema : undefined;
         await em.populate(this.owner, populate, {
             refresh: true,
             ...options,
@@ -297,7 +299,8 @@ export class Collection {
         if (this.property.kind === ReferenceKind.ONE_TO_MANY) {
             cond[this.property.mappedBy] = helper(this.owner).getPrimaryKey();
         }
-        else { // MANY_TO_MANY
+        else {
+            // MANY_TO_MANY
             this.createManyToManyCondition(cond);
         }
         return cond;
@@ -386,7 +389,9 @@ export class Collection {
         if (items.length === 0) {
             return [];
         }
-        field ??= targetMeta.compositePK ? targetMeta.primaryKeys : (targetMeta.serializedPrimaryKey ?? targetMeta.primaryKeys[0]);
+        field ??= targetMeta.compositePK
+            ? targetMeta.primaryKeys
+            : (targetMeta.serializedPrimaryKey ?? targetMeta.primaryKeys[0]);
         const cb = (i, f) => {
             if (Utils.isEntity(i[f], true)) {
                 return wrap(i[f], true).getPrimaryKey();
@@ -616,6 +621,7 @@ export class Collection {
      * @internal
      */
     get property() {
+        // cannot be typed to `EntityProperty<O, T>` as it causes issues in assignability of `Loaded` type
         if (!this._property) {
             const meta = wrap(this.owner, true).__meta;
             /* v8 ignore next */
@@ -630,6 +636,7 @@ export class Collection {
      * @internal
      */
     set property(prop) {
+        // cannot be typed to `EntityProperty<O, T>` as it causes issues in assignability of `Loaded` type
         this._property = prop;
     }
     propagate(item, method) {
@@ -696,7 +703,18 @@ export class Collection {
     /** @ignore */
     [Symbol.for('nodejs.util.inspect.custom')](depth = 2) {
         const object = { ...this };
-        const hidden = ['items', 'owner', '_property', '_count', 'snapshot', '_populated', '_lazyInitialized', '_em', 'readonly', 'partial'];
+        const hidden = [
+            'items',
+            'owner',
+            '_property',
+            '_count',
+            'snapshot',
+            '_populated',
+            '_lazyInitialized',
+            '_em',
+            'readonly',
+            'partial',
+        ];
         hidden.forEach(k => delete object[k]);
         const ret = inspect(object, { depth });
         const name = `${this.constructor.name}<${this.property?.type ?? 'unknown'}>`;
@@ -704,7 +722,15 @@ export class Collection {
     }
 }
 Object.defineProperties(Collection.prototype, {
-    $: { get() { return this; } },
-    get: { get() { return () => this; } },
+    $: {
+        get() {
+            return this;
+        },
+    },
+    get: {
+        get() {
+            return () => this;
+        },
+    },
     __collection: { value: true, enumerable: false, writable: false },
 });

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.js

@@ -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' });
+                            data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, {
+                                key: prop.name,
+                                mode: 'hydration',
+                            });
                         }
                     }
                 }
@@ -111,33 +115,46 @@ export class EntityFactory {
         const originalEntityData = helper(entity).__originalEntityData ?? {};
         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 });
         // 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
-        this.hydrate(entity, meta, diff2, options);
+        // 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;
         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 ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE, ReferenceKind.SCALAR].includes(prop.kind) && prop.customType?.ensureComparable(meta, prop) && diff2[key] != 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 });
             }
@@ -146,7 +163,8 @@ export class EntityFactory {
         });
         // 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]
@@ -154,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
             }
         });
@@ -353,7 +374,9 @@ 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) {

package/entity/EntityHelper.js

@@ -1,4 +1,4 @@
-import { EagerProps, EntityRepositoryType, HiddenProps, OptionalProps, PrimaryKeyProp, } from '../typings.js';
+import { EagerProps, EntityName, EntityRepositoryType, HiddenProps, OptionalProps, PrimaryKeyProp, } from '../typings.js';
 import { EntityTransformer } from '../serialization/EntityTransformer.js';
 import { Reference } from './Reference.js';
 import { Utils } from '../utils/Utils.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, {
@@ -130,10 +136,8 @@ export class EntityHelper {
                 }
             }
             // ensure we dont have internal symbols in the POJO
-            [OptionalProps, EntityRepositoryType, PrimaryKeyProp, EagerProps, HiddenProps].forEach(sym => delete object[sym]);
-            meta.props
-                .filter(prop => object[prop.name] === undefined)
-                .forEach(prop => delete object[prop.name]);
+            [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]);
             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

@@ -1,13 +1,13 @@
-import type { AnyEntity, ConnectionType, EntityName, EntityProperty, FilterQuery, PopulateOptions } from '../typings.js';
+import type { AnyEntity, AutoPath, ConnectionType, EntityName, 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, FilterOptions } from '../drivers/IDatabaseDriver.js';
+import type { FilterOptions } from '../drivers/IDatabaseDriver.js';
 import type { LoggingOptions } from '../logging/Logger.js';
-export type EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL, Excludes extends string = never> = {
+export interface EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL, Excludes extends string = never> {
+    fields?: readonly AutoPath<Entity, Fields, `${PopulatePath.ALL}`>[];
+    exclude?: readonly AutoPath<Entity, Excludes>[];
     where?: FilterQuery<Entity>;
     populateWhere?: PopulateHint | `${PopulateHint}`;
-    fields?: readonly EntityField<Entity, Fields>[];
-    exclude?: readonly EntityField<Entity, Excludes>[];
     orderBy?: QueryOrderMap<Entity> | QueryOrderMap<Entity>[];
     refresh?: boolean;
     validate?: boolean;
@@ -20,7 +20,7 @@ export type EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL
     schema?: string;
     connectionType?: ConnectionType;
     logging?: LoggingOptions;
-};
+}
 export declare class EntityLoader {
     private readonly em;
     private readonly metadata;