@mikro-orm/sql 7.0.0-dev.191 → 7.0.0-dev.192

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.191",
+  "version": "7.0.0-dev.192",
   "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.",
   "type": "module",
   "exports": {
@@ -56,6 +56,6 @@
     "@mikro-orm/core": "^6.6.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.191"
+    "@mikro-orm/core": "7.0.0-dev.192"
   }
 }

package/query/QueryBuilder.d.ts

@@ -341,7 +341,28 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     private processNestedJoins;
     private hasToManyJoins;
     protected wrapPaginateSubQuery(meta: EntityMetadata): void;
-    private pruneExtraJoins;
+    /**
+     * Computes the set of populate paths from the _populate hints.
+     */
+    protected getPopulatePaths(): Set<string>;
+    protected normalizeJoinPath(join: JoinOptions, meta: EntityMetadata): string;
+    /**
+     * Transfers WHERE conditions to ORDER BY joins that are not used for population.
+     * This ensures the outer query's ORDER BY uses the same filtered rows as the subquery.
+     * GH #6160
+     */
+    protected transferConditionsForOrderByJoins(meta: EntityMetadata, cond: Dictionary | undefined, populatePaths: Set<string>): void;
+    /**
+     * Removes joins that are not used for population or ordering to improve performance.
+     */
+    protected pruneJoinsForPagination(meta: EntityMetadata, populatePaths: Set<string>): void;
+    /**
+     * Transfers WHERE conditions that reference a join alias to the join's ON clause.
+     * This is needed when a join is kept for ORDER BY after pagination wrapping,
+     * so the outer query orders by the same filtered rows as the subquery.
+     * @internal
+     */
+    protected transferConditionsToJoin(cond: Dictionary, join: JoinOptions, path?: string): void;
     private wrapModifySubQuery;
     private getSchema;
     private createAlias;

package/query/QueryBuilder.js

@@ -1410,28 +1410,67 @@ export class QueryBuilder {
         subSubQuery.select(pks).from(innerQuery);
         this._limit = undefined;
         this._offset = undefined;
+        // Save the original WHERE conditions before pruning joins
+        const originalCond = this._cond;
+        const populatePaths = this.getPopulatePaths();
         if (!this._fields.some(field => isRaw(field))) {
-            this.pruneExtraJoins(meta);
+            this.pruneJoinsForPagination(meta, populatePaths);
         }
+        // Transfer WHERE conditions to ORDER BY joins (GH #6160)
+        this.transferConditionsForOrderByJoins(meta, originalCond, populatePaths);
         const { sql, params } = subSubQuery.compile();
         this.select(this._fields).where({ [Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: raw(sql, params) } });
     }
-    pruneExtraJoins(meta) {
-        // remove joins that are not used for population or ordering to improve performance
-        const populate = new Set();
-        const orderByAliases = this._orderBy
-            .flatMap(hint => Object.keys(hint))
-            .map(k => k.split('.')[0]);
+    /**
+     * Computes the set of populate paths from the _populate hints.
+     */
+    getPopulatePaths() {
+        const paths = new Set();
         function addPath(hints, prefix = '') {
             for (const hint of hints) {
                 const field = hint.field.split(':')[0];
-                populate.add((prefix ? prefix + '.' : '') + field);
+                const fullPath = prefix ? prefix + '.' + field : field;
+                paths.add(fullPath);
                 if (hint.children) {
-                    addPath(hint.children, (prefix ? prefix + '.' : '') + field);
+                    addPath(hint.children, fullPath);
                 }
             }
         }
         addPath(this._populate);
+        return paths;
+    }
+    normalizeJoinPath(join, meta) {
+        return join.path?.replace(/\[populate]|\[pivot]|:ref/g, '').replace(new RegExp(`^${meta.className}.`), '') ?? '';
+    }
+    /**
+     * Transfers WHERE conditions to ORDER BY joins that are not used for population.
+     * This ensures the outer query's ORDER BY uses the same filtered rows as the subquery.
+     * GH #6160
+     */
+    transferConditionsForOrderByJoins(meta, cond, populatePaths) {
+        if (!cond || this._orderBy.length === 0) {
+            return;
+        }
+        const orderByAliases = new Set(this._orderBy
+            .flatMap(hint => Object.keys(hint))
+            .filter(k => !RawQueryFragment.isKnownFragmentSymbol(k))
+            .map(k => k.split('.')[0]));
+        for (const join of Object.values(this._joins)) {
+            const joinPath = this.normalizeJoinPath(join, meta);
+            const isPopulateJoin = populatePaths.has(joinPath);
+            // Only transfer conditions for joins used for ORDER BY but not for population
+            if (orderByAliases.has(join.alias) && !isPopulateJoin) {
+                this.transferConditionsToJoin(cond, join);
+            }
+        }
+    }
+    /**
+     * Removes joins that are not used for population or ordering to improve performance.
+     */
+    pruneJoinsForPagination(meta, populatePaths) {
+        const orderByAliases = this._orderBy
+            .flatMap(hint => Object.keys(hint))
+            .map(k => k.split('.')[0]);
         const joins = Object.entries(this._joins);
         const rootAlias = this.alias;
         function addParentAlias(alias) {
@@ -1445,12 +1484,38 @@ export class QueryBuilder {
             addParentAlias(orderByAlias);
         }
         for (const [key, join] of joins) {
-            const path = join.path?.replace(/\[populate]|\[pivot]|:ref/g, '').replace(new RegExp(`^${meta.className}.`), '');
-            if (!populate.has(path ?? '') && !orderByAliases.includes(join.alias)) {
+            const path = this.normalizeJoinPath(join, meta);
+            if (!populatePaths.has(path) && !orderByAliases.includes(join.alias)) {
                 delete this._joins[key];
             }
         }
     }
+    /**
+     * Transfers WHERE conditions that reference a join alias to the join's ON clause.
+     * This is needed when a join is kept for ORDER BY after pagination wrapping,
+     * so the outer query orders by the same filtered rows as the subquery.
+     * @internal
+     */
+    transferConditionsToJoin(cond, join, path = '') {
+        const aliasPrefix = join.alias + '.';
+        for (const key of Object.keys(cond)) {
+            const value = cond[key];
+            // Handle $and/$or operators - recurse into nested conditions
+            if (key === '$and' || key === '$or') {
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        this.transferConditionsToJoin(item, join, path);
+                    }
+                }
+                continue;
+            }
+            // Check if this condition references the join alias
+            if (key.startsWith(aliasPrefix)) {
+                // Add condition to the join's ON clause
+                join.cond[key] = value;
+            }
+        }
+    }
     wrapModifySubQuery(meta) {
         const subQuery = this.clone();
         subQuery.finalized = true;