@tanstack/db-ivm 0.1.18 → 0.1.20

package/src/operators/groupBy.ts

@@ -62,7 +62,7 @@ export function groupBy<
     stream: IStreamBuilder<T>,
   ): IStreamBuilder<KeyValue<string, ResultType>> => {
     // Special key to store the original key object
-    const KEY_SENTINEL = `__original_key__`
+    const KEY_SENTINEL = Symbol(`original_group_key`)
 
     // First map to extract keys and pre-aggregate values
     const withKeysAndValues = stream.pipe(
@@ -71,7 +71,7 @@ export function groupBy<
         const keyString = serializeValue(key)
 
         // Create values object with pre-aggregated values
-        const values: Record<string, unknown> = {}
+        const values: Record<string | symbol, unknown> = {}
 
         // Store the original key object
         values[KEY_SENTINEL] = key
@@ -81,7 +81,10 @@ export function groupBy<
           values[name] = aggregate.preMap(data)
         }
 
-        return [keyString, values] as KeyValue<string, Record<string, unknown>>
+        return [keyString, values] as KeyValue<
+          string,
+          Record<string | symbol, unknown>
+        >
       }),
     )
 
@@ -99,7 +102,7 @@ export function groupBy<
           return []
         }
 
-        const result: Record<string, unknown> = {}
+        const result: Record<PropertyKey, unknown> = {}
 
         // Get the original key from first value in group
         const originalKey = values[0]?.[0]?.[KEY_SENTINEL]

package/src/utils.ts

