@mikro-orm/sql 7.1.0-dev.36 → 7.1.0-dev.38

package/AbstractSqlDriver.d.ts

@@ -118,6 +118,13 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     mergeJoinedResult<T extends object>(rawResults: EntityData<T>[], meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[]): EntityData<T>[];
     protected shouldHaveColumn<T, U>(meta: EntityMetadata<T>, prop: EntityProperty<U>, populate: readonly PopulateOptions<U>[], fields?: readonly InternalField<U>[], exclude?: readonly InternalField<U>[]): boolean;
     protected getFieldsForJoinedLoad<T extends object>(qb: AnyQueryBuilder<T>, meta: EntityMetadata<T>, options: FieldsForJoinedLoadOptions<T>): InternalField<T>[];
+    /**
+     * Walks the TPT inheritance chain of `leafMeta` and INNER JOINs each parent table.
+     * Registers the parent aliases in `qb.state.tptAlias` so column resolution finds them
+     * when filter conditions reference parent-table columns.
+     * @internal
+     */
+    protected addTPTParentJoinsForRelation<T extends object>(qb: AnyQueryBuilder<T>, leafMeta: EntityMetadata, leafAlias: string, basePath: string): void;
     /**
      * Adds LEFT JOINs and fields for TPT polymorphic loading when populating a relation to a TPT base class.
      * @internal

package/AbstractSqlDriver.js

@@ -1727,6 +1727,13 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     const targetPath = `${pathPrefix}${basePath}[${targetMeta.className}]`;
                     const schema = targetMeta.schema === '*' ? (options?.schema ?? this.config.get('schema')) : targetMeta.schema;
                     qb.addPolymorphicJoin(prop, targetMeta, options.parentTableAlias, tableAlias, JoinType.leftJoin, targetPath, schema);
+                    // For polymorphic targets that are TPT child entities, INNER JOIN parent tables so that
+                    // filter conditions referencing parent-table columns resolve to the correct alias. The
+                    // INNER JOINs get nested inside the polymorphic LEFT JOIN by processNestedJoins, which
+                    // keeps the resulting query valid for rows pointing to other polymorphic targets.
+                    if (targetMeta.inheritanceType === 'tpt' && targetMeta.tptParent) {
+                        this.addTPTParentJoinsForRelation(qb, targetMeta, tableAlias, targetPath);
+                    }
                     // For polymorphic targets that are TPT base classes, also LEFT JOIN
                     // all descendant tables so child-specific fields can be selected.
                     if (targetMeta.inheritanceType === 'tpt' && targetMeta.tptChildren?.length && !ref) {
@@ -1775,17 +1782,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             qb.join(field, tableAlias, {}, joinType, path, schema);
             // For relations to TPT child entities, INNER JOIN parent tables (GH #7469)
             if (meta2.inheritanceType === 'tpt' && meta2.tptParent) {
-                let childAlias = tableAlias;
-                let childMeta = meta2;
-                while (childMeta.tptParent) {
-                    const parentMeta = childMeta.tptParent;
-                    const parentAlias = qb.getNextAlias(parentMeta.className);
-                    qb.createAlias(parentMeta.class, parentAlias);
-                    qb.state.tptAlias[`${tableAlias}:${parentMeta.className}`] = parentAlias;
-                    qb.addPropertyJoin(childMeta.tptParentProp, childAlias, parentAlias, JoinType.innerJoin, `${path}.[tpt]${childMeta.className}`);
-                    childAlias = parentAlias;
-                    childMeta = parentMeta;
-                }
+                this.addTPTParentJoinsForRelation(qb, meta2, tableAlias, path);
             }
             // For relations to TPT base classes, add LEFT JOINs for all child tables (polymorphic loading)
             if (meta2.inheritanceType === 'tpt' && meta2.tptChildren?.length && !ref) {
@@ -1833,6 +1830,25 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         return fields;
     }
+    /**
+     * Walks the TPT inheritance chain of `leafMeta` and INNER JOINs each parent table.
+     * Registers the parent aliases in `qb.state.tptAlias` so column resolution finds them
+     * when filter conditions reference parent-table columns.
+     * @internal
+     */
+    addTPTParentJoinsForRelation(qb, leafMeta, leafAlias, basePath) {
+        let childAlias = leafAlias;
+        let childMeta = leafMeta;
+        while (childMeta.tptParent) {
+            const parentMeta = childMeta.tptParent;
+            const parentAlias = qb.getNextAlias(parentMeta.className);
+            qb.createAlias(parentMeta.class, parentAlias);
+            qb.state.tptAlias[`${leafAlias}:${parentMeta.className}`] = parentAlias;
+            qb.addPropertyJoin(childMeta.tptParentProp, childAlias, parentAlias, JoinType.innerJoin, `${basePath}.[tpt]${childMeta.className}`);
+            childAlias = parentAlias;
+            childMeta = parentMeta;
+        }
+    }
     /**
      * Adds LEFT JOINs and fields for TPT polymorphic loading when populating a relation to a TPT base class.
      * @internal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.0-dev.36",
+  "version": "7.1.0-dev.38",
   "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",
@@ -50,10 +50,10 @@
     "kysely": "0.29.0"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.15"
+    "@mikro-orm/core": "^7.0.16"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.36"
+    "@mikro-orm/core": "7.1.0-dev.38"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/QueryBuilder.js

@@ -1777,13 +1777,13 @@ export class QueryBuilder {
         }
         const types = Object.values(meta.root.discriminatorMap).map(cls => this.metadata.get(cls));
         const children = [];
-        const lookUpChildren = (ret, type) => {
-            const children = types.filter(meta2 => meta2.extends === type);
-            children.forEach(m => lookUpChildren(ret, m.class));
+        const lookUpChildren = (ret, parent) => {
+            const children = types.filter(meta2 => meta2.extends && this.metadata.find(meta2.extends) === parent);
+            children.forEach(m => lookUpChildren(ret, m));
             ret.push(...children.filter(c => c.discriminatorValue));
             return children;
         };
-        lookUpChildren(children, meta.class);
+        lookUpChildren(children, meta);
         this.andWhere({
             [meta.root.discriminatorColumn]: children.length > 0
                 ? { $in: [meta.discriminatorValue, ...children.map(c => c.discriminatorValue)] }