@mikro-orm/core 7.0.0-dev.31 → 7.0.0-dev.311

package/unit-of-work/UnitOfWork.js

@@ -1,4 +1,3 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
 import { Collection } from '../entity/Collection.js';
 import { EntityHelper } from '../entity/EntityHelper.js';
 import { helper } from '../entity/wrap.js';
@@ -13,8 +12,9 @@ import { Cascade, DeferMode, EventType, LockMode, ReferenceKind } from '../enums
 import { OptimisticLockError, ValidationError } from '../errors.js';
 import { TransactionEventBroadcaster } from '../events/TransactionEventBroadcaster.js';
 import { IdentityMap } from './IdentityMap.js';
+import { createAsyncContext } from '../utils/AsyncContext.js';
 // to deal with validation for flush inside flush hooks and `Promise.all`
-const insideFlush = new AsyncLocalStorage();
+const insideFlush = createAsyncContext();
 export class UnitOfWork {
     em;
     /** map of references to managed entities */
@@ -42,8 +42,8 @@ export class UnitOfWork {
         this.identityMap = new IdentityMap(this.platform.getDefaultSchemaName());
         this.eventManager = this.em.getEventManager();
         this.comparator = this.em.getComparator();
-        this.changeSetComputer = new ChangeSetComputer(this.em.getValidator(), this.collectionUpdates, this.metadata, this.platform, this.em.config, this.em);
-        this.changeSetPersister = new ChangeSetPersister(this.em.getDriver(), this.metadata, this.em.config.getHydrator(this.metadata), this.em.getEntityFactory(), this.em.getValidator(), this.em.config, this.em);
+        this.changeSetComputer = new ChangeSetComputer(this.em, this.collectionUpdates);
+        this.changeSetPersister = new ChangeSetPersister(this.em);
     }
     merge(entity, visited) {
         const wrapped = helper(entity);
@@ -61,10 +61,51 @@ export class UnitOfWork {
         // as there can be some entity with already changed state that is not yet flushed
         if (wrapped.__initialized && (!visited || !wrapped.__originalEntityData)) {
             wrapped.__originalEntityData = this.comparator.prepareEntity(entity);
-            wrapped.__touched = false;
         }
         this.cascade(entity, Cascade.MERGE, visited ?? new Set());
     }
+    /**
+     * Entity data can wary in its shape, e.g. we might get a deep relation graph with joined strategy, but for diffing,
+     * we need to normalize the shape, so relation values are only raw FKs. This method handles that.
+     * @internal
+     */
+    normalizeEntityData(meta, data) {
+        const forceUndefined = this.em.config.get('forceUndefined');
+        for (const key of Utils.keys(data)) {
+            const prop = meta.properties[key];
+            if (!prop) {
+                continue;
+            }
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+                Utils.isPlainObject(data[prop.name])) {
+                // Skip polymorphic relations - they use PolymorphicRef wrapper
+                if (!prop.polymorphic) {
+                    data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
+                }
+            }
+            else if (prop.kind === ReferenceKind.EMBEDDED && !prop.object && Utils.isPlainObject(data[prop.name])) {
+                for (const p of prop.targetMeta.props) {
+                    /* v8 ignore next */
+                    const prefix = prop.prefix === false ? '' : prop.prefix === true ? prop.name + '_' : prop.prefix;
+                    data[(prefix + p.name)] = data[prop.name][p.name];
+                }
+                data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
+            }
+            if (prop.hydrate === false && prop.customType?.ensureComparable(meta, prop)) {
+                const converted = prop.customType.convertToJSValue(data[key], this.platform, {
+                    key,
+                    mode: 'hydration',
+                    force: true,
+                });
+                data[key] = prop.customType.convertToDatabaseValue(converted, this.platform, { key, mode: 'hydration' });
+            }
+            if (forceUndefined) {
+                if (data[key] === null) {
+                    data[key] = undefined;
+                }
+            }
+        }
+    }
     /**
      * @internal
      */
@@ -82,31 +123,14 @@ export class UnitOfWork {
         wrapped.__em ??= this.em;
         wrapped.__managed = true;
         if (data && (options?.refresh || !wrapped.__originalEntityData)) {
+            this.normalizeEntityData(wrapped.__meta, data);
             for (const key of Utils.keys(data)) {
                 const prop = wrapped.__meta.properties[key];
-                if (!prop) {
-                    continue;
-                }
-                wrapped.__loadedProperties.add(key);
-                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);
-                }
-                else if (prop.kind === ReferenceKind.EMBEDDED && !prop.object && Utils.isPlainObject(data[prop.name])) {
-                    for (const p of prop.targetMeta.props) {
-                        /* v8 ignore next */
-                        const prefix = prop.prefix === false ? '' : prop.prefix === true ? prop.name + '_' : prop.prefix;
-                        data[prefix + p.name] = data[prop.name][p.name];
-                    }
-                    data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
-                }
-                if (forceUndefined) {
-                    if (data[key] === null) {
-                        data[key] = undefined;
-                    }
+                if (prop) {
+                    wrapped.__loadedProperties.add(key);
                 }
             }
             wrapped.__originalEntityData = data;
-            wrapped.__touched = false;
         }
         return entity;
     }
