@tanstack/db 0.0.13 → 0.0.15

package/dist/cjs/query/builder/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../../../../src/query/builder/index.ts"],"sourcesContent":["import { CollectionImpl } from \"../../collection.js\"\nimport { CollectionRef, QueryRef } from \"../ir.js\"\nimport { createRefProxy, isRefProxy, toExpression } from \"./ref-proxy.js\"\nimport type { NamespacedRow } from \"../../types.js\"\nimport type {\n  Aggregate,\n  BasicExpression,\n  JoinClause,\n  OrderBy,\n  OrderByClause,\n  OrderByDirection,\n  QueryIR,\n} from \"../ir.js\"\nimport type {\n  Context,\n  GroupByCallback,\n  JoinOnCallback,\n  MergeContext,\n  MergeContextWithJoinType,\n  OrderByCallback,\n  RefProxyForContext,\n  ResultTypeFromSelect,\n  SchemaFromSource,\n  SelectObject,\n  Source,\n  WhereCallback,\n  WithResult,\n} from \"./types.js\"\n\nexport class BaseQueryBuilder<TContext extends Context = Context> {\n  private readonly query: Partial<QueryIR> = {}\n\n  constructor(query: Partial<QueryIR> = {}) {\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<TSource extends Source>(\n    source: TSource,\n    context: string\n  ): [string, CollectionRef | QueryRef] {\n    if (Object.keys(source).length !== 1) {\n      throw new Error(`Only one source is allowed in the ${context}`)\n    }\n\n    const alias = Object.keys(source)[0]!\n    const sourceValue = source[alias]\n\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<QueryIR>).from) {\n        throw new Error(\n          `A sub query passed to a ${context} must have a from clause itself`\n        )\n      }\n      ref = new QueryRef(subQuery, alias)\n    } else {\n      throw new Error(`Invalid source`)\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<TSource extends Source>(\n    source: TSource\n  ): QueryBuilder<{\n    baseSchema: SchemaFromSource<TSource>\n    schema: SchemaFromSource<TSource>\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      MergeContext<TContext, SchemaFromSource<TSource>>\n    >,\n    type: TJoinType = `left` as TJoinType\n  ): QueryBuilder<\n    MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, 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 RefProxyForContext<\n      MergeContext<TContext, SchemaFromSource<TSource>>\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 Error(`Join condition must be an equality expression`)\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   * 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<TContext>): QueryBuilder<TContext> {\n    const aliases = this._getCurrentAliases()\n    const refProxy = createRefProxy(aliases) as RefProxyForContext<TContext>\n    const expression = callback(refProxy)\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<TContext>): QueryBuilder<TContext> {\n    const aliases = this._getCurrentAliases()\n    const refProxy = createRefProxy(aliases) as RefProxyForContext<TContext>\n    const expression = callback(refProxy)\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<TSelectObject extends SelectObject>(\n    callback: (refs: RefProxyForContext<TContext>) => TSelectObject\n  ): QueryBuilder<WithResult<TContext, ResultTypeFromSelect<TSelectObject>>> {\n    const aliases = this._getCurrentAliases()\n    const refProxy = createRefProxy(aliases) as RefProxyForContext<TContext>\n    const selectObject = callback(refProxy)\n\n    // Check if any tables were spread during the callback\n    const spreadSentinels = (refProxy as any).__spreadSentinels as Set<string>\n\n    // Convert the select object to use expressions, including spread sentinels\n    const select: Record<string, BasicExpression | Aggregate> = {}\n\n    // First, add spread sentinels for any tables that were spread\n    for (const spreadAlias of spreadSentinels) {\n      const sentinelKey = `__SPREAD_SENTINEL__${spreadAlias}`\n      select[sentinelKey] = toExpression(spreadAlias) // Use alias as a simple reference\n    }\n\n    // Then add the explicit select fields\n    for (const [key, value] of Object.entries(selectObject)) {\n      if (isRefProxy(value)) {\n        select[key] = toExpression(value)\n      } else if (\n        typeof value === `object` &&\n        `type` in value &&\n        (value.type === `agg` || value.type === `func`)\n      ) {\n        select[key] = value as BasicExpression | Aggregate\n      } else {\n        select[key] = toExpression(value)\n      }\n    }\n\n    return new BaseQueryBuilder({\n      ...this.query,\n      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<TContext>,\n    direction: OrderByDirection = `asc`\n  ): QueryBuilder<TContext> {\n    const aliases = this._getCurrentAliases()\n    const refProxy = createRefProxy(aliases) as RefProxyForContext<TContext>\n    const result = callback(refProxy)\n\n    // Create the new OrderBy structure with expression and direction\n    const orderByClause: OrderByClause = {\n      expression: toExpression(result),\n      direction,\n    }\n\n    const existingOrderBy: OrderBy = this.query.orderBy || []\n\n    return new BaseQueryBuilder({\n      ...this.query,\n      orderBy: [...existingOrderBy, orderByClause],\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<TContext>): QueryBuilder<TContext> {\n    const aliases = this._getCurrentAliases()\n    const refProxy = createRefProxy(aliases) as RefProxyForContext<TContext>\n    const result = callback(refProxy)\n\n    const newExpressions = Array.isArray(result)\n      ? result.map((r) => toExpression(r))\n      : [toExpression(result)]\n\n    // Replace existing groupBy expressions instead of extending them\n    return new BaseQueryBuilder({\n      ...this.query,\n      groupBy: 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<TContext> {\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<TContext> {\n    return new BaseQueryBuilder({\n      ...this.query,\n      offset: count,\n    }) as any\n  }\n\n  // Helper methods\n  private _getCurrentAliases(): Array<string> {\n    const aliases: Array<string> = []\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<TFuncSelectResult>(\n        callback: (row: TContext[`schema`]) => TFuncSelectResult\n      ): QueryBuilder<WithResult<TContext, TFuncSelectResult>> {\n        return new BaseQueryBuilder({\n          ...builder.query,\n          select: undefined, // remove the select clause if it exists\n          fnSelect: callback,\n        })\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<TContext> {\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 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       *   .fn.having(row => row.count > 5)\n       * ```\n       */\n      having(\n        callback: (row: TContext[`schema`]) => any\n      ): QueryBuilder<TContext> {\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 Error(`Query must have a from clause`)\n    }\n    return this.query as QueryIR\n  }\n}\n\n// Internal function to build a query from a callback\n// used by liveQueryCollectionOptions.query\nexport function buildQuery<TContext extends Context>(\n  fn: (builder: InitialQueryBuilder) => QueryBuilder<TContext>\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<any> | 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<BaseQueryBuilder<Context>, `from`>\n\nexport type InitialQueryBuilderConstructor = new () => InitialQueryBuilder\n\nexport type QueryBuilder<TContext extends Context> = Omit<\n  BaseQueryBuilder<TContext>,\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<T> =\n  T extends BaseQueryBuilder<infer TContext>\n    ? TContext\n    : T extends QueryBuilder<infer TContext>\n      ? TContext\n      : never\n\n// Export the types from types.ts for convenience\nexport type { Context, Source, GetResult } from \"./types.js\"\n"],"names":["CollectionImpl","CollectionRef","QueryRef","refProxy","createRefProxy","toExpression","isRefProxy"],"mappings":"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"}

