relay-runtime 18.1.0 → 19.0.0

package/experimental.js

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

package/experimental.js.flow

@@ -16,6 +16,7 @@ import type {DataID} from './util/RelayRuntimeTypes';
 
 const resolverDataInjector = require('./store/live-resolvers/resolverDataInjector');
 const {observeFragment} = require('./store/observeFragmentExperimental');
+const {observeQuery} = require('./store/observeQueryExperimental');
 const {waitForFragmentData} = require('./store/waitForFragmentExperimental');
 
 // Annotates a strong object return type, where `A` is the GraphQL typename and `Typename` is the
@@ -27,18 +28,29 @@ export type IdOf<A: string, Typename: void | string = void> = [
   ? {id: DataID}
   : {id: DataID, __typename: Typename};
 
-// Annotates a `RelayResolverValue` GraphQL return type
-// eslint-disable-next-line no-unused-vars
-export type RelayResolverValue<A> = A;
+/**
+ * Annotates a `RelayResolverValue` GraphQL return type. Using this type in the
+ * return position of a Relay Resolver informs Relay that it should model this
+ * field as returning a `RelayResolverValue` type. See the docs for more
+ * information:
+ *
+ * https://relay.dev/docs/next/guides/relay-resolvers/return-types/#javascript-values
+ *
+ * Note: This type forces the value to be non-maybe. This is required in order
+ * to allow the Relay compiler to to "see", via static analysis, if the field
+ * can return null or not. If the field is nullable, you can type it as
+ * returning `?RelayResolverValue<T>`.
+ */
+export type RelayResolverValue<A> = $NonMaybeType<A>;
 
 type ErrorResult<Error> = {
-  ok: false,
-  errors: $ReadOnlyArray<Error>,
+  +ok: false,
+  +errors: $ReadOnlyArray<Error>,
 };
 
 type OkayResult<T> = {
-  ok: true,
-  value: T,
+  +ok: true,
+  +value: T,
 };
 
 export type Result<T, Error> = OkayResult<T> | ErrorResult<Error>;
@@ -46,19 +58,20 @@ export type Result<T, Error> = OkayResult<T> | ErrorResult<Error>;
 function isValueResult<T = mixed>(
   input: Result<T, Error>,
 ): input is OkayResult<T> {
-  return input.ok === true;
+  return input.ok === (true as const);
 }
 
 function isErrorResult<T = mixed>(
   input: Result<T, Error>,
 ): input is ErrorResult<Error> {
-  return input.ok === false;
+  return input.ok === (false as const);
 }
 
 module.exports = {
   resolverDataInjector,
   isValueResult,
   isErrorResult,
+  observeQuery,
   observeFragment,
   waitForFragmentData,
 };

package/handlers/connection/ConnectionHandler.js.flow

@@ -67,7 +67,12 @@ function update(store: RecordSourceProxy, payload: HandleFieldPayload): void {
   const serverPageInfo =
     serverConnection && serverConnection.getLinkedRecord(PAGE_INFO);
   if (!serverConnection) {
-    record.setValue(null, payload.handleKey);
+    record.setValue(
+      null,
+      payload.handleKey,
+      undefined,
+      record.getErrors(payload.fieldKey),
+    );
     return;
   }
   // In rare cases the handleKey field may be unset even though the client

package/index.js

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

package/index.js.flow

@@ -35,6 +35,7 @@ const {
 } = require('./store/ClientID');
 const createFragmentSpecResolver = require('./store/createFragmentSpecResolver');
 const createRelayContext = require('./store/createRelayContext');
+const createRelayLoggingContext = require('./store/createRelayLoggingContext');
 const isRelayModernEnvironment = require('./store/isRelayModernEnvironment');
 const {
   isSuspenseSentinel,
@@ -232,6 +233,7 @@ export type {
   ClientQuery,
   RefetchableFragment,
   RenderPolicy,
+  PrefetchableRefetchableFragment,
   UpdatableFragment,
   UpdatableQuery,
   Variables,
@@ -315,6 +317,7 @@ module.exports = {
   suspenseSentinel,
   isRequest: GraphQLTag.isRequest,
   readInlineData,
+  readFragment: ResolverFragments.readFragment,
 
   // Declarative mutation API
   MutationTypes: RelayDeclarativeMutationConfig.MutationTypes,
@@ -378,6 +381,7 @@ module.exports = {
     ResolverFragments,
     OperationTracker: RelayOperationTracker,
     createRelayContext: createRelayContext,
+    createRelayLoggingContext: createRelayLoggingContext,
     getOperationVariables: RelayConcreteVariables.getOperationVariables,
     getLocalVariables: RelayConcreteVariables.getLocalVariables,
     fetchQuery: fetchQueryInternal.fetchQuery,

package/lib/experimental.js

@@ -3,8 +3,10 @@
 var resolverDataInjector = require('./store/live-resolvers/resolverDataInjector');
 var _require = require('./store/observeFragmentExperimental'),
   observeFragment = _require.observeFragment;
-var _require2 = require('./store/waitForFragmentExperimental'),
-  waitForFragmentData = _require2.waitForFragmentData;
+var _require2 = require('./store/observeQueryExperimental'),
+  observeQuery = _require2.observeQuery;
+var _require3 = require('./store/waitForFragmentExperimental'),
+  waitForFragmentData = _require3.waitForFragmentData;
 function isValueResult(input) {
   return input.ok === true;
 }
@@ -15,6 +17,7 @@ module.exports = {
   resolverDataInjector: resolverDataInjector,
   isValueResult: isValueResult,
   isErrorResult: isErrorResult,
+  observeQuery: observeQuery,
   observeFragment: observeFragment,
   waitForFragmentData: waitForFragmentData
 };

package/lib/handlers/connection/ConnectionHandler.js

@@ -26,7 +26,7 @@ function update(store, payload) {
   var serverConnection = record.getLinkedRecord(payload.fieldKey);
   var serverPageInfo = serverConnection && serverConnection.getLinkedRecord(PAGE_INFO);
   if (!serverConnection) {
-    record.setValue(null, payload.handleKey);
+    record.setValue(null, payload.handleKey, undefined, record.getErrors(payload.fieldKey));
     return;
   }
   var clientConnectionID = generateClientID(record.getDataID(), payload.handleKey);

package/lib/index.js

@@ -25,6 +25,7 @@ var _require2 = require('./store/ClientID'),
   isClientID = _require2.isClientID;
 var createFragmentSpecResolver = require('./store/createFragmentSpecResolver');
 var createRelayContext = require('./store/createRelayContext');
+var createRelayLoggingContext = require('./store/createRelayLoggingContext');
 var isRelayModernEnvironment = require('./store/isRelayModernEnvironment');
 var _require3 = require('./store/live-resolvers/LiveResolverSuspenseSentinel'),
   isSuspenseSentinel = _require3.isSuspenseSentinel,
@@ -123,6 +124,7 @@ module.exports = {
   suspenseSentinel: suspenseSentinel,
   isRequest: GraphQLTag.isRequest,
   readInlineData: readInlineData,
+  readFragment: ResolverFragments.readFragment,
   MutationTypes: RelayDeclarativeMutationConfig.MutationTypes,
   RangeOperations: RelayDeclarativeMutationConfig.RangeOperations,
   DefaultHandlerProvider: RelayDefaultHandlerProvider,
@@ -173,6 +175,7 @@ module.exports = {
     ResolverFragments: ResolverFragments,
     OperationTracker: RelayOperationTracker,
     createRelayContext: createRelayContext,
+    createRelayLoggingContext: createRelayLoggingContext,
     getOperationVariables: RelayConcreteVariables.getOperationVariables,
     getLocalVariables: RelayConcreteVariables.getLocalVariables,
     fetchQuery: fetchQueryInternal.fetchQuery,

package/lib/multi-actor-environment/ActorSpecificEnvironment.js

@@ -16,7 +16,7 @@ var ActorSpecificEnvironment = /*#__PURE__*/function () {
     this._operationTracker = new RelayOperationTracker();
     this._store = config.store;
     this._network = wrapNetworkWithLogObserver(this, config.network);
-    this._publishQueue = new RelayPublishQueue(config.store, config.handlerProvider, defaultGetDataID, config.missingFieldHandlers);
+    this._publishQueue = new RelayPublishQueue(config.store, config.handlerProvider, defaultGetDataID, config.missingFieldHandlers, this.__log);
     this._defaultRenderPolicy = config.defaultRenderPolicy;
     this.options = {
       actorID: this.actorIdentifier

package/lib/mutations/RelayRecordProxy.js

@@ -27,13 +27,24 @@ var RelayRecordProxy = /*#__PURE__*/function () {
     var storageKey = getStableStorageKey(name, args);
     return this._mutator.getValue(this._dataID, storageKey);
   };
-  _proto.setValue = function setValue(value, name, args) {
+  _proto.setValue = function setValue(value, name, args, errors) {
     !isValidLeafValue(value) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayRecordProxy#setValue(): Expected a scalar or array of scalars, ' + 'got `%s`.', JSON.stringify(value)) : invariant(false) : void 0;
-    return this.setValue__UNSAFE(value, name, args);
+    return this.setValue__UNSAFE(value, name, args, errors);
   };
-  _proto.setValue__UNSAFE = function setValue__UNSAFE(value, name, args) {
+  _proto.getErrors = function getErrors(name, args) {
+    var storageKey = getStableStorageKey(name, args);
+    return this._mutator.getErrors(this._dataID, storageKey);
+  };
+  _proto.setValue__UNSAFE = function setValue__UNSAFE(value, name, args, errors) {
     var storageKey = getStableStorageKey(name, args);
     this._mutator.setValue(this._dataID, storageKey, value);
+    if (errors != null) {
+      if (errors.length === 0) {
+        this._mutator.setErrors(this._dataID, storageKey);
+      } else {
+        this._mutator.setErrors(this._dataID, storageKey, errors);
+      }
+    }
     return this;
   };
   _proto.getLinkedRecord = function getLinkedRecord(name, args) {

package/lib/mutations/RelayRecordSourceMutator.js

@@ -105,6 +105,23 @@ var RelayRecordSourceMutator = /*#__PURE__*/function () {
     var sinkRecord = this._getSinkRecord(dataID);
     RelayModernRecord.setValue(sinkRecord, storageKey, value);
   };
+  _proto.getErrors = function getErrors(dataID, storageKey) {
+    for (var ii = 0; ii < this.__sources.length; ii++) {
+      var record = this.__sources[ii].get(dataID);
+      if (record) {
+        var value = RelayModernRecord.getErrors(record, storageKey);
+        if (value !== undefined) {
+          return value;
+        }
+      } else if (record === null) {
+        return null;
+      }
+    }
+  };
+  _proto.setErrors = function setErrors(dataID, storageKey, errors) {
+    var sinkRecord = this._getSinkRecord(dataID);
+    RelayModernRecord.setErrors(sinkRecord, storageKey, errors);
+  };
   _proto.getLinkedRecordID = function getLinkedRecordID(dataID, storageKey) {
     for (var ii = 0; ii < this.__sources.length; ii++) {
       var record = this.__sources[ii].get(dataID);

package/lib/mutations/RelayRecordSourceProxy.js

@@ -14,7 +14,7 @@ var _require4 = require('./readUpdatableQuery'),
 var RelayRecordProxy = require('./RelayRecordProxy');
 var invariant = require('invariant');
 var RelayRecordSourceProxy = /*#__PURE__*/function () {
-  function RelayRecordSourceProxy(mutator, getDataID, handlerProvider, missingFieldHandlers) {
+  function RelayRecordSourceProxy(mutator, getDataID, handlerProvider, missingFieldHandlers, log) {
     this.__mutator = mutator;
     this._handlerProvider = handlerProvider || null;
     this._proxies = {};
@@ -22,6 +22,7 @@ var RelayRecordSourceProxy = /*#__PURE__*/function () {
     this._invalidatedStore = false;
     this._idsMarkedForInvalidation = new Set();
     this._missingFieldHandlers = missingFieldHandlers;
+    this._log = log !== null && log !== void 0 ? log : function (LogEvent) {};
   }
   var _proto = RelayRecordSourceProxy.prototype;
   _proto.publishSource = function publishSource(source, fieldPayloads) {

package/lib/mutations/createUpdatableProxy.js

@@ -71,11 +71,11 @@ function updateProxyFromSelections(mutableUpdatableProxy, updatableProxyRootReco
         case 'ClientEdgeToServerObject':
         case 'Defer':
         case 'ModuleImport':
-        case 'RelayLiveResolver':
         case 'RequiredField':
         case 'CatchField':
         case 'Stream':
         case 'RelayResolver':
+        case 'RelayLiveResolver':
           throw new Error('Encountered an unexpected ReaderSelection variant in RelayRecordSourceProxy. This indicates a bug in Relay.');
         default:
           selection.kind;

package/lib/mutations/validateMutation.js

@@ -72,13 +72,13 @@ if (process.env.NODE_ENV !== "production") {
         return validateModuleImport(context);
       case 'TypeDiscriminator':
         return validateAbstractKey(context, selection.abstractKey);
-      case 'RelayResolver':
-      case 'RelayLiveResolver':
       case 'ClientEdgeToClientObject':
       case 'LinkedHandle':
       case 'ScalarHandle':
       case 'Defer':
       case 'Stream':
+      case 'RelayResolver':
+      case 'RelayLiveResolver':
         {
           return;
         }

package/lib/network/RelayObservable.js

@@ -364,9 +364,7 @@ function _subscribe(source, observer) {
 function swallowError(_error, _isUncaughtThrownError) {}
 if (process.env.NODE_ENV !== "production") {
   RelayObservable.onUnhandledError(function (error, isUncaughtThrownError) {
-    if (typeof fail === 'function') {
-      fail(String(error));
-    } else if (isUncaughtThrownError) {
+    if (isUncaughtThrownError) {
       setTimeout(function () {
         throw error;
       });

package/lib/network/wrapNetworkWithLogObserver.js

@@ -3,7 +3,7 @@
 var generateID = require('../util/generateID');
 function wrapNetworkWithLogObserver(env, network) {
   return {
-    execute: function execute(params, variables, cacheConfig, uploadables) {
+    execute: function execute(params, variables, cacheConfig, uploadables, _, encryptedVariables, preprocessResponse, checkOperation) {
       var networkRequestId = generateID();
       var logObserver = {
         start: function start(subscription) {
@@ -49,7 +49,7 @@ function wrapNetworkWithLogObserver(env, network) {
           info: info
         });
       };
-      return network.execute(params, variables, cacheConfig, uploadables, logRequestInfo)["do"](logObserver);
+      return network.execute(params, variables, cacheConfig, uploadables, logRequestInfo, encryptedVariables, preprocessResponse, checkOperation)["do"](logObserver);
     }
   };
 }

package/lib/query/fetchQuery.js

@@ -21,7 +21,7 @@ function fetchQuery(environment, query, variables, options) {
   var operation = createOperationDescriptor(queryNode, variables, networkCacheConfig);
   var fetchPolicy = (_options$fetchPolicy = options === null || options === void 0 ? void 0 : options.fetchPolicy) !== null && _options$fetchPolicy !== void 0 ? _options$fetchPolicy : 'network-only';
   function readData(snapshot) {
-    handlePotentialSnapshotErrors(environment, snapshot.errorResponseFields);
+    handlePotentialSnapshotErrors(environment, snapshot.fieldErrors);
     return snapshot.data;
   }
   switch (fetchPolicy) {

package/lib/store/DataChecker.js

@@ -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);
+  var checker = new DataChecker(getSourceForActor, getTargetForActor, defaultActorIdentifier, variables, handlers, operationLoader, getDataID, shouldProcessClientComponents, log);
   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) {
+  function DataChecker(getSourceForActor, getTargetForActor, defaultActorIdentifier, variables, handlers, operationLoader, getDataID, shouldProcessClientComponents, log) {
     this._getSourceForActor = getSourceForActor;
     this._getTargetForActor = getTargetForActor;
     this._getDataID = getDataID;
@@ -61,6 +61,7 @@ var DataChecker = /*#__PURE__*/function () {
     this._recordWasMissing = false;
     this._variables = variables;
     this._shouldProcessClientComponents = shouldProcessClientComponents;
+    this._log = log;
   }
   var _proto = DataChecker.prototype;
   _proto._getMutatorAndRecordProxyForActor = function _getMutatorAndRecordProxyForActor(actorIdentifier) {
@@ -68,7 +69,7 @@ var DataChecker = /*#__PURE__*/function () {
     if (tuple == null) {
       var target = this._getTargetForActor(actorIdentifier);
       var mutator = new RelayRecordSourceMutator(this._getSourceForActor(actorIdentifier), target);
-      var recordSourceProxy = new RelayRecordSourceProxy(mutator, this._getDataID, undefined, this._handlers);
+      var recordSourceProxy = new RelayRecordSourceProxy(mutator, this._getDataID, undefined, this._handlers, this._log);
       tuple = [mutator, recordSourceProxy];
       this._mutatorRecordSourceProxyCache.set(actorIdentifier, tuple);
     }
@@ -275,8 +276,6 @@ var DataChecker = /*#__PURE__*/function () {
           _this2._traverseSelections(selection.fragment.selections, dataID);
           break;
         case 'RelayResolver':
-          _this2._checkResolver(selection, dataID);
-          break;
         case 'RelayLiveResolver':
           _this2._checkResolver(selection, dataID);
           break;

package/lib/store/OperationExecutor.js

@@ -111,6 +111,12 @@ var Executor = /*#__PURE__*/function () {
           variables: _this._operation.request.variables,
           cacheConfig: (_this$_operation$requ = _this._operation.request.cacheConfig) !== null && _this$_operation$requ !== void 0 ? _this$_operation$requ : {}
         });
+      },
+      unsubscribe: function unsubscribe() {
+        _this._log({
+          name: 'execute.unsubscribe',
+          executeId: _this._executeId
+        });
       }
     });
     if (!RelayFeatureFlags.PROCESS_OPTIMISTIC_UPDATE_BEFORE_SUBSCRIPTION && optimisticConfig != null) {
@@ -378,6 +384,7 @@ var Executor = /*#__PURE__*/function () {
       var payload = this._normalizeResponse(response, this._operation.root, ROOT_TYPE, {
         actorIdentifier: this._actorIdentifier,
         getDataID: this._getDataID,
+        log: this._log,
         path: [],
         shouldProcessClientComponents: this._shouldProcessClientComponents,
         treatMissingFieldsAsNull: treatMissingFieldsAsNull
@@ -459,6 +466,7 @@ var Executor = /*#__PURE__*/function () {
     }, selector, followupPayload.typeName, {
       actorIdentifier: this._actorIdentifier,
       getDataID: this._getDataID,
+      log: this._log,
       path: followupPayload.path,
       treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       shouldProcessClientComponents: this._shouldProcessClientComponents
@@ -515,6 +523,7 @@ var Executor = /*#__PURE__*/function () {
       var relayPayload = _this8._normalizeResponse(payloadPart, _this8._operation.root, ROOT_TYPE, {
         actorIdentifier: _this8._actorIdentifier,
         getDataID: _this8._getDataID,
+        log: _this8._log,
         path: [],
         treatMissingFieldsAsNull: _this8._treatMissingFieldsAsNull,
         shouldProcessClientComponents: _this8._shouldProcessClientComponents
@@ -801,6 +810,7 @@ var Executor = /*#__PURE__*/function () {
     var relayPayload = this._normalizeResponse(response, placeholder.selector, placeholder.typeName, {
       actorIdentifier: this._actorIdentifier,
       getDataID: this._getDataID,
+      log: this._log,
       path: placeholder.path,
       treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       shouldProcessClientComponents: this._shouldProcessClientComponents
@@ -903,6 +913,7 @@ var Executor = /*#__PURE__*/function () {
     var relayPayload = this._normalizeResponse(response, selector, typeName, {
       actorIdentifier: this._actorIdentifier,
       getDataID: this._getDataID,
+      log: this._log,
       path: [].concat((0, _toConsumableArray2["default"])(normalizationPath), [responseKey, String(itemIndex)]),
       treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       shouldProcessClientComponents: this._shouldProcessClientComponents

package/lib/store/RelayModernEnvironment.js

@@ -14,13 +14,14 @@ var defaultGetDataID = require('./defaultGetDataID');
 var defaultRelayFieldLogger = require('./defaultRelayFieldLogger');
 var normalizeResponse = require('./normalizeResponse');
 var OperationExecutor = require('./OperationExecutor');
+var RelayModernStore = require('./RelayModernStore');
 var RelayPublishQueue = require('./RelayPublishQueue');
 var RelayRecordSource = require('./RelayRecordSource');
 var invariant = require('invariant');
 var RelayModernEnvironment = /*#__PURE__*/function () {
   function RelayModernEnvironment(config) {
     var _this = this;
-    var _config$log, _config$relayFieldLog, _config$UNSTABLE_defa, _config$getDataID, _config$missingFieldH, _config$handlerProvid, _config$scheduler, _config$isServer, _config$normalizeResp, _config$operationTrac;
+    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;
     var operationLoader = config.operationLoader;
@@ -29,6 +30,12 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
         !(typeof operationLoader === 'object' && typeof operationLoader.get === 'function' && typeof operationLoader.load === 'function') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected `operationLoader` to be an object ' + 'with get() and load() functions, got `%s`.', operationLoader) : invariant(false) : void 0;
       }
     }
+    var store = (_config$store = config.store) !== null && _config$store !== void 0 ? _config$store : new RelayModernStore(new RelayRecordSource(), {
+      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;
     this.relayFieldLogger = (_config$relayFieldLog = config.relayFieldLogger) !== null && _config$relayFieldLog !== void 0 ? _config$relayFieldLog : defaultRelayFieldLogger;
     this._defaultRenderPolicy = (_config$UNSTABLE_defa = config.UNSTABLE_defaultRenderPolicy) !== null && _config$UNSTABLE_defa !== void 0 ? _config$UNSTABLE_defa : 'partial';
@@ -37,9 +44,9 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
     this._network = wrapNetworkWithLogObserver(this, config.network);
     this._getDataID = (_config$getDataID = config.getDataID) !== null && _config$getDataID !== void 0 ? _config$getDataID : defaultGetDataID;
     this._missingFieldHandlers = (_config$missingFieldH = config.missingFieldHandlers) !== null && _config$missingFieldH !== void 0 ? _config$missingFieldH : [];
-    this._publishQueue = new RelayPublishQueue(config.store, (_config$handlerProvid = config.handlerProvider) !== null && _config$handlerProvid !== void 0 ? _config$handlerProvid : RelayDefaultHandlerProvider, this._getDataID, this._missingFieldHandlers);
+    this._publishQueue = new RelayPublishQueue(store, (_config$handlerProvid = config.handlerProvider) !== null && _config$handlerProvid !== void 0 ? _config$handlerProvid : RelayDefaultHandlerProvider, this._getDataID, this._missingFieldHandlers, this.__log);
     this._scheduler = (_config$scheduler = config.scheduler) !== null && _config$scheduler !== void 0 ? _config$scheduler : null;
-    this._store = config.store;
+    this._store = store;
     this.options = config.options;
     this._isServer = (_config$isServer = config.isServer) !== null && _config$isServer !== void 0 ? _config$isServer : false;
     this._normalizeResponse = (_config$normalizeResp = config.normalizeResponse) !== null && _config$normalizeResp !== void 0 ? _config$normalizeResp : normalizeResponse;
@@ -199,7 +206,9 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
     var operation = _ref.operation;
     return this._execute({
       createSource: function createSource() {
-        return _this7.getNetwork().execute(operation.request.node.params, operation.request.variables, operation.request.cacheConfig || {}, null);
+        return _this7.getNetwork().execute(operation.request.node.params, operation.request.variables, operation.request.cacheConfig || {}, null, undefined, undefined, undefined, function () {
+          return _this7.check(operation);
+        });
       },
       isClientPayload: false,
       operation: operation,

package/lib/store/RelayModernFragmentSpecResolver.js

@@ -132,14 +132,14 @@ var SelectorResolver = /*#__PURE__*/function () {
     (0, _defineProperty2["default"])(this, "_onChange", function (snapshot) {
       _this2._data = snapshot.data;
       _this2._isMissingData = snapshot.isMissingData;
-      _this2._errorResponseFields = snapshot.errorResponseFields;
+      _this2._fieldErrors = snapshot.fieldErrors;
       _this2._callback();
     });
     var _snapshot = environment.lookup(selector);
     this._callback = callback;
     this._data = _snapshot.data;
     this._isMissingData = _snapshot.isMissingData;
-    this._errorResponseFields = _snapshot.errorResponseFields;
+    this._fieldErrors = _snapshot.fieldErrors;
     this._environment = environment;
     this._rootIsQueryRenderer = rootIsQueryRenderer;
     this._selector = selector;
@@ -182,7 +182,7 @@ var SelectorResolver = /*#__PURE__*/function () {
         }
       }
     }
-    handlePotentialSnapshotErrors(this._environment, this._errorResponseFields);
+    handlePotentialSnapshotErrors(this._environment, this._fieldErrors);
     return this._data;
   };
   _proto2.setSelector = function setSelector(selector) {
@@ -193,7 +193,7 @@ var SelectorResolver = /*#__PURE__*/function () {
     var snapshot = this._environment.lookup(selector);
     this._data = recycleNodesInto(this._data, snapshot.data);
     this._isMissingData = snapshot.isMissingData;
-    this._errorResponseFields = snapshot.errorResponseFields;
+    this._fieldErrors = snapshot.fieldErrors;
     this._selector = selector;
     this._subscription = this._environment.subscribe(snapshot, this._onChange);
   };