relay-runtime 11.0.1 → 13.0.0-rc.1

package/lib/store/RelayResponseNormalizer.js

@@ -16,61 +16,67 @@ var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
+var _require = require('../multi-actor-environment/ActorUtils'),
+    ACTOR_IDENTIFIER_FIELD_NAME = _require.ACTOR_IDENTIFIER_FIELD_NAME,
+    getActorIdentifierFromPayload = _require.getActorIdentifierFromPayload;
+
+var _require2 = require('../util/RelayConcreteNode'),
+    ACTOR_CHANGE = _require2.ACTOR_CHANGE,
+    CLIENT_COMPONENT = _require2.CLIENT_COMPONENT,
+    CLIENT_EXTENSION = _require2.CLIENT_EXTENSION,
+    CONDITION = _require2.CONDITION,
+    DEFER = _require2.DEFER,
+    FLIGHT_FIELD = _require2.FLIGHT_FIELD,
+    FRAGMENT_SPREAD = _require2.FRAGMENT_SPREAD,
+    INLINE_FRAGMENT = _require2.INLINE_FRAGMENT,
+    LINKED_FIELD = _require2.LINKED_FIELD,
+    LINKED_HANDLE = _require2.LINKED_HANDLE,
+    MODULE_IMPORT = _require2.MODULE_IMPORT,
+    SCALAR_FIELD = _require2.SCALAR_FIELD,
+    SCALAR_HANDLE = _require2.SCALAR_HANDLE,
+    STREAM = _require2.STREAM,
+    TYPE_DISCRIMINATOR = _require2.TYPE_DISCRIMINATOR;
+
 var RelayFeatureFlags = require('../util/RelayFeatureFlags');
 
+var _require3 = require('./ClientID'),
+    generateClientID = _require3.generateClientID,
+    isClientID = _require3.isClientID;
+
+var _require4 = require('./RelayConcreteVariables'),
+    getLocalVariables = _require4.getLocalVariables;
+
 var RelayModernRecord = require('./RelayModernRecord');
 
-var RelayProfiler = require('../util/RelayProfiler');
+var _require5 = require('./RelayModernSelector'),
+    createNormalizationSelector = _require5.createNormalizationSelector;
+
+var _require6 = require('./RelayStoreReactFlightUtils'),
+    REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY = _require6.REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY,
+    REACT_FLIGHT_TREE_STORAGE_KEY = _require6.REACT_FLIGHT_TREE_STORAGE_KEY,
+    REACT_FLIGHT_TYPE_NAME = _require6.REACT_FLIGHT_TYPE_NAME,
+    refineToReactFlightPayloadData = _require6.refineToReactFlightPayloadData;
+
+var _require7 = require('./RelayStoreUtils'),
+    ROOT_ID = _require7.ROOT_ID,
+    ROOT_TYPE = _require7.ROOT_TYPE,
+    TYPENAME_KEY = _require7.TYPENAME_KEY,
+    getArgumentValues = _require7.getArgumentValues,
+    getHandleStorageKey = _require7.getHandleStorageKey,
+    getModuleComponentKey = _require7.getModuleComponentKey,
+    getModuleOperationKey = _require7.getModuleOperationKey,
+    getStorageKey = _require7.getStorageKey;
+
+var _require8 = require('./TypeID'),
+    TYPE_SCHEMA_TYPE = _require8.TYPE_SCHEMA_TYPE,
+    generateTypeID = _require8.generateTypeID;
 
 var areEqual = require("fbjs/lib/areEqual");
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var warning = require("fbjs/lib/warning");
 