package/dist/cjs/query/builder/index.d.cts

@@ -0,0 +1,324 @@
+import { OrderByDirection, QueryIR } from '../ir.js';
+import { Context, GroupByCallback, JoinOnCallback, MergeContext, MergeContextWithJoinType, OrderByCallback, RefProxyForContext, ResultTypeFromSelect, SchemaFromSource, SelectObject, Source, WhereCallback, WithResult } from './types.js';
+export declare class BaseQueryBuilder<TContext extends Context = Context> {
+    private readonly query;
+    constructor(query?: Partial<QueryIR>);
+    /**
+     * Creates a CollectionRef or QueryRef from a source object
+     * @param source - An object with a single key-value pair
+     * @param context - Context string for error messages (e.g., "from clause", "join clause")
+     * @returns A tuple of [alias, ref] where alias is the source key and ref is the created reference
+     */
+    private _createRefForSource;
+    /**
+     * Specify the source table or subquery for the query
+     *
+     * @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
+     * @returns A QueryBuilder with the specified source
+     *
+     * @example
+     * ```ts
+     * // Query from a collection
+     * query.from({ users: usersCollection })
+     *
+     * // Query from a subquery
+     * const activeUsers = query.from({ u: usersCollection }).where(({u}) => u.active)
+     * query.from({ activeUsers })
+     * ```
+     */
+    from<TSource extends Source>(source: TSource): QueryBuilder<{
+        baseSchema: SchemaFromSource<TSource>;
+        schema: SchemaFromSource<TSource>;
+        fromSourceName: keyof TSource & string;
+        hasJoins: false;
+    }>;
+    /**
+     * Join another table or subquery to the current query
+     *
+     * @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
+     * @param onCallback - A function that receives table references and returns the join condition
+     * @param type - The type of join: 'inner', 'left', 'right', or 'full' (defaults to 'left')
+     * @returns A QueryBuilder with the joined table available
+     *
+     * @example
+     * ```ts
+     * // Left join users with posts
+     * query
+     *   .from({ users: usersCollection })
+     *   .join({ posts: postsCollection }, ({users, posts}) => eq(users.id, posts.userId))
+     *
+     * // Inner join with explicit type
+     * query
+     *   .from({ u: usersCollection })
+     *   .join({ p: postsCollection }, ({u, p}) => eq(u.id, p.userId), 'inner')
+     * ```
+     *
+     * // Join with a subquery
+     * const activeUsers = query.from({ u: usersCollection }).where(({u}) => u.active)
+     * query
+     *   .from({ activeUsers })
+     *   .join({ p: postsCollection }, ({u, p}) => eq(u.id, p.userId))
+     */
+    join<TSource extends Source, TJoinType extends `inner` | `left` | `right` | `full` = `left`>(source: TSource, onCallback: JoinOnCallback<MergeContext<TContext, SchemaFromSource<TSource>>>, type?: TJoinType): QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, TJoinType>>;
+    /**
+     * Filter rows based on a condition
+     *
+     * @param callback - A function that receives table references and returns an expression
+     * @returns A QueryBuilder with the where condition applied
+     *
+     * @example
+     * ```ts
+     * // Simple condition
+     * query
+     *   .from({ users: usersCollection })
+     *   .where(({users}) => gt(users.age, 18))
+     *
+     * // Multiple conditions
+     * query
+     *   .from({ users: usersCollection })
+     *   .where(({users}) => and(
+     *     gt(users.age, 18),
+     *     eq(users.active, true)
+     *   ))
+     *
+     * // Multiple where calls are ANDed together
+     * query
+     *   .from({ users: usersCollection })
+     *   .where(({users}) => gt(users.age, 18))
+     *   .where(({users}) => eq(users.active, true))
+     * ```
+     */
+    where(callback: WhereCallback<TContext>): QueryBuilder<TContext>;
+    /**
+     * 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({ posts: postsCollection })
+     *   .groupBy(({posts}) => posts.userId)
+     *   .having(({posts}) => gt(count(posts.id), 5))
+     *
+     * // Filter by average
+     * query
+     *   .from({ orders: ordersCollection })
+     *   .groupBy(({orders}) => orders.customerId)
+     *   .having(({orders}) => gt(avg(orders.total), 100))
+     *
+     * // Multiple having calls are ANDed together
+     * query
+     *   .from({ orders: ordersCollection })
+     *   .groupBy(({orders}) => orders.customerId)
+     *   .having(({orders}) => gt(count(orders.id), 5))
+     *   .having(({orders}) => gt(avg(orders.total), 100))
+     * ```
+     */
+    having(callback: WhereCallback<TContext>): QueryBuilder<TContext>;
+    /**
+     * Select specific columns or computed values from the query
+     *
+     * @param callback - A function that receives table references and returns an object with selected fields or expressions
+     * @returns A QueryBuilder that returns only the selected fields
+     *
+     * @example
+     * ```ts
+     * // Select specific columns
+     * query
+     *   .from({ users: usersCollection })
+     *   .select(({users}) => ({
+     *     name: users.name,
+     *     email: users.email
+     *   }))
+     *
+     * // Select with computed values
+     * query
+     *   .from({ users: usersCollection })
+     *   .select(({users}) => ({
+     *     fullName: concat(users.firstName, ' ', users.lastName),
+     *     ageInMonths: mul(users.age, 12)
+     *   }))
+     *
+     * // Select with aggregates (requires GROUP BY)
+     * query
+     *   .from({ posts: postsCollection })
+     *   .groupBy(({posts}) => posts.userId)
+     *   .select(({posts, count}) => ({
+     *     userId: posts.userId,
+     *     postCount: count(posts.id)
+     *   }))
+     * ```
+     */
+    select<TSelectObject extends SelectObject>(callback: (refs: RefProxyForContext<TContext>) => TSelectObject): QueryBuilder<WithResult<TContext, ResultTypeFromSelect<TSelectObject>>>;
+    /**
+     * Sort the query results by one or more columns
+     *
+     * @param callback - A function that receives table references and returns the field to sort by
+     * @param direction - Sort direction: 'asc' for ascending, 'desc' for descending (defaults to 'asc')
+     * @returns A QueryBuilder with the ordering applied
+     *
+     * @example
+     * ```ts
+     * // Sort by a single column
+     * query
+     *   .from({ users: usersCollection })
+     *   .orderBy(({users}) => users.name)
+     *
+     * // Sort descending
+     * query
+     *   .from({ users: usersCollection })
+     *   .orderBy(({users}) => users.createdAt, 'desc')
+     *
+     * // Multiple sorts (chain orderBy calls)
+     * query
+     *   .from({ users: usersCollection })
+     *   .orderBy(({users}) => users.lastName)
+     *   .orderBy(({users}) => users.firstName)
+     * ```
+     */
+    orderBy(callback: OrderByCallback<TContext>, direction?: OrderByDirection): QueryBuilder<TContext>;
+    /**
+     * Group rows by one or more columns for aggregation
+     *
+     * @param callback - A function that receives table references and returns the field(s) to group by
+     * @returns A QueryBuilder with grouping applied (enables aggregate functions in SELECT and HAVING)
+     *
+     * @example
+     * ```ts
+     * // Group by a single column
+     * query
+     *   .from({ posts: postsCollection })
+     *   .groupBy(({posts}) => posts.userId)
+     *   .select(({posts, count}) => ({
+     *     userId: posts.userId,
+     *     postCount: count()
+     *   }))
+     *
+     * // Group by multiple columns
+     * query
+     *   .from({ sales: salesCollection })
+     *   .groupBy(({sales}) => [sales.region, sales.category])
+     *   .select(({sales, sum}) => ({
+     *     region: sales.region,
+     *     category: sales.category,
+     *     totalSales: sum(sales.amount)
+     *   }))
+     * ```
+     */
+    groupBy(callback: GroupByCallback<TContext>): QueryBuilder<TContext>;
+    /**
+     * Limit the number of rows returned by the query
+     * `orderBy` is required for `limit`
+     *
+     * @param count - Maximum number of rows to return
+     * @returns A QueryBuilder with the limit applied
+     *
+     * @example
+     * ```ts
+     * // Get top 5 posts by likes
+     * query
+     *   .from({ posts: postsCollection })
+     *   .orderBy(({posts}) => posts.likes, 'desc')
+     *   .limit(5)
+     * ```
+     */
+    limit(count: number): QueryBuilder<TContext>;
+    /**
+     * Skip a number of rows before returning results
+     * `orderBy` is required for `offset`
+     *
+     * @param count - Number of rows to skip
+     * @returns A QueryBuilder with the offset applied
+     *
+     * @example
+     * ```ts
+     * // Get second page of results
+     * query
+     *   .from({ posts: postsCollection })
+     *   .orderBy(({posts}) => posts.createdAt, 'desc')
+     *   .offset(page * pageSize)
+     *   .limit(pageSize)
+     * ```
+     */
+    offset(count: number): QueryBuilder<TContext>;
+    private _getCurrentAliases;
+    /**
+     * Functional variants of the query builder
+     * These are imperative function that are called for ery row.
+     * Warning: that these cannot be optimized by the query compiler, and may prevent
+     * some type of optimizations being possible.
+     * @example
+     * ```ts
+     * q.fn.select((row) => ({
+     *   name: row.user.name.toUpperCase(),
+     *   age: row.user.age + 1,
+     * }))
+     * ```
+     */
+    get fn(): {
+        /**
+         * Select fields using a function that operates on each row
+         * Warning: This cannot be optimized by the query compiler
+         *
+         * @param callback - A function that receives a row and returns the selected value
+         * @returns A QueryBuilder with functional selection applied
+         *
+         * @example
+         * ```ts
+         * // Functional select (not optimized)
+         * query
+         *   .from({ users: usersCollection })
+         *   .fn.select(row => ({
+         *     name: row.users.name.toUpperCase(),
+         *     age: row.users.age + 1,
+         *   }))
+         * ```
+         */
+        select<TFuncSelectResult>(callback: (row: TContext[`schema`]) => TFuncSelectResult): QueryBuilder<WithResult<TContext, TFuncSelectResult>>;
+        /**
+         * Filter rows using a function that operates on each row
+         * Warning: This cannot be optimized by the query compiler
+         *
+         * @param callback - A function that receives a row and returns a boolean
+         * @returns A QueryBuilder with functional filtering applied
+         *
+         * @example
+         * ```ts
+         * // Functional where (not optimized)
+         * query
+         *   .from({ users: usersCollection })
+         *   .fn.where(row => row.users.name.startsWith('A'))
+         * ```
+         */
+        where(callback: (row: TContext[`schema`]) => any): QueryBuilder<TContext>;
+        /**
+         * Filter grouped rows using a function that operates on each aggregated row
+         * Warning: This cannot be optimized by the query compiler
+         *
+         * @param callback - A function that receives an aggregated row and returns a boolean
+         * @returns A QueryBuilder with functional having filter applied
+         *
+         * @example
+         * ```ts
+         * // Functional having (not optimized)
+         * query
+         *   .from({ posts: postsCollection })
+         *   .groupBy(({posts}) => posts.userId)
+         *   .fn.having(row => row.count > 5)
+         * ```
+         */
+        having(callback: (row: TContext[`schema`]) => any): QueryBuilder<TContext>;
+    };
+    _getQuery(): QueryIR;
+}
+export declare function buildQuery<TContext extends Context>(fn: (builder: InitialQueryBuilder) => QueryBuilder<TContext>): QueryIR;
+export declare function getQueryIR(builder: BaseQueryBuilder | QueryBuilder<any> | InitialQueryBuilder): QueryIR;
+export type InitialQueryBuilder = Pick<BaseQueryBuilder<Context>, `from`>;
+export type InitialQueryBuilderConstructor = new () => InitialQueryBuilder;
+export type QueryBuilder<TContext extends Context> = Omit<BaseQueryBuilder<TContext>, `from` | `_getQuery`>;
+export declare const Query: InitialQueryBuilderConstructor;
+export type ExtractContext<T> = T extends BaseQueryBuilder<infer TContext> ? TContext : T extends QueryBuilder<infer TContext> ? TContext : never;
+export type { Context, Source, GetResult } from './types.js';

