@mikro-orm/core 7.0.11-dev.13 → 7.0.11-dev.14

package/entity/EntityLoader.js

@@ -555,7 +555,12 @@ export class EntityLoader {
         };
         if (prop.polymorphic && prop.polymorphTargets) {
             await Promise.all(prop.polymorphTargets.map(async (targetMeta) => {
-                const targetChildren = unique.filter(child => helper(child).__meta.className === targetMeta.className);
+                const targetChildren = unique.filter(child => {
+                    const childMeta = helper(child).__meta;
+                    // Use root.className for TPT entities: a Dog (root: Animal) should match
+                    // targetMeta Animal. For non-TPT entities, root === self.
+                    return childMeta.root.className === targetMeta.root.className;
+                });
                 if (targetChildren.length > 0) {
                     await populateChildren(targetMeta, targetChildren);
                 }

package/metadata/MetadataValidator.js

@@ -283,8 +283,10 @@ export class MetadataValidator {
     validateIndexes(meta, indexes, type) {
         for (const index of indexes) {
             for (const propName of Utils.asArray(index.properties)) {
-                const prop = meta.root.properties[propName];
-                if (!prop && !Object.values(meta.root.properties).some(p => propName.startsWith(p.name + '.'))) {
+                const prop = meta.properties[propName] ?? meta.root.properties[propName];
+                if (!prop &&
+                    !Object.values(meta.properties).some(p => propName.startsWith(p.name + '.')) &&
+                    !Object.values(meta.root.properties).some(p => propName.startsWith(p.name + '.'))) {
                     throw MetadataError.unknownIndexProperty(meta, propName, type);
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.11-dev.13",
+  "version": "7.0.11-dev.14",
   "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/utils/EntityComparator.js

@@ -569,7 +569,14 @@ export class EntityComparator {
                 ret += `      ret${dataKey} = null;\n`;
                 ret += `    } else if (typeof entity${entityKey} !== 'undefined') {\n`;
                 ret += `      const val${level} = entity${entityKey}${unwrap};\n`;
-                ret += `      const discriminator = ${discriminatorMapKey}.get(val${level}?.constructor);\n`;
+                // walk up the prototype chain so TPT subclasses resolve to their root's discriminator
+                ret += `      let __cls${level} = val${level}?.constructor;\n`;
+                ret += `      let discriminator;\n`;
+                ret += `      while (__cls${level} != null) {\n`;
+                ret += `        discriminator = ${discriminatorMapKey}.get(__cls${level});\n`;
+                ret += `        if (discriminator !== undefined) break;\n`;
+                ret += `        __cls${level} = Object.getPrototypeOf(__cls${level});\n`;
+                ret += `      }\n`;
                 ret += `      const pk = val${level}?.__helper?.__identifier && !val${level}?.__helper?.hasPrimaryKey()\n`;
                 ret += `        ? val${level}.__helper.__identifier\n`;
                 ret += `        : toArray(val${level}?.__helper?.getPrimaryKey(true));\n`;

package/utils/QueryHelper.d.ts

@@ -8,6 +8,7 @@ export declare class QueryHelper {
     static readonly SUPPORTED_OPERATORS: string[];
     /**
      * Finds the discriminator value (key) for a given entity class in a discriminator map.
+     * Walks up the prototype chain so TPT subclasses resolve to their root's key.
      */
     static findDiscriminatorValue<T>(discriminatorMap: Dictionary<T>, targetClass: T): string | undefined;
     static processParams(params: unknown): any;

package/utils/QueryHelper.js

@@ -9,9 +9,19 @@ export class QueryHelper {
     static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
     /**
      * Finds the discriminator value (key) for a given entity class in a discriminator map.
+     * Walks up the prototype chain so TPT subclasses resolve to their root's key.
      */
     static findDiscriminatorValue(discriminatorMap, targetClass) {
-        return Object.entries(discriminatorMap).find(([, cls]) => cls === targetClass)?.[0];
+        const entries = Object.entries(discriminatorMap);
+        let current = targetClass;
+        while (current != null) {
+            const hit = entries.find(([, cls]) => cls === current)?.[0];
+            if (hit) {
+                return hit;
+            }
+            current = Object.getPrototypeOf(current);
+        }
+        return undefined;
     }
     static processParams(params) {
         if (Reference.isReference(params)) {

package/utils/Utils.js

@@ -141,7 +141,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.11-dev.13';
+    static #ORM_VERSION = '7.0.11-dev.14';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */