fix(graphcache): ignore current entity during invalidateType (#3560)

.changeset/rich-suns-sit.md

···
+---
+'@urql/exchange-graphcache': patch
+---
+
+When invoking the automatic creation updater ignore the entity we are currently on in the mutation

exchanges/graphcache/src/cacheExchange.test.ts

···
     vi.runAllTimers();
     expect(response).toHaveBeenCalledTimes(3);
     expect(result).toHaveBeenCalledTimes(3);
+    expect(result.mock.calls[1][0].data).toEqual({
+      addAuthor: {
+        id: '2',
+        name: 'Author 2',
+      },
+    });
   });
 });
 

exchanges/graphcache/src/operations/invalidate.ts

···
   }
 };
 
-export const invalidateType = (typename: string) => {
+export const invalidateType = (
+  typename: string,
+  excludedEntities: string[]
+) => {
   const types = InMemoryData.getEntitiesForType(typename);
   for (const entity of types) {
+    if (excludedEntities.includes(entity)) continue;
     invalidateEntity(entity);
   }
 };

exchanges/graphcache/src/operations/write.ts

···
       // if we don't we'll assume this is a create mutation and invalidate
       // the found __typename.
       if (fieldValue && Array.isArray(fieldValue)) {
+        const excludedEntities: string[] = fieldValue.map(
+          entity => ctx.store.keyOfEntity(entity) || ''
+        );
         for (let i = 0, l = fieldValue.length; i < l; i++) {
-          const key = ctx.store.keyOfEntity(fieldValue[i]);
+          const key = excludedEntities[i];
           if (key && fieldValue[i].__typename) {
             const resolved = InMemoryData.readRecord(key, '__typename');
             const count = InMemoryData!.getRefCount(key);
             if (resolved && !count) {
-              invalidateType(fieldValue[i].__typename);
+              invalidateType(fieldValue[i].__typename, excludedEntities);
             }
           }
         }
···
           const resolved = InMemoryData.readRecord(key, '__typename');
           const count = InMemoryData.getRefCount(key);
           if ((!resolved || !count) && fieldValue.__typename) {
-            invalidateType(fieldValue.__typename);
+            invalidateType(fieldValue.__typename, [key]);
           }
         }
       }

exchanges/graphcache/src/store/store.ts

···
       !this.resolve(entity, '__typename');
 
     if (shouldInvalidateType) {
-      invalidateType(entity);
+      invalidateType(entity, []);
     } else {
       invariant(
         entityKey,