@mikro-orm/knex 7.0.0-dev.0 → 7.0.0-dev.10

package/query/ObjectCriteriaNode.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectCriteriaNode = void 0;
-const core_1 = require("@mikro-orm/core");
-const CriteriaNode_1 = require("./CriteriaNode");
-const enums_1 = require("./enums");
+import { ALIAS_REPLACEMENT, QueryFlag, raw, RawQueryFragment, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { CriteriaNode } from './CriteriaNode.js';
+import { JoinType, QueryType } from './enums.js';
 /**
  * @internal
  */
-class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
+export class ObjectCriteriaNode extends CriteriaNode {
     process(qb, options) {
         const nestedAlias = qb.getAliasForJoinPath(this.getPath(), options);
         const ownerAlias = options?.alias || qb.alias;
@@ -18,7 +15,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
         }
         if (this.shouldAutoJoin(qb, nestedAlias)) {
             if (keys.some(k => ['$some', '$none', '$every'].includes(k))) {
-                if (![core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(this.prop.kind)) {
+                if (![ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(this.prop.kind)) {
                     // ignore collection operators when used on a non-relational property - this can happen when they get into
                     // populateWhere via `infer` on m:n properties with select-in strategy
                     if (this.parent?.parent) { // we validate only usage on top level
@@ -27,10 +24,10 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
                     throw new Error(`Collection operators can be used only inside a collection property context, but it was used for ${this.getPath()}.`);
                 }
                 const $and = [];
-                const knownKey = [core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.EMBEDDED].includes(this.prop.kind) || (this.prop.kind === core_1.ReferenceKind.ONE_TO_ONE && this.prop.owner);
+                const knownKey = [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE, ReferenceKind.EMBEDDED].includes(this.prop.kind) || (this.prop.kind === ReferenceKind.ONE_TO_ONE && this.prop.owner);
                 const parentMeta = this.metadata.find(this.parent.entityName);
                 const primaryKeys = parentMeta.primaryKeys.map(pk => {
-                    return [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(qb.type) ? `${knownKey ? alias : ownerAlias}.${pk}` : pk;
+                    return [QueryType.SELECT, QueryType.COUNT].includes(qb.type) ? `${knownKey ? alias : ownerAlias}.${pk}` : pk;
                 });
                 for (const key of keys) {
                     if (!['$some', '$none', '$every'].includes(key)) {
@@ -50,7 +47,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
                     }
                     const op = key === '$some' ? '$in' : '$nin';
                     $and.push({
-                        [core_1.Utils.getPrimaryKeyHash(primaryKeys)]: { [op]: sub.getNativeQuery().toRaw() },
+                        [Utils.getPrimaryKeyHash(primaryKeys)]: { [op]: sub.getNativeQuery().toRaw() },
                     });
                 }
                 if ($and.length === 1) {
@@ -58,13 +55,13 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
                 }
                 return { $and };
             }
-            alias = this.autoJoin(qb, ownerAlias);
+            alias = this.autoJoin(qb, ownerAlias, options);
         }
         return keys.reduce((o, field) => {
             const childNode = this.payload[field];
             const payload = childNode.process(qb, { ...options, alias: this.prop ? alias : ownerAlias });
-            const operator = core_1.Utils.isOperator(field);
-            const isRawField = core_1.RawQueryFragment.isKnownFragment(field);
+            const operator = Utils.isOperator(field);
+            const isRawField = RawQueryFragment.isKnownFragment(field);
             // we need to keep the prefixing for formulas otherwise we would lose aliasing context when nesting inside group operators
             const virtual = childNode.prop?.persist === false && !childNode.prop?.formula;
             // if key is missing, we are inside group operator and we need to prefix with alias
@@ -78,11 +75,11 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
                 this.inlineCondition(childNode.renameFieldToPK(qb), o, payload);
             }
             else if (isRawField) {
-                const rawField = core_1.RawQueryFragment.getKnownFragment(field);
-                o[(0, core_1.raw)(rawField.sql.replaceAll(core_1.ALIAS_REPLACEMENT, alias), rawField.params)] = payload;
+                const rawField = RawQueryFragment.getKnownFragment(field);
+                o[raw(rawField.sql.replaceAll(ALIAS_REPLACEMENT, alias), rawField.params)] = payload;
             }
-            else if (primaryKey || virtual || operator || field.includes('.') || ![enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(qb.type)) {
-                this.inlineCondition(field.replaceAll(core_1.ALIAS_REPLACEMENT, alias), o, payload);
+            else if (primaryKey || virtual || operator || field.includes('.') || ![QueryType.SELECT, QueryType.COUNT].includes(qb.type)) {
+                this.inlineCondition(field.replaceAll(ALIAS_REPLACEMENT, alias), o, payload);
             }
             else {
                 this.inlineCondition(`${alias}.${field}`, o, payload);
@@ -112,21 +109,21 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
         });
     }
     shouldInline(payload) {
-        const customExpression = core_1.RawQueryFragment.isKnownFragment(this.key);
-        const scalar = core_1.Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
-        const operator = core_1.Utils.isObject(payload) && Object.keys(payload).every(k => core_1.Utils.isOperator(k, false));
-        return !!this.prop && this.prop.kind !== core_1.ReferenceKind.SCALAR && !scalar && !operator;
+        const customExpression = RawQueryFragment.isKnownFragment(this.key);
+        const scalar = Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
+        const operator = Utils.isObject(payload) && Object.keys(payload).every(k => Utils.isOperator(k, false));
+        return !!this.prop && this.prop.kind !== ReferenceKind.SCALAR && !scalar && !operator;
     }
     getChildKey(k, prop, childAlias, alias) {
         const idx = prop.referencedPKs.indexOf(k);
-        return idx !== -1 && !childAlias && ![core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind)
+        return idx !== -1 && !childAlias && ![ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)
             ? this.aliased(prop.joinColumns[idx], alias)
             : k;
     }
     inlineArrayChildPayload(obj, payload, k, prop, childAlias, alias) {
         const key = this.getChildKey(k, prop, childAlias);
         const value = payload.map((child) => Object.keys(child).reduce((inner, childKey) => {
-            const key = (this.isPrefixed(childKey) || core_1.Utils.isOperator(childKey)) ? childKey : this.aliased(childKey, childAlias);
+            const key = (this.isPrefixed(childKey) || Utils.isOperator(childKey)) ? childKey : this.aliased(childKey, childAlias);
             inner[key] = child[childKey];
             return inner;
         }, {}));
@@ -135,19 +132,19 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
     inlineChildPayload(o, payload, field, alias, childAlias) {
         const prop = this.metadata.find(this.entityName).properties[field];
         for (const k of Object.keys(payload)) {
-            if (core_1.Utils.isOperator(k, false)) {
+            if (Utils.isOperator(k, false)) {
                 const tmp = payload[k];
                 delete payload[k];
                 o[this.aliased(field, alias)] = { [k]: tmp, ...o[this.aliased(field, alias)] };
             }
-            else if (core_1.Utils.isGroupOperator(k) && Array.isArray(payload[k])) {
+            else if (Utils.isGroupOperator(k) && Array.isArray(payload[k])) {
                 this.inlineArrayChildPayload(o, payload[k], k, prop, childAlias, alias);
             }
-            else if (this.isPrefixed(k) || core_1.Utils.isOperator(k) || !childAlias) {
+            else if (this.isPrefixed(k) || Utils.isOperator(k) || !childAlias) {
                 const key = this.getChildKey(k, prop, childAlias, alias);
                 this.inlineCondition(key, o, payload[k]);
             }
-            else if (core_1.RawQueryFragment.isKnownFragment(k)) {
+            else if (RawQueryFragment.isKnownFragment(k)) {
                 o[k] = payload[k];
             }
             else {
@@ -160,7 +157,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             o[key] = value;
             return;
         }
-        /* istanbul ignore next */
+        /* v8 ignore next 4 */
         if (key === '$and') {
             o.$and.push({ [key]: value });
             return;
@@ -182,41 +179,44 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             return true;
         }
         const meta = this.metadata.find(this.entityName);
-        const embeddable = this.prop.kind === core_1.ReferenceKind.EMBEDDED;
-        const knownKey = [core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.EMBEDDED].includes(this.prop.kind) || (this.prop.kind === core_1.ReferenceKind.ONE_TO_ONE && this.prop.owner);
-        const operatorKeys = knownKey && keys.every(key => core_1.Utils.isOperator(key, false));
+        const embeddable = this.prop.kind === ReferenceKind.EMBEDDED;
+        const knownKey = [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE, ReferenceKind.EMBEDDED].includes(this.prop.kind) || (this.prop.kind === ReferenceKind.ONE_TO_ONE && this.prop.owner);
+        const operatorKeys = knownKey && keys.every(key => Utils.isOperator(key, false));
         const primaryKeys = knownKey && keys.every(key => {
             if (!meta.primaryKeys.includes(key)) {
                 return false;
             }
-            if (!core_1.Utils.isPlainObject(this.payload[key].payload) || ![core_1.ReferenceKind.ONE_TO_ONE, core_1.ReferenceKind.MANY_TO_ONE].includes(meta.properties[key].kind)) {
+            if (!Utils.isPlainObject(this.payload[key].payload) || ![ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(meta.properties[key].kind)) {
                 return true;
             }
             return Object.keys(this.payload[key].payload).every(k => meta.properties[key].targetMeta.primaryKeys.includes(k));
         });
         return !primaryKeys && !nestedAlias && !operatorKeys && !embeddable;
     }
-    autoJoin(qb, alias) {
+    autoJoin(qb, alias, options) {
         const nestedAlias = qb.getNextAlias(this.prop?.pivotTable ?? this.entityName);
-        const customExpression = core_1.RawQueryFragment.isKnownFragment(this.key);
-        const scalar = core_1.Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || customExpression;
-        const operator = core_1.Utils.isPlainObject(this.payload) && Object.keys(this.payload).every(k => core_1.Utils.isOperator(k, false));
+        const customExpression = RawQueryFragment.isKnownFragment(this.key);
+        const scalar = Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || customExpression;
+        const operator = Utils.isPlainObject(this.payload) && Object.keys(this.payload).every(k => Utils.isOperator(k, false));
         const field = `${alias}.${this.prop.name}`;
-        const method = qb.hasFlag(core_1.QueryFlag.INFER_POPULATE) ? 'joinAndSelect' : 'join';
-        if (this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY && (scalar || operator)) {
-            qb.join(field, nestedAlias, undefined, enums_1.JoinType.pivotJoin, this.getPath());
+        const method = qb.hasFlag(QueryFlag.INFER_POPULATE) ? 'joinAndSelect' : 'join';
+        const path = this.getPath();
+        if (this.prop.kind === ReferenceKind.MANY_TO_MANY && (scalar || operator)) {
+            qb.join(field, nestedAlias, undefined, JoinType.pivotJoin, path);
         }
         else {
             const prev = qb._fields?.slice();
-            qb[method](field, nestedAlias, undefined, enums_1.JoinType.leftJoin, this.getPath());
-            if (!qb.hasFlag(core_1.QueryFlag.INFER_POPULATE)) {
+            qb[method](field, nestedAlias, undefined, JoinType.leftJoin, path);
+            if (!qb.hasFlag(QueryFlag.INFER_POPULATE)) {
                 qb._fields = prev;
             }
         }
+        if (!options || options.type !== 'orderBy') {
+            qb.scheduleFilterCheck(path);
+        }
         return nestedAlias;
     }
     isPrefixed(field) {
         return !!field.match(/\w+\./);
     }
 }
-exports.ObjectCriteriaNode = ObjectCriteriaNode;

package/query/QueryBuilder.d.ts

@@ -1,12 +1,12 @@
 import { inspect } from 'node:util';
-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, type Transaction } from '@mikro-orm/core';
-import { JoinType, QueryType } from './enums';
-import type { AbstractSqlDriver } from '../AbstractSqlDriver';
-import { type Alias, type OnConflictClause, QueryBuilderHelper } from './QueryBuilderHelper';
-import type { SqlEntityManager } from '../SqlEntityManager';
-import type { Field, ICriteriaNodeProcessOptions, JoinOptions } from '../typings';
-import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
-import { NativeQueryBuilder } from './NativeQueryBuilder';
+import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityKey, type EntityManager, 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, type Transaction } from '@mikro-orm/core';
+import { JoinType, QueryType } from './enums.js';
+import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
+import { type Alias, type OnConflictClause, QueryBuilderHelper } from './QueryBuilderHelper.js';
+import type { SqlEntityManager } from '../SqlEntityManager.js';
+import type { Field, ICriteriaNodeProcessOptions, JoinOptions } from '../typings.js';
+import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
+import { NativeQueryBuilder } from './NativeQueryBuilder.js';
 export interface ExecuteOptions {
     mapResults?: boolean;
     mergeResults?: boolean;
@@ -141,6 +141,15 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * Apply filters to the QB where condition.
      */
     applyFilters(filterOptions?: Dictionary<boolean | Dictionary> | string[] | boolean): Promise<void>;
+    private readonly autoJoinedPaths;
+    /**
+     * @internal
+     */
+    scheduleFilterCheck(path: string): void;
+    /**
+     * @internal
+     */
+    applyJoinedFilters(em: EntityManager, filterOptions?: Dictionary<boolean | Dictionary> | string[] | boolean): Promise<void>;
     withSubQuery(subQuery: RawQueryFragment | NativeQueryBuilder, alias: string): this;
     where(cond: QBFilterQuery<Entity>, operator?: keyof typeof GroupOperator): this;
     where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;
@@ -256,10 +265,6 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * Executes the query, returning both array of results and total count query (without offset and limit).
      */
     getResultAndCount(): Promise<[Entity[], number]>;
-    /**
-     * Provides promise-like interface so we can await the QB instance.
-     */
-    then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<Loaded<Entity, Hint>[] | number | QueryResult<Entity>>;
     /**
      * Returns native query builder instance with sub-query aliased with given alias.
      * You can provide `EntityName.propName` as alias, then the field name will be used based on the metadata
@@ -303,14 +308,12 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
 export interface RunQueryBuilder<Entity extends object> extends Omit<QueryBuilder<Entity, any, any>, 'getResult' | 'getSingleResult' | 'getResultList' | 'where'> {
     where(cond: QBFilterQuery<Entity> | string, params?: keyof typeof GroupOperator | any[], operator?: keyof typeof GroupOperator): this;
     execute<Result = QueryResult<Entity>>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<Result>;
-    then<TResult1 = QueryResult<Entity>, TResult2 = never>(onfulfilled?: ((value: QueryResult<Entity>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<QueryResult<Entity>>;
 }
 export interface SelectQueryBuilder<Entity extends object = AnyEntity, RootAlias extends string = never, Hint extends string = never, Context extends object = never> extends QueryBuilder<Entity, RootAlias, Hint, Context> {
     execute<Result = Entity[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<Result>;
     execute<Result = Entity[]>(method: 'all', mapResults?: boolean): Promise<Result>;
     execute<Result = Entity>(method: 'get', mapResults?: boolean): Promise<Result>;
     execute<Result = QueryResult<Entity>>(method: 'run', mapResults?: boolean): Promise<Result>;
-    then<TResult1 = Entity[], TResult2 = never>(onfulfilled?: ((value: Loaded<Entity, Hint>[]) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<Loaded<Entity, Hint>[]>;
 }
 export interface CountQueryBuilder<Entity extends object> extends QueryBuilder<Entity, any, any> {
     execute<Result = {
@@ -325,7 +328,6 @@ export interface CountQueryBuilder<Entity extends object> extends QueryBuilder<E
     execute<Result = QueryResult<{
         count: number;
     }>>(method: 'run', mapResults?: boolean): Promise<Result>;
-    then<TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<number>;
 }
 export interface InsertQueryBuilder<T extends object> extends RunQueryBuilder<T> {
 }