@mikro-orm/sql 7.1.13-dev.5 → 7.1.13-dev.6

package/package.json

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

package/query/QueryBuilder.d.ts

@@ -994,6 +994,13 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     processPopulateHint(): void;
     private processPopulateWhere;
     private mergeOnConditions;
+    /**
+     * `$or` branches can be moved to a to-one join's `on` clause only when they all target that same
+     * join and stay flat — a partial `$or` in the `on` clause would drop rows matching a sibling
+     * branch. A `$or` targeting only to-many joins keeps the partial distribution, as that is how
+     * `PopulateHint.INFER` narrows collections.
+     */
+    private canDistributeOrBranches;
     /**
      * When adding an inner join on a left joined relation, we need to nest them,
      * otherwise the inner join could discard rows of the root table.

package/query/QueryBuilder.js

@@ -2038,6 +2038,10 @@ export class QueryBuilder {
         for (const k of Object.keys(cond)) {
             if (Utils.isOperator(k)) {
                 if (Array.isArray(cond[k])) {
+                    // a partial `$or` on a to-one join drops rows matching a sibling branch, but entity filters have no other sink, so they must pass
+                    if (k === '$or' && !filter && !this.canDistributeOrBranches(cond[k], joins)) {
+                        continue;
+                    }
                     cond[k].forEach((c) => this.mergeOnConditions(joins, c, filter, k));
                 }
                 /* v8 ignore next */
@@ -2071,6 +2075,33 @@ export class QueryBuilder {
             }
         }
     }
+    /**
+     * `$or` branches can be moved to a to-one join's `on` clause only when they all target that same
+     * join and stay flat — a partial `$or` in the `on` clause would drop rows matching a sibling
+     * branch. A `$or` targeting only to-many joins keeps the partial distribution, as that is how
+     * `PopulateHint.INFER` narrows collections.
+     */
+    canDistributeOrBranches(branches, joins) {
+        const aliases = new Set();
+        const collectAliases = (cond) => {
+            for (const k of Object.keys(cond)) {
+                if (Utils.isOperator(k)) {
+                    Utils.asArray(cond[k]).forEach((c) => collectAliases(c));
+                }
+                else {
+                    aliases.add(this.helper.splitField(k)[0]);
+                }
+            }
+        };
+        branches.forEach(collectAliases);
+        const targeted = joins.filter(j => aliases.has(j.alias));
+        // nested operators cannot be preserved inside a distributed disjunction, `mergeOnConditions` would flatten them into `and` conjuncts
+        const flat = branches.every(branch => Object.keys(branch).every(k => !Utils.isOperator(k)));
+        if (aliases.size === 1 && targeted.length === 1 && flat) {
+            return true;
+        }
+        return !targeted.some(j => [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(j.prop.kind));
+    }
     /**
      * When adding an inner join on a left joined relation, we need to nest them,
      * otherwise the inner join could discard rows of the root table.