relay-runtime 10.0.1 → 10.1.3

package/lib/store/RelayResponseNormalizer.js

@@ -12,6 +12,8 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
 var RelayFeatureFlags = require('../util/RelayFeatureFlags');
@@ -20,6 +22,8 @@ var RelayModernRecord = require('./RelayModernRecord');
 
 var RelayProfiler = require('../util/RelayProfiler');
 
+var areEqual = require("fbjs/lib/areEqual");
+
 var invariant = require("fbjs/lib/invariant");
 
 var warning = require("fbjs/lib/warning");
@@ -28,6 +32,7 @@ var _require = require('../util/RelayConcreteNode'),
     CONDITION = _require.CONDITION,
     CLIENT_EXTENSION = _require.CLIENT_EXTENSION,
     DEFER = _require.DEFER,
+    FLIGHT_FIELD = _require.FLIGHT_FIELD,
     INLINE_FRAGMENT = _require.INLINE_FRAGMENT,
     LINKED_FIELD = _require.LINKED_FIELD,
     LINKED_HANDLE = _require.LINKED_HANDLE,
@@ -44,18 +49,25 @@ var _require2 = require('./ClientID'),
 var _require3 = require('./RelayModernSelector'),
     createNormalizationSelector = _require3.createNormalizationSelector;
 
