@apollo/client 4.0.0-alpha.4 → 4.0.0-alpha.6

package/__cjs/core/ObservableQuery.d.cts

@@ -5,7 +5,7 @@ import type { MissingTree } from "@apollo/client/cache";
 import type { MaybeMasked, Unmasked } from "@apollo/client/masking";
 import type { QueryInfo } from "./QueryInfo.cjs";
 import type { QueryManager } from "./QueryManager.cjs";
-import type { ApolloQueryResult, ErrorLike, OperationVariables, TypedDocumentNode } from "./types.cjs";
+import type { ApolloQueryResult, ErrorLike, OperationVariables, QueryResult, TypedDocumentNode } from "./types.cjs";
 import type { FetchMoreQueryOptions, SubscribeToMoreOptions, UpdateQueryMapFn, WatchQueryOptions } from "./watchQueryOptions.cjs";
 export interface FetchMoreOptions<TData = unknown, TVariables = OperationVariables> {
     updateQuery?: (previousQueryResult: TData, options: {
@@ -61,7 +61,7 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
      * @param variables - The new set of variables. If there are missing variables,
      * the previous values of those variables will be used.
      */
-    refetch(variables?: Partial<TVariables>): Promise<ApolloQueryResult<MaybeMasked<TData>>>;
+    refetch(variables?: Partial<TVariables>): Promise<QueryResult<TData>>;
     /**
      * 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/).
      */
@@ -70,7 +70,7 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
             fetchMoreResult: Unmasked<TFetchData>;
             variables: TFetchVars;
         }) => Unmasked<TData>;
-    }): Promise<ApolloQueryResult<MaybeMasked<TFetchData>>>;
+    }): 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.
      *
@@ -97,7 +97,7 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
      * @param variables - The new set of variables. If there are missing variables,
      * the previous values of those variables will be used.
      */
-    setVariables(variables: TVariables): Promise<ApolloQueryResult<MaybeMasked<TData>>>;
+    setVariables(variables: TVariables): Promise<QueryResult<TData>>;
     /**
      * A function that enables you to update the query's cached result without executing a followup GraphQL operation.
      *
@@ -120,7 +120,7 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
      * Reevaluate the query, optionally against new options. New options will be
      * merged with the current options when given.
      */
-    reobserve(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>): Promise<ApolloQueryResult<MaybeMasked<TData>>>;
+    reobserve(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>): Promise<QueryResult<MaybeMasked<TData>>>;
     private observe;
     private reportResult;
     private reportError;
@@ -129,6 +129,6 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
     private transformDocument;
     private maskResult;
 }
-export declare function reobserveCacheFirst<TData, TVars extends OperationVariables>(obsQuery: ObservableQuery<TData, TVars>): Promise<ApolloQueryResult<TData>>;
+export declare function reobserveCacheFirst<TData, TVars extends OperationVariables>(obsQuery: ObservableQuery<TData, TVars>): Promise<QueryResult<TData>>;
 export declare function logMissingFieldErrors(missing: MissingFieldError | MissingTree | undefined): void;
 //# sourceMappingURL=ObservableQuery.d.cts.map

package/__cjs/core/QueryManager.cjs

@@ -95,15 +95,15 @@ class QueryManager {
         this.queries.forEach((_info, queryId) => {
             this.removeQuery(queryId);
         });
-        this.cancelPendingFetches((0, invariant_1.newInvariantError)(72));
+        this.cancelPendingFetches((0, invariant_1.newInvariantError)(74));
     }
     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, }) {
-        (0, invariant_1.invariant)(mutation, 73);
-        (0, invariant_1.invariant)(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 74);
+        (0, invariant_1.invariant)(mutation, 75);
+        (0, invariant_1.invariant)(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 76);
         const mutationId = this.generateMutationId();
         mutation = this.cache.transformForLink(this.transform(mutation));
         const { hasClientExports } = this.getDocumentInfo(mutation);
@@ -136,9 +136,10 @@ class QueryManager {
                 ...context,
                 optimisticResponse: isOptimistic ? optimisticResponse : void 0,
             }, variables, {}, false)
