relay-runtime 11.0.2 → 12.0.0

package/lib/store/OperationExecutor.js

@@ -17,6 +17,8 @@ var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/obje
 
 var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
 
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
 var RelayError = require('../util/RelayError');
@@ -31,6 +33,8 @@ var RelayRecordSource = require('./RelayRecordSource');
 
 var RelayResponseNormalizer = require('./RelayResponseNormalizer');
 
+var generateID = require('../util/generateID');
+
 var getOperation = require('../util/getOperation');
 
 var invariant = require('invariant');
@@ -39,18 +43,23 @@ var stableCopy = require('../util/stableCopy');
 
 var warning = require("fbjs/lib/warning");
 
+var withDuration = require('../util/withDuration');
+
 var _require = require('./ClientID'),
     generateClientID = _require.generateClientID,
     generateUniqueClientID = _require.generateUniqueClientID;
 
-var _require2 = require('./RelayModernSelector'),
-    createNormalizationSelector = _require2.createNormalizationSelector,
-    createReaderSelector = _require2.createReaderSelector;
+var _require2 = require('./RelayConcreteVariables'),
+    getLocalVariables = _require2.getLocalVariables;
 
-var _require3 = require('./RelayStoreUtils'),
-    ROOT_TYPE = _require3.ROOT_TYPE,
-    TYPENAME_KEY = _require3.TYPENAME_KEY,
-    getStorageKey = _require3.getStorageKey;
+var _require3 = require('./RelayModernSelector'),
+    createNormalizationSelector = _require3.createNormalizationSelector,
+    createReaderSelector = _require3.createReaderSelector;
+
+var _require4 = require('./RelayStoreUtils'),
+    ROOT_TYPE = _require4.ROOT_TYPE,
+    TYPENAME_KEY = _require4.TYPENAME_KEY,
+    getStorageKey = _require4.getStorageKey;
 
 function execute(config) {
   return new Executor(config);
@@ -66,27 +75,51 @@ var Executor = /*#__PURE__*/function () {
   function Executor(_ref) {
     var _this = this;
 
-    var operation = _ref.operation,
+    var actorIdentifier = _ref.actorIdentifier,
+        getDataID = _ref.getDataID,
+        getPublishQueue = _ref.getPublishQueue,
+        getStore = _ref.getStore,
+        isClientPayload = _ref.isClientPayload,
+        operation = _ref.operation,
         operationExecutions = _ref.operationExecutions,
         operationLoader = _ref.operationLoader,
+        operationTracker = _ref.operationTracker,
         optimisticConfig = _ref.optimisticConfig,
-        publishQueue = _ref.publishQueue,
+        _reactFlightPayloadDeserializer = _ref.reactFlightPayloadDeserializer,
+        reactFlightServerErrorHandler = _ref.reactFlightServerErrorHandler,
         scheduler = _ref.scheduler,
+        shouldProcessClientComponents = _ref.shouldProcessClientComponents,
         sink = _ref.sink,
         source = _ref.source,
-        store = _ref.store,
-        updater = _ref.updater,
-        operationTracker = _ref.operationTracker,
         treatMissingFieldsAsNull = _ref.treatMissingFieldsAsNull,
-        getDataID = _ref.getDataID,
-        isClientPayload = _ref.isClientPayload,
-        reactFlightPayloadDeserializer = _ref.reactFlightPayloadDeserializer,
-        reactFlightServerErrorHandler = _ref.reactFlightServerErrorHandler,
-        shouldProcessClientComponents = _ref.shouldProcessClientComponents;
+        updater = _ref.updater,
+        log = _ref.log;
+    (0, _defineProperty2["default"])(this, "_deserializeReactFlightPayloadWithLogging", function (tree) {
+      var reactFlightPayloadDeserializer = _this._reactFlightPayloadDeserializer;
+      !(typeof reactFlightPayloadDeserializer === 'function') ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected reactFlightPayloadDeserializer to be available when calling _deserializeReactFlightPayloadWithLogging.') : invariant(false) : void 0;
+
+      var _withDuration = withDuration(function () {
+        return reactFlightPayloadDeserializer(tree);
+      }),
+          duration = _withDuration[0],
+          result = _withDuration[1];
+
+      _this._log({
+        name: 'execute.flight.payload_deserialize',
+        executeId: _this._executeId,
+        operationName: _this._operation.request.node.params.name,
+        duration: duration
+      });
+
+      return result;
+    });
+    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;
@@ -95,19 +128,22 @@ var Executor = /*#__PURE__*/function () {
     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;
-    this._reactFlightPayloadDeserializer = reactFlightPayloadDeserializer;
+    this._reactFlightPayloadDeserializer = _reactFlightPayloadDeserializer;
     this._reactFlightServerErrorHandler = reactFlightServerErrorHandler;
     this._isSubscriptionOperation = this._operation.request.node.params.operationKind === 'subscription';
     this._shouldProcessClientComponents = shouldProcessClientComponents;
+    this._retainDisposables = new Map();
+    this._seenActors = new Set();
+    this._completeFns = [];
     var id = this._nextSubscriptionId++;
     source.subscribe({
       complete: function complete() {
@@ -124,7 +160,17 @@ var Executor = /*#__PURE__*/function () {
         }
       },
       start: function start(subscription) {
-        return _this._start(id, subscription);
+        var _this$_operation$requ;
+
+        _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$requ = _this._operation.request.cacheConfig) !== null && _this$_operation$requ !== void 0 ? _this$_operation$requ : {}
+        });
       }
     });
 
@@ -162,21 +208,25 @@ var Executor = /*#__PURE__*/function () {
     if (optimisticUpdates !== null) {
       this._optimisticUpdates = null;
       optimisticUpdates.forEach(function (update) {
-        return _this2._publishQueue.revertUpdate(update);
+        return _this2._getPublishQueueAndSaveActor().revertUpdate(update);
       }); // OK: run revert on cancel
 
-      this._publishQueue.run();
+      this._runPublishQueue();
     }
 
     this._incrementalResults.clear();
 
-    this._completeOperationTracker();
-
-    if (this._retainDisposable) {
-      this._retainDisposable.dispose();
+    if (this._asyncStoreUpdateDisposable != null) {
+      this._asyncStoreUpdateDisposable.dispose();
 
-      this._retainDisposable = null;
+      this._asyncStoreUpdateDisposable = null;
     }
+
+    this._completeFns = [];
+
+    this._completeOperationTracker();
+
+    this._disposeRetainedData();
   };
 
   _proto._updateActiveState = function _updateActiveState() {
@@ -258,6 +308,11 @@ var Executor = /*#__PURE__*/function () {
       this.cancel();
 
       this._sink.complete();
+
+      this._log({
+        name: 'execute.complete',
+        executeId: this._executeId
+      });
     }
   };
 
@@ -265,6 +320,12 @@ var Executor = /*#__PURE__*/function () {
     this.cancel();
 
     this._sink.error(error);
+
+    this._log({
+      name: 'execute.error',
+      executeId: this._executeId,
+      error: error
+    });
   };
 
   _proto._start = function _start(id, subscription) {
@@ -278,9 +339,19 @@ var Executor = /*#__PURE__*/function () {
     var _this4 = this;
 
     this._schedule(function () {
-      _this4._handleNext(response);
-
-      _this4._maybeCompleteSubscriptionOperationTracking();
+      var _withDuration2 = withDuration(function () {
+        _this4._handleNext(response);
+
+        _this4._maybeCompleteSubscriptionOperationTracking();
+      }),
+          duration = _withDuration2[0];
+
+      _this4._log({
+        name: 'execute.next',
+        executeId: _this4._executeId,
+        response: response,
+        duration: duration
+      });
     });
   };
 
@@ -332,7 +403,7 @@ var Executor = /*#__PURE__*/function () {
 
         return ((_responsePart$extensi = responsePart.extensions) === null || _responsePart$extensi === void 0 ? void 0 : _responsePart$extensi.isOptimistic) === true;
       })) {
-        !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'Optimistic responses cannot be batched.') : invariant(false) : void 0;
+        !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Optimistic responses cannot be batched.') : invariant(false) : void 0;
       }
 
       return false;
