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

package/core/QueryManager.js

@@ -9,16 +9,18 @@ import { execute } from "@apollo/client/link";
 import { maskFragment, maskOperation } from "@apollo/client/masking";
 import { cacheSizes, DocumentTransform, print } from "@apollo/client/utilities";
 import { __DEV__ } from "@apollo/client/utilities/environment";
-import { AutoCleanedWeakCache, checkDocument, filterMap, getDefaultValues, getGraphQLErrorsFromResult, getOperationDefinition, getOperationName, graphQLResultHasError, hasDirectives, hasForcedResolvers, isDocumentNode, isExecutionPatchIncrementalResult, isExecutionPatchResult, isNonEmptyArray, isNonNullObject, makeUniqueId, mergeIncrementalData, removeDirectivesFromDocument, toQueryResult, } from "@apollo/client/utilities/internal";
+import { AutoCleanedWeakCache, checkDocument, filterMap, getDefaultValues, getGraphQLErrorsFromResult, getOperationDefinition, getOperationName, graphQLResultHasError, hasDirectives, hasForcedResolvers, isDocumentNode, isExecutionPatchResult, isNonNullObject, makeUniqueId, removeDirectivesFromDocument, toQueryResult, } from "@apollo/client/utilities/internal";
 import { invariant, newInvariantError, } from "@apollo/client/utilities/invariant";
 import { isNetworkRequestInFlight, NetworkStatus } from "./networkStatus.js";
 import { logMissingFieldErrors, ObservableQuery } from "./ObservableQuery.js";
