@apollo/client 3.13.9-rc.0 → 3.13.9

package/core/QueryInfo.js

@@ -1,11 +1,12 @@
-import { __DEV__ } from "@apollo/client/utilities/environment";
+import { __assign } from "tslib";
 import { equal } from "@wry/equality";
-import { getOperationName, graphQLResultHasError, } from "@apollo/client/utilities/internal";
-import { invariant } from "@apollo/client/utilities/invariant";
-const IGNORE = {};
-const destructiveMethodCounts = new WeakMap();
+import { DeepMerger } from "../utilities/index.js";
+import { mergeIncrementalData } from "../utilities/index.js";
+import { isNonEmptyArray, graphQLResultHasError, canUseWeakMap, } from "../utilities/index.js";
+import { NetworkStatus } from "./networkStatus.js";
+var destructiveMethodCounts = new (canUseWeakMap ? WeakMap : Map)();
 function wrapDestructiveCacheMethod(cache, methodName) {
-    const original = cache[methodName];
+    var original = cache[methodName];
     if (typeof original === "function") {
         // @ts-expect-error this is just too generic to be typed correctly
         cache[methodName] = function () {
@@ -20,29 +21,29 @@ function wrapDestructiveCacheMethod(cache, methodName) {
         };
     }
 }
-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 {
-    // TODO remove soon - this should be able to be handled by cancelling old operations before starting new ones
-    lastRequestId = 1;
-    cache;
-    queryManager;
-    id;
-    observableQuery;
-    incremental;
-    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;
+// 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.
+var QueryInfo = /** @class */ (function () {
+    function QueryInfo(queryManager, queryId) {
+        if (queryId === void 0) { queryId = queryManager.generateQueryId(); }
+        this.queryId = queryId;
+        this.document = null;
+        this.lastRequestId = 1;
+        this.stopped = false;
+        this.observableQuery = null;
+        var cache = (this.cache = queryManager.cache);
         // Track how often cache.evict is called, since we want eviction to
-        // override the feud-stopping logic in the markQueryResult method, by
+        // override the feud-stopping logic in the markResult 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.
@@ -53,25 +54,133 @@ export class QueryInfo {
             wrapDestructiveCacheMethod(cache, "reset");
         }
     }
-    /**
-    * @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;
-    }
-    set lastWrite(value) {
-        (this.observableQuery || this)._lastWrite = value;
-    }
-    resetLastWrite() {
+    QueryInfo.prototype.init = function (query) {
+        var networkStatus = query.networkStatus || NetworkStatus.loading;
+        if (this.variables &&
+            this.networkStatus !== NetworkStatus.loading &&
+            !equal(this.variables, query.variables)) {
+            networkStatus = NetworkStatus.setVariables;
+        }
+        if (!equal(query.variables, this.variables)) {
+            this.lastDiff = void 0;
+            // Ensure we don't continue to receive cache updates for old variables
+            this.cancel();
+        }
+        Object.assign(this, {
+            document: query.document,
+            variables: query.variables,
+            networkError: null,
+            graphQLErrors: this.graphQLErrors || [],
+            networkStatus: networkStatus,
+        });
+        if (query.observableQuery) {
+            this.setObservableQuery(query.observableQuery);
+        }
+        if (query.lastRequestId) {
+            this.lastRequestId = query.lastRequestId;
+        }
+        return this;
+    };
+    QueryInfo.prototype.resetDiff = function () {
+        this.lastDiff = void 0;
+    };
+    QueryInfo.prototype.getDiff = function () {
+        var options = this.getDiffOptions();
+        if (this.lastDiff && equal(options, this.lastDiff.options)) {
+            return this.lastDiff.diff;
+        }
+        this.updateWatch(this.variables);
+        var oq = this.observableQuery;
+        if (oq && oq.options.fetchPolicy === "no-cache") {
+            return { complete: false };
+        }
+        var diff = this.cache.diff(options);
+        this.updateLastDiff(diff, options);
+        return diff;
+    };
+    QueryInfo.prototype.updateLastDiff = function (diff, options) {
+        this.lastDiff =
+            diff ?
+                {
+                    diff: diff,
+                    options: options || this.getDiffOptions(),
+                }
+                : void 0;
+    };
+    QueryInfo.prototype.getDiffOptions = function (variables) {
+        var _a;
+        if (variables === void 0) { variables = this.variables; }
+        return {
+            query: this.document,
+            variables: variables,
+            returnPartialData: true,
+            optimistic: true,
+            canonizeResults: (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.options.canonizeResults,
+        };
+    };
+    QueryInfo.prototype.setDiff = function (diff) {
+        var _a, _b;
+        var 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 && ((_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.getLastError())) {
+            return;
+        }
+        this.updateLastDiff(diff);
+        if (!equal(oldDiff && oldDiff.result, diff && diff.result)) {
+            (_b = this.observableQuery) === null || _b === void 0 ? void 0 : _b["scheduleNotify"]();
+        }
+    };
+    QueryInfo.prototype.setObservableQuery = function (oq) {
+        if (oq === this.observableQuery)
+            return;
+        this.observableQuery = oq;
+        if (oq) {
+            oq["queryInfo"] = this;
+        }
+    };
+    QueryInfo.prototype.stop = function () {
+        var _a;
+        if (!this.stopped) {
+            this.stopped = true;
+            // Cancel the pending notify timeout
+            (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a["resetNotifications"]();
+            this.cancel();
+            var oq = this.observableQuery;
+            if (oq)
+                oq.stopPolling();
+        }
+    };
+    QueryInfo.prototype.cancel = function () {
+        var _a;
+        (_a = this.cancelWatch) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.cancelWatch = void 0;
+    };
+    QueryInfo.prototype.updateWatch = function (variables) {
+        var _this = this;
+        if (variables === void 0) { variables = this.variables; }
+        var oq = this.observableQuery;
+        if (oq && oq.options.fetchPolicy === "no-cache") {
+            return;
+        }
+        var watchOptions = __assign(__assign({}, this.getDiffOptions(variables)), { watcher: this, callback: function (diff) { return _this.setDiff(diff); } });
+        if (!this.lastWatch || !equal(watchOptions, this.lastWatch)) {
+            this.cancel();
+            this.cancelWatch = this.cache.watch((this.lastWatch = watchOptions));
+        }
+    };
+    QueryInfo.prototype.resetLastWrite = function () {
         this.lastWrite = void 0;
-    }
-    shouldWrite(result, variables) {
-        const { lastWrite } = this;
+    };
+    QueryInfo.prototype.shouldWrite = function (result, variables) {
+        var lastWrite = this.lastWrite;
         return !(lastWrite &&
             // If cache.evict has been called since the last time we wrote this
             // data into the cache, there's a chance writing this result into
@@ -79,63 +188,50 @@ export class QueryInfo {
             lastWrite.dmCount === destructiveMethodCounts.get(this.cache) &&
             equal(variables, lastWrite.variables) &&
             equal(result.data, lastWrite.result.data));
-    }
-    get hasNext() {
-        return this.incremental ? this.incremental.hasNext : false;
-    }
-    maybeHandleIncrementalResult(cacheData, incoming, query) {
-        const { incrementalHandler } = this.queryManager;
-        if (incrementalHandler.isIncrementalResult(incoming)) {
-            this.incremental ||= incrementalHandler.startRequest({
-                query,
-            });
-            return this.incremental.handle(cacheData, incoming);
-        }
-        return incoming;
-    }
-    markQueryResult(incoming, { document: query, variables, errorPolicy, cacheWriteBehavior, }) {
-        const diffOptions = {
-            query,
-            variables,
-            returnPartialData: true,
-            optimistic: true,
-        };
+    };
+    QueryInfo.prototype.markResult = function (result, document, options, cacheWriteBehavior) {
+        var _this = this;
+        var _a;
+        var merger = new DeepMerger();
+        var graphQLErrors = isNonEmptyArray(result.errors) ? result.errors.slice(0) : [];
         // 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.observableQuery?.["resetNotifications"]();
-        const skipCache = cacheWriteBehavior === 0 /* CacheWriteBehavior.FORBID */;
-        const lastDiff = skipCache ? undefined : this.cache.diff(diffOptions);
-        let result = this.maybeHandleIncrementalResult(lastDiff?.result, incoming, query);
-        if (skipCache) {
-            return result;
+        (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a["resetNotifications"]();
+        if ("incremental" in result && isNonEmptyArray(result.incremental)) {
+            var 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.
         }
-        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.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)) {
+        else if ("hasNext" in result && result.hasNext) {
+            var diff = this.getDiff();
+            result.data = merger.merge(diff.result, result.data);
+        }
+        this.graphQLErrors = graphQLErrors;
+        if (options.fetchPolicy === "no-cache") {
+            this.updateLastDiff({ result: result.data, complete: true }, this.getDiffOptions(options.variables));
+        }
+        else if (cacheWriteBehavior !== 0 /* CacheWriteBehavior.FORBID */) {
+            if (shouldWriteResult(result, options.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(function (cache) {
+                    if (_this.shouldWrite(result, options.variables)) {
                         cache.writeQuery({
-                            query,
+                            query: document,
                             data: result.data,
-                            variables,
+                            variables: options.variables,
                             overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,
                         });
-                        this.lastWrite = {
-                            result,
-                            variables,
-                            dmCount: destructiveMethodCounts.get(this.cache),
+                        _this.lastWrite = {
+                            result: result,
+                            variables: options.variables,
+                            dmCount: destructiveMethodCounts.get(_this.cache),
                         };
                     }
                     else {
@@ -171,220 +267,71 @@ export class QueryInfo {
                         // 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) {
+                        if (_this.lastDiff && _this.lastDiff.diff.complete) {
                             // Reuse data from the last good (complete) diff that we
                             // received, when possible.
-                            result = { ...result, data: lastDiff.result };
+                            result.data = _this.lastDiff.diff.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);
+                    var diffOptions = _this.getDiffOptions(options.variables);
+                    var 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 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 = { ...result, data: diff.result };
-                    }
-                },
-            });
-        }
-        else {
-            this.lastWrite = void 0;
-        }
-        return result;
-    }
-    markMutationResult(incoming, mutation, cache = this.cache) {
-        const cacheWrites = [];
-        const skipCache = mutation.cacheWriteBehavior === 0 /* CacheWriteBehavior.FORBID */;
-        let result = this.maybeHandleIncrementalResult(skipCache ? undefined : (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,
-        }).result), incoming, mutation.document);
-        if (mutation.errorPolicy === "ignore") {
-            result = { ...result, errors: [] };
-        }
-        if (graphQLResultHasError(result) && mutation.errorPolicy === "none") {
-            return Promise.resolve(result);
-        }
-        const getResultWithDataState = () => ({
-            ...result,
-            dataState: this.hasNext ? "streaming" : "complete",
-        });
-        if (!skipCache && shouldWriteResult(result, mutation.errorPolicy)) {
-            cacheWrites.push({
-                result: result.data,
-                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;
-                    }
-                    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: getResultWithDataState(),
-                            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,
-                            });
-                        }
+                        result.data = diff.result;
                     }
                 });
             }
-        }
-        let refetchQueries = mutation.refetchQueries;
-        if (typeof refetchQueries === "function") {
-            refetchQueries = refetchQueries(getResultWithDataState());
-        }
-        if (cacheWrites.length > 0 ||
-            (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 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.
-                    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 we've received the whole response, call the update function.
-                        if (!this.hasNext) {
-                            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 && !this.hasNext) {
-                        cache.modify({
-                            id: "ROOT_MUTATION",
-                            fields(value, { fieldName, DELETE }) {
-                                return fieldName === "__typename" ? value : DELETE;
-                            },
-                        });
-                    }
-                },
-                include: 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;
+    };
+    QueryInfo.prototype.markReady = function () {
+        this.networkError = null;
+        return (this.networkStatus = NetworkStatus.ready);
+    };
+    QueryInfo.prototype.markError = function (error) {
+        var _a;
+        this.networkStatus = NetworkStatus.error;
+        this.lastWrite = void 0;
+        (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a["resetNotifications"]();
+        if (error.graphQLErrors) {
+            this.graphQLErrors = error.graphQLErrors;
         }
-        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();
+        if (error.networkError) {
+            this.networkError = error.networkError;
         }
-    }
-}
-function shouldWriteResult(result, errorPolicy = "none") {
-    const ignoreErrors = errorPolicy === "ignore" || errorPolicy === "all";
-    let writeWithErrors = !graphQLResultHasError(result);
+        return error;
+    };
+    return QueryInfo;
+}());
+export { QueryInfo };
+export function shouldWriteResult(result, errorPolicy) {
+    if (errorPolicy === void 0) { errorPolicy = "none"; }
+    var ignoreErrors = errorPolicy === "ignore" || errorPolicy === "all";
+    var writeWithErrors = !graphQLResultHasError(result);
     if (!writeWithErrors && ignoreErrors && result.data) {
         writeWithErrors = true;
     }
     return writeWithErrors;
 }
-//# sourceMappingURL=QueryInfo.js.map
+//# sourceMappingURL=QueryInfo.js.map