@tanstack/db 0.5.10 → 0.5.12

package/src/query/builder/index.ts

@@ -1,4 +1,4 @@
-import { CollectionImpl } from "../../collection/index.js"
+import { CollectionImpl } from '../../collection/index.js'
 import {
   Aggregate as AggregateExpr,
   CollectionRef,
@@ -7,7 +7,7 @@ import {
   QueryRef,
   Value as ValueExpr,
   isExpressionLike,
-} from "../ir.js"
+} from '../ir.js'
 import {
   InvalidSourceError,
   InvalidSourceTypeError,
@@ -15,9 +15,9 @@ import {
   OnlyOneSourceAllowedError,
   QueryMustHaveFromClauseError,
   SubQueryMustHaveFromClauseError,
-} from "../../errors.js"
-import { createRefProxy, toExpression } from "./ref-proxy.js"
-import type { NamespacedRow, SingleResult } from "../../types.js"
+} from '../../errors.js'
+import { createRefProxy, toExpression } from './ref-proxy.js'
+import type { NamespacedRow, SingleResult } from '../../types.js'
 import type {
   Aggregate,
   BasicExpression,
@@ -25,7 +25,7 @@ import type {
   OrderBy,
   OrderByDirection,
   QueryIR,
-} from "../ir.js"
+} from '../ir.js'
 import type {
   CompareOptions,
   Context,
@@ -42,7 +42,7 @@ import type {
   Source,
   WhereCallback,
   WithResult,
-} from "./types.js"
+} from './types.js'
 
 export class BaseQueryBuilder<TContext extends Context = Context> {
   private readonly query: Partial<QueryIR> = {}
@@ -59,7 +59,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
    */
   private _createRefForSource<TSource extends Source>(
     source: TSource,
-    context: string
+    context: string,
   ): [string, CollectionRef | QueryRef] {
     // Validate source is a plain object (not null, array, string, etc.)
     // We use try-catch to handle null/undefined gracefully
@@ -127,7 +127,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
    * ```
    */
   from<TSource extends Source>(
-    source: TSource
+    source: TSource,
   ): QueryBuilder<{
     baseSchema: SchemaFromSource<TSource>
     schema: SchemaFromSource<TSource>
@@ -177,7 +177,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
     onCallback: JoinOnCallback<
       MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
     >,
-    type: TJoinType = `left` as TJoinType
+    type: TJoinType = `left` as TJoinType,
   ): QueryBuilder<
     MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, TJoinType>
   > {
@@ -243,7 +243,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
     source: TSource,
     onCallback: JoinOnCallback<
       MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
-    >
+    >,
   ): QueryBuilder<
     MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, `left`>
   > {
@@ -269,7 +269,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
     source: TSource,
     onCallback: JoinOnCallback<
       MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
-    >
+    >,
   ): QueryBuilder<
     MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, `right`>
   > {
@@ -295,7 +295,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
     source: TSource,
     onCallback: JoinOnCallback<
       MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
-    >
+    >,
   ): QueryBuilder<
     MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, `inner`>
   > {
@@ -321,7 +321,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
     source: TSource,
     onCallback: JoinOnCallback<
       MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
-    >
+    >,
   ): QueryBuilder<
     MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, `full`>
   > {
@@ -445,7 +445,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
    * ```
    */
   select<TSelectObject extends SelectObject>(
-    callback: (refs: RefsForContext<TContext>) => TSelectObject
+    callback: (refs: RefsForContext<TContext>) => TSelectObject,
   ): QueryBuilder<WithResult<TContext, ResultTypeFromSelect<TSelectObject>>> {
     const aliases = this._getCurrentAliases()
     const refProxy = createRefProxy(aliases) as RefsForContext<TContext>
@@ -487,7 +487,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
    */
   orderBy(
     callback: OrderByCallback<TContext>,
-    options: OrderByDirection | OrderByOptions = `asc`
+    options: OrderByDirection | OrderByOptions = `asc`,
   ): QueryBuilder<TContext> {
     const aliases = this._getCurrentAliases()
     const refProxy = createRefProxy(aliases) as RefsForContext<TContext>
@@ -717,7 +717,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
        * ```
        */
       select<TFuncSelectResult>(
-        callback: (row: TContext[`schema`]) => TFuncSelectResult
+        callback: (row: TContext[`schema`]) => TFuncSelectResult,
       ): QueryBuilder<WithResult<TContext, TFuncSelectResult>> {
         return new BaseQueryBuilder({
           ...builder.query,
@@ -741,7 +741,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
        * ```
        */
       where(
-        callback: (row: TContext[`schema`]) => any
+        callback: (row: TContext[`schema`]) => any,
       ): QueryBuilder<TContext> {
         return new BaseQueryBuilder({
           ...builder.query,
@@ -768,7 +768,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
        * ```
        */
       having(
-        callback: (row: TContext[`schema`]) => any
+        callback: (row: TContext[`schema`]) => any,
       ): QueryBuilder<TContext> {
         return new BaseQueryBuilder({
           ...builder.query,
@@ -829,7 +829,7 @@ function buildNestedSelect(obj: any): any {
 // Internal function to build a query from a callback
 // used by liveQueryCollectionOptions.query
 export function buildQuery<TContext extends Context>(
-  fn: (builder: InitialQueryBuilder) => QueryBuilder<TContext>
+  fn: (builder: InitialQueryBuilder) => QueryBuilder<TContext>,
 ): QueryIR {
   const result = fn(new BaseQueryBuilder())
   return getQueryIR(result)
@@ -837,7 +837,7 @@ export function buildQuery<TContext extends Context>(
 
 // Internal function to get the QueryIR from a builder
 export function getQueryIR(
-  builder: BaseQueryBuilder | QueryBuilder<any> | InitialQueryBuilder
+  builder: BaseQueryBuilder | QueryBuilder<any> | InitialQueryBuilder,
 ): QueryIR {
   return (builder as unknown as BaseQueryBuilder)._getQuery()
 }
@@ -871,4 +871,4 @@ export type {
   GetResult,
   RefLeaf as Ref,
   InferResultType,
-} from "./types.js"
+} from './types.js'

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

@@ -1,6 +1,6 @@
-import { PropRef, Value } from "../ir.js"
-import type { BasicExpression } from "../ir.js"
-import type { RefLeaf } from "./types.js"
+import { PropRef, Value } from '../ir.js'
+import type { BasicExpression } from '../ir.js'
+import type { RefLeaf } from './types.js'
 
 export interface RefProxy<T = any> {
   /** @internal */
@@ -81,7 +81,7 @@ export function createSingleRowRefProxy<
  * Used in callbacks like where, select, etc. to create type-safe references
  */
 export function createRefProxy<T extends Record<string, any>>(
-  aliases: Array<string>
+  aliases: Array<string>,
 ): RefProxy<T> & T {
   const cache = new Map<string, any>()
   let accessId = 0 // Monotonic counter to record evaluation order

package/src/query/builder/types.ts

@@ -1,5 +1,5 @@
-import type { CollectionImpl } from "../../collection/index.js"
-import type { SingleResult, StringCollationConfig } from "../../types.js"
+import type { CollectionImpl } from '../../collection/index.js'
+import type { SingleResult, StringCollationConfig } from '../../types.js'
 import type {
   Aggregate,
   BasicExpression,
@@ -7,8 +7,8 @@ import type {
   OrderByDirection,
   PropRef,
   Value,
-} from "../ir.js"
-import type { QueryBuilder } from "./index.js"
+} from '../ir.js'
+import type { QueryBuilder } from './index.js'
 
 /**
  * Context - The central state container for query builder operations
@@ -121,7 +121,7 @@ export type GetAliases<TContext extends Context> = keyof TContext[`schema`]
  * Example: `(refs) => eq(refs.users.age, 25)`
  */
 export type WhereCallback<TContext extends Context> = (
-  refs: RefsForContext<TContext>
+  refs: RefsForContext<TContext>,
 ) => any
 
 /**
@@ -290,7 +290,7 @@ type NeedsExtraction<T> = T extends
  * Example: `(refs) => refs.users.createdAt`
  */
 export type OrderByCallback<TContext extends Context> = (
-  refs: RefsForContext<TContext>
+  refs: RefsForContext<TContext>,
 ) => any
 
 /**
@@ -326,7 +326,7 @@ export type CompareOptions = StringCollationConfig & {
  * Example: `(refs) => refs.orders.status`
  */
 export type GroupByCallback<TContext extends Context> = (
-  refs: RefsForContext<TContext>
+  refs: RefsForContext<TContext>,
 ) => any
 
 /**
@@ -342,7 +342,7 @@ export type GroupByCallback<TContext extends Context> = (
  * Example: `(refs) => eq(refs.users.id, refs.orders.userId)`
  */
 export type JoinOnCallback<TContext extends Context> = (
-  refs: RefsForContext<TContext>
+  refs: RefsForContext<TContext>,
 ) => any
 
 /**

package/src/query/compiler/evaluators.ts

@@ -2,10 +2,10 @@ import {
   EmptyReferencePathError,
   UnknownExpressionTypeError,
   UnknownFunctionError,
-} from "../../errors.js"
-import { areValuesEqual, normalizeValue } from "../../utils/comparison.js"
-import type { BasicExpression, Func, PropRef } from "../ir.js"
-import type { NamespacedRow } from "../../types.js"
+} from '../../errors.js'
+import { areValuesEqual, normalizeValue } from '../../utils/comparison.js'
+import type { BasicExpression, Func, PropRef } from '../ir.js'
+import type { NamespacedRow } from '../../types.js'
 
 /**
  * Helper function to check if a value is null or undefined (represents UNKNOWN in 3-valued logic)
@@ -46,7 +46,7 @@ export type CompiledSingleRowExpression = (item: Record<string, unknown>) => any
  */
 export function compileExpression(
   expr: BasicExpression,
-  isSingleRow: boolean = false
+  isSingleRow: boolean = false,
 ): CompiledExpression | CompiledSingleRowExpression {
   const compiledFn = compileExpressionInternal(expr, isSingleRow)
   return compiledFn
@@ -56,7 +56,7 @@ export function compileExpression(
  * Compiles a single-row expression into an optimized evaluator function.
  */
 export function compileSingleRowExpression(
-  expr: BasicExpression
+  expr: BasicExpression,
 ): CompiledSingleRowExpression {
   const compiledFn = compileExpressionInternal(expr, true)
   return compiledFn as CompiledSingleRowExpression
@@ -67,7 +67,7 @@ export function compileSingleRowExpression(
  */
 function compileExpressionInternal(
   expr: BasicExpression,
-  isSingleRow: boolean
+  isSingleRow: boolean,
 ): (data: any) => any {
   switch (expr.type) {
     case `val`: {
@@ -157,7 +157,7 @@ function compileSingleRowRef(ref: PropRef): CompiledSingleRowExpression {
 function compileFunction(func: Func, isSingleRow: boolean): (data: any) => any {
   // Pre-compile all arguments using the appropriate compiler
   const compiledArgs = func.args.map((arg) =>
-    compileExpressionInternal(arg, isSingleRow)
+    compileExpressionInternal(arg, isSingleRow),
   )
 
   switch (func.name) {
@@ -463,7 +463,7 @@ function compileFunction(func: Func, isSingleRow: boolean): (data: any) => any {
 function evaluateLike(
   value: any,
   pattern: any,
-  caseInsensitive: boolean
+  caseInsensitive: boolean,
 ): boolean {
   if (typeof value !== `string` || typeof pattern !== `string`) {
     return false

package/src/query/compiler/expressions.ts

@@ -1,5 +1,5 @@
-import { Func, PropRef, Value } from "../ir.js"
-import type { BasicExpression, OrderBy } from "../ir.js"
+import { Func, PropRef, Value } from '../ir.js'
+import type { BasicExpression, OrderBy } from '../ir.js'
 
 /**
  * Normalizes a WHERE clause expression by removing table aliases from property references.
@@ -20,7 +20,7 @@ import type { BasicExpression, OrderBy } from "../ir.js"
  */
 export function normalizeExpressionPaths(
   whereClause: BasicExpression<boolean>,
-  collectionAlias: string
+  collectionAlias: string,
 ): BasicExpression<boolean> {
   const tpe = whereClause.type
   if (tpe === `val`) {
@@ -44,7 +44,7 @@ export function normalizeExpressionPaths(
     for (const arg of whereClause.args) {
       const convertedArg = normalizeExpressionPaths(
         arg as BasicExpression<boolean>,
-        collectionAlias
+        collectionAlias,
       )
       args.push(convertedArg)
     }
@@ -54,12 +54,12 @@ export function normalizeExpressionPaths(
 
 export function normalizeOrderByPaths(
   orderBy: OrderBy,
-  collectionAlias: string
+  collectionAlias: string,
 ): OrderBy {
   const normalizedOrderBy = orderBy.map((clause) => {
     const basicExp = normalizeExpressionPaths(
       clause.expression,
-      collectionAlias
+      collectionAlias,
     )
 
     return {

package/src/query/compiler/group-by.ts

@@ -1,20 +1,20 @@
-import { filter, groupBy, groupByOperators, map } from "@tanstack/db-ivm"
-import { Func, PropRef, getHavingExpression } from "../ir.js"
+import { filter, groupBy, groupByOperators, map } from '@tanstack/db-ivm'
+import { Func, PropRef, getHavingExpression } from '../ir.js'
 import {
   AggregateFunctionNotInSelectError,
   NonAggregateExpressionNotInGroupByError,
   UnknownHavingExpressionTypeError,
   UnsupportedAggregateFunctionError,
-} from "../../errors.js"
-import { compileExpression, toBooleanPredicate } from "./evaluators.js"
+} from '../../errors.js'
+import { compileExpression, toBooleanPredicate } from './evaluators.js'
 import type {
   Aggregate,
   BasicExpression,
   GroupBy,
   Having,
   Select,
-} from "../ir.js"
-import type { NamespacedAndKeyedStream, NamespacedRow } from "../../types.js"
+} from '../ir.js'
+import type { NamespacedAndKeyedStream, NamespacedRow } from '../../types.js'
 
 const { sum, count, avg, min, max } = groupByOperators
 
@@ -32,7 +32,7 @@ interface GroupBySelectMapping {
  */
 function validateAndCreateMapping(
   groupByClause: GroupBy,
-  selectClause?: Select
+  selectClause?: Select,
 ): GroupBySelectMapping {
   const selectToGroupByIndex = new Map<string, number>()
   const groupByExpressions = [...groupByClause]
@@ -50,7 +50,7 @@ function validateAndCreateMapping(
 
     // Non-aggregate expression must be in GROUP BY
     const groupIndex = groupByExpressions.findIndex((groupExpr) =>
-      expressionsEqual(expr, groupExpr)
+      expressionsEqual(expr, groupExpr),
     )
 
     if (groupIndex === -1) {
@@ -73,7 +73,7 @@ export function processGroupBy(
   groupByClause: GroupBy,
   havingClauses?: Array<Having>,
   selectClause?: Select,
-  fnHavingClauses?: Array<(row: any) => any>
+  fnHavingClauses?: Array<(row: any) => any>,
 ): NamespacedAndKeyedStream {
   // Handle empty GROUP BY (single-group aggregation)
   if (groupByClause.length === 0) {
@@ -95,7 +95,7 @@ export function processGroupBy(
 
     // Apply the groupBy operator with single group
     pipeline = pipeline.pipe(
-      groupBy(keyExtractor, aggregates)
+      groupBy(keyExtractor, aggregates),
     ) as NamespacedAndKeyedStream
 
     // Update __select_results to include aggregate values
@@ -123,7 +123,7 @@ export function processGroupBy(
             __select_results: finalResults,
           },
         ] as [unknown, Record<string, any>]
-      })
+      }),
     )
 
     // Apply HAVING clauses if present
@@ -132,7 +132,7 @@ export function processGroupBy(
         const havingExpression = getHavingExpression(havingClause)
         const transformedHavingClause = replaceAggregatesByRefs(
           havingExpression,
-          selectClause || {}
+          selectClause || {},
         )
         const compiledHaving = compileExpression(transformedHavingClause)
 
@@ -141,7 +141,7 @@ export function processGroupBy(
             // Create a namespaced row structure for HAVING evaluation
             const namespacedRow = { result: (row as any).__select_results }
             return toBooleanPredicate(compiledHaving(namespacedRow))
-          })
+          }),
         )
       }
     }
@@ -154,7 +154,7 @@ export function processGroupBy(
             // Create a namespaced row structure for functional HAVING evaluation
             const namespacedRow = { result: (row as any).__select_results }
             return toBooleanPredicate(fnHaving(namespacedRow))
-          })
+          }),
         )
       }
     }
@@ -168,7 +168,7 @@ export function processGroupBy(
 
   // Pre-compile groupBy expressions
   const compiledGroupByExpressions = groupByClause.map((e) =>
-    compileExpression(e)
+    compileExpression(e),
   )
 
   // Create a key extractor function using simple __key_X format
@@ -258,7 +258,7 @@ export function processGroupBy(
           __select_results: finalResults,
         },
       ] as [unknown, Record<string, any>]
-    })
+    }),
   )
 
   // Apply HAVING clauses if present
@@ -267,7 +267,7 @@ export function processGroupBy(
       const havingExpression = getHavingExpression(havingClause)
       const transformedHavingClause = replaceAggregatesByRefs(
         havingExpression,
-        selectClause || {}
+        selectClause || {},
       )
       const compiledHaving = compileExpression(transformedHavingClause)
 
@@ -276,7 +276,7 @@ export function processGroupBy(
           // Create a namespaced row structure for HAVING evaluation
           const namespacedRow = { result: (row as any).__select_results }
           return compiledHaving(namespacedRow)
-        })
+        }),
       )
     }
   }
@@ -289,7 +289,7 @@ export function processGroupBy(
           // Create a namespaced row structure for functional HAVING evaluation
           const namespacedRow = { result: (row as any).__select_results }
           return toBooleanPredicate(fnHaving(namespacedRow))
-        })
+        }),
       )
     }
   }
@@ -310,7 +310,7 @@ function expressionsEqual(expr1: any, expr2: any): boolean {
       if (!expr1.path || !expr2.path) return false
       if (expr1.path.length !== expr2.path.length) return false
       return expr1.path.every(
-        (segment: string, i: number) => segment === expr2.path[i]
+        (segment: string, i: number) => segment === expr2.path[i],
       )
     case `val`:
       return expr1.value === expr2.value
@@ -319,7 +319,7 @@ function expressionsEqual(expr1: any, expr2: any): boolean {
         expr1.name === expr2.name &&
         expr1.args?.length === expr2.args?.length &&
         (expr1.args || []).every((arg: any, i: number) =>
-          expressionsEqual(arg, expr2.args[i])
+          expressionsEqual(arg, expr2.args[i]),
         )
       )
     case `agg`:
@@ -327,7 +327,7 @@ function expressionsEqual(expr1: any, expr2: any): boolean {
         expr1.name === expr2.name &&
         expr1.args?.length === expr2.args?.length &&
         (expr1.args || []).every((arg: any, i: number) =>
-          expressionsEqual(arg, expr2.args[i])
+          expressionsEqual(arg, expr2.args[i]),
         )
       )
     default:
@@ -390,7 +390,7 @@ function getAggregateFunction(aggExpr: Aggregate) {
 export function replaceAggregatesByRefs(
   havingExpr: BasicExpression | Aggregate,
   selectClause: Select,
-  resultAlias: string = `result`
+  resultAlias: string = `result`,
 ): BasicExpression {
   switch (havingExpr.type) {
     case `agg`: {
@@ -411,7 +411,7 @@ export function replaceAggregatesByRefs(
       // Transform function arguments recursively
       const transformedArgs = funcExpr.args.map(
         (arg: BasicExpression | Aggregate) =>
-          replaceAggregatesByRefs(arg, selectClause)
+          replaceAggregatesByRefs(arg, selectClause),
       )
       return new Func(funcExpr.name, transformedArgs)
     }