@mikro-orm/knex 6.4.17-dev.74 → 6.4.17-dev.76

package/AbstractSqlDriver.js

@@ -837,7 +837,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const toPopulate = meta.relations
             .filter(prop => prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner && !prop.lazy && !relationsToPopulate.includes(prop.name))
             .filter(prop => fields.length === 0 || fields.some(f => prop.name === f || prop.name.startsWith(`${String(f)}.`)))
-            .map(prop => ({ field: `${prop.name}:ref`, strategy: prop.strategy ?? core_1.LoadStrategy.JOINED }));
+            .map(prop => ({ field: `${prop.name}:ref`, strategy: core_1.LoadStrategy.JOINED }));
         return [...populate, ...toPopulate];
     }
     /**
@@ -847,8 +847,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         return populate.filter(hint => {
             const [propName] = hint.field.split(':', 2);
             const prop = meta.properties[propName] || {};
-            const strategy = (0, core_1.getLoadingStrategy)(hint.strategy || options?.strategy || prop.strategy || this.config.get('loadStrategy'), prop.kind);
-            if (hint.filter && (0, core_1.getLoadingStrategy)(hint.strategy, prop.kind) === core_1.LoadStrategy.JOINED) {
+            const strategy = (0, core_1.getLoadingStrategy)(hint.strategy || prop.strategy || options?.strategy || this.config.get('loadStrategy'), prop.kind);
+            if (hint.filter && [core_1.ReferenceKind.ONE_TO_ONE, core_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind) && !prop.nullable) {
                 return true;
             }
             // skip redundant joins for 1:1 owner population hints when using `mapToPk`
@@ -938,11 +938,12 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             if (!parentJoinPath && populateWhereAll && !hint.filter && !path.startsWith('[populate]')) {
                 path = '[populate]' + path;
             }
+            const mandatoryToOneProperty = [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.nullable;
             const joinType = pivotRefJoin
                 ? query_1.JoinType.pivotJoin
                 : hint.joinType
                     ? hint.joinType
-                    : hint.filter && !prop.nullable
+                    : (hint.filter && !prop.nullable) || mandatoryToOneProperty
                         ? query_1.JoinType.innerJoin
                         : query_1.JoinType.leftJoin;
             qb.join(field, tableAlias, {}, joinType, path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.4.17-dev.74",
+  "version": "6.4.17-dev.76",
   "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.16"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.4.17-dev.74",
+    "@mikro-orm/core": "6.4.17-dev.76",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/query/ObjectCriteriaNode.js

@@ -210,7 +210,23 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
         }
         else {
             const prev = qb._fields?.slice();
-            qb[method](field, nestedAlias, undefined, enums_1.JoinType.leftJoin, path);
+            const toOneProperty = [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(this.prop.kind);
+            const joinType = toOneProperty && !this.prop.nullable
+                ? enums_1.JoinType.innerJoin
+                : enums_1.JoinType.leftJoin;
+            qb[method](field, nestedAlias, undefined, joinType, path);
+            // if the property is nullable, we need to use left join, so we mimic the inner join behaviour
+            // with an exclusive condition on the join columns:
+            // - if the owning column is null, the row is missing, we don't apply the filter
+            // - if the target column is not null, the row is matched, we apply the filter
+            if (toOneProperty && this.prop.nullable && options?.filter) {
+                qb.andWhere({
+                    $or: [
+                        { [field]: null },
+                        { [nestedAlias + '.' + core_1.Utils.getPrimaryKeyHash(this.prop.referencedPKs)]: { $ne: null } },
+                    ],
+                });
+            }
             if (!qb.hasFlag(core_1.QueryFlag.INFER_POPULATE)) {
                 qb._fields = prev;
             }

package/query/QueryBuilder.d.ts

@@ -299,6 +299,11 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     processPopulateHint(): void;
     private processPopulateWhere;
     private mergeOnConditions;
+    /**
+     * When adding an inner join on a left joined relation, we need to nest them,
+     * otherwise the inner join could discard rows of the root table.
+     */
+    private processNestedJoins;
     private hasToManyJoins;
     protected wrapPaginateSubQuery(meta: EntityMetadata): void;
     private wrapModifySubQuery;

package/query/QueryBuilder.js

@@ -1161,6 +1161,7 @@ class QueryBuilder {
         const meta = this.mainAlias.metadata;
         this.applyDiscriminatorCondition();
         this.processPopulateHint();
+        this.processNestedJoins();
         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)))
@@ -1240,7 +1241,7 @@ class QueryBuilder {
         if (typeof this[key] === 'object') {
             const cond = CriteriaNodeFactory_1.CriteriaNodeFactory
                 .createNode(this.metadata, this.mainAlias.entityName, this[key])
-                .process(this, { matchPopulateJoins: true, ignoreBranching: true, preferNoBranch: true });
+                .process(this, { matchPopulateJoins: true, ignoreBranching: true, preferNoBranch: true, filter });
             // there might be new joins created by processing the `populateWhere` object
             joins = Object.values(this._joins);
             this.mergeOnConditions(joins, cond, filter);
@@ -1281,6 +1282,29 @@ class QueryBuilder {
             }
         }
     }
+    /**
+     * When adding an inner join on a left joined relation, we need to nest them,
+     * otherwise the inner join could discard rows of the root table.
+     */
+    processNestedJoins() {
+        if (this.flags.has(core_1.QueryFlag.DISABLE_NESTED_INNER_JOIN)) {
+            return;
+        }
+        const joins = Object.values(this._joins);
+        for (const join of joins) {
+            if (join.type === enums_1.JoinType.innerJoin) {
+                const parentJoin = joins.find(j => j.alias === join.ownerAlias);
+                // https://stackoverflow.com/a/56815807/3665878
+                if (parentJoin?.type === enums_1.JoinType.leftJoin || parentJoin?.type === enums_1.JoinType.nestedLeftJoin) {
+                    const nested = (parentJoin.nested ??= new Set());
+                    join.type = join.type === enums_1.JoinType.innerJoin
+                        ? enums_1.JoinType.nestedInnerJoin
+                        : enums_1.JoinType.nestedLeftJoin;
+                    nested.add(join);
+                }
+            }
+        }
+    }
     hasToManyJoins() {
         return Object.values(this._joins).some(join => {
             return [core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(join.prop.kind);

package/typings.d.ts

@@ -172,6 +172,7 @@ export interface ICriteriaNodeProcessOptions {
     ignoreBranching?: boolean;
     preferNoBranch?: boolean;
     type?: 'orderBy';
+    filter?: boolean;
 }
 export interface ICriteriaNode<T extends object> {
     readonly entityName: string;