relay-runtime 11.0.0-rc.0 → 12.0.0

package/lib/network/RelayObservable.js

@@ -332,13 +332,15 @@ var RelayObservable = /*#__PURE__*/function () {
         if (subscriptions.length === 0) {
           sink.complete();
         }
-      }
+      } // $FlowFixMe[incompatible-call]
+
 
       _this7.subscribe({
         start: start,
         next: function next(value) {
           try {
             if (!sink.closed) {
+              // $FlowFixMe[incompatible-call]
               RelayObservable.from(fn(value)).subscribe({
                 start: start,
                 next: sink.next,

package/lib/network/RelayQueryResponseCache.js

@@ -14,7 +14,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var stableCopy = require('../util/stableCopy');
 
@@ -53,11 +53,28 @@ var RelayQueryResponseCache = /*#__PURE__*/function () {
 
     var response = this._responses.get(cacheKey);
 
-    return response != null ? (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, response.payload), {}, {
+    if (response == null) {
+      return null;
+    }
+
+    if (Array.isArray(response.payload)) {
+      return response.payload.map(function (payload) {
+        return (// $FlowFixMe[incompatible-cast]
+          (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, payload), {}, {
+            extensions: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, payload.extensions), {}, {
+              cacheTimestamp: response.fetchTime
+            })
+          })
+        );
+      });
+    } // $FlowFixMe[incompatible-cast]
+
+
+    return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, response.payload), {}, {
       extensions: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, response.payload.extensions), {}, {
         cacheTimestamp: response.fetchTime
       })
-    }) : null;
+    });
   };
 
   _proto.set = function set(queryID, variables, payload) {

package/lib/network/wrapNetworkWithLogObserver.js

@@ -0,0 +1,78 @@
+/**
+ * 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
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var generateID = require('../util/generateID');
+
+/**
+ * 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.
+ * NOTE: This function takes an environment instance, because Relay
+ * devtools will mutate the `env.__log` method, and the devtools rely
+ * on it to receive network events.
+ */
+function wrapNetworkWithLogObserver(env, network) {
+  return {
+    execute: function execute(params, variables, cacheConfig, uploadables) {
+      var networkRequestId = generateID();
+      var logObserver = {
+        start: function start(subscription) {
+          env.__log({
+            name: 'network.start',
+            networkRequestId: networkRequestId,
+            params: params,
+            variables: variables,
+            cacheConfig: cacheConfig
+          });
+        },
+        next: function next(response) {
+          env.__log({
+            name: 'network.next',
+            networkRequestId: networkRequestId,
+            response: response
+          });
+        },
+        error: function error(_error) {
+          env.__log({
+            name: 'network.error',
+            networkRequestId: networkRequestId,
+            error: _error
+          });
+        },
+        complete: function complete() {
+          env.__log({
+            name: 'network.complete',
+            networkRequestId: networkRequestId
+          });
+        },
+        unsubscribe: function unsubscribe() {
+          env.__log({
+            name: 'network.unsubscribe',
+            networkRequestId: networkRequestId
+          });
+        }
+      };
+
+      var logRequestInfo = function logRequestInfo(info) {
+        env.__log({
+          name: 'network.info',
+          networkRequestId: networkRequestId,
+          info: info
+        });
+      };
+
+      return network.execute(params, variables, cacheConfig, uploadables, logRequestInfo)["do"](logObserver);
+    }
+  };
+}
+
+module.exports = wrapNetworkWithLogObserver;

package/lib/query/GraphQLTag.js

@@ -12,7 +12,7 @@
 
 var RelayConcreteNode = require('../util/RelayConcreteNode');
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var warning = require("fbjs/lib/warning");
 

package/lib/query/fetchQuery.js

@@ -19,7 +19,7 @@ var RelayObservable = require('../network/RelayObservable');
 
 var fetchQueryInternal = require('./fetchQueryInternal');
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var reportMissingRequiredFields = require('../util/reportMissingRequiredFields');
 

package/lib/query/fetchQueryInternal.js

@@ -14,7 +14,7 @@ var Observable = require('../network/RelayObservable');
 
 var RelayReplaySubject = require('../util/RelayReplaySubject');
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var WEAKMAP_SUPPORTED = typeof WeakMap === 'function';
 var requestCachesByEnvironment = WEAKMAP_SUPPORTED ? new WeakMap() : new Map();

package/lib/store/DataChecker.js

@@ -35,19 +35,24 @@ var cloneRelayScalarHandleSourceField = require('./cloneRelayScalarHandleSourceF
 
 var getOperation = require('../util/getOperation');
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var _require = require('./ClientID'),
     isClientID = _require.isClientID;
 
-var _require2 = require('./RelayRecordState'),
-    EXISTENT = _require2.EXISTENT,
-    UNKNOWN = _require2.UNKNOWN;
+var _require2 = require('./RelayConcreteVariables'),
+    getLocalVariables = _require2.getLocalVariables;
 
-var _require3 = require('./TypeID'),
-    generateTypeID = _require3.generateTypeID;
+var _require3 = require('./RelayRecordState'),
+    EXISTENT = _require3.EXISTENT,
+    UNKNOWN = _require3.UNKNOWN;
 
-var CONDITION = RelayConcreteNode.CONDITION,
+var _require4 = require('./TypeID'),
+    generateTypeID = _require4.generateTypeID;
+
+var ACTOR_CHANGE = RelayConcreteNode.ACTOR_CHANGE,
+    CONDITION = RelayConcreteNode.CONDITION,
+    CLIENT_COMPONENT = RelayConcreteNode.CLIENT_COMPONENT,
     CLIENT_EXTENSION = RelayConcreteNode.CLIENT_EXTENSION,
     DEFER = RelayConcreteNode.DEFER,
     FLIGHT_FIELD = RelayConcreteNode.FLIGHT_FIELD,
@@ -75,11 +80,11 @@ var ROOT_ID = RelayStoreUtils.ROOT_ID,
  * If all records are present, returns `true`, otherwise `false`.
  */
 
-function check(source, target, selector, handlers, operationLoader, getDataID) {
+function check(getSourceForActor, getTargetForActor, defaultActorIdentifier, selector, handlers, operationLoader, getDataID, shouldProcessClientComponents) {
   var dataID = selector.dataID,
       node = selector.node,
       variables = selector.variables;
-  var checker = new DataChecker(source, target, variables, handlers, operationLoader, getDataID);
+  var checker = new DataChecker(getSourceForActor, getTargetForActor, defaultActorIdentifier, variables, handlers, operationLoader, getDataID, shouldProcessClientComponents);
   return checker.check(node, dataID);
 }
 /**
@@ -88,20 +93,45 @@ function check(source, target, selector, handlers, operationLoader, getDataID) {
 
 
 var DataChecker = /*#__PURE__*/function () {
-  function DataChecker(source, target, variables, handlers, operationLoader, getDataID) {
-    var mutator = new RelayRecordSourceMutator(source, target);
+  function DataChecker(getSourceForActor, getTargetForActor, defaultActorIdentifier, variables, handlers, operationLoader, getDataID, shouldProcessClientComponents) {
+    this._getSourceForActor = getSourceForActor;
+    this._getTargetForActor = getTargetForActor;
+    this._getDataID = getDataID;
+    this._source = getSourceForActor(defaultActorIdentifier);
+    this._mutatorRecordSourceProxyCache = new Map();
+
+    var _this$_getMutatorAndR = this._getMutatorAndRecordProxyForActor(defaultActorIdentifier),
+        mutator = _this$_getMutatorAndR[0],
+        recordSourceProxy = _this$_getMutatorAndR[1];
+
     this._mostRecentlyInvalidatedAt = null;
     this._handlers = handlers;
     this._mutator = mutator;
     this._operationLoader = operationLoader !== null && operationLoader !== void 0 ? operationLoader : null;
-    this._recordSourceProxy = new RelayRecordSourceProxy(mutator, getDataID);
+    this._recordSourceProxy = recordSourceProxy;
     this._recordWasMissing = false;
-    this._source = source;
     this._variables = variables;
+    this._shouldProcessClientComponents = shouldProcessClientComponents;
   }
 
   var _proto = DataChecker.prototype;
 
+  _proto._getMutatorAndRecordProxyForActor = function _getMutatorAndRecordProxyForActor(actorIdentifier) {
+    var tuple = this._mutatorRecordSourceProxyCache.get(actorIdentifier);
+
+    if (tuple == null) {
+      var target = this._getTargetForActor(actorIdentifier);
+
+      var mutator = new RelayRecordSourceMutator(this._getSourceForActor(actorIdentifier), target);
+      var recordSourceProxy = new RelayRecordSourceProxy(mutator, this._getDataID);
+      tuple = [mutator, recordSourceProxy];
+
+      this._mutatorRecordSourceProxyCache.set(actorIdentifier, tuple);
+    }
+
+    return tuple;
+  };
+
   _proto.check = function check(node, dataID) {
     this._traverse(node, dataID);
 
@@ -115,7 +145,8 @@ var DataChecker = /*#__PURE__*/function () {
   };
 
   _proto._getVariableValue = function _getVariableValue(name) {
-    !this._variables.hasOwnProperty(name) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayAsyncLoader(): Undefined variable `%s`.', name) : invariant(false) : void 0;
+    !this._variables.hasOwnProperty(name) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayAsyncLoader(): Undefined variable `%s`.', name) : invariant(false) : void 0; // $FlowFixMe[cannot-write]
+
     return this._variables[name];
   };
 
@@ -125,6 +156,8 @@ var DataChecker = /*#__PURE__*/function () {
 
   _proto._getDataForHandlers = function _getDataForHandlers(field, dataID) {
     return {
+      /* $FlowFixMe[class-object-subtyping] added when improving typing for
+       * this parameters */
       args: field.args ? getArgumentValues(field.args, this._variables) : {},
       // Getting a snapshot of the record state is potentially expensive since
       // we will need to merge the sink and source records. Since we do not create
@@ -276,8 +309,13 @@ var DataChecker = /*#__PURE__*/function () {
 
           break;
 
+        case ACTOR_CHANGE:
+          _this2._checkActorChange(selection.linkedField, dataID);
+
+          break;
+
         case CONDITION:
-          var conditionValue = _this2._getVariableValue(selection.condition);
+          var conditionValue = Boolean(_this2._getVariableValue(selection.condition));
 
           if (conditionValue === selection.passingValue) {
             _this2._traverseSelections(selection.selections, dataID);
@@ -287,16 +325,16 @@ var DataChecker = /*#__PURE__*/function () {
 
         case INLINE_FRAGMENT:
           {
-            var abstractKey = selection.abstractKey;
+            var _abstractKey = selection.abstractKey;
 
-            if (abstractKey == null) {
+            if (_abstractKey == null) {
               // concrete type refinement: only check data if the type exactly matches
               var typeName = _this2._mutator.getType(dataID);
 
               if (typeName === selection.type) {
                 _this2._traverseSelections(selection.selections, dataID);
               }
-            } else if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
+            } else {
               // Abstract refinement: check data depending on whether the type
               // conforms to the interface/union or not:
               // - Type known to _not_ implement the interface: don't check the selections.
@@ -304,25 +342,22 @@ var DataChecker = /*#__PURE__*/function () {
               // - Unknown whether the type implements the interface: don't check the selections
               //   and treat the data as missing; we do this because the Relay Compiler
               //   guarantees that the type discriminator will always be fetched.
-              var recordType = _this2._mutator.getType(dataID);
+              var _recordType = _this2._mutator.getType(dataID);
+
+              !(_recordType != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'DataChecker: Expected record `%s` to have a known type', dataID) : invariant(false) : void 0;
 
-              !(recordType != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'DataChecker: Expected record `%s` to have a known type', dataID) : invariant(false) : void 0;
-              var typeID = generateTypeID(recordType);
+              var _typeID = generateTypeID(_recordType);
 
-              var implementsInterface = _this2._mutator.getValue(typeID, abstractKey);
+              var _implementsInterface = _this2._mutator.getValue(_typeID, _abstractKey);
 
-              if (implementsInterface === true) {
+              if (_implementsInterface === true) {
                 _this2._traverseSelections(selection.selections, dataID);
-              } else if (implementsInterface == null) {
+              } else if (_implementsInterface == null) {
                 // unsure if the type implements the interface: data is
                 // missing so don't bother reading the fragment
                 _this2._handleMissing();
               } // else false: known to not implement the interface
 
-            } else {
-              // legacy behavior for abstract refinements: always check even
-              // if the type doesn't conform
-              _this2._traverseSelections(selection.selections, dataID);
             }
 
             break;
@@ -362,11 +397,14 @@ var DataChecker = /*#__PURE__*/function () {
           _this2._traverseSelections(selection.selections, dataID);
 
           break;
-        // $FlowFixMe[incompatible-type]
 
         case FRAGMENT_SPREAD:
+          var prevVariables = _this2._variables;
+          _this2._variables = getLocalVariables(_this2._variables, selection.fragment.argumentDefinitions, selection.args);
+
           _this2._traverseSelections(selection.fragment.selections, dataID);
 
+          _this2._variables = prevVariables;
           break;
 
         case CLIENT_EXTENSION:
@@ -378,24 +416,21 @@ var DataChecker = /*#__PURE__*/function () {
           break;
 
         case TYPE_DISCRIMINATOR:
-          if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
-            var _abstractKey = selection.abstractKey;
+          var abstractKey = selection.abstractKey;
 
-            var _recordType = _this2._mutator.getType(dataID);
+          var recordType = _this2._mutator.getType(dataID);
 
-            !(_recordType != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'DataChecker: Expected record `%s` to have a known type', dataID) : invariant(false) : void 0;
+          !(recordType != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'DataChecker: Expected record `%s` to have a known type', dataID) : invariant(false) : void 0;
+          var typeID = generateTypeID(recordType);
 
-            var _typeID = generateTypeID(_recordType);
+          var implementsInterface = _this2._mutator.getValue(typeID, abstractKey);
 
-            var _implementsInterface = _this2._mutator.getValue(_typeID, _abstractKey);
+          if (implementsInterface == null) {
+            // unsure if the type implements the interface: data is
+            // missing
+            _this2._handleMissing();
+          } // else: if it does or doesn't implement, we don't need to check or skip anything else
 
-            if (_implementsInterface == null) {
-              // unsure if the type implements the interface: data is
-              // missing
-              _this2._handleMissing();
-            } // else: if it does or doesn't implement, we don't need to check or skip anything else
-
-          }
 
           break;
 
@@ -408,6 +443,15 @@ var DataChecker = /*#__PURE__*/function () {
 
           break;
 
+        case CLIENT_COMPONENT:
+          if (_this2._shouldProcessClientComponents === false) {
+            break;
+          }
+
+          _this2._traverseSelections(selection.fragment.selections, dataID);
+
+          break;
+
         default:
           selection;
           !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayAsyncLoader(): Unexpected ast kind `%s`.', selection.kind) : invariant(false) : void 0;
@@ -434,8 +478,12 @@ var DataChecker = /*#__PURE__*/function () {
 
     if (normalizationRootNode != null) {
       var operation = getOperation(normalizationRootNode);
+      var prevVariables = this._variables;
+      this._variables = getLocalVariables(this._variables, operation.argumentDefinitions, moduleImport.args);
 
       this._traverse(operation, dataID);
+
+      this._variables = prevVariables;
     } else {
       // If the fragment is not available, we assume that the data cannot have been
       // processed yet and must therefore be missing.
@@ -503,6 +551,40 @@ var DataChecker = /*#__PURE__*/function () {
     }
   };
 
+  _proto._checkActorChange = function _checkActorChange(field, dataID) {
+    var storageKey = getStorageKey(field, this._variables);
+
+    var record = this._source.get(dataID);
+
+    var tuple = record != null ? RelayModernRecord.getActorLinkedRecordID(record, storageKey) : record;
+
+    if (tuple == null) {
+      if (tuple === undefined) {
+        this._handleMissing();
+      }
+    } else {
+      var _actorIdentifier = tuple[0],
+          linkedID = tuple[1];
+      var prevSource = this._source;
+      var prevMutator = this._mutator;
+      var prevRecordSourceProxy = this._recordSourceProxy;
+
+      var _this$_getMutatorAndR2 = this._getMutatorAndRecordProxyForActor(_actorIdentifier),
+          mutator = _this$_getMutatorAndR2[0],
+          recordSourceProxy = _this$_getMutatorAndR2[1];
+
+      this._source = this._getSourceForActor(_actorIdentifier);
+      this._mutator = mutator;
+      this._recordSourceProxy = recordSourceProxy;
+
+      this._traverse(field, linkedID);
+
+      this._source = prevSource;
+      this._mutator = prevMutator;
+      this._recordSourceProxy = prevRecordSourceProxy;
+    }
+  };
+
   _proto._checkFlightField = function _checkFlightField(field, dataID) {
     var storageKey = getStorageKey(field, this._variables);
 
@@ -520,28 +602,28 @@ var DataChecker = /*#__PURE__*/function () {
 
     var tree = this._mutator.getValue(linkedID, RelayStoreReactFlightUtils.REACT_FLIGHT_TREE_STORAGE_KEY);
 
-    var reachableQueries = this._mutator.getValue(linkedID, RelayStoreReactFlightUtils.REACT_FLIGHT_QUERIES_STORAGE_KEY);
+    var reachableExecutableDefinitions = this._mutator.getValue(linkedID, RelayStoreReactFlightUtils.REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY);
 
-    if (tree == null || !Array.isArray(reachableQueries)) {
+    if (tree == null || !Array.isArray(reachableExecutableDefinitions)) {
       this._handleMissing();
 
       return;
     }
 
     var operationLoader = this._operationLoader;
-    !(operationLoader !== null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'DataChecker: Expected an operationLoader to be configured when using ' + 'React Flight.') : invariant(false) : void 0; // In Flight, the variables that are in scope for reachable queries aren't
-    // the same as what's in scope for the outer query.
+    !(operationLoader !== null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'DataChecker: Expected an operationLoader to be configured when using ' + 'React Flight.') : invariant(false) : void 0; // In Flight, the variables that are in scope for reachable executable
+    // definitions aren't the same as what's in scope for the outer query.
 
     var prevVariables = this._variables; // $FlowFixMe[incompatible-cast]
 
-    var _iterator4 = (0, _createForOfIteratorHelper2["default"])(reachableQueries),
+    var _iterator4 = (0, _createForOfIteratorHelper2["default"])(reachableExecutableDefinitions),
         _step4;
 
     try {
       for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-        var query = _step4.value;
-        this._variables = query.variables;
-        var normalizationRootNode = operationLoader.get(query.module);
+        var definition = _step4.value;
+        this._variables = definition.variables;
+        var normalizationRootNode = operationLoader.get(definition.module);
 
         if (normalizationRootNode != null) {
           var operation = getOperation(normalizationRootNode);