relay-runtime 11.0.2 → 12.0.0

package/lib/store/RelayOperationTracker.js

@@ -18,9 +18,9 @@ var invariant = require('invariant');
 
 var RelayOperationTracker = /*#__PURE__*/function () {
   function RelayOperationTracker() {
-    this._ownersToPendingOperationsIdentifier = new Map();
-    this._pendingOperationsToOwnersIdentifier = new Map();
-    this._ownersIdentifierToPromise = new Map();
+    this._ownersToPendingOperations = new Map();
+    this._pendingOperationsToOwners = new Map();
+    this._ownersToPendingPromise = new Map();
   }
   /**
    * Update the map of current processing operations with the set of
@@ -46,19 +46,19 @@ var RelayOperationTracker = /*#__PURE__*/function () {
         var owner = _step.value;
         var ownerIdentifier = owner.identifier;
 
-        var pendingOperationsAffectingOwner = this._ownersToPendingOperationsIdentifier.get(ownerIdentifier);
+        var pendingOperationsAffectingOwner = this._ownersToPendingOperations.get(ownerIdentifier);
 
         if (pendingOperationsAffectingOwner != null) {
           // In this case the `ownerIdentifier` already affected by some operations
           // We just need to detect, is it the same operation that we already
           // have in the list, or it's a new operation
           if (!pendingOperationsAffectingOwner.has(pendingOperationIdentifier)) {
-            pendingOperationsAffectingOwner.add(pendingOperationIdentifier);
+            pendingOperationsAffectingOwner.set(pendingOperationIdentifier, pendingOperation);
             newlyAffectedOwnersIdentifier.add(ownerIdentifier);
           }
         } else {
           // This is a new `ownerIdentifier` that is affected by the operation
-          this._ownersToPendingOperationsIdentifier.set(ownerIdentifier, new Set([pendingOperationIdentifier]));
+          this._ownersToPendingOperations.set(ownerIdentifier, new Map([[pendingOperationIdentifier, pendingOperation]]));
 
           newlyAffectedOwnersIdentifier.add(ownerIdentifier);
         }
@@ -73,10 +73,10 @@ var RelayOperationTracker = /*#__PURE__*/function () {
     if (newlyAffectedOwnersIdentifier.size === 0) {
       return;
     } // But, if some owners were affected we need to add them to
-    // the `_pendingOperationsToOwnersIdentifier` set
+    // the `_pendingOperationsToOwners` set
 
 
-    var ownersAffectedByOperationIdentifier = this._pendingOperationsToOwnersIdentifier.get(pendingOperationIdentifier) || new Set();
+    var ownersAffectedByPendingOperation = this._pendingOperationsToOwners.get(pendingOperationIdentifier) || new Set();
 
     var _iterator2 = (0, _createForOfIteratorHelper2["default"])(newlyAffectedOwnersIdentifier),
         _step2;
@@ -87,7 +87,7 @@ var RelayOperationTracker = /*#__PURE__*/function () {
 
         this._resolveOwnerResolvers(_ownerIdentifier);
 
-        ownersAffectedByOperationIdentifier.add(_ownerIdentifier);
+        ownersAffectedByPendingOperation.add(_ownerIdentifier);
       }
     } catch (err) {
       _iterator2.e(err);
@@ -95,7 +95,7 @@ var RelayOperationTracker = /*#__PURE__*/function () {
       _iterator2.f();
     }
 
-    this._pendingOperationsToOwnersIdentifier.set(pendingOperationIdentifier, ownersAffectedByOperationIdentifier);
+    this._pendingOperationsToOwners.set(pendingOperationIdentifier, ownersAffectedByPendingOperation);
   }
   /**
    * Once pending operation is completed we need to remove it
@@ -106,7 +106,7 @@ var RelayOperationTracker = /*#__PURE__*/function () {
   _proto.complete = function complete(pendingOperation) {
     var pendingOperationIdentifier = pendingOperation.identifier;
 
-    var affectedOwnersIdentifier = this._pendingOperationsToOwnersIdentifier.get(pendingOperationIdentifier);
+    var affectedOwnersIdentifier = this._pendingOperationsToOwners.get(pendingOperationIdentifier);
 
     if (affectedOwnersIdentifier == null) {
       return;
@@ -125,7 +125,7 @@ var RelayOperationTracker = /*#__PURE__*/function () {
       for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
         var ownerIdentifier = _step3.value;
 
-        var pendingOperationsAffectingOwner = this._ownersToPendingOperationsIdentifier.get(ownerIdentifier);
+        var pendingOperationsAffectingOwner = this._ownersToPendingOperations.get(ownerIdentifier);
 
         if (!pendingOperationsAffectingOwner) {
           continue;
@@ -155,7 +155,7 @@ var RelayOperationTracker = /*#__PURE__*/function () {
 
         this._resolveOwnerResolvers(_ownerIdentifier2);
 
-        this._ownersToPendingOperationsIdentifier["delete"](_ownerIdentifier2);
+        this._ownersToPendingOperations["delete"](_ownerIdentifier2);
       } // Update all ownerIdentifier that were updated by `pendingOperationIdentifier` but still
       // are affected by other operations
 
@@ -181,30 +181,35 @@ var RelayOperationTracker = /*#__PURE__*/function () {
       _iterator5.f();
     }
 
-    this._pendingOperationsToOwnersIdentifier["delete"](pendingOperationIdentifier);
+    this._pendingOperationsToOwners["delete"](pendingOperationIdentifier);
   };
 
   _proto._resolveOwnerResolvers = function _resolveOwnerResolvers(ownerIdentifier) {
-    var promiseEntry = this._ownersIdentifierToPromise.get(ownerIdentifier);
+    var promiseEntry = this._ownersToPendingPromise.get(ownerIdentifier);
 
     if (promiseEntry != null) {
       promiseEntry.resolve();
     }
 
-    this._ownersIdentifierToPromise["delete"](ownerIdentifier);
+    this._ownersToPendingPromise["delete"](ownerIdentifier);
   };
 
-  _proto.getPromiseForPendingOperationsAffectingOwner = function getPromiseForPendingOperationsAffectingOwner(owner) {
+  _proto.getPendingOperationsAffectingOwner = function getPendingOperationsAffectingOwner(owner) {
     var ownerIdentifier = owner.identifier;
 
-    if (!this._ownersToPendingOperationsIdentifier.has(ownerIdentifier)) {
+    var pendingOperationsForOwner = this._ownersToPendingOperations.get(ownerIdentifier);
+
+    if (pendingOperationsForOwner == null || pendingOperationsForOwner.size === 0) {
       return null;
     }
 
-    var cachedPromiseEntry = this._ownersIdentifierToPromise.get(ownerIdentifier);
+    var cachedPromiseEntry = this._ownersToPendingPromise.get(ownerIdentifier);
 
     if (cachedPromiseEntry != null) {
-      return cachedPromiseEntry.promise;
+      return {
+        promise: cachedPromiseEntry.promise,
+        pendingOperations: cachedPromiseEntry.pendingOperations
+      };
     }
 
     var resolve;
@@ -212,13 +217,18 @@ var RelayOperationTracker = /*#__PURE__*/function () {
       resolve = r;
     });
     !(resolve != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayOperationTracker: Expected resolver to be defined. If you' + 'are seeing this, it is likely a bug in Relay.') : invariant(false) : void 0;
+    var pendingOperations = Array.from(pendingOperationsForOwner.values());
 
-    this._ownersIdentifierToPromise.set(ownerIdentifier, {
+    this._ownersToPendingPromise.set(ownerIdentifier, {
       promise: promise,
-      resolve: resolve
+      resolve: resolve,
+      pendingOperations: pendingOperations
     });
 
-    return promise;
+    return {
+      promise: promise,
+      pendingOperations: pendingOperations
+    };
   };
 
   return RelayOperationTracker;

package/lib/store/RelayPublishQueue.js

@@ -10,7 +10,7 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var _global$ErrorUtils$ap, _global$ErrorUtils;
+var _global$ErrorUtils$ap, _global, _global$ErrorUtils;
 
 var RelayReader = require('./RelayReader');
 
@@ -26,7 +26,7 @@ var invariant = require('invariant');
 
 var warning = require("fbjs/lib/warning");
 
-var applyWithGuard = (_global$ErrorUtils$ap = (_global$ErrorUtils = global.ErrorUtils) === null || _global$ErrorUtils === void 0 ? void 0 : _global$ErrorUtils.applyWithGuard) !== null && _global$ErrorUtils$ap !== void 0 ? _global$ErrorUtils$ap : function (callback, context, args, onError, name) {
+var applyWithGuard = (_global$ErrorUtils$ap = (_global = global) === null || _global === void 0 ? void 0 : (_global$ErrorUtils = _global.ErrorUtils) === null || _global$ErrorUtils === void 0 ? void 0 : _global$ErrorUtils.applyWithGuard) !== null && _global$ErrorUtils$ap !== void 0 ? _global$ErrorUtils$ap : function (callback, context, args, onError, name) {
   return callback.apply(context, args);
 };
 /**
@@ -149,11 +149,25 @@ var RelayPublishQueue = /*#__PURE__*/function () {
   ;
 
   _proto.run = function run(sourceOperation) {
+    var runWillClearGcHold = this._appliedOptimisticUpdates === 0 && !!this._gcHold;
+    var runIsANoop = // this._pendingBackupRebase is true if an applied optimistic
+    // update has potentially been reverted or if this._pendingData is not empty.
+    !this._pendingBackupRebase && this._pendingOptimisticUpdates.size === 0 && !runWillClearGcHold;
+
     if (process.env.NODE_ENV !== "production") {
+      process.env.NODE_ENV !== "production" ? warning(!runIsANoop, 'RelayPublishQueue.run was called, but the call would have been a noop.') : void 0;
       process.env.NODE_ENV !== "production" ? warning(this._isRunning !== true, 'A store update was detected within another store update. Please ' + "make sure new store updates aren't being executed within an " + 'updater function for a different update.') : void 0;
       this._isRunning = true;
     }
 
+    if (runIsANoop) {
+      if (process.env.NODE_ENV !== "production") {
+        this._isRunning = false;
+      }
+
+      return [];
+    }
+
     if (this._pendingBackupRebase) {
       if (this._hasStoreSnapshot) {
         this._store.restore();
@@ -299,15 +313,19 @@ var RelayPublishQueue = /*#__PURE__*/function () {
             updater = optimisticUpdate.updater;
         var source = payload.source,
             fieldPayloads = payload.fieldPayloads;
-        var recordSourceSelectorProxy = new RelayRecordSourceSelectorProxy(mutator, recordSourceProxy, operation.fragment);
-        var selectorData;
 
         if (source) {
           recordSourceProxy.publishSource(source, fieldPayloads);
-          selectorData = lookupSelector(source, operation.fragment);
         }
 
         if (updater) {
+          var selectorData;
+
+          if (source) {
+            selectorData = lookupSelector(source, operation.fragment);
+          }
+
+          var recordSourceSelectorProxy = new RelayRecordSourceSelectorProxy(mutator, recordSourceProxy, operation.fragment);
           applyWithGuard(updater, null, [recordSourceSelectorProxy, selectorData], null, 'RelayPublishQueue:applyUpdates');
         }
       }

package/lib/store/RelayReader.js

@@ -14,6 +14,8 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
+var ClientID = require('./ClientID');
+
 var RelayFeatureFlags = require('../util/RelayFeatureFlags');
 
 var RelayModernRecord = require('./RelayModernRecord');
@@ -21,6 +23,7 @@ var RelayModernRecord = require('./RelayModernRecord');
 var invariant = require('invariant');
 
 var _require = require('../util/RelayConcreteNode'),
+    ACTOR_CHANGE = _require.ACTOR_CHANGE,
     CLIENT_EXTENSION = _require.CLIENT_EXTENSION,
     CONDITION = _require.CONDITION,
     DEFER = _require.DEFER,
@@ -50,14 +53,17 @@ var _require3 = require('./RelayStoreUtils'),
     getStorageKey = _require3.getStorageKey,
     getModuleComponentKey = _require3.getModuleComponentKey;
 
-var _require4 = require('./ResolverFragments'),
-    withResolverContext = _require4.withResolverContext;
+var _require4 = require('./ResolverCache'),
+    NoopResolverCache = _require4.NoopResolverCache;
+
+var _require5 = require('./ResolverFragments'),
+    withResolverContext = _require5.withResolverContext;
 
-var _require5 = require('./TypeID'),
-    generateTypeID = _require5.generateTypeID;
+var _require6 = require('./TypeID'),
+    generateTypeID = _require6.generateTypeID;
 
-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();
 }
 /**
@@ -66,7 +72,7 @@ function read(recordSource, selector) {
 
 
 var RelayReader = /*#__PURE__*/function () {
-  function RelayReader(recordSource, selector) {
+  function RelayReader(recordSource, selector, resolverCache) {
     this._isMissingData = false;
     this._isWithinUnmatchedTypeRefinement = false;
     this._missingRequiredFields = null;
@@ -75,6 +81,7 @@ var RelayReader = /*#__PURE__*/function () {
     this._seenRecords = new Set();
     this._selector = selector;
     this._variables = selector.variables;
+    this._resolverCache = resolverCache;
   }
 
   var _proto = RelayReader.prototype;
@@ -103,7 +110,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)
@@ -112,7 +127,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);
@@ -254,7 +269,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);
@@ -281,7 +296,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.
@@ -309,10 +324,6 @@ var RelayReader = /*#__PURE__*/function () {
                 // Don't know if the type implements the interface or not
                 this._isMissingData = true;
               }
-            } 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;
@@ -380,6 +391,11 @@ var RelayReader = /*#__PURE__*/function () {
 
           break;
 
+        case ACTOR_CHANGE:
+          this._readActorChange(selection, record, data);
+
+          break;
+
         default:
           selection;
           !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayReader(): Unexpected ast kind `%s`.', selection.kind) : invariant(false) : void 0;
@@ -401,44 +417,93 @@ 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._readResolverField = function _readResolverField(selection, record, data) {
+  _proto._readResolverField = function _readResolverField(field, record, data) {
     var _this = this;
 
-    var name = selection.name,
-        alias = selection.alias,
-        resolverModule = selection.resolverModule,
-        fragment = selection.fragment;
-    var key = {
-      __id: RelayModernRecord.getDataID(record),
-      __fragmentOwner: this._owner,
-      __fragments: (0, _defineProperty2["default"])({}, fragment.name, {})
-    };
-    var resolverContext = {
-      getDataForResolverFragment: function getDataForResolverFragment(singularReaderSelector) {
+    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);
 
-        var answer = (_resolverFragmentData = resolverFragmentData[FRAGMENTS_KEY]) === null || _resolverFragmentData === void 0 ? void 0 : _resolverFragmentData[fragment.name];
-        !(typeof answer === 'object' && answer !== 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 answer;
+        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 resolverResult = withResolverContext(resolverContext, function () {
-      return (// $FlowFixMe[prop-missing] - resolver module's type signature is a lie
-        resolverModule(key)
-      );
-    });
-    data[alias !== null && alias !== void 0 ? alias : name] = resolverResult;
-    return resolverResult;
+
+    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);
+    }
+
+    data[storageKey] = result;
+    return result;
   };
 
   _proto._readFlightField = function _readFlightField(field, record, data) {
@@ -518,12 +583,44 @@ var RelayReader = /*#__PURE__*/function () {
     return value;
   };
 
+  _proto._readActorChange = function _readActorChange(field, record, data) {
+    var _field$alias4;
+
+    var applicationName = (_field$alias4 = field.alias) !== null && _field$alias4 !== void 0 ? _field$alias4 : field.name;
+    var storageKey = getStorageKey(field, this._variables);
+    var externalRef = RelayModernRecord.getActorLinkedRecordID(record, storageKey);
+
+    if (externalRef == null) {
+      data[applicationName] = externalRef;
+
+      if (externalRef === undefined) {
+        this._isMissingData = true;
+      }
+
+      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 _this2 = this;
 
-    var _field$alias4;
+    var _field$alias5;
 
-    var applicationName = (_field$alias4 = field.alias) !== null && _field$alias4 !== void 0 ? _field$alias4 : field.name;
+    var applicationName = (_field$alias5 = field.alias) !== null && _field$alias5 !== void 0 ? _field$alias5 : field.name;
     var storageKey = getStorageKey(field, this._variables);
     var linkedIDs = RelayModernRecord.getLinkedRecordIDs(record, storageKey);
 
@@ -588,7 +685,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;
@@ -611,10 +708,7 @@ var RelayReader = /*#__PURE__*/function () {
 
     fragmentPointers[fragmentSpread.name] = fragmentSpread.args ? getArgumentValues(fragmentSpread.args, this._variables) : {};
     data[FRAGMENT_OWNER_KEY] = this._owner;
-
-    if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
-      data[IS_WITHIN_UNMATCHED_TYPE_REFINEMENT] = this._isWithinUnmatchedTypeRefinement;
-    }
+    data[IS_WITHIN_UNMATCHED_TYPE_REFINEMENT] = this._isWithinUnmatchedTypeRefinement;
   };
 
   _proto._createInlineDataOrResolverFragmentPointer = function _createInlineDataOrResolverFragmentPointer(fragmentSpreadOrFragment, record, data) {

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;