@@ -185,6 +185,14 @@ function range(start: number, end: number): Array<number> {
 export function compareKeys(a: string | number, b: string | number): number {
   // Same type: compare directly
   if (typeof a === typeof b) {
+    if (typeof a === `number` && typeof b === `number`) {
+      const aIsNaN = Number.isNaN(a)
+      const bIsNaN = Number.isNaN(b)
+      if (aIsNaN || bIsNaN) {
+        if (aIsNaN && bIsNaN) return 0
+        return aIsNaN ? 1 : -1
+      }
+    }
     if (a < b) return -1
     if (a > b) return 1
     return 0
@@ -193,19 +201,214 @@ export function compareKeys(a: string | number, b: string | number): number {
   return typeof a === `string` ? -1 : 1
 }
 
+type CanonicalValue =
+  | readonly [`undefined`]
+  | readonly [`null`]
+  | readonly [`boolean`, boolean]
+  | readonly [`number`, number | `NaN` | `Infinity` | `-Infinity`]
+  | readonly [`bigint`, string]
+  | readonly [`string`, string]
+  | readonly [`date`, number | `Invalid`]
+  | readonly [`regexp`, string, string]
+  | readonly [`bytes`, Array<number>]
+  | readonly [`array`, Array<CanonicalValue>]
+  | readonly [`map`, Array<readonly [CanonicalValue, CanonicalValue]>]
+  | readonly [`set`, Array<CanonicalValue>]
+  | readonly [`object`, Array<readonly [string, CanonicalValue]>]
+
 /**
- * Serializes a value for use as a key, handling BigInt and Date values that JSON.stringify cannot handle.
- * Uses JSON.stringify with a replacer function to convert BigInt values to strings and Date values to ISO strings.
- * This is used for creating string keys in groupBy operations.
+ * Serializes a supported query value into one canonical key.
+ *
+ * JSON's native encoding is not suitable for relation keys: it merges BigInt
+ * with strings when a replacer is used, merges NaN with null, drops undefined,
+ * and depends on object insertion order. Ordinary JSON values keep their
+ * established wire form. Values that need richer types use a reserved prefix
+ * plus a structural, type-tagged encoding.
  */
 export function serializeValue(value: unknown): string {
-  return JSON.stringify(value, (_, val) => {
-    if (typeof val === 'bigint') {
-      return val.toString()
+  if (isJsonSafeStructuralValue(value, new Set())) {
+    return JSON.stringify(toStableJsonValue(value))
+  }
+
+  return `~${JSON.stringify(toCanonicalValue(value, new Set()))}`
+}
+
+type JsonValue =
+  | null
+  | boolean
+  | number
+  | string
+  | Array<JsonValue>
+  | { [key: string]: JsonValue }
+
+function isJsonSafeStructuralValue(
+  value: unknown,
+  ancestors: Set<object>,
+): boolean {
+  if (value === null) return true
+
+  switch (typeof value) {
+    case `boolean`:
+    case `string`:
+      return true
+    case `number`:
+      return Number.isFinite(value)
+    case `undefined`:
+    case `bigint`:
+    case `symbol`:
+    case `function`:
+      return false
+  }
+
+  return withAcyclicValue(value, ancestors, () => {
+    if (
+      value instanceof Date ||
+      value instanceof RegExp ||
+      value instanceof Uint8Array ||
+      value instanceof Map ||
+      value instanceof Set
+    ) {
+      return false
     }
-    if (val instanceof Date) {
-      return val.toISOString()
+
+    return Array.isArray(value)
+      ? value.every((item) => isJsonSafeStructuralValue(item, ancestors))
+      : Object.keys(value).every((key) =>
+          isJsonSafeStructuralValue(
+            (value as Record<string, unknown>)[key],
+            ancestors,
+          ),
+        )
+  })
+}
+
+function toStableJsonValue(value: unknown): JsonValue {
+  if (
+    value === null ||
+    typeof value === `boolean` ||
+    typeof value === `number` ||
+    typeof value === `string`
+  ) {
+    return value
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(toStableJsonValue)
+  }
+
+  return Object.fromEntries(
+    Object.keys(value as object)
+      .sort()
+      .map((key) => [
+        key,
+        toStableJsonValue((value as Record<string, unknown>)[key]),
+      ]),
+  )
+}
+
+function toCanonicalValue(
+  value: unknown,
+  ancestors: Set<object>,
+): CanonicalValue {
+  if (value === undefined) return [`undefined`]
+  if (value === null) return [`null`]
+
+  switch (typeof value) {
+    case `boolean`:
+      return [`boolean`, value]
+    case `number`:
+      if (Number.isNaN(value)) return [`number`, `NaN`]
+      if (value === Infinity) return [`number`, `Infinity`]
+      if (value === -Infinity) return [`number`, `-Infinity`]
+      return [`number`, value === 0 ? 0 : value]
+    case `bigint`:
+      return [`bigint`, value.toString()]
+    case `string`:
+      return [`string`, value]
+    case `symbol`:
+    case `function`:
+      throw new TypeError(
+        `Cannot serialize ${typeof value} as a structural relation key`,
+      )
+  }
+
+  return withAcyclicValue(value, ancestors, () => {
+    if (value instanceof Date) {
+      const timestamp = value.getTime()
+      return Number.isNaN(timestamp)
+        ? ([`date`, `Invalid`] as const)
+        : ([`date`, timestamp] as const)
+    }
+
+    if (value instanceof RegExp) {
+      return [`regexp`, value.source, value.flags]
+    }
+
+    if (value instanceof Uint8Array) {
+      return [`bytes`, Array.from(value)]
+    }
+
+    if (Array.isArray(value)) {
+      return [`array`, value.map((item) => toCanonicalValue(item, ancestors))]
+    }
+
+    if (value instanceof Map) {
+      const entries = [...value.entries()].map(
+        ([key, entryValue]) =>
+          [
+            toCanonicalValue(key, ancestors),
+            toCanonicalValue(entryValue, ancestors),
+          ] as const,
+      )
+      entries.sort((left, right) =>
+        compareSerializedValues(JSON.stringify(left), JSON.stringify(right)),
+      )
+      return [`map`, entries]
     }
-    return val
+
+    if (value instanceof Set) {
+      const entries = [...value].map((entry) =>
+        toCanonicalValue(entry, ancestors),
+      )
+      entries.sort((left, right) =>
+        compareSerializedValues(JSON.stringify(left), JSON.stringify(right)),
+      )
+      return [`set`, entries]
+    }
+
+    const entries = Object.keys(value)
+      .sort()
+      .map(
+        (key) =>
+          [
+            key,
+            toCanonicalValue(
+              (value as Record<string, unknown>)[key],
+              ancestors,
+            ),
+          ] as const,
+      )
+    return [`object`, entries]
   })
 }
+
+function compareSerializedValues(left: string, right: string): number {
+  return left < right ? -1 : left > right ? 1 : 0
+}
+
+function withAcyclicValue<T>(
+  value: object,
+  ancestors: Set<object>,
+  encode: () => T,
+): T {
+  if (ancestors.has(value)) {
+    throw new TypeError(`Cannot serialize a cyclic structural relation key`)
+  }
+
+  ancestors.add(value)
+  try {
+    return encode()
+  } finally {
+    ancestors.delete(value)
+  }
+}

package/dist/cjs/operators/orderByBTree.d.cts

@@ -1,3 +0,0 @@
-import { KeyValue } from '../types.js';
-import { OrderByOptions } from './orderBy.js';
-export declare function orderByWithFractionalIndexBTree<T extends KeyValue<unknown, unknown>, Ve = unknown>(valueExtractor: (value: T extends KeyValue<unknown, infer V> ? V : never) => Ve, options?: OrderByOptions<Ve>): (stream: import('../types.js').IStreamBuilder<T>) => import('../types.js').IStreamBuilder<[T extends KeyValue<infer K, unknown> ? K : never, [T extends KeyValue<unknown, infer V> ? V : never, string]]>;

package/dist/esm/operators/orderByBTree.d.ts

@@ -1,3 +0,0 @@
-import { KeyValue } from '../types.js';
-import { OrderByOptions } from './orderBy.js';
-export declare function orderByWithFractionalIndexBTree<T extends KeyValue<unknown, unknown>, Ve = unknown>(valueExtractor: (value: T extends KeyValue<unknown, infer V> ? V : never) => Ve, options?: OrderByOptions<Ve>): (stream: import('../types.js').IStreamBuilder<T>) => import('../types.js').IStreamBuilder<[T extends KeyValue<infer K, unknown> ? K : never, [T extends KeyValue<unknown, infer V> ? V : never, string]]>;

package/src/operators/orderByBTree.ts

@@ -1,20 +0,0 @@
-import { orderByWithFractionalIndexBase } from './orderBy.js'
-import { topKWithFractionalIndexBTree } from './topKWithFractionalIndexBTree.js'
-import type { KeyValue } from '../types.js'
-import type { OrderByOptions } from './orderBy.js'
-
-export function orderByWithFractionalIndexBTree<
-  T extends KeyValue<unknown, unknown>,
-  Ve = unknown,
->(
-  valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never,
-  ) => Ve,
-  options?: OrderByOptions<Ve>,
-) {
-  return orderByWithFractionalIndexBase(
-    topKWithFractionalIndexBTree,
-    valueExtractor,
-    options,
-  )
-}