relay-runtime 11.0.1 → 13.0.0-rc.1

package/store/{RelayModernQueryExecutor.js.flow → OperationExecutor.js.flow}

@@ -13,37 +13,22 @@
 
 'use strict';
 
-const RelayError = require('../util/RelayError');
-const RelayFeatureFlags = require('../util/RelayFeatureFlags');
-const RelayModernRecord = require('./RelayModernRecord');
-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');
-
-const {generateClientID, generateUniqueClientID} = require('./ClientID');
-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,
+  GraphQLSingularResponse,
+  ReactFlightServerTree,
 } from '../network/RelayNetworkTypes';
 import type {Sink, Subscription} from '../network/RelayObservable';
 import type {
   DeferPlaceholder,
-  RequestDescriptor,
+  FollowupPayload,
   HandleFieldPayload,
   IncrementalDataPlaceholder,
+  LogFunction,
   ModuleImportPayload,
+  MutationParameters,
   NormalizationSelector,
   OperationDescriptor,
   OperationLoader,
@@ -51,10 +36,12 @@ import type {
   OptimisticResponseConfig,
   OptimisticUpdate,
   PublishQueue,
+  ReactFlightClientResponse,
   ReactFlightPayloadDeserializer,
   ReactFlightServerErrorHandler,
   Record,
   RelayResponsePayload,
+  RequestDescriptor,
   SelectorStoreUpdater,
   Store,
   StreamPlaceholder,
@@ -66,28 +53,50 @@ import type {
   NormalizationSelectableNode,
   NormalizationSplitOperation,
 } from '../util/NormalizationNode';
-import type {DataID, Variables, Disposable} from '../util/RelayRuntimeTypes';
+import type {DataID, Disposable, Variables} from '../util/RelayRuntimeTypes';
 import type {GetDataID} from './RelayResponseNormalizer';
 import type {NormalizationOptions} from './RelayResponseNormalizer';
 
-export type ExecuteConfig = {|
+const RelayObservable = require('../network/RelayObservable');
+const generateID = require('../util/generateID');
+const getOperation = require('../util/getOperation');
+const RelayError = require('../util/RelayError');
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
+const stableCopy = require('../util/stableCopy');
+const withDuration = require('../util/withDuration');
+const {generateClientID, generateUniqueClientID} = require('./ClientID');
+const {getLocalVariables} = require('./RelayConcreteVariables');
+const RelayModernRecord = require('./RelayModernRecord');
+const {
+  createNormalizationSelector,
+  createReaderSelector,
+} = require('./RelayModernSelector');
+const RelayRecordSource = require('./RelayRecordSource');
+const RelayResponseNormalizer = require('./RelayResponseNormalizer');
+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,
-  +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,
+  +operationTracker: OperationTracker,
+  +optimisticConfig: ?OptimisticResponseConfig<TMutation>,
   +reactFlightPayloadDeserializer?: ?ReactFlightPayloadDeserializer,
   +reactFlightServerErrorHandler?: ?ReactFlightServerErrorHandler,
   +scheduler?: ?TaskScheduler,
+  +shouldProcessClientComponents?: ?boolean,
   +sink: Sink<GraphQLResponse>,
   +source: RelayObservable<GraphQLResponse>,
-  +store: Store,
-  +updater?: ?SelectorStoreUpdater,
-  +isClientPayload?: boolean,
-  +shouldProcessClientComponents?: ?boolean,
+  +treatMissingFieldsAsNull: boolean,
+  +updater?: ?SelectorStoreUpdater<TMutation['response']>,
+  +log: LogFunction,
 |};
 
 export type ActiveState = 'active' | 'inactive';
@@ -115,7 +124,9 @@ type IncrementalGraphQLResponse = {|
   response: GraphQLResponseWithData,
 |};
 
-function execute(config: ExecuteConfig): Executor {
+function execute<TMutation: MutationParameters>(
+  config: ExecuteConfig<TMutation>,
+): Executor<TMutation> {
   return new Executor(config);
 }
 
@@ -124,20 +135,23 @@ function execute(config: ExecuteConfig): Executor {
  * including optimistic payloads, standard payloads, resolution of match
  * dependencies, etc.
  */
-class Executor {
+class Executor<TMutation: MutationParameters> {
+  _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>;
   _operationLoader: ?OperationLoader;
-  _operationTracker: ?OperationTracker;
+  _operationTracker: OperationTracker;
   _operationUpdateEpochs: Map<string, number>;
-  _optimisticUpdates: null | Array<OptimisticUpdate>;
+  _optimisticUpdates: null | Array<OptimisticUpdate<TMutation>>;
   _pendingModulePayloadsCount: number;
-  _publishQueue: PublishQueue;
+  +_getPublishQueue: (actorIdentifier: ActorIdentifier) => PublishQueue;
   _reactFlightPayloadDeserializer: ?ReactFlightPayloadDeserializer;
   _reactFlightServerErrorHandler: ?ReactFlightServerErrorHandler;
   _shouldProcessClientComponents: ?boolean;
@@ -148,36 +162,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;
+  _updater: ?SelectorStoreUpdater<TMutation['response']>;
+  _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,
-  }: ExecuteConfig): void {
+    updater,
+    log,
+  }: ExecuteConfig<TMutation>): 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 +208,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 +222,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 +237,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,18 +276,41 @@ class Executor {
     if (optimisticUpdates !== null) {
       this._optimisticUpdates = null;
       optimisticUpdates.forEach(update =>
-        this._publishQueue.revertUpdate(update),
+        this._getPublishQueueAndSaveActor().revertUpdate(update),
       );
-      this._publishQueue.run();
+      // OK: run revert on cancel
+      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) {
@@ -276,7 +333,7 @@ class Executor {
       }
       default:
         (this._state: empty);
-        invariant(false, 'RelayModernQueryExecutor: invalid executor state.');
+        invariant(false, 'OperationExecutor: invalid executor state.');
     }
     this._operationExecutions.set(
       this._operation.request.identifier,
@@ -313,12 +370,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 {
@@ -329,8 +395,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,
+      });
     });
   }
 
@@ -374,7 +448,8 @@ class Executor {
         error.stack;
         throw error;
       } else {
-        const responseWithData: GraphQLResponseWithData = (response: $FlowFixMe);
+        const responseWithData: GraphQLResponseWithData =
+          (response: $FlowFixMe);
         results.push(responseWithData);
       }
     });
