relay-runtime 11.0.2 → 12.0.0

package/store/OperationExecutor.js.flow

@@ -20,29 +20,36 @@ const RelayObservable = require('../network/RelayObservable');
 const RelayRecordSource = require('./RelayRecordSource');
 const RelayResponseNormalizer = require('./RelayResponseNormalizer');
 
+const generateID = require('../util/generateID');
 const getOperation = require('../util/getOperation');
 const invariant = require('invariant');
 const stableCopy = require('../util/stableCopy');
 const warning = require('warning');
+const withDuration = require('../util/withDuration');
 
 const {generateClientID, generateUniqueClientID} = require('./ClientID');
+const {getLocalVariables} = require('./RelayConcreteVariables');
 const {
   createNormalizationSelector,
   createReaderSelector,
 } = require('./RelayModernSelector');
 const {ROOT_TYPE, TYPENAME_KEY, getStorageKey} = require('./RelayStoreUtils');
 
+import type {ActorIdentifier} from '../multi-actor-environment/ActorIdentifier';
 import type {
   GraphQLResponse,
   GraphQLSingularResponse,
   GraphQLResponseWithData,
+  ReactFlightServerTree,
 } from '../network/RelayNetworkTypes';
 import type {Sink, Subscription} from '../network/RelayObservable';
 import type {
   DeferPlaceholder,
+  FollowupPayload,
   RequestDescriptor,
   HandleFieldPayload,
   IncrementalDataPlaceholder,
+  LogFunction,
   ModuleImportPayload,
   NormalizationSelector,
   OperationDescriptor,
@@ -53,6 +60,7 @@ import type {
   PublishQueue,
   ReactFlightPayloadDeserializer,
   ReactFlightServerErrorHandler,
+  ReactFlightClientResponse,
   Record,
   RelayResponsePayload,
   SelectorStoreUpdater,
@@ -71,23 +79,25 @@ import type {GetDataID} from './RelayResponseNormalizer';
 import type {NormalizationOptions} from './RelayResponseNormalizer';
 
 export type ExecuteConfig = {|
+  +actorIdentifier: ActorIdentifier,
   +getDataID: GetDataID,
-  +treatMissingFieldsAsNull: boolean,
+  +getPublishQueue: (actorIdentifier: ActorIdentifier) => PublishQueue,
+  +getStore: (actorIdentifier: ActorIdentifier) => Store,
+  +isClientPayload?: boolean,
   +operation: OperationDescriptor,
   +operationExecutions: Map<string, ActiveState>,
   +operationLoader: ?OperationLoader,
   +operationTracker: OperationTracker,
   +optimisticConfig: ?OptimisticResponseConfig,
-  +publishQueue: PublishQueue,
   +reactFlightPayloadDeserializer?: ?ReactFlightPayloadDeserializer,
   +reactFlightServerErrorHandler?: ?ReactFlightServerErrorHandler,
   +scheduler?: ?TaskScheduler,
+  +shouldProcessClientComponents?: ?boolean,
   +sink: Sink<GraphQLResponse>,
   +source: RelayObservable<GraphQLResponse>,
-  +store: Store,
+  +treatMissingFieldsAsNull: boolean,
   +updater?: ?SelectorStoreUpdater,
-  +isClientPayload?: boolean,
-  +shouldProcessClientComponents?: ?boolean,
+  +log: LogFunction,
 |};
 
 export type ActiveState = 'active' | 'inactive';
@@ -125,10 +135,13 @@ function execute(config: ExecuteConfig): Executor {
  * dependencies, etc.
  */
 class Executor {
+  _actorIdentifier: ActorIdentifier;
   _getDataID: GetDataID;
   _treatMissingFieldsAsNull: boolean;
   _incrementalPayloadsPending: boolean;
   _incrementalResults: Map<Label, Map<PathKey, IncrementalResults>>;
+  _log: LogFunction;
+  _executeId: number;
   _nextSubscriptionId: number;
   _operation: OperationDescriptor;
   _operationExecutions: Map<string, ActiveState>;
@@ -137,7 +150,7 @@ class Executor {
   _operationUpdateEpochs: Map<string, number>;
   _optimisticUpdates: null | Array<OptimisticUpdate>;
   _pendingModulePayloadsCount: number;
-  _publishQueue: PublishQueue;
+  +_getPublishQueue: (actorIdentifier: ActorIdentifier) => PublishQueue;
   _reactFlightPayloadDeserializer: ?ReactFlightPayloadDeserializer;
   _reactFlightServerErrorHandler: ?ReactFlightServerErrorHandler;
   _shouldProcessClientComponents: ?boolean;
@@ -148,36 +161,44 @@ class Executor {
     {|+record: Record, +fieldPayloads: Array<HandleFieldPayload>|},
   >;
   _state: 'started' | 'loading_incremental' | 'loading_final' | 'completed';
-  _store: Store;
+  +_getStore: (actorIdentifier: ActorIdentifier) => Store;
   _subscriptions: Map<number, Subscription>;
   _updater: ?SelectorStoreUpdater;
-  _retainDisposable: ?Disposable;
+  _asyncStoreUpdateDisposable: ?Disposable;
+  _completeFns: Array<() => void>;
+  +_retainDisposables: Map<ActorIdentifier, Disposable>;
   +_isClientPayload: boolean;
   +_isSubscriptionOperation: boolean;
+  +_seenActors: Set<ActorIdentifier>;
 
   constructor({
+    actorIdentifier,
+    getDataID,
+    getPublishQueue,
+    getStore,
+    isClientPayload,
     operation,
     operationExecutions,
     operationLoader,
+    operationTracker,
     optimisticConfig,
-    publishQueue,
+    reactFlightPayloadDeserializer,
+    reactFlightServerErrorHandler,
     scheduler,
+    shouldProcessClientComponents,
     sink,
     source,
-    store,
-    updater,
-    operationTracker,
     treatMissingFieldsAsNull,
-    getDataID,
-    isClientPayload,
-    reactFlightPayloadDeserializer,
-    reactFlightServerErrorHandler,
-    shouldProcessClientComponents,
+    updater,
+    log,
   }: ExecuteConfig): void {
+    this._actorIdentifier = actorIdentifier;
     this._getDataID = getDataID;
     this._treatMissingFieldsAsNull = treatMissingFieldsAsNull;
     this._incrementalPayloadsPending = false;
     this._incrementalResults = new Map();
+    this._log = log;
+    this._executeId = generateID();
     this._nextSubscriptionId = 0;
     this._operation = operation;
     this._operationExecutions = operationExecutions;
@@ -186,12 +207,12 @@ class Executor {
     this._operationUpdateEpochs = new Map();
     this._optimisticUpdates = null;
     this._pendingModulePayloadsCount = 0;
-    this._publishQueue = publishQueue;
+    this._getPublishQueue = getPublishQueue;
     this._scheduler = scheduler;
     this._sink = sink;
     this._source = new Map();
     this._state = 'started';
-    this._store = store;
+    this._getStore = getStore;
     this._subscriptions = new Map();
     this._updater = updater;
     this._isClientPayload = isClientPayload === true;
@@ -200,6 +221,9 @@ class Executor {
     this._isSubscriptionOperation =
       this._operation.request.node.params.operationKind === 'subscription';
     this._shouldProcessClientComponents = shouldProcessClientComponents;
+    this._retainDisposables = new Map();
+    this._seenActors = new Set();
+    this._completeFns = [];
 
     const id = this._nextSubscriptionId++;
     source.subscribe({
@@ -212,7 +236,16 @@ class Executor {
           sink.error(error);
         }
       },
-      start: subscription => this._start(id, subscription),
+      start: subscription => {
+        this._start(id, subscription);
+        this._log({
+          name: 'execute.start',
+          executeId: this._executeId,
+          params: this._operation.request.node.params,
+          variables: this._operation.request.variables,
+          cacheConfig: this._operation.request.cacheConfig ?? {},
+        });
+      },
     });
 
     if (optimisticConfig != null) {
@@ -242,19 +275,41 @@ class Executor {
     if (optimisticUpdates !== null) {
       this._optimisticUpdates = null;
       optimisticUpdates.forEach(update =>
-        this._publishQueue.revertUpdate(update),
+        this._getPublishQueueAndSaveActor().revertUpdate(update),
       );
       // OK: run revert on cancel
-      this._publishQueue.run();
+      this._runPublishQueue();
     }
     this._incrementalResults.clear();
-    this._completeOperationTracker();
-    if (this._retainDisposable) {
-      this._retainDisposable.dispose();
-      this._retainDisposable = null;
+    if (this._asyncStoreUpdateDisposable != null) {
+      this._asyncStoreUpdateDisposable.dispose();
+      this._asyncStoreUpdateDisposable = null;
     }
+    this._completeFns = [];
+    this._completeOperationTracker();
+    this._disposeRetainedData();
   }
 
+  _deserializeReactFlightPayloadWithLogging = (
+    tree: ReactFlightServerTree,
+  ): ReactFlightClientResponse => {
+    const reactFlightPayloadDeserializer = this._reactFlightPayloadDeserializer;
+    invariant(
+      typeof reactFlightPayloadDeserializer === 'function',
+      'OperationExecutor: Expected reactFlightPayloadDeserializer to be available when calling _deserializeReactFlightPayloadWithLogging.',
+    );
+    const [duration, result] = withDuration(() => {
+      return reactFlightPayloadDeserializer(tree);
+    });
+    this._log({
+      name: 'execute.flight.payload_deserialize',
+      executeId: this._executeId,
+      operationName: this._operation.request.node.params.name,
+      duration,
+    });
+    return result;
+  };
+
   _updateActiveState(): void {
     let activeState;
     switch (this._state) {
@@ -314,12 +369,21 @@ class Executor {
     if (this._subscriptions.size === 0) {
       this.cancel();
       this._sink.complete();
+      this._log({
+        name: 'execute.complete',
+        executeId: this._executeId,
+      });
     }
   }
 
   _error(error: Error): void {
     this.cancel();
     this._sink.error(error);
+    this._log({
+      name: 'execute.error',
+      executeId: this._executeId,
+      error,
+    });
   }
 
   _start(id: number, subscription: Subscription): void {
@@ -330,8 +394,16 @@ class Executor {
   // Handle a raw GraphQL response.
   _next(_id: number, response: GraphQLResponse): void {
     this._schedule(() => {
-      this._handleNext(response);
-      this._maybeCompleteSubscriptionOperationTracking();
+      const [duration] = withDuration(() => {
+        this._handleNext(response);
+        this._maybeCompleteSubscriptionOperationTracking();
+      });
+      this._log({
+        name: 'execute.next',
+        executeId: this._executeId,
+        response,
+        duration,
+      });
     });
   }
 
@@ -395,7 +467,10 @@ class Executor {
           responsePart => responsePart.extensions?.isOptimistic === true,
         )
       ) {
-        invariant(false, 'Optimistic responses cannot be batched.');
+        invariant(
+          false,
+          'OperationExecutor: Optimistic responses cannot be batched.',
+        );
       }
       return false;
     }
@@ -423,6 +498,7 @@ class Executor {
     if (this._state === 'completed') {
       return;
     }
+    this._seenActors.clear();
 
     const responses = Array.isArray(response) ? response : [response];
     const responsesWithData = this._handleErrorResponse(responses);
@@ -460,39 +536,39 @@ class Executor {
     // with the initial payload followed by some early-to-resolve incremental
     // payloads (although, can that even happen?)
     if (hasNonIncrementalResponses) {
-      const payloadFollowups = this._processResponses(nonIncrementalResponses);
-
-      if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
-        const updatedOwners = this._publishQueue.run(this._operation);
-        this._updateOperationTracker(updatedOwners);
+      // For subscriptions, to avoid every new payload from overwriting existing
+      // data from previous payloads, assign a unique rootID for every new
+      // non-incremental payload.
+      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,
+          ),
+          root: createNormalizationSelector(
+            this._operation.root.node,
+            nextID,
+            this._operation.root.variables,
+          ),
+        };
       }
 
+      const payloadFollowups = this._processResponses(nonIncrementalResponses);
       this._processPayloadFollowups(payloadFollowups);
-
-      if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
-        if (this._incrementalPayloadsPending && !this._retainDisposable) {
-          this._retainDisposable = this._store.retain(this._operation);
-        }
-      }
     }
 
     if (incrementalResponses.length > 0) {
       const payloadFollowups = this._processIncrementalResponses(
         incrementalResponses,
       );
-      if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
-        // For the incremental case, we're only handling follow-up responses
-        // for already initiated operation (and we're not passing it to
-        // the run(...) call)
-        const updatedOwners = this._publishQueue.run();
-        this._updateOperationTracker(updatedOwners);
-      }
+
       this._processPayloadFollowups(payloadFollowups);
     }
-    if (
-      this._isSubscriptionOperation &&
-      RelayFeatureFlags.ENABLE_UNIQUE_SUBSCRIPTION_ROOT
-    ) {
+    if (this._isSubscriptionOperation) {
       // We attach the id to allow the `requestSubscription` to read from the store using
       // the current id in its `onNext` callback
       if (responsesWithData[0].extensions == null) {
@@ -505,21 +581,20 @@ class Executor {
       }
     }
 
-    if (RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
-      // OK: run once after each new payload
-      // If we have non-incremental responses, we passing `this._operation` to
-      // 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._publishQueue.run(
-        hasNonIncrementalResponses ? this._operation : undefined,
-      );
-      if (hasNonIncrementalResponses) {
-        if (this._incrementalPayloadsPending && !this._retainDisposable) {
-          this._retainDisposable = this._store.retain(this._operation);
-        }
+    // OK: run once after each new payload
+    // If we have non-incremental responses, we passing `this._operation` to
+    // 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,
+    );
+
+    if (hasNonIncrementalResponses) {
+      if (this._incrementalPayloadsPending) {
+        this._retainData();
       }
-      this._updateOperationTracker(updatedOwners);
     }
+    this._updateOperationTracker(updatedOwners);
     this._sink.next(response);
   }
 
@@ -530,7 +605,7 @@ class Executor {
   ): void {
     invariant(
       this._optimisticUpdates === null,
-      'environment.execute: only support one optimistic response per ' +
+      'OperationExecutor: environment.execute: only support one optimistic response per ' +
         'execute.',
     );
     if (response == null && updater == null) {
@@ -543,9 +618,13 @@ class Executor {
         this._operation.root,
         ROOT_TYPE,
         {
+          actorIdentifier: this._actorIdentifier,
           getDataID: this._getDataID,
           path: [],
-          reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
+          reactFlightPayloadDeserializer:
+            this._reactFlightPayloadDeserializer != null
+              ? this._deserializeReactFlightPayloadWithLogging
+              : null,
           reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,
           shouldProcessClientComponents: this._shouldProcessClientComponents,
           treatMissingFieldsAsNull,
@@ -565,7 +644,7 @@ class Executor {
           errors: null,
           fieldPayloads: null,
           incrementalPlaceholders: null,
-          moduleImportPayloads: null,
+          followupPayloads: null,
           source: RelayRecordSource.create(),
           isFinal: false,
         },
@@ -573,61 +652,92 @@ class Executor {
       });
     }
     this._optimisticUpdates = optimisticUpdates;
-    optimisticUpdates.forEach(update => this._publishQueue.applyUpdate(update));
+    optimisticUpdates.forEach(update =>
+      this._getPublishQueueAndSaveActor().applyUpdate(update),
+    );
     // OK: only called on construction and when receiving an optimistic payload from network,
     // which doesn't fall-through to the regular next() handling
-    this._publishQueue.run();
+    this._runPublishQueue();
   }
 
   _processOptimisticFollowups(
     payload: RelayResponsePayload,
     optimisticUpdates: Array<OptimisticUpdate>,
   ): void {
-    if (payload.moduleImportPayloads && payload.moduleImportPayloads.length) {
-      const moduleImportPayloads = payload.moduleImportPayloads;
-      const operationLoader = this._operationLoader;
-      invariant(
-        operationLoader,
-        'RelayModernEnvironment: Expected an operationLoader to be ' +
-          'configured when using `@match`.',
-      );
-      for (const moduleImportPayload of moduleImportPayloads) {
-        const operation = operationLoader.get(
-          moduleImportPayload.operationReference,
-        );
-        if (operation == null) {
-          this._processAsyncOptimisticModuleImport(
-            operationLoader,
-            moduleImportPayload,
-          );
-        } else {
-          const moduleImportOptimisticUpdates = this._processOptimisticModuleImport(
-            operation,
-            moduleImportPayload,
-          );
-          optimisticUpdates.push(...moduleImportOptimisticUpdates);
+    if (payload.followupPayloads && payload.followupPayloads.length) {
+      const followupPayloads = payload.followupPayloads;
+      for (const followupPayload of followupPayloads) {
+        switch (followupPayload.kind) {
+          case 'ModuleImportPayload':
+            const operationLoader = this._expectOperationLoader();
+            const operation = operationLoader.get(
+              followupPayload.operationReference,
+            );
+            if (operation == null) {
+              this._processAsyncOptimisticModuleImport(followupPayload);
+            } else {
+              const moduleImportOptimisticUpdates = this._processOptimisticModuleImport(
+                operation,
+                followupPayload,
+              );
+              optimisticUpdates.push(...moduleImportOptimisticUpdates);
+            }
+            break;
+          case 'ActorPayload':
+            warning(
+              false,
+              'OperationExecutor: Unexpected optimistic ActorPayload. These updates are not supported.',
+            );
+            break;
+          default:
+            (followupPayload: empty);
+            invariant(
+              false,
+              'OperationExecutor: Unexpected followup kind `%s`. when processing optimistic updates.',
+              followupPayload.kind,
+            );
         }
       }
     }
   }
 
-  _normalizeModuleImport(
-    moduleImportPayload: ModuleImportPayload,
-    operation: NormalizationSelectableNode,
+  /**
+   * Normalize Data for @module payload, and actor-specific payload
+   */
+  _normalizeFollowupPayload(
+    followupPayload: FollowupPayload,
+    normalizationNode: NormalizationSelectableNode,
   ) {
+    let variables;
+    if (
+      normalizationNode.kind === 'SplitOperation' &&
+      followupPayload.kind === 'ModuleImportPayload'
+    ) {
+      variables = getLocalVariables(
+        followupPayload.variables,
+        normalizationNode.argumentDefinitions,
+        followupPayload.args,
+      );
+    } else {
+      variables = followupPayload.variables;
+    }
     const selector = createNormalizationSelector(
-      operation,
-      moduleImportPayload.dataID,
-      moduleImportPayload.variables,
+      normalizationNode,
+      followupPayload.dataID,
+      variables,
     );
     return normalizeResponse(
-      {data: moduleImportPayload.data},
+      {data: followupPayload.data},
       selector,
-      moduleImportPayload.typeName,
+      followupPayload.typeName,
       {
+        actorIdentifier: this._actorIdentifier,
         getDataID: this._getDataID,
-        path: moduleImportPayload.path,
-        reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
+        path: followupPayload.path,
+        reactFlightPayloadDeserializer:
+          this._reactFlightPayloadDeserializer != null
+            ? this._deserializeReactFlightPayloadWithLogging
+            : null,
         reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         shouldProcessClientComponents: this._shouldProcessClientComponents,
@@ -641,7 +751,7 @@ class Executor {
   ): $ReadOnlyArray<OptimisticUpdate> {
     const operation = getOperation(normalizationRootNode);
     const optimisticUpdates = [];
-    const modulePayload = this._normalizeModuleImport(
+    const modulePayload = this._normalizeFollowupPayload(
       moduleImportPayload,
       operation,
     );
@@ -656,10 +766,9 @@ class Executor {
   }
 
   _processAsyncOptimisticModuleImport(
-    operationLoader: OperationLoader,
     moduleImportPayload: ModuleImportPayload,
   ): void {
-    operationLoader
+    this._expectOperationLoader()
       .load(moduleImportPayload.operationReference)
       .then(operation => {
         if (operation == null || this._state !== 'started') {
@@ -670,7 +779,7 @@ class Executor {
           moduleImportPayload,
         );
         moduleImportOptimisticUpdates.forEach(update =>
-          this._publishQueue.applyUpdate(update),
+          this._getPublishQueueAndSaveActor().applyUpdate(update),
         );
         if (this._optimisticUpdates == null) {
           warning(
@@ -682,16 +791,18 @@ class Executor {
         } else {
           this._optimisticUpdates.push(...moduleImportOptimisticUpdates);
           // OK: always have to run() after an module import resolves async
-          this._publishQueue.run();
+          this._runPublishQueue();
         }
       });
   }
 
-  _processResponses(responses: $ReadOnlyArray<GraphQLResponseWithData>) {
+  _processResponses(
+    responses: $ReadOnlyArray<GraphQLResponseWithData>,
+  ): $ReadOnlyArray<RelayResponsePayload> {
     if (this._optimisticUpdates !== null) {
-      this._optimisticUpdates.forEach(update =>
-        this._publishQueue.revertUpdate(update),
-      );
+      this._optimisticUpdates.forEach(update => {
+        this._getPublishQueueAndSaveActor().revertUpdate(update);
+      });
       this._optimisticUpdates = null;
     }
 
@@ -704,19 +815,24 @@ class Executor {
         this._operation.root,
         ROOT_TYPE,
         {
+          actorIdentifier: this._actorIdentifier,
           getDataID: this._getDataID,
           path: [],
-          reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
+          reactFlightPayloadDeserializer:
+            this._reactFlightPayloadDeserializer != null
+              ? this._deserializeReactFlightPayloadWithLogging
+              : null,
           reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,
           treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
           shouldProcessClientComponents: this._shouldProcessClientComponents,
         },
       );
-      this._publishQueue.commitPayload(
+      this._getPublishQueueAndSaveActor().commitPayload(
         this._operation,
         relayPayload,
         this._updater,
       );
+
       return relayPayload;
     });
   }
@@ -732,30 +848,30 @@ class Executor {
       return;
     }
     payloads.forEach(payload => {
-      const {incrementalPlaceholders, moduleImportPayloads, isFinal} = payload;
+      const {incrementalPlaceholders, followupPayloads, isFinal} = payload;
       this._state = isFinal ? 'loading_final' : 'loading_incremental';
       this._updateActiveState();
       if (isFinal) {
         this._incrementalPayloadsPending = false;
       }
-      if (moduleImportPayloads && moduleImportPayloads.length !== 0) {
-        const operationLoader = this._operationLoader;
-        invariant(
-          operationLoader,
-          'RelayModernEnvironment: Expected an operationLoader to be ' +
-            'configured when using `@match`.',
-        );
-        moduleImportPayloads.forEach(moduleImportPayload => {
-          this._processModuleImportPayload(
-            moduleImportPayload,
-            operationLoader,
-          );
+      if (followupPayloads && followupPayloads.length !== 0) {
+        followupPayloads.forEach(followupPayload => {
+          const prevActorIdentifier = this._actorIdentifier;
+          this._actorIdentifier =
+            followupPayload.actorIdentifier ?? this._actorIdentifier;
+          this._processFollowupPayload(followupPayload);
+          this._actorIdentifier = prevActorIdentifier;
         });
       }
+
       if (incrementalPlaceholders && incrementalPlaceholders.length !== 0) {
         this._incrementalPayloadsPending = this._state !== 'loading_final';
         incrementalPlaceholders.forEach(incrementalPlaceholder => {
+          const prevActorIdentifier = this._actorIdentifier;
+          this._actorIdentifier =
+            incrementalPlaceholder.actorIdentifier ?? this._actorIdentifier;
           this._processIncrementalPlaceholder(payload, incrementalPlaceholder);
+          this._actorIdentifier = prevActorIdentifier;
         });
 
         if (this._isClientPayload || this._state === 'loading_final') {
@@ -787,10 +903,6 @@ class Executor {
             }
           });
           if (relayPayloads.length > 0) {
-            if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
-              const updatedOwners = this._publishQueue.run();
-              this._updateOperationTracker(updatedOwners);
-            }
             this._processPayloadFollowups(relayPayloads);
           }
         }
@@ -808,23 +920,6 @@ class Executor {
     ) {
       this._completeOperationTracker();
     }
-    if (RelayFeatureFlags.ENABLE_UNIQUE_SUBSCRIPTION_ROOT) {
-      const nextID = generateUniqueClientID();
-      this._operation = {
-        request: this._operation.request,
-        fragment: createReaderSelector(
-          this._operation.fragment.node,
-          nextID,
-          this._operation.fragment.variables,
-          this._operation.fragment.owner,
-        ),
-        root: createNormalizationSelector(
-          this._operation.root.node,
-          nextID,
-          this._operation.root.variables,
-        ),
-      };
-    }
   }
 
   /**
@@ -834,78 +929,154 @@ class Executor {
    * defer, stream, etc); these are handled by calling
    * `_processPayloadFollowups()`.
    */
-  _processModuleImportPayload(
-    moduleImportPayload: ModuleImportPayload,
-    operationLoader: OperationLoader,
-  ): void {
-    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, operation);
-      this._maybeCompleteSubscriptionOperationTracking();
-    } else {
-      // Otherwise load the operation module and schedule a task to normalize
-      // the data when the module is available.
-      const id = this._nextSubscriptionId++;
-      this._pendingModulePayloadsCount++;
-
-      const decrementPendingCount = () => {
-        this._pendingModulePayloadsCount--;
-        this._maybeCompleteSubscriptionOperationTracking();
-      };
-
-      // Observable.from(operationLoader.load()) wouldn't catch synchronous
-      // errors thrown by the load function, which is user-defined. Guard
-      // against that with Observable.from(new Promise(<work>)).
-      RelayObservable.from(
-        new Promise((resolve, reject) => {
-          operationLoader
-            .load(moduleImportPayload.operationReference)
-            .then(resolve, reject);
-        }),
-      )
-        .map((operation: ?NormalizationRootNode) => {
-          if (operation != null) {
-            this._schedule(() => {
-              this._handleModuleImportPayload(
-                moduleImportPayload,
-                getOperation(operation),
-              );
-              // OK: always have to run after an async module import resolves
-              const updatedOwners = this._publishQueue.run();
-              this._updateOperationTracker(updatedOwners);
+  _processFollowupPayload(followupPayload: FollowupPayload): void {
+    switch (followupPayload.kind) {
+      case 'ModuleImportPayload':
+        const operationLoader = this._expectOperationLoader();
+        const node = operationLoader.get(followupPayload.operationReference);
+        if (node != null) {
+          // If the operation module is available synchronously, normalize the
+          // data synchronously.
+          this._processFollowupPayloadWithNormalizationNode(
+            followupPayload,
+            getOperation(node),
+          );
+        } else {
+          // Otherwise load the operation module and schedule a task to normalize
+          // the data when the module is available.
+          const id = this._nextSubscriptionId++;
+          this._pendingModulePayloadsCount++;
+
+          const decrementPendingCount = () => {
+            this._pendingModulePayloadsCount--;
+            this._maybeCompleteSubscriptionOperationTracking();
+          };
+
+          // Observable.from(operationLoader.load()) wouldn't catch synchronous
+          // errors thrown by the load function, which is user-defined. Guard
+          // against that with Observable.from(new Promise(<work>)).
+          const networkObservable = RelayObservable.from(
+            new Promise((resolve, reject) => {
+              operationLoader
+                .load(followupPayload.operationReference)
+                .then(resolve, reject);
+            }),
+          );
+          RelayObservable.create(sink => {
+            let cancellationToken;
+            const subscription = networkObservable.subscribe({
+              next: (loadedNode: ?NormalizationRootNode) => {
+                if (loadedNode != null) {
+                  const publishModuleImportPayload = () => {
+                    try {
+                      const operation = getOperation(loadedNode);
+                      const batchAsyncModuleUpdatesFN =
+                        RelayFeatureFlags.BATCH_ASYNC_MODULE_UPDATES_FN;
+                      const shouldScheduleAsyncStoreUpdate =
+                        batchAsyncModuleUpdatesFN != null &&
+                        this._pendingModulePayloadsCount > 1;
+                      const [duration] = withDuration(() => {
+                        this._handleFollowupPayload(followupPayload, operation);
+                        // OK: always have to run after an async module import resolves
+                        if (shouldScheduleAsyncStoreUpdate) {
+                          this._scheduleAsyncStoreUpdate(
+                            // $FlowFixMe[incompatible-call] `shouldScheduleAsyncStoreUpdate` check should cover `null` case
+                            batchAsyncModuleUpdatesFN,
+                            sink.complete,
+                          );
+                        } else {
+                          const updatedOwners = this._runPublishQueue();
+                          this._updateOperationTracker(updatedOwners);
+                        }
+                      });
+                      this._log({
+                        name: 'execute.async.module',
+                        executeId: this._executeId,
+                        operationName: operation.name,
+                        duration,
+                      });
+                      if (!shouldScheduleAsyncStoreUpdate) {
+                        sink.complete();
+                      }
+                    } catch (error) {
+                      sink.error(error);
+                    }
+                  };
+                  const scheduler = this._scheduler;
+                  if (scheduler == null) {
+                    publishModuleImportPayload();
+                  } else {
+                    cancellationToken = scheduler.schedule(
+                      publishModuleImportPayload,
+                    );
+                  }
+                } else {
+                  sink.complete();
+                }
+              },
+              error: sink.error,
             });
-          }
-        })
-        .subscribe({
-          complete: () => {
-            this._complete(id);
-            decrementPendingCount();
-          },
-          error: error => {
-            this._error(error);
-            decrementPendingCount();
-          },
-          start: subscription => this._start(id, subscription),
-        });
+            return () => {
+              subscription.unsubscribe();
+              if (this._scheduler != null && cancellationToken != null) {
+                this._scheduler.cancel(cancellationToken);
+              }
+            };
+          }).subscribe({
+            complete: () => {
+              this._complete(id);
+              decrementPendingCount();
+            },
+            error: error => {
+              this._error(error);
+              decrementPendingCount();
+            },
+            start: subscription => this._start(id, subscription),
+          });
+        }
+        break;
+      case 'ActorPayload':
+        this._processFollowupPayloadWithNormalizationNode(
+          followupPayload,
+          followupPayload.node,
+        );
+        break;
+      default:
+        (followupPayload: empty);
+        invariant(
+          false,
+          'OperationExecutor: Unexpected followup kind `%s`.',
+          followupPayload.kind,
+        );
     }
   }
 
-  _handleModuleImportPayload(
-    moduleImportPayload: ModuleImportPayload,
-    operation: NormalizationSplitOperation | NormalizationOperation,
+  _processFollowupPayloadWithNormalizationNode(
+    followupPayload: FollowupPayload,
+    normalizationNode:
+      | NormalizationSplitOperation
+      | NormalizationOperation
+      | NormalizationLinkedField,
+  ) {
+    this._handleFollowupPayload(followupPayload, normalizationNode);
+    this._maybeCompleteSubscriptionOperationTracking();
+  }
+
+  _handleFollowupPayload(
+    followupPayload: FollowupPayload,
+    normalizationNode:
+      | NormalizationSplitOperation
+      | NormalizationOperation
+      | NormalizationLinkedField,
   ): void {
-    const relayPayload = this._normalizeModuleImport(
-      moduleImportPayload,
-      operation,
+    const relayPayload = this._normalizeFollowupPayload(
+      followupPayload,
+      normalizationNode,
+    );
+    this._getPublishQueueAndSaveActor().commitPayload(
+      this._operation,
+      relayPayload,
     );
-    this._publishQueue.commitPayload(this._operation, relayPayload);
-    if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
-      const updatedOwners = this._publishQueue.run();
-      this._updateOperationTracker(updatedOwners);
-    }
     this._processPayloadFollowups([relayPayload]);
   }
 
@@ -951,7 +1122,7 @@ class Executor {
       (placeholder: empty);
       invariant(
         false,
-        'Unsupported incremental placeholder kind `%s`.',
+        'OperationExecutor: Unsupported incremental placeholder kind `%s`.',
         placeholder.kind,
       );
     }
@@ -975,7 +1146,7 @@ class Executor {
     // exist.
     invariant(
       parentRecord != null,
-      'RelayModernEnvironment: Expected record `%s` to exist.',
+      'OperationExecutor: Expected record `%s` to exist.',
       parentID,
     );
     let nextParentRecord;
@@ -1004,16 +1175,13 @@ class Executor {
       record: nextParentRecord,
       fieldPayloads: nextParentPayloads,
     });
+
     // If there were any queued responses, process them now that placeholders
     // are in place
     if (pendingResponses != null) {
       const payloadFollowups = this._processIncrementalResponses(
         pendingResponses,
       );
-      if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
-        const updatedOwners = this._publishQueue.run();
-        this._updateOperationTracker(updatedOwners);
-      }
       this._processPayloadFollowups(payloadFollowups);
     }
   }
@@ -1049,7 +1217,7 @@ class Executor {
         const placeholder = resultForPath.placeholder;
         invariant(
           placeholder.kind === 'defer',
-          'RelayModernEnvironment: Expected data for path `%s` for label `%s` ' +
+          'OperationExecutor: Expected data for path `%s` for label `%s` ' +
             'to be data for @defer, was `@%s`.',
           pathKey,
           label,
@@ -1079,7 +1247,7 @@ class Executor {
         const placeholder = resultForPath.placeholder;
         invariant(
           placeholder.kind === 'stream',
-          'RelayModernEnvironment: Expected data for path `%s` for label `%s` ' +
+          'OperationExecutor: Expected data for path `%s` for label `%s` ' +
             'to be data for @stream, was `@%s`.',
           pathKey,
           label,
@@ -1100,27 +1268,37 @@ class Executor {
     response: GraphQLResponseWithData,
   ): RelayResponsePayload {
     const {dataID: parentID} = placeholder.selector;
+    const prevActorIdentifier = this._actorIdentifier;
+    this._actorIdentifier =
+      placeholder.actorIdentifier ?? this._actorIdentifier;
     const relayPayload = normalizeResponse(
       response,
       placeholder.selector,
       placeholder.typeName,
       {
+        actorIdentifier: this._actorIdentifier,
         getDataID: this._getDataID,
         path: placeholder.path,
-        reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
+        reactFlightPayloadDeserializer:
+          this._reactFlightPayloadDeserializer != null
+            ? this._deserializeReactFlightPayloadWithLogging
+            : null,
         reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         shouldProcessClientComponents: this._shouldProcessClientComponents,
       },
     );
-    this._publishQueue.commitPayload(this._operation, relayPayload);
+    this._getPublishQueueAndSaveActor().commitPayload(
+      this._operation,
+      relayPayload,
+    );
 
     // Load the version of the parent record from which this incremental data
     // was derived
     const parentEntry = this._source.get(parentID);
     invariant(
       parentEntry != null,
-      'RelayModernEnvironment: Expected the parent record `%s` for @defer ' +
+      'OperationExecutor: Expected the parent record `%s` for @defer ' +
         'data to exist.',
       parentID,
     );
@@ -1130,15 +1308,17 @@ class Executor {
         errors: null,
         fieldPayloads,
         incrementalPlaceholders: null,
-        moduleImportPayloads: null,
+        followupPayloads: null,
         source: RelayRecordSource.create(),
         isFinal: response.extensions?.is_final === true,
       };
-      this._publishQueue.commitPayload(
+      this._getPublishQueueAndSaveActor().commitPayload(
         this._operation,
         handleFieldsRelayPayload,
       );
     }
+
+    this._actorIdentifier = prevActorIdentifier;
     return relayPayload;
   }
 
@@ -1151,12 +1331,14 @@ class Executor {
     placeholder: StreamPlaceholder,
     response: GraphQLResponseWithData,
   ): RelayResponsePayload {
-    const {parentID, node, variables} = placeholder;
+    const {parentID, node, variables, actorIdentifier} = placeholder;
+    const prevActorIdentifier = this._actorIdentifier;
+    this._actorIdentifier = actorIdentifier ?? this._actorIdentifier;
     // Find the LinkedField where @stream was applied
     const field = node.selections[0];
     invariant(
       field != null && field.kind === 'LinkedField' && field.plural === true,
-      'RelayModernEnvironment: Expected @stream to be used on a plural field.',
+      'OperationExecutor: Expected @stream to be used on a plural field.',
     );
     const {
       fieldPayloads,
@@ -1176,34 +1358,38 @@ class Executor {
     // Publish the new item and update the parent record to set
     // field[index] = item *if* the parent record hasn't been concurrently
     // modified.
-    this._publishQueue.commitPayload(this._operation, relayPayload, store => {
-      const currentParentRecord = store.get(parentID);
-      if (currentParentRecord == null) {
-        // parent has since been deleted, stream data is stale
-        return;
-      }
-      const currentItems = currentParentRecord.getLinkedRecords(storageKey);
-      if (currentItems == null) {
-        // field has since been deleted, stream data is stale
-        return;
-      }
-      if (
-        currentItems.length !== prevIDs.length ||
-        currentItems.some(
-          (currentItem, index) =>
-            prevIDs[index] !== (currentItem && currentItem.getDataID()),
-        )
-      ) {
-        // field has been modified by something other than this query,
-        // stream data is stale
-        return;
-      }
-      // parent.field has not been concurrently modified:
-      // update `parent.field[index] = item`
-      const nextItems = [...currentItems];
-      nextItems[itemIndex] = store.get(itemID);
-      currentParentRecord.setLinkedRecords(nextItems, storageKey);
-    });
+    this._getPublishQueueAndSaveActor().commitPayload(
+      this._operation,
+      relayPayload,
+      store => {
+        const currentParentRecord = store.get(parentID);
+        if (currentParentRecord == null) {
+          // parent has since been deleted, stream data is stale
+          return;
+        }
+        const currentItems = currentParentRecord.getLinkedRecords(storageKey);
+        if (currentItems == null) {
+          // field has since been deleted, stream data is stale
+          return;
+        }
+        if (
+          currentItems.length !== prevIDs.length ||
+          currentItems.some(
+            (currentItem, index) =>
+              prevIDs[index] !== (currentItem && currentItem.getDataID()),
+          )
+        ) {
+          // field has been modified by something other than this query,
+          // stream data is stale
+          return;
+        }
+        // parent.field has not been concurrently modified:
+        // update `parent.field[index] = item`
+        const nextItems = [...currentItems];
+        nextItems[itemIndex] = store.get(itemID);
+        currentParentRecord.setLinkedRecords(nextItems, storageKey);
+      },
+    );
 
     // Now that the parent record has been updated to include the new item,
     // also update any handle fields that are derived from the parent record.
@@ -1212,15 +1398,17 @@ class Executor {
         errors: null,
         fieldPayloads,
         incrementalPlaceholders: null,
-        moduleImportPayloads: null,
+        followupPayloads: null,
         source: RelayRecordSource.create(),
         isFinal: false,
       };
-      this._publishQueue.commitPayload(
+      this._getPublishQueueAndSaveActor().commitPayload(
         this._operation,
         handleFieldsRelayPayload,
       );
     }
+
+    this._actorIdentifier = prevActorIdentifier;
     return relayPayload;
   }
 
@@ -1242,7 +1430,7 @@ class Executor {
     const {data} = response;
     invariant(
       typeof data === 'object',
-      'RelayModernEnvironment: Expected the GraphQL @stream payload `data` ' +
+      'OperationExecutor: Expected the GraphQL @stream payload `data` ' +
         'value to be an object.',
     );
     const responseKey = field.alias ?? field.name;
@@ -1253,7 +1441,7 @@ class Executor {
     const parentEntry = this._source.get(parentID);
     invariant(
       parentEntry != null,
-      'RelayModernEnvironment: Expected the parent record `%s` for @stream ' +
+      'OperationExecutor: Expected the parent record `%s` for @stream ' +
         'data to exist.',
       parentID,
     );
@@ -1268,7 +1456,7 @@ class Executor {
     );
     invariant(
       prevIDs != null,
-      'RelayModernEnvironment: Expected record `%s` to have fetched field ' +
+      'OperationExecutor: Expected record `%s` to have fetched field ' +
         '`%s` with @stream.',
       parentID,
       field.name,
@@ -1279,7 +1467,7 @@ class Executor {
     const itemIndex = parseInt(finalPathEntry, 10);
     invariant(
       itemIndex === finalPathEntry && itemIndex >= 0,
-      'RelayModernEnvironment: Expected path for @stream to end in a ' +
+      'OperationExecutor: Expected path for @stream to end in a ' +
         'positive integer index, got `%s`',
       finalPathEntry,
     );
@@ -1287,7 +1475,7 @@ class Executor {
     const typeName = field.concreteType ?? data[TYPENAME_KEY];
     invariant(
       typeof typeName === 'string',
-      'RelayModernEnvironment: Expected @stream field `%s` to have a ' +
+      'OperationExecutor: Expected @stream field `%s` to have a ' +
         '__typename.',
       field.name,
     );
@@ -1302,7 +1490,7 @@ class Executor {
       generateClientID(parentID, storageKey, itemIndex);
     invariant(
       typeof itemID === 'string',
-      'RelayModernEnvironment: Expected id of elements of field `%s` to ' +
+      'OperationExecutor: Expected id of elements of field `%s` to ' +
         'be strings.',
       storageKey,
     );
@@ -1322,9 +1510,13 @@ class Executor {
       fieldPayloads,
     });
     const relayPayload = normalizeResponse(response, selector, typeName, {
+      actorIdentifier: this._actorIdentifier,
       getDataID: this._getDataID,
       path: [...normalizationPath, responseKey, String(itemIndex)],
-      reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
+      reactFlightPayloadDeserializer:
+        this._reactFlightPayloadDeserializer != null
+          ? this._deserializeReactFlightPayloadWithLogging
+          : null,
       reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,
       treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       shouldProcessClientComponents: this._shouldProcessClientComponents,
@@ -1339,6 +1531,25 @@ class Executor {
     };
   }
 
+  _scheduleAsyncStoreUpdate(
+    scheduleFn: (() => void) => Disposable,
+    completeFn: () => void,
+  ): void {
+    this._completeFns.push(completeFn);
+    if (this._asyncStoreUpdateDisposable != null) {
+      return;
+    }
+    this._asyncStoreUpdateDisposable = scheduleFn(() => {
+      this._asyncStoreUpdateDisposable = null;
+      const updatedOwners = this._runPublishQueue();
+      this._updateOperationTracker(updatedOwners);
+      for (const complete of this._completeFns) {
+        complete();
+      }
+      this._completeFns = [];
+    });
+  }
+
   _updateOperationTracker(
     updatedOwners: ?$ReadOnlyArray<RequestDescriptor>,
   ): void {
@@ -1353,6 +1564,58 @@ class Executor {
   _completeOperationTracker() {
     this._operationTracker.complete(this._operation.request);
   }
+
+  _getPublishQueueAndSaveActor(): PublishQueue {
+    this._seenActors.add(this._actorIdentifier);
+    return this._getPublishQueue(this._actorIdentifier);
+  }
+
+  _getActorsToVisit(): $ReadOnlySet<ActorIdentifier> {
+    if (this._seenActors.size === 0) {
+      return new Set([this._actorIdentifier]);
+    } else {
+      return this._seenActors;
+    }
+  }
+
+  _runPublishQueue(
+    operation?: OperationDescriptor,
+  ): $ReadOnlyArray<RequestDescriptor> {
+    const updatedOwners = new Set();
+    for (const actorIdentifier of this._getActorsToVisit()) {
+      const owners = this._getPublishQueue(actorIdentifier).run(operation);
+      owners.forEach(owner => updatedOwners.add(owner));
+    }
+    return Array.from(updatedOwners);
+  }
+
+  _retainData() {
+    for (const actorIdentifier of this._getActorsToVisit()) {
+      if (!this._retainDisposables.has(actorIdentifier)) {
+        this._retainDisposables.set(
+          actorIdentifier,
+          this._getStore(actorIdentifier).retain(this._operation),
+        );
+      }
+    }
+  }
+
+  _disposeRetainedData() {
+    for (const disposable of this._retainDisposables.values()) {
+      disposable.dispose();
+    }
+    this._retainDisposables.clear();
+  }
+
+  _expectOperationLoader(): OperationLoader {
+    const operationLoader = this._operationLoader;
+    invariant(
+      operationLoader,
+      'OperationExecutor: Expected an operationLoader to be ' +
+        'configured when using `@match`.',
+    );
+    return operationLoader;
+  }
 }
 
 function partitionGraphQLResponses(