@mikro-orm/knex 6.3.3-dev.2 → 6.3.3-dev.4

package/package.json

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

package/query/QueryBuilder.d.ts

@@ -1,6 +1,6 @@
 import { inspect } from 'node:util';
 import type { Knex } from 'knex';
-import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityName, type EntityProperty, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryOrderMap, type QueryResult, RawQueryFragment, type RequiredEntityData, type ExpandProperty } from '@mikro-orm/core';
+import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityName, type EntityProperty, type ExpandProperty, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryOrderMap, type QueryResult, RawQueryFragment, type RequiredEntityData } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
 import { type Alias, QueryBuilderHelper } from './QueryBuilderHelper';

package/query/QueryBuilder.js

@@ -1155,7 +1155,7 @@ class QueryBuilder {
         if (this._populateWhere == null || this._populateWhere === core_1.PopulateHint.ALL) {
             return;
         }
-        const joins = Object.values(this._joins);
+        let joins = Object.values(this._joins);
         joins.forEach(join => {
             join.cond_ = join.cond;
             join.cond = {};
@@ -1172,6 +1172,15 @@ class QueryBuilder {
                 const [alias] = this.helper.splitField(k);
                 const join = joins.find(j => j.alias === alias);
                 if (join) {
+                    const parentJoin = joins.find(j => j.alias === join.ownerAlias);
+                    // https://stackoverflow.com/a/56815807/3665878
+                    if (parentJoin) {
+                        const nested = (parentJoin.nested ??= new Set());
+                        join.type = join.type === enums_1.JoinType.innerJoin || [core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(parentJoin.prop.kind)
+                            ? enums_1.JoinType.nestedInnerJoin
+                            : enums_1.JoinType.nestedLeftJoin;
+                        nested.add(join);
+                    }
                     if (join.cond[k]) {
                         join.cond = { [op ?? '$and']: [join.cond, { [k]: cond[k] }] };
                     }
@@ -1189,6 +1198,7 @@ class QueryBuilder {
             const cond = CriteriaNodeFactory_1.CriteriaNodeFactory
                 .createNode(this.metadata, this.mainAlias.entityName, this._populateWhere)
                 .process(this, { matchPopulateJoins: true, ignoreBranching: true, preferNoBranch: true });
+            joins = Object.values(this._joins); // there might be new joins created by processing the `populateWhere` object
             replaceOnConditions(cond);
         }
     }

package/query/QueryBuilderHelper.d.ts

@@ -23,6 +23,10 @@ export declare class QueryBuilderHelper {
     joinManyToOneReference(prop: EntityProperty, ownerAlias: string, alias: string, type: JoinType, cond?: Dictionary, schema?: string): JoinOptions;
     joinManyToManyReference(prop: EntityProperty, ownerAlias: string, alias: string, pivotAlias: string, type: JoinType, cond: Dictionary, path: string, schema?: string): Dictionary<JoinOptions>;
     processJoins(qb: Knex.QueryBuilder, joins: Dictionary<JoinOptions>, schema?: string): void;
+    createJoinExpression(join: JoinOptions, joins: Dictionary<JoinOptions>, schema?: string): {
+        sql: string;
+        params: Knex.Value[];
+    };
     private processJoinClause;
     private wrapQueryGroup;
     mapJoinColumns(type: QueryType, join: JoinOptions): (string | Knex.Raw)[];

package/query/QueryBuilderHelper.js

@@ -183,56 +183,75 @@ class QueryBuilderHelper {
     }
     processJoins(qb, joins, schema) {
         Object.values(joins).forEach(join => {
-            let table = join.table;
-            const method = join.type === enums_1.JoinType.pivotJoin ? 'left join' : join.type;
-            const conditions = [];
-            const params = [];
-            schema = join.schema && join.schema !== '*' ? join.schema : schema;
-            if (schema) {
-                table = `${schema}.${table}`;
+            if ([enums_1.JoinType.nestedInnerJoin, enums_1.JoinType.nestedLeftJoin].includes(join.type)) {
+                return;
             }
-            if (join.prop.name !== '__subquery__') {
-                join.primaryKeys.forEach((primaryKey, idx) => {
-                    const right = `${join.alias}.${join.joinColumns[idx]}`;
-                    if (join.prop.formula) {
-                        const alias = this.platform.quoteIdentifier(join.ownerAlias);
-                        const left = join.prop.formula(alias);
-                        conditions.push(`${left} = ${this.knex.ref(right)}`);
-                        return;
-                    }
-                    const left = join.prop.object && join.prop.fieldNameRaw
-                        ? join.prop.fieldNameRaw.replaceAll(core_1.ALIAS_REPLACEMENT, join.ownerAlias)
-                        : this.knex.ref(`${join.ownerAlias}.${primaryKey}`);
+            const { sql, params } = this.createJoinExpression(join, joins, schema);
+            qb.joinRaw(sql, params);
+        });
+    }
+    createJoinExpression(join, joins, schema) {
+        let table = join.table;
+        const method = {
+            [enums_1.JoinType.nestedInnerJoin]: 'inner join',
+            [enums_1.JoinType.nestedLeftJoin]: 'left join',
+            [enums_1.JoinType.pivotJoin]: 'left join',
+        }[join.type] ?? join.type;
+        const conditions = [];
+        const params = [];
+        schema = join.schema && join.schema !== '*' ? join.schema : schema;
+        if (schema) {
+            table = `${schema}.${table}`;
+        }
+        if (join.prop.name !== '__subquery__') {
+            join.primaryKeys.forEach((primaryKey, idx) => {
+                const right = `${join.alias}.${join.joinColumns[idx]}`;
+                if (join.prop.formula) {
+                    const alias = this.platform.quoteIdentifier(join.ownerAlias);
+                    const left = join.prop.formula(alias);
                     conditions.push(`${left} = ${this.knex.ref(right)}`);
-                });
-            }
-            if (join.prop.targetMeta?.discriminatorValue && !join.path?.endsWith('[pivot]')) {
-                const typeProperty = join.prop.targetMeta.root.discriminatorColumn;
-                const alias = join.inverseAlias ?? join.alias;
-                join.cond[`${alias}.${typeProperty}`] = join.prop.targetMeta.discriminatorValue;
-            }
-            for (const key of Object.keys(join.cond)) {
-                const hasPrefix = key.includes('.') || core_1.Utils.isOperator(key) || core_1.RawQueryFragment.isKnownFragment(key);
-                const newKey = hasPrefix ? key : `${join.alias}.${key}`;
-                const clause = this.processJoinClause(newKey, join.cond[key], join.alias, params);
-                /* istanbul ignore else */
-                if (clause !== '()') {
-                    conditions.push(clause);
+                    return;
                 }
+                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]')) {
+            const typeProperty = join.prop.targetMeta.root.discriminatorColumn;
+            const alias = join.inverseAlias ?? join.alias;
+            join.cond[`${alias}.${typeProperty}`] = join.prop.targetMeta.discriminatorValue;
+        }
+        for (const key of Object.keys(join.cond)) {
+            const hasPrefix = key.includes('.') || core_1.Utils.isOperator(key) || core_1.RawQueryFragment.isKnownFragment(key);
+            const newKey = hasPrefix ? key : `${join.alias}.${key}`;
+            const clause = this.processJoinClause(newKey, join.cond[key], join.alias, params);
+            /* istanbul ignore else */
+            if (clause !== '()') {
+                conditions.push(clause);
             }
-            let sql = method + ' ';
-            if (join.subquery) {
-                sql += `(${join.subquery})`;
-            }
-            else {
-                sql += this.knex.ref(table);
-            }
-            sql += ` as ${this.knex.ref(join.alias)}`;
-            if (conditions.length > 0) {
-                sql += ` on ${conditions.join(' and ')}`;
+        }
+        let sql = method + ' ';
+        if (join.nested) {
+            sql += `(${this.knex.ref(table)} as ${this.knex.ref(join.alias)}`;
+            for (const nested of join.nested) {
+                const { sql: nestedSql, params: nestedParams } = this.createJoinExpression(nested, joins, schema);
+                sql += ' ' + nestedSql;
+                params.unshift(...nestedParams);
             }
-            return qb.joinRaw(sql, params);
-        });
+            sql += `)`;
+        }
+        else if (join.subquery) {
+            sql += `(${join.subquery}) as ${this.knex.ref(join.alias)}`;
+        }
+        else {
+            sql += `${this.knex.ref(table)} as ${this.knex.ref(join.alias)}`;
+        }
+        if (conditions.length > 0) {
+            sql += ` on ${conditions.join(' and ')}`;
+        }
+        return { sql, params };
     }
     processJoinClause(key, value, alias, params, operator = '$eq') {
         if (core_1.Utils.isGroupOperator(key) && Array.isArray(value)) {

package/query/enums.d.ts

@@ -9,6 +9,8 @@ export declare enum QueryType {
 export declare enum JoinType {
     leftJoin = "left join",
     innerJoin = "inner join",
+    nestedLeftJoin = "nested left join",
+    nestedInnerJoin = "nested inner join",
     pivotJoin = "pivot join",
     innerJoinLateral = "inner join lateral",
     leftJoinLateral = "left join lateral"

package/query/enums.js

@@ -14,6 +14,8 @@ var JoinType;
 (function (JoinType) {
     JoinType["leftJoin"] = "left join";
     JoinType["innerJoin"] = "inner join";
+    JoinType["nestedLeftJoin"] = "nested left join";
+    JoinType["nestedInnerJoin"] = "nested inner join";
     JoinType["pivotJoin"] = "pivot join";
     JoinType["innerJoinLateral"] = "inner join lateral";
     JoinType["leftJoinLateral"] = "left join lateral";

package/typings.d.ts

@@ -27,6 +27,7 @@ export interface JoinOptions {
     cond: Dictionary;
     cond_?: Dictionary;
     subquery?: string;
+    nested?: Set<JoinOptions>;
 }
 export interface Column {
     name: string;