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

package/core/QueryManager.js

@@ -1,17 +1,18 @@
 import { Trie } from "@wry/trie";
+import { OperationTypeNode } from "graphql";
 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";
 import { execute } from "@apollo/client/link/core";
 import { maskFragment, maskOperation } from "@apollo/client/masking";
-import { print } from "@apollo/client/utilities";
+import { checkDocument, print } from "@apollo/client/utilities";
 import { AutoCleanedWeakCache, cacheSizes } from "@apollo/client/utilities";
 import { addNonReactiveToNamedFragments, hasDirectives, isExecutionPatchIncrementalResult, isExecutionPatchResult, isFullyUnmaskedOperation, removeDirectivesFromDocument, } from "@apollo/client/utilities";
 import { DocumentTransform, getDefaultValues, getGraphQLErrorsFromResult, getOperationDefinition, getOperationName, graphQLResultHasError, hasClientExports, isDocumentNode, isNonEmptyArray, isNonNullObject, makeUniqueId, } from "@apollo/client/utilities";
 import { mergeIncrementalData } from "@apollo/client/utilities";
 import { __DEV__ } from "@apollo/client/utilities/environment";
-import { onAnyEvent } from "@apollo/client/utilities/internal";
+import { onAnyEvent, toQueryResult } from "@apollo/client/utilities/internal";
 import { invariant, newInvariantError, } from "@apollo/client/utilities/invariant";
 import { isNetworkRequestInFlight, NetworkStatus } from "./networkStatus.js";
 import { logMissingFieldErrors, ObservableQuery } from "./ObservableQuery.js";
@@ -88,15 +89,16 @@ export class QueryManager {
         this.queries.forEach((_info, queryId) => {
             this.removeQuery(queryId);
         });
-        this.cancelPendingFetches(newInvariantError(68));
+        this.cancelPendingFetches(newInvariantError(70));
     }
     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, 69);
-        invariant(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 70);
+        invariant(mutation, 71);
+        checkDocument(mutation, OperationTypeNode.MUTATION);
+        invariant(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 72);
         const mutationId = this.generateMutationId();
         mutation = this.cache.transformForLink(this.transform(mutation));
         const { hasClientExports } = this.getDocumentInfo(mutation);
@@ -129,10 +131,10 @@ export class QueryManager {
                 ...context,
                 optimisticResponse: isOptimistic ? optimisticResponse : void 0,
             }, variables, {}, false)