-var _require = require('../util/RelayConcreteNode'),
-    CONDITION = _require.CONDITION,
-    CLIENT_COMPONENT = _require.CLIENT_COMPONENT,
-    CLIENT_EXTENSION = _require.CLIENT_EXTENSION,
-    DEFER = _require.DEFER,
-    FLIGHT_FIELD = _require.FLIGHT_FIELD,
-    FRAGMENT_SPREAD = _require.FRAGMENT_SPREAD,
-    INLINE_FRAGMENT = _require.INLINE_FRAGMENT,
-    LINKED_FIELD = _require.LINKED_FIELD,
-    LINKED_HANDLE = _require.LINKED_HANDLE,
-    MODULE_IMPORT = _require.MODULE_IMPORT,
-    SCALAR_FIELD = _require.SCALAR_FIELD,
-    SCALAR_HANDLE = _require.SCALAR_HANDLE,
-    STREAM = _require.STREAM,
-    TYPE_DISCRIMINATOR = _require.TYPE_DISCRIMINATOR;
-
-var _require2 = require('./ClientID'),
-    generateClientID = _require2.generateClientID,
-    isClientID = _require2.isClientID;
-
-var _require3 = require('./RelayModernSelector'),
-    createNormalizationSelector = _require3.createNormalizationSelector;
-
-var _require4 = require('./RelayStoreReactFlightUtils'),
-    refineToReactFlightPayloadData = _require4.refineToReactFlightPayloadData,
-    REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY = _require4.REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY,
-    REACT_FLIGHT_TREE_STORAGE_KEY = _require4.REACT_FLIGHT_TREE_STORAGE_KEY,
-    REACT_FLIGHT_TYPE_NAME = _require4.REACT_FLIGHT_TYPE_NAME;
-
-var _require5 = require('./RelayStoreUtils'),
-    getArgumentValues = _require5.getArgumentValues,
-    getHandleStorageKey = _require5.getHandleStorageKey,
-    getModuleComponentKey = _require5.getModuleComponentKey,
-    getModuleOperationKey = _require5.getModuleOperationKey,
-    getStorageKey = _require5.getStorageKey,
-    TYPENAME_KEY = _require5.TYPENAME_KEY,
-    ROOT_ID = _require5.ROOT_ID,
-    ROOT_TYPE = _require5.ROOT_TYPE;
-
-var _require6 = require('./TypeID'),
-    generateTypeID = _require6.generateTypeID,
-    TYPE_SCHEMA_TYPE = _require6.TYPE_SCHEMA_TYPE;
-
 /**
  * Normalizes the results of a query and standard GraphQL response, writing the
  * normalized records/fields into the given MutableRecordSource.
@@ -91,13 +97,14 @@ function normalize(recordSource, selector, response, options) {
 
 var RelayResponseNormalizer = /*#__PURE__*/function () {
   function RelayResponseNormalizer(recordSource, variables, options) {
+    this._actorIdentifier = options.actorIdentifier;
     this._getDataId = options.getDataID;
     this._handleFieldPayloads = [];
     this._treatMissingFieldsAsNull = options.treatMissingFieldsAsNull;
     this._incrementalPlaceholders = [];
     this._isClientExtension = false;
     this._isUnmatchedAbstractType = false;
-    this._moduleImportPayloads = [];
+    this._followupPayloads = [];
     this._path = options.path ? (0, _toConsumableArray2["default"])(options.path) : [];
     this._recordSource = recordSource;
     this._variables = variables;
@@ -119,15 +126,14 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
       errors: null,
       fieldPayloads: this._handleFieldPayloads,
       incrementalPlaceholders: this._incrementalPlaceholders,
-      moduleImportPayloads: this._moduleImportPayloads,
+      followupPayloads: this._followupPayloads,
       source: this._recordSource,
       isFinal: false
     };
   };
 
   _proto._getVariableValue = function _getVariableValue(name) {
-    !this._variables.hasOwnProperty(name) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer(): Undefined variable `%s`.', name) : invariant(false) : void 0; // $FlowFixMe[cannot-write]
-
+    !this._variables.hasOwnProperty(name) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer(): Undefined variable `%s`.', name) : invariant(false) : void 0;
     return this._variables[name];
   };
 
@@ -149,7 +155,7 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
           break;
 
         case CONDITION:
