@mikro-orm/knex 6.0.0-dev.305 → 6.0.0-dev.307

package/AbstractSqlDriver.d.ts

@@ -35,7 +35,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     /**
      * 1:1 owner side needs to be marked for population so QB auto-joins the owner id
      */
-    protected autoJoinOneToOneOwner<T extends object, P extends string = never>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, any>[]): PopulateOptions<T>[];
+    protected autoJoinOneToOneOwner<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, any>[]): PopulateOptions<T>[];
     /**
      * @internal
      */

package/AbstractSqlDriver.js

@@ -766,7 +766,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (!this.config.get('autoJoinOneToOneOwner')) {
             return populate;
         }
-        const relationsToPopulate = populate.map(({ field }) => field);
+        const relationsToPopulate = populate.map(({ field }) => field.split(':')[0]);
         const toPopulate = meta.relations
             .filter(prop => prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner && !relationsToPopulate.includes(prop.name))
             .filter(prop => fields.length === 0 || fields.some(f => prop.name === f || prop.name.startsWith(`${String(f)}.`)))
@@ -778,14 +778,14 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
      */
     joinedProps(meta, populate, options) {
         return populate.filter(hint => {
-            const [propName, ref] = hint.field.split(':', 2);
+            const [propName] = 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;
             }
-            if (ref) {
-                return [core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(prop.kind);
-            }
             return ![core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.EMBEDDED].includes(prop.kind);
         });
     }
@@ -853,15 +853,23 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         joinedProps.forEach(hint => {
             const [propName, ref] = hint.field.split(':', 2);
             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))) {
+                return;
+            }
             const meta2 = this.metadata.find(prop.type);
             const pivotRefJoin = prop.kind === core_1.ReferenceKind.MANY_TO_MANY && ref;
             const tableAlias = qb.getNextAlias(prop.name);
             const field = parentTableAlias ? `${parentTableAlias}.${prop.name}` : prop.name;
             let path = parentJoinPath ? `${parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
-            if (!parentJoinPath && populateWhereAll && !path.startsWith('[populate]')) {
+            if (!parentJoinPath && populateWhereAll && !hint.filter && !path.startsWith('[populate]')) {
                 path = '[populate]' + path;
             }
-            const joinType = pivotRefJoin ? query_1.JoinType.pivotJoin : query_1.JoinType.leftJoin;
+            const joinType = pivotRefJoin
+                ? query_1.JoinType.pivotJoin
+                : hint.filter && !prop.nullable
+                    ? query_1.JoinType.innerJoin
+                    : query_1.JoinType.leftJoin;
             qb.join(field, tableAlias, {}, joinType, path);
             if (pivotRefJoin) {
                 fields.push(...prop.joinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)), ...prop.inverseJoinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
@@ -879,6 +887,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             if (!ref) {
                 fields.push(...this.getFieldsForJoinedLoad(qb, meta2, childExplicitFields.length === 0 ? undefined : childExplicitFields, childExclude, hint.children, options, tableAlias, path));
             }
+            else if (hint.filter) {
+                fields.push(field);
+            }
         });
         return fields;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.305",
+  "version": "6.0.0-dev.307",
   "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": "^5.0.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.0.0-dev.305"
+    "@mikro-orm/core": "6.0.0-dev.307"
   }
 }

package/query/QueryBuilder.d.ts

@@ -2,7 +2,7 @@
 import { inspect } from 'util';
 import type { Knex } from 'knex';
 import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityName, type EntityProperty, type FlushMode, type GroupOperator, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryResult, type RequiredEntityData } from '@mikro-orm/core';
-import { QueryType, JoinType } from './enums';
+import { JoinType, QueryType } from './enums';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
 import { type Alias, QueryBuilderHelper } from './QueryBuilderHelper';
 import type { SqlEntityManager } from '../SqlEntityManager';

package/query/QueryBuilder.js

@@ -264,19 +264,20 @@ class QueryBuilder {
         const op = operator || params;
         const topLevel = !op || !core_1.Utils.hasObjectKeys(this._cond);
         const criteriaNode = CriteriaNodeFactory_1.CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond);
+        const ignoreBranching = this.__populateWhere === 'infer';
         if ([enums_1.QueryType.UPDATE, enums_1.QueryType.DELETE].includes(this.type) && criteriaNode.willAutoJoin(this)) {
             // use sub-query to support joining
             this.setFlag(this.type === enums_1.QueryType.UPDATE ? core_1.QueryFlag.UPDATE_SUB_QUERY : core_1.QueryFlag.DELETE_SUB_QUERY);
             this.select(this.mainAlias.metadata.primaryKeys, true);
         }
         if (topLevel) {
-            this._cond = criteriaNode.process(this);
+            this._cond = criteriaNode.process(this, { ignoreBranching });
         }
         else if (Array.isArray(this._cond[op])) {
-            this._cond[op].push(criteriaNode.process(this));
+            this._cond[op].push(criteriaNode.process(this, { ignoreBranching }));
         }
         else {
-            const cond1 = [this._cond, criteriaNode.process(this)];
+            const cond1 = [this._cond, criteriaNode.process(this, { ignoreBranching })];
             this._cond = { [op]: cond1 };
         }
         if (this._onConflict) {
@@ -1060,18 +1061,24 @@ class QueryBuilder {
             join.cond_ = join.cond;
             join.cond = {};
         });
-        const replaceOnConditions = (cond) => {
+        const replaceOnConditions = (cond, op) => {
             Object.keys(cond).forEach(k => {
                 if (core_1.Utils.isOperator(k)) {
                     if (Array.isArray(cond[k])) {
-                        return cond[k].forEach((c) => replaceOnConditions(c));
+                        return cond[k].forEach((c) => replaceOnConditions(c, k));
                     }
-                    return replaceOnConditions(cond[k]);
+                    /* istanbul ignore next */
+                    return replaceOnConditions(cond[k], k);
                 }
                 const [alias] = this.helper.splitField(k);
                 const join = joins.find(j => j.alias === alias);
                 if (join) {
-                    join.cond = { ...join.cond, [k]: cond[k] };
+                    if (join.cond[k]) {
+                        join.cond = { [op ?? '$and']: [join.cond, { [k]: cond[k] }] };
+                    }
+                    else {
+                        join.cond = { ...join.cond, [k]: cond[k] };
+                    }
                 }
             });
         };

package/query/QueryBuilderHelper.js

@@ -288,9 +288,10 @@ class QueryBuilderHelper {
         return `(${parts.join(` ${core_1.GroupOperator[operator]} `)})`;
     }
     mapJoinColumns(type, join) {
-        if (join.prop && join.prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !join.prop.owner) {
+        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) => {
-                return this.mapper(`${join.alias}.${join.inverseJoinColumns[idx]}`, type, undefined, fieldName);
+                const columns = join.prop.owner ? join.joinColumns : join.inverseJoinColumns;
+                return this.mapper(`${join.alias}.${columns[idx]}`, type, undefined, fieldName);
             });
         }
         return [