-var _require4 = require('./RelayStoreUtils'),
-    getArgumentValues = _require4.getArgumentValues,
-    getHandleStorageKey = _require4.getHandleStorageKey,
-    getModuleComponentKey = _require4.getModuleComponentKey,
-    getModuleOperationKey = _require4.getModuleOperationKey,
-    getStorageKey = _require4.getStorageKey,
-    TYPENAME_KEY = _require4.TYPENAME_KEY,
-    ROOT_ID = _require4.ROOT_ID;
-
-var _require5 = require('./TypeID'),
-    generateTypeID = _require5.generateTypeID,
-    TYPE_SCHEMA_TYPE = _require5.TYPE_SCHEMA_TYPE;
+var _require4 = require('./RelayStoreReactFlightUtils'),
+    refineToReactFlightPayloadData = _require4.refineToReactFlightPayloadData,
+    REACT_FLIGHT_QUERIES_STORAGE_KEY = _require4.REACT_FLIGHT_QUERIES_STORAGE_KEY,
+    REACT_FLIGHT_TREE_STORAGE_KEY = _require4.REACT_FLIGHT_TREE_STORAGE_KEY,
+    REACT_FLIGHT_TYPE_NAME = _require4.REACT_FLIGHT_TYPE_NAME;
+
+var _require5 = require('./RelayStoreUtils'),
+    getArgumentValues = _require5.getArgumentValues,
+    getHandleStorageKey = _require5.getHandleStorageKey,
+    getModuleComponentKey = _require5.getModuleComponentKey,
+    getModuleOperationKey = _require5.getModuleOperationKey,
+    getStorageKey = _require5.getStorageKey,
+    TYPENAME_KEY = _require5.TYPENAME_KEY,
+    ROOT_ID = _require5.ROOT_ID,
+    ROOT_TYPE = _require5.ROOT_TYPE;
+
+var _require6 = require('./TypeID'),
+    generateTypeID = _require6.generateTypeID,
+    TYPE_SCHEMA_TYPE = _require6.TYPE_SCHEMA_TYPE;
 
 /**
  * Normalizes the results of a query and standard GraphQL response, writing the
@@ -87,6 +99,7 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
     this._path = options.path ? (0, _toConsumableArray2["default"])(options.path) : [];
     this._recordSource = recordSource;
     this._variables = variables;
+    this._reactFlightPayloadDeserializer = options.reactFlightPayloadDeserializer;
   }
 
   var _proto = RelayResponseNormalizer.prototype;
@@ -252,6 +265,15 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
           this._isClientExtension = isClientExtension;
           break;
 
+        case FLIGHT_FIELD:
+          if (RelayFeatureFlags.ENABLE_REACT_FLIGHT_COMPONENT_FIELD) {
+            this._normalizeFlightField(node, selection, record, data);
+          } else {
+            throw new Error('Flight fields are not yet supported.');
+          }
+
+          break;
+
         default:
           selection;
           !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer(): Unexpected ast kind `%s`.', selection.kind) : invariant(false) : void 0;
@@ -366,8 +388,10 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
         }
       }
 
-      if (selection.kind === SCALAR_FIELD && process.env.NODE_ENV !== "production") {
-        this._validateConflictingFieldsWithIdenticalId(record, storageKey, fieldValue);
+      if (process.env.NODE_ENV !== "production") {
+        if (selection.kind === SCALAR_FIELD) {
+          this._validateConflictingFieldsWithIdenticalId(record, storageKey, fieldValue);
+        }
       }
 
       RelayModernRecord.setValue(record, storageKey, null);
@@ -375,7 +399,9 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
     }
 
     if (selection.kind === SCALAR_FIELD) {
-      this._validateConflictingFieldsWithIdenticalId(record, storageKey, fieldValue);
+      if (process.env.NODE_ENV !== "production") {
+        this._validateConflictingFieldsWithIdenticalId(record, storageKey, fieldValue);
+      }
 
       RelayModernRecord.setValue(record, storageKey, fieldValue);
     } else if (selection.kind === LINKED_FIELD) {
@@ -394,6 +420,70 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
     }
   };
 
+  _proto._normalizeFlightField = function _normalizeFlightField(parent, selection, record, data) {
+    var responseKey = selection.alias || selection.name;
+    var storageKey = getStorageKey(selection, this._variables);
+    var fieldValue = data[responseKey];
+
+    if (fieldValue == null) {
+      RelayModernRecord.setValue(record, storageKey, null);
+      return;
+    }
+
+    var reactFlightPayload = refineToReactFlightPayloadData(fieldValue);
+    !(reactFlightPayload != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer(): Expected React Flight payload data ' + 'to be an object with `tree` and `queries` properties, got `%s`.', fieldValue) : invariant(false) : void 0;
+    !(typeof this._reactFlightPayloadDeserializer === 'function') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer: Expected reactFlightPayloadDeserializer to ' + 'be a function, got `%s`.', this._reactFlightPayloadDeserializer) : invariant(false) : void 0; // We store the deserialized reactFlightClientResponse in a separate
+    // record and link it to the parent record. This is so we can GC the Flight
+    // tree later even if the parent record is still reachable.
+
+    var reactFlightClientResponse = this._reactFlightPayloadDeserializer(reactFlightPayload.tree);
+
+    var reactFlightID = generateClientID(RelayModernRecord.getDataID(record), getStorageKey(selection, this._variables));
+
+    var reactFlightClientResponseRecord = this._recordSource.get(reactFlightID);
+
+    if (reactFlightClientResponseRecord == null) {
+      reactFlightClientResponseRecord = RelayModernRecord.create(reactFlightID, REACT_FLIGHT_TYPE_NAME);
+
+      this._recordSource.set(reactFlightID, reactFlightClientResponseRecord);
+    }
+
+    RelayModernRecord.setValue(reactFlightClientResponseRecord, REACT_FLIGHT_TREE_STORAGE_KEY, reactFlightClientResponse);
+    var reachableQueries = [];
+
+    var _iterator = (0, _createForOfIteratorHelper2["default"])(reactFlightPayload.queries),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var query = _step.value;
+
+        if (query.response.data != null) {
+          this._moduleImportPayloads.push({
+            data: query.response.data,
+            dataID: ROOT_ID,
+            operationReference: query.module,
+            path: [],
+            typeName: ROOT_TYPE,
+            variables: query.variables
+          });
+        }
+
+        reachableQueries.push({
+          module: query.module,
+          variables: query.variables
+        });
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    RelayModernRecord.setValue(reactFlightClientResponseRecord, REACT_FLIGHT_QUERIES_STORAGE_KEY, reachableQueries);
+    RelayModernRecord.setLinkedRecordID(record, storageKey, reactFlightID);
+  };
+
   _proto._normalizeLink = function _normalizeLink(field, record, storageKey, fieldValue) {
     var _field$concreteType;
 
@@ -463,10 +553,14 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
         _this._recordSource.set(nextID, nextRecord);
       } else if (process.env.NODE_ENV !== "production") {
         _this._validateRecordType(nextRecord, field, item);
-      }
+      } // NOTE: the check to strip __DEV__ code only works for simple
+      // `if (__DEV__)`
 
-      if (prevIDs && process.env.NODE_ENV !== "production") {
-        _this._validateConflictingLinkedFieldsWithIdenticalId(record, prevIDs[nextIndex], nextID, storageKey);
+
+      if (process.env.NODE_ENV !== "production") {
+        if (prevIDs) {
+          _this._validateConflictingLinkedFieldsWithIdenticalId(record, prevIDs[nextIndex], nextID, storageKey);
+        }
       } // $FlowFixMe[incompatible-variance]
 
 
@@ -494,10 +588,11 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
   ;
 
   _proto._validateConflictingFieldsWithIdenticalId = function _validateConflictingFieldsWithIdenticalId(record, storageKey, fieldValue) {
+    // NOTE: Only call this function in DEV
     if (process.env.NODE_ENV !== "production") {
       var dataID = RelayModernRecord.getDataID(record);
       var previousValue = RelayModernRecord.getValue(record, storageKey);
-      process.env.NODE_ENV !== "production" ? warning(storageKey === TYPENAME_KEY || previousValue === undefined || previousValue === fieldValue, 'RelayResponseNormalizer: Invalid record. The record contains two ' + 'instances of the same id: `%s` with conflicting field, %s and its values: %s and %s. ' + 'If two fields are different but share ' + 'the same id, one field will overwrite the other.', dataID, storageKey, previousValue, fieldValue) : void 0;
+      process.env.NODE_ENV !== "production" ? warning(storageKey === TYPENAME_KEY || previousValue === undefined || areEqual(previousValue, fieldValue), 'RelayResponseNormalizer: Invalid record. The record contains two ' + 'instances of the same id: `%s` with conflicting field, %s and its values: %s and %s. ' + 'If two fields are different but share ' + 'the same id, one field will overwrite the other.', dataID, storageKey, previousValue, fieldValue) : void 0;
     }
   }
   /**
@@ -506,6 +601,7 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
   ;
 
   _proto._validateConflictingLinkedFieldsWithIdenticalId = function _validateConflictingLinkedFieldsWithIdenticalId(record, prevID, nextID, storageKey) {
+    // NOTE: Only call this function in DEV
     if (process.env.NODE_ENV !== "production") {
       process.env.NODE_ENV !== "production" ? warning(prevID === undefined || prevID === nextID, 'RelayResponseNormalizer: Invalid record. The record contains ' + 'references to the conflicting field, %s and its id values: %s and %s. ' + 'We need to make sure that the record the field points ' + 'to remains consistent or one field will overwrite the other.', storageKey, prevID, nextID) : void 0;
     }

package/lib/store/RelayStoreReactFlightUtils.js

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var invariant = require("fbjs/lib/invariant");
+
+var _require = require('./RelayModernRecord'),
+    getType = _require.getType;
+
+var REACT_FLIGHT_QUERIES_STORAGE_KEY = 'queries';
+var REACT_FLIGHT_TREE_STORAGE_KEY = 'tree';
+var REACT_FLIGHT_TYPE_NAME = 'ReactFlightComponent';
+
+function refineToReactFlightPayloadData(payload) {
+  if (payload == null || typeof payload !== 'object' || !Array.isArray(payload.tree) || !Array.isArray(payload.queries)) {
+    return null;
+  }
+
+  return payload;
+}
+
+function getReactFlightClientResponse(record) {
+  !(getType(record) === REACT_FLIGHT_TYPE_NAME) ? process.env.NODE_ENV !== "production" ? invariant(false, 'getReactFlightClientResponse(): Expected a ReactFlightComponentRecord, ' + 'got %s.', record) : invariant(false) : void 0;
+  var response = record[REACT_FLIGHT_TREE_STORAGE_KEY];
+
+  if (response != null) {
+    return response;
+  }
+
+  return null;
+}
+
+module.exports = {
+  REACT_FLIGHT_QUERIES_STORAGE_KEY: REACT_FLIGHT_QUERIES_STORAGE_KEY,
+  REACT_FLIGHT_TREE_STORAGE_KEY: REACT_FLIGHT_TREE_STORAGE_KEY,
+  REACT_FLIGHT_TYPE_NAME: REACT_FLIGHT_TYPE_NAME,
+  getReactFlightClientResponse: getReactFlightClientResponse,
+  refineToReactFlightPayloadData: refineToReactFlightPayloadData
+};

package/lib/store/RelayStoreSubscriptions.js

@@ -0,0 +1,162 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var RelayReader = require('./RelayReader');
+
+var deepFreeze = require('../util/deepFreeze');
+
+var hasOverlappingIDs = require('./hasOverlappingIDs');
+
+var isEmptyObject = require('../util/isEmptyObject');
+
+var recycleNodesInto = require('../util/recycleNodesInto');
+
+var RelayStoreSubscriptions = /*#__PURE__*/function () {
+  function RelayStoreSubscriptions() {
+    this._subscriptions = new Set();
+  }
+
+  var _proto = RelayStoreSubscriptions.prototype;
+
+  _proto.subscribe = function subscribe(snapshot, callback) {
+    var _this = this;
+
+    var subscription = {
+      backup: null,
+      callback: callback,
+      snapshot: snapshot,
+      stale: false
+    };
+
+    var dispose = function dispose() {
+      _this._subscriptions["delete"](subscription);
+    };
+
+    this._subscriptions.add(subscription);
+
+    return {
+      dispose: dispose
+    };
+  };
+
+  _proto.snapshotSubscriptions = function snapshotSubscriptions(source) {
+    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;
+      }
+
+      var snapshot = subscription.snapshot;
+      var backup = RelayReader.read(source, snapshot.selector);
+      var nextData = recycleNodesInto(snapshot.data, backup.data);
+      backup.data = nextData; // backup owns the snapshot and can safely mutate
+
+      subscription.backup = backup;
+    });
+  };
+
+  _proto.restoreSubscriptions = function restoreSubscriptions() {
+    this._subscriptions.forEach(function (subscription) {
+      var backup = subscription.backup;
+      subscription.backup = null;
+
+      if (backup) {
+        if (backup.data !== subscription.snapshot.data) {
+          subscription.stale = true;
+        }
+
+        subscription.snapshot = {
+          data: subscription.snapshot.data,
+          isMissingData: backup.isMissingData,
+          seenRecords: backup.seenRecords,
+          selector: backup.selector,
+          missingRequiredFields: backup.missingRequiredFields
+        };
+      } else {
+        subscription.stale = true;
+      }
+    });
+  };
+
+  _proto.updateSubscriptions = function updateSubscriptions(source, updatedRecordIDs, updatedOwners) {
+    var _this2 = this;
+
+    var hasUpdatedRecords = !isEmptyObject(updatedRecordIDs);
+
+    this._subscriptions.forEach(function (subscription) {
+      var owner = _this2._updateSubscription(source, subscription, updatedRecordIDs, hasUpdatedRecords);
+
+      if (owner != null) {
+        updatedOwners.push(owner);
+      }
+    });
+  }
+  /**
+   * Notifies the callback for the subscription if the data for the associated
+   * snapshot has changed.
+   * Additionally, updates the subscription snapshot with the latest snapshot,
+   * and marks it as not stale.
+   * Returns the owner (RequestDescriptor) if the subscription was affected by the
+   * latest update, or null if it was not affected.
+   */
+  ;
+
+  _proto._updateSubscription = function _updateSubscription(source, subscription, updatedRecordIDs, hasUpdatedRecords) {
+    var backup = subscription.backup,
+        callback = subscription.callback,
+        snapshot = subscription.snapshot,
+        stale = subscription.stale;
+    var hasOverlappingUpdates = hasUpdatedRecords && hasOverlappingIDs(snapshot.seenRecords, updatedRecordIDs);
+
+    if (!stale && !hasOverlappingUpdates) {
+      return;
+    }
+
+    var nextSnapshot = hasOverlappingUpdates || !backup ? RelayReader.read(source, snapshot.selector) : backup;
+    var nextData = recycleNodesInto(snapshot.data, nextSnapshot.data);
+    nextSnapshot = {
+      data: nextData,
+      isMissingData: nextSnapshot.isMissingData,
+      seenRecords: nextSnapshot.seenRecords,
+      selector: nextSnapshot.selector,
+      missingRequiredFields: nextSnapshot.missingRequiredFields
+    };
+
+    if (process.env.NODE_ENV !== "production") {
+      deepFreeze(nextSnapshot);
+    }
+
+    subscription.snapshot = nextSnapshot;
+    subscription.stale = false;
+
+    if (nextSnapshot.data !== snapshot.data) {
+      callback(nextSnapshot);
+      return snapshot.selector.owner;
+    }
+  };
+
+  return RelayStoreSubscriptions;
+}();
+
+module.exports = RelayStoreSubscriptions;