@@ -153,6 +177,40 @@ export class UnitOfWork {
         }
         return this.identityMap.getByHash(meta, hash);
     }
+    /**
+     * Returns entity from the identity map by an alternate key (non-PK property).
+     * @param convertCustomTypes - If true, the value is in database format and will be converted to JS format for lookup.
+     *                             If false (default), the value is assumed to be in JS format already.
+     */
+    getByKey(entityName, key, value, schema, convertCustomTypes) {
+        const meta = this.metadata.find(entityName).root;
+        schema ??= meta.schema ?? this.em.config.getSchema();
+        const prop = meta.properties[key];
+        // Convert from DB format to JS format if needed
+        if (convertCustomTypes && prop?.customType) {
+            value = prop.customType.convertToJSValue(value, this.platform, { mode: 'hydration' });
+        }
+        const hash = this.identityMap.getKeyHash(key, '' + value, schema);
+        return this.identityMap.getByHash(meta, hash);
+    }
+    /**
+     * Stores an entity in the identity map under an alternate key (non-PK property).
+     * Also sets the property value on the entity.
+     * @param convertCustomTypes - If true, the value is in database format and will be converted to JS format.
+     *                             If false (default), the value is assumed to be in JS format already.
+     */
+    storeByKey(entity, key, value, schema, convertCustomTypes) {
+        const meta = entity.__meta.root;
+        schema ??= meta.schema ?? this.em.config.getSchema();
+        const prop = meta.properties[key];
+        // Convert from DB format to JS format if needed
+        if (convertCustomTypes && prop?.customType) {
+            value = prop.customType.convertToJSValue(value, this.platform, { mode: 'hydration' });
+        }
+        // Set the property on the entity
+        entity[key] = value;
+        this.identityMap.storeByKey(entity, key, '' + value, schema);
+    }
     tryGetById(entityName, where, schema, strict = true) {
         const pk = Utils.extractPK(where, this.metadata.find(entityName), strict);
         if (!pk) {
@@ -191,13 +249,11 @@ export class UnitOfWork {
         if (insideFlush.getStore()) {
             return false;
         }
-        if (this.queuedActions.has(meta.className) || this.queuedActions.has(meta.root.className)) {
+        if (this.queuedActions.has(meta.class) || this.queuedActions.has(meta.root.class)) {
             return true;
         }
-        for (const entity of this.identityMap.getStore(meta).values()) {
-            if (helper(entity).__initialized && helper(entity).isTouched()) {
-                return true;
-            }
+        if (meta.discriminatorMap && Object.values(meta.discriminatorMap).some(v => this.queuedActions.has(v))) {
+            return true;
         }
         return false;
     }
@@ -206,7 +262,7 @@ export class UnitOfWork {
     }
     computeChangeSet(entity, type) {
         const wrapped = helper(entity);
-        if (type) {
+        if (type === ChangeSetType.DELETE || type === ChangeSetType.DELETE_EARLY) {
             this.changeSets.set(entity, new ChangeSet(entity, type, {}, wrapped.__meta));
             return;
         }
@@ -214,11 +270,14 @@ export class UnitOfWork {
         if (!cs || this.checkUniqueProps(cs)) {
             return;
         }
+        /* v8 ignore next */
+        if (type) {
+            cs.type = type;
+        }
         this.initIdentifier(entity);
         this.changeSets.set(entity, cs);
         this.persistStack.delete(entity);
         wrapped.__originalEntityData = this.comparator.prepareEntity(entity);
-        wrapped.__touched = false;
     }
     recomputeSingleChangeSet(entity) {
         const changeSet = this.changeSets.get(entity);
@@ -229,7 +288,6 @@ export class UnitOfWork {
         if (cs && !this.checkUniqueProps(cs)) {
             Object.assign(changeSet.payload, cs.payload);
             helper(entity).__originalEntityData = this.comparator.prepareEntity(entity);
-            helper(entity).__touched = false;
         }
     }
     persist(entity, visited, options = {}) {
@@ -239,7 +297,7 @@ export class UnitOfWork {
         }
         const wrapped = helper(entity);
         this.persistStack.add(entity);
-        this.queuedActions.add(wrapped.__meta.className);
+        this.queuedActions.add(wrapped.__meta.class);
         this.removeStack.delete(entity);
         if (!wrapped.__managed && wrapped.hasPrimaryKey()) {
             this.identityMap.store(entity);
@@ -252,7 +310,7 @@ export class UnitOfWork {
         // allow removing not managed entities if they are not part of the persist stack
         if (helper(entity).__managed || !this.persistStack.has(entity)) {
             this.removeStack.add(entity);
-            this.queuedActions.add(helper(entity).__meta.className);
+            this.queuedActions.add(helper(entity).__meta.class);
         }
         else {
             this.persistStack.delete(entity);
@@ -269,7 +327,7 @@ export class UnitOfWork {
                 }
                 continue;
             }
-            const target = relation && relation[inverseProp];
+            const target = relation?.[inverseProp];
             if (relation && Utils.isCollection(target)) {
                 target.removeWithoutPropagation(entity);
             }
@@ -315,7 +373,8 @@ export class UnitOfWork {
             this.filterCollectionUpdates();
             // nothing to do, do not start transaction
             if (this.changeSets.size === 0 && this.collectionUpdates.size === 0 && this.extraUpdates.size === 0) {
-                return void (await this.eventManager.dispatchEvent(EventType.afterFlush, { em: this.em, uow: this }));
+                await this.eventManager.dispatchEvent(EventType.afterFlush, { em: this.em, uow: this });
+                return;
             }
             const groups = this.getChangeSetGroups();
             const platform = this.em.getPlatform();
@@ -342,10 +401,10 @@ export class UnitOfWork {
         }
     }
     async lock(entity, options) {
-        if (!this.getById(entity.constructor.name, helper(entity).__primaryKeys, helper(entity).__schema)) {
+        if (!this.getById(entity.constructor, helper(entity).__primaryKeys, helper(entity).__schema)) {
             throw ValidationError.entityNotManaged(entity);
         }
-        const meta = this.metadata.find(entity.constructor.name);
+        const meta = this.metadata.find(entity.constructor);
         if (options.lockMode === LockMode.OPTIMISTIC) {
             await this.lockOptimistic(entity, meta, options.lockVersion);
         }
@@ -369,7 +428,10 @@ export class UnitOfWork {
                 if (Utils.isCollection(rel)) {
                     rel.removeWithoutPropagation(entity);
                 }
-                else if (rel && (prop.mapToPk ? helper(this.em.getReference(prop.type, rel)).getSerializedPrimaryKey() === serializedPK : rel === entity)) {
+                else if (rel &&
+                    (prop.mapToPk
+                        ? helper(this.em.getReference(prop.targetMeta.class, rel)).getSerializedPrimaryKey() === serializedPK
+                        : rel === entity)) {
                     if (prop.formula) {
                         delete referrer[prop.name];
                     }
@@ -381,7 +443,6 @@ export class UnitOfWork {
         }
         delete wrapped.__identifier;
         delete wrapped.__originalEntityData;
-        wrapped.__touched = false;
         wrapped.__managed = false;
     }
     computeChangeSets() {
@@ -391,14 +452,14 @@ export class UnitOfWork {
             this.cascade(entity, Cascade.REMOVE, visited);
         }
         visited.clear();
-        for (const entity of this.persistStack) {
-            this.cascade(entity, Cascade.PERSIST, visited, { checkRemoveStack: true });
-        }
         for (const entity of this.identityMap) {
             if (!this.removeStack.has(entity) && !this.persistStack.has(entity) && !this.orphanRemoveStack.has(entity)) {
                 this.cascade(entity, Cascade.PERSIST, visited, { checkRemoveStack: true });
             }
         }
+        for (const entity of this.persistStack) {
+            this.cascade(entity, Cascade.PERSIST, visited, { checkRemoveStack: true });
+        }
         visited.clear();
         for (const entity of this.persistStack) {
             this.findNewEntities(entity, visited);
@@ -412,24 +473,24 @@ export class UnitOfWork {
         const inserts = {};
         for (const cs of this.changeSets.values()) {
             if (cs.type === ChangeSetType.CREATE) {
-                inserts[cs.meta.className] ??= [];
-                inserts[cs.meta.className].push(cs);
+                inserts[cs.meta.uniqueName] ??= [];
+                inserts[cs.meta.uniqueName].push(cs);
             }
         }
         for (const cs of this.changeSets.values()) {
             if (cs.type === ChangeSetType.UPDATE) {
-                this.findEarlyUpdates(cs, inserts[cs.meta.className]);
+                this.findEarlyUpdates(cs, inserts[cs.meta.uniqueName]);
             }
         }
         for (const entity of this.removeStack) {
             const wrapped = helper(entity);
-            /* v8 ignore next 3 */
+            /* v8 ignore next */
             if (wrapped.__processing) {
                 continue;
             }
             const deletePkHash = [wrapped.getSerializedPrimaryKey(), ...this.expandUniqueProps(entity)];
             let type = ChangeSetType.DELETE;
-            for (const cs of inserts[wrapped.__meta.className] ?? []) {
+            for (const cs of inserts[wrapped.__meta.uniqueName] ?? []) {
                 if (deletePkHash.some(hash => hash === cs.getSerializedPrimaryKey() || this.expandUniqueProps(cs.entity).find(child => hash === child))) {
                     type = ChangeSetType.DELETE_EARLY;
                 }
@@ -448,7 +509,7 @@ export class UnitOfWork {
         }
         for (const cs of this.changeSets.values()) {
             for (const prop of props) {
-                if (prop.name in cs.payload && cs.rootName === changeSet.rootName && cs.type === changeSet.type) {
+                if (prop.name in cs.payload && cs.rootMeta === changeSet.rootMeta && cs.type === changeSet.type) {
                     conflicts = true;
                     if (changeSet.payload[prop.name] == null) {
                         type = ChangeSetType.UPDATE_EARLY;
@@ -459,7 +520,13 @@ export class UnitOfWork {
         if (!conflicts) {
             return;
         }
-        this.extraUpdates.add([changeSet.entity, props.map(p => p.name), props.map(p => changeSet.entity[p.name]), changeSet, type]);
+        this.extraUpdates.add([
+            changeSet.entity,
+            props.map(p => p.name),
+            props.map(p => changeSet.entity[p.name]),
+            changeSet,
+            type,
+        ]);
         for (const p of props) {
             delete changeSet.entity[p.name];
             delete changeSet.payload[p.name];
@@ -467,9 +534,10 @@ export class UnitOfWork {
     }
     scheduleOrphanRemoval(entity, visited) {
         if (entity) {
-            helper(entity).__em = this.em;
+            const wrapped = helper(entity);
+            wrapped.__em = this.em;
             this.orphanRemoveStack.add(entity);
-            this.queuedActions.add(entity.__meta.className);
+            this.queuedActions.add(wrapped.__meta.class);
             this.cascade(entity, Cascade.SCHEDULE_ORPHAN_REMOVAL, visited);
         }
     }
@@ -505,7 +573,68 @@ export class UnitOfWork {
         }
         const changeSet = this.changeSetComputer.computeChangeSet(entity);
         if (changeSet && !this.checkUniqueProps(changeSet)) {
-            this.changeSets.set(entity, changeSet);
+            // For TPT child entities, create changesets for each table in hierarchy
+            if (wrapped.__meta.inheritanceType === 'tpt' && wrapped.__meta.tptParent) {
+                this.createTPTChangeSets(entity, changeSet);
+            }
+            else {
+                this.changeSets.set(entity, changeSet);
+            }
+        }
+    }
+    /**
+     * For TPT inheritance, creates separate changesets for each table in the hierarchy.
+     * Uses the same entity instance for all changesets - only the metadata and payload differ.
+     */
+    createTPTChangeSets(entity, originalChangeSet) {
+        const meta = helper(entity).__meta;
+        const isCreate = originalChangeSet.type === ChangeSetType.CREATE;
+        let current = meta;
+        let leafCs;
+        const parentChangeSets = [];
+        while (current) {
+            const isRoot = !current.tptParent;
+            const payload = {};
+            for (const prop of current.ownProps) {
+                if (prop.name in originalChangeSet.payload) {
+                    payload[prop.name] = originalChangeSet.payload[prop.name];
+                }
+            }
+            // For CREATE on non-root tables, include the PK (EntityIdentifier for deferred resolution)
+            if (isCreate && !isRoot) {
+                const wrapped = helper(entity);
+                const identifier = wrapped.__identifier;
+                const identifiers = Array.isArray(identifier) ? identifier : [identifier];
+                for (let i = 0; i < current.primaryKeys.length; i++) {
+                    const pk = current.primaryKeys[i];
+                    payload[pk] = identifiers[i] ?? originalChangeSet.payload[pk];
+                }
+            }
+            if (!isCreate && Object.keys(payload).length === 0) {
+                current = current.tptParent;
+                continue;
+            }
+            const cs = new ChangeSet(entity, originalChangeSet.type, payload, current);
+            if (current === meta) {
+                cs.originalEntity = originalChangeSet.originalEntity;
+                leafCs = cs;
+            }
+            else {
+                parentChangeSets.push(cs);
+            }
+            current = current.tptParent;
+        }
+        // When only parent properties changed (UPDATE), leaf payload is empty—create a stub anchor
+        if (!leafCs && parentChangeSets.length > 0) {
+            leafCs = new ChangeSet(entity, originalChangeSet.type, {}, meta);
+            leafCs.originalEntity = originalChangeSet.originalEntity;
+        }
+        // Store the leaf changeset in the main map (entity as key), with parent CSs attached
+        if (leafCs) {
+            if (parentChangeSets.length > 0) {
+                leafCs.tptChangeSets = parentChangeSets;
+            }
+            this.changeSets.set(entity, leafCs);
         }
     }
     /**
@@ -518,7 +647,7 @@ export class UnitOfWork {
         // when changing a unique nullable property (or a 1:1 relation), we can't do it in a single
         // query as it would cause unique constraint violations
         const uniqueProps = changeSet.meta.uniqueProps.filter(prop => {
-            return (prop.nullable || changeSet.type !== ChangeSetType.CREATE);
+            return prop.nullable || changeSet.type !== ChangeSetType.CREATE;
         });
         this.scheduleExtraUpdate(changeSet, uniqueProps);
         return changeSet.type === ChangeSetType.UPDATE && !Utils.hasObjectKeys(changeSet.payload);
@@ -528,25 +657,33 @@ export class UnitOfWork {
         if (!wrapped.__meta.hasUniqueProps) {
             return [];
         }
-        const simpleUniqueHashes = wrapped.__meta.uniqueProps.map(prop => {
+        const simpleUniqueHashes = wrapped.__meta.uniqueProps
+            .map(prop => {
             if (entity[prop.name] != null) {
-                return prop.kind === ReferenceKind.SCALAR || prop.mapToPk ? entity[prop.name] : helper(entity[prop.name]).getSerializedPrimaryKey();
+                return prop.kind === ReferenceKind.SCALAR || prop.mapToPk
+                    ? entity[prop.name]
+                    : helper(entity[prop.name]).getSerializedPrimaryKey();
             }
             if (wrapped.__originalEntityData?.[prop.name] != null) {
                 return Utils.getPrimaryKeyHash(Utils.asArray(wrapped.__originalEntityData[prop.name]));
             }
             return undefined;
-        }).filter(i => i);
-        const compoundUniqueHashes = wrapped.__meta.uniques.map(unique => {
+        })
+            .filter(i => i);
+        const compoundUniqueHashes = wrapped.__meta.uniques
+            .map(unique => {
             const props = Utils.asArray(unique.properties);
             if (props.every(prop => entity[prop] != null)) {
                 return Utils.getPrimaryKeyHash(props.map(p => {
                     const prop = wrapped.__meta.properties[p];
-                    return prop.kind === ReferenceKind.SCALAR || prop.mapToPk ? entity[prop.name] : helper(entity[prop.name]).getSerializedPrimaryKey();
+                    return prop.kind === ReferenceKind.SCALAR || prop.mapToPk
+                        ? entity[prop.name]
+                        : helper(entity[prop.name]).getSerializedPrimaryKey();
                 }));
             }
             return undefined;
-        }).filter(i => i);
+        })
+            .filter(i => i);
         return simpleUniqueHashes.concat(compoundUniqueHashes);
     }
     initIdentifier(entity) {
@@ -578,7 +715,8 @@ export class UnitOfWork {
             return this.processToOneReference(kind, visited, processed, idx);
         }
         if (Utils.isCollection(kind)) {
-            kind.getItems(false)
+            kind
+                .getItems(false)
                 .filter(item => !item.__helper.__originalEntityData)
                 .forEach(item => {
                 // propagate schema from parent
@@ -602,7 +740,8 @@ export class UnitOfWork {
             parent[prop.name] = coll;
             return;
         }
-        collection.getItems(false)
+        collection
+            .getItems(false)
             .filter(item => !item.__helper.__originalEntityData)
             .forEach(item => this.findNewEntities(item, visited, 0, processed));
     }
@@ -618,7 +757,7 @@ export class UnitOfWork {
         const copy = this.comparator.prepareEntity(changeSet.entity);
         await this.eventManager.dispatchEvent(type, { entity: changeSet.entity, meta, em: this.em, changeSet });
         const current = this.comparator.prepareEntity(changeSet.entity);
-        const diff = this.comparator.diffEntities(changeSet.name, copy, current);
+        const diff = this.comparator.diffEntities(changeSet.meta.class, copy, current);
         Object.assign(changeSet.payload, diff);
         const wrapped = helper(changeSet.entity);
         if (wrapped.__identifier) {
@@ -694,7 +833,8 @@ export class UnitOfWork {
         return filtered.some(items => processed.has(items));
     }
     shouldCascade(prop, type) {
-        if ([Cascade.REMOVE, Cascade.SCHEDULE_ORPHAN_REMOVAL, Cascade.CANCEL_ORPHAN_REMOVAL, Cascade.ALL].includes(type) && prop.orphanRemoval) {
+        if ([Cascade.REMOVE, Cascade.SCHEDULE_ORPHAN_REMOVAL, Cascade.CANCEL_ORPHAN_REMOVAL, Cascade.ALL].includes(type) &&
+            prop.orphanRemoval) {
             return true;
         }
         // ignore user settings for merge, it is kept only for back compatibility, this should have never been configurable
@@ -713,7 +853,7 @@ export class UnitOfWork {
         if (!meta.versionProperty) {
             throw OptimisticLockError.notVersioned(meta);
         }
-        if (!Utils.isDefined(version)) {
+        if (typeof version === 'undefined') {
             return;
         }
         const wrapped = helper(entity);
@@ -727,26 +867,28 @@ export class UnitOfWork {
     }
     fixMissingReference(entity, prop) {
         const reference = entity[prop.name];
-        const kind = Reference.unwrapReference(reference);
-        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && kind && !prop.mapToPk) {
-            if (!Utils.isEntity(kind)) {
-                entity[prop.name] = this.em.getReference(prop.type, kind, { wrapped: !!prop.ref });
+        const target = Reference.unwrapReference(reference);
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && target && !prop.mapToPk) {
+            if (!Utils.isEntity(target)) {
+                entity[prop.name] = this.em.getReference(prop.targetMeta.class, target, {
+                    wrapped: !!prop.ref,
+                });
             }
-            else if (!helper(kind).__initialized && !helper(kind).__em) {
-                const pk = helper(kind).getPrimaryKey();
-                entity[prop.name] = this.em.getReference(prop.type, pk, { wrapped: !!prop.ref });
+            else if (!helper(target).__initialized && !helper(target).__em) {
+                const pk = helper(target).getPrimaryKey();
+                entity[prop.name] = this.em.getReference(prop.targetMeta.class, pk, { wrapped: !!prop.ref });
             }
         }
-        // perf: set the `Collection._property` to skip the getter, as it can be slow when there is a lot of relations
-        if (Utils.isCollection(kind)) {
-            kind.property = prop;
+        // perf: set the `Collection._property` to skip the getter, as it can be slow when there are a lot of relations
+        if (Utils.isCollection(target)) {
+            target.property = prop;
         }
         const isCollection = [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind);
-        if (isCollection && Array.isArray(kind)) {
+        if (isCollection && Array.isArray(target)) {
             const collection = new Collection(entity);
             collection.property = prop;
             entity[prop.name] = collection;
-            collection.set(kind);
+            collection.set(target);
         }
     }
     async persistToDatabase(groups, ctx) {
@@ -756,30 +898,30 @@ export class UnitOfWork {
         const commitOrder = this.getCommitOrder();
         const commitOrderReversed = [...commitOrder].reverse();
         // early delete - when we recreate entity in the same UoW, we need to issue those delete queries before inserts
-        for (const name of commitOrderReversed) {
-            await this.commitDeleteChangeSets(groups[ChangeSetType.DELETE_EARLY].get(name) ?? [], ctx);
+        for (const meta of commitOrderReversed) {
+            await this.commitDeleteChangeSets(groups[ChangeSetType.DELETE_EARLY].get(meta) ?? [], ctx);
         }
         // early update - when we recreate entity in the same UoW, we need to issue those delete queries before inserts
-        for (const name of commitOrder) {
-            await this.commitUpdateChangeSets(groups[ChangeSetType.UPDATE_EARLY].get(name) ?? [], ctx);
+        for (const meta of commitOrder) {
+            await this.commitUpdateChangeSets(groups[ChangeSetType.UPDATE_EARLY].get(meta) ?? [], ctx);
         }
         // extra updates
         await this.commitExtraUpdates(ChangeSetType.UPDATE_EARLY, ctx);
         // create
-        for (const name of commitOrder) {
-            await this.commitCreateChangeSets(groups[ChangeSetType.CREATE].get(name) ?? [], ctx);
+        for (const meta of commitOrder) {
+            await this.commitCreateChangeSets(groups[ChangeSetType.CREATE].get(meta) ?? [], ctx);
         }
         // update
-        for (const name of commitOrder) {
-            await this.commitUpdateChangeSets(groups[ChangeSetType.UPDATE].get(name) ?? [], ctx);
+        for (const meta of commitOrder) {
+            await this.commitUpdateChangeSets(groups[ChangeSetType.UPDATE].get(meta) ?? [], ctx);
         }
         // extra updates
         await this.commitExtraUpdates(ChangeSetType.UPDATE, ctx);
         // collection updates
         await this.commitCollectionUpdates(ctx);
         // delete - entity deletions need to be in reverse commit order
-        for (const name of commitOrderReversed) {
-            await this.commitDeleteChangeSets(groups[ChangeSetType.DELETE].get(name) ?? [], ctx);
+        for (const meta of commitOrderReversed) {
+            await this.commitDeleteChangeSets(groups[ChangeSetType.DELETE].get(meta) ?? [], ctx);
         }
         // take snapshots of all persisted collections
         const visited = new Set();
@@ -792,9 +934,9 @@ export class UnitOfWork {
             return;
         }
         const props = changeSets[0].meta.root.relations.filter(prop => {
-            return (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner)
-                || prop.kind === ReferenceKind.MANY_TO_ONE
-                || (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !this.platform.usesPivotTable());
+            return ((prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner) ||
+                prop.kind === ReferenceKind.MANY_TO_ONE ||
+                (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !this.platform.usesPivotTable()));
         });
         for (const changeSet of changeSets) {
             this.findExtraUpdates(changeSet, props);
@@ -815,16 +957,28 @@ export class UnitOfWork {
             if (Utils.isCollection(ref)) {
                 ref.getItems(false).some(item => {
                     const cs = this.changeSets.get(Reference.unwrapReference(item));
-                    const isScheduledForInsert = cs && cs.type === ChangeSetType.CREATE && !cs.persisted;
+                    const isScheduledForInsert = cs?.type === ChangeSetType.CREATE && !cs.persisted;
                     if (isScheduledForInsert) {
                         this.scheduleExtraUpdate(changeSet, [prop]);
                         return true;
                     }
                     return false;
                 });
+                continue;
+            }
+            const refEntity = Reference.unwrapReference(ref);
+            // For mapToPk properties, the value is a primitive (string/array), not an entity
+            if (!Utils.isEntity(refEntity)) {
+                continue;
             }
-            const cs = this.changeSets.get(Reference.unwrapReference(ref));
-            const isScheduledForInsert = cs && cs.type === ChangeSetType.CREATE && !cs.persisted;
+            // For TPT entities, check if the ROOT table's changeset has been persisted
+            // (since the FK is to the root table, not the concrete entity's table)
+            let cs = this.changeSets.get(refEntity);
+            if (cs?.tptChangeSets?.length) {
+                // Root table changeset is the last one (ordered immediate parent → root)
+                cs = cs.tptChangeSets[cs.tptChangeSets.length - 1];
+            }
+            const isScheduledForInsert = cs?.type === ChangeSetType.CREATE && !cs.persisted;
             if (isScheduledForInsert) {
                 this.scheduleExtraUpdate(changeSet, [prop]);
             }
@@ -855,10 +1009,10 @@ export class UnitOfWork {
         for (const changeSet of changeSets) {
             const wrapped = helper(changeSet.entity);
             wrapped.__originalEntityData = this.comparator.prepareEntity(changeSet.entity);
-            wrapped.__touched = false;
             if (!wrapped.__initialized) {
                 for (const prop of changeSet.meta.relations) {
-                    if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) && changeSet.entity[prop.name] == null) {
+                    if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) &&
+                        changeSet.entity[prop.name] == null) {
                         changeSet.entity[prop.name] = Collection.create(changeSet.entity, prop.name, undefined, wrapped.isInitialized());
                     }
                 }
@@ -887,7 +1041,7 @@ export class UnitOfWork {
                 continue;
             }
             if (Array.isArray(extraUpdate[1])) {
-                extraUpdate[1].forEach((p, i) => extraUpdate[0][p] = extraUpdate[2][i]);
+                extraUpdate[1].forEach((p, i) => (extraUpdate[0][p] = extraUpdate[2][i]));
             }
             else {
                 extraUpdate[0][extraUpdate[1]] = extraUpdate[2];
@@ -947,12 +1101,24 @@ export class UnitOfWork {
             [ChangeSetType.UPDATE_EARLY]: new Map(),
             [ChangeSetType.DELETE_EARLY]: new Map(),
         };
-        for (const cs of this.changeSets.values()) {
+        const addToGroup = (cs) => {
+            // Skip stub TPT changesets with empty payload (e.g. leaf with no own-property changes on UPDATE)
+            if ((cs.type === ChangeSetType.UPDATE || cs.type === ChangeSetType.UPDATE_EARLY) &&
+                !Utils.hasObjectKeys(cs.payload)) {
+                return;
+            }
             const group = groups[cs.type];
-            const classGroup = group.get(cs.rootName) ?? [];
+            const groupKey = cs.meta.inheritanceType === 'tpt' ? cs.meta : cs.rootMeta;
+            const classGroup = group.get(groupKey) ?? [];
             classGroup.push(cs);
-            if (!group.has(cs.rootName)) {
-                group.set(cs.rootName, classGroup);
+            if (!group.has(groupKey)) {
+                group.set(groupKey, classGroup);
+            }
+        };
+        for (const cs of this.changeSets.values()) {
+            addToGroup(cs);
+            for (const parentCs of cs.tptChangeSets ?? []) {
+                addToGroup(parentCs);
             }
         }
         return groups;
@@ -960,14 +1126,35 @@ export class UnitOfWork {
     getCommitOrder() {
         const calc = new CommitOrderCalculator();
         const set = new Set();
-        this.changeSets.forEach(cs => set.add(cs.rootName));
-        set.forEach(entityName => calc.addNode(entityName));
-        for (const entityName of set) {
-            for (const prop of this.metadata.find(entityName).props) {
-                calc.discoverProperty(prop, entityName);
+        this.changeSets.forEach(cs => {
+            if (cs.meta.inheritanceType === 'tpt') {
+                set.add(cs.meta);
+                for (const parentCs of cs.tptChangeSets ?? []) {
+                    set.add(parentCs.meta);
+                }
+            }
+            else {
+                set.add(cs.rootMeta);
+            }
+        });
+        set.forEach(meta => calc.addNode(meta._id));
+        for (const meta of set) {
+            for (const prop of meta.relations) {
+                if (prop.polymorphTargets) {
+                    for (const targetMeta of prop.polymorphTargets) {
+                        calc.discoverProperty({ ...prop, targetMeta }, meta._id);
+                    }
+                }
+                else {
+                    calc.discoverProperty(prop, meta._id);
+                }
+            }
+            // For TPT, parent table must be inserted BEFORE child tables
+            if (meta.inheritanceType === 'tpt' && meta.tptParent && set.has(meta.tptParent)) {
+                calc.addDependency(meta.tptParent._id, meta._id, 1);
             }
         }
-        return calc.sort();
+        return calc.sort().map(id => this.metadata.getById(id));
     }
     resetTransaction(oldTx) {
         if (oldTx) {