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

package/core/QueryInfo.d.ts

@@ -4,10 +4,11 @@ import type { ApolloLink } from "@apollo/client/link";
 import type { Unmasked } from "@apollo/client/masking";
 import type { ExtensionsWithStreamInfo } from "@apollo/client/utilities/internal";
 import type { ApolloClient } from "./ApolloClient.js";
+import { NetworkStatus } from "./networkStatus.js";
 import type { ObservableQuery } from "./ObservableQuery.js";
 import type { QueryManager } from "./QueryManager.js";
 import type { DataValue, DefaultContext, InternalRefetchQueriesInclude, MutationUpdaterFunction, NormalizedExecutionResult, OnQueryUpdated, OperationVariables, TypedDocumentNode } from "./types.js";
-import type { ErrorPolicy } from "./watchQueryOptions.js";
+import type { ErrorPolicy, WatchQueryFetchPolicy } from "./watchQueryOptions.js";
 type UpdateQueries<TData> = ApolloClient.MutateOptions<TData, any, any>["updateQueries"];
 export declare const enum CacheWriteBehavior {
     FORBID = 0,
@@ -24,9 +25,12 @@ interface OperationInfo<TData, TVariables extends OperationVariables, AllowedCac
     variables: TVariables;
     errorPolicy: ErrorPolicy;
     cacheWriteBehavior: AllowedCacheWriteBehavior;
+    returnPartialData?: boolean | undefined;
+}
+interface MarkQueryResult<TData, TExtensions> extends FormattedExecutionResult<TData, TExtensions> {
+    dataState: "empty" | "partial" | "streaming" | "complete";
 }
 export declare class QueryInfo<TData, TVariables extends OperationVariables = OperationVariables, TCache extends Cache.Implementation = Cache.Implementation> {
-    lastRequestId: number;
     private cache;
     private queryManager;
     readonly id: string;
@@ -47,7 +51,12 @@ export declare class QueryInfo<TData, TVariables extends OperationVariables = Op
     private shouldWrite;
     get hasNext(): boolean;
     private maybeHandleIncrementalResult;
-    markQueryResult(incoming: ApolloLink.Result<TData>, { document: query, variables, errorPolicy, cacheWriteBehavior, }: OperationInfo<TData, TVariables>): FormattedExecutionResult<DataValue.Complete<TData> | DataValue.Streaming<TData>, ExtensionsWithStreamInfo>;
+    markQueryResult(incoming: ApolloLink.Result<TData>, { document: query, variables, errorPolicy, cacheWriteBehavior, returnPartialData, fetchPolicy, networkStatus, }: OperationInfo<TData, TVariables> & {
+        fetchPolicy: WatchQueryFetchPolicy;
+        networkStatus: NetworkStatus;
+    }): MarkQueryResult<DataValue.Complete<TData> | DataValue.Streaming<TData>, ExtensionsWithStreamInfo>;
+    private getIncrementalInfo;
+    private getDiff;
     markMutationResult(incoming: ApolloLink.Result<TData>, mutation: OperationInfo<TData, TVariables, CacheWriteBehavior.FORBID | CacheWriteBehavior.MERGE> & {
         context?: DefaultContext;
         updateQueries: UpdateQueries<TData>;

package/core/QueryInfo.js

@@ -1,6 +1,8 @@
 import { equal } from "@wry/equality";
-import { getOperationName, graphQLResultHasError, streamInfoSymbol, } from "@apollo/client/utilities/internal";
+import { Trie } from "@wry/trie";
+import { getOperationName, graphQLResultHasError, handleIncrementalSymbol, hasDirectives, streamInfoSymbol, } from "@apollo/client/utilities/internal";
 import { invariant } from "@apollo/client/utilities/invariant";
+import { NetworkStatus } from "./networkStatus.js";
 const IGNORE = {};
 const destructiveMethodCounts = new WeakMap();
 function wrapDestructiveCacheMethod(cache, methodName) {
@@ -26,8 +28,6 @@ const queryInfoIds = new WeakMap();
 // 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;
@@ -97,20 +97,49 @@ export 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 &&
+                    hasDirectives(["defer"], query))) {
+                result.dataState = "streaming";
+            }
             return result;
         }
         if (shouldWriteResult(result, errorPolicy)) {
@@ -129,7 +158,8 @@ export class QueryInfo {
                     }
                 },
                 update: (cache) => {
-                    if (this.shouldWrite(result, variables)) {
+                    const shouldWrite = this.shouldWrite(result, variables);
+                    if (shouldWrite) {
                         cache.writeQuery({
                             query,
                             data: result.data,
@@ -179,20 +209,27 @@ export 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.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 };
                     }
                 },
             });
@@ -202,6 +239,47 @@ export class QueryInfo {
         }
         return result;
     }
+    getIncrementalInfo(result, { isNetworkOnly }) {
+        const pending = this.incremental?.pending ?? [];
+        const streamInfo = result.extensions?.[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(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[handleIncrementalSymbol]) {
+            return this.cache.diff({
+                ...options,
+                [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 */;