@mikro-orm/core 7.0.0-dev.21 → 7.0.0-dev.210

package/entity/EntityAssigner.js

@@ -1,12 +1,11 @@
-import { inspect } from 'node:util';
 import { Collection } from './Collection.js';
 import { Utils } from '../utils/Utils.js';
 import { Reference } from './Reference.js';
 import { ReferenceKind, SCALAR_TYPES } from '../enums.js';
-import { EntityValidator } from './EntityValidator.js';
+import { validateProperty } from './validators.js';
 import { helper, wrap } from './wrap.js';
 import { EntityHelper } from './EntityHelper.js';
-const validator = new EntityValidator(false);
+import { ValidationError } from '../errors.js';
 export class EntityAssigner {
     static assign(entity, data, options = {}) {
         let opts = options;
@@ -42,9 +41,17 @@ export class EntityAssigner {
         }
         const prop = { ...props[propName], name: propName };
         if (prop && options.onlyOwnProperties) {
-            if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
+            if ([ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
                 return;
             }
+            if ([ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+                if (!prop.owner) {
+                    return;
+                }
+                else if (value?.map) {
+                    value = value.map((v) => Utils.extractPK(v, prop.targetMeta));
+                }
+            }
             if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
                 value = Utils.extractPK(value, prop.targetMeta);
             }
@@ -70,7 +77,7 @@ export class EntityAssigner {
                 if (options.updateByPrimaryKey) {
                     const pk = Utils.extractPK(value, prop.targetMeta);
                     if (pk) {
-                        const ref = options.em.getReference(prop.type, pk, options);
+                        const ref = options.em.getReference(prop.targetMeta.class, pk, options);
                         // if the PK differs, we want to change the target entity, not update it
                         const wrappedChild = helper(ref);
                         const sameTarget = wrappedChild.getSerializedPrimaryKey() === wrapped.getSerializedPrimaryKey();
@@ -86,8 +93,9 @@ export class EntityAssigner {
             }
             return EntityAssigner.assignReference(entity, value, prop, options.em, options);
         }
-        if (prop.kind === ReferenceKind.SCALAR && SCALAR_TYPES.includes(prop.runtimeType) && (prop.setter || !prop.getter)) {
-            return entity[prop.name] = validator.validateProperty(prop, value, entity);
+        if (prop.kind === ReferenceKind.SCALAR && SCALAR_TYPES.has(prop.runtimeType) && (prop.setter || !prop.getter)) {
+            validateProperty(prop, value, entity);
+            return entity[prop.name] = value;
         }
         if (prop.kind === ReferenceKind.EMBEDDED && EntityAssigner.validateEM(options.em)) {
             return EntityAssigner.assignEmbeddable(entity, value, prop, options.em, options);
@@ -112,7 +120,7 @@ export class EntityAssigner {
         }
         const meta2 = helper(ref).__meta;
         const prop2 = meta2.properties[prop.inversedBy || prop.mappedBy];
-        /* v8 ignore next 7 */
+        /* v8 ignore next */
         if (prop2 && !ref[prop2.name]) {
             if (Reference.isReference(ref)) {
                 ref.unwrap()[prop2.name] = Reference.wrapReference(entity, prop2);
@@ -133,13 +141,13 @@ 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.type, 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.type, value, options), prop);
+            entity[prop.name] = Reference.wrapReference(em.merge(prop.targetMeta.class, value, options), prop);
         }
         else if (Utils.isPlainObject(value) && EntityAssigner.validateEM(em)) {
-            entity[prop.name] = Reference.wrapReference(em.create(prop.type, value, options), prop);
+            entity[prop.name] = Reference.wrapReference(em.create(prop.targetMeta.class, value, options), prop);
         }
         else {
             const name = entity.constructor.name;
@@ -158,14 +166,14 @@ export class EntityAssigner {
             if (options.updateNestedEntities && options.updateByPrimaryKey && Utils.isPlainObject(item)) {
                 const pk = Utils.extractPK(item, prop.targetMeta);
                 if (pk && EntityAssigner.validateEM(em)) {
-                    const ref = em.getUnitOfWork().getById(prop.type, pk, options.schema);
+                    const ref = em.getUnitOfWork().getById(prop.targetMeta.class, pk, options.schema);
                     if (ref) {
                         return EntityAssigner.assign(ref, item, options);
                     }
                 }
                 return this.createCollectionItem(item, em, prop, invalid, options);
             }
-            /* v8 ignore next 3 */
+            /* v8 ignore next */
             if (options.updateNestedEntities && !options.updateByPrimaryKey && collection[idx] && helper(collection[idx])?.isInitialized()) {
                 return EntityAssigner.assign(collection[idx], item, options);
             }
@@ -173,7 +181,7 @@ export class EntityAssigner {
         });
         if (invalid.length > 0) {
             const name = entity.constructor.name;
-            throw new Error(`Invalid collection values provided for '${name}.${prop.name}' in ${name}.assign(): ${inspect(invalid)}`);
+            throw ValidationError.invalidCollectionValues(name, prop.name, invalid);
         }
         if (Array.isArray(value)) {
             collection.set(items);
@@ -199,7 +207,7 @@ export class EntityAssigner {
                 entity[propName].push(...Object.values(tmp));
             });
         }
-        const create = () => EntityAssigner.validateEM(em) && em.getEntityFactory().createEmbeddable(prop.type, value, {
+        const create = () => EntityAssigner.validateEM(em) && em.getEntityFactory().createEmbeddable(prop.targetMeta.class, value, {
             convertCustomTypes: options.convertCustomTypes,
             newEntity: options.mergeEmbeddedProperties ? !('propName' in entity) : true,
         });
@@ -213,13 +221,13 @@ export class EntityAssigner {
             return item;
         }
         if (Utils.isPrimaryKey(item) && EntityAssigner.validateEM(em)) {
-            return em.getReference(prop.type, item, options);
+            return em.getReference(prop.targetMeta.class, item, options);
         }
         if (Utils.isPlainObject(item) && options.merge && EntityAssigner.validateEM(em)) {
-            return em.merge(prop.type, item, options);
+            return em.merge(prop.targetMeta.class, item, options);
         }
         if (Utils.isPlainObject(item) && EntityAssigner.validateEM(em)) {
-            return em.create(prop.type, item, options);
+            return em.create(prop.targetMeta.class, item, options);
         }
         invalid.push(item);
         return item;

package/entity/EntityFactory.d.ts

@@ -4,12 +4,23 @@ import type { EntityComparator } from '../utils/EntityComparator.js';
 export interface FactoryOptions {
     initialized?: boolean;
     newEntity?: boolean;
+    /**
+     * Property `onCreate` hooks are normally executed during `flush` operation.
+     * With this option, they will be processed early inside `em.create()` method.
+     */
+    processOnCreateHooksEarly?: boolean;
     merge?: boolean;
     refresh?: boolean;
     convertCustomTypes?: boolean;
     recomputeSnapshot?: boolean;
     schema?: string;
     parentSchema?: string;
+    normalizeAccessors?: boolean;
+    /**
+     * Property name to use for identity map lookup instead of the primary key.
+     * This is useful for creating references by unique non-PK properties.
+     */
+    key?: string;
 }
 export declare class EntityFactory {
     private readonly em;
@@ -23,10 +34,11 @@ export declare class EntityFactory {
     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;
-    createReference<T extends object>(entityName: EntityName<T>, id: Primary<T> | Primary<T>[] | Record<string, Primary<T>>, options?: Pick<FactoryOptions, 'merge' | 'convertCustomTypes' | 'schema'>): T;
+    createReference<T extends object>(entityName: EntityName<T>, id: Primary<T> | Primary<T>[] | Record<string, Primary<T>>, options?: Pick<FactoryOptions, 'merge' | 'convertCustomTypes' | 'schema' | 'key'>): T;
     createEmbeddable<T extends object>(entityName: EntityName<T>, data: EntityData<T>, options?: Pick<FactoryOptions, 'newEntity' | 'convertCustomTypes'>): T;
     getComparator(): EntityComparator;
     private createEntity;
+    private assignDefaultValues;
     private hydrate;
     private findEntity;
     private processDiscriminatorColumn;

package/entity/EntityFactory.js

@@ -4,6 +4,7 @@ import { EventType, ReferenceKind } from '../enums.js';
 import { Reference } from './Reference.js';
 import { helper } from './wrap.js';
 import { EntityHelper } from './EntityHelper.js';
+import { JsonType } from '../types/JsonType.js';
 export class EntityFactory {
     em;
     driver;
@@ -29,7 +30,6 @@ export class EntityFactory {
         if (data.__entity) {
             return data;
         }
-        entityName = Utils.className(entityName);
         const meta = this.metadata.get(entityName);
         if (meta.virtual) {
             data = { ...data };
@@ -37,8 +37,8 @@ export class EntityFactory {
             this.hydrate(entity, meta, data, options);
             return entity;
         }
-        if (this.platform.usesDifferentSerializedPrimaryKey()) {
-            meta.primaryKeys.forEach(pk => this.denormalizePrimaryKey(data, pk, meta.properties[pk]));
+        if (meta.serializedPrimaryKey) {
+            this.denormalizePrimaryKey(meta, data);
         }
         const meta2 = this.processDiscriminatorColumn(meta, data);
         const exists = this.findEntity(data, meta2, options);
@@ -59,7 +59,7 @@ export class EntityFactory {
         wrapped.__initialized = options.initialized;
         if (options.newEntity || meta.forceConstructor || meta.virtual) {
             const tmp = { ...data };
-            meta.constructorParams.forEach(prop => delete tmp[prop]);
+            meta.constructorParams?.forEach(prop => delete tmp[prop]);
             this.hydrate(entity, meta2, tmp, options);
             // since we now process only a copy of the `data` via hydrator, but later we register the state with the full snapshot,
             // we need to go through all props with custom types that have `ensureComparable: true` and ensure they are comparable
@@ -71,9 +71,11 @@ export class EntityFactory {
                             continue;
                         }
                         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
-                            data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
+                            data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
+                        }
+                        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' });
                     }
                 }
             }
@@ -81,7 +83,6 @@ export class EntityFactory {
         else {
             this.hydrate(entity, meta2, data, options);
         }
-        wrapped.__touched = false;
         if (exists && meta.discriminatorColumn && !(entity instanceof meta2.class)) {
             Object.setPrototypeOf(entity, meta2.prototype);
         }
@@ -108,12 +109,12 @@ export class EntityFactory {
         data = QueryHelper.processParams(data);
         const existsData = this.comparator.prepareEntity(entity);
         const originalEntityData = helper(entity).__originalEntityData ?? {};
-        const diff = this.comparator.diffEntities(meta.className, 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.className, existsData, data);
+        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 => {
@@ -136,6 +137,10 @@ export class EntityFactory {
             if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
                 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) {
+                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);
         });
@@ -146,20 +151,31 @@ export class EntityFactory {
                 // 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]
                     .filter(child => Utils.isPlainObject(child)) // objects with prototype can be PKs (e.g. `ObjectId`)
-                    .forEach(child => this.create(prop.type, child, options)); // we can ignore the value, we just care about the `mergeData` call
+                    .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) {
-                this.create(prop.type, data[prop.name], options); // we can ignore the value, we just care about the `mergeData` call
+                this.create(prop.targetMeta.class, data[prop.name], options); // we can ignore the value, we just care about the `mergeData` call
             }
         });
-        helper(entity).__touched = false;
+        this.unitOfWork.normalizeEntityData(meta, originalEntityData);
     }
     createReference(entityName, id, options = {}) {
         options.convertCustomTypes ??= true;
-        entityName = Utils.className(entityName);
         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);
+            const exists = this.unitOfWork.getByKey(entityName, options.key, value, schema, options.convertCustomTypes);
+            if (exists) {
+                return exists;
+            }
+            // Create entity stub - storeByKey will set the alternate key property and store in identity map
+            const entity = this.create(entityName, {}, { ...options, initialized: false });
+            this.unitOfWork.storeByKey(entity, options.key, value, schema, options.convertCustomTypes);
+            return entity;
+        }
         if (meta.simplePK) {
             const exists = this.unitOfWork.getById(entityName, id, schema);
             if (exists) {
@@ -171,8 +187,8 @@ export class EntityFactory {
         if (Array.isArray(id)) {
             id = Utils.getPrimaryKeyCondFromArray(id, meta);
         }
-        const pks = Utils.getOrderedPrimaryKeys(id, meta, this.platform, options.convertCustomTypes);
-        const exists = this.unitOfWork.getById(entityName, pks, schema);
+        const pks = Utils.getOrderedPrimaryKeys(id, meta, this.platform);
+        const exists = this.unitOfWork.getById(entityName, pks, schema, options.convertCustomTypes);
         if (exists) {
             return exists;
         }
@@ -182,7 +198,6 @@ export class EntityFactory {
         return this.create(entityName, id, { ...options, initialized: false });
     }
     createEmbeddable(entityName, data, options = {}) {
-        entityName = Utils.className(entityName);
         data = { ...data };
         const meta = this.metadata.get(entityName);
         const meta2 = this.processDiscriminatorColumn(meta, data);
@@ -194,7 +209,7 @@ export class EntityFactory {
     createEntity(data, meta, options) {
         const schema = this.driver.getSchemaName(meta, options);
         if (options.newEntity || meta.forceConstructor || meta.virtual) {
-            if (!meta.class) {
+            if (meta.polymorphs) {
                 throw new Error(`Cannot create entity ${meta.className}, class prototype is unknown`);
             }
             const params = this.extractConstructorParams(meta, data, options);
@@ -231,28 +246,39 @@ export class EntityFactory {
         }
         return entity;
     }
+    assignDefaultValues(entity, meta) {
+        for (const prop of meta.props) {
+            if (prop.onCreate) {
+                entity[prop.name] ??= prop.onCreate(entity, this.em);
+            }
+        }
+    }
     hydrate(entity, meta, data, options) {
         if (options.initialized) {
-            this.hydrator.hydrate(entity, meta, data, this, 'full', options.newEntity, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options));
+            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));
+            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');
+        if (options.newEntity && processOnCreateHooksEarly) {
+            this.assignDefaultValues(entity, meta);
+        }
     }
     findEntity(data, meta, options) {
         const schema = this.driver.getSchemaName(meta, options);
         if (meta.simplePK) {
-            return this.unitOfWork.getById(meta.className, data[meta.primaryKeys[0]], schema);
+            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);
-        return this.unitOfWork.getById(meta.className, pks, schema);
+        const pks = Utils.getOrderedPrimaryKeys(data, meta, this.platform, options.convertCustomTypes);
+        return this.unitOfWork.getById(meta.class, pks, schema);
     }
     processDiscriminatorColumn(meta, data) {
         if (!meta.root.discriminatorColumn) {
@@ -261,60 +287,65 @@ 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.find(type) : meta;
+        meta = type ? this.metadata.get(type) : meta;
         return meta;
     }
     /**
      * denormalize PK to value required by driver (e.g. ObjectId)
      */
-    denormalizePrimaryKey(data, primaryKey, prop) {
-        const pk = this.platform.getSerializedPrimaryKeyField(primaryKey);
-        if (data[pk] != null || data[primaryKey] != null) {
-            let id = (data[pk] || data[primaryKey]);
-            if (prop.type.toLowerCase() === 'objectid') {
-                id = this.platform.denormalizePrimaryKey(id);
-            }
-            delete data[pk];
-            data[primaryKey] = id;
+    denormalizePrimaryKey(meta, data) {
+        const pk = meta.getPrimaryProp();
+        const spk = meta.properties[meta.serializedPrimaryKey];
+        if (!spk?.serializedPrimaryKey) {
+            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]));
+            delete data[spk.name];
         }
     }
     /**
      * returns parameters for entity constructor, creating references from plain ids
      */
     extractConstructorParams(meta, data, options) {
+        if (!meta.constructorParams) {
+            return [data];
+        }
         return meta.constructorParams.map(k => {
-            if (meta.properties[k] && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(meta.properties[k].kind) && data[k]) {
-                const pk = Reference.unwrapReference(data[k]);
-                const entity = this.unitOfWork.getById(meta.properties[k].type, pk, options.schema);
+            const prop = meta.properties[k];
+            const value = data[k];
+            if (prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && value) {
+                const pk = Reference.unwrapReference(value);
+                const entity = this.unitOfWork.getById(prop.targetMeta.class, pk, options.schema, true);
                 if (entity) {
                     return entity;
                 }
-                if (Utils.isEntity(data[k])) {
-                    return data[k];
+                if (Utils.isEntity(value)) {
+                    return value;
                 }
-                const nakedPk = Utils.extractPK(data[k], meta.properties[k].targetMeta, true);
-                if (Utils.isObject(data[k]) && !nakedPk) {
-                    return this.create(meta.properties[k].type, data[k], options);
+                const nakedPk = Utils.extractPK(value, prop.targetMeta, true);
+                if (Utils.isObject(value) && !nakedPk) {
+                    return this.create(prop.targetMeta.class, value, options);
                 }
                 const { newEntity, initialized, ...rest } = options;
-                const target = this.createReference(meta.properties[k].type, nakedPk, rest);
-                return Reference.wrapReference(target, meta.properties[k]);
+                const target = this.createReference(prop.targetMeta.class, nakedPk, rest);
+                return Reference.wrapReference(target, prop);
             }
-            if (meta.properties[k]?.kind === ReferenceKind.EMBEDDED && data[k]) {
-                /* v8 ignore next 3 */
-                if (Utils.isEntity(data[k])) {
-                    return data[k];
+            if (prop?.kind === ReferenceKind.EMBEDDED && value) {
+                /* v8 ignore next */
+                if (Utils.isEntity(value)) {
+                    return value;
                 }
-                return this.createEmbeddable(meta.properties[k].type, data[k], options);
+                return this.createEmbeddable(prop.targetMeta.class, value, options);
             }
-            if (!meta.properties[k]) {
+            if (!prop) {
                 const tmp = { ...data };
                 for (const prop of meta.props) {
                     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], meta.properties[prop.name].targetMeta, true)) {
-                        tmp[prop.name] = Reference.wrapReference(this.create(meta.properties[prop.name].type, tmp[prop.name], options), prop);
+                    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);
@@ -322,10 +353,10 @@ export class EntityFactory {
                 }
                 return tmp;
             }
-            if (options.convertCustomTypes && meta.properties[k].customType && data[k] != null) {
-                return meta.properties[k].customType.convertToJSValue(data[k], this.platform);
+            if (options.convertCustomTypes && prop.customType && value != null) {
+                return prop.customType.convertToJSValue(value, this.platform);
             }
-            return data[k];
+            return value;
         });
     }
     get unitOfWork() {

package/entity/EntityHelper.d.ts

@@ -6,9 +6,9 @@ import { type EntityMetadata, type EntityProperty, type IHydrator } from '../typ
 export declare class EntityHelper {
     static decorate<T extends object>(meta: EntityMetadata<T>, em: EntityManager): void;
     /**
-     * As a performance optimization, we create entity state methods in a lazy manner. We first add
+     * As a performance optimization, we create entity state methods lazily. We first add
      * the `null` value to the prototype to reserve space in memory. Then we define a setter on the
-     * prototype, that will be executed exactly once per entity instance. There we redefine given
+     * prototype that will be executed exactly once per entity instance. There we redefine the given
      * property on the entity instance, so shadowing the prototype setter.
      */
     private static defineBaseProperties;

package/entity/EntityHelper.js

@@ -1,4 +1,3 @@
-import { inspect } from 'node:util';
 import { EagerProps, EntityRepositoryType, HiddenProps, OptionalProps, PrimaryKeyProp, } from '../typings.js';
 import { EntityTransformer } from '../serialization/EntityTransformer.js';
 import { Reference } from './Reference.js';
@@ -6,6 +5,8 @@ import { Utils } from '../utils/Utils.js';
 import { WrappedEntity } from './WrappedEntity.js';
 import { ReferenceKind } from '../enums.js';
 import { helper } from './wrap.js';
+import { inspect } from '../logging/inspect.js';
+import { getEnv } from '../utils/env-vars.js';
 /**
  * @internal
  */
@@ -32,14 +33,14 @@ export class EntityHelper {
         const prototype = meta.prototype;
         if (!prototype.toJSON) { // toJSON can be overridden
             prototype.toJSON = function (...args) {
-                return EntityTransformer.toObject(this, ...args.slice(meta.toJsonParams.length));
+                return EntityTransformer.toObject(this, ...args);
             };
         }
     }
     /**
-     * As a performance optimization, we create entity state methods in a lazy manner. We first add
+     * As a performance optimization, we create entity state methods lazily. We first add
      * the `null` value to the prototype to reserve space in memory. Then we define a setter on the
-     * prototype, that will be executed exactly once per entity instance. There we redefine given
+     * prototype that will be executed exactly once per entity instance. There we redefine the given
      * property on the entity instance, so shadowing the prototype setter.
      */
     static defineBaseProperties(meta, prototype, em) {
@@ -87,7 +88,7 @@ export class EntityHelper {
                 });
                 return;
             }
-            if (prop.inherited || prop.primary || prop.persist === false || prop.trackChanges === false || prop.embedded || isCollection) {
+            if (prop.inherited || prop.primary || prop.accessor || prop.persist === false || prop.embedded || isCollection) {
                 return;
             }
             Object.defineProperty(meta.prototype, prop.name, {
@@ -98,13 +99,11 @@ export class EntityHelper {
                         },
                         set(val) {
                             this.__helper.__data[prop.name] = val;
-                            this.__helper.__touched = !this.__helper.hydrator.isRunning();
                         },
                         enumerable: true,
                         configurable: true,
                     });
                     this.__helper.__data[prop.name] = val;
-                    this.__helper.__touched = !this.__helper.hydrator.isRunning();
                 },
                 configurable: true,
             });
@@ -112,16 +111,27 @@ export class EntityHelper {
     }
     static defineCustomInspect(meta) {
         // @ts-ignore
-        meta.prototype[inspect.custom] ??= function (depth = 2) {
-            const object = { ...this };
+        meta.prototype[Symbol.for('nodejs.util.inspect.custom')] ??= function (depth = 2) {
+            const object = {};
+            const keys = new Set(Utils.keys(this));
+            for (const prop of meta.props) {
+                if (keys.has(prop.name) || (prop.getter && prop.accessor === prop.name)) {
+                    object[prop.name] = this[prop.name];
+                }
+            }
+            for (const key of keys) {
+                if (!meta.properties[key]) {
+                    object[key] = this[key];
+                }
+            }
             // 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]);
             const ret = inspect(object, { depth });
-            let name = (this).constructor.name;
-            const showEM = ['true', 't', '1'].includes(process.env.MIKRO_ORM_LOG_EM_ID?.toString().toLowerCase() ?? '');
+            let name = this.constructor.name;
+            const showEM = ['true', 't', '1'].includes(getEnv('MIKRO_ORM_LOG_EM_ID')?.toLowerCase() ?? '');
             if (showEM) {
                 if (helper(this).__em) {
                     name += ` [managed by ${helper(this).__em.id}]`;
@@ -152,10 +162,7 @@ export class EntityHelper {
                 wrapped.__data[prop.name] = Reference.wrapReference(val, prop);
                 // when propagation from inside hydration, we set the FK to the entity data immediately
                 if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
-                    wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta.primaryKeys, true);
-                }
-                else {
-                    wrapped.__touched = !hydrator.isRunning();
+                    wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta, true);
                 }
                 EntityHelper.propagate(meta, entity, this, prop, Reference.unwrapReference(val), old);
             },
@@ -172,6 +179,13 @@ export class EntityHelper {
                 continue;
             }
             const inverse = value?.[prop2.name];
+            if (prop.ref && owner[prop.name]) {
+                // eslint-disable-next-line dot-notation
+                owner[prop.name]['property'] = prop;
+            }
+            if (Utils.isCollection(inverse) && inverse.isPartial()) {
+                continue;
+            }
             if (prop.kind === ReferenceKind.MANY_TO_ONE && Utils.isCollection(inverse) && inverse.isInitialized()) {
                 inverse.addWithoutPropagation(owner);
                 helper(owner).__em?.getUnitOfWork().cancelOrphanRemoval(owner);
@@ -199,6 +213,11 @@ export class EntityHelper {
                 helper(other).__em?.getUnitOfWork().scheduleOrphanRemoval(other);
             }
         }
+        // Skip setting the inverse side to null if it's a primary key - the entity will be removed via orphan removal
+        // Setting a primary key to null would corrupt the entity and cause validation errors
+        if (value == null && prop.orphanRemoval && prop2.primary) {
+            return;
+        }
         if (value == null) {
             entity[prop2.name] = value;
         }
@@ -210,6 +229,7 @@ export class EntityHelper {
         }
         if (old?.[prop2.name] != null) {
             delete helper(old).__data[prop2.name];
+            old[prop2.name] = null;
         }
     }
     static ensurePropagation(entity) {

package/entity/EntityLoader.d.ts

@@ -1,7 +1,7 @@
-import type { AnyEntity, ConnectionType, Dictionary, EntityProperty, FilterQuery, PopulateOptions } from '../typings.js';
+import type { AnyEntity, 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 } from '../drivers/IDatabaseDriver.js';
+import type { EntityField, 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> = {
     where?: FilterQuery<Entity>;
@@ -14,8 +14,8 @@ export type EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL
     lookup?: boolean;
     convertCustomTypes?: boolean;
     ignoreLazyScalarProperties?: boolean;
-    filters?: Dictionary<boolean | Dictionary> | string[] | boolean;
-    strategy?: LoadStrategy;
+    filters?: FilterOptions;
+    strategy?: LoadStrategy | `${LoadStrategy}`;
     lockMode?: Exclude<LockMode, LockMode.OPTIMISTIC>;
     schema?: string;
     connectionType?: ConnectionType;
@@ -30,8 +30,8 @@ export declare class EntityLoader {
      * Loads specified relations in batch.
      * This will execute one query for each relation, that will populate it on all the specified entities.
      */
-    populate<Entity extends object, Fields extends string = PopulatePath.ALL>(entityName: string, entities: Entity[], populate: PopulateOptions<Entity>[] | boolean, options: EntityLoaderOptions<Entity, Fields>): Promise<void>;
-    normalizePopulate<Entity>(entityName: string, populate: (PopulateOptions<Entity> | boolean)[] | PopulateOptions<Entity> | boolean, strategy?: LoadStrategy, lookup?: boolean): PopulateOptions<Entity>[];
+    populate<Entity extends object, Fields extends string = PopulatePath.ALL>(entityName: EntityName<Entity>, entities: Entity[], populate: PopulateOptions<Entity>[] | boolean, options: EntityLoaderOptions<Entity, Fields>): Promise<void>;
+    normalizePopulate<Entity>(entityName: EntityName<Entity>, populate: (PopulateOptions<Entity> | boolean)[] | PopulateOptions<Entity> | boolean, strategy?: LoadStrategy, lookup?: boolean, exclude?: string[]): PopulateOptions<Entity>[];
     private setSerializationContext;
     /**
      * Merge multiple populates for the same entity with different children. Also skips `*` fields, those can come from