relay-runtime 11.0.0 → 13.0.0-rc.0

package/lib/store/DataChecker.js

@@ -15,39 +15,44 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
 
-var RelayConcreteNode = require('../util/RelayConcreteNode');
-
-var RelayFeatureFlags = require('../util/RelayFeatureFlags');
-
-var RelayModernRecord = require('./RelayModernRecord');
-
 var RelayRecordSourceMutator = require('../mutations/RelayRecordSourceMutator');
 
 var RelayRecordSourceProxy = require('../mutations/RelayRecordSourceProxy');
 
-var RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');
+var getOperation = require('../util/getOperation');
 
-var RelayStoreUtils = require('./RelayStoreUtils');
+var RelayConcreteNode = require('../util/RelayConcreteNode');
+
+var RelayFeatureFlags = require('../util/RelayFeatureFlags');
+
+var _require = require('./ClientID'),
+    isClientID = _require.isClientID;
 
 var cloneRelayHandleSourceField = require('./cloneRelayHandleSourceField');
 
 var cloneRelayScalarHandleSourceField = require('./cloneRelayScalarHandleSourceField');
 
-var getOperation = require('../util/getOperation');
+var _require2 = require('./RelayConcreteVariables'),
+    getLocalVariables = _require2.getLocalVariables;
 
-var invariant = require("fbjs/lib/invariant");
+var RelayModernRecord = require('./RelayModernRecord');
 
-var _require = require('./ClientID'),
-    isClientID = _require.isClientID;
+var _require3 = require('./RelayRecordState'),
+    EXISTENT = _require3.EXISTENT,
+    UNKNOWN = _require3.UNKNOWN;
+
+var RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');
 
-var _require2 = require('./RelayRecordState'),
-    EXISTENT = _require2.EXISTENT,
-    UNKNOWN = _require2.UNKNOWN;
+var RelayStoreUtils = require('./RelayStoreUtils');
+
+var _require4 = require('./TypeID'),
+    generateTypeID = _require4.generateTypeID;
 
-var _require3 = require('./TypeID'),
-    generateTypeID = _require3.generateTypeID;
+var invariant = require('invariant');
 
-var CONDITION = RelayConcreteNode.CONDITION,
+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);
 
@@ -125,6 +155,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 +308,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 +324,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 +341,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 +396,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 +415,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 +442,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 +477,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 +550,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 +601,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);