@mikro-orm/sql 7.0.4-dev.0 → 7.0.4-dev.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.4-dev.0",
+  "version": "7.0.4-dev.2",
   "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",
@@ -42,7 +42,7 @@
   },
   "scripts": {
     "build": "yarn compile && yarn copy",
-    "clean": "yarn run -T rimraf ./dist",
+    "clean": "yarn run -T rimraf ./dist ./tsconfig.build.tsbuildinfo",
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
   },
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.0.3"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.4-dev.0"
+    "@mikro-orm/core": "7.0.4-dev.2"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/QueryBuilder.d.ts

@@ -923,7 +923,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     /**
      * Removes joins that are not used for population or ordering to improve performance.
      */
-    protected pruneJoinsForPagination(meta: EntityMetadata, populatePaths: Set<string>): void;
+    protected pruneJoinsForPagination(): 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,

package/query/QueryBuilder.js

@@ -1988,7 +1988,7 @@ export class QueryBuilder {
         const originalCond = this.#state.cond;
         const populatePaths = this.getPopulatePaths();
         if (!this.#state.fields.some(field => isRaw(field))) {
-            this.pruneJoinsForPagination(meta, populatePaths);
+            this.pruneJoinsForPagination();
         }
         // Transfer WHERE conditions to ORDER BY joins (GH #6160)
         this.transferConditionsForOrderByJoins(meta, originalCond, populatePaths);
@@ -2043,23 +2043,51 @@ export class QueryBuilder {
     /**
      * Removes joins that are not used for population or ordering to improve performance.
      */
-    pruneJoinsForPagination(meta, populatePaths) {
-        const orderByAliases = this.#state.orderBy.flatMap(hint => Object.keys(hint)).map(k => k.split('.')[0]);
+    pruneJoinsForPagination() {
         const joins = Object.entries(this.#state.joins);
         const rootAlias = this.alias;
-        function addParentAlias(alias) {
+        const keptAliases = new Set();
+        // Collect aliases needed for ORDER BY
+        for (const hint of this.#state.orderBy) {
+            for (const k of Object.keys(hint)) {
+                if (!RawQueryFragment.isKnownFragmentSymbol(k)) {
+                    keptAliases.add(k.split('.')[0]);
+                }
+            }
+        }
+        // Collect aliases needed for population (joined strategy):
+        // 1. Joins tracked in populateMap (OneToOne inverse from processPopulateHint)
+        // 2. Joins tracked in joinedProps (manual joinAndSelect calls)
+        // 3. Joins whose alias is referenced in SELECT fields (JOINED strategy populate fields)
+        for (const [key, join] of joins) {
+            if (key in this.#state.populateMap || this.#state.joinedProps.has(join.alias)) {
+                keptAliases.add(join.alias);
+            }
+        }
+        // Check SELECT fields for alias references - keeps joins needed for data loading
+        if (this.#state.fields) {
+            for (const field of this.#state.fields) {
+                const fieldStr = typeof field === 'string' ? field : isRaw(field) ? field.sql : '';
+                for (const [, join] of joins) {
+                    if (fieldStr.includes(`${join.alias}.`) || fieldStr.includes(`${join.alias}__`)) {
+                        keptAliases.add(join.alias);
+                    }
+                }
+            }
+        }
+        // Also keep parent joins of all kept aliases (e.g. pivot tables for M:N)
+        function addParentAliases(alias) {
             const join = joins.find(j => j[1].alias === alias);
-            if (join && join[1].ownerAlias !== rootAlias) {
-                orderByAliases.push(join[1].ownerAlias);
-                addParentAlias(join[1].ownerAlias);
+            if (join && join[1].ownerAlias !== rootAlias && !keptAliases.has(join[1].ownerAlias)) {
+                keptAliases.add(join[1].ownerAlias);
+                addParentAliases(join[1].ownerAlias);
             }
         }
-        for (const orderByAlias of orderByAliases) {
-            addParentAlias(orderByAlias);
+        for (const alias of [...keptAliases]) {
+            addParentAliases(alias);
         }
         for (const [key, join] of joins) {
-            const path = this.normalizeJoinPath(join, meta);
-            if (!populatePaths.has(path) && !orderByAliases.includes(join.alias)) {
+            if (!keptAliases.has(join.alias)) {
                 delete this.#state.joins[key];
             }
         }