Don't corrupt type registry with false abstract-type tag under deferDeduplicatedFields

RelayResponseNormalizer's TypeDiscriminator and InlineFragment
normalization paths unconditionally write
'client:__type:<ConcreteType>.__is<Interface>: <hasOwnProperty>'
during payload traversal.

Without deferDeduplicatedFields, this is fine: a missing __isFoo tag
in a normalized payload is a real 'type does not implement Foo'
signal, and the false write is load-bearing so DataChecker can skip
future '... on Foo' selections for that concrete type.

Under Environment({ deferDeduplicatedFields: true }), the same missing
tag can just mean 'delivered earlier in a different chunk of this
operation, dedup'd out of the current chunk'. Writing false in that
case is wrong: it plants a schema-contradicting negative claim in the
type registry, and DataChecker (which treats false as authoritative
non-implementation) then silently skips '... on <Interface>' subtrees
for every future query touching that concrete type — never marking
anything missing, never fetching.

Symptom in our app: after an SSR page load that fetches a defer'd
query, client-navigations to any page that reads a Cloudcast via
'node(id) { ... on Node { ... on Cloudcast ... } }' rendered null for
every field inside — reader saw $isWithinUnmatchedTypeRefinement:true
because DataChecker had marked the query 'available' without ever
fetching, thanks to __type:Cloudcast.__isNode=false written during the
defer'd chunk.

Fix: skip the write when 'hasOwnProperty === false && this
._deferDeduplicatedFields'. When the write is skipped, DataChecker
treats the registry entry as unknown (_implementsInterface == null) →
handles missing → fetches on next check → the response arrives with
the tag → true written normally. Non-dedup environments are
byte-identical to the previous behaviour.

Filed as #5389.

Author: jonreading81

packages/relay-runtime/store/RelayResponseNormalizer.js

@@ -283,18 +283,24 @@ class RelayResponseNormalizer {
             data,
             abstractKey,
           );
-          const typeName = RelayModernRecord.getType(record);
-          const typeID = generateTypeID(typeName);
-          let typeRecord = this._recordSource.get(typeID);
-          if (typeRecord == null) {
-            typeRecord = RelayModernRecord.create(typeID, TYPE_SCHEMA_TYPE);
-            this._recordSource.set(typeID, typeRecord);
+          // Under `deferDeduplicatedFields` a missing abstract typename means
+          // the server omitted it as already-delivered, not that the concrete
+          // type fails the type refinement. Skip the write; DataChecker then
+          // treats the entry as unknown and refetches on the next check.
+          if (implementsInterface || !this._deferDeduplicatedFields) {
+            const typeName = RelayModernRecord.getType(record);
+            const typeID = generateTypeID(typeName);
+            let typeRecord = this._recordSource.get(typeID);
+            if (typeRecord == null) {
+              typeRecord = RelayModernRecord.create(typeID, TYPE_SCHEMA_TYPE);
+              this._recordSource.set(typeID, typeRecord);
+            }
+            RelayModernRecord.setValue(
+              typeRecord,
+              abstractKey,
+              implementsInterface,
+            );
           }
-          RelayModernRecord.setValue(
-            typeRecord,
-            abstractKey,
-            implementsInterface,
-          );
           break;
         }
         case 'LinkedHandle':
@@ -402,14 +408,21 @@ class RelayResponseNormalizer {
         data,
         abstractKey,
       );
-      const typeName = RelayModernRecord.getType(record);
-      const typeID = generateTypeID(typeName);
-      let typeRecord = this._recordSource.get(typeID);
-      if (typeRecord == null) {
-        typeRecord = RelayModernRecord.create(typeID, TYPE_SCHEMA_TYPE);
-        this._recordSource.set(typeID, typeRecord);
+      // See the `TypeDiscriminator` case above for the reasoning.
+      if (implementsInterface || !this._deferDeduplicatedFields) {
+        const typeName = RelayModernRecord.getType(record);
+        const typeID = generateTypeID(typeName);
+        let typeRecord = this._recordSource.get(typeID);
+        if (typeRecord == null) {
+          typeRecord = RelayModernRecord.create(typeID, TYPE_SCHEMA_TYPE);
+          this._recordSource.set(typeID, typeRecord);
+        }
+        RelayModernRecord.setValue(
+          typeRecord,
+          abstractKey,
+          implementsInterface,
+        );
       }
-      RelayModernRecord.setValue(typeRecord, abstractKey, implementsInterface);
       if (implementsInterface) {
         this._traverseSelections(selection, record, data);
       }

packages/relay-runtime/store/__tests__/RelayResponseNormalizer-test.js

@@ -4390,4 +4390,139 @@ describe('RelayResponseNormalizer', () => {
       });
     });
   });
