Method where

packages/sql/src/query/QueryBuilder.ts:1558–1622

(
    cond: QBFilterQuery<Entity, RootAlias, Context, RawAliases> | string | RawQueryFragment,
    params?: keyof typeof GroupOperator | any[],
    operator?: keyof typeof GroupOperator,
  )

   */
  where(cond: string | RawQueryFragment, params?: any[], operator?: keyof typeof GroupOperator): this;
  where(
    cond: QBFilterQuery<Entity, RootAlias, Context, RawAliases> | string | RawQueryFragment,
    params?: keyof typeof GroupOperator | any[],
    operator?: keyof typeof GroupOperator,
  ): this {
    this.ensureNotFinalized();
    let processedCond: FilterQuery<Entity>;

    if (isRaw(cond)) {
      const sql = this.platform.formatQuery(cond.sql, cond.params);
      processedCond = { [raw(`(${sql})`)]: Utils.asArray(params) } as FilterQuery<Entity>;
      operator ??= '$and';
    } else if (typeof cond === 'string') {
      processedCond = { [raw(`(${cond})`, Utils.asArray(params))]: [] } as FilterQuery<Entity>;
      operator ??= '$and';
    } else {
      processedCond = QueryHelper.processWhere({
        where: cond as FilterQuery<Entity>,
        entityName: this.mainAlias.entityName,
        metadata: this.metadata,
        platform: this.platform,
        aliasMap: this.getAliasMap(),
        aliased: [QueryType.SELECT, QueryType.COUNT].includes(this.type),
        convertCustomTypes: this.#state.flags.has(QueryFlag.CONVERT_CUSTOM_TYPES),
      }) as FilterQuery<Entity>;
    }

    const op = operator || (params as keyof typeof GroupOperator);
    const topLevel =
      !op || !(Utils.hasObjectKeys(this.#state.cond) || RawQueryFragment.hasObjectFragments(this.#state.cond));
    const criteriaNode = CriteriaNodeFactory.createNode<Entity>(
      this.metadata,
      this.mainAlias.entityName,
      processedCond,
    );
    const ignoreBranching = this.#state.resolvedPopulateWhere === 'infer';

    if (
      [QueryType.UPDATE, QueryType.DELETE].includes(this.type) &&
      criteriaNode.willAutoJoin(this as IQueryBuilder<Entity>, undefined, { ignoreBranching })
    ) {
      // use sub-query to support joining
      this.setFlag(this.type === QueryType.UPDATE ? QueryFlag.UPDATE_SUB_QUERY : QueryFlag.DELETE_SUB_QUERY);
      this.select(this.mainAlias.meta.primaryKeys, true);
    }

    if (topLevel) {
      this.#state.cond = criteriaNode.process(this as IQueryBuilder<Entity>, { ignoreBranching });
    } else if (Array.isArray(this.#state.cond[op])) {
      this.#state.cond[op].push(criteriaNode.process(this as IQueryBuilder<Entity>, { ignoreBranching }));
    } else {
      const cond1 = [this.#state.cond, criteriaNode.process(this as IQueryBuilder<Entity>, { ignoreBranching })];
      this.#state.cond = { [op]: cond1 };
    }

    if (this.#state.onConflict) {
      this.#state.onConflict[this.#state.onConflict.length - 1].where = this.helper.processOnConflictCondition(
        this.#state.cond,