relay-runtime 2.0.0-rc.2 → 5.0.0

package/lib/RelayOperationTracker.js

@@ -0,0 +1,265 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+'use strict';
+
+var invariant = require("fbjs/lib/invariant");
+
+var RelayOperationTracker =
+/*#__PURE__*/
+function () {
+  function RelayOperationTracker() {
+    this._ownersToPendingOperations = new Map();
+    this._pendingOperationsToOwners = new Map();
+    this._ownersToPromise = new Map();
+  }
+  /**
+   * Update the map of current processing operations with the set of
+   * affected owners and notify subscribers
+   */
+
+
+  var _proto = RelayOperationTracker.prototype;
+
+  _proto.update = function update(pendingOperation, affectedOwners) {
+    if (affectedOwners.size === 0) {
+      return;
+    }
+
+    var newlyAffectedOwners = new Set();
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = affectedOwners[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var owner = _step.value;
+
+        var pendingOperationsAffectingOwner = this._ownersToPendingOperations.get(owner);
+
+        if (pendingOperationsAffectingOwner != null) {
+          // In this case the `owner` 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(pendingOperation)) {
+            pendingOperationsAffectingOwner.add(pendingOperation);
+            newlyAffectedOwners.add(owner);
+          }
+        } else {
+          // This is a new `owner` that is affected by the operation
+          this._ownersToPendingOperations.set(owner, new Set([pendingOperation]));
+
+          newlyAffectedOwners.add(owner);
+        }
+      } // No new owners were affected by this operation, we may stop here
+
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator["return"] != null) {
+          _iterator["return"]();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+
+    if (newlyAffectedOwners.size === 0) {
+      return;
+    } // But, if some owners were affected we need to add them to
+    // the `_pendingOperationsToOwners` set
+
+
+    var ownersAffectedByOperation = this._pendingOperationsToOwners.get(pendingOperation) || new Set();
+    var _iteratorNormalCompletion2 = true;
+    var _didIteratorError2 = false;
+    var _iteratorError2 = undefined;
+
+    try {
+      for (var _iterator2 = newlyAffectedOwners[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        var _owner = _step2.value;
+
+        this._resolveOwnerResolvers(_owner);
+
+        ownersAffectedByOperation.add(_owner);
+      }
+    } catch (err) {
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion2 && _iterator2["return"] != null) {
+          _iterator2["return"]();
+        }
+      } finally {
+        if (_didIteratorError2) {
+          throw _iteratorError2;
+        }
+      }
+    }
+
+    this._pendingOperationsToOwners.set(pendingOperation, ownersAffectedByOperation);
+  }
+  /**
+   * Once pending operation is completed we need to remove it
+   * from all tracking maps
+   */
+  ;
+
+  _proto.complete = function complete(pendingOperation) {
+    var affectedOwners = this._pendingOperationsToOwners.get(pendingOperation);
+
+    if (affectedOwners == null) {
+      return;
+    } // These were the owners affected only by `pendingOperation`
+
+
+    var completedOwners = new Set(); // These were the owners affected by `pendingOperation`
+    // and some other operations
+
+    var updatedOwners = new Set();
+    var _iteratorNormalCompletion3 = true;
+    var _didIteratorError3 = false;
+    var _iteratorError3 = undefined;
+
+    try {
+      for (var _iterator3 = affectedOwners[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+        var owner = _step3.value;
+
+        var pendingOperationsAffectingOwner = this._ownersToPendingOperations.get(owner);
+
+        if (!pendingOperationsAffectingOwner) {
+          continue;
+        }
+
+        pendingOperationsAffectingOwner["delete"](pendingOperation);
+
+        if (pendingOperationsAffectingOwner.size > 0) {
+          updatedOwners.add(owner);
+        } else {
+          completedOwners.add(owner);
+        }
+      } // Complete subscriptions for all owners, affected by `pendingOperation`
+
+    } catch (err) {
+      _didIteratorError3 = true;
+      _iteratorError3 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion3 && _iterator3["return"] != null) {
+          _iterator3["return"]();
+        }
+      } finally {
+        if (_didIteratorError3) {
+          throw _iteratorError3;
+        }
+      }
+    }
+
+    var _iteratorNormalCompletion4 = true;
+    var _didIteratorError4 = false;
+    var _iteratorError4 = undefined;
+
+    try {
+      for (var _iterator4 = completedOwners[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+        var _owner2 = _step4.value;
+
+        this._resolveOwnerResolvers(_owner2);
+
+        this._ownersToPendingOperations["delete"](_owner2);
+      } // Update all owner that were updated by `pendingOperation` but still
+      // are affected by other operations
+
+    } catch (err) {
+      _didIteratorError4 = true;
+      _iteratorError4 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion4 && _iterator4["return"] != null) {
+          _iterator4["return"]();
+        }
+      } finally {
+        if (_didIteratorError4) {
+          throw _iteratorError4;
+        }
+      }
+    }
+
+    var _iteratorNormalCompletion5 = true;
+    var _didIteratorError5 = false;
+    var _iteratorError5 = undefined;
+
+    try {
+      for (var _iterator5 = updatedOwners[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+        var _owner3 = _step5.value;
+
+        this._resolveOwnerResolvers(_owner3);
+      } // Finally, remove pending operation
+
+    } catch (err) {
+      _didIteratorError5 = true;
+      _iteratorError5 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion5 && _iterator5["return"] != null) {
+          _iterator5["return"]();
+        }
+      } finally {
+        if (_didIteratorError5) {
+          throw _iteratorError5;
+        }
+      }
+    }
+
+    this._pendingOperationsToOwners["delete"](pendingOperation);
+  };
+
+  _proto._resolveOwnerResolvers = function _resolveOwnerResolvers(owner) {
+    var promiseEntry = this._ownersToPromise.get(owner);
+
+    if (promiseEntry != null) {
+      promiseEntry.resolve();
+    }
+
+    this._ownersToPromise["delete"](owner);
+  };
+
+  _proto.getPromiseForPendingOperationsAffectingOwner = function getPromiseForPendingOperationsAffectingOwner(owner) {
+    if (!this._ownersToPendingOperations.has(owner)) {
+      return null;
+    }
+
+    var cachedPromiseEntry = this._ownersToPromise.get(owner);
+
+    if (cachedPromiseEntry != null) {
+      return cachedPromiseEntry.promise;
+    }
+
+    var resolve;
+    var promise = new Promise(function (r) {
+      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;
+
+    this._ownersToPromise.set(owner, {
+      promise: promise,
+      resolve: resolve
+    });
+
+    return promise;
+  };
+
+  return RelayOperationTracker;
+}();
+
+module.exports = RelayOperationTracker;

package/lib/RelayProfiler.js

@@ -9,6 +9,10 @@
  */
 'use strict';
 
+var emptyFunction = require("fbjs/lib/emptyFunction");
+
+var removeFromArray = require("fbjs/lib/removeFromArray");
+
 var aggregateHandlersByName = {
   '*': []
 };
@@ -17,7 +21,7 @@ var profileHandlersByName = {
 };
 var NOT_INVOKED = {};
 var defaultProfiler = {
-  stop: require("fbjs/lib/emptyFunction")
+  stop: emptyFunction
 };
 
 var shouldInstrument = function shouldInstrument(name) {
@@ -101,8 +105,8 @@ var RelayProfiler = {
    */
   instrument: function instrument(name, originalFunction) {
     if (!shouldInstrument(name)) {
-      originalFunction.attachHandler = require("fbjs/lib/emptyFunction");
-      originalFunction.detachHandler = require("fbjs/lib/emptyFunction");
+      originalFunction.attachHandler = emptyFunction;
+      originalFunction.detachHandler = emptyFunction;
       return originalFunction;
     }
 
@@ -156,7 +160,7 @@ var RelayProfiler = {
     };
 
     instrumentedCallback.detachHandler = function (handler) {
-      require("fbjs/lib/removeFromArray")(handlers, handler);
+      removeFromArray(handlers, handler);
     };
 
     instrumentedCallback.displayName = '(instrumented ' + name + ')';
@@ -195,7 +199,7 @@ var RelayProfiler = {
   detachAggregateHandler: function detachAggregateHandler(name, handler) {
     if (shouldInstrument(name)) {
       if (aggregateHandlersByName.hasOwnProperty(name)) {
-        require("fbjs/lib/removeFromArray")(aggregateHandlersByName[name], handler);
+        removeFromArray(aggregateHandlersByName[name], handler);
       }
     }
   },
@@ -262,7 +266,7 @@ var RelayProfiler = {
   detachProfileHandler: function detachProfileHandler(name, handler) {
     if (shouldInstrument(name)) {
       if (profileHandlersByName.hasOwnProperty(name)) {
-        require("fbjs/lib/removeFromArray")(profileHandlersByName[name], handler);
+        removeFromArray(profileHandlersByName[name], handler);
       }
     }
   }

package/lib/RelayPublishQueue.js

@@ -4,11 +4,27 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict-local
+ * 
  * @format
  */
 'use strict';
 
+var ErrorUtils = require("fbjs/lib/ErrorUtils");
+
+var RelayInMemoryRecordSource = require("./RelayInMemoryRecordSource");
+
+var RelayReader = require("./RelayReader");
+
+var RelayRecordSourceMutator = require("./RelayRecordSourceMutator");
+
+var RelayRecordSourceProxy = require("./RelayRecordSourceProxy");
+
+var RelayRecordSourceSelectorProxy = require("./RelayRecordSourceSelectorProxy");
+
+var invariant = require("fbjs/lib/invariant");
+
+var normalizeRelayPayload = require("./normalizeRelayPayload");
+
 /**
  * Coordinates the concurrent modification of a `Store` due to optimistic and
  * non-revertable client updates and server payloads:
@@ -34,8 +50,8 @@ function () {
   // Optimistic updaters that are already added and might be rerun in order to
   // rebase them.
   // Garbage collection hold, should rerun gc on dispose
-  function RelayPublishQueue(store, handlerProvider) {
-    this._backup = new (require("./RelayInMemoryRecordSource"))();
+  function RelayPublishQueue(store, handlerProvider, getDataID) {
+    this._backup = new RelayInMemoryRecordSource();
     this._handlerProvider = handlerProvider || null;
     this._pendingBackupRebase = false;
     this._pendingUpdaters = new Set();
@@ -44,6 +60,7 @@ function () {
     this._store = store;
     this._appliedOptimisticUpdates = new Set();
     this._gcHold = null;
+    this._getDataID = getDataID;
   }
   /**
    * Schedule applying an optimistic updates on the next `run()`.
@@ -53,14 +70,14 @@ function () {
   var _proto = RelayPublishQueue.prototype;
 
   _proto.applyUpdate = function applyUpdate(updater) {
-    !(!this._appliedOptimisticUpdates.has(updater) && !this._pendingOptimisticUpdates.has(updater)) ? process.env.NODE_ENV !== "production" ? require("fbjs/lib/invariant")(false, 'RelayPublishQueue: Cannot apply the same update function more than ' + 'once concurrently.') : require("fbjs/lib/invariant")(false) : void 0;
+    !(!this._appliedOptimisticUpdates.has(updater) && !this._pendingOptimisticUpdates.has(updater)) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayPublishQueue: Cannot apply the same update function more than ' + 'once concurrently.') : invariant(false) : void 0;
 
     this._pendingOptimisticUpdates.add(updater);
-  };
+  }
   /**
    * Schedule reverting an optimistic updates on the next `run()`.
    */
-
+  ;
 
   _proto.revertUpdate = function revertUpdate(updater) {
     if (this._pendingOptimisticUpdates.has(updater)) {
@@ -71,11 +88,11 @@ function () {
 
       this._appliedOptimisticUpdates["delete"](updater);
     }
-  };
+  }
   /**
    * Schedule a revert of all optimistic updates on the next `run()`.
    */
-
+  ;
 
   _proto.revertAll = function revertAll() {
     this._pendingBackupRebase = true;
@@ -83,11 +100,11 @@ function () {
     this._pendingOptimisticUpdates.clear();
 
     this._appliedOptimisticUpdates.clear();
-  };
+  }
   /**
    * Schedule applying a payload to the store on the next `run()`.
    */
-
+  ;
 
   _proto.commitPayload = function commitPayload(operation, _ref, updater) {
     var fieldPayloads = _ref.fieldPayloads,
@@ -98,7 +115,7 @@ function () {
       kind: 'payload',
       payload: {
         fieldPayloads: fieldPayloads,
-        selector: operation.fragment,
+        operation: operation,
         source: source,
         updater: updater
       }
@@ -114,29 +131,29 @@ function () {
       kind: 'payload',
       payload: {
         fieldPayloads: fieldPayloads,
-        selector: null,
+        operation: null,
         source: source,
         updater: null
       }
     });
-  };
+  }
   /**
    * Schedule an updater to mutate the store on the next `run()` typically to
    * update client schema fields.
    */
-
+  ;
 
   _proto.commitUpdate = function commitUpdate(updater) {
     this._pendingBackupRebase = true;
 
     this._pendingUpdaters.add(updater);
-  };
+  }
   /**
    * Schedule a publish to the store from the provided source on the next
    * `run()`. As an example, to update the store with substituted fields that
    * are missing in the store.
    */
-
+  ;
 
   _proto.commitSource = function commitSource(source) {
     this._pendingBackupRebase = true;
@@ -145,17 +162,17 @@ function () {
       kind: 'source',
       source: source
     });
-  };
+  }
   /**
    * Execute all queued up operations from the other public methods.
    */
-
+  ;
 
   _proto.run = function run() {
     if (this._pendingBackupRebase && this._backup.size()) {
       this._store.publish(this._backup);
 
-      this._backup = new (require("./RelayInMemoryRecordSource"))();
+      this._backup = new RelayInMemoryRecordSource();
     }
 
     this._commitData();
@@ -178,32 +195,33 @@ function () {
       }
     }
 
-    this._store.notify();
+    return this._store.notify();
   };
 
   _proto._getSourceFromPayload = function _getSourceFromPayload(payload) {
     var _this = this;
 
     var fieldPayloads = payload.fieldPayloads,
-        selector = payload.selector,
+        operation = payload.operation,
         source = payload.source,
         updater = payload.updater;
-    var mutator = new (require("./RelayRecordSourceMutator"))(this._store.getSource(), source);
-    var store = new (require("./RelayRecordSourceProxy"))(mutator);
+    var mutator = new RelayRecordSourceMutator(this._store.getSource(), source);
+    var store = new RelayRecordSourceProxy(mutator, this._getDataID);
 
     if (fieldPayloads && fieldPayloads.length) {
       fieldPayloads.forEach(function (fieldPayload) {
         var handler = _this._handlerProvider && _this._handlerProvider(fieldPayload.handle);
 
-        !handler ? process.env.NODE_ENV !== "production" ? require("fbjs/lib/invariant")(false, 'RelayModernEnvironment: Expected a handler to be provided for ' + 'handle `%s`.', fieldPayload.handle) : require("fbjs/lib/invariant")(false) : void 0;
+        !handler ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected a handler to be provided for ' + 'handle `%s`.', fieldPayload.handle) : invariant(false) : void 0;
         handler.update(store, fieldPayload);
       });
     }
 
     if (updater) {
-      !(selector != null) ? process.env.NODE_ENV !== "production" ? require("fbjs/lib/invariant")(false, 'RelayModernEnvironment: Expected a selector to be provided with updater function.') : require("fbjs/lib/invariant")(false) : void 0;
-      var selectorStore = new (require("./RelayRecordSourceSelectorProxy"))(store, selector);
-      var selectorData = lookupSelector(source, selector);
+      var selector = operation === null || operation === void 0 ? void 0 : operation.fragment;
+      !(selector != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected a selector to be provided with updater function.') : invariant(false) : void 0;
+      var selectorStore = new RelayRecordSourceSelectorProxy(store, selector);
+      var selectorData = lookupSelector(source, selector, operation);
       updater(selectorStore, selectorData);
     }
 
@@ -239,13 +257,12 @@ function () {
       return;
     }
 
-    var sink = new (require("./RelayInMemoryRecordSource"))();
+    var sink = new RelayInMemoryRecordSource();
 
     this._pendingUpdaters.forEach(function (updater) {
-      var mutator = new (require("./RelayRecordSourceMutator"))(_this3._store.getSource(), sink);
-      var store = new (require("./RelayRecordSourceProxy"))(mutator);
-
-      require("fbjs/lib/ErrorUtils").applyWithGuard(updater, null, [store], null, 'RelayPublishQueue:commitUpdaters');
+      var mutator = new RelayRecordSourceMutator(_this3._store.getSource(), sink);
+      var store = new RelayRecordSourceProxy(mutator, _this3._getDataID);
+      ErrorUtils.applyWithGuard(updater, null, [store], null, 'RelayPublishQueue:commitUpdaters');
     });
 
     this._store.publish(sink);
@@ -257,9 +274,9 @@ function () {
     var _this4 = this;
 
     if (this._pendingOptimisticUpdates.size || this._pendingBackupRebase && this._appliedOptimisticUpdates.size) {
-      var sink = new (require("./RelayInMemoryRecordSource"))();
-      var mutator = new (require("./RelayRecordSourceMutator"))(this._store.getSource(), sink, this._backup);
-      var store = new (require("./RelayRecordSourceProxy"))(mutator, this._handlerProvider); // rerun all updaters in case we are running a rebase
+      var sink = new RelayInMemoryRecordSource();
+      var mutator = new RelayRecordSourceMutator(this._store.getSource(), sink, this._backup);
+      var store = new RelayRecordSourceProxy(mutator, this._getDataID, this._handlerProvider); // rerun all updaters in case we are running a rebase
 
       if (this._pendingBackupRebase && this._appliedOptimisticUpdates.size) {
         this._appliedOptimisticUpdates.forEach(function (optimisticUpdate) {
@@ -272,17 +289,18 @@ function () {
             var selectorData, source;
 
             if (response) {
-              var _normalizeRelayPayloa = require("./normalizeRelayPayload")(operation.root, response);
+              var _normalizeRelayPayloa = normalizeRelayPayload(operation.root, response, null, {
+                getDataID: _this4._getDataID
+              });
 
               source = _normalizeRelayPayloa.source;
-              selectorData = lookupSelector(source, operation.fragment);
+              selectorData = lookupSelector(source, operation.fragment, operation);
             }
 
-            selectorStoreUpdater && require("fbjs/lib/ErrorUtils").applyWithGuard(selectorStoreUpdater, null, [selectorStore, selectorData], null, 'RelayPublishQueue:applyUpdates');
+            selectorStoreUpdater && ErrorUtils.applyWithGuard(selectorStoreUpdater, null, [selectorStore, selectorData], null, 'RelayPublishQueue:applyUpdates');
           } else if (optimisticUpdate.storeUpdater) {
             var storeUpdater = optimisticUpdate.storeUpdater;
-
-            require("fbjs/lib/ErrorUtils").applyWithGuard(storeUpdater, null, [store], null, 'RelayPublishQueue:applyUpdates');
+            ErrorUtils.applyWithGuard(storeUpdater, null, [store], null, 'RelayPublishQueue:applyUpdates');
           } else {
             var _source = optimisticUpdate.source,
                 fieldPayloads = optimisticUpdate.fieldPayloads;
@@ -303,17 +321,18 @@ function () {
             var selectorData, source;
 
             if (response) {
-              var _normalizeRelayPayloa2 = require("./normalizeRelayPayload")(operation.root, response);
+              var _normalizeRelayPayloa2 = normalizeRelayPayload(operation.root, response, null, {
+                getDataID: _this4._getDataID
+              });
 
               source = _normalizeRelayPayloa2.source;
-              selectorData = lookupSelector(source, operation.fragment);
+              selectorData = lookupSelector(source, operation.fragment, operation);
             }
 
-            selectorStoreUpdater && require("fbjs/lib/ErrorUtils").applyWithGuard(selectorStoreUpdater, null, [selectorStore, selectorData], null, 'RelayPublishQueue:applyUpdates');
+            selectorStoreUpdater && ErrorUtils.applyWithGuard(selectorStoreUpdater, null, [selectorStore, selectorData], null, 'RelayPublishQueue:applyUpdates');
           } else if (optimisticUpdate.storeUpdater) {
             var storeUpdater = optimisticUpdate.storeUpdater;
-
-            require("fbjs/lib/ErrorUtils").applyWithGuard(storeUpdater, null, [store], null, 'RelayPublishQueue:applyUpdates');
+            ErrorUtils.applyWithGuard(storeUpdater, null, [store], null, 'RelayPublishQueue:applyUpdates');
           } else {
             var _source2 = optimisticUpdate.source,
                 fieldPayloads = optimisticUpdate.fieldPayloads;
@@ -333,8 +352,8 @@ function () {
   return RelayPublishQueue;
 }();
 
-function lookupSelector(source, selector) {
-  var selectorData = require("./RelayReader").read(source, selector).data;
+function lookupSelector(source, selector, owner) {
+  var selectorData = RelayReader.read(source, selector, owner).data;
 
   if (process.env.NODE_ENV !== "production") {
     var deepFreeze = require("./deepFreeze");

package/lib/RelayQueryResponseCache.js

@@ -4,12 +4,18 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict-local
+ * 
  * @format
  */
 'use strict';
 
-var _objectSpread2 = require("@babel/runtime/helpers/interopRequireDefault")(require("@babel/runtime/helpers/objectSpread"));
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));
+
+var invariant = require("fbjs/lib/invariant");
+
+var stableCopy = require("./stableCopy");
 
 /**
  * A cache for storing query responses, featuring:
@@ -22,8 +28,8 @@ function () {
   function RelayQueryResponseCache(_ref) {
     var size = _ref.size,
         ttl = _ref.ttl;
-    !(size > 0) ? process.env.NODE_ENV !== "production" ? require("fbjs/lib/invariant")(false, 'RelayQueryResponseCache: Expected the max cache size to be > 0, got ' + '`%s`.', size) : require("fbjs/lib/invariant")(false) : void 0;
-    !(ttl > 0) ? process.env.NODE_ENV !== "production" ? require("fbjs/lib/invariant")(false, 'RelayQueryResponseCache: Expected the max ttl to be > 0, got `%s`.', ttl) : require("fbjs/lib/invariant")(false) : void 0;
+    !(size > 0) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayQueryResponseCache: Expected the max cache size to be > 0, got ' + '`%s`.', size) : invariant(false) : void 0;
+    !(ttl > 0) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayQueryResponseCache: Expected the max ttl to be > 0, got `%s`.', ttl) : invariant(false) : void 0;
     this._responses = new Map();
     this._size = size;
     this._ttl = ttl;
@@ -82,7 +88,7 @@ function () {
 }();
 
 function getCacheKey(queryID, variables) {
-  return JSON.stringify(require("./stableCopy")({
+  return JSON.stringify(stableCopy({
     queryID: queryID,
     variables: variables
   }));