@mikro-orm/knex 6.0.0-dev.104 → 6.0.0-dev.106

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.104",
+  "version": "6.0.0-dev.106",
   "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.8.3"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "~6.0.0-dev.104"
+    "@mikro-orm/core": "~6.0.0-dev.106"
   }
 }

package/query/QueryBuilder.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="node" />
 import { inspect } from 'util';
 import type { Knex } from 'knex';
-import { LockMode, PopulateHint, QueryFlag, type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityName, type EntityProperty, type FlushMode, type GroupOperator, type MetadataStorage, type ObjectQuery, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, type QueryResult, type RequiredEntityData, type LoggingOptions } from '@mikro-orm/core';
+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 } from './enums';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
-import { QueryBuilderHelper, type Alias } from './QueryBuilderHelper';
+import { type Alias, QueryBuilderHelper } from './QueryBuilderHelper';
 import type { SqlEntityManager } from '../SqlEntityManager';
 import type { Field } from '../typings';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -92,11 +92,12 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     delete(cond?: QBFilterQuery): DeleteQueryBuilder<T>;
     truncate(): TruncateQueryBuilder<T>;
     count(field?: string | string[], distinct?: boolean): CountQueryBuilder<T>;
-    join(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string, schema?: string): this;
-    leftJoin(field: string, alias: string, cond?: QBFilterQuery, schema?: string): this;
-    joinAndSelect(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string, fields?: string[], schema?: string): SelectQueryBuilder<T>;
-    leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
-    innerJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
+    join(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string, schema?: string): this;
+    innerJoin(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
+    leftJoin(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
+    joinAndSelect(field: string | [field: string, Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string, fields?: string[], schema?: string): SelectQueryBuilder<T>;
+    leftJoinAndSelect(field: string | [field: string, Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
+    innerJoinAndSelect(field: string | [field: string, Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
     protected getFieldsForJoinedLoad(prop: EntityProperty<T>, alias: string, explicitFields?: string[]): Field<T>[];
     withSubQuery(subQuery: Knex.QueryBuilder, alias: string): this;
     where(cond: QBFilterQuery<T>, operator?: keyof typeof GroupOperator): this;

package/query/QueryBuilder.js

@@ -158,6 +158,10 @@ class QueryBuilder {
         this.joinReference(field, alias, cond, type, path, schema);
         return this;
     }
+    innerJoin(field, alias, cond = {}, schema) {
+        this.join(field, alias, cond, 'innerJoin', undefined, schema);
+        return this;
+    }
     leftJoin(field, alias, cond = {}, schema) {
         return this.join(field, alias, cond, 'leftJoin', undefined, schema);
     }
@@ -165,9 +169,17 @@ class QueryBuilder {
         if (!this.type) {
             this.select('*');
         }
+        let subquery;
+        if (Array.isArray(field)) {
+            subquery = field[1] instanceof QueryBuilder ? field[1].getFormattedQuery() : field[1].toString();
+            field = field[0];
+        }
         const prop = this.joinReference(field, alias, cond, type, path, schema);
-        this.addSelect(this.getFieldsForJoinedLoad(prop, alias, fields));
         const [fromAlias] = this.helper.splitField(field);
+        if (subquery) {
+            this._joins[`${fromAlias}.${prop.name}#${alias}`].subquery = subquery;
+        }
+        this.addSelect(this.getFieldsForJoinedLoad(prop, alias, fields));
         const populate = this._joinedProps.get(fromAlias);
         const item = { field: prop.name, strategy: core_1.LoadStrategy.JOINED, children: [] };
         if (populate) {
@@ -662,6 +674,27 @@ class QueryBuilder {
     }
     joinReference(field, alias, cond, type, path, schema) {
         this.ensureNotFinalized();
+        if (typeof field === 'object') {
+            const prop = {
+                name: '__subquery__',
+                kind: core_1.ReferenceKind.MANY_TO_ONE,
+            };
+            if (field instanceof QueryBuilder) {
+                prop.type = field.mainAlias.entityName;
+                prop.targetMeta = field.mainAlias.metadata;
+                field = field.getKnexQuery();
+            }
+            this._joins[`${this.alias}.${prop.name}#${alias}`] = {
+                prop,
+                alias,
+                type,
+                cond,
+                schema,
+                subquery: field.toString(),
+                ownerAlias: this.alias,
+            };
+            return prop;
+        }
         const [fromAlias, fromField] = this.helper.splitField(field);
         const q = (str) => `'${str}'`;
         if (!this._aliases[fromAlias]) {

package/query/QueryBuilderHelper.js

@@ -161,28 +161,43 @@ class QueryBuilderHelper {
     }
     processJoins(qb, joins, schema) {
         Object.values(joins).forEach(join => {
-            let table = `${join.table} as ${join.alias}`;
+            let table = join.table;
             const method = join.type === 'innerJoin' ? 'inner join' : 'left join';
+            const conditions = [];
+            const params = [];
             schema = join.schema && join.schema !== '*' ? join.schema : schema;
             if (schema) {
                 table = `${schema}.${table}`;
             }
-            const conditions = [];
-            const params = [];
-            join.primaryKeys.forEach((primaryKey, idx) => {
-                const left = `${join.ownerAlias}.${primaryKey}`;
-                const right = `${join.alias}.${join.joinColumns[idx]}`;
-                conditions.push(`${this.knex.ref(left)} = ${this.knex.ref(right)}`);
-            });
-            if (join.prop.targetMeta.discriminatorValue && !join.path?.endsWith('[pivot]')) {
+            if (!join.subquery) {
+                join.primaryKeys.forEach((primaryKey, idx) => {
+                    const left = `${join.ownerAlias}.${primaryKey}`;
+                    const right = `${join.alias}.${join.joinColumns[idx]}`;
+                    conditions.push(`${this.knex.ref(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;
             }
             Object.keys(join.cond).forEach(key => {
-                conditions.push(this.processJoinClause(key, join.cond[key], params));
+                const needsPrefix = key.includes('.') || core_1.Utils.isOperator(key) || core_1.RawQueryFragment.isKnownFragment(key);
+                const newKey = needsPrefix ? key : `${join.alias}.${key}`;
+                conditions.push(this.processJoinClause(newKey, join.cond[key], params));
             });
-            return qb.joinRaw(`${method} ${this.knex.ref(table)} on ${conditions.join(' and ')}`, params);
+            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 ')}`;
+            }
+            return qb.joinRaw(sql, params);
         });
     }
     processJoinClause(key, value, params, operator = '$eq') {

package/typings.d.ts

@@ -26,6 +26,7 @@ export interface JoinOptions {
     prop: EntityProperty;
     cond: Dictionary;
     cond_?: Dictionary;
+    subquery?: string;
 }
 export interface Column {
     name: string;