@tanstack/db 0.5.9 → 0.5.10

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/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 {