relay-runtime 11.0.0 → 13.0.0-rc.0

package/lib/store/RelayConcreteVariables.js

@@ -14,8 +14,10 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 
-var invariant = require("fbjs/lib/invariant");
+var _require = require('./RelayStoreUtils'),
+    getArgumentValues = _require.getArgumentValues;
 
+var invariant = require('invariant');
 /**
  * Determines the variables that are in scope for a fragment given the variables
  * in scope at the root query as well as any arguments applied at the fragment
@@ -23,6 +25,8 @@ var invariant = require("fbjs/lib/invariant");
  *
  * Note that this is analagous to determining function arguments given a function call.
  */
+
+
 function getFragmentVariables(fragment, rootVariables, argumentVariables) {
   var variables;
   fragment.argumentDefinitions.forEach(function (definition) {
@@ -48,11 +52,9 @@ function getFragmentVariables(fragment, rootVariables, argumentVariables) {
            * RelayStoreUtils.getStableVariableValue() that variable keys are all
            * present.
            */
-          // $FlowFixMe[incompatible-use]
           variables[definition.name] = undefined;
           break;
-        } // $FlowFixMe[incompatible-use]
-
+        }
 
         variables[definition.name] = rootVariables[definition.name];
         break;
@@ -86,7 +88,25 @@ function getOperationVariables(operation, variables) {
   return operationVariables;
 }
 
+function getLocalVariables(currentVariables, argumentDefinitions, args) {
+  if (argumentDefinitions == null) {
+    return currentVariables;
+  }
+
+  var nextVariables = (0, _objectSpread2["default"])({}, currentVariables);
+  var nextArgs = args ? getArgumentValues(args, currentVariables) : {};
+  argumentDefinitions.forEach(function (def) {
+    var _nextArgs$def$name;
+
+    // $FlowFixMe[cannot-write]
+    var value = (_nextArgs$def$name = nextArgs[def.name]) !== null && _nextArgs$def$name !== void 0 ? _nextArgs$def$name : def.defaultValue;
+    nextVariables[def.name] = value;
+  });
+  return nextVariables;
+}
+
 module.exports = {
+  getLocalVariables: getLocalVariables,
   getFragmentVariables: getFragmentVariables,
   getOperationVariables: getOperationVariables
 };

package/lib/store/RelayModernEnvironment.js

@@ -17,34 +17,39 @@ var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/obje
 
 var RelayDefaultHandlerProvider = require('../handlers/RelayDefaultHandlerProvider');
 
-var RelayFeatureFlags = require('../util/RelayFeatureFlags');
-
-var RelayModernQueryExecutor = require('./RelayModernQueryExecutor');
+var _require = require('../multi-actor-environment/ActorIdentifier'),
+    INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE = _require.INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
+    assertInternalActorIndentifier = _require.assertInternalActorIndentifier;
 
 var RelayObservable = require('../network/RelayObservable');
 
+var wrapNetworkWithLogObserver = require('../network/wrapNetworkWithLogObserver');
+
 var RelayOperationTracker = require('../store/RelayOperationTracker');
 
-var RelayPublishQueue = require('./RelayPublishQueue');
+var registerEnvironmentWithDevTools = require('../util/registerEnvironmentWithDevTools');
 
-var RelayRecordSource = require('./RelayRecordSource');
+var RelayFeatureFlags = require('../util/RelayFeatureFlags');
 
 var defaultGetDataID = require('./defaultGetDataID');
 
 var defaultRequiredFieldLogger = require('./defaultRequiredFieldLogger');
 
-var generateID = require('../util/generateID');
+var OperationExecutor = require('./OperationExecutor');
 
-var invariant = require("fbjs/lib/invariant");
+var RelayPublishQueue = require('./RelayPublishQueue');
+
+var RelayRecordSource = require('./RelayRecordSource');
+
+var invariant = require('invariant');
 
 var RelayModernEnvironment = /*#__PURE__*/function () {
   function RelayModernEnvironment(config) {
     var _this = this;
 
-    var _config$log, _config$requiredField, _config$UNSTABLE_defa, _config$getDataID, _config$scheduler, _config$isServer, _config$operationTrac;
+    var _config$log, _config$requiredField, _config$UNSTABLE_defa, _config$getDataID, _config$handlerProvid, _config$scheduler, _config$isServer, _config$operationTrac;
 
     this.configName = config.configName;
-    var handlerProvider = config.handlerProvider ? config.handlerProvider : RelayDefaultHandlerProvider;
     this._treatMissingFieldsAsNull = config.treatMissingFieldsAsNull === true;
     var operationLoader = config.operationLoader;
     var reactFlightPayloadDeserializer = config.reactFlightPayloadDeserializer;
@@ -65,41 +70,35 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
     this._defaultRenderPolicy = ((_config$UNSTABLE_defa = config.UNSTABLE_defaultRenderPolicy) !== null && _config$UNSTABLE_defa !== void 0 ? _config$UNSTABLE_defa : RelayFeatureFlags.ENABLE_PARTIAL_RENDERING_DEFAULT === true) ? 'partial' : 'full';
     this._operationLoader = operationLoader;
     this._operationExecutions = new Map();
-    this._network = this.__wrapNetworkWithLogObserver(config.network);
+    this._network = wrapNetworkWithLogObserver(this, config.network);
     this._getDataID = (_config$getDataID = config.getDataID) !== null && _config$getDataID !== void 0 ? _config$getDataID : defaultGetDataID;
-    this._publishQueue = new RelayPublishQueue(config.store, handlerProvider, this._getDataID);
+    this._publishQueue = new RelayPublishQueue(config.store, (_config$handlerProvid = config.handlerProvider) !== null && _config$handlerProvid !== void 0 ? _config$handlerProvid : RelayDefaultHandlerProvider, this._getDataID);
     this._scheduler = (_config$scheduler = config.scheduler) !== null && _config$scheduler !== void 0 ? _config$scheduler : null;
     this._store = config.store;
     this.options = config.options;
     this._isServer = (_config$isServer = config.isServer) !== null && _config$isServer !== void 0 ? _config$isServer : false;
 
     this.__setNet = function (newNet) {
-      return _this._network = _this.__wrapNetworkWithLogObserver(newNet);
+      return _this._network = wrapNetworkWithLogObserver(_this, newNet);
     };
 
     if (process.env.NODE_ENV !== "production") {
-      var _require = require('./StoreInspector'),
-          inspect = _require.inspect;
+      var _require2 = require('./StoreInspector'),
+          inspect = _require2.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.
-
-
-    var _global = typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : undefined;
-
-    var devToolsHook = _global && _global.__RELAY_DEVTOOLS_HOOK__;
-
-    if (devToolsHook) {
-      devToolsHook.registerEnvironment(this);
     }
 
     this._missingFieldHandlers = config.missingFieldHandlers;
     this._operationTracker = (_config$operationTrac = config.operationTracker) !== null && _config$operationTrac !== void 0 ? _config$operationTrac : new RelayOperationTracker();
     this._reactFlightPayloadDeserializer = reactFlightPayloadDeserializer;
     this._reactFlightServerErrorHandler = reactFlightServerErrorHandler;
+    this._shouldProcessClientComponents = config.shouldProcessClientComponents; // Register this Relay Environment with Relay DevTools if it exists.
+    // Note: this must always be the last step in the constructor.
+
+    registerEnvironmentWithDevTools(this);
   }
 
   var _proto = RelayModernEnvironment.prototype;
@@ -171,31 +170,16 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
   };
 
   _proto.applyMutation = function applyMutation(optimisticConfig) {
-    var _this5 = this;
-
-    var subscription = RelayObservable.create(function (sink) {
-      var source = RelayObservable.create(function (_sink) {});
-      var executor = RelayModernQueryExecutor.execute({
-        operation: optimisticConfig.operation,
-        operationExecutions: _this5._operationExecutions,
-        operationLoader: _this5._operationLoader,
-        optimisticConfig: optimisticConfig,
-        publishQueue: _this5._publishQueue,
-        reactFlightPayloadDeserializer: _this5._reactFlightPayloadDeserializer,
-        reactFlightServerErrorHandler: _this5._reactFlightServerErrorHandler,
-        scheduler: _this5._scheduler,
-        sink: sink,
-        source: source,
-        store: _this5._store,
-        updater: null,
-        operationTracker: _this5._operationTracker,
-        getDataID: _this5._getDataID,
-        treatMissingFieldsAsNull: _this5._treatMissingFieldsAsNull
-      });
-      return function () {
-        return executor.cancel();
-      };
+    var subscription = this._execute({
+      createSource: function createSource() {
+        return RelayObservable.create(function (_sink) {});
+      },
+      isClientPayload: false,
+      operation: optimisticConfig.operation,
+      optimisticConfig: optimisticConfig,
+      updater: null
     }).subscribe({});
+
     return {
       dispose: function dispose() {
         return subscription.unsubscribe();
@@ -212,42 +196,26 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
   };
 
   _proto.commitPayload = function commitPayload(operation, payload) {
-    var _this6 = this;
-
-    RelayObservable.create(function (sink) {
-      var executor = RelayModernQueryExecutor.execute({
-        operation: operation,
-        operationExecutions: _this6._operationExecutions,
-        operationLoader: _this6._operationLoader,
-        optimisticConfig: null,
-        publishQueue: _this6._publishQueue,
-        reactFlightPayloadDeserializer: _this6._reactFlightPayloadDeserializer,
-        reactFlightServerErrorHandler: _this6._reactFlightServerErrorHandler,
-        scheduler: _this6._scheduler,
-        sink: sink,
-        source: RelayObservable.from({
+    this._execute({
+      createSource: function createSource() {
+        return RelayObservable.from({
           data: payload
-        }),
-        store: _this6._store,
-        updater: null,
-        operationTracker: _this6._operationTracker,
-        getDataID: _this6._getDataID,
-        isClientPayload: true,
-        treatMissingFieldsAsNull: _this6._treatMissingFieldsAsNull
-      });
-      return function () {
-        return executor.cancel();
-      };
+        });
+      },
+      isClientPayload: true,
+      operation: operation,
+      optimisticConfig: null,
+      updater: null
     }).subscribe({});
   };
 
   _proto.commitUpdate = function commitUpdate(updater) {
-    var _this7 = this;
+    var _this5 = this;
 
     this._scheduleUpdates(function () {
-      _this7._publishQueue.commitUpdate(updater);
+      _this5._publishQueue.commitUpdate(updater);
 
-      _this7._publishQueue.run();
+      _this5._publishQueue.run();
     });
   };
 
@@ -268,20 +236,30 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
   };
 
   _proto._checkSelectorAndHandleMissingFields = function _checkSelectorAndHandleMissingFields(operation, handlers) {
-    var _this8 = this;
+    var _this6 = this;
 
     var target = RelayRecordSource.create();
 
+    var source = this._store.getSource();
+
     var result = this._store.check(operation, {
-      target: target,
-      handlers: handlers
+      handlers: handlers,
+      defaultActorIdentifier: INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
+      getSourceForActor: function getSourceForActor(actorIdentifier) {
+        assertInternalActorIndentifier(actorIdentifier);
+        return source;
+      },
+      getTargetForActor: function getTargetForActor(actorIdentifier) {
+        assertInternalActorIndentifier(actorIdentifier);
+        return target;
+      }
     });
 
     if (target.size() > 0) {
       this._scheduleUpdates(function () {
-        _this8._publishQueue.commitSource(target);
+        _this6._publishQueue.commitSource(target);
 
-        _this8._publishQueue.run();
+        _this6._publishQueue.run();
       });
     }
 
@@ -299,7 +277,7 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
   }
   /**
    * Returns an Observable of GraphQLResponse resulting from executing the
-   * provided Query or Subscription operation, each result of which is then
+   * provided Query operation, each result of which is then
    * normalized and committed to the publish queue.
    *
    * Note: Observables are lazy, so calling this method will do nothing until
@@ -308,33 +286,42 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
   ;
 
   _proto.execute = function execute(_ref) {
-    var _this9 = this;
+    var _this7 = this;
 
-    var operation = _ref.operation,
-        updater = _ref.updater;
-    return RelayObservable.create(function (sink) {
-      var source = _this9._network.execute(operation.request.node.params, operation.request.variables, operation.request.cacheConfig || {}, null);
+    var operation = _ref.operation;
+    return this._execute({
+      createSource: function createSource() {
+        return _this7._network.execute(operation.request.node.params, operation.request.variables, operation.request.cacheConfig || {}, null);
+      },
+      isClientPayload: false,
+      operation: operation,
+      optimisticConfig: null,
+      updater: null
+    });
+  }
+  /**
+   * Returns an Observable of GraphQLResponse resulting from executing the
+   * provided Subscription operation, each result of which is then
+   * normalized and committed to the publish queue.
+   *
+   * Note: Observables are lazy, so calling this method will do nothing until
+   * the result is subscribed to: environment.execute({...}).subscribe({...}).
+   */
+  ;
 
-      var executor = RelayModernQueryExecutor.execute({
-        operation: operation,
-        operationExecutions: _this9._operationExecutions,
-        operationLoader: _this9._operationLoader,
-        optimisticConfig: null,
-        publishQueue: _this9._publishQueue,
-        reactFlightPayloadDeserializer: _this9._reactFlightPayloadDeserializer,
-        reactFlightServerErrorHandler: _this9._reactFlightServerErrorHandler,
-        scheduler: _this9._scheduler,
-        sink: sink,
-        source: source,
-        store: _this9._store,
-        updater: updater,
-        operationTracker: _this9._operationTracker,
-        getDataID: _this9._getDataID,
-        treatMissingFieldsAsNull: _this9._treatMissingFieldsAsNull
-      });
-      return function () {
-        return executor.cancel();
-      };
+  _proto.executeSubscription = function executeSubscription(_ref2) {
+    var _this8 = this;
+
+    var operation = _ref2.operation,
+        updater = _ref2.updater;
+    return this._execute({
+      createSource: function createSource() {
+        return _this8._network.execute(operation.request.node.params, operation.request.variables, operation.request.cacheConfig || {}, null);
+      },
+      isClientPayload: false,
+      operation: operation,
+      optimisticConfig: null,
+      updater: updater
     });
   }
   /**
@@ -349,55 +336,40 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
    */
   ;
 
-  _proto.executeMutation = function executeMutation(_ref2) {
-    var _this10 = this;
-
-    var operation = _ref2.operation,
-        optimisticResponse = _ref2.optimisticResponse,
-        optimisticUpdater = _ref2.optimisticUpdater,
-        updater = _ref2.updater,
-        uploadables = _ref2.uploadables;
-    return RelayObservable.create(function (sink) {
-      var optimisticConfig;
-
-      if (optimisticResponse || optimisticUpdater) {
-        optimisticConfig = {
-          operation: operation,
-          response: optimisticResponse,
-          updater: optimisticUpdater
-        };
-      }
-
-      var source = _this10._network.execute(operation.request.node.params, operation.request.variables, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, operation.request.cacheConfig), {}, {
-        force: true
-      }), uploadables);
+  _proto.executeMutation = function executeMutation(_ref3) {
+    var _this9 = this;
 
-      var executor = RelayModernQueryExecutor.execute({
+    var operation = _ref3.operation,
+        optimisticResponse = _ref3.optimisticResponse,
+        optimisticUpdater = _ref3.optimisticUpdater,
+        updater = _ref3.updater,
+        uploadables = _ref3.uploadables;
+    var optimisticConfig;
+
+    if (optimisticResponse || optimisticUpdater) {
+      optimisticConfig = {
         operation: operation,
-        operationExecutions: _this10._operationExecutions,
-        operationLoader: _this10._operationLoader,
-        optimisticConfig: optimisticConfig,
-        publishQueue: _this10._publishQueue,
-        reactFlightPayloadDeserializer: _this10._reactFlightPayloadDeserializer,
-        reactFlightServerErrorHandler: _this10._reactFlightServerErrorHandler,
-        scheduler: _this10._scheduler,
-        sink: sink,
-        source: source,
-        store: _this10._store,
-        updater: updater,
-        operationTracker: _this10._operationTracker,
-        getDataID: _this10._getDataID,
-        treatMissingFieldsAsNull: _this10._treatMissingFieldsAsNull
-      });
-      return function () {
-        return executor.cancel();
+        response: optimisticResponse,
+        updater: optimisticUpdater
       };
+    }
+
+    return this._execute({
+      createSource: function createSource() {
+        return _this9._network.execute(operation.request.node.params, operation.request.variables, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, operation.request.cacheConfig), {}, {
+          force: true
+        }), uploadables);
+      },
+      isClientPayload: false,
+      operation: operation,
+      optimisticConfig: optimisticConfig,
+      updater: updater
     });
   }
   /**
    * 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.
+   * then normalized and committed to the publish queue.
    *
    * Note: Observables are lazy, so calling this method will do nothing until
    * the result is subscribed to:
@@ -405,27 +377,65 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
    */
   ;
 
-  _proto.executeWithSource = function executeWithSource(_ref3) {
-    var _this11 = this;
+  _proto.executeWithSource = function executeWithSource(_ref4) {
+    var operation = _ref4.operation,
+        source = _ref4.source;
+    return this._execute({
+      createSource: function createSource() {
+        return source;
+      },
+      isClientPayload: false,
+      operation: operation,
+      optimisticConfig: null,
+      updater: null
+    });
+  };
 
-    var operation = _ref3.operation,
-        source = _ref3.source;
+  _proto.toJSON = function toJSON() {
+    var _this$configName;
+
+    return "RelayModernEnvironment(".concat((_this$configName = this.configName) !== null && _this$configName !== void 0 ? _this$configName : '', ")");
+  };
+
+  _proto._execute = function _execute(_ref5) {
+    var _this10 = this;
+
+    var createSource = _ref5.createSource,
+        isClientPayload = _ref5.isClientPayload,
+        operation = _ref5.operation,
+        optimisticConfig = _ref5.optimisticConfig,
+        updater = _ref5.updater;
+    var publishQueue = this._publishQueue;
+    var store = this._store;
     return RelayObservable.create(function (sink) {
-      var executor = RelayModernQueryExecutor.execute({
+      var executor = OperationExecutor.execute({
+        actorIdentifier: INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
+        getDataID: _this10._getDataID,
+        isClientPayload: isClientPayload,
+        log: _this10.__log,
         operation: operation,
-        operationExecutions: _this11._operationExecutions,
-        operationLoader: _this11._operationLoader,
-        operationTracker: _this11._operationTracker,
-        optimisticConfig: null,
-        publishQueue: _this11._publishQueue,
-        reactFlightPayloadDeserializer: _this11._reactFlightPayloadDeserializer,
-        reactFlightServerErrorHandler: _this11._reactFlightServerErrorHandler,
-        scheduler: _this11._scheduler,
+        operationExecutions: _this10._operationExecutions,
+        operationLoader: _this10._operationLoader,
+        operationTracker: _this10._operationTracker,
+        optimisticConfig: optimisticConfig,
+        getPublishQueue: function getPublishQueue(actorIdentifier) {
+          assertInternalActorIndentifier(actorIdentifier);
+          return publishQueue;
+        },
+        reactFlightPayloadDeserializer: _this10._reactFlightPayloadDeserializer,
+        reactFlightServerErrorHandler: _this10._reactFlightServerErrorHandler,
+        scheduler: _this10._scheduler,
+        shouldProcessClientComponents: _this10._shouldProcessClientComponents,
         sink: sink,
-        source: source,
-        store: _this11._store,
-        getDataID: _this11._getDataID,
-        treatMissingFieldsAsNull: _this11._treatMissingFieldsAsNull
+        // NOTE: Some product tests expect `Network.execute` to be called only
+        //       when the Observable is executed.
+        source: createSource(),
+        getStore: function getStore(actorIdentifier) {
+          assertInternalActorIndentifier(actorIdentifier);
+          return store;
+        },
+        treatMissingFieldsAsNull: _this10._treatMissingFieldsAsNull,
+        updater: updater
       });
       return function () {
         return executor.cancel();
@@ -433,75 +443,6 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
     });
   };
 
-  _proto.toJSON = function toJSON() {
-    var _this$configName;
-
-    return "RelayModernEnvironment(".concat((_this$configName = this.configName) !== null && _this$configName !== void 0 ? _this$configName : '', ")");
-  }
-  /**
-   * Wraps the network with logging to ensure that network requests are
-   * always logged. Relying on each network callsite to be wrapped is
-   * untenable and will eventually lead to holes in the logging.
-   */
-  ;
-
-  _proto.__wrapNetworkWithLogObserver = function __wrapNetworkWithLogObserver(network) {
-    var that = this;
-    return {
-      execute: function execute(params, variables, cacheConfig, uploadables) {
-        var transactionID = generateID();
-        var log = that.__log;
-        var logObserver = {
-          start: function start(subscription) {
-            log({
-              name: 'network.start',
-              transactionID: transactionID,
-              params: params,
-              variables: variables,
-              cacheConfig: cacheConfig
-            });
-          },
-          next: function next(response) {
-            log({
-              name: 'network.next',
-              transactionID: transactionID,
-              response: response
-            });
-          },
-          error: function error(_error) {
-            log({
-              name: 'network.error',
-              transactionID: transactionID,
-              error: _error
-            });
-          },
-          complete: function complete() {
-            log({
-              name: 'network.complete',
-              transactionID: transactionID
-            });
-          },
-          unsubscribe: function unsubscribe() {
-            log({
-              name: 'network.unsubscribe',
-              transactionID: transactionID
-            });
-          }
-        };
-
-        var logRequestInfo = function logRequestInfo(info) {
-          log({
-            name: 'network.info',
-            transactionID: transactionID,
-            info: info
-          });
-        };
-
-        return network.execute(params, variables, cacheConfig, uploadables, logRequestInfo)["do"](logObserver);
-      }
-    };
-  };
-
   return RelayModernEnvironment;
 }(); // Add a sigil for detection by `isRelayModernEnvironment()` to avoid a
 // realm-specific instanceof check, and to aid in module tree-shaking to