relay-runtime 9.0.0 → 10.1.0

package/lib/store/RelayResponseNormalizer.js

@@ -14,10 +14,20 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var RelayFeatureFlags = require('../util/RelayFeatureFlags');
+
 var RelayModernRecord = require('./RelayModernRecord');
 
 var RelayProfiler = require('../util/RelayProfiler');
 
+var areEqual = require("fbjs/lib/areEqual");
+
 var invariant = require("fbjs/lib/invariant");
 
 var warning = require("fbjs/lib/warning");
@@ -26,13 +36,15 @@ var _require = require('../util/RelayConcreteNode'),
     CONDITION = _require.CONDITION,
     CLIENT_EXTENSION = _require.CLIENT_EXTENSION,
     DEFER = _require.DEFER,
+    FLIGHT_FIELD = _require.FLIGHT_FIELD,
     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;
+    STREAM = _require.STREAM,
+    TYPE_DISCRIMINATOR = _require.TYPE_DISCRIMINATOR;
 
 var _require2 = require('./ClientID'),
     generateClientID = _require2.generateClientID,
@@ -41,13 +53,25 @@ var _require2 = require('./ClientID'),
 var _require3 = require('./RelayModernSelector'),
     createNormalizationSelector = _require3.createNormalizationSelector;
 
