@mikro-orm/sql 7.1.10-dev.3 → 7.1.10-dev.5

package/package.json

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

package/query/QueryBuilder.d.ts

@@ -506,6 +506,12 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * @internal
      */
     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;
     withSubQuery(subQuery: RawQueryFragment | NativeQueryBuilder, alias: string): this;
     /**
      * Adds a WHERE clause to the query using an object condition.

package/query/QueryBuilder.js

@@ -411,6 +411,7 @@ 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,
@@ -418,6 +419,7 @@ 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)) {
@@ -456,6 +458,27 @@ 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).
+     */
+    nestNewJoins(condJoin, joinCountBefore) {
+        // 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 nested = (condJoin.nested ??= new Set());
+            j.type = j.type === JoinType.innerJoin ? JoinType.nestedInnerJoin : JoinType.nestedLeftJoin;
+            nested.add(j);
+        }
+    }
     withSubQuery(subQuery, alias) {
         this.ensureNotFinalized();
         if (isRaw(subQuery)) {
@@ -1444,20 +1467,7 @@ export class QueryBuilder {
             this.#state.joins[aliasedName] = this.helper.joinManyToOneReference(prop, ownerAlias, alias, type, cond, schema);
             this.#state.joins[aliasedName].path ??= path;
         }
-        // auto-joins added by cond processing that depend on the new alias would otherwise produce a
-        // forward reference (the auto-join's ON refers to alias, while alias's ON refers back to it);
-        // fold them into the new join so both aliases share scope in the outer ON clause (issue #7681)
-        const condJoin = this.#state.joins[aliasedName];
-        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 !== alias) {
-                continue;
-            }
-            const nested = (condJoin.nested ??= new Set());
-            j.type = j.type === JoinType.innerJoin ? JoinType.nestedInnerJoin : JoinType.nestedLeftJoin;
-            nested.add(j);
-        }
+        this.nestNewJoins(this.#state.joins[aliasedName], joinCountBefore);
         return { prop, key: aliasedName };
     }
     prepareFields(fields, type = 'where', schema) {