relay-runtime 11.0.1 → 13.0.0-rc.1

package/lib/query/fetchQuery.js

@@ -17,18 +17,17 @@ var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/obje
 
 var RelayObservable = require('../network/RelayObservable');
 
-var fetchQueryInternal = require('./fetchQueryInternal');
-
-var invariant = require("fbjs/lib/invariant");
+var _require = require('../store/RelayModernOperationDescriptor'),
+    createOperationDescriptor = _require.createOperationDescriptor;
 
 var reportMissingRequiredFields = require('../util/reportMissingRequiredFields');
 
-var _require = require('../store/RelayModernOperationDescriptor'),
-    createOperationDescriptor = _require.createOperationDescriptor;
+var fetchQueryInternal = require('./fetchQueryInternal');
 
 var _require2 = require('./GraphQLTag'),
     getRequest = _require2.getRequest;
 
+var invariant = require('invariant');
 /**
  * Fetches the given query and variables on the provided environment,
  * and de-dupes identical in-flight requests.
@@ -106,6 +105,8 @@ var _require2 = require('./GraphQLTag'),
  * ```
  * NOTE: When using .toPromise(), the request cannot be cancelled.
  */
+
+
 function fetchQuery(environment, query, variables, options) {
   var _options$fetchPolicy;
 

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/query/fetchQuery_DEPRECATED.js

@@ -15,12 +15,13 @@ var _require = require('../store/RelayModernOperationDescriptor'),
 
 var _require2 = require('./GraphQLTag'),
     getRequest = _require2.getRequest;
-
 /**
  * A helper function to fetch the results of a query. Note that results for
  * fragment spreads are masked: fields must be explicitly listed in the query in
  * order to be accessible in the result object.
  */
+
+
 function fetchQuery_DEPRECATED(environment, taggedNode, variables, cacheConfig) {
   var query = getRequest(taggedNode);
 

package/lib/store/ClientID.js

@@ -10,10 +10,16 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
+var RelayFeatureFlags = require('../util/RelayFeatureFlags');
+
+var _require = require('../util/StringInterner'),
+    intern = _require.intern;
+
 var PREFIX = 'client:';
 
 function generateClientID(id, storageKey, index) {
-  var key = id + ':' + storageKey;
+  var internedId = RelayFeatureFlags.STRING_INTERN_LEVEL <= 0 ? id : intern(id, RelayFeatureFlags.MAX_DATA_ID_LENGTH);
+  var key = internedId + ':' + storageKey;
 
   if (index != null) {
     key += ':' + index;

package/lib/store/DataChecker.js

@@ -15,39 +15,43 @@ 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 RelayStoreUtils = require('./RelayStoreUtils');
 
-var _require2 = require('./RelayRecordState'),
-    EXISTENT = _require2.EXISTENT,
-    UNKNOWN = _require2.UNKNOWN;
+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,
@@ -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);
 
@@ -117,8 +145,7 @@ 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; // $FlowFixMe[cannot-write]
-
+    !this._variables.hasOwnProperty(name) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayAsyncLoader(): Undefined variable `%s`.', name) : invariant(false) : void 0;
     return this._variables[name];
   };
 
@@ -128,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
@@ -279,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);
@@ -290,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.
@@ -307,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;
-              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 +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:
@@ -381,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;
 
@@ -446,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.
@@ -515,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);