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

package/core/QueryInfo.js

@@ -1,9 +1,8 @@
+import { __DEV__ } from "@apollo/client/utilities/environment";
 import { equal } from "@wry/equality";
-import { graphQLResultHasError, isNonEmptyArray, } from "@apollo/client/utilities";
-import { mergeIncrementalData } from "@apollo/client/utilities";
-import { DeepMerger } from "@apollo/client/utilities";
-import { isNetworkRequestInFlight } from "./networkStatus.js";
-import { reobserveCacheFirst } from "./ObservableQuery.js";
+import { DeepMerger, getOperationName, graphQLResultHasError, isExecutionPatchIncrementalResult, isExecutionPatchResult, isNonEmptyArray, mergeIncrementalData, } from "@apollo/client/utilities/internal";
+import { invariant } from "@apollo/client/utilities/invariant";
+const IGNORE = {};
 const destructiveMethodCounts = new WeakMap();
 function wrapDestructiveCacheMethod(cache, methodName) {
     const original = cache[methodName];
@@ -21,37 +20,28 @@ function wrapDestructiveCacheMethod(cache, methodName) {
         };
     }
 }
-function cancelNotifyTimeout(info) {
-    if (info["notifyTimeout"]) {
-        clearTimeout(info["notifyTimeout"]);
-        info["notifyTimeout"] = void 0;
-    }
-}
-// A QueryInfo object represents a single query managed by the
-// QueryManager, which tracks all QueryInfo objects by queryId in its
-// this.queries Map. QueryInfo objects store the latest results and errors
-// for the given query, and are responsible for reporting those results to
-// the corresponding ObservableQuery, via the QueryInfo.notify method.
-// Results are reported asynchronously whenever setDiff marks the
-// QueryInfo object as dirty, though a call to the QueryManager's
-// broadcastQueries method may trigger the notification before it happens
-// automatically. This class used to be a simple interface type without
-// any field privacy or meaningful methods, which is why it still has so
-// many public fields. The effort to lock down and simplify the QueryInfo
-// interface is ongoing, and further improvements are welcome.
+const queryInfoIds = new WeakMap();
+// A QueryInfo object represents a single network request, either initiated
+// from the QueryManager or from an ObservableQuery.
+// It will only ever be used for a single network call.
+// It is responsible for reporting results to the cache, merging and in a no-cache
+// scenario accumulating the response.
 export class QueryInfo {
-    queryId;
-    listeners = new Set();
-    document = null;
+    // TODO remove soon - this should be able to be handled by cancelling old operations before starting new ones
     lastRequestId = 1;
-    variables;
-    stopped = false;
     cache;
-    constructor(queryManager, queryId = queryManager.generateQueryId()) {
-        this.queryId = queryId;
+    queryManager;
+    id;
+    observableQuery;
+    constructor(queryManager, observableQuery) {
         const cache = (this.cache = queryManager.cache);
+        const id = (queryInfoIds.get(queryManager) || 0) + 1;
+        queryInfoIds.set(queryManager, id);
+        this.id = id + "";
+        this.observableQuery = observableQuery;
+        this.queryManager = queryManager;
         // Track how often cache.evict is called, since we want eviction to
-        // override the feud-stopping logic in the markResult method, by
+        // override the feud-stopping logic in the markQueryResult method, by
         // causing shouldWrite to return true. Wrapping the cache.evict method
         // is a bit of a hack, but it saves us from having to make eviction
         // counting an official part of the ApolloCache API.
@@ -62,181 +52,20 @@ export class QueryInfo {
             wrapDestructiveCacheMethod(cache, "reset");
         }
     }
-    init(query) {
-        if (!equal(query.variables, this.variables)) {
-            this.lastDiff = void 0;
-        }
-        Object.assign(this, {
-            document: query.document,
-            variables: query.variables,
-            networkError: null,
-        });
-        if (query.observableQuery) {
-            this.setObservableQuery(query.observableQuery);
-        }
-        if (query.lastRequestId) {
-            this.lastRequestId = query.lastRequestId;
-        }
-        return this;
-    }
-    dirty = false;
-    notifyTimeout;
-    reset() {
-        cancelNotifyTimeout(this);
-        this.dirty = false;
-    }
-    resetDiff() {
-        this.lastDiff = void 0;
-    }
-    getDiff() {
-        const options = this.getDiffOptions();
-        if (this.lastDiff && equal(options, this.lastDiff.options)) {
-            return this.lastDiff.diff;
-        }
-        this.updateWatch(this.variables);
-        const oq = this.observableQuery;
-        if (oq && oq.options.fetchPolicy === "no-cache") {
-            return { result: null, complete: false };
-        }
-        const diff = this.cache.diff(options);
-        this.updateLastDiff(diff, options);
-        return diff;
-    }
-    lastDiff;
-    updateLastDiff(diff, options) {
-        this.lastDiff =
-            diff ?
-                {
-                    diff,
-                    options: options || this.getDiffOptions(),
-                }
-                : void 0;
-    }
-    getDiffOptions(variables = this.variables) {
-        return {
-            query: this.document,
-            variables,
-            returnPartialData: true,
-            optimistic: true,
-        };
+    /**
+    * @internal
+    * For feud-preventing behaviour, `lastWrite` should be shared by all `QueryInfo` instances of an `ObservableQuery`.
+    * In the case of a standalone `QueryInfo`, we will keep a local version.
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    _lastWrite;
+    get lastWrite() {
+        return (this.observableQuery || this)._lastWrite;
     }
-    setDiff(diff) {
-        const oldDiff = this.lastDiff && this.lastDiff.diff;
-        // If we are trying to deliver an incomplete cache result, we avoid
-        // reporting it if the query has errored, otherwise we let the broadcast try
-        // and repair the partial result by refetching the query. This check avoids
-        // a situation where a query that errors and another succeeds with
-        // overlapping data does not report the partial data result to the errored
-        // query.
-        //
-        // See https://github.com/apollographql/apollo-client/issues/11400 for more
-        // information on this issue.
-        if (diff && !diff.complete && this.observableQuery?.getLastError()) {
-            return;
-        }
-        this.updateLastDiff(diff);
-        if (!this.dirty && !equal(oldDiff && oldDiff.result, diff && diff.result)) {
-            this.dirty = true;
-            if (!this.notifyTimeout) {
-                this.notifyTimeout = setTimeout(() => this.notify(), 0);
-            }
-        }
+    set lastWrite(value) {
+        (this.observableQuery || this)._lastWrite = value;
     }
-    observableQuery = null;
-    oqListener;
-    setObservableQuery(oq) {
-        if (oq === this.observableQuery)
-            return;
-        if (this.oqListener) {
-            this.listeners.delete(this.oqListener);
-        }
-        this.observableQuery = oq;
-        if (oq) {
-            oq["queryInfo"] = this;
-            this.listeners.add((this.oqListener = () => {
-                const diff = this.getDiff();
-                if (diff.fromOptimisticTransaction) {
-                    // If this diff came from an optimistic transaction, deliver the
-                    // current cache data to the ObservableQuery, but don't perform a
-                    // reobservation, since oq.reobserveCacheFirst might make a network
-                    // request, and we never want to trigger network requests in the
-                    // middle of optimistic updates.
-                    oq["observe"]();
-                }
-                else {
-                    // Otherwise, make the ObservableQuery "reobserve" the latest data
-                    // using a temporary fetch policy of "cache-first", so complete cache
-                    // results have a chance to be delivered without triggering additional
-                    // network requests, even when options.fetchPolicy is "network-only"
-                    // or "cache-and-network". All other fetch policies are preserved by
-                    // this method, and are handled by calling oq.reobserve(). If this
-                    // reobservation is spurious, isDifferentFromLastResult still has a
-                    // chance to catch it before delivery to ObservableQuery subscribers.
-                    reobserveCacheFirst(oq);
-                }
-            }));
-        }
-        else {
-            delete this.oqListener;
-        }
-    }
-    notify() {
-        cancelNotifyTimeout(this);
-        if (this.shouldNotify()) {
-            this.listeners.forEach((listener) => listener(this));
-        }
-        this.dirty = false;
-    }
-    shouldNotify() {
-        if (!this.dirty || !this.listeners.size) {
-            return false;
-        }
-        if (this.observableQuery &&
-            isNetworkRequestInFlight(this.observableQuery["networkStatus"])) {
-            const { fetchPolicy } = this.observableQuery.options;
-            if (fetchPolicy !== "cache-only" && fetchPolicy !== "cache-and-network") {
-                return false;
-            }
-        }
-        return true;
-    }
-    stop() {
-        if (!this.stopped) {
-            this.stopped = true;
-            // Cancel the pending notify timeout
-            this.reset();
-            this.cancel();
-            // Revert back to the no-op version of cancel inherited from
-            // QueryInfo.prototype.
-            this.cancel = QueryInfo.prototype.cancel;
-            const oq = this.observableQuery;
-            if (oq)
-                oq.stopPolling();
-        }
-    }
-    // This method is a no-op by default, until/unless overridden by the
-    // updateWatch method.
-    cancel() { }
-    lastWatch;
-    updateWatch(variables = this.variables) {
-        const oq = this.observableQuery;
-        if (oq && oq.options.fetchPolicy === "no-cache") {
-            return;
-        }
-        const watchOptions = {
-            // Although this.getDiffOptions returns Cache.DiffOptions instead of
-            // Cache.WatchOptions, all the overlapping options should be the same, so
-            // we can reuse getDiffOptions here, for consistency.
-            ...this.getDiffOptions(variables),
-            watcher: this,
-            callback: (diff) => this.setDiff(diff),
-        };
-        if (!this.lastWatch || !equal(watchOptions, this.lastWatch)) {
-            this.cancel();
-            this.cancel = this.cache.watch((this.lastWatch = watchOptions));
-        }
-    }
-    lastWrite;
     resetLastWrite() {
         this.lastWrite = void 0;
     }
@@ -250,120 +79,329 @@ export class QueryInfo {
             equal(variables, lastWrite.variables) &&
             equal(result.data, lastWrite.result.data));
     }
-    markResult(result, document, options, cacheWriteBehavior) {
-        const merger = new DeepMerger();
+    lastDiff;
+    markQueryResult(result, { document: query, variables, errorPolicy, cacheWriteBehavior, }) {
+        const diffOptions = {
+            query,
+            variables,
+            returnPartialData: true,
+            optimistic: true,
+        };
         // Cancel the pending notify timeout (if it exists) to prevent extraneous network
         // requests. To allow future notify timeouts, diff and dirty are reset as well.
-        this.reset();
-        if ("incremental" in result && isNonEmptyArray(result.incremental)) {
-            const mergedData = mergeIncrementalData(this.getDiff().result, result);
-            result.data = mergedData;
-            // Detect the first chunk of a deferred query and merge it with existing
-            // cache data. This ensures a `cache-first` fetch policy that returns
-            // partial cache data or a `cache-and-network` fetch policy that already
-            // has full data in the cache does not complain when trying to merge the
-            // initial deferred server data with existing cache data.
-        }
-        else if ("hasNext" in result && result.hasNext) {
-            const diff = this.getDiff();
-            result.data = merger.merge(diff.result, result.data);
-        }
-        if (options.fetchPolicy === "no-cache") {
-            this.updateLastDiff({ result: result.data, complete: true }, this.getDiffOptions(options.variables));
+        this.observableQuery?.["resetNotifications"]();
+        if (cacheWriteBehavior === 0 /* CacheWriteBehavior.FORBID */) {
+            const lastDiff = this.lastDiff && equal(diffOptions, this.lastDiff.options) ?
+                this.lastDiff.diff
+                : { result: null, complete: false };
+            handleIncrementalResult(result, lastDiff);
+            this.lastDiff = {
+                diff: { result: result.data, complete: true },
+                options: diffOptions,
+            };
         }
-        else if (cacheWriteBehavior !== 0 /* CacheWriteBehavior.FORBID */) {
-            if (shouldWriteResult(result, options.errorPolicy)) {
+        else {
+            const lastDiff = this.cache.diff(diffOptions);
+            handleIncrementalResult(result, lastDiff);
+            if (shouldWriteResult(result, errorPolicy)) {
                 // Using a transaction here so we have a chance to read the result
                 // back from the cache before the watch callback fires as a result
                 // of writeQuery, so we can store the new diff quietly and ignore
                 // it when we receive it redundantly from the watch callback.
-                this.cache.performTransaction((cache) => {
-                    if (this.shouldWrite(result, options.variables)) {
-                        cache.writeQuery({
-                            query: document,
-                            data: result.data,
-                            variables: options.variables,
-                            overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,
-                        });
-                        this.lastWrite = {
-                            result,
-                            variables: options.variables,
-                            dmCount: destructiveMethodCounts.get(this.cache),
-                        };
+                this.cache.batch({
+                    onWatchUpdated: (
+                    // all additional options on ObservableQuery.CacheWatchOptions are
+                    // optional so we can use the type here
+                    watch, diff) => {
+                        if (watch.watcher === this.observableQuery) {
+                            // see comment on `lastOwnDiff` for explanation
+                            watch.lastOwnDiff = diff;
+                        }
+                    },
+                    update: (cache) => {
+                        if (this.shouldWrite(result, variables)) {
+                            cache.writeQuery({
+                                query,
+                                data: result.data,
+                                variables,
+                                overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,
+                            });
+                            this.lastWrite = {
+                                result,
+                                variables,
+                                dmCount: destructiveMethodCounts.get(this.cache),
+                            };
+                        }
+                        else {
+                            // If result is the same as the last result we received from
+                            // the network (and the variables match too), avoid writing
+                            // result into the cache again. The wisdom of skipping this
+                            // cache write is far from obvious, since any cache write
+                            // could be the one that puts the cache back into a desired
+                            // state, fixing corruption or missing data. However, if we
+                            // always write every network result into the cache, we enable
+                            // feuds between queries competing to update the same data in
+                            // incompatible ways, which can lead to an endless cycle of
+                            // cache broadcasts and useless network requests. As with any
+                            // feud, eventually one side must step back from the brink,
+                            // letting the other side(s) have the last word(s). There may
+                            // be other points where we could break this cycle, such as
+                            // silencing the broadcast for cache.writeQuery (not a good
+                            // idea, since it just delays the feud a bit) or somehow
+                            // avoiding the network request that just happened (also bad,
+                            // because the server could return useful new data). All
+                            // options considered, skipping this cache write seems to be
+                            // the least damaging place to break the cycle, because it
+                            // reflects the intuition that we recently wrote this exact
+                            // result into the cache, so the cache *should* already/still
+                            // contain this data. If some other query has clobbered that
+                            // data in the meantime, that's too bad, but there will be no
+                            // winners if every query blindly reverts to its own version
+                            // of the data. This approach also gives the network a chance
+                            // to return new data, which will be written into the cache as
+                            // usual, notifying only those queries that are directly
+                            // affected by the cache updates, as usual. In the future, an
+                            // even more sophisticated cache could perhaps prevent or
+                            // mitigate the clobbering somehow, but that would make this
+                            // particular cache write even less important, and thus
+                            // skipping it would be even safer than it is today.
+                            if (lastDiff && lastDiff.complete) {
+                                // Reuse data from the last good (complete) diff that we
+                                // received, when possible.
+                                result.data = lastDiff.result;
+                                return;
+                            }
+                            // If the previous this.diff was incomplete, fall through to
+                            // re-reading the latest data with cache.diff, below.
+                        }
+                        const diff = cache.diff(diffOptions);
+                        // If we're allowed to write to the cache, and we can read a
+                        // complete result from the cache, update result.data to be the
+                        // result from the cache, rather than the raw network result.
+                        // Set without setDiff to avoid triggering a notify call, since
+                        // we have other ways of notifying for this result.
+                        if (diff.complete) {
+                            result.data = diff.result;
+                        }
+                    },
+                });
+            }
+            else {
+                this.lastWrite = void 0;
+            }
+        }
+    }
+    markMutationResult(result, mutation, cache = this.cache) {
+        const cacheWrites = [];
+        const skipCache = mutation.cacheWriteBehavior === 0 /* CacheWriteBehavior.FORBID */;
+        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.queryManager.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.queryManager
+                    .getObservableQueries("all")
+                    .forEach((observableQuery) => {
+                    const queryName = observableQuery && observableQuery.queryName;
+                    if (!queryName ||
+                        !Object.hasOwnProperty.call(updateQueries, queryName)) {
+                        return;
                     }
-                    else {
-                        // If result is the same as the last result we received from
-                        // the network (and the variables match too), avoid writing
-                        // result into the cache again. The wisdom of skipping this
-                        // cache write is far from obvious, since any cache write
-                        // could be the one that puts the cache back into a desired
-                        // state, fixing corruption or missing data. However, if we
-                        // always write every network result into the cache, we enable
-                        // feuds between queries competing to update the same data in
-                        // incompatible ways, which can lead to an endless cycle of
-                        // cache broadcasts and useless network requests. As with any
-                        // feud, eventually one side must step back from the brink,
-                        // letting the other side(s) have the last word(s). There may
-                        // be other points where we could break this cycle, such as
-                        // silencing the broadcast for cache.writeQuery (not a good
-                        // idea, since it just delays the feud a bit) or somehow
-                        // avoiding the network request that just happened (also bad,
-                        // because the server could return useful new data). All
-                        // options considered, skipping this cache write seems to be
-                        // the least damaging place to break the cycle, because it
-                        // reflects the intuition that we recently wrote this exact
-                        // result into the cache, so the cache *should* already/still
-                        // contain this data. If some other query has clobbered that
-                        // data in the meantime, that's too bad, but there will be no
-                        // winners if every query blindly reverts to its own version
-                        // of the data. This approach also gives the network a chance
-                        // to return new data, which will be written into the cache as
-                        // usual, notifying only those queries that are directly
-                        // affected by the cache updates, as usual. In the future, an
-                        // even more sophisticated cache could perhaps prevent or
-                        // mitigate the clobbering somehow, but that would make this
-                        // particular cache write even less important, and thus
-                        // skipping it would be even safer than it is today.
-                        if (this.lastDiff && this.lastDiff.diff.complete) {
-                            // Reuse data from the last good (complete) diff that we
-                            // received, when possible.
-                            result.data = this.lastDiff.diff.result;
-                            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 the previous this.diff was incomplete, fall through to
-                        // re-reading the latest data with cache.diff, below.
                     }
-                    const diffOptions = this.getDiffOptions(options.variables);
-                    const diff = cache.diff(diffOptions);
-                    // In case the QueryManager stops this QueryInfo before its
-                    // results are delivered, it's important to avoid restarting the
-                    // cache watch when markResult is called. We also avoid updating
-                    // the watch if we are writing a result that doesn't match the current
-                    // variables to avoid race conditions from broadcasting the wrong
-                    // result.
-                    if (!this.stopped && equal(this.variables, options.variables)) {
-                        // Any time we're about to update this.diff, we need to make
-                        // sure we've started watching the cache.
-                        this.updateWatch(options.variables);
+                });
+            }
+        }
+        if (cacheWrites.length > 0 ||
+            (mutation.refetchQueries || "").length > 0 ||
+            mutation.update ||
+            mutation.onQueryUpdated ||
+            mutation.removeOptimistic) {
+            const results = [];
+            this.queryManager
+                .refetchQueries({
+                updateCache: (cache) => {
+                    if (!skipCache) {
+                        cacheWrites.forEach((write) => cache.write(write));
                     }
-                    // If we're allowed to write to the cache, and we can read a
-                    // complete result from the cache, update result.data to be the
-                    // result from the cache, rather than the raw network result.
-                    // Set without setDiff to avoid triggering a notify call, since
-                    // we have other ways of notifying for this result.
-                    this.updateLastDiff(diff, diffOptions);
-                    if (diff.complete) {
-                        result.data = diff.result;
+                    // 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.queryManager.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);
             }
-            else {
-                this.lastWrite = void 0;
+        }
+        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({ data }, mutation, cache);
+            }
+            catch (error) {
+                __DEV__ && invariant.error(error);
             }
+        }, this.id);
+        return true;
+    }
+    markSubscriptionResult(result, { document, variables, errorPolicy, cacheWriteBehavior, }) {
+        if (cacheWriteBehavior !== 0 /* CacheWriteBehavior.FORBID */) {
+            if (shouldWriteResult(result, errorPolicy)) {
+                this.cache.write({
+                    query: document,
+                    result: result.data,
+                    dataId: "ROOT_SUBSCRIPTION",
+                    variables: variables,
+                });
+            }
+            this.queryManager.broadcastQueries();
         }
     }
 }
-export function shouldWriteResult(result, errorPolicy = "none") {
+function handleIncrementalResult(result, lastDiff) {
+    if ("incremental" in result && isNonEmptyArray(result.incremental)) {
+        const mergedData = mergeIncrementalData(lastDiff.result, result);
+        result.data = mergedData;
+        // Detect the first chunk of a deferred query and merge it with existing
+        // cache data. This ensures a `cache-first` fetch policy that returns
+        // partial cache data or a `cache-and-network` fetch policy that already
+        // has full data in the cache does not complain when trying to merge the
+        // initial deferred server data with existing cache data.
+    }
+    else if ("hasNext" in result && result.hasNext) {
+        const merger = new DeepMerger();
+        result.data = merger.merge(lastDiff.result, result.data);
+    }
+}
+function shouldWriteResult(result, errorPolicy = "none") {
     const ignoreErrors = errorPolicy === "ignore" || errorPolicy === "all";
     let writeWithErrors = !graphQLResultHasError(result);
     if (!writeWithErrors && ignoreErrors && result.data) {