Just write the correct returnPartialData from options

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]: DiffIncrementalInfo;
+      [handleIncrementalSymbol]: DiffIncrementalInfo | undefined;
     }
   ): Cache.InternalDiffResultWithDataState<TData> | Cache.DiffResult<TData>;
 

src/cache/inmemory/readFromStore.ts

@@ -315,13 +315,11 @@ 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,7 +136,6 @@ export type ReadQueryOptions = {
 
 /** @internal */
 export interface DiffIncrementalInfo {
-  returnPartialData: boolean | undefined;
   streamInfo?: StreamInfoTrie;
   deferInfo?: DeferInfoTrie;
 }

src/core/QueryInfo.ts

@@ -389,12 +389,12 @@ export class QueryInfo<
             networkStatus !== NetworkStatus.refetch;
 
           const { dataState, result: diffResult } = this.getDiff(
-            diffOptions,
-            this.getIncrementalInfo(result, {
+            {
+              ...diffOptions,
               // Never deliver partial data for network-only requests
               returnPartialData: returnPartialData && !isNetworkOnly,
-              isNetworkOnly,
-            })
+            },
+            this.getIncrementalInfo(result, { isNetworkOnly })
           );
 
           if (
@@ -415,17 +415,11 @@ export class QueryInfo<
 
   private getIncrementalInfo(
     result: MarkQueryResult<any, ExtensionsWithStreamInfo>,
-    {
-      isNetworkOnly,
-      returnPartialData,
-    }: { isNetworkOnly: boolean; returnPartialData: boolean | undefined }
+    { isNetworkOnly }: { isNetworkOnly: boolean }
   ) {
     const pending = this.incremental?.pending ?? [];
     const streamInfo = result.extensions?.[streamInfoSymbol]?.deref();
-    const incrementalInfo: DiffIncrementalInfo = {
-      streamInfo,
-      returnPartialData,
-    };
+    const incrementalInfo: DiffIncrementalInfo = { 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
@@ -453,14 +447,7 @@ export class QueryInfo<
   ): Cache.InternalDiffResultWithDataState<TData> {
     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,
-      },
+      [handleIncrementalSymbol]: incrementalInfo,
     });
 
     if ("dataState" in diff) {