relay-runtime 19.0.0 → 20.1.0

package/experimental.js

@@ -1,5 +1,5 @@
 /**
- * Relay v19.0.0
+ * Relay v20.1.0
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Relay v19.0.0
+ * Relay v20.1.0
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/lib/store/DataChecker.js

@@ -23,7 +23,7 @@ var invariant = require('invariant');
 var getModuleOperationKey = RelayStoreUtils.getModuleOperationKey,
   getStorageKey = RelayStoreUtils.getStorageKey,
   getArgumentValues = RelayStoreUtils.getArgumentValues;
-function check(getSourceForActor, getTargetForActor, defaultActorIdentifier, selector, handlers, operationLoader, getDataID, shouldProcessClientComponents, log) {
+function check(getSourceForActor, getTargetForActor, defaultActorIdentifier, selector, handlers, operationLoader, getDataID, shouldProcessClientComponents, log, useExecTimeResolvers) {
   if (log != null) {
     log({
       name: 'store.datachecker.start',
@@ -33,7 +33,7 @@ function check(getSourceForActor, getTargetForActor, defaultActorIdentifier, sel
   var dataID = selector.dataID,
     node = selector.node,
     variables = selector.variables;
-  var checker = new DataChecker(getSourceForActor, getTargetForActor, defaultActorIdentifier, variables, handlers, operationLoader, getDataID, shouldProcessClientComponents, log);
+  var checker = new DataChecker(getSourceForActor, getTargetForActor, defaultActorIdentifier, variables, handlers, operationLoader, getDataID, shouldProcessClientComponents, log, useExecTimeResolvers);
   var result = checker.check(node, dataID);
   if (log != null) {
     log({
@@ -44,7 +44,7 @@ function check(getSourceForActor, getTargetForActor, defaultActorIdentifier, sel
   return result;
 }
 var DataChecker = /*#__PURE__*/function () {
-  function DataChecker(getSourceForActor, getTargetForActor, defaultActorIdentifier, variables, handlers, operationLoader, getDataID, shouldProcessClientComponents, log) {
+  function DataChecker(getSourceForActor, getTargetForActor, defaultActorIdentifier, variables, handlers, operationLoader, getDataID, shouldProcessClientComponents, log, useExecTimeResolvers) {
     this._getSourceForActor = getSourceForActor;
     this._getTargetForActor = getTargetForActor;
     this._getDataID = getDataID;
@@ -53,6 +53,7 @@ var DataChecker = /*#__PURE__*/function () {
     var _this$_getMutatorAndR = this._getMutatorAndRecordProxyForActor(defaultActorIdentifier),
       mutator = _this$_getMutatorAndR[0],
       recordSourceProxy = _this$_getMutatorAndR[1];
+    this._useExecTimeResolvers = useExecTimeResolvers !== null && useExecTimeResolvers !== void 0 ? useExecTimeResolvers : false;
     this._mostRecentlyInvalidatedAt = null;
     this._handlers = handlers;
     this._mutator = mutator;
@@ -277,10 +278,14 @@ var DataChecker = /*#__PURE__*/function () {
           break;
         case 'RelayResolver':
         case 'RelayLiveResolver':
-          _this2._checkResolver(selection, dataID);
+          if (!_this2._useExecTimeResolvers) {
+            _this2._checkResolver(selection, dataID);
+          }
           break;
         case 'ClientEdgeToClientObject':
-          _this2._checkResolver(selection.backingField, dataID);
+          if (!_this2._useExecTimeResolvers) {
+            _this2._checkResolver(selection.backingField, dataID);
+          }
           break;
         default:
           selection;

package/lib/store/OperationExecutor.js

@@ -31,26 +31,27 @@ function execute(config) {
   return new Executor(config);
 }
 var Executor = /*#__PURE__*/function () {
-  function Executor(_ref2) {
+  function Executor(_ref3) {
     var _this = this;
-    var actorIdentifier = _ref2.actorIdentifier,
-      getDataID = _ref2.getDataID,
-      getPublishQueue = _ref2.getPublishQueue,
-      getStore = _ref2.getStore,
-      isClientPayload = _ref2.isClientPayload,
-      operation = _ref2.operation,
-      operationExecutions = _ref2.operationExecutions,
-      operationLoader = _ref2.operationLoader,
-      operationTracker = _ref2.operationTracker,
-      optimisticConfig = _ref2.optimisticConfig,
-      scheduler = _ref2.scheduler,
-      shouldProcessClientComponents = _ref2.shouldProcessClientComponents,
-      sink = _ref2.sink,
-      source = _ref2.source,
-      treatMissingFieldsAsNull = _ref2.treatMissingFieldsAsNull,
-      updater = _ref2.updater,
-      log = _ref2.log,
-      normalizeResponse = _ref2.normalizeResponse;
+    var _ref, _this$_operation$requ, _this$_operation$requ2;
+    var actorIdentifier = _ref3.actorIdentifier,
+      getDataID = _ref3.getDataID,
+      getPublishQueue = _ref3.getPublishQueue,
+      getStore = _ref3.getStore,
+      isClientPayload = _ref3.isClientPayload,
+      operation = _ref3.operation,
+      operationExecutions = _ref3.operationExecutions,
+      operationLoader = _ref3.operationLoader,
+      operationTracker = _ref3.operationTracker,
+      optimisticConfig = _ref3.optimisticConfig,
+      scheduler = _ref3.scheduler,
+      shouldProcessClientComponents = _ref3.shouldProcessClientComponents,
+      sink = _ref3.sink,
+      source = _ref3.source,
+      treatMissingFieldsAsNull = _ref3.treatMissingFieldsAsNull,
+      updater = _ref3.updater,
+      log = _ref3.log,
+      normalizeResponse = _ref3.normalizeResponse;
     this._actorIdentifier = actorIdentifier;
     this._getDataID = getDataID;
     this._treatMissingFieldsAsNull = treatMissingFieldsAsNull;
@@ -65,6 +66,8 @@ var Executor = /*#__PURE__*/function () {
     this._operationTracker = operationTracker;
     this._operationUpdateEpochs = new Map();
     this._optimisticUpdates = null;
+    this._useExecTimeResolvers = (_ref = (_this$_operation$requ = this._operation.request.node.operation.use_exec_time_resolvers) !== null && _this$_operation$requ !== void 0 ? _this$_operation$requ : ((_this$_operation$requ2 = this._operation.request.node.operation.exec_time_resolvers_enabled_provider) === null || _this$_operation$requ2 === void 0 ? void 0 : _this$_operation$requ2.get()) === true) !== null && _ref !== void 0 ? _ref : false;
+    this._execTimeResolverResponseComplete = false;
     this._pendingModulePayloadsCount = 0;
     this._getPublishQueue = getPublishQueue;
     this._scheduler = scheduler;
@@ -102,14 +105,14 @@ var Executor = /*#__PURE__*/function () {
         }
       },
       start: function start(subscription) {
-        var _this$_operation$requ;
+        var _this$_operation$requ3;
         _this._start(id, subscription);
         _this._log({
           name: 'execute.start',
           executeId: _this._executeId,
           params: _this._operation.request.node.params,
           variables: _this._operation.request.variables,
-          cacheConfig: (_this$_operation$requ = _this._operation.request.cacheConfig) !== null && _this$_operation$requ !== void 0 ? _this$_operation$requ : {}
+          cacheConfig: (_this$_operation$requ3 = _this._operation.request.cacheConfig) !== null && _this$_operation$requ3 !== void 0 ? _this$_operation$requ3 : {}
         });
       },
       unsubscribe: function unsubscribe() {
@@ -176,7 +179,7 @@ var Executor = /*#__PURE__*/function () {
         }
       case 'loading_final':
         {
-          activeState = this._pendingModulePayloadsCount > 0 ? 'active' : 'inactive';
+          activeState = this._pendingModulePayloadsCount > 0 || this._useExecTimeResolvers && !this._execTimeResolverResponseComplete ? 'active' : 'inactive';
           break;
         }
       default:
@@ -269,8 +272,8 @@ var Executor = /*#__PURE__*/function () {
         return;
       } else if (response.data == null) {
         var errors = response.hasOwnProperty('errors') && response.errors != null ? response.errors : null;
-        var messages = errors ? errors.map(function (_ref3) {
-          var message = _ref3.message;
+        var messages = errors ? errors.map(function (_ref4) {
+          var message = _ref4.message;
           return message;
         }).join('\n') : '(No errors)';
         var error = RelayError.create('RelayNetwork', 'No data returned for operation `' + _this5._operation.request.node.params.name + '`, got error(s):\n' + messages + '\n\nSee the error `source` property for more information.');
@@ -337,8 +340,10 @@ var Executor = /*#__PURE__*/function () {
     }
     var _partitionGraphQLResp = partitionGraphQLResponses(responsesWithData),
       nonIncrementalResponses = _partitionGraphQLResp[0],
-      incrementalResponses = _partitionGraphQLResp[1];
+      incrementalResponses = _partitionGraphQLResp[1],
+      normalizedResponses = _partitionGraphQLResp[2];
     var hasNonIncrementalResponses = nonIncrementalResponses.length > 0;
+    var hasNormalizedResponses = normalizedResponses.length > 0;
     if (hasNonIncrementalResponses) {
       if (this._isSubscriptionOperation) {
         var nextID = generateUniqueClientID();
@@ -351,9 +356,32 @@ var Executor = /*#__PURE__*/function () {
       var payloadFollowups = this._processResponses(nonIncrementalResponses);
       this._processPayloadFollowups(payloadFollowups);
     }
+    if (hasNormalizedResponses) {
+      var _payloadFollowups = [];
+      for (var i = 0; i < normalizedResponses.length; i++) {
+        var _response$extensions2;
+        var _response = normalizedResponses[i];
+        var source = new RelayRecordSource(_response.data);
+        var isFinal = ((_response$extensions2 = _response.extensions) === null || _response$extensions2 === void 0 ? void 0 : _response$extensions2.is_final) === true;
+        var payload = {
+          errors: [],
+          fieldPayloads: [],
+          followupPayloads: [],
+          incrementalPlaceholders: [],
+          isFinal: isFinal,
+          source: source
+        };
+        this._getPublishQueueAndSaveActor().commitPayload(this._operation, payload, this._updater);
+        _payloadFollowups.push(payload);
+        this._execTimeResolverResponseComplete = isFinal;
+        if (isFinal) {
+          this._updateActiveState();
+        }
+      }
+    }
     if (incrementalResponses.length > 0) {
-      var _payloadFollowups = this._processIncrementalResponses(incrementalResponses);
-      this._processPayloadFollowups(_payloadFollowups);
+      var _payloadFollowups2 = this._processIncrementalResponses(incrementalResponses);
+      this._processPayloadFollowups(_payloadFollowups2);
     }
     if (this._isSubscriptionOperation) {
       if (responsesWithData[0].extensions == null) {
@@ -364,7 +392,7 @@ var Executor = /*#__PURE__*/function () {
         responsesWithData[0].extensions.__relay_subscription_root_id = this._operation.fragment.dataID;
       }
     }
-    var updatedOwners = this._runPublishQueue(hasNonIncrementalResponses ? this._operation : undefined);
+    var updatedOwners = this._runPublishQueue(hasNonIncrementalResponses || hasNormalizedResponses ? this._operation : undefined);
     if (hasNonIncrementalResponses) {
       if (this._incrementalPayloadsPending) {
         this._retainData();
@@ -388,7 +416,7 @@ var Executor = /*#__PURE__*/function () {
         path: [],
         shouldProcessClientComponents: this._shouldProcessClientComponents,
         treatMissingFieldsAsNull: treatMissingFieldsAsNull
-      });
+      }, this._useExecTimeResolvers);
       validateOptimisticResponsePayload(payload);
       optimisticUpdates.push({
         operation: this._operation,
@@ -461,16 +489,20 @@ var Executor = /*#__PURE__*/function () {
       variables = followupPayload.variables;
     }
     var selector = createNormalizationSelector(normalizationNode, followupPayload.dataID, variables);
-    return this._normalizeResponse({
-      data: followupPayload.data
-    }, selector, followupPayload.typeName, {
+    var nextResponse = {
+      data: followupPayload.data,
+      extensions: this._state === 'loading_final' ? {
+        is_final: true
+      } : undefined
+    };
+    return this._normalizeResponse(nextResponse, selector, followupPayload.typeName, {
       actorIdentifier: this._actorIdentifier,
       getDataID: this._getDataID,
       log: this._log,
       path: followupPayload.path,
       treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       shouldProcessClientComponents: this._shouldProcessClientComponents
-    });
+    }, this._useExecTimeResolvers);
   };
   _proto._processOptimisticModuleImport = function _processOptimisticModuleImport(normalizationRootNode, moduleImportPayload) {
     var operation = getOperation(normalizationRootNode);
@@ -527,7 +559,7 @@ var Executor = /*#__PURE__*/function () {
         path: [],
         treatMissingFieldsAsNull: _this8._treatMissingFieldsAsNull,
         shouldProcessClientComponents: _this8._shouldProcessClientComponents
-      });
+      }, _this8._useExecTimeResolvers);
       _this8._getPublishQueueAndSaveActor().commitPayload(_this8._operation, relayPayload, _this8._updater);
       _this8._log({
         name: 'execute.normalize.end',
@@ -574,7 +606,10 @@ var Executor = /*#__PURE__*/function () {
           incrementalPlaceholders.forEach(function (placeholder) {
             if (placeholder.kind === 'defer') {
               relayPayloads.push(_this9._processDeferResponse(placeholder.label, placeholder.path, placeholder, {
-                data: placeholder.data
+                data: placeholder.data,
+                extensions: {
+                  is_final: true
+                }
               }));
             }
           });
@@ -586,7 +621,7 @@ var Executor = /*#__PURE__*/function () {
     });
   };
   _proto._maybeCompleteSubscriptionOperationTracking = function _maybeCompleteSubscriptionOperationTracking() {
-    if (!this._isSubscriptionOperation) {
+    if (!this._isSubscriptionOperation && !(this._useExecTimeResolvers && this._execTimeResolverResponseComplete && this._state === 'loading_final')) {
       return;
     }
     if (this._pendingModulePayloadsCount === 0 && this._incrementalPayloadsPending === false) {
@@ -814,20 +849,20 @@ var Executor = /*#__PURE__*/function () {
       path: placeholder.path,
       treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       shouldProcessClientComponents: this._shouldProcessClientComponents
-    });
+    }, this._useExecTimeResolvers);
     this._getPublishQueueAndSaveActor().commitPayload(this._operation, relayPayload);
     var parentEntry = this._source.get(parentID);
     !(parentEntry != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected the parent record `%s` for @defer ' + 'data to exist.', parentID) : invariant(false) : void 0;
     var fieldPayloads = parentEntry.fieldPayloads;
     if (fieldPayloads.length !== 0) {
-      var _response$extensions2;
+      var _response$extensions3;
       var handleFieldsRelayPayload = {
         errors: null,
         fieldPayloads: fieldPayloads,
         incrementalPlaceholders: null,
         followupPayloads: null,
         source: RelayRecordSource.create(),
-        isFinal: ((_response$extensions2 = response.extensions) === null || _response$extensions2 === void 0 ? void 0 : _response$extensions2.is_final) === true
+        isFinal: ((_response$extensions3 = response.extensions) === null || _response$extensions3 === void 0 ? void 0 : _response$extensions3.is_final) === true
       };
       this._getPublishQueueAndSaveActor().commitPayload(this._operation, handleFieldsRelayPayload);
     }
@@ -883,7 +918,7 @@ var Executor = /*#__PURE__*/function () {
     return relayPayload;
   };
   _proto._normalizeStreamItem = function _normalizeStreamItem(response, parentID, field, variables, path, normalizationPath) {
-    var _field$alias, _field$concreteType, _ref, _this$_getDataID;
+    var _field$alias, _field$concreteType, _ref2, _this$_getDataID;
     var data = response.data;
     !(typeof data === 'object') ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected the GraphQL @stream payload `data` ' + 'value to be an object.') : invariant(false) : void 0;
     var responseKey = (_field$alias = field.alias) !== null && _field$alias !== void 0 ? _field$alias : field.name;
@@ -899,7 +934,7 @@ var Executor = /*#__PURE__*/function () {
     !(itemIndex === finalPathEntry && itemIndex >= 0) ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected path for @stream to end in a ' + 'positive integer index, got `%s`', finalPathEntry) : invariant(false) : void 0;
     var typeName = (_field$concreteType = field.concreteType) !== null && _field$concreteType !== void 0 ? _field$concreteType : data[TYPENAME_KEY];
     !(typeof typeName === 'string') ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected @stream field `%s` to have a ' + '__typename.', field.name) : invariant(false) : void 0;
-    var itemID = (_ref = (_this$_getDataID = this._getDataID(data, typeName)) !== null && _this$_getDataID !== void 0 ? _this$_getDataID : prevIDs === null || prevIDs === void 0 ? void 0 : prevIDs[itemIndex]) !== null && _ref !== void 0 ? _ref : generateClientID(parentID, storageKey, itemIndex);
+    var itemID = (_ref2 = (_this$_getDataID = this._getDataID(data, typeName)) !== null && _this$_getDataID !== void 0 ? _this$_getDataID : prevIDs === null || prevIDs === void 0 ? void 0 : prevIDs[itemIndex]) !== null && _ref2 !== void 0 ? _ref2 : generateClientID(parentID, storageKey, itemIndex);
     !(typeof itemID === 'string') ? process.env.NODE_ENV !== "production" ? invariant(false, 'OperationExecutor: Expected id of elements of field `%s` to ' + 'be strings.', storageKey) : invariant(false) : void 0;
     var selector = createNormalizationSelector(field, itemID, variables);
     var nextParentRecord = RelayModernRecord.clone(parentRecord);
@@ -917,7 +952,7 @@ var Executor = /*#__PURE__*/function () {
       path: [].concat((0, _toConsumableArray2["default"])(normalizationPath), [responseKey, String(itemIndex)]),
       treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       shouldProcessClientComponents: this._shouldProcessClientComponents
-    });
+    }, this._useExecTimeResolvers);
     return {
       fieldPayloads: fieldPayloads,
       itemID: itemID,
@@ -1031,7 +1066,9 @@ var Executor = /*#__PURE__*/function () {
 function partitionGraphQLResponses(responses) {
   var nonIncrementalResponses = [];
   var incrementalResponses = [];
+  var normalizedResponses = [];
   responses.forEach(function (response) {
+    var _response$extensions4;
     if (response.path != null || response.label != null) {
       var label = response.label,
         path = response.path;
@@ -1043,11 +1080,13 @@ function partitionGraphQLResponses(responses) {
         path: path,
         response: response
       });
+    } else if (((_response$extensions4 = response.extensions) === null || _response$extensions4 === void 0 ? void 0 : _response$extensions4.is_normalized) === true) {
+      normalizedResponses.push(response);
     } else {
       nonIncrementalResponses.push(response);
     }
   });
-  return [nonIncrementalResponses, incrementalResponses];
+  return [nonIncrementalResponses, incrementalResponses, normalizedResponses];
 }
 function stableStringify(value) {
   var _JSON$stringify;

package/lib/store/RelayModernStore.js

@@ -108,10 +108,11 @@ var RelayModernStore = /*#__PURE__*/function () {
     }
   };
   _proto.check = function check(operation, options) {
-    var _options$handlers, _options$getSourceFor, _options$getTargetFor, _options$defaultActor;
+    var _ref, _operation$request$no, _operation$request$no2, _options$handlers, _options$getSourceFor, _options$getTargetFor, _options$defaultActor;
     var selector = operation.root;
     var source = this._getMutableRecordSource();
     var globalInvalidationEpoch = this._globalInvalidationEpoch;
+    var useExecTimeResolvers = (_ref = (_operation$request$no = operation.request.node.operation.use_exec_time_resolvers) !== null && _operation$request$no !== void 0 ? _operation$request$no : ((_operation$request$no2 = operation.request.node.operation.exec_time_resolvers_enabled_provider) === null || _operation$request$no2 === void 0 ? void 0 : _operation$request$no2.get()) === true) !== null && _ref !== void 0 ? _ref : false;
     var rootEntry = this._roots.get(operation.request.identifier);
     var operationLastWrittenAt = rootEntry != null ? rootEntry.epoch : null;
     if (globalInvalidationEpoch != null) {
@@ -130,7 +131,7 @@ var RelayModernStore = /*#__PURE__*/function () {
       assertInternalActorIdentifier(actorIdentifier);
       return source;
     };
-    var operationAvailability = DataChecker.check(getSourceForActor, getTargetForActor, (_options$defaultActor = options === null || options === void 0 ? void 0 : options.defaultActorIdentifier) !== null && _options$defaultActor !== void 0 ? _options$defaultActor : INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE, selector, handlers, this._operationLoader, this._getDataID, this._shouldProcessClientComponents, this.__log);
+    var operationAvailability = DataChecker.check(getSourceForActor, getTargetForActor, (_options$defaultActor = options === null || options === void 0 ? void 0 : options.defaultActorIdentifier) !== null && _options$defaultActor !== void 0 ? _options$defaultActor : INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE, selector, handlers, this._operationLoader, this._getDataID, this._shouldProcessClientComponents, this.__log, useExecTimeResolvers);
     return getAvailabilityStatus(operationAvailability, operationLastWrittenAt, rootEntry === null || rootEntry === void 0 ? void 0 : rootEntry.fetchTime, this._queryCacheExpirationTime);
   };
   _proto.retain = function retain(operation) {
@@ -435,6 +436,7 @@ var RelayModernStore = /*#__PURE__*/function () {
         _step2;
       try {
         for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _ref2, _operation$request$no3, _operation$request$no4;
           var _step2$value = _step2.value,
             _dataID = _step2$value[0],
             _step2$value$ = _step2$value[1],
@@ -451,7 +453,8 @@ var RelayModernStore = /*#__PURE__*/function () {
             }
           }
           var selector = operation.root;
-          RelayReferenceMarker.mark(this._recordSource, selector, references, this._operationLoader, this._shouldProcessClientComponents);
+          var useExecTimeResolvers = (_ref2 = (_operation$request$no3 = operation.request.node.operation.use_exec_time_resolvers) !== null && _operation$request$no3 !== void 0 ? _operation$request$no3 : ((_operation$request$no4 = operation.request.node.operation.exec_time_resolvers_enabled_provider) === null || _operation$request$no4 === void 0 ? void 0 : _operation$request$no4.get()) === true) !== null && _ref2 !== void 0 ? _ref2 : false;
+          RelayReferenceMarker.mark(this._recordSource, selector, references, this._operationLoader, this._shouldProcessClientComponents, useExecTimeResolvers);
           yield;
           if (startEpoch !== this._currentWriteEpoch) {
             if (log != null) {

package/lib/store/RelayReader.js

@@ -470,6 +470,9 @@ var RelayReader = /*#__PURE__*/function () {
           __fragmentOwner: _this._owner,
           __fragments: (0, _defineProperty2["default"])({}, fragment.name, fragment.args ? getArgumentValues(fragment.args, _this._variables) : {})
         };
+        if (_this._clientEdgeTraversalPath.length > 0 && _this._clientEdgeTraversalPath[_this._clientEdgeTraversalPath.length - 1] !== null) {
+          key[CLIENT_EDGE_TRAVERSAL_PATH] = (0, _toConsumableArray2["default"])(_this._clientEdgeTraversalPath);
+        }
         var resolverContext = {
           getDataForResolverFragment: getDataForResolverFragment
         };

package/lib/store/RelayReferenceMarker.js

@@ -15,17 +15,18 @@ var invariant = require('invariant');
 var getReadTimeResolverStorageKey = RelayStoreUtils.getReadTimeResolverStorageKey,
   getStorageKey = RelayStoreUtils.getStorageKey,
   getModuleOperationKey = RelayStoreUtils.getModuleOperationKey;
-function mark(recordSource, selector, references, operationLoader, shouldProcessClientComponents) {
+function mark(recordSource, selector, references, operationLoader, shouldProcessClientComponents, useExecTimeResolvers) {
   var dataID = selector.dataID,
     node = selector.node,
     variables = selector.variables;
-  var marker = new RelayReferenceMarker(recordSource, variables, references, operationLoader, shouldProcessClientComponents);
+  var marker = new RelayReferenceMarker(recordSource, variables, references, operationLoader, shouldProcessClientComponents, useExecTimeResolvers);
   marker.mark(node, dataID);
 }
 var RelayReferenceMarker = /*#__PURE__*/function () {
-  function RelayReferenceMarker(recordSource, variables, references, operationLoader, shouldProcessClientComponents) {
+  function RelayReferenceMarker(recordSource, variables, references, operationLoader, shouldProcessClientComponents, useExecTimeResolvers) {
     this._operationLoader = operationLoader !== null && operationLoader !== void 0 ? operationLoader : null;
     this._operationName = null;
+    this._useExecTimeResolvers = useExecTimeResolvers !== null && useExecTimeResolvers !== void 0 ? useExecTimeResolvers : false;
     this._recordSource = recordSource;
     this._references = references;
     this._variables = variables;
@@ -137,6 +138,10 @@ var RelayReferenceMarker = /*#__PURE__*/function () {
     });
   };
   _proto._traverseClientEdgeToClientObject = function _traverseClientEdgeToClientObject(field, record) {
+    if (this._useExecTimeResolvers) {
+      this._traverseLink(field.linkedField, record);
+      return;
+    }
     var dataID = this._traverseResolverField(field.backingField, record);
     if (dataID == null) {
       return;
@@ -194,6 +199,9 @@ var RelayReferenceMarker = /*#__PURE__*/function () {
     }
   };
   _proto._traverseResolverField = function _traverseResolverField(field, record) {
+    if (this._useExecTimeResolvers) {
+      return;
+    }
     var storageKey = getReadTimeResolverStorageKey(field, this._variables);
     var dataID = RelayModernRecord.getLinkedRecordID(record, storageKey);
     if (dataID != null) {

package/lib/store/RelayResponseNormalizer.js

@@ -33,15 +33,15 @@ var _require7 = require('./TypeID'),
 var areEqual = require("fbjs/lib/areEqual");
 var invariant = require('invariant');
 var warning = require("fbjs/lib/warning");
-function normalize(recordSource, selector, response, options, errors) {
+function normalize(recordSource, selector, response, options, errors, useExecTimeResolvers) {
   var dataID = selector.dataID,
     node = selector.node,
     variables = selector.variables;
-  var normalizer = new RelayResponseNormalizer(recordSource, variables, options);
+  var normalizer = new RelayResponseNormalizer(recordSource, variables, options, useExecTimeResolvers !== null && useExecTimeResolvers !== void 0 ? useExecTimeResolvers : false);
   return normalizer.normalizeResponse(node, dataID, response, errors);
 }
 var RelayResponseNormalizer = /*#__PURE__*/function () {
-  function RelayResponseNormalizer(recordSource, variables, options) {
+  function RelayResponseNormalizer(recordSource, variables, options, useExecTimeResolvers) {
     this._actorIdentifier = options.actorIdentifier;
     this._getDataId = options.getDataID;
     this._handleFieldPayloads = [];
@@ -49,6 +49,7 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
     this._incrementalPlaceholders = [];
     this._isClientExtension = false;
     this._isUnmatchedAbstractType = false;
+    this._useExecTimeResolvers = useExecTimeResolvers;
     this._followupPayloads = [];
     this._path = options.path ? (0, _toConsumableArray2["default"])(options.path) : [];
     this._recordSource = recordSource;
@@ -207,10 +208,14 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
           break;
         case 'RelayResolver':
         case 'RelayLiveResolver':
-          this._normalizeResolver(selection, record, data);
+          if (!this._useExecTimeResolvers) {
+            this._normalizeResolver(selection, record, data);
+          }
           break;
         case 'ClientEdgeToClientObject':
-          this._normalizeResolver(selection.backingField, record, data);
+          if (!this._useExecTimeResolvers) {
+            this._normalizeResolver(selection.backingField, record, data);
+          }
           break;
         default:
           selection;

package/lib/store/live-resolvers/LiveResolverCache.js

@@ -368,8 +368,9 @@ var LiveResolverCache = /*#__PURE__*/function () {
           var record = RelayModernRecord.create(outputTypeDataID, typename);
           source.set(outputTypeDataID, record);
           var selector = createNormalizationSelector(normalizationInfo.normalizationNode, outputTypeDataID, variables);
+          var useExecTimeResolvers = false;
           var normalizationOptions = this._store.__getNormalizationOptions(fieldPath);
-          return normalize(source, selector, value, normalizationOptions).source;
+          return normalize(source, selector, value, normalizationOptions, undefined, useExecTimeResolvers).source;
         }
       case 'WeakModel':
         {

package/lib/store/normalizeResponse.js

@@ -5,14 +5,14 @@ var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/obje
 var _RelayModernRecord = _interopRequireDefault(require("./RelayModernRecord"));
 var _RelayRecordSource = _interopRequireDefault(require("./RelayRecordSource"));
 var _RelayResponseNormalizer = _interopRequireDefault(require("./RelayResponseNormalizer"));
-function normalizeResponse(response, selector, typeName, options) {
+function normalizeResponse(response, selector, typeName, options, useExecTimeResolvers) {
   var _response$extensions;
   var data = response.data,
     errors = response.errors;
   var source = _RelayRecordSource["default"].create();
   var record = _RelayModernRecord["default"].create(selector.dataID, typeName);
   source.set(selector.dataID, record);
-  var relayPayload = _RelayResponseNormalizer["default"].normalize(source, selector, data, options, errors);
+  var relayPayload = _RelayResponseNormalizer["default"].normalize(source, selector, data, options, errors, useExecTimeResolvers);
   return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, relayPayload), {}, {
     isFinal: ((_response$extensions = response.extensions) === null || _response$extensions === void 0 ? void 0 : _response$extensions.is_final) === true
   });

package/lib/util/RelayFeatureFlags.js

@@ -25,6 +25,7 @@ var RelayFeatureFlags = {
   ENABLE_USE_PAGINATION_IS_LOADING_FIX: false,
   DISALLOW_NESTED_UPDATES: false,
   ENABLE_TYPENAME_PREFIXED_DATA_ID: false,
-  ENABLE_UI_CONTEXT_ON_RELAY_LOGGER: false
+  ENABLE_UI_CONTEXT_ON_RELAY_LOGGER: false,
+  CHECK_ALL_FRAGMENTS_FOR_MISSING_CLIENT_EDGES: false
 };
 module.exports = RelayFeatureFlags;

package/mutations/commitMutation.js.flow

@@ -37,7 +37,7 @@ const validateMutation = require('./validateMutation');
 const invariant = require('invariant');
 const warning = require('warning');
 
-export type MutationConfig<TMutation: MutationParameters> = {
+export type MutationConfig<TMutation: MutationParameters> = $ReadOnly<{
   cacheConfig?: CacheConfig,
   configs?: Array<DeclarativeMutationConfig>,
   mutation: GraphQLTaggedNode,
@@ -57,9 +57,9 @@ export type MutationConfig<TMutation: MutationParameters> = {
   updater?: ?SelectorStoreUpdater<TMutation['response']>,
   uploadables?: UploadableMap,
   variables: TMutation['variables'],
-};
+}>;
 
-export type CommitMutationConfig<TVariables, TData, TRawResponse> = {
+export type CommitMutationConfig<TVariables, TData, TRawResponse> = $ReadOnly<{
   cacheConfig?: CacheConfig,
   configs?: Array<DeclarativeMutationConfig>,
   mutation: Mutation<TVariables, TData, TRawResponse>,
@@ -71,8 +71,8 @@ export type CommitMutationConfig<TVariables, TData, TRawResponse> = {
   optimisticUpdater?: ?SelectorStoreUpdater<TData>,
   updater?: ?SelectorStoreUpdater<TData>,
   uploadables?: UploadableMap,
-  variables: TVariables,
-};
+  variables: NoInfer<TVariables>,
+}>;
 
 /**
  * Higher-level helper function to execute a mutation against a specific

package/network/RelayNetworkTypes.js.flow

@@ -26,7 +26,7 @@ export interface INetwork {
 
 export type LogRequestInfoFunction = mixed => void;
 
-export type PayloadData = {[key: string]: mixed};
+export type PayloadData = {+[key: string]: mixed};
 
 export type PayloadError = interface {
   message: string,
@@ -134,4 +134,4 @@ export type SubscribeFunction = (
 ) => RelayObservable<GraphQLResponse>;
 
 export type Uploadable = File | Blob;
-export type UploadableMap = {[key: string]: Uploadable};
+export type UploadableMap = {+[key: string]: Uploadable};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "relay-runtime",
   "description": "A core runtime for building GraphQL-driven applications.",
-  "version": "19.0.0",
+  "version": "20.1.0",
   "keywords": [
     "graphql",
     "relay"

package/query/fetchQuery.js.flow

@@ -115,7 +115,7 @@ const invariant = require('invariant');
 function fetchQuery<TVariables: Variables, TData, TRawResponse>(
   environment: IEnvironment,
   query: Query<TVariables, TData, TRawResponse>,
-  variables: TVariables,
+  variables: NoInfer<TVariables>,
   options?: $ReadOnly<{
     fetchPolicy?: FetchQueryFetchPolicy,
     networkCacheConfig?: CacheConfig,

package/store/DataChecker.js.flow

@@ -73,6 +73,7 @@ function check(
   getDataID: GetDataID,
   shouldProcessClientComponents: ?boolean,
   log: ?LogFunction,
+  useExecTimeResolvers: ?boolean,
 ): Availability {
   if (log != null) {
     log({
@@ -91,6 +92,7 @@ function check(
     getDataID,
     shouldProcessClientComponents,
     log,
+    useExecTimeResolvers,
   );
   const result = checker.check(node, dataID);
   if (log != null) {
@@ -113,6 +115,7 @@ class DataChecker {
   _recordSourceProxy: RelayRecordSourceProxy;
   _recordWasMissing: boolean;
   _source: RecordSource;
+  _useExecTimeResolvers: boolean;
   _variables: Variables;
   _shouldProcessClientComponents: ?boolean;
   +_getSourceForActor: (actorIdentifier: ActorIdentifier) => RecordSource;
@@ -138,6 +141,7 @@ class DataChecker {
     getDataID: GetDataID,
     shouldProcessClientComponents: ?boolean,
     log: ?LogFunction,
+    useExecTimeResolvers: ?boolean,
   ) {
     this._getSourceForActor = getSourceForActor;
     this._getTargetForActor = getTargetForActor;
@@ -147,6 +151,7 @@ class DataChecker {
     const [mutator, recordSourceProxy] = this._getMutatorAndRecordProxyForActor(
       defaultActorIdentifier,
     );
+    this._useExecTimeResolvers = useExecTimeResolvers ?? false;
     this._mostRecentlyInvalidatedAt = null;
     this._handlers = handlers;
     this._mutator = mutator;
@@ -455,10 +460,14 @@ class DataChecker {
           break;
         case 'RelayResolver':
         case 'RelayLiveResolver':
-          this._checkResolver(selection, dataID);
+          if (!this._useExecTimeResolvers) {
+            this._checkResolver(selection, dataID);
+          }
           break;
         case 'ClientEdgeToClientObject':
-          this._checkResolver(selection.backingField, dataID);
+          if (!this._useExecTimeResolvers) {
+            this._checkResolver(selection.backingField, dataID);
+          }
           break;
         default:
           (selection: empty);

package/store/OperationExecutor.js.flow

@@ -138,6 +138,7 @@ class Executor<TMutation: MutationParameters> {
   _operationTracker: OperationTracker;
   _operationUpdateEpochs: Map<string, number>;
   _optimisticUpdates: null | Array<OptimisticUpdate<TMutation>>;
+  _useExecTimeResolvers: boolean;
   _pendingModulePayloadsCount: number;
   +_getPublishQueue: (actorIdentifier: ActorIdentifier) => PublishQueue;
   _shouldProcessClientComponents: ?boolean;
@@ -158,6 +159,7 @@ class Executor<TMutation: MutationParameters> {
   +_isSubscriptionOperation: boolean;
   +_seenActors: Set<ActorIdentifier>;
   _normalizeResponse: NormalizeResponseFunction;
+  _execTimeResolverResponseComplete: boolean;
 
   constructor({
     actorIdentifier,
@@ -193,6 +195,12 @@ class Executor<TMutation: MutationParameters> {
     this._operationTracker = operationTracker;
     this._operationUpdateEpochs = new Map();
     this._optimisticUpdates = null;
+    this._useExecTimeResolvers =
+      this._operation.request.node.operation.use_exec_time_resolvers ??
+      this._operation.request.node.operation.exec_time_resolvers_enabled_provider?.get() ===
+        true ??
+      false;
+    this._execTimeResolverResponseComplete = false;
     this._pendingModulePayloadsCount = 0;
     this._getPublishQueue = getPublishQueue;
     this._scheduler = scheduler;
@@ -315,7 +323,11 @@ class Executor<TMutation: MutationParameters> {
       }
       case 'loading_final': {
         activeState =
-          this._pendingModulePayloadsCount > 0 ? 'active' : 'inactive';
+          this._pendingModulePayloadsCount > 0 ||
+          (this._useExecTimeResolvers &&
+            !this._execTimeResolverResponseComplete)
+            ? 'active'
+            : 'inactive';
         break;
       }
       default:
@@ -516,9 +528,10 @@ class Executor<TMutation: MutationParameters> {
       return;
     }
 
-    const [nonIncrementalResponses, incrementalResponses] =
+    const [nonIncrementalResponses, incrementalResponses, normalizedResponses] =
       partitionGraphQLResponses(responsesWithData);
     const hasNonIncrementalResponses = nonIncrementalResponses.length > 0;
+    const hasNormalizedResponses = normalizedResponses.length > 0;
 
     // In theory this doesn't preserve the ordering of the batch.
     // The idea is that a batch is always:
@@ -553,6 +566,37 @@ class Executor<TMutation: MutationParameters> {
       this._processPayloadFollowups(payloadFollowups);
     }
 
+    if (hasNormalizedResponses) {
+      const payloadFollowups = [];
+      for (let i = 0; i < normalizedResponses.length; i++) {
+        const response = normalizedResponses[i];
+        const source = new RelayRecordSource(
+          response.data as $FlowExpectedError,
+        );
+        const isFinal = response.extensions?.is_final === true;
+        const payload: RelayResponsePayload = {
+          errors: [],
+          fieldPayloads: [],
+          followupPayloads: [],
+          incrementalPlaceholders: [],
+          isFinal,
+          source,
+        };
+        this._getPublishQueueAndSaveActor().commitPayload(
+          this._operation,
+          payload,
+          this._updater,
+        );
+        payloadFollowups.push(payload);
+        this._execTimeResolverResponseComplete = isFinal;
+        if (isFinal) {
+          // Need to update the active state to mark the query as inactive,
+          // incase server payloads have completed
+          this._updateActiveState();
+        }
+      }
+    }
+
     if (incrementalResponses.length > 0) {
       const payloadFollowups =
         this._processIncrementalResponses(incrementalResponses);
@@ -578,7 +622,9 @@ class Executor<TMutation: MutationParameters> {
     // the publish queue here, which will later be passed to the store (via
     // notify) to indicate that this operation caused the store to update
     const updatedOwners = this._runPublishQueue(
-      hasNonIncrementalResponses ? this._operation : undefined,
+      hasNonIncrementalResponses || hasNormalizedResponses
+        ? this._operation
+        : undefined,
     );
 
     if (hasNonIncrementalResponses) {
@@ -617,6 +663,7 @@ class Executor<TMutation: MutationParameters> {
           shouldProcessClientComponents: this._shouldProcessClientComponents,
           treatMissingFieldsAsNull,
         },
+        this._useExecTimeResolvers,
       );
       validateOptimisticResponsePayload(payload);
       optimisticUpdates.push({
@@ -715,8 +762,15 @@ class Executor<TMutation: MutationParameters> {
       followupPayload.dataID,
       variables,
     );
+    const nextResponse: GraphQLResponseWithData = {
+      data: followupPayload.data,
+      // `is_final` flag needs to be set for processing nested defer and 3D
+      // when the server doesn't support streaming
+      extensions:
+        this._state === 'loading_final' ? {is_final: true} : undefined,
+    };
     return this._normalizeResponse(
-      {data: followupPayload.data},
+      nextResponse,
       selector,
       followupPayload.typeName,
       {
@@ -727,6 +781,7 @@ class Executor<TMutation: MutationParameters> {
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         shouldProcessClientComponents: this._shouldProcessClientComponents,
       },
+      this._useExecTimeResolvers,
     );
   }
 
@@ -810,6 +865,7 @@ class Executor<TMutation: MutationParameters> {
           treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
           shouldProcessClientComponents: this._shouldProcessClientComponents,
         },
+        this._useExecTimeResolvers,
       );
       this._getPublishQueueAndSaveActor().commitPayload(
         this._operation,
@@ -884,7 +940,8 @@ class Executor<TMutation: MutationParameters> {
                   placeholder.label,
                   placeholder.path,
                   placeholder,
-                  {data: placeholder.data},
+                  // `is_final` flag needs to be set for processing nested defer payloads
+                  {data: placeholder.data, extensions: {is_final: true}},
                 ),
               );
             }
@@ -898,7 +955,14 @@ class Executor<TMutation: MutationParameters> {
   }
 
   _maybeCompleteSubscriptionOperationTracking() {
-    if (!this._isSubscriptionOperation) {
+    if (
+      !this._isSubscriptionOperation &&
+      !(
+        this._useExecTimeResolvers &&
+        this._execTimeResolverResponseComplete &&
+        this._state === 'loading_final'
+      )
+    ) {
       return;
     }
     if (
@@ -1267,6 +1331,7 @@ class Executor<TMutation: MutationParameters> {
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         shouldProcessClientComponents: this._shouldProcessClientComponents,
       },
+      this._useExecTimeResolvers,
     );
     this._getPublishQueueAndSaveActor().commitPayload(
       this._operation,
@@ -1487,14 +1552,20 @@ class Executor<TMutation: MutationParameters> {
       record: nextParentRecord,
       fieldPayloads,
     });
-    const relayPayload = this._normalizeResponse(response, selector, typeName, {
-      actorIdentifier: this._actorIdentifier,
-      getDataID: this._getDataID,
-      log: this._log,
-      path: [...normalizationPath, responseKey, String(itemIndex)],
-      treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
-      shouldProcessClientComponents: this._shouldProcessClientComponents,
-    });
+    const relayPayload = this._normalizeResponse(
+      response,
+      selector,
+      typeName,
+      {
+        actorIdentifier: this._actorIdentifier,
+        getDataID: this._getDataID,
+        log: this._log,
+        path: [...normalizationPath, responseKey, String(itemIndex)],
+        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
+        shouldProcessClientComponents: this._shouldProcessClientComponents,
+      },
+      this._useExecTimeResolvers,
+    );
     return {
       fieldPayloads,
       itemID,
@@ -1597,9 +1668,11 @@ function partitionGraphQLResponses(
 ): [
   $ReadOnlyArray<GraphQLResponseWithData>,
   $ReadOnlyArray<IncrementalGraphQLResponse>,
+  $ReadOnlyArray<GraphQLResponseWithData>,
 ] {
   const nonIncrementalResponses: Array<GraphQLResponseWithData> = [];
   const incrementalResponses: Array<IncrementalGraphQLResponse> = [];
+  const normalizedResponses: Array<GraphQLResponseWithData> = [];
   responses.forEach(response => {
     if (response.path != null || response.label != null) {
       const {label, path} = response;
@@ -1617,11 +1690,13 @@ function partitionGraphQLResponses(
         path,
         response,
       });
+    } else if (response.extensions?.is_normalized === true) {
+      normalizedResponses.push(response);
     } else {
       nonIncrementalResponses.push(response);
     }
   });
-  return [nonIncrementalResponses, incrementalResponses];
+  return [nonIncrementalResponses, incrementalResponses, normalizedResponses];
 }
 
 function stableStringify(value: mixed): string {

package/store/RelayModernStore.js.flow

@@ -242,6 +242,11 @@ class RelayModernStore implements Store {
     const selector = operation.root;
     const source = this._getMutableRecordSource();
     const globalInvalidationEpoch = this._globalInvalidationEpoch;
+    const useExecTimeResolvers =
+      operation.request.node.operation.use_exec_time_resolvers ??
+      operation.request.node.operation.exec_time_resolvers_enabled_provider?.get() ===
+        true ??
+      false;
 
     const rootEntry = this._roots.get(operation.request.identifier);
     const operationLastWrittenAt = rootEntry != null ? rootEntry.epoch : null;
@@ -286,6 +291,7 @@ class RelayModernStore implements Store {
       this._getDataID,
       this._shouldProcessClientComponents,
       this.__log,
+      useExecTimeResolvers,
     );
 
     return getAvailabilityStatus(
@@ -464,6 +470,8 @@ class RelayModernStore implements Store {
           fetchTime: Date.now(),
         };
         this._releaseBuffer.push(id);
+        /* $FlowFixMe[incompatible-call] Natural Inference rollout. See
+         * https://fburl.com/gdoc/y8dn025u */
         this._roots.set(id, temporaryRootEntry);
       }
     }
@@ -743,12 +751,18 @@ class RelayModernStore implements Store {
 
         // Mark all records that are traversable from a root that is still valid
         const selector = operation.root;
+        const useExecTimeResolvers =
+          operation.request.node.operation.use_exec_time_resolvers ??
+          operation.request.node.operation.exec_time_resolvers_enabled_provider?.get() ===
+            true ??
+          false;
         RelayReferenceMarker.mark(
           this._recordSource,
           selector,
           references,
           this._operationLoader,
           this._shouldProcessClientComponents,
+          useExecTimeResolvers,
         );
         // Yield for other work after each operation
         yield;

package/store/RelayReader.js.flow

@@ -788,7 +788,7 @@ class RelayReader {
     //   `getResolverValue`) and converted into an error object.
     const evaluate = (): EvaluationResult<mixed> => {
       if (fragment != null) {
-        const key = {
+        const key: SelectorData = {
           __id: parentRecordID,
           __fragmentOwner: this._owner,
           __fragments: {
@@ -797,6 +797,14 @@ class RelayReader {
               : {},
           },
         };
+        if (
+          this._clientEdgeTraversalPath.length > 0 &&
+          this._clientEdgeTraversalPath[
+            this._clientEdgeTraversalPath.length - 1
+          ] !== null
+        ) {
+          key[CLIENT_EDGE_TRAVERSAL_PATH] = [...this._clientEdgeTraversalPath];
+        }
         const resolverContext = {getDataForResolverFragment};
         return withResolverContext(resolverContext, () => {
           const [resolverResult, resolverError] = getResolverValue(

package/store/RelayRecordSource.js.flow

@@ -86,7 +86,7 @@ class RelayRecordSource implements MutableRecordSource {
   }
 
   toJSON(): RecordSourceJSON {
-    const obj: RecordSourceJSON = {};
+    const obj: {...RecordSourceJSON} = {};
     for (const [key, record] of this._records) {
       obj[key] = RelayModernRecord.toJSON<null | void>(record);
     }

package/store/RelayReferenceMarker.js.flow

@@ -47,6 +47,7 @@ function mark(
   references: DataIDSet,
   operationLoader: ?OperationLoader,
   shouldProcessClientComponents: ?boolean,
+  useExecTimeResolvers: ?boolean,
 ): void {
   const {dataID, node, variables} = selector;
   const marker = new RelayReferenceMarker(
@@ -55,6 +56,7 @@ function mark(
     references,
     operationLoader,
     shouldProcessClientComponents,
+    useExecTimeResolvers,
   );
   marker.mark(node, dataID);
 }
@@ -68,6 +70,7 @@ class RelayReferenceMarker {
   _recordSource: RecordSource;
   _references: DataIDSet;
   _variables: Variables;
+  _useExecTimeResolvers: boolean;
   _shouldProcessClientComponents: ?boolean;
 
   constructor(
@@ -76,9 +79,11 @@ class RelayReferenceMarker {
     references: DataIDSet,
     operationLoader: ?OperationLoader,
     shouldProcessClientComponents: ?boolean,
+    useExecTimeResolvers: ?boolean,
   ) {
     this._operationLoader = operationLoader ?? null;
     this._operationName = null;
+    this._useExecTimeResolvers = useExecTimeResolvers ?? false;
     this._recordSource = recordSource;
     this._references = references;
     this._variables = variables;
@@ -238,6 +243,10 @@ class RelayReferenceMarker {
     field: NormalizationClientEdgeToClientObject,
     record: Record,
   ): void {
+    if (this._useExecTimeResolvers) {
+      this._traverseLink(field.linkedField, record);
+      return;
+    }
     const dataID = this._traverseResolverField(field.backingField, record);
     if (dataID == null) {
       return;
@@ -290,6 +299,9 @@ class RelayReferenceMarker {
     field: NormalizationResolverField | NormalizationLiveResolverField,
     record: Record,
   ): ?DataID {
+    if (this._useExecTimeResolvers) {
+      return;
+    }
     const storageKey = getReadTimeResolverStorageKey(field, this._variables);
     const dataID = RelayModernRecord.getLinkedRecordID(record, storageKey);
 
@@ -305,7 +317,6 @@ class RelayReferenceMarker {
       // Mark the contents of the resolver's data dependencies.
       this._traverseSelections([fragment], record);
     }
-
     return dataID;
   }
 

package/store/RelayResponseNormalizer.js.flow

@@ -67,7 +67,7 @@ const invariant = require('invariant');
 const warning = require('warning');
 
 export type GetDataID = (
-  fieldValue: {[string]: mixed},
+  fieldValue: {+[string]: mixed},
   typeName: string,
 ) => mixed;
 
@@ -90,12 +90,14 @@ function normalize(
   response: PayloadData,
   options: NormalizationOptions,
   errors?: Array<PayloadError>,
+  useExecTimeResolvers?: boolean,
 ): RelayResponsePayload {
   const {dataID, node, variables} = selector;
   const normalizer = new RelayResponseNormalizer(
     recordSource,
     variables,
     options,
+    useExecTimeResolvers ?? false,
   );
   return normalizer.normalizeResponse(node, dataID, response, errors);
 }
@@ -117,6 +119,7 @@ class RelayResponseNormalizer {
   _path: Array<string>;
   _recordSource: MutableRecordSource;
   _variables: Variables;
+  _useExecTimeResolvers: boolean;
   _shouldProcessClientComponents: ?boolean;
   _errorTrie: RelayErrorTrie | null;
   _log: ?LogFunction;
@@ -125,6 +128,7 @@ class RelayResponseNormalizer {
     recordSource: MutableRecordSource,
     variables: Variables,
     options: NormalizationOptions,
+    useExecTimeResolvers: boolean,
   ) {
     this._actorIdentifier = options.actorIdentifier;
     this._getDataId = options.getDataID;
@@ -133,6 +137,7 @@ class RelayResponseNormalizer {
     this._incrementalPlaceholders = [];
     this._isClientExtension = false;
     this._isUnmatchedAbstractType = false;
+    this._useExecTimeResolvers = useExecTimeResolvers;
     this._followupPayloads = [];
     this._path = options.path ? [...options.path] : [];
     this._recordSource = recordSource;
@@ -325,10 +330,14 @@ class RelayResponseNormalizer {
           break;
         case 'RelayResolver':
         case 'RelayLiveResolver':
-          this._normalizeResolver(selection, record, data);
+          if (!this._useExecTimeResolvers) {
+            this._normalizeResolver(selection, record, data);
+          }
           break;
         case 'ClientEdgeToClientObject':
-          this._normalizeResolver(selection.backingField, record, data);
+          if (!this._useExecTimeResolvers) {
+            this._normalizeResolver(selection.backingField, record, data);
+          }
           break;
         default:
           (selection: empty);

package/store/RelayStoreTypes.js.flow

@@ -245,7 +245,7 @@ export interface RecordSource {
 /**
  * A collection of records keyed by id.
  */
-export type RecordSourceJSON = {[DataID]: ?RecordJSON};
+export type RecordSourceJSON = {+[DataID]: ?RecordJSON};
 
 /**
  * A read/write interface for accessing and updating graph data.
@@ -258,10 +258,10 @@ export interface MutableRecordSource extends RecordSource {
 }
 
 export type CheckOptions = {
-  handlers: $ReadOnlyArray<MissingFieldHandler>,
-  defaultActorIdentifier: ActorIdentifier,
-  getTargetForActor: (actorIdentifier: ActorIdentifier) => MutableRecordSource,
-  getSourceForActor: (actorIdentifier: ActorIdentifier) => RecordSource,
+  +handlers: $ReadOnlyArray<MissingFieldHandler>,
+  +defaultActorIdentifier: ActorIdentifier,
+  +getTargetForActor: (actorIdentifier: ActorIdentifier) => MutableRecordSource,
+  +getSourceForActor: (actorIdentifier: ActorIdentifier) => RecordSource,
 };
 
 export type OperationAvailability =
@@ -1172,6 +1172,7 @@ export type NormalizeResponseFunction = (
   selector: NormalizationSelector,
   typeName: string,
   options: NormalizationOptions,
+  useExecTimeResolvers: boolean,
 ) => RelayResponsePayload;
 
 /**

package/store/ResolverCache.js.flow

@@ -32,11 +32,11 @@ export type EvaluationResult<T> = {
   error: ?Error,
 };
 
-export type ResolverFragmentResult = {
+export type ResolverFragmentResult = $ReadOnly<{
   data: mixed,
   isMissingData: boolean,
   fieldErrors: ?FieldErrors,
-};
+}>;
 
 export type GetDataForResolverFragmentFn =
   SingularReaderSelector => ResolverFragmentResult;

package/store/defaultGetDataID.js.flow

@@ -14,7 +14,7 @@
 const {VIEWER_ID, VIEWER_TYPE} = require('./ViewerPattern');
 
 function defaultGetDataID(
-  fieldValue: {[string]: mixed},
+  fieldValue: {+[string]: mixed},
   typeName: string,
 ): mixed {
   if (typeName === VIEWER_TYPE) {

package/store/live-resolvers/LiveResolverCache.js.flow

@@ -754,7 +754,8 @@ class LiveResolverCache implements ResolverCache {
           outputTypeDataID,
           variables,
         );
-
+        // LiveResolverCache is only used by read time resolvers, so this flag should be hardcoded as false.
+        const useExecTimeResolvers = false;
         const normalizationOptions =
           this._store.__getNormalizationOptions(fieldPath);
         // The resulted `source` is the normalized version of the
@@ -762,6 +763,7 @@ class LiveResolverCache implements ResolverCache {
         // All records in the `source` should have IDs that
         // is "prefix-ed" with the parent resolver record `ID`
         // and they don't expect to have a "strong" identifier.
+
         return normalize(
           source,
           selector,
@@ -771,6 +773,8 @@ class LiveResolverCache implements ResolverCache {
           // $FlowFixMe[incompatible-variance]
           value,
           normalizationOptions,
+          undefined,
+          useExecTimeResolvers,
         ).source;
       }
       // For weak models we have a simpler case. We simply need to update a

package/store/normalizeResponse.js.flow

@@ -27,6 +27,7 @@ function normalizeResponse(
   selector: NormalizationSelector,
   typeName: string,
   options: NormalizationOptions,
+  useExecTimeResolvers: boolean,
 ): RelayResponsePayload {
   const {data, errors} = response;
   const source = RelayRecordSource.create();
@@ -38,6 +39,7 @@ function normalizeResponse(
     data,
     options,
     errors,
+    useExecTimeResolvers,
   );
   return {
     ...relayPayload,

package/subscription/requestSubscription.js.flow

@@ -41,16 +41,17 @@ export type SubscriptionParameters = {
  * Updated Flow type that makes use of typed graphql tagged literals with
  * type information.
  */
-export type GraphQLSubscriptionConfig<TVariables, TData, TRawResponse> = {
-  configs?: Array<DeclarativeMutationConfig>,
-  cacheConfig?: CacheConfig,
-  subscription: GraphQLSubscription<TVariables, TData, TRawResponse>,
-  variables: TVariables,
-  onCompleted?: ?() => void,
-  onError?: ?(error: Error) => void,
-  onNext?: ?(response: ?TData) => void,
-  updater?: ?SelectorStoreUpdater<TData>,
-};
+export type GraphQLSubscriptionConfig<TVariables, TData, TRawResponse> =
+  $ReadOnly<{
+    configs?: Array<DeclarativeMutationConfig>,
+    cacheConfig?: CacheConfig,
+    subscription: GraphQLSubscription<TVariables, TData, TRawResponse>,
+    variables: TVariables,
+    onCompleted?: ?() => void,
+    onError?: ?(error: Error) => void,
+    onNext?: ?(response: ?TData) => void,
+    updater?: ?SelectorStoreUpdater<TData>,
+  }>;
 
 function requestSubscription<TVariables: Variables, TData, TRawResponse>(
   environment: IEnvironment,

package/util/RelayFeatureFlags.js.flow

@@ -71,6 +71,15 @@ export type FeatureFlags = {
 
   // Enable prefixing of DataID in the store with __typename
   ENABLE_TYPENAME_PREFIXED_DATA_ID: boolean,
+
+  // Relay previously had a bug where it would fail to check for missing client
+  // edge to server data in fragments nested within client edge Relay Resolver
+  // fields. This feature flag fixes the behavior but comes with a perf cost.
+  // This flag is here to allow us to gradually rollout the fix and track the perf
+  // impact.
+  //
+  // See https://github.com/facebook/relay/issues/4882
+  CHECK_ALL_FRAGMENTS_FOR_MISSING_CLIENT_EDGES: boolean,
 };
 
 const RelayFeatureFlags: FeatureFlags = {
@@ -99,6 +108,7 @@ const RelayFeatureFlags: FeatureFlags = {
   DISALLOW_NESTED_UPDATES: false,
   ENABLE_TYPENAME_PREFIXED_DATA_ID: false,
   ENABLE_UI_CONTEXT_ON_RELAY_LOGGER: false,
+  CHECK_ALL_FRAGMENTS_FOR_MISSING_CLIENT_EDGES: false,
 };
 
 module.exports = RelayFeatureFlags;

package/util/RelayRuntimeTypes.js.flow

@@ -62,14 +62,14 @@ export type VariablesOf<T: OperationType> = T['variables'];
  *   a given instance of executing an operation.
  */
 export type CacheConfig = {
-  force?: ?boolean,
-  poll?: ?number,
-  liveConfigId?: ?string,
-  onSubscribe?: () => void,
-  onResume?: (pauseTimeMs: number) => void,
-  onPause?: (mqttConnectionIsOk: boolean, internetIsOk: boolean) => void,
-  metadata?: {[key: string]: mixed, ...},
-  transactionId?: ?string,
+  +force?: ?boolean,
+  +poll?: ?number,
+  +liveConfigId?: ?string,
+  +onSubscribe?: () => void,
+  +onResume?: (pauseTimeMs: number) => void,
+  +onPause?: (mqttConnectionIsOk: boolean, internetIsOk: boolean) => void,
+  +metadata?: {+[key: string]: mixed, ...},
+  +transactionId?: ?string,
 };
 
 export type FetchQueryFetchPolicy = 'store-or-network' | 'network-only';