relay-runtime 11.0.2 → 12.0.0

package/lib/store/RelayConcreteVariables.js

@@ -16,6 +16,9 @@ var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/obje
 
 var invariant = require('invariant');
 
+var _require = require('./RelayStoreUtils'),
+    getArgumentValues = _require.getArgumentValues;
+
 /**
  * Determines the variables that are in scope for a fragment given the variables
  * in scope at the root query as well as any arguments applied at the fragment
@@ -88,7 +91,25 @@ function getOperationVariables(operation, variables) {
   return operationVariables;
 }
 
+function getLocalVariables(currentVariables, argumentDefinitions, args) {
+  if (argumentDefinitions == null) {
+    return currentVariables;
+  }
+
+  var nextVariables = (0, _objectSpread2["default"])({}, currentVariables);
+  var nextArgs = args ? getArgumentValues(args, currentVariables) : {};
+  argumentDefinitions.forEach(function (def) {
+    var _nextArgs$def$name;
+
+    // $FlowFixMe[cannot-write]
+    var value = (_nextArgs$def$name = nextArgs[def.name]) !== null && _nextArgs$def$name !== void 0 ? _nextArgs$def$name : def.defaultValue;
+    nextVariables[def.name] = value;
+  });
+  return nextVariables;
+}
+
 module.exports = {
+  getLocalVariables: getLocalVariables,
   getFragmentVariables: getFragmentVariables,
   getOperationVariables: getOperationVariables
 };

package/lib/store/RelayModernEnvironment.js

@@ -33,10 +33,16 @@ var defaultGetDataID = require('./defaultGetDataID');
 
 var defaultRequiredFieldLogger = require('./defaultRequiredFieldLogger');
 
-var generateID = require('../util/generateID');
-
 var invariant = require('invariant');
 
+var registerEnvironmentWithDevTools = require('../util/registerEnvironmentWithDevTools');
+
+var wrapNetworkWithLogObserver = require('../network/wrapNetworkWithLogObserver');
+
+var _require = require('../multi-actor-environment/ActorIdentifier'),
+    INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE = _require.INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
+    assertInternalActorIndentifier = _require.assertInternalActorIndentifier;
+
 var RelayModernEnvironment = /*#__PURE__*/function () {
   function RelayModernEnvironment(config) {
     var _this = this;
@@ -64,7 +70,7 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
     this._defaultRenderPolicy = ((_config$UNSTABLE_defa = config.UNSTABLE_defaultRenderPolicy) !== null && _config$UNSTABLE_defa !== void 0 ? _config$UNSTABLE_defa : RelayFeatureFlags.ENABLE_PARTIAL_RENDERING_DEFAULT === true) ? 'partial' : 'full';
     this._operationLoader = operationLoader;
     this._operationExecutions = new Map();
-    this._network = this.__wrapNetworkWithLogObserver(config.network);
+    this._network = wrapNetworkWithLogObserver(this, config.network);
     this._getDataID = (_config$getDataID = config.getDataID) !== null && _config$getDataID !== void 0 ? _config$getDataID : defaultGetDataID;
     this._publishQueue = new RelayPublishQueue(config.store, (_config$handlerProvid = config.handlerProvider) !== null && _config$handlerProvid !== void 0 ? _config$handlerProvid : RelayDefaultHandlerProvider, this._getDataID);
     this._scheduler = (_config$scheduler = config.scheduler) !== null && _config$scheduler !== void 0 ? _config$scheduler : null;
@@ -73,33 +79,26 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
     this._isServer = (_config$isServer = config.isServer) !== null && _config$isServer !== void 0 ? _config$isServer : false;
 
     this.__setNet = function (newNet) {
-      return _this._network = _this.__wrapNetworkWithLogObserver(newNet);
+      return _this._network = wrapNetworkWithLogObserver(_this, newNet);
     };
 
     if (process.env.NODE_ENV !== "production") {
-      var _require = require('./StoreInspector'),
-          inspect = _require.inspect;
+      var _require2 = require('./StoreInspector'),
+          inspect = _require2.inspect;
 
       this.DEBUG_inspect = function (dataID) {
         return inspect(_this, dataID);
       };
-    } // Register this Relay Environment with Relay DevTools if it exists.
-    // Note: this must always be the last step in the constructor.
-
-
-    var _global = typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : undefined;
-
-    var devToolsHook = _global && _global.__RELAY_DEVTOOLS_HOOK__;
-
-    if (devToolsHook) {
-      devToolsHook.registerEnvironment(this);
     }
 
     this._missingFieldHandlers = config.missingFieldHandlers;
     this._operationTracker = (_config$operationTrac = config.operationTracker) !== null && _config$operationTrac !== void 0 ? _config$operationTrac : new RelayOperationTracker();
     this._reactFlightPayloadDeserializer = reactFlightPayloadDeserializer;
     this._reactFlightServerErrorHandler = reactFlightServerErrorHandler;
-    this._shouldProcessClientComponents = config.shouldProcessClientComponents;
+    this._shouldProcessClientComponents = config.shouldProcessClientComponents; // Register this Relay Environment with Relay DevTools if it exists.
+    // Note: this must always be the last step in the constructor.
+
+    registerEnvironmentWithDevTools(this);
   }
 
   var _proto = RelayModernEnvironment.prototype;
@@ -241,9 +240,19 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
 
     var target = RelayRecordSource.create();
 
+    var source = this._store.getSource();
+
     var result = this._store.check(operation, {
-      target: target,
-      handlers: handlers
+      handlers: handlers,
+      defaultActorIdentifier: INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
+      getSourceForActor: function getSourceForActor(actorIdentifier) {
+        assertInternalActorIndentifier(actorIdentifier);
+        return source;
+      },
+      getTargetForActor: function getTargetForActor(actorIdentifier) {
+        assertInternalActorIndentifier(actorIdentifier);
+        return target;
+      }
     });
 
     if (target.size() > 0) {
@@ -336,7 +345,7 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
   /**
    * Returns an Observable of GraphQLResponse resulting from executing the
    * provided Query or Subscription operation responses, the result of which is
-   * then normalized and comitted to the publish queue.
+   * then normalized and committed to the publish queue.
    *
    * Note: Observables are lazy, so calling this method will do nothing until
    * the result is subscribed to:
@@ -372,16 +381,23 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
         operation = _ref4.operation,
         optimisticConfig = _ref4.optimisticConfig,
         updater = _ref4.updater;
+    var publishQueue = this._publishQueue;
+    var store = this._store;
     return RelayObservable.create(function (sink) {
       var executor = OperationExecutor.execute({
+        actorIdentifier: INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
         getDataID: _this9._getDataID,
         isClientPayload: isClientPayload,
+        log: _this9.__log,
         operation: operation,
         operationExecutions: _this9._operationExecutions,
         operationLoader: _this9._operationLoader,
         operationTracker: _this9._operationTracker,
         optimisticConfig: optimisticConfig,
-        publishQueue: _this9._publishQueue,
+        getPublishQueue: function getPublishQueue(actorIdentifier) {
+          assertInternalActorIndentifier(actorIdentifier);
+          return publishQueue;
+        },
         reactFlightPayloadDeserializer: _this9._reactFlightPayloadDeserializer,
         reactFlightServerErrorHandler: _this9._reactFlightServerErrorHandler,
         scheduler: _this9._scheduler,
@@ -390,7 +406,10 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
         // NOTE: Some product tests expect `Network.execute` to be called only
         //       when the Observable is executed.
         source: createSource(),
-        store: _this9._store,
+        getStore: function getStore(actorIdentifier) {
+          assertInternalActorIndentifier(actorIdentifier);
+          return store;
+        },
         treatMissingFieldsAsNull: _this9._treatMissingFieldsAsNull,
         updater: updater
       });
@@ -398,69 +417,6 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
         return executor.cancel();
       };
     });
-  }
-  /**
-   * Wraps the network with logging to ensure that network requests are
-   * always logged. Relying on each network callsite to be wrapped is
-   * untenable and will eventually lead to holes in the logging.
-   */
-  ;
-
-  _proto.__wrapNetworkWithLogObserver = function __wrapNetworkWithLogObserver(network) {
-    var that = this;
-    return {
-      execute: function execute(params, variables, cacheConfig, uploadables) {
-        var transactionID = generateID();
-        var log = that.__log;
-        var logObserver = {
-          start: function start(subscription) {
-            log({
-              name: 'network.start',
-              transactionID: transactionID,
-              params: params,
-              variables: variables,
-              cacheConfig: cacheConfig
-            });
-          },
-          next: function next(response) {
-            log({
-              name: 'network.next',
-              transactionID: transactionID,
-              response: response
-            });
-          },
-          error: function error(_error) {
-            log({
-              name: 'network.error',
-              transactionID: transactionID,
-              error: _error
-            });
-          },
-          complete: function complete() {
-            log({
-              name: 'network.complete',
-              transactionID: transactionID
-            });
-          },
-          unsubscribe: function unsubscribe() {
-            log({
-              name: 'network.unsubscribe',
-              transactionID: transactionID
-            });
-          }
-        };
-
-        var logRequestInfo = function logRequestInfo(info) {
-          log({
-            name: 'network.info',
-            transactionID: transactionID,
-            info: info
-          });
-        };
-
-        return network.execute(params, variables, cacheConfig, uploadables, logRequestInfo)["do"](logObserver);
-      }
-    };
   };
 
   return RelayModernEnvironment;

package/lib/store/RelayModernFragmentSpecResolver.js

@@ -20,24 +20,25 @@ var RelayFeatureFlags = require('../util/RelayFeatureFlags');
 
 var areEqual = require("fbjs/lib/areEqual");
 
+var getPendingOperationsForFragment = require('../util/getPendingOperationsForFragment');
+
 var invariant = require('invariant');
 
 var isScalarAndEqual = require('../util/isScalarAndEqual');
 
+var recycleNodesInto = require('../util/recycleNodesInto');
+
 var reportMissingRequiredFields = require('../util/reportMissingRequiredFields');
 
 var warning = require("fbjs/lib/warning");
 
-var _require = require('../query/fetchQueryInternal'),
-    getPromiseForActiveRequest = _require.getPromiseForActiveRequest;
+var _require = require('./RelayModernOperationDescriptor'),
+    createRequestDescriptor = _require.createRequestDescriptor;
 
-var _require2 = require('./RelayModernOperationDescriptor'),
-    createRequestDescriptor = _require2.createRequestDescriptor;
-
-var _require3 = require('./RelayModernSelector'),
-    areEqualSelectors = _require3.areEqualSelectors,
-    createReaderSelector = _require3.createReaderSelector,
-    getSelectorsFromObject = _require3.getSelectorsFromObject;
+var _require2 = require('./RelayModernSelector'),
+    areEqualSelectors = _require2.areEqualSelectors,
+    createReaderSelector = _require2.createReaderSelector,
+    getSelectorsFromObject = _require2.getSelectorsFromObject;
 
 /**
  * A utility for resolving and subscribing to the results of a fragment spec
@@ -129,13 +130,17 @@ var RelayModernFragmentSpecResolver = /*#__PURE__*/function () {
     return this._data;
   };
 
-  _proto.setCallback = function setCallback(callback) {
+  _proto.setCallback = function setCallback(props, callback) {
     this._callback = callback;
+
+    if (RelayFeatureFlags.ENABLE_CONTAINERS_SUBSCRIBE_ON_COMMIT === true) {
+      this.setProps(props);
+    }
   };
 
   _proto.setProps = function setProps(props) {
-    var ownedSelectors = getSelectorsFromObject(this._fragments, props);
     this._props = {};
+    var ownedSelectors = getSelectorsFromObject(this._fragments, props);
 
     for (var _key3 in ownedSelectors) {
       if (ownedSelectors.hasOwnProperty(_key3)) {
@@ -150,14 +155,14 @@ var RelayModernFragmentSpecResolver = /*#__PURE__*/function () {
           resolver = null;
         } else if (ownedSelector.kind === 'PluralReaderSelector') {
           if (resolver == null) {
-            resolver = new SelectorListResolver(this._context.environment, this._rootIsQueryRenderer, ownedSelector, this._onChange);
+            resolver = new SelectorListResolver(this._context.environment, this._rootIsQueryRenderer, ownedSelector, this._callback != null, this._onChange);
           } else {
             !(resolver instanceof SelectorListResolver) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernFragmentSpecResolver: Expected prop `%s` to always be an array.', _key3) : invariant(false) : void 0;
             resolver.setSelector(ownedSelector);
           }
         } else {
           if (resolver == null) {
-            resolver = new SelectorResolver(this._context.environment, this._rootIsQueryRenderer, ownedSelector, this._onChange);
+            resolver = new SelectorResolver(this._context.environment, this._rootIsQueryRenderer, ownedSelector, this._callback != null, this._onChange);
           } else {
             !(resolver instanceof SelectorResolver) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernFragmentSpecResolver: Expected prop `%s` to always be an object.', _key3) : invariant(false) : void 0;
             resolver.setSelector(ownedSelector);
@@ -194,7 +199,7 @@ var RelayModernFragmentSpecResolver = /*#__PURE__*/function () {
 
 
 var SelectorResolver = /*#__PURE__*/function () {
-  function SelectorResolver(environment, rootIsQueryRenderer, selector, callback) {
+  function SelectorResolver(environment, rootIsQueryRenderer, selector, subscribeOnConstruction, callback) {
     var _this2 = this;
 
     (0, _defineProperty2["default"])(this, "_onChange", function (snapshot) {
@@ -214,7 +219,14 @@ var SelectorResolver = /*#__PURE__*/function () {
     this._environment = environment;
     this._rootIsQueryRenderer = rootIsQueryRenderer;
     this._selector = selector;
-    this._subscription = environment.subscribe(_snapshot, this._onChange);
+
+    if (RelayFeatureFlags.ENABLE_CONTAINERS_SUBSCRIBE_ON_COMMIT === true) {
+      if (subscribeOnConstruction) {
+        this._subscription = environment.subscribe(_snapshot, this._onChange);
+      }
+    } else {
+      this._subscription = environment.subscribe(_snapshot, this._onChange);
+    }
   }
 
   var _proto2 = SelectorResolver.prototype;
@@ -228,9 +240,7 @@ var SelectorResolver = /*#__PURE__*/function () {
   };
 
   _proto2.resolve = function resolve() {
-    if (RelayFeatureFlags.ENABLE_RELAY_CONTAINERS_SUSPENSE === true && this._isMissingData === true) {
-      var _getPromiseForActiveR;
-
+    if (this._isMissingData === true) {
       // NOTE: This branch exists to handle the case in which:
       // - A RelayModern container is rendered as a descendant of a Relay Hook
       //   root using a "partial" renderPolicy (this means that eargerly
@@ -252,13 +262,28 @@ var SelectorResolver = /*#__PURE__*/function () {
       // This should eventually go away with something like @optional, where we only
       // suspend at specific boundaries depending on whether the boundary
       // can be fulfilled or not.
-      var promise = (_getPromiseForActiveR = getPromiseForActiveRequest(this._environment, this._selector.owner)) !== null && _getPromiseForActiveR !== void 0 ? _getPromiseForActiveR : this._environment.getOperationTracker().getPromiseForPendingOperationsAffectingOwner(this._selector.owner);
+      var pendingOperationsResult = getPendingOperationsForFragment(this._environment, this._selector.node, this._selector.owner);
+      var promise = pendingOperationsResult === null || pendingOperationsResult === void 0 ? void 0 : pendingOperationsResult.promise;
 
       if (promise != null) {
         if (this._rootIsQueryRenderer) {
           process.env.NODE_ENV !== "production" ? warning(false, 'Relay: Relay Container for fragment `%s` has missing data and ' + 'would suspend. When using features such as @defer or @module, ' + 'use `useFragment` instead of a Relay Container.', this._selector.node.name) : void 0;
         } else {
+          var _pendingOperationsRes;
+
+          var pendingOperations = (_pendingOperationsRes = pendingOperationsResult === null || pendingOperationsResult === void 0 ? void 0 : pendingOperationsResult.pendingOperations) !== null && _pendingOperationsRes !== void 0 ? _pendingOperationsRes : [];
           process.env.NODE_ENV !== "production" ? warning(false, 'Relay: Relay Container for fragment `%s` suspended. When using ' + 'features such as @defer or @module, use `useFragment` instead ' + 'of a Relay Container.', this._selector.node.name) : void 0;
+
+          this._environment.__log({
+            name: 'suspense.fragment',
+            data: this._data,
+            fragment: this._selector.node,
+            isRelayHooks: false,
+            isMissingData: this._isMissingData,
+            isPromiseCached: false,
+            pendingOperations: pendingOperations
+          });
+
           throw promise;
         }
       }
@@ -280,7 +305,7 @@ var SelectorResolver = /*#__PURE__*/function () {
 
     var snapshot = this._environment.lookup(selector);
 
-    this._data = snapshot.data;
+    this._data = recycleNodesInto(this._data, snapshot.data);
     this._isMissingData = snapshot.isMissingData;
     this._missingRequiredFields = snapshot.missingRequiredFields;
     this._selector = selector;
@@ -319,7 +344,7 @@ var SelectorResolver = /*#__PURE__*/function () {
 
 
 var SelectorListResolver = /*#__PURE__*/function () {
-  function SelectorListResolver(environment, rootIsQueryRenderer, selector, callback) {
+  function SelectorListResolver(environment, rootIsQueryRenderer, selector, subscribeOnConstruction, callback) {
     var _this3 = this;
 
     (0, _defineProperty2["default"])(this, "_onChange", function (data) {
@@ -333,6 +358,7 @@ var SelectorListResolver = /*#__PURE__*/function () {
     this._resolvers = [];
     this._stale = true;
     this._rootIsQueryRenderer = rootIsQueryRenderer;
+    this._subscribeOnConstruction = subscribeOnConstruction;
     this.setSelector(selector);
   }
 
@@ -384,7 +410,7 @@ var SelectorListResolver = /*#__PURE__*/function () {
       if (ii < this._resolvers.length) {
         this._resolvers[ii].setSelector(selectors[ii]);
       } else {
-        this._resolvers[ii] = new SelectorResolver(this._environment, this._rootIsQueryRenderer, selectors[ii], this._onChange);
+        this._resolvers[ii] = new SelectorResolver(this._environment, this._rootIsQueryRenderer, selectors[ii], this._subscribeOnConstruction, this._onChange);
       }
     }
 

package/lib/store/RelayModernRecord.js

@@ -26,6 +26,7 @@ var _require = require('./ClientID'),
     isClientID = _require.isClientID;
 
 var _require2 = require('./RelayStoreUtils'),
+    ACTOR_IDENTIFIER_KEY = _require2.ACTOR_IDENTIFIER_KEY,
     ID_KEY = _require2.ID_KEY,
     REF_KEY = _require2.REF_KEY,
     REFS_KEY = _require2.REFS_KEY,
@@ -336,6 +337,37 @@ function setLinkedRecordIDs(record, storageKey, linkedIDs) {
   links[REFS_KEY] = linkedIDs;
   record[storageKey] = links;
 }
+/**
+ * @public
+ *
+ * Set the value of a field to a reference to another record in the actor specific store.
+ */
+
+
+function setActorLinkedRecordID(record, storageKey, actorIdentifier, linkedID) {
+  // See perf note above for why we aren't using computed property access.
+  var link = {};
+  link[REF_KEY] = linkedID;
+  link[ACTOR_IDENTIFIER_KEY] = actorIdentifier;
+  record[storageKey] = link;
+}
+/**
+ * @public
+ *
+ * Get link to a record and the actor identifier for the store.
+ */
+
+
+function getActorLinkedRecordID(record, storageKey) {
+  var link = record[storageKey];
+
+  if (link == null) {
+    return link;
+  }
+
+  !(typeof link === 'object' && typeof link[REF_KEY] === 'string' && link[ACTOR_IDENTIFIER_KEY] != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernRecord.getActorLinkedRecordID(): Expected `%s.%s` to be an actor specific linked ID, ' + 'was `%s`.', record[ID_KEY], storageKey, JSON.stringify(link)) : invariant(false) : void 0;
+  return [link[ACTOR_IDENTIFIER_KEY], link[REF_KEY]];
+}
 
 module.exports = {
   clone: clone,
@@ -352,5 +384,7 @@ module.exports = {
   setValue: setValue,
   setLinkedRecordID: setLinkedRecordID,
   setLinkedRecordIDs: setLinkedRecordIDs,
-  update: update
+  update: update,
+  getActorLinkedRecordID: getActorLinkedRecordID,
+  setActorLinkedRecordID: setActorLinkedRecordID
 };

package/lib/store/RelayModernStore.js

@@ -32,8 +32,6 @@ var RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');
 
 var RelayStoreSubscriptions = require('./RelayStoreSubscriptions');
 
-var RelayStoreSubscriptionsUsingMapByID = require('./RelayStoreSubscriptionsUsingMapByID');
-
 var RelayStoreUtils = require('./RelayStoreUtils');
 
 var deepFreeze = require('../util/deepFreeze');
@@ -44,9 +42,16 @@ var invariant = require('invariant');
 
 var resolveImmediate = require('../util/resolveImmediate');
 
-var _require = require('./RelayStoreUtils'),
-    ROOT_ID = _require.ROOT_ID,
-    ROOT_TYPE = _require.ROOT_TYPE;
+var _require = require('../multi-actor-environment/ActorIdentifier'),
+    INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE = _require.INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
+    assertInternalActorIndentifier = _require.assertInternalActorIndentifier;
+
+var _require2 = require('./RelayStoreUtils'),
+    ROOT_ID = _require2.ROOT_ID,
+    ROOT_TYPE = _require2.ROOT_TYPE;
+
+var _require3 = require('./ResolverCache'),
+    RecordResolverCache = _require3.RecordResolverCache;
 
 var DEFAULT_RELEASE_BUFFER_SIZE = 10;
 /**
@@ -108,7 +113,10 @@ var RelayModernStore = /*#__PURE__*/function () {
     this._releaseBuffer = [];
     this._roots = new Map();
     this._shouldScheduleGC = false;
-    this._storeSubscriptions = RelayFeatureFlags.ENABLE_STORE_SUBSCRIPTIONS_REFACTOR === true ? new RelayStoreSubscriptionsUsingMapByID(options === null || options === void 0 ? void 0 : options.log) : new RelayStoreSubscriptions(options === null || options === void 0 ? void 0 : options.log);
+    this._resolverCache = new RecordResolverCache(function () {
+      return _this._getMutableRecordSource();
+    });
+    this._storeSubscriptions = new RelayStoreSubscriptions(options === null || options === void 0 ? void 0 : options.log, this._resolverCache);
     this._updatedRecordIDs = new Set();
     this._shouldProcessClientComponents = options === null || options === void 0 ? void 0 : options.shouldProcessClientComponents;
     initializeRecordSource(this._recordSource);
@@ -122,11 +130,19 @@ var RelayModernStore = /*#__PURE__*/function () {
     return (_this$_optimisticSour = this._optimisticSource) !== null && _this$_optimisticSour !== void 0 ? _this$_optimisticSour : this._recordSource;
   };
 
+  _proto._getMutableRecordSource = function _getMutableRecordSource() {
+    var _this$_optimisticSour2;
+
+    return (_this$_optimisticSour2 = this._optimisticSource) !== null && _this$_optimisticSour2 !== void 0 ? _this$_optimisticSour2 : this._recordSource;
+  };
+
   _proto.check = function check(operation, options) {
-    var _this$_optimisticSour2, _options$target, _options$handlers;
+    var _options$handlers, _options$getSourceFor, _options$getTargetFor, _options$defaultActor;
 
     var selector = operation.root;
-    var source = (_this$_optimisticSour2 = this._optimisticSource) !== null && _this$_optimisticSour2 !== void 0 ? _this$_optimisticSour2 : this._recordSource;
+
+    var source = this._getMutableRecordSource();
+
     var globalInvalidationEpoch = this._globalInvalidationEpoch;
 
     var rootEntry = this._roots.get(operation.request.identifier);
@@ -135,7 +151,7 @@ var RelayModernStore = /*#__PURE__*/function () {
 
     if (globalInvalidationEpoch != null) {
       // If so, check if the operation we're checking was last written
-      // before or after invalidation occured.
+      // before or after invalidation occurred.
       if (operationLastWrittenAt == null || operationLastWrittenAt <= globalInvalidationEpoch) {
         // If the operation was written /before/ global invalidation occurred,
         // or if this operation has never been written to the store before,
@@ -147,9 +163,16 @@ var RelayModernStore = /*#__PURE__*/function () {
       }
     }
 
-    var target = (_options$target = options === null || options === void 0 ? void 0 : options.target) !== null && _options$target !== void 0 ? _options$target : source;
     var handlers = (_options$handlers = options === null || options === void 0 ? void 0 : options.handlers) !== null && _options$handlers !== void 0 ? _options$handlers : [];
-    var operationAvailability = DataChecker.check(source, target, selector, handlers, this._operationLoader, this._getDataID, this._shouldProcessClientComponents);
+    var getSourceForActor = (_options$getSourceFor = options === null || options === void 0 ? void 0 : options.getSourceForActor) !== null && _options$getSourceFor !== void 0 ? _options$getSourceFor : function (actorIdentifier) {
+      assertInternalActorIndentifier(actorIdentifier);
+      return source;
+    };
+    var getTargetForActor = (_options$getTargetFor = options === null || options === void 0 ? void 0 : options.getTargetForActor) !== null && _options$getTargetFor !== void 0 ? _options$getTargetFor : function (actorIdentifier) {
+      assertInternalActorIndentifier(actorIdentifier);
+      return source;
+    };
+    var operationAvailability = DataChecker.check(getSourceForActor, getTargetForActor, (_options$defaultActor = options === null || options === void 0 ? void 0 : options.defaultActorIdentifier) !== null && _options$defaultActor !== void 0 ? _options$defaultActor : INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE, selector, handlers, this._operationLoader, this._getDataID, this._shouldProcessClientComponents);
     return getAvailabilityStatus(operationAvailability, operationLastWrittenAt, rootEntry === null || rootEntry === void 0 ? void 0 : rootEntry.fetchTime, this._queryCacheExpirationTime);
   };
 
@@ -234,7 +257,7 @@ var RelayModernStore = /*#__PURE__*/function () {
 
   _proto.lookup = function lookup(selector) {
     var source = this.getSource();
-    var snapshot = RelayReader.read(source, selector);
+    var snapshot = RelayReader.read(source, selector, this._resolverCache);
 
     if (process.env.NODE_ENV !== "production") {
       deepFreeze(snapshot);
@@ -264,6 +287,14 @@ var RelayModernStore = /*#__PURE__*/function () {
       this._globalInvalidationEpoch = this._currentWriteEpoch;
     }
 
+    if (RelayFeatureFlags.ENABLE_RELAY_RESOLVERS) {
+      // When a record is updated, we need to also handle records that depend on it,
+      // specifically Relay Resolver result records containing results based on the
+      // updated records. This both adds to updatedRecordIDs and invalidates any
+      // cached data as needed.
+      this._resolverCache.invalidateDataIDs(this._updatedRecordIDs);
+    }
+
     var source = this.getSource();
     var updatedOwners = [];
 
@@ -322,9 +353,8 @@ var RelayModernStore = /*#__PURE__*/function () {
   };
 
   _proto.publish = function publish(source, idsMarkedForInvalidation) {
-    var _this$_optimisticSour3;
+    var target = this._getMutableRecordSource();
 
-    var target = (_this$_optimisticSour3 = this._optimisticSource) !== null && _this$_optimisticSour3 !== void 0 ? _this$_optimisticSour3 : this._recordSource;
     updateTargetFromSource(target, source, // We increment the current epoch at the end of the set of updates,
     // in notify(). Here, we pass what will be the incremented value of
     // the epoch to use to write to invalidated records.
@@ -375,6 +405,10 @@ var RelayModernStore = /*#__PURE__*/function () {
 
   _proto.toJSON = function toJSON() {
     return 'RelayModernStore()';
+  };
+
+  _proto.getEpoch = function getEpoch() {
+    return this._currentWriteEpoch;
   } // Internal API
   ;