package/dist/cjs/query/builder/ref-proxy.cjs

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ir = require("../ir.cjs");
+function createRefProxy(aliases) {
+  const cache = /* @__PURE__ */ new Map();
+  const spreadSentinels = /* @__PURE__ */ new Set();
+  function createProxy(path) {
+    const pathKey = path.join(`.`);
+    if (cache.has(pathKey)) {
+      return cache.get(pathKey);
+    }
+    const proxy = new Proxy({}, {
+      get(target, prop, receiver) {
+        if (prop === `__refProxy`) return true;
+        if (prop === `__path`) return path;
+        if (prop === `__type`) return void 0;
+        if (typeof prop === `symbol`) return Reflect.get(target, prop, receiver);
+        const newPath = [...path, String(prop)];
+        return createProxy(newPath);
+      },
+      has(target, prop) {
+        if (prop === `__refProxy` || prop === `__path` || prop === `__type`)
+          return true;
+        return Reflect.has(target, prop);
+      },
+      ownKeys(target) {
+        if (path.length === 1) {
+          const aliasName = path[0];
+          spreadSentinels.add(aliasName);
+        }
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        if (prop === `__refProxy` || prop === `__path` || prop === `__type`) {
+          return { enumerable: false, configurable: true };
+        }
+        return Reflect.getOwnPropertyDescriptor(target, prop);
+      }
+    });
+    cache.set(pathKey, proxy);
+    return proxy;
+  }
+  const rootProxy = new Proxy({}, {
+    get(target, prop, receiver) {
+      if (prop === `__refProxy`) return true;
+      if (prop === `__path`) return [];
+      if (prop === `__type`) return void 0;
+      if (prop === `__spreadSentinels`) return spreadSentinels;
+      if (typeof prop === `symbol`) return Reflect.get(target, prop, receiver);
+      const propStr = String(prop);
+      if (aliases.includes(propStr)) {
+        return createProxy([propStr]);
+      }
+      return void 0;
+    },
+    has(target, prop) {
+      if (prop === `__refProxy` || prop === `__path` || prop === `__type` || prop === `__spreadSentinels`)
+        return true;
+      if (typeof prop === `string` && aliases.includes(prop)) return true;
+      return Reflect.has(target, prop);
+    },
+    ownKeys(_target) {
+      return [...aliases, `__refProxy`, `__path`, `__type`, `__spreadSentinels`];
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      if (prop === `__refProxy` || prop === `__path` || prop === `__type` || prop === `__spreadSentinels`) {
+        return { enumerable: false, configurable: true };
+      }
+      if (typeof prop === `string` && aliases.includes(prop)) {
+        return { enumerable: true, configurable: true };
+      }
+      return void 0;
+    }
+  });
+  return rootProxy;
+}
+function toExpression(value) {
+  if (isRefProxy(value)) {
+    return new ir.Ref(value.__path);
+  }
+  if (value && typeof value === `object` && `type` in value && (value.type === `func` || value.type === `ref` || value.type === `val` || value.type === `agg`)) {
+    return value;
+  }
+  return new ir.Value(value);
+}
+function isRefProxy(value) {
+  return value && typeof value === `object` && value.__refProxy === true;
+}
+function val(value) {
+  return new ir.Value(value);
+}
+exports.createRefProxy = createRefProxy;
+exports.isRefProxy = isRefProxy;
+exports.toExpression = toExpression;
+exports.val = val;
+//# sourceMappingURL=ref-proxy.cjs.map

