Method processWhere

packages/core/src/utils/QueryHelper.ts:246–366

(options: ProcessWhereOptions<T>)

  }

  static processWhere<T extends object>(options: ProcessWhereOptions<T>): FilterQuery<T> {
    // eslint-disable-next-line prefer-const
    let { where, entityName, metadata, platform, aliased = true, convertCustomTypes = true, root = true } = options;
    const meta = metadata.find<T>(entityName);

    // inline PK-only objects in M:N queries, so we don't join the target entity when not needed
    if (meta && root) {
      QueryHelper.liftGroupOperators(where as Dictionary, meta, metadata);
      QueryHelper.inlinePrimaryKeyObjects(where as Dictionary, meta, metadata);
    }

    if (meta && root) {
      QueryHelper.convertCompositeEntityRefs(where as Dictionary, meta);
    }

    if (platform.getConfig().get('ignoreUndefinedInQuery') && where && typeof where === 'object') {
      Utils.dropUndefinedProperties(where);
    }

    where = QueryHelper.processParams(where) ?? {};

    /* v8 ignore next */
    if (!root && Utils.isPrimaryKey<T>(where)) {
      return where;
    }

    if (meta && Utils.isPrimaryKey(where, meta.compositePK)) {
      where = { [Utils.getPrimaryKeyHash(meta.primaryKeys)]: where } as FilterQuery<T>;
    }

    if (Array.isArray(where) && root) {
      const rootPrimaryKey = meta ? Utils.getPrimaryKeyHash(meta.primaryKeys) : Utils.className(entityName);
      let cond = { [rootPrimaryKey]: { $in: where } } as FilterQuery<T>;

      // @ts-ignore
      // detect tuple comparison, use `$or` in case the number of constituents don't match
      if (
        meta &&
        !where.every(
          c =>
            Utils.isPrimaryKey(c as unknown) ||
            (Array.isArray(c) && c.length === meta.primaryKeys.length && c.every(i => Utils.isPrimaryKey(i))),
        )
      ) {
        cond = { $or: where } as FilterQuery<T>;
      }

      return QueryHelper.processWhere({ ...options, where: cond, root: false });
    }

    if (!Utils.isPlainObject(where)) {
      return where;
    }

    return Utils.getObjectQueryKeys(where).reduce((o, key) => {
      let value = where[key as keyof typeof where] as unknown as FilterQuery<T>;
      const customExpression = Raw.isKnownFragmentSymbol(key);