@@ -394,7 +469,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;
     }
@@ -403,7 +481,7 @@ class Executor {
     if (isOptimistic && this._state !== 'started') {
       invariant(
         false,
-        'RelayModernQueryExecutor: optimistic payload received after server payload.',
+        'OperationExecutor: optimistic payload received after server payload.',
       );
     }
     if (isOptimistic) {
@@ -422,6 +500,7 @@ class Executor {
     if (this._state === 'completed') {
       return;
     }
+    this._seenActors.clear();
 
     const responses = Array.isArray(response) ? response : [response];
     const responsesWithData = this._handleErrorResponse(responses);
@@ -445,10 +524,9 @@ class Executor {
       return;
     }
 
-    const [
-      nonIncrementalResponses,
-      incrementalResponses,
-    ] = partitionGraphQLResponses(responsesWithData);
+    const [nonIncrementalResponses, incrementalResponses] =
+      partitionGraphQLResponses(responsesWithData);
+    const hasNonIncrementalResponses = nonIncrementalResponses.length > 0;
 
     // In theory this doesn't preserve the ordering of the batch.
     // The idea is that a batch is always:
@@ -457,56 +535,96 @@ class Executor {
     // The non-incremental payload can appear if the server sends a batch
     // with the initial payload followed by some early-to-resolve incremental
     // payloads (although, can that even happen?)
-    if (nonIncrementalResponses.length > 0) {
+    if (hasNonIncrementalResponses) {
+      // 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);
-      // 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 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) {
-      const payloadFollowups = this._processIncrementalResponses(
-        incrementalResponses,
-      );
-      // 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);
+      const payloadFollowups =
+        this._processIncrementalResponses(incrementalResponses);
+
       this._processPayloadFollowups(payloadFollowups);
     }
+    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) {
+        // $FlowFixMe[cannot-write]
+        responsesWithData[0].extensions = {
+          __relay_subscription_root_id: this._operation.fragment.dataID,
+        };
+      } else {
+        responsesWithData[0].extensions.__relay_subscription_root_id =
+          this._operation.fragment.dataID;
+      }
+    }
+
+    // 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._sink.next(response);
   }
 
   _processOptimisticResponse(
     response: ?GraphQLResponseWithData,
-    updater: ?SelectorStoreUpdater,
+    updater: ?SelectorStoreUpdater<TMutation['response']>,
     treatMissingFieldsAsNull: boolean,
   ): 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) {
       return;
     }
-    const optimisticUpdates: Array<OptimisticUpdate> = [];
+    const optimisticUpdates: Array<OptimisticUpdate<TMutation>> = [];
     if (response) {
       const payload = normalizeResponse(
         response,
         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,
@@ -526,7 +644,7 @@ class Executor {
           errors: null,
           fieldPayloads: null,
           incrementalPlaceholders: null,
-          moduleImportPayloads: null,
+          followupPayloads: null,
           source: RelayRecordSource.create(),
           isFinal: false,
         },
@@ -534,59 +652,90 @@ class Executor {
       });
     }
     this._optimisticUpdates = optimisticUpdates;
-    optimisticUpdates.forEach(update => this._publishQueue.applyUpdate(update));
-    this._publishQueue.run();
+    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._runPublishQueue();
   }
 
   _processOptimisticFollowups(
     payload: RelayResponsePayload,
-    optimisticUpdates: Array<OptimisticUpdate>,
+    optimisticUpdates: Array<OptimisticUpdate<TMutation>>,
   ): 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,