-          var conditionValue = this._getVariableValue(selection.condition);
+          var conditionValue = Boolean(this._getVariableValue(selection.condition));
 
           if (conditionValue === selection.passingValue) {
             this._traverseSelections(selection, record, data);
@@ -159,8 +165,12 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
 
         case FRAGMENT_SPREAD:
           {
+            var prevVariables = this._variables;
+            this._variables = getLocalVariables(this._variables, selection.fragment.argumentDefinitions, selection.args);
+
             this._traverseSelections(selection.fragment, record, data);
 
+            this._variables = prevVariables;
             break;
           }
 
@@ -174,7 +184,7 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
               if (_typeName === selection.type) {
                 this._traverseSelections(selection, record, data);
               }
-            } else if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
+            } else {
               var implementsInterface = data.hasOwnProperty(abstractKey);
 
               var _typeName2 = RelayModernRecord.getType(record);
@@ -194,18 +204,6 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
               if (implementsInterface) {
                 this._traverseSelections(selection, record, data);
               }
-            } else {
-              // legacy behavior for abstract refinements: always normalize even
-              // if the type doesn't conform, but track if the type matches or not
-              // for determining whether response fields are expected to be present
-              var _implementsInterface = data.hasOwnProperty(abstractKey);
-
-              var parentIsUnmatchedAbstractType = this._isUnmatchedAbstractType;
-              this._isUnmatchedAbstractType = this._isUnmatchedAbstractType || !_implementsInterface;
-
-              this._traverseSelections(selection, record, data);
-
-              this._isUnmatchedAbstractType = parentIsUnmatchedAbstractType;
             }
 
             break;
@@ -213,26 +211,23 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
 
         case TYPE_DISCRIMINATOR:
           {
-            if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
-              var _abstractKey = selection.abstractKey;
+            var _abstractKey = selection.abstractKey;
 
-              var _implementsInterface2 = data.hasOwnProperty(_abstractKey);
+            var _implementsInterface = data.hasOwnProperty(_abstractKey);
 
-              var _typeName3 = RelayModernRecord.getType(record);
+            var _typeName3 = RelayModernRecord.getType(record);
 
-              var _typeID = generateTypeID(_typeName3);
+            var _typeID = generateTypeID(_typeName3);
 
-              var _typeRecord = this._recordSource.get(_typeID);
+            var _typeRecord = this._recordSource.get(_typeID);
 
-              if (_typeRecord == null) {
-                _typeRecord = RelayModernRecord.create(_typeID, TYPE_SCHEMA_TYPE);
+            if (_typeRecord == null) {
+              _typeRecord = RelayModernRecord.create(_typeID, TYPE_SCHEMA_TYPE);
 
-                this._recordSource.set(_typeID, _typeRecord);
-              }
-
-              RelayModernRecord.setValue(_typeRecord, _abstractKey, _implementsInterface2);
+              this._recordSource.set(_typeID, _typeRecord);
             }
 
+            RelayModernRecord.setValue(_typeRecord, _abstractKey, _implementsInterface);
             break;
           }
 
@@ -243,12 +238,17 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
           var handleKey = getHandleStorageKey(selection, this._variables);
 
           this._handleFieldPayloads.push({
+            /* $FlowFixMe[class-object-subtyping] added when improving typing
+             * for this parameters */
             args: args,
             dataID: RelayModernRecord.getDataID(record),
             fieldKey: fieldKey,
             handle: selection.handle,
             handleKey: handleKey,
-            handleArgs: selection.handleArgs ? getArgumentValues(selection.handleArgs, this._variables) : {}
+            handleArgs: selection.handleArgs ?
+            /* $FlowFixMe[class-object-subtyping] added when improving typing
+             * for this parameters */
+            getArgumentValues(selection.handleArgs, this._variables) : {}
           });
 
           break;
@@ -295,6 +295,11 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
 
           break;
 
+        case ACTOR_CHANGE:
+          this._normalizeActorChange(node, selection, record, data);
+
+          break;
+
         default:
           selection;
           !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer(): Unexpected ast kind `%s`.', selection.kind) : invariant(false) : void 0;
