@apollo/client 4.3.0-alpha.0 → 4.3.0-alpha.10

package/__cjs/core/ApolloClient.d.cts

@@ -8,7 +8,7 @@ import type { ClientAwarenessLink } from "@apollo/client/link/client-awareness";
 import type { LocalState } from "@apollo/client/local-state";
 import type { MaybeMasked, Unmasked } from "@apollo/client/masking";
 import { DocumentTransform } from "@apollo/client/utilities";
-import type { LazyType, OptionWithFallback, SignatureStyle, VariablesOption, variablesUnknownSymbol } from "@apollo/client/utilities/internal";
+import type { LazyType, OptionWithFallback, Prettify, SignatureStyle, VariablesOption, variablesUnknownSymbol } from "@apollo/client/utilities/internal";
 import { getApolloClientMemoryInternals } from "@apollo/client/utilities/internal";
 import type { DeclareDefaultOptions, DefaultOptions } from "./defaultOptions.cjs";
 import type { ObservableQuery } from "./ObservableQuery.cjs";
@@ -232,7 +232,20 @@ export declare namespace ApolloClient {
     export namespace mutate {
         interface DefaultOptions extends ApolloClient.DefaultOptions.Mutate.Calculated {
         }
-        type ResultForOptions<TData, TVariables extends OperationVariables, TCache extends Cache.Implementation, TOptions extends Record<string, unknown> | MutateOptions<any, TVariables, TCache>> = LazyType<MutateResult<MaybeMasked<TData>, OptionWithFallback<TOptions, DefaultOptions, "errorPolicy"> & ErrorPolicy>>;
+        type OptionsFor<TData, TVariables extends OperationVariables, TCache extends Cache.Implementation, TOptions extends {
+            variables?: unknown;
+        }> = MutateOptions<NoInfer<TData>, NoInfer<TVariables>, TCache> & {
+            variables?: Prettify<TVariables & {
+                [K in keyof TOptions["variables"]]: K extends keyof TVariables ? TVariables[K] : never;
+            }>;
+        } & (Exclude<keyof TOptions, keyof MutateOptions<any, any, any>> extends (infer InvalidOptionNames extends string) ? [
+            InvalidOptionNames
+        ] extends [never] ? unknown : {
+            [K in InvalidOptionNames]: never;
+        } : never);
+        type ResultForOptions<TData, TErrorPolicy extends ErrorPolicy | undefined = undefined> = LazyType<MutateResult<MaybeMasked<TData>, OptionWithFallback<{
+            errorPolicy: TErrorPolicy;
+        }, DefaultOptions, "errorPolicy"> & ErrorPolicy>>;
         namespace Signatures {
             interface Classic {
                 /**
@@ -271,11 +284,21 @@ export declare namespace ApolloClient {
                 * 
                 * It takes options as an object with the following keys and values:
                 */
-                <TData, TVariables extends OperationVariables, TOptions extends ApolloClient.MutateOptions<NoInfer<TData>, NoInfer<TVariables>, Cache.Implementation> & VariablesOption<TVariables & {
-                    [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
-                }>>(options: TOptions & {
+                <TData, TVariables extends OperationVariables, TOptions extends Omit<ApolloClient.MutateOptions<NoInfer<TData>, any, Cache.Implementation>, "variables"> & {
+                    variables?: unknown;
+                }, TErrorPolicy extends ErrorPolicy | undefined = undefined>(options: TOptions & ApolloClient.mutate.OptionsFor<TData, TVariables, Cache.Implementation, TOptions> & {
                     mutation: TypedDocumentNode<TData, TVariables>;
-                }): Promise<ApolloClient.mutate.ResultForOptions<TData, TVariables, Cache.Implementation, TOptions>>;
+                    /**
+                    * Specifies how the mutation handles a response that returns both GraphQL errors and partial results.
+                    * 
+                    * For details, see [GraphQL error policies](https://www.apollographql.com/docs/react/data/error-handling/#graphql-error-policies).
+                    * 
+                    * The default value is `none`, meaning that the mutation result includes error details but _not_ partial results.
+                    * 
+                    * @docGroup 1. Operation options
+                    */
+                    errorPolicy?: TErrorPolicy;
+                }): Promise<ApolloClient.mutate.ResultForOptions<TData, TErrorPolicy>>;
             }
             type Evaluated = SignatureStyle extends "classic" ? Classic : Modern;
         }
@@ -473,7 +496,18 @@ export declare namespace ApolloClient {
     export namespace query {
         interface DefaultOptions extends ApolloClient.DefaultOptions.Query.Calculated {
         }
-        type ResultForOptions<TData, TVariables extends OperationVariables, TOptions extends Record<string, unknown> | QueryOptions<any, TVariables>> = LazyType<QueryResult<MaybeMasked<TData>, OptionWithFallback<TOptions, DefaultOptions, "errorPolicy"> & ErrorPolicy>>;
+        type OptionsFor<TData, TVariables extends OperationVariables, TOptions extends {
+            variables?: unknown;
+        }> = QueryOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+            variables?: Prettify<TVariables & {
+                [K in keyof TOptions["variables"]]: K extends keyof TVariables ? TVariables[K] : never;
+            }>;
+        } & (Exclude<keyof TOptions, keyof QueryOptions<any, any>> extends (infer InvalidOptionNames extends string) ? [
+            InvalidOptionNames
+        ] extends [never] ? unknown : {
+            [K in InvalidOptionNames]: never;
+        } : never);
+        type ResultForOptions<TData, TVariables extends OperationVariables, TOptions extends Record<string, unknown> | Omit<QueryOptions<any, any>, "variables">> = LazyType<QueryResult<MaybeMasked<TData>, OptionWithFallback<TOptions, DefaultOptions, "errorPolicy"> & ErrorPolicy>>;
         namespace Signatures {
             interface Classic {
                 /**
@@ -515,9 +549,9 @@ export declare namespace ApolloClient {
                 * describe how this query should be treated e.g. whether it should hit the
                 * server at all or just resolve from the cache, etc.
                 */
-                <TData, TVariables extends OperationVariables, TOptions extends ApolloClient.QueryOptions<NoInfer<TData>, NoInfer<TVariables>> & VariablesOption<TVariables & {
-                    [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
-                }>>(options: TOptions & {
+                <TData, TVariables extends OperationVariables, TOptions extends Omit<ApolloClient.QueryOptions<NoInfer<TData>, any>, "variables"> & {
+                    variables?: unknown;
+                }>(options: TOptions & ApolloClient.query.OptionsFor<TData, TVariables, TOptions> & {
                     query: TypedDocumentNode<TData, TVariables>;
                 }): Promise<ApolloClient.query.ResultForOptions<TData, TVariables, TOptions>>;
             }

package/__cjs/core/ObservableQuery.cjs

@@ -12,6 +12,7 @@ const utilities_1 = require("@apollo/client/utilities");
 const environment_1 = require("@apollo/client/utilities/environment");
 const internal_1 = require("@apollo/client/utilities/internal");
 const invariant_1 = require("@apollo/client/utilities/invariant");
+const dataStateErrorCache_js_1 = require("./dataStateErrorCache.cjs");
 const networkStatus_js_1 = require("./networkStatus.cjs");
 const { assign, hasOwnProperty } = Object;
 const uninitialized = {
@@ -28,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
@@ -74,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;
@@ -84,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;
@@ -213,12 +239,13 @@ class ObservableQuery {
     * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
     */
     getCacheDiff({ optimistic = true } = {}) {
-        return this.cache.diff({
+        return (0, internal_1.toDiffWithDataState)(this.cache.diff({
             query: this.query,
             variables: this.variables,
             returnPartialData: true,
             optimistic,
-        });
+            [internal_1.handleIncrementalSymbol]: undefined,
+        }));
     }
     getInitialResult(initialFetchPolicy) {
         let fetchPolicy = initialFetchPolicy || this.options.fetchPolicy;
@@ -228,16 +255,18 @@ class ObservableQuery {
         }
         const cacheResult = () => {
             const diff = this.getCacheDiff();
+            let { dataState } = diff;
             // TODO: queryInfo.getDiff should handle this since cache.diff returns a
             // null when returnPartialData is false
             const data = this.options.returnPartialData || diff.complete ?
                 diff.result ?? undefined
                 : undefined;
+            if (data === undefined) {
+                dataState = "empty";
+            }
             return this.maskResult({
                 data,
-                dataState: diff.complete ? "complete"
-                    : data === undefined ? "empty"
-                        : "partial",
+                dataState,
                 loading: !diff.complete,
                 networkStatus: diff.complete ? networkStatus_js_1.NetworkStatus.ready : networkStatus_js_1.NetworkStatus.loading,
                 partial: !diff.complete,
@@ -390,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)) {
@@ -398,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,
         });
@@ -406,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 = {
@@ -440,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({
@@ -517,9 +545,7 @@ class ObservableQuery {
                                             // will be overwritten anyways, just here for types sake
                                             loading: false,
                                             data: diff.result,
-                                            dataState: fetchMoreResult.dataState === "streaming" ?
-                                                "streaming"
-                                                : "complete",
+                                            dataState: diff.complete ? "complete" : "streaming",
                                         },
                                     });
                                 }
@@ -616,7 +642,7 @@ class ObservableQuery {
                         onError(error);
                     }
                     else {
-                        invariant_1.invariant.error(86, error);
+                        invariant_1.invariant.error(87, error);
                     }
                     return;
                 }
@@ -867,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;
                 }
             }
@@ -933,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
@@ -1074,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);
@@ -1132,53 +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.complete ? "complete"
-                            : diff.result ? "partial"
-                                : "empty",
-                        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) {
@@ -1241,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 */,
         });
@@ -1262,19 +1365,55 @@ class ObservableQuery {
         });
     }
     operator = (0, internal_1.filterMap)((notification) => {
-        const { query, variables, meta } = notification;
+        const { query, meta } = notification;
         if (notification.source === "setResult") {
-            return { query, variables, result: notification.value, meta };
+            return {
+                query,
+                variables: this.variables,
+                result: notification.value,
+                meta,
+            };
+        }
+        if (notification.kind === "C") {
+            return;
         }
-        if (notification.kind === "C" || !isEqualQuery(notification, this)) {
+        const resolvedVariables = "resolvedVariables" in notification ?
+            notification.resolvedVariables
+            : undefined;
+        // Usually we prefer to drop notifications that don't match this query
+        // but this breaks when used with `@export` queries that resolve variables
+        // after the request is initiated. `notification.resolvedVariables` gives us
+        // the variables the query actually resolved with during evaluation in
+        // QueryManager (which is the variables value after `@export` variables have
+        // been applied), but we need to update this query with those resolved
+        // variables maybe in the middle of a request (updating is handled below).
+        // When we update this.variables to the resolved variables, this causes
+        // isEqualQuery(notification, this) to fail for future notifications since
+        // the notification.variables holds the stale variables value. In this case,
+        // we want to allow the notification through only if the current variables
+        // value matches the resolved variables.
+        //
+        // Note: the check for matching resolved variables typically kicks in for
+        // multi-emission fetches (such as defer, or cache-and-network, etc).
+        if (notification.query !== this.query) {
             return;
         }
+        if (!(0, equality_1.equal)(resolvedVariables, this.variables)) {
+            if (!(0, equality_1.equal)(notification.variables, this.variables)) {
+                return;
+            }
+            if (resolvedVariables) {
+                this.options.variables = resolvedVariables;
+                this.resubscribeCache();
+            }
+        }
+        const variables = this.variables;
         let result;
         const previous = this.subject.getValue();
         if (notification.source === "cache") {
             result = notification.value;
             if (result.networkStatus === networkStatus_js_1.NetworkStatus.ready &&
-                result.partial &&
+                result.dataState === "partial" &&
                 (!this.options.returnPartialData ||
                     previous.result.networkStatus === networkStatus_js_1.NetworkStatus.error) &&
                 this.options.fetchPolicy !== "cache-only") {
@@ -1289,7 +1428,9 @@ class ObservableQuery {
             result =
                 notification.kind === "E" ?
                     {
-                        ...(isEqualQuery(previous, notification) ?
+                        ...((isEqualQuery(previous, notification) ||
+                            (resolvedVariables &&
+                                (0, equality_1.equal)(resolvedVariables, previous.variables))) ?
                             previous.result
                             : { data: undefined, dataState: "empty", partial: true }),
                         error: notification.error,
@@ -1298,7 +1439,8 @@ class ObservableQuery {
                     }
                     : notification.value;
             if (notification.kind === "E" && result.dataState === "streaming") {
-                result.dataState = "complete";
+                result.dataState =
+                    dataStateErrorCache_js_1.dataStateErrorCache.get(notification.error) ?? "complete";
             }
             if (result.error) {
                 meta.shouldEmit = 1 /* EmitBehavior.force */;
@@ -1346,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.
@@ -1362,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) {
@@ -1375,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) {
@@ -1418,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