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

package/__cjs/core/QueryManager.cjs

@@ -24,14 +24,18 @@ const QueryInfo_js_1 = require("./QueryInfo.cjs");
 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.
@@ -61,11 +65,12 @@ 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 ?
@@ -94,16 +99,13 @@ class QueryManager {
      */
     stop() {
         this.obsQueries.forEach((oq) => oq.stop());
-        this.cancelPendingFetches((0, invariant_1.newInvariantError)(81));
+        this.cancelPendingFetches((0, invariant_1.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, }) {
-        (0, invariant_1.invariant)(mutation, 82);
-        (0, internal_1.checkDocument)(mutation, graphql_1.OperationTypeNode.MUTATION);
-        (0, invariant_1.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_js_1.QueryInfo(this);
         mutation = this.cache.transformForLink(this.transform(mutation));
         const { hasClientExports } = this.getDocumentInfo(mutation);
@@ -112,7 +114,7 @@ class QueryManager {
             if (environment_1.__DEV__) {
                 (0, invariant_1.invariant)(
                     this.localState,
-                    84,
+                    86,
                     (0, internal_1.getOperationName)(mutation, "(anonymous)")
                 );
             }
@@ -151,21 +153,7 @@ class QueryManager {
                 optimisticResponse: isOptimistic ? optimisticResponse : void 0,
             }, variables, {}, false)
                 .observable.pipe(validateDidEmitValue(), (0, rxjs_2.mergeMap)((result) => {
-                const hasErrors = (0, internal_1.graphQLResultHasError)(result);
-                if (hasErrors && errorPolicy === "none") {
-                    throw new errors_1.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 (0, rxjs_2.from)(queryInfo.markMutationResult(storeResult, {
                     document: mutation,
                     variables,
@@ -182,6 +170,17 @@ class QueryManager {
                     onQueryUpdated,
                     keepRootFields,
                 }));
+            }))
+                .pipe((0, rxjs_2.map)((storeResult) => {
+                const hasErrors = (0, internal_1.graphQLResultHasError)(storeResult);
+                if (hasErrors && errorPolicy === "none") {
+                    throw new errors_1.CombinedGraphQLErrors(storeResult);
+                }
+                if (mutationStoreValue) {
+                    mutationStoreValue.loading = false;
+                    mutationStoreValue.error = null;
+                }
+                return storeResult;
             }))
                 .subscribe({
                 next: (storeResult) => {
@@ -191,7 +190,7 @@ 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,
@@ -203,7 +202,7 @@ class QueryManager {
                         if ((0, internal_1.graphQLResultHasError)(storeResult)) {
                             result.error = new errors_1.CombinedGraphQLErrors(storeResult);
                         }
-                        if (storeResult.extensions) {
+                        if (Object.keys(storeResult.extensions || {}).length) {
                             result.extensions = storeResult.extensions;
                         }
                         resolve(result);
@@ -230,7 +229,10 @@ class QueryManager {
         });
     }
     fetchQuery(options, networkStatus) {
-        return (0, rxjs_2.lastValueFrom)(this.fetchObservableWithInfo(options, {
+        (0, internal_1.checkDocument)(options.query, graphql_1.OperationTypeNode.QUERY);
+        // do the rest asynchronously to keep the same rejection timing as
+        // checks further in `.mutate`
+        return (async () => (0, rxjs_2.lastValueFrom)(this.fetchObservableWithInfo(options, {
             networkStatus,
         }).observable.pipe((0, internal_1.filterMap)((value) => {
             switch (value.kind) {
@@ -245,7 +247,7 @@ 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);
@@ -265,6 +267,7 @@ class QueryManager {
                 hasClientExports: (0, internal_1.hasDirectives)(["client", "export"], document, true),
                 hasForcedResolvers: (0, internal_1.hasForcedResolvers)(document),
                 hasNonreactiveDirective: (0, internal_1.hasDirectives)(["nonreactive"], document),
+                hasIncrementalDirective: (0, internal_1.hasDirectives)(["defer"], document),
                 nonReactiveQuery: addNonReactiveToNamedFragments(document),
                 clientQuery: (0, internal_1.hasDirectives)(["client"], document) ? document : null,
                 serverQuery: (0, internal_1.removeDirectivesFromDocument)([
@@ -290,7 +293,11 @@ 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;
@@ -320,7 +327,7 @@ class QueryManager {
         });
         return observable;
     }
-    async query(options) {
+    query(options) {
         const query = this.transform(options.query);
         return this.fetchQuery({
             ...options,
@@ -346,7 +353,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)(85));
+        this.cancelPendingFetches((0, invariant_1.newInvariantError)(87));
         this.obsQueries.forEach((observableQuery) => {
             // Set loading to true so listeners don't trigger unless they want
             // results with partial data.
@@ -416,10 +423,10 @@ class QueryManager {
                 if (!included) {
                     const queryName = queryNames.get(nameOrQueryString);
                     if (queryName) {
-                        __DEV__ && invariant_1.invariant.warn(86, queryName);
+                        __DEV__ && invariant_1.invariant.warn(88, queryName);
                     }
                     else {
-                        __DEV__ && invariant_1.invariant.warn(87);
+                        __DEV__ && invariant_1.invariant.warn(89);
                     }
                 }
             });
@@ -430,8 +437,8 @@ 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());
             }
         });
@@ -448,7 +455,7 @@ class QueryManager {
         if (environment_1.__DEV__) {
             (0, invariant_1.invariant)(
                 !this.getDocumentInfo(query).hasClientExports || this.localState,
-                88,
+                90,
                 (0, internal_1.getOperationName)(query, "(anonymous)")
             );
         }
@@ -516,82 +523,92 @@ 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 = (0, internal_1.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 rxjs_1.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 = (0, utilities_1.print)(serverQuery);
-                const varJson = (0, cache_1.canonicalStringify)(variables);
-                entry = inFlightLinkObservables.lookup(printedServerQuery, varJson);
-                if (!entry.observable) {
-                    entry.observable = (0, link_1.execute)(link, operation, executeContext).pipe(withRestart, (0, rxjs_2.finalize)(() => {
-                        if (inFlightLinkObservables.peek(printedServerQuery, varJson) ===
-                            entry) {
-                            inFlightLinkObservables.remove(printedServerQuery, varJson);
+                context = operation.context;
+                function withRestart(source) {
+                    return new rxjs_1.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 === graphql_1.OperationTypeNode.SUBSCRIPTION ?
-                        (0, rxjs_2.share)()
-                        : (0, rxjs_2.shareReplay)({ refCount: true }));
+                        let subscription = subscribe();
+                        entry.restart ||= () => {
+                            subscription.unsubscribe();
+                            subscription = subscribe();
+                        };
+                        return () => {
+                            subscription.unsubscribe();
+                            entry.restart = undefined;
+                        };
+                    });
+                }
+                if (deduplication) {
+                    const printedServerQuery = (0, utilities_1.print)(serverQuery);
+                    const varJson = (0, cache_1.canonicalStringify)(variables);
+                    entry = inFlightLinkObservables.lookup(printedServerQuery, varJson);
+                    if (!entry.observable) {
+                        entry.observable = (0, link_1.execute)(link, operation, executeContext).pipe(withRestart, (0, rxjs_2.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 === graphql_1.OperationTypeNode.SUBSCRIPTION ?
+                            (0, rxjs_2.share)()
+                            : (0, rxjs_2.shareReplay)({ refCount: true }));
+                    }
+                }
+                else {
+                    entry.observable = (0, link_1.execute)(link, operation, executeContext).pipe(withRestart);
                 }
             }
-            else {
-                entry.observable = (0, link_1.execute)(link, operation, executeContext).pipe(withRestart);
+            catch (error) {
+                entry.observable = (0, rxjs_1.throwError)(() => error);
             }
         }
         else {
             entry.observable = (0, rxjs_2.of)({ data: {} });
         }
         if (clientQuery) {
+            const { operation } = (0, internal_1.getOperationDefinition)(query);
             if (environment_1.__DEV__) {
-                const { operation } = (0, internal_1.getOperationDefinition)(query);
                 (0, invariant_1.invariant)(
                     this.localState,
-                    89,
+                    91,
                     operation[0].toUpperCase() + operation.slice(1),
                     operationName ?? "(anonymous)"
                 );
             }
+            (0, invariant_1.invariant)(
+                !hasIncrementalDirective,
+                92,
+                operation[0].toUpperCase() + operation.slice(1),
+                operationName ?? "(anonymous)"
+            );
             entry.observable = entry.observable.pipe((0, rxjs_2.mergeMap)((result) => {
                 return (0, rxjs_2.from)(this.localState.execute({
                     client: this.client,
@@ -618,30 +635,24 @@ 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((0, rxjs_2.map)((result) => {
-            const graphQLErrors = (0, internal_1.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 errors_1.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((0, rxjs_2.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 = (0, internal_1.graphQLResultHasError)(result);
+            if (hasErrors && errorPolicy === "none") {
+                queryInfo.resetLastWrite();
+                observableQuery?.["resetNotifications"]();
+                throw new errors_1.CombinedGraphQLErrors(result);
             }
             const aqr = {
                 data: result.data,
-                ...((0, internal_1.isExecutionPatchResult)(result) && result.hasNext ?
+                ...(queryInfo.hasNext ?
                     {
                         loading: true,
                         networkStatus: networkStatus_js_1.NetworkStatus.streaming,
@@ -659,15 +670,16 @@ 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 errors_1.CombinedGraphQLErrors(result);
-                aqr.networkStatus = networkStatus_js_1.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 errors_1.CombinedGraphQLErrors(result);
+                    if (aqr.dataState !== "streaming") {
+                        aqr.networkStatus = networkStatus_js_1.NetworkStatus.error;
+                    }
                 }
             }
             return aqr;
@@ -762,7 +774,7 @@ class QueryManager {
             if (environment_1.__DEV__) {
                 (0, invariant_1.invariant)(
                     this.localState,
-                    90,
+                    93,
                     (0, internal_1.getOperationName)(normalized.query, "(anonymous)")
                 );
             }
@@ -799,6 +811,9 @@ 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,
@@ -878,7 +893,8 @@ 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.
@@ -934,7 +950,7 @@ class QueryManager {
                 !this.noCacheWarningsByCause.has(cause)) {
                 this.noCacheWarningsByCause.add(cause);
                 __DEV__ && invariant_1.invariant.warn(
-                    91,
+                    94,
                     (0, internal_1.getOperationName)(document, `Unnamed ${operationType ?? "operation"}`)
                 );
             }
@@ -996,7 +1012,7 @@ class QueryManager {
                 if (environment_1.__DEV__) {
                     (0, invariant_1.invariant)(
                         this.localState,
-                        92,
+                        95,
                         (0, internal_1.getOperationName)(query, "(anonymous)")
                     );
                 }
@@ -1090,7 +1106,7 @@ function validateDidEmitValue() {
             didEmitValue = true;
         },
         complete() {
-            (0, invariant_1.invariant)(didEmitValue, 93);
+            (0, invariant_1.invariant)(didEmitValue, 96);
         },
     });
 }
@@ -1109,7 +1125,6 @@ function isFullyUnmaskedOperation(document) {
     return isUnmasked;
 }
 function addNonReactiveToNamedFragments(document) {
-    (0, internal_1.checkDocument)(document);
     return (0, graphql_1.visit)(document, {
         FragmentSpread: (node) => {
             // Do not add `@nonreactive` if the fragment is marked with `@unmask`