@@ -322,7 +327,8 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
         label: defer.label,
         path: (0, _toConsumableArray2["default"])(this._path),
         selector: createNormalizationSelector(defer, RelayModernRecord.getDataID(record), this._variables),
-        typeName: RelayModernRecord.getType(record)
+        typeName: RelayModernRecord.getType(record),
+        actorIdentifier: this._actorIdentifier
       });
     }
   };
@@ -348,7 +354,8 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
         path: (0, _toConsumableArray2["default"])(this._path),
         parentID: RelayModernRecord.getDataID(record),
         node: stream,
-        variables: this._variables
+        variables: this._variables,
+        actorIdentifier: this._actorIdentifier
       });
     }
   };
@@ -364,13 +371,16 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
     RelayModernRecord.setValue(record, operationKey, operationReference !== null && operationReference !== void 0 ? operationReference : null);
 
     if (operationReference != null) {
-      this._moduleImportPayloads.push({
+      this._followupPayloads.push({
+        kind: 'ModuleImportPayload',
+        args: moduleImport.args,
         data: data,
         dataID: RelayModernRecord.getDataID(record),
         operationReference: operationReference,
         path: (0, _toConsumableArray2["default"])(this._path),
         typeName: typeName,
-        variables: this._variables
+        variables: this._variables,
+        actorIdentifier: this._actorIdentifier
       });
     }
   };
@@ -411,7 +421,11 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
 
       if (process.env.NODE_ENV !== "production") {
         if (selection.kind === SCALAR_FIELD) {
-          this._validateConflictingFieldsWithIdenticalId(record, storageKey, fieldValue);
+          this._validateConflictingFieldsWithIdenticalId(record, storageKey, // When using `treatMissingFieldsAsNull` the conflicting validation raises a false positive
+          // because the value is set using `null` but validated using `fieldValue` which at this point
+          // will be `undefined`.
+          // Setting this to `null` matches the value that we actually set to the `fieldValue`.
+          null);
         }
       }
 
@@ -441,19 +455,97 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
     }
   };
 
