Process abstract type key on resolver fragments

Differential Revision: D80972077

Author: captbaritone

packages/react-relay/__tests__/RelayResolvers-abstractTypeRootFragment-test.js

@@ -86,15 +86,6 @@ test('Can read a resolver with a rootFragment on an abstract type', async () =>
     jest.runAllImmediates();
   });
 
-  // Incorrect! We provided `__isNode`!
-  expect(logEvents).toEqual([
-    {
-      fieldPath: '<abstract-type-hint>',
-      kind: 'missing_expected_data.log',
-      owner: 'NodeResolversGreeting',
-      uiContext: undefined,
-    },
-  ]);
-  // Incorrect! Should be the greeting.
-  expect(renderer?.toJSON()).toEqual(null);
+  expect(logEvents).toEqual([]);
+  expect(renderer?.toJSON()).toEqual('Hello Node with id 4!');
 });

packages/relay-runtime/store/RelayResponseNormalizer.js

@@ -16,6 +16,7 @@ import type {PayloadData, PayloadError} from '../network/RelayNetworkTypes';
 import type {
   NormalizationActorChange,
   NormalizationDefer,
+  NormalizationInlineFragment,
   NormalizationLinkedField,
   NormalizationLiveResolverField,
   NormalizationModuleImport,
@@ -243,34 +244,7 @@ class RelayResponseNormalizer {
           break;
         }
         case 'InlineFragment': {
-          const {abstractKey} = selection;
-          if (abstractKey == null) {
-            const typeName = RelayModernRecord.getType(record);
-            if (typeName === selection.type) {
-              this._traverseSelections(selection, record, data);
-            }
-          } else {
-            // $FlowFixMe[method-unbinding] - data could be prototype less
-            const implementsInterface = Object.prototype.hasOwnProperty.call(
-              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);
-            }
-            RelayModernRecord.setValue(
-              typeRecord,
-              abstractKey,
-              implementsInterface,
-            );
-            if (implementsInterface) {
-              this._traverseSelections(selection, record, data);
-            }
-          }
+          this._normalizeInlineFragment(selection, record, data);
           break;
         }
         case 'TypeDiscriminator': {
@@ -358,13 +332,44 @@ class RelayResponseNormalizer {
     }
   }
 
+  _normalizeInlineFragment(
+    selection: NormalizationInlineFragment,
+    record: Record,
+    data: PayloadData,
+  ) {
+    const {abstractKey} = selection;
+    if (abstractKey == null) {
+      const typeName = RelayModernRecord.getType(record);
+      if (typeName === selection.type) {
+        this._traverseSelections(selection, record, data);
+      }
+    } else {
+      // $FlowFixMe[method-unbinding] - data could be prototype less
+      const implementsInterface = Object.prototype.hasOwnProperty.call(
+        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);
+      }
+      RelayModernRecord.setValue(typeRecord, abstractKey, implementsInterface);
+      if (implementsInterface) {
+        this._traverseSelections(selection, record, data);
+      }
+    }
+  }
+
   _normalizeResolver(
     resolver: NormalizationResolverField | NormalizationLiveResolverField,
     record: Record,
     data: PayloadData,
   ) {
     if (resolver.fragment != null) {
-      this._traverseSelections(resolver.fragment, record, data);
+      this._normalizeInlineFragment(resolver.fragment, record, data);
     }
   }