package/dist/cjs/query/builder/ref-proxy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref-proxy.cjs","sources":["../../../../src/query/builder/ref-proxy.ts"],"sourcesContent":["import { Ref, Value } from \"../ir.js\"\nimport type { BasicExpression } from \"../ir.js\"\n\nexport interface RefProxy<T = any> {\n  /** @internal */\n  readonly __refProxy: true\n  /** @internal */\n  readonly __path: Array<string>\n  /** @internal */\n  readonly __type: T\n}\n\n/**\n * Creates a proxy object that records property access paths\n * Used in callbacks like where, select, etc. to create type-safe references\n */\nexport function createRefProxy<T extends Record<string, any>>(\n  aliases: Array<string>\n): RefProxy<T> & T {\n  const cache = new Map<string, any>()\n  const spreadSentinels = new Set<string>() // Track which aliases have been spread\n\n  function createProxy(path: Array<string>): any {\n    const pathKey = path.join(`.`)\n    if (cache.has(pathKey)) {\n      return cache.get(pathKey)\n    }\n\n    const proxy = new Proxy({} as any, {\n      get(target, prop, receiver) {\n        if (prop === `__refProxy`) return true\n        if (prop === `__path`) return path\n        if (prop === `__type`) return undefined // Type is only for TypeScript inference\n        if (typeof prop === `symbol`) return Reflect.get(target, prop, receiver)\n\n        const newPath = [...path, String(prop)]\n        return createProxy(newPath)\n      },\n\n      has(target, prop) {\n        if (prop === `__refProxy` || prop === `__path` || prop === `__type`)\n          return true\n        return Reflect.has(target, prop)\n      },\n\n      ownKeys(target) {\n        // If this is a table-level proxy (path length 1), mark it as spread\n        if (path.length === 1) {\n          const aliasName = path[0]!\n          spreadSentinels.add(aliasName)\n        }\n        return Reflect.ownKeys(target)\n      },\n\n      getOwnPropertyDescriptor(target, prop) {\n        if (prop === `__refProxy` || prop === `__path` || prop === `__type`) {\n          return { enumerable: false, configurable: true }\n        }\n        return Reflect.getOwnPropertyDescriptor(target, prop)\n      },\n    })\n\n    cache.set(pathKey, proxy)\n    return proxy\n  }\n\n  // Create the root proxy with all aliases as top-level properties\n  const rootProxy = new Proxy({} as any, {\n    get(target, prop, receiver) {\n      if (prop === `__refProxy`) return true\n      if (prop === `__path`) return []\n      if (prop === `__type`) return undefined // Type is only for TypeScript inference\n      if (prop === `__spreadSentinels`) return spreadSentinels // Expose spread sentinels\n      if (typeof prop === `symbol`) return Reflect.get(target, prop, receiver)\n\n      const propStr = String(prop)\n      if (aliases.includes(propStr)) {\n        return createProxy([propStr])\n      }\n\n      return undefined\n    },\n\n    has(target, prop) {\n      if (\n        prop === `__refProxy` ||\n        prop === `__path` ||\n        prop === `__type` ||\n        prop === `__spreadSentinels`\n      )\n        return true\n      if (typeof prop === `string` && aliases.includes(prop)) return true\n      return Reflect.has(target, prop)\n    },\n\n    ownKeys(_target) {\n      return [...aliases, `__refProxy`, `__path`, `__type`, `__spreadSentinels`]\n    },\n\n    getOwnPropertyDescriptor(target, prop) {\n      if (\n        prop === `__refProxy` ||\n        prop === `__path` ||\n        prop === `__type` ||\n        prop === `__spreadSentinels`\n      ) {\n        return { enumerable: false, configurable: true }\n      }\n      if (typeof prop === `string` && aliases.includes(prop)) {\n        return { enumerable: true, configurable: true }\n      }\n      return undefined\n    },\n  })\n\n  return rootProxy\n}\n\n/**\n * Converts a value to an Expression\n * If it's a RefProxy, creates a Ref, otherwise creates a Value\n */\nexport function toExpression<T = any>(value: T): BasicExpression<T>\nexport function toExpression(value: RefProxy<any>): BasicExpression<any>\nexport function toExpression(value: any): BasicExpression<any> {\n  if (isRefProxy(value)) {\n    return new Ref(value.__path)\n  }\n  // If it's already an Expression (Func, Ref, Value) or Agg, return it directly\n  if (\n    value &&\n    typeof value === `object` &&\n    `type` in value &&\n    (value.type === `func` ||\n      value.type === `ref` ||\n      value.type === `val` ||\n      value.type === `agg`)\n  ) {\n    return value\n  }\n  return new Value(value)\n}\n\n/**\n * Type guard to check if a value is a RefProxy\n */\nexport function isRefProxy(value: any): value is RefProxy {\n  return value && typeof value === `object` && value.__refProxy === true\n}\n\n/**\n * Helper to create a Value expression from a literal\n */\nexport function val<T>(value: T): BasicExpression<T> {\n  return new Value(value)\n}\n"],"names":["Ref","Value"],"mappings":"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"}

