fix(graphcache): preserve entity data when creating new entities

Previously, when a mutation created a truly new entity, graphcache would
incorrectly invalidate existing entities of the same type. This happened
because the "entity exists" check occurred AFTER writing, so the check
was always truthy for new entities. The actual trigger was `!count`
(no active references), which wiped data from existing entities.

Changes:
- Check if entity existed BEFORE writing mutation data to cache
- Only auto-invalidate for existing entities with no references
- Update test to reflect corrected behavior

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: jtomaszewski

exchanges/graphcache/src/cacheExchange.test.ts

@@ -2229,7 +2229,7 @@ describe('optimistic updates', () => {
 });
 
 describe('mutation updates', () => {
-  it('invalidates the type when the entity is not present in the cache', () => {
+  it('does not auto-invalidate when creating a truly new entity (use updaters instead)', () => {
     vi.useFakeTimers();
 
     const authorsQuery = gql`
@@ -2326,12 +2326,9 @@ describe('mutation updates', () => {
 
     expect(response).toHaveBeenCalledTimes(2);
     expect(result).toHaveBeenCalledTimes(2);
-    expect(reexec).toHaveBeenCalledTimes(1);
-
-    next(opOne);
-    vi.runAllTimers();
-    expect(response).toHaveBeenCalledTimes(3);
-    expect(result).toHaveBeenCalledTimes(3);
+    // With the fix, creating a truly new entity does NOT auto-invalidate
+    // existing entities. Use an updater if you need this behavior.
+    expect(reexec).toHaveBeenCalledTimes(0);
     expect(result.mock.calls[1][0].data).toEqual({
       addAuthor: {
         id: '2',

exchanges/graphcache/src/operations/write.ts

@@ -330,6 +330,22 @@ const writeSelection = (
       continue; // Skip this field
     }
 
+    // Check if mutation field entity existed BEFORE writing (for auto-invalidation)
+    let entityExistedBeforeWrite: boolean | undefined;
+    if (
+      typename === ctx.store.rootFields['mutation'] &&
+      !ctx.optimistic &&
+      fieldValue &&
+      typeof fieldValue === 'object' &&
+      !Array.isArray(fieldValue)
+    ) {
+      const key = ctx.store.keyOfEntity(fieldValue as any);
+      if (key) {
+        entityExistedBeforeWrite =
+          InMemoryData.readRecord(key, '__typename') !== undefined;
+      }
+    }
+
     if (node.selectionSet) {
       // Process the field and write links for the child entities that have been written
       if (entityKey && rootField === 'query') {
@@ -400,9 +416,9 @@ const writeSelection = (
       } else if (fieldValue && typeof fieldValue === 'object') {
         const key = ctx.store.keyOfEntity(fieldValue as any);
         if (key) {
-          const resolved = InMemoryData.readRecord(key, '__typename');
           const count = InMemoryData.getRefCount(key);
-          if ((!resolved || !count) && fieldValue.__typename) {
+          // Only invalidate if entity existed BEFORE this mutation and has no references
+          if (entityExistedBeforeWrite && !count && fieldValue.__typename) {
             invalidateType(fieldValue.__typename, [key]);
           }
         }