@mikro-orm/core 7.0.8-dev.5 → 7.0.8-dev.7

package/entity/EntityLoader.js

@@ -53,6 +53,32 @@ export class EntityLoader {
         for (const pop of populate) {
             await this.populateField(entityName, entities, pop, options);
         }
+        // Child-specific relations exist only on child metadata, so the parent-scoped populate loop above skips them (GH #7453).
+        if (Array.isArray(populate) &&
+            populate.some(p => p.all) &&
+            meta.inheritanceType === 'tpt' &&
+            meta.tptChildren?.length) {
+            const byType = new Map();
+            for (const entity of entities) {
+                const entityMeta = helper(entity).__meta;
+                if (entityMeta !== meta) {
+                    const group = byType.get(entityMeta);
+                    if (group) {
+                        group.push(entity);
+                    }
+                    else {
+                        byType.set(entityMeta, [entity]);
+                    }
+                }
+            }
+            for (const [childMeta, group] of byType) {
+                await this.populate(childMeta.class, group, true, {
+                    ...options,
+                    lookup: false,
+                    validate: false,
+                });
+            }
+        }
         for (const entity of entities) {
             visited.delete(entity);
         }
@@ -711,6 +737,11 @@ export class EntityLoader {
                 all: true,
             });
         });
+        // For TPT parents with child types, keep an all:true sentinel so the populate
+        // loop doesn't exit early and the TPT child relation population can run after it.
+        if (ret.length === 0 && meta.inheritanceType === 'tpt' && meta.tptChildren?.length) {
+            ret.push({ field: meta.primaryKeys[0], strategy: LoadStrategy.SELECT_IN, all: true });
+        }
         return ret;
     }
     getRelationName(meta, prop) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.8-dev.5",
+  "version": "7.0.8-dev.7",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",

package/unit-of-work/UnitOfWork.js

@@ -292,7 +292,12 @@ export class UnitOfWork {
             cs.type = type;
         }
         this.initIdentifier(entity);
-        this.#changeSets.set(entity, cs);
+        if (wrapped.__meta.inheritanceType === 'tpt' && wrapped.__meta.tptParent) {
+            this.createTPTChangeSets(entity, cs);
+        }
+        else {
+            this.#changeSets.set(entity, cs);
+        }
         this.#persistStack.delete(entity);
         wrapped.__originalEntityData = this.#comparator.prepareEntity(entity);
     }
@@ -304,8 +309,37 @@ export class UnitOfWork {
         }
         const cs = this.#changeSetComputer.computeChangeSet(entity);
         if (cs && !this.checkUniqueProps(cs)) {
-            Object.assign(changeSet.payload, cs.payload);
-            helper(entity).__originalEntityData = this.#comparator.prepareEntity(entity);
+            const wrapped = helper(entity);
+            // For TPT entities, update only each table's own properties so parent
+            // columns don't leak into the leaf table's INSERT/UPDATE (GH #7455).
+            if (wrapped.__meta.inheritanceType === 'tpt' && wrapped.__meta.tptParent) {
+                for (const prop of wrapped.__meta.ownProps) {
+                    if (prop.name in cs.payload) {
+                        changeSet.payload[prop.name] = cs.payload[prop.name];
+                    }
+                }
+                changeSet.tptChangeSets ??= [];
+                let current = wrapped.__meta.tptParent;
+                let idx = 0;
+                while (current) {
+                    let parentCs = changeSet.tptChangeSets.find(pc => pc.meta === current);
+                    if (!parentCs) {
+                        parentCs = new ChangeSet(entity, changeSet.type, {}, current);
+                        changeSet.tptChangeSets.splice(idx, 0, parentCs);
+                    }
+                    idx++;
+                    for (const prop of current.ownProps) {
+                        if (prop.name in cs.payload) {
+                            parentCs.payload[prop.name] = cs.payload[prop.name];
+                        }
+                    }
+                    current = current.tptParent;
+                }
+            }
+            else {
+                Object.assign(changeSet.payload, cs.payload);
+            }
+            wrapped.__originalEntityData = this.#comparator.prepareEntity(entity);
         }
     }
     /** Marks an entity for persistence, cascading to related entities. */

package/utils/Utils.js

@@ -132,7 +132,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.8-dev.5';
+    static #ORM_VERSION = '7.0.8-dev.7';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */