relay-runtime 20.1.1 → 21.0.1

package/lib/store/RelayErrorTrie.js

@@ -120,6 +120,6 @@ function getNestedErrorTrieByKey(trie, key) {
 module.exports = {
   SELF: SELF,
   buildErrorTrie: buildErrorTrie,
-  getNestedErrorTrieByKey: getNestedErrorTrieByKey,
-  getErrorsByKey: getErrorsByKey
+  getErrorsByKey: getErrorsByKey,
+  getNestedErrorTrieByKey: getNestedErrorTrieByKey
 };

package/lib/store/RelayExperimentalGraphResponseTransform.js

@@ -89,10 +89,10 @@ var GraphModeNormalizer = /*#__PURE__*/function () {
     yield* this._traverseSelections(node, data, rootFields, dataID, new Set());
     var $streamID = this._getStreamID();
     yield (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, rootFields), {}, {
-      $kind: 'Record',
-      $streamID: $streamID,
       __id: dataID,
-      __typename: ROOT_TYPE
+      __typename: ROOT_TYPE,
+      $kind: 'Record',
+      $streamID: $streamID
     });
     yield {
       $kind: 'Complete'
@@ -104,9 +104,9 @@ var GraphModeNormalizer = /*#__PURE__*/function () {
     if (maybeStreamID == null) {
       this._cacheKeyToStreamID.set(cacheKey, $streamID);
       yield (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, fields), {}, {
-        $kind: 'Record',
-        __typename: typename,
         __id: cacheKey,
+        __typename: typename,
+        $kind: 'Record',
         $streamID: $streamID
       });
     } else if (Object.keys(fields).length > 0) {
@@ -190,13 +190,13 @@ var GraphModeNormalizer = /*#__PURE__*/function () {
               yield* this._traverseSelections(selection, data, parentFields, parentID, sentFields);
             } else {
               this._incrementalPlaceholders.push({
-                kind: 'defer',
+                actorIdentifier: this._actorIdentifier,
                 data: data,
+                kind: 'defer',
                 label: selection.label,
                 path: (0, _toConsumableArray2["default"])(this._path),
                 selector: createNormalizationSelector(selection, parentID, this._variables),
-                typeName: this._getObjectType(data),
-                actorIdentifier: this._actorIdentifier
+                typeName: this._getObjectType(data)
               });
             }
             break;

package/lib/store/RelayModernEnvironment.js

@@ -24,6 +24,7 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
     var _config$store, _config$log, _config$relayFieldLog, _config$UNSTABLE_defa, _config$getDataID, _config$missingFieldH, _config$handlerProvid, _config$scheduler, _config$isServer, _config$normalizeResp, _config$operationTrac;
     this.configName = config.configName;
     this._treatMissingFieldsAsNull = config.treatMissingFieldsAsNull === true;
+    this._deferDeduplicatedFields = config.deferDeduplicatedFields === true;
     var operationLoader = config.operationLoader;
     if (process.env.NODE_ENV !== "production") {
       if (operationLoader != null) {
@@ -31,9 +32,9 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
       }
     }
     var store = (_config$store = config.store) !== null && _config$store !== void 0 ? _config$store : new RelayModernStore(new RelayRecordSource(), {
+      getDataID: config.getDataID,
       log: config.log,
       operationLoader: config.operationLoader,
-      getDataID: config.getDataID,
       shouldProcessClientComponents: config.shouldProcessClientComponents
     });
     this.__log = (_config$log = config.log) !== null && _config$log !== void 0 ? _config$log : emptyFunction;
@@ -166,6 +167,11 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
   _proto.retain = function retain(operation) {
     return this._store.retain(operation);
   };
+  _proto.experimental_batchUpdates = function experimental_batchUpdates(callback) {
+    var batchFn = this._store.experimental_batchUpdates;
+    !(typeof batchFn === 'function') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: The current store does not support experimental_batchUpdates.') : invariant(false) : void 0;
+    batchFn.call(this._store, callback);
+  };
   _proto.isServer = function isServer() {
     return this._isServer;
   };
@@ -174,7 +180,6 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
     var target = RelayRecordSource.create();
     var source = this._store.getSource();
     var result = this._store.check(operation, {
-      handlers: handlers,
       defaultActorIdentifier: INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
       getSourceForActor: function getSourceForActor(actorIdentifier) {
         assertInternalActorIdentifier(actorIdentifier);
@@ -183,7 +188,8 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
       getTargetForActor: function getTargetForActor(actorIdentifier) {
         assertInternalActorIdentifier(actorIdentifier);
         return target;
-      }
+      },
+      handlers: handlers
     });
     if (target.size() > 0) {
       this._scheduleUpdates(function () {
@@ -275,7 +281,7 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
     return "RelayModernEnvironment(".concat((_this$configName = this.configName) !== null && _this$configName !== void 0 ? _this$configName : '', ")");
   };
   _proto._execute = function _execute(_ref5) {
-    var _this10 = this;
+    var _this0 = this;
     var createSource = _ref5.createSource,
       isClientPayload = _ref5.isClientPayload,
       operation = _ref5.operation,
@@ -286,29 +292,30 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
     return RelayObservable.create(function (sink) {
       var executor = OperationExecutor.execute({
         actorIdentifier: INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
-        getDataID: _this10._getDataID,
-        isClientPayload: isClientPayload,
-        log: _this10.__log,
-        operation: operation,
-        operationExecutions: _this10._operationExecutions,
-        operationLoader: _this10._operationLoader,
-        operationTracker: _this10._operationTracker,
-        optimisticConfig: optimisticConfig,
+        getDataID: _this0._getDataID,
         getPublishQueue: function getPublishQueue(actorIdentifier) {
           assertInternalActorIdentifier(actorIdentifier);
           return publishQueue;
         },
-        scheduler: _this10._scheduler,
-        shouldProcessClientComponents: _this10._shouldProcessClientComponents,
-        sink: sink,
-        source: createSource(),
         getStore: function getStore(actorIdentifier) {
           assertInternalActorIdentifier(actorIdentifier);
           return store;
         },
-        treatMissingFieldsAsNull: _this10._treatMissingFieldsAsNull,
-        updater: updater,
-        normalizeResponse: _this10._normalizeResponse
+        isClientPayload: isClientPayload,
+        log: _this0.__log,
+        normalizeResponse: _this0._normalizeResponse,
+        operation: operation,
+        operationExecutions: _this0._operationExecutions,
+        operationLoader: _this0._operationLoader,
+        operationTracker: _this0._operationTracker,
+        optimisticConfig: optimisticConfig,
+        scheduler: _this0._scheduler,
+        shouldProcessClientComponents: _this0._shouldProcessClientComponents,
+        sink: sink,
+        source: createSource(),
+        treatMissingFieldsAsNull: _this0._treatMissingFieldsAsNull,
+        deferDeduplicatedFields: _this0._deferDeduplicatedFields,
+        updater: updater
       });
       return function () {
         return executor.cancel();

package/lib/store/RelayModernRecord.js

@@ -292,6 +292,15 @@ function getResolverLinkedRecordIDs(record, typeName) {
     return generateClientObjectClientID(typeName, id);
   });
 }
+function hasFieldChanged(prevRecord, nextRecord, storageKey) {
+  var _prevRecord$ERRORS_KE, _nextRecord$ERRORS_KE;
+  if (!areEqual(prevRecord[storageKey], nextRecord[storageKey])) {
+    return true;
+  }
+  var prevErrors = (_prevRecord$ERRORS_KE = prevRecord[ERRORS_KEY]) === null || _prevRecord$ERRORS_KE === void 0 ? void 0 : _prevRecord$ERRORS_KE[storageKey];
+  var nextErrors = (_nextRecord$ERRORS_KE = nextRecord[ERRORS_KEY]) === null || _nextRecord$ERRORS_KE === void 0 ? void 0 : _nextRecord$ERRORS_KE[storageKey];
+  return !areEqual(prevErrors, nextErrors);
+}
 function toJSON(record) {
   return record;
 }
@@ -301,26 +310,27 @@ module.exports = {
   create: create,
   freeze: freeze,
   fromObject: fromObject,
+  getActorLinkedRecordID: getActorLinkedRecordID,
   getDataID: getDataID,
   getErrors: getErrors,
   getFields: getFields,
   getInvalidationEpoch: getInvalidationEpoch,
   getLinkedRecordID: getLinkedRecordID,
   getLinkedRecordIDs: getLinkedRecordIDs,
+  getResolverLinkedRecordID: getResolverLinkedRecordID,
+  getResolverLinkedRecordIDs: getResolverLinkedRecordIDs,
   getType: getType,
   getValue: getValue,
-  hasValue: hasValue,
+  hasFieldChanged: hasFieldChanged,
   hasLinkedRecordID: hasLinkedRecordID,
   hasLinkedRecordIDs: hasLinkedRecordIDs,
+  hasValue: hasValue,
   merge: merge,
+  setActorLinkedRecordID: setActorLinkedRecordID,
   setErrors: setErrors,
-  setValue: setValue,
   setLinkedRecordID: setLinkedRecordID,
   setLinkedRecordIDs: setLinkedRecordIDs,
-  update: update,
-  getActorLinkedRecordID: getActorLinkedRecordID,
-  setActorLinkedRecordID: setActorLinkedRecordID,
-  getResolverLinkedRecordID: getResolverLinkedRecordID,
-  getResolverLinkedRecordIDs: getResolverLinkedRecordIDs,
-  toJSON: toJSON
+  setValue: setValue,
+  toJSON: toJSON,
+  update: update
 };

package/lib/store/RelayModernSelector.js

@@ -210,13 +210,13 @@ function createReaderSelector(fragment, dataID, variables, request) {
   var isWithinUnmatchedTypeRefinement = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
   var clientEdgeTraversalPath = arguments.length > 5 ? arguments[5] : undefined;
   return {
-    kind: 'SingularReaderSelector',
+    clientEdgeTraversalPath: clientEdgeTraversalPath !== null && clientEdgeTraversalPath !== void 0 ? clientEdgeTraversalPath : null,
     dataID: dataID,
     isWithinUnmatchedTypeRefinement: isWithinUnmatchedTypeRefinement,
-    clientEdgeTraversalPath: clientEdgeTraversalPath !== null && clientEdgeTraversalPath !== void 0 ? clientEdgeTraversalPath : null,
+    kind: 'SingularReaderSelector',
     node: fragment,
-    variables: variables,
-    owner: request
+    owner: request,
+    variables: variables
   };
 }
 function createNormalizationSelector(node, dataID, variables) {
@@ -228,16 +228,16 @@ function createNormalizationSelector(node, dataID, variables) {
 }
 module.exports = {
   areEqualSelectors: areEqualSelectors,
-  createReaderSelector: createReaderSelector,
   createNormalizationSelector: createNormalizationSelector,
+  createReaderSelector: createReaderSelector,
   getDataIDsFromFragment: getDataIDsFromFragment,
   getDataIDsFromObject: getDataIDsFromObject,
-  getSingularSelector: getSingularSelector,
   getPluralSelector: getPluralSelector,
   getSelector: getSelector,
   getSelectorsFromObject: getSelectorsFromObject,
-  getVariablesFromSingularFragment: getVariablesFromSingularFragment,
-  getVariablesFromPluralFragment: getVariablesFromPluralFragment,
+  getSingularSelector: getSingularSelector,
   getVariablesFromFragment: getVariablesFromFragment,
-  getVariablesFromObject: getVariablesFromObject
+  getVariablesFromObject: getVariablesFromObject,
+  getVariablesFromPluralFragment: getVariablesFromPluralFragment,
+  getVariablesFromSingularFragment: getVariablesFromSingularFragment
 };

package/lib/store/RelayModernStore.js

@@ -7,6 +7,7 @@ var _require = require('../multi-actor-environment/ActorIdentifier'),
   INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE = _require.INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
   assertInternalActorIdentifier = _require.assertInternalActorIdentifier;
 var deepFreeze = require('../util/deepFreeze');
+var RelayFeatureFlags = require('../util/RelayFeatureFlags');
 var resolveImmediate = require('../util/resolveImmediate');
 var DataChecker = require('./DataChecker');
 var defaultGetDataID = require('./defaultGetDataID');
@@ -21,14 +22,16 @@ var RelayReferenceMarker = require('./RelayReferenceMarker');
 var RelayStoreSubscriptions = require('./RelayStoreSubscriptions');
 var RelayStoreUtils = require('./RelayStoreUtils');
 var _require3 = require('./RelayStoreUtils'),
+  FIELD_GRANULAR_NOTIFICATIONS_KEY = _require3.FIELD_GRANULAR_NOTIFICATIONS_KEY,
   ROOT_ID = _require3.ROOT_ID,
-  ROOT_TYPE = _require3.ROOT_TYPE;
+  ROOT_TYPE = _require3.ROOT_TYPE,
+  getFieldNotificationKey = _require3.getFieldNotificationKey;
 var invariant = require('invariant');
 var DEFAULT_RELEASE_BUFFER_SIZE = 10;
 var RelayModernStore = /*#__PURE__*/function () {
   function RelayModernStore(source, options) {
     var _this = this;
-    var _options$gcReleaseBuf, _options$shouldRetain, _options$gcScheduler, _options$getDataID, _options$log, _options$operationLoa, _options$shouldProces, _options$treatMissing;
+    var _options$gcReleaseBuf, _options$shouldRetain, _options$gcScheduler, _options$getDataID, _options$log, _options$operationLoa, _options$shouldProces, _options$treatMissing, _options$deferDedupli;
     (0, _defineProperty2["default"])(this, "_gcStep", function () {
       if (_this._gcRun) {
         if (_this._gcRun.next().done) {
@@ -73,7 +76,9 @@ var RelayModernStore = /*#__PURE__*/function () {
     this._updatedRecordIDs = new Set();
     this._shouldProcessClientComponents = (_options$shouldProces = options === null || options === void 0 ? void 0 : options.shouldProcessClientComponents) !== null && _options$shouldProces !== void 0 ? _options$shouldProces : false;
     this._treatMissingFieldsAsNull = (_options$treatMissing = options === null || options === void 0 ? void 0 : options.treatMissingFieldsAsNull) !== null && _options$treatMissing !== void 0 ? _options$treatMissing : false;
+    this._deferDeduplicatedFields = (_options$deferDedupli = options === null || options === void 0 ? void 0 : options.deferDeduplicatedFields) !== null && _options$deferDedupli !== void 0 ? _options$deferDedupli : false;
     this._actorIdentifier = options === null || options === void 0 ? void 0 : options.actorIdentifier;
+    this._batch = null;
     initializeRecordSource(this._recordSource);
   }
   var _proto = RelayModernStore.prototype;
@@ -107,6 +112,65 @@ var RelayModernStore = /*#__PURE__*/function () {
       }
     }
   };
+  _proto.experimental_batchUpdates = function experimental_batchUpdates(callback) {
+    if (this._batch != null) {
+      throw new Error('RelayModernStore: Cannot batch updates while already batching updates.');
+    }
+    var log = this.__log;
+    if (log != null) {
+      log({
+        name: 'store.batch.start'
+      });
+    }
+    var batch = {
+      sourceOperations: [],
+      invalidateStore: false
+    };
+    this._batch = batch;
+    try {
+      callback();
+    } finally {
+      this._batch = null;
+      this.notify(undefined, batch.invalidateStore);
+      var _iterator = (0, _createForOfIteratorHelper2["default"])(batch.sourceOperations),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var sourceOperation = _step.value;
+          this._recordSourceOperation(sourceOperation);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      if (log != null) {
+        log({
+          name: 'store.batch.complete',
+          sourceOperations: batch.sourceOperations,
+          invalidateStore: batch.invalidateStore
+        });
+      }
+    }
+  };
+  _proto.batchLiveStateUpdatesWithoutNotify = function batchLiveStateUpdatesWithoutNotify(callback) {
+    if (this.__log != null) {
+      this.__log({
+        name: 'liveresolver.batch.start'
+      });
+    }
+    var hasPublished = false;
+    try {
+      hasPublished = this._resolverCache.batchLiveStateUpdatesWithoutNotify(callback);
+    } finally {
+      if (this.__log != null) {
+        this.__log({
+          name: 'liveresolver.batch.end'
+        });
+      }
+    }
+    return hasPublished;
+  };
   _proto.check = function check(operation, options) {
     var _ref, _operation$request$no, _operation$request$no2, _options$handlers, _options$getSourceFor, _options$getTargetFor, _options$defaultActor;
     var selector = operation.root;
@@ -197,7 +261,7 @@ var RelayModernStore = /*#__PURE__*/function () {
       });
     }
     var source = this.getSource();
-    var snapshot = RelayReader.read(source, selector, this._resolverCache, this._resolverContext);
+    var snapshot = RelayReader.read(source, selector, log, this._resolverCache, this._resolverContext);
     if (process.env.NODE_ENV !== "production") {
       deepFreeze(snapshot);
     }
@@ -211,6 +275,16 @@ var RelayModernStore = /*#__PURE__*/function () {
   };
   _proto.notify = function notify(sourceOperation, invalidateStore) {
     var _this3 = this;
+    var batch = this._batch;
+    if (batch != null) {
+      if (sourceOperation != null) {
+        batch.sourceOperations.push(sourceOperation);
+      }
+      if (invalidateStore === true) {
+        batch.invalidateStore = true;
+      }
+      return [];
+    }
     var log = this.__log;
     if (log != null) {
       log({
@@ -218,34 +292,36 @@ var RelayModernStore = /*#__PURE__*/function () {
         sourceOperation: sourceOperation
       });
     }
-    this._currentWriteEpoch++;
-    if (invalidateStore === true) {
-      this._globalInvalidationEpoch = this._currentWriteEpoch;
+    if (!RelayFeatureFlags.OPTIMIZE_NOTIFY) {
+      this._currentWriteEpoch++;
+      if (invalidateStore === true) {
+        this._globalInvalidationEpoch = this._currentWriteEpoch;
+      }
+    }
+    if (!RelayFeatureFlags.OPTIMIZE_NOTIFY || this._updatedRecordIDs.size > 0) {
+      this._resolverCache.invalidateDataIDs(this._updatedRecordIDs);
     }
-    this._resolverCache.invalidateDataIDs(this._updatedRecordIDs);
     var source = this.getSource();
     var updatedOwners = [];
-    this._storeSubscriptions.updateSubscriptions(source, this._updatedRecordIDs, updatedOwners, sourceOperation);
-    this._invalidationSubscriptions.forEach(function (subscription) {
-      _this3._updateInvalidationSubscription(subscription, invalidateStore === true);
-    });
-    if (sourceOperation != null) {
-      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) {
-        var temporaryRootEntry = {
-          operation: sourceOperation,
-          refCount: 0,
-          epoch: this._currentWriteEpoch,
-          fetchTime: Date.now()
-        };
-        this._releaseBuffer.push(id);
-        this._roots.set(id, temporaryRootEntry);
+    if (!RelayFeatureFlags.OPTIMIZE_NOTIFY || this._updatedRecordIDs.size > 0) {
+      this._storeSubscriptions.updateSubscriptions(source, this._updatedRecordIDs, updatedOwners, sourceOperation);
+    } else {
+      this._storeSubscriptions.updateStaleSubscriptions(source, this._updatedRecordIDs, updatedOwners, sourceOperation);
+    }
+    if (RelayFeatureFlags.OPTIMIZE_NOTIFY && (this._updatedRecordIDs.size > 0 || updatedOwners.length > 0 || this._invalidatedRecordIDs.size > 0 || invalidateStore === true || this._globalInvalidationEpoch === this._currentWriteEpoch)) {
+      this._currentWriteEpoch++;
+      if (invalidateStore === true) {
+        this._globalInvalidationEpoch = this._currentWriteEpoch;
       }
     }
+    if (!RelayFeatureFlags.OPTIMIZE_NOTIFY || this._invalidatedRecordIDs.size > 0 || invalidateStore === true) {
+      this._invalidationSubscriptions.forEach(function (subscription) {
+        _this3._updateInvalidationSubscription(subscription, invalidateStore === true);
+      });
+    }
+    if (sourceOperation != null) {
+      this._recordSourceOperation(sourceOperation);
+    }
     if (log != null) {
       log({
         name: 'store.notify.complete',
@@ -260,6 +336,23 @@ var RelayModernStore = /*#__PURE__*/function () {
     this._invalidatedRecordIDs.clear();
     return updatedOwners;
   };
+  _proto._recordSourceOperation = function _recordSourceOperation(sourceOperation) {
+    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) {
+      var temporaryRootEntry = {
+        operation: sourceOperation,
+        refCount: 0,
+        epoch: this._currentWriteEpoch,
+        fetchTime: Date.now()
+      };
+      this._releaseBuffer.push(id);
+      this._roots.set(id, temporaryRootEntry);
+    }
+  };
   _proto.publish = function publish(source, idsMarkedForInvalidation) {
     var target = this._getMutableRecordSource();
     updateTargetFromSource(target, source, this._currentWriteEpoch + 1, idsMarkedForInvalidation, this._updatedRecordIDs, this._invalidatedRecordIDs);
@@ -325,19 +418,19 @@ var RelayModernStore = /*#__PURE__*/function () {
     if (currentInvalidations.get('global') !== prevInvalidations.get('global')) {
       return true;
     }
-    var _iterator = (0, _createForOfIteratorHelper2["default"])(prevInvalidationState.dataIDs),
-      _step;
+    var _iterator2 = (0, _createForOfIteratorHelper2["default"])(prevInvalidationState.dataIDs),
+      _step2;
     try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var dataID = _step.value;
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var dataID = _step2.value;
         if (currentInvalidations.get(dataID) !== prevInvalidations.get(dataID)) {
           return true;
         }
       }
     } catch (err) {
-      _iterator.e(err);
+      _iterator2.e(err);
     } finally {
-      _iterator.f();
+      _iterator2.f();
     }
     return false;
   };
@@ -432,17 +525,17 @@ var RelayModernStore = /*#__PURE__*/function () {
       }
       var startEpoch = this._currentWriteEpoch;
       var references = new Set();
-      var _iterator2 = (0, _createForOfIteratorHelper2["default"])(this._roots.entries()),
-        _step2;
+      var _iterator3 = (0, _createForOfIteratorHelper2["default"])(this._roots.entries()),
+        _step3;
       try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
           var _ref2, _operation$request$no3, _operation$request$no4;
-          var _step2$value = _step2.value,
-            _dataID = _step2$value[0],
-            _step2$value$ = _step2$value[1],
-            operation = _step2$value$.operation,
-            refCount = _step2$value$.refCount,
-            fetchTime = _step2$value$.fetchTime;
+          var _step3$value = _step3.value,
+            _dataID = _step3$value[0],
+            _step3$value$ = _step3$value[1],
+            operation = _step3$value$.operation,
+            refCount = _step3$value$.refCount,
+            fetchTime = _step3$value$.fetchTime;
           if (this._shouldRetainWithinTTL_EXPERIMENTAL) {
             var _queryCacheExpirationTime = this._queryCacheExpirationTime;
             !(_queryCacheExpirationTime != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Query cache expiration time should be non-null if executing GC') : invariant(false) : void 0;
@@ -466,9 +559,9 @@ var RelayModernStore = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator2.e(err);
+        _iterator3.e(err);
       } finally {
-        _iterator2.f();
+        _iterator3.f();
       }
       var storeIDs = this._recordSource.getRecordIDs();
       for (var ii = 0; ii < storeIDs.length; ii++) {
@@ -502,6 +595,7 @@ var RelayModernStore = /*#__PURE__*/function () {
       getDataID: this._getDataID,
       log: this.__log,
       treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
+      deferDeduplicatedFields: this._deferDeduplicatedFields,
       shouldProcessClientComponents: this._shouldProcessClientComponents,
       actorIdentifier: this._actorIdentifier
     };
@@ -518,6 +612,9 @@ var RelayModernStore = /*#__PURE__*/function () {
 function initializeRecordSource(target) {
   if (!target.has(ROOT_ID)) {
     var rootRecord = RelayModernRecord.create(ROOT_ID, ROOT_TYPE);
+    if (RelayFeatureFlags.ENABLE_FIELD_GRANULAR_NOTIFICATIONS) {
+      RelayModernRecord.setValue(rootRecord, FIELD_GRANULAR_NOTIFICATIONS_KEY, true);
+    }
     target.set(ROOT_ID, rootRecord);
   }
 }
@@ -561,6 +658,18 @@ function updateTargetFromSource(target, source, currentWriteEpoch, idsMarkedForI
         }
         updatedRecordIDs.add(dataID);
         target.set(dataID, nextRecord);
+        if (RelayModernRecord.getValue(nextRecord, FIELD_GRANULAR_NOTIFICATIONS_KEY)) {
+          var fields = RelayModernRecord.getFields(nextRecord);
+          for (var jj = 0; jj < fields.length; jj++) {
+            var storageKey = fields[jj];
+            if (storageKey.startsWith('__')) {
+              continue;
+            }
+            if (RelayModernRecord.hasFieldChanged(targetRecord, nextRecord, storageKey)) {
+              updatedRecordIDs.add(getFieldNotificationKey(dataID, storageKey));
+            }
+          }
+        }
       }
     } else if (sourceRecord === null) {
       target["delete"](dataID);

package/lib/store/RelayPublishQueue.js

@@ -203,7 +203,7 @@ var RelayPublishQueue = /*#__PURE__*/function () {
   return RelayPublishQueue;
 }();
 function lookupSelector(source, selector) {
-  var selectorData = RelayReader.read(source, selector).data;
+  var selectorData = RelayReader.read(source, selector, null, undefined, undefined).data;
   if (process.env.NODE_ENV !== "production") {
     var deepFreeze = require('../util/deepFreeze');
     if (selectorData) {