@apollo/client 4.3.0-alpha.2 → 4.3.0-alpha.4

package/__cjs/core/QueryInfo.cjs

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryInfo = void 0;
 const equality_1 = require("@wry/equality");
+const trie_1 = require("@wry/trie");
 const internal_1 = require("@apollo/client/utilities/internal");
 const invariant_1 = require("@apollo/client/utilities/invariant");
+const networkStatus_js_1 = require("./networkStatus.cjs");
 const IGNORE = {};
 const destructiveMethodCounts = new WeakMap();
 function wrapDestructiveCacheMethod(cache, methodName) {
@@ -29,8 +31,6 @@ const queryInfoIds = new WeakMap();
 // It is responsible for reporting results to the cache, merging and in a no-cache
 // scenario accumulating the response.
 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;
@@ -100,20 +100,49 @@ class QueryInfo {
         }
         return incoming;
     }
-    markQueryResult(incoming, { document: query, variables, errorPolicy, cacheWriteBehavior, }) {
+    markQueryResult(incoming, { document: query, variables, errorPolicy, cacheWriteBehavior, returnPartialData, fetchPolicy, networkStatus, }) {
         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.observableQuery?.["resetNotifications"]();
         const skipCache = cacheWriteBehavior === 0 /* CacheWriteBehavior.FORBID */;
-        const lastDiff = skipCache ? undefined : this.cache.diff(diffOptions);
-        let result = this.maybeHandleIncrementalResult(lastDiff?.result, incoming, query);
+        const lastDiff = skipCache ? undefined : (this.getDiff({
+            ...diffOptions,
+            // Always request partial data to ensure the network incremental
+            // result is merged with all existing data (especially true to
+            // maintain @stream arrays with partial list items in the right order)
+            returnPartialData: true,
+        }));
+        const incrementalResult = this.maybeHandleIncrementalResult(lastDiff?.result, incoming, query);
+        let result = {
+            ...incrementalResult,
+            dataState: incrementalResult.data == null ? "empty" : "complete",
+        };
         if (skipCache) {
+            const hasPendingDefer = this.incremental?.pending?.some((pending) => this.incremental?.getPendingType?.(pending.id) === "defer");
+            if (hasPendingDefer ||
+                // The Defer20220824Handler cannot track pending/completed incremental
+                // chunks due to its data format so we naively set dataState to
+                // streaming if we are still processing chunks. The only case where
+                // streaming is incorrect and should actually be complete is when
+                // both a @defer and @stream boundary is present and the @defer chunk
+                // has completed before the `@stream` array.
+                //
+                // Assigning the naive "streaming" value avoids a much more expensive
+                // pass over `result.data` that would otherwise need to traverse the
+                // selection sets and evaluate the data object at each defer boundary
+                // to see if it fulfills the selection set. For such a narrow case where
+                // its incorrect on a format that is now outdated is not worth the
+                // fix so we are ok with reporting a `streaming` here.
+                (!this.incremental?.pending &&
+                    this.hasNext &&
+                    (0, internal_1.hasDirectives)(["defer"], query))) {
+                result.dataState = "streaming";
+            }
             return result;
         }
         if (shouldWriteResult(result, errorPolicy)) {
@@ -132,7 +161,8 @@ class QueryInfo {
                     }
                 },
                 update: (cache) => {
-                    if (this.shouldWrite(result, variables)) {
+                    const shouldWrite = this.shouldWrite(result, variables);
+                    if (shouldWrite) {
                         cache.writeQuery({
                             query,
                             data: result.data,
@@ -182,20 +212,27 @@ class QueryInfo {
                         if (lastDiff && lastDiff.complete) {
                             // Reuse data from the last good (complete) diff that we
                             // received, when possible.
-                            result = { ...result, data: lastDiff.result };
+                            result = {
+                                ...result,
+                                data: lastDiff.result,
+                                dataState: "complete",
+                            };
                             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 = { ...result, data: diff.result };
+                    const isNetworkOnly = fetchPolicy === "network-only" &&
+                        networkStatus !== networkStatus_js_1.NetworkStatus.refetch;
+                    const { dataState, result: diffResult } = this.getDiff({
+                        ...diffOptions,
+                        // Never deliver partial data for network-only requests
+                        returnPartialData: returnPartialData && !isNetworkOnly,
+                    }, this.getIncrementalInfo(result, { isNetworkOnly }));
+                    if (dataState === "complete" ||
+                        (returnPartialData && dataState === "partial" && shouldWrite) ||
+                        (this.hasNext && dataState === "streaming")) {
+                        result = { ...result, data: diffResult, dataState };
                     }
                 },
             });
@@ -205,6 +242,47 @@ class QueryInfo {
         }
         return result;
     }
+    getIncrementalInfo(result, { isNetworkOnly }) {
+        const pending = this.incremental?.pending ?? [];
+        const streamInfo = result.extensions?.[internal_1.streamInfoSymbol]?.deref();
+        const incrementalInfo = { streamInfo };
+        // We don't want to deliver stream items or complete defer boundaries
+        // for a network-only request if they haven't yet streamed from the
+        // network. We record all the still-pending paths so that cache.diff
+        // can prune complete defer/stream boundaries at those paths.
+        if (isNetworkOnly) {
+            for (const item of pending) {
+                const type = this.incremental?.getPendingType?.(item.id);
+                if (type === "defer") {
+                    incrementalInfo.deferInfo ||= new trie_1.Trie(true, () => true);
+                    incrementalInfo.deferInfo.lookupArray(item.path);
+                }
+                else if (streamInfo && type === "stream") {
+                    streamInfo.lookupArray(item.path).state.truncate = true;
+                }
+            }
+        }
+        return incrementalInfo;
+    }
+    getDiff(options, incrementalInfo) {
+        if (this.cache[internal_1.handleIncrementalSymbol]) {
+            return this.cache.diff({
+                ...options,
+                [internal_1.handleIncrementalSymbol]: incrementalInfo || true,
+            });
+        }
+        // returnPartialData is overridden for backwards compatibility with caches
+        // that don't handle incremental results. Without this, in-flight
+        // incremental cache data would come back null when returnPartialData is
+        // false due to the partial result.
+        const diff = this.cache.diff({ ...options, returnPartialData: true });
+        return {
+            ...diff,
+            dataState: diff.complete ? "complete"
+                : diff.result === null ? "empty"
+                    : "partial",
+        };
+    }
     markMutationResult(incoming, mutation, cache = this.cache) {
         const cacheWrites = [];
         const skipCache = mutation.cacheWriteBehavior === 0 /* CacheWriteBehavior.FORBID */;