-                .pipe(mergeMap((result) => {
+                .pipe(validateDidEmitValue(), mergeMap((result) => {
                 const hasErrors = graphQLResultHasError(result);
                 if (hasErrors && errorPolicy === "none") {
-                    throw new CombinedGraphQLErrors(getGraphQLErrorsFromResult(result));
+                    throw new CombinedGraphQLErrors(result);
                 }
                 if (mutationStoreValue) {
                     mutationStoreValue.loading = false;
@@ -180,7 +182,7 @@ export class QueryManager {
                             }),
                         };
                         if (graphQLResultHasError(storeResult)) {
-                            result.error = new CombinedGraphQLErrors(getGraphQLErrorsFromResult(storeResult));
+                            result.error = new CombinedGraphQLErrors(storeResult);
                         }
                         if (storeResult.extensions) {
                             result.extensions = storeResult.extensions;
@@ -394,7 +396,11 @@ export class QueryManager {
         return true;
     }
     fetchQuery(queryId, options, networkStatus) {
-        return lastValueFrom(this.fetchObservableWithInfo(queryId, options, networkStatus).observable, { defaultValue: undefined });
+        return lastValueFrom(this.fetchObservableWithInfo(queryId, options, networkStatus).observable.pipe(map(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);
@@ -446,6 +452,7 @@ export class QueryManager {
         };
     }
     watchQuery(options) {
+        checkDocument(options.query, OperationTypeNode.QUERY);
         const query = this.transform(options.query);
         // assign variable default values if supplied
         // NOTE: We don't modify options.query here with the transformed query to
@@ -467,31 +474,23 @@ export class QueryManager {
         this.queries.set(observable.queryId, queryInfo);
         // We give queryInfo the transformed query to ensure the first cache diff
         // uses the transformed query instead of the raw query
-        queryInfo.init({
-            document: query,
-            observableQuery: observable,
-            variables: observable.variables,
-        });
+        queryInfo.init({ document: query, variables: observable.variables });
+        queryInfo.setObservableQuery(observable);
         return observable;
     }
-    // TODO: catch `EmptyError` and rethrow as network error if `complete`
-    // notification is emitted without a value.
     query(options, queryId = this.generateQueryId()) {
-        invariant(options.query, 71);
-        invariant(options.query.kind === "Document", 72);
-        invariant(!options.returnPartialData, 73);
-        invariant(!options.pollInterval, 74);
+        checkDocument(options.query, OperationTypeNode.QUERY);
         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;
@@ -514,7 +513,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(75));
+        this.cancelPendingFetches(newInvariantError(73));
         this.queries.forEach((queryInfo) => {
             if (queryInfo.observableQuery) {
                 // Set loading to true so listeners don't trigger unless they want
@@ -602,10 +601,10 @@ export class QueryManager {
                 if (!included) {
                     const queryName = queryNames.get(nameOrQueryString);
                     if (queryName) {
-                        __DEV__ && invariant.warn(76, queryName);
+                        __DEV__ && invariant.warn(74, queryName);
                     }
                     else {
-                        __DEV__ && invariant.warn(77);
+                        __DEV__ && invariant.warn(75);
                     }
                 }
             });
@@ -632,6 +631,7 @@ export class QueryManager {
     startGraphQLSubscription(options) {
         let { query, variables } = options;
         const { fetchPolicy, errorPolicy = "none", context = {}, extensions = {}, } = options;
+        checkDocument(query, OperationTypeNode.SUBSCRIPTION);
         query = this.transform(query);
         variables = this.getVariables(query, variables);
         const makeObservable = (variables) => this.getObservableFromLink(query, context, variables, extensions).pipe(map((rawResult) => {
@@ -652,7 +652,7 @@ export class QueryManager {
                 data: rawResult.data ?? undefined,
             };
             if (graphQLResultHasError(rawResult)) {
-                result.error = new CombinedGraphQLErrors(rawResult.errors);
+                result.error = new CombinedGraphQLErrors(rawResult);
             }
             else if (graphQLResultHasProtocolErrors(rawResult)) {
                 result.error = rawResult.extensions[PROTOCOL_ERRORS_SYMBOL];
@@ -788,7 +788,7 @@ export class QueryManager {
                     queryInfo.resetLastWrite();
                     queryInfo.reset();
                     // Throwing here effectively calls observer.error.
-                    throw new CombinedGraphQLErrors(graphQLErrors);
+                    throw new CombinedGraphQLErrors(result);
                 }
                 // Use linkDocument rather than queryInfo.document so the
                 // operation/fragments used to write the result are the same as the
@@ -809,7 +809,7 @@ export class QueryManager {
                 aqr.data = void 0;
             }
             if (hasErrors && errorPolicy !== "ignore") {
-                aqr.error = new CombinedGraphQLErrors(graphQLErrors);
+                aqr.error = new CombinedGraphQLErrors(result);
                 aqr.networkStatus = NetworkStatus.error;
             }
             return aqr;
@@ -1046,7 +1046,7 @@ export class QueryManager {
                 !isFullyUnmaskedOperation(document) &&
                 !this.noCacheWarningsByQueryId.has(operationId)) {
                 this.noCacheWarningsByQueryId.add(operationId);
-                __DEV__ && invariant.warn(78, getOperationName(document) ??
+                __DEV__ && invariant.warn(76, getOperationName(document) ??
                     `Unnamed ${operationType ?? "operation"}`);
             }
         }
@@ -1136,7 +1136,7 @@ export class QueryManager {
             context,
             fetchPolicy,
             errorPolicy,
-        });
+        }).pipe(validateDidEmitValue());
         switch (fetchPolicy) {
             default:
             case "cache-first": {
@@ -1225,4 +1225,15 @@ function maybeWrapError(error) {
     }
     return new UnconventionalError(error);
 }
+function validateDidEmitValue() {
+    let didEmitValue = false;
+    return tap({
+        next() {
+            didEmitValue = true;
+        },
+        complete() {
+            invariant(didEmitValue, 77);
+        },
+    });
+}
 //# sourceMappingURL=QueryManager.js.map