+
+  describe('deferDeduplicatedFields', () => {
+    it('does not write `__is<Interface>: false` when the abstract typename is missing from the payload', () => {
+      const query = graphql`
+        query RelayResponseNormalizerTest44Query($id: ID!) {
+          node(id: $id) {
+            ...RelayResponseNormalizerTest44Fragment
+          }
+        }
+      `;
+
+      graphql`
+        fragment RelayResponseNormalizerTest44Fragment on Node {
+          id
+          ... on User {
+            name
+          }
+        }
+      `;
+
+      // Payload omits `__isNode`: under deferDeduplicatedFields this signals
+      // that the server dedup'd an already-delivered field, not that the
+      // concrete type fails the type refinement.
+      const payload = {
+        node: {
+          __typename: 'User',
+          id: '1',
+          name: 'Alice',
+        },
+      };
+
+      const recordSource = new RelayRecordSource();
+      recordSource.set(ROOT_ID, RelayModernRecord.create(ROOT_ID, ROOT_TYPE));
+
+      normalize(
+        recordSource,
+        createNormalizationSelector(query.operation, ROOT_ID, {id: '1'}),
+        payload,
+        {...defaultOptions, deferDeduplicatedFields: true},
+      );
+
+      // No `client:__type:User` record — the write is skipped so
+      // DataChecker treats the entry as unknown and refetches on next
+      // check.
+      expect(recordSource.get('client:__type:User')).toBe(undefined);
+    });
+
+    it('still writes `__is<Interface>: true` when the abstract typename is present in the payload', () => {
+      const query = graphql`
+        query RelayResponseNormalizerTest45Query($id: ID!) {
+          node(id: $id) {
+            ...RelayResponseNormalizerTest45Fragment
+          }
+        }
+      `;
+
+      graphql`
+        fragment RelayResponseNormalizerTest45Fragment on Node {
+          id
+          ... on User {
+            name
+          }
+        }
+      `;
+
+      const payload = {
+        node: {
+          __typename: 'User',
+          __isNode: 'User',
+          id: '1',
+          name: 'Alice',
+        },
+      };
+
+      const recordSource = new RelayRecordSource();
+      recordSource.set(ROOT_ID, RelayModernRecord.create(ROOT_ID, ROOT_TYPE));
+
+      normalize(
+        recordSource,
+        createNormalizationSelector(query.operation, ROOT_ID, {id: '1'}),
+        payload,
+        {...defaultOptions, deferDeduplicatedFields: true},
+      );
+
+      expect(recordSource.get('client:__type:User')).toEqual({
+        __id: 'client:__type:User',
+        __typename: '__TypeSchema',
+        __isNode: true,
+      });
+    });
+
+    it('still writes `__is<Interface>: false` when deferDeduplicatedFields is off (default behaviour preserved)', () => {
+      const query = graphql`
+        query RelayResponseNormalizerTest46Query($id: ID!) {
+          node(id: $id) {
+            ...RelayResponseNormalizerTest46Fragment
+          }
+        }
+      `;
+
+      graphql`
+        fragment RelayResponseNormalizerTest46Fragment on Node {
+          id
+          ... on User {
+            name
+          }
+        }
+      `;
+
+      const payload = {
+        node: {
+          __typename: 'Page',
+          id: '1',
+        },
+      };
+
+      const recordSource = new RelayRecordSource();
+      recordSource.set(ROOT_ID, RelayModernRecord.create(ROOT_ID, ROOT_TYPE));
+
+      normalize(
+        recordSource,
+        createNormalizationSelector(query.operation, ROOT_ID, {id: '1'}),
+        payload,
+        defaultOptions,
+      );
+
+      // Without deferDeduplicatedFields the missing `__isNode` is still a
+      // real "type does not implement" signal — behaviour unchanged.
+      expect(recordSource.get('client:__type:Page')).toEqual({
+        __id: 'client:__type:Page',
+        __typename: '__TypeSchema',
+        __isNode: false,
+      });
+    });
+  });
 });