relay-runtime 11.0.2 → 12.0.0

package/lib/store/DataChecker.js

@@ -40,14 +40,18 @@ 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,
@@ -76,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, shouldProcessClientComponents) {
+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, shouldProcessClientComponents);
+  var checker = new DataChecker(getSourceForActor, getTargetForActor, defaultActorIdentifier, variables, handlers, operationLoader, getDataID, shouldProcessClientComponents);
   return checker.check(node, dataID);
 }
 /**
@@ -89,21 +93,45 @@ function check(source, target, selector, handlers, operationLoader, getDataID, s
 
 
 var DataChecker = /*#__PURE__*/function () {
-  function DataChecker(source, target, variables, handlers, operationLoader, getDataID, shouldProcessClientComponents) {
-    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);
 
@@ -128,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
@@ -279,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);
@@ -290,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.
@@ -307,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;
-              var typeID = generateTypeID(recordType);
+              !(_recordType != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'DataChecker: Expected record `%s` to have a known type', dataID) : invariant(false) : void 0;
 
-              var implementsInterface = _this2._mutator.getValue(typeID, abstractKey);
+              var _typeID = generateTypeID(_recordType);
 
-              if (implementsInterface === true) {
+              var _implementsInterface = _this2._mutator.getValue(_typeID, _abstractKey);
+
+              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;
@@ -365,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:
@@ -381,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;
 
@@ -446,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.
@@ -515,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);