relay-runtime 9.0.0 → 10.1.0

package/lib/store/RelayModernStore.js

@@ -10,6 +10,16 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; 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 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; } } }; }
+
+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(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+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 DataChecker = require('./DataChecker');
 
 var RelayModernRecord = require('./RelayModernRecord');
@@ -22,6 +32,8 @@ var RelayReader = require('./RelayReader');
 
 var RelayReferenceMarker = require('./RelayReferenceMarker');
 
+var RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');
+
 var RelayStoreUtils = require('./RelayStoreUtils');
 
 var deepFreeze = require('../util/deepFreeze');
@@ -32,6 +44,8 @@ var hasOverlappingIDs = require('./hasOverlappingIDs');
 
 var invariant = require("fbjs/lib/invariant");
 
+var isEmptyObject = require('../util/isEmptyObject');
+
 var recycleNodesInto = require('../util/recycleNodesInto');
 
 var resolveImmediate = require('../util/resolveImmediate');
@@ -54,11 +68,21 @@ 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 _this = this;
+
+    var _options$gcReleaseBuf, _options$gcScheduler, _options$UNSTABLE_DO_, _options$log, _options$operationLoa;
+
+    (0, _defineProperty2["default"])(this, "_gcStep", function () {
+      if (_this._gcRun) {
+        if (_this._gcRun.next().done) {
+          _this._gcRun = null;
+        } else {
+          _this._gcScheduler(_this._gcStep);
+        }
+      }
+    });
 
     // Prevent mutation of a record from outside the store.
     if (process.env.NODE_ENV !== "production") {
@@ -75,15 +99,16 @@ function () {
 
     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._gcRun = null;
+    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._invalidationSubscriptions = new Set();
     this._invalidatedRecordIDs = new Set();
-    this._operationLoader = (_ref4 = options === null || options === void 0 ? void 0 : options.operationLoader) !== null && _ref4 !== void 0 ? _ref4 : null;
+    this.__log = (_options$log = options === null || options === void 0 ? void 0 : options.log) !== null && _options$log !== void 0 ? _options$log : null;
+    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 = [];
@@ -103,7 +128,7 @@ function () {
   };
 
   _proto.check = function check(operation, options) {
-    var _this$_optimisticSour2, _ref5, _ref6;
+    var _this$_optimisticSour2, _options$target, _options$handlers;
 
     var selector = operation.root;
     var source = (_this$_optimisticSour2 = this._optimisticSource) !== null && _this$_optimisticSour2 !== void 0 ? _this$_optimisticSour2 : this._recordSource;
@@ -117,58 +142,68 @@ function () {
       // 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 ocurred,
+        // 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).
+        // (i.e. not resolvable from the store).
         return {
           status: 'stale'
         };
       }
     }
 
-    var target = (_ref5 = options === null || options === void 0 ? void 0 : options.target) !== null && _ref5 !== void 0 ? _ref5 : source;
-    var handlers = (_ref6 = options === null || options === void 0 ? void 0 : options.handlers) !== null && _ref6 !== void 0 ? _ref6 : [];
+    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 getAvailablityStatus(operationAvailability, operationLastWrittenAt, rootEntry === null || rootEntry === void 0 ? void 0 : rootEntry.fetchTime);
+    return getAvailabilityStatus(operationAvailability, operationLastWrittenAt, rootEntry === null || rootEntry === void 0 ? void 0 : rootEntry.fetchTime, this._queryCacheExpirationTime);
   };
 
   _proto.retain = function retain(operation) {
-    var _this = this;
+    var _this2 = this;
 
     var id = operation.request.identifier;
+    var disposed = false;
 
     var dispose = function dispose() {
-      // When disposing, instead of immediately decrementing the refCount and
-      // potentially deleting/collecting the root, move the operation onto
-      // the release buffer. When the operation is extracted from the release
-      // buffer, we will determine if it needs to be collected.
-      _this._releaseBuffer.push(id); // Only when the release buffer is full do we actually:
-      // - extract the least recent operation in the release buffer
-      // - attempt to release it and run GC if it's no longer referenced
-      //   (refCount reached 0).
+      // Ensure each retain can only dispose once
+      if (disposed) {
+        return;
+      }
+
+      disposed = true; // For Flow: guard against the entry somehow not existing
 
+      var rootEntry = _this2._roots.get(id);
 
-      if (_this._releaseBuffer.length > _this._gcReleaseBufferSize) {
-        var _id = _this._releaseBuffer.shift();
+      if (rootEntry == null) {
+        return;
+      } // Decrement the ref count: if it becomes zero it is eligible
+      // for release.
 
-        var _rootEntry = _this._roots.get(_id);
 
-        if (_rootEntry == null) {
-          // If operation has already been fully released, we don't need
-          // to do anything.
-          return;
-        }
+      rootEntry.refCount--;
+
+      if (rootEntry.refCount === 0) {
+        var _queryCacheExpirationTime = _this2._queryCacheExpirationTime;
+
+        var rootEntryIsStale = rootEntry.fetchTime != null && _queryCacheExpirationTime != null && rootEntry.fetchTime <= Date.now() - _queryCacheExpirationTime;
 
-        if (_rootEntry.refCount > 0) {
-          // If the operation is still retained by other callers
-          // decrement the refCount
-          _rootEntry.refCount -= 1;
+        if (rootEntryIsStale) {
+          _this2._roots["delete"](id);
+
+          _this2.scheduleGC();
         } else {
-          // Otherwise fully release the query and run GC.
-          _this._roots["delete"](_id);
+          _this2._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.
+
+
+          if (_this2._releaseBuffer.length > _this2._gcReleaseBufferSize) {
+            var _id = _this2._releaseBuffer.shift();
+
+            _this2._roots["delete"](_id);
 
-          _this._scheduleGC();
+            _this2.scheduleGC();
+          }
         }
       }
     };
@@ -176,13 +211,22 @@ function () {
     var rootEntry = this._roots.get(id);
 
     if (rootEntry != null) {
-      // If we've previously retained this operation, inrement the refCount
+      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: 0,
+        refCount: 1,
         epoch: null,
         fetchTime: null
       });
@@ -202,14 +246,22 @@ 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(sourceOperation, invalidateStore) {
-    var _this2 = this;
+    var _this3 = this;
+
+    var log = this.__log;
 
-    // Increment the current write when notifying after executing
+    if (log != null) {
+      log({
+        name: 'store.notify.start'
+      });
+    } // Increment the current write when notifying after executing
     // a set of changes to the store.
+
+
     this._currentWriteEpoch++;
 
     if (invalidateStore === true) {
@@ -218,9 +270,10 @@ function () {
 
     var source = this.getSource();
     var updatedOwners = [];
+    var hasUpdatedRecords = !isEmptyObject(this._updatedRecordIDs);
 
     this._subscriptions.forEach(function (subscription) {
-      var owner = _this2._updateSubscription(source, subscription);
+      var owner = _this3._updateSubscription(source, subscription, hasUpdatedRecords);
 
       if (owner != null) {
         updatedOwners.push(owner);
@@ -228,9 +281,17 @@ function () {
     });
 
     this._invalidationSubscriptions.forEach(function (subscription) {
-      _this2._updateInvalidationSubscription(subscription, invalidateStore === true);
+      _this3._updateInvalidationSubscription(subscription, invalidateStore === true);
     });
 
+    if (log != null) {
+      log({
+        name: 'store.notify.complete',
+        updatedRecordIDs: this._updatedRecordIDs,
+        invalidatedRecordIDs: this._invalidatedRecordIDs
+      });
+    }
+
     this._updatedRecordIDs = {};
 
     this._invalidatedRecordIDs.clear(); // If a source operation was provided (indicating the operation
@@ -249,10 +310,21 @@ function () {
       var rootEntry = this._roots.get(id);
 
       if (rootEntry != null) {
-        var _rootEntry$fetchTime;
-
         rootEntry.epoch = this._currentWriteEpoch;
-        rootEntry.fetchTime = (_rootEntry$fetchTime = rootEntry.fetchTime) !== null && _rootEntry$fetchTime !== void 0 ? _rootEntry$fetchTime : Date.now();
+        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._releaseBuffer.push(id);
+
+        this._roots.set(id, temporaryRootEntry);
       }
     }
 
@@ -266,11 +338,22 @@ function () {
     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);
+    this._currentWriteEpoch + 1, idsMarkedForInvalidation, this._updatedRecordIDs, this._invalidatedRecordIDs); // NOTE: log *after* processing the source so that even if a bad log function
+    // mutates the source, it doesn't affect Relay processing of it.
+
+    var log = this.__log;
+
+    if (log != null) {
+      log({
+        name: 'store.publish',
+        source: source,
+        optimistic: target === this._optimisticSource
+      });
+    }
   };
 
   _proto.subscribe = function subscribe(snapshot, callback) {
-    var _this3 = this;
+    var _this4 = this;
 
     var subscription = {
       backup: null,
@@ -280,7 +363,7 @@ function () {
     };
 
     var dispose = function dispose() {
-      _this3._subscriptions["delete"](subscription);
+      _this4._subscriptions["delete"](subscription);
     };
 
     this._subscriptions.add(subscription);
@@ -291,18 +374,23 @@ function () {
   };
 
   _proto.holdGC = function holdGC() {
-    var _this4 = this;
+    var _this5 = this;
+
+    if (this._gcRun) {
+      this._gcRun = null;
+      this._shouldScheduleGC = true;
+    }
 
     this._gcHoldCounter++;
 
     var dispose = function dispose() {
-      if (_this4._gcHoldCounter > 0) {
-        _this4._gcHoldCounter--;
+      if (_this5._gcHoldCounter > 0) {
+        _this5._gcHoldCounter--;
 
-        if (_this4._gcHoldCounter === 0 && _this4._shouldScheduleGC) {
-          _this4._scheduleGC();
+        if (_this5._gcHoldCounter === 0 && _this5._shouldScheduleGC) {
+          _this5.scheduleGC();
 
-          _this4._shouldScheduleGC = false;
+          _this5._shouldScheduleGC = false;
         }
       }
     };
@@ -323,12 +411,12 @@ function () {
   // latest update, or null if it was not affected.
   ;
 
-  _proto._updateSubscription = function _updateSubscription(source, subscription) {
+  _proto._updateSubscription = function _updateSubscription(source, subscription, hasUpdatedRecords) {
     var backup = subscription.backup,
         callback = subscription.callback,
         snapshot = subscription.snapshot,
         stale = subscription.stale;
-    var hasOverlappingUpdates = hasOverlappingIDs(snapshot.seenRecords, this._updatedRecordIDs);
+    var hasOverlappingUpdates = hasUpdatedRecords && hasOverlappingIDs(snapshot.seenRecords, this._updatedRecordIDs);
 
     if (!stale && !hasOverlappingUpdates) {
       return;
@@ -340,7 +428,8 @@ function () {
       data: nextData,
       isMissingData: nextSnapshot.isMissingData,
       seenRecords: nextSnapshot.seenRecords,
-      selector: nextSnapshot.selector
+      selector: nextSnapshot.selector,
+      missingRequiredFields: nextSnapshot.missingRequiredFields
     };
 
     if (process.env.NODE_ENV !== "production") {
@@ -357,13 +446,13 @@ function () {
   };
 
   _proto.lookupInvalidationState = function lookupInvalidationState(dataIDs) {
-    var _this5 = this;
+    var _this6 = this;
 
     var invalidations = new Map();
     dataIDs.forEach(function (dataID) {
       var _RelayModernRecord$ge;
 
-      var record = _this5.getSource().get(dataID);
+      var record = _this6.getSource().get(dataID);
 
       invalidations.set(dataID, (_RelayModernRecord$ge = RelayModernRecord.getInvalidationEpoch(record)) !== null && _RelayModernRecord$ge !== void 0 ? _RelayModernRecord$ge : null);
     });
@@ -384,12 +473,11 @@ function () {
     } // Check if the invalidation state for any of the ids has changed.
 
 
-    var _iteratorNormalCompletion = true;
-    var _didIteratorError = false;
-    var _iteratorError = undefined;
+    var _iterator = _createForOfIteratorHelper(prevInvalidationState.dataIDs),
+        _step;
 
     try {
-      for (var _iterator = prevInvalidationState.dataIDs[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
         var dataID = _step.value;
 
         if (currentInvalidations.get(dataID) !== prevInvalidations.get(dataID)) {
@@ -397,25 +485,16 @@ function () {
         }
       }
     } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
+      _iterator.e(err);
     } finally {
-      try {
-        if (!_iteratorNormalCompletion && _iterator["return"] != null) {
-          _iterator["return"]();
-        }
-      } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
-        }
-      }
+      _iterator.f();
     }
 
     return false;
   };
 
   _proto.subscribeToInvalidationState = function subscribeToInvalidationState(invalidationState, callback) {
-    var _this6 = this;
+    var _this7 = this;
 
     var subscription = {
       callback: callback,
@@ -423,7 +502,7 @@ function () {
     };
 
     var dispose = function dispose() {
-      _this6._invalidationSubscriptions["delete"](subscription);
+      _this7._invalidationSubscriptions["delete"](subscription);
     };
 
     this._invalidationSubscriptions.add(subscription);
@@ -434,13 +513,13 @@ function () {
   };
 
   _proto._updateInvalidationSubscription = function _updateInvalidationSubscription(subscription, invalidatedStore) {
-    var _this7 = this;
+    var _this8 = this;
 
     var callback = subscription.callback,
         invalidationState = subscription.invalidationState;
     var dataIDs = invalidationState.dataIDs;
     var isSubscribedToInvalidatedIDs = invalidatedStore || dataIDs.some(function (dataID) {
-      return _this7._invalidatedRecordIDs.has(dataID);
+      return _this8._invalidatedRecordIDs.has(dataID);
     });
 
     if (!isSubscribedToInvalidatedIDs) {
@@ -451,9 +530,16 @@ function () {
   };
 
   _proto.snapshot = function snapshot() {
-    var _this8 = this;
+    var _this9 = this;
 
     !(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 log = this.__log;
+
+    if (log != null) {
+      log({
+        name: 'store.snapshot'
+      });
+    }
 
     this._subscriptions.forEach(function (subscription) {
       // Backup occurs after writing a new "final" payload(s) and before (re)applying
@@ -474,20 +560,37 @@ function () {
       }
 
       var snapshot = subscription.snapshot;
-      var backup = RelayReader.read(_this8.getSource(), snapshot.selector);
+      var backup = RelayReader.read(_this9.getSource(), snapshot.selector);
       var nextData = recycleNodesInto(snapshot.data, backup.data);
       backup.data = nextData; // backup owns the snapshot and can safely mutate
 
       subscription.backup = backup;
     });
 
+    if (this._gcRun) {
+      this._gcRun = null;
+      this._shouldScheduleGC = true;
+    }
+
     this._optimisticSource = RelayOptimisticRecordSource.create(this.getSource());
   };
 
   _proto.restore = function restore() {
     !(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;
+    var log = this.__log;
+
+    if (log != null) {
+      log({
+        name: 'store.restore'
+      });
+    }
+
     this._optimisticSource = null;
 
+    if (this._shouldScheduleGC) {
+      this.scheduleGC();
+    }
+
     this._subscriptions.forEach(function (subscription) {
       var backup = subscription.backup;
       subscription.backup = null;
@@ -501,7 +604,8 @@ function () {
           data: subscription.snapshot.data,
           isMissingData: backup.isMissingData,
           seenRecords: backup.seenRecords,
-          selector: backup.selector
+          selector: backup.selector,
+          missingRequiredFields: backup.missingRequiredFields
         };
       } else {
         subscription.stale = true;
@@ -509,57 +613,90 @@ function () {
     });
   };
 
-  _proto._scheduleGC = function _scheduleGC() {
-    var _this9 = this;
-
+  _proto.scheduleGC = function scheduleGC() {
     if (this._gcHoldCounter > 0) {
       this._shouldScheduleGC = true;
       return;
     }
 
-    if (this._hasScheduledGC) {
+    if (this._gcRun) {
       return;
     }
 
-    this._hasScheduledGC = true;
-
-    this._gcScheduler(function () {
-      _this9.__gc();
+    this._gcRun = this._collect();
 
-      _this9._hasScheduledGC = false;
-    });
-  };
+    this._gcScheduler(this._gcStep);
+  }
+  /**
+   * Run a full GC synchronously.
+   */
+  ;
 
   _proto.__gc = function __gc() {
-    var _this10 = this;
-
     // Don't run GC while there are optimistic updates applied
     if (this._optimisticSource != null) {
       return;
     }
 
-    var references = new Set(); // Mark all records that are traversable from a root
+    var gcRun = this._collect();
 
-    this._roots.forEach(function (_ref7) {
-      var operation = _ref7.operation;
-      var selector = operation.root;
-      RelayReferenceMarker.mark(_this10._recordSource, selector, references, _this10._operationLoader);
-    });
+    while (!gcRun.next().done) {}
+  };
 
-    if (references.size === 0) {
-      // Short-circuit if *nothing* is referenced
-      this._recordSource.clear();
-    } else {
-      // Evict any unreferenced nodes
-      var storeIDs = this._recordSource.getRecordIDs();
+  _proto._collect = function* _collect() {
+    /* eslint-disable no-labels */
+    top: while (true) {
+      var startEpoch = this._currentWriteEpoch;
+      var references = new Set(); // Mark all records that are traversable from a root
 
-      for (var ii = 0; ii < storeIDs.length; ii++) {
-        var dataID = storeIDs[ii];
+      var _iterator2 = _createForOfIteratorHelper(this._roots.values()),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var operation = _step2.value.operation;
+          var selector = operation.root;
+          RelayReferenceMarker.mark(this._recordSource, selector, references, this._operationLoader); // Yield for other work after each operation
+
+          yield; // If the store was updated, restart
+
+          if (startEpoch !== this._currentWriteEpoch) {
+            continue top;
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+
+      var log = this.__log;
+
+      if (log != null) {
+        log({
+          name: 'store.gc',
+          references: references
+        });
+      } // Sweep records without references
+
+
+      if (references.size === 0) {
+        // Short-circuit if *nothing* is referenced
+        this._recordSource.clear();
+      } else {
+        // Evict any unreferenced nodes
+        var storeIDs = this._recordSource.getRecordIDs();
+
+        for (var ii = 0; ii < storeIDs.length; ii++) {
+          var dataID = storeIDs[ii];
 
-        if (!references.has(dataID)) {
-          this._recordSource.remove(dataID);
+          if (!references.has(dataID)) {
+            this._recordSource.remove(dataID);
+          }
         }
       }
+
+      return;
     }
   };
 
@@ -575,7 +712,7 @@ function initializeRecordSource(target) {
 /**
  * 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
+ * Additionally, will mark records as invalidated at the current write epoch
  * given the set of record ids marked as stale in this update.
  */
 
@@ -637,7 +774,11 @@ function updateTargetFromSource(target, source, currentWriteEpoch, idsMarkedForI
     }
 
     if (sourceRecord && targetRecord) {
-      var nextRecord = RelayModernRecord.update(targetRecord, sourceRecord);
+      // ReactFlightClientResponses are lazy and only materialize when readRoot
+      // is called when we read the field, so if the record is a Flight field
+      // we always use the new record's data regardless of whether
+      // it actually changed. Let React take care of reconciliation instead.
+      var nextRecord = RelayModernRecord.getType(targetRecord) === RelayStoreReactFlightUtils.REACT_FLIGHT_TYPE_NAME ? sourceRecord : RelayModernRecord.update(targetRecord, sourceRecord);
 
       if (nextRecord !== targetRecord) {
         // Prevent mutation of a record from outside the store.
@@ -664,7 +805,7 @@ function updateTargetFromSource(target, source, currentWriteEpoch, idsMarkedForI
 /**
  * Returns an OperationAvailability given the Availability returned
  * by checking an operation, and when that operation was last written to the store.
- * Specifically, the provided Availablity of a an operation will contain the
+ * 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
@@ -672,11 +813,9 @@ function updateTargetFromSource(target, source, currentWriteEpoch, idsMarkedForI
  */
 
 
-function getAvailablityStatus(opearionAvailability, operationLastWrittenAt, operationFetchTime) {
-  var _operationFetchTime;
-
-  var mostRecentlyInvalidatedAt = opearionAvailability.mostRecentlyInvalidatedAt,
-      status = opearionAvailability.status;
+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
@@ -687,22 +826,33 @@ function getAvailablityStatus(opearionAvailability, operationLastWrittenAt, oper
         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 === 'missing' ? {
-    status: 'missing'
-  } : {
+  return {
     status: 'available',
-    fetchTime: (_operationFetchTime = operationFetchTime) !== null && _operationFetchTime !== void 0 ? _operationFetchTime : null
+    fetchTime: operationFetchTime !== null && operationFetchTime !== void 0 ? operationFetchTime : null
   };
 }
 
 RelayProfiler.instrumentMethods(RelayModernStore.prototype, {
-  lookup: 'RelayModernStore.prototype.lookup',
-  notify: 'RelayModernStore.prototype.notify',
-  publish: 'RelayModernStore.prototype.publish',
-  __gc: 'RelayModernStore.prototype.__gc'
+  lookup: 'RelayModernStore.prototype.lookup'
 });
 module.exports = RelayModernStore;