relay-runtime 7.0.0 → 9.1.0

package/lib/store/RelayModernStore.js

@@ -7,15 +7,16 @@
  * 
  * @format
  */
+// flowlint ambiguous-object-type:error
 'use strict';
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+function _createForOfIteratorHelper(o) { if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var it, normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-var DataChecker = require('./DataChecker');
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-var RelayFeatureFlags = require('../util/RelayFeatureFlags');
+var DataChecker = require('./DataChecker');
 
 var RelayModernRecord = require('./RelayModernRecord');
 
@@ -27,6 +28,8 @@ var RelayReader = require('./RelayReader');
 
 var RelayReferenceMarker = require('./RelayReferenceMarker');
 
+var RelayStoreUtils = require('./RelayStoreUtils');
+
 var deepFreeze = require('../util/deepFreeze');
 
 var defaultGetDataID = require('./defaultGetDataID');
@@ -39,8 +42,9 @@ var recycleNodesInto = require('../util/recycleNodesInto');
 
 var resolveImmediate = require('../util/resolveImmediate');
 
-var _require = require('./RelayModernSelector'),
-    createReaderSelector = _require.createReaderSelector;
+var _require = require('./RelayStoreUtils'),
+    ROOT_ID = _require.ROOT_ID,
+    ROOT_TYPE = _require.ROOT_TYPE;
 
 var DEFAULT_RELEASE_BUFFER_SIZE = 0;
 /**
@@ -56,11 +60,9 @@ var DEFAULT_RELEASE_BUFFER_SIZE = 0;
  * is also enforced in development mode by freezing all records passed to a store.
  */
 
-var RelayModernStore =
-/*#__PURE__*/
-function () {
+var RelayModernStore = /*#__PURE__*/function () {
   function RelayModernStore(source, options) {
-    var _ref, _ref2, _ref3, _ref4;
+    var _options$gcReleaseBuf, _options$gcScheduler, _options$UNSTABLE_DO_, _options$operationLoa;
 
     // Prevent mutation of a record from outside the store.
     if (process.env.NODE_ENV !== "production") {
@@ -75,23 +77,26 @@ function () {
       }
     }
 
-    this._connectionEvents = new Map();
-    this._connectionSubscriptions = new Map();
+    this._currentWriteEpoch = 0;
     this._gcHoldCounter = 0;
-    this._gcReleaseBufferSize = (_ref = options === null || options === void 0 ? void 0 : options.gcReleaseBufferSize) !== null && _ref !== void 0 ? _ref : DEFAULT_RELEASE_BUFFER_SIZE;
-    this._gcScheduler = (_ref2 = options === null || options === void 0 ? void 0 : options.gcScheduler) !== null && _ref2 !== void 0 ? _ref2 : resolveImmediate;
-    this._getDataID = (_ref3 = options === null || options === void 0 ? void 0 : options.UNSTABLE_DO_NOT_USE_getDataID) !== null && _ref3 !== void 0 ? _ref3 : defaultGetDataID;
+    this._gcReleaseBufferSize = (_options$gcReleaseBuf = options === null || options === void 0 ? void 0 : options.gcReleaseBufferSize) !== null && _options$gcReleaseBuf !== void 0 ? _options$gcReleaseBuf : DEFAULT_RELEASE_BUFFER_SIZE;
+    this._gcScheduler = (_options$gcScheduler = options === null || options === void 0 ? void 0 : options.gcScheduler) !== null && _options$gcScheduler !== void 0 ? _options$gcScheduler : resolveImmediate;
+    this._getDataID = (_options$UNSTABLE_DO_ = options === null || options === void 0 ? void 0 : options.UNSTABLE_DO_NOT_USE_getDataID) !== null && _options$UNSTABLE_DO_ !== void 0 ? _options$UNSTABLE_DO_ : defaultGetDataID;
+    this._globalInvalidationEpoch = null;
     this._hasScheduledGC = false;
     this._index = 0;
-    this._operationLoader = (_ref4 = options === null || options === void 0 ? void 0 : options.operationLoader) !== null && _ref4 !== void 0 ? _ref4 : null;
+    this._invalidationSubscriptions = new Set();
+    this._invalidatedRecordIDs = new Set();
+    this._queryCacheExpirationTime = options === null || options === void 0 ? void 0 : options.queryCacheExpirationTime;
+    this._operationLoader = (_options$operationLoa = options === null || options === void 0 ? void 0 : options.operationLoader) !== null && _options$operationLoa !== void 0 ? _options$operationLoa : null;
     this._optimisticSource = null;
     this._recordSource = source;
     this._releaseBuffer = [];
     this._roots = new Map();
     this._shouldScheduleGC = false;
     this._subscriptions = new Set();
-    this._updatedConnectionIDs = {};
     this._updatedRecordIDs = {};
+    initializeRecordSource(this._recordSource);
   }
 
   var _proto = RelayModernStore.prototype;
@@ -102,48 +107,110 @@ function () {
     return (_this$_optimisticSour = this._optimisticSource) !== null && _this$_optimisticSour !== void 0 ? _this$_optimisticSour : this._recordSource;
   };
 
-  _proto.getConnectionEvents_UNSTABLE = function getConnectionEvents_UNSTABLE(connectionID) {
-    var events = this._connectionEvents.get(connectionID);
-
-    if (events != null) {
-      var _events$optimistic;
+  _proto.check = function check(operation, options) {
+    var _this$_optimisticSour2, _options$target, _options$handlers;
 
-      return (_events$optimistic = events.optimistic) !== null && _events$optimistic !== void 0 ? _events$optimistic : events["final"];
+    var selector = operation.root;
+    var source = (_this$_optimisticSour2 = this._optimisticSource) !== null && _this$_optimisticSour2 !== void 0 ? _this$_optimisticSour2 : this._recordSource;
+    var globalInvalidationEpoch = this._globalInvalidationEpoch;
+
+    var rootEntry = this._roots.get(operation.request.identifier);
+
+    var operationLastWrittenAt = rootEntry != null ? rootEntry.epoch : null; // Check if store has been globally invalidated
+
+    if (globalInvalidationEpoch != null) {
+      // If so, check if the operation we're checking was last written
+      // before or after invalidation occured.
+      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,
+        // we will consider the data for this operation to be stale
+        // (i.e. not resolvable from the store).
+        return {
+          status: 'stale'
+        };
+      }
     }
+
+    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);
+    return getAvailabilityStatus(operationAvailability, operationLastWrittenAt, rootEntry === null || rootEntry === void 0 ? void 0 : rootEntry.fetchTime, this._queryCacheExpirationTime);
   };
 
-  _proto.check = function check(selector) {
+  _proto.retain = function retain(operation) {
     var _this = this;
 
-    var _this$_optimisticSour2;
+    var id = operation.request.identifier;
+    var disposed = false;
 
-    var source = (_this$_optimisticSour2 = this._optimisticSource) !== null && _this$_optimisticSour2 !== void 0 ? _this$_optimisticSour2 : this._recordSource;
-    return DataChecker.check(source, source, selector, [], this._operationLoader, this._getDataID, function (id) {
-      return _this.getConnectionEvents_UNSTABLE(id);
-    });
-  };
+    var dispose = function dispose() {
+      // Ensure each retain can only dispose once
+      if (disposed) {
+        return;
+      }
 
-  _proto.retain = function retain(selector) {
-    var _this2 = this;
+      disposed = true; // For Flow: guard against the entry somehow not existing
 
-    var index = this._index++;
+      var rootEntry = _this._roots.get(id);
 
-    var dispose = function dispose() {
-      // When disposing, move the selector onto the release buffer
-      _this2._releaseBuffer.push(index); // Only when the release buffer is full do we actually
-      // release the selector and run GC
+      if (rootEntry == null) {
+        return;
+      } // Decrement the ref count: if it becomes zero it is eligible
+      // for release.
+
+
+      rootEntry.refCount--;
+
+      if (rootEntry.refCount === 0) {
+        var _queryCacheExpirationTime = _this._queryCacheExpirationTime;
+
+        var rootEntryIsStale = rootEntry.fetchTime != null && _queryCacheExpirationTime != null && rootEntry.fetchTime <= Date.now() - _queryCacheExpirationTime;
 
+        if (rootEntryIsStale) {
+          _this._roots["delete"](id);
 
-      if (_this2._releaseBuffer.length > _this2._gcReleaseBufferSize) {
-        var idx = _this2._releaseBuffer.shift();
+          _this._scheduleGC();
+        } else {
+          _this._releaseBuffer.push(id); // If the release buffer is now over-full, remove the least-recently
+          // added entry and schedule a GC. Note that all items in the release
+          // buffer have a refCount of 0.
 
-        _this2._roots["delete"](idx);
 
-        _this2._scheduleGC();
+          if (_this._releaseBuffer.length > _this._gcReleaseBufferSize) {
+            var _id = _this._releaseBuffer.shift();
+
+            _this._roots["delete"](_id);
+
+            _this._scheduleGC();
+          }
+        }
       }
     };
 
-    this._roots.set(index, selector);
+    var rootEntry = this._roots.get(id);
+
+    if (rootEntry != null) {
+      if (rootEntry.refCount === 0) {
+        // This entry should be in the release buffer, but it no longer belongs
+        // there since it's retained. Remove it to maintain the invariant that
+        // all release buffer entries have a refCount of 0.
+        this._releaseBuffer = this._releaseBuffer.filter(function (_id) {
+          return _id !== id;
+        });
+      } // If we've previously retained this operation, increment the refCount
+
+
+      rootEntry.refCount += 1;
+    } else {
+      // Otherwise create a new entry for the operation
+      this._roots.set(id, {
+        operation: operation,
+        refCount: 1,
+        epoch: null,
+        fetchTime: null
+      });
+    }
 
     return {
       dispose: dispose
@@ -159,61 +226,86 @@ function () {
     }
 
     return snapshot;
-  } // This method will return a list of updated owners form the subscriptions
+  } // This method will return a list of updated owners from the subscriptions
   ;
 
-  _proto.notify = function notify() {
-    var _this3 = this;
+  _proto.notify = function notify(sourceOperation, invalidateStore) {
+    var _this2 = this;
+
+    // Increment the current write when notifying after executing
+    // a set of changes to the store.
+    this._currentWriteEpoch++;
+
+    if (invalidateStore === true) {
+      this._globalInvalidationEpoch = this._currentWriteEpoch;
+    }
 
     var source = this.getSource();
     var updatedOwners = [];
 
     this._subscriptions.forEach(function (subscription) {
-      var owner = _this3._updateSubscription(source, subscription);
+      var owner = _this2._updateSubscription(source, subscription);
 
       if (owner != null) {
         updatedOwners.push(owner);
       }
     });
 
-    this._connectionSubscriptions.forEach(function (subscription, id) {
-      if (subscription.stale) {
-        subscription.stale = false;
-        subscription.callback(subscription.snapshot);
-      }
+    this._invalidationSubscriptions.forEach(function (subscription) {
+      _this2._updateInvalidationSubscription(subscription, invalidateStore === true);
     });
 
-    this._updatedConnectionIDs = {};
     this._updatedRecordIDs = {};
-    return updatedOwners;
-  };
 
-  _proto.publish = function publish(source) {
-    var _this4 = this;
-
-    var _this$_optimisticSour3;
-
-    var target = (_this$_optimisticSour3 = this._optimisticSource) !== null && _this$_optimisticSour3 !== void 0 ? _this$_optimisticSour3 : this._recordSource;
-    updateTargetFromSource(target, source, this._updatedRecordIDs);
+    this._invalidatedRecordIDs.clear(); // If a source operation was provided (indicating the operation
+    // that produced this update to the store), record the current epoch
+    // at which this operation was written.
+
+
+    if (sourceOperation != null) {
+      // We only track the epoch at which the operation was written if
+      // it was previously retained, to keep the size of our operation
+      // epoch map bounded. If a query wasn't retained, we assume it can
+      // may be deleted at any moment and thus is not relevant for us to track
+      // for the purposes of invalidation.
+      var id = sourceOperation.request.identifier;
+
+      var rootEntry = this._roots.get(id);
+
+      if (rootEntry != null) {
+        rootEntry.epoch = this._currentWriteEpoch;
+        rootEntry.fetchTime = Date.now();
+      } else if (sourceOperation.request.node.params.operationKind === 'query' && this._gcReleaseBufferSize > 0 && this._releaseBuffer.length < this._gcReleaseBufferSize) {
+        // The operation isn't retained but there is space in the release buffer:
+        // temporarily track this operation in case the data can be reused soon.
+        var temporaryRootEntry = {
+          operation: sourceOperation,
+          refCount: 0,
+          epoch: this._currentWriteEpoch,
+          fetchTime: Date.now()
+        };
 
-    this._connectionSubscriptions.forEach(function (subscription, id) {
-      var hasStoreUpdates = hasOverlappingIDs(subscription.snapshot.seenRecords, _this4._updatedRecordIDs);
+        this._releaseBuffer.push(id);
 
-      if (!hasStoreUpdates) {
-        return;
+        this._roots.set(id, temporaryRootEntry);
       }
+    }
 
-      var nextSnapshot = _this4._updateConnection_UNSTABLE(subscription.resolver, subscription.snapshot, source, null);
+    return updatedOwners;
+  };
 
-      if (nextSnapshot) {
-        subscription.snapshot = nextSnapshot;
-        subscription.stale = true;
-      }
-    });
+  _proto.publish = function publish(source, idsMarkedForInvalidation) {
+    var _this$_optimisticSour3;
+
+    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.
+    this._currentWriteEpoch + 1, idsMarkedForInvalidation, this._updatedRecordIDs, this._invalidatedRecordIDs);
   };
 
   _proto.subscribe = function subscribe(snapshot, callback) {
-    var _this5 = this;
+    var _this3 = this;
 
     var subscription = {
       backup: null,
@@ -223,7 +315,7 @@ function () {
     };
 
     var dispose = function dispose() {
-      _this5._subscriptions["delete"](subscription);
+      _this3._subscriptions["delete"](subscription);
     };
 
     this._subscriptions.add(subscription);
@@ -234,18 +326,18 @@ function () {
   };
 
   _proto.holdGC = function holdGC() {
-    var _this6 = this;
+    var _this4 = this;
 
     this._gcHoldCounter++;
 
     var dispose = function dispose() {
-      if (_this6._gcHoldCounter > 0) {
-        _this6._gcHoldCounter--;
+      if (_this4._gcHoldCounter > 0) {
+        _this4._gcHoldCounter--;
 
-        if (_this6._gcHoldCounter === 0 && _this6._shouldScheduleGC) {
-          _this6._scheduleGC();
+        if (_this4._gcHoldCounter === 0 && _this4._shouldScheduleGC) {
+          _this4._scheduleGC();
 
-          _this6._shouldScheduleGC = false;
+          _this4._shouldScheduleGC = false;
         }
       }
     };
@@ -299,271 +391,128 @@ function () {
     }
   };
 
-  _proto.lookupConnection_UNSTABLE = function lookupConnection_UNSTABLE(connectionReference, resolver) {
-    var _connectionEvents$opt;
+  _proto.lookupInvalidationState = function lookupInvalidationState(dataIDs) {
+    var _this5 = this;
 
-    !RelayFeatureFlags.ENABLE_CONNECTION_RESOLVERS ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernStore: Connection resolvers are not yet supported.') : invariant(false) : void 0;
-    var id = connectionReference.id;
-    var initialState = resolver.initialize();
+    var invalidations = new Map();
+    dataIDs.forEach(function (dataID) {
+      var _RelayModernRecord$ge;
 
-    var connectionEvents = this._connectionEvents.get(id);
+      var record = _this5.getSource().get(dataID);
 
-    var events = connectionEvents != null ? (_connectionEvents$opt = connectionEvents.optimistic) !== null && _connectionEvents$opt !== void 0 ? _connectionEvents$opt : connectionEvents["final"] : null;
-    var initialSnapshot = {
-      edgeSnapshots: {},
-      id: id,
-      reference: connectionReference,
-      seenRecords: {},
-      state: initialState
+      invalidations.set(dataID, (_RelayModernRecord$ge = RelayModernRecord.getInvalidationEpoch(record)) !== null && _RelayModernRecord$ge !== void 0 ? _RelayModernRecord$ge : null);
+    });
+    invalidations.set('global', this._globalInvalidationEpoch);
+    return {
+      dataIDs: dataIDs,
+      invalidations: invalidations
     };
+  };
+
+  _proto.checkInvalidationState = function checkInvalidationState(prevInvalidationState) {
+    var latestInvalidationState = this.lookupInvalidationState(prevInvalidationState.dataIDs);
+    var currentInvalidations = latestInvalidationState.invalidations;
+    var prevInvalidations = prevInvalidationState.invalidations; // Check if global invalidation has changed
+
+    if (currentInvalidations.get('global') !== prevInvalidations.get('global')) {
+      return true;
+    } // Check if the invalidation state for any of the ids has changed.
+
+
+    var _iterator = _createForOfIteratorHelper(prevInvalidationState.dataIDs),
+        _step;
 
-    if (events == null || events.length === 0) {
-      return initialSnapshot;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var dataID = _step.value;
+
+        if (currentInvalidations.get(dataID) !== prevInvalidations.get(dataID)) {
+          return true;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
     }
 
-    return this._reduceConnection_UNSTABLE(resolver, connectionReference, initialSnapshot, events);
+    return false;
   };
 
-  _proto.subscribeConnection_UNSTABLE = function subscribeConnection_UNSTABLE(snapshot, resolver, callback) {
-    var _this7 = this;
+  _proto.subscribeToInvalidationState = function subscribeToInvalidationState(invalidationState, callback) {
+    var _this6 = this;
 
-    !RelayFeatureFlags.ENABLE_CONNECTION_RESOLVERS ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernStore: Connection resolvers are not yet supported.') : invariant(false) : void 0;
-    var id = String(this._index++);
     var subscription = {
-      backup: null,
       callback: callback,
-      id: id,
-      resolver: resolver,
-      snapshot: snapshot,
-      stale: false
+      invalidationState: invalidationState
     };
 
     var dispose = function dispose() {
-      _this7._connectionSubscriptions["delete"](id);
+      _this6._invalidationSubscriptions["delete"](subscription);
     };
 
-    this._connectionSubscriptions.set(id, subscription);
+    this._invalidationSubscriptions.add(subscription);
 
     return {
       dispose: dispose
     };
   };
 
-  _proto.publishConnectionEvents_UNSTABLE = function publishConnectionEvents_UNSTABLE(events, final) {
-    var _this8 = this;
-
-    if (events.length === 0) {
-      return;
-    }
-
-    !RelayFeatureFlags.ENABLE_CONNECTION_RESOLVERS ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernStore: Connection resolvers are not yet supported.') : invariant(false) : void 0;
-    var pendingConnectionEvents = new Map();
-    events.forEach(function (event) {
-      var connectionID = event.connectionID;
-      var pendingEvents = pendingConnectionEvents.get(connectionID);
-
-      if (pendingEvents == null) {
-        pendingEvents = [];
-        pendingConnectionEvents.set(connectionID, pendingEvents);
-      }
-
-      pendingEvents.push(event);
-
-      var connectionEvents = _this8._connectionEvents.get(connectionID);
-
-      if (connectionEvents == null) {
-        connectionEvents = {
-          "final": [],
-          optimistic: null
-        };
-
-        _this8._connectionEvents.set(connectionID, connectionEvents);
-      }
-
-      if (final) {
-        connectionEvents["final"].push(event);
-      } else {
-        var optimisticEvents = connectionEvents.optimistic;
-
-        if (optimisticEvents == null) {
-          optimisticEvents = connectionEvents["final"].slice();
-          connectionEvents.optimistic = optimisticEvents;
-        }
-
-        optimisticEvents.push(event);
-      }
-    });
-
-    this._connectionSubscriptions.forEach(function (subscription, id) {
-      var pendingEvents = pendingConnectionEvents.get(subscription.snapshot.reference.id);
-
-      if (pendingEvents == null) {
-        return;
-      }
-
-      var nextSnapshot = _this8._updateConnection_UNSTABLE(subscription.resolver, subscription.snapshot, null, pendingEvents);
+  _proto._updateInvalidationSubscription = function _updateInvalidationSubscription(subscription, invalidatedStore) {
+    var _this7 = this;
 
-      if (nextSnapshot) {
-        subscription.snapshot = nextSnapshot;
-        subscription.stale = true;
-      }
+    var callback = subscription.callback,
+        invalidationState = subscription.invalidationState;
+    var dataIDs = invalidationState.dataIDs;
+    var isSubscribedToInvalidatedIDs = invalidatedStore || dataIDs.some(function (dataID) {
+      return _this7._invalidatedRecordIDs.has(dataID);
     });
-  };
-
-  _proto._updateConnection_UNSTABLE = function _updateConnection_UNSTABLE(resolver, snapshot, source, pendingEvents) {
-    var _pendingEvents;
-
-    var nextSnapshot = this._reduceConnection_UNSTABLE(resolver, snapshot.reference, snapshot, (_pendingEvents = pendingEvents) !== null && _pendingEvents !== void 0 ? _pendingEvents : [], source);
 
-    var state = recycleNodesInto(snapshot.state, nextSnapshot.state);
-
-    if (process.env.NODE_ENV !== "production") {
-      deepFreeze(nextSnapshot);
+    if (!isSubscribedToInvalidatedIDs) {
+      return;
     }
 
-    if (state !== snapshot.state) {
-      return (0, _objectSpread2["default"])({}, nextSnapshot, {
-        state: state
-      });
-    }
+    callback();
   };
 
-  _proto._reduceConnection_UNSTABLE = function _reduceConnection_UNSTABLE(resolver, connectionReference, snapshot, events) {
-    var _this9 = this;
-
-    var _edgesField$concreteT;
-
-    var source = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
-    var edgesField = connectionReference.edgesField,
-        id = connectionReference.id,
-        variables = connectionReference.variables;
-    var fragment = {
-      kind: 'Fragment',
-      name: edgesField.name,
-      type: (_edgesField$concreteT = edgesField.concreteType) !== null && _edgesField$concreteT !== void 0 ? _edgesField$concreteT : '__Any',
-      metadata: null,
-      argumentDefinitions: [],
-      selections: edgesField.selections
-    };
-    var seenRecords = {};
-    var edgeSnapshots = (0, _objectSpread2["default"])({}, snapshot.edgeSnapshots);
-    var initialState = snapshot.state;
-
-    if (source) {
-      var edgeData = {};
-      Object.keys(edgeSnapshots).forEach(function (edgeID) {
-        var prevSnapshot = edgeSnapshots[edgeID];
-        var nextSnapshot = RelayReader.read(_this9.getSource(), createReaderSelector(fragment, edgeID, variables, prevSnapshot.selector.owner));
-        var data = recycleNodesInto(prevSnapshot.data, nextSnapshot.data);
-        nextSnapshot = {
-          data: data,
-          isMissingData: nextSnapshot.isMissingData,
-          seenRecords: nextSnapshot.seenRecords,
-          selector: nextSnapshot.selector
-        };
-
-        if (data !== prevSnapshot.data) {
-          edgeData[edgeID] = data;
-          edgeSnapshots[edgeID] = nextSnapshot;
-        }
-      });
-
-      if (Object.keys(edgeData).length !== 0) {
-        initialState = resolver.reduce(initialState, {
-          kind: 'update',
-          edgeData: edgeData
-        });
-      }
-    }
+  _proto.snapshot = function snapshot() {
+    var _this8 = this;
 
-    var state = events.reduce(function (prevState, event) {
-      if (event.kind === 'fetch') {
-        var edges = [];
-        event.edgeIDs.forEach(function (edgeID) {
-          if (edgeID == null) {
-            edges.push(edgeID);
-            return;
-          }
+    !(this._optimisticSource == null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernStore: Unexpected call to snapshot() while a previous ' + 'snapshot exists.') : invariant(false) : void 0;
 
-          var edgeSnapshot = RelayReader.read(_this9.getSource(), createReaderSelector(fragment, edgeID, variables, event.request));
-          Object.assign(seenRecords, edgeSnapshot.seenRecords);
-          var itemData = edgeSnapshot.data;
-          edgeSnapshots[edgeID] = edgeSnapshot;
-          edges.push(itemData);
-        });
-        return resolver.reduce(prevState, {
-          kind: 'fetch',
-          args: event.args,
-          edges: edges,
-          pageInfo: event.pageInfo,
-          stream: event.stream
-        });
-      } else if (event.kind === 'insert') {
-        var edgeSnapshot = RelayReader.read(_this9.getSource(), createReaderSelector(fragment, event.edgeID, variables, event.request));
-        Object.assign(seenRecords, edgeSnapshot.seenRecords);
-        var itemData = edgeSnapshot.data;
-        edgeSnapshots[event.edgeID] = edgeSnapshot;
-        return resolver.reduce(prevState, {
-          args: event.args,
-          edge: itemData,
-          kind: 'insert'
-        });
-      } else if (event.kind === 'stream.edge') {
-        var _edgeSnapshot = RelayReader.read(_this9.getSource(), createReaderSelector(fragment, event.edgeID, variables, event.request));
-
-        Object.assign(seenRecords, _edgeSnapshot.seenRecords);
-        var _itemData = _edgeSnapshot.data;
-        edgeSnapshots[event.edgeID] = _edgeSnapshot;
-        return resolver.reduce(prevState, {
-          args: event.args,
-          edge: _itemData,
-          index: event.index,
-          kind: 'stream.edge'
-        });
-      } else if (event.kind === 'stream.pageInfo') {
-        return resolver.reduce(prevState, {
-          args: event.args,
-          kind: 'stream.pageInfo',
-          pageInfo: event.pageInfo
-        });
-      } else {
-        event.kind;
-        !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernStore: Unexpected connection event kind `%s`.', event.kind) : invariant(false) : void 0;
+    this._subscriptions.forEach(function (subscription) {
+      // Backup occurs after writing a new "final" payload(s) and before (re)applying
+      // optimistic changes. Each subscription's `snapshot` represents what was *last
+      // published to the subscriber*, which notably may include previous optimistic
+      // updates. Therefore a subscription can be in any of the following states:
+      // - stale=true: This subscription was restored to a different value than
+      //   `snapshot`. That means this subscription has changes relative to its base,
+      //   but its base has changed (we just applied a final payload): recompute
+      //   a backup so that we can later restore to the state the subscription
+      //   should be in.
+      // - stale=false: This subscription was restored to the same value than
+      //   `snapshot`. That means this subscription does *not* have changes relative
+      //   to its base, so the current `snapshot` is valid to use as a backup.
+      if (!subscription.stale) {
+        subscription.backup = subscription.snapshot;
+        return;
       }
-    }, initialState);
-    return {
-      edgeSnapshots: edgeSnapshots,
-      id: id,
-      reference: connectionReference,
-      seenRecords: seenRecords,
-      state: state
-    };
-  };
 
-  _proto.snapshot = function snapshot() {
-    !(this._optimisticSource == null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernStore: Unexpected call to snapshot() while a previous ' + 'snapshot exists.') : invariant(false) : void 0;
+      var snapshot = subscription.snapshot;
+      var backup = RelayReader.read(_this8.getSource(), snapshot.selector);
+      var nextData = recycleNodesInto(snapshot.data, backup.data);
+      backup.data = nextData; // backup owns the snapshot and can safely mutate
 
-    this._connectionSubscriptions.forEach(function (subscription) {
-      subscription.backup = subscription.snapshot;
-    });
-
-    this._subscriptions.forEach(function (subscription) {
-      subscription.backup = subscription.snapshot;
+      subscription.backup = backup;
     });
 
     this._optimisticSource = RelayOptimisticRecordSource.create(this.getSource());
   };
 
   _proto.restore = function restore() {
-    var _this10 = this;
-
     !(this._optimisticSource != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernStore: Unexpected call to restore(), expected a snapshot ' + 'to exist (make sure to call snapshot()).') : invariant(false) : void 0;
     this._optimisticSource = null;
 
-    this._connectionEvents.forEach(function (events) {
-      events.optimistic = null;
-    });
-
     this._subscriptions.forEach(function (subscription) {
       var backup = subscription.backup;
       subscription.backup = null;
@@ -583,38 +532,10 @@ function () {
         subscription.stale = true;
       }
     });
-
-    this._connectionSubscriptions.forEach(function (subscription) {
-      var backup = subscription.backup;
-      subscription.backup = null;
-
-      if (backup) {
-        if (backup.state !== subscription.snapshot.state) {
-          subscription.stale = true;
-        }
-
-        subscription.snapshot = backup;
-      } else {
-        // This subscription was established after the creation of the
-        // connection snapshot so there's nothing to restore to. Recreate the
-        // connection from scratch and check ifs value changes.
-        var baseSnapshot = _this10.lookupConnection_UNSTABLE(subscription.snapshot.reference, subscription.resolver);
-
-        var nextState = recycleNodesInto(subscription.snapshot.state, baseSnapshot.state);
-
-        if (nextState !== subscription.snapshot.state) {
-          subscription.stale = true;
-        }
-
-        subscription.snapshot = (0, _objectSpread2["default"])({}, baseSnapshot, {
-          state: nextState
-        });
-      }
-    });
   };
 
   _proto._scheduleGC = function _scheduleGC() {
-    var _this11 = this;
+    var _this9 = this;
 
     if (this._gcHoldCounter > 0) {
       this._shouldScheduleGC = true;
@@ -628,27 +549,26 @@ function () {
     this._hasScheduledGC = true;
 
     this._gcScheduler(function () {
-      _this11.__gc();
+      _this9.__gc();
 
-      _this11._hasScheduledGC = false;
+      _this9._hasScheduledGC = false;
     });
   };
 
   _proto.__gc = function __gc() {
-    var _this12 = this;
+    var _this10 = this;
 
     // Don't run GC while there are optimistic updates applied
     if (this._optimisticSource != null) {
       return;
     }
 
-    var references = new Set();
-    var connectionReferences = new Set(); // Mark all records that are traversable from a root
+    var references = new Set(); // Mark all records that are traversable from a root
 
-    this._roots.forEach(function (selector) {
-      RelayReferenceMarker.mark(_this12._recordSource, selector, references, connectionReferences, function (id) {
-        return _this12.getConnectionEvents_UNSTABLE(id);
-      }, _this12._operationLoader);
+    this._roots.forEach(function (_ref) {
+      var operation = _ref.operation;
+      var selector = operation.root;
+      RelayReferenceMarker.mark(_this10._recordSource, selector, references, _this10._operationLoader);
     });
 
     if (references.size === 0) {
@@ -666,49 +586,68 @@ function () {
         }
       }
     }
-
-    if (connectionReferences.size === 0) {
-      this._connectionEvents.clear();
-    } else {
-      // Evict any unreferenced connections
-      var _iteratorNormalCompletion = true;
-      var _didIteratorError = false;
-      var _iteratorError = undefined;
-
-      try {
-        for (var _iterator = this._connectionEvents.keys()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-          var connectionID = _step.value;
-
-          if (!connectionReferences.has(connectionID)) {
-            this._connectionEvents["delete"](connectionID);
-          }
-        }
-      } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion && _iterator["return"] != null) {
-            _iterator["return"]();
-          }
-        } finally {
-          if (_didIteratorError) {
-            throw _iteratorError;
-          }
-        }
-      }
-    }
   };
 
   return RelayModernStore;
 }();
+
+function initializeRecordSource(target) {
+  if (!target.has(ROOT_ID)) {
+    var rootRecord = RelayModernRecord.create(ROOT_ID, ROOT_TYPE);
+    target.set(ROOT_ID, rootRecord);
+  }
+}
 /**
  * Updates the target with information from source, also updating a mapping of
  * which records in the target were changed as a result.
+ * Additionally, will marc records as invalidated at the current write epoch
+ * given the set of record ids marked as stale in this update.
  */
 
 
-function updateTargetFromSource(target, source, updatedRecordIDs) {
+function updateTargetFromSource(target, source, currentWriteEpoch, idsMarkedForInvalidation, updatedRecordIDs, invalidatedRecordIDs) {
+  // First, update any records that were marked for invalidation.
+  // For each provided dataID that was invalidated, we write the
+  // INVALIDATED_AT_KEY on the record, indicating
+  // the epoch at which the record was invalidated.
+  if (idsMarkedForInvalidation) {
+    idsMarkedForInvalidation.forEach(function (dataID) {
+      var targetRecord = target.get(dataID);
+      var sourceRecord = source.get(dataID); // If record was deleted during the update (and also invalidated),
+      // we don't need to count it as an invalidated id
+
+      if (sourceRecord === null) {
+        return;
+      }
+
+      var nextRecord;
+
+      if (targetRecord != null) {
+        // If the target record exists, use it to set the epoch
+        // at which it was invalidated. This record will be updated with
+        // any changes from source in the section below
+        // where we update the target records based on the source.
+        nextRecord = RelayModernRecord.clone(targetRecord);
+      } else {
+        // If the target record doesn't exist, it means that a new record
+        // in the source was created (and also invalidated), so we use that
+        // record to set the epoch at which it was invalidated. This record
+        // will be updated with any changes from source in the section below
+        // where we update the target records based on the source.
+        nextRecord = sourceRecord != null ? RelayModernRecord.clone(sourceRecord) : null;
+      }
+
+      if (!nextRecord) {
+        return;
+      }
+
+      RelayModernRecord.setValue(nextRecord, RelayStoreUtils.INVALIDATED_AT_KEY, currentWriteEpoch);
+      invalidatedRecordIDs.add(dataID);
+      target.set(dataID, nextRecord);
+    });
+  } // Update the target based on the changes present in source
+
+
   var dataIDs = source.getRecordIDs();
 
   for (var ii = 0; ii < dataIDs.length; ii++) {
@@ -747,6 +686,55 @@ function updateTargetFromSource(target, source, updatedRecordIDs) {
 
   }
 }
+/**
+ * Returns an OperationAvailability given the Availability returned
+ * by checking an operation, and when that operation was last written to the store.
+ * Specifically, the provided Availability of an operation will contain the
+ * value of when a record referenced by the operation was most recently
+ * invalidated; given that value, and given when this operation was last
+ * written to the store, this function will return the overall
+ * OperationAvailability for the operation.
+ */
+
+
+function getAvailabilityStatus(operationAvailability, operationLastWrittenAt, operationFetchTime, queryCacheExpirationTime) {
+  var mostRecentlyInvalidatedAt = operationAvailability.mostRecentlyInvalidatedAt,
+      status = operationAvailability.status;
+
+  if (typeof mostRecentlyInvalidatedAt === 'number') {
+    // If some record referenced by this operation is stale, then the operation itself is stale
+    // if either the operation itself was never written *or* the operation was last written
+    // before the most recent invalidation of its reachable records.
+    if (operationLastWrittenAt == null || mostRecentlyInvalidatedAt > operationLastWrittenAt) {
+      return {
+        status: 'stale'
+      };
+    }
+  }
+
+  if (status === 'missing') {
+    return {
+      status: 'missing'
+    };
+  }
+
+  if (operationFetchTime != null && queryCacheExpirationTime != null) {
+    var isStale = operationFetchTime <= Date.now() - queryCacheExpirationTime;
+
+    if (isStale) {
+      return {
+        status: 'stale'
+      };
+    }
+  } // There were no invalidations of any reachable records *or* the operation is known to have
+  // been fetched after the most recent record invalidation.
+
+
+  return {
+    status: 'available',
+    fetchTime: operationFetchTime !== null && operationFetchTime !== void 0 ? operationFetchTime : null
+  };
+}
 
 RelayProfiler.instrumentMethods(RelayModernStore.prototype, {
   lookup: 'RelayModernStore.prototype.lookup',