Method having

packages/db/src/query/builder/index.ts:504–534

* Filter grouped rows based on aggregate conditions * * @param callback - A function that receives table references and returns an expression * @returns A QueryBuilder with the having condition applied * * @example * ```ts * // Filter groups by count * query * .from({ po

(callback: WhereCallback<TContext>)

   * ```
   */
  having(callback: WhereCallback<TContext>): QueryBuilder<TContext> {
    const aliases = this._getCurrentAliases()
    // Add $selected namespace if SELECT clause exists (either regular or functional)
    const refProxy = (
      this.query.select || this.query.fnSelect
        ? createRefProxyWithSelected(aliases)
        : createRefProxy(aliases)
    ) as RefsForContext<TContext>
    const rawExpression = callback(refProxy)

    // Allow bare boolean column references like `.having(({ $selected }) => $selected.isActive)`
    // by converting ref proxies to PropRef expressions, the same way helper
    // functions like `not()` and `eq()` do via `toExpression()`.
    const expression = isRefProxy(rawExpression)
      ? toExpression(rawExpression)
      : rawExpression

    // Validate that the callback returned a valid expression
    // This catches common mistakes like using JavaScript comparison operators (===, !==, etc.)
    // which return boolean primitives instead of expression objects
    if (!isExpressionLike(expression)) {
      throw new InvalidWhereExpressionError(getValueTypeName(expression))
    }

    const existingHaving = this.query.having || []

    return new BaseQueryBuilder({
      ...this.query,
      having: [...existingHaving, expression],
    }) as any
  }

  /**
   * Select specific columns or computed values from the query