@mikro-orm/knex 6.0.0-dev.124 → 6.0.0-dev.126

package/AbstractSqlDriver.js

@@ -117,12 +117,14 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     }
     async wrapVirtualExpressionInSubquery(meta, expression, where, options, type) {
         const qb = this.createQueryBuilder(meta.className, options?.ctx, options.connectionType, options.convertCustomTypes)
-            .limit(options?.limit, options?.offset)
             .indexHint(options.indexHint)
             .comment(options.comments)
             .hintComment(options.hintComments);
-        if (options.orderBy) {
-            qb.orderBy(options.orderBy);
+        if (type !== query_1.QueryType.COUNT) {
+            qb.limit(options?.limit, options?.offset);
+            if (options.orderBy) {
+                qb.orderBy(options.orderBy);
+            }
         }
         qb.where(where);
         const kqb = qb.getKnexQuery().clear('select');
@@ -709,7 +711,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     joinedProps(meta, populate) {
         return populate.filter(p => {
             const prop = meta.properties[p.field] || {};
-            return (p.strategy || prop.strategy || this.config.get('loadStrategy')) === core_1.LoadStrategy.JOINED && prop.kind !== core_1.ReferenceKind.SCALAR;
+            return (p.strategy || prop.strategy || this.config.get('loadStrategy')) === core_1.LoadStrategy.JOINED && ![core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.EMBEDDED].includes(prop.kind);
         });
     }
     /**
@@ -771,7 +773,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             const tableAlias = qb.getNextAlias(prop.name);
             const field = parentTableAlias ? `${parentTableAlias}.${prop.name}` : prop.name;
             const path = parentJoinPath ? `${parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
-            qb.join(field, tableAlias, {}, 'leftJoin', path);
+            qb.join(field, tableAlias, {}, query_1.JoinType.leftJoin, path);
             const childExplicitFields = explicitFields?.filter(f => core_1.Utils.isPlainObject(f)).map(o => o[prop.name])[0] || [];
             explicitFields?.forEach(f => {
                 if (typeof f === 'string' && f.startsWith(`${prop.name}.`)) {

package/index.mjs

@@ -99,6 +99,7 @@ export const Index = mod.Index;
 export const IntegerType = mod.IntegerType;
 export const InvalidFieldNameException = mod.InvalidFieldNameException;
 export const IsolationLevel = mod.IsolationLevel;
+export const JoinType = mod.JoinType;
 export const JsonProperty = mod.JsonProperty;
 export const JsonType = mod.JsonType;
 export const Knex = mod.Knex;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.124",
+  "version": "6.0.0-dev.126",
   "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",
@@ -63,9 +63,9 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^5.9.0"
+    "@mikro-orm/core": "^5.9.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.0.0-dev.124"
+    "@mikro-orm/core": "6.0.0-dev.126"
   }
 }

package/query/ObjectCriteriaNode.js

@@ -130,11 +130,11 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
         const operator = core_1.Utils.isPlainObject(this.payload) && Object.keys(this.payload).every(k => core_1.Utils.isOperator(k, false));
         const field = `${alias}.${this.prop.name}`;
         if (this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY && (scalar || operator)) {
-            qb.join(field, nestedAlias, undefined, 'pivotJoin', this.getPath());
+            qb.join(field, nestedAlias, undefined, enums_1.JoinType.pivotJoin, this.getPath());
         }
         else {
             const prev = qb._fields?.slice();
-            qb.join(field, nestedAlias, undefined, 'leftJoin', this.getPath());
+            qb.join(field, nestedAlias, undefined, enums_1.JoinType.leftJoin, this.getPath());
             qb._fields = prev;
         }
         return nestedAlias;

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 } from './enums';
+import { QueryType, JoinType } from './enums';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
 import { type Alias, QueryBuilderHelper } from './QueryBuilderHelper';
 import type { SqlEntityManager } from '../SqlEntityManager';
@@ -96,12 +96,16 @@ 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 | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string, schema?: string): this;
+    join(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, type?: JoinType, path?: string, schema?: string): this;
     innerJoin(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
+    innerJoinLateral(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, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string, fields?: string[], schema?: string): SelectQueryBuilder<T>;
+    leftJoinLateral(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
+    joinAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, type?: JoinType, path?: string, fields?: string[], schema?: string): SelectQueryBuilder<T>;
     leftJoinAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
+    leftJoinLateralAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
     innerJoinAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
+    innerJoinLateralAndSelect(field: string | [field: string, qb: 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

@@ -154,18 +154,25 @@ class QueryBuilder {
         }
         return this.init(enums_1.QueryType.COUNT);
     }
-    join(field, alias, cond = {}, type = 'innerJoin', path, schema) {
+    join(field, alias, cond = {}, type = enums_1.JoinType.innerJoin, path, schema) {
         this.joinReference(field, alias, cond, type, path, schema);
         return this;
     }
     innerJoin(field, alias, cond = {}, schema) {
-        this.join(field, alias, cond, 'innerJoin', undefined, schema);
+        this.join(field, alias, cond, enums_1.JoinType.innerJoin, undefined, schema);
+        return this;
+    }
+    innerJoinLateral(field, alias, cond = {}, schema) {
+        this.join(field, alias, cond, enums_1.JoinType.innerJoinLateral, undefined, schema);
         return this;
     }
     leftJoin(field, alias, cond = {}, schema) {
-        return this.join(field, alias, cond, 'leftJoin', undefined, schema);
+        return this.join(field, alias, cond, enums_1.JoinType.leftJoin, undefined, schema);
+    }
+    leftJoinLateral(field, alias, cond = {}, schema) {
+        return this.join(field, alias, cond, enums_1.JoinType.leftJoinLateral, undefined, schema);
     }
-    joinAndSelect(field, alias, cond = {}, type = 'innerJoin', path, fields, schema) {
+    joinAndSelect(field, alias, cond = {}, type = enums_1.JoinType.innerJoin, path, fields, schema) {
         if (!this.type) {
             this.select('*');
         }
@@ -174,7 +181,7 @@ class QueryBuilder {
             subquery = field[1] instanceof QueryBuilder ? field[1].getFormattedQuery() : field[1].toString();
             field = field[0];
         }
-        const prop = this.joinReference(field, alias, cond, type, path, schema);
+        const prop = this.joinReference(field, alias, cond, type, path, schema, subquery);
         const [fromAlias] = this.helper.splitField(field);
         if (subquery) {
             this._joins[`${fromAlias}.${prop.name}#${alias}`].subquery = subquery;
@@ -192,10 +199,16 @@ class QueryBuilder {
         return this;
     }
     leftJoinAndSelect(field, alias, cond = {}, fields, schema) {
-        return this.joinAndSelect(field, alias, cond, 'leftJoin', undefined, fields, schema);
+        return this.joinAndSelect(field, alias, cond, enums_1.JoinType.leftJoin, undefined, fields, schema);
+    }
+    leftJoinLateralAndSelect(field, alias, cond = {}, fields, schema) {
+        return this.joinAndSelect(field, alias, cond, enums_1.JoinType.leftJoinLateral, undefined, fields, schema);
     }
     innerJoinAndSelect(field, alias, cond = {}, fields, schema) {
-        return this.joinAndSelect(field, alias, cond, 'innerJoin', undefined, fields, schema);
+        return this.joinAndSelect(field, alias, cond, enums_1.JoinType.innerJoin, undefined, fields, schema);
+    }
+    innerJoinLateralAndSelect(field, alias, cond = {}, fields, schema) {
+        return this.joinAndSelect(field, alias, cond, enums_1.JoinType.innerJoinLateral, undefined, fields, schema);
     }
     getFieldsForJoinedLoad(prop, alias, explicitFields) {
         const fields = [];
@@ -685,7 +698,7 @@ class QueryBuilder {
         }
         return qb;
     }
-    joinReference(field, alias, cond, type, path, schema) {
+    joinReference(field, alias, cond, type, path, schema, subquery) {
         this.ensureNotFinalized();
         if (typeof field === 'object') {
             const prop = {
@@ -708,6 +721,9 @@ class QueryBuilder {
             };
             return prop;
         }
+        if (!subquery && type.includes('lateral')) {
+            throw new Error(`Lateral join can be used only with a sub-query.`);
+        }
         const [fromAlias, fromField] = this.helper.splitField(field);
         const q = (str) => `'${str}'`;
         if (!this._aliases[fromAlias]) {
@@ -735,7 +751,7 @@ class QueryBuilder {
         }
         else if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY) {
             let pivotAlias = alias;
-            if (type !== 'pivotJoin') {
+            if (type !== enums_1.JoinType.pivotJoin) {
                 const oldPivotAlias = this.getAliasForJoinPath(path + '[pivot]');
                 pivotAlias = oldPivotAlias ?? this.getNextAlias(prop.pivotEntity);
                 aliasedName = `${fromAlias}.${prop.name}#${pivotAlias}`;
@@ -948,7 +964,7 @@ class QueryBuilder {
                 const prop = meta.properties[fromField];
                 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, 'leftJoin');
+                this._joins[aliasedName] = this.helper.joinOneToReference(prop, this.mainAlias.aliasName, alias, enums_1.JoinType.leftJoin);
                 this._populateMap[aliasedName] = this._joins[aliasedName].alias;
             }
         });

package/query/QueryBuilderHelper.d.ts

@@ -1,6 +1,6 @@
 import type { Knex } from 'knex';
 import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityProperty, type FlatQueryOrderMap, LockMode, type QBFilterQuery } from '@mikro-orm/core';
-import { QueryType } from './enums';
+import { JoinType, QueryType } from './enums';
 import type { Field, JoinOptions } from '../typings';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
 /**
@@ -19,9 +19,9 @@ export declare class QueryBuilderHelper {
     mapper(field: string | Knex.Raw, type?: QueryType): string;
     mapper(field: string | Knex.Raw, type?: QueryType, value?: any, alias?: string | null): string;
     processData(data: Dictionary, convertCustomTypes: boolean, multi?: boolean): any;
-    joinOneToReference(prop: EntityProperty, ownerAlias: string, alias: string, type: 'leftJoin' | 'innerJoin' | 'pivotJoin', cond?: Dictionary, schema?: string): JoinOptions;
-    joinManyToOneReference(prop: EntityProperty, ownerAlias: string, alias: string, type: 'leftJoin' | 'innerJoin' | 'pivotJoin', cond?: Dictionary, schema?: string): JoinOptions;
-    joinManyToManyReference(prop: EntityProperty, ownerAlias: string, alias: string, pivotAlias: string, type: 'leftJoin' | 'innerJoin' | 'pivotJoin', cond: Dictionary, path: string, schema?: string): Dictionary<JoinOptions>;
+    joinOneToReference(prop: EntityProperty, ownerAlias: string, alias: string, type: JoinType, cond?: Dictionary, schema?: string): JoinOptions;
+    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;
     private processJoinClause;
     private wrapQueryGroup;

package/query/QueryBuilderHelper.js

@@ -165,7 +165,7 @@ class QueryBuilderHelper {
                 path: path.endsWith('[pivot]') ? path : `${path}[pivot]`,
             },
         };
-        if (type === 'pivotJoin') {
+        if (type === enums_1.JoinType.pivotJoin) {
             return ret;
         }
         const prop2 = prop.owner ? pivotMeta.relations[1] : pivotMeta.relations[0];
@@ -178,7 +178,7 @@ class QueryBuilderHelper {
     processJoins(qb, joins, schema) {
         Object.values(joins).forEach(join => {
             let table = join.table;
-            const method = join.type === 'innerJoin' ? 'inner join' : 'left join';
+            const method = join.type === enums_1.JoinType.pivotJoin ? 'left join' : join.type;
             const conditions = [];
             const params = [];
             schema = join.schema && join.schema !== '*' ? join.schema : schema;

package/query/ScalarCriteriaNode.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScalarCriteriaNode = void 0;
 const core_1 = require("@mikro-orm/core");
 const CriteriaNode_1 = require("./CriteriaNode");
+const enums_1 = require("./enums");
 /**
  * @internal
  */
@@ -13,7 +14,7 @@ class ScalarCriteriaNode extends CriteriaNode_1.CriteriaNode {
             const parentPath = this.parent.getPath(); // the parent is always there, otherwise `shouldJoin` would return `false`
             const nestedAlias = qb.getAliasForJoinPath(path) || qb.getNextAlias(this.prop?.pivotTable ?? this.entityName);
             const field = `${alias}.${this.prop.name}`;
-            const type = this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY ? 'pivotJoin' : 'leftJoin';
+            const type = this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY ? enums_1.JoinType.pivotJoin : enums_1.JoinType.leftJoin;
             qb.join(field, nestedAlias, undefined, type, path);
             // select the owner as virtual property when joining from 1:1 inverse side, but only if the parent is root entity
             if (this.prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !parentPath.includes('.')) {

package/query/enums.d.ts

@@ -6,3 +6,10 @@ export declare enum QueryType {
     UPDATE = "UPDATE",
     DELETE = "DELETE"
 }
+export declare enum JoinType {
+    leftJoin = "left join",
+    innerJoin = "inner join",
+    pivotJoin = "pivot join",
+    innerJoinLateral = "inner join lateral",
+    leftJoinLateral = "left join lateral"
+}

package/query/enums.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryType = void 0;
+exports.JoinType = exports.QueryType = void 0;
 var QueryType;
 (function (QueryType) {
     QueryType["TRUNCATE"] = "TRUNCATE";
@@ -10,3 +10,11 @@ var QueryType;
     QueryType["UPDATE"] = "UPDATE";
     QueryType["DELETE"] = "DELETE";
 })(QueryType || (exports.QueryType = QueryType = {}));
+var JoinType;
+(function (JoinType) {
+    JoinType["leftJoin"] = "left join";
+    JoinType["innerJoin"] = "inner join";
+    JoinType["pivotJoin"] = "pivot join";
+    JoinType["innerJoinLateral"] = "inner join lateral";
+    JoinType["leftJoinLateral"] = "left join lateral";
+})(JoinType || (exports.JoinType = JoinType = {}));

package/typings.d.ts

@@ -1,6 +1,6 @@
 import type { Knex } from 'knex';
 import type { CheckCallback, Dictionary, EntityProperty, GroupOperator, RawQueryFragment, QBFilterQuery, QueryOrderMap, Type } from '@mikro-orm/core';
-import type { QueryType } from './query/enums';
+import type { JoinType, QueryType } from './query/enums';
 import type { DatabaseSchema, DatabaseTable } from './schema';
 export interface Table {
     table_name: string;
@@ -15,7 +15,7 @@ export type Field<T> = AnyString | keyof T | RawQueryFragment | KnexStringRef |
 export interface JoinOptions {
     table: string;
     schema?: string;
-    type: 'leftJoin' | 'innerJoin' | 'pivotJoin';
+    type: JoinType;
     alias: string;
     ownerAlias: string;
     inverseAlias?: string;
@@ -125,7 +125,7 @@ export interface IQueryBuilder<T> {
     delete(cond?: QBFilterQuery): this;
     truncate(): this;
     count(field?: string | string[], distinct?: boolean): this;
-    join(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string): this;
+    join(field: string, alias: string, cond?: QBFilterQuery, type?: JoinType, path?: string): this;
     leftJoin(field: string, alias: string, cond?: QBFilterQuery): this;
     joinAndSelect(field: string, alias: string, cond?: QBFilterQuery): this;
     leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery, fields?: string[]): this;