relay-runtime 1.7.0-rc.1 → 2.0.0

package/lib/RelayProfiler.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2013-present, Facebook, Inc.
+ * 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.
@@ -7,7 +7,6 @@
  * 
  * @format
  */
-
 'use strict';
 
 var aggregateHandlersByName = {
@@ -16,16 +15,18 @@ var aggregateHandlersByName = {
 var profileHandlersByName = {
   '*': []
 };
-
 var NOT_INVOKED = {};
-var defaultProfiler = { stop: require('fbjs/lib/emptyFunction') };
+var defaultProfiler = {
+  stop: require("fbjs/lib/emptyFunction")
+};
+
 var shouldInstrument = function shouldInstrument(name) {
-  if (process.env.NODE_ENV !== 'production') {
+  if (process.env.NODE_ENV !== "production") {
     return true;
   }
+
   return name.charAt(0) !== '@';
 };
-
 /**
  * @public
  *
@@ -58,6 +59,8 @@ var shouldInstrument = function shouldInstrument(name) {
  * methods and profilers with names that begin with `@` will only be measured
  * if `__DEV__` is true. This should be used for very hot functions.
  */
+
+
 var RelayProfiler = {
   /**
    * Instruments methods on a class or object. This re-assigns the method in
@@ -84,7 +87,6 @@ var RelayProfiler = {
     }
   },
 
-
   /**
    * Wraps the supplied function with one that provides the `attachHandler` and
    * `detachHandler` methods. Example usage:
@@ -99,19 +101,23 @@ var RelayProfiler = {
    */
   instrument: function instrument(name, originalFunction) {
     if (!shouldInstrument(name)) {
-      originalFunction.attachHandler = require('fbjs/lib/emptyFunction');
-      originalFunction.detachHandler = require('fbjs/lib/emptyFunction');
+      originalFunction.attachHandler = require("fbjs/lib/emptyFunction");
+      originalFunction.detachHandler = require("fbjs/lib/emptyFunction");
       return originalFunction;
     }
+
     if (!aggregateHandlersByName.hasOwnProperty(name)) {
       aggregateHandlersByName[name] = [];
     }
+
     var catchallHandlers = aggregateHandlersByName['*'];
     var aggregateHandlers = aggregateHandlersByName[name];
     var handlers = [];
     var contexts = [];
+
     var invokeHandlers = function invokeHandlers() {
       var context = contexts[contexts.length - 1];
+
       if (context[0]) {
         context[0]--;
         catchallHandlers[context[0]](name, invokeHandlers);
@@ -125,8 +131,10 @@ var RelayProfiler = {
         context[5] = originalFunction.apply(context[3], context[4]);
       }
     };
+
     var instrumentedCallback = function instrumentedCallback() {
-      var returnValue = void 0;
+      var returnValue;
+
       if (aggregateHandlers.length === 0 && handlers.length === 0 && catchallHandlers.length === 0) {
         returnValue = originalFunction.apply(this, arguments);
       } else {
@@ -134,23 +142,27 @@ var RelayProfiler = {
         invokeHandlers();
         var context = contexts.pop();
         returnValue = context[5];
+
         if (returnValue === NOT_INVOKED) {
           throw new Error('RelayProfiler: Handler did not invoke original function.');
         }
       }
+
       return returnValue;
     };
+
     instrumentedCallback.attachHandler = function (handler) {
       handlers.push(handler);
     };
+
     instrumentedCallback.detachHandler = function (handler) {
-      require('fbjs/lib/removeFromArray')(handlers, handler);
+      require("fbjs/lib/removeFromArray")(handlers, handler);
     };
+
     instrumentedCallback.displayName = '(instrumented ' + name + ')';
     return instrumentedCallback;
   },
 
-
   /**
    * Attaches a handler to all methods instrumented with the supplied name.
    *
@@ -172,23 +184,22 @@ var RelayProfiler = {
       if (!aggregateHandlersByName.hasOwnProperty(name)) {
         aggregateHandlersByName[name] = [];
       }
+
       aggregateHandlersByName[name].push(handler);
     }
   },
 
-
   /**
    * Detaches a handler attached via `attachAggregateHandler`.
    */
   detachAggregateHandler: function detachAggregateHandler(name, handler) {
     if (shouldInstrument(name)) {
       if (aggregateHandlersByName.hasOwnProperty(name)) {
-        require('fbjs/lib/removeFromArray')(aggregateHandlersByName[name], handler);
+        require("fbjs/lib/removeFromArray")(aggregateHandlersByName[name], handler);
       }
     }
   },
 
-
   /**
    * Instruments profiling for arbitrarily asynchronous code by a name.
    *
@@ -205,29 +216,32 @@ var RelayProfiler = {
   profile: function profile(name, state) {
     var hasCatchAllHandlers = profileHandlersByName['*'].length > 0;
     var hasNamedHandlers = profileHandlersByName.hasOwnProperty(name);
+
     if (hasNamedHandlers || hasCatchAllHandlers) {
       var profileHandlers = hasNamedHandlers && hasCatchAllHandlers ? profileHandlersByName[name].concat(profileHandlersByName['*']) : hasNamedHandlers ? profileHandlersByName[name] : profileHandlersByName['*'];
-      var stopHandlers = void 0;
+      var stopHandlers;
+
       for (var ii = profileHandlers.length - 1; ii >= 0; ii--) {
         var profileHandler = profileHandlers[ii];
         var stopHandler = profileHandler(name, state);
         stopHandlers = stopHandlers || [];
         stopHandlers.unshift(stopHandler);
       }
+
       return {
-        stop: function stop() {
+        stop: function stop(error) {
           if (stopHandlers) {
             stopHandlers.forEach(function (stopHandler) {
-              return stopHandler();
+              return stopHandler(error);
             });
           }
         }
       };
     }
+
     return defaultProfiler;
   },
 
-
   /**
    * Attaches a handler to profiles with the supplied name. You can also
    * attach to the special name '*' which is a catch all.
@@ -237,21 +251,20 @@ var RelayProfiler = {
       if (!profileHandlersByName.hasOwnProperty(name)) {
         profileHandlersByName[name] = [];
       }
+
       profileHandlersByName[name].push(handler);
     }
   },
 
-
   /**
    * Detaches a handler attached via `attachProfileHandler`.
    */
   detachProfileHandler: function detachProfileHandler(name, handler) {
     if (shouldInstrument(name)) {
       if (profileHandlersByName.hasOwnProperty(name)) {
-        require('fbjs/lib/removeFromArray')(profileHandlersByName[name], handler);
+        require("fbjs/lib/removeFromArray")(profileHandlersByName[name], handler);
       }
     }
   }
 };
-
 module.exports = RelayProfiler;

package/lib/RelayPublishQueue.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2013-present, Facebook, Inc.
+ * 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.
@@ -7,13 +7,8 @@
  *  strict-local
  * @format
  */
-
 'use strict';
 
-var _classCallCheck3 = _interopRequireDefault(require('babel-runtime/helpers/classCallCheck'));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
 /**
  * Coordinates the concurrent modification of a `Store` due to optimistic and
  * non-revertable client updates and server payloads:
@@ -25,18 +20,22 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'd
  *   - Executes handlers for "handle" fields.
  *   - Reverts and reapplies pending optimistic updates.
  */
-var RelayPublishQueue = function () {
-  // Optimistic updaters to add with the next `run()`.
-
-  // Payloads to apply or Sources to publish to the store with the next `run()`.
-
-
+var RelayPublishQueue =
+/*#__PURE__*/
+function () {
   // A "negative" of all applied updaters. It can be published to the store to
   // undo them in order to re-apply some of them for a rebase.
+  // True if the next `run()` should apply the backup and rerun all optimistic
+  // updates performing a rebase.
+  // Payloads to apply or Sources to publish to the store with the next `run()`.
+  // Updaters to apply with the next `run()`. These mutate the store and should
+  // typically only mutate client schema extensions.
+  // Optimistic updaters to add with the next `run()`.
+  // 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) {
-    (0, _classCallCheck3['default'])(this, RelayPublishQueue);
-
-    this._backup = new (require('./RelayInMemoryRecordSource'))();
+    this._backup = new (require("./RelayInMemoryRecordSource"))();
     this._handlerProvider = handlerProvider || null;
     this._pendingBackupRebase = false;
     this._pendingUpdaters = new Set();
@@ -44,80 +43,94 @@ var RelayPublishQueue = function () {
     this._pendingOptimisticUpdates = new Set();
     this._store = store;
     this._appliedOptimisticUpdates = new Set();
+    this._gcHold = null;
   }
-
   /**
    * Schedule applying an optimistic updates on the next `run()`.
    */
 
-  // Optimistic updaters that are already added and might be rerun in order to
-  // rebase them.
-
-  // Updaters to apply with the next `run()`. These mutate the store and should
-  // typically only mutate client schema extensions.
 
-  // True if the next `run()` should apply the backup and rerun all optimistic
-  // updates performing a rebase.
+  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;
 
-  RelayPublishQueue.prototype.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._pendingOptimisticUpdates.add(updater);
   };
-
   /**
    * Schedule reverting an optimistic updates on the next `run()`.
    */
 
 
-  RelayPublishQueue.prototype.revertUpdate = function revertUpdate(updater) {
+  _proto.revertUpdate = function revertUpdate(updater) {
     if (this._pendingOptimisticUpdates.has(updater)) {
       // Reverted before it was applied
-      this._pendingOptimisticUpdates['delete'](updater);
+      this._pendingOptimisticUpdates["delete"](updater);
     } else if (this._appliedOptimisticUpdates.has(updater)) {
       this._pendingBackupRebase = true;
-      this._appliedOptimisticUpdates['delete'](updater);
+
+      this._appliedOptimisticUpdates["delete"](updater);
     }
   };
-
   /**
    * Schedule a revert of all optimistic updates on the next `run()`.
    */
 
 
-  RelayPublishQueue.prototype.revertAll = function revertAll() {
+  _proto.revertAll = function revertAll() {
     this._pendingBackupRebase = true;
+
     this._pendingOptimisticUpdates.clear();
+
     this._appliedOptimisticUpdates.clear();
   };
-
   /**
    * Schedule applying a payload to the store on the next `run()`.
    */
 
 
-  RelayPublishQueue.prototype.commitPayload = function commitPayload(operation, _ref, updater) {
+  _proto.commitPayload = function commitPayload(operation, _ref, updater) {
     var fieldPayloads = _ref.fieldPayloads,
         source = _ref.source;
-
     this._pendingBackupRebase = true;
+
     this._pendingData.add({
       kind: 'payload',
-      payload: { fieldPayloads: fieldPayloads, operation: operation, source: source, updater: updater }
+      payload: {
+        fieldPayloads: fieldPayloads,
+        operation: operation,
+        source: source,
+        updater: updater
+      }
     });
   };
 
+  _proto.commitRelayPayload = function commitRelayPayload(_ref2) {
+    var fieldPayloads = _ref2.fieldPayloads,
+        source = _ref2.source;
+    this._pendingBackupRebase = true;
+
+    this._pendingData.add({
+      kind: 'payload',
+      payload: {
+        fieldPayloads: fieldPayloads,
+        operation: null,
+        source: source,
+        updater: null
+      }
+    });
+  };
   /**
    * Schedule an updater to mutate the store on the next `run()` typically to
    * update client schema fields.
    */
 
 
-  RelayPublishQueue.prototype.commitUpdate = function commitUpdate(updater) {
+  _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
@@ -125,160 +138,192 @@ var RelayPublishQueue = function () {
    */
 
 
-  RelayPublishQueue.prototype.commitSource = function commitSource(source) {
+  _proto.commitSource = function commitSource(source) {
     this._pendingBackupRebase = true;
-    this._pendingData.add({ kind: 'source', source: source });
-  };
 
+    this._pendingData.add({
+      kind: 'source',
+      source: source
+    });
+  };
   /**
    * Execute all queued up operations from the other public methods.
    */
 
 
-  RelayPublishQueue.prototype.run = function run() {
+  _proto.run = function run() {
     if (this._pendingBackupRebase && this._backup.size()) {
       this._store.publish(this._backup);
-      this._backup = new (require('./RelayInMemoryRecordSource'))();
+
+      this._backup = new (require("./RelayInMemoryRecordSource"))();
     }
+
     this._commitData();
+
     this._commitUpdaters();
+
     this._applyUpdates();
+
     this._pendingBackupRebase = false;
+
+    if (this._appliedOptimisticUpdates.size > 0) {
+      if (!this._gcHold) {
+        this._gcHold = this._store.holdGC();
+      }
+    } else {
+      if (this._gcHold) {
+        this._gcHold.dispose();
+
+        this._gcHold = null;
+      }
+    }
+
     this._store.notify();
   };
 
-  RelayPublishQueue.prototype._getSourceFromPayload = function _getSourceFromPayload(payload) {
+  _proto._getSourceFromPayload = function _getSourceFromPayload(payload) {
     var _this = this;
 
     var fieldPayloads = payload.fieldPayloads,
         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 (require('./RelayRecordSourceMutator'))(this._store.getSource(), source);
-    var store = new (require('./RelayRecordSourceProxy'))(mutator);
-    var selectorStore = new (require('./RelayRecordSourceSelectorProxy'))(store, operation.fragment);
     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" ? 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.update(store, fieldPayload);
       });
     }
+
     if (updater) {
-      var selectorData = lookupSelector(source, operation.fragment);
+      var selector = operation === null || operation === void 0 ? void 0 : operation.fragment;
+      !(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, operation);
       updater(selectorStore, selectorData);
     }
+
     return source;
   };
 
-  RelayPublishQueue.prototype._commitData = function _commitData() {
+  _proto._commitData = function _commitData() {
     var _this2 = this;
 
     if (!this._pendingData.size) {
       return;
     }
+
     this._pendingData.forEach(function (data) {
-      var source = void 0;
+      var source;
+
       if (data.kind === 'payload') {
         source = _this2._getSourceFromPayload(data.payload);
       } else {
         source = data.source;
       }
+
       _this2._store.publish(source);
     });
+
     this._pendingData.clear();
   };
 
-  RelayPublishQueue.prototype._commitUpdaters = function _commitUpdaters() {
+  _proto._commitUpdaters = function _commitUpdaters() {
     var _this3 = this;
 
     if (!this._pendingUpdaters.size) {
       return;
     }
-    var sink = new (require('./RelayInMemoryRecordSource'))();
+
+    var sink = new (require("./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 (require("./RelayRecordSourceMutator"))(_this3._store.getSource(), sink);
+      var store = new (require("./RelayRecordSourceProxy"))(mutator);
+
+      require("fbjs/lib/ErrorUtils").applyWithGuard(updater, null, [store], null, 'RelayPublishQueue:commitUpdaters');
     });
+
     this._store.publish(sink);
+
     this._pendingUpdaters.clear();
   };
 
-  RelayPublishQueue.prototype._applyUpdates = function _applyUpdates() {
+  _proto._applyUpdates = function _applyUpdates() {
     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);
+      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
 
-      // rerun all updaters in case we are running a rebase
       if (this._pendingBackupRebase && this._appliedOptimisticUpdates.size) {
         this._appliedOptimisticUpdates.forEach(function (optimisticUpdate) {
           if (optimisticUpdate.operation) {
             var selectorStoreUpdater = optimisticUpdate.selectorStoreUpdater,
-                _operation = optimisticUpdate.operation,
+                operation = optimisticUpdate.operation,
                 response = optimisticUpdate.response;
+            var selectorStore = store.commitPayload(operation, response); // TODO: Fix commitPayload so we don't have to run normalize twice
 
-            var selectorStore = store.commitPayload(_operation, response);
-            // TODO: Fix commitPayload so we don't have to run normalize twice
-            var selectorData = void 0,
-                _source = void 0;
-            if (response) {
-              var _normalizeRelayPayloa = require('./normalizeRelayPayload')(_operation.root, response);
+            var selectorData, source;
 
-              _source = _normalizeRelayPayloa.source;
+            if (response) {
+              var _normalizeRelayPayloa = require("./normalizeRelayPayload")(operation.root, response);
 
-              selectorData = lookupSelector(_source, _operation.fragment);
+              source = _normalizeRelayPayloa.source;
+              selectorData = lookupSelector(source, operation.fragment, operation);
             }
-            selectorStoreUpdater && require('fbjs/lib/ErrorUtils').applyWithGuard(selectorStoreUpdater, null, [selectorStore, selectorData], null, 'RelayPublishQueue:applyUpdates');
+
+            selectorStoreUpdater && require("fbjs/lib/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');
+            require("fbjs/lib/ErrorUtils").applyWithGuard(storeUpdater, null, [store], null, 'RelayPublishQueue:applyUpdates');
           } else {
-            var _source2 = optimisticUpdate.source,
-                _fieldPayloads = optimisticUpdate.fieldPayloads;
-
-            store.publishSource(_source2, _fieldPayloads);
+            var _source = optimisticUpdate.source,
+                fieldPayloads = optimisticUpdate.fieldPayloads;
+            store.publishSource(_source, fieldPayloads);
           }
         });
-      }
+      } // apply any new updaters
+
 
-      // apply any new updaters
       if (this._pendingOptimisticUpdates.size) {
         this._pendingOptimisticUpdates.forEach(function (optimisticUpdate) {
           if (optimisticUpdate.operation) {
             var selectorStoreUpdater = optimisticUpdate.selectorStoreUpdater,
-                _operation2 = optimisticUpdate.operation,
+                operation = optimisticUpdate.operation,
                 response = optimisticUpdate.response;
+            var selectorStore = store.commitPayload(operation, response); // TODO: Fix commitPayload so we don't have to run normalize twice
 
-            var selectorStore = store.commitPayload(_operation2, response);
-            // TODO: Fix commitPayload so we don't have to run normalize twice
-            var selectorData = void 0,
-                _source3 = void 0;
-            if (response) {
-              var _normalizeRelayPayloa2 = require('./normalizeRelayPayload')(_operation2.root, response);
+            var selectorData, source;
 
-              _source3 = _normalizeRelayPayloa2.source;
+            if (response) {
+              var _normalizeRelayPayloa2 = require("./normalizeRelayPayload")(operation.root, response);
 
-              selectorData = lookupSelector(_source3, _operation2.fragment);
+              source = _normalizeRelayPayloa2.source;
+              selectorData = lookupSelector(source, operation.fragment, operation);
             }
-            selectorStoreUpdater && require('fbjs/lib/ErrorUtils').applyWithGuard(selectorStoreUpdater, null, [selectorStore, selectorData], null, 'RelayPublishQueue:applyUpdates');
+
+            selectorStoreUpdater && require("fbjs/lib/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');
+            require("fbjs/lib/ErrorUtils").applyWithGuard(storeUpdater, null, [store], null, 'RelayPublishQueue:applyUpdates');
           } else {
-            var _source4 = optimisticUpdate.source,
-                _fieldPayloads2 = optimisticUpdate.fieldPayloads;
-
-            store.publishSource(_source4, _fieldPayloads2);
+            var _source2 = optimisticUpdate.source,
+                fieldPayloads = optimisticUpdate.fieldPayloads;
+            store.publishSource(_source2, fieldPayloads);
           }
+
           _this4._appliedOptimisticUpdates.add(optimisticUpdate);
         });
+
         this._pendingOptimisticUpdates.clear();
       }
 
@@ -289,14 +334,17 @@ var RelayPublishQueue = function () {
   return RelayPublishQueue;
 }();
 
-function lookupSelector(source, selector) {
-  var selectorData = require('./RelayReader').read(source, selector).data;
-  if (process.env.NODE_ENV !== 'production') {
-    var deepFreeze = require('./deepFreeze');
+function lookupSelector(source, selector, owner) {
+  var selectorData = require("./RelayReader").read(source, selector, owner).data;
+
+  if (process.env.NODE_ENV !== "production") {
+    var deepFreeze = require("./deepFreeze");
+
     if (selectorData) {
       deepFreeze(selectorData);
     }
   }
+
   return selectorData;
 }