relay-runtime 11.0.0 → 13.0.0-rc.0

package/lib/store/RelayReader.js

@@ -10,13 +10,15 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var RelayFeatureFlags = require('../util/RelayFeatureFlags');
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-var RelayModernRecord = require('./RelayModernRecord');
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var invariant = require("fbjs/lib/invariant");
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
 var _require = require('../util/RelayConcreteNode'),
+    ACTOR_CHANGE = _require.ACTOR_CHANGE,
+    CLIENT_EDGE = _require.CLIENT_EDGE,
     CLIENT_EXTENSION = _require.CLIENT_EXTENSION,
     CONDITION = _require.CONDITION,
     DEFER = _require.DEFER,
@@ -26,30 +28,46 @@ var _require = require('../util/RelayConcreteNode'),
     INLINE_FRAGMENT = _require.INLINE_FRAGMENT,
     LINKED_FIELD = _require.LINKED_FIELD,
     MODULE_IMPORT = _require.MODULE_IMPORT,
+    RELAY_RESOLVER = _require.RELAY_RESOLVER,
     REQUIRED_FIELD = _require.REQUIRED_FIELD,
     SCALAR_FIELD = _require.SCALAR_FIELD,
     STREAM = _require.STREAM;
 
+var RelayFeatureFlags = require('../util/RelayFeatureFlags');
+
+var ClientID = require('./ClientID');
+
+var RelayModernRecord = require('./RelayModernRecord');
+
 var _require2 = require('./RelayStoreReactFlightUtils'),
     getReactFlightClientResponse = _require2.getReactFlightClientResponse;
 
 var _require3 = require('./RelayStoreUtils'),
-    FRAGMENTS_KEY = _require3.FRAGMENTS_KEY,
+    CLIENT_EDGE_TRAVERSAL_PATH = _require3.CLIENT_EDGE_TRAVERSAL_PATH,
     FRAGMENT_OWNER_KEY = _require3.FRAGMENT_OWNER_KEY,
     FRAGMENT_PROP_NAME_KEY = _require3.FRAGMENT_PROP_NAME_KEY,
+    FRAGMENTS_KEY = _require3.FRAGMENTS_KEY,
     ID_KEY = _require3.ID_KEY,
     IS_WITHIN_UNMATCHED_TYPE_REFINEMENT = _require3.IS_WITHIN_UNMATCHED_TYPE_REFINEMENT,
     MODULE_COMPONENT_KEY = _require3.MODULE_COMPONENT_KEY,
     ROOT_ID = _require3.ROOT_ID,
     getArgumentValues = _require3.getArgumentValues,
-    getStorageKey = _require3.getStorageKey,
-    getModuleComponentKey = _require3.getModuleComponentKey;
+    getModuleComponentKey = _require3.getModuleComponentKey,
+    getStorageKey = _require3.getStorageKey;
+
+var _require4 = require('./ResolverCache'),
+    NoopResolverCache = _require4.NoopResolverCache;
+
+var _require5 = require('./ResolverFragments'),
+    withResolverContext = _require5.withResolverContext;
+
+var _require6 = require('./TypeID'),
+    generateTypeID = _require6.generateTypeID;
 
-var _require4 = require('./TypeID'),
-    generateTypeID = _require4.generateTypeID;
+var invariant = require('invariant');
 
