@mikro-orm/knex 6.1.10-dev.1 → 6.1.10-dev.2

package/AbstractSqlDriver.js

@@ -187,6 +187,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 path += '[pivot]';
             }
             const relationAlias = qb.getAliasForJoinPath(path, { matchPopulateJoins: true });
+            /* istanbul ignore next */
+            if (!relationAlias) {
+                return;
+            }
             // pivot ref joins via joined strategy need to be handled separately here, as they dont join the target entity
             if (pivotRefJoin) {
                 let item;
@@ -212,10 +216,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             }));
             if (!hasPK) {
                 if ([core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
-                    result[prop.name] ??= [];
+                    result[prop.name] = [];
                 }
                 if ([core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-                    result[prop.name] ??= null;
+                    result[prop.name] = null;
                 }
                 return;
             }
@@ -709,12 +713,12 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 const alias = qb.getNextAlias(prop.targetMeta.tableName);
                 qb.leftJoin(`${targetAlias}.${hint.field}`, alias);
                 // eslint-disable-next-line dot-notation
-                Object.values(qb['_joins']).forEach(join => {
+                for (const join of Object.values(qb['_joins'])) {
                     const [propName] = hint.field.split(':', 2);
                     if (join.alias === alias && join.prop.name === propName) {
                         fields.push(...qb.helper.mapJoinColumns(qb.type, join));
                     }
-                });
+                }
             });
         }
         qb.select(fields)
@@ -724,19 +728,30 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (owners.length === 1 && (options.offset != null || options.limit != null)) {
             qb.limit(options.limit, options.offset);
         }
+        // console.log('pivot qb', qb, qb._fields);
         const res = owners.length ? await this.rethrow(qb.execute('all', { mergeResults: false, mapResults: false })) : [];
-        const items = res.map((row) => super.mapResult(row, prop.targetMeta));
+        // console.log(res);
+        // const items = res.map((row: Dictionary) => super.mapResult(row, prop.targetMeta));
+        const tmp = {};
+        // const items = res.map((row: Dictionary) => this.mapResult(row, prop.targetMeta!, populate, qb, tmp));
+        // const items = res.map((row: Dictionary) => this.mapResult(row, pivotMeta, populate, qb, tmp));
+        const items = res.map((row) => {
+            const root = super.mapResult(row, prop.targetMeta);
+            this.mapJoinedProps(root, prop.targetMeta, populate, qb, root, tmp, pivotMeta.className + '.' + pivotProp1.name);
+            return root;
+        });
+        // console.log(prop.name, prop.targetMeta!.className, items);
         qb.clearRawFragmentsCache();
         const map = {};
         const pkProps = ownerMeta.getPrimaryProps();
-        owners.forEach(owner => {
+        for (const owner of owners) {
             const key = core_1.Utils.getPrimaryKeyHash(prop.joinColumns.map((_col, idx) => {
                 const pkProp = pkProps[idx];
                 return pkProp.customType ? pkProp.customType.convertToJSValue(owner[idx], this.platform) : owner[idx];
             }));
-            return map[key] = [];
-        });
-        items.forEach((item) => {
+            map[key] = [];
+        }
+        for (const item of items) {
             const key = core_1.Utils.getPrimaryKeyHash(prop.joinColumns.map((col, idx) => {
                 const pkProp = pkProps[idx];
                 return pkProp.customType ? pkProp.customType.convertToJSValue(item[`fk__${col}`], this.platform) : item[`fk__${col}`];
@@ -746,7 +761,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             prop.inverseJoinColumns.forEach((col, idx) => {
                 core_1.Utils.renameKey(item, `fk__${col}`, prop.targetMeta.primaryKeys[idx]);
             });
-        });
+        }
         return map;
     }
     getPivotOrderBy(prop, pivotProp, pivotAlias, orderBy) {
@@ -784,13 +799,14 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
      */
     joinedProps(meta, populate, options) {
         return populate.filter(hint => {
-            const [propName] = hint.field.split(':', 2);
+            const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName] || {};
             if (hint.filter && hint.strategy === core_1.LoadStrategy.JOINED) {
                 return true;
             }
             if ((options?.strategy || hint.strategy || prop.strategy || this.config.get('loadStrategy')) !== core_1.LoadStrategy.JOINED) {
-                return false;
+                // force joined strategy for explicit 1:1 owner populate hint as it would require a join anyway
+                return prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner;
             }
             return ![core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.EMBEDDED].includes(prop.kind);
         });
@@ -861,6 +877,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             const prop = meta.properties[propName];
             // ignore ref joins of known FKs unless it's a filter hint
             if (ref && !hint.filter && (prop.kind === core_1.ReferenceKind.MANY_TO_ONE || (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner))) {
+                // // console.log('wat', hint);
                 return;
             }
             const meta2 = this.metadata.find(prop.type);
@@ -894,9 +911,11 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 fields.push(...this.getFieldsForJoinedLoad(qb, meta2, childExplicitFields.length === 0 ? undefined : childExplicitFields, childExclude, hint.children, options, tableAlias, path));
             }
             else if (hint.filter) {
-                fields.push(field);
+                // fields.push(field);
+                fields.push(...prop.referencedColumnNames.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
             }
         });
+        // // console.log(fields, joinedProps);
         return fields;
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.1.10-dev.1",
+  "version": "6.1.10-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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -66,6 +66,6 @@
     "@mikro-orm/core": "^6.1.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.1.10-dev.1"
+    "@mikro-orm/core": "6.1.10-dev.2"
   }
 }

package/query/QueryBuilder.js

@@ -1072,6 +1072,7 @@ class QueryBuilder {
                 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;
             }
         });
@@ -1131,6 +1132,10 @@ class QueryBuilder {
                     if (join.cond[k]) {
                         join.cond = { [op ?? '$and']: [join.cond, { [k]: cond[k] }] };
                     }
+                    else if (op === '$or') {
+                        join.cond.$or ??= [];
+                        join.cond.$or.push({ [k]: cond[k] });
+                    }
                     else {
                         join.cond = { ...join.cond, [k]: cond[k] };
                     }

package/query/QueryBuilderHelper.js

@@ -193,8 +193,10 @@ class QueryBuilderHelper {
                         conditions.push(`${left} = ${this.knex.ref(right)}`);
                         return;
                     }
-                    const left = `${join.ownerAlias}.${primaryKey}`;
-                    conditions.push(`${this.knex.ref(left)} = ${this.knex.ref(right)}`);
+                    const left = join.prop.object && join.prop.fieldNameRaw
+                        ? join.prop.fieldNameRaw.replaceAll(core_1.ALIAS_REPLACEMENT, join.ownerAlias)
+                        : this.knex.ref(`${join.ownerAlias}.${primaryKey}`);
+                    conditions.push(`${left} = ${this.knex.ref(right)}`);
                 });
             }
             if (join.prop.targetMeta?.discriminatorValue && !join.path?.endsWith('[pivot]')) {
@@ -295,7 +297,7 @@ class QueryBuilderHelper {
         if (join.prop && [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(join.prop.kind)) {
             return join.prop.fieldNames.map((fieldName, idx) => {
                 const columns = join.prop.owner ? join.joinColumns : join.inverseJoinColumns;
-                return this.mapper(`${join.alias}.${columns[idx]}`, type, undefined, fieldName);
+                return this.mapper(`${join.alias}.${columns[idx]}`, type, undefined, `${join.alias}__${columns[idx]}`);
             });
         }
         return [