package/lib/store/RelayStoreSubscriptionsUsingMapByID.js

@@ -0,0 +1,258 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var RelayReader = require('./RelayReader');
+
+var deepFreeze = require('../util/deepFreeze');
+
+var recycleNodesInto = require('../util/recycleNodesInto');
+
+var RelayStoreSubscriptionsUsingMapByID = /*#__PURE__*/function () {
+  function RelayStoreSubscriptionsUsingMapByID() {
+    this._notifiedRevision = 0;
+    this._snapshotRevision = 0;
+    this._subscriptionsByDataId = new Map();
+    this._staleSubscriptions = new Set();
+  }
+
+  var _proto = RelayStoreSubscriptionsUsingMapByID.prototype;
+
+  _proto.subscribe = function subscribe(snapshot, callback) {
+    var _this = this;
+
+    var subscription = {
+      backup: null,
+      callback: callback,
+      notifiedRevision: this._notifiedRevision,
+      snapshotRevision: this._snapshotRevision,
+      snapshot: snapshot
+    };
+
+    var dispose = function dispose() {
+      for (var dataId in snapshot.seenRecords) {
+        var subscriptionsForDataId = _this._subscriptionsByDataId.get(dataId);
+
+        if (subscriptionsForDataId != null) {
+          subscriptionsForDataId["delete"](subscription);
+
+          if (subscriptionsForDataId.size === 0) {
+            _this._subscriptionsByDataId["delete"](dataId);
+          }
+        }
+      }
+    };
+
+    for (var dataId in snapshot.seenRecords) {
+      var subscriptionsForDataId = this._subscriptionsByDataId.get(dataId);
+
+      if (subscriptionsForDataId != null) {
+        subscriptionsForDataId.add(subscription);
+      } else {
+        this._subscriptionsByDataId.set(dataId, new Set([subscription]));
+      }
+    }
+
+    return {
+      dispose: dispose
+    };
+  };
+
+  _proto.snapshotSubscriptions = function snapshotSubscriptions(source) {
+    var _this2 = this;
+
+    this._snapshotRevision++;
+
+    this._subscriptionsByDataId.forEach(function (subscriptions) {
+      subscriptions.forEach(function (subscription) {
+        if (subscription.snapshotRevision === _this2._snapshotRevision) {
+          return;
+        }
+
+        subscription.snapshotRevision = _this2._snapshotRevision; // 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 (!_this2._staleSubscriptions.has(subscription)) {
+          subscription.backup = subscription.snapshot;
+          return;
+        }
+
+        var snapshot = subscription.snapshot;
+        var backup = RelayReader.read(source, snapshot.selector);
+        var nextData = recycleNodesInto(snapshot.data, backup.data);
+        backup.data = nextData; // backup owns the snapshot and can safely mutate
+
+        subscription.backup = backup;
+      });
+    });
+  };
+
+  _proto.restoreSubscriptions = function restoreSubscriptions() {
+    var _this3 = this;
+
+    this._snapshotRevision++;
+
+    this._subscriptionsByDataId.forEach(function (subscriptions) {
+      subscriptions.forEach(function (subscription) {
+        if (subscription.snapshotRevision === _this3._snapshotRevision) {
+          return;
+        }
+
+        subscription.snapshotRevision = _this3._snapshotRevision;
+        var backup = subscription.backup;
+        subscription.backup = null;
+
+        if (backup) {
+          if (backup.data !== subscription.snapshot.data) {
+            _this3._staleSubscriptions.add(subscription);
+          }
+
+          var prevSeenRecords = subscription.snapshot.seenRecords;
+          subscription.snapshot = {
+            data: subscription.snapshot.data,
+            isMissingData: backup.isMissingData,
+            seenRecords: backup.seenRecords,
+            selector: backup.selector,
+            missingRequiredFields: backup.missingRequiredFields
+          };
+
+          _this3._updateSubscriptionsMap(subscription, prevSeenRecords);
+        } else {
+          _this3._staleSubscriptions.add(subscription);
+        }
+      });
+    });
+  };
+
+  _proto.updateSubscriptions = function updateSubscriptions(source, updatedRecordIDs, updatedOwners) {
+    var _this4 = this;
+
+    this._notifiedRevision++;
+    Object.keys(updatedRecordIDs).forEach(function (updatedRecordId) {
+      var subcriptionsForDataId = _this4._subscriptionsByDataId.get(updatedRecordId);
+
+      if (subcriptionsForDataId == null) {
+        return;
+      }
+
+      subcriptionsForDataId.forEach(function (subscription) {
+        if (subscription.notifiedRevision === _this4._notifiedRevision) {
+          return;
+        }
+
+        var owner = _this4._updateSubscription(source, subscription, false);
+
+        if (owner != null) {
+          updatedOwners.push(owner);
+        }
+      });
+    });
+
+    this._staleSubscriptions.forEach(function (subscription) {
+      if (subscription.notifiedRevision === _this4._notifiedRevision) {
+        return;
+      }
+
+      var owner = _this4._updateSubscription(source, subscription, true);
+
+      if (owner != null) {
+        updatedOwners.push(owner);
+      }
+    });
+
+    this._staleSubscriptions.clear();
+  }
+  /**
+   * Notifies the callback for the subscription if the data for the associated
+   * snapshot has changed.
+   * Additionally, updates the subscription snapshot with the latest snapshot,
+   * amarks it as not stale, and updates the subscription tracking for any
+   * any new ids observed in the latest data snapshot.
+   * Returns the owner (RequestDescriptor) if the subscription was affected by the
+   * latest update, or null if it was not affected.
+   */
+  ;
+
+  _proto._updateSubscription = function _updateSubscription(source, subscription, stale) {
+    var backup = subscription.backup,
+        callback = subscription.callback,
+        snapshot = subscription.snapshot;
+    var nextSnapshot = stale && backup != null ? backup : RelayReader.read(source, snapshot.selector);
+    var nextData = recycleNodesInto(snapshot.data, nextSnapshot.data);
+    nextSnapshot = {
+      data: nextData,
+      isMissingData: nextSnapshot.isMissingData,
+      seenRecords: nextSnapshot.seenRecords,
+      selector: nextSnapshot.selector,
+      missingRequiredFields: nextSnapshot.missingRequiredFields
+    };
+
+    if (process.env.NODE_ENV !== "production") {
+      deepFreeze(nextSnapshot);
+    }
+
+    var prevSeenRecords = subscription.snapshot.seenRecords;
+    subscription.snapshot = nextSnapshot;
+    subscription.notifiedRevision = this._notifiedRevision;
+
+    this._updateSubscriptionsMap(subscription, prevSeenRecords);
+
+    if (nextSnapshot.data !== snapshot.data) {
+      callback(nextSnapshot);
+      return snapshot.selector.owner;
+    }
+  }
+  /**
+   * Updates the Map that tracks subscriptions by id.
+   * Given an updated subscription and the records that where seen
+   * on the previous subscription snapshot, updates our tracking
+   * to track the subscription for the newly and no longer seen ids.
+   */
+  ;
+
+  _proto._updateSubscriptionsMap = function _updateSubscriptionsMap(subscription, prevSeenRecords) {
+    for (var dataId in prevSeenRecords) {
+      var subscriptionsForDataId = this._subscriptionsByDataId.get(dataId);
+
+      if (subscriptionsForDataId != null) {
+        subscriptionsForDataId["delete"](subscription);
+
+        if (subscriptionsForDataId.size === 0) {
+          this._subscriptionsByDataId["delete"](dataId);
+        }
+      }
+    }
+
+    for (var _dataId in subscription.snapshot.seenRecords) {
+      var _subscriptionsForDataId = this._subscriptionsByDataId.get(_dataId);
+
+      if (_subscriptionsForDataId != null) {
+        _subscriptionsForDataId.add(subscription);
+      } else {
+        this._subscriptionsByDataId.set(_dataId, new Set([subscription]));
+      }
+    }
+  };
+
+  return RelayStoreSubscriptionsUsingMapByID;
+}();
+
+module.exports = RelayStoreSubscriptionsUsingMapByID;