@mikro-orm/sql 7.0.2 → 7.0.3-dev.0

package/query/ObjectCriteriaNode.d.ts

@@ -4,16 +4,16 @@ import type { ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings.js';
  * @internal
  */
 export declare class ObjectCriteriaNode<T extends object> extends CriteriaNode<T> {
-  process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
-  isStrict(): boolean;
-  unwrap(): any;
-  willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
-  shouldInline(payload: any): boolean;
-  private getChildKey;
-  private inlineArrayChildPayload;
-  private inlineChildPayload;
-  private inlineCondition;
-  private shouldAutoJoin;
-  private autoJoin;
-  private isPrefixed;
+    process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
+    isStrict(): boolean;
+    unwrap(): any;
+    willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
+    shouldInline(payload: any): boolean;
+    private getChildKey;
+    private inlineArrayChildPayload;
+    private inlineChildPayload;
+    private inlineCondition;
+    private shouldAutoJoin;
+    private autoJoin;
+    private isPrefixed;
 }

package/query/ObjectCriteriaNode.js

@@ -1,12 +1,4 @@
-import {
-  ALIAS_REPLACEMENT,
-  GroupOperator,
-  QueryFlag,
-  raw,
-  RawQueryFragment,
-  ReferenceKind,
-  Utils,
-} from '@mikro-orm/core';
+import { ALIAS_REPLACEMENT, GroupOperator, QueryFlag, raw, RawQueryFragment, ReferenceKind, Utils, } from '@mikro-orm/core';
 import { CriteriaNode } from './CriteriaNode.js';
 import { JoinType, QueryType } from './enums.js';
 const COLLECTION_OPERATORS = ['$some', '$none', '$every', '$size'];
@@ -14,311 +6,303 @@ const COLLECTION_OPERATORS = ['$some', '$none', '$every', '$size'];
  * @internal
  */
 export class ObjectCriteriaNode extends CriteriaNode {
-  process(qb, options) {
-    const matchPopulateJoins =
-      options?.matchPopulateJoins ||
-      (this.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
-    const nestedAlias = qb.getAliasForJoinPath(this.getPath(options), { ...options, matchPopulateJoins });
-    const ownerAlias = options?.alias || qb.alias;
-    const keys = Utils.getObjectQueryKeys(this.payload);
-    let alias = options?.alias;
-    if (nestedAlias) {
-      alias = nestedAlias;
-    }
-    if (this.shouldAutoJoin(qb, nestedAlias)) {
-      if (keys.some(k => COLLECTION_OPERATORS.includes(k))) {
-        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
-            return {};
-          }
-          throw new Error(
-            `Collection operators can be used only inside a collection property context, but it was used for ${this.getPath()}.`,
-          );
+    process(qb, options) {
+        const matchPopulateJoins = options?.matchPopulateJoins ||
+            (this.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
+        const nestedAlias = qb.getAliasForJoinPath(this.getPath(options), { ...options, matchPopulateJoins });
+        const ownerAlias = options?.alias || qb.alias;
+        const keys = Utils.getObjectQueryKeys(this.payload);
+        let alias = options?.alias;
+        if (nestedAlias) {
+            alias = nestedAlias;
         }
-        const $and = [];
-        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 [QueryType.SELECT, QueryType.COUNT].includes(qb.type) ? `${knownKey ? alias : ownerAlias}.${pk}` : pk;
-        });
-        for (const key of keys) {
-          if (typeof key !== 'string' || !COLLECTION_OPERATORS.includes(key)) {
-            throw new Error('Mixing collection operators with other filters is not allowed.');
-          }
-          const payload = this.payload[key].unwrap();
-          const qb2 = qb.clone(true, ['schema']);
-          const joinAlias = qb2.getNextAlias(this.prop.targetMeta.class);
-          const sub = qb2
-            .from(parentMeta.class)
-            // eslint-disable-next-line no-unexpected-multiline
-            [key === '$size' ? 'leftJoin' : 'innerJoin'](this.key, joinAlias)
-            .select(parentMeta.primaryKeys);
-          if (key === '$size') {
-            const sizeCondition = typeof payload === 'number' ? { $eq: payload } : payload;
-            const pks = this.prop.referencedColumnNames;
-            const countExpr = raw(
-              `count(${pks.map(() => '??').join(', ')})`,
-              pks.map(pk => `${joinAlias}.${pk}`),
-            );
-            sub.groupBy(parentMeta.primaryKeys);
-            sub.having({
-              $and: Object.keys(sizeCondition).map(op => ({ [countExpr]: { [op]: sizeCondition[op] } })),
-            });
-          } else if (key === '$every') {
-            sub.where({ $not: { [this.key]: payload } });
-          } else {
-            sub.where({ [this.key]: payload });
-          }
-          const op = ['$size', '$some'].includes(key) ? '$in' : '$nin';
-          $and.push({
-            [Utils.getPrimaryKeyHash(primaryKeys)]: { [op]: sub.getNativeQuery().toRaw() },
-          });
+        if (this.shouldAutoJoin(qb, nestedAlias)) {
+            if (keys.some(k => COLLECTION_OPERATORS.includes(k))) {
+                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
+                        return {};
+                    }
+                    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 = [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 [QueryType.SELECT, QueryType.COUNT].includes(qb.type) ? `${knownKey ? alias : ownerAlias}.${pk}` : pk;
+                });
+                for (const key of keys) {
+                    if (typeof key !== 'string' || !COLLECTION_OPERATORS.includes(key)) {
+                        throw new Error('Mixing collection operators with other filters is not allowed.');
+                    }
+                    const payload = this.payload[key].unwrap();
+                    const qb2 = qb.clone(true, ['schema']);
+                    const joinAlias = qb2.getNextAlias(this.prop.targetMeta.class);
+                    const sub = qb2
+                        .from(parentMeta.class)
+                    // eslint-disable-next-line no-unexpected-multiline
+                    [key === '$size' ? 'leftJoin' : 'innerJoin'](this.key, joinAlias)
+                        .select(parentMeta.primaryKeys);
+                    if (key === '$size') {
+                        const sizeCondition = typeof payload === 'number' ? { $eq: payload } : payload;
+                        const pks = this.prop.referencedColumnNames;
+                        const countExpr = raw(`count(${pks.map(() => '??').join(', ')})`, pks.map(pk => `${joinAlias}.${pk}`));
+                        sub.groupBy(parentMeta.primaryKeys);
+                        sub.having({
+                            $and: Object.keys(sizeCondition).map(op => ({ [countExpr]: { [op]: sizeCondition[op] } })),
+                        });
+                    }
+                    else if (key === '$every') {
+                        sub.where({ $not: { [this.key]: payload } });
+                    }
+                    else {
+                        sub.where({ [this.key]: payload });
+                    }
+                    const op = ['$size', '$some'].includes(key) ? '$in' : '$nin';
+                    $and.push({
+                        [Utils.getPrimaryKeyHash(primaryKeys)]: { [op]: sub.getNativeQuery().toRaw() },
+                    });
+                }
+                if ($and.length === 1) {
+                    return $and[0];
+                }
+                return { $and };
+            }
+            alias = this.autoJoin(qb, ownerAlias, options);
         }
-        if ($and.length === 1) {
-          return $and[0];
+        if (this.prop && nestedAlias) {
+            const toOneProperty = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind);
+            // if the property is nullable and the filter is strict, we need to use left join, so we mimic the inner join behaviour
+            // with an exclusive condition on the join columns:
+            // - if the owning column is null, the row is missing, we don't apply the filter
+            // - if the target column is not null, the row is matched, we apply the filter
+            if (toOneProperty && this.prop.nullable && this.isStrict()) {
+                const key = this.prop.owner ? this.prop.name : this.prop.referencedPKs;
+                qb.andWhere({
+                    $or: [
+                        { [ownerAlias + '.' + key]: null },
+                        { [nestedAlias + '.' + Utils.getPrimaryKeyHash(this.prop.referencedPKs)]: { $ne: null } },
+                    ],
+                });
+            }
         }
-        return { $and };
-      }
-      alias = this.autoJoin(qb, ownerAlias, options);
-    }
-    if (this.prop && nestedAlias) {
-      const toOneProperty = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind);
-      // if the property is nullable and the filter is strict, we need to use left join, so we mimic the inner join behaviour
-      // with an exclusive condition on the join columns:
-      // - if the owning column is null, the row is missing, we don't apply the filter
-      // - if the target column is not null, the row is matched, we apply the filter
-      if (toOneProperty && this.prop.nullable && this.isStrict()) {
-        const key = this.prop.owner ? this.prop.name : this.prop.referencedPKs;
-        qb.andWhere({
-          $or: [
-            { [ownerAlias + '.' + key]: null },
-            { [nestedAlias + '.' + Utils.getPrimaryKeyHash(this.prop.referencedPKs)]: { $ne: null } },
-          ],
-        });
-      }
+        return keys.reduce((o, field) => {
+            const childNode = this.payload[field];
+            const payload = childNode.process(qb, { ...options, alias: this.prop ? alias : ownerAlias });
+            const operator = Utils.isOperator(field);
+            const isRawField = RawQueryFragment.isKnownFragmentSymbol(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 && !!options?.type;
+            // if key is missing, we are inside group operator and we need to prefix with alias
+            const primaryKey = this.key && this.metadata.find(this.entityName)?.primaryKeys.includes(field);
+            const isToOne = childNode.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(childNode.prop.kind);
+            if (childNode.shouldInline(payload)) {
+                const childAlias = qb.getAliasForJoinPath(childNode.getPath(), { preferNoBranch: isToOne, ...options });
+                const a = qb.helper.isTableNameAliasRequired(qb.type) ? alias : undefined;
+                this.inlineChildPayload(o, payload, field, a, childAlias);
+            }
+            else if (childNode.shouldRename(payload)) {
+                this.inlineCondition(childNode.renameFieldToPK(qb, alias), o, payload);
+            }
+            else if (isRawField) {
+                const rawField = RawQueryFragment.getKnownFragment(field);
+                o[raw(rawField.sql.replaceAll(ALIAS_REPLACEMENT, alias), rawField.params)] = payload;
+            }
+            else if (!childNode.validate && !childNode.prop && !field.includes('.') && !operator) {
+                // wrap unknown fields in raw() to prevent alias prefixing (e.g. raw SQL aliases in HAVING)
+                // use '??' placeholder to properly quote the identifier
+                o[raw('??', [field])] = 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 ?? qb.alias}.${field}`, o, payload);
+            }
+            return o;
+        }, {});
     }
-    return keys.reduce((o, field) => {
-      const childNode = this.payload[field];
-      const payload = childNode.process(qb, { ...options, alias: this.prop ? alias : ownerAlias });
-      const operator = Utils.isOperator(field);
-      const isRawField = RawQueryFragment.isKnownFragmentSymbol(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 && !!options?.type;
-      // if key is missing, we are inside group operator and we need to prefix with alias
-      const primaryKey = this.key && this.metadata.find(this.entityName)?.primaryKeys.includes(field);
-      const isToOne =
-        childNode.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(childNode.prop.kind);
-      if (childNode.shouldInline(payload)) {
-        const childAlias = qb.getAliasForJoinPath(childNode.getPath(), { preferNoBranch: isToOne, ...options });
-        const a = qb.helper.isTableNameAliasRequired(qb.type) ? alias : undefined;
-        this.inlineChildPayload(o, payload, field, a, childAlias);
-      } else if (childNode.shouldRename(payload)) {
-        this.inlineCondition(childNode.renameFieldToPK(qb, alias), o, payload);
-      } else if (isRawField) {
-        const rawField = RawQueryFragment.getKnownFragment(field);
-        o[raw(rawField.sql.replaceAll(ALIAS_REPLACEMENT, alias), rawField.params)] = payload;
-      } else if (!childNode.validate && !childNode.prop && !field.includes('.') && !operator) {
-        // wrap unknown fields in raw() to prevent alias prefixing (e.g. raw SQL aliases in HAVING)
-        // use '??' placeholder to properly quote the identifier
-        o[raw('??', [field])] = 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 ?? qb.alias}.${field}`, o, payload);
-      }
-      return o;
-    }, {});
-  }
-  isStrict() {
-    return (
-      this.strict ||
-      Utils.getObjectQueryKeys(this.payload).some(key => {
-        return this.payload[key].isStrict();
-      })
-    );
-  }
-  unwrap() {
-    return Utils.getObjectQueryKeys(this.payload).reduce((o, field) => {
-      o[field] = this.payload[field].unwrap();
-      return o;
-    }, {});
-  }
-  willAutoJoin(qb, alias, options) {
-    const nestedAlias = qb.getAliasForJoinPath(this.getPath(options), options);
-    const ownerAlias = alias || qb.alias;
-    const keys = Utils.getObjectQueryKeys(this.payload);
-    if (nestedAlias) {
-      alias = nestedAlias;
+    isStrict() {
+        return (this.strict ||
+            Utils.getObjectQueryKeys(this.payload).some(key => {
+                return this.payload[key].isStrict();
+            }));
     }
-    if (this.shouldAutoJoin(qb, nestedAlias)) {
-      return !keys.some(k => COLLECTION_OPERATORS.includes(k));
+    unwrap() {
+        return Utils.getObjectQueryKeys(this.payload).reduce((o, field) => {
+            o[field] = this.payload[field].unwrap();
+            return o;
+        }, {});
     }
-    return keys.some(field => {
-      const childNode = this.payload[field];
-      return childNode.willAutoJoin(qb, this.prop ? alias : ownerAlias, options);
-    });
-  }
-  shouldInline(payload) {
-    const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
-    const scalar = Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || rawField;
-    const operator =
-      Utils.isObject(payload) &&
-      Utils.getObjectQueryKeys(payload).every(k => {
-        if (k === '$not' && Utils.isPlainObject(payload[k])) {
-          // $not wrapping non-operator conditions (entity props) should be inlined
-          return Utils.getObjectQueryKeys(payload[k]).every(ik => Utils.isOperator(ik, false));
+    willAutoJoin(qb, alias, options) {
+        const nestedAlias = qb.getAliasForJoinPath(this.getPath(options), options);
+        const ownerAlias = alias || qb.alias;
+        const keys = Utils.getObjectQueryKeys(this.payload);
+        if (nestedAlias) {
+            alias = nestedAlias;
         }
-        return 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 && ![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 =>
-      Utils.getObjectQueryKeys(child).reduce((inner, childKey) => {
-        const key =
-          RawQueryFragment.isKnownFragmentSymbol(childKey) || this.isPrefixed(childKey) || Utils.isOperator(childKey)
-            ? childKey
-            : this.aliased(childKey, childAlias);
-        inner[key] = child[childKey];
-        return inner;
-      }, {}),
-    );
-    this.inlineCondition(key, obj, value);
-  }
-  inlineChildPayload(o, payload, field, alias, childAlias) {
-    const prop = this.metadata.find(this.entityName).properties[field];
-    for (const k of Utils.getObjectQueryKeys(payload)) {
-      if (RawQueryFragment.isKnownFragmentSymbol(k)) {
-        o[k] = payload[k];
-      } else if (
-        k === '$not' &&
-        Utils.isPlainObject(payload[k]) &&
-        Utils.getObjectQueryKeys(payload[k]).some(ik => !Utils.isOperator(ik, false))
-      ) {
-        // $not wraps entity conditions (from auto-join), inline at current level
-        this.inlineCondition(k, o, payload[k]);
-      } else 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 (k in GroupOperator && Array.isArray(payload[k])) {
-        this.inlineArrayChildPayload(o, payload[k], k, prop, childAlias, alias);
-      } else if (this.isPrefixed(k) || Utils.isOperator(k) || !childAlias) {
-        const key = this.getChildKey(k, prop, childAlias, alias);
-        this.inlineCondition(key, o, payload[k]);
-      } else {
-        o[this.aliased(k, childAlias)] = payload[k];
-      }
+        if (this.shouldAutoJoin(qb, nestedAlias)) {
+            return !keys.some(k => COLLECTION_OPERATORS.includes(k));
+        }
+        return keys.some(field => {
+            const childNode = this.payload[field];
+            return childNode.willAutoJoin(qb, this.prop ? alias : ownerAlias, options);
+        });
     }
-  }
-  inlineCondition(key, o, value) {
-    if (!(key in o)) {
-      o[key] = value;
-      return;
+    shouldInline(payload) {
+        const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
+        const scalar = Utils.isPrimaryKey(payload) ||
+            payload instanceof RegExp ||
+            payload instanceof Date ||
+            rawField;
+        const operator = Utils.isObject(payload) &&
+            Utils.getObjectQueryKeys(payload).every(k => {
+                if (k === '$not' && Utils.isPlainObject(payload[k])) {
+                    // $not wrapping non-operator conditions (entity props) should be inlined
+                    return Utils.getObjectQueryKeys(payload[k]).every(ik => Utils.isOperator(ik, false));
+                }
+                return Utils.isOperator(k, false);
+            });
+        return !!this.prop && this.prop.kind !== ReferenceKind.SCALAR && !scalar && !operator;
     }
-    /* v8 ignore next */
-    if (key === '$and') {
-      o.$and.push({ [key]: value });
-      return;
+    getChildKey(k, prop, childAlias, alias) {
+        const idx = prop.referencedPKs.indexOf(k);
+        return idx !== -1 && !childAlias && ![ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)
+            ? this.aliased(prop.joinColumns[idx], alias)
+            : k;
     }
-    const $and = o.$and ?? [];
-    $and.push({ [key]: o[key] }, { [key]: value });
-    delete o[key];
-    o.$and = $and;
-  }
-  shouldAutoJoin(qb, nestedAlias) {
-    if (!this.prop || !this.parent) {
-      return false;
+    inlineArrayChildPayload(obj, payload, k, prop, childAlias, alias) {
+        const key = this.getChildKey(k, prop, childAlias);
+        const value = payload.map((child) => Utils.getObjectQueryKeys(child).reduce((inner, childKey) => {
+            const key = RawQueryFragment.isKnownFragmentSymbol(childKey) || this.isPrefixed(childKey) || Utils.isOperator(childKey)
+                ? childKey
+                : this.aliased(childKey, childAlias);
+            inner[key] = child[childKey];
+            return inner;
+        }, {}));
+        this.inlineCondition(key, obj, value);
     }
-    const keys = Utils.getObjectQueryKeys(this.payload);
-    if (keys.every(k => typeof k === 'string' && k.includes('.') && k.startsWith(`${qb.alias}.`))) {
-      return false;
+    inlineChildPayload(o, payload, field, alias, childAlias) {
+        const prop = this.metadata.find(this.entityName).properties[field];
+        for (const k of Utils.getObjectQueryKeys(payload)) {
+            if (RawQueryFragment.isKnownFragmentSymbol(k)) {
+                o[k] = payload[k];
+            }
+            else if (k === '$not' &&
+                Utils.isPlainObject(payload[k]) &&
+                Utils.getObjectQueryKeys(payload[k]).some(ik => !Utils.isOperator(ik, false))) {
+                // $not wraps entity conditions (from auto-join), inline at current level
+                this.inlineCondition(k, o, payload[k]);
+            }
+            else 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 (k in GroupOperator && Array.isArray(payload[k])) {
+                this.inlineArrayChildPayload(o, payload[k], k, prop, childAlias, alias);
+            }
+            else if (this.isPrefixed(k) || Utils.isOperator(k) || !childAlias) {
+                const key = this.getChildKey(k, prop, childAlias, alias);
+                this.inlineCondition(key, o, payload[k]);
+            }
+            else {
+                o[this.aliased(k, childAlias)] = payload[k];
+            }
+        }
     }
-    if (keys.some(k => COLLECTION_OPERATORS.includes(k))) {
-      return true;
+    inlineCondition(key, o, value) {
+        if (!(key in o)) {
+            o[key] = value;
+            return;
+        }
+        /* v8 ignore next */
+        if (key === '$and') {
+            o.$and.push({ [key]: value });
+            return;
+        }
+        const $and = o.$and ?? [];
+        $and.push({ [key]: o[key] }, { [key]: value });
+        delete o[key];
+        o.$and = $and;
+    }
+    shouldAutoJoin(qb, nestedAlias) {
+        if (!this.prop || !this.parent) {
+            return false;
+        }
+        const keys = Utils.getObjectQueryKeys(this.payload);
+        if (keys.every(k => typeof k === 'string' && k.includes('.') && k.startsWith(`${qb.alias}.`))) {
+            return false;
+        }
+        if (keys.some(k => COLLECTION_OPERATORS.includes(k))) {
+            return true;
+        }
+        const meta = this.metadata.find(this.entityName);
+        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 => {
+                if (key === '$not') {
+                    // $not wraps conditions like $and/$or, check if it wraps entity property conditions (needs auto-join)
+                    // vs simple operator conditions on the FK (doesn't need auto-join)
+                    const childPayload = this.payload[key].payload;
+                    if (Utils.isPlainObject(childPayload)) {
+                        return Utils.getObjectQueryKeys(childPayload).every(k => Utils.isOperator(k, false));
+                    }
+                }
+                return Utils.isOperator(key, false);
+            });
+        const primaryKeys = knownKey &&
+            keys.every(key => {
+                if (typeof key !== 'string' || !meta.primaryKeys.includes(key)) {
+                    return false;
+                }
+                if (!Utils.isPlainObject(this.payload[key].payload) ||
+                    ![ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(meta.properties[key].kind)) {
+                    return true;
+                }
+                return Utils.getObjectQueryKeys(this.payload[key].payload).every(k => typeof k === 'string' && meta.properties[key].targetMeta.primaryKeys.includes(k));
+            });
+        return !primaryKeys && !nestedAlias && !operatorKeys && !embeddable;
     }
-    const meta = this.metadata.find(this.entityName);
-    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 => {
-        if (key === '$not') {
-          // $not wraps conditions like $and/$or, check if it wraps entity property conditions (needs auto-join)
-          // vs simple operator conditions on the FK (doesn't need auto-join)
-          const childPayload = this.payload[key].payload;
-          if (Utils.isPlainObject(childPayload)) {
-            return Utils.getObjectQueryKeys(childPayload).every(k => Utils.isOperator(k, false));
-          }
+    autoJoin(qb, alias, options) {
+        const nestedAlias = qb.getNextAlias(this.prop?.pivotEntity ?? this.entityName);
+        const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
+        const scalar = Utils.isPrimaryKey(this.payload) ||
+            this.payload instanceof RegExp ||
+            this.payload instanceof Date ||
+            rawField;
+        const operator = Utils.isPlainObject(this.payload) &&
+            Utils.getObjectQueryKeys(this.payload).every(k => Utils.isOperator(k, false));
+        const field = `${alias}.${this.prop.name}`;
+        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);
         }
-        return Utils.isOperator(key, false);
-      });
-    const primaryKeys =
-      knownKey &&
-      keys.every(key => {
-        if (typeof key !== 'string' || !meta.primaryKeys.includes(key)) {
-          return false;
+        else {
+            const prev = qb.state.fields?.slice();
+            const toOneProperty = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind);
+            const joinType = toOneProperty && !this.prop.nullable ? JoinType.innerJoin : JoinType.leftJoin;
+            qb[method](field, nestedAlias, undefined, joinType, path);
+            if (!qb.hasFlag(QueryFlag.INFER_POPULATE)) {
+                qb.state.fields = prev;
+            }
         }
-        if (
-          !Utils.isPlainObject(this.payload[key].payload) ||
-          ![ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(meta.properties[key].kind)
-        ) {
-          return true;
+        if (options?.type !== 'orderBy') {
+            qb.scheduleFilterCheck(path);
         }
-        return Utils.getObjectQueryKeys(this.payload[key].payload).every(
-          k => typeof k === 'string' && meta.properties[key].targetMeta.primaryKeys.includes(k),
-        );
-      });
-    return !primaryKeys && !nestedAlias && !operatorKeys && !embeddable;
-  }
-  autoJoin(qb, alias, options) {
-    const nestedAlias = qb.getNextAlias(this.prop?.pivotEntity ?? this.entityName);
-    const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
-    const scalar =
-      Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || rawField;
-    const operator =
-      Utils.isPlainObject(this.payload) &&
-      Utils.getObjectQueryKeys(this.payload).every(k => Utils.isOperator(k, false));
-    const field = `${alias}.${this.prop.name}`;
-    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.state.fields?.slice();
-      const toOneProperty = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind);
-      const joinType = toOneProperty && !this.prop.nullable ? JoinType.innerJoin : JoinType.leftJoin;
-      qb[method](field, nestedAlias, undefined, joinType, path);
-      if (!qb.hasFlag(QueryFlag.INFER_POPULATE)) {
-        qb.state.fields = prev;
-      }
+        return nestedAlias;
     }
-    if (options?.type !== 'orderBy') {
-      qb.scheduleFilterCheck(path);
+    isPrefixed(field) {
+        return !!/\w+\./.exec(field);
     }
-    return nestedAlias;
-  }
-  isPrefixed(field) {
-    return !!/\w+\./.exec(field);
-  }
 }