@mikro-orm/knex 6.3.3-dev.1 → 6.3.3-dev.10

package/package.json

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

package/query/CriteriaNode.js

@@ -28,7 +28,7 @@ class CriteriaNode {
                 return;
             }
             for (const k of pks) {
-                this.prop = meta.props.find(prop => prop.name === k || (prop.fieldNames?.length === 1 && prop.fieldNames[0] === k));
+                this.prop = meta.props.find(prop => prop.name === k || (prop.fieldNames?.length === 1 && prop.fieldNames[0] === k && prop.persist !== false));
                 const isProp = this.prop || meta.props.find(prop => (prop.fieldNames || []).includes(k));
                 // do not validate if the key is prefixed or type casted (e.g. `k::text`)
                 if (validate && !isProp && !k.includes('.') && !k.includes('::') && !core_1.Utils.isOperator(k) && !core_1.RawQueryFragment.isKnownFragment(k)) {

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';
@@ -140,6 +140,10 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     innerJoinAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field | [field: Field, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: Alias, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>>;
     innerJoinLateralAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: [field: Field, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: Alias, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>>;
     protected getFieldsForJoinedLoad(prop: EntityProperty<Entity>, alias: string, explicitFields?: string[]): Field<Entity>[];
+    /**
+     * Apply filters to the QB where condition.
+     */
+    applyFilters(filterOptions?: Dictionary<boolean | Dictionary> | string[] | boolean): Promise<this>;
     withSubQuery(subQuery: Knex.QueryBuilder, alias: string): this;
     where(cond: QBFilterQuery<Entity>, operator?: keyof typeof GroupOperator): this;
     where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;

package/query/QueryBuilder.js

@@ -253,6 +253,18 @@ class QueryBuilder {
             .forEach(prop => fields.push(...this.driver.mapPropToFieldNames(this, prop, alias)));
         return fields;
     }
+    /**
+     * Apply filters to the QB where condition.
+     */
+    async applyFilters(filterOptions = {}) {
+        /* istanbul ignore next */
+        if (!this.em) {
+            throw new Error('Cannot apply filters, this QueryBuilder is not attached to an EntityManager');
+        }
+        const cond = await this.em.applyFilters(this.mainAlias.entityName, {}, filterOptions, 'read');
+        this.andWhere(cond);
+        return this;
+    }
     withSubQuery(subQuery, alias) {
         this.ensureNotFinalized();
         this.subQueries[alias] = subQuery.toString();
@@ -1155,7 +1167,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 +1184,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 +1210,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;