@apollo/client 4.0.0-alpha.12 → 4.0.0-alpha.14

package/__cjs/core/QueryManager.cjs

@@ -16,8 +16,6 @@ const masking_1 = require("@apollo/client/masking");
 const utilities_1 = require("@apollo/client/utilities");
 const utilities_2 = require("@apollo/client/utilities");
 const utilities_3 = require("@apollo/client/utilities");
-const utilities_4 = require("@apollo/client/utilities");
-const utilities_5 = require("@apollo/client/utilities");
 const environment_1 = require("@apollo/client/utilities/environment");
 const internal_1 = require("@apollo/client/utilities/internal");
 const invariant_1 = require("@apollo/client/utilities/invariant");
@@ -34,9 +32,9 @@ class QueryManager {
     ssrMode;
     defaultContext;
     dataMasking;
+    localState;
     queryDeduplication;
     clientAwareness = {};
-    localState;
     /**
      * Whether to prioritize cache values over network results when
      * `fetchObservableWithInfo` is called.
@@ -59,17 +57,17 @@ class QueryManager {
     // @apollo/experimental-nextjs-app-support can access type info.
     fetchCancelFns = new Map();
     constructor(options) {
-        const defaultDocumentTransform = new utilities_4.DocumentTransform((document) => this.cache.transformDocument(document), 
+        const defaultDocumentTransform = new utilities_3.DocumentTransform((document) => this.cache.transformDocument(document), 
         // Allow the apollo cache to manage its own transform caches
         { cache: false });
         this.client = options.client;
         this.defaultOptions = options.defaultOptions;
         this.queryDeduplication = options.queryDeduplication;
         this.clientAwareness = options.clientAwareness;
-        this.localState = options.localState;
         this.ssrMode = options.ssrMode;
         this.assumeImmutableResults = options.assumeImmutableResults;
         this.dataMasking = options.dataMasking;
+        this.localState = options.localState;
         const documentTransform = options.documentTransform;
         this.documentTransform =
             documentTransform ?
@@ -100,22 +98,34 @@ class QueryManager {
         this.queries.forEach((_info, queryId) => {
             this.removeQuery(queryId);
         });
-        this.cancelPendingFetches((0, invariant_1.newInvariantError)(75));
+        this.cancelPendingFetches((0, invariant_1.newInvariantError)(82));
     }
     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, 76);
-        (0, utilities_1.checkDocument)(mutation, graphql_1.OperationTypeNode.MUTATION);
-        (0, invariant_1.invariant)(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 77);
+        (0, invariant_1.invariant)(mutation, 83);
+        (0, internal_1.checkDocument)(mutation, graphql_1.OperationTypeNode.MUTATION);
+        (0, invariant_1.invariant)(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 84);
         const mutationId = this.generateMutationId();
         mutation = this.cache.transformForLink(this.transform(mutation));
         const { hasClientExports } = this.getDocumentInfo(mutation);
         variables = this.getVariables(mutation, variables);
         if (hasClientExports) {
-            variables = (await this.localState.addExportedVariables(mutation, variables, context));
+            if (environment_1.__DEV__) {
+                (0, invariant_1.invariant)(
+                    this.localState,
+                    85,
+                    (0, internal_1.getOperationName)(mutation, "(anonymous)")
+                );
+            }
+            variables = await this.localState.getExportedVariables({
+                client: this.client,
+                document: mutation,
+                variables,
+                context,
+            });
         }
         const mutationStoreValue = this.mutationStore &&
             (this.mutationStore[mutationId] = {
@@ -143,7 +153,7 @@ class QueryManager {
                 optimisticResponse: isOptimistic ? optimisticResponse : void 0,
             }, variables, {}, false)
                 .pipe(validateDidEmitValue(), (0, rxjs_1.mergeMap)((result) => {
-                const hasErrors = (0, utilities_4.graphQLResultHasError)(result);
+                const hasErrors = (0, internal_1.graphQLResultHasError)(result);
                 if (hasErrors && errorPolicy === "none") {
                     throw new errors_1.CombinedGraphQLErrors(result);
                 }
@@ -192,7 +202,7 @@ class QueryManager {
                                 id: mutationId,
                             }),
                         };
-                        if ((0, utilities_4.graphQLResultHasError)(storeResult)) {
+                        if ((0, internal_1.graphQLResultHasError)(storeResult)) {
                             result.error = new errors_1.CombinedGraphQLErrors(storeResult);
                         }
                         if (storeResult.extensions) {
@@ -226,7 +236,7 @@ class QueryManager {
         const cacheWrites = [];
         const skipCache = mutation.fetchPolicy === "no-cache";
         if (!skipCache && (0, QueryInfo_js_1.shouldWriteResult)(result, mutation.errorPolicy)) {
-            if (!(0, utilities_3.isExecutionPatchIncrementalResult)(result)) {
+            if (!(0, internal_1.isExecutionPatchIncrementalResult)(result)) {
                 cacheWrites.push({
                     result: result.data,
                     dataId: "ROOT_MUTATION",
@@ -234,8 +244,8 @@ class QueryManager {
                     variables: mutation.variables,
                 });
             }
-            if ((0, utilities_3.isExecutionPatchIncrementalResult)(result) &&
-                (0, utilities_4.isNonEmptyArray)(result.incremental)) {
+            if ((0, internal_1.isExecutionPatchIncrementalResult)(result) &&
+                (0, internal_1.isNonEmptyArray)(result.incremental)) {
                 const diff = cache.diff({
                     id: "ROOT_MUTATION",
                     // The cache complains if passed a mutation where it expects a
@@ -248,7 +258,7 @@ class QueryManager {
                 });
                 let mergedData;
                 if (diff.result) {
-                    mergedData = (0, utilities_5.mergeIncrementalData)(diff.result, result);
+                    mergedData = (0, internal_1.mergeIncrementalData)(diff.result, result);
                 }
                 if (typeof mergedData !== "undefined") {
                     // cast the ExecutionPatchResult to FetchResult here since
@@ -282,7 +292,7 @@ class QueryManager {
                         // Run our reducer using the current query result and the mutation result.
                         const nextQueryResult = updater(currentQueryResult, {
                             mutationResult: result,
-                            queryName: (document && (0, utilities_4.getOperationName)(document)) || void 0,
+                            queryName: (document && (0, internal_1.getOperationName)(document)) || void 0,
                             queryVariables: variables,
                         });
                         // Write the modified result back into the store if we got a new result.
@@ -315,8 +325,8 @@ class QueryManager {
                     const { update } = mutation;
                     // Determine whether result is a SingleExecutionResult,
                     // or the final ExecutionPatchResult.
-                    const isFinalResult = !(0, utilities_3.isExecutionPatchResult)(result) ||
-                        ((0, utilities_3.isExecutionPatchIncrementalResult)(result) && !result.hasNext);
+                    const isFinalResult = !(0, internal_1.isExecutionPatchResult)(result) ||
+                        ((0, internal_1.isExecutionPatchIncrementalResult)(result) && !result.hasNext);
                     if (update) {
                         if (!skipCache) {
                             // Re-read the ROOT_MUTATION data we just wrote into the cache
@@ -406,7 +416,18 @@ class QueryManager {
         return true;
     }
     fetchQuery(queryId, options, networkStatus) {
-        return (0, rxjs_1.lastValueFrom)(this.fetchObservableWithInfo(this.getOrCreateQuery(queryId), options, networkStatus).observable.pipe((0, rxjs_1.map)(internal_1.toQueryResult)), {
+        return (0, rxjs_1.lastValueFrom)(this.fetchObservableWithInfo(this.getOrCreateQuery(queryId), options, {
+            networkStatus,
+        }).observable.pipe((0, internal_1.filterMap)((value) => {
+            switch (value.kind) {
+                case "E":
+                    throw value.error;
+                case "N": {
+                    if (value.source !== "newNetworkStatus")
+                        return (0, internal_1.toQueryResult)(value.value);
+                }
+            }
+        })), {
             // This default is needed when a `standby` fetch policy is used to avoid
             // an EmptyError from rejecting this promise.
             defaultValue: { data: undefined },
@@ -415,7 +436,7 @@ class QueryManager {
     transform(document) {
         return this.documentTransform.transformDocument(document);
     }
-    transformCache = new utilities_2.AutoCleanedWeakCache(utilities_2.cacheSizes["queryManager.getDocumentInfo"] ||
+    transformCache = new internal_1.AutoCleanedWeakCache(utilities_2.cacheSizes["queryManager.getDocumentInfo"] ||
         2000 /* defaultCacheSizes["queryManager.getDocumentInfo"] */);
     getDocumentInfo(document) {
         const { transformCache } = this;
@@ -426,18 +447,18 @@ class QueryManager {
                 // of the transformed document. We should consider merging these
                 // traversals into a single pass in the future, though the work is
                 // cached after the first time.
-                hasClientExports: (0, utilities_4.hasClientExports)(document),
-                hasForcedResolvers: this.localState.shouldForceResolvers(document),
-                hasNonreactiveDirective: (0, utilities_3.hasDirectives)(["nonreactive"], document),
-                nonReactiveQuery: (0, utilities_3.addNonReactiveToNamedFragments)(document),
-                clientQuery: this.localState.clientQuery(document),
-                serverQuery: (0, utilities_3.removeDirectivesFromDocument)([
+                hasClientExports: (0, internal_1.hasDirectives)(["client", "export"], document, true),
+                hasForcedResolvers: (0, internal_1.hasForcedResolvers)(document),
+                hasNonreactiveDirective: (0, internal_1.hasDirectives)(["nonreactive"], document),
+                nonReactiveQuery: addNonReactiveToNamedFragments(document),
+                clientQuery: (0, internal_1.hasDirectives)(["client"], document) ? document : null,
+                serverQuery: (0, internal_1.removeDirectivesFromDocument)([
                     { name: "client", remove: true },
                     { name: "connection" },
                     { name: "nonreactive" },
                     { name: "unmask" },
                 ], document),
-                defaultVars: (0, utilities_4.getDefaultValues)((0, utilities_4.getOperationDefinition)(document)),
+                defaultVars: (0, internal_1.getDefaultValues)((0, internal_1.getOperationDefinition)(document)),
                 // Transform any mutation or subscription operations to query operations
                 // so we can read/write them from/to the cache.
                 asQuery: {
@@ -464,7 +485,7 @@ class QueryManager {
         };
     }
     watchQuery(options) {
-        (0, utilities_1.checkDocument)(options.query, graphql_1.OperationTypeNode.QUERY);
+        (0, internal_1.checkDocument)(options.query, graphql_1.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
@@ -492,7 +513,7 @@ class QueryManager {
         queryInfo.setObservableQuery(observable);
         return observable;
     }
-    query(options, queryId = this.generateQueryId()) {
+    async query(options, queryId = this.generateQueryId()) {
         const query = this.transform(options.query);
         return this.fetchQuery(queryId, {
             ...options,
@@ -529,16 +550,11 @@ 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)(78));
-        this.queries.forEach((queryInfo) => {
-            if (queryInfo.observableQuery) {
-                // Set loading to true so listeners don't trigger unless they want
-                // results with partial data.
-                queryInfo.observableQuery["networkStatus"] = networkStatus_js_1.NetworkStatus.loading;
-            }
-            else {
-                queryInfo.stop();
-            }
+        this.cancelPendingFetches((0, invariant_1.newInvariantError)(86));
+        this.queries.forEach(({ observableQuery }) => {
+            // Set loading to true so listeners don't trigger unless they want
+            // results with partial data.
+            observableQuery?.reset();
         });
         if (this.mutationStore) {
             this.mutationStore = {};
@@ -557,12 +573,12 @@ class QueryManager {
                     queryNames.set(desc, desc);
                     queryNamesAndQueryStrings.set(desc, false);
                 }
-                else if ((0, utilities_4.isDocumentNode)(desc)) {
+                else if ((0, internal_1.isDocumentNode)(desc)) {
                     const queryString = (0, utilities_1.print)(this.transform(desc));
-                    queryNames.set(queryString, (0, utilities_4.getOperationName)(desc));
+                    queryNames.set(queryString, (0, internal_1.getOperationName)(desc));
                     queryNamesAndQueryStrings.set(queryString, false);
                 }
-                else if ((0, utilities_4.isNonNullObject)(desc) && desc.query) {
+                else if ((0, internal_1.isNonNullObject)(desc) && desc.query) {
                     legacyQueryOptions.add(desc);
                 }
             });
@@ -594,7 +610,7 @@ class QueryManager {
                 // We will be issuing a fresh network request for this query, so we
                 // pre-allocate a new query ID here, using a special prefix to enable
                 // cleaning up these temporary queries later, after fetching.
-                const queryId = (0, utilities_4.makeUniqueId)("legacyOneTimeQuery");
+                const queryId = (0, internal_1.makeUniqueId)("legacyOneTimeQuery");
                 const queryInfo = this.getOrCreateQuery(queryId).init({
                     document: options.query,
                     variables: options.variables,
@@ -617,26 +633,25 @@ class QueryManager {
                 if (!included) {
                     const queryName = queryNames.get(nameOrQueryString);
                     if (queryName) {
-                        __DEV__ && invariant_1.invariant.warn(79, queryName);
+                        __DEV__ && invariant_1.invariant.warn(87, queryName);
                     }
                     else {
-                        __DEV__ && invariant_1.invariant.warn(80);
+                        __DEV__ && invariant_1.invariant.warn(88);
                     }
                 }
             });
         }
         return queries;
     }
-    reFetchObservableQueries(includeStandby = false) {
+    refetchObservableQueries(includeStandby = false) {
         const observableQueryPromises = [];
         this.getObservableQueries(includeStandby ? "all" : "active").forEach((observableQuery, queryId) => {
             const { fetchPolicy } = observableQuery.options;
-            observableQuery.resetLastResults();
             if (includeStandby ||
                 (fetchPolicy !== "standby" && fetchPolicy !== "cache-only")) {
                 observableQueryPromises.push(observableQuery.refetch());
             }
-            (this.queries.get(queryId) || observableQuery["queryInfo"]).setDiff(null);
+            (this.queries.get(queryId) || observableQuery["queryInfo"]).resetDiff();
         });
         this.broadcastQueries();
         return Promise.all(observableQueryPromises);
@@ -644,7 +659,7 @@ class QueryManager {
     startGraphQLSubscription(options) {
         let { query, variables } = options;
         const { fetchPolicy, errorPolicy = "none", context = {}, extensions = {}, } = options;
-        (0, utilities_1.checkDocument)(query, graphql_1.OperationTypeNode.SUBSCRIPTION);
+        (0, internal_1.checkDocument)(query, graphql_1.OperationTypeNode.SUBSCRIPTION);
         query = this.transform(query);
         variables = this.getVariables(query, variables);
         const makeObservable = (variables) => this.getObservableFromLink(query, context, variables, extensions).pipe((0, rxjs_1.map)((rawResult) => {
@@ -664,7 +679,7 @@ class QueryManager {
             const result = {
                 data: rawResult.data ?? undefined,
             };
-            if ((0, utilities_4.graphQLResultHasError)(rawResult)) {
+            if ((0, internal_1.graphQLResultHasError)(rawResult)) {
                 result.error = new errors_1.CombinedGraphQLErrors(rawResult);
             }
             else if ((0, errors_1.graphQLResultHasProtocolErrors)(rawResult)) {
@@ -690,9 +705,19 @@ class QueryManager {
             return (0, rxjs_1.of)({ data: undefined, error });
         }), (0, rxjs_1.filter)((result) => !!(result.data || result.error)));
         if (this.getDocumentInfo(query).hasClientExports) {
-            const observablePromise = this.localState
-                .addExportedVariables(query, variables, context)
-                .then(makeObservable);
+            if (environment_1.__DEV__) {
+                (0, invariant_1.invariant)(
+                    this.localState,
+                    89,
+                    (0, internal_1.getOperationName)(query, "(anonymous)")
+                );
+            }
+            const observablePromise = this.localState.getExportedVariables({
+                client: this.client,
+                document: query,
+                variables,
+                context,
+            }).then(makeObservable);
             return new rxjs_1.Observable((observer) => {
                 let sub = null;
                 observablePromise.then((observable) => (sub = observable.subscribe(observer)), observer.error);
@@ -709,17 +734,19 @@ class QueryManager {
         // The same queryId could have two rejection fns for two promises
         this.fetchCancelFns.delete(queryId);
         if (this.queries.has(queryId)) {
-            this.queries.get(queryId)?.stop();
+            const oq = this.queries.get(queryId).observableQuery;
+            if (oq) {
+                oq["resetNotifications"]();
+                oq["unsubscribeFromCache"]?.();
+                oq.stopPolling();
+            }
             this.queries.delete(queryId);
         }
     }
     broadcastQueries() {
         if (this.onBroadcast)
             this.onBroadcast();
-        this.queries.forEach((info) => info.observableQuery?.["notify"]());
-    }
-    getLocalState() {
-        return this.localState;
+        this.queries.forEach((info) => info.observableQuery?.notify());
     }
     // Use protected instead of private field so
     // @apollo/experimental-nextjs-app-support can access type info.
@@ -730,15 +757,7 @@ class QueryManager {
         this.queryDeduplication) {
         let observable;
         const { serverQuery, clientQuery } = this.getDocumentInfo(query);
-        const prepareContext = (context = {}) => {
-            const newContext = this.localState.prepareContext(context);
-            return {
-                ...this.defaultContext,
-                ...newContext,
-                queryDeduplication: deduplication,
-                clientAwareness: this.clientAwareness,
-            };
-        };
+        const operationName = (0, internal_1.getOperationName)(query);
         const executeContext = {
             client: this.client,
         };
@@ -747,8 +766,13 @@ class QueryManager {
             const operation = {
                 query: serverQuery,
                 variables,
-                operationName: (0, utilities_4.getOperationName)(serverQuery) || void 0,
-                context: prepareContext(context),
+                operationName,
+                context: {
+                    ...this.defaultContext,
+                    ...context,
+                    queryDeduplication: deduplication,
+                    clientAwareness: this.clientAwareness,
+                },
                 extensions,
             };
             context = operation.context;
@@ -775,11 +799,20 @@ class QueryManager {
         }
         else {
             observable = (0, rxjs_1.of)({ data: {} });
-            context = prepareContext(context);
         }
         if (clientQuery) {
+            if (environment_1.__DEV__) {
+                const { operation } = (0, internal_1.getOperationDefinition)(query);
+                (0, invariant_1.invariant)(
+                    this.localState,
+                    90,
+                    operation[0].toUpperCase() + operation.slice(1),
+                    operationName ?? "(anonymous)"
+                );
+            }
             observable = observable.pipe((0, rxjs_1.mergeMap)((result) => {
-                return (0, rxjs_1.from)(this.localState.runResolvers({
+                return (0, rxjs_1.from)(this.localState.execute({
+                    client: this.client,
                     document: clientQuery,
                     remoteResult: result,
                     context,
@@ -801,7 +834,7 @@ class QueryManager {
         // through the link chain.
         const linkDocument = this.cache.transformForLink(options.query);
         return this.getObservableFromLink(linkDocument, options.context, options.variables).pipe((0, rxjs_1.map)((result) => {
-            const graphQLErrors = (0, utilities_4.getGraphQLErrorsFromResult)(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.
@@ -855,11 +888,11 @@ class QueryManager {
             return (0, rxjs_1.of)(aqr);
         }));
     }
-    fetchObservableWithInfo(queryInfo, options, 
+    fetchObservableWithInfo(queryInfo, options, { 
     // The initial networkStatus for this fetch, most often
     // NetworkStatus.loading, but also possibly fetchMore, poll, refetch,
     // or setVariables.
-    networkStatus = networkStatus_js_1.NetworkStatus.loading, query = options.query, emitLoadingState = false) {
+    networkStatus = networkStatus_js_1.NetworkStatus.loading, query = options.query, fetchQueryOperator = (x) => x, onCacheHit = () => { }, }) {
         const variables = this.getVariables(query, options.variables);
         const defaults = this.defaultOptions.watchQuery;
         let { fetchPolicy = (defaults && defaults.fetchPolicy) || "cache-first", errorPolicy = (defaults && defaults.errorPolicy) || "none", returnPartialData = false, notifyOnNetworkStatusChange = true, context = {}, } = options;
@@ -881,7 +914,16 @@ class QueryManager {
             // modify its properties here, rather than creating yet another new
             // WatchQueryOptions object.
             normalized.variables = variables;
-            const observableWithInfo = this.fetchQueryByPolicy(queryInfo, normalized, networkStatus, emitLoadingState);
+            const cacheWriteBehavior = fetchPolicy === "no-cache" ? 0 /* CacheWriteBehavior.FORBID */
+                // Watched queries must opt into overwriting existing data on refetch,
+                // by passing refetchWritePolicy: "overwrite" in their WatchQueryOptions.
+                : (networkStatus === networkStatus_js_1.NetworkStatus.refetch &&
+                    normalized.refetchWritePolicy !== "merge") ?
+                    1 /* CacheWriteBehavior.OVERWRITE */
+                    : 2 /* CacheWriteBehavior.MERGE */;
+            const observableWithInfo = this.fetchQueryByPolicy(queryInfo, normalized, cacheWriteBehavior, onCacheHit);
+            observableWithInfo.observable =
+                observableWithInfo.observable.pipe(fetchQueryOperator);
             if (
             // If we're in standby, postpone advancing options.fetchPolicy using
             // applyNextFetchPolicy.
@@ -900,8 +942,13 @@ class QueryManager {
             // observables to complete before itself completes.
             fetchCancelSubject.complete();
         };
-        this.fetchCancelFns.set(queryInfo.queryId, (reason) => {
-            fetchCancelSubject.error(reason);
+        this.fetchCancelFns.set(queryInfo.queryId, (error) => {
+            fetchCancelSubject.next({
+                kind: "E",
+                error,
+                source: "network",
+            });
+            fetchCancelSubject.complete();
             cleanupCancelFn();
         });
         const fetchCancelSubject = new rxjs_1.Subject();
@@ -914,7 +961,19 @@ class QueryManager {
         // for backwards compatibility. TODO This code could be simpler if
         // we deprecated and removed LocalState.
         if (this.getDocumentInfo(normalized.query).hasClientExports) {
-            observable = (0, rxjs_1.from)(this.localState.addExportedVariables(normalized.query, normalized.variables, normalized.context)).pipe((0, rxjs_1.mergeMap)((variables) => fromVariables(variables).observable));
+            if (environment_1.__DEV__) {
+                (0, invariant_1.invariant)(
+                    this.localState,
+                    91,
+                    (0, internal_1.getOperationName)(normalized.query, "(anonymous)")
+                );
+            }
+            observable = (0, rxjs_1.from)(this.localState.getExportedVariables({
+                client: this.client,
+                document: normalized.query,
+                variables: normalized.variables,
+                context: normalized.context,
+            })).pipe((0, rxjs_1.mergeMap)((variables) => fromVariables(variables).observable));
             // there is just no way we can synchronously get the *right* value here,
             // so we will assume `true`, which is the behaviour before the bug fix in
             // #10597. This means that bug is not fixed in that case, and is probably
@@ -932,18 +991,23 @@ class QueryManager {
             fromLink: containsDataFromLink,
         };
     }
-    refetchQueries({ updateCache, include, optimistic = false, removeOptimistic = optimistic ? (0, utilities_4.makeUniqueId)("refetchQueries") : void 0, onQueryUpdated, }) {
+    refetchQueries({ updateCache, include, optimistic = false, removeOptimistic = optimistic ? (0, internal_1.makeUniqueId)("refetchQueries") : void 0, onQueryUpdated, }) {
         const includedQueriesById = new Map();
         if (include) {
             this.getObservableQueries(include).forEach((oq, queryId) => {
+                const current = oq.getCurrentResult();
                 includedQueriesById.set(queryId, {
                     oq,
-                    lastDiff: (this.queries.get(queryId) || oq["queryInfo"]).getDiff(),
+                    lastDiff: {
+                        result: current?.data,
+                        complete: !current?.partial,
+                    },
                 });
             });
         }
         const results = new Map();
         if (updateCache) {
+            const handled = new Set();
             this.cache.batch({
                 update: updateCache,
                 // Since you can perform any combination of cache reads and/or writes in
@@ -985,9 +1049,10 @@ class QueryManager {
                 // temporary optimistic layer, in case that ever matters.
                 removeOptimistic,
                 onWatchUpdated(watch, diff, lastDiff) {
-                    const oq = watch.watcher instanceof QueryInfo_js_1.QueryInfo && watch.watcher.observableQuery;
-                    if (oq) {
-                        if (onQueryUpdated) {
+                    const oq = watch.watcher;
+                    if (oq instanceof ObservableQuery_js_1.ObservableQuery) {
+                        if (onQueryUpdated && !handled.has(oq)) {
+                            handled.add(oq);
                             // Since we're about to handle this query now, remove it from
                             // includedQueriesById, in case it was added earlier because of
                             // options.include.
@@ -1024,7 +1089,7 @@ class QueryManager {
                 // queries, even the QueryOptions ones.
                 if (onQueryUpdated) {
                     if (!diff) {
-                        diff = this.cache.diff(oq["queryInfo"]["getDiffOptions"]());
+                        diff = this.cache.diff(oq["queryInfo"].getDiffOptions());
                     }
                     result = onQueryUpdated(oq, diff, lastDiff);
                 }
@@ -1057,15 +1122,17 @@ class QueryManager {
         const { document, data } = options;
         if (environment_1.__DEV__) {
             const { fetchPolicy, id } = options;
-            const operationType = (0, utilities_4.getOperationDefinition)(document)?.operation;
+            const operationType = (0, internal_1.getOperationDefinition)(document)?.operation;
             const operationId = (operationType?.[0] ?? "o") + id;
             if (this.dataMasking &&
                 fetchPolicy === "no-cache" &&
-                !(0, utilities_3.isFullyUnmaskedOperation)(document) &&
+                !isFullyUnmaskedOperation(document) &&
                 !this.noCacheWarningsByQueryId.has(operationId)) {
                 this.noCacheWarningsByQueryId.add(operationId);
-                __DEV__ && invariant_1.invariant.warn(81, (0, utilities_4.getOperationName)(document) ??
-                    `Unnamed ${operationType ?? "operation"}`);
+                __DEV__ && invariant_1.invariant.warn(
+                    92,
+                    (0, internal_1.getOperationName)(document, `Unnamed ${operationType ?? "operation"}`)
+                );
             }
         }
         return (this.dataMasking ?
@@ -1078,17 +1145,13 @@ class QueryManager {
             (0, masking_1.maskFragment)(data, fragment, this.cache, fragmentName)
             : data;
     }
-    fetchQueryByPolicy(queryInfo, { query, variables, fetchPolicy, refetchWritePolicy, errorPolicy, returnPartialData, context, }, 
-    // The initial networkStatus for this fetch, most often
-    // NetworkStatus.loading, but also possibly fetchMore, poll, refetch,
-    // or setVariables.
-    newNetworkStatus, emitLoadingState) {
+    fetchQueryByPolicy(queryInfo, { query, variables, fetchPolicy, errorPolicy, returnPartialData, context, }, cacheWriteBehavior, onCacheHit) {
         queryInfo.init({
             document: query,
             variables,
         });
-        const readCache = () => queryInfo.getDiff();
-        const resultsFromCache = (diff, networkStatus = newNetworkStatus) => {
+        const readCache = () => this.cache.diff(queryInfo.getDiffOptions());
+        const resultsFromCache = (diff, networkStatus) => {
             const data = diff.result;
             if (environment_1.__DEV__ && !returnPartialData && data !== null) {
                 (0, ObservableQuery_js_1.logMissingFieldErrors)(diff.missing);
@@ -1110,25 +1173,39 @@ class QueryManager {
                 };
             };
             const fromData = (data) => {
-                return (0, rxjs_1.of)(toResult(data));
+                return (0, rxjs_1.of)({
+                    kind: "N",
+                    value: toResult(data),
+                    source: "cache",
+                });
             };
-            if (this.getDocumentInfo(query).hasForcedResolvers) {
-                return (0, rxjs_1.from)(this.localState
-                    .runResolvers({
+            if (
+            // Don't attempt to run forced resolvers if we have incomplete cache
+            // data and partial isn't allowed since this result would get set to
+            // `undefined` anyways in `toResult`.
+            (diff.complete || returnPartialData) &&
+                this.getDocumentInfo(query).hasForcedResolvers) {
+                if (environment_1.__DEV__) {
+                    (0, invariant_1.invariant)(
+                        this.localState,
+                        93,
+                        (0, internal_1.getOperationName)(query, "(anonymous)")
+                    );
+                }
+                onCacheHit();
+                return (0, rxjs_1.from)(this.localState.execute({
+                    client: this.client,
                     document: query,
-                    // TODO: Update remoteResult to handle `null`. In v3 the `if`
-                    // statement contained a check against `data`, but this value was
-                    // always `{}` if nothing was in the cache, which meant the check
-                    // above always succeeded when there were forced resolvers. Now that
-                    // `data` is nullable, this `remoteResult` needs to be an empty
-                    // object. Ideally we can pass in `null` here and the resolvers
-                    // would be able to handle this the same way.
-                    remoteResult: { data: data || {} },
+                    remoteResult: data ? { data } : undefined,
                     context,
                     variables,
                     onlyRunForcedResolvers: true,
-                })
-                    .then((resolved) => toResult(resolved.data || void 0)));
+                    returnPartialData: true,
+                }).then((resolved) => ({
+                    kind: "N",
+                    value: toResult(resolved.data || void 0),
+                    source: "cache",
+                })));
             }
             // Resolves https://github.com/apollographql/apollo-client/issues/10317.
             // If errorPolicy is 'none' and notifyOnNetworkStatusChange is true,
@@ -1141,20 +1218,16 @@ class QueryManager {
             }
             return fromData(data || undefined);
         };
-        const cacheWriteBehavior = fetchPolicy === "no-cache" ? 0 /* CacheWriteBehavior.FORBID */
-            // Watched queries must opt into overwriting existing data on refetch,
-            // by passing refetchWritePolicy: "overwrite" in their WatchQueryOptions.
-            : (newNetworkStatus === networkStatus_js_1.NetworkStatus.refetch &&
-                refetchWritePolicy !== "merge") ?
-                1 /* CacheWriteBehavior.OVERWRITE */
-                : 2 /* CacheWriteBehavior.MERGE */;
         const resultsFromLink = () => this.getResultsFromLink(queryInfo, cacheWriteBehavior, {
             query,
             variables,
             context,
             fetchPolicy,
             errorPolicy,
-        }).pipe(validateDidEmitValue());
+        }).pipe(validateDidEmitValue(), (0, rxjs_1.materialize)(), (0, rxjs_1.map)((result) => ({
+            ...result,
+            source: "network",
+        })));
         switch (fetchPolicy) {
             default:
             case "cache-first": {
@@ -1165,20 +1238,20 @@ class QueryManager {
                         observable: resultsFromCache(diff, networkStatus_js_1.NetworkStatus.ready),
                     };
                 }
-                if (returnPartialData || emitLoadingState) {
+                if (returnPartialData) {
                     return {
                         fromLink: true,
-                        observable: (0, rxjs_1.concat)(resultsFromCache(diff), resultsFromLink()),
+                        observable: (0, rxjs_1.concat)(resultsFromCache(diff, networkStatus_js_1.NetworkStatus.loading), resultsFromLink()),
                     };
                 }
                 return { fromLink: true, observable: resultsFromLink() };
             }
             case "cache-and-network": {
                 const diff = readCache();
-                if (diff.complete || returnPartialData || emitLoadingState) {
+                if (diff.complete || returnPartialData) {
                     return {
                         fromLink: true,
-                        observable: (0, rxjs_1.concat)(resultsFromCache(diff), resultsFromLink()),
+                        observable: (0, rxjs_1.concat)(resultsFromCache(diff, networkStatus_js_1.NetworkStatus.loading), resultsFromLink()),
                     };
                 }
                 return { fromLink: true, observable: resultsFromLink() };
@@ -1189,23 +1262,8 @@ class QueryManager {
                     observable: (0, rxjs_1.concat)(resultsFromCache(readCache(), networkStatus_js_1.NetworkStatus.ready)),
                 };
             case "network-only":
-                if (emitLoadingState) {
-                    return {
-                        fromLink: true,
-                        observable: (0, rxjs_1.concat)(resultsFromCache(readCache()), resultsFromLink()),
-                    };
-                }
                 return { fromLink: true, observable: resultsFromLink() };
             case "no-cache":
-                if (emitLoadingState) {
-                    return {
-                        fromLink: true,
-                        // Note that queryInfo.getDiff() for no-cache queries does not call
-                        // cache.diff, but instead returns a { complete: false } stub result
-                        // when there is no queryInfo.diff already defined.
-                        observable: (0, rxjs_1.concat)(resultsFromCache(queryInfo.getDiff()), resultsFromLink()),
-                    };
-                }
                 return { fromLink: true, observable: resultsFromLink() };
             case "standby":
                 return { fromLink: false, observable: rxjs_1.EMPTY };
@@ -1226,7 +1284,43 @@ function validateDidEmitValue() {
             didEmitValue = true;
         },
         complete() {
-            (0, invariant_1.invariant)(didEmitValue, 82);
+            (0, invariant_1.invariant)(didEmitValue, 94);
+        },
+    });
+}
+function isFullyUnmaskedOperation(document) {
+    let isUnmasked = true;
+    (0, graphql_1.visit)(document, {
+        FragmentSpread: (node) => {
+            isUnmasked =
+                !!node.directives &&
+                    node.directives.some((directive) => directive.name.value === "unmask");
+            if (!isUnmasked) {
+                return graphql_1.BREAK;
+            }
+        },
+    });
+    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`
+            // since we want to react to changes in this fragment.
+            if (node.directives?.some((directive) => directive.name.value === "unmask")) {
+                return;
+            }
+            return {
+                ...node,
+                directives: [
+                    ...(node.directives || []),
+                    {
+                        kind: graphql_1.Kind.DIRECTIVE,
+                        name: { kind: graphql_1.Kind.NAME, value: "nonreactive" },
+                    },
+                ],
+            };
         },
     });
 }