relay-runtime 18.2.0 → 20.0.0

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,11 +49,13 @@ 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;
     this._variables = variables;
     this._shouldProcessClientComponents = options.shouldProcessClientComponents;
+    this._log = options.log;
   }
   var _proto = RelayResponseNormalizer.prototype;
   _proto.normalizeResponse = function normalizeResponse(node, dataID, data, errors) {
@@ -205,13 +207,15 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
           this._normalizeActorChange(selection, record, data);
           break;
         case 'RelayResolver':
-          this._normalizeResolver(selection, record, data);
-          break;
         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;
@@ -289,7 +293,8 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
     var responseKey = selection.alias || selection.name;
     var storageKey = getStorageKey(selection, this._variables);
     var fieldValue = data[responseKey];
-    if (fieldValue == null || RelayFeatureFlags.ENABLE_NONCOMPLIANT_ERROR_HANDLING_ON_LISTS && Array.isArray(fieldValue) && fieldValue.length === 0) {
+    var isNoncompliantlyNullish = RelayFeatureFlags.ENABLE_NONCOMPLIANT_ERROR_HANDLING_ON_LISTS && Array.isArray(fieldValue) && fieldValue.length === 0;
+    if (fieldValue == null || isNoncompliantlyNullish) {
       if (fieldValue === undefined) {
         var isOptionalField = this._isClientExtension || this._isUnmatchedAbstractType;
         if (isOptionalField) {
@@ -301,12 +306,18 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
           return;
         }
       }
-      if (process.env.NODE_ENV !== "production") {
-        if (selection.kind === 'ScalarField') {
-          this._validateConflictingFieldsWithIdenticalId(record, storageKey, null);
+      if (selection.kind === 'ScalarField') {
+        this._validateConflictingFieldsWithIdenticalId(record, storageKey, null);
+      }
+      if (isNoncompliantlyNullish) {
+        if (selection.kind === 'LinkedField') {
+          RelayModernRecord.setLinkedRecordIDs(record, storageKey, []);
+        } else {
+          RelayModernRecord.setValue(record, storageKey, []);
         }
+      } else {
+        RelayModernRecord.setValue(record, storageKey, null);
       }
-      RelayModernRecord.setValue(record, storageKey, null);
       var errorTrie = this._errorTrie;
       if (errorTrie != null) {
         var errors = getErrorsByKey(errorTrie, responseKey);
@@ -317,9 +328,7 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
       return;
     }
     if (selection.kind === 'ScalarField') {
-      if (process.env.NODE_ENV !== "production") {
-        this._validateConflictingFieldsWithIdenticalId(record, storageKey, fieldValue);
-      }
+      this._validateConflictingFieldsWithIdenticalId(record, storageKey, fieldValue);
       RelayModernRecord.setValue(record, storageKey, fieldValue);
     } else if (selection.kind === 'LinkedField') {
       this._path.push(responseKey);
@@ -387,16 +396,14 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
     !(typeof fieldValue === 'object' && fieldValue) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer: Expected data for field `%s` to be an object.', storageKey) : invariant(false) : void 0;
     var nextID = this._getDataId(fieldValue, (_field$concreteType2 = field.concreteType) !== null && _field$concreteType2 !== void 0 ? _field$concreteType2 : this._getRecordType(fieldValue)) || RelayModernRecord.getLinkedRecordID(record, storageKey) || generateClientID(RelayModernRecord.getDataID(record), storageKey);
     !(typeof nextID === 'string') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer: Expected id on field `%s` to be a string.', storageKey) : invariant(false) : void 0;
-    if (process.env.NODE_ENV !== "production") {
-      this._validateConflictingLinkedFieldsWithIdenticalId(RelayModernRecord.getLinkedRecordID(record, storageKey), nextID, storageKey);
-    }
+    this._validateConflictingLinkedFieldsWithIdenticalId(RelayModernRecord.getLinkedRecordID(record, storageKey), nextID, storageKey);
     RelayModernRecord.setLinkedRecordID(record, storageKey, nextID);
     var nextRecord = this._recordSource.get(nextID);
     if (!nextRecord) {
       var typeName = field.concreteType || this._getRecordType(fieldValue);
       nextRecord = RelayModernRecord.create(nextID, typeName);
       this._recordSource.set(nextID, nextRecord);
-    } else if (process.env.NODE_ENV !== "production") {
+    } else {
       this._validateRecordType(nextRecord, field, fieldValue);
     }
     this._traverseSelections(field, nextRecord, fieldValue);
@@ -424,13 +431,11 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
         var typeName = field.concreteType || _this._getRecordType(item);
         nextRecord = RelayModernRecord.create(nextID, typeName);
         _this._recordSource.set(nextID, nextRecord);
-      } else if (process.env.NODE_ENV !== "production") {
+      } else {
         _this._validateRecordType(nextRecord, field, item);
       }
-      if (process.env.NODE_ENV !== "production") {
-        if (prevIDs) {
-          _this._validateConflictingLinkedFieldsWithIdenticalId(prevIDs[nextIndex], nextID, storageKey);
-        }
+      if (prevIDs) {
+        _this._validateConflictingLinkedFieldsWithIdenticalId(prevIDs[nextIndex], nextID, storageKey);
       }
       _this._traverseSelections(field, nextRecord, item);
       _this._errorTrie = oldErrorTrie;
@@ -439,21 +444,42 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
     RelayModernRecord.setLinkedRecordIDs(record, storageKey, nextIDs);
   };
   _proto._validateRecordType = function _validateRecordType(record, field, payload) {
-    var _field$concreteType4;
-    var typeName = (_field$concreteType4 = field.concreteType) !== null && _field$concreteType4 !== void 0 ? _field$concreteType4 : this._getRecordType(payload);
-    var dataID = RelayModernRecord.getDataID(record);
-    process.env.NODE_ENV !== "production" ? warning(isClientID(dataID) && dataID !== ROOT_ID || RelayModernRecord.getType(record) === typeName, 'RelayResponseNormalizer: Invalid record `%s`. Expected %s to be ' + 'consistent, but the record was assigned conflicting types `%s` ' + 'and `%s`. The GraphQL server likely violated the globally unique ' + 'id requirement by returning the same id for different objects.', dataID, TYPENAME_KEY, RelayModernRecord.getType(record), typeName) : void 0;
+    if (RelayFeatureFlags.ENABLE_STORE_ID_COLLISION_LOGGING) {
+      var _field$concreteType4;
+      var typeName = (_field$concreteType4 = field.concreteType) !== null && _field$concreteType4 !== void 0 ? _field$concreteType4 : this._getRecordType(payload);
+      var dataID = RelayModernRecord.getDataID(record);
+      var expected = isClientID(dataID) && dataID !== ROOT_ID || RelayModernRecord.getType(record) === typeName;
+      if (!expected) {
+        var logEvent = {
+          name: 'idCollision.typename',
+          previous_typename: RelayModernRecord.getType(record),
+          new_typename: typeName
+        };
+        if (this._log != null) {
+          this._log(logEvent);
+        }
+      }
+    }
+    if (process.env.NODE_ENV !== "production") {
+      var _field$concreteType5;
+      var _typeName3 = (_field$concreteType5 = field.concreteType) !== null && _field$concreteType5 !== void 0 ? _field$concreteType5 : this._getRecordType(payload);
+      var _dataID = RelayModernRecord.getDataID(record);
+      var _expected = isClientID(_dataID) && _dataID !== ROOT_ID || RelayModernRecord.getType(record) === _typeName3;
+      process.env.NODE_ENV !== "production" ? warning(_expected, 'RelayResponseNormalizer: Invalid record `%s`. Expected %s to be ' + 'consistent, but the record was assigned conflicting types `%s` ' + 'and `%s`. The GraphQL server likely violated the globally unique ' + 'id requirement by returning the same id for different objects.', _dataID, TYPENAME_KEY, RelayModernRecord.getType(record), _typeName3) : void 0;
+    }
   };
   _proto._validateConflictingFieldsWithIdenticalId = function _validateConflictingFieldsWithIdenticalId(record, storageKey, fieldValue) {
     if (process.env.NODE_ENV !== "production") {
-      var dataID = RelayModernRecord.getDataID(record);
       var previousValue = RelayModernRecord.getValue(record, storageKey);
-      process.env.NODE_ENV !== "production" ? warning(storageKey === TYPENAME_KEY || previousValue === undefined || areEqual(previousValue, fieldValue), 'RelayResponseNormalizer: Invalid record. The record contains two ' + 'instances of the same id: `%s` with conflicting field, %s and its values: %s and %s. ' + 'If two fields are different but share ' + 'the same id, one field will overwrite the other.', dataID, storageKey, previousValue, fieldValue) : void 0;
+      var dataID = RelayModernRecord.getDataID(record);
+      var expected = storageKey === TYPENAME_KEY || previousValue === undefined || areEqual(previousValue, fieldValue);
+      process.env.NODE_ENV !== "production" ? warning(expected, 'RelayResponseNormalizer: Invalid record. The record contains two ' + 'instances of the same id: `%s` with conflicting field, %s and its values: %s and %s. ' + 'If two fields are different but share ' + 'the same id, one field will overwrite the other.', dataID, storageKey, previousValue, fieldValue) : void 0;
     }
   };
   _proto._validateConflictingLinkedFieldsWithIdenticalId = function _validateConflictingLinkedFieldsWithIdenticalId(prevID, nextID, storageKey) {
     if (process.env.NODE_ENV !== "production") {
-      process.env.NODE_ENV !== "production" ? warning(prevID === undefined || prevID === nextID, 'RelayResponseNormalizer: Invalid record. The record contains ' + 'references to the conflicting field, %s and its id values: %s and %s. ' + 'We need to make sure that the record the field points ' + 'to remains consistent or one field will overwrite the other.', storageKey, prevID, nextID) : void 0;
+      var expected = prevID === undefined || prevID === nextID;
+      process.env.NODE_ENV !== "production" ? warning(expected, 'RelayResponseNormalizer: Invalid record. The record contains ' + 'references to the conflicting field, %s and its id values: %s and %s. ' + 'We need to make sure that the record the field points ' + 'to remains consistent or one field will overwrite the other.', storageKey, prevID, nextID) : void 0;
     }
   };
   return RelayResponseNormalizer;

package/lib/store/RelayStoreSubscriptions.js

@@ -59,7 +59,7 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
           missingLiveResolverFields: backup.missingLiveResolverFields,
           seenRecords: backup.seenRecords,
           selector: backup.selector,
-          errorResponseFields: backup.errorResponseFields
+          fieldErrors: backup.fieldErrors
         };
       } else {
         subscription.stale = true;
@@ -94,7 +94,7 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
       missingLiveResolverFields: nextSnapshot.missingLiveResolverFields,
       seenRecords: nextSnapshot.seenRecords,
       selector: nextSnapshot.selector,
-      errorResponseFields: nextSnapshot.errorResponseFields
+      fieldErrors: nextSnapshot.fieldErrors
     };
     if (process.env.NODE_ENV !== "production") {
       deepFreeze(nextSnapshot);

package/lib/store/RelayStoreUtils.js

@@ -4,6 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var getRelayHandleKey = require('../util/getRelayHandleKey');
 var RelayConcreteNode = require('../util/RelayConcreteNode');
+var RelayFeatureFlags = require('../util/RelayFeatureFlags');
 var _require = require('../util/stableCopy'),
   stableCopy = _require.stableCopy;
 var invariant = require('invariant');
@@ -14,6 +15,7 @@ var VARIABLE = RelayConcreteNode.VARIABLE,
 var ERRORS_KEY = '__errors';
 var MODULE_COMPONENT_KEY_PREFIX = '__module_component_';
 var MODULE_OPERATION_KEY_PREFIX = '__module_operation_';
+var RELAY_READ_TIME_RESOLVER_KEY_PREFIX = '$r:';
 function getArgumentValue(arg, variables) {
   if (arg.kind === VARIABLE) {
     return getStableVariableValue(arg.variableName, variables);
@@ -76,6 +78,10 @@ function getStorageKey(field, variables) {
   var name = field.name;
   return args && args.length !== 0 ? formatStorageKey(name, getArgumentValues(args, variables)) : name;
 }
+function getReadTimeResolverStorageKey(field, variables) {
+  var storageKey = getStorageKey(field, variables);
+  return RelayFeatureFlags.ENABLE_READ_TIME_RESOLVER_STORAGE_KEY_PREFIX ? '$r:' + storageKey : storageKey;
+}
 function getArguments(field) {
   if (field.kind === 'RelayResolver' || field.kind === 'RelayLiveResolver') {
     var _field$fragment2;
@@ -141,11 +147,13 @@ var RelayStoreUtils = {
   RELAY_RESOLVER_SNAPSHOT_KEY: '__resolverSnapshot',
   RELAY_RESOLVER_ERROR_KEY: '__resolverError',
   RELAY_RESOLVER_OUTPUT_TYPE_RECORD_IDS: '__resolverOutputTypeRecordIDs',
+  RELAY_READ_TIME_RESOLVER_KEY_PREFIX: RELAY_READ_TIME_RESOLVER_KEY_PREFIX,
   formatStorageKey: formatStorageKey,
   getArgumentValue: getArgumentValue,
   getArgumentValues: getArgumentValues,
   getHandleStorageKey: getHandleStorageKey,
   getStorageKey: getStorageKey,
+  getReadTimeResolverStorageKey: getReadTimeResolverStorageKey,
   getStableStorageKey: getStableStorageKey,
   getModuleComponentKey: getModuleComponentKey,
   getModuleOperationKey: getModuleOperationKey

package/lib/store/ResolverFragments.js

@@ -28,8 +28,8 @@ function readFragment(fragmentInput, fragmentKey) {
   var _context$getDataForRe = context.getDataForResolverFragment(fragmentSelector, fragmentKey),
     data = _context$getDataForRe.data,
     isMissingData = _context$getDataForRe.isMissingData,
-    errorResponseFields = _context$getDataForRe.errorResponseFields;
-  if (isMissingData || errorResponseFields != null && errorResponseFields.some(eventShouldThrow)) {
+    fieldErrors = _context$getDataForRe.fieldErrors;
+  if (isMissingData || fieldErrors != null && fieldErrors.some(eventShouldThrow)) {
     throw RESOLVER_FRAGMENT_ERRORED_SENTINEL;
   }
   return data;

package/lib/store/createRelayLoggingContext.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var invariant = require('invariant');
+var relayLoggingContext;
+var firstReact;
+function createRelayLoggingContext(react) {
+  if (!relayLoggingContext) {
+    relayLoggingContext = react.createContext(null);
+    if (process.env.NODE_ENV !== "production") {
+      relayLoggingContext.displayName = 'RelayLoggingContext';
+    }
+    firstReact = react;
+  }
+  !(react === firstReact) ? process.env.NODE_ENV !== "production" ? invariant(false, '[createRelayLoggingContext]: You are passing a different instance of React', react.version) : invariant(false) : void 0;
+  return relayLoggingContext;
+}
+module.exports = createRelayLoggingContext;

package/lib/store/generateTypenamePrefixedDataID.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var TYPENAME_PREFIX = '__type:';
+function generateTypenamePrefixedDataID(typeName, dataID) {
+  return "".concat(TYPENAME_PREFIX).concat(typeName, ":").concat(dataID);
+}
+module.exports = {
+  generateTypenamePrefixedDataID: generateTypenamePrefixedDataID
+};

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

@@ -22,6 +22,7 @@ var _require5 = require('../RelayStoreUtils'),
   RELAY_RESOLVER_OUTPUT_TYPE_RECORD_IDS = _require5.RELAY_RESOLVER_OUTPUT_TYPE_RECORD_IDS,
   RELAY_RESOLVER_SNAPSHOT_KEY = _require5.RELAY_RESOLVER_SNAPSHOT_KEY,
   RELAY_RESOLVER_VALUE_KEY = _require5.RELAY_RESOLVER_VALUE_KEY,
+  getReadTimeResolverStorageKey = _require5.getReadTimeResolverStorageKey,
   getStorageKey = _require5.getStorageKey;
 var getOutputTypeRecordIDs = require('./getOutputTypeRecordIDs');
 var isLiveStateValue = require('./isLiveStateValue');
@@ -55,7 +56,7 @@ var LiveResolverCache = /*#__PURE__*/function () {
   _proto.readFromCacheOrEvaluate = function readFromCacheOrEvaluate(recordID, field, variables, evaluate, getDataForResolverFragment) {
     var recordSource = this._getRecordSource();
     var record = expectRecord(recordSource, recordID);
-    var storageKey = getStorageKey(field, variables);
+    var storageKey = getReadTimeResolverStorageKey(field, variables);
     var linkedID = RelayModernRecord.getLinkedRecordID(record, storageKey);
     var linkedRecord = linkedID == null ? null : recordSource.get(linkedID);
     var updatedDataIDs;
@@ -367,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/live-resolvers/resolverDataInjector.js

@@ -5,26 +5,26 @@ var _require = require('../ResolverFragments'),
 var invariant = require('invariant');
 function resolverDataInjector(fragment, _resolverFn, fieldName, isRequiredField) {
   var resolverFn = _resolverFn;
-  return function (fragmentKey, args) {
+  return function (fragmentKey, args, resolverContext) {
     var data = readFragment(fragment, fragmentKey);
     if (fieldName != null) {
       if (data == null) {
         if (isRequiredField === true) {
           !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'Expected required resolver field `%s` in fragment `%s` to be present. But resolvers fragment data is null/undefined.', fieldName, fragment.name) : invariant(false) : void 0;
         } else {
-          return resolverFn(null, args);
+          return resolverFn(null, args, resolverContext);
         }
       }
       if (fieldName in data) {
         if (isRequiredField === true) {
           !(data[fieldName] != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Expected required resolver field `%s` in fragment `%s` to be non-null.', fieldName, fragment.name) : invariant(false) : void 0;
         }
-        return resolverFn(data[fieldName], args);
+        return resolverFn(data[fieldName], args, resolverContext);
       } else {
         !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'Missing field `%s` in fragment `%s` in resolver response.', fieldName, fragment.name) : invariant(false) : void 0;
       }
     } else {
-      return resolverFn(data, args);
+      return resolverFn(null, args, resolverContext);
     }
   };
 }

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/store/observeFragmentExperimental.js

@@ -1,14 +1,17 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
 var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator").default;
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
 var Observable = require('../network/RelayObservable');
-var _require = require('../query/GraphQLTag'),
-  getFragment = _require.getFragment;
-var getPendingOperationsForFragment = require('../util/getPendingOperationsForFragment');
-var _require2 = require('../util/handlePotentialSnapshotErrors'),
-  handlePotentialSnapshotErrors = _require2.handlePotentialSnapshotErrors;
-var _require3 = require('./RelayModernSelector'),
-  getSelector = _require3.getSelector;
+var _require = require('../query/fetchQueryInternal'),
+  getObservableForActiveRequest = _require.getObservableForActiveRequest;
+var _require2 = require('../query/GraphQLTag'),
+  getFragment = _require2.getFragment;
+var _require3 = require('../util/handlePotentialSnapshotErrors'),
+  handlePotentialSnapshotErrors = _require3.handlePotentialSnapshotErrors;
+var _require4 = require('./RelayModernSelector'),
+  getSelector = _require4.getSelector;
 var invariant = require('invariant');
 function waitForFragmentData(_x, _x2, _x3) {
   return _waitForFragmentData.apply(this, arguments);
@@ -47,15 +50,15 @@ function observeFragment(environment, fragment, fragmentRef) {
   !(fragmentSelector != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Expected a selector, got null.') : invariant(false) : void 0;
   switch (fragmentSelector.kind) {
     case 'SingularReaderSelector':
-      return observeSelector(environment, fragment, fragmentSelector);
+      return observeSingularSelector(environment, fragment, fragmentSelector);
     case 'PluralReaderSelector':
       {
-        !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'Plural fragments are not supported') : invariant(false) : void 0;
+        return observePluralSelector(environment, fragment, fragmentSelector);
       }
   }
   !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'Unsupported fragment selector kind') : invariant(false) : void 0;
 }
-function observeSelector(environment, fragmentNode, fragmentSelector) {
+function observeSingularSelector(environment, fragmentNode, fragmentSelector) {
   var snapshot = environment.lookup(fragmentSelector);
   return Observable.create(function (sink) {
     sink.next(snapshotToFragmentState(environment, fragmentNode, fragmentSelector.owner, snapshot));
@@ -67,6 +70,28 @@ function observeSelector(environment, fragmentNode, fragmentSelector) {
     };
   });
 }
+function observePluralSelector(environment, fragmentNode, fragmentSelector) {
+  var snapshots = fragmentSelector.selectors.map(function (selector) {
+    return environment.lookup(selector);
+  });
+  return Observable.create(function (sink) {
+    var states = snapshots.map(function (snapshot, index) {
+      return snapshotToFragmentState(environment, fragmentNode, fragmentSelector.selectors[index].owner, snapshot);
+    });
+    sink.next(mergeFragmentStates(states));
+    var subscriptions = snapshots.map(function (snapshot, index) {
+      return environment.subscribe(snapshot, function (latestSnapshot) {
+        states[index] = snapshotToFragmentState(environment, fragmentNode, fragmentSelector.selectors[index].owner, latestSnapshot);
+        sink.next(mergeFragmentStates(states));
+      });
+    });
+    return function () {
+      return subscriptions.forEach(function (subscription) {
+        return subscription.dispose();
+      });
+    };
+  });
+}
 function snapshotToFragmentState(environment, fragmentNode, owner, snapshot) {
   var missingLiveResolverFields = snapshot.missingLiveResolverFields != null && snapshot.missingLiveResolverFields.length > 0;
   var missingClientEdges = snapshot.missingClientEdges != null && snapshot.missingClientEdges.length > 0;
@@ -76,15 +101,14 @@ function snapshotToFragmentState(environment, fragmentNode, owner, snapshot) {
     };
   }
   if (snapshot.isMissingData) {
-    var pendingOperations = getPendingOperationsForFragment(environment, fragmentNode, owner);
-    if (pendingOperations != null) {
+    if (getObservableForActiveRequest(environment, owner) != null || environment.getOperationTracker().getPendingOperationsAffectingOwner(owner) != null) {
       return {
         state: 'loading'
       };
     }
   }
   try {
-    handlePotentialSnapshotErrors(environment, snapshot.errorResponseFields);
+    handlePotentialSnapshotErrors(environment, snapshot.fieldErrors);
   } catch (error) {
     return {
       error: error,
@@ -97,6 +121,29 @@ function snapshotToFragmentState(environment, fragmentNode, owner, snapshot) {
     value: snapshot.data
   };
 }
+function mergeFragmentStates(states) {
+  var value = [];
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(states),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var state = _step.value;
+      if (state.state === 'ok') {
+        value.push(state.value);
+      } else {
+        return state;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    state: 'ok',
+    value: value
+  };
+}
 module.exports = {
   observeFragment: observeFragment,
   waitForFragmentData: waitForFragmentData

package/lib/store/observeQueryExperimental.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _require = require('./observeFragmentExperimental'),
+  observeFragment = _require.observeFragment;
+var _require2 = require('./RelayModernOperationDescriptor'),
+  createOperationDescriptor = _require2.createOperationDescriptor;
+function observeQuery(environment, gqlQuery, variables) {
+  var operation = createOperationDescriptor(gqlQuery, variables);
+  var rootFragmentRef = {
+    __id: operation.fragment.dataID,
+    __fragments: (0, _defineProperty2["default"])({}, operation.fragment.node.name, operation.request.variables),
+    __fragmentOwner: operation.request
+  };
+  var fragmentNode = operation.request.node.fragment;
+  return observeFragment(environment, fragmentNode, rootFragmentRef);
+}
+module.exports = {
+  observeQuery: observeQuery
+};

package/lib/util/RelayFeatureFlags.js

@@ -12,6 +12,7 @@ var RelayFeatureFlags = {
   MAX_DATA_ID_LENGTH: null,
   STRING_INTERN_LEVEL: 0,
   LOG_MISSING_RECORDS_IN_PROD: false,
+  ENABLE_STORE_ID_COLLISION_LOGGING: false,
   ENABLE_NONCOMPLIANT_ERROR_HANDLING_ON_LISTS: false,
   ENABLE_LOOSE_SUBSCRIPTION_ATTRIBUTION: false,
   ENABLE_OPERATION_TRACKER_OPTIMISTIC_UPDATES: false,
@@ -20,6 +21,11 @@ var RelayFeatureFlags = {
   MARK_RESOLVER_VALUES_AS_CLEAN_AFTER_FRAGMENT_REREAD: false,
   ENABLE_CYLE_DETECTION_IN_VARIABLES: false,
   ENABLE_ACTIVITY_COMPATIBILITY: false,
-  ENABLE_READ_TIME_RESOLVER_STORAGE_KEY_PREFIX: true
+  ENABLE_READ_TIME_RESOLVER_STORAGE_KEY_PREFIX: true,
+  ENABLE_USE_PAGINATION_IS_LOADING_FIX: false,
+  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/lib/util/handlePotentialSnapshotErrors.js

@@ -1,22 +1,25 @@
 'use strict';
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
 var invariant = require('invariant');
-function handleFieldErrors(environment, errorResponseFields) {
-  var _iterator = (0, _createForOfIteratorHelper2["default"])(errorResponseFields),
+function handleFieldErrors(environment, fieldErrors, loggingContext) {
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(fieldErrors),
     _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var fieldError = _step.value;
-      environment.relayFieldLogger(fieldError);
+      environment.relayFieldLogger((0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, fieldError), {}, {
+        uiContext: loggingContext
+      }));
     }
   } catch (err) {
     _iterator.e(err);
   } finally {
     _iterator.f();
   }
-  var _iterator2 = (0, _createForOfIteratorHelper2["default"])(errorResponseFields),
+  var _iterator2 = (0, _createForOfIteratorHelper2["default"])(fieldErrors),
     _step2;
   try {
     for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
@@ -24,7 +27,7 @@ function handleFieldErrors(environment, errorResponseFields) {
       if (eventShouldThrow(_fieldError)) {
         switch (_fieldError.kind) {
           case 'relay_resolver.error':
-            throw new Error("Relay: Resolver error at path '".concat(_fieldError.fieldPath, "' in '").concat(_fieldError.owner, "'."));
+            throw new Error("Relay: Resolver error at path '".concat(_fieldError.fieldPath, "' in '").concat(_fieldError.owner, "'. Message: ").concat(_fieldError.error.message));
           case 'relay_field_payload.error':
             throw new Error("Relay: Unexpected response payload - check server logs for details.");
           case 'missing_expected_data.throw':
@@ -62,9 +65,9 @@ function eventShouldThrow(event) {
       throw new Error('Relay: Unexpected event kind');
   }
 }
-function handlePotentialSnapshotErrors(environment, errorResponseFields) {
-  if (errorResponseFields != null) {
-    handleFieldErrors(environment, errorResponseFields);
+function handlePotentialSnapshotErrors(environment, fieldErrors, loggingContext) {
+  if (fieldErrors != null) {
+    handleFieldErrors(environment, fieldErrors, loggingContext);
   }
 }
 module.exports = {

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

@@ -87,6 +87,7 @@ class ActorSpecificEnvironment implements IActorEnvironment {
       config.handlerProvider,
       defaultGetDataID,
       config.missingFieldHandlers,
+      this.__log,
     );
     this._defaultRenderPolicy = config.defaultRenderPolicy;
     // TODO:T92305692 Remove `options` in favor of directly using `actorIdentifier` on the environment

package/mutations/RelayRecordSourceProxy.js.flow

@@ -18,6 +18,7 @@ import type {
   FragmentType,
   HandleFieldPayload,
   HasUpdatableSpread,
+  LogFunction,
   MissingFieldHandler,
   RecordProxy,
   RecordSource,
@@ -53,12 +54,14 @@ class RelayRecordSourceProxy implements RecordSourceProxy {
   _invalidatedStore: boolean;
   _idsMarkedForInvalidation: DataIDSet;
   _missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>;
+  _log: LogFunction;
 
   constructor(
     mutator: RelayRecordSourceMutator,
     getDataID: GetDataID,
     handlerProvider?: ?HandlerProvider,
     missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>,
+    log: ?LogFunction,
   ) {
     this.__mutator = mutator;
     this._handlerProvider = handlerProvider || null;
@@ -67,6 +70,7 @@ class RelayRecordSourceProxy implements RecordSourceProxy {
     this._invalidatedStore = false;
     this._idsMarkedForInvalidation = new Set();
     this._missingFieldHandlers = missingFieldHandlers;
+    this._log = log ?? (LogEvent => {});
   }
 
   publishSource(

package/mutations/createUpdatableProxy.js.flow

@@ -181,11 +181,11 @@ function updateProxyFromSelections<TData>(
       case 'ClientEdgeToServerObject':
       case 'Defer':
       case 'ModuleImport':
-      case 'RelayLiveResolver':
       case 'RequiredField':
       case 'CatchField':
       case 'Stream':
       case 'RelayResolver':
+      case 'RelayLiveResolver':
         // These types of reader nodes are not currently handled.
         throw new Error(
           'Encountered an unexpected ReaderSelection variant in RelayRecordSourceProxy. This indicates a bug in Relay.',