Fix issue returning arrays from cache.modify modifier functions when the array contains a union type

.changeset/grumpy-pandas-pump.md

@@ -0,0 +1,5 @@
+---
+"@apollo/client": patch
+---
+
+Allow `cache.modify` to return deeply partial data.

.changeset/shaggy-lions-brake.md

@@ -0,0 +1,5 @@
+---
+"@apollo/client": patch
+---
+
+Prevent accidental distribution on `cache.modify` field modifiers when a field is a union type array.

src/cache/core/__tests__/cache.ts

@@ -517,5 +517,59 @@ describe.skip("Cache type tests", () => {
         },
       });
     });
+
+    test("Allow for mixed arrays on union fields", () => {
+      const cache = new TestCache();
+      cache.modify<{
+        union: Array<
+          | { __typename: "Type1"; a: string }
+          | { __typename: "Type2"; b: string }
+        >;
+      }>({
+        fields: {
+          union(field) {
+            expectTypeOf(field).toEqualTypeOf<
+              ReadonlyArray<
+                | Reference
+                | { __typename: "Type1"; a: string }
+                | { __typename: "Type2"; b: string }
+              >
+            >();
+            return field;
+          },
+        },
+      });
+    });
+
+    test("Allows partial return data", () => {
+      const cache = new TestCache();
+      cache.modify<{
+        union: Array<
+          | { __typename: "Type1"; a: string; c: { foo: string } }
+          | { __typename: "Type2"; b: string; d: { bar: number } }
+        >;
+      }>({
+        fields: {
+          union(field) {
+            expectTypeOf(field).toEqualTypeOf<
+              ReadonlyArray<
+                | Reference
+                | {
+                    __typename: "Type1";
+                    a: string;
+                    c: { foo: string };
+                  }
+                | {
+                    __typename: "Type2";
+                    b: string;
+                    d: { bar: number };
+                  }
+              >
+            >();
+            return [{ __typename: "Type1", a: "foo" }];
+          },
+        },
+      });
+    });
   });
 });

src/cache/core/types/common.ts

@@ -6,6 +6,7 @@ import type {
   StoreValue,
   isReference,
   AsStoreObject,
+  DeepPartial,
 } from "../../../utilities/index.js";
 
 import type { StorageType } from "../../inmemory/policies.js";
@@ -107,12 +108,12 @@ export type ModifierDetails = {
 export type Modifier<T> = (
   value: T,
   details: ModifierDetails
-) => T | DeleteModifier | InvalidateModifier | undefined;
+) => DeepPartial<T> | DeleteModifier | InvalidateModifier | undefined;
 
 type StoreObjectValueMaybeReference<StoreVal> =
   StoreVal extends Array<Record<string, any>> ?
     StoreVal extends Array<infer Item> ?
-      Item extends Record<string, any> ?
+      [Item] extends [Record<string, any>] ?
         ReadonlyArray<AsStoreObject<Item> | Reference>
       : never
     : never

src/cache/inmemory/entityStore.ts

@@ -257,7 +257,7 @@ export abstract class EntityStore implements NormalizedCache {
             if (newValue !== fieldValue) {
               changedFields[storeFieldName] = newValue;
               needToMerge = true;
-              fieldValue = newValue;
+              fieldValue = newValue as StoreValue;
 
               if (__DEV__) {
                 const checkReference = (ref: Reference) => {