@apollo/client 4.3.0-alpha.6 → 4.3.0-alpha.8

package/__cjs/cache/inmemory/policies.cjs

@@ -251,7 +251,7 @@ class Policies {
         const rootId = "ROOT_" + which.toUpperCase();
         const old = this.rootTypenamesById[rootId];
         if (typename !== old) {
-            (0, invariant_1.invariant)(!old || old === which, 109, which);
+            (0, invariant_1.invariant)(!old || old === which, 111, which);
             // First, delete any old __typename associated with this rootId from
             // rootIdsByTypename.
             if (old)
@@ -394,7 +394,7 @@ class Policies {
                 if (supertypeSet.has(supertype)) {
                     if (!typenameSupertypeSet.has(supertype)) {
                         if (checkingFuzzySubtypes) {
-                            __DEV__ && invariant_1.invariant.warn(110, typename, supertype);
+                            __DEV__ && invariant_1.invariant.warn(112, typename, supertype);
                         }
                         // Record positive results for faster future lookup.
                         // Unfortunately, we cannot safely cache negative results,
@@ -651,7 +651,7 @@ function normalizeReadFieldOptions(readFieldArgs, objectOrReference, variables)
         }
     }
     if (environment_1.__DEV__ && options.from === void 0) {
-        __DEV__ && invariant_1.invariant.warn(111, (0, internal_2.stringifyForDisplay)(Array.from(readFieldArgs)));
+        __DEV__ && invariant_1.invariant.warn(113, (0, internal_2.stringifyForDisplay)(Array.from(readFieldArgs)));
     }
     if (void 0 === options.variables) {
         options.variables = variables;
@@ -661,7 +661,7 @@ function normalizeReadFieldOptions(readFieldArgs, objectOrReference, variables)
 function makeMergeObjectsFunction(store) {
     return function mergeObjects(existing, incoming) {
         if ((0, internal_2.isArray)(existing) || (0, internal_2.isArray)(incoming)) {
-            throw (0, invariant_1.newInvariantError)(112);
+            throw (0, invariant_1.newInvariantError)(114);
         }
         // These dynamic checks are necessary because the parameters of a
         // custom merge function can easily have the any type, so the type
@@ -698,6 +698,6 @@ function makeMergeObjectsFunction(store) {
     };
 }
 function warnAboutScalarConfig(typename, fieldName, scalar, kind) {
-    __DEV__ && invariant_1.invariant.warn(113, `${typename}.${fieldName}`, scalar, kind);
+    __DEV__ && invariant_1.invariant.warn(115, `${typename}.${fieldName}`, scalar, kind);
 }
 //# sourceMappingURL=policies.cjs.map

package/__cjs/cache/inmemory/readFromStore.cjs

@@ -289,7 +289,7 @@ class StoreReader {
                         if (typename) {
                             const policy = policies["getFieldPolicy"](typename, fieldName);
                             if (policy?.scalar) {
-                                __DEV__ && invariant_1.invariant.warn(114, `${typename}.${fieldName}`, policy.scalar);
+                                __DEV__ && invariant_1.invariant.warn(116, `${typename}.${fieldName}`, policy.scalar);
                             }
                         }
                     }
@@ -326,7 +326,7 @@ class StoreReader {
             else {
                 const fragment = (0, internal_1.getFragmentFromSelection)(selection, context.lookupFragment);
                 if (!fragment && selection.kind === graphql_1.Kind.FRAGMENT_SPREAD) {
-                    throw (0, invariant_1.newInvariantError)(115, selection.name.value);
+                    throw (0, invariant_1.newInvariantError)(117, selection.name.value);
                 }
                 if (fragment && policies.fragmentMatches(fragment, typename)) {
                     const isDeferBoundary = (0, internal_1.isDeferredFragment)(selection, context.variables);
@@ -624,7 +624,7 @@ function assertSelectionSetForIdValue(store, field, fieldValue) {
             if ((0, internal_1.isNonNullObject)(value)) {
                 (0, invariant_1.invariant)(
                     !(0, utilities_1.isReference)(value),
-                    116,
+                    118,
                     (0, helpers_js_1.getTypenameFromStoreObject)(store, value),
                     field.name.value
                 );

package/__cjs/cache/inmemory/writeToStore.cjs

@@ -75,7 +75,7 @@ class StoreWriter {
             path: [],
         });
         if (!(0, utilities_1.isReference)(ref)) {
-            throw (0, invariant_1.newInvariantError)(117, result);
+            throw (0, invariant_1.newInvariantError)(119, result);
         }
         // So far, the store has not been modified, so now it's time to process
         // context.incomingById and merge those incoming fields into context.store.
@@ -237,7 +237,7 @@ class StoreWriter {
                 // provide a default value, so its absence from the written data should
                 // not be cause for alarm.
                 !policies.getReadFunction(typename, field.name.value)) {
-                invariant_1.invariant.error(118, (0, internal_1.resultKeyNameFromField)(field), result);
+                invariant_1.invariant.error(120, (0, internal_1.resultKeyNameFromField)(field), result);
             }
         });
         // Identify the result object, even if dataId was already provided,
@@ -385,7 +385,7 @@ class StoreWriter {
                 else {
                     const fragment = (0, internal_1.getFragmentFromSelection)(selection, context.lookupFragment);
                     if (!fragment && selection.kind === graphql_1.Kind.FRAGMENT_SPREAD) {
-                        throw (0, invariant_1.newInvariantError)(119, selection.name.value);
+                        throw (0, invariant_1.newInvariantError)(121, selection.name.value);
                     }
                     if (fragment &&
                         policies.fragmentMatches(fragment, typename, result, context.variables)) {
@@ -558,7 +558,7 @@ function warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {
             }
         });
     }
-    __DEV__ && invariant_1.invariant.warn(120, fieldName, parentType, childTypenames.length ?
+    __DEV__ && invariant_1.invariant.warn(122, fieldName, parentType, childTypenames.length ?
         "either ensure all objects of type " +
             childTypenames.join(" and ") +
             " have an ID or a custom merge function, or "

package/__cjs/core/ApolloClient.cjs

@@ -78,8 +78,8 @@ class ApolloClient {
      */
     constructor(options) {
         if (environment_1.__DEV__) {
-            (0, invariant_1.invariant)(options.cache, 68);
-            (0, invariant_1.invariant)(options.link, 69);
+            (0, invariant_1.invariant)(options.cache, 69);
+            (0, invariant_1.invariant)(options.link, 70);
         }
         const { cache, documentTransform, ssrMode = false, ssrForceFetchDelay = 0, queryDeduplication = true, defaultOptions, defaultContext, assumeImmutableResults = cache.assumeImmutableResults, localState, devtools, dataMasking, link, incrementalHandler = new incremental_1.NotImplementedHandler(), experiments = [], refetchEventManager, } = options;
         this.link = link;
@@ -267,12 +267,12 @@ class ApolloClient {
             if (refetchOn) {
                 const operationName = (0, internal_1.getOperationName)(query, "(anonymous)");
                 if (!refetchEventManager) {
-                    __DEV__ && invariant_1.invariant.warn(70, operationName);
+                    __DEV__ && invariant_1.invariant.warn(71, operationName);
                 }
                 else if (typeof refetchOn === "object") {
                     Object.keys(refetchOn).forEach((source) => {
                         if (!refetchEventManager.hasSource(source)) {
-                            __DEV__ && invariant_1.invariant.warn(71, source, operationName);
+                            __DEV__ && invariant_1.invariant.warn(72, source, operationName);
                         }
                     });
                 }
@@ -294,13 +294,13 @@ class ApolloClient {
             options = (0, internal_1.mergeOptions)(this.defaultOptions.query, options);
         }
         if (environment_1.__DEV__) {
-            (0, invariant_1.invariant)(options.fetchPolicy !== "cache-and-network", 72);
-            (0, invariant_1.invariant)(options.fetchPolicy !== "standby", 73);
-            (0, invariant_1.invariant)(options.query, 74);
-            (0, invariant_1.invariant)(options.query.kind === "Document", 75);
-            (0, invariant_1.invariant)(!options.returnPartialData, 76);
-            (0, invariant_1.invariant)(!options.pollInterval, 77);
-            (0, invariant_1.invariant)(!options.notifyOnNetworkStatusChange, 78);
+            (0, invariant_1.invariant)(options.fetchPolicy !== "cache-and-network", 73);
+            (0, invariant_1.invariant)(options.fetchPolicy !== "standby", 74);
+            (0, invariant_1.invariant)(options.query, 75);
+            (0, invariant_1.invariant)(options.query.kind === "Document", 76);
+            (0, invariant_1.invariant)(!options.returnPartialData, 77);
+            (0, invariant_1.invariant)(!options.pollInterval, 78);
+            (0, invariant_1.invariant)(!options.notifyOnNetworkStatusChange, 79);
         }
         return this.queryManager.query(options);
     };
@@ -318,9 +318,9 @@ class ApolloClient {
             errorPolicy: "none",
         }, this.defaultOptions.mutate), options);
         if (environment_1.__DEV__) {
-            (0, invariant_1.invariant)(optionsWithDefaults.mutation, 79);
+            (0, invariant_1.invariant)(optionsWithDefaults.mutation, 80);
             (0, invariant_1.invariant)(optionsWithDefaults.fetchPolicy === "network-only" ||
-                optionsWithDefaults.fetchPolicy === "no-cache", 80);
+                optionsWithDefaults.fetchPolicy === "no-cache", 81);
         }
         (0, internal_1.checkDocument)(optionsWithDefaults.mutation, graphql_1.OperationTypeNode.MUTATION);
         return this.queryManager.mutate(optionsWithDefaults);
@@ -526,7 +526,7 @@ class ApolloClient {
         // result.queries and result.results instead, you shouldn't have to worry
         // about preventing uncaught rejections for the Promise.all result.
         result.catch((error) => {
-            __DEV__ && invariant_1.invariant.debug(81, error);
+            __DEV__ && invariant_1.invariant.debug(82, error);
         });
         return result;
     }

package/__cjs/core/ObservableQuery.cjs

@@ -29,16 +29,29 @@ const empty = {
     dataState: "empty",
     partial: true,
 };
+const destructiveMethodCounts = new WeakMap();
+function wrapDestructiveCacheMethod(cache, methodName) {
+    const original = cache[methodName];
+    if (typeof original === "function") {
+        // @ts-expect-error this is just too generic to be typed correctly
+        cache[methodName] = function () {
+            destructiveMethodCounts.set(cache, 
+            // The %1e15 allows the count to wrap around to 0 safely every
+            // quadrillion evictions, so there's no risk of overflow. To be
+            // clear, this is more of a pedantic principle than something
+            // that matters in any conceivable practical scenario.
+            (destructiveMethodCounts.get(cache) + 1) % 1e15);
+            // @ts-expect-error this is just too generic to be typed correctly
+            return original.apply(this, arguments);
+        };
+    }
+}
 class ObservableQuery {
     options;
     queryName;
     variablesUnknown = false;
-    /**
-    * @internal will be read and written from `QueryInfo`
-    * 
-    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
-    */
-    _lastWrite;
+    didWarnOnFeud = false;
+    lastMissing;
     // The `query` computed property will always reflect the document transformed
     // by the last run query. `this.options.query` will always reflect the raw
     // untransformed query to ensure document transforms with runtime conditionals
@@ -75,6 +88,18 @@ class ObservableQuery {
     }
     constructor({ queryManager, options, transformedQuery = queryManager.transform(options.query), }) {
         this.queryManager = queryManager;
+        // Track how often destructive cache methods are called, since we want
+        // eviction to override the feud-stopping logic in `shouldAutoRefetch`,
+        // by causing it to return true. Wrapping these cache methods is a bit of a
+        // hack, but it saves us from having to make eviction counting an official
+        // part of the ApolloCache API.
+        const { cache } = queryManager;
+        if (!destructiveMethodCounts.has(cache)) {
+            destructiveMethodCounts.set(cache, 0);
+            wrapDestructiveCacheMethod(cache, "evict");
+            wrapDestructiveCacheMethod(cache, "modify");
+            wrapDestructiveCacheMethod(cache, "reset");
+        }
         // active state
         this.waitForNetworkResult = options.fetchPolicy === "network-only";
         this.isTornDown = false;
@@ -85,7 +110,7 @@ class ObservableQuery {
         // Make sure we don't store "standby" as the initialFetchPolicy.
         initialFetchPolicy = fetchPolicy === "standby" ? defaultFetchPolicy : (fetchPolicy), } = options;
         if (options[internal_1.variablesUnknownSymbol]) {
-            (0, invariant_1.invariant)(fetchPolicy === "standby", 82);
+            (0, invariant_1.invariant)(fetchPolicy === "standby", 83);
             this.variablesUnknown = true;
         }
         this.lastQuery = transformedQuery;
@@ -394,7 +419,7 @@ class ObservableQuery {
             const queryDef = (0, internal_1.getQueryDefinition)(this.query);
             const vars = queryDef.variableDefinitions;
             if (!vars || !vars.some((v) => v.variable.name.value === "variables")) {
-                __DEV__ && invariant_1.invariant.warn(83, variables, queryDef.name?.value || queryDef);
+                __DEV__ && invariant_1.invariant.warn(84, variables, queryDef.name?.value || queryDef);
             }
         }
         if (variables && !(0, equality_1.equal)(this.variables, variables)) {
@@ -402,7 +427,6 @@ class ObservableQuery {
             reobserveOptions.variables = this.options.variables =
                 this.getVariablesWithDefaults({ ...this.variables, ...variables });
         }
-        this._lastWrite = undefined;
         return this._reobserve(reobserveOptions, {
             newNetworkStatus: networkStatus_js_1.NetworkStatus.refetch,
         });
@@ -410,7 +434,7 @@ class ObservableQuery {
     fetchMore({ query, variables, context, errorPolicy, updateQuery, }) {
         (0, invariant_1.invariant)(
             this.options.fetchPolicy !== "cache-only",
-            84,
+            85,
             (0, internal_1.getOperationName)(this.query, "(anonymous)")
         );
         const combinedOptions = {
@@ -444,7 +468,7 @@ class ObservableQuery {
         let wasUpdated = false;
         const isCached = this.options.fetchPolicy !== "no-cache";
         if (!isCached) {
-            (0, invariant_1.invariant)(updateQuery, 85);
+            (0, invariant_1.invariant)(updateQuery, 86);
         }
         const { finalize, pushNotification } = this.pushOperation(networkStatus_js_1.NetworkStatus.fetchMore);
         pushNotification({
@@ -618,7 +642,7 @@ class ObservableQuery {
                         onError(error);
                     }
                     else {
-                        invariant_1.invariant.error(86, error);
+                        invariant_1.invariant.error(87, error);
                     }
                     return;
                 }
@@ -869,7 +893,7 @@ class ObservableQuery {
                 if (!this.didWarnCacheOnlyPolling &&
                     pollInterval &&
                     fetchPolicy === "cache-only") {
-                    __DEV__ && invariant_1.invariant.warn(87, (0, internal_1.getOperationName)(this.query, "(anonymous)"));
+                    __DEV__ && invariant_1.invariant.warn(88, (0, internal_1.getOperationName)(this.query, "(anonymous)"));
                     this.didWarnCacheOnlyPolling = true;
                 }
             }
@@ -890,7 +914,6 @@ class ObservableQuery {
             if (this.pollingInfo) {
                 if (!(0, utilities_1.isNetworkRequestInFlight)(this.networkStatus) &&
                     !this.options.skipPollAttempt?.()) {
-                    this._lastWrite = undefined;
                     this._reobserve({
                         // Most fetchPolicy options don't make sense to use in a polling context, as
                         // users wouldn't want to be polling the cache directly. However, network-only and
@@ -936,7 +959,10 @@ class ObservableQuery {
     }
     _reobserve(newOptions, internalOptions) {
         this.isTornDown = false;
-        let { newNetworkStatus } = internalOptions || {};
+        let { newNetworkStatus, keepLastMissing } = internalOptions || {};
+        if (!keepLastMissing) {
+            this.lastMissing = undefined;
+        }
         this.queryManager.obsQueries.add(this);
         const useDisposableObservable = 
         // Refetching uses a disposable Observable to allow refetches using different
@@ -1077,7 +1103,7 @@ class ObservableQuery {
         this.queryManager.obsQueries.delete(this);
         this.isTornDown = true;
         this.abortActiveOperations();
-        this._lastWrite = undefined;
+        this.lastMissing = undefined;
     }
     transformDocument(document) {
         return this.queryManager.transform(document);
@@ -1135,51 +1161,126 @@ class ObservableQuery {
                 return;
             }
         }
-        const { dirty } = this;
+        const { dirty, lastMissing } = this;
+        const { fetchPolicy } = this.options;
         this.resetNotifications();
-        if (dirty &&
-            (this.options.fetchPolicy === "cache-only" ||
-                this.options.fetchPolicy === "cache-and-network" ||
-                !this.activeOperations.size)) {
-            const diff = this.getCacheDiff();
-            if (
-            // `fromOptimisticTransaction` is not available through the `cache.diff`
-            // code path, so we need to check it this way
-            (0, equality_1.equal)(diff.result, this.getCacheDiff({ optimistic: false }).result)) {
-                //If this diff did not come from an optimistic transaction
-                // make the ObservableQuery "reobserve" the latest data
-                // using a temporary fetch policy of "cache-first", so complete cache
-                // results have a chance to be delivered without triggering additional
-                // network requests, even when options.fetchPolicy is "network-only"
-                // or "cache-and-network". All other fetch policies are preserved by
-                // this method, and are handled by calling oq.reobserve(). If this
-                // reobservation is spurious, distinctUntilChanged still has a
-                // chance to catch it before delivery to ObservableQuery subscribers.
-                this.reobserveCacheFirst();
+        if (!dirty ||
+            (fetchPolicy !== "cache-only" &&
+                fetchPolicy !== "cache-and-network" &&
+                this.activeOperations.size)) {
+            return;
+        }
+        const diff = this.getCacheDiff();
+        const current = this.getCurrentResult();
+        // `fromOptimisticTransaction` is not available through the `cache.diff`
+        // code path, so we need to check whether the cache result is an optimistic
+        // result this way.
+        const isOptimistic = !(0, equality_1.equal)(diff.result, this.getCacheDiff({ optimistic: false }).result);
+        if (
+        // When this diff came from an optimistic transaction, deliver the
+        // current cache data to the ObservableQuery, but don't perform a
+        // reobservation, since oq.reobserveCacheFirst might make a network
+        // request, and we never want to trigger network requests in the
+        // middle of optimistic updates.
+        isOptimistic ||
+            // If we get a cache update in the middle of streaming (possible with
+            // cache-and-network fetch policy), just deliver the cache value without
+            // going through the full reobserve which would otherwise trigger another
+            // request (deduplication should kick in, but doing so replays any
+            // previous emits from the link chain, which get rewritten into the cache
+            // and might clobber this cache update)
+            (!diff.complete && current.networkStatus === networkStatus_js_1.NetworkStatus.streaming)) {
+            this.deliverCacheDiff(diff);
+            return;
+        }
+        if (diff.complete) {
+            this.lastMissing = undefined;
+        }
+        else if (!lastMissing ||
+            // If a destructive cache method has been called since the last recorded
+            // incomplete result, there's a chance fetching this data again will
+            // restore what was evicted, even though the cache result looks the same
+            // as before.
+            lastMissing.dmCount !== destructiveMethodCounts.get(this.cache) ||
+            !(0, equality_1.equal)(lastMissing.variables, this.variables) ||
+            !(0, equality_1.equal)(lastMissing.missing, diff.missing?.missing)) {
+            this.didWarnOnFeud = false;
+            this.lastMissing = {
+                variables: this.variables,
+                missing: diff.missing?.missing,
+                dmCount: destructiveMethodCounts.get(this.cache),
+            };
+        }
+        else if (
+        // reobserveCacheFirst with cache-only fetch policy only calls
+        // reobserve which never fetches from the network so we are ok
+        // allowing cache-only queries to fallthrough to reobserveCacheFirst.
+        // This also prevents the feud warning which would be confusing for a
+        // cache-only query anyways.
+        fetchPolicy !== "cache-only") {
+            // If we've fallen through to this case, a cache emit has returned the
+            // same missing fields which means at least one value on the fields we've
+            // already delivered have changed. We are ok delivering the updated
+            // partial result in this case to keep the result as fresh as possible. We
+            // NEVER want to downgrade this query from a complete query to a partial
+            // query though, so we also make sure we only deliver if the previous
+            // result was also partial.
+            if (current.dataState === "partial") {
+                this.deliverCacheDiff(diff);
             }
-            else {
-                // If this diff came from an optimistic transaction, deliver the
-                // current cache data to the ObservableQuery, but don't perform a
-                // reobservation, since oq.reobserveCacheFirst might make a network
-                // request, and we never want to trigger network requests in the
-                // middle of optimistic updates.
-                this.input.next({
-                    kind: "N",
-                    value: {
-                        data: diff.result,
-                        dataState: diff.dataState,
-                        networkStatus: networkStatus_js_1.NetworkStatus.ready,
-                        loading: false,
-                        error: undefined,
-                        partial: !diff.complete,
-                    },
-                    source: "cache",
-                    query: this.query,
-                    variables: this.variables,
-                    meta: {},
-                });
+            // If the (partial) result is the same as the last partial result
+            // we recorded from a previous broadcast (and the variables match
+            // too), avoid calling reobserveCacheFirst to refetch this query
+            // again. If we allow refetching anytime this result becomes partial,
+            // we risk feuds between queries competing to update the same data in
+            // incompatible ways, which can lead to an endless cycle of cache
+            // broadcasts and useless network requests. As with any
+            // feud, eventually one side must step back from the brink,
+            // letting the other side(s) have the last word(s). There may
+            // be other points where we could break this cycle, such as
+            // silencing the broadcast for cache.writeQuery (not a good
+            // idea, since it just delays the feud a bit) or somehow
+            // avoiding the network request that just happened (also bad,
+            // because the server could return useful new data). All
+            // options considered, returning early and stopping the
+            // reobserveCacheFirst cycle seems to be the least damaging place to
+            // break the cycle because it allows read functions/custom scalars to
+            // be applied to the feuding query while avoiding the endless cycle of
+            // requests.
+            if (environment_1.__DEV__ && !this.didWarnOnFeud) {
+                this.didWarnOnFeud = true;
+                warnOnFeud(this.query, diff);
             }
+            return;
         }
+        //If this diff did not come from an optimistic transaction
+        // make the ObservableQuery "reobserve" the latest data
+        // using a temporary fetch policy of "cache-first", so complete cache
+        // results have a chance to be delivered without triggering additional
+        // network requests, even when options.fetchPolicy is "network-only"
+        // or "cache-and-network". All other fetch policies are preserved by
+        // this method, and are handled by calling oq.reobserve(). If this
+        // reobservation is spurious, distinctUntilChanged still has a
+        // chance to catch it before delivery to ObservableQuery subscribers.
+        this.reobserveCacheFirst();
+    }
+    deliverCacheDiff(diff) {
+        const current = this.getCurrentResult();
+        this.input.next({
+            kind: "N",
+            value: {
+                data: diff.result,
+                dataState: diff.dataState,
+                networkStatus: current.networkStatus,
+                loading: current.loading,
+                error: undefined,
+                partial: !diff.complete,
+            },
+            source: "cache",
+            query: this.query,
+            variables: this.variables,
+            meta: {},
+        });
     }
     activeOperations = new Set();
     pushOperation(networkStatus) {
@@ -1242,6 +1343,7 @@ class ObservableQuery {
         // exception for cache-only queries - we reset them into a "ready" state
         // as we won't trigger a refetch for them
         const resetToEmpty = this.options.fetchPolicy === "cache-only";
+        this.lastMissing = undefined;
         this.setResult(resetToEmpty ? empty : uninitialized, {
             shouldEmit: resetToEmpty ? 1 /* EmitBehavior.force */ : 2 /* EmitBehavior.never */,
         });
@@ -1386,7 +1488,10 @@ class ObservableQuery {
     reobserveCacheFirst() {
         const { fetchPolicy, nextFetchPolicy } = this.options;
         if (fetchPolicy === "cache-and-network" || fetchPolicy === "network-only") {
-            this.reobserve({
+            // Preserve this.lastMissing so a cache update that triggers this
+            // reobserve doesn't reset feud detection. All user-initiated calls to
+            // reobserve (refetch/poll/reobserve, etc) should clear it.
+            this._reobserve({
                 fetchPolicy: "cache-first",
                 // Use a temporary nextFetchPolicy function that replaces itself with the
                 // previous nextFetchPolicy value and returns the original fetchPolicy.
@@ -1402,10 +1507,10 @@ class ObservableQuery {
                     // Otherwise go back to the original this.options.fetchPolicy.
                     return fetchPolicy;
                 },
-            });
+            }, { keepLastMissing: true });
         }
         else {
-            this.reobserve();
+            this._reobserve(undefined, { keepLastMissing: true });
         }
     }
     getVariablesWithDefaults(variables) {
@@ -1415,7 +1520,7 @@ class ObservableQuery {
 exports.ObservableQuery = ObservableQuery;
 function logMissingFieldErrors(missing) {
     if (environment_1.__DEV__ && missing) {
-        __DEV__ && invariant_1.invariant.debug(88, missing);
+        __DEV__ && invariant_1.invariant.debug(89, missing);
     }
 }
 function isEqualQuery(a, b) {
@@ -1458,4 +1563,11 @@ function getTrackingOperatorPromise(defaultValue) {
     });
     return { promise, operator };
 }
+function warnOnFeud(query, diff) {
+    __DEV__ && invariant_1.invariant.warn(
+        90,
+        (0, internal_1.getOperationName)(query, "(anonymous)"),
+        diff.missing?.missing
+    );
+}
 //# sourceMappingURL=ObservableQuery.cjs.map