{"version":3,"file":"index.cjs","sources":["../../../../src/query/builder/index.ts"],"sourcesContent":["import { CollectionImpl } from '../../collection/index.js'\nimport {\n Aggregate as AggregateExpr,\n CollectionRef,\n Func as FuncExpr,\n INCLUDES_SCALAR_FIELD,\n IncludesSubquery,\n PropRef,\n QueryRef,\n Value as ValueExpr,\n isExpressionLike,\n} from '../ir.js'\nimport {\n InvalidSourceError,\n InvalidSourceTypeError,\n InvalidWhereExpressionError,\n JoinConditionMustBeEqualityError,\n OnlyOneSourceAllowedError,\n QueryMustHaveFromClauseError,\n SubQueryMustHaveFromClauseError,\n} from '../../errors.js'\nimport {\n createRefProxy,\n createRefProxyWithSelected,\n isRefProxy,\n toExpression,\n} from './ref-proxy.js'\nimport { ConcatToArrayWrapper, ToArrayWrapper } from './functions.js'\nimport type { NamespacedRow, SingleResult } from '../../types.js'\nimport type {\n Aggregate,\n BasicExpression,\n IncludesMaterialization,\n JoinClause,\n OrderBy,\n OrderByDirection,\n QueryIR,\n Where,\n} from '../ir.js'\nimport type {\n CompareOptions,\n Context,\n FunctionalHavingRow,\n GetResult,\n GroupByCallback,\n JoinOnCallback,\n MergeContextForJoinCallback,\n MergeContextWithJoinType,\n NonScalarSelectObject,\n OrderByCallback,\n OrderByOptions,\n RefsForContext,\n ResultTypeFromSelect,\n ResultTypeFromSelectValue,\n ScalarSelectValue,\n SchemaFromSource,\n SelectObject,\n Source,\n WhereCallback,\n WithResult,\n} from './types.js'\n\nexport class BaseQueryBuilder {\n private readonly query: Partial = {}\n\n constructor(query: Partial = {}) {\n this.query = { ...query }\n }\n\n /**\n * Creates a CollectionRef or QueryRef from a source object\n * @param source - An object with a single key-value pair\n * @param context - Context string for error messages (e.g., \"from clause\", \"join clause\")\n * @returns A tuple of [alias, ref] where alias is the source key and ref is the created reference\n */\n private _createRefForSource(\n source: TSource,\n context: string,\n ): [string, CollectionRef | QueryRef] {\n // Validate source is a plain object (not null, array, string, etc.)\n // We use try-catch to handle null/undefined gracefully\n let keys: Array\n try {\n keys = Object.keys(source)\n } catch {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n const type = source === null ? `null` : `undefined`\n throw new InvalidSourceTypeError(context, type)\n }\n\n // Check if it's an array (arrays pass Object.keys but aren't valid sources)\n if (Array.isArray(source)) {\n throw new InvalidSourceTypeError(context, `array`)\n }\n\n // Validate exactly one key\n if (keys.length !== 1) {\n if (keys.length === 0) {\n throw new InvalidSourceTypeError(context, `empty object`)\n }\n // Check if it looks like a string was passed (has numeric keys)\n if (keys.every((k) => !isNaN(Number(k)))) {\n throw new InvalidSourceTypeError(context, `string`)\n }\n throw new OnlyOneSourceAllowedError(context)\n }\n\n const alias = keys[0]!\n const sourceValue = source[alias]\n\n // Validate the value is a Collection or QueryBuilder\n let ref: CollectionRef | QueryRef\n\n if (sourceValue instanceof CollectionImpl) {\n ref = new CollectionRef(sourceValue, alias)\n } else if (sourceValue instanceof BaseQueryBuilder) {\n const subQuery = sourceValue._getQuery()\n if (!(subQuery as Partial).from) {\n throw new SubQueryMustHaveFromClauseError(context)\n }\n ref = new QueryRef(subQuery, alias)\n } else {\n throw new InvalidSourceError(alias)\n }\n\n return [alias, ref]\n }\n\n /**\n * Specify the source table or subquery for the query\n *\n * @param source - An object with a single key-value pair where the key is the table alias and the value is a Collection or subquery\n * @returns A QueryBuilder with the specified source\n *\n * @example\n * ```ts\n * // Query from a collection\n * query.from({ users: usersCollection })\n *\n * // Query from a subquery\n * const activeUsers = query.from({ u: usersCollection }).where(({u}) => u.active)\n * query.from({ activeUsers })\n * ```\n */\n from(\n source: TSource,\n ): QueryBuilder<{\n baseSchema: SchemaFromSource\n schema: SchemaFromSource\n fromSourceName: keyof TSource & string\n hasJoins: false\n }> {\n const [, from] = this._createRefForSource(source, `from clause`)\n\n return new BaseQueryBuilder({\n ...this.query,\n from,\n }) as any\n }\n\n /**\n * Join another table or subquery to the current query\n *\n * @param source - An object with a single key-value pair where the key is the table alias and the value is a Collection or subquery\n * @param onCallback - A function that receives table references and returns the join condition\n * @param type - The type of join: 'inner', 'left', 'right', or 'full' (defaults to 'left')\n * @returns A QueryBuilder with the joined table available\n *\n * @example\n * ```ts\n * // Left join users with posts\n * query\n * .from({ users: usersCollection })\n * .join({ posts: postsCollection }, ({users, posts}) => eq(users.id, posts.userId))\n *\n * // Inner join with explicit type\n * query\n * .from({ u: usersCollection })\n * .join({ p: postsCollection }, ({u, p}) => eq(u.id, p.userId), 'inner')\n * ```\n *\n * // Join with a subquery\n * const activeUsers = query.from({ u: usersCollection }).where(({u}) => u.active)\n * query\n * .from({ activeUsers })\n * .join({ p: postsCollection }, ({u, p}) => eq(u.id, p.userId))\n */\n join<\n TSource extends Source,\n TJoinType extends `inner` | `left` | `right` | `full` = `left`,\n >(\n source: TSource,\n onCallback: JoinOnCallback<\n MergeContextForJoinCallback>\n >,\n type: TJoinType = `left` as TJoinType,\n ): QueryBuilder<\n MergeContextWithJoinType, TJoinType>\n > {\n const [alias, from] = this._createRefForSource(source, `join clause`)\n\n // Create a temporary context for the callback\n const currentAliases = this._getCurrentAliases()\n const newAliases = [...currentAliases, alias]\n const refProxy = createRefProxy(newAliases) as RefsForContext<\n MergeContextForJoinCallback>\n >\n\n // Get the join condition expression\n const onExpression = onCallback(refProxy)\n\n // Extract left and right from the expression\n // For now, we'll assume it's an eq function with two arguments\n let left: BasicExpression\n let right: BasicExpression\n\n if (\n onExpression.type === `func` &&\n onExpression.name === `eq` &&\n onExpression.args.length === 2\n ) {\n left = onExpression.args[0]!\n right = onExpression.args[1]!\n } else {\n throw new JoinConditionMustBeEqualityError()\n }\n\n const joinClause: JoinClause = {\n from,\n type,\n left,\n right,\n }\n\n const existingJoins = this.query.join || []\n\n return new BaseQueryBuilder({\n ...this.query,\n join: [...existingJoins, joinClause],\n }) as any\n }\n\n /**\n * Perform a LEFT JOIN with another table or subquery\n *\n * @param source - An object with a single key-value pair where the key is the table alias and the value is a Collection or subquery\n * @param onCallback - A function that receives table references and returns the join condition\n * @returns A QueryBuilder with the left joined table available\n *\n * @example\n * ```ts\n * // Left join users with posts\n * query\n * .from({ users: usersCollection })\n * .leftJoin({ posts: postsCollection }, ({users, posts}) => eq(users.id, posts.userId))\n * ```\n */\n leftJoin(\n source: TSource,\n onCallback: JoinOnCallback<\n MergeContextForJoinCallback>\n >,\n ): QueryBuilder<\n MergeContextWithJoinType, `left`>\n > {\n return this.join(source, onCallback, `left`)\n }\n\n /**\n * Perform a RIGHT JOIN with another table or subquery\n *\n * @param source - An object with a single key-value pair where the key is the table alias and the value is a Collection or subquery\n * @param onCallback - A function that receives table references and returns the join condition\n * @returns A QueryBuilder with the right joined table available\n *\n * @example\n * ```ts\n * // Right join users with posts\n * query\n * .from({ users: usersCollection })\n * .rightJoin({ posts: postsCollection }, ({users, posts}) => eq(users.id, posts.userId))\n * ```\n */\n rightJoin(\n source: TSource,\n onCallback: JoinOnCallback<\n MergeContextForJoinCallback>\n >,\n ): QueryBuilder<\n MergeContextWithJoinType, `right`>\n > {\n return this.join(source, onCallback, `right`)\n }\n\n /**\n * Perform an INNER JOIN with another table or subquery\n *\n * @param source - An object with a single key-value pair where the key is the table alias and the value is a Collection or subquery\n * @param onCallback - A function that receives table references and returns the join condition\n * @returns A QueryBuilder with the inner joined table available\n *\n * @example\n * ```ts\n * // Inner join users with posts\n * query\n * .from({ users: usersCollection })\n * .innerJoin({ posts: postsCollection }, ({users, posts}) => eq(users.id, posts.userId))\n * ```\n */\n innerJoin(\n source: TSource,\n onCallback: JoinOnCallback<\n MergeContextForJoinCallback>\n >,\n ): QueryBuilder<\n MergeContextWithJoinType, `inner`>\n > {\n return this.join(source, onCallback, `inner`)\n }\n\n /**\n * Perform a FULL JOIN with another table or subquery\n *\n * @param source - An object with a single key-value pair where the key is the table alias and the value is a Collection or subquery\n * @param onCallback - A function that receives table references and returns the join condition\n * @returns A QueryBuilder with the full joined table available\n *\n * @example\n * ```ts\n * // Full join users with posts\n * query\n * .from({ users: usersCollection })\n * .fullJoin({ posts: postsCollection }, ({users, posts}) => eq(users.id, posts.userId))\n * ```\n */\n fullJoin(\n source: TSource,\n onCallback: JoinOnCallback<\n MergeContextForJoinCallback>\n >,\n ): QueryBuilder<\n MergeContextWithJoinType, `full`>\n > {\n return this.join(source, onCallback, `full`)\n }\n\n /**\n * Filter rows based on a condition\n *\n * @param callback - A function that receives table references and returns an expression\n * @returns A QueryBuilder with the where condition applied\n *\n * @example\n * ```ts\n * // Simple condition\n * query\n * .from({ users: usersCollection })\n * .where(({users}) => gt(users.age, 18))\n *\n * // Multiple conditions\n * query\n * .from({ users: usersCollection })\n * .where(({users}) => and(\n * gt(users.age, 18),\n * eq(users.active, true)\n * ))\n *\n * // Multiple where calls are ANDed together\n * query\n * .from({ users: usersCollection })\n * .where(({users}) => gt(users.age, 18))\n * .where(({users}) => eq(users.active, true))\n * ```\n */\n where(callback: WhereCallback): QueryBuilder {\n const aliases = this._getCurrentAliases()\n const refProxy = createRefProxy(aliases) as RefsForContext\n const rawExpression = callback(refProxy)\n\n // Allow bare boolean column references like `.where(({ u }) => u.active)`\n // by converting ref proxies to PropRef expressions, the same way helper\n // functions like `not()` and `eq()` do via `toExpression()`.\n const expression = isRefProxy(rawExpression)\n ? toExpression(rawExpression)\n : rawExpression\n\n // Validate that the callback returned a valid expression\n // This catches common mistakes like using JavaScript comparison operators (===, !==, etc.)\n // which return boolean primitives instead of expression objects\n if (!isExpressionLike(expression)) {\n throw new InvalidWhereExpressionError(getValueTypeName(expression))\n }\n\n const existingWhere = this.query.where || []\n\n return new BaseQueryBuilder({\n ...this.query,\n where: [...existingWhere, expression],\n }) as any\n }\n\n /**\n * Filter grouped rows based on aggregate conditions\n *\n * @param callback - A function that receives table references and returns an expression\n * @returns A QueryBuilder with the having condition applied\n *\n * @example\n * ```ts\n * // Filter groups by count\n * query\n * .from({ posts: postsCollection })\n * .groupBy(({posts}) => posts.userId)\n * .having(({posts}) => gt(count(posts.id), 5))\n *\n * // Filter by average\n * query\n * .from({ orders: ordersCollection })\n * .groupBy(({orders}) => orders.customerId)\n * .having(({orders}) => gt(avg(orders.total), 100))\n *\n * // Multiple having calls are ANDed together\n * query\n * .from({ orders: ordersCollection })\n * .groupBy(({orders}) => orders.customerId)\n * .having(({orders}) => gt(count(orders.id), 5))\n * .having(({orders}) => gt(avg(orders.total), 100))\n * ```\n */\n having(callback: WhereCallback): QueryBuilder {\n const aliases = this._getCurrentAliases()\n // Add $selected namespace if SELECT clause exists (either regular or functional)\n const refProxy = (\n this.query.select || this.query.fnSelect\n ? createRefProxyWithSelected(aliases)\n : createRefProxy(aliases)\n ) as RefsForContext\n const rawExpression = callback(refProxy)\n\n // Allow bare boolean column references like `.having(({ $selected }) => $selected.isActive)`\n // by converting ref proxies to PropRef expressions, the same way helper\n // functions like `not()` and `eq()` do via `toExpression()`.\n const expression = isRefProxy(rawExpression)\n ? toExpression(rawExpression)\n : rawExpression\n\n // Validate that the callback returned a valid expression\n // This catches common mistakes like using JavaScript comparison operators (===, !==, etc.)\n // which return boolean primitives instead of expression objects\n if (!isExpressionLike(expression)) {\n throw new InvalidWhereExpressionError(getValueTypeName(expression))\n }\n\n const existingHaving = this.query.having || []\n\n return new BaseQueryBuilder({\n ...this.query,\n having: [...existingHaving, expression],\n }) as any\n }\n\n /**\n * Select specific columns or computed values from the query\n *\n * @param callback - A function that receives table references and returns an object with selected fields or expressions\n * @returns A QueryBuilder that returns only the selected fields\n *\n * @example\n * ```ts\n * // Select specific columns\n * query\n * .from({ users: usersCollection })\n * .select(({users}) => ({\n * name: users.name,\n * email: users.email\n * }))\n *\n * // Select with computed values\n * query\n * .from({ users: usersCollection })\n * .select(({users}) => ({\n * fullName: concat(users.firstName, ' ', users.lastName),\n * ageInMonths: mul(users.age, 12)\n * }))\n *\n * // Select with aggregates (requires GROUP BY)\n * query\n * .from({ posts: postsCollection })\n * .groupBy(({posts}) => posts.userId)\n * .select(({posts, count}) => ({\n * userId: posts.userId,\n * postCount: count(posts.id)\n * }))\n * ```\n */\n select(\n callback: (\n refs: RefsForContext,\n ) => NonScalarSelectObject,\n ): QueryBuilder>>\n select(\n callback: (refs: RefsForContext) => TSelectValue,\n ): QueryBuilder>>\n select(\n callback: (\n refs: RefsForContext,\n ) => SelectObject | ScalarSelectValue,\n ) {\n const aliases = this._getCurrentAliases()\n const refProxy = createRefProxy(aliases) as RefsForContext\n let selectObject = callback(refProxy)\n\n // Returning a top-level alias directly is equivalent to spreading it.\n // Leaf refs like `row.name` must remain scalar selections.\n if (isRefProxy(selectObject) && selectObject.__path.length === 1) {\n const sentinelKey = `__SPREAD_SENTINEL__${selectObject.__path[0]}__0`\n selectObject = { [sentinelKey]: true }\n }\n\n const select = buildNestedSelect(selectObject, aliases)\n\n return new BaseQueryBuilder({\n ...this.query,\n select: select,\n fnSelect: undefined, // remove the fnSelect clause if it exists\n }) as any\n }\n\n /**\n * Sort the query results by one or more columns\n *\n * @param callback - A function that receives table references and returns the field to sort by\n * @param direction - Sort direction: 'asc' for ascending, 'desc' for descending (defaults to 'asc')\n * @returns A QueryBuilder with the ordering applied\n *\n * @example\n * ```ts\n * // Sort by a single column\n * query\n * .from({ users: usersCollection })\n * .orderBy(({users}) => users.name)\n *\n * // Sort descending\n * query\n * .from({ users: usersCollection })\n * .orderBy(({users}) => users.createdAt, 'desc')\n *\n * // Multiple sorts (chain orderBy calls)\n * query\n * .from({ users: usersCollection })\n * .orderBy(({users}) => users.lastName)\n * .orderBy(({users}) => users.firstName)\n * ```\n */\n orderBy(\n callback: OrderByCallback,\n options: OrderByDirection | OrderByOptions = `asc`,\n ): QueryBuilder {\n const aliases = this._getCurrentAliases()\n // Add $selected namespace if SELECT clause exists (either regular or functional)\n const refProxy = (\n this.query.select || this.query.fnSelect\n ? createRefProxyWithSelected(aliases)\n : createRefProxy(aliases)\n ) as RefsForContext\n const result = callback(refProxy)\n\n const opts: CompareOptions =\n typeof options === `string`\n ? { direction: options, nulls: `first` }\n : {\n direction: options.direction ?? `asc`,\n nulls: options.nulls ?? `first`,\n stringSort: options.stringSort,\n locale:\n options.stringSort === `locale` ? options.locale : undefined,\n localeOptions:\n options.stringSort === `locale`\n ? options.localeOptions\n : undefined,\n }\n\n const makeOrderByClause = (res: any) => {\n return {\n expression: toExpression(res),\n compareOptions: opts,\n }\n }\n\n // Create the new OrderBy structure with expression and direction\n const orderByClauses = Array.isArray(result)\n ? result.map((r) => makeOrderByClause(r))\n : [makeOrderByClause(result)]\n\n const existingOrderBy: OrderBy = this.query.orderBy || []\n\n return new BaseQueryBuilder({\n ...this.query,\n orderBy: [...existingOrderBy, ...orderByClauses],\n }) as any\n }\n\n /**\n * Group rows by one or more columns for aggregation\n *\n * @param callback - A function that receives table references and returns the field(s) to group by\n * @returns A QueryBuilder with grouping applied (enables aggregate functions in SELECT and HAVING)\n *\n * @example\n * ```ts\n * // Group by a single column\n * query\n * .from({ posts: postsCollection })\n * .groupBy(({posts}) => posts.userId)\n * .select(({posts, count}) => ({\n * userId: posts.userId,\n * postCount: count()\n * }))\n *\n * // Group by multiple columns\n * query\n * .from({ sales: salesCollection })\n * .groupBy(({sales}) => [sales.region, sales.category])\n * .select(({sales, sum}) => ({\n * region: sales.region,\n * category: sales.category,\n * totalSales: sum(sales.amount)\n * }))\n * ```\n */\n groupBy(callback: GroupByCallback): QueryBuilder {\n const aliases = this._getCurrentAliases()\n const refProxy = createRefProxy(aliases) as RefsForContext\n const result = callback(refProxy)\n\n const newExpressions = Array.isArray(result)\n ? result.map((r) => toExpression(r))\n : [toExpression(result)]\n\n // Extend existing groupBy expressions (multiple groupBy calls should accumulate)\n const existingGroupBy = this.query.groupBy || []\n return new BaseQueryBuilder({\n ...this.query,\n groupBy: [...existingGroupBy, ...newExpressions],\n }) as any\n }\n\n /**\n * Limit the number of rows returned by the query\n * `orderBy` is required for `limit`\n *\n * @param count - Maximum number of rows to return\n * @returns A QueryBuilder with the limit applied\n *\n * @example\n * ```ts\n * // Get top 5 posts by likes\n * query\n * .from({ posts: postsCollection })\n * .orderBy(({posts}) => posts.likes, 'desc')\n * .limit(5)\n * ```\n */\n limit(count: number): QueryBuilder {\n return new BaseQueryBuilder({\n ...this.query,\n limit: count,\n }) as any\n }\n\n /**\n * Skip a number of rows before returning results\n * `orderBy` is required for `offset`\n *\n * @param count - Number of rows to skip\n * @returns A QueryBuilder with the offset applied\n *\n * @example\n * ```ts\n * // Get second page of results\n * query\n * .from({ posts: postsCollection })\n * .orderBy(({posts}) => posts.createdAt, 'desc')\n * .offset(page * pageSize)\n * .limit(pageSize)\n * ```\n */\n offset(count: number): QueryBuilder {\n return new BaseQueryBuilder({\n ...this.query,\n offset: count,\n }) as any\n }\n\n /**\n * Specify that the query should return distinct rows.\n * Deduplicates rows based on the selected columns.\n * @returns A QueryBuilder with distinct enabled\n *\n * @example\n * ```ts\n * // Get countries our users are from\n * query\n * .from({ users: usersCollection })\n * .select(({users}) => ({ country: users.country }))\n * .distinct()\n * ```\n */\n distinct(): QueryBuilder {\n return new BaseQueryBuilder({\n ...this.query,\n distinct: true,\n }) as any\n }\n\n /**\n * Specify that the query should return a single result\n * @returns A QueryBuilder that returns the first result\n *\n * @example\n * ```ts\n * // Get the user matching the query\n * query\n * .from({ users: usersCollection })\n * .where(({users}) => eq(users.id, 1))\n * .findOne()\n *```\n */\n findOne(): QueryBuilder {\n return new BaseQueryBuilder({\n ...this.query,\n // TODO: enforcing return only one result with also a default orderBy if none is specified\n // limit: 1,\n singleResult: true,\n }) as any\n }\n\n // Helper methods\n private _getCurrentAliases(): Array {\n const aliases: Array = []\n\n // Add the from alias\n if (this.query.from) {\n aliases.push(this.query.from.alias)\n }\n\n // Add join aliases\n if (this.query.join) {\n for (const join of this.query.join) {\n aliases.push(join.from.alias)\n }\n }\n\n return aliases\n }\n\n /**\n * Functional variants of the query builder\n * These are imperative function that are called for ery row.\n * Warning: that these cannot be optimized by the query compiler, and may prevent\n * some type of optimizations being possible.\n * @example\n * ```ts\n * q.fn.select((row) => ({\n * name: row.user.name.toUpperCase(),\n * age: row.user.age + 1,\n * }))\n * ```\n */\n get fn() {\n const builder = this\n return {\n /**\n * Select fields using a function that operates on each row\n * Warning: This cannot be optimized by the query compiler\n *\n * @param callback - A function that receives a row and returns the selected value\n * @returns A QueryBuilder with functional selection applied\n *\n * @example\n * ```ts\n * // Functional select (not optimized)\n * query\n * .from({ users: usersCollection })\n * .fn.select(row => ({\n * name: row.users.name.toUpperCase(),\n * age: row.users.age + 1,\n * }))\n * ```\n */\n select(\n callback: (row: TContext[`schema`]) => TFuncSelectResult,\n ): QueryBuilder> {\n return new BaseQueryBuilder({\n ...builder.query,\n select: undefined, // remove the select clause if it exists\n fnSelect: callback,\n }) as any\n },\n /**\n * Filter rows using a function that operates on each row\n * Warning: This cannot be optimized by the query compiler\n *\n * @param callback - A function that receives a row and returns a boolean\n * @returns A QueryBuilder with functional filtering applied\n *\n * @example\n * ```ts\n * // Functional where (not optimized)\n * query\n * .from({ users: usersCollection })\n * .fn.where(row => row.users.name.startsWith('A'))\n * ```\n */\n where(\n callback: (row: TContext[`schema`]) => any,\n ): QueryBuilder {\n return new BaseQueryBuilder({\n ...builder.query,\n fnWhere: [\n ...(builder.query.fnWhere || []),\n callback as (row: NamespacedRow) => any,\n ],\n })\n },\n /**\n * Filter grouped rows using a function that operates on each aggregated row\n * Warning: This cannot be optimized by the query compiler\n *\n * @param callback - A function that receives an aggregated row (with $selected when select() was called) and returns a boolean\n * @returns A QueryBuilder with functional having filter applied\n *\n * @example\n * ```ts\n * // Functional having (not optimized)\n * query\n * .from({ posts: postsCollection })\n * .groupBy(({posts}) => posts.userId)\n * .select(({posts}) => ({ userId: posts.userId, count: count(posts.id) }))\n * .fn.having(({ $selected }) => $selected.count > 5)\n * ```\n */\n having(\n callback: (row: FunctionalHavingRow) => any,\n ): QueryBuilder {\n return new BaseQueryBuilder({\n ...builder.query,\n fnHaving: [\n ...(builder.query.fnHaving || []),\n callback as (row: NamespacedRow) => any,\n ],\n })\n },\n }\n }\n\n _getQuery(): QueryIR {\n if (!this.query.from) {\n throw new QueryMustHaveFromClauseError()\n }\n return this.query as QueryIR\n }\n}\n\n// Helper to get a descriptive type name for error messages\nfunction getValueTypeName(value: unknown): string {\n if (value === null) return `null`\n if (value === undefined) return `undefined`\n if (typeof value === `object`) return `object`\n return typeof value\n}\n\n// Helper to ensure we have a BasicExpression/Aggregate for a value\nfunction toExpr(value: any): BasicExpression | Aggregate {\n if (value === undefined) return toExpression(null)\n if (\n value instanceof AggregateExpr ||\n value instanceof FuncExpr ||\n value instanceof PropRef ||\n value instanceof ValueExpr\n ) {\n return value as BasicExpression | Aggregate\n }\n return toExpression(value)\n}\n\nfunction isPlainObject(value: any): value is Record {\n return (\n value !== null &&\n typeof value === `object` &&\n !isExpressionLike(value) &&\n !value.__refProxy\n )\n}\n\nfunction buildNestedSelect(obj: any, parentAliases: Array = []): any {\n if (!isPlainObject(obj)) return toExpr(obj)\n const out: Record = {}\n for (const [k, v] of Object.entries(obj)) {\n if (typeof k === `string` && k.startsWith(`__SPREAD_SENTINEL__`)) {\n // Preserve sentinel key and its value (value is unimportant at compile time)\n out[k] = v\n continue\n }\n if (v instanceof BaseQueryBuilder) {\n out[k] = buildIncludesSubquery(v, k, parentAliases, `collection`)\n continue\n }\n if (v instanceof ToArrayWrapper) {\n if (!(v.query instanceof BaseQueryBuilder)) {\n throw new Error(`toArray() must wrap a subquery builder`)\n }\n out[k] = buildIncludesSubquery(v.query, k, parentAliases, `array`)\n continue\n }\n if (v instanceof ConcatToArrayWrapper) {\n if (!(v.query instanceof BaseQueryBuilder)) {\n throw new Error(`concat(toArray(...)) must wrap a subquery builder`)\n }\n out[k] = buildIncludesSubquery(v.query, k, parentAliases, `concat`)\n continue\n }\n out[k] = buildNestedSelect(v, parentAliases)\n }\n return out\n}\n\n/**\n * Recursively collects all PropRef nodes from an expression tree.\n */\nfunction collectRefsFromExpression(expr: BasicExpression): Array {\n const refs: Array = []\n switch (expr.type) {\n case `ref`:\n refs.push(expr)\n break\n case `func`:\n for (const arg of (expr as any).args ?? []) {\n refs.push(...collectRefsFromExpression(arg))\n }\n break\n default:\n break\n }\n return refs\n}\n\n/**\n * Checks whether a WHERE clause references any parent alias.\n */\nfunction referencesParent(where: Where, parentAliases: Array): boolean {\n const expr =\n typeof where === `object` && `expression` in where\n ? where.expression\n : where\n return collectRefsFromExpression(expr).some(\n (ref) => ref.path[0] != null && parentAliases.includes(ref.path[0]),\n )\n}\n\n/**\n * Builds an IncludesSubquery IR node from a child query builder.\n * Extracts the correlation condition from the child's WHERE clauses by finding\n * an eq() predicate that references both a parent alias and a child alias.\n */\nfunction buildIncludesSubquery(\n childBuilder: BaseQueryBuilder,\n fieldName: string,\n parentAliases: Array,\n materialization: IncludesMaterialization,\n): IncludesSubquery {\n const childQuery = childBuilder._getQuery()\n\n // Collect child's own aliases\n const childAliases: Array = [childQuery.from.alias]\n if (childQuery.join) {\n for (const j of childQuery.join) {\n childAliases.push(j.from.alias)\n }\n }\n\n // Walk child's WHERE clauses to find the correlation condition.\n // The correlation eq() may be a standalone WHERE or nested inside a top-level and().\n let parentRef: PropRef | undefined\n let childRef: PropRef | undefined\n let correlationWhereIndex = -1\n let correlationAndArgIndex = -1 // >= 0 when found inside an and()\n\n if (childQuery.where) {\n for (let i = 0; i < childQuery.where.length; i++) {\n const where = childQuery.where[i]!\n const expr =\n typeof where === `object` && `expression` in where\n ? where.expression\n : where\n\n // Try standalone eq()\n if (\n expr.type === `func` &&\n expr.name === `eq` &&\n expr.args.length === 2\n ) {\n const result = extractCorrelation(\n expr.args[0]!,\n expr.args[1]!,\n parentAliases,\n childAliases,\n )\n if (result) {\n parentRef = result.parentRef\n childRef = result.childRef\n correlationWhereIndex = i\n break\n }\n }\n\n // Try inside top-level and()\n if (\n expr.type === `func` &&\n expr.name === `and` &&\n expr.args.length >= 2\n ) {\n for (let j = 0; j < expr.args.length; j++) {\n const arg = expr.args[j]!\n if (\n arg.type === `func` &&\n arg.name === `eq` &&\n arg.args.length === 2\n ) {\n const result = extractCorrelation(\n arg.args[0]!,\n arg.args[1]!,\n parentAliases,\n childAliases,\n )\n if (result) {\n parentRef = result.parentRef\n childRef = result.childRef\n correlationWhereIndex = i\n correlationAndArgIndex = j\n break\n }\n }\n }\n if (parentRef) break\n }\n }\n }\n\n if (!parentRef || !childRef || correlationWhereIndex === -1) {\n throw new Error(\n `Includes subquery for \"${fieldName}\" must have a WHERE clause with an eq() condition ` +\n `that correlates a parent field with a child field. ` +\n `Example: .where(({child}) => eq(child.parentId, parent.id))`,\n )\n }\n\n // Remove the correlation eq() from the child query's WHERE clauses.\n // If it was inside an and(), remove just that arg (collapsing the and() if needed).\n const modifiedWhere = [...childQuery.where!]\n if (correlationAndArgIndex >= 0) {\n const where = modifiedWhere[correlationWhereIndex]!\n const expr =\n typeof where === `object` && `expression` in where\n ? where.expression\n : where\n const remainingArgs = (expr as any).args.filter(\n (_: any, idx: number) => idx !== correlationAndArgIndex,\n )\n if (remainingArgs.length === 1) {\n // Collapse and() with single remaining arg to just that expression\n const isResidual =\n typeof where === `object` && `expression` in where && where.residual\n modifiedWhere[correlationWhereIndex] = isResidual\n ? { expression: remainingArgs[0], residual: true }\n : remainingArgs[0]\n } else {\n // Rebuild and() without the extracted arg\n const newAnd = new FuncExpr(`and`, remainingArgs)\n const isResidual =\n typeof where === `object` && `expression` in where && where.residual\n modifiedWhere[correlationWhereIndex] = isResidual\n ? { expression: newAnd, residual: true }\n : newAnd\n }\n } else {\n modifiedWhere.splice(correlationWhereIndex, 1)\n }\n\n // Separate remaining WHEREs into pure-child vs parent-referencing\n const pureChildWhere: Array = []\n const parentFilters: Array = []\n for (const w of modifiedWhere) {\n if (referencesParent(w, parentAliases)) {\n parentFilters.push(w)\n } else {\n pureChildWhere.push(w)\n }\n }\n\n // Collect distinct parent PropRefs from parent-referencing filters\n let parentProjection: Array | undefined\n if (parentFilters.length > 0) {\n const seen = new Set()\n parentProjection = []\n for (const w of parentFilters) {\n const expr = typeof w === `object` && `expression` in w ? w.expression : w\n for (const ref of collectRefsFromExpression(expr)) {\n if (\n ref.path[0] != null &&\n parentAliases.includes(ref.path[0]) &&\n !seen.has(ref.path.join(`.`))\n ) {\n seen.add(ref.path.join(`.`))\n parentProjection.push(ref)\n }\n }\n }\n }\n\n const modifiedQuery: QueryIR = {\n ...childQuery,\n where: pureChildWhere.length > 0 ? pureChildWhere : undefined,\n }\n\n const rawChildSelect = modifiedQuery.select as any\n const hasObjectSelect =\n rawChildSelect === undefined || isPlainObject(rawChildSelect)\n let includesQuery = modifiedQuery\n let scalarField: string | undefined\n\n if (materialization === `concat`) {\n if (rawChildSelect === undefined || hasObjectSelect) {\n throw new Error(\n `concat(toArray(...)) for \"${fieldName}\" requires the subquery to select a scalar value`,\n )\n }\n }\n\n if (!hasObjectSelect) {\n if (materialization === `collection`) {\n throw new Error(\n `Includes subquery for \"${fieldName}\" must select an object when materializing as a Collection`,\n )\n }\n\n scalarField = INCLUDES_SCALAR_FIELD\n includesQuery = {\n ...modifiedQuery,\n select: {\n [scalarField]: rawChildSelect,\n },\n }\n }\n\n return new IncludesSubquery(\n includesQuery,\n parentRef,\n childRef,\n fieldName,\n parentFilters.length > 0 ? parentFilters : undefined,\n parentProjection,\n materialization,\n scalarField,\n )\n}\n\n/**\n * Checks if two eq() arguments form a parent-child correlation.\n * Returns the parent and child PropRefs if found, undefined otherwise.\n */\nfunction extractCorrelation(\n argA: BasicExpression,\n argB: BasicExpression,\n parentAliases: Array,\n childAliases: Array,\n): { parentRef: PropRef; childRef: PropRef } | undefined {\n if (argA.type === `ref` && argB.type === `ref`) {\n const aAlias = argA.path[0]\n const bAlias = argB.path[0]\n\n if (\n aAlias &&\n bAlias &&\n parentAliases.includes(aAlias) &&\n childAliases.includes(bAlias)\n ) {\n return { parentRef: argA, childRef: argB }\n }\n\n if (\n aAlias &&\n bAlias &&\n parentAliases.includes(bAlias) &&\n childAliases.includes(aAlias)\n ) {\n return { parentRef: argB, childRef: argA }\n }\n }\n\n return undefined\n}\n\n// Internal function to build a query from a callback\n// used by liveQueryCollectionOptions.query\nexport function buildQuery(\n fn: (builder: InitialQueryBuilder) => QueryBuilder,\n): QueryIR {\n const result = fn(new BaseQueryBuilder())\n return getQueryIR(result)\n}\n\n// Internal function to get the QueryIR from a builder\nexport function getQueryIR(\n builder: BaseQueryBuilder | QueryBuilder | InitialQueryBuilder,\n): QueryIR {\n return (builder as unknown as BaseQueryBuilder)._getQuery()\n}\n\n// Type-only exports for the query builder\nexport type InitialQueryBuilder = Pick, `from`>\n\nexport type InitialQueryBuilderConstructor = new () => InitialQueryBuilder\n\nexport type QueryBuilder = Omit<\n BaseQueryBuilder,\n `from` | `_getQuery`\n>\n\n// Main query builder class alias with the constructor type modified to hide all\n// but the from method on the initial instance\nexport const Query: InitialQueryBuilderConstructor = BaseQueryBuilder\n\n// Helper type to extract context from a QueryBuilder\nexport type ExtractContext =\n T extends BaseQueryBuilder\n ? TContext\n : T extends QueryBuilder\n ? TContext\n : never\n\n// Helper type to extract the result type from a QueryBuilder (similar to Zod's z.infer)\nexport type QueryResult = GetResult>\n\n// Export the types from types.ts for convenience\nexport type {\n Context,\n ContextSchema,\n Source,\n GetResult,\n RefLeaf as Ref,\n InferResultType,\n // Types used in public method signatures that must be exported\n // for declaration emit to work (see https://github.com/TanStack/db/issues/1012)\n SchemaFromSource,\n InferCollectionType,\n MergeContextWithJoinType,\n MergeContextForJoinCallback,\n ApplyJoinOptionalityToMergedSchema,\n ResultTypeFromSelect,\n WithResult,\n JoinOnCallback,\n RefsForContext,\n WhereCallback,\n OrderByCallback,\n GroupByCallback,\n SelectObject,\n FunctionalHavingRow,\n Prettify,\n} from './types.js'\n"],"names":["InvalidSourceTypeError","OnlyOneSourceAllowedError","CollectionImpl","CollectionRef","SubQueryMustHaveFromClauseError","QueryRef","InvalidSourceError","refProxy","createRefProxy","JoinConditionMustBeEqualityError","isRefProxy","toExpression","isExpressionLike","InvalidWhereExpressionError","createRefProxyWithSelected","QueryMustHaveFromClauseError","AggregateExpr","FuncExpr","PropRef","ValueExpr","ToArrayWrapper","ConcatToArrayWrapper","INCLUDES_SCALAR_FIELD","IncludesSubquery"],"mappings":"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"}