@apollo/client 4.3.0-alpha.3 → 4.3.0-alpha.5

package/core/ObservableQuery.d.ts

@@ -372,7 +372,18 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
     /**
      * A function that helps you fetch the next set of results for a [paginated list field](https://www.apollographql.com/docs/react/pagination/core-api/).
      */
-    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(options: ObservableQuery.FetchMoreOptions<TData, TVariables, TFetchData, TFetchVars>): Promise<ApolloClient.QueryResult<TFetchData>>;
+    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables, TErrorPolicy extends ErrorPolicy = "none">(options: ObservableQuery.FetchMoreOptions<TData, TVariables, TFetchData, TFetchVars> & {
+        /**
+        * Specifies how the query 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 query result includes error details but not partial results.
+        * 
+        * @docGroup 1. Operation options
+        */
+        errorPolicy?: TErrorPolicy;
+    }): Promise<ApolloClient.QueryResult<TFetchData, TErrorPolicy>>;
     /**
      * A function that enables you to execute a [subscription](https://www.apollographql.com/docs/react/data/subscriptions/), usually to subscribe to specific fields that were included in the query.
      *

package/core/ObservableQuery.js

@@ -4,6 +4,7 @@ import { isNetworkRequestInFlight, isNetworkRequestSettled, } from "@apollo/clie
 import { __DEV__ } from "@apollo/client/utilities/environment";
 import { compact, equalByQuery, extensionsSymbol, filterMap, getOperationDefinition, getOperationName, getQueryDefinition, preventUnhandledRejection, toQueryResult, variablesUnknownSymbol, } from "@apollo/client/utilities/internal";
 import { invariant } from "@apollo/client/utilities/invariant";
+import { dataStateErrorCache } from "./dataStateErrorCache.js";
 import { NetworkStatus } from "./networkStatus.js";
 const { assign, hasOwnProperty } = Object;
 const uninitialized = {
@@ -878,6 +879,7 @@ export class ObservableQuery {
             if (this.pollingInfo) {
                 if (!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
@@ -1252,13 +1254,49 @@ export class ObservableQuery {
         });
     }
     operator = 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" || !isEqualQuery(notification, this)) {
+        if (notification.kind === "C") {
+            return;
+        }
+        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 (!equal(resolvedVariables, this.variables)) {
+            if (!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") {
@@ -1279,7 +1317,9 @@ export class ObservableQuery {
             result =
                 notification.kind === "E" ?
                     {
-                        ...(isEqualQuery(previous, notification) ?
+                        ...((isEqualQuery(previous, notification) ||
+                            (resolvedVariables &&
+                                equal(resolvedVariables, previous.variables))) ?
                             previous.result
                             : { data: undefined, dataState: "empty", partial: true }),
                         error: notification.error,
@@ -1288,7 +1328,8 @@ export class ObservableQuery {
                     }
                     : notification.value;
             if (notification.kind === "E" && result.dataState === "streaming") {
-                result.dataState = "complete";
+                result.dataState =
+                    dataStateErrorCache.get(notification.error) ?? "complete";
             }
             if (result.error) {
                 meta.shouldEmit = 1 /* EmitBehavior.force */;