-                .pipe((0, rxjs_1.mergeMap)((result) => {
-                if ((0, utilities_4.graphQLResultHasError)(result) && errorPolicy === "none") {
-                    throw new errors_1.CombinedGraphQLErrors((0, utilities_4.getGraphQLErrorsFromResult)(result));
+                .pipe(validateDidEmitValue(), (0, rxjs_1.mergeMap)((result) => {
+                const hasErrors = (0, utilities_4.graphQLResultHasError)(result);
+                if (hasErrors && errorPolicy === "none") {
+                    throw new errors_1.CombinedGraphQLErrors(result);
                 }
                 if (mutationStoreValue) {
                     mutationStoreValue.loading = false;
@@ -148,8 +149,7 @@ class QueryManager {
                 if (typeof refetchQueries === "function") {
                     refetchQueries = refetchQueries(storeResult);
                 }
-                if (errorPolicy === "ignore" &&
-                    (0, utilities_4.graphQLResultHasError)(storeResult)) {
+                if (errorPolicy === "ignore" && hasErrors) {
                     delete storeResult.errors;
                 }
                 return (0, rxjs_1.from)(this.markMutationResult({
@@ -178,28 +178,40 @@ 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 ((0, utilities_4.graphQLResultHasError)(storeResult)) {
+                            result.error = new errors_1.CombinedGraphQLErrors(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);
                 },
             });
         });
@@ -389,7 +401,11 @@ class QueryManager {
         return true;
     }
     fetchQuery(queryId, options, networkStatus) {
-        return (0, rxjs_1.lastValueFrom)(this.fetchObservableWithInfo(queryId, options, networkStatus).observable, { defaultValue: undefined });
+        return (0, rxjs_1.lastValueFrom)(this.fetchObservableWithInfo(queryId, options, networkStatus).observable.pipe((0, rxjs_1.map)(internal_1.toQueryResult)), {
+            // This default is needed when a `standby` fetch policy is used to avoid
+            // an EmptyError from rejecting this promise.
+            defaultValue: { data: undefined },
+        });
     }
     transform(document) {
         return this.documentTransform.transformDocument(document);
@@ -469,24 +485,18 @@ class QueryManager {
         });
         return observable;
     }
-    // TODO: catch `EmptyError` and rethrow as network error if `complete`
-    // notification is emitted without a value.
     query(options, queryId = this.generateQueryId()) {
-        (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);
         const query = this.transform(options.query);
         return this.fetchQuery(queryId, { ...options, query })
-            .then((result) => result && {
-            ...result,
+            .then((value) => ({
+            ...value,
             data: this.maskOperation({
                 document: query,
-                data: result.data,
+                data: value?.data,
                 fetchPolicy: options.fetchPolicy,
                 id: queryId,
             }),
-        })
+        }))
             .finally(() => this.stopQuery(queryId));
     }
     queryIdCounter = 1;
@@ -509,7 +519,7 @@ 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((0, invariant_1.newInvariantError)(79));
+        this.cancelPendingFetches((0, invariant_1.newInvariantError)(77));
         this.queries.forEach((queryInfo) => {
             if (queryInfo.observableQuery) {
                 // Set loading to true so listeners don't trigger unless they want
@@ -597,10 +607,10 @@ class QueryManager {
                 if (!included) {
                     const queryName = queryNames.get(nameOrQueryString);
                     if (queryName) {
-                        __DEV__ && invariant_1.invariant.warn(80, queryName);
+                        __DEV__ && invariant_1.invariant.warn(78, queryName);
                     }
                     else {
-                        __DEV__ && invariant_1.invariant.warn(81);
+                        __DEV__ && invariant_1.invariant.warn(79);
                     }
                 }
             });
@@ -629,38 +639,48 @@ 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((0, rxjs_1.map)((result) => {
+        const makeObservable = (variables) => this.getObservableFromLink(query, context, variables, extensions).pipe((0, rxjs_1.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 ((0, QueryInfo_js_1.shouldWriteResult)(result, errorPolicy)) {
+                if ((0, QueryInfo_js_1.shouldWriteResult)(rawResult, errorPolicy)) {
                     this.cache.write({
                         query,
-                        result: result.data,
+                        result: rawResult.data,
                         dataId: "ROOT_SUBSCRIPTION",
                         variables: variables,
                     });
                 }
                 this.broadcastQueries();
             }
-            const hasErrors = (0, utilities_4.graphQLResultHasError)(result);
-            const hasProtocolErrors = (0, errors_1.graphQLResultHasProtocolErrors)(result);
-            if (hasErrors && errorPolicy === "none") {
-                throw new errors_1.CombinedGraphQLErrors(result.errors);
+            const result = {
+                data: rawResult.data ?? undefined,
+            };
+            if ((0, utilities_4.graphQLResultHasError)(rawResult)) {
+                result.error = new errors_1.CombinedGraphQLErrors(rawResult);
+            }
+            else if ((0, errors_1.graphQLResultHasProtocolErrors)(rawResult)) {
+                result.error = rawResult.extensions[errors_2.PROTOCOL_ERRORS_SYMBOL];
+                // Don't emit protocol errors added by HttpLink
+                delete rawResult.extensions[errors_2.PROTOCOL_ERRORS_SYMBOL];
             }
-            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[errors_2.PROTOCOL_ERRORS_SYMBOL];
+            if (rawResult.extensions &&
+                Object.keys(rawResult.extensions).length) {
+                result.extensions = rawResult.extensions;
+            }
+            if (result.error && errorPolicy === "none") {
+                result.data = undefined;
             }
             if (errorPolicy === "ignore") {
-                delete result.errors;
+                delete result.error;
             }
             return result;
         }), (0, rxjs_1.catchError)((error) => {
-            throw maybeWrapError(error);
-        }));
+            if (errorPolicy === "ignore") {
+                return (0, rxjs_1.of)({ data: undefined });
+            }
+            return (0, rxjs_1.of)({ data: undefined, error: maybeWrapError(error) });
+        }), (0, rxjs_1.filter)((result) => !!(result.data || result.error)));
         if (this.getDocumentInfo(query).hasClientExports) {
             const observablePromise = this.localState
                 .addExportedVariables(query, variables, context)
@@ -773,7 +793,7 @@ class QueryManager {
                     queryInfo.resetLastWrite();
                     queryInfo.reset();
                     // Throwing here effectively calls observer.error.
-                    throw new errors_1.CombinedGraphQLErrors(graphQLErrors);
+                    throw new errors_1.CombinedGraphQLErrors(result);
                 }
                 // Use linkDocument rather than queryInfo.document so the
                 // operation/fragments used to write the result are the same as the
@@ -794,7 +814,7 @@ class QueryManager {
                 aqr.data = void 0;
             }
             if (hasErrors && errorPolicy !== "ignore") {
-                aqr.error = new errors_1.CombinedGraphQLErrors(graphQLErrors);
+                aqr.error = new errors_1.CombinedGraphQLErrors(result);
                 aqr.networkStatus = networkStatus_js_1.NetworkStatus.error;
             }
             return aqr;
@@ -1031,7 +1051,7 @@ class QueryManager {
                 !(0, utilities_3.isFullyUnmaskedOperation)(document) &&
                 !this.noCacheWarningsByQueryId.has(operationId)) {
                 this.noCacheWarningsByQueryId.add(operationId);
-                __DEV__ && invariant_1.invariant.warn(82, (0, utilities_4.getOperationName)(document) ??
+                __DEV__ && invariant_1.invariant.warn(80, (0, utilities_4.getOperationName)(document) ??
                     `Unnamed ${operationType ?? "operation"}`);
             }
         }
@@ -1121,7 +1141,7 @@ class QueryManager {
             context,
             fetchPolicy,
             errorPolicy,
-        });
+        }).pipe(validateDidEmitValue());
         switch (fetchPolicy) {
             default:
             case "cache-first": {
@@ -1211,4 +1231,15 @@ function maybeWrapError(error) {
     }
     return new errors_1.UnconventionalError(error);
 }
+function validateDidEmitValue() {
+    let didEmitValue = false;
+    return (0, rxjs_1.tap)({
+        next() {
+            didEmitValue = true;
+        },
+        complete() {
+            (0, invariant_1.invariant)(didEmitValue, 81);
+        },
+    });
+}
 //# sourceMappingURL=QueryManager.cjs.map