@apollo/client 4.3.3 → 4.3.5

package/cache/inmemory/inMemoryCache.js

@@ -73,7 +73,8 @@ export class InMemoryCache extends ApolloCache {
                 // currently using a data store that can track cache dependencies.
                 const store = c.optimistic ? this.optimisticData : this.data;
                 if (supportsResultCaching(store)) {
-                    const { optimistic, id, variables } = c;
+                    const { optimistic, id } = c;
+                    const variables = this.serializeVariables(c.query, c.variables);
                     return store.makeCacheKey(c.query, 
                     // Different watches can have the same query, optimistic
                     // status, rootId, and variables, but if their callbacks are
@@ -129,7 +130,7 @@ export class InMemoryCache extends ApolloCache {
                     return this.serializeInputArray(value, variableTypes, match[1], coordinate);
                 }
                 else if (__DEV__) {
-                    __DEV__ && invariant.warn(112, coordinate, scalarType, unwrapScalarType(scalarType));
+                    __DEV__ && invariant.warn(113, coordinate, scalarType, unwrapScalarType(scalarType));
                 }
             }
             const scalar = this.getScalar(unwrapScalarType(scalarType));
@@ -271,10 +272,7 @@ export class InMemoryCache extends ApolloCache {
             recallCache(this);
         }
         this.watches.add(watch);
-        if (watch.immediate) {
-            this.maybeBroadcastWatch(watch);
-        }
-        return () => {
+        const removeWatch = () => {
             // Once we remove the last watch from this.watches, cache.broadcastWatches
             // no longer does anything, so we preemptively tell the reactive variable
             // system to exclude this cache from future broadcasts.
@@ -286,6 +284,19 @@ export class InMemoryCache extends ApolloCache {
             // leaks involving the closure of watch.callback.
             this.maybeBroadcastWatch.forget(watch);
         };
+        if (watch.immediate) {
+            try {
+                this.maybeBroadcastWatch(watch);
+            }
+            catch (error) {
+                // The caller never receives removeWatch when this throws, so without
+                // this the watch would stay registered with nothing able to remove it,
+                // and every later broadcast would run into the same failing read.
+                removeWatch();
+                throw error;
+            }
+        }
+        return removeWatch;
     }
     gc(options) {
         canonicalStringify.reset();