package/dist/cjs/query/builder/ref-proxy.d.cts

@@ -0,0 +1,28 @@
+import { BasicExpression } from '../ir.js';
+export interface RefProxy<T = any> {
+    /** @internal */
+    readonly __refProxy: true;
+    /** @internal */
+    readonly __path: Array<string>;
+    /** @internal */
+    readonly __type: T;
+}
+/**
+ * Creates a proxy object that records property access paths
+ * Used in callbacks like where, select, etc. to create type-safe references
+ */
+export declare function createRefProxy<T extends Record<string, any>>(aliases: Array<string>): RefProxy<T> & T;
+/**
+ * Converts a value to an Expression
+ * If it's a RefProxy, creates a Ref, otherwise creates a Value
+ */
+export declare function toExpression<T = any>(value: T): BasicExpression<T>;
+export declare function toExpression(value: RefProxy<any>): BasicExpression<any>;
+/**
+ * Type guard to check if a value is a RefProxy
+ */
+export declare function isRefProxy(value: any): value is RefProxy;
+/**
+ * Helper to create a Value expression from a literal
+ */
+export declare function val<T>(value: T): BasicExpression<T>;

package/dist/cjs/query/builder/types.d.cts

@@ -0,0 +1,80 @@
+import { CollectionImpl } from '../../collection.js';
+import { Aggregate, BasicExpression } from '../ir.js';
+import { QueryBuilder } from './index.js';
+export interface Context {
+    baseSchema: ContextSchema;
+    schema: ContextSchema;
+    fromSourceName: string;
+    hasJoins?: boolean;
+    joinTypes?: Record<string, `inner` | `left` | `right` | `full` | `outer` | `cross`>;
+    result?: any;
+}
+export type ContextSchema = Record<string, unknown>;
+export type Source = {
+    [alias: string]: CollectionImpl<any, any> | QueryBuilder<Context>;
+};
+export type InferCollectionType<T> = T extends CollectionImpl<infer U> ? U : never;
+export type SchemaFromSource<T extends Source> = Prettify<{
+    [K in keyof T]: T[K] extends CollectionImpl<infer U> ? U : T[K] extends QueryBuilder<infer TContext> ? GetResult<TContext> : never;
+}>;
+export type GetAliases<TContext extends Context> = keyof TContext[`schema`];
+export type WhereCallback<TContext extends Context> = (refs: RefProxyForContext<TContext>) => any;
+export type SelectObject<T extends Record<string, BasicExpression | Aggregate | RefProxy | RefProxyFor<any>> = Record<string, BasicExpression | Aggregate | RefProxy | RefProxyFor<any>>> = T;
+export type ResultTypeFromSelect<TSelectObject> = {
+    [K in keyof TSelectObject]: TSelectObject[K] extends RefProxy<infer T> ? T : TSelectObject[K] extends BasicExpression<infer T> ? T : TSelectObject[K] extends Aggregate<infer T> ? T : TSelectObject[K] extends RefProxyFor<infer T> ? T : never;
+};
+export type OrderByCallback<TContext extends Context> = (refs: RefProxyForContext<TContext>) => any;
+export type GroupByCallback<TContext extends Context> = (refs: RefProxyForContext<TContext>) => any;
+export type JoinOnCallback<TContext extends Context> = (refs: RefProxyForContext<TContext>) => any;
+export type RefProxyForContext<TContext extends Context> = {
+    [K in keyof TContext[`schema`]]: RefProxyFor<TContext[`schema`][K]>;
+};
+type IsExactlyUndefined<T> = [T] extends [undefined] ? true : false;
+type IsOptional<T> = undefined extends T ? true : false;
+type NonUndefined<T> = T extends undefined ? never : T;
+export type RefProxyFor<T> = OmitRefProxy<IsExactlyUndefined<T> extends true ? RefProxy<T> : IsOptional<T> extends true ? NonUndefined<T> extends Record<string, any> ? {
+    [K in keyof NonUndefined<T>]: NonUndefined<T>[K] extends Record<string, any> ? RefProxyFor<NonUndefined<T>[K] | undefined> & RefProxy<NonUndefined<T>[K] | undefined> : RefProxy<NonUndefined<T>[K] | undefined>;
+} & RefProxy<T> : RefProxy<T> : T extends Record<string, any> ? {
+    [K in keyof T]: T[K] extends Record<string, any> ? RefProxyFor<T[K]> & RefProxy<T[K]> : RefProxy<T[K]>;
+} & RefProxy<T> : RefProxy<T>>;
+type OmitRefProxy<T> = Omit<T, `__refProxy` | `__path` | `__type`>;
+export interface RefProxy<T = any> {
+    /** @internal */
+    readonly __refProxy: true;
+    /** @internal */
+    readonly __path: Array<string>;
+    /** @internal */
+    readonly __type: T;
+}
+export type MergeContextWithJoinType<TContext extends Context, TNewSchema extends ContextSchema, TJoinType extends `inner` | `left` | `right` | `full` | `outer` | `cross`> = {
+    baseSchema: TContext[`baseSchema`];
+    schema: ApplyJoinOptionalityToMergedSchema<TContext[`schema`], TNewSchema, TJoinType, TContext[`fromSourceName`]>;
+    fromSourceName: TContext[`fromSourceName`];
+    hasJoins: true;
+    joinTypes: (TContext[`joinTypes`] extends Record<string, any> ? TContext[`joinTypes`] : {}) & {
+        [K in keyof TNewSchema & string]: TJoinType;
+    };
+    result: TContext[`result`];
+};
+export type ApplyJoinOptionalityToMergedSchema<TExistingSchema extends ContextSchema, TNewSchema extends ContextSchema, TJoinType extends `inner` | `left` | `right` | `full` | `outer` | `cross`, TFromSourceName extends string> = {
+    [K in keyof TExistingSchema]: K extends TFromSourceName ? TJoinType extends `right` | `full` ? TExistingSchema[K] | undefined : TExistingSchema[K] : TExistingSchema[K];
+} & {
+    [K in keyof TNewSchema]: TJoinType extends `left` | `full` ? // New table becomes optional for left and full joins
+    TNewSchema[K] | undefined : TNewSchema[K];
+};
+export type GetResult<TContext extends Context> = Prettify<TContext[`result`] extends object ? TContext[`result`] : TContext[`hasJoins`] extends true ? TContext[`schema`] : TContext[`schema`][TContext[`fromSourceName`]]>;
+export type ApplyJoinOptionalityToSchema<TSchema extends ContextSchema, TJoinTypes extends Record<string, string>, TFromSourceName extends string> = {
+    [K in keyof TSchema]: K extends TFromSourceName ? HasJoinType<TJoinTypes, `right` | `full`> extends true ? TSchema[K] | undefined : TSchema[K] : K extends keyof TJoinTypes ? TJoinTypes[K] extends `left` | `full` ? TSchema[K] | undefined : IsTableMadeOptionalBySubsequentJoins<K, TJoinTypes, TFromSourceName> extends true ? TSchema[K] | undefined : TSchema[K] : TSchema[K];
+};
+type IsTableMadeOptionalBySubsequentJoins<TTableAlias extends string | number | symbol, TJoinTypes extends Record<string, string>, TFromSourceName extends string> = TTableAlias extends TFromSourceName ? HasJoinType<TJoinTypes, `right` | `full`> : false;
+export type HasJoinType<TJoinTypes extends Record<string, string>, TTargetTypes extends string> = true extends {
+    [K in keyof TJoinTypes]: TJoinTypes[K] extends TTargetTypes ? true : false;
+}[keyof TJoinTypes] ? true : false;
+export type MergeContext<TContext extends Context, TNewSchema extends ContextSchema> = MergeContextWithJoinType<TContext, TNewSchema, `left`>;
+export type WithResult<TContext extends Context, TResult> = Prettify<Omit<TContext, `result`> & {
+    result: Prettify<TResult>;
+}>;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export {};