@apollo/client 4.0.0-alpha.2 → 4.0.0-alpha.20

package/core/QueryManager.js

@@ -1,17 +1,15 @@
 import { Trie } from "@wry/trie";
-import { catchError, concat, EMPTY, from, lastValueFrom, map, mergeMap, mergeWith, Observable, of, share, shareReplay, Subject, tap, } from "rxjs";
+import { BREAK, Kind, OperationTypeNode, visit } from "graphql";
+import { Observable } 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, UnconventionalError, } from "@apollo/client/errors";
+import { CombinedGraphQLErrors, graphQLResultHasProtocolErrors, registerLinkError, toErrorLike, } from "@apollo/client/errors";
 import { PROTOCOL_ERRORS_SYMBOL } from "@apollo/client/errors";
-import { execute } from "@apollo/client/link/core";
+import { execute } from "@apollo/client/link";
 import { maskFragment, maskOperation } from "@apollo/client/masking";
-import { 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 { cacheSizes, DocumentTransform, print } from "@apollo/client/utilities";
 import { __DEV__ } from "@apollo/client/utilities/environment";
-import { onAnyEvent } from "@apollo/client/utilities/internal";
+import { AutoCleanedWeakCache, checkDocument, filterMap, getDefaultValues, getGraphQLErrorsFromResult, getOperationDefinition, getOperationName, graphQLResultHasError, hasDirectives, hasForcedResolvers, isDocumentNode, isExecutionPatchIncrementalResult, isExecutionPatchResult, isNonEmptyArray, isNonNullObject, makeUniqueId, mergeIncrementalData, 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";
@@ -19,22 +17,33 @@ import { QueryInfo, shouldWriteResult, } from "./QueryInfo.js";
 const { hasOwnProperty } = Object.prototype;
 const IGNORE = {};
 export class QueryManager {
-    cache;
-    link;
     defaultOptions;
+    client;
     assumeImmutableResults;
     documentTransform;
     ssrMode;
     defaultContext;
     dataMasking;
+    localState;
     queryDeduplication;
     clientAwareness = {};
-    localState;
+    /**
+     * Whether to prioritize cache values over network results when
+     * `fetchObservableWithInfo` is called.
+     * This will essentially turn a `"network-only"` or `"cache-and-network"`
+     * fetchPolicy into a `"cache-first"` fetchPolicy, but without influencing
+     * the `fetchPolicy` of the `ObservableQuery`.
+     *
+     * This can e.g. be used to prioritize the cache during the first render after
+     * SSR.
+     */
+    prioritizeCacheValues = false;
     onBroadcast;
     mutationStore;
-    // All the queries that the QueryManager is currently managing (not
-    // including mutations and subscriptions).
-    queries = new Map();
+    /**
+     * All ObservableQueries that currently have at least one subscriber.
+     */
+    obsQueries = new Set();
     // Maps from queryId strings to Promise rejection functions for
     // currently active queries and fetches.
     // Use protected instead of private field so
@@ -44,15 +53,14 @@ export class QueryManager {
         const defaultDocumentTransform = new DocumentTransform((document) => this.cache.transformDocument(document), 
         // Allow the apollo cache to manage its own transform caches
         { cache: false });
-        this.cache = options.cache;
-        this.link = options.link;
+        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 ?
@@ -69,29 +77,42 @@ export class QueryManager {
             this.mutationStore = {};
         }
     }
+    get link() {
+        return this.client.link;
+    }
+    get cache() {
+        return this.client.cache;
+    }
     /**
      * Call this method to terminate any active query processes, making it safe
      * to dispose of this QueryManager instance.
      */
     stop() {
-        this.queries.forEach((_info, queryId) => {
-            this.removeQuery(queryId);
-        });
-        this.cancelPendingFetches(newInvariantError(72));
+        this.obsQueries.forEach((oq) => oq.stop());
+        this.cancelPendingFetches(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, }) {
-        invariant(mutation, 73);
-        invariant(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 74);
+        invariant(mutation, 83);
+        checkDocument(mutation, OperationTypeNode.MUTATION);
+        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 (__DEV__) {
+                invariant(this.localState, 85, getOperationName(mutation, "(anonymous)"));
+            }
+            variables = await this.localState.getExportedVariables({
+                client: this.client,
+                document: mutation,
+                variables,
+                context,
+            });
         }
         const mutationStoreValue = this.mutationStore &&
             (this.mutationStore[mutationId] = {
@@ -114,13 +135,15 @@ export class QueryManager {
             });
         this.broadcastQueries();
         return new Promise((resolve, reject) => {
+            const cause = {};
             return this.getObservableFromLink(mutation, {
                 ...context,
                 optimisticResponse: isOptimistic ? optimisticResponse : void 0,
             }, variables, {}, false)
-                .pipe(mergeMap((result) => {
-                if (graphQLResultHasError(result) && errorPolicy === "none") {
-                    throw new CombinedGraphQLErrors(getGraphQLErrorsFromResult(result));
+                .observable.pipe(validateDidEmitValue(), mergeMap((result) => {
+                const hasErrors = graphQLResultHasError(result);
+                if (hasErrors && errorPolicy === "none") {
+                    throw new CombinedGraphQLErrors(result);
                 }
                 if (mutationStoreValue) {
                     mutationStoreValue.loading = false;
@@ -130,8 +153,7 @@ export class QueryManager {
                 if (typeof refetchQueries === "function") {
                     refetchQueries = refetchQueries(storeResult);
                 }
-                if (errorPolicy === "ignore" &&
-                    graphQLResultHasError(storeResult)) {
+                if (errorPolicy === "ignore" && hasErrors) {
                     delete storeResult.errors;
                 }
                 return from(this.markMutationResult({
@@ -160,28 +182,39 @@ export class QueryManager {
                     // ExecutionPatchResult has arrived and we have assembled the
                     // multipart response into a single result.
                     if (!("hasNext" in storeResult) || storeResult.hasNext === false) {
-                        resolve({
-                            ...storeResult,
+                        const result = {
                             data: this.maskOperation({
                                 document: mutation,
                                 data: storeResult.data,
                                 fetchPolicy,
-                                id: mutationId,
+                                cause,
                             }),
-                        });
+                        };
+                        if (graphQLResultHasError(storeResult)) {
+                            result.error = new CombinedGraphQLErrors(storeResult);
+                        }
+                        if (storeResult.extensions) {
+                            result.extensions = storeResult.extensions;
+                        }
+                        resolve(result);
                     }
                 },
-                error: (err) => {
-                    err = maybeWrapError(err);
+                error: (error) => {
                     if (mutationStoreValue) {
                         mutationStoreValue.loading = false;
-                        mutationStoreValue.error = err;
+                        mutationStoreValue.error = error;
                     }
                     if (isOptimistic) {
                         this.cache.removeOptimistic(mutationId);
                     }
                     this.broadcastQueries();
-                    reject(err);
+                    if (errorPolicy === "ignore") {
+                        return resolve({ data: undefined });
+                    }
+                    if (errorPolicy === "all") {
+                        return resolve({ data: undefined, error });
+                    }
+                    reject(error);
                 },
             });
         });
@@ -229,20 +262,15 @@ export class QueryManager {
             }
             const { updateQueries } = mutation;
             if (updateQueries) {
-                this.queries.forEach(({ observableQuery }, queryId) => {
+                this.obsQueries.forEach((observableQuery) => {
                     const queryName = observableQuery && observableQuery.queryName;
                     if (!queryName || !hasOwnProperty.call(updateQueries, queryName)) {
                         return;
                     }
                     const updater = updateQueries[queryName];
-                    const { document, variables } = this.queries.get(queryId);
+                    const { query: document, variables } = observableQuery;
                     // Read the current query result from the store.
-                    const { result: currentQueryResult, complete } = cache.diff({
-                        query: document,
-                        variables,
-                        returnPartialData: true,
-                        optimistic: false,
-                    });
+                    const { result: currentQueryResult, complete } = observableQuery.getCacheDiff({ optimistic: false });
                     if (complete && currentQueryResult) {
                         // Run our reducer using the current query result and the mutation result.
                         const nextQueryResult = updater(currentQueryResult, {
@@ -370,8 +398,26 @@ export class QueryManager {
         }, mutation.mutationId);
         return true;
     }
-    fetchQuery(queryId, options, networkStatus) {
-        return lastValueFrom(this.fetchObservableWithInfo(queryId, options, networkStatus).observable, { defaultValue: undefined });
+    fetchQuery(options, networkStatus) {
+        const queryInfo = new QueryInfo({
+            queryManager: this,
+        });
+        return lastValueFrom(this.fetchObservableWithInfo(queryInfo, options, {
+            networkStatus,
+        }).observable.pipe(filterMap((value) => {
+            switch (value.kind) {
+                case "E":
+                    throw value.error;
+                case "N": {
+                    if (value.source !== "newNetworkStatus")
+                        return 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 },
+        });
     }
     transform(document) {
         return this.documentTransform.transformDocument(document);
@@ -381,24 +427,26 @@ export class QueryManager {
     getDocumentInfo(document) {
         const { transformCache } = this;
         if (!transformCache.has(document)) {
+            const operationDefinition = getOperationDefinition(document);
             const cacheEntry = {
                 // TODO These three calls (hasClientExports, shouldForceResolvers, and
                 // usesNonreactiveDirective) are performing independent full traversals
                 // 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: hasClientExports(document),
-                hasForcedResolvers: this.localState.shouldForceResolvers(document),
+                hasClientExports: hasDirectives(["client", "export"], document, true),
+                hasForcedResolvers: hasForcedResolvers(document),
                 hasNonreactiveDirective: hasDirectives(["nonreactive"], document),
                 nonReactiveQuery: addNonReactiveToNamedFragments(document),
-                clientQuery: this.localState.clientQuery(document),
+                clientQuery: hasDirectives(["client"], document) ? document : null,
                 serverQuery: removeDirectivesFromDocument([
                     { name: "client", remove: true },
                     { name: "connection" },
                     { name: "nonreactive" },
                     { name: "unmask" },
                 ], document),
-                defaultVars: getDefaultValues(getOperationDefinition(document)),
+                operationType: operationDefinition?.operation,
+                defaultVars: getDefaultValues(operationDefinition),
                 // Transform any mutation or subscription operations to query operations
                 // so we can read/write them from/to the cache.
                 asQuery: {
@@ -417,12 +465,15 @@ export class QueryManager {
         return transformCache.get(document);
     }
     getVariables(document, variables) {
+        const defaultVars = this.getDocumentInfo(document).defaultVars;
+        const varsWithDefaults = Object.entries(variables ?? {}).map(([key, value]) => [key, value === undefined ? defaultVars[key] : value]);
         return {
-            ...this.getDocumentInfo(document).defaultVars,
-            ...variables,
+            ...defaultVars,
+            ...Object.fromEntries(varsWithDefaults),
         };
     }
     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
@@ -432,44 +483,28 @@ export class QueryManager {
             variables: this.getVariables(query, options.variables),
         };
         if (typeof options.notifyOnNetworkStatusChange === "undefined") {
-            options.notifyOnNetworkStatusChange = false;
+            options.notifyOnNetworkStatusChange = true;
         }
-        const queryInfo = new QueryInfo(this);
         const observable = new ObservableQuery({
             queryManager: this,
-            queryInfo,
             options,
-        });
-        observable["lastQuery"] = query;
-        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,
+            transformedQuery: query,
         });
         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, 75);
-        invariant(options.query.kind === "Document", 76);
-        invariant(!options.returnPartialData, 77);
-        invariant(!options.pollInterval, 78);
+    async query(options) {
         const query = this.transform(options.query);
-        return this.fetchQuery(queryId, { ...options, query })
-            .then((result) => result && {
-            ...result,
+        return this.fetchQuery({
+            ...options,
+            query,
+        }).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;
     generateQueryId() {
@@ -491,16 +526,11 @@ 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(79));
-        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.loading;
-            }
-            else {
-                queryInfo.stop();
-            }
+        this.cancelPendingFetches(newInvariantError(86));
+        this.obsQueries.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 = {};
@@ -509,7 +539,7 @@ export class QueryManager {
         return this.cache.reset(options);
     }
     getObservableQueries(include = "active") {
-        const queries = new Map();
+        const queries = new Set();
         const queryNames = new Map();
         const queryNamesAndQueryStrings = new Map();
         const legacyQueryOptions = new Set();
@@ -529,49 +559,36 @@ export class QueryManager {
                 }
             });
         }
-        this.queries.forEach(({ observableQuery: oq, document }, queryId) => {
-            if (oq) {
-                if (include === "all") {
-                    queries.set(queryId, oq);
-                    return;
-                }
-                const { queryName, options: { fetchPolicy }, } = oq;
-                if (fetchPolicy === "standby" ||
-                    (include === "active" && !oq.hasObservers())) {
-                    return;
-                }
-                if (include === "active" ||
-                    (queryName && queryNamesAndQueryStrings.has(queryName)) ||
-                    (document && queryNamesAndQueryStrings.has(print(document)))) {
-                    queries.set(queryId, oq);
-                    if (queryName)
-                        queryNamesAndQueryStrings.set(queryName, true);
-                    if (document)
-                        queryNamesAndQueryStrings.set(print(document), true);
-                }
+        this.obsQueries.forEach((oq) => {
+            const document = print(this.transform(oq.options.query));
+            if (include === "all") {
+                queries.add(oq);
+                return;
+            }
+            const { queryName, options: { fetchPolicy }, } = oq;
+            if (include === "active" && fetchPolicy === "standby") {
+                return;
+            }
+            if (include === "active" ||
+                (queryName && queryNamesAndQueryStrings.has(queryName)) ||
+                (document && queryNamesAndQueryStrings.has(document))) {
+                queries.add(oq);
+                if (queryName)
+                    queryNamesAndQueryStrings.set(queryName, true);
+                if (document)
+                    queryNamesAndQueryStrings.set(document, true);
             }
         });
         if (legacyQueryOptions.size) {
             legacyQueryOptions.forEach((options) => {
-                // 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 = makeUniqueId("legacyOneTimeQuery");
-                const queryInfo = this.getQuery(queryId).init({
-                    document: options.query,
-                    variables: options.variables,
-                });
                 const oq = new ObservableQuery({
                     queryManager: this,
-                    queryInfo,
                     options: {
                         ...options,
                         fetchPolicy: "network-only",
                     },
                 });
-                invariant(oq.queryId === queryId);
-                queryInfo.setObservableQuery(oq);
-                queries.set(queryId, oq);
+                queries.add(oq);
             });
         }
         if (__DEV__ && queryNamesAndQueryStrings.size) {
@@ -579,105 +596,101 @@ export class QueryManager {
                 if (!included) {
                     const queryName = queryNames.get(nameOrQueryString);
                     if (queryName) {
-                        __DEV__ && invariant.warn(80, queryName);
+                        __DEV__ && invariant.warn(87, queryName);
                     }
                     else {
-                        __DEV__ && invariant.warn(81);
+                        __DEV__ && invariant.warn(88);
                     }
                 }
             });
         }
         return queries;
     }
-    reFetchObservableQueries(includeStandby = false) {
+    refetchObservableQueries(includeStandby = false) {
         const observableQueryPromises = [];
-        this.getObservableQueries(includeStandby ? "all" : "active").forEach((observableQuery, queryId) => {
+        this.getObservableQueries(includeStandby ? "all" : "active").forEach((observableQuery) => {
             const { fetchPolicy } = observableQuery.options;
-            observableQuery.resetLastResults();
             if (includeStandby ||
                 (fetchPolicy !== "standby" && fetchPolicy !== "cache-only")) {
                 observableQueryPromises.push(observableQuery.refetch());
             }
-            this.getQuery(queryId).setDiff(null);
         });
         this.broadcastQueries();
         return Promise.all(observableQueryPromises);
     }
-    setObservableQuery(observableQuery) {
-        this.getQuery(observableQuery.queryId).setObservableQuery(observableQuery);
-    }
     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((result) => {
-            if (fetchPolicy !== "no-cache") {
-                // the subscription interface should handle not sending us results we no longer subscribe to.
-                // XXX I don't think we ever send in an object with errors, but we might in the future...
-                if (shouldWriteResult(result, errorPolicy)) {
-                    this.cache.write({
-                        query,
-                        result: result.data,
-                        dataId: "ROOT_SUBSCRIPTION",
-                        variables: variables,
-                    });
+        let restart;
+        if (__DEV__) {
+            invariant(
+                !this.getDocumentInfo(query).hasClientExports || this.localState,
+                89,
+                getOperationName(query, "(anonymous)")
+            );
+        }
+        const observable = (this.getDocumentInfo(query).hasClientExports ?
+            from(this.localState.getExportedVariables({
+                client: this.client,
+                document: query,
+                variables,
+                context,
+            }))
+            : of(variables)).pipe(mergeMap((variables) => {
+            const { observable, restart: res } = this.getObservableFromLink(query, context, variables, extensions);
+            restart = res;
+            return observable.pipe(map((rawResult) => {
+                if (fetchPolicy !== "no-cache") {
+                    // the subscription interface should handle not sending us results we no longer subscribe to.
+                    // XXX I don't think we ever send in an object with errors, but we might in the future...
+                    if (shouldWriteResult(rawResult, errorPolicy)) {
+                        this.cache.write({
+                            query,
+                            result: rawResult.data,
+                            dataId: "ROOT_SUBSCRIPTION",
+                            variables: variables,
+                        });
+                    }
+                    this.broadcastQueries();
                 }
-                this.broadcastQueries();
-            }
-            const hasErrors = graphQLResultHasError(result);
-            const hasProtocolErrors = graphQLResultHasProtocolErrors(result);
-            if (hasErrors && errorPolicy === "none") {
-                throw new CombinedGraphQLErrors(result.errors);
-            }
-            if (hasProtocolErrors) {
-                // `errorPolicy` is a mechanism for handling GraphQL errors, according
-                // to our documentation, so we throw protocol errors regardless of the
-                // set error policy.
-                throw result.extensions[PROTOCOL_ERRORS_SYMBOL];
-            }
-            if (errorPolicy === "ignore") {
-                delete result.errors;
-            }
-            return result;
-        }), catchError((error) => {
-            throw maybeWrapError(error);
+                const result = {
+                    data: rawResult.data ?? undefined,
+                };
+                if (graphQLResultHasError(rawResult)) {
+                    result.error = new CombinedGraphQLErrors(rawResult);
+                }
+                else if (graphQLResultHasProtocolErrors(rawResult)) {
+                    result.error = rawResult.extensions[PROTOCOL_ERRORS_SYMBOL];
+                    // Don't emit protocol errors added by HttpLink
+                    delete rawResult.extensions[PROTOCOL_ERRORS_SYMBOL];
+                }
+                if (rawResult.extensions &&
+                    Object.keys(rawResult.extensions).length) {
+                    result.extensions = rawResult.extensions;
+                }
+                if (result.error && errorPolicy === "none") {
+                    result.data = undefined;
+                }
+                if (errorPolicy === "ignore") {
+                    delete result.error;
+                }
+                return result;
+            }), catchError((error) => {
+                if (errorPolicy === "ignore") {
+                    return of({ data: undefined });
+                }
+                return of({ data: undefined, error });
+            }), filter((result) => !!(result.data || result.error)));
         }));
-        if (this.getDocumentInfo(query).hasClientExports) {
-            const observablePromise = this.localState
-                .addExportedVariables(query, variables, context)
-                .then(makeObservable);
-            return new Observable((observer) => {
-                let sub = null;
-                observablePromise.then((observable) => (sub = observable.subscribe(observer)), observer.error);
-                return () => sub && sub.unsubscribe();
-            });
-        }
-        return makeObservable(variables);
-    }
-    stopQuery(queryId) {
-        this.removeQuery(queryId);
-        this.broadcastQueries();
-    }
-    removeQuery(queryId) {
-        // teardown all links
-        // Both `QueryManager.fetchRequest` and `QueryManager.query` create separate promises
-        // that each add their reject functions to fetchCancelFns.
-        // A query created with `QueryManager.query()` could trigger a `QueryManager.fetchRequest`.
-        // The same queryId could have two rejection fns for two promises
-        this.fetchCancelFns.delete(queryId);
-        if (this.queries.has(queryId)) {
-            this.getQuery(queryId).stop();
-            this.queries.delete(queryId);
-        }
+        return Object.assign(observable, { restart: () => restart?.() });
     }
     broadcastQueries() {
         if (this.onBroadcast)
             this.onBroadcast();
-        this.queries.forEach((info) => info.notify());
-    }
-    getLocalState() {
-        return this.localState;
+        this.obsQueries.forEach((observableQuery) => observableQuery.notify());
     }
     // Use protected instead of private field so
     // @apollo/experimental-nextjs-app-support can access type info.
@@ -686,49 +699,86 @@ export class QueryManager {
     // Prefer context.queryDeduplication if specified.
     deduplication = context?.queryDeduplication ??
         this.queryDeduplication) {
-        let observable;
-        const { serverQuery, clientQuery } = this.getDocumentInfo(query);
+        let entry = {};
+        const { serverQuery, clientQuery, operationType } = this.getDocumentInfo(query);
+        const operationName = getOperationName(query);
+        const executeContext = {
+            client: this.client,
+        };
         if (serverQuery) {
             const { inFlightLinkObservables, link } = this;
             const operation = {
                 query: serverQuery,
                 variables,
-                operationName: getOperationName(serverQuery) || void 0,
-                context: this.prepareContext({
+                operationName,
+                context: {
+                    ...this.defaultContext,
                     ...context,
-                    forceFetch: !deduplication,
-                }),
+                    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;
+                    };
+                });
+            }
             if (deduplication) {
                 const printedServerQuery = print(serverQuery);
                 const varJson = canonicalStringify(variables);
-                const entry = inFlightLinkObservables.lookup(printedServerQuery, varJson);
-                observable = entry.observable;
-                if (!observable) {
-                    observable = entry.observable = execute(link, operation).pipe(onAnyEvent((event) => {
-                        if ((event.type !== "next" ||
-                            !("hasNext" in event.value) ||
-                            !event.value.hasNext) &&
-                            inFlightLinkObservables.peek(printedServerQuery, varJson) ===
-                                entry) {
+                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);
                         }
-                    }), shareReplay({ refCount: true }));
+                    }), 
+                    // 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 {
-                observable = execute(link, operation);
+                entry.observable = execute(link, operation, executeContext).pipe(withRestart);
             }
         }
         else {
-            observable = of({ data: {} });
-            context = this.prepareContext(context);
+            entry.observable = of({ data: {} });
         }
         if (clientQuery) {
-            observable = observable.pipe(mergeMap((result) => {
-                return from(this.localState.runResolvers({
+            if (__DEV__) {
+                const { operation } = getOperationDefinition(query);
+                invariant(
+                    this.localState,
+                    90,
+                    operation[0].toUpperCase() + operation.slice(1),
+                    operationName ?? "(anonymous)"
+                );
+            }
+            entry.observable = entry.observable.pipe(mergeMap((result) => {
+                return from(this.localState.execute({
+                    client: this.client,
                     document: clientQuery,
                     remoteResult: result,
                     context,
@@ -736,34 +786,33 @@ export class QueryManager {
                 }));
             }));
         }
-        return observable;
+        return {
+            restart: () => entry.restart?.(),
+            observable: entry.observable.pipe(catchError((error) => {
+                error = toErrorLike(error);
+                registerLinkError(error);
+                throw error;
+            })),
+        };
     }
     getResultsFromLink(queryInfo, cacheWriteBehavior, options) {
         const requestId = (queryInfo.lastRequestId = this.generateRequestId());
+        const { errorPolicy } = options;
         // Performing transformForLink here gives this.cache a chance to fill in
         // 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).pipe(catchError((error) => {
-            error = maybeWrapError(error);
-            // Avoid storing errors from older interrupted queries.
-            if (requestId >= queryInfo.lastRequestId) {
-                queryInfo.resetLastWrite();
-                queryInfo.reset();
-            }
-            throw error;
-        }), map((result) => {
+        return this.getObservableFromLink(linkDocument, options.context, options.variables).observable.pipe(map((result) => {
             const graphQLErrors = getGraphQLErrorsFromResult(result);
             const hasErrors = graphQLErrors.length > 0;
-            const { errorPolicy } = options;
             // 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();
-                    queryInfo.reset();
+                    queryInfo.observableQuery?.["resetNotifications"]();
                     // 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
@@ -772,33 +821,64 @@ export class QueryManager {
             }
             const aqr = {
                 data: result.data,
+                dataState: result.data ? "complete" : "empty",
                 loading: false,
                 networkStatus: NetworkStatus.ready,
                 partial: !result.data,
             };
+            if (isExecutionPatchResult(result) && result.hasNext) {
+                aqr.dataState = "streaming";
+                aqr.partial = true;
+            }
             // In the case we start multiple network requests simulatenously, we
             // 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(graphQLErrors);
+                aqr.error = new CombinedGraphQLErrors(result);
                 aqr.networkStatus = NetworkStatus.error;
+                if (aqr.data) {
+                    aqr.dataState = "complete";
+                }
             }
             return aqr;
+        }), catchError((error) => {
+            // Avoid storing errors from older interrupted queries.
+            if (requestId >= queryInfo.lastRequestId && errorPolicy === "none") {
+                queryInfo.resetLastWrite();
+                queryInfo.observableQuery?.["resetNotifications"]();
+                throw error;
+            }
+            const aqr = {
+                data: undefined,
+                dataState: "empty",
+                loading: false,
+                networkStatus: NetworkStatus.ready,
+                partial: true,
+            };
+            if (errorPolicy !== "ignore") {
+                aqr.error = error;
+                aqr.networkStatus = NetworkStatus.error;
+            }
+            return of(aqr);
         }));
     }
-    fetchObservableWithInfo(queryId, options, 
+    fetchObservableWithInfo(queryInfo, options, { 
     // The initial networkStatus for this fetch, most often
     // NetworkStatus.loading, but also possibly fetchMore, poll, refetch,
     // or setVariables.
-    networkStatus = NetworkStatus.loading, query = options.query, emitLoadingState = false) {
+    networkStatus = NetworkStatus.loading, query = options.query, fetchQueryOperator = (x) => x, onCacheHit = () => { }, }) {
         const variables = this.getVariables(query, options.variables);
-        const queryInfo = this.getQuery(queryId);
         const defaults = this.defaultOptions.watchQuery;
-        let { fetchPolicy = (defaults && defaults.fetchPolicy) || "cache-first", errorPolicy = (defaults && defaults.errorPolicy) || "none", returnPartialData = false, notifyOnNetworkStatusChange = false, context = {}, } = options;
+        let { fetchPolicy = (defaults && defaults.fetchPolicy) || "cache-first", errorPolicy = (defaults && defaults.errorPolicy) || "none", returnPartialData = false, notifyOnNetworkStatusChange = true, context = {}, } = options;
+        if (this.prioritizeCacheValues &&
+            (fetchPolicy === "network-only" || fetchPolicy === "cache-and-network")) {
+            fetchPolicy = "cache-first";
+        }
         const normalized = Object.assign({}, options, {
             query,
             variables,
@@ -813,7 +893,16 @@ export 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.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.
@@ -826,15 +915,14 @@ export class QueryManager {
         // This cancel function needs to be set before the concast is created,
         // in case concast creation synchronously cancels the request.
         const cleanupCancelFn = () => {
-            this.fetchCancelFns.delete(queryId);
-            // We need to call `complete` on the subject here otherwise the merged
-            // observable will never complete since it waits for all source
-            // observables to complete before itself completes.
-            fetchCancelSubject.complete();
+            this.fetchCancelFns.delete(queryInfo.queryId);
         };
-        this.fetchCancelFns.set(queryId, (reason) => {
-            fetchCancelSubject.error(reason);
-            cleanupCancelFn();
+        this.fetchCancelFns.set(queryInfo.queryId, (error) => {
+            fetchCancelSubject.next({
+                kind: "E",
+                error,
+                source: "network",
+            });
         });
         const fetchCancelSubject = new Subject();
         let observable, containsDataFromLink;
@@ -846,7 +934,15 @@ export class QueryManager {
         // for backwards compatibility. TODO This code could be simpler if
         // we deprecated and removed LocalState.
         if (this.getDocumentInfo(normalized.query).hasClientExports) {
-            observable = from(this.localState.addExportedVariables(normalized.query, normalized.variables, normalized.context)).pipe(mergeMap((variables) => fromVariables(variables).observable));
+            if (__DEV__) {
+                invariant(this.localState, 91, getOperationName(normalized.query, "(anonymous)"));
+            }
+            observable = from(this.localState.getExportedVariables({
+                client: this.client,
+                document: normalized.query,
+                variables: normalized.variables,
+                context: normalized.context,
+            })).pipe(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
@@ -860,22 +956,33 @@ export class QueryManager {
             observable = sourcesWithInfo.observable;
         }
         return {
-            observable: observable.pipe(tap({ error: cleanupCancelFn, complete: cleanupCancelFn }), mergeWith(fetchCancelSubject), share()),
+            // Merge `observable` with `fetchCancelSubject`, in a way that completing or
+            // erroring either of them will complete the merged obserable.
+            observable: new Observable((observer) => {
+                observer.add(cleanupCancelFn);
+                observable.subscribe(observer);
+                fetchCancelSubject.subscribe(observer);
+            }).pipe(share()),
             fromLink: containsDataFromLink,
         };
     }
     refetchQueries({ updateCache, include, optimistic = false, removeOptimistic = optimistic ? makeUniqueId("refetchQueries") : void 0, onQueryUpdated, }) {
-        const includedQueriesById = new Map();
+        const includedQueriesByOq = new Map();
         if (include) {
-            this.getObservableQueries(include).forEach((oq, queryId) => {
-                includedQueriesById.set(queryId, {
+            this.getObservableQueries(include).forEach((oq) => {
+                const current = oq.getCurrentResult();
+                includedQueriesByOq.set(oq, {
                     oq,
-                    lastDiff: this.getQuery(queryId).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
@@ -917,18 +1024,21 @@ export class QueryManager {
                 // temporary optimistic layer, in case that ever matters.
                 removeOptimistic,
                 onWatchUpdated(watch, diff, lastDiff) {
-                    const oq = watch.watcher instanceof QueryInfo && watch.watcher.observableQuery;
-                    if (oq) {
+                    const oq = watch.watcher;
+                    if (oq instanceof ObservableQuery && !handled.has(oq)) {
+                        handled.add(oq);
                         if (onQueryUpdated) {
                             // Since we're about to handle this query now, remove it from
                             // includedQueriesById, in case it was added earlier because of
                             // options.include.
-                            includedQueriesById.delete(oq.queryId);
+                            includedQueriesByOq.delete(oq);
                             let result = onQueryUpdated(oq, diff, lastDiff);
                             if (result === true) {
                                 // The onQueryUpdated function requested the default refetching
                                 // behavior by returning true.
-                                result = oq.refetch();
+                                result = oq
+                                    .refetch()
+                                    .retain( /* create a persistent subscription on the query */);
                             }
                             // Record the result in the results Map, as long as onQueryUpdated
                             // did not return false to skip/ignore this result.
@@ -943,35 +1053,32 @@ export class QueryManager {
                             // 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.
-                            includedQueriesById.set(oq.queryId, { oq, lastDiff, diff });
+                            includedQueriesByOq.set(oq, { oq, lastDiff, diff });
                         }
                     }
                 },
             });
         }
-        if (includedQueriesById.size) {
-            includedQueriesById.forEach(({ oq, lastDiff, diff }, queryId) => {
+        if (includedQueriesByOq.size) {
+            includedQueriesByOq.forEach(({ oq, lastDiff, diff }) => {
                 let result;
                 // If onQueryUpdated is provided, we want to use it for all included
                 // queries, even the QueryOptions ones.
                 if (onQueryUpdated) {
                     if (!diff) {
-                        const info = oq["queryInfo"];
-                        info.reset(); // Force info.getDiff() to read from cache.
-                        diff = info.getDiff();
+                        diff = oq.getCacheDiff();
                     }
                     result = onQueryUpdated(oq, diff, lastDiff);
                 }
                 // Otherwise, we fall back to refetching.
                 if (!onQueryUpdated || result === true) {
-                    result = oq.refetch();
+                    result = oq
+                        .refetch()
+                        .retain( /* create a persistent subscription on the query */);
                 }
                 if (result !== false) {
                     results.set(oq, result);
                 }
-                if (queryId.indexOf("legacyOneTimeQuery") >= 0) {
-                    this.removeQuery(queryId);
-                }
             });
         }
         if (removeOptimistic) {
@@ -986,20 +1093,18 @@ export class QueryManager {
         }
         return results;
     }
-    noCacheWarningsByQueryId = new Set();
+    noCacheWarningsByCause = new WeakSet();
     maskOperation(options) {
         const { document, data } = options;
         if (__DEV__) {
-            const { fetchPolicy, id } = options;
+            const { fetchPolicy, cause = {} } = options;
             const operationType = getOperationDefinition(document)?.operation;
-            const operationId = (operationType?.[0] ?? "o") + id;
             if (this.dataMasking &&
                 fetchPolicy === "no-cache" &&
                 !isFullyUnmaskedOperation(document) &&
-                !this.noCacheWarningsByQueryId.has(operationId)) {
-                this.noCacheWarningsByQueryId.add(operationId);
-                __DEV__ && invariant.warn(82, getOperationName(document) ??
-                    `Unnamed ${operationType ?? "operation"}`);
+                !this.noCacheWarningsByCause.has(cause)) {
+                this.noCacheWarningsByCause.add(cause);
+                __DEV__ && invariant.warn(92, getOperationName(document, `Unnamed ${operationType ?? "operation"}`));
             }
         }
         return (this.dataMasking ?
@@ -1012,17 +1117,13 @@ export class QueryManager {
             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 (__DEV__ && !returnPartialData && data !== null) {
                 logMissingFieldErrors(diff.missing);
@@ -1038,31 +1139,44 @@ export class QueryManager {
                 return {
                     // TODO: Handle partial data
                     data: data,
+                    dataState: diff.complete ? "complete"
+                        : data ? "partial"
+                            : "empty",
                     loading: isNetworkRequestInFlight(networkStatus),
                     networkStatus,
                     partial: !diff.complete,
                 };
             };
             const fromData = (data) => {
-                return of(toResult(data));
+                return of({
+                    kind: "N",
+                    value: toResult(data),
+                    source: "cache",
+                });
             };
-            if (this.getDocumentInfo(query).hasForcedResolvers) {
-                return 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 (__DEV__) {
+                    invariant(this.localState, 93, getOperationName(query, "(anonymous)"));
+                }
+                onCacheHit();
+                return 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,
@@ -1075,20 +1189,16 @@ export 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.refetch &&
-                refetchWritePolicy !== "merge") ?
-                1 /* CacheWriteBehavior.OVERWRITE */
-                : 2 /* CacheWriteBehavior.MERGE */;
         const resultsFromLink = () => this.getResultsFromLink(queryInfo, cacheWriteBehavior, {
             query,
             variables,
             context,
             fetchPolicy,
             errorPolicy,
-        });
+        }).pipe(validateDidEmitValue(), materialize(), map((result) => ({
+            ...result,
+            source: "network",
+        })));
         switch (fetchPolicy) {
             default:
             case "cache-first": {
@@ -1099,20 +1209,20 @@ export class QueryManager {
                         observable: resultsFromCache(diff, NetworkStatus.ready),
                     };
                 }
-                if (returnPartialData || emitLoadingState) {
+                if (returnPartialData) {
                     return {
                         fromLink: true,
-                        observable: concat(resultsFromCache(diff), resultsFromLink()),
+                        observable: concat(resultsFromCache(diff, 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: concat(resultsFromCache(diff), resultsFromLink()),
+                        observable: concat(resultsFromCache(diff, NetworkStatus.loading), resultsFromLink()),
                     };
                 }
                 return { fromLink: true, observable: resultsFromLink() };
@@ -1123,58 +1233,59 @@ export class QueryManager {
                     observable: concat(resultsFromCache(readCache(), NetworkStatus.ready)),
                 };
             case "network-only":
-                if (emitLoadingState) {
-                    return {
-                        fromLink: true,
-                        observable: 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: concat(resultsFromCache(queryInfo.getDiff()), resultsFromLink()),
-                    };
-                }
                 return { fromLink: true, observable: resultsFromLink() };
             case "standby":
                 return { fromLink: false, observable: EMPTY };
         }
     }
-    getQuery(queryId) {
-        if (queryId && !this.queries.has(queryId)) {
-            this.queries.set(queryId, new QueryInfo(this, queryId));
-        }
-        return this.queries.get(queryId);
-    }
-    prepareContext(context = {}) {
-        const newContext = this.localState.prepareContext(context);
-        return {
-            ...this.defaultContext,
-            ...newContext,
-            clientAwareness: this.clientAwareness,
-        };
-    }
 }
-function isErrorLike(error) {
-    return (error !== null &&
-        typeof error === "object" &&
-        typeof error.message === "string" &&
-        typeof error.name === "string" &&
-        (typeof error.stack === "undefined" ||
-            typeof error.stack === "string"));
+function validateDidEmitValue() {
+    let didEmitValue = false;
+    return tap({
+        next() {
+            didEmitValue = true;
+        },
+        complete() {
+            invariant(didEmitValue, 94);
+        },
+    });
 }
-function maybeWrapError(error) {
-    if (isErrorLike(error)) {
-        return error;
-    }
-    if (typeof error === "string") {
-        return new Error(error, { cause: error });
-    }
-    return new UnconventionalError(error);
+function isFullyUnmaskedOperation(document) {
+    let isUnmasked = true;
+    visit(document, {
+        FragmentSpread: (node) => {
+            isUnmasked =
+                !!node.directives &&
+                    node.directives.some((directive) => directive.name.value === "unmask");
+            if (!isUnmasked) {
+                return BREAK;
+            }
+        },
+    });
+    return isUnmasked;
+}
+function addNonReactiveToNamedFragments(document) {
+    checkDocument(document);
+    return 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: Kind.DIRECTIVE,
+                        name: { kind: Kind.NAME, value: "nonreactive" },
+                    },
+                ],
+            };
+        },
+    });
 }
 //# sourceMappingURL=QueryManager.js.map