relay-runtime 20.1.1 → 21.0.1

package/store/OperationExecutor.js.flow

@@ -71,25 +71,31 @@ const {ROOT_TYPE, TYPENAME_KEY, getStorageKey} = require('./RelayStoreUtils');
 const invariant = require('invariant');
 const warning = require('warning');
 
-export type ExecuteConfig<TMutation: MutationParameters> = {
-  +actorIdentifier: ActorIdentifier,
-  +getDataID: GetDataID,
-  +getPublishQueue: (actorIdentifier: ActorIdentifier) => PublishQueue,
-  +getStore: (actorIdentifier: ActorIdentifier) => Store,
-  +normalizeResponse: NormalizeResponseFunction,
-  +isClientPayload?: boolean,
-  +operation: OperationDescriptor,
-  +operationExecutions: Map<string, ActiveState>,
-  +operationLoader: ?OperationLoader,
-  +operationTracker: OperationTracker,
-  +optimisticConfig: ?OptimisticResponseConfig<TMutation>,
-  +scheduler?: ?TaskScheduler,
-  +shouldProcessClientComponents?: ?boolean,
-  +sink: Sink<GraphQLResponse>,
-  +source: RelayObservable<GraphQLResponse>,
-  +treatMissingFieldsAsNull: boolean,
-  +updater?: ?SelectorStoreUpdater<TMutation['response']>,
-  +log: LogFunction,
+// A network response OR a pre-normalized payload from the network layer.
+// RelayObservable<+T> is covariant, so Observable<GraphQLResponse> is
+// assignable to Observable<NetworkResponse> automatically.
+type NetworkResponse = GraphQLResponse | RelayResponsePayload;
+
+export type ExecuteConfig<TMutation extends MutationParameters> = {
+  readonly actorIdentifier: ActorIdentifier,
+  readonly getDataID: GetDataID,
+  readonly getPublishQueue: (actorIdentifier: ActorIdentifier) => PublishQueue,
+  readonly getStore: (actorIdentifier: ActorIdentifier) => Store,
+  readonly normalizeResponse: NormalizeResponseFunction,
+  readonly isClientPayload?: boolean,
+  readonly operation: OperationDescriptor,
+  readonly operationExecutions: Map<string, ActiveState>,
+  readonly operationLoader: ?OperationLoader,
+  readonly operationTracker: OperationTracker,
+  readonly optimisticConfig: ?OptimisticResponseConfig<TMutation>,
+  readonly scheduler?: ?TaskScheduler,
+  readonly shouldProcessClientComponents?: ?boolean,
+  readonly sink: Sink<GraphQLResponse>,
+  readonly source: RelayObservable<NetworkResponse>,
+  readonly treatMissingFieldsAsNull: boolean,
+  readonly deferDeduplicatedFields: boolean,
+  readonly updater?: ?SelectorStoreUpdater<TMutation['response']>,
+  readonly log: LogFunction,
 };
 
 export type ActiveState = 'active' | 'inactive';
@@ -98,21 +104,21 @@ type Label = string;
 type PathKey = string;
 type IncrementalResults =
   | {
-      +kind: 'placeholder',
-      +placeholder: IncrementalDataPlaceholder,
+      readonly kind: 'placeholder',
+      readonly placeholder: IncrementalDataPlaceholder,
     }
   | {
-      +kind: 'response',
-      +responses: Array<IncrementalGraphQLResponse>,
+      readonly kind: 'response',
+      readonly responses: Array<IncrementalGraphQLResponse>,
     };
 
 type IncrementalGraphQLResponse = {
   label: string,
-  path: $ReadOnlyArray<mixed>,
+  path: ReadonlyArray<unknown>,
   response: GraphQLResponseWithData,
 };
 
-function execute<TMutation: MutationParameters>(
+function execute<TMutation extends MutationParameters>(
   config: ExecuteConfig<TMutation>,
 ): Executor<TMutation> {
   return new Executor(config);
@@ -123,10 +129,11 @@ function execute<TMutation: MutationParameters>(
  * including optimistic payloads, standard payloads, resolution of match
  * dependencies, etc.
  */
-class Executor<TMutation: MutationParameters> {
+class Executor<TMutation extends MutationParameters> {
   _actorIdentifier: ActorIdentifier;
   _getDataID: GetDataID;
   _treatMissingFieldsAsNull: boolean;
+  _deferDeduplicatedFields: boolean;
   _incrementalPayloadsPending: boolean;
   _incrementalResults: Map<Label, Map<PathKey, IncrementalResults>>;
   _log: LogFunction;
@@ -140,26 +147,30 @@ class Executor<TMutation: MutationParameters> {
   _optimisticUpdates: null | Array<OptimisticUpdate<TMutation>>;
   _useExecTimeResolvers: boolean;
   _pendingModulePayloadsCount: number;
-  +_getPublishQueue: (actorIdentifier: ActorIdentifier) => PublishQueue;
+  readonly _getPublishQueue: (actorIdentifier: ActorIdentifier) => PublishQueue;
   _shouldProcessClientComponents: ?boolean;
   _scheduler: ?TaskScheduler;
   _sink: Sink<GraphQLResponse>;
   _source: Map<
     string,
-    {+record: Record, +fieldPayloads: Array<HandleFieldPayload>},
+    {
+      readonly record: Record,
+      readonly fieldPayloads: Array<HandleFieldPayload>,
+    },
   >;
   _state: 'started' | 'loading_incremental' | 'loading_final' | 'completed';
-  +_getStore: (actorIdentifier: ActorIdentifier) => Store;
+  readonly _getStore: (actorIdentifier: ActorIdentifier) => Store;
   _subscriptions: Map<number, Subscription>;
   _updater: ?SelectorStoreUpdater<TMutation['response']>;
   _asyncStoreUpdateDisposable: ?Disposable;
   _completeFns: Array<() => void>;
-  +_retainDisposables: Map<ActorIdentifier, Disposable>;
-  +_isClientPayload: boolean;
-  +_isSubscriptionOperation: boolean;
-  +_seenActors: Set<ActorIdentifier>;
+  readonly _retainDisposables: Map<ActorIdentifier, Disposable>;
+  readonly _isClientPayload: boolean;
+  readonly _isSubscriptionOperation: boolean;
+  readonly _seenActors: Set<ActorIdentifier>;
   _normalizeResponse: NormalizeResponseFunction;
   _execTimeResolverResponseComplete: boolean;
+  _isClientQuery: boolean;
 
   constructor({
     actorIdentifier,
@@ -177,6 +188,7 @@ class Executor<TMutation: MutationParameters> {
     sink,
     source,
     treatMissingFieldsAsNull,
+    deferDeduplicatedFields,
     updater,
     log,
     normalizeResponse,
@@ -184,6 +196,7 @@ class Executor<TMutation: MutationParameters> {
     this._actorIdentifier = actorIdentifier;
     this._getDataID = getDataID;
     this._treatMissingFieldsAsNull = treatMissingFieldsAsNull;
+    this._deferDeduplicatedFields = deferDeduplicatedFields;
     this._incrementalPayloadsPending = false;
     this._incrementalResults = new Map();
     this._log = log;
@@ -218,6 +231,9 @@ class Executor<TMutation: MutationParameters> {
     this._seenActors = new Set();
     this._completeFns = [];
     this._normalizeResponse = normalizeResponse;
+    this._isClientQuery =
+      this._operation.request.node.params.id == null &&
+      this._operation.request.node.params.text == null;
 
     const id = this._nextSubscriptionId++;
 
@@ -246,17 +262,17 @@ class Executor<TMutation: MutationParameters> {
       start: subscription => {
         this._start(id, subscription);
         this._log({
-          name: 'execute.start',
+          cacheConfig: this._operation.request.cacheConfig ?? {},
           executeId: this._executeId,
+          name: 'execute.start',
           params: this._operation.request.node.params,
           variables: this._operation.request.variables,
-          cacheConfig: this._operation.request.cacheConfig ?? {},
         });
       },
       unsubscribe: () => {
         this._log({
-          name: 'execute.unsubscribe',
           executeId: this._executeId,
+          name: 'execute.unsubscribe',
         });
       },
     });
@@ -331,7 +347,7 @@ class Executor<TMutation: MutationParameters> {
         break;
       }
       default:
-        (this._state: empty);
+        this._state as empty;
         invariant(false, 'OperationExecutor: invalid executor state.');
     }
     this._operationExecutions.set(
@@ -370,8 +386,8 @@ class Executor<TMutation: MutationParameters> {
       this.cancel();
       this._sink.complete();
       this._log({
-        name: 'execute.complete',
         executeId: this._executeId,
+        name: 'execute.complete',
       });
     }
   }
@@ -380,9 +396,9 @@ class Executor<TMutation: MutationParameters> {
     this.cancel();
     this._sink.error(error);
     this._log({
-      name: 'execute.error',
-      executeId: this._executeId,
       error,
+      executeId: this._executeId,
+      name: 'execute.error',
     });
   }
 
@@ -391,30 +407,48 @@ class Executor<TMutation: MutationParameters> {
     this._updateActiveState();
   }
 
-  // Handle a raw GraphQL response.
-  _next(_id: number, response: GraphQLResponse): void {
+  // Handle a raw GraphQL response or a pre-normalized payload from the
+  // network layer. Pre-normalized payloads bypass the normal GraphQL pipeline.
+  _next(_id: number, response: NetworkResponse): void {
     const priority = this._state === 'loading_incremental' ? 'low' : 'default';
     this._schedule(() => {
+      // Pre-normalized payloads from the network layer have isPreNormalized
+      // set by NormalizationEngine. Route them to a dedicated handler that
+      // commits directly to the store, bypassing normalizeResponse().
+      if (
+        !Array.isArray(response) &&
+        // $FlowFixMe[prop-missing] isPreNormalized exists on RelayResponsePayload branch
+        response.isPreNormalized === true
+      ) {
+        // $FlowFixMe[incompatible-type] narrowed by isPreNormalized check
+        this._handlePreNormalizedPayload(response);
+        return;
+      }
+      // After the pre-normalized early return, response is a standard
+      // GraphQLResponse (Flow cannot narrow this automatically because
+      // isPreNormalized is optional, so we cast once here at the boundary).
+      // $FlowFixMe[incompatible-type] narrowed by isPreNormalized check above
+      const graphQLResponse: GraphQLResponse = response;
       this._log({
-        name: 'execute.next.start',
         executeId: this._executeId,
-        response,
+        name: 'execute.next.start',
         operation: this._operation,
+        response: graphQLResponse,
       });
-      this._handleNext(response);
+      this._handleNext(graphQLResponse);
       this._maybeCompleteSubscriptionOperationTracking();
       this._log({
-        name: 'execute.next.end',
         executeId: this._executeId,
-        response,
+        name: 'execute.next.end',
         operation: this._operation,
+        response: graphQLResponse,
       });
     }, priority);
   }
 
   _handleErrorResponse(
-    responses: $ReadOnlyArray<GraphQLSingularResponse>,
-  ): $ReadOnlyArray<GraphQLResponseWithData> {
+    responses: ReadonlyArray<GraphQLSingularResponse>,
+  ): ReadonlyArray<GraphQLResponseWithData> {
     const results = [];
     responses.forEach(response => {
       if (
@@ -442,7 +476,7 @@ class Executor<TMutation: MutationParameters> {
             messages +
             '\n\nSee the error `source` property for more information.',
         );
-        (error: $FlowFixMe).source = {
+        (error as $FlowFixMe).source = {
           errors,
           operation: this._operation.request.node,
           variables: this._operation.request.variables,
@@ -453,7 +487,7 @@ class Executor<TMutation: MutationParameters> {
         throw error;
       } else {
         const responseWithData: GraphQLResponseWithData =
-          (response: $FlowFixMe);
+          response as $FlowFixMe;
         results.push(responseWithData);
       }
     });
@@ -465,7 +499,7 @@ class Executor<TMutation: MutationParameters> {
    * response has been handled
    */
   _handleOptimisticResponses(
-    responses: $ReadOnlyArray<GraphQLResponseWithData>,
+    responses: ReadonlyArray<GraphQLResponseWithData>,
   ): boolean {
     if (responses.length > 1) {
       if (
@@ -500,6 +534,39 @@ class Executor<TMutation: MutationParameters> {
     return false;
   }
 
+  _handlePreNormalizedPayload(payload: RelayResponsePayload): void {
+    // NOTE: This path intentionally skips _maybeCompleteSubscriptionOperationTracking
+    // and the execute.next.start/end log events. Pre-normalized payloads come from
+    // the network-normalization path (NormalizationEngine via executeWithNetwork),
+    // which is used only for live exec-time-resolver queries. Those queries never
+    // complete from the consumer's perspective — exec-time resolvers re-emit on
+    // updates indefinitely — so completion tracking would never fire and is not
+    // needed.
+    if (this._state === 'completed') {
+      return;
+    }
+    this._seenActors.clear();
+    if (this._optimisticUpdates !== null) {
+      this._optimisticUpdates.forEach(update =>
+        this._getPublishQueueAndSaveActor().revertUpdate(update),
+      );
+      this._optimisticUpdates = null;
+    }
+    this._getPublishQueueAndSaveActor().commitPayload(
+      this._operation,
+      payload,
+      payload.storeUpdater ?? this._updater,
+    );
+    if (payload.isFinal) {
+      this._state = 'loading_final';
+    } else if (this._state === 'started') {
+      this._state = 'loading_incremental';
+    }
+    const updatedOwners = this._runPublishQueue(this._operation);
+    this._updateActiveState();
+    this._updateOperationTracker(updatedOwners);
+  }
+
   _handleNext(response: GraphQLResponse): void {
     if (this._state === 'completed') {
       return;
@@ -511,12 +578,38 @@ class Executor<TMutation: MutationParameters> {
 
     if (responsesWithData.length === 0) {
       // no results with data, nothing to process
-      // this can occur with extensions-only payloads
+      // this can occur with extensions-only payloads, or exec time resolver
+      // responses
       const isFinal = responses.some(x => x.extensions?.is_final === true);
       if (isFinal) {
-        this._state = 'loading_final';
-        this._updateActiveState();
-        this._incrementalPayloadsPending = false;
+        if (
+          this._useExecTimeResolvers &&
+          this._state !== 'loading_final' &&
+          responses.some(x => x.extensions?.is_normalized === true)
+        ) {
+          // An exec time resolver query can flush an empty response, if the
+          // same response has been included in other queries. Check if we need
+          // to mark the request as final
+          this._execTimeResolverResponseComplete = true;
+          if (
+            !this._isClientQuery &&
+            responses.some(x => x.extensions?.is_client_only === true)
+          ) {
+            this._isClientQuery = true;
+          }
+          // Need to update the active state to mark the query as inactive,
+          // incase server payloads have completed
+          if (this._isClientQuery) {
+            // If it is a client query, there is no server response to set the
+            // final state, so we need to set it here
+            this._state = 'loading_final';
+          }
+          this._updateActiveState();
+        } else {
+          this._state = 'loading_final';
+          this._updateActiveState();
+          this._incrementalPayloadsPending = false;
+        }
       }
       this._sink.next(response);
       return;
@@ -547,13 +640,13 @@ class Executor<TMutation: MutationParameters> {
       if (this._isSubscriptionOperation) {
         const nextID = generateUniqueClientID();
         this._operation = {
-          request: this._operation.request,
           fragment: createReaderSelector(
             this._operation.fragment.node,
             nextID,
             this._operation.fragment.variables,
             this._operation.fragment.owner,
           ),
+          request: this._operation.request,
           root: createNormalizationSelector(
             this._operation.root.node,
             nextID,
@@ -570,10 +663,13 @@ class Executor<TMutation: MutationParameters> {
       const payloadFollowups = [];
       for (let i = 0; i < normalizedResponses.length; i++) {
         const response = normalizedResponses[i];
-        const source = new RelayRecordSource(
-          response.data as $FlowExpectedError,
-        );
+        const source = new RelayRecordSource(response.data as $FlowFixMe);
         const isFinal = response.extensions?.is_final === true;
+        if (response.extensions?.is_client_only === true) {
+          // For a mixed server and client query, if the network request is
+          // skipped, need to treat it as a client query
+          this._isClientQuery = true;
+        }
         const payload: RelayResponsePayload = {
           errors: [],
           fieldPayloads: [],
@@ -592,6 +688,11 @@ class Executor<TMutation: MutationParameters> {
         if (isFinal) {
           // Need to update the active state to mark the query as inactive,
           // incase server payloads have completed
+          if (this._isClientQuery) {
+            // If it is a client query, there is no server response to set the
+            // final state, so we need to set it here
+            this._state = 'loading_final';
+          }
           this._updateActiveState();
         }
       }
@@ -657,6 +758,7 @@ class Executor<TMutation: MutationParameters> {
         ROOT_TYPE,
         {
           actorIdentifier: this._actorIdentifier,
+          deferDeduplicatedFields: false,
           getDataID: this._getDataID,
           log: this._log,
           path: [],
@@ -678,12 +780,12 @@ class Executor<TMutation: MutationParameters> {
         payload: {
           errors: null,
           fieldPayloads: null,
-          incrementalPlaceholders: null,
           followupPayloads: null,
-          source: RelayRecordSource.create(),
+          incrementalPlaceholders: null,
           isFinal: false,
+          source: RelayRecordSource.create(),
         },
-        updater: updater,
+        updater,
       });
     }
     this._optimisticUpdates = optimisticUpdates;
@@ -726,7 +828,7 @@ class Executor<TMutation: MutationParameters> {
             );
             break;
           default:
-            (followupPayload: empty);
+            followupPayload as empty;
             invariant(
               false,
               'OperationExecutor: Unexpected followup kind `%s`. when processing optimistic updates.',
@@ -775,11 +877,12 @@ class Executor<TMutation: MutationParameters> {
       followupPayload.typeName,
       {
         actorIdentifier: this._actorIdentifier,
+        deferDeduplicatedFields: false,
         getDataID: this._getDataID,
         log: this._log,
         path: followupPayload.path,
-        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         shouldProcessClientComponents: this._shouldProcessClientComponents,
+        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       },
       this._useExecTimeResolvers,
     );
@@ -788,7 +891,7 @@ class Executor<TMutation: MutationParameters> {
   _processOptimisticModuleImport(
     normalizationRootNode: NormalizationRootNode,
     moduleImportPayload: ModuleImportPayload,
-  ): $ReadOnlyArray<OptimisticUpdate<TMutation>> {
+  ): ReadonlyArray<OptimisticUpdate<TMutation>> {
     const operation = getOperation(normalizationRootNode);
     const optimisticUpdates: Array<OptimisticUpdate<TMutation>> = [];
     const modulePayload = this._normalizeFollowupPayload(
@@ -836,8 +939,8 @@ class Executor<TMutation: MutationParameters> {
   }
 
   _processResponses(
-    responses: $ReadOnlyArray<GraphQLResponseWithData>,
-  ): $ReadOnlyArray<RelayResponsePayload> {
+    responses: ReadonlyArray<GraphQLResponseWithData>,
+  ): ReadonlyArray<RelayResponsePayload> {
     this._log({
       name: 'execute.normalize.start',
       operation: this._operation,
@@ -859,11 +962,12 @@ class Executor<TMutation: MutationParameters> {
         ROOT_TYPE,
         {
           actorIdentifier: this._actorIdentifier,
+          deferDeduplicatedFields: false,
           getDataID: this._getDataID,
           log: this._log,
           path: [],
-          treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
           shouldProcessClientComponents: this._shouldProcessClientComponents,
+          treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         },
         this._useExecTimeResolvers,
       );
@@ -885,7 +989,7 @@ class Executor<TMutation: MutationParameters> {
    * and @stream directives.
    */
   _processPayloadFollowups(
-    payloads: $ReadOnlyArray<RelayResponsePayload>,
+    payloads: ReadonlyArray<RelayResponsePayload>,
   ): void {
     if (this._state === 'completed') {
       return;
@@ -1017,6 +1121,7 @@ class Executor<TMutation: MutationParameters> {
           RelayObservable.create<empty>(sink => {
             let cancellationToken;
             const subscription = networkObservable.subscribe({
+              error: sink.error,
               next: (loadedNode: ?NormalizationRootNode) => {
                 if (loadedNode != null) {
                   const publishModuleImportPayload = () => {
@@ -1032,7 +1137,7 @@ class Executor<TMutation: MutationParameters> {
                         // OK: always have to run after an async module import resolves
                         if (shouldScheduleAsyncStoreUpdate) {
                           this._scheduleAsyncStoreUpdate(
-                            // $FlowFixMe[incompatible-call] `shouldScheduleAsyncStoreUpdate` check should cover `null` case
+                            // $FlowFixMe[incompatible-type] `shouldScheduleAsyncStoreUpdate` check should cover `null` case
                             batchAsyncModuleUpdatesFN,
                             sink.complete,
                           );
@@ -1042,10 +1147,10 @@ class Executor<TMutation: MutationParameters> {
                         }
                       });
                       this._log({
-                        name: 'execute.async.module',
+                        duration,
                         executeId: this._executeId,
+                        name: 'execute.async.module',
                         operationName: operation.name,
-                        duration,
                       });
                       if (!shouldScheduleAsyncStoreUpdate) {
                         sink.complete();
@@ -1066,7 +1171,6 @@ class Executor<TMutation: MutationParameters> {
                   sink.complete();
                 }
               },
-              error: sink.error,
             });
             return () => {
               subscription.unsubscribe();
@@ -1094,7 +1198,7 @@ class Executor<TMutation: MutationParameters> {
         );
         break;
       default:
-        (followupPayload: empty);
+        followupPayload as empty;
         invariant(
           false,
           'OperationExecutor: Unexpected followup kind `%s`.',
@@ -1171,7 +1275,7 @@ class Executor<TMutation: MutationParameters> {
     } else if (placeholder.kind === 'defer') {
       parentID = placeholder.selector.dataID;
     } else {
-      (placeholder: empty);
+      placeholder as empty;
       invariant(
         false,
         'OperationExecutor: Unsupported incremental placeholder kind `%s`.',
@@ -1224,8 +1328,8 @@ class Executor<TMutation: MutationParameters> {
       nextParentPayloads = parentPayloads;
     }
     this._source.set(parentID, {
-      record: nextParentRecord,
       fieldPayloads: nextParentPayloads,
+      record: nextParentRecord,
     });
 
     // If there were any queued responses, process them now that placeholders
@@ -1243,8 +1347,8 @@ class Executor<TMutation: MutationParameters> {
    * metadata.
    */
   _processIncrementalResponses(
-    incrementalResponses: $ReadOnlyArray<IncrementalGraphQLResponse>,
-  ): $ReadOnlyArray<RelayResponsePayload> {
+    incrementalResponses: ReadonlyArray<IncrementalGraphQLResponse>,
+  ): ReadonlyArray<RelayResponsePayload> {
     const relayPayloads = [];
     incrementalResponses.forEach(incrementalResponse => {
       const {label, path, response} = incrementalResponse;
@@ -1311,7 +1415,7 @@ class Executor<TMutation: MutationParameters> {
 
   _processDeferResponse(
     label: string,
-    path: $ReadOnlyArray<mixed>,
+    path: ReadonlyArray<unknown>,
     placeholder: DeferPlaceholder,
     response: GraphQLResponseWithData,
   ): RelayResponsePayload {
@@ -1325,11 +1429,12 @@ class Executor<TMutation: MutationParameters> {
       placeholder.typeName,
       {
         actorIdentifier: this._actorIdentifier,
+        deferDeduplicatedFields: this._deferDeduplicatedFields,
         getDataID: this._getDataID,
         log: this._log,
         path: placeholder.path,
-        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         shouldProcessClientComponents: this._shouldProcessClientComponents,
+        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       },
       this._useExecTimeResolvers,
     );
@@ -1352,10 +1457,10 @@ class Executor<TMutation: MutationParameters> {
       const handleFieldsRelayPayload = {
         errors: null,
         fieldPayloads,
-        incrementalPlaceholders: null,
         followupPayloads: null,
-        source: RelayRecordSource.create(),
+        incrementalPlaceholders: null,
         isFinal: response.extensions?.is_final === true,
+        source: RelayRecordSource.create(),
       };
       this._getPublishQueueAndSaveActor().commitPayload(
         this._operation,
@@ -1372,7 +1477,7 @@ class Executor<TMutation: MutationParameters> {
    */
   _processStreamResponse(
     label: string,
-    path: $ReadOnlyArray<mixed>,
+    path: ReadonlyArray<unknown>,
     placeholder: StreamPlaceholder,
     response: GraphQLResponseWithData,
   ): RelayResponsePayload {
@@ -1442,10 +1547,10 @@ class Executor<TMutation: MutationParameters> {
       const handleFieldsRelayPayload = {
         errors: null,
         fieldPayloads,
-        incrementalPlaceholders: null,
         followupPayloads: null,
-        source: RelayRecordSource.create(),
+        incrementalPlaceholders: null,
         isFinal: false,
+        source: RelayRecordSource.create(),
       };
       this._getPublishQueueAndSaveActor().commitPayload(
         this._operation,
@@ -1462,8 +1567,8 @@ class Executor<TMutation: MutationParameters> {
     parentID: DataID,
     field: NormalizationLinkedField,
     variables: Variables,
-    path: $ReadOnlyArray<mixed>,
-    normalizationPath: $ReadOnlyArray<string>,
+    path: ReadonlyArray<unknown>,
+    normalizationPath: ReadonlyArray<string>,
   ): {
     fieldPayloads: Array<HandleFieldPayload>,
     itemID: DataID,
@@ -1549,8 +1654,8 @@ class Executor<TMutation: MutationParameters> {
     nextIDs[itemIndex] = itemID;
     RelayModernRecord.setLinkedRecordIDs(nextParentRecord, storageKey, nextIDs);
     this._source.set(parentID, {
-      record: nextParentRecord,
       fieldPayloads,
+      record: nextParentRecord,
     });
     const relayPayload = this._normalizeResponse(
       response,
@@ -1558,11 +1663,12 @@ class Executor<TMutation: MutationParameters> {
       typeName,
       {
         actorIdentifier: this._actorIdentifier,
+        deferDeduplicatedFields: false,
         getDataID: this._getDataID,
         log: this._log,
         path: [...normalizationPath, responseKey, String(itemIndex)],
-        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         shouldProcessClientComponents: this._shouldProcessClientComponents,
+        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       },
       this._useExecTimeResolvers,
     );
@@ -1596,7 +1702,7 @@ class Executor<TMutation: MutationParameters> {
   }
 
   _updateOperationTracker(
-    updatedOwners: ?$ReadOnlyArray<RequestDescriptor>,
+    updatedOwners: ?ReadonlyArray<RequestDescriptor>,
   ): void {
     if (updatedOwners != null && updatedOwners.length > 0) {
       this._operationTracker.update(
@@ -1615,7 +1721,7 @@ class Executor<TMutation: MutationParameters> {
     return this._getPublishQueue(this._actorIdentifier);
   }
 
-  _getActorsToVisit(): $ReadOnlySet<ActorIdentifier> {
+  _getActorsToVisit(): ReadonlySet<ActorIdentifier> {
     if (this._seenActors.size === 0) {
       return new Set([this._actorIdentifier]);
     } else {
@@ -1625,7 +1731,7 @@ class Executor<TMutation: MutationParameters> {
 
   _runPublishQueue(
     operation?: OperationDescriptor,
-  ): $ReadOnlyArray<RequestDescriptor> {
+  ): ReadonlyArray<RequestDescriptor> {
     const updatedOwners = new Set<RequestDescriptor>();
     for (const actorIdentifier of this._getActorsToVisit()) {
       const owners = this._getPublishQueue(actorIdentifier).run(operation);
@@ -1664,11 +1770,11 @@ class Executor<TMutation: MutationParameters> {
 }
 
 function partitionGraphQLResponses(
-  responses: $ReadOnlyArray<GraphQLResponseWithData>,
+  responses: ReadonlyArray<GraphQLResponseWithData>,
 ): [
-  $ReadOnlyArray<GraphQLResponseWithData>,
-  $ReadOnlyArray<IncrementalGraphQLResponse>,
-  $ReadOnlyArray<GraphQLResponseWithData>,
+  ReadonlyArray<GraphQLResponseWithData>,
+  ReadonlyArray<IncrementalGraphQLResponse>,
+  ReadonlyArray<GraphQLResponseWithData>,
 ] {
   const nonIncrementalResponses: Array<GraphQLResponseWithData> = [];
   const incrementalResponses: Array<IncrementalGraphQLResponse> = [];
@@ -1699,7 +1805,7 @@ function partitionGraphQLResponses(
   return [nonIncrementalResponses, incrementalResponses, normalizedResponses];
 }
 
-function stableStringify(value: mixed): string {
+function stableStringify(value: unknown): string {
   return JSON.stringify(stableCopy(value)) ?? ''; // null-check for flow
 }