@mikro-orm/knex 6.4.2-dev.6 → 6.4.2-dev.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.4.2-dev.6",
+  "version": "6.4.2-dev.8",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -66,7 +66,7 @@
     "@mikro-orm/core": "^6.4.1"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.4.2-dev.6",
+    "@mikro-orm/core": "6.4.2-dev.8",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/query/QueryBuilder.d.ts

@@ -80,6 +80,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     protected aliasCounter: number;
     protected flags: Set<QueryFlag>;
     protected finalized: boolean;
+    protected populateHintFinalized: boolean;
     protected _joins: Dictionary<JoinOptions>;
     protected _explicitAlias: boolean;
     protected _schema?: string;
@@ -285,6 +286,8 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     private getQueryBase;
     private applyDiscriminatorCondition;
     private finalize;
+    /** @internal */
+    processPopulateHint(): void;
     private processPopulateWhere;
     private mergeOnConditions;
     private hasToManyJoins;

package/query/QueryBuilder.js

@@ -62,6 +62,7 @@ class QueryBuilder {
     aliasCounter = 0;
     flags = new Set([core_1.QueryFlag.CONVERT_CUSTOM_TYPES]);
     finalized = false;
+    populateHintFinalized = false;
     _joins = {};
     _explicitAlias = false;
     _schema;
@@ -150,7 +151,7 @@ class QueryBuilder {
         if (field) {
             this._fields = core_1.Utils.asArray(field);
         }
-        else if (this.hasToManyJoins()) {
+        else if (distinct || this.hasToManyJoins()) {
             this._fields = this.mainAlias.metadata.primaryKeys;
         }
         else {
@@ -742,6 +743,7 @@ class QueryBuilder {
         }
         else {
             const qb = this.type === undefined ? this : this.clone();
+            qb.processPopulateHint(); // needs to happen sooner so `qb.hasToManyJoins()` reports correctly
             qb.count(field, distinct ?? qb.hasToManyJoins()).limit(undefined).offset(undefined).orderBy([]);
             res = await qb.execute('get', false);
         }
@@ -1121,30 +1123,7 @@ class QueryBuilder {
         }
         const meta = this.mainAlias.metadata;
         this.applyDiscriminatorCondition();
-        if (meta && this.flags.has(core_1.QueryFlag.AUTO_JOIN_ONE_TO_ONE_OWNER)) {
-            const relationsToPopulate = this._populate.map(({ field }) => field);
-            meta.relations
-                .filter(prop => prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner && !relationsToPopulate.includes(prop.name) && !relationsToPopulate.includes(`${prop.name}:ref`))
-                .map(prop => ({ field: `${prop.name}:ref` }))
-                .forEach(item => this._populate.push(item));
-        }
-        this._populate.forEach(({ field }) => {
-            const [fromAlias, fromField] = this.helper.splitField(field);
-            const aliasedField = `${fromAlias}.${fromField}`;
-            const join = Object.keys(this._joins).find(k => `${aliasedField}#${this._joins[k].alias}` === k);
-            if (join && this._joins[join] && this.helper.isOneToOneInverse(fromField)) {
-                this._populateMap[join] = this._joins[join].alias;
-                return;
-            }
-            if (meta && this.helper.isOneToOneInverse(fromField)) {
-                const prop = meta.properties[fromField];
-                const alias = this.getNextAlias(prop.pivotEntity ?? prop.type);
-                const aliasedName = `${fromAlias}.${prop.name}#${alias}`;
-                this._joins[aliasedName] = this.helper.joinOneToReference(prop, this.mainAlias.aliasName, alias, enums_1.JoinType.leftJoin);
-                this._joins[aliasedName].path = `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? meta.className)}.${prop.name}`;
-                this._populateMap[aliasedName] = this._joins[aliasedName].alias;
-            }
-        });
+        this.processPopulateHint();
         if (meta && (this._fields?.includes('*') || this._fields?.includes(`${this.mainAlias.aliasName}.*`))) {
             meta.props
                 .filter(prop => prop.formula && (!prop.lazy || this.flags.has(core_1.QueryFlag.INCLUDE_LAZY_FORMULAS)))
@@ -1161,8 +1140,6 @@ class QueryBuilder {
             }))
                 .forEach(field => this._fields.push((0, core_1.raw)(field)));
         }
-        this.processPopulateWhere(false);
-        this.processPopulateWhere(true);
         core_1.QueryHelper.processObjectParams(this._data);
         core_1.QueryHelper.processObjectParams(this._cond);
         core_1.QueryHelper.processObjectParams(this._having);
@@ -1178,6 +1155,40 @@ class QueryBuilder {
         }
         this.finalized = true;
     }
+    /** @internal */
+    processPopulateHint() {
+        if (this.populateHintFinalized) {
+            return;
+        }
+        const meta = this.mainAlias.metadata;
+        if (meta && this.flags.has(core_1.QueryFlag.AUTO_JOIN_ONE_TO_ONE_OWNER)) {
+            const relationsToPopulate = this._populate.map(({ field }) => field);
+            meta.relations
+                .filter(prop => prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner && !relationsToPopulate.includes(prop.name) && !relationsToPopulate.includes(`${prop.name}:ref`))
+                .map(prop => ({ field: `${prop.name}:ref` }))
+                .forEach(item => this._populate.push(item));
+        }
+        this._populate.forEach(({ field }) => {
+            const [fromAlias, fromField] = this.helper.splitField(field);
+            const aliasedField = `${fromAlias}.${fromField}`;
+            const join = Object.keys(this._joins).find(k => `${aliasedField}#${this._joins[k].alias}` === k);
+            if (join && this._joins[join] && this.helper.isOneToOneInverse(fromField)) {
+                this._populateMap[join] = this._joins[join].alias;
+                return;
+            }
+            if (meta && this.helper.isOneToOneInverse(fromField)) {
+                const prop = meta.properties[fromField];
+                const alias = this.getNextAlias(prop.pivotEntity ?? prop.type);
+                const aliasedName = `${fromAlias}.${prop.name}#${alias}`;
+                this._joins[aliasedName] = this.helper.joinOneToReference(prop, this.mainAlias.aliasName, alias, enums_1.JoinType.leftJoin);
+                this._joins[aliasedName].path = `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? meta.className)}.${prop.name}`;
+                this._populateMap[aliasedName] = this._joins[aliasedName].alias;
+            }
+        });
+        this.processPopulateWhere(false);
+        this.processPopulateWhere(true);
+        this.populateHintFinalized = true;
+    }
     processPopulateWhere(filter) {
         const key = filter ? '_populateFilter' : '_populateWhere';
         if (this[key] == null || this[key] === core_1.PopulateHint.ALL) {
@@ -1233,7 +1244,9 @@ class QueryBuilder {
         }
     }
     hasToManyJoins() {
+        // console.log(this._joins);
         return Object.values(this._joins).some(join => {
+            // console.log(join.prop.name, join.prop.kind, [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(join.prop.kind));
             return [core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(join.prop.kind);
         });
     }