Pass in real returnPartialData via symbol

Author: jerelmiller

src/cache/core/cache.ts

@@ -201,7 +201,7 @@ export abstract class ApolloCache {
     TVariables extends OperationVariables = OperationVariables,
   >(
     query: Cache.DiffOptions<TData, TVariables> & {
-      [handleIncrementalSymbol]: true | DiffIncrementalInfo;
+      [handleIncrementalSymbol]: DiffIncrementalInfo;
     }
   ): Cache.InternalDiffResultWithDataState<TData> | Cache.DiffResult<TData>;
 

src/cache/inmemory/readFromStore.ts

@@ -302,7 +302,7 @@ export class StoreReader {
    */
   public diffQueryAgainstStore<T>(
     options: DiffQueryAgainstStoreOptions & {
-      [handleIncrementalSymbol]: true | DiffIncrementalInfo;
+      [handleIncrementalSymbol]: DiffIncrementalInfo;
     }
   ): Cache.InternalDiffResultWithDataState<T>;
 
@@ -315,11 +315,13 @@ export class StoreReader {
     query,
     rootId = "ROOT_QUERY",
     variables,
-    returnPartialData = true,
     [handleIncrementalSymbol]: handleIncremental,
+    ...options
   }: DiffQueryAgainstStoreOptions): Cache.DiffResult<T> & {
     dataState?: "empty" | "partial" | "streaming" | "complete";
   } {
+    const returnPartialData =
+      handleIncremental?.returnPartialData ?? options.returnPartialData ?? true;
     const policies = this.config.cache.policies;
 
     variables = {

src/cache/inmemory/types.ts

@@ -136,13 +136,14 @@ export type ReadQueryOptions = {
 
 /** @internal */
 export interface DiffIncrementalInfo {
+  returnPartialData: boolean | undefined;
   streamInfo?: StreamInfoTrie;
   deferInfo?: DeferInfoTrie;
 }
 
 export type DiffQueryAgainstStoreOptions = ReadQueryOptions & {
   returnPartialData?: boolean;
-  [handleIncrementalSymbol]?: true | DiffIncrementalInfo;
+  [handleIncrementalSymbol]?: DiffIncrementalInfo;
 };
 
 export type ApolloReducerConfig = {

src/core/QueryInfo.ts

@@ -7,7 +7,6 @@ import type {
   Cache,
   DiffIncrementalInfo,
   IgnoreModifier,
-  InMemoryCache,
 } from "@apollo/client/cache";
 import type { Incremental } from "@apollo/client/incremental";
 import type { ApolloLink } from "@apollo/client/link";
@@ -390,12 +389,12 @@ export class QueryInfo<
             networkStatus !== NetworkStatus.refetch;
 
           const { dataState, result: diffResult } = this.getDiff(
-            {
-              ...diffOptions,
+            diffOptions,
+            this.getIncrementalInfo(result, {
               // Never deliver partial data for network-only requests
               returnPartialData: returnPartialData && !isNetworkOnly,
-            },
-            this.getIncrementalInfo(result, { isNetworkOnly })
+              isNetworkOnly,
+            })
           );
 
           if (
@@ -416,11 +415,17 @@ export class QueryInfo<
 
   private getIncrementalInfo(
     result: MarkQueryResult<any, ExtensionsWithStreamInfo>,
-    { isNetworkOnly }: { isNetworkOnly: boolean }
+    {
+      isNetworkOnly,
+      returnPartialData,
+    }: { isNetworkOnly: boolean; returnPartialData: boolean | undefined }
   ) {
     const pending = this.incremental?.pending ?? [];
     const streamInfo = result.extensions?.[streamInfoSymbol]?.deref();
-    const incrementalInfo: DiffIncrementalInfo = { streamInfo };
+    const incrementalInfo: DiffIncrementalInfo = {
+      streamInfo,
+      returnPartialData,
+    };
 
     // 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
@@ -446,19 +451,22 @@ export class QueryInfo<
     options: Cache.DiffOptions<TData>,
     incrementalInfo?: DiffIncrementalInfo
   ): Cache.InternalDiffResultWithDataState<TData> {
-    if ((this.cache as any)[handleIncrementalSymbol]) {
-      return (this.cache as unknown as InMemoryCache).diff({
-        ...options,
-        [handleIncrementalSymbol]: incrementalInfo || true,
-      });
+    const diff = this.cache.diff({
+      ...options,
+      // 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.
+      returnPartialData: true,
+      [handleIncrementalSymbol]: incrementalInfo || {
+        returnPartialData: options.returnPartialData,
+      },
+    });
+
+    if ("dataState" in diff) {
+      return diff;
     }
 
-    // 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: