@mikro-orm/sql 7.1.10-dev.6 → 7.1.10-dev.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.10-dev.6",
+  "version": "7.1.10-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",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.1.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.10-dev.6"
+    "@mikro-orm/core": "7.1.10-dev.7"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/QueryBuilder.d.ts

@@ -507,11 +507,16 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      */
     applyJoinedFilters(em: EntityManager, filterOptions: FilterOptions | undefined): Promise<void>;
     /**
-     * Auto-joins added while processing a condition of `condJoin` would render after it and produce a
-     * forward alias reference in its `on` clause. Fold them into `condJoin`, so they render as a single
-     * parenthesized join group and share the scope of the outer `on` clause (issue #7681).
-     */
-    private nestNewJoins;
+     * The `on` clause of `condJoin` — its explicit join condition or a filter condition merged into
+     * it — can reference the alias of any join in its subtree, both auto-joins created while
+     * processing the condition and pre-existing joined paths, all of which render after `condJoin`
+     * and would be forward alias references (issues #7681, #8090, #8099). When that happens, fold the
+     * subtree into `condJoin`, so it renders as a single parenthesized join group and every alias
+     * shares the scope of the outer `on` clause.
+     */
+    private nestReferencedJoins;
+    private getJoinSubtree;
+    private condReferencesAlias;
     withSubQuery(subQuery: RawQueryFragment | NativeQueryBuilder, alias: string): this;
     /**
      * Adds a WHERE clause to the query using an object condition.

package/query/QueryBuilder.js

@@ -411,7 +411,6 @@ export class QueryBuilder {
             filterOptions = QueryHelper.mergePropertyFilters(join.prop.filters, filterOptions);
             let cond = await em.applyFilters(join.prop.targetMeta.class, join.cond, filterOptions, 'read');
             const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, join.prop.targetMeta.class, cond);
-            const joinCountBefore = Object.keys(this.#state.joins).length;
             cond = criteriaNode.process(this, {
                 matchPopulateJoins: true,
                 filter: true,
@@ -419,7 +418,6 @@ export class QueryBuilder {
                 ignoreBranching: true,
                 parentPath: join.path,
             });
-            this.nestNewJoins(join, joinCountBefore);
             if (Utils.hasObjectKeys(cond) || RawQueryFragment.hasObjectFragments(cond)) {
                 // remove nested filters, we only care about scalars here, nesting would require another join branch
                 for (const key of Object.keys(cond)) {
@@ -435,6 +433,7 @@ export class QueryBuilder {
                 else {
                     join.cond = { ...cond };
                 }
+                this.nestReferencedJoins(join);
                 // For polymorphic LEFT JOIN filters, add a WHERE condition to enforce the filter
                 // only for rows matching this target's discriminator value. This ensures rows pointing
                 // to other polymorphic targets are not excluded.
@@ -459,26 +458,44 @@ export class QueryBuilder {
         }
     }
     /**
-     * Auto-joins added while processing a condition of `condJoin` would render after it and produce a
-     * forward alias reference in its `on` clause. Fold them into `condJoin`, so they render as a single
-     * parenthesized join group and share the scope of the outer `on` clause (issue #7681).
+     * The `on` clause of `condJoin` — its explicit join condition or a filter condition merged into
+     * it — can reference the alias of any join in its subtree, both auto-joins created while
+     * processing the condition and pre-existing joined paths, all of which render after `condJoin`
+     * and would be forward alias references (issues #7681, #8090, #8099). When that happens, fold the
+     * subtree into `condJoin`, so it renders as a single parenthesized join group and every alias
+     * shares the scope of the outer `on` clause.
      */
-    nestNewJoins(condJoin, joinCountBefore) {
+    nestReferencedJoins(condJoin) {
         // m:n pivot joins might not have the target join entry created
         if (!condJoin) {
             return;
         }
-        const joinKeys = Object.keys(this.#state.joins);
-        for (let i = joinCountBefore; i < joinKeys.length; i++) {
-            const j = this.#state.joins[joinKeys[i]];
-            if (j === condJoin || j.ownerAlias !== condJoin.alias) {
-                continue;
+        const subtree = this.getJoinSubtree(condJoin);
+        if (!subtree.some(j => this.condReferencesAlias(condJoin.cond, j.alias))) {
+            return;
+        }
+        for (const j of subtree) {
+            const parent = j.ownerAlias === condJoin.alias ? condJoin : subtree.find(p => p.alias === j.ownerAlias);
+            if (!parent.nested?.has(j)) {
+                const nested = (parent.nested ??= new Set());
+                j.type = j.type === JoinType.innerJoin ? JoinType.nestedInnerJoin : JoinType.nestedLeftJoin;
+                nested.add(j);
             }
-            const nested = (condJoin.nested ??= new Set());
-            j.type = j.type === JoinType.innerJoin ? JoinType.nestedInnerJoin : JoinType.nestedLeftJoin;
-            nested.add(j);
         }
     }
+    getJoinSubtree(join) {
+        const children = Object.values(this.#state.joins).filter(j => j !== join && j.ownerAlias === join.alias);
+        return children.flatMap(j => [j, ...this.getJoinSubtree(j)]);
+    }
+    condReferencesAlias(cond, alias) {
+        if (Array.isArray(cond)) {
+            return cond.some(c => this.condReferencesAlias(c, alias));
+        }
+        if (Utils.isPlainObject(cond)) {
+            return Object.entries(cond).some(([key, value]) => key.startsWith(`${alias}.`) || this.condReferencesAlias(value, alias));
+        }
+        return false;
+    }
     withSubQuery(subQuery, alias) {
         this.ensureNotFinalized();
         if (isRaw(subQuery)) {
@@ -1437,7 +1454,6 @@ export class QueryBuilder {
             aliased: [QueryType.SELECT, QueryType.COUNT].includes(this.type),
         });
         const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, prop.targetMeta.class, cond);
-        const joinCountBefore = Object.keys(this.#state.joins).length;
         cond = criteriaNode.process(this, { ignoreBranching: true, alias });
         let aliasedName = `${fromAlias}.${prop.name}#${alias}`;
         path ??= `${Object.values(this.#state.joins).find(j => j.alias === fromAlias)?.path ?? Utils.className(entityName)}.${prop.name}`;
@@ -1467,7 +1483,7 @@ export class QueryBuilder {
             this.#state.joins[aliasedName] = this.helper.joinManyToOneReference(prop, ownerAlias, alias, type, cond, schema);
             this.#state.joins[aliasedName].path ??= path;
         }
-        this.nestNewJoins(this.#state.joins[aliasedName], joinCountBefore);
+        this.nestReferencedJoins(this.#state.joins[aliasedName]);
         return { prop, key: aliasedName };
     }
     prepareFields(fields, type = 'where', schema) {