@apollo/client 4.0.0-alpha.21 → 4.0.0-alpha.23

package/core/ObservableQuery.d.ts

@@ -6,13 +6,51 @@ import type { MissingTree } from "@apollo/client/cache";
 import type { MaybeMasked, Unmasked } from "@apollo/client/masking";
 import type { QueryManager } from "./QueryManager.js";
 import type { ApolloQueryResult, DefaultContext, OperationVariables, QueryResult, TypedDocumentNode } from "./types.js";
-import type { ErrorPolicy, FetchMoreQueryOptions, NextFetchPolicyContext, RefetchWritePolicy, SubscribeToMoreOptions, UpdateQueryMapFn, WatchQueryFetchPolicy, WatchQueryOptions } from "./watchQueryOptions.js";
-export interface FetchMoreOptions<TData = unknown, TVariables = OperationVariables> {
-    updateQuery?: (previousQueryResult: TData, options: {
-        fetchMoreResult?: TData;
-        variables?: TVariables;
-    }) => TData;
-}
+import type { ErrorPolicy, NextFetchPolicyContext, RefetchWritePolicy, SubscribeToMoreOptions, UpdateQueryMapFn, WatchQueryFetchPolicy, WatchQueryOptions } from "./watchQueryOptions.js";
+export type FetchMoreOptions<TData, TVariables extends OperationVariables, TFetchData = TData, TFetchVars extends OperationVariables = TVariables> = {
+    /**
+    * A GraphQL query string parsed into an AST with the gql template literal.
+    * 
+    * @docGroup
+    * 
+    * 1. Operation options
+    */
+    query?: DocumentNode | TypedDocumentNode<TFetchData, TFetchVars>;
+    /**
+    * An object containing all of the GraphQL variables your query requires to execute.
+    * 
+    * Each key in the object corresponds to a variable name, and that key's value corresponds to the variable value.
+    * 
+    * @docGroup
+    * 
+    * 1. Operation options
+    */
+    variables?: Partial<NoInfer<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?: ErrorPolicy;
+    /**
+    * If you're using [Apollo Link](https://www.apollographql.com/docs/react/api/link/introduction/), this object is the initial value of the `context` object that's passed along your link chain.
+    * 
+    * @docGroup
+    * 
+    * 2. Networking options
+    */
+    context?: DefaultContext;
+    updateQuery?: (previousQueryResult: Unmasked<TData>, options: {
+        fetchMoreResult: Unmasked<TFetchData>;
+        variables: TFetchVars;
+    }) => Unmasked<TData>;
+};
 export declare namespace ObservableQuery {
     type Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
         /**
@@ -232,12 +270,7 @@ 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>(fetchMoreOptions: FetchMoreQueryOptions<TFetchVars, TFetchData> & {
-        updateQuery?: (previousQueryResult: Unmasked<TData>, options: {
-            fetchMoreResult: Unmasked<TFetchData>;
-            variables: TFetchVars;
-        }) => Unmasked<TData>;
-    }): Promise<QueryResult<TFetchData>>;
+    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>({ query, variables, context, errorPolicy, updateQuery, }: FetchMoreOptions<TData, TVariables, TFetchData, TFetchVars>): Promise<QueryResult<TFetchData>>;
     /**
      * 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.
      *
@@ -249,7 +282,7 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
     * 
     * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
     */
-    silentSetOptions(newOptions: Partial<ObservableQuery.Options<TData, TVariables>>): void;
+    applyOptions(newOptions: Partial<ObservableQuery.Options<TData, TVariables>>): void;
     /**
      * Update the variables of this observable query, and fetch the new results
      * if they've changed. Most users should prefer `refetch` instead of
@@ -285,6 +318,7 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
     stopPolling(): void;
     private applyNextFetchPolicy;
     private fetch;
+    private didWarnCacheOnlyPolling;
     private updatePolling;
     private cancelPolling;
     /**

package/core/ObservableQuery.js

@@ -1,7 +1,7 @@
 import { equal } from "@wry/equality";
 import { BehaviorSubject, Observable, share, Subject, tap } from "rxjs";
 import { __DEV__ } from "@apollo/client/utilities/environment";
-import { compact, filterMap, getOperationDefinition, getQueryDefinition, preventUnhandledRejection, toQueryResult, } from "@apollo/client/utilities/internal";
+import { compact, filterMap, getOperationDefinition, getOperationName, getQueryDefinition, preventUnhandledRejection, toQueryResult, } from "@apollo/client/utilities/internal";
 import { invariant } from "@apollo/client/utilities/invariant";
 import { equalByQuery } from "./equalByQuery.js";
 import { isNetworkRequestInFlight, NetworkStatus } from "./networkStatus.js";
@@ -183,13 +183,6 @@ export class ObservableQuery {
         const fetchPolicy = this.queryManager.prioritizeCacheValues ?
             "cache-first"
             : initialFetchPolicy || this.options.fetchPolicy;
-        const defaultResult = {
-            data: undefined,
-            dataState: "empty",
-            loading: true,
-            networkStatus: NetworkStatus.loading,
-            partial: true,
-        };
         const cacheResult = () => {
             const diff = this.getCacheDiff();
             // TODO: queryInfo.getDiff should handle this since cache.diff returns a
@@ -208,7 +201,13 @@ export class ObservableQuery {
             });
         };
         switch (fetchPolicy) {
-            case "cache-only":
+            case "cache-only": {
+                return {
+                    ...cacheResult(),
+                    loading: false,
+                    networkStatus: NetworkStatus.ready,
+                };
+            }
             case "cache-first":
                 return cacheResult();
             case "cache-and-network":
@@ -218,13 +217,9 @@ export class ObservableQuery {
                     networkStatus: NetworkStatus.loading,
                 };
             case "standby":
-                return {
-                    ...defaultResult,
-                    loading: false,
-                    networkStatus: NetworkStatus.ready,
-                };
+                return empty;
             default:
-                return defaultResult;
+                return uninitialized;
         }
     }
     resubscribeCache() {
@@ -327,6 +322,7 @@ export class ObservableQuery {
      * the previous values of those variables will be used.
      */
     refetch(variables) {
+        const { fetchPolicy } = this.options;
         const reobserveOptions = {
             // Always disable polling for refetches.
             pollInterval: 0,
@@ -334,7 +330,6 @@ export class ObservableQuery {
         // Unless the provided fetchPolicy always consults the network
         // (no-cache, network-only, or cache-and-network), override it with
         // network-only to force the refetch for this fetchQuery call.
-        const { fetchPolicy } = this.options;
         if (fetchPolicy === "no-cache") {
             reobserveOptions.fetchPolicy = "no-cache";
         }
@@ -345,7 +340,7 @@ export class ObservableQuery {
             const queryDef = getQueryDefinition(this.query);
             const vars = queryDef.variableDefinitions;
             if (!vars || !vars.some((v) => v.variable.name.value === "variables")) {
-                __DEV__ && invariant.warn(76, variables, queryDef.name?.value || queryDef);
+                __DEV__ && invariant.warn(79, variables, queryDef.name?.value || queryDef);
             }
         }
         if (variables && !equal(this.variables, variables)) {
@@ -361,16 +356,21 @@ export class ObservableQuery {
     /**
      * 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(fetchMoreOptions) {
+    fetchMore({ query, variables, context, errorPolicy, updateQuery, }) {
+        invariant(
+            this.options.fetchPolicy !== "cache-only",
+            80,
+            getOperationName(this.query, "(anonymous)")
+        );
         const combinedOptions = {
-            ...(fetchMoreOptions.query ? fetchMoreOptions : ({
-                ...this.options,
-                query: this.options.query,
-                ...fetchMoreOptions,
-                variables: {
-                    ...this.variables,
-                    ...fetchMoreOptions.variables,
-                },
+            ...compact(this.options, { errorPolicy: "none" }, {
+                query,
+                context,
+                errorPolicy,
+            }),
+            variables: (query ? variables : ({
+                ...this.variables,
+                ...variables,
             })),
             // The fetchMore request goes immediately to the network and does
             // not automatically write its result to the cache (hence no-cache
@@ -387,14 +387,13 @@ export class ObservableQuery {
         // as well as the document passed in `fetchMoreOptions` to ensure the cache
         // uses the most up-to-date document which may rely on runtime conditionals.
         this.lastQuery =
-            fetchMoreOptions.query ?
+            query ?
                 this.transformDocument(this.options.query)
                 : combinedOptions.query;
         let wasUpdated = false;
-        const updateQuery = fetchMoreOptions?.updateQuery;
         const isCached = this.options.fetchPolicy !== "no-cache";
         if (!isCached) {
-            invariant(updateQuery, 77);
+            invariant(updateQuery, 81);
         }
         const { finalize, pushNotification } = this.pushOperation(NetworkStatus.fetchMore);
         pushNotification({
@@ -418,7 +417,6 @@ export class ObservableQuery {
                 // fetchMore cache results back to this ObservableQuery.
                 this.queryManager.cache.batch({
                     update: (cache) => {
-                        const { updateQuery } = fetchMoreOptions;
                         if (updateQuery) {
                             cache.updateQuery({
                                 query: this.query,
@@ -527,7 +525,7 @@ export class ObservableQuery {
                         onError(error);
                     }
                     else {
-                        __DEV__ && invariant.error(78, error);
+                        __DEV__ && invariant.error(82, error);
                     }
                     return;
                 }
@@ -551,9 +549,10 @@ export class ObservableQuery {
     * 
     * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
     */
-    silentSetOptions(newOptions) {
+    applyOptions(newOptions) {
         const mergedOptions = compact(this.options, newOptions || {});
         assign(this.options, mergedOptions);
+        this.updatePolling();
     }
     /**
      * Update the variables of this observable query, and fetch the new results
@@ -760,20 +759,28 @@ export class ObservableQuery {
         return { fromLink, subscription, observable };
     }
     // Turns polling on or off based on this.options.pollInterval.
+    didWarnCacheOnlyPolling = false;
     updatePolling() {
         // Avoid polling in SSR mode
         if (this.queryManager.ssrMode) {
             return;
         }
-        const { pollingInfo, options: { pollInterval }, } = this;
-        if (!pollInterval || !this.hasObservers()) {
+        const { pollingInfo, options: { fetchPolicy, pollInterval }, } = this;
+        if (!pollInterval || !this.hasObservers() || fetchPolicy === "cache-only") {
+            if (__DEV__) {
+                if (!this.didWarnCacheOnlyPolling &&
+                    pollInterval &&
+                    fetchPolicy === "cache-only") {
+                    __DEV__ && invariant.warn(83, getOperationName(this.query, "(anonymous)"));
+                    this.didWarnCacheOnlyPolling = true;
+                }
+            }
             this.cancelPolling();
             return;
         }
-        if (pollingInfo && pollingInfo.interval === pollInterval) {
+        if (pollingInfo?.interval === pollInterval) {
             return;
         }
-        invariant(pollInterval, 79);
         const info = pollingInfo || (this.pollingInfo = {});
         info.interval = pollInterval;
         const maybeFetch = () => {
@@ -973,17 +980,14 @@ export class ObservableQuery {
         return this.queryManager.transform(document);
     }
     maskResult(result) {
-        return result && "data" in result ?
-            {
-                ...result,
-                data: this.queryManager.maskOperation({
-                    document: this.query,
-                    data: result.data,
-                    fetchPolicy: this.options.fetchPolicy,
-                    cause: this,
-                }),
-            }
-            : result;
+        const masked = this.queryManager.maskOperation({
+            document: this.query,
+            data: result.data,
+            fetchPolicy: this.options.fetchPolicy,
+            cause: this,
+        });
+        // Maintain object identity as much as possible
+        return masked === result.data ? result : { ...result, data: masked };
     }
     dirty = false;
     notifyTimeout;
@@ -1190,7 +1194,7 @@ export class ObservableQuery {
                         loading: false,
                     }
                     : notification.value;
-            if (result.error && result.dataState === "streaming") {
+            if (notification.kind === "E" && result.dataState === "streaming") {
                 result.dataState = "complete";
             }
             if (result.error) {
@@ -1259,7 +1263,7 @@ export class ObservableQuery {
 }
 export function logMissingFieldErrors(missing) {
     if (__DEV__ && missing) {
-        __DEV__ && invariant.debug(80, missing);
+        __DEV__ && invariant.debug(84, missing);
     }
 }
 function isEqualQuery(a, b) {