@@ -597,10 +746,10 @@ class Executor {
   _processOptimisticModuleImport(
     normalizationRootNode: NormalizationRootNode,
     moduleImportPayload: ModuleImportPayload,
-  ): $ReadOnlyArray<OptimisticUpdate> {
+  ): $ReadOnlyArray<OptimisticUpdate<TMutation>> {
     const operation = getOperation(normalizationRootNode);
     const optimisticUpdates = [];
-    const modulePayload = this._normalizeModuleImport(
+    const modulePayload = this._normalizeFollowupPayload(
       moduleImportPayload,
       operation,
     );
@@ -615,41 +764,41 @@ class Executor {
   }
 
   _processAsyncOptimisticModuleImport(
-    operationLoader: OperationLoader,
     moduleImportPayload: ModuleImportPayload,
   ): void {
-    operationLoader
+    this._expectOperationLoader()
       .load(moduleImportPayload.operationReference)
       .then(operation => {
         if (operation == null || this._state !== 'started') {
           return;
         }
-        const moduleImportOptimisticUpdates = this._processOptimisticModuleImport(
-          operation,
-          moduleImportPayload,
-        );
+        const moduleImportOptimisticUpdates =
+          this._processOptimisticModuleImport(operation, moduleImportPayload);
         moduleImportOptimisticUpdates.forEach(update =>
-          this._publishQueue.applyUpdate(update),
+          this._getPublishQueueAndSaveActor().applyUpdate(update),
         );
         if (this._optimisticUpdates == null) {
           warning(
             false,
-            'RelayModernQueryExecutor: Unexpected ModuleImport optimistic ' +
+            'OperationExecutor: Unexpected ModuleImport optimistic ' +
               'update in operation %s.' +
               this._operation.request.node.params.name,
           );
         } else {
           this._optimisticUpdates.push(...moduleImportOptimisticUpdates);
-          this._publishQueue.run();
+          // OK: always have to run() after an module import resolves async
+          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;
     }
 
@@ -662,19 +811,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;
     });
   }
@@ -690,30 +844,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') {
@@ -745,8 +899,6 @@ class Executor {
             }
           });
           if (relayPayloads.length > 0) {
-            const updatedOwners = this._publishQueue.run();
-            this._updateOperationTracker(updatedOwners);
             this._processPayloadFollowups(relayPayloads);
           }
         }