+  _proto._normalizeActorChange = function _normalizeActorChange(parent, selection, record, data) {
+    var _field$concreteType;
+
+    var field = selection.linkedField;
+    !(typeof data === 'object' && data) ? process.env.NODE_ENV !== "production" ? invariant(false, '_normalizeActorChange(): Expected data for field `%s` to be an object.', field.name) : invariant(false) : void 0;
+    var responseKey = field.alias || field.name;
+    var storageKey = getStorageKey(field, this._variables);
+    var fieldValue = data[responseKey];
+
+    if (fieldValue == null) {
+      if (fieldValue === undefined) {
+        var isOptionalField = this._isClientExtension || this._isUnmatchedAbstractType;
+
+        if (isOptionalField) {
+          return;
+        } else if (!this._treatMissingFieldsAsNull) {
+          if (process.env.NODE_ENV !== "production") {
+            process.env.NODE_ENV !== "production" ? warning(false, 'RelayResponseNormalizer: Payload did not contain a value ' + 'for field `%s: %s`. Check that you are parsing with the same ' + 'query that was used to fetch the payload.', responseKey, storageKey) : void 0;
+          }
+
+          return;
+        }
+      }
+
+      RelayModernRecord.setValue(record, storageKey, null);
+      return;
+    }
+
+    var actorIdentifier = getActorIdentifierFromPayload(fieldValue);
+
+    if (actorIdentifier == null) {
+      if (process.env.NODE_ENV !== "production") {
+        process.env.NODE_ENV !== "production" ? warning(false, 'RelayResponseNormalizer: Payload did not contain a value ' + 'for field `%s`. Check that you are parsing with the same ' + 'query that was used to fetch the payload. Payload is `%s`.', ACTOR_IDENTIFIER_FIELD_NAME, JSON.stringify(fieldValue, null, 2)) : void 0;
+      }
+
+      RelayModernRecord.setValue(record, storageKey, null);
+      return;
+    } // $FlowFixMe[incompatible-call]
+
+
+    var typeName = (_field$concreteType = field.concreteType) !== null && _field$concreteType !== void 0 ? _field$concreteType : this._getRecordType(fieldValue);
+    var nextID = this._getDataId( // $FlowFixMe[incompatible-call]
+    fieldValue, typeName) || RelayModernRecord.getLinkedRecordID(record, storageKey) || generateClientID(RelayModernRecord.getDataID(record), storageKey);
+    !(typeof nextID === 'string') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer: Expected id on field `%s` to be a string.', storageKey) : invariant(false) : void 0;
+    RelayModernRecord.setActorLinkedRecordID(record, storageKey, actorIdentifier, nextID);
+
+    this._followupPayloads.push({
+      kind: 'ActorPayload',
+      data: fieldValue,
+      dataID: nextID,
+      path: [].concat((0, _toConsumableArray2["default"])(this._path), [responseKey]),
+      typeName: typeName,
+      variables: this._variables,
+      node: field,
+      actorIdentifier: actorIdentifier
+    });
+  };
+
   _proto._normalizeFlightField = function _normalizeFlightField(parent, selection, record, data) {
     var responseKey = selection.alias || selection.name;
     var storageKey = getStorageKey(selection, this._variables);
     var fieldValue = data[responseKey];
 
     if (fieldValue == null) {
+      if (fieldValue === undefined) {
+        // Flight field may be missing in the response if:
+        // - It is inside an abstract type refinement where the concrete type does
+        //   not conform to the interface/union.
+        // However an otherwise-required field may also be missing if the server
+        // is configured to skip fields with `null` values, in which case the
+        // client is assumed to be correctly configured with
+        // treatMissingFieldsAsNull=true.
+        if (this._isUnmatchedAbstractType) {
+          // Field not expected to exist regardless of whether the server is pruning null
+          // fields or not.
+          return;
+        } else {
+          // Not optional and the server is not pruning null fields: field is expected
+          // to be present
+          !this._treatMissingFieldsAsNull ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer: Payload did not contain a value for ' + 'field `%s: %s`. Check that you are parsing with the same ' + 'query that was used to fetch the payload.', responseKey, storageKey) : invariant(false) : void 0;
+        }
+      }
+
       RelayModernRecord.setValue(record, storageKey, null);
       return;
     }
 
     var reactFlightPayload = refineToReactFlightPayloadData(fieldValue);
+    var reactFlightPayloadDeserializer = this._reactFlightPayloadDeserializer;
     !(reactFlightPayload != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer: Expected React Flight payload data to be an ' + 'object with `status`, tree`, `queries` and `errors` properties, got ' + '`%s`.', fieldValue) : invariant(false) : void 0;
-    !(typeof this._reactFlightPayloadDeserializer === 'function') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer: Expected reactFlightPayloadDeserializer to ' + 'be a function, got `%s`.', this._reactFlightPayloadDeserializer) : invariant(false) : void 0;
+    !(typeof reactFlightPayloadDeserializer === 'function') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer: Expected reactFlightPayloadDeserializer to ' + 'be a function, got `%s`.', reactFlightPayloadDeserializer) : invariant(false) : void 0;
 
     if (reactFlightPayload.errors.length > 0) {
       if (typeof this._reactFlightServerErrorHandler === 'function') {
@@ -461,22 +553,7 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
       } else {
         process.env.NODE_ENV !== "production" ? warning(false, 'RelayResponseNormalizer: Received server errors for field `%s`.\n\n' + '%s\n%s', responseKey, reactFlightPayload.errors[0].message, reactFlightPayload.errors[0].stack) : void 0;
       }
-    } // This typically indicates that a fatal server error prevented rows from
-    // being written. When this occurs, we should not continue normalization of
-    // the Flight field because the row response is malformed.
-    //
-    // Receiving empty rows is OK because it can indicate the start of a stream.
-
-
-    if (reactFlightPayload.tree == null) {
-      process.env.NODE_ENV !== "production" ? warning(false, 'RelayResponseNormalizer: Expected `tree` not to be null. This ' + 'typically indicates that a fatal server error prevented any Server ' + 'Component rows from being written.') : void 0;
-      return;
-    } // We store the deserialized reactFlightClientResponse in a separate
-    // record and link it to the parent record. This is so we can GC the Flight
-    // tree later even if the parent record is still reachable.
-
-
-    var reactFlightClientResponse = this._reactFlightPayloadDeserializer(reactFlightPayload.tree);
+    }
 
     var reactFlightID = generateClientID(RelayModernRecord.getDataID(record), getStorageKey(selection, this._variables));
 
@@ -488,6 +565,25 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
       this._recordSource.set(reactFlightID, reactFlightClientResponseRecord);
     }
 
+    if (reactFlightPayload.tree == null) {
+      // This typically indicates that a fatal server error prevented rows from
+      // being written. When this occurs, we should not continue normalization of
+      // the Flight field because the row response is malformed.
+      //
+      // Receiving empty rows is OK because it can indicate the start of a stream.
+      process.env.NODE_ENV !== "production" ? warning(false, 'RelayResponseNormalizer: Expected `tree` not to be null. This ' + 'typically indicates that a fatal server error prevented any Server ' + 'Component rows from being written.') : void 0; // We create the flight record with a null value for the tree
+      // and empty reachable definitions
+
+      RelayModernRecord.setValue(reactFlightClientResponseRecord, REACT_FLIGHT_TREE_STORAGE_KEY, null);
+      RelayModernRecord.setValue(reactFlightClientResponseRecord, REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY, []);
+      RelayModernRecord.setLinkedRecordID(record, storageKey, reactFlightID);
+      return;
+    } // We store the deserialized reactFlightClientResponse in a separate
+    // record and link it to the parent record. This is so we can GC the Flight
+    // tree later even if the parent record is still reachable.
+
+
+    var reactFlightClientResponse = reactFlightPayloadDeserializer(reactFlightPayload.tree);
     RelayModernRecord.setValue(reactFlightClientResponseRecord, REACT_FLIGHT_TREE_STORAGE_KEY, reactFlightClientResponse);
     var reachableExecutableDefinitions = [];
 
@@ -499,13 +595,16 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
         var query = _step.value;
 
         if (query.response.data != null) {
-          this._moduleImportPayloads.push({
+          this._followupPayloads.push({
+            kind: 'ModuleImportPayload',
+            args: null,
             data: query.response.data,
             dataID: ROOT_ID,
             operationReference: query.module,
             path: [],
             typeName: ROOT_TYPE,
-            variables: query.variables
+            variables: query.variables,
+            actorIdentifier: this._actorIdentifier
           });
         }
 
@@ -528,13 +627,16 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
         var fragment = _step2.value;
 
         if (fragment.response.data != null) {
-          this._moduleImportPayloads.push({
+          this._followupPayloads.push({
+            kind: 'ModuleImportPayload',
+            args: null,
             data: fragment.response.data,
             dataID: fragment.__id,
             operationReference: fragment.module,
             path: [],
             typeName: fragment.__typename,
-            variables: fragment.variables
+            variables: fragment.variables,
+            actorIdentifier: this._actorIdentifier
           });
         }
 
@@ -554,12 +656,12 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
   };
 
   _proto._normalizeLink = function _normalizeLink(field, record, storageKey, fieldValue) {
-    var _field$concreteType;
+    var _field$concreteType2;
 
     !(typeof fieldValue === 'object' && fieldValue) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer: Expected data for field `%s` to be an object.', storageKey) : invariant(false) : void 0;
     var nextID = this._getDataId( // $FlowFixMe[incompatible-variance]
     fieldValue, // $FlowFixMe[incompatible-variance]
-    (_field$concreteType = field.concreteType) !== null && _field$concreteType !== void 0 ? _field$concreteType : this._getRecordType(fieldValue)) || // Reuse previously generated client IDs
+    (_field$concreteType2 = field.concreteType) !== null && _field$concreteType2 !== void 0 ? _field$concreteType2 : this._getRecordType(fieldValue)) || // Reuse previously generated client IDs
     RelayModernRecord.getLinkedRecordID(record, storageKey) || generateClientID(RelayModernRecord.getDataID(record), storageKey);
     !(typeof nextID === 'string') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer: Expected id on field `%s` to be a string.', storageKey) : invariant(false) : void 0;
 
@@ -593,7 +695,7 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
     var prevIDs = RelayModernRecord.getLinkedRecordIDs(record, storageKey);
     var nextIDs = [];
     fieldValue.forEach(function (item, nextIndex) {
-      var _field$concreteType2;
+      var _field$concreteType3;
 
       // validate response data
       if (item == null) {
@@ -606,7 +708,7 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
       !(typeof item === 'object') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer: Expected elements for field `%s` to be ' + 'objects.', storageKey) : invariant(false) : void 0;
       var nextID = _this._getDataId( // $FlowFixMe[incompatible-variance]
       item, // $FlowFixMe[incompatible-variance]
-      (_field$concreteType2 = field.concreteType) !== null && _field$concreteType2 !== void 0 ? _field$concreteType2 : _this._getRecordType(item)) || prevIDs && prevIDs[nextIndex] || // Reuse previously generated client IDs:
+      (_field$concreteType3 = field.concreteType) !== null && _field$concreteType3 !== void 0 ? _field$concreteType3 : _this._getRecordType(item)) || prevIDs && prevIDs[nextIndex] || // Reuse previously generated client IDs:
       generateClientID(RelayModernRecord.getDataID(record), storageKey, nextIndex);
       !(typeof nextID === 'string') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer: Expected id of elements of field `%s` to ' + 'be strings.', storageKey) : invariant(false) : void 0;
       nextIDs.push(nextID);
@@ -645,9 +747,9 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
   ;
 
   _proto._validateRecordType = function _validateRecordType(record, field, payload) {
-    var _field$concreteType3;
+    var _field$concreteType4;
 
-    var typeName = (_field$concreteType3 = field.concreteType) !== null && _field$concreteType3 !== void 0 ? _field$concreteType3 : this._getRecordType(payload);
+    var typeName = (_field$concreteType4 = field.concreteType) !== null && _field$concreteType4 !== void 0 ? _field$concreteType4 : this._getRecordType(payload);
     var dataID = RelayModernRecord.getDataID(record);
     process.env.NODE_ENV !== "production" ? warning(isClientID(dataID) && dataID !== ROOT_ID || RelayModernRecord.getType(record) === typeName, 'RelayResponseNormalizer: Invalid record `%s`. Expected %s to be ' + 'consistent, but the record was assigned conflicting types `%s` ' + 'and `%s`. The GraphQL server likely violated the globally unique ' + 'id requirement by returning the same id for different objects.', dataID, TYPENAME_KEY, RelayModernRecord.getType(record), typeName) : void 0;
   }
@@ -679,7 +781,6 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
   return RelayResponseNormalizer;
 }();
 
-var instrumentedNormalize = RelayProfiler.instrument('RelayResponseNormalizer.normalize', normalize);
 module.exports = {
-  normalize: instrumentedNormalize
+  normalize: normalize
 };

package/lib/store/RelayStoreReactFlightUtils.js

@@ -10,13 +10,13 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var invariant = require("fbjs/lib/invariant");
-
 var _require = require('./RelayModernRecord'),
     getType = _require.getType;
 
-// Reachable (client) executable definitions encountered while server component
+var invariant = require('invariant'); // Reachable (client) executable definitions encountered while server component
 // rendering
+
+
 var REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY = 'executableDefinitions';
 var REACT_FLIGHT_TREE_STORAGE_KEY = 'tree';
 var REACT_FLIGHT_TYPE_NAME = 'ReactFlightComponent';
@@ -31,13 +31,7 @@ function refineToReactFlightPayloadData(payload) {
 
 function getReactFlightClientResponse(record) {
   !(getType(record) === REACT_FLIGHT_TYPE_NAME) ? process.env.NODE_ENV !== "production" ? invariant(false, 'getReactFlightClientResponse(): Expected a ReactFlightComponentRecord, ' + 'got %s.', record) : invariant(false) : void 0;
-  var response = record[REACT_FLIGHT_TREE_STORAGE_KEY];
-
-  if (response != null) {
-    return response;
-  }
-
-  return null;
+  return record[REACT_FLIGHT_TREE_STORAGE_KEY];
 }
 
 module.exports = {

package/lib/store/RelayStoreSubscriptions.js

@@ -10,20 +10,21 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var RelayFeatureFlags = require('../util/RelayFeatureFlags');
+var deepFreeze = require('../util/deepFreeze');
 
-var RelayReader = require('./RelayReader');
+var recycleNodesInto = require('../util/recycleNodesInto');
 
-var deepFreeze = require('../util/deepFreeze');
+var RelayFeatureFlags = require('../util/RelayFeatureFlags');
 
 var hasOverlappingIDs = require('./hasOverlappingIDs');
 
-var recycleNodesInto = require('../util/recycleNodesInto');
+var RelayReader = require('./RelayReader');
 
 var RelayStoreSubscriptions = /*#__PURE__*/function () {
-  function RelayStoreSubscriptions(log) {
+  function RelayStoreSubscriptions(log, resolverCache) {
     this._subscriptions = new Set();
     this.__log = log;
+    this._resolverCache = resolverCache;
   }
 
   var _proto = RelayStoreSubscriptions.prototype;
@@ -50,6 +51,8 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
   };
 
   _proto.snapshotSubscriptions = function snapshotSubscriptions(source) {
+    var _this2 = this;
+
     this._subscriptions.forEach(function (subscription) {
       // Backup occurs after writing a new "final" payload(s) and before (re)applying
       // optimistic changes. Each subscription's `snapshot` represents what was *last
@@ -69,7 +72,7 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
       }
 
       var snapshot = subscription.snapshot;
-      var backup = RelayReader.read(source, snapshot.selector);
+      var backup = RelayReader.read(source, snapshot.selector, _this2._resolverCache);
       var nextData = recycleNodesInto(snapshot.data, backup.data);
       backup.data = nextData; // backup owns the snapshot and can safely mutate
 
@@ -90,6 +93,7 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
         subscription.snapshot = {
           data: subscription.snapshot.data,
           isMissingData: backup.isMissingData,
+          missingClientEdges: backup.missingClientEdges,
           seenRecords: backup.seenRecords,
           selector: backup.selector,
           missingRequiredFields: backup.missingRequiredFields
@@ -101,12 +105,12 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
   };
 
   _proto.updateSubscriptions = function updateSubscriptions(source, updatedRecordIDs, updatedOwners, sourceOperation) {
-    var _this2 = this;
+    var _this3 = this;
 
     var hasUpdatedRecords = updatedRecordIDs.size !== 0;
 
     this._subscriptions.forEach(function (subscription) {
-      var owner = _this2._updateSubscription(source, subscription, updatedRecordIDs, hasUpdatedRecords, sourceOperation);
+      var owner = _this3._updateSubscription(source, subscription, updatedRecordIDs, hasUpdatedRecords, sourceOperation);
 
       if (owner != null) {
         updatedOwners.push(owner);
@@ -134,11 +138,12 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
       return;
     }
 
-    var nextSnapshot = hasOverlappingUpdates || !backup ? RelayReader.read(source, snapshot.selector) : backup;
+    var nextSnapshot = hasOverlappingUpdates || !backup ? RelayReader.read(source, snapshot.selector, this._resolverCache) : backup;
     var nextData = recycleNodesInto(snapshot.data, nextSnapshot.data);
     nextSnapshot = {
       data: nextData,
       isMissingData: nextSnapshot.isMissingData,
+      missingClientEdges: nextSnapshot.missingClientEdges,
       seenRecords: nextSnapshot.seenRecords,
       selector: nextSnapshot.selector,
       missingRequiredFields: nextSnapshot.missingRequiredFields