-function read(recordSource, selector) {
-  var reader = new RelayReader(recordSource, selector);
+function read(recordSource, selector, resolverCache) {
+  var reader = new RelayReader(recordSource, selector, resolverCache !== null && resolverCache !== void 0 ? resolverCache : new NoopResolverCache());
   return reader.read();
 }
 /**
@@ -58,7 +76,11 @@ function read(recordSource, selector) {
 
 
 var RelayReader = /*#__PURE__*/function () {
-  function RelayReader(recordSource, selector) {
+  function RelayReader(recordSource, selector, resolverCache) {
+    var _selector$clientEdgeT;
+
+    this._clientEdgeTraversalPath = RelayFeatureFlags.ENABLE_CLIENT_EDGES && ((_selector$clientEdgeT = selector.clientEdgeTraversalPath) === null || _selector$clientEdgeT === void 0 ? void 0 : _selector$clientEdgeT.length) ? (0, _toConsumableArray2["default"])(selector.clientEdgeTraversalPath) : [];
+    this._missingClientEdges = [];
     this._isMissingData = false;
     this._isWithinUnmatchedTypeRefinement = false;
     this._missingRequiredFields = null;
@@ -67,6 +89,7 @@ var RelayReader = /*#__PURE__*/function () {
     this._seenRecords = new Set();
     this._selector = selector;
     this._variables = selector.variables;
+    this._resolverCache = resolverCache;
   }
 
   var _proto = RelayReader.prototype;
@@ -95,7 +118,15 @@ var RelayReader = /*#__PURE__*/function () {
     if (isDataExpectedToBePresent && abstractKey == null && record != null) {
       var recordType = RelayModernRecord.getType(record);
 
-      if (recordType !== node.type && dataID !== ROOT_ID) {
+      if (recordType !== node.type && // The root record type is a special `__Root` type and may not match the
+      // type on the ast, so ignore type mismatches at the root.
+      // We currently detect whether we're at the root by checking against ROOT_ID,
+      // but this does not work for mutations/subscriptions which generate unique
+      // root ids. This is acceptable in practice as we don't read data for mutations/
+      // subscriptions in a situation where we would use isMissingData to decide whether
+      // to suspend or not.
+      // TODO T96653810: Correctly detect reading from root of mutation/subscription
+      dataID !== ROOT_ID) {
         isDataExpectedToBePresent = false;
       }
     } // If this is an abstract fragment (and the precise refinement GK is enabled)
@@ -104,7 +135,7 @@ var RelayReader = /*#__PURE__*/function () {
     // the interface, that itself constitutes "expected" data being missing.
 
 
-    if (isDataExpectedToBePresent && abstractKey != null && record != null && RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
+    if (isDataExpectedToBePresent && abstractKey != null && record != null) {
       var _recordType = RelayModernRecord.getType(record);
 
       var typeID = generateTypeID(_recordType);
@@ -129,12 +160,30 @@ var RelayReader = /*#__PURE__*/function () {
     return {
       data: data,
       isMissingData: this._isMissingData && isDataExpectedToBePresent,
+      missingClientEdges: RelayFeatureFlags.ENABLE_CLIENT_EDGES && this._missingClientEdges.length ? this._missingClientEdges : null,
       seenRecords: this._seenRecords,
       selector: this._selector,
       missingRequiredFields: this._missingRequiredFields
     };
   };
 
+  _proto._markDataAsMissing = function _markDataAsMissing() {
+    this._isMissingData = true;
+
+    if (RelayFeatureFlags.ENABLE_CLIENT_EDGES && this._clientEdgeTraversalPath.length) {
+      var top = this._clientEdgeTraversalPath[this._clientEdgeTraversalPath.length - 1]; // Top can be null if we've traversed past a client edge into an ordinary
+      // client extension field; we never want to fetch in response to missing
+      // data off of a client extension field.
+
+      if (top !== null) {
+        this._missingClientEdges.push({
+          request: top.readerClientEdge.operation,
+          clientEdgeDestinationID: top.clientEdgeDestinationID
+        });
+      }
+    }
+  };
+
   _proto._traverse = function _traverse(node, dataID, prevData) {
     var record = this._recordSource.get(dataID);
 
@@ -142,7 +191,7 @@ var RelayReader = /*#__PURE__*/function () {
 
     if (record == null) {
       if (record === undefined) {
-        this._isMissingData = true;
+        this._markDataAsMissing();
       }
 
       return record;
@@ -245,7 +294,7 @@ var RelayReader = /*#__PURE__*/function () {
           break;
 
         case CONDITION:
-          var conditionValue = this._getVariableValue(selection.condition);
+          var conditionValue = Boolean(this._getVariableValue(selection.condition));
 
           if (conditionValue === selection.passingValue) {
             var hasExpectedData = this._traverseSelections(selection.selections, record, data);
@@ -272,7 +321,7 @@ var RelayReader = /*#__PURE__*/function () {
                   return false;
                 }
               }
-            } else if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
+            } else {
               // Similar to the logic in read(): data is only expected to be present
               // if the record is known to conform to the interface. If we don't know
               // whether the type conforms or not, that constitutes missing data.
@@ -298,17 +347,24 @@ var RelayReader = /*#__PURE__*/function () {
                 this._isMissingData = parentIsMissingData;
               } else if (implementsInterface == null) {
                 // Don't know if the type implements the interface or not
-                this._isMissingData = true;
+                this._markDataAsMissing();
               }
-            } else {
-              // legacy behavior for abstract refinements: always read even
-              // if the type doesn't conform and don't reset isMissingData
-              this._traverseSelections(selection.selections, record, data);
             }
 
             break;
           }
 
+        case RELAY_RESOLVER:
+          {
+            if (!RelayFeatureFlags.ENABLE_RELAY_RESOLVERS) {
+              throw new Error('Relay Resolver fields are not yet supported.');
+            }
+
+            this._readResolverField(selection, record, data);
+
+            break;
+          }
+
         case FRAGMENT_SPREAD:
           this._createFragmentPointer(selection, record, data);
 
@@ -320,7 +376,7 @@ var RelayReader = /*#__PURE__*/function () {
           break;
 
         case INLINE_DATA_FRAGMENT_SPREAD:
-          this._createInlineDataFragmentPointer(selection, record, data);
+          this._createInlineDataOrResolverFragmentPointer(selection, record, data);
 
           break;
 
@@ -328,10 +384,22 @@ var RelayReader = /*#__PURE__*/function () {
         case CLIENT_EXTENSION:
           {
             var isMissingData = this._isMissingData;
+            var alreadyMissingClientEdges = this._missingClientEdges.length;
 
-            var _hasExpectedData2 = this._traverseSelections(selection.selections, record, data);
+            if (RelayFeatureFlags.ENABLE_CLIENT_EDGES) {
+              this._clientEdgeTraversalPath.push(null);
+            }
+
+            var _hasExpectedData2 = this._traverseSelections(selection.selections, record, data); // The only case where we want to suspend due to missing data off of
+            // a client extension is if we reached a client edge that we might be
+            // able to fetch:
+
+
+            this._isMissingData = isMissingData || this._missingClientEdges.length > alreadyMissingClientEdges;
 
-            this._isMissingData = isMissingData;
+            if (RelayFeatureFlags.ENABLE_CLIENT_EDGES) {
+              this._clientEdgeTraversalPath.pop();
+            }
 
             if (!_hasExpectedData2) {
               return false;
@@ -360,6 +428,20 @@ var RelayReader = /*#__PURE__*/function () {
 
           break;
 
+        case ACTOR_CHANGE:
+          this._readActorChange(selection, record, data);
+
+          break;
+
+        case CLIENT_EDGE:
+          if (RelayFeatureFlags.ENABLE_CLIENT_EDGES) {
+            this._readClientEdge(selection, record, data);
+          } else {
+            throw new Error('Client edges are not yet supported.');
+          }
+
+          break;
+
         default:
           selection;
           !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayReader(): Unexpected ast kind `%s`.', selection.kind) : invariant(false) : void 0;
@@ -381,16 +463,140 @@ var RelayReader = /*#__PURE__*/function () {
           return this._readLink(selection.field, record, data);
         }
 
+      case RELAY_RESOLVER:
+        if (!RelayFeatureFlags.ENABLE_RELAY_RESOLVERS) {
+          throw new Error('Relay Resolver fields are not yet supported.');
+        }
+
+        this._readResolverField(selection.field, record, data);
+
+        break;
+
       default:
         selection.field.kind;
         !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayReader(): Unexpected ast kind `%s`.', selection.kind) : invariant(false) : void 0;
     }
   };
 
-  _proto._readFlightField = function _readFlightField(field, record, data) {
+  _proto._readResolverField = function _readResolverField(field, record, data) {
+    var _this = this;
+
     var _field$alias;
 
+    var resolverModule = field.resolverModule,
+        fragment = field.fragment;
+    var storageKey = getStorageKey(field, this._variables);
+    var resolverID = ClientID.generateClientID(RelayModernRecord.getDataID(record), storageKey); // Found when reading the resolver fragment, which can happen either when
+    // evaluating the resolver and it calls readFragment, or when checking if the
+    // inputs have changed since a previous evaluation:
+
+    var fragmentValue;
+    var fragmentReaderSelector;
+    var fragmentSeenRecordIDs = new Set();
+
+    var getDataForResolverFragment = function getDataForResolverFragment(singularReaderSelector) {
+      if (fragmentValue != null) {
+        // It was already read when checking for input staleness; no need to read it again.
+        // Note that the variables like fragmentSeenRecordIDs in the outer closure will have
+        // already been set and will still be used in this case.
+        return fragmentValue;
+      }
+
+      fragmentReaderSelector = singularReaderSelector;
+      var existingSeenRecords = _this._seenRecords;
+
+      try {
+        var _resolverFragmentData;
+
+        _this._seenRecords = fragmentSeenRecordIDs;
+        var resolverFragmentData = {};
+
+        _this._createInlineDataOrResolverFragmentPointer(singularReaderSelector.node, record, resolverFragmentData);
+
+        fragmentValue = (_resolverFragmentData = resolverFragmentData[FRAGMENTS_KEY]) === null || _resolverFragmentData === void 0 ? void 0 : _resolverFragmentData[fragment.name];
+        !(typeof fragmentValue === 'object' && fragmentValue !== null) ? process.env.NODE_ENV !== "production" ? invariant(false, "Expected reader data to contain a __fragments property with a property for the fragment named ".concat(fragment.name, ", but it is missing.")) : invariant(false) : void 0;
+        return fragmentValue;
+      } finally {
+        _this._seenRecords = existingSeenRecords;
+      }
+    };
+
+    var resolverContext = {
+      getDataForResolverFragment: getDataForResolverFragment
+    };
+
+    var _this$_resolverCache$ = this._resolverCache.readFromCacheOrEvaluate(record, field, this._variables, function () {
+      var key = {
+        __id: RelayModernRecord.getDataID(record),
+        __fragmentOwner: _this._owner,
+        __fragments: (0, _defineProperty2["default"])({}, fragment.name, {})
+      };
+      return withResolverContext(resolverContext, function () {
+        // $FlowFixMe[prop-missing] - resolver module's type signature is a lie
+        var resolverResult = resolverModule(key);
+        return {
+          resolverResult: resolverResult,
+          fragmentValue: fragmentValue,
+          resolverID: resolverID,
+          seenRecordIDs: fragmentSeenRecordIDs,
+          readerSelector: fragmentReaderSelector
+        };
+      });
+    }, getDataForResolverFragment),
+        result = _this$_resolverCache$[0],
+        seenRecord = _this$_resolverCache$[1];
+
+    if (seenRecord != null) {
+      this._seenRecords.add(seenRecord);
+    }
+
     var applicationName = (_field$alias = field.alias) !== null && _field$alias !== void 0 ? _field$alias : field.name;
+    data[applicationName] = result;
+  };
+
+  _proto._readClientEdge = function _readClientEdge(field, record, data) {
+    var _backingField$alias;
+
+    var backingField = field.backingField; // Because ReaderClientExtension doesn't have `alias` or `name` and so I don't know
+    // how to get its applicationName or storageKey yet:
+
+    !(backingField.kind !== 'ClientExtension') ? process.env.NODE_ENV !== "production" ? invariant(false, 'Client extension client edges are not yet implemented.') : invariant(false) : void 0;
+    var applicationName = (_backingField$alias = backingField.alias) !== null && _backingField$alias !== void 0 ? _backingField$alias : backingField.name;
+    var backingFieldData = {};
+
+    this._traverseSelections([backingField], record, backingFieldData);
+
+    var destinationDataID = backingFieldData[applicationName];
+
+    if (destinationDataID == null) {
+      data[applicationName] = destinationDataID;
+      return;
+    }
+
+    !(typeof destinationDataID === 'string') ? process.env.NODE_ENV !== "production" ? invariant(false, 'Plural client edges not are yet implemented') : invariant(false) : void 0; // FIXME support plural
+    // Not wrapping the push/pop in a try/finally because if we throw, the
+    // Reader object is not usable after that anyway.
+
+    this._clientEdgeTraversalPath.push({
+      readerClientEdge: field,
+      clientEdgeDestinationID: destinationDataID
+    });
+
+    var prevData = data[applicationName];
+    !(prevData == null || typeof prevData === 'object') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayReader(): Expected data for field `%s` on record `%s` ' + 'to be an object, got `%s`.', applicationName, RelayModernRecord.getDataID(record), prevData) : invariant(false) : void 0;
+
+    var value = this._traverse(field.linkedField, destinationDataID, // $FlowFixMe[incompatible-variance]
+    prevData);
+
+    data[applicationName] = value;
+
+    this._clientEdgeTraversalPath.pop();
+  };
+
+  _proto._readFlightField = function _readFlightField(field, record, data) {
+    var _field$alias2;
+
+    var applicationName = (_field$alias2 = field.alias) !== null && _field$alias2 !== void 0 ? _field$alias2 : field.name;
     var storageKey = getStorageKey(field, this._variables);
     var reactFlightClientResponseRecordID = RelayModernRecord.getLinkedRecordID(record, storageKey);
 
@@ -398,7 +604,7 @@ var RelayReader = /*#__PURE__*/function () {
       data[applicationName] = reactFlightClientResponseRecordID;
 
       if (reactFlightClientResponseRecordID === undefined) {
-        this._isMissingData = true;
+        this._markDataAsMissing();
       }
 
       return reactFlightClientResponseRecordID;
@@ -412,7 +618,7 @@ var RelayReader = /*#__PURE__*/function () {
       data[applicationName] = reactFlightClientResponseRecord;
 
       if (reactFlightClientResponseRecord === undefined) {
-        this._isMissingData = true;
+        this._markDataAsMissing();
       }
 
       return reactFlightClientResponseRecord;
@@ -424,14 +630,14 @@ var RelayReader = /*#__PURE__*/function () {
   };
 
   _proto._readScalar = function _readScalar(field, record, data) {
-    var _field$alias2;
+    var _field$alias3;
 
-    var applicationName = (_field$alias2 = field.alias) !== null && _field$alias2 !== void 0 ? _field$alias2 : field.name;
+    var applicationName = (_field$alias3 = field.alias) !== null && _field$alias3 !== void 0 ? _field$alias3 : field.name;
     var storageKey = getStorageKey(field, this._variables);
     var value = RelayModernRecord.getValue(record, storageKey);
 
     if (value === undefined) {
-      this._isMissingData = true;
+      this._markDataAsMissing();
     }
 
     data[applicationName] = value;
@@ -439,9 +645,9 @@ var RelayReader = /*#__PURE__*/function () {
   };
 
   _proto._readLink = function _readLink(field, record, data) {
-    var _field$alias3;
+    var _field$alias4;
 
-    var applicationName = (_field$alias3 = field.alias) !== null && _field$alias3 !== void 0 ? _field$alias3 : field.name;
+    var applicationName = (_field$alias4 = field.alias) !== null && _field$alias4 !== void 0 ? _field$alias4 : field.name;
     var storageKey = getStorageKey(field, this._variables);
     var linkedID = RelayModernRecord.getLinkedRecordID(record, storageKey);
 
@@ -449,7 +655,7 @@ var RelayReader = /*#__PURE__*/function () {
       data[applicationName] = linkedID;
 
       if (linkedID === undefined) {
-        this._isMissingData = true;
+        this._markDataAsMissing();
       }
 
       return linkedID;
@@ -464,12 +670,44 @@ var RelayReader = /*#__PURE__*/function () {
     return value;
   };
 
+  _proto._readActorChange = function _readActorChange(field, record, data) {
+    var _field$alias5;
+
+    var applicationName = (_field$alias5 = field.alias) !== null && _field$alias5 !== void 0 ? _field$alias5 : field.name;
+    var storageKey = getStorageKey(field, this._variables);
+    var externalRef = RelayModernRecord.getActorLinkedRecordID(record, storageKey);
+
+    if (externalRef == null) {
+      data[applicationName] = externalRef;
+
+      if (externalRef === undefined) {
+        this._markDataAsMissing();
+      }
+
+      return data[applicationName];
+    }
+
+    var actorIdentifier = externalRef[0],
+        dataID = externalRef[1];
+    var fragmentRef = {};
+
+    this._createFragmentPointer(field.fragmentSpread, {
+      __id: dataID
+    }, fragmentRef);
+
+    data[applicationName] = {
+      __fragmentRef: fragmentRef,
+      __viewer: actorIdentifier
+    };
+    return data[applicationName];
+  };
+
   _proto._readPluralLink = function _readPluralLink(field, record, data) {
-    var _this = this;
+    var _this2 = this;
 
-    var _field$alias4;
+    var _field$alias6;
 
-    var applicationName = (_field$alias4 = field.alias) !== null && _field$alias4 !== void 0 ? _field$alias4 : field.name;
+    var applicationName = (_field$alias6 = field.alias) !== null && _field$alias6 !== void 0 ? _field$alias6 : field.name;
     var storageKey = getStorageKey(field, this._variables);
     var linkedIDs = RelayModernRecord.getLinkedRecordIDs(record, storageKey);
 
@@ -477,7 +715,7 @@ var RelayReader = /*#__PURE__*/function () {
       data[applicationName] = linkedIDs;
 
       if (linkedIDs === undefined) {
-        this._isMissingData = true;
+        this._markDataAsMissing();
       }
 
       return linkedIDs;
@@ -489,7 +727,7 @@ var RelayReader = /*#__PURE__*/function () {
     linkedIDs.forEach(function (linkedID, nextIndex) {
       if (linkedID == null) {
         if (linkedID === undefined) {
-          _this._isMissingData = true;
+          _this2._markDataAsMissing();
         } // $FlowFixMe[cannot-write]
 
 
@@ -501,7 +739,7 @@ var RelayReader = /*#__PURE__*/function () {
       !(prevItem == null || typeof prevItem === 'object') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayReader(): Expected data for field `%s` on record `%s` ' + 'to be an object, got `%s`.', applicationName, RelayModernRecord.getDataID(record), prevItem) : invariant(false) : void 0; // $FlowFixMe[cannot-write]
       // $FlowFixMe[incompatible-variance]
 
-      linkedArray[nextIndex] = _this._traverse(field, linkedID, prevItem);
+      linkedArray[nextIndex] = _this2._traverse(field, linkedID, prevItem);
     });
     data[applicationName] = linkedArray;
     return linkedArray;
@@ -520,7 +758,7 @@ var RelayReader = /*#__PURE__*/function () {
 
     if (component == null) {
       if (component === undefined) {
-        this._isMissingData = true;
+        this._markDataAsMissing();
       }
 
       return;
@@ -534,7 +772,7 @@ var RelayReader = /*#__PURE__*/function () {
     this._createFragmentPointer({
       kind: 'FragmentSpread',
       name: moduleImport.fragmentName,
-      args: null
+      args: moduleImport.args
     }, record, data);
 
     data[FRAGMENT_PROP_NAME_KEY] = moduleImport.fragmentPropName;
@@ -557,13 +795,16 @@ var RelayReader = /*#__PURE__*/function () {
 
     fragmentPointers[fragmentSpread.name] = fragmentSpread.args ? getArgumentValues(fragmentSpread.args, this._variables) : {};
     data[FRAGMENT_OWNER_KEY] = this._owner;
+    data[IS_WITHIN_UNMATCHED_TYPE_REFINEMENT] = this._isWithinUnmatchedTypeRefinement;
 
-    if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
-      data[IS_WITHIN_UNMATCHED_TYPE_REFINEMENT] = this._isWithinUnmatchedTypeRefinement;
+    if (RelayFeatureFlags.ENABLE_CLIENT_EDGES) {
+      if (this._clientEdgeTraversalPath.length > 0 && this._clientEdgeTraversalPath[this._clientEdgeTraversalPath.length - 1] !== null) {
+        data[CLIENT_EDGE_TRAVERSAL_PATH] = (0, _toConsumableArray2["default"])(this._clientEdgeTraversalPath);
+      }
     }
   };
 
-  _proto._createInlineDataFragmentPointer = function _createInlineDataFragmentPointer(inlineDataFragmentSpread, record, data) {
+  _proto._createInlineDataOrResolverFragmentPointer = function _createInlineDataOrResolverFragmentPointer(fragmentSpreadOrFragment, record, data) {
     var fragmentPointers = data[FRAGMENTS_KEY];
 
     if (fragmentPointers == null) {
@@ -578,10 +819,10 @@ var RelayReader = /*#__PURE__*/function () {
 
     var inlineData = {};
 
-    this._traverseSelections(inlineDataFragmentSpread.selections, record, inlineData); // $FlowFixMe[cannot-write] - writing into read-only field
+    this._traverseSelections(fragmentSpreadOrFragment.selections, record, inlineData); // $FlowFixMe[cannot-write] - writing into read-only field
 
 
-    fragmentPointers[inlineDataFragmentSpread.name] = inlineData;
+    fragmentPointers[fragmentSpreadOrFragment.name] = inlineData;
   };
 
   return RelayReader;

package/lib/store/RelayRecordSource.js

@@ -10,15 +10,99 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var RelayRecordSourceMapImpl = require('./RelayRecordSourceMapImpl');
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var RelayRecordState = require('./RelayRecordState');
+
+var EXISTENT = RelayRecordState.EXISTENT,
+    NONEXISTENT = RelayRecordState.NONEXISTENT,
+    UNKNOWN = RelayRecordState.UNKNOWN;
+/**
+ * An implementation of the `MutableRecordSource` interface (defined in
+ * `RelayStoreTypes`) that holds all records in memory (JS Map).
+ */
 
 var RelayRecordSource = /*#__PURE__*/function () {
   function RelayRecordSource(records) {
-    return RelayRecordSource.create(records);
+    var _this = this;
+
+    this._records = new Map();
+
+    if (records != null) {
+      Object.keys(records).forEach(function (key) {
+        _this._records.set(key, records[key]);
+      });
+    }
   }
 
   RelayRecordSource.create = function create(records) {
-    return new RelayRecordSourceMapImpl(records);
+    return new RelayRecordSource(records);
+  };
+
+  var _proto = RelayRecordSource.prototype;
+
+  _proto.clear = function clear() {
+    this._records = new Map();
+  };
+
+  _proto["delete"] = function _delete(dataID) {
+    this._records.set(dataID, null);
+  };
+
+  _proto.get = function get(dataID) {
+    return this._records.get(dataID);
+  };
+
+  _proto.getRecordIDs = function getRecordIDs() {
+    return Array.from(this._records.keys());
+  };
+
+  _proto.getStatus = function getStatus(dataID) {
+    if (!this._records.has(dataID)) {
+      return UNKNOWN;
+    }
+
+    return this._records.get(dataID) == null ? NONEXISTENT : EXISTENT;
+  };
+
+  _proto.has = function has(dataID) {
+    return this._records.has(dataID);
+  };
+
+  _proto.remove = function remove(dataID) {
+    this._records["delete"](dataID);
+  };
+
+  _proto.set = function set(dataID, record) {
+    this._records.set(dataID, record);
+  };
+
+  _proto.size = function size() {
+    return this._records.size;
+  };
+
+  _proto.toJSON = function toJSON() {
+    var obj = {};
+
+    var _iterator = (0, _createForOfIteratorHelper2["default"])(this._records),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _step.value,
+            key = _step$value[0],
+            value = _step$value[1];
+        obj[key] = value;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return obj;
   };
 
   return RelayRecordSource;