@@ -764,23 +916,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,
-        ),
-      };
-    }
   }
 
   /**
@@ -790,73 +925,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),
-              );
+  _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);
-    const updatedOwners = this._publishQueue.run();
-    this._updateOperationTracker(updatedOwners);
     this._processPayloadFollowups([relayPayload]);
   }
 
@@ -902,7 +1118,7 @@ class Executor {
       (placeholder: empty);
       invariant(
         false,
-        'Unsupported incremental placeholder kind `%s`.',
+        'OperationExecutor: Unsupported incremental placeholder kind `%s`.',
         placeholder.kind,
       );
     }
@@ -926,7 +1142,7 @@ class Executor {
     // exist.
     invariant(
       parentRecord != null,
-      'RelayModernEnvironment: Expected record `%s` to exist.',
+      'OperationExecutor: Expected record `%s` to exist.',
       parentID,
     );
     let nextParentRecord;
@@ -955,14 +1171,12 @@ 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,
-      );
-      const updatedOwners = this._publishQueue.run();
-      this._updateOperationTracker(updatedOwners);
+      const payloadFollowups =
+        this._processIncrementalResponses(pendingResponses);
       this._processPayloadFollowups(payloadFollowups);
     }
   }
@@ -998,7 +1212,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,
@@ -1012,10 +1226,7 @@ class Executor {
         // but Relay records paths relative to the parent of the stream node:
         // therefore we strip the last two elements just to lookup the path
         // (the item index is used later to insert the element in the list)
-        const pathKey = path
-          .slice(0, -2)
-          .map(String)
-          .join('.');
+        const pathKey = path.slice(0, -2).map(String).join('.');
         let resultForPath = resultForLabel.get(pathKey);
         if (resultForPath == null) {
           resultForPath = {kind: 'response', responses: [incrementalResponse]};
@@ -1028,7 +1239,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,
@@ -1049,27 +1260,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,
     );
@@ -1079,15 +1300,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;
   }
 
@@ -1100,12 +1323,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,
@@ -1125,34 +1350,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.
@@ -1161,15 +1390,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;
   }
 
@@ -1191,7 +1422,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;
@@ -1202,7 +1433,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,
     );
@@ -1217,7 +1448,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,
@@ -1228,7 +1459,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,
     );
@@ -1236,7 +1467,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,
     );
@@ -1251,7 +1482,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,
     );
@@ -1271,9 +1502,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,
@@ -1288,14 +1523,29 @@ 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 {
-    if (
-      this._operationTracker != null &&
-      updatedOwners != null &&
-      updatedOwners.length > 0
-    ) {
+    if (updatedOwners != null && updatedOwners.length > 0) {
       this._operationTracker.update(
         this._operation.request,
         new Set(updatedOwners),
@@ -1304,10 +1554,60 @@ class Executor {
   }
 
   _completeOperationTracker() {
-    if (this._operationTracker != null) {
-      this._operationTracker.complete(this._operation.request);
+    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(
@@ -1324,7 +1624,7 @@ function partitionGraphQLResponses(
       if (label == null || path == null) {
         invariant(
           false,
-          'RelayModernQueryExecutor: invalid incremental payload, expected ' +
+          'OperationExecutor: invalid incremental payload, expected ' +
             '`path` and `label` to either both be null/undefined, or ' +
             '`path` to be an `Array<string | number>` and `label` to be a ' +
             '`string`.',
@@ -1376,11 +1676,13 @@ function validateOptimisticResponsePayload(
   if (incrementalPlaceholders != null && incrementalPlaceholders.length !== 0) {
     invariant(
       false,
-      'RelayModernQueryExecutor: optimistic responses cannot be returned ' +
+      'OperationExecutor: optimistic responses cannot be returned ' +
         'for operations that use incremental data delivery (@defer, ' +
         '@stream, and @stream_connection).',
     );
   }
 }
 
-module.exports = {execute};
+module.exports = {
+  execute,
+};