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

package/core/QueryManager.d.ts

@@ -9,7 +9,7 @@ import type { DefaultOptions } from "./ApolloClient.js";
 import type { LocalState } from "./LocalState.js";
 import { NetworkStatus } from "./networkStatus.js";
 import { ObservableQuery } from "./ObservableQuery.js";
-import type { ApolloQueryResult, DefaultContext, InternalRefetchQueriesInclude, InternalRefetchQueriesMap, InternalRefetchQueriesOptions, MutationUpdaterFunction, OnQueryUpdated, OperationVariables } from "./types.js";
+import type { ApolloQueryResult, DefaultContext, InternalRefetchQueriesInclude, InternalRefetchQueriesMap, InternalRefetchQueriesOptions, MutateResult, MutationUpdaterFunction, OnQueryUpdated, OperationVariables, SubscribeResult } from "./types.js";
 import type { ErrorPolicy, MutationFetchPolicy, MutationOptions, QueryOptions, SubscriptionOptions, WatchQueryFetchPolicy, WatchQueryOptions } from "./watchQueryOptions.js";
 interface MutationStoreValue {
     mutation: DocumentNode;
@@ -65,6 +65,17 @@ export declare class QueryManager {
     private queryDeduplication;
     private clientAwareness;
     private localState;
+    /**
+     * Whether to prioritize cache values over network results when
+     * `fetchObservableWithInfo` is called.
+     * This will essentially turn a `"network-only"` or `"cache-and-network"`
+     * fetchPolicy into a `"cache-first"` fetchPolicy, but without influencing
+     * the `fetchPolicy` of the `ObservableQuery`.
+     *
+     * This can e.g. be used to prioritize the cache during the first render after
+     * SSR.
+     */
+    prioritizeCacheValues: boolean;
     private onBroadcast?;
     mutationStore?: {
         [mutationId: string]: MutationStoreValue;
@@ -78,7 +89,7 @@ export declare class QueryManager {
      */
     stop(): void;
     private cancelPendingFetches;
-    mutate<TData, TVariables extends OperationVariables, TContext extends Record<string, any>, TCache extends ApolloCache>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: MutationOptions<TData, TVariables, TContext>): Promise<FetchResult<MaybeMasked<TData>>>;
+    mutate<TData, TVariables extends OperationVariables, TContext extends Record<string, any>, TCache extends ApolloCache>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: MutationOptions<TData, TVariables, TContext>): Promise<MutateResult<MaybeMasked<TData>>>;
     markMutationResult<TData, TVariables extends OperationVariables, TContext, TCache extends ApolloCache>(mutation: {
         mutationId: string;
         result: FetchResult<TData>;
@@ -123,7 +134,7 @@ export declare class QueryManager {
     getObservableQueries(include?: InternalRefetchQueriesInclude): Map<string, ObservableQuery<any, OperationVariables>>;
     reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
     setObservableQuery(observableQuery: ObservableQuery<any, any>): void;
-    startGraphQLSubscription<TData = unknown>(options: SubscriptionOptions): Observable<FetchResult<TData>>;
+    startGraphQLSubscription<TData = unknown>(options: SubscriptionOptions): Observable<SubscribeResult<TData>>;
     stopQuery(queryId: string): void;
     removeQuery(queryId: string): void;
     broadcastQueries(): void;

package/core/QueryManager.js

@@ -1,5 +1,5 @@
 import { Trie } from "@wry/trie";
-import { catchError, concat, EMPTY, from, lastValueFrom, map, mergeMap, mergeWith, Observable, of, share, shareReplay, Subject, tap, } from "rxjs";
+import { catchError, concat, EMPTY, filter, from, lastValueFrom, map, mergeMap, mergeWith, Observable, of, share, shareReplay, Subject, tap, } from "rxjs";
 import { canonicalStringify } from "@apollo/client/cache";
 import { CombinedGraphQLErrors, graphQLResultHasProtocolErrors, UnconventionalError, } from "@apollo/client/errors";
 import { PROTOCOL_ERRORS_SYMBOL } from "@apollo/client/errors";
@@ -30,6 +30,17 @@ export class QueryManager {
     queryDeduplication;
     clientAwareness = {};
     localState;
+    /**
+     * Whether to prioritize cache values over network results when
+     * `fetchObservableWithInfo` is called.
+     * This will essentially turn a `"network-only"` or `"cache-and-network"`
+     * fetchPolicy into a `"cache-first"` fetchPolicy, but without influencing
+     * the `fetchPolicy` of the `ObservableQuery`.
+     *
+     * This can e.g. be used to prioritize the cache during the first render after
+     * SSR.
+     */
+    prioritizeCacheValues = false;
     onBroadcast;
     mutationStore;
     // All the queries that the QueryManager is currently managing (not
@@ -77,15 +88,15 @@ export class QueryManager {
         this.queries.forEach((_info, queryId) => {
             this.removeQuery(queryId);
         });
-        this.cancelPendingFetches(newInvariantError(72));
+        this.cancelPendingFetches(newInvariantError(68));
     }
     cancelPendingFetches(error) {
         this.fetchCancelFns.forEach((cancel) => cancel(error));
         this.fetchCancelFns.clear();
     }
     async mutate({ mutation, variables, optimisticResponse, updateQueries, refetchQueries = [], awaitRefetchQueries = false, update: updateWithProxyFn, onQueryUpdated, fetchPolicy = this.defaultOptions.mutate?.fetchPolicy || "network-only", errorPolicy = this.defaultOptions.mutate?.errorPolicy || "none", keepRootFields, context, }) {
-        invariant(mutation, 73);
-        invariant(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 74);
+        invariant(mutation, 69);
+        invariant(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 70);
         const mutationId = this.generateMutationId();
         mutation = this.cache.transformForLink(this.transform(mutation));
         const { hasClientExports } = this.getDocumentInfo(mutation);
@@ -119,7 +130,8 @@ export class QueryManager {
                 optimisticResponse: isOptimistic ? optimisticResponse : void 0,
             }, variables, {}, false)
                 .pipe(mergeMap((result) => {
-                if (graphQLResultHasError(result) && errorPolicy === "none") {
+                const hasErrors = graphQLResultHasError(result);
+                if (hasErrors && errorPolicy === "none") {
                     throw new CombinedGraphQLErrors(getGraphQLErrorsFromResult(result));
                 }
                 if (mutationStoreValue) {
@@ -130,8 +142,7 @@ export class QueryManager {
                 if (typeof refetchQueries === "function") {
                     refetchQueries = refetchQueries(storeResult);
                 }
-                if (errorPolicy === "ignore" &&
-                    graphQLResultHasError(storeResult)) {
+                if (errorPolicy === "ignore" && hasErrors) {
                     delete storeResult.errors;
                 }
                 return from(this.markMutationResult({
@@ -160,28 +171,40 @@ export class QueryManager {
                     // ExecutionPatchResult has arrived and we have assembled the
                     // multipart response into a single result.
                     if (!("hasNext" in storeResult) || storeResult.hasNext === false) {
-                        resolve({
-                            ...storeResult,
+                        const result = {
                             data: this.maskOperation({
                                 document: mutation,
                                 data: storeResult.data,
                                 fetchPolicy,
                                 id: mutationId,
                             }),
-                        });
+                        };
+                        if (graphQLResultHasError(storeResult)) {
+                            result.error = new CombinedGraphQLErrors(getGraphQLErrorsFromResult(storeResult));
+                        }
+                        if (storeResult.extensions) {
+                            result.extensions = storeResult.extensions;
+                        }
+                        resolve(result);
                     }
                 },
                 error: (err) => {
-                    err = maybeWrapError(err);
+                    const error = maybeWrapError(err);
                     if (mutationStoreValue) {
                         mutationStoreValue.loading = false;
-                        mutationStoreValue.error = err;
+                        mutationStoreValue.error = error;
                     }
                     if (isOptimistic) {
                         this.cache.removeOptimistic(mutationId);
                     }
                     this.broadcastQueries();
-                    reject(err);
+                    if (errorPolicy === "ignore") {
+                        return resolve({ data: undefined });
+                    }
+                    if (errorPolicy === "all") {
+                        return resolve({ data: undefined, error });
+                    }
+                    reject(error);
                 },
             });
         });
@@ -454,10 +477,10 @@ export class QueryManager {
     // TODO: catch `EmptyError` and rethrow as network error if `complete`
     // notification is emitted without a value.
     query(options, queryId = this.generateQueryId()) {
-        invariant(options.query, 75);
-        invariant(options.query.kind === "Document", 76);
-        invariant(!options.returnPartialData, 77);
-        invariant(!options.pollInterval, 78);
+        invariant(options.query, 71);
+        invariant(options.query.kind === "Document", 72);
+        invariant(!options.returnPartialData, 73);
+        invariant(!options.pollInterval, 74);
         const query = this.transform(options.query);
         return this.fetchQuery(queryId, { ...options, query })
             .then((result) => result && {
@@ -491,7 +514,7 @@ export class QueryManager {
         // depend on values that previously existed in the data portion of the
         // store. So, we cancel the promises and observers that we have issued
         // so far and not yet resolved (in the case of queries).
-        this.cancelPendingFetches(newInvariantError(79));
+        this.cancelPendingFetches(newInvariantError(75));
         this.queries.forEach((queryInfo) => {
             if (queryInfo.observableQuery) {
                 // Set loading to true so listeners don't trigger unless they want
@@ -579,10 +602,10 @@ export class QueryManager {
                 if (!included) {
                     const queryName = queryNames.get(nameOrQueryString);
                     if (queryName) {
-                        __DEV__ && invariant.warn(80, queryName);
+                        __DEV__ && invariant.warn(76, queryName);
                     }
                     else {
-                        __DEV__ && invariant.warn(81);
+                        __DEV__ && invariant.warn(77);
                     }
                 }
             });
@@ -611,38 +634,48 @@ export class QueryManager {
         const { fetchPolicy, errorPolicy = "none", context = {}, extensions = {}, } = options;
         query = this.transform(query);
         variables = this.getVariables(query, variables);
-        const makeObservable = (variables) => this.getObservableFromLink(query, context, variables, extensions).pipe(map((result) => {
+        const makeObservable = (variables) => this.getObservableFromLink(query, context, variables, extensions).pipe(map((rawResult) => {
             if (fetchPolicy !== "no-cache") {
                 // the subscription interface should handle not sending us results we no longer subscribe to.
                 // XXX I don't think we ever send in an object with errors, but we might in the future...
-                if (shouldWriteResult(result, errorPolicy)) {
+                if (shouldWriteResult(rawResult, errorPolicy)) {
                     this.cache.write({
                         query,
-                        result: result.data,
+                        result: rawResult.data,
                         dataId: "ROOT_SUBSCRIPTION",
                         variables: variables,
                     });
                 }
                 this.broadcastQueries();
             }
-            const hasErrors = graphQLResultHasError(result);
-            const hasProtocolErrors = graphQLResultHasProtocolErrors(result);
-            if (hasErrors && errorPolicy === "none") {
-                throw new CombinedGraphQLErrors(result.errors);
+            const result = {
+                data: rawResult.data ?? undefined,
+            };
+            if (graphQLResultHasError(rawResult)) {
+                result.error = new CombinedGraphQLErrors(rawResult.errors);
+            }
+            else if (graphQLResultHasProtocolErrors(rawResult)) {
+                result.error = rawResult.extensions[PROTOCOL_ERRORS_SYMBOL];
+                // Don't emit protocol errors added by HttpLink
+                delete rawResult.extensions[PROTOCOL_ERRORS_SYMBOL];
+            }
+            if (rawResult.extensions &&
+                Object.keys(rawResult.extensions).length) {
+                result.extensions = rawResult.extensions;
             }
-            if (hasProtocolErrors) {
-                // `errorPolicy` is a mechanism for handling GraphQL errors, according
-                // to our documentation, so we throw protocol errors regardless of the
-                // set error policy.
-                throw result.extensions[PROTOCOL_ERRORS_SYMBOL];
+            if (result.error && errorPolicy === "none") {
+                result.data = undefined;
             }
             if (errorPolicy === "ignore") {
-                delete result.errors;
+                delete result.error;
             }
             return result;
         }), catchError((error) => {
-            throw maybeWrapError(error);
-        }));
+            if (errorPolicy === "ignore") {
+                return of({ data: undefined });
+            }
+            return of({ data: undefined, error: maybeWrapError(error) });
+        }), filter((result) => !!(result.data || result.error)));
         if (this.getDocumentInfo(query).hasClientExports) {
             const observablePromise = this.localState
                 .addExportedVariables(query, variables, context)
@@ -810,6 +843,10 @@ export class QueryManager {
         const queryInfo = this.getQuery(queryId);
         const defaults = this.defaultOptions.watchQuery;
         let { fetchPolicy = (defaults && defaults.fetchPolicy) || "cache-first", errorPolicy = (defaults && defaults.errorPolicy) || "none", returnPartialData = false, notifyOnNetworkStatusChange = false, context = {}, } = options;
+        if (this.prioritizeCacheValues &&
+            (fetchPolicy === "network-only" || fetchPolicy === "cache-and-network")) {
+            fetchPolicy = "cache-first";
+        }
         const normalized = Object.assign({}, options, {
             query,
             variables,
@@ -1009,7 +1046,7 @@ export class QueryManager {
                 !isFullyUnmaskedOperation(document) &&
                 !this.noCacheWarningsByQueryId.has(operationId)) {
                 this.noCacheWarningsByQueryId.add(operationId);
-                __DEV__ && invariant.warn(82, getOperationName(document) ??
+                __DEV__ && invariant.warn(78, getOperationName(document) ??
                     `Unnamed ${operationType ?? "operation"}`);
             }
         }