Support normalized responses in OperationExecutor

Reviewed By: lynnshaoyu

Differential Revision: D75038384

fbshipit-source-id: 819aca26e2583660db2642223ae6dfbc04bec174

Author: tyao1

packages/relay-runtime/store/OperationExecutor.js

@@ -522,9 +522,10 @@ class Executor<TMutation: MutationParameters> {
       return;
     }
 
-    const [nonIncrementalResponses, incrementalResponses] =
+    const [nonIncrementalResponses, incrementalResponses, normalizedResponses] =
       partitionGraphQLResponses(responsesWithData);
     const hasNonIncrementalResponses = nonIncrementalResponses.length > 0;
+    const hasNormalizedResponses = normalizedResponses.length > 0;
 
     // In theory this doesn't preserve the ordering of the batch.
     // The idea is that a batch is always:
@@ -559,6 +560,28 @@ class Executor<TMutation: MutationParameters> {
       this._processPayloadFollowups(payloadFollowups);
     }
 
+    if (hasNormalizedResponses) {
+      for (let i = 0; i < normalizedResponses.length; i++) {
+        const response = normalizedResponses[i];
+        const source = new RelayRecordSource(
+          response.data as $FlowExpectedError,
+        );
+        const payload: RelayResponsePayload = {
+          errors: [],
+          fieldPayloads: [],
+          followupPayloads: [],
+          incrementalPlaceholders: [],
+          isFinal: response.extensions?.is_final === true,
+          source,
+        };
+        this._getPublishQueueAndSaveActor().commitPayload(
+          this._operation,
+          payload,
+          this._updater,
+        );
+      }
+    }
+
     if (incrementalResponses.length > 0) {
       const payloadFollowups =
         this._processIncrementalResponses(incrementalResponses);
@@ -584,7 +607,9 @@ class Executor<TMutation: MutationParameters> {
     // the publish queue here, which will later be passed to the store (via
     // notify) to indicate that this operation caused the store to update
     const updatedOwners = this._runPublishQueue(
-      hasNonIncrementalResponses ? this._operation : undefined,
+      hasNonIncrementalResponses || hasNormalizedResponses
+        ? this._operation
+        : undefined,
     );
 
     if (hasNonIncrementalResponses) {
@@ -1613,9 +1638,11 @@ function partitionGraphQLResponses(
 ): [
   $ReadOnlyArray<GraphQLResponseWithData>,
   $ReadOnlyArray<IncrementalGraphQLResponse>,
+  $ReadOnlyArray<GraphQLResponseWithData>,
 ] {
   const nonIncrementalResponses: Array<GraphQLResponseWithData> = [];
   const incrementalResponses: Array<IncrementalGraphQLResponse> = [];
+  const normalizedResponses: Array<GraphQLResponseWithData> = [];
   responses.forEach(response => {
     if (response.path != null || response.label != null) {
       const {label, path} = response;
@@ -1633,11 +1660,13 @@ function partitionGraphQLResponses(
         path,
         response,
       });
+    } else if (response.extensions?.is_normalized === true) {
+      normalizedResponses.push(response);
     } else {
       nonIncrementalResponses.push(response);
     }
   });
-  return [nonIncrementalResponses, incrementalResponses];
+  return [nonIncrementalResponses, incrementalResponses, normalizedResponses];
 }
 
 function stableStringify(value: mixed): string {

packages/relay-runtime/store/__tests__/RelayModernEnvironment-ExecuteWithDefer-test.js

@@ -251,6 +251,63 @@ describe.each(['RelayModernEnvironment', 'MultiActorEnvironment'])(
         });
       });
 
+      it('processes deferred payloads mixed with normalized response payloads', () => {
+        const initialSnapshot = environment.lookup(selector);
+        const callback = jest.fn<[Snapshot], void>();
+        environment.subscribe(initialSnapshot, callback);
+
+        environment.execute({operation}).subscribe(callbacks);
+        dataSource.next({
+          data: {
+            node: {
+              id: '1',
+              __typename: 'User',
+            },
+          },
+        });
+        jest.runAllTimers();
+        next.mockClear();
+        callback.mockClear();
+
+        const extensionsPayload = {
+          data: {
+            '1': {
+              __id: '1',
+              __typename: 'User',
+              extra_data: 'Zuck',
+            },
+          },
+          extensions: {is_normalized: true},
+        };
+        dataSource.next(extensionsPayload);
+        expect(callback).toBeCalledTimes(0);
+        expect(next).toBeCalledTimes(1);
+        expect(next.mock.calls[0][0]).toBe(extensionsPayload);
+        next.mockClear();
+
+        dataSource.next({
+          data: {
+            id: '1',
+            __typename: 'User',
+            name: 'joe',
+          },
+          label:
+            'RelayModernEnvironmentExecuteWithDeferTestUserQuery$defer$UserFragment',
+          path: ['node'],
+        });
+
+        expect(complete).toBeCalledTimes(0);
+        expect(error).toBeCalledTimes(0);
+        expect(next).toBeCalledTimes(1);
+        expect(callback).toBeCalledTimes(1);
+        const snapshot = callback.mock.calls[0][0];
+        expect(snapshot.isMissingData).toBe(false);
+        expect(snapshot.data).toEqual({
+          id: '1',
+          name: 'JOE',
+        });
+      });
+
       describe('when using a scheduler', () => {
         let taskID;
         let tasks;

packages/relay-runtime/store/__tests__/RelayModernEnvironment-ExecuteWithSource-test.js

@@ -203,6 +203,53 @@ describe.each(['RelayModernEnvironment', 'MultiActorEnvironment'])(
           },
         });
       });
+
+      it('calls next() and publishes normalized response to the store', () => {
+        const selector = createReaderSelector(
+          query.fragment,
+          ROOT_ID,
+          variables,
+          operation.request,
+        );
+        const snapshot = environment.lookup(selector);
+        const callback = jest.fn<[Snapshot], void>();
+        environment.subscribe(snapshot, callback);
+
+        environment
+          .executeWithSource({operation, source: fetchSource})
+          .subscribe(callbacks);
+        const payload = {
+          data: {
+            '842472': {
+              __id: '842472',
+              __typename: 'User',
+              name: 'Joe',
+              id: '842472',
+            },
+            'client:root': {
+              __id: 'client:root',
+              __typename: '__Root',
+              me: {__ref: '842472'},
+            },
+          },
+          extensions: {
+            is_normalized: true,
+          },
+        };
+        subject.next(payload);
+        jest.runAllTimers();
+
+        expect(next.mock.calls.length).toBe(1);
+        expect(next).toBeCalledWith(payload);
+        expect(complete).not.toBeCalled();
+        expect(error).not.toBeCalled();
+        expect(callback.mock.calls.length).toBe(1);
+        expect(callback.mock.calls[0][0].data).toEqual({
+          me: {
+            name: 'Joe',
+          },
+        });
+      });
     });
   },
 );