@tanstack/db 0.1.11 → 0.2.0

package/src/query/builder/index.ts

@@ -1,5 +1,13 @@
 import { CollectionImpl } from "../../collection.js"
-import { CollectionRef, QueryRef } from "../ir.js"
+import {
+  Aggregate as AggregateExpr,
+  CollectionRef,
+  Func as FuncExpr,
+  PropRef,
+  QueryRef,
+  Value as ValueExpr,
+  isExpressionLike,
+} from "../ir.js"
 import {
   InvalidSourceError,
   JoinConditionMustBeEqualityError,
@@ -7,7 +15,7 @@ import {
   QueryMustHaveFromClauseError,
   SubQueryMustHaveFromClauseError,
 } from "../../errors.js"
-import { createRefProxy, isRefProxy, toExpression } from "./ref-proxy.js"
+import { createRefProxy, toExpression } from "./ref-proxy.js"
 import type { NamespacedRow } from "../../types.js"
 import type {
   Aggregate,
@@ -22,11 +30,11 @@ import type {
   Context,
   GroupByCallback,
   JoinOnCallback,
-  MergeContext,
+  MergeContextForJoinCallback,
   MergeContextWithJoinType,
   OrderByCallback,
   OrderByOptions,
-  RefProxyForContext,
+  RefsForContext,
   ResultTypeFromSelect,
   SchemaFromSource,
   SelectObject,
@@ -141,7 +149,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
   >(
     source: TSource,
     onCallback: JoinOnCallback<
-      MergeContext<TContext, SchemaFromSource<TSource>>
+      MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
     >,
     type: TJoinType = `left` as TJoinType
   ): QueryBuilder<
@@ -152,8 +160,8 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
     // Create a temporary context for the callback
     const currentAliases = this._getCurrentAliases()
     const newAliases = [...currentAliases, alias]
-    const refProxy = createRefProxy(newAliases) as RefProxyForContext<
-      MergeContext<TContext, SchemaFromSource<TSource>>
+    const refProxy = createRefProxy(newAliases) as RefsForContext<
+      MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
     >
 
     // Get the join condition expression
@@ -208,7 +216,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
   leftJoin<TSource extends Source>(
     source: TSource,
     onCallback: JoinOnCallback<
-      MergeContext<TContext, SchemaFromSource<TSource>>
+      MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
     >
   ): QueryBuilder<
     MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, `left`>
@@ -234,7 +242,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
   rightJoin<TSource extends Source>(
     source: TSource,
     onCallback: JoinOnCallback<
-      MergeContext<TContext, SchemaFromSource<TSource>>
+      MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
     >
   ): QueryBuilder<
     MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, `right`>
@@ -260,7 +268,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
   innerJoin<TSource extends Source>(
     source: TSource,
     onCallback: JoinOnCallback<
-      MergeContext<TContext, SchemaFromSource<TSource>>
+      MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
     >
   ): QueryBuilder<
     MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, `inner`>
@@ -286,7 +294,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
   fullJoin<TSource extends Source>(
     source: TSource,
     onCallback: JoinOnCallback<
-      MergeContext<TContext, SchemaFromSource<TSource>>
+      MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
     >
   ): QueryBuilder<
     MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, `full`>
@@ -324,7 +332,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
    */
   where(callback: WhereCallback<TContext>): QueryBuilder<TContext> {
     const aliases = this._getCurrentAliases()
-    const refProxy = createRefProxy(aliases) as RefProxyForContext<TContext>
+    const refProxy = createRefProxy(aliases) as RefsForContext<TContext>
     const expression = callback(refProxy)
 
     const existingWhere = this.query.where || []
@@ -365,7 +373,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
    */
   having(callback: WhereCallback<TContext>): QueryBuilder<TContext> {
     const aliases = this._getCurrentAliases()
-    const refProxy = createRefProxy(aliases) as RefProxyForContext<TContext>
+    const refProxy = createRefProxy(aliases) as RefsForContext<TContext>
     const expression = callback(refProxy)
 
     const existingHaving = this.query.having || []
@@ -411,42 +419,16 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
    * ```
    */
   select<TSelectObject extends SelectObject>(
-    callback: (refs: RefProxyForContext<TContext>) => TSelectObject
+    callback: (refs: RefsForContext<TContext>) => TSelectObject
   ): QueryBuilder<WithResult<TContext, ResultTypeFromSelect<TSelectObject>>> {
     const aliases = this._getCurrentAliases()
-    const refProxy = createRefProxy(aliases) as RefProxyForContext<TContext>
+    const refProxy = createRefProxy(aliases) as RefsForContext<TContext>
     const selectObject = callback(refProxy)
-
-    // Check if any tables were spread during the callback
-    const spreadSentinels = (refProxy as any).__spreadSentinels as Set<string>
-
-    // Convert the select object to use expressions, including spread sentinels
-    const select: Record<string, BasicExpression | Aggregate> = {}
-
-    // First, add spread sentinels for any tables that were spread
-    for (const spreadAlias of spreadSentinels) {
-      const sentinelKey = `__SPREAD_SENTINEL__${spreadAlias}`
-      select[sentinelKey] = toExpression(spreadAlias) // Use alias as a simple reference
-    }
-
-    // Then add the explicit select fields
-    for (const [key, value] of Object.entries(selectObject)) {
-      if (isRefProxy(value)) {
-        select[key] = toExpression(value)
-      } else if (
-        typeof value === `object` &&
-        `type` in value &&
-        (value.type === `agg` || value.type === `func`)
-      ) {
-        select[key] = value as BasicExpression | Aggregate
-      } else {
-        select[key] = toExpression(value)
-      }
-    }
+    const select = buildNestedSelect(selectObject)
 
     return new BaseQueryBuilder({
       ...this.query,
-      select,
+      select: select,
       fnSelect: undefined, // remove the fnSelect clause if it exists
     }) as any
   }
@@ -482,7 +464,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
     options: OrderByDirection | OrderByOptions = `asc`
   ): QueryBuilder<TContext> {
     const aliases = this._getCurrentAliases()
-    const refProxy = createRefProxy(aliases) as RefProxyForContext<TContext>
+    const refProxy = createRefProxy(aliases) as RefsForContext<TContext>
     const result = callback(refProxy)
 
     const opts: CompareOptions =
@@ -550,17 +532,18 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
    */
   groupBy(callback: GroupByCallback<TContext>): QueryBuilder<TContext> {
     const aliases = this._getCurrentAliases()
-    const refProxy = createRefProxy(aliases) as RefProxyForContext<TContext>
+    const refProxy = createRefProxy(aliases) as RefsForContext<TContext>
     const result = callback(refProxy)
 
     const newExpressions = Array.isArray(result)
       ? result.map((r) => toExpression(r))
       : [toExpression(result)]
 
-    // Replace existing groupBy expressions instead of extending them
+    // Extend existing groupBy expressions (multiple groupBy calls should accumulate)
+    const existingGroupBy = this.query.groupBy || []
     return new BaseQueryBuilder({
       ...this.query,
-      groupBy: newExpressions,
+      groupBy: [...existingGroupBy, ...newExpressions],
     }) as any
   }
 
@@ -758,6 +741,43 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
   }
 }
 
+// Helper to ensure we have a BasicExpression/Aggregate for a value
+function toExpr(value: any): BasicExpression | Aggregate {
+  if (value === undefined) return toExpression(null)
+  if (
+    value instanceof AggregateExpr ||
+    value instanceof FuncExpr ||
+    value instanceof PropRef ||
+    value instanceof ValueExpr
+  ) {
+    return value as BasicExpression | Aggregate
+  }
+  return toExpression(value)
+}
+
+function isPlainObject(value: any): value is Record<string, any> {
+  return (
+    value !== null &&
+    typeof value === `object` &&
+    !isExpressionLike(value) &&
+    !value.__refProxy
+  )
+}
+
+function buildNestedSelect(obj: any): any {
+  if (!isPlainObject(obj)) return toExpr(obj)
+  const out: Record<string, any> = {}
+  for (const [k, v] of Object.entries(obj)) {
+    if (typeof k === `string` && k.startsWith(`__SPREAD_SENTINEL__`)) {
+      // Preserve sentinel key and its value (value is unimportant at compile time)
+      out[k] = v
+      continue
+    }
+    out[k] = buildNestedSelect(v)
+  }
+  return out
+}
+
 // Internal function to build a query from a callback
 // used by liveQueryCollectionOptions.query
 export function buildQuery<TContext extends Context>(
@@ -797,4 +817,4 @@ export type ExtractContext<T> =
       : never
 
 // Export the types from types.ts for convenience
-export type { Context, Source, GetResult } from "./types.js"
+export type { Context, Source, GetResult, RefLeaf as Ref } from "./types.js"

package/src/query/builder/ref-proxy.ts

@@ -1,5 +1,6 @@
 import { PropRef, Value } from "../ir.js"
 import type { BasicExpression } from "../ir.js"
+import type { RefLeaf } from "./types.js"
 
 export interface RefProxy<T = any> {
   /** @internal */
@@ -19,7 +20,7 @@ export type SingleRowRefProxy<T> =
     ? {
         [K in keyof T]: T[K] extends Record<string, any>
           ? SingleRowRefProxy<T[K]> & RefProxy<T[K]>
-          : RefProxy<T[K]>
+          : RefLeaf<T[K]>
       } & RefProxy<T>
     : RefProxy<T>
 
@@ -83,7 +84,7 @@ export function createRefProxy<T extends Record<string, any>>(
   aliases: Array<string>
 ): RefProxy<T> & T {
   const cache = new Map<string, any>()
-  const spreadSentinels = new Set<string>() // Track which aliases have been spread
+  let accessId = 0 // Monotonic counter to record evaluation order
 
   function createProxy(path: Array<string>): any {
     const pathKey = path.join(`.`)
@@ -109,10 +110,14 @@ export function createRefProxy<T extends Record<string, any>>(
       },
 
       ownKeys(target) {
-        // If this is a table-level proxy (path length 1), mark it as spread
-        if (path.length === 1) {
-          const aliasName = path[0]!
-          spreadSentinels.add(aliasName)
+        const id = ++accessId
+        const sentinelKey = `__SPREAD_SENTINEL__${path.join(`.`)}__${id}`
+        if (!Object.prototype.hasOwnProperty.call(target, sentinelKey)) {
+          Object.defineProperty(target, sentinelKey, {
+            enumerable: true,
+            configurable: true,
+            value: true,
+          })
         }
         return Reflect.ownKeys(target)
       },
@@ -135,7 +140,6 @@ export function createRefProxy<T extends Record<string, any>>(
       if (prop === `__refProxy`) return true
       if (prop === `__path`) return []
       if (prop === `__type`) return undefined // Type is only for TypeScript inference
-      if (prop === `__spreadSentinels`) return spreadSentinels // Expose spread sentinels
       if (typeof prop === `symbol`) return Reflect.get(target, prop, receiver)
 
       const propStr = String(prop)
@@ -147,28 +151,18 @@ export function createRefProxy<T extends Record<string, any>>(
     },
 
     has(target, prop) {
-      if (
-        prop === `__refProxy` ||
-        prop === `__path` ||
-        prop === `__type` ||
-        prop === `__spreadSentinels`
-      )
+      if (prop === `__refProxy` || prop === `__path` || prop === `__type`)
         return true
       if (typeof prop === `string` && aliases.includes(prop)) return true
       return Reflect.has(target, prop)
     },
 
     ownKeys(_target) {
-      return [...aliases, `__refProxy`, `__path`, `__type`, `__spreadSentinels`]
+      return [...aliases, `__refProxy`, `__path`, `__type`]
     },
 
     getOwnPropertyDescriptor(target, prop) {
-      if (
-        prop === `__refProxy` ||
-        prop === `__path` ||
-        prop === `__type` ||
-        prop === `__spreadSentinels`
-      ) {
+      if (prop === `__refProxy` || prop === `__path` || prop === `__type`) {
         return { enumerable: false, configurable: true }
       }
       if (typeof prop === `string` && aliases.includes(prop)) {