-import { QueryInfo, shouldWriteResult, } from "./QueryInfo.js";
-const { hasOwnProperty } = Object.prototype;
-const IGNORE = {};
+import { QueryInfo } from "./QueryInfo.js";
 export class QueryManager {
     defaultOptions;
     client;
+    /**
+     * The options that were passed to the ApolloClient constructor.
+     */
+    clientOptions;
     assumeImmutableResults;
     documentTransform;
     ssrMode;
@@ -26,7 +28,6 @@ export class QueryManager {
     dataMasking;
     localState;
     queryDeduplication;
-    clientAwareness = {};
     /**
      * Whether to prioritize cache values over network results when
      * `fetchObservableWithInfo` is called.
@@ -44,7 +45,7 @@ export class QueryManager {
      * All ObservableQueries that currently have at least one subscriber.
      */
     obsQueries = new Set();
-    // Maps from queryId strings to Promise rejection functions for
+    // Maps from queryInfo.id strings to Promise rejection functions for
     // currently active queries and fetches.
     // Use protected instead of private field so
     // @apollo/experimental-nextjs-app-support can access type info.
@@ -56,7 +57,7 @@ export class QueryManager {
         this.client = options.client;
         this.defaultOptions = options.defaultOptions;
         this.queryDeduplication = options.queryDeduplication;
-        this.clientAwareness = options.clientAwareness;
+        this.clientOptions = options.clientOptions;
         this.ssrMode = options.ssrMode;
         this.assumeImmutableResults = options.assumeImmutableResults;
         this.dataMasking = options.dataMasking;
@@ -89,23 +90,20 @@ export class QueryManager {
      */
     stop() {
         this.obsQueries.forEach((oq) => oq.stop());
-        this.cancelPendingFetches(newInvariantError(82));
+        this.cancelPendingFetches(newInvariantError(83));
     }
     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, 83);
-        checkDocument(mutation, OperationTypeNode.MUTATION);
-        invariant(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 84);
-        const mutationId = this.generateMutationId();
+    async mutate({ mutation, variables, optimisticResponse, updateQueries, refetchQueries = [], awaitRefetchQueries = false, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }) {
+        const queryInfo = new QueryInfo(this);
         mutation = this.cache.transformForLink(this.transform(mutation));
         const { hasClientExports } = this.getDocumentInfo(mutation);
         variables = this.getVariables(mutation, variables);
         if (hasClientExports) {
             if (__DEV__) {
-                invariant(this.localState, 85, getOperationName(mutation, "(anonymous)"));
+                invariant(this.localState, 84, getOperationName(mutation, "(anonymous)"));
             }
             variables = await this.localState.getExportedVariables({
                 client: this.client,
@@ -115,18 +113,19 @@ export class QueryManager {
             });
         }
         const mutationStoreValue = this.mutationStore &&
-            (this.mutationStore[mutationId] = {
+            (this.mutationStore[queryInfo.id] = {
                 mutation,
                 variables,
                 loading: true,
                 error: null,
             });
         const isOptimistic = optimisticResponse &&
-            this.markMutationOptimistic(optimisticResponse, {
-                mutationId,
+            queryInfo.markMutationOptimistic(optimisticResponse, {
                 document: mutation,
                 variables,
-                fetchPolicy,
+                cacheWriteBehavior: fetchPolicy === "no-cache" ?
+                    0 /* CacheWriteBehavior.FORBID */
+                    : 2 /* CacheWriteBehavior.MERGE */,
                 errorPolicy,
                 context,
                 updateQueries,
@@ -156,19 +155,19 @@ export class QueryManager {
                 if (errorPolicy === "ignore" && hasErrors) {
                     delete storeResult.errors;
                 }
-                return from(this.markMutationResult({
-                    mutationId,
-                    result: storeResult,
+                return from(queryInfo.markMutationResult(storeResult, {
                     document: mutation,
                     variables,
-                    fetchPolicy,
+                    cacheWriteBehavior: fetchPolicy === "no-cache" ?
+                        0 /* CacheWriteBehavior.FORBID */
+                        : 2 /* CacheWriteBehavior.MERGE */,
                     errorPolicy,
                     context,
                     update: updateWithProxyFn,
                     updateQueries,
                     awaitRefetchQueries,
                     refetchQueries,
-                    removeOptimistic: isOptimistic ? mutationId : void 0,
+                    removeOptimistic: isOptimistic ? queryInfo.id : void 0,
                     onQueryUpdated,
                     keepRootFields,
                 }));
@@ -205,7 +204,7 @@ export class QueryManager {
                         mutationStoreValue.error = error;
                     }
                     if (isOptimistic) {
-                        this.cache.removeOptimistic(mutationId);
+                        this.cache.removeOptimistic(queryInfo.id);
                     }
                     this.broadcastQueries();
                     if (errorPolicy === "ignore") {
@@ -219,190 +218,11 @@ export class QueryManager {
             });
         });
     }
-    markMutationResult(mutation, cache = this.cache) {
-        let { result } = mutation;
-        const cacheWrites = [];
-        const skipCache = mutation.fetchPolicy === "no-cache";
-        if (!skipCache && shouldWriteResult(result, mutation.errorPolicy)) {
-            if (!isExecutionPatchIncrementalResult(result)) {
-                cacheWrites.push({
-                    result: result.data,
-                    dataId: "ROOT_MUTATION",
-                    query: mutation.document,
-                    variables: mutation.variables,
-                });
-            }
-            if (isExecutionPatchIncrementalResult(result) &&
-                isNonEmptyArray(result.incremental)) {
-                const diff = cache.diff({
-                    id: "ROOT_MUTATION",
-                    // The cache complains if passed a mutation where it expects a
-                    // query, so we transform mutations and subscriptions to queries
-                    // (only once, thanks to this.transformCache).
-                    query: this.getDocumentInfo(mutation.document).asQuery,
-                    variables: mutation.variables,
-                    optimistic: false,
-                    returnPartialData: true,
-                });
-                let mergedData;
-                if (diff.result) {
-                    mergedData = mergeIncrementalData(diff.result, result);
-                }
-                if (typeof mergedData !== "undefined") {
-                    // cast the ExecutionPatchResult to FetchResult here since
-                    // ExecutionPatchResult never has `data` when returned from the server
-                    result.data = mergedData;
-                    cacheWrites.push({
-                        result: mergedData,
-                        dataId: "ROOT_MUTATION",
-                        query: mutation.document,
-                        variables: mutation.variables,
-                    });
-                }
-            }
-            const { updateQueries } = mutation;
-            if (updateQueries) {
-                this.obsQueries.forEach((observableQuery) => {
-                    const queryName = observableQuery && observableQuery.queryName;
-                    if (!queryName || !hasOwnProperty.call(updateQueries, queryName)) {
-                        return;
-                    }
-                    const updater = updateQueries[queryName];
-                    const { query: document, variables } = observableQuery;
-                    // Read the current query result from the store.
-                    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, {
-                            mutationResult: result,
-                            queryName: (document && getOperationName(document)) || void 0,
-                            queryVariables: variables,
-                        });
-                        // Write the modified result back into the store if we got a new result.
-                        if (nextQueryResult) {
-                            cacheWrites.push({
-                                result: nextQueryResult,
-                                dataId: "ROOT_QUERY",
-                                query: document,
-                                variables,
-                            });
-                        }
-                    }
-                });
-            }
-        }
-        if (cacheWrites.length > 0 ||
-            (mutation.refetchQueries || "").length > 0 ||
-            mutation.update ||
-            mutation.onQueryUpdated ||
-            mutation.removeOptimistic) {
-            const results = [];
-            this.refetchQueries({
-                updateCache: (cache) => {
-                    if (!skipCache) {
-                        cacheWrites.forEach((write) => cache.write(write));
-                    }
-                    // If the mutation has some writes associated with it then we need to
-                    // apply those writes to the store by running this reducer again with
-                    // a write action.
-                    const { update } = mutation;
-                    // Determine whether result is a SingleExecutionResult,
-                    // or the final ExecutionPatchResult.
-                    const isFinalResult = !isExecutionPatchResult(result) ||
-                        (isExecutionPatchIncrementalResult(result) && !result.hasNext);
-                    if (update) {
-                        if (!skipCache) {
-                            // Re-read the ROOT_MUTATION data we just wrote into the cache
-                            // (the first cache.write call in the cacheWrites.forEach loop
-                            // above), so field read functions have a chance to run for
-                            // fields within mutation result objects.
-                            const diff = cache.diff({
-                                id: "ROOT_MUTATION",
-                                // The cache complains if passed a mutation where it expects a
-                                // query, so we transform mutations and subscriptions to queries
-                                // (only once, thanks to this.transformCache).
-                                query: this.getDocumentInfo(mutation.document).asQuery,
-                                variables: mutation.variables,
-                                optimistic: false,
-                                returnPartialData: true,
-                            });
-                            if (diff.complete) {
-                                result = { ...result, data: diff.result };
-                                if ("incremental" in result) {
-                                    delete result.incremental;
-                                }
-                                if ("hasNext" in result) {
-                                    delete result.hasNext;
-                                }
-                            }
-                        }
-                        // If we've received the whole response,
-                        // either a SingleExecutionResult or the final ExecutionPatchResult,
-                        // call the update function.
-                        if (isFinalResult) {
-                            update(cache, result, {
-                                context: mutation.context,
-                                variables: mutation.variables,
-                            });
-                        }
-                    }
-                    // TODO Do this with cache.evict({ id: 'ROOT_MUTATION' }) but make it
-                    // shallow to allow rolling back optimistic evictions.
-                    if (!skipCache && !mutation.keepRootFields && isFinalResult) {
-                        cache.modify({
-                            id: "ROOT_MUTATION",
-                            fields(value, { fieldName, DELETE }) {
-                                return fieldName === "__typename" ? value : DELETE;
-                            },
-                        });
-                    }
-                },
-                include: mutation.refetchQueries,
-                // Write the final mutation.result to the root layer of the cache.
-                optimistic: false,
-                // Remove the corresponding optimistic layer at the same time as we
-                // write the final non-optimistic result.
-                removeOptimistic: mutation.removeOptimistic,
-                // Let the caller of client.mutate optionally determine the refetching
-                // behavior for watched queries after the mutation.update function runs.
-                // If no onQueryUpdated function was provided for this mutation, pass
-                // null instead of undefined to disable the default refetching behavior.
-                onQueryUpdated: mutation.onQueryUpdated || null,
-            }).forEach((result) => results.push(result));
-            if (mutation.awaitRefetchQueries || mutation.onQueryUpdated) {
-                // Returning a promise here makes the mutation await that promise, so we
-                // include results in that promise's work if awaitRefetchQueries or an
-                // onQueryUpdated function was specified.
-                return Promise.all(results).then(() => result);
-            }
-        }
-        return Promise.resolve(result);
-    }
-    markMutationOptimistic(optimisticResponse, mutation) {
-        const data = typeof optimisticResponse === "function" ?
-            optimisticResponse(mutation.variables, { IGNORE })
-            : optimisticResponse;
-        if (data === IGNORE) {
-            return false;
-        }
-        this.cache.recordOptimisticTransaction((cache) => {
-            try {
-                this.markMutationResult({
-                    ...mutation,
-                    result: { data },
-                }, cache);
-            }
-            catch (error) {
-                __DEV__ && invariant.error(error);
-            }
-        }, mutation.mutationId);
-        return true;
-    }
     fetchQuery(options, networkStatus) {
-        const queryInfo = new QueryInfo({
-            queryManager: this,
-        });
-        return lastValueFrom(this.fetchObservableWithInfo(queryInfo, options, {
+        checkDocument(options.query, OperationTypeNode.QUERY);
+        // do the rest asynchronously to keep the same rejection timing as
+        // checks further in `.mutate`
+        return (async () => lastValueFrom(this.fetchObservableWithInfo(options, {
             networkStatus,
         }).observable.pipe(filterMap((value) => {
             switch (value.kind) {
@@ -417,7 +237,7 @@ export class QueryManager {
             // This default is needed when a `standby` fetch policy is used to avoid
             // an EmptyError from rejecting this promise.
             defaultValue: { data: undefined },
-        });
+        }))();
     }
     transform(document) {
         return this.documentTransform.transformDocument(document);
@@ -462,7 +282,11 @@ export class QueryManager {
             };
             transformCache.set(document, cacheEntry);
         }
-        return transformCache.get(document);
+        const entry = transformCache.get(document);
+        if (entry.violation) {
+            throw entry.violation;
+        }
+        return entry;
     }
     getVariables(document, variables) {
         const defaultVars = this.getDocumentInfo(document).defaultVars;
@@ -492,7 +316,7 @@ export class QueryManager {
         });
         return observable;
     }
-    async query(options) {
+    query(options) {
         const query = this.transform(options.query);
         return this.fetchQuery({
             ...options,
@@ -506,18 +330,10 @@ export class QueryManager {
             }),
         }));
     }
-    queryIdCounter = 1;
-    generateQueryId() {
-        return String(this.queryIdCounter++);
-    }
     requestIdCounter = 1;
     generateRequestId() {
         return this.requestIdCounter++;
     }
-    mutationIdCounter = 1;
-    generateMutationId() {
-        return String(this.mutationIdCounter++);
-    }
     clearStore(options = {
         discardWatches: true,
     }) {
@@ -526,7 +342,7 @@ export class QueryManager {
         // depend on values that previously existed in the data portion of the
         // store. So, we cancel the promises and observers that we have issued
         // so far and not yet resolved (in the case of queries).
-        this.cancelPendingFetches(newInvariantError(86));
+        this.cancelPendingFetches(newInvariantError(85));
         this.obsQueries.forEach((observableQuery) => {
             // Set loading to true so listeners don't trigger unless they want
             // results with partial data.
@@ -596,10 +412,10 @@ export class QueryManager {
                 if (!included) {
                     const queryName = queryNames.get(nameOrQueryString);
                     if (queryName) {
-                        __DEV__ && invariant.warn(87, queryName);
+                        __DEV__ && invariant.warn(86, queryName);
                     }
                     else {
-                        __DEV__ && invariant.warn(88);
+                        __DEV__ && invariant.warn(87);
                     }
                 }
             });
@@ -628,7 +444,7 @@ export class QueryManager {
         if (__DEV__) {
             invariant(
                 !this.getDocumentInfo(query).hasClientExports || this.localState,
-                89,
+                88,
                 getOperationName(query, "(anonymous)")
             );
         }
@@ -641,21 +457,17 @@ export class QueryManager {
             }))
             : of(variables)).pipe(mergeMap((variables) => {
             const { observable, restart: res } = this.getObservableFromLink(query, context, variables, extensions);
+            const queryInfo = new QueryInfo(this);
             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();
-                }
+                queryInfo.markSubscriptionResult(rawResult, {
+                    document: query,
+                    variables,
+                    errorPolicy,
+                    cacheWriteBehavior: fetchPolicy === "no-cache" ?
+                        0 /* CacheWriteBehavior.FORBID */
+                        : 2 /* CacheWriteBehavior.MERGE */,
+                });
                 const result = {
                     data: rawResult.data ?? undefined,
                 };
@@ -715,7 +527,6 @@ export class QueryManager {
                     ...this.defaultContext,
                     ...context,
                     queryDeduplication: deduplication,
-                    clientAwareness: this.clientAwareness,
                 },
                 extensions,
             };
@@ -771,7 +582,7 @@ export class QueryManager {
                 const { operation } = getOperationDefinition(query);
                 invariant(
                     this.localState,
-                    90,
+                    89,
                     operation[0].toUpperCase() + operation.slice(1),
                     operationName ?? "(anonymous)"
                 );
@@ -795,7 +606,7 @@ export class QueryManager {
             })),
         };
     }
-    getResultsFromLink(queryInfo, cacheWriteBehavior, options) {
+    getResultsFromLink(options, { queryInfo, cacheWriteBehavior, observableQuery, }) {
         const requestId = (queryInfo.lastRequestId = this.generateRequestId());
         const { errorPolicy } = options;
         // Performing transformForLink here gives this.cache a chance to fill in
@@ -810,26 +621,35 @@ export class QueryManager {
             if (requestId >= queryInfo.lastRequestId) {
                 if (hasErrors && errorPolicy === "none") {
                     queryInfo.resetLastWrite();
-                    queryInfo.observableQuery?.["resetNotifications"]();
+                    observableQuery?.["resetNotifications"]();
                     // Throwing here effectively calls observer.error.
                     throw new CombinedGraphQLErrors(result);
                 }
                 // Use linkDocument rather than queryInfo.document so the
                 // operation/fragments used to write the result are the same as the
                 // ones used to obtain it from the link.
-                queryInfo.markResult(result, linkDocument, options, cacheWriteBehavior);
+                queryInfo.markQueryResult(result, {
+                    ...options,
+                    document: linkDocument,
+                    cacheWriteBehavior,
+                });
             }
             const aqr = {
                 data: result.data,
-                dataState: result.data ? "complete" : "empty",
-                loading: false,
-                networkStatus: NetworkStatus.ready,
-                partial: !result.data,
+                ...(isExecutionPatchResult(result) && result.hasNext ?
+                    {
+                        loading: true,
+                        networkStatus: NetworkStatus.streaming,
+                        dataState: "streaming",
+                        partial: true,
+                    }
+                    : {
+                        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
@@ -850,7 +670,7 @@ export class QueryManager {
             // Avoid storing errors from older interrupted queries.
             if (requestId >= queryInfo.lastRequestId && errorPolicy === "none") {
                 queryInfo.resetLastWrite();
-                queryInfo.observableQuery?.["resetNotifications"]();
+                observableQuery?.["resetNotifications"]();
                 throw error;
             }
             const aqr = {
@@ -867,11 +687,11 @@ export class QueryManager {
             return of(aqr);
         }));
     }
-    fetchObservableWithInfo(queryInfo, options, { 
+    fetchObservableWithInfo(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, fetchQueryOperator = (x) => x, onCacheHit = () => { }, }) {
+    networkStatus = NetworkStatus.loading, query = options.query, fetchQueryOperator = (x) => x, onCacheHit = () => { }, observableQuery, }) {
         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;
@@ -888,6 +708,7 @@ export class QueryManager {
             notifyOnNetworkStatusChange,
             context,
         });
+        const queryInfo = new QueryInfo(this, observableQuery);
         const fromVariables = (variables) => {
             // Since normalized is always a fresh copy of options, it's safe to
             // modify its properties here, rather than creating yet another new
@@ -900,24 +721,23 @@ export class QueryManager {
                     normalized.refetchWritePolicy !== "merge") ?
                     1 /* CacheWriteBehavior.OVERWRITE */
                     : 2 /* CacheWriteBehavior.MERGE */;
-            const observableWithInfo = this.fetchQueryByPolicy(queryInfo, normalized, cacheWriteBehavior, onCacheHit);
+            const observableWithInfo = this.fetchQueryByPolicy(normalized, { queryInfo, cacheWriteBehavior, onCacheHit, observableQuery });
             observableWithInfo.observable =
                 observableWithInfo.observable.pipe(fetchQueryOperator);
             if (
             // If we're in standby, postpone advancing options.fetchPolicy using
             // applyNextFetchPolicy.
-            normalized.fetchPolicy !== "standby" &&
-                queryInfo.observableQuery) {
-                queryInfo.observableQuery["applyNextFetchPolicy"]("after-fetch", options);
+            normalized.fetchPolicy !== "standby") {
+                observableQuery?.["applyNextFetchPolicy"]("after-fetch", options);
             }
             return observableWithInfo;
         };
         // 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(queryInfo.queryId);
+            this.fetchCancelFns.delete(queryInfo.id);
         };
-        this.fetchCancelFns.set(queryInfo.queryId, (error) => {
+        this.fetchCancelFns.set(queryInfo.id, (error) => {
             fetchCancelSubject.next({
                 kind: "E",
                 error,
@@ -935,7 +755,7 @@ export class QueryManager {
         // we deprecated and removed LocalState.
         if (this.getDocumentInfo(normalized.query).hasClientExports) {
             if (__DEV__) {
-                invariant(this.localState, 91, getOperationName(normalized.query, "(anonymous)"));
+                invariant(this.localState, 90, getOperationName(normalized.query, "(anonymous)"));
             }
             observable = from(this.localState.getExportedVariables({
                 client: this.client,
@@ -1104,7 +924,7 @@ export class QueryManager {
                 !isFullyUnmaskedOperation(document) &&
                 !this.noCacheWarningsByCause.has(cause)) {
                 this.noCacheWarningsByCause.add(cause);
-                __DEV__ && invariant.warn(92, getOperationName(document, `Unnamed ${operationType ?? "operation"}`));
+                __DEV__ && invariant.warn(91, getOperationName(document, `Unnamed ${operationType ?? "operation"}`));
             }
         }
         return (this.dataMasking ?
@@ -1117,12 +937,13 @@ export class QueryManager {
             maskFragment(data, fragment, this.cache, fragmentName)
             : data;
     }
-    fetchQueryByPolicy(queryInfo, { query, variables, fetchPolicy, errorPolicy, returnPartialData, context, }, cacheWriteBehavior, onCacheHit) {
-        queryInfo.init({
-            document: query,
+    fetchQueryByPolicy({ query, variables, fetchPolicy, errorPolicy, returnPartialData, context, }, { cacheWriteBehavior, onCacheHit, queryInfo, observableQuery, }) {
+        const readCache = () => this.cache.diff({
+            query,
             variables,
+            returnPartialData: true,
+            optimistic: true,
         });
-        const readCache = () => this.cache.diff(queryInfo.getDiffOptions());
         const resultsFromCache = (diff, networkStatus) => {
             const data = diff.result;
             if (__DEV__ && !returnPartialData && data !== null) {
@@ -1161,7 +982,7 @@ export class QueryManager {
             (diff.complete || returnPartialData) &&
                 this.getDocumentInfo(query).hasForcedResolvers) {
                 if (__DEV__) {
-                    invariant(this.localState, 93, getOperationName(query, "(anonymous)"));
+                    invariant(this.localState, 92, getOperationName(query, "(anonymous)"));
                 }
                 onCacheHit();
                 return from(this.localState.execute({
@@ -1189,12 +1010,16 @@ export class QueryManager {
             }
             return fromData(data || undefined);
         };
-        const resultsFromLink = () => this.getResultsFromLink(queryInfo, cacheWriteBehavior, {
+        const resultsFromLink = () => this.getResultsFromLink({
             query,
             variables,
             context,
             fetchPolicy,
             errorPolicy,
+        }, {
+            cacheWriteBehavior,
+            queryInfo,
+            observableQuery,
         }).pipe(validateDidEmitValue(), materialize(), map((result) => ({
             ...result,
             source: "network",
@@ -1248,7 +1073,7 @@ function validateDidEmitValue() {
             didEmitValue = true;
         },
         complete() {
-            invariant(didEmitValue, 94);
+            invariant(didEmitValue, 93);
         },
     });
 }
@@ -1267,7 +1092,6 @@ function isFullyUnmaskedOperation(document) {
     return isUnmasked;
 }
 function addNonReactiveToNamedFragments(document) {
-    checkDocument(document);
     return visit(document, {
         FragmentSpread: (node) => {
             // Do not add `@nonreactive` if the fragment is marked with `@unmask`