relay-runtime 10.0.1 → 10.1.0

package/store/DataChecker.js.flow

@@ -18,10 +18,12 @@ const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 const RelayModernRecord = require('./RelayModernRecord');
 const RelayRecordSourceMutator = require('../mutations/RelayRecordSourceMutator');
 const RelayRecordSourceProxy = require('../mutations/RelayRecordSourceProxy');
+const RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');
 const RelayStoreUtils = require('./RelayStoreUtils');
 
 const cloneRelayHandleSourceField = require('./cloneRelayHandleSourceField');
 const cloneRelayScalarHandleSourceField = require('./cloneRelayScalarHandleSourceField');
+const getOperation = require('../util/getOperation');
 const invariant = require('invariant');
 
 const {isClientID} = require('./ClientID');
@@ -30,6 +32,7 @@ const {generateTypeID} = require('./TypeID');
 
 import type {
   NormalizationField,
+  NormalizationFlightField,
   NormalizationLinkedField,
   NormalizationModuleImport,
   NormalizationNode,
@@ -43,6 +46,7 @@ import type {
   MutableRecordSource,
   NormalizationSelector,
   OperationLoader,
+  ReactFlightReachableQuery,
   Record,
   RecordSource,
 } from './RelayStoreTypes';
@@ -56,6 +60,7 @@ const {
   CONDITION,
   CLIENT_EXTENSION,
   DEFER,
+  FLIGHT_FIELD,
   FRAGMENT_SPREAD,
   INLINE_FRAGMENT,
   LINKED_FIELD,
@@ -67,6 +72,7 @@ const {
   TYPE_DISCRIMINATOR,
 } = RelayConcreteNode;
 const {
+  ROOT_ID,
   getModuleOperationKey,
   getStorageKey,
   getArgumentValues,
@@ -375,6 +381,7 @@ class DataChecker {
         case STREAM:
           this._traverseSelections(selection.selections, dataID);
           break;
+        // $FlowFixMe[incompatible-type]
         case FRAGMENT_SPREAD:
           invariant(
             false,
@@ -409,6 +416,13 @@ class DataChecker {
             } // else: if it does or doesn't implement, we don't need to check or skip anything else
           }
           break;
+        case FLIGHT_FIELD:
+          if (RelayFeatureFlags.ENABLE_REACT_FLIGHT_COMPONENT_FIELD) {
+            this._checkFlightField(selection, dataID);
+          } else {
+            throw new Error('Flight fields are not yet supported.');
+          }
+          break;
         default:
           (selection: empty);
           invariant(
@@ -437,8 +451,9 @@ class DataChecker {
       }
       return;
     }
-    const operation = operationLoader.get(operationReference);
-    if (operation != null) {
+    const normalizationRootNode = operationLoader.get(operationReference);
+    if (normalizationRootNode != null) {
+      const operation = getOperation(normalizationRootNode);
       this._traverse(operation, dataID);
     } else {
       // If the fragment is not available, we assume that the data cannot have been
@@ -495,6 +510,57 @@ class DataChecker {
       });
     }
   }
+
+  _checkFlightField(field: NormalizationFlightField, dataID: DataID): void {
+    const storageKey = getStorageKey(field, this._variables);
+    const linkedID = this._mutator.getLinkedRecordID(dataID, storageKey);
+
+    if (linkedID == null) {
+      if (linkedID === undefined) {
+        this._handleMissing();
+        return;
+      }
+      return;
+    }
+
+    const tree = this._mutator.getValue(
+      linkedID,
+      RelayStoreReactFlightUtils.REACT_FLIGHT_TREE_STORAGE_KEY,
+    );
+    const reachableQueries = this._mutator.getValue(
+      linkedID,
+      RelayStoreReactFlightUtils.REACT_FLIGHT_QUERIES_STORAGE_KEY,
+    );
+
+    if (tree == null || !Array.isArray(reachableQueries)) {
+      this._handleMissing();
+      return;
+    }
+
+    const operationLoader = this._operationLoader;
+    invariant(
+      operationLoader !== null,
+      'DataChecker: Expected an operationLoader to be configured when using ' +
+        'React Flight.',
+    );
+    // In Flight, the variables that are in scope for reachable queries aren't
+    // the same as what's in scope for the outer query.
+    const prevVariables = this._variables;
+    // $FlowFixMe[incompatible-cast]
+    for (const query of (reachableQueries: Array<ReactFlightReachableQuery>)) {
+      this._variables = query.variables;
+      const normalizationRootNode = operationLoader.get(query.module);
+      if (normalizationRootNode != null) {
+        const operation = getOperation(normalizationRootNode);
+        this._traverseSelections(operation.selections, ROOT_ID);
+      } else {
+        // If the fragment is not available, we assume that the data cannot have
+        // been processed yet and must therefore be missing.
+        this._handleMissing();
+      }
+    }
+    this._variables = prevVariables;
+  }
 }
 
 module.exports = {

package/store/RelayModernEnvironment.js.flow

@@ -22,6 +22,7 @@ const RelayPublishQueue = require('./RelayPublishQueue');
 const RelayRecordSource = require('./RelayRecordSource');
 
 const defaultGetDataID = require('./defaultGetDataID');
+const defaultRequiredFieldLogger = require('./defaultRequiredFieldLogger');
 const generateID = require('../util/generateID');
 const invariant = require('invariant');
 
@@ -48,6 +49,7 @@ import type {
   IEnvironment,
   LogFunction,
   MissingFieldHandler,
+  RequiredFieldLogger,
   OperationAvailability,
   OperationDescriptor,
   OperationLoader,
@@ -55,6 +57,7 @@ import type {
   OptimisticResponseConfig,
   OptimisticUpdateFunction,
   PublishQueue,
+  ReactFlightPayloadDeserializer,
   SelectorStoreUpdater,
   SingularReaderSelector,
   Snapshot,
@@ -68,6 +71,7 @@ export type EnvironmentConfig = {|
   +treatMissingFieldsAsNull?: boolean,
   +log?: ?LogFunction,
   +operationLoader?: ?OperationLoader,
+  +reactFlightPayloadDeserializer?: ?ReactFlightPayloadDeserializer,
   +network: INetwork,
   +scheduler?: ?TaskScheduler,
   +store: Store,
@@ -82,12 +86,14 @@ export type EnvironmentConfig = {|
   +UNSTABLE_defaultRenderPolicy?: ?RenderPolicy,
   +options?: mixed,
   +isServer?: boolean,
+  +requiredFieldLogger?: ?RequiredFieldLogger,
 |};
 
 class RelayModernEnvironment implements IEnvironment {
   __log: LogFunction;
   +_defaultRenderPolicy: RenderPolicy;
   _operationLoader: ?OperationLoader;
+  _reactFlightPayloadDeserializer: ?ReactFlightPayloadDeserializer;
   _network: INetwork;
   _publishQueue: PublishQueue;
   _scheduler: ?TaskScheduler;
@@ -100,6 +106,7 @@ class RelayModernEnvironment implements IEnvironment {
   _operationExecutions: Map<string, ActiveState>;
   +options: mixed;
   +_isServer: boolean;
+  requiredFieldLogger: RequiredFieldLogger;
 
   constructor(config: EnvironmentConfig) {
     this.configName = config.configName;
@@ -108,6 +115,8 @@ class RelayModernEnvironment implements IEnvironment {
       : RelayDefaultHandlerProvider;
     this._treatMissingFieldsAsNull = config.treatMissingFieldsAsNull === true;
     const operationLoader = config.operationLoader;
+    const reactFlightPayloadDeserializer =
+      config.reactFlightPayloadDeserializer;
     if (__DEV__) {
       if (operationLoader != null) {
         invariant(
@@ -119,8 +128,18 @@ class RelayModernEnvironment implements IEnvironment {
           operationLoader,
         );
       }
+      if (reactFlightPayloadDeserializer != null) {
+        invariant(
+          typeof reactFlightPayloadDeserializer === 'function',
+          'RelayModernEnvironment: Expected `reactFlightPayloadDeserializer` ' +
+            ' to be a function, got `%s`.',
+          reactFlightPayloadDeserializer,
+        );
+      }
     }
     this.__log = config.log ?? emptyFunction;
+    this.requiredFieldLogger =
+      config.requiredFieldLogger ?? defaultRequiredFieldLogger;
     this._defaultRenderPolicy =
       config.UNSTABLE_defaultRenderPolicy ??
       RelayFeatureFlags.ENABLE_PARTIAL_RENDERING_DEFAULT === true
@@ -162,6 +181,7 @@ class RelayModernEnvironment implements IEnvironment {
     this._missingFieldHandlers = config.missingFieldHandlers;
     this._operationTracker =
       config.operationTracker ?? new RelayOperationTracker();
+    this._reactFlightPayloadDeserializer = reactFlightPayloadDeserializer;
   }
 
   getStore(): Store {
@@ -226,6 +246,7 @@ class RelayModernEnvironment implements IEnvironment {
         operationLoader: this._operationLoader,
         optimisticConfig,
         publishQueue: this._publishQueue,
+        reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
         scheduler: this._scheduler,
         sink,
         source,
@@ -263,6 +284,7 @@ class RelayModernEnvironment implements IEnvironment {
         operationLoader: this._operationLoader,
         optimisticConfig: null,
         publishQueue: this._publishQueue,
+        reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
         scheduler: this._scheduler,
         sink,
         source: RelayObservable.from({
@@ -339,14 +361,11 @@ class RelayModernEnvironment implements IEnvironment {
    */
   execute({
     operation,
-    cacheConfig,
     updater,
-  }: {
+  }: {|
     operation: OperationDescriptor,
-    cacheConfig?: ?CacheConfig,
     updater?: ?SelectorStoreUpdater,
-    ...
-  }): RelayObservable<GraphQLResponse> {
+  |}): RelayObservable<GraphQLResponse> {
     const [logObserver, logRequestInfo] = this.__createLogObserver(
       operation.request.node.params,
       operation.request.variables,
@@ -356,7 +375,7 @@ class RelayModernEnvironment implements IEnvironment {
         .execute(
           operation.request.node.params,
           operation.request.variables,
-          cacheConfig || {},
+          operation.request.cacheConfig || {},
           null,
           logRequestInfo,
         )
@@ -367,6 +386,7 @@ class RelayModernEnvironment implements IEnvironment {
         operationLoader: this._operationLoader,
         optimisticConfig: null,
         publishQueue: this._publishQueue,
+        reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
         scheduler: this._scheduler,
         sink,
         source,
@@ -391,14 +411,12 @@ class RelayModernEnvironment implements IEnvironment {
    * environment.executeMutation({...}).subscribe({...}).
    */
   executeMutation({
-    cacheConfig,
     operation,
     optimisticResponse,
     optimisticUpdater,
     updater,
     uploadables,
   }: {|
-    cacheConfig?: ?CacheConfig,
     operation: OperationDescriptor,
     optimisticUpdater?: ?SelectorStoreUpdater,
     optimisticResponse?: ?Object,
@@ -423,7 +441,7 @@ class RelayModernEnvironment implements IEnvironment {
           operation.request.node.params,
           operation.request.variables,
           {
-            ...cacheConfig,
+            ...operation.request.cacheConfig,
             force: true,
           },
           uploadables,
@@ -436,6 +454,7 @@ class RelayModernEnvironment implements IEnvironment {
         operationLoader: this._operationLoader,
         optimisticConfig,
         publishQueue: this._publishQueue,
+        reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
         scheduler: this._scheduler,
         sink,
         source,
@@ -473,6 +492,7 @@ class RelayModernEnvironment implements IEnvironment {
         operationTracker: this._operationTracker,
         optimisticConfig: null,
         publishQueue: this._publishQueue,
+        reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
         scheduler: this._scheduler,
         sink,
         source,

package/store/RelayModernFragmentSpecResolver.js.flow

@@ -17,6 +17,7 @@ const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 const areEqual = require('areEqual');
 const invariant = require('invariant');
 const isScalarAndEqual = require('../util/isScalarAndEqual');
+const reportMissingRequiredFields = require('../util/reportMissingRequiredFields');
 const warning = require('warning');
 
 const {getPromiseForActiveRequest} = require('../query/fetchQueryInternal');
@@ -34,6 +35,7 @@ import type {
   FragmentMap,
   FragmentSpecResolver,
   FragmentSpecResults,
+  MissingRequiredFields,
   PluralReaderSelector,
   RelayContext,
   SelectorData,
@@ -216,6 +218,7 @@ class SelectorResolver {
   _data: ?SelectorData;
   _environment: IEnvironment;
   _isMissingData: boolean;
+  _missingRequiredFields: ?MissingRequiredFields;
   _selector: SingularReaderSelector;
   _subscription: ?Disposable;
 
@@ -228,6 +231,7 @@ class SelectorResolver {
     this._callback = callback;
     this._data = snapshot.data;
     this._isMissingData = snapshot.isMissingData;
+    this._missingRequiredFields = snapshot.missingRequiredFields;
     this._environment = environment;
     this._selector = selector;
     this._subscription = environment.subscribe(snapshot, this._onChange);
@@ -282,6 +286,12 @@ class SelectorResolver {
         throw promise;
       }
     }
+    if (this._missingRequiredFields != null) {
+      reportMissingRequiredFields(
+        this._environment,
+        this._missingRequiredFields,
+      );
+    }
     return this._data;
   }
 
@@ -296,6 +306,7 @@ class SelectorResolver {
     const snapshot = this._environment.lookup(selector);
     this._data = snapshot.data;
     this._isMissingData = snapshot.isMissingData;
+    this._missingRequiredFields = snapshot.missingRequiredFields;
     this._selector = selector;
     this._subscription = this._environment.subscribe(snapshot, this._onChange);
   }
@@ -314,7 +325,7 @@ class SelectorResolver {
     // NOTE: We manually create the request descriptor here instead of
     // calling createOperationDescriptor() because we want to set a
     // descriptor with *unaltered* variables as the fragment owner.
-    // This is a hack that allows us to preserve exisiting (broken)
+    // This is a hack that allows us to preserve existing (broken)
     // behavior of RelayModern containers while using fragment ownership
     // to propagate variables instead of Context.
     // For more details, see the summary of D13999308
@@ -331,6 +342,7 @@ class SelectorResolver {
   _onChange = (snapshot: Snapshot): void => {
     this._data = snapshot.data;
     this._isMissingData = snapshot.isMissingData;
+    this._missingRequiredFields = snapshot.missingRequiredFields;
     this._callback();
   };
 }

package/store/RelayModernOperationDescriptor.js.flow

@@ -23,7 +23,7 @@ const {
 const {ROOT_ID} = require('./RelayStoreUtils');
 
 import type {ConcreteRequest} from '../util/RelayConcreteNode';
-import type {DataID, Variables} from '../util/RelayRuntimeTypes';
+import type {CacheConfig, DataID, Variables} from '../util/RelayRuntimeTypes';
 import type {OperationDescriptor, RequestDescriptor} from './RelayStoreTypes';
 
 /**
@@ -35,6 +35,7 @@ import type {OperationDescriptor, RequestDescriptor} from './RelayStoreTypes';
 function createOperationDescriptor(
   request: ConcreteRequest,
   variables: Variables,
+  cacheConfig?: ?CacheConfig,
   dataID?: DataID = ROOT_ID,
 ): OperationDescriptor {
   const operation = request.operation;
@@ -42,6 +43,7 @@ function createOperationDescriptor(
   const requestDescriptor = createRequestDescriptor(
     request,
     operationVariables,
+    cacheConfig,
   );
   const operationDescriptor = {
     fragment: createReaderSelector(
@@ -68,11 +70,13 @@ function createOperationDescriptor(
 function createRequestDescriptor(
   request: ConcreteRequest,
   variables: Variables,
+  cacheConfig?: ?CacheConfig,
 ): RequestDescriptor {
   const requestDescriptor = {
     identifier: getRequestIdentifier(request.params, variables),
     node: request,
     variables: variables,
+    cacheConfig: cacheConfig,
   };
   if (__DEV__) {
     deepFreeze(variables);

package/store/RelayModernQueryExecutor.js.flow

@@ -19,6 +19,7 @@ const RelayObservable = require('../network/RelayObservable');
 const RelayRecordSource = require('./RelayRecordSource');
 const RelayResponseNormalizer = require('./RelayResponseNormalizer');
 
+const getOperation = require('../util/getOperation');
 const invariant = require('invariant');
 const stableCopy = require('../util/stableCopy');
 const warning = require('warning');
@@ -46,6 +47,7 @@ import type {
   OptimisticResponseConfig,
   OptimisticUpdate,
   PublishQueue,
+  ReactFlightPayloadDeserializer,
   Record,
   RelayResponsePayload,
   SelectorStoreUpdater,
@@ -54,10 +56,12 @@ import type {
 } from '../store/RelayStoreTypes';
 import type {
   NormalizationLinkedField,
-  NormalizationSplitOperation,
+  NormalizationOperation,
+  NormalizationRootNode,
   NormalizationSelectableNode,
+  NormalizationSplitOperation,
 } from '../util/NormalizationNode';
-import type {DataID, Variables} from '../util/RelayRuntimeTypes';
+import type {DataID, Variables, Disposable} from '../util/RelayRuntimeTypes';
 import type {GetDataID} from './RelayResponseNormalizer';
 import type {NormalizationOptions} from './RelayResponseNormalizer';
 
@@ -70,6 +74,7 @@ export type ExecuteConfig = {|
   +operationTracker?: ?OperationTracker,
   +optimisticConfig: ?OptimisticResponseConfig,
   +publishQueue: PublishQueue,
+  +reactFlightPayloadDeserializer?: ?ReactFlightPayloadDeserializer,
   +scheduler?: ?TaskScheduler,
   +sink: Sink<GraphQLResponse>,
   +source: RelayObservable<GraphQLResponse>,
@@ -126,6 +131,7 @@ class Executor {
   _optimisticUpdates: null | Array<OptimisticUpdate>;
   _pendingModulePayloadsCount: number;
   _publishQueue: PublishQueue;
+  _reactFlightPayloadDeserializer: ?ReactFlightPayloadDeserializer;
   _scheduler: ?TaskScheduler;
   _sink: Sink<GraphQLResponse>;
   _source: Map<
@@ -136,6 +142,7 @@ class Executor {
   _store: Store;
   _subscriptions: Map<number, Subscription>;
   _updater: ?SelectorStoreUpdater;
+  _retainDisposable: ?Disposable;
   +_isClientPayload: boolean;
 
   constructor({
@@ -153,6 +160,7 @@ class Executor {
     treatMissingFieldsAsNull,
     getDataID,
     isClientPayload,
+    reactFlightPayloadDeserializer,
   }: ExecuteConfig): void {
     this._getDataID = getDataID;
     this._treatMissingFieldsAsNull = treatMissingFieldsAsNull;
@@ -175,6 +183,7 @@ class Executor {
     this._subscriptions = new Map();
     this._updater = updater;
     this._isClientPayload = isClientPayload === true;
+    this._reactFlightPayloadDeserializer = reactFlightPayloadDeserializer;
 
     const id = this._nextSubscriptionId++;
     source.subscribe({
@@ -223,6 +232,10 @@ class Executor {
     }
     this._incrementalResults.clear();
     this._completeOperationTracker();
+    if (this._retainDisposable) {
+      this._retainDisposable.dispose();
+      this._retainDisposable = null;
+    }
   }
 
   _updateActiveState(): void {
@@ -423,19 +436,22 @@ class Executor {
 
     // In theory this doesn't preserve the ordering of the batch.
     // The idea is that a batch is always:
-    //  * at-most one non-incremental payload
-    //  * followed zero or more incremental payloads
+    //  * at most one non-incremental payload
+    //  * followed by zero or more incremental payloads
     // The non-incremental payload can appear if the server sends a batch
-    // w the initial payload followed by some early-to-resolve incremental
+    // with the initial payload followed by some early-to-resolve incremental
     // payloads (although, can that even happen?)
     if (nonIncrementalResponses.length > 0) {
       const payloadFollowups = this._processResponses(nonIncrementalResponses);
-      // Please note, that we're passing `this._operation` to the publish
+      // Please note that we're passing `this._operation` to the publish
       // queue here, which will later passed to the store (via notify)
-      // to indicate that this is an operation that cause the store to update
+      // to indicate that this is an operation that caused the store to update
       const updatedOwners = this._publishQueue.run(this._operation);
       this._updateOperationTracker(updatedOwners);
       this._processPayloadFollowups(payloadFollowups);
+      if (this._incrementalPayloadsPending && !this._retainDisposable) {
+        this._retainDisposable = this._store.retain(this._operation);
+      }
     }
 
     if (incrementalResponses.length > 0) {
@@ -474,6 +490,7 @@ class Executor {
         {
           getDataID: this._getDataID,
           path: [],
+          reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
           treatMissingFieldsAsNull,
         },
       );
@@ -525,11 +542,11 @@ class Executor {
             moduleImportPayload,
           );
         } else {
-          const moduleImportOptimisitcUpdates = this._processOptimisticModuleImport(
+          const moduleImportOptimisticUpdates = this._processOptimisticModuleImport(
             operation,
             moduleImportPayload,
           );
-          optimisticUpdates.push(...moduleImportOptimisitcUpdates);
+          optimisticUpdates.push(...moduleImportOptimisticUpdates);
         }
       }
     }
@@ -551,15 +568,17 @@ class Executor {
       {
         getDataID: this._getDataID,
         path: moduleImportPayload.path,
+        reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       },
     );
   }
 
   _processOptimisticModuleImport(
-    operation: NormalizationSplitOperation,
+    normalizationRootNode: NormalizationRootNode,
     moduleImportPayload: ModuleImportPayload,
   ): $ReadOnlyArray<OptimisticUpdate> {
+    const operation = getOperation(normalizationRootNode);
     const optimisticUpdates = [];
     const modulePayload = this._normalizeModuleImport(
       moduleImportPayload,
@@ -585,22 +604,22 @@ class Executor {
         if (operation == null || this._state !== 'started') {
           return;
         }
-        const moduleImportOptimisitcUpdates = this._processOptimisticModuleImport(
+        const moduleImportOptimisticUpdates = this._processOptimisticModuleImport(
           operation,
           moduleImportPayload,
         );
-        moduleImportOptimisitcUpdates.forEach(update =>
+        moduleImportOptimisticUpdates.forEach(update =>
           this._publishQueue.applyUpdate(update),
         );
         if (this._optimisticUpdates == null) {
           warning(
             false,
-            'RelayModernQueryExecutor: Unexpected ModuleImport optimisitc ' +
+            'RelayModernQueryExecutor: Unexpected ModuleImport optimistic ' +
               'update in operation %s.' +
               this._operation.request.node.params.name,
           );
         } else {
-          this._optimisticUpdates.push(...moduleImportOptimisitcUpdates);
+          this._optimisticUpdates.push(...moduleImportOptimisticUpdates);
           this._publishQueue.run();
         }
       });
@@ -624,8 +643,9 @@ class Executor {
         ROOT_TYPE,
         {
           getDataID: this._getDataID,
-          treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
           path: [],
+          reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
+          treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         },
       );
       this._publishQueue.commitPayload(
@@ -737,13 +757,12 @@ class Executor {
     moduleImportPayload: ModuleImportPayload,
     operationLoader: OperationLoader,
   ): void {
-    const syncOperation = operationLoader.get(
-      moduleImportPayload.operationReference,
-    );
-    if (syncOperation != null) {
+    const node = operationLoader.get(moduleImportPayload.operationReference);
+    if (node != null) {
+      const operation = getOperation(node);
       // If the operation module is available synchronously, normalize the
       // data synchronously.
-      this._handleModuleImportPayload(moduleImportPayload, syncOperation);
+      this._handleModuleImportPayload(moduleImportPayload, operation);
       this._maybeCompleteSubscriptionOperationTracking();
     } else {
       // Otherwise load the operation module and schedule a task to normalize
@@ -766,10 +785,13 @@ class Executor {
             .then(resolve, reject);
         }),
       )
-        .map((operation: ?NormalizationSplitOperation) => {
+        .map((operation: ?NormalizationRootNode) => {
           if (operation != null) {
             this._schedule(() => {
-              this._handleModuleImportPayload(moduleImportPayload, operation);
+              this._handleModuleImportPayload(
+                moduleImportPayload,
+                getOperation(operation),
+              );
             });
           }
         })
@@ -789,7 +811,7 @@ class Executor {
 
   _handleModuleImportPayload(
     moduleImportPayload: ModuleImportPayload,
-    operation: NormalizationSplitOperation,
+    operation: NormalizationSplitOperation | NormalizationOperation,
   ): void {
     const relayPayload = this._normalizeModuleImport(
       moduleImportPayload,
@@ -997,6 +1019,7 @@ class Executor {
       {
         getDataID: this._getDataID,
         path: placeholder.path,
+        reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       },
     );
@@ -1211,6 +1234,7 @@ class Executor {
     const relayPayload = normalizeResponse(response, selector, typeName, {
       getDataID: this._getDataID,
       path: [...normalizationPath, responseKey, String(itemIndex)],
+      reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
       treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
     });
     return {