@tanstack/db 0.5.8 → 0.5.10

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tanstack/db",
   "description": "A reactive client store for building super fast apps on sync",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "dependencies": {
     "@standard-schema/spec": "^1.0.0",
     "@tanstack/pacer-lite": "^0.1.0",
@@ -10,7 +10,7 @@
   "devDependencies": {
     "@vitest/coverage-istanbul": "^3.2.4",
     "arktype": "^2.1.27",
-    "superjson": "^2.2.5",
+    "superjson": "^2.2.6",
     "temporal-polyfill": "^0.3.0"
   },
   "exports": {

package/src/collection/index.ts

@@ -127,32 +127,85 @@ export interface Collection<
  *
  */
 
-// Overload for when schema is provided
+// Overload for when schema is provided and utils is required (not optional)
+// We can't infer the Utils type from the CollectionConfig because it will always be optional
+// So we omit it from that type and instead infer it from the extension `& { utils: TUtils }`
+// such that we have the real, non-optional Utils type
 export function createCollection<
   T extends StandardSchemaV1,
-  TKey extends string | number = string | number,
-  TUtils extends UtilsRecord = UtilsRecord,
+  TKey extends string | number,
+  TUtils extends UtilsRecord,
 >(
-  options: CollectionConfig<InferSchemaOutput<T>, TKey, T, TUtils> & {
+  options: Omit<
+    CollectionConfig<InferSchemaOutput<T>, TKey, T, TUtils>,
+    `utils`
+  > & {
     schema: T
-    utils?: TUtils
+    utils: TUtils // Required utils
   } & NonSingleResult
 ): Collection<InferSchemaOutput<T>, TKey, TUtils, T, InferSchemaInput<T>> &
   NonSingleResult
 
+// Overload for when schema is provided and utils is optional
+// In this case we can simply infer the Utils type from the CollectionConfig type
+export function createCollection<
+  T extends StandardSchemaV1,
+  TKey extends string | number,
+  TUtils extends UtilsRecord,
+>(
+  options: CollectionConfig<InferSchemaOutput<T>, TKey, T, TUtils> & {
+    schema: T
+  } & NonSingleResult
+): Collection<
+  InferSchemaOutput<T>,
+  TKey,
+  Exclude<TUtils, undefined>,
+  T,
+  InferSchemaInput<T>
+> &
+  NonSingleResult
+
+// Overload for when schema is provided, singleResult is true, and utils is required
+export function createCollection<
+  T extends StandardSchemaV1,
+  TKey extends string | number,
+  TUtils extends UtilsRecord,
+>(
+  options: Omit<
+    CollectionConfig<InferSchemaOutput<T>, TKey, T, TUtils>,
+    `utils`
+  > & {
+    schema: T
+    utils: TUtils // Required utils
+  } & SingleResult
+): Collection<InferSchemaOutput<T>, TKey, TUtils, T, InferSchemaInput<T>> &
+  SingleResult
+
 // Overload for when schema is provided and singleResult is true
 export function createCollection<
   T extends StandardSchemaV1,
-  TKey extends string | number = string | number,
-  TUtils extends UtilsRecord = UtilsRecord,
+  TKey extends string | number,
+  TUtils extends UtilsRecord,
 >(
   options: CollectionConfig<InferSchemaOutput<T>, TKey, T, TUtils> & {
     schema: T
-    utils?: TUtils
   } & SingleResult
 ): Collection<InferSchemaOutput<T>, TKey, TUtils, T, InferSchemaInput<T>> &
   SingleResult
 
+// Overload for when no schema is provided and utils is required
+// the type T needs to be passed explicitly unless it can be inferred from the getKey function in the config
+export function createCollection<
+  T extends object,
+  TKey extends string | number,
+  TUtils extends UtilsRecord,
+>(
+  options: Omit<CollectionConfig<T, TKey, never, TUtils>, `utils`> & {
+    schema?: never // prohibit schema if an explicit type is provided
+    utils: TUtils // Required utils
+  } & NonSingleResult
+): Collection<T, TKey, TUtils, never, T> & NonSingleResult
+
 // Overload for when no schema is provided
 // the type T needs to be passed explicitly unless it can be inferred from the getKey function in the config
 export function createCollection<
@@ -162,10 +215,22 @@ export function createCollection<
 >(
   options: CollectionConfig<T, TKey, never, TUtils> & {
     schema?: never // prohibit schema if an explicit type is provided
-    utils?: TUtils
   } & NonSingleResult
 ): Collection<T, TKey, TUtils, never, T> & NonSingleResult
 
+// Overload for when no schema is provided, singleResult is true, and utils is required
+// the type T needs to be passed explicitly unless it can be inferred from the getKey function in the config
+export function createCollection<
+  T extends object,
+  TKey extends string | number = string | number,
+  TUtils extends UtilsRecord = UtilsRecord,
+>(
+  options: Omit<CollectionConfig<T, TKey, never, TUtils>, `utils`> & {
+    schema?: never // prohibit schema if an explicit type is provided
+    utils: TUtils // Required utils
+  } & SingleResult
+): Collection<T, TKey, TUtils, never, T> & SingleResult
+
 // Overload for when no schema is provided and singleResult is true
 // the type T needs to be passed explicitly unless it can be inferred from the getKey function in the config
 export function createCollection<
@@ -175,15 +240,13 @@ export function createCollection<
 >(
   options: CollectionConfig<T, TKey, never, TUtils> & {
     schema?: never // prohibit schema if an explicit type is provided
-    utils?: TUtils
   } & SingleResult
 ): Collection<T, TKey, TUtils, never, T> & SingleResult
 
 // Implementation
 export function createCollection(
-  options: CollectionConfig<any, string | number, any> & {
+  options: CollectionConfig<any, string | number, any, UtilsRecord> & {
     schema?: StandardSchemaV1
-    utils?: UtilsRecord
   }
 ): Collection<any, string | number, UtilsRecord, any, any> {
   const collection = new CollectionImpl<any, string | number, any, any, any>(

package/src/collection/mutations.ts

@@ -163,17 +163,19 @@ export class CollectionMutationsManager<
 
     const items = Array.isArray(data) ? data : [data]
     const mutations: Array<PendingMutation<TOutput>> = []
+    const keysInCurrentBatch = new Set<TKey>()
 
     // Create mutations for each item
     items.forEach((item) => {
       // Validate the data against the schema if one exists
       const validatedData = this.validateData(item, `insert`)
 
-      // Check if an item with this ID already exists in the collection
+      // Check if an item with this ID already exists in the collection or in the current batch
       const key = this.config.getKey(validatedData)
-      if (this.state.has(key)) {
+      if (this.state.has(key) || keysInCurrentBatch.has(key)) {
         throw new DuplicateKeyError(key)
       }
+      keysInCurrentBatch.add(key)
       const globalKey = this.generateGlobalKey(key, item)
 
       const mutation: PendingMutation<TOutput, `insert`> = {

package/src/indexes/base-index.ts

@@ -73,9 +73,9 @@ export interface IndexInterface<
 /**
  * Base abstract class that all index types extend
  */
-export abstract class BaseIndex<TKey extends string | number = string | number>
-  implements IndexInterface<TKey>
-{
+export abstract class BaseIndex<
+  TKey extends string | number = string | number,
+> implements IndexInterface<TKey> {
   public readonly id: number
   public readonly name?: string
   public readonly expression: BasicExpression

package/src/indexes/reverse-index.ts

@@ -3,9 +3,9 @@ import type { OrderByDirection } from "../query/ir"
 import type { IndexInterface, IndexOperation, IndexStats } from "./base-index"
 import type { RangeQueryOptions } from "./btree-index"
 
-export class ReverseIndex<TKey extends string | number>
-  implements IndexInterface<TKey>
-{
+export class ReverseIndex<
+  TKey extends string | number,
+> implements IndexInterface<TKey> {
   private originalIndex: IndexInterface<TKey>
 
   constructor(index: IndexInterface<TKey>) {

package/src/local-only.ts

@@ -24,9 +24,9 @@ export interface LocalOnlyCollectionConfig<
   TSchema extends StandardSchemaV1 = never,
   TKey extends string | number = string | number,
 > extends Omit<
-    BaseCollectionConfig<T, TKey, TSchema, LocalOnlyCollectionUtils>,
-    `gcTime` | `startSync`
-  > {
+  BaseCollectionConfig<T, TKey, TSchema, LocalOnlyCollectionUtils>,
+  `gcTime` | `startSync`
+> {
   /**
    * Optional initial data to populate the collection with on creation
    * This data will be applied during the initial sync process

package/src/proxy.ts

@@ -994,21 +994,31 @@ export function createChangeProxy<
         return true
       },
 
-      defineProperty(_ptarget, prop, descriptor) {
-        // const result = Reflect.defineProperty(
-        //   changeTracker.copy_,
-        //   prop,
-        //   descriptor
-        // )
-        // if (result) {
-        if (`value` in descriptor) {
+      defineProperty(ptarget, prop, descriptor) {
+        // Forward the defineProperty to the target to maintain Proxy invariants
+        // This allows Object.seal() and Object.freeze() to work on the proxy
+        const result = Reflect.defineProperty(ptarget, prop, descriptor)
+        if (result && `value` in descriptor) {
           changeTracker.copy_[prop as keyof T] = deepClone(descriptor.value)
           changeTracker.assigned_[prop.toString()] = true
           markChanged(changeTracker)
         }
-        // }
-        // return result
-        return true
+        return result
+      },
+
+      getOwnPropertyDescriptor(ptarget, prop) {
+        // Forward to target to maintain Proxy invariants for seal/freeze
+        return Reflect.getOwnPropertyDescriptor(ptarget, prop)
+      },
+
+      preventExtensions(ptarget) {
+        // Forward to target to allow Object.seal() and Object.preventExtensions()
+        return Reflect.preventExtensions(ptarget)
+      },
+
+      isExtensible(ptarget) {
+        // Forward to target to maintain consistency
+        return Reflect.isExtensible(ptarget)
       },
 
       deleteProperty(dobj, prop) {
@@ -1020,33 +1030,36 @@ export function createChangeProxy<
           const hadPropertyInOriginal =
             stringProp in changeTracker.originalObject
 
-          // Delete the property from the copy
-          // Use type assertion to tell TypeScript this is allowed
-          delete (changeTracker.copy_ as Record<string | symbol, unknown>)[prop]
+          // Forward the delete to the target using Reflect
+          // This respects Object.seal/preventExtensions constraints
+          const result = Reflect.deleteProperty(dobj, prop)
 
-          // If the property didn't exist in the original object, removing it
-          // should revert to the original state
-          if (!hadPropertyInOriginal) {
-            delete changeTracker.copy_[stringProp]
-            delete changeTracker.assigned_[stringProp]
+          if (result) {
+            // If the property didn't exist in the original object, removing it
+            // should revert to the original state
+            if (!hadPropertyInOriginal) {
+              delete changeTracker.assigned_[stringProp]
 
-            // If this is the last change and we're not a nested object,
-            // mark the object as unmodified
-            if (
-              Object.keys(changeTracker.assigned_).length === 0 &&
-              Object.getOwnPropertySymbols(changeTracker.assigned_).length === 0
-            ) {
-              changeTracker.modified = false
+              // If this is the last change and we're not a nested object,
+              // mark the object as unmodified
+              if (
+                Object.keys(changeTracker.assigned_).length === 0 &&
+                Object.getOwnPropertySymbols(changeTracker.assigned_).length ===
+                  0
+              ) {
+                changeTracker.modified = false
+              } else {
+                // We still have changes, keep as modified
+                changeTracker.modified = true
+              }
             } else {
-              // We still have changes, keep as modified
-              changeTracker.modified = true
+              // Mark this property as deleted
+              changeTracker.assigned_[stringProp] = false
+              markChanged(changeTracker)
             }
-          } else {
-            // Mark this property as deleted
-            changeTracker.assigned_[stringProp] = false
-            changeTracker.copy_[stringProp as keyof T] = undefined as T[keyof T]
-            markChanged(changeTracker)
           }
+
+          return result
         }
 
         return true
@@ -1060,7 +1073,9 @@ export function createChangeProxy<
   }
 
   // Create a proxy for the target object
-  const proxy = createObjectProxy(target)
+  // Use the unfrozen copy_ as the proxy target to avoid Proxy invariant violations
+  // when the original target is frozen (e.g., from Immer)
+  const proxy = createObjectProxy(changeTracker.copy_ as unknown as T)
 
   // Return the proxy and a function to get the changes
   return {

package/src/query/builder/types.ts

@@ -371,11 +371,11 @@ export type RefsForContext<TContext extends Context> = {
   > extends true
     ? IsNonExactNullable<TContext[`schema`][K]> extends true
       ? // T is both non-exact optional and non-exact nullable (e.g., string | null | undefined)
-        // Extract the non-undefined and non-null part and place undefined outside
-        Ref<NonNullable<TContext[`schema`][K]>> | undefined
+          // Extract the non-undefined and non-null part and place undefined outside
+          Ref<NonNullable<TContext[`schema`][K]>> | undefined
       : // T is optional (T | undefined) but not exactly undefined, and not nullable
-        // Extract the non-undefined part and place undefined outside
-        Ref<NonUndefined<TContext[`schema`][K]>> | undefined
+          // Extract the non-undefined part and place undefined outside
+          Ref<NonUndefined<TContext[`schema`][K]>> | undefined
     : IsNonExactNullable<TContext[`schema`][K]> extends true
       ? // T is nullable (T | null) but not exactly null, and not optional
         // Extract the non-null part and place null outside
@@ -612,7 +612,7 @@ export type ApplyJoinOptionalityToMergedSchema<
   // Apply optionality to new schema based on join type
   [K in keyof TNewSchema]: TJoinType extends `left` | `full`
     ? // New table becomes optional for left and full joins
-      TNewSchema[K] | undefined
+        TNewSchema[K] | undefined
     : // New table is required for inner and right joins
       TNewSchema[K]
 }

package/src/types.ts

@@ -13,9 +13,9 @@ export interface CollectionLike<
   T extends object = Record<string, unknown>,
   TKey extends string | number = string | number,
 > extends Pick<
-    Collection<T, TKey>,
-    `get` | `has` | `entries` | `indexes` | `id` | `compareOptions`
-  > {}
+  Collection<T, TKey>,
+  `get` | `has` | `entries` | `indexes` | `id` | `compareOptions`
+> {}
 
 /**
  * StringSortOpts - Options for string sorting behavior
@@ -727,8 +727,10 @@ export interface SubscribeChangesOptions {
   whereExpression?: BasicExpression<boolean>
 }
 
-export interface SubscribeChangesSnapshotOptions
-  extends Omit<SubscribeChangesOptions, `includeInitialState`> {
+export interface SubscribeChangesSnapshotOptions extends Omit<
+  SubscribeChangesOptions,
+  `includeInitialState`
+> {
   orderBy?: OrderBy
   limit?: number
 }