relay-runtime 2.0.0-rc.2 → 5.0.0

package/lib/RelayModernEnvironment.js

@@ -10,31 +10,76 @@
  */
 'use strict';
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));
+
+var DataChecker = require("./DataChecker");
+
+var RelayCore = require("./RelayCore");
+
+var RelayDefaultHandlerProvider = require("./RelayDefaultHandlerProvider");
+
+var RelayDefaultMissingFieldHandlers = require("./RelayDefaultMissingFieldHandlers");
+
+var RelayInMemoryRecordSource = require("./RelayInMemoryRecordSource");
+
+var RelayModernQueryExecutor = require("./RelayModernQueryExecutor");
+
+var RelayObservable = require("./RelayObservable");
+
+var RelayPublishQueue = require("./RelayPublishQueue");
+
+var defaultGetDataID = require("./defaultGetDataID");
+
+var invariant = require("fbjs/lib/invariant");
+
+var normalizeRelayPayload = require("./normalizeRelayPayload");
+
+var warning = require("fbjs/lib/warning");
+
 var RelayModernEnvironment =
 /*#__PURE__*/
 function () {
   function RelayModernEnvironment(config) {
     var _this = this;
 
+    var _config$UNSTABLE_DO_N, _config$publishQueue, _config$scheduler, _config$missingFieldH;
+
     this.configName = config.configName;
-    var handlerProvider = config.handlerProvider ? config.handlerProvider : require("./RelayDefaultHandlerProvider");
+    var handlerProvider = config.handlerProvider ? config.handlerProvider : RelayDefaultHandlerProvider;
     var operationLoader = config.operationLoader;
 
     if (process.env.NODE_ENV !== "production") {
       if (operationLoader != null) {
-        !(typeof operationLoader === 'object' && typeof operationLoader.get === 'function' && typeof operationLoader.load === 'function') ? process.env.NODE_ENV !== "production" ? require("fbjs/lib/invariant")(false, 'RelayModernEnvironment: Expected `operationLoader` to be an object ' + 'with get() and load() functions, got `%s`.', operationLoader) : require("fbjs/lib/invariant")(false) : void 0;
+        !(typeof operationLoader === 'object' && typeof operationLoader.get === 'function' && typeof operationLoader.load === 'function') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected `operationLoader` to be an object ' + 'with get() and load() functions, got `%s`.', operationLoader) : invariant(false) : void 0;
       }
     }
 
     this._operationLoader = operationLoader;
     this._network = config.network;
-    this._publishQueue = new (require("./RelayPublishQueue"))(config.store, handlerProvider);
+    this._getDataID = (_config$UNSTABLE_DO_N = config.UNSTABLE_DO_NOT_USE_getDataID) !== null && _config$UNSTABLE_DO_N !== void 0 ? _config$UNSTABLE_DO_N : defaultGetDataID;
+    this._publishQueue = (_config$publishQueue = config.publishQueue) !== null && _config$publishQueue !== void 0 ? _config$publishQueue : new RelayPublishQueue(config.store, handlerProvider, this._getDataID);
+    this._scheduler = (_config$scheduler = config.scheduler) !== null && _config$scheduler !== void 0 ? _config$scheduler : null;
     this._store = config.store;
-    this.unstable_internal = require("./RelayCore");
+    this.unstable_internal = (0, _objectSpread2["default"])({}, RelayCore, {
+      getOperationTracker: function getOperationTracker() {
+        return _this._operationTracker;
+      }
+    });
 
     this.__setNet = function (newNet) {
       return _this._network = newNet;
-    }; // Register this Relay Environment with Relay DevTools if it exists.
+    };
+
+    if (process.env.NODE_ENV !== "production") {
+      var _require = require("./StoreInspector"),
+          inspect = _require.inspect;
+
+      this.DEBUG_inspect = function (dataID) {
+        return inspect(_this, dataID);
+      };
+    } // Register this Relay Environment with Relay DevTools if it exists.
     // Note: this must always be the last step in the constructor.
 
 
@@ -46,8 +91,10 @@ function () {
       devToolsHook.registerEnvironment(this);
     }
 
-    if (config.missingFieldHandlers != null) {
-      this._missingFieldHandlers = config.missingFieldHandlers;
+    this._missingFieldHandlers = (_config$missingFieldH = config.missingFieldHandlers) !== null && _config$missingFieldH !== void 0 ? _config$missingFieldH : RelayDefaultMissingFieldHandlers;
+
+    if (config.operationTracker != null) {
+      this._operationTracker = config.operationTracker;
     }
   }
 
@@ -113,8 +160,12 @@ function () {
   };
 
   _proto.commitPayload = function commitPayload(operationDescriptor, payload) {
-    // Do not handle stripped nulls when commiting a payload
-    var relayPayload = require("./normalizeRelayPayload")(operationDescriptor.root, payload);
+    // Do not handle stripped nulls when committing a payload
+    var relayPayload = normalizeRelayPayload(operationDescriptor.root, payload, null
+    /* errors */
+    , {
+      getDataID: this._getDataID
+    });
 
     this._publishQueue.commitPayload(operationDescriptor, relayPayload);
 
@@ -140,9 +191,8 @@ function () {
   };
 
   _proto._checkSelectorAndHandleMissingFields = function _checkSelectorAndHandleMissingFields(selector, handlers) {
-    var target = new (require("./RelayInMemoryRecordSource"))();
-
-    var result = require("./DataChecker").check(this._store.getSource(), target, selector, handlers, this._operationLoader);
+    var target = new RelayInMemoryRecordSource();
+    var result = DataChecker.check(this._store.getSource(), target, selector, handlers, this._operationLoader, this._getDataID);
 
     if (target.size() > 0) {
       this._publishQueue.commitSource(target);
@@ -151,7 +201,7 @@ function () {
     }
 
     return result;
-  };
+  }
   /**
    * Returns an Observable of GraphQLResponse resulting from executing the
    * provided Query or Subscription operation, each result of which is then
@@ -160,7 +210,7 @@ function () {
    * Note: Observables are lazy, so calling this method will do nothing until
    * the result is subscribed to: environment.execute({...}).subscribe({...}).
    */
-
+  ;
 
   _proto.execute = function execute(_ref2) {
     var _this3 = this;
@@ -168,114 +218,26 @@ function () {
     var operation = _ref2.operation,
         cacheConfig = _ref2.cacheConfig,
         updater = _ref2.updater;
-    return require("./RelayObservable").create(function (sink) {
-      var optimisticResponse = null;
-      var subscriptions = new Set();
-
-      function start(subscription) {
-        // NOTE: store the subscription object on the observer so that it
-        // can be cleaned up in complete() or the dispose function.
-        this._subscription = subscription;
-        subscriptions.add(subscription);
-      }
+    return RelayObservable.create(function (sink) {
+      var source = _this3._network.execute(operation.node.params, operation.variables, cacheConfig || {});
 
-      function complete() {
-        subscriptions["delete"](this._subscription);
-
-        if (subscriptions.size === 0) {
-          sink.complete();
-        }
-      } // Convert each GraphQLResponse from the network to a RelayResponsePayload
-      // and process it
-
-
-      function next(response) {
-        var _response$extensions;
-
-        var payload = require("./normalizePayload")(operation, response);
-
-        var isOptimistic = ((_response$extensions = response.extensions) === null || _response$extensions === void 0 ? void 0 : _response$extensions.isOptimistic) === true;
-        processRelayPayload(payload, operation, updater, isOptimistic);
-        sink.next(response);
-      } // Each RelayResponsePayload contains both data to publish to the store
-      // immediately, but may also contain matchPayloads that need to be
-      // asynchronously normalized into RelayResponsePayloads, which may
-      // themselves have matchPayloads: this function is recursive and relies
-      // on GraphQL queries *disallowing* recursion to ensure termination.
-
-
-      var processRelayPayload = function processRelayPayload(payload) {
-        var operationDescriptor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-        var payloadUpdater = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-        var isOptimistic = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-        var matchPayloads = payload.matchPayloads;
-
-        if (matchPayloads && matchPayloads.length) {
-          var operationLoader = _this3._operationLoader;
-          !operationLoader ? process.env.NODE_ENV !== "production" ? require("fbjs/lib/invariant")(false, 'RelayModernEnvironment: Expected an operationLoader to be ' + 'configured when using `@match`.') : require("fbjs/lib/invariant")(false) : void 0;
-          matchPayloads.forEach(function (matchPayload) {
-            processMatchPayload(processRelayPayload, operationLoader, matchPayload).subscribe({
-              complete: complete,
-              error: sink.error,
-              start: start
-            });
-          });
-        }
-
-        if (isOptimistic) {
-          !(optimisticResponse === null) ? process.env.NODE_ENV !== "production" ? require("fbjs/lib/invariant")(false, 'environment.execute: only support one optimistic response per ' + 'execute.') : require("fbjs/lib/invariant")(false) : void 0;
-          optimisticResponse = {
-            source: payload.source,
-            fieldPayloads: payload.fieldPayloads
-          };
-
-          _this3._publishQueue.applyUpdate(optimisticResponse);
-
-          _this3._publishQueue.run();
-        } else {
-          if (optimisticResponse !== null) {
-            _this3._publishQueue.revertUpdate(optimisticResponse);
-
-            optimisticResponse = null;
-          }
-
-          if (operationDescriptor && payloadUpdater) {
-            _this3._publishQueue.commitPayload(operationDescriptor, payload, payloadUpdater);
-          } else {
-            _this3._publishQueue.commitRelayPayload(payload);
-          }
-
-          _this3._publishQueue.run();
-        }
-      };
-
-      var node = operation.node;
-
-      _this3._network.execute(node.params, operation.variables, cacheConfig || {}).subscribe({
-        complete: complete,
-        next: next,
-        error: sink.error,
-        start: start
+      var executor = RelayModernQueryExecutor.execute({
+        operation: operation,
+        operationLoader: _this3._operationLoader,
+        optimisticUpdate: null,
+        publishQueue: _this3._publishQueue,
+        scheduler: _this3._scheduler,
+        sink: sink,
+        source: source,
+        updater: updater,
+        operationTracker: _this3._operationTracker,
+        getDataID: _this3._getDataID
       });
-
       return function () {
-        if (subscriptions.size !== 0) {
-          subscriptions.forEach(function (sub) {
-            return sub.unsubscribe();
-          });
-          subscriptions.clear();
-        }
-
-        if (optimisticResponse !== null) {
-          _this3._publishQueue.revertUpdate(optimisticResponse);
-
-          optimisticResponse = null;
-
-          _this3._publishQueue.run();
-        }
+        return executor.cancel();
       };
     });
-  };
+  }
   /**
    * Returns an Observable of GraphQLResponse resulting from executing the
    * provided Mutation operation, the result of which is then normalized and
@@ -286,7 +248,7 @@ function () {
    * the result is subscribed to:
    * environment.executeMutation({...}).subscribe({...}).
    */
-
+  ;
 
   _proto.executeMutation = function executeMutation(_ref3) {
     var _this4 = this;
@@ -296,80 +258,84 @@ function () {
         optimisticUpdater = _ref3.optimisticUpdater,
         updater = _ref3.updater,
         uploadables = _ref3.uploadables;
-    var optimisticUpdate;
+    return RelayObservable.create(function (sink) {
+      var optimisticUpdate;
 
-    if (optimisticResponse || optimisticUpdater) {
-      optimisticUpdate = {
-        operation: operation,
-        selectorStoreUpdater: optimisticUpdater,
-        response: optimisticResponse || null
-      };
-    }
-
-    var node = operation.node;
-    return this._network.execute(node.params, operation.variables, {
-      force: true
-    }, uploadables)["do"]({
-      start: function start() {
-        if (optimisticUpdate) {
-          _this4._publishQueue.applyUpdate(optimisticUpdate);
-
-          _this4._publishQueue.run();
-        }
-      },
-      next: function next(payload) {
-        if (optimisticUpdate) {
-          _this4._publishQueue.revertUpdate(optimisticUpdate);
+      if (optimisticResponse || optimisticUpdater) {
+        var _optimisticResponse;
 
-          optimisticUpdate = undefined;
-        }
-
-        _this4._publishQueue.commitPayload(operation, require("./normalizePayload")(operation, payload), updater);
-
-        _this4._publishQueue.run();
-      },
-      error: function (_error) {
-        function error(_x) {
-          return _error.apply(this, arguments);
-        }
-
-        error.toString = function () {
-          return _error.toString();
+        optimisticUpdate = {
+          operation: operation,
+          selectorStoreUpdater: optimisticUpdater,
+          response: (_optimisticResponse = optimisticResponse) !== null && _optimisticResponse !== void 0 ? _optimisticResponse : null
         };
+      }
 
-        return error;
-      }(function (error) {
-        if (optimisticUpdate) {
-          _this4._publishQueue.revertUpdate(optimisticUpdate);
-
-          optimisticUpdate = undefined;
+      var source = _this4._network.execute(operation.node.params, operation.variables, {
+        force: true
+      }, uploadables);
 
-          _this4._publishQueue.run();
-        }
-      }),
-      unsubscribe: function unsubscribe() {
-        if (optimisticUpdate) {
-          _this4._publishQueue.revertUpdate(optimisticUpdate);
+      var executor = RelayModernQueryExecutor.execute({
+        operation: operation,
+        operationLoader: _this4._operationLoader,
+        optimisticUpdate: optimisticUpdate,
+        publishQueue: _this4._publishQueue,
+        scheduler: _this4._scheduler,
+        sink: sink,
+        source: source,
+        updater: updater,
+        operationTracker: _this4._operationTracker,
+        getDataID: _this4._getDataID
+      });
+      return function () {
+        return executor.cancel();
+      };
+    });
+  }
+  /**
+   * Returns an Observable of GraphQLResponse resulting from executing the
+   * provided Query or Subscription operation responses, the result of which is
+   * then normalized and comitted to the publish queue.
+   *
+   * Note: Observables are lazy, so calling this method will do nothing until
+   * the result is subscribed to:
+   * environment.executeWithSource({...}).subscribe({...}).
+   */
+  ;
 
-          optimisticUpdate = undefined;
+  _proto.executeWithSource = function executeWithSource(_ref4) {
+    var _this5 = this;
 
-          _this4._publishQueue.run();
-        }
-      }
+    var operation = _ref4.operation,
+        source = _ref4.source;
+    return RelayObservable.create(function (sink) {
+      var executor = RelayModernQueryExecutor.execute({
+        operation: operation,
+        operationLoader: _this5._operationLoader,
+        optimisticUpdate: null,
+        publishQueue: _this5._publishQueue,
+        scheduler: _this5._scheduler,
+        sink: sink,
+        source: source,
+        getDataID: _this5._getDataID
+      });
+      return function () {
+        return executor.cancel();
+      };
     });
-  };
+  }
   /**
    * @deprecated Use Environment.execute().subscribe()
    */
+  ;
 
-
-  _proto.sendQuery = function sendQuery(_ref4) {
-    var cacheConfig = _ref4.cacheConfig,
-        onCompleted = _ref4.onCompleted,
-        onError = _ref4.onError,
-        onNext = _ref4.onNext,
-        operation = _ref4.operation;
-    process.env.NODE_ENV !== "production" ? require("fbjs/lib/warning")(false, 'environment.sendQuery() is deprecated. Update to the latest ' + 'version of react-relay, and use environment.execute().') : void 0;
+  _proto.sendQuery = function sendQuery(_ref5) {
+    var cacheConfig = _ref5.cacheConfig,
+        onCompleted = _ref5.onCompleted,
+        onError = _ref5.onError,
+        onNext = _ref5.onNext,
+        operation = _ref5.operation;
+    process.env.NODE_ENV !== "production" ? warning(false, 'environment.sendQuery() is deprecated. Update to the latest ' + 'version of react-relay, and use environment.execute().') : void 0;
     return this.execute({
       operation: operation,
       cacheConfig: cacheConfig
@@ -378,21 +344,21 @@ function () {
       onError: onError,
       onCompleted: onCompleted
     });
-  };
+  }
   /**
    * @deprecated Use Environment.executeMutation().subscribe()
    */
-
-
-  _proto.sendMutation = function sendMutation(_ref5) {
-    var onCompleted = _ref5.onCompleted,
-        onError = _ref5.onError,
-        operation = _ref5.operation,
-        optimisticResponse = _ref5.optimisticResponse,
-        optimisticUpdater = _ref5.optimisticUpdater,
-        updater = _ref5.updater,
-        uploadables = _ref5.uploadables;
-    process.env.NODE_ENV !== "production" ? require("fbjs/lib/warning")(false, 'environment.sendMutation() is deprecated. Update to the latest ' + 'version of react-relay, and use environment.executeMutation().') : void 0;
+  ;
+
+  _proto.sendMutation = function sendMutation(_ref6) {
+    var onCompleted = _ref6.onCompleted,
+        onError = _ref6.onError,
+        operation = _ref6.operation,
+        optimisticResponse = _ref6.optimisticResponse,
+        optimisticUpdater = _ref6.optimisticUpdater,
+        updater = _ref6.updater,
+        uploadables = _ref6.uploadables;
+    process.env.NODE_ENV !== "production" ? warning(false, 'environment.sendMutation() is deprecated. Update to the latest ' + 'version of react-relay, and use environment.executeMutation().') : void 0;
     return this.executeMutation({
       operation: operation,
       optimisticResponse: optimisticResponse,
@@ -418,51 +384,7 @@ function () {
   };
 
   return RelayModernEnvironment;
-}();
-/**
- * Processes a MatchFieldPayload, asynchronously resolving the fragment,
- * using it to normalize the field data into a RelayResponsePayload.
- * Because @match fields may contain other @match fields, the result of
- * normalizing `matchPayload` may contain *other* MatchFieldPayloads:
- * the processRelayPayload() callback is responsible for publishing
- * both the normalize payload's source as well as recursively calling
- * this function for any matchPayloads it contains.
- *
- * @private
- */
-
-
-function processMatchPayload(processRelayPayload, operationLoader, matchPayload) {
-  return require("./RelayObservable").from(new Promise(function (resolve, reject) {
-    operationLoader.load(matchPayload.operationReference).then(resolve, reject);
-  })).map(function (operation) {
-    if (operation == null) {
-      return;
-    }
-
-    var selector = {
-      dataID: matchPayload.dataID,
-      variables: matchPayload.variables,
-      node: operation
-    };
-    var source = new (require("./RelayInMemoryRecordSource"))();
-
-    var matchRecord = require("./RelayModernRecord").create(matchPayload.dataID, matchPayload.typeName);
-
-    source.set(matchPayload.dataID, matchRecord);
-
-    var normalizeResult = require("./RelayResponseNormalizer").normalize(source, selector, matchPayload.data);
-
-    var relayPayload = {
-      errors: null,
-      // Errors are handled as part of the parent GraphQLResponse
-      fieldPayloads: normalizeResult.fieldPayloads,
-      matchPayloads: normalizeResult.matchPayloads,
-      source: source
-    };
-    processRelayPayload(relayPayload);
-  });
-} // Add a sigil for detection by `isRelayModernEnvironment()` to avoid a
+}(); // Add a sigil for detection by `isRelayModernEnvironment()` to avoid a
 // realm-specific instanceof check, and to aid in module tree-shaking to
 // avoid requiring all of RelayRuntime just to detect its environment.
 

package/lib/RelayModernFragmentOwner.js

@@ -0,0 +1,72 @@
+/**
+ * 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 mapObject = require("fbjs/lib/mapObject");
+
+var _require = require("./RelayStoreUtils"),
+    FRAGMENT_OWNER_KEY = _require.FRAGMENT_OWNER_KEY;
+
+function getSingularFragmentOwner(fragmentNode, fragmentRef) {
+  var _fragmentRef$FRAGMENT;
+
+  if (fragmentRef == null) {
+    return null;
+  }
+
+  !(typeof fragmentRef === 'object') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernFragmentOwner: Expected value for fragment `%s` to be an object, got ' + '`%s`.', fragmentNode.name, typeof fragmentRef) : invariant(false) : void 0;
+  var owner = (_fragmentRef$FRAGMENT = fragmentRef[FRAGMENT_OWNER_KEY]) !== null && _fragmentRef$FRAGMENT !== void 0 ? _fragmentRef$FRAGMENT : null;
+  return owner;
+}
+
+function getPluralFragmentOwner(fragmentNode, fragmentRef) {
+  return fragmentRef.map(function (ref) {
+    return getSingularFragmentOwner(fragmentNode, ref);
+  });
+}
+/**
+ * @public
+ * Extracts the fragment owner associated with the given fragment reference.
+ * TODO(T39494051) - This helper function will become unnecessary once we're
+ * using fragment ownership by default
+ */
+
+
+function getFragmentOwner(fragmentNode, fragmentRef) {
+  if (Array.isArray(fragmentRef)) {
+    return getPluralFragmentOwner(fragmentNode, fragmentRef);
+  }
+
+  return getSingularFragmentOwner(fragmentNode, fragmentRef);
+}
+/**
+ * @public
+ * Given a map of key -> fragment nodes, and a map of key -> fragment refs,
+ * extracts and returns a map of key -> associated fragment owner.
+ * This is useful to construct the argument required by getSelectorsFromObject
+ * TODO(T39494051) - This helper function will become unnecessary once we're
+ * using fragment ownership by default
+ */
+
+
+function getFragmentOwners(fragmentNodes, fragmentRefs) {
+  return mapObject(fragmentNodes, function (fragmentNode, key) {
+    var fragmentRef = fragmentRefs[key];
+    return getFragmentOwner(fragmentNode, // $FlowFixMe - TODO T39154660 Use FragmentPointer type instead of mixed
+    fragmentRef);
+  });
+}
+
+module.exports = {
+  getFragmentOwner: getFragmentOwner,
+  getFragmentOwners: getFragmentOwners
+};