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

package/core/QueryManager.js

@@ -1,6 +1,6 @@
 import { Trie } from "@wry/trie";
 import { BREAK, Kind, OperationTypeNode, visit } from "graphql";
-import { Observable } from "rxjs";
+import { Observable, throwError } from "rxjs";
 import { catchError, concat, EMPTY, filter, finalize, from, lastValueFrom, map, materialize, mergeMap, of, share, shareReplay, Subject, tap, } from "rxjs";
 import { canonicalStringify } from "@apollo/client/cache";
 import { CombinedGraphQLErrors, graphQLResultHasProtocolErrors, registerLinkError, toErrorLike, } from "@apollo/client/errors";
@@ -9,7 +9,7 @@ import { execute } from "@apollo/client/link";
 import { maskFragment, maskOperation } from "@apollo/client/masking";
 import { cacheSizes, DocumentTransform, print } from "@apollo/client/utilities";
 import { __DEV__ } from "@apollo/client/utilities/environment";
-import { AutoCleanedWeakCache, checkDocument, filterMap, getDefaultValues, getGraphQLErrorsFromResult, getOperationDefinition, getOperationName, graphQLResultHasError, hasDirectives, hasForcedResolvers, isDocumentNode, isExecutionPatchResult, isNonNullObject, makeUniqueId, removeDirectivesFromDocument, toQueryResult, } from "@apollo/client/utilities/internal";
+import { AutoCleanedWeakCache, checkDocument, filterMap, getDefaultValues, getOperationDefinition, getOperationName, graphQLResultHasError, hasDirectives, hasForcedResolvers, isDocumentNode, isNonNullObject, makeUniqueId, removeDirectivesFromDocument, 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";
@@ -17,14 +17,18 @@ import { QueryInfo } from "./QueryInfo.js";
 export class QueryManager {
     defaultOptions;
     client;
+    /**
+     * The options that were passed to the ApolloClient constructor.
+     */
+    clientOptions;
     assumeImmutableResults;
     documentTransform;
     ssrMode;
     defaultContext;
     dataMasking;
+    incrementalHandler;
     localState;
     queryDeduplication;
-    clientAwareness = {};
     /**
      * Whether to prioritize cache values over network results when
      * `fetchObservableWithInfo` is called.
@@ -54,11 +58,12 @@ export class QueryManager {
         this.client = options.client;
         this.defaultOptions = options.defaultOptions;
         this.queryDeduplication = options.queryDeduplication;
-        this.clientAwareness = options.clientAwareness;
+        this.clientOptions = options.clientOptions;
         this.ssrMode = options.ssrMode;
         this.assumeImmutableResults = options.assumeImmutableResults;
         this.dataMasking = options.dataMasking;
         this.localState = options.localState;
+        this.incrementalHandler = options.incrementalHandler;
         const documentTransform = options.documentTransform;
         this.documentTransform =
             documentTransform ?
@@ -87,23 +92,20 @@ export class QueryManager {
      */
     stop() {
         this.obsQueries.forEach((oq) => oq.stop());
-        this.cancelPendingFetches(newInvariantError(81));
+        this.cancelPendingFetches(newInvariantError(85));
     }
     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, 82);
-        checkDocument(mutation, OperationTypeNode.MUTATION);
-        invariant(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 83);
+    async mutate({ mutation, variables, optimisticResponse, updateQueries, refetchQueries = [], awaitRefetchQueries = false, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }) {
         const queryInfo = new QueryInfo(this);
         mutation = this.cache.transformForLink(this.transform(mutation));
         const { hasClientExports } = this.getDocumentInfo(mutation);
         variables = this.getVariables(mutation, variables);
         if (hasClientExports) {
             if (__DEV__) {
-                invariant(this.localState, 84, getOperationName(mutation, "(anonymous)"));
+                invariant(this.localState, 86, getOperationName(mutation, "(anonymous)"));
             }
             variables = await this.localState.getExportedVariables({
                 client: this.client,
@@ -140,21 +142,7 @@ export class QueryManager {
                 optimisticResponse: isOptimistic ? optimisticResponse : void 0,
             }, variables, {}, false)
                 .observable.pipe(validateDidEmitValue(), mergeMap((result) => {
-                const hasErrors = graphQLResultHasError(result);
-                if (hasErrors && errorPolicy === "none") {
-                    throw new CombinedGraphQLErrors(result);
-                }
-                if (mutationStoreValue) {
-                    mutationStoreValue.loading = false;
-                    mutationStoreValue.error = null;
-                }
                 const storeResult = { ...result };
-                if (typeof refetchQueries === "function") {
-                    refetchQueries = refetchQueries(storeResult);
-                }
-                if (errorPolicy === "ignore" && hasErrors) {
-                    delete storeResult.errors;
-                }
                 return from(queryInfo.markMutationResult(storeResult, {
                     document: mutation,
                     variables,
@@ -171,6 +159,17 @@ export class QueryManager {
                     onQueryUpdated,
                     keepRootFields,
                 }));
+            }))
+                .pipe(map((storeResult) => {
+                const hasErrors = graphQLResultHasError(storeResult);
+                if (hasErrors && errorPolicy === "none") {
+                    throw new CombinedGraphQLErrors(storeResult);
+                }
+                if (mutationStoreValue) {
+                    mutationStoreValue.loading = false;
+                    mutationStoreValue.error = null;
+                }
+                return storeResult;
             }))
                 .subscribe({
                 next: (storeResult) => {
@@ -180,7 +179,7 @@ export class QueryManager {
                     // we resolve with a SingleExecutionResult or after the final
                     // ExecutionPatchResult has arrived and we have assembled the
                     // multipart response into a single result.
-                    if (!("hasNext" in storeResult) || storeResult.hasNext === false) {
+                    if (!queryInfo.hasNext) {
                         const result = {
                             data: this.maskOperation({
                                 document: mutation,
@@ -192,7 +191,7 @@ export class QueryManager {
                         if (graphQLResultHasError(storeResult)) {
                             result.error = new CombinedGraphQLErrors(storeResult);
                         }
-                        if (storeResult.extensions) {
+                        if (Object.keys(storeResult.extensions || {}).length) {
                             result.extensions = storeResult.extensions;
                         }
                         resolve(result);
@@ -219,7 +218,10 @@ export class QueryManager {
         });
     }
     fetchQuery(options, networkStatus) {
-        return lastValueFrom(this.fetchObservableWithInfo(options, {
+        checkDocument(options.query, OperationTypeNode.QUERY);
+        // do the rest asynchronously to keep the same rejection timing as
+        // checks further in `.mutate`
+        return (async () => lastValueFrom(this.fetchObservableWithInfo(options, {
             networkStatus,
         }).observable.pipe(filterMap((value) => {
             switch (value.kind) {
@@ -234,7 +236,7 @@ export class QueryManager {
             // 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);
@@ -254,6 +256,7 @@ export class QueryManager {
                 hasClientExports: hasDirectives(["client", "export"], document, true),
                 hasForcedResolvers: hasForcedResolvers(document),
                 hasNonreactiveDirective: hasDirectives(["nonreactive"], document),
+                hasIncrementalDirective: hasDirectives(["defer"], document),
                 nonReactiveQuery: addNonReactiveToNamedFragments(document),
                 clientQuery: hasDirectives(["client"], document) ? document : null,
                 serverQuery: removeDirectivesFromDocument([
@@ -279,7 +282,11 @@ export class QueryManager {
             };
             transformCache.set(document, cacheEntry);
         }
-        return transformCache.get(document);
+        const entry = transformCache.get(document);
+        if (entry.violation) {
+            throw entry.violation;
+        }
+        return entry;
     }
     getVariables(document, variables) {
         const defaultVars = this.getDocumentInfo(document).defaultVars;
@@ -309,7 +316,7 @@ export class QueryManager {
         });
         return observable;
     }
-    async query(options) {
+    query(options) {
         const query = this.transform(options.query);
         return this.fetchQuery({
             ...options,
@@ -335,7 +342,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(85));
+        this.cancelPendingFetches(newInvariantError(87));
         this.obsQueries.forEach((observableQuery) => {
             // Set loading to true so listeners don't trigger unless they want
             // results with partial data.
@@ -405,10 +412,10 @@ export class QueryManager {
                 if (!included) {
                     const queryName = queryNames.get(nameOrQueryString);
                     if (queryName) {
-                        __DEV__ && invariant.warn(86, queryName);
+                        __DEV__ && invariant.warn(88, queryName);
                     }
                     else {
-                        __DEV__ && invariant.warn(87);
+                        __DEV__ && invariant.warn(89);
                     }
                 }
             });
@@ -419,8 +426,8 @@ export class QueryManager {
         const observableQueryPromises = [];
         this.getObservableQueries(includeStandby ? "all" : "active").forEach((observableQuery) => {
             const { fetchPolicy } = observableQuery.options;
-            if (includeStandby ||
-                (fetchPolicy !== "standby" && fetchPolicy !== "cache-only")) {
+            if ((includeStandby || fetchPolicy !== "standby") &&
+                fetchPolicy !== "cache-only") {
                 observableQueryPromises.push(observableQuery.refetch());
             }
         });
@@ -437,7 +444,7 @@ export class QueryManager {
         if (__DEV__) {
             invariant(
                 !this.getDocumentInfo(query).hasClientExports || this.localState,
-                88,
+                90,
                 getOperationName(query, "(anonymous)")
             );
         }
@@ -505,82 +512,92 @@ export class QueryManager {
     deduplication = context?.queryDeduplication ??
         this.queryDeduplication) {
         let entry = {};
-        const { serverQuery, clientQuery, operationType } = this.getDocumentInfo(query);
+        const { serverQuery, clientQuery, operationType, hasIncrementalDirective } = this.getDocumentInfo(query);
         const operationName = getOperationName(query);
         const executeContext = {
             client: this.client,
         };
         if (serverQuery) {
             const { inFlightLinkObservables, link } = this;
-            const operation = {
-                query: serverQuery,
-                variables,
-                operationName,
-                context: {
-                    ...this.defaultContext,
-                    ...context,
-                    queryDeduplication: deduplication,
-                    clientAwareness: this.clientAwareness,
-                },
-                extensions,
-            };
-            context = operation.context;
-            function withRestart(source) {
-                return new Observable((observer) => {
-                    function subscribe() {
-                        return source.subscribe({
-                            next: observer.next.bind(observer),
-                            complete: observer.complete.bind(observer),
-                            error: observer.error.bind(observer),
-                        });
-                    }
-                    let subscription = subscribe();
-                    entry.restart ||= () => {
-                        subscription.unsubscribe();
-                        subscription = subscribe();
-                    };
-                    return () => {
-                        subscription.unsubscribe();
-                        entry.restart = undefined;
-                    };
+            try {
+                const operation = this.incrementalHandler.prepareRequest({
+                    query: serverQuery,
+                    variables,
+                    operationName,
+                    context: {
+                        ...this.defaultContext,
+                        ...context,
+                        queryDeduplication: deduplication,
+                    },
+                    extensions,
                 });
-            }
-            if (deduplication) {
-                const printedServerQuery = print(serverQuery);
-                const varJson = canonicalStringify(variables);
-                entry = inFlightLinkObservables.lookup(printedServerQuery, varJson);
-                if (!entry.observable) {
-                    entry.observable = execute(link, operation, executeContext).pipe(withRestart, finalize(() => {
-                        if (inFlightLinkObservables.peek(printedServerQuery, varJson) ===
-                            entry) {
-                            inFlightLinkObservables.remove(printedServerQuery, varJson);
+                context = operation.context;
+                function withRestart(source) {
+                    return new Observable((observer) => {
+                        function subscribe() {
+                            return source.subscribe({
+                                next: observer.next.bind(observer),
+                                complete: observer.complete.bind(observer),
+                                error: observer.error.bind(observer),
+                            });
                         }
-                    }), 
-                    // We don't want to replay the last emitted value for
-                    // subscriptions and instead opt to wait to receive updates until
-                    // the subscription emits new values.
-                    operationType === OperationTypeNode.SUBSCRIPTION ?
-                        share()
-                        : shareReplay({ refCount: true }));
+                        let subscription = subscribe();
+                        entry.restart ||= () => {
+                            subscription.unsubscribe();
+                            subscription = subscribe();
+                        };
+                        return () => {
+                            subscription.unsubscribe();
+                            entry.restart = undefined;
+                        };
+                    });
+                }
+                if (deduplication) {
+                    const printedServerQuery = print(serverQuery);
+                    const varJson = canonicalStringify(variables);
+                    entry = inFlightLinkObservables.lookup(printedServerQuery, varJson);
+                    if (!entry.observable) {
+                        entry.observable = execute(link, operation, executeContext).pipe(withRestart, finalize(() => {
+                            if (inFlightLinkObservables.peek(printedServerQuery, varJson) ===
+                                entry) {
+                                inFlightLinkObservables.remove(printedServerQuery, varJson);
+                            }
+                        }), 
+                        // We don't want to replay the last emitted value for
+                        // subscriptions and instead opt to wait to receive updates until
+                        // the subscription emits new values.
+                        operationType === OperationTypeNode.SUBSCRIPTION ?
+                            share()
+                            : shareReplay({ refCount: true }));
+                    }
+                }
+                else {
+                    entry.observable = execute(link, operation, executeContext).pipe(withRestart);
                 }
             }
-            else {
-                entry.observable = execute(link, operation, executeContext).pipe(withRestart);
+            catch (error) {
+                entry.observable = throwError(() => error);
             }
         }
         else {
             entry.observable = of({ data: {} });
         }
         if (clientQuery) {
+            const { operation } = getOperationDefinition(query);
             if (__DEV__) {
-                const { operation } = getOperationDefinition(query);
                 invariant(
                     this.localState,
-                    89,
+                    91,
                     operation[0].toUpperCase() + operation.slice(1),
                     operationName ?? "(anonymous)"
                 );
             }
+            invariant(
+                !hasIncrementalDirective,
+                92,
+                operation[0].toUpperCase() + operation.slice(1),
+                operationName ?? "(anonymous)"
+            );
             entry.observable = entry.observable.pipe(mergeMap((result) => {
                 return from(this.localState.execute({
                     client: this.client,
@@ -607,30 +624,24 @@ export class QueryManager {
         // missing fragment definitions (for example) before sending this document
         // through the link chain.
         const linkDocument = this.cache.transformForLink(options.query);
-        return this.getObservableFromLink(linkDocument, options.context, options.variables).observable.pipe(map((result) => {
-            const graphQLErrors = getGraphQLErrorsFromResult(result);
-            const hasErrors = graphQLErrors.length > 0;
-            // If we interrupted this request by calling getResultsFromLink again
-            // with the same QueryInfo object, we ignore the old results.
-            if (requestId >= queryInfo.lastRequestId) {
-                if (hasErrors && errorPolicy === "none") {
-                    queryInfo.resetLastWrite();
-                    observableQuery?.["resetNotifications"]();
-                    // Throwing here effectively calls observer.error.
-                    throw new CombinedGraphQLErrors(result);
-                }
-                // Use linkDocument rather than queryInfo.document so the
-                // operation/fragments used to write the result are the same as the
-                // ones used to obtain it from the link.
-                queryInfo.markQueryResult(result, {
-                    ...options,
-                    document: linkDocument,
-                    cacheWriteBehavior,
-                });
+        return this.getObservableFromLink(linkDocument, options.context, options.variables).observable.pipe(map((incoming) => {
+            // Use linkDocument rather than queryInfo.document so the
+            // operation/fragments used to write the result are the same as the
+            // ones used to obtain it from the link.
+            const result = queryInfo.markQueryResult(incoming, {
+                ...options,
+                document: linkDocument,
+                cacheWriteBehavior,
+            });
+            const hasErrors = graphQLResultHasError(result);
+            if (hasErrors && errorPolicy === "none") {
+                queryInfo.resetLastWrite();
+                observableQuery?.["resetNotifications"]();
+                throw new CombinedGraphQLErrors(result);
             }
             const aqr = {
                 data: result.data,
-                ...(isExecutionPatchResult(result) && result.hasNext ?
+                ...(queryInfo.hasNext ?
                     {
                         loading: true,
                         networkStatus: NetworkStatus.streaming,
@@ -648,15 +659,16 @@ export class QueryManager {
             // want to ensure we properly set `data` if we're reporting on an old
             // result which will not be caught by the conditional above that ends up
             // throwing the markError result.
-            if (hasErrors && errorPolicy === "none") {
-                aqr.data = void 0;
-                aqr.dataState = "empty";
-            }
-            if (hasErrors && errorPolicy !== "ignore") {
-                aqr.error = new CombinedGraphQLErrors(result);
-                aqr.networkStatus = NetworkStatus.error;
-                if (aqr.data) {
-                    aqr.dataState = "complete";
+            if (hasErrors) {
+                if (errorPolicy === "none") {
+                    aqr.data = void 0;
+                    aqr.dataState = "empty";
+                }
+                if (errorPolicy !== "ignore") {
+                    aqr.error = new CombinedGraphQLErrors(result);
+                    if (aqr.dataState !== "streaming") {
+                        aqr.networkStatus = NetworkStatus.error;
+                    }
                 }
             }
             return aqr;
@@ -749,7 +761,7 @@ export class QueryManager {
         // we deprecated and removed LocalState.
         if (this.getDocumentInfo(normalized.query).hasClientExports) {
             if (__DEV__) {
-                invariant(this.localState, 90, getOperationName(normalized.query, "(anonymous)"));
+                invariant(this.localState, 93, getOperationName(normalized.query, "(anonymous)"));
             }
             observable = from(this.localState.getExportedVariables({
                 client: this.client,
@@ -784,6 +796,9 @@ export class QueryManager {
         const includedQueriesByOq = new Map();
         if (include) {
             this.getObservableQueries(include).forEach((oq) => {
+                if (oq.options.fetchPolicy === "cache-only") {
+                    return;
+                }
                 const current = oq.getCurrentResult();
                 includedQueriesByOq.set(oq, {
                     oq,
@@ -863,7 +878,8 @@ export class QueryManager {
                             // onQueryUpdated returns false.
                             return result;
                         }
-                        if (onQueryUpdated !== null) {
+                        if (onQueryUpdated !== null &&
+                            oq.options.fetchPolicy !== "cache-only") {
                             // If we don't have an onQueryUpdated function, and onQueryUpdated
                             // was not disabled by passing null, make sure this query is
                             // "included" like any other options.include-specified query.
@@ -918,7 +934,7 @@ export class QueryManager {
                 !isFullyUnmaskedOperation(document) &&
                 !this.noCacheWarningsByCause.has(cause)) {
                 this.noCacheWarningsByCause.add(cause);
-                __DEV__ && invariant.warn(91, getOperationName(document, `Unnamed ${operationType ?? "operation"}`));
+                __DEV__ && invariant.warn(94, getOperationName(document, `Unnamed ${operationType ?? "operation"}`));
             }
         }
         return (this.dataMasking ?
@@ -976,7 +992,7 @@ export class QueryManager {
             (diff.complete || returnPartialData) &&
                 this.getDocumentInfo(query).hasForcedResolvers) {
                 if (__DEV__) {
-                    invariant(this.localState, 92, getOperationName(query, "(anonymous)"));
+                    invariant(this.localState, 95, getOperationName(query, "(anonymous)"));
                 }
                 onCacheHit();
                 return from(this.localState.execute({
@@ -1067,7 +1083,7 @@ function validateDidEmitValue() {
             didEmitValue = true;
         },
         complete() {
-            invariant(didEmitValue, 93);
+            invariant(didEmitValue, 96);
         },
     });
 }
@@ -1086,7 +1102,6 @@ function isFullyUnmaskedOperation(document) {
     return isUnmasked;
 }
 function addNonReactiveToNamedFragments(document) {
-    checkDocument(document);
     return visit(document, {
         FragmentSpread: (node) => {
             // Do not add `@nonreactive` if the fragment is marked with `@unmask`