-var _require4 = require('./RelayStoreUtils'),
-    getArgumentValues = _require4.getArgumentValues,
-    getHandleStorageKey = _require4.getHandleStorageKey,
-    getModuleComponentKey = _require4.getModuleComponentKey,
-    getModuleOperationKey = _require4.getModuleOperationKey,
-    getStorageKey = _require4.getStorageKey,
-    TYPENAME_KEY = _require4.TYPENAME_KEY;
+var _require4 = require('./RelayStoreReactFlightUtils'),
+    refineToReactFlightPayloadData = _require4.refineToReactFlightPayloadData,
+    REACT_FLIGHT_QUERIES_STORAGE_KEY = _require4.REACT_FLIGHT_QUERIES_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
@@ -67,19 +91,19 @@ function normalize(recordSource, selector, response, options) {
  */
 
 
-var RelayResponseNormalizer =
-/*#__PURE__*/
-function () {
+var RelayResponseNormalizer = /*#__PURE__*/function () {
   function RelayResponseNormalizer(recordSource, variables, options) {
     this._getDataId = options.getDataID;
     this._handleFieldPayloads = [];
+    this._treatMissingFieldsAsNull = options.treatMissingFieldsAsNull;
     this._incrementalPlaceholders = [];
     this._isClientExtension = false;
+    this._isUnmatchedAbstractType = false;
     this._moduleImportPayloads = [];
     this._path = options.path ? (0, _toConsumableArray2["default"])(options.path) : [];
     this._recordSource = recordSource;
-    this._request = options.request;
     this._variables = variables;
+    this._reactFlightPayloadDeserializer = options.reactFlightPayloadDeserializer;
   }
 
   var _proto = RelayResponseNormalizer.prototype;
@@ -133,13 +157,76 @@ function () {
           break;
 
         case INLINE_FRAGMENT:
-          var _typeName = RelayModernRecord.getType(record);
+          {
+            var abstractKey = selection.abstractKey;
 
-          if (_typeName === selection.type) {
-            this._traverseSelections(selection, record, data);
+            if (abstractKey == null) {
+              var _typeName = RelayModernRecord.getType(record);
+
+              if (_typeName === selection.type) {
+                this._traverseSelections(selection, record, data);
+              }
+            } else if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
+              var implementsInterface = data.hasOwnProperty(abstractKey);
+
+              var _typeName2 = RelayModernRecord.getType(record);
+
+              var typeID = generateTypeID(_typeName2);
+
+              var typeRecord = this._recordSource.get(typeID);
+
+              if (typeRecord == null) {
+                typeRecord = RelayModernRecord.create(typeID, TYPE_SCHEMA_TYPE);
+
+                this._recordSource.set(typeID, typeRecord);
+              }
+
+              RelayModernRecord.setValue(typeRecord, abstractKey, implementsInterface);
+
+              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;
           }
 
-          break;
+        case TYPE_DISCRIMINATOR:
+          {
+            if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
+              var _abstractKey = selection.abstractKey;
+
+              var _implementsInterface2 = data.hasOwnProperty(_abstractKey);
+
+              var _typeName3 = RelayModernRecord.getType(record);
+
+              var _typeID = generateTypeID(_typeName3);
+
+              var _typeRecord = this._recordSource.get(_typeID);
+
+              if (_typeRecord == null) {
+                _typeRecord = RelayModernRecord.create(_typeID, TYPE_SCHEMA_TYPE);
+
+                this._recordSource.set(_typeID, _typeRecord);
+              }
+
+              RelayModernRecord.setValue(_typeRecord, _abstractKey, _implementsInterface2);
+            }
+
+            break;
+          }
 
         case LINKED_HANDLE:
         case SCALAR_HANDLE:
@@ -152,7 +239,8 @@ function () {
             dataID: RelayModernRecord.getDataID(record),
             fieldKey: fieldKey,
             handle: selection.handle,
-            handleKey: handleKey
+            handleKey: handleKey,
+            handleArgs: selection.handleArgs ? getArgumentValues(selection.handleArgs, this._variables) : {}
           });
 
           break;
@@ -181,6 +269,15 @@ function () {
           this._isClientExtension = isClientExtension;
           break;
 
+        case FLIGHT_FIELD:
+          if (RelayFeatureFlags.ENABLE_REACT_FLIGHT_COMPONENT_FIELD) {
+            this._normalizeFlightField(node, selection, record, data);
+          } else {
+            throw new Error('Flight fields are not yet supported.');
+          }
+
+          break;
+
         default:
           selection;
           !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer(): Unexpected ast kind `%s`.', selection.kind) : invariant(false) : void 0;
@@ -240,16 +337,14 @@ function () {
   };
 
   _proto._normalizeModuleImport = function _normalizeModuleImport(parent, moduleImport, record, data) {
-    var _componentReference, _operationReference;
-
     !(typeof data === 'object' && data) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer: Expected data for @module to be an object.') : invariant(false) : void 0;
     var typeName = RelayModernRecord.getType(record);
     var componentKey = getModuleComponentKey(moduleImport.documentName);
     var componentReference = data[componentKey];
-    RelayModernRecord.setValue(record, componentKey, (_componentReference = componentReference) !== null && _componentReference !== void 0 ? _componentReference : null);
+    RelayModernRecord.setValue(record, componentKey, componentReference !== null && componentReference !== void 0 ? componentReference : null);
     var operationKey = getModuleOperationKey(moduleImport.documentName);
     var operationReference = data[operationKey];
-    RelayModernRecord.setValue(record, operationKey, (_operationReference = operationReference) !== null && _operationReference !== void 0 ? _operationReference : null);
+    RelayModernRecord.setValue(record, operationKey, operationReference !== null && operationReference !== void 0 ? operationReference : null);
 
     if (operationReference != null) {
       this._moduleImportPayloads.push({
@@ -271,20 +366,36 @@ function () {
 
     if (fieldValue == null) {
       if (fieldValue === undefined) {
-        // Fields that are missing in the response are not set on the record.
-        // There are three main cases where this can occur:
+        // Fields may be missing in the response in two main cases:
         // - Inside a client extension: the server will not generally return
         //   values for these fields, but a local update may provide them.
-        // - Fields on abstract types: these may be missing if the concrete
-        //   response type does not match the abstract type.
-        //
-        // Otherwise, missing fields usually indicate a server or user error (
-        // the latter for manually constructed payloads).
-        if (process.env.NODE_ENV !== "production") {
-          process.env.NODE_ENV !== "production" ? warning(this._isClientExtension || parent.kind === LINKED_FIELD && parent.concreteType == null ? true : Object.prototype.hasOwnProperty.call(data, responseKey), '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;
+        // - 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.
+        var isOptionalField = this._isClientExtension || this._isUnmatchedAbstractType;
+
+        if (isOptionalField) {
+          // Field not expected to exist regardless of whether the server is pruning null
+          // fields or not.
+          return;
+        } else if (!this._treatMissingFieldsAsNull) {
+          // Not optional and the server is not pruning null fields: field is expected
+          // to be present
+          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;
         }
+      }
 
-        return;
+      if (process.env.NODE_ENV !== "production") {
+        if (selection.kind === SCALAR_FIELD) {
+          this._validateConflictingFieldsWithIdenticalId(record, storageKey, fieldValue);
+        }
       }
 
       RelayModernRecord.setValue(record, storageKey, null);
@@ -292,6 +403,10 @@ function () {
     }
 
     if (selection.kind === SCALAR_FIELD) {
+      if (process.env.NODE_ENV !== "production") {
+        this._validateConflictingFieldsWithIdenticalId(record, storageKey, fieldValue);
+      }
+
       RelayModernRecord.setValue(record, storageKey, fieldValue);
     } else if (selection.kind === LINKED_FIELD) {
       this._path.push(responseKey);
@@ -309,40 +424,98 @@ function () {
     }
   };
 
+  _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) {
+      RelayModernRecord.setValue(record, storageKey, null);
+      return;
+    }
+
+    var reactFlightPayload = refineToReactFlightPayloadData(fieldValue);
+    !(reactFlightPayload != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayResponseNormalizer(): Expected React Flight payload data ' + 'to be an object with `tree` and `queries` 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; // 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));
+
+    var reactFlightClientResponseRecord = this._recordSource.get(reactFlightID);
+
+    if (reactFlightClientResponseRecord == null) {
+      reactFlightClientResponseRecord = RelayModernRecord.create(reactFlightID, REACT_FLIGHT_TYPE_NAME);
+
+      this._recordSource.set(reactFlightID, reactFlightClientResponseRecord);
+    }
+
+    RelayModernRecord.setValue(reactFlightClientResponseRecord, REACT_FLIGHT_TREE_STORAGE_KEY, reactFlightClientResponse);
+    var reachableQueries = [];
+
+    var _iterator = _createForOfIteratorHelper(reactFlightPayload.queries),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var query = _step.value;
+
+        if (query.response.data != null) {
+          this._moduleImportPayloads.push({
+            data: query.response.data,
+            dataID: ROOT_ID,
+            operationReference: query.module,
+            path: [],
+            typeName: ROOT_TYPE,
+            variables: query.variables
+          });
+        }
+
+        reachableQueries.push({
+          module: query.module,
+          variables: query.variables
+        });
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    RelayModernRecord.setValue(reactFlightClientResponseRecord, REACT_FLIGHT_QUERIES_STORAGE_KEY, reachableQueries);
+    RelayModernRecord.setLinkedRecordID(record, storageKey, reactFlightID);
+  };
+
   _proto._normalizeLink = function _normalizeLink(field, record, storageKey, fieldValue) {
     var _field$concreteType;
 
     !(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(>=0.98.0 site=www,mobile,react_native_fb,oss) This comment
-     * suppresses an error found when Flow v0.98 was deployed. To see the
-     * error delete this comment and run Flow. */
-    fieldValue,
-    /* $FlowFixMe(>=0.98.0 site=www,mobile,react_native_fb,oss) This comment
-     * suppresses an error found when Flow v0.98 was deployed. To see the
-     * error delete this comment and run Flow. */
+    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
     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;
+
+    if (process.env.NODE_ENV !== "production") {
+      this._validateConflictingLinkedFieldsWithIdenticalId(record, RelayModernRecord.getLinkedRecordID(record, storageKey), nextID, storageKey);
+    }
+
     RelayModernRecord.setLinkedRecordID(record, storageKey, nextID);
 
     var nextRecord = this._recordSource.get(nextID);
 
     if (!nextRecord) {
-      /* $FlowFixMe(>=0.98.0 site=www,mobile,react_native_fb,oss) This comment
-       * suppresses an error found when Flow v0.98 was deployed. To see the
-       * error delete this comment and run Flow. */
-      var _typeName2 = field.concreteType || this._getRecordType(fieldValue);
+      // $FlowFixMe[incompatible-variance]
+      var _typeName4 = field.concreteType || this._getRecordType(fieldValue);
 
-      nextRecord = RelayModernRecord.create(nextID, _typeName2);
+      nextRecord = RelayModernRecord.create(nextID, _typeName4);
 
       this._recordSource.set(nextID, nextRecord);
     } else if (process.env.NODE_ENV !== "production") {
       this._validateRecordType(nextRecord, field, fieldValue);
-    }
-    /* $FlowFixMe(>=0.98.0 site=www,mobile,react_native_fb,oss) This comment
-     * suppresses an error found when Flow v0.98 was deployed. To see the error
-     * delete this comment and run Flow. */
+    } // $FlowFixMe[incompatible-variance]
 
 
     this._traverseSelections(field, nextRecord, fieldValue);
@@ -366,14 +539,8 @@ function () {
       _this._path.push(String(nextIndex));
 
       !(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(>=0.98.0 site=www,mobile,react_native_fb,oss) This comment
-       * suppresses an error found when Flow v0.98 was deployed. To see the
-       * error delete this comment and run Flow. */
-      item,
-      /* $FlowFixMe(>=0.98.0 site=www,mobile,react_native_fb,oss) This comment
-       * suppresses an error found when Flow v0.98 was deployed. To see the
-       * error delete this comment and run Flow. */
+      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:
       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;
@@ -382,20 +549,23 @@ function () {
       var nextRecord = _this._recordSource.get(nextID);
 
       if (!nextRecord) {
-        /* $FlowFixMe(>=0.98.0 site=www,mobile,react_native_fb,oss) This comment
-         * suppresses an error found when Flow v0.98 was deployed. To see the
-         * error delete this comment and run Flow. */
-        var _typeName3 = field.concreteType || _this._getRecordType(item);
+        // $FlowFixMe[incompatible-variance]
+        var _typeName5 = field.concreteType || _this._getRecordType(item);
 
-        nextRecord = RelayModernRecord.create(nextID, _typeName3);
+        nextRecord = RelayModernRecord.create(nextID, _typeName5);
 
         _this._recordSource.set(nextID, nextRecord);
       } else if (process.env.NODE_ENV !== "production") {
         _this._validateRecordType(nextRecord, field, item);
-      }
-      /* $FlowFixMe(>=0.98.0 site=www,mobile,react_native_fb,oss) This comment
-       * suppresses an error found when Flow v0.98 was deployed. To see the
-       * error delete this comment and run Flow. */
+      } // NOTE: the check to strip __DEV__ code only works for simple
+      // `if (__DEV__)`
+
+
+      if (process.env.NODE_ENV !== "production") {
+        if (prevIDs) {
+          _this._validateConflictingLinkedFieldsWithIdenticalId(record, prevIDs[nextIndex], nextID, storageKey);
+        }
+      } // $FlowFixMe[incompatible-variance]
 
 
       _this._traverseSelections(field, nextRecord, item);
@@ -413,7 +583,32 @@ function () {
     var _field$concreteType3;
 
     var typeName = (_field$concreteType3 = field.concreteType) !== null && _field$concreteType3 !== void 0 ? _field$concreteType3 : this._getRecordType(payload);
-    process.env.NODE_ENV !== "production" ? warning(isClientID(RelayModernRecord.getDataID(record)) || 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.', RelayModernRecord.getDataID(record), TYPENAME_KEY, RelayModernRecord.getType(record), typeName) : void 0;
+    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;
+  }
+  /**
+   * Warns if a single response contains conflicting fields with the same id
+   */
+  ;
+
+  _proto._validateConflictingFieldsWithIdenticalId = function _validateConflictingFieldsWithIdenticalId(record, storageKey, fieldValue) {
+    // NOTE: Only call this function in DEV
+    if (process.env.NODE_ENV !== "production") {
+      var dataID = RelayModernRecord.getDataID(record);
+      var previousValue = RelayModernRecord.getValue(record, storageKey);
+      process.env.NODE_ENV !== "production" ? warning(storageKey === TYPENAME_KEY || previousValue === undefined || areEqual(previousValue, fieldValue), 'RelayResponseNormalizer: Invalid record. The record contains two ' + 'instances of the same id: `%s` with conflicting field, %s and its values: %s and %s. ' + 'If two fields are different but share ' + 'the same id, one field will overwrite the other.', dataID, storageKey, previousValue, fieldValue) : void 0;
+    }
+  }
+  /**
+   * Warns if a single response contains conflicting fields with the same id
+   */
+  ;
+
+  _proto._validateConflictingLinkedFieldsWithIdenticalId = function _validateConflictingLinkedFieldsWithIdenticalId(record, prevID, nextID, storageKey) {
+    // NOTE: Only call this function in DEV
+    if (process.env.NODE_ENV !== "production") {
+      process.env.NODE_ENV !== "production" ? warning(prevID === undefined || prevID === nextID, 'RelayResponseNormalizer: Invalid record. The record contains ' + 'references to the conflicting field, %s and its id values: %s and %s. ' + 'We need to make sure that the record the field points ' + 'to remains consistent or one field will overwrite the other.', storageKey, prevID, nextID) : void 0;
+    }
   };
 
   return RelayResponseNormalizer;

package/lib/store/RelayStoreReactFlightUtils.js

@@ -0,0 +1,47 @@
+/**
+ * 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 invariant = require("fbjs/lib/invariant");
+
+var _require = require('./RelayModernRecord'),
+    getType = _require.getType;
+
+var REACT_FLIGHT_QUERIES_STORAGE_KEY = 'queries';
+var REACT_FLIGHT_TREE_STORAGE_KEY = 'tree';
+var REACT_FLIGHT_TYPE_NAME = 'ReactFlightComponent';
+
+function refineToReactFlightPayloadData(payload) {
+  if (payload == null || typeof payload !== 'object' || !Array.isArray(payload.tree) || !Array.isArray(payload.queries)) {
+    return null;
+  }
+
+  return 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;
+}
+
+module.exports = {
+  REACT_FLIGHT_QUERIES_STORAGE_KEY: REACT_FLIGHT_QUERIES_STORAGE_KEY,
+  REACT_FLIGHT_TREE_STORAGE_KEY: REACT_FLIGHT_TREE_STORAGE_KEY,
+  REACT_FLIGHT_TYPE_NAME: REACT_FLIGHT_TYPE_NAME,
+  getReactFlightClientResponse: getReactFlightClientResponse,
+  refineToReactFlightPayloadData: refineToReactFlightPayloadData
+};

package/lib/store/RelayStoreUtils.js

@@ -204,6 +204,7 @@ var RelayStoreUtils = {
   ROOT_TYPE: '__Root',
   TYPENAME_KEY: '__typename',
   INVALIDATED_AT_KEY: '__invalidated_at',
+  IS_WITHIN_UNMATCHED_TYPE_REFINEMENT: '__isWithinUnmatchedTypeRefinement',
   formatStorageKey: formatStorageKey,
   getArgumentValue: getArgumentValue,
   getArgumentValues: getArgumentValues,

package/lib/store/StoreInspector.js

@@ -13,10 +13,14 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
 var inspect = function inspect() {};
 
 if (process.env.NODE_ENV !== "production") {
@@ -134,7 +138,7 @@ if (process.env.NODE_ENV !== "production") {
       return record;
     }
 
-    return new Proxy((0, _objectSpread2["default"])({}, record), {
+    return new Proxy(_objectSpread({}, record), {
       get: function get(target, prop) {
         var value = target[prop];
 
@@ -148,9 +152,7 @@ if (process.env.NODE_ENV !== "production") {
           }
 
           if (Array.isArray(value.__refs)) {
-            /* $FlowFixMe(>=0.111.0) This comment suppresses an error found
-             * when Flow v0.111.0 was deployed. To see the error, delete this
-             * comment and run Flow. */
+            // $FlowFixMe[incompatible-call]
             return value.__refs.map(function (ref) {
               return getWrappedRecord(source, ref);
             });
@@ -163,10 +165,8 @@ if (process.env.NODE_ENV !== "production") {
   };
 
   inspect = function inspect(environment, dataID) {
-    var _dataID;
-
     installDevtoolFormatters();
-    return getWrappedRecord(environment.getStore().getSource(), (_dataID = dataID) !== null && _dataID !== void 0 ? _dataID : 'client:root');
+    return getWrappedRecord(environment.getStore().getSource(), dataID !== null && dataID !== void 0 ? dataID : 'client:root');
   };
 }
 

package/lib/store/TypeID.js

@@ -0,0 +1,28 @@
+/**
+ * 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 PREFIX = 'client:__type:';
+var TYPE_SCHEMA_TYPE = '__TypeSchema';
+
+function generateTypeID(typeName) {
+  return PREFIX + typeName;
+}
+
+function isTypeID(id) {
+  return id.indexOf(PREFIX) === 0;
+}
+
+module.exports = {
+  generateTypeID: generateTypeID,
+  isTypeID: isTypeID,
+  TYPE_SCHEMA_TYPE: TYPE_SCHEMA_TYPE
+};

package/lib/store/cloneRelayScalarHandleSourceField.js

@@ -0,0 +1,44 @@
+/**
+ * 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 areEqual = require("fbjs/lib/areEqual");
+
+var invariant = require("fbjs/lib/invariant");
+
+var _require = require('../util/RelayConcreteNode'),
+    SCALAR_FIELD = _require.SCALAR_FIELD;
+
+var _require2 = require('./RelayStoreUtils'),
+    getHandleStorageKey = _require2.getHandleStorageKey;
+
+/**
+ * @private
+ *
+ * Creates a clone of the supplied `handleField` by finding the original scalar
+ * field (on which the handle was declared) among the sibling `selections`.
+ */
+function cloneRelayScalarHandleSourceField(handleField, selections, variables) {
+  var sourceField = selections.find(function (source) {
+    return source.kind === SCALAR_FIELD && source.name === handleField.name && source.alias === handleField.alias && areEqual(source.args, handleField.args);
+  });
+  !(sourceField && sourceField.kind === SCALAR_FIELD) ? process.env.NODE_ENV !== "production" ? invariant(false, 'cloneRelayScalarHandleSourceField: Expected a corresponding source field for ' + 'handle `%s`.', handleField.handle) : invariant(false) : void 0;
+  var handleKey = getHandleStorageKey(handleField, variables);
+  return {
+    kind: 'ScalarField',
+    alias: sourceField.alias,
+    name: handleKey,
+    storageKey: handleKey,
+    args: null
+  };
+}
+
+module.exports = cloneRelayScalarHandleSourceField;