@apollo/client 4.1.0-alpha.7 → 4.1.0-alpha.9

package/__cjs/cache/core/types/Cache.d.cts

@@ -50,6 +50,11 @@ export declare namespace Cache {
          * @defaultValue false
          */
         overwrite?: boolean;
+        /**
+         * GraphQL extensions for the write operation. Any provided `extensions`
+         * are available in `merge` functions.
+         */
+        extensions?: Record<string, unknown>;
     }
     interface DiffOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Omit<ReadOptions<TData, TVariables>, "rootId"> {
     }
@@ -75,9 +80,37 @@ export declare namespace Cache {
         broadcast?: boolean;
     }
     interface BatchOptions<TCache extends ApolloCache, TUpdateResult = void> {
+        /**
+         * A function that performs cache operations. Receives the cache instance as its argument.
+         *
+         * The return value of this function becomes the return value of `batch`.
+         */
         update(cache: TCache): TUpdateResult;
+        /**
+         * Controls how optimistic data is handled:
+         *
+         * - `string`: Creates a new optimistic layer with this ID. Use `removeOptimistic` later to remove it.
+         * - `true`: Updates the current top layer of the cache (including any optimistic data).
+         * - `false`: Updates only the root (non-optimistic) cache data.
+         *
+         * @defaultValue false
+         */
         optimistic?: string | boolean;
+        /**
+         * If provided, removes the optimistic layer with this ID after the batch completes.
+         *
+         * This is useful for atomically applying server data while removing a pending optimistic update, triggering at most one broadcast for both operations.
+         *
+         * Note: this option is needed because calling `cache.removeOptimistic` during the transaction function may not be safe, since any modifications to cache layers may be discarded after the transaction finishes.
+         */
         removeOptimistic?: string;
+        /**
+         * Optional callback invoked for each watcher affected by the batch operation.
+         *
+         * Receives the watch options, the new diff result, and optionally the previous diff result.
+         *
+         * Return `false` to prevent broadcasting to that specific watcher.
+         */
         onWatchUpdated?: (this: TCache, watch: Cache.WatchOptions, diff: Cache.DiffResult<any>, lastDiff?: Cache.DiffResult<any> | undefined) => any;
     }
     interface ReadQueryOptions<TData, TVariables extends OperationVariables> {
@@ -174,6 +207,11 @@ export declare namespace Cache {
          * @defaultValue false
          */
         overwrite?: boolean;
+        /**
+         * GraphQL extensions for the write operation. Any provided `extensions`
+         * are available in `merge` functions.
+         */
+        extensions?: Record<string, unknown>;
     }
     type WriteFragmentOptions<TData, TVariables extends OperationVariables> = {
         /**

package/__cjs/cache/inmemory/entityStore.cjs

@@ -82,7 +82,7 @@ class EntityStore {
         // then there are no fields to be merged, so we're done.
         if (!incoming)
             return;
-        (0, invariant_1.invariant)(typeof dataId === "string", 98);
+        (0, invariant_1.invariant)(typeof dataId === "string", 99);
         const merged = new internal_1.DeepMerger({
             reconciler: storeObjectReconciler,
         }).merge(existing, incoming);
@@ -184,7 +184,7 @@ class EntityStore {
                             if (environment_1.__DEV__) {
                                 const checkReference = (ref) => {
                                     if (this.lookup(ref.__ref) === undefined) {
-                                        __DEV__ && invariant_1.invariant.warn(99, ref);
+                                        __DEV__ && invariant_1.invariant.warn(100, ref);
                                         return true;
                                     }
                                 };
@@ -213,7 +213,7 @@ class EntityStore {
                                             }
                                         }
                                         if (seenReference && someNonReference !== undefined) {
-                                            __DEV__ && invariant_1.invariant.warn(100, someNonReference);
+                                            __DEV__ && invariant_1.invariant.warn(101, someNonReference);
                                             break;
                                         }
                                     }