@@ -361,6 +432,8 @@ var Executor = /*#__PURE__*/function () {
       return;
     }
 
+    this._seenActors.clear();
+
     var responses = Array.isArray(response) ? response : [response];
 
     var responsesWithData = this._handleErrorResponse(responses);
@@ -407,39 +480,30 @@ var Executor = /*#__PURE__*/function () {
     // payloads (although, can that even happen?)
 
     if (hasNonIncrementalResponses) {
-      var payloadFollowups = this._processResponses(nonIncrementalResponses);
-
-      if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
-        var 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) {
+        var 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)
+        };
       }
 
-      this._processPayloadFollowups(payloadFollowups);
+      var payloadFollowups = this._processResponses(nonIncrementalResponses);
 
-      if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
-        if (this._incrementalPayloadsPending && !this._retainDisposable) {
-          this._retainDisposable = this._store.retain(this._operation);
-        }
-      }
+      this._processPayloadFollowups(payloadFollowups);
     }
 
     if (incrementalResponses.length > 0) {
       var _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)
-        var _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) {
@@ -450,31 +514,29 @@ var Executor = /*#__PURE__*/function () {
       } 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
 
-    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
-      var _updatedOwners2 = this._publishQueue.run(hasNonIncrementalResponses ? this._operation : undefined);
 
-      if (hasNonIncrementalResponses) {
-        if (this._incrementalPayloadsPending && !this._retainDisposable) {
-          this._retainDisposable = this._store.retain(this._operation);
-        }
-      }
+    var updatedOwners = this._runPublishQueue(hasNonIncrementalResponses ? this._operation : undefined);
 
-      this._updateOperationTracker(_updatedOwners2);
+    if (hasNonIncrementalResponses) {
+      if (this._incrementalPayloadsPending) {
+        this._retainData();
+      }
     }
 
+    this._updateOperationTracker(updatedOwners);
+
     this._sink.next(response);
   };
 
   _proto._processOptimisticResponse = function _processOptimisticResponse(response, updater, treatMissingFieldsAsNull) {
     var _this6 = this;
 
-    !(this._optimisticUpdates === null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'environment.execute: only support one optimistic response per ' + 'execute.') : invariant(false) : void 0;
+    !(this._optimisticUpdates === null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: environment.execute: only support one optimistic response per ' + 'execute.') : invariant(false) : void 0;
 
     if (response == null && updater == null) {
       return;
@@ -484,9 +546,10 @@ var Executor = /*#__PURE__*/function () {
 
     if (response) {
       var 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: treatMissingFieldsAsNull
@@ -506,7 +569,7 @@ var Executor = /*#__PURE__*/function () {
           errors: null,
           fieldPayloads: null,
           incrementalPlaceholders: null,
-          moduleImportPayloads: null,
+          followupPayloads: null,
           source: RelayRecordSource.create(),
           isFinal: false
         },
@@ -516,33 +579,47 @@ var Executor = /*#__PURE__*/function () {
 
     this._optimisticUpdates = optimisticUpdates;
     optimisticUpdates.forEach(function (update) {
-      return _this6._publishQueue.applyUpdate(update);
+      return _this6._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();
   };
 
   _proto._processOptimisticFollowups = function _processOptimisticFollowups(payload, optimisticUpdates) {
-    if (payload.moduleImportPayloads && payload.moduleImportPayloads.length) {
-      var moduleImportPayloads = payload.moduleImportPayloads;
-      var operationLoader = this._operationLoader;
-      !operationLoader ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected an operationLoader to be ' + 'configured when using `@match`.') : invariant(false) : void 0;
+    if (payload.followupPayloads && payload.followupPayloads.length) {
+      var followupPayloads = payload.followupPayloads;
 
-      var _iterator = (0, _createForOfIteratorHelper2["default"])(moduleImportPayloads),
+      var _iterator = (0, _createForOfIteratorHelper2["default"])(followupPayloads),
           _step;
 
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var moduleImportPayload = _step.value;
-          var operation = operationLoader.get(moduleImportPayload.operationReference);
+          var followupPayload = _step.value;
+
+          switch (followupPayload.kind) {
+            case 'ModuleImportPayload':
+              var operationLoader = this._expectOperationLoader();
+
+              var operation = operationLoader.get(followupPayload.operationReference);
+
+              if (operation == null) {
+                this._processAsyncOptimisticModuleImport(followupPayload);
+              } else {
+                var moduleImportOptimisticUpdates = this._processOptimisticModuleImport(operation, followupPayload);
 
-          if (operation == null) {
-            this._processAsyncOptimisticModuleImport(operationLoader, moduleImportPayload);
-          } else {
-            var moduleImportOptimisticUpdates = this._processOptimisticModuleImport(operation, moduleImportPayload);
+                optimisticUpdates.push.apply(optimisticUpdates, (0, _toConsumableArray2["default"])(moduleImportOptimisticUpdates));
+              }
 
-            optimisticUpdates.push.apply(optimisticUpdates, (0, _toConsumableArray2["default"])(moduleImportOptimisticUpdates));
+              break;
+
+            case 'ActorPayload':
+              process.env.NODE_ENV !== "production" ? warning(false, 'OperationExecutor: Unexpected optimistic ActorPayload. These updates are not supported.') : void 0;
+              break;
+
+            default:
+              followupPayload;
+              !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Unexpected followup kind `%s`. when processing optimistic updates.', followupPayload.kind) : invariant(false) : void 0;
           }
         }
       } catch (err) {
@@ -551,16 +628,29 @@ var Executor = /*#__PURE__*/function () {
         _iterator.f();
       }
     }
-  };
+  }
+  /**
+   * Normalize Data for @module payload, and actor-specific payload
+   */
+  ;
+
+  _proto._normalizeFollowupPayload = function _normalizeFollowupPayload(followupPayload, normalizationNode) {
+    var variables;
+
+    if (normalizationNode.kind === 'SplitOperation' && followupPayload.kind === 'ModuleImportPayload') {
+      variables = getLocalVariables(followupPayload.variables, normalizationNode.argumentDefinitions, followupPayload.args);
+    } else {
+      variables = followupPayload.variables;
+    }
 
-  _proto._normalizeModuleImport = function _normalizeModuleImport(moduleImportPayload, operation) {
-    var selector = createNormalizationSelector(operation, moduleImportPayload.dataID, moduleImportPayload.variables);
+    var selector = createNormalizationSelector(normalizationNode, followupPayload.dataID, variables);
     return normalizeResponse({
-      data: moduleImportPayload.data
-    }, selector, moduleImportPayload.typeName, {
+      data: followupPayload.data
+    }, selector, 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
@@ -571,7 +661,7 @@ var Executor = /*#__PURE__*/function () {
     var operation = getOperation(normalizationRootNode);
     var optimisticUpdates = [];
 
-    var modulePayload = this._normalizeModuleImport(moduleImportPayload, operation);
+    var modulePayload = this._normalizeFollowupPayload(moduleImportPayload, operation);
 
     validateOptimisticResponsePayload(modulePayload);
     optimisticUpdates.push({
@@ -585,10 +675,10 @@ var Executor = /*#__PURE__*/function () {
     return optimisticUpdates;
   };
 
-  _proto._processAsyncOptimisticModuleImport = function _processAsyncOptimisticModuleImport(operationLoader, moduleImportPayload) {
+  _proto._processAsyncOptimisticModuleImport = function _processAsyncOptimisticModuleImport(moduleImportPayload) {
     var _this7 = this;
 
-    operationLoader.load(moduleImportPayload.operationReference).then(function (operation) {
+    this._expectOperationLoader().load(moduleImportPayload.operationReference).then(function (operation) {
       if (operation == null || _this7._state !== 'started') {
         return;
       }
@@ -596,7 +686,7 @@ var Executor = /*#__PURE__*/function () {
       var moduleImportOptimisticUpdates = _this7._processOptimisticModuleImport(operation, moduleImportPayload);
 
       moduleImportOptimisticUpdates.forEach(function (update) {
-        return _this7._publishQueue.applyUpdate(update);
+        return _this7._getPublishQueueAndSaveActor().applyUpdate(update);
       });
 
       if (_this7._optimisticUpdates == null) {
@@ -607,7 +697,7 @@ var Executor = /*#__PURE__*/function () {
         (_this$_optimisticUpda = _this7._optimisticUpdates).push.apply(_this$_optimisticUpda, (0, _toConsumableArray2["default"])(moduleImportOptimisticUpdates)); // OK: always have to run() after an module import resolves async
 
 
-        _this7._publishQueue.run();
+        _this7._runPublishQueue();
       }
     });
   };
@@ -617,7 +707,7 @@ var Executor = /*#__PURE__*/function () {
 
     if (this._optimisticUpdates !== null) {
       this._optimisticUpdates.forEach(function (update) {
-        return _this8._publishQueue.revertUpdate(update);
+        _this8._getPublishQueueAndSaveActor().revertUpdate(update);
       });
 
       this._optimisticUpdates = null;
@@ -631,15 +721,16 @@ var Executor = /*#__PURE__*/function () {
 
     return responses.map(function (payloadPart) {
       var relayPayload = normalizeResponse(payloadPart, _this8._operation.root, ROOT_TYPE, {
+        actorIdentifier: _this8._actorIdentifier,
         getDataID: _this8._getDataID,
         path: [],
-        reactFlightPayloadDeserializer: _this8._reactFlightPayloadDeserializer,
+        reactFlightPayloadDeserializer: _this8._reactFlightPayloadDeserializer != null ? _this8._deserializeReactFlightPayloadWithLogging : null,
         reactFlightServerErrorHandler: _this8._reactFlightServerErrorHandler,
         treatMissingFieldsAsNull: _this8._treatMissingFieldsAsNull,
         shouldProcessClientComponents: _this8._shouldProcessClientComponents
       });
 
-      _this8._publishQueue.commitPayload(_this8._operation, relayPayload, _this8._updater);
+      _this8._getPublishQueueAndSaveActor().commitPayload(_this8._operation, relayPayload, _this8._updater);
 
       return relayPayload;
     });
@@ -659,7 +750,7 @@ var Executor = /*#__PURE__*/function () {
 
     payloads.forEach(function (payload) {
       var incrementalPlaceholders = payload.incrementalPlaceholders,
-          moduleImportPayloads = payload.moduleImportPayloads,
+          followupPayloads = payload.followupPayloads,
           isFinal = payload.isFinal;
       _this9._state = isFinal ? 'loading_final' : 'loading_incremental';
 
@@ -669,18 +760,30 @@ var Executor = /*#__PURE__*/function () {
         _this9._incrementalPayloadsPending = false;
       }
 
-      if (moduleImportPayloads && moduleImportPayloads.length !== 0) {
-        var operationLoader = _this9._operationLoader;
-        !operationLoader ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected an operationLoader to be ' + 'configured when using `@match`.') : invariant(false) : void 0;
-        moduleImportPayloads.forEach(function (moduleImportPayload) {
-          _this9._processModuleImportPayload(moduleImportPayload, operationLoader);
+      if (followupPayloads && followupPayloads.length !== 0) {
+        followupPayloads.forEach(function (followupPayload) {
+          var _followupPayload$acto;
+
+          var prevActorIdentifier = _this9._actorIdentifier;
+          _this9._actorIdentifier = (_followupPayload$acto = followupPayload.actorIdentifier) !== null && _followupPayload$acto !== void 0 ? _followupPayload$acto : _this9._actorIdentifier;
+
+          _this9._processFollowupPayload(followupPayload);
+
+          _this9._actorIdentifier = prevActorIdentifier;
         });
       }
 
       if (incrementalPlaceholders && incrementalPlaceholders.length !== 0) {
         _this9._incrementalPayloadsPending = _this9._state !== 'loading_final';
         incrementalPlaceholders.forEach(function (incrementalPlaceholder) {
+          var _incrementalPlacehold;
+
+          var prevActorIdentifier = _this9._actorIdentifier;
+          _this9._actorIdentifier = (_incrementalPlacehold = incrementalPlaceholder.actorIdentifier) !== null && _incrementalPlacehold !== void 0 ? _incrementalPlacehold : _this9._actorIdentifier;
+
           _this9._processIncrementalPlaceholder(payload, incrementalPlaceholder);
+
+          _this9._actorIdentifier = prevActorIdentifier;
         });
 
         if (_this9._isClientPayload || _this9._state === 'loading_final') {
@@ -702,12 +805,6 @@ var Executor = /*#__PURE__*/function () {
           });
 
           if (relayPayloads.length > 0) {
-            if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
-              var updatedOwners = _this9._publishQueue.run();
-
-              _this9._updateOperationTracker(updatedOwners);
-            }
-
             _this9._processPayloadFollowups(relayPayloads);
           }
         }
@@ -723,15 +820,6 @@ var Executor = /*#__PURE__*/function () {
     if (this._pendingModulePayloadsCount === 0 && this._incrementalPayloadsPending === false) {
       this._completeOperationTracker();
     }
-
-    if (RelayFeatureFlags.ENABLE_UNIQUE_SUBSCRIPTION_ROOT) {
-      var 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)
-      };
-    }
   }
   /**
    * Processes a ModuleImportPayload, asynchronously resolving the normalization
@@ -742,75 +830,140 @@ var Executor = /*#__PURE__*/function () {
    */
   ;
 
-  _proto._processModuleImportPayload = function _processModuleImportPayload(moduleImportPayload, operationLoader) {
+  _proto._processFollowupPayload = function _processFollowupPayload(followupPayload) {
     var _this10 = this;
 
-    var node = operationLoader.get(moduleImportPayload.operationReference);
-
-    if (node != null) {
-      var 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.
-      var _id3 = this._nextSubscriptionId++;
-
-      this._pendingModulePayloadsCount++;
-
-      var decrementPendingCount = function decrementPendingCount() {
-        _this10._pendingModulePayloadsCount--;
-
-        _this10._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(function (resolve, reject) {
-        operationLoader.load(moduleImportPayload.operationReference).then(resolve, reject);
-      })).map(function (operation) {
-        if (operation != null) {
-          _this10._schedule(function () {
-            _this10._handleModuleImportPayload(moduleImportPayload, getOperation(operation)); // OK: always have to run after an async module import resolves
-
-
-            var updatedOwners = _this10._publishQueue.run();
-
-            _this10._updateOperationTracker(updatedOwners);
+    switch (followupPayload.kind) {
+      case 'ModuleImportPayload':
+        var operationLoader = this._expectOperationLoader();
+
+        var 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.
+          var _id3 = this._nextSubscriptionId++;
+
+          this._pendingModulePayloadsCount++;
+
+          var decrementPendingCount = function decrementPendingCount() {
+            _this10._pendingModulePayloadsCount--;
+
+            _this10._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>)).
+
+
+          var networkObservable = RelayObservable.from(new Promise(function (resolve, reject) {
+            operationLoader.load(followupPayload.operationReference).then(resolve, reject);
+          }));
+          RelayObservable.create(function (sink) {
+            var cancellationToken;
+            var subscription = networkObservable.subscribe({
+              next: function next(loadedNode) {
+                if (loadedNode != null) {
+                  var publishModuleImportPayload = function publishModuleImportPayload() {
+                    try {
+                      var operation = getOperation(loadedNode);
+                      var batchAsyncModuleUpdatesFN = RelayFeatureFlags.BATCH_ASYNC_MODULE_UPDATES_FN;
+                      var shouldScheduleAsyncStoreUpdate = batchAsyncModuleUpdatesFN != null && _this10._pendingModulePayloadsCount > 1;
+
+                      var _withDuration3 = withDuration(function () {
+                        _this10._handleFollowupPayload(followupPayload, operation); // OK: always have to run after an async module import resolves
+
+
+                        // OK: always have to run after an async module import resolves
+                        if (shouldScheduleAsyncStoreUpdate) {
+                          _this10._scheduleAsyncStoreUpdate( // $FlowFixMe[incompatible-call] `shouldScheduleAsyncStoreUpdate` check should cover `null` case
+                          batchAsyncModuleUpdatesFN, sink.complete);
+                        } else {
+                          var updatedOwners = _this10._runPublishQueue();
+
+                          _this10._updateOperationTracker(updatedOwners);
+                        }
+                      }),
+                          duration = _withDuration3[0];
+
+                      _this10._log({
+                        name: 'execute.async.module',
+                        executeId: _this10._executeId,
+                        operationName: operation.name,
+                        duration: duration
+                      });
+
+                      if (!shouldScheduleAsyncStoreUpdate) {
+                        sink.complete();
+                      }
+                    } catch (error) {
+                      sink.error(error);
+                    }
+                  };
+
+                  var scheduler = _this10._scheduler;
+
+                  if (scheduler == null) {
+                    publishModuleImportPayload();
+                  } else {
+                    cancellationToken = scheduler.schedule(publishModuleImportPayload);
+                  }
+                } else {
+                  sink.complete();
+                }
+              },
+              error: sink.error
+            });
+            return function () {
+              subscription.unsubscribe();
+
+              if (_this10._scheduler != null && cancellationToken != null) {
+                _this10._scheduler.cancel(cancellationToken);
+              }
+            };
+          }).subscribe({
+            complete: function complete() {
+              _this10._complete(_id3);
+
+              decrementPendingCount();
+            },
+            error: function error(_error4) {
+              _this10._error(_error4);
+
+              decrementPendingCount();
+            },
+            start: function start(subscription) {
+              return _this10._start(_id3, subscription);
+            }
           });
         }
-      }).subscribe({
-        complete: function complete() {
-          _this10._complete(_id3);
 
-          decrementPendingCount();
-        },
-        error: function error(_error4) {
-          _this10._error(_error4);
+        break;
 
-          decrementPendingCount();
-        },
-        start: function start(subscription) {
-          return _this10._start(_id3, subscription);
-        }
-      });
+      case 'ActorPayload':
+        this._processFollowupPayloadWithNormalizationNode(followupPayload, followupPayload.node);
+
+        break;
+
+      default:
+        followupPayload;
+        !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Unexpected followup kind `%s`.', followupPayload.kind) : invariant(false) : void 0;
     }
   };
 
-  _proto._handleModuleImportPayload = function _handleModuleImportPayload(moduleImportPayload, operation) {
-    var relayPayload = this._normalizeModuleImport(moduleImportPayload, operation);
+  _proto._processFollowupPayloadWithNormalizationNode = function _processFollowupPayloadWithNormalizationNode(followupPayload, normalizationNode) {
+    this._handleFollowupPayload(followupPayload, normalizationNode);
 
-    this._publishQueue.commitPayload(this._operation, relayPayload);
+    this._maybeCompleteSubscriptionOperationTracking();
+  };
 
-    if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
-      var updatedOwners = this._publishQueue.run();
+  _proto._handleFollowupPayload = function _handleFollowupPayload(followupPayload, normalizationNode) {
+    var relayPayload = this._normalizeFollowupPayload(followupPayload, normalizationNode);
 
-      this._updateOperationTracker(updatedOwners);
-    }
+    this._getPublishQueueAndSaveActor().commitPayload(this._operation, relayPayload);
 
     this._processPayloadFollowups([relayPayload]);
   }
@@ -860,7 +1013,7 @@ var Executor = /*#__PURE__*/function () {
       parentID = placeholder.selector.dataID;
     } else {
       placeholder;
-      !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'Unsupported incremental placeholder kind `%s`.', placeholder.kind) : invariant(false) : void 0;
+      !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Unsupported incremental placeholder kind `%s`.', placeholder.kind) : invariant(false) : void 0;
     }
 
     var parentRecord = relayPayload.source.get(parentID);
@@ -874,7 +1027,7 @@ var Executor = /*#__PURE__*/function () {
     }); // If an incremental payload exists for some id that record should also
     // exist.
 
-    !(parentRecord != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected record `%s` to exist.', parentID) : invariant(false) : void 0;
+    !(parentRecord != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected record `%s` to exist.', parentID) : invariant(false) : void 0;
     var nextParentRecord;
     var nextParentPayloads;
 
@@ -909,12 +1062,6 @@ var Executor = /*#__PURE__*/function () {
     if (pendingResponses != null) {
       var payloadFollowups = this._processIncrementalResponses(pendingResponses);
 
-      if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
-        var updatedOwners = this._publishQueue.run();
-
-        this._updateOperationTracker(updatedOwners);
-      }
-
       this._processPayloadFollowups(payloadFollowups);
     }
   }
@@ -959,7 +1106,7 @@ var Executor = /*#__PURE__*/function () {
         }
 
         var placeholder = resultForPath.placeholder;
-        !(placeholder.kind === 'defer') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected data for path `%s` for label `%s` ' + 'to be data for @defer, was `@%s`.', pathKey, label, placeholder.kind) : invariant(false) : void 0;
+        !(placeholder.kind === 'defer') ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected data for path `%s` for label `%s` ' + 'to be data for @defer, was `@%s`.', pathKey, label, placeholder.kind) : invariant(false) : void 0;
         relayPayloads.push(_this11._processDeferResponse(label, path, placeholder, response));
       } else {
         // @stream payload path values end in the field name and item index,
@@ -984,7 +1131,7 @@ var Executor = /*#__PURE__*/function () {
         }
 
         var _placeholder = _resultForPath.placeholder;
-        !(_placeholder.kind === 'stream') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected data for path `%s` for label `%s` ' + 'to be data for @stream, was `@%s`.', _pathKey, label, _placeholder.kind) : invariant(false) : void 0;
+        !(_placeholder.kind === 'stream') ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected data for path `%s` for label `%s` ' + 'to be data for @stream, was `@%s`.', _pathKey, label, _placeholder.kind) : invariant(false) : void 0;
         relayPayloads.push(_this11._processStreamResponse(label, path, _placeholder, response));
       }
     });
@@ -992,23 +1139,28 @@ var Executor = /*#__PURE__*/function () {
   };
 
   _proto._processDeferResponse = function _processDeferResponse(label, path, placeholder, response) {
+    var _placeholder$actorIde;
+
     var parentID = placeholder.selector.dataID;
+    var prevActorIdentifier = this._actorIdentifier;
+    this._actorIdentifier = (_placeholder$actorIde = placeholder.actorIdentifier) !== null && _placeholder$actorIde !== void 0 ? _placeholder$actorIde : this._actorIdentifier;
     var 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); // Load the version of the parent record from which this incremental data
+    this._getPublishQueueAndSaveActor().commitPayload(this._operation, relayPayload); // Load the version of the parent record from which this incremental data
     // was derived
 
 
     var parentEntry = this._source.get(parentID);
 
-    !(parentEntry != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected the parent record `%s` for @defer ' + 'data to exist.', parentID) : invariant(false) : void 0;
+    !(parentEntry != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected the parent record `%s` for @defer ' + 'data to exist.', parentID) : invariant(false) : void 0;
     var fieldPayloads = parentEntry.fieldPayloads;
 
     if (fieldPayloads.length !== 0) {
@@ -1018,14 +1170,15 @@ var Executor = /*#__PURE__*/function () {
         errors: null,
         fieldPayloads: fieldPayloads,
         incrementalPlaceholders: null,
-        moduleImportPayloads: null,
+        followupPayloads: null,
         source: RelayRecordSource.create(),
         isFinal: ((_response$extensions2 = response.extensions) === null || _response$extensions2 === void 0 ? void 0 : _response$extensions2.is_final) === true
       };
 
-      this._publishQueue.commitPayload(this._operation, handleFieldsRelayPayload);
+      this._getPublishQueueAndSaveActor().commitPayload(this._operation, handleFieldsRelayPayload);
     }
 
+    this._actorIdentifier = prevActorIdentifier;
     return relayPayload;
   }
   /**
@@ -1036,10 +1189,13 @@ var Executor = /*#__PURE__*/function () {
   _proto._processStreamResponse = function _processStreamResponse(label, path, placeholder, response) {
     var parentID = placeholder.parentID,
         node = placeholder.node,
-        variables = placeholder.variables; // Find the LinkedField where @stream was applied
+        variables = placeholder.variables,
+        actorIdentifier = placeholder.actorIdentifier;
+    var prevActorIdentifier = this._actorIdentifier;
+    this._actorIdentifier = actorIdentifier !== null && actorIdentifier !== void 0 ? actorIdentifier : this._actorIdentifier; // Find the LinkedField where @stream was applied
 
     var field = node.selections[0];
-    !(field != null && field.kind === 'LinkedField' && field.plural === true) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected @stream to be used on a plural field.') : invariant(false) : void 0;
+    !(field != null && field.kind === 'LinkedField' && field.plural === true) ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected @stream to be used on a plural field.') : invariant(false) : void 0;
 
     var _this$_normalizeStrea = this._normalizeStreamItem(response, parentID, field, variables, path, placeholder.path),
         fieldPayloads = _this$_normalizeStrea.fieldPayloads,
@@ -1052,7 +1208,7 @@ var Executor = /*#__PURE__*/function () {
     // modified.
 
 
-    this._publishQueue.commitPayload(this._operation, relayPayload, function (store) {
+    this._getPublishQueueAndSaveActor().commitPayload(this._operation, relayPayload, function (store) {
       var currentParentRecord = store.get(parentID);
 
       if (currentParentRecord == null) {
@@ -1089,14 +1245,15 @@ var Executor = /*#__PURE__*/function () {
         errors: null,
         fieldPayloads: fieldPayloads,
         incrementalPlaceholders: null,
-        moduleImportPayloads: null,
+        followupPayloads: null,
         source: RelayRecordSource.create(),
         isFinal: false
       };
 
-      this._publishQueue.commitPayload(this._operation, handleFieldsRelayPayload);
+      this._getPublishQueueAndSaveActor().commitPayload(this._operation, handleFieldsRelayPayload);
     }
 
+    this._actorIdentifier = prevActorIdentifier;
     return relayPayload;
   };
 
@@ -1104,34 +1261,34 @@ var Executor = /*#__PURE__*/function () {
     var _field$alias, _field$concreteType, _this$_getDataID;
 
     var data = response.data;
-    !(typeof data === 'object') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected the GraphQL @stream payload `data` ' + 'value to be an object.') : invariant(false) : void 0;
+    !(typeof data === 'object') ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected the GraphQL @stream payload `data` ' + 'value to be an object.') : invariant(false) : void 0;
     var responseKey = (_field$alias = field.alias) !== null && _field$alias !== void 0 ? _field$alias : field.name;
     var storageKey = getStorageKey(field, variables); // Load the version of the parent record from which this incremental data
     // was derived
 
     var parentEntry = this._source.get(parentID);
 
-    !(parentEntry != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected the parent record `%s` for @stream ' + 'data to exist.', parentID) : invariant(false) : void 0;
+    !(parentEntry != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected the parent record `%s` for @stream ' + 'data to exist.', parentID) : invariant(false) : void 0;
     var parentRecord = parentEntry.record,
         fieldPayloads = parentEntry.fieldPayloads; // Load the field value (items) that were created by *this* query executor
     // in order to check if there has been any concurrent modifications by some
     // other operation.
 
     var prevIDs = RelayModernRecord.getLinkedRecordIDs(parentRecord, storageKey);
-    !(prevIDs != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected record `%s` to have fetched field ' + '`%s` with @stream.', parentID, field.name) : invariant(false) : void 0; // Determine the index in the field of the new item
+    !(prevIDs != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected record `%s` to have fetched field ' + '`%s` with @stream.', parentID, field.name) : invariant(false) : void 0; // Determine the index in the field of the new item
 
     var finalPathEntry = path[path.length - 1];
     var itemIndex = parseInt(finalPathEntry, 10);
-    !(itemIndex === finalPathEntry && itemIndex >= 0) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected path for @stream to end in a ' + 'positive integer index, got `%s`', finalPathEntry) : invariant(false) : void 0;
+    !(itemIndex === finalPathEntry && itemIndex >= 0) ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected path for @stream to end in a ' + 'positive integer index, got `%s`', finalPathEntry) : invariant(false) : void 0;
     var typeName = (_field$concreteType = field.concreteType) !== null && _field$concreteType !== void 0 ? _field$concreteType : data[TYPENAME_KEY];
-    !(typeof typeName === 'string') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected @stream field `%s` to have a ' + '__typename.', field.name) : invariant(false) : void 0; // Determine the __id of the new item: this must equal the value that would
+    !(typeof typeName === 'string') ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected @stream field `%s` to have a ' + '__typename.', field.name) : invariant(false) : void 0; // Determine the __id of the new item: this must equal the value that would
     // be assigned had the item not been streamed
 
     var itemID = // https://github.com/prettier/prettier/issues/6403
     // prettier-ignore
     ((_this$_getDataID = this._getDataID(data, typeName)) !== null && _this$_getDataID !== void 0 ? _this$_getDataID : prevIDs && prevIDs[itemIndex]) || // Reuse previously generated client IDs
     generateClientID(parentID, storageKey, itemIndex);
-    !(typeof itemID === 'string') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected id of elements of field `%s` to ' + 'be strings.', storageKey) : invariant(false) : void 0; // Build a selector to normalize the item data with
+    !(typeof itemID === 'string') ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected id of elements of field `%s` to ' + 'be strings.', storageKey) : invariant(false) : void 0; // Build a selector to normalize the item data with
 
     var selector = createNormalizationSelector(field, itemID, variables); // Update the cached version of the parent record to reflect the new item:
     // this is used when subsequent stream payloads arrive to see if there
@@ -1148,9 +1305,10 @@ var Executor = /*#__PURE__*/function () {
     });
 
     var relayPayload = normalizeResponse(response, selector, typeName, {
+      actorIdentifier: this._actorIdentifier,
       getDataID: this._getDataID,
       path: [].concat((0, _toConsumableArray2["default"])(normalizationPath), [responseKey, String(itemIndex)]),
-      reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
+      reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer != null ? this._deserializeReactFlightPayloadWithLogging : null,
       reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,
       treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       shouldProcessClientComponents: this._shouldProcessClientComponents
@@ -1165,6 +1323,40 @@ var Executor = /*#__PURE__*/function () {
     };
   };
 
+  _proto._scheduleAsyncStoreUpdate = function _scheduleAsyncStoreUpdate(scheduleFn, completeFn) {
+    var _this12 = this;
+
+    this._completeFns.push(completeFn);
+
+    if (this._asyncStoreUpdateDisposable != null) {
+      return;
+    }
+
+    this._asyncStoreUpdateDisposable = scheduleFn(function () {
+      _this12._asyncStoreUpdateDisposable = null;
+
+      var updatedOwners = _this12._runPublishQueue();
+
+      _this12._updateOperationTracker(updatedOwners);
+
+      var _iterator2 = (0, _createForOfIteratorHelper2["default"])(_this12._completeFns),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var complete = _step2.value;
+          complete();
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+
+      _this12._completeFns = [];
+    });
+  };
+
   _proto._updateOperationTracker = function _updateOperationTracker(updatedOwners) {
     if (updatedOwners != null && updatedOwners.length > 0) {
       this._operationTracker.update(this._operation.request, new Set(updatedOwners));
@@ -1175,6 +1367,88 @@ var Executor = /*#__PURE__*/function () {
     this._operationTracker.complete(this._operation.request);
   };
 
+  _proto._getPublishQueueAndSaveActor = function _getPublishQueueAndSaveActor() {
+    this._seenActors.add(this._actorIdentifier);
+
+    return this._getPublishQueue(this._actorIdentifier);
+  };
+
+  _proto._getActorsToVisit = function _getActorsToVisit() {
+    if (this._seenActors.size === 0) {
+      return new Set([this._actorIdentifier]);
+    } else {
+      return this._seenActors;
+    }
+  };
+
+  _proto._runPublishQueue = function _runPublishQueue(operation) {
+    var updatedOwners = new Set();
+
+    var _iterator3 = (0, _createForOfIteratorHelper2["default"])(this._getActorsToVisit()),
+        _step3;
+
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var _actorIdentifier = _step3.value;
+
+        var owners = this._getPublishQueue(_actorIdentifier).run(operation);
+
+        owners.forEach(function (owner) {
+          return updatedOwners.add(owner);
+        });
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+
+    return Array.from(updatedOwners);
+  };
+
+  _proto._retainData = function _retainData() {
+    var _iterator4 = (0, _createForOfIteratorHelper2["default"])(this._getActorsToVisit()),
+        _step4;
+
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var _actorIdentifier2 = _step4.value;
+
+        if (!this._retainDisposables.has(_actorIdentifier2)) {
+          this._retainDisposables.set(_actorIdentifier2, this._getStore(_actorIdentifier2).retain(this._operation));
+        }
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+  };
+
+  _proto._disposeRetainedData = function _disposeRetainedData() {
+    var _iterator5 = (0, _createForOfIteratorHelper2["default"])(this._retainDisposables.values()),
+        _step5;
+
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var disposable = _step5.value;
+        disposable.dispose();
+      }
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+
+    this._retainDisposables.clear();
+  };
+
+  _proto._expectOperationLoader = function _expectOperationLoader() {
+    var operationLoader = this._operationLoader;
+    !operationLoader ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected an operationLoader to be ' + 'configured when using `@match`.') : invariant(false) : void 0;
+    return operationLoader;
+  };
+
   return Executor;
 }();