relay-runtime 10.0.0 → 10.1.2

package/lib/store/RelayStoreSubscriptionsUsingMapByID.js

@@ -0,0 +1,258 @@
+/**
+ * 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 RelayReader = require('./RelayReader');
+
+var deepFreeze = require('../util/deepFreeze');
+
+var recycleNodesInto = require('../util/recycleNodesInto');
+
+var RelayStoreSubscriptionsUsingMapByID = /*#__PURE__*/function () {
+  function RelayStoreSubscriptionsUsingMapByID() {
+    this._notifiedRevision = 0;
+    this._snapshotRevision = 0;
+    this._subscriptionsByDataId = new Map();
+    this._staleSubscriptions = new Set();
+  }
+
+  var _proto = RelayStoreSubscriptionsUsingMapByID.prototype;
+
+  _proto.subscribe = function subscribe(snapshot, callback) {
+    var _this = this;
+
+    var subscription = {
+      backup: null,
+      callback: callback,
+      notifiedRevision: this._notifiedRevision,
+      snapshotRevision: this._snapshotRevision,
+      snapshot: snapshot
+    };
+
+    var dispose = function dispose() {
+      for (var dataId in snapshot.seenRecords) {
+        var subscriptionsForDataId = _this._subscriptionsByDataId.get(dataId);
+
+        if (subscriptionsForDataId != null) {
+          subscriptionsForDataId["delete"](subscription);
+
+          if (subscriptionsForDataId.size === 0) {
+            _this._subscriptionsByDataId["delete"](dataId);
+          }
+        }
+      }
+    };
+
+    for (var dataId in snapshot.seenRecords) {
+      var subscriptionsForDataId = this._subscriptionsByDataId.get(dataId);
+
+      if (subscriptionsForDataId != null) {
+        subscriptionsForDataId.add(subscription);
+      } else {
+        this._subscriptionsByDataId.set(dataId, new Set([subscription]));
+      }
+    }
+
+    return {
+      dispose: dispose
+    };
+  };
+
+  _proto.snapshotSubscriptions = function snapshotSubscriptions(source) {
+    var _this2 = this;
+
+    this._snapshotRevision++;
+
+    this._subscriptionsByDataId.forEach(function (subscriptions) {
+      subscriptions.forEach(function (subscription) {
+        if (subscription.snapshotRevision === _this2._snapshotRevision) {
+          return;
+        }
+
+        subscription.snapshotRevision = _this2._snapshotRevision; // Backup occurs after writing a new "final" payload(s) and before (re)applying
+        // optimistic changes. Each subscription's `snapshot` represents what was *last
+        // published to the subscriber*, which notably may include previous optimistic
+        // updates. Therefore a subscription can be in any of the following states:
+        // - stale=true: This subscription was restored to a different value than
+        //   `snapshot`. That means this subscription has changes relative to its base,
+        //   but its base has changed (we just applied a final payload): recompute
+        //   a backup so that we can later restore to the state the subscription
+        //   should be in.
+        // - stale=false: This subscription was restored to the same value than
+        //   `snapshot`. That means this subscription does *not* have changes relative
+        //   to its base, so the current `snapshot` is valid to use as a backup.
+
+        if (!_this2._staleSubscriptions.has(subscription)) {
+          subscription.backup = subscription.snapshot;
+          return;
+        }
+
+        var snapshot = subscription.snapshot;
+        var backup = RelayReader.read(source, snapshot.selector);
+        var nextData = recycleNodesInto(snapshot.data, backup.data);
+        backup.data = nextData; // backup owns the snapshot and can safely mutate
+
+        subscription.backup = backup;
+      });
+    });
+  };
+
+  _proto.restoreSubscriptions = function restoreSubscriptions() {
+    var _this3 = this;
+
+    this._snapshotRevision++;
+
+    this._subscriptionsByDataId.forEach(function (subscriptions) {
+      subscriptions.forEach(function (subscription) {
+        if (subscription.snapshotRevision === _this3._snapshotRevision) {
+          return;
+        }
+
+        subscription.snapshotRevision = _this3._snapshotRevision;
+        var backup = subscription.backup;
+        subscription.backup = null;
+
+        if (backup) {
+          if (backup.data !== subscription.snapshot.data) {
+            _this3._staleSubscriptions.add(subscription);
+          }
+
+          var prevSeenRecords = subscription.snapshot.seenRecords;
+          subscription.snapshot = {
+            data: subscription.snapshot.data,
+            isMissingData: backup.isMissingData,
+            seenRecords: backup.seenRecords,
+            selector: backup.selector,
+            missingRequiredFields: backup.missingRequiredFields
+          };
+
+          _this3._updateSubscriptionsMap(subscription, prevSeenRecords);
+        } else {
+          _this3._staleSubscriptions.add(subscription);
+        }
+      });
+    });
+  };
+
+  _proto.updateSubscriptions = function updateSubscriptions(source, updatedRecordIDs, updatedOwners) {
+    var _this4 = this;
+
+    this._notifiedRevision++;
+    Object.keys(updatedRecordIDs).forEach(function (updatedRecordId) {
+      var subcriptionsForDataId = _this4._subscriptionsByDataId.get(updatedRecordId);
+
+      if (subcriptionsForDataId == null) {
+        return;
+      }
+
+      subcriptionsForDataId.forEach(function (subscription) {
+        if (subscription.notifiedRevision === _this4._notifiedRevision) {
+          return;
+        }
+
+        var owner = _this4._updateSubscription(source, subscription, false);
+
+        if (owner != null) {
+          updatedOwners.push(owner);
+        }
+      });
+    });
+
+    this._staleSubscriptions.forEach(function (subscription) {
+      if (subscription.notifiedRevision === _this4._notifiedRevision) {
+        return;
+      }
+
+      var owner = _this4._updateSubscription(source, subscription, true);
+
+      if (owner != null) {
+        updatedOwners.push(owner);
+      }
+    });
+
+    this._staleSubscriptions.clear();
+  }
+  /**
+   * Notifies the callback for the subscription if the data for the associated
+   * snapshot has changed.
+   * Additionally, updates the subscription snapshot with the latest snapshot,
+   * amarks it as not stale, and updates the subscription tracking for any
+   * any new ids observed in the latest data snapshot.
+   * Returns the owner (RequestDescriptor) if the subscription was affected by the
+   * latest update, or null if it was not affected.
+   */
+  ;
+
+  _proto._updateSubscription = function _updateSubscription(source, subscription, stale) {
+    var backup = subscription.backup,
+        callback = subscription.callback,
+        snapshot = subscription.snapshot;
+    var nextSnapshot = stale && backup != null ? backup : RelayReader.read(source, snapshot.selector);
+    var nextData = recycleNodesInto(snapshot.data, nextSnapshot.data);
+    nextSnapshot = {
+      data: nextData,
+      isMissingData: nextSnapshot.isMissingData,
+      seenRecords: nextSnapshot.seenRecords,
+      selector: nextSnapshot.selector,
+      missingRequiredFields: nextSnapshot.missingRequiredFields
+    };
+
+    if (process.env.NODE_ENV !== "production") {
+      deepFreeze(nextSnapshot);
+    }
+
+    var prevSeenRecords = subscription.snapshot.seenRecords;
+    subscription.snapshot = nextSnapshot;
+    subscription.notifiedRevision = this._notifiedRevision;
+
+    this._updateSubscriptionsMap(subscription, prevSeenRecords);
+
+    if (nextSnapshot.data !== snapshot.data) {
+      callback(nextSnapshot);
+      return snapshot.selector.owner;
+    }
+  }
+  /**
+   * Updates the Map that tracks subscriptions by id.
+   * Given an updated subscription and the records that where seen
+   * on the previous subscription snapshot, updates our tracking
+   * to track the subscription for the newly and no longer seen ids.
+   */
+  ;
+
+  _proto._updateSubscriptionsMap = function _updateSubscriptionsMap(subscription, prevSeenRecords) {
+    for (var dataId in prevSeenRecords) {
+      var subscriptionsForDataId = this._subscriptionsByDataId.get(dataId);
+
+      if (subscriptionsForDataId != null) {
+        subscriptionsForDataId["delete"](subscription);
+
+        if (subscriptionsForDataId.size === 0) {
+          this._subscriptionsByDataId["delete"](dataId);
+        }
+      }
+    }
+
+    for (var _dataId in subscription.snapshot.seenRecords) {
+      var _subscriptionsForDataId = this._subscriptionsByDataId.get(_dataId);
+
+      if (_subscriptionsForDataId != null) {
+        _subscriptionsForDataId.add(subscription);
+      } else {
+        this._subscriptionsByDataId.set(_dataId, new Set([subscription]));
+      }
+    }
+  };
+
+  return RelayStoreSubscriptionsUsingMapByID;
+}();
+
+module.exports = RelayStoreSubscriptionsUsingMapByID;

package/lib/store/StoreInspector.js

@@ -13,14 +13,10 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 
 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") {
@@ -138,7 +134,7 @@ if (process.env.NODE_ENV !== "production") {
       return record;
     }
 
-    return new Proxy(_objectSpread({}, record), {
+    return new Proxy((0, _objectSpread2["default"])({}, record), {
       get: function get(target, prop) {
         var value = target[prop];
 
@@ -152,9 +148,7 @@ if (process.env.NODE_ENV !== "production") {
           }
 
           if (Array.isArray(value.__refs)) {
-            /* $FlowFixMe[incompatible-call] (>=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);
             });

package/lib/store/createRelayContext.js

@@ -18,6 +18,11 @@ var firstReact;
 function createRelayContext(react) {
   if (!relayContext) {
     relayContext = react.createContext(null);
+
+    if (process.env.NODE_ENV !== "production") {
+      relayContext.displayName = 'RelayContext';
+    }
+
     firstReact = react;
   }
 

package/lib/store/defaultRequiredFieldLogger.js

@@ -0,0 +1,18 @@
+/**
+ * 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
+ */
+'use strict';
+
+var defaultRequiredFieldLogger = function defaultRequiredFieldLogger(event) {
+  if (process.env.NODE_ENV !== "production" && event.kind === 'missing_field.log') {
+    throw new Error('Relay Environment Configuration Error (dev only): `@required(action: LOG)` requires that the Relay Environment be configured with a `requiredFieldLogger`.');
+  }
+};
+
+module.exports = defaultRequiredFieldLogger;

package/lib/store/normalizeRelayPayload.js

@@ -12,11 +12,7 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-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 _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 
 var RelayModernRecord = require('./RelayModernRecord');
 
@@ -31,7 +27,7 @@ function normalizeRelayPayload(selector, payload, errors, options) {
   var source = RelayRecordSource.create();
   source.set(selector.dataID, RelayModernRecord.create(selector.dataID, ROOT_TYPE));
   var relayPayload = RelayResponseNormalizer.normalize(source, selector, payload, options);
-  return _objectSpread({}, relayPayload, {
+  return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, relayPayload), {}, {
     errors: errors
   });
 }

package/lib/subscription/requestSubscription.js

@@ -33,7 +33,7 @@ function requestSubscription(environment, config) {
       onNext = config.onNext,
       variables = config.variables,
       cacheConfig = config.cacheConfig;
-  var operation = createOperationDescriptor(subscription, variables);
+  var operation = createOperationDescriptor(subscription, variables, cacheConfig);
   process.env.NODE_ENV !== "production" ? warning(!(config.updater && configs), 'requestSubscription: Expected only one of `updater` and `configs` to be provided') : void 0;
 
   var _ref = configs ? RelayDeclarativeMutationConfig.convert(configs, subscription, null
@@ -43,8 +43,7 @@ function requestSubscription(environment, config) {
 
   var sub = environment.execute({
     operation: operation,
-    updater: updater,
-    cacheConfig: cacheConfig
+    updater: updater
   }).map(function () {
     var data = environment.lookup(operation.fragment).data; // $FlowFixMe[incompatible-cast]
 

package/lib/util/NormalizationNode.js

@@ -8,8 +8,4 @@
  * @format
  */
 // flowlint ambiguous-object-type:error
-'use strict';
-/**
- * Represents a single operation used to processing and normalize runtime
- * request results.
- */
+'use strict';

package/lib/util/RelayConcreteNode.js

@@ -28,6 +28,7 @@ var RelayConcreteNode = {
   CLIENT_EXTENSION: 'ClientExtension',
   DEFER: 'Defer',
   CONNECTION: 'Connection',
+  FLIGHT_FIELD: 'FlightField',
   FRAGMENT: 'Fragment',
   FRAGMENT_SPREAD: 'FragmentSpread',
   INLINE_DATA_FRAGMENT_SPREAD: 'InlineDataFragmentSpread',
@@ -39,6 +40,7 @@ var RelayConcreteNode = {
   LIST_VALUE: 'ListValue',
   LOCAL_ARGUMENT: 'LocalArgument',
   MODULE_IMPORT: 'ModuleImport',
+  REQUIRED_FIELD: 'RequiredField',
   OBJECT_VALUE: 'ObjectValue',
   OPERATION: 'Operation',
   REQUEST: 'Request',

package/lib/util/RelayFeatureFlags.js

@@ -11,10 +11,14 @@
 'use strict';
 
 var RelayFeatureFlags = {
-  // T45504512: new connection model
   ENABLE_VARIABLE_CONNECTION_KEY: false,
   ENABLE_PARTIAL_RENDERING_DEFAULT: false,
   ENABLE_RELAY_CONTAINERS_SUSPENSE: false,
-  ENABLE_PRECISE_TYPE_REFINEMENT: false
+  ENABLE_PRECISE_TYPE_REFINEMENT: false,
+  ENABLE_REACT_FLIGHT_COMPONENT_FIELD: false,
+  ENABLE_REQUIRED_DIRECTIVES: false,
+  ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: false,
+  ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: false,
+  ENABLE_STORE_SUBSCRIPTIONS_REFACTOR: false
 };
 module.exports = RelayFeatureFlags;

package/lib/util/createPayloadFor3DField.js

@@ -13,19 +13,14 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-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 _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 
 var _require = require('../store/RelayStoreUtils'),
     getModuleComponentKey = _require.getModuleComponentKey,
     getModuleOperationKey = _require.getModuleOperationKey;
 
 function createPayloadFor3DField(name, operation, component, response) {
-  var data = _objectSpread({}, response);
-
+  var data = (0, _objectSpread2["default"])({}, response);
   data[getModuleComponentKey(name)] = component;
   data[getModuleOperationKey(name)] = operation;
   return data;

package/lib/util/getFragmentIdentifier.js

@@ -11,6 +11,10 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
+var RelayFeatureFlags = require('./RelayFeatureFlags');
+
+var isEmptyObject = require('./isEmptyObject');
+
 var stableCopy = require('./stableCopy');
 
 var _require = require('../store/RelayModernSelector'),
@@ -19,15 +23,20 @@ var _require = require('../store/RelayModernSelector'),
     getSelector = _require.getSelector;
 
 function getFragmentIdentifier(fragmentNode, fragmentRef) {
-  var _JSON$stringify;
-
   var selector = getSelector(fragmentNode, fragmentRef);
   var fragmentOwnerIdentifier = selector == null ? 'null' : selector.kind === 'SingularReaderSelector' ? selector.owner.identifier : '[' + selector.selectors.map(function (sel) {
     return sel.owner.identifier;
   }).join(',') + ']';
   var fragmentVariables = getVariablesFromFragment(fragmentNode, fragmentRef);
   var dataIDs = getDataIDsFromFragment(fragmentNode, fragmentRef);
-  return fragmentOwnerIdentifier + '/' + fragmentNode.name + '/' + JSON.stringify(stableCopy(fragmentVariables)) + '/' + ((_JSON$stringify = JSON.stringify(dataIDs)) !== null && _JSON$stringify !== void 0 ? _JSON$stringify : 'missing');
+
+  if (RelayFeatureFlags.ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION) {
+    return fragmentOwnerIdentifier + '/' + fragmentNode.name + '/' + (fragmentVariables == null || isEmptyObject(fragmentVariables) ? '{}' : JSON.stringify(stableCopy(fragmentVariables))) + '/' + (typeof dataIDs === 'undefined' ? 'missing' : dataIDs == null ? 'null' : Array.isArray(dataIDs) ? '[' + dataIDs.join(',') + ']' : dataIDs);
+  } else {
+    var _JSON$stringify;
+
+    return fragmentOwnerIdentifier + '/' + fragmentNode.name + '/' + JSON.stringify(stableCopy(fragmentVariables)) + '/' + ((_JSON$stringify = JSON.stringify(dataIDs)) !== null && _JSON$stringify !== void 0 ? _JSON$stringify : 'missing');
+  }
 }
 
 module.exports = getFragmentIdentifier;

package/lib/util/getOperation.js

@@ -0,0 +1,33 @@
+/**
+ * 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
+ * @emails oncall+relay
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _require = require('./RelayConcreteNode'),
+    REQUEST = _require.REQUEST,
+    SPLIT_OPERATION = _require.SPLIT_OPERATION;
+
+/**
+ * OperationLoaders can return either a NormalizationSplitOperation or
+ * ConcreteRequest.
+ */
+function getOperation(node) {
+  switch (node.kind) {
+    case REQUEST:
+      return node.operation;
+
+    case SPLIT_OPERATION:
+    default:
+      return node;
+  }
+}
+
+module.exports = getOperation;

package/lib/util/isEmptyObject.js

@@ -0,0 +1,25 @@
+/**
+ * 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
+ * @emails oncall+relay
+ */
+'use strict';
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function isEmptyObject(obj) {
+  for (var _key in obj) {
+    if (hasOwnProperty.call(obj, _key)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+module.exports = isEmptyObject;

package/lib/util/recycleNodesInto.js

@@ -9,12 +9,15 @@
  */
 // flowlint ambiguous-object-type:error
 'use strict';
+
+var hasWeakSetDefined = typeof WeakSet !== 'undefined';
+var hasWeakMapDefined = typeof WeakMap !== 'undefined';
 /**
  * Recycles subtrees from `prevData` by replacing equal subtrees in `nextData`.
  */
 
 function recycleNodesInto(prevData, nextData) {
-  if (prevData === nextData || typeof prevData !== 'object' || !prevData || typeof nextData !== 'object' || !nextData) {
+  if (prevData === nextData || typeof prevData !== 'object' || prevData instanceof Set || prevData instanceof Map || hasWeakSetDefined && prevData instanceof WeakSet || hasWeakMapDefined && prevData instanceof WeakMap || !prevData || typeof nextData !== 'object' || nextData instanceof Set || nextData instanceof Map || hasWeakSetDefined && nextData instanceof WeakSet || hasWeakMapDefined && nextData instanceof WeakMap || !nextData) {
     return nextData;
   }
 
@@ -53,17 +56,11 @@ function recycleNodesInto(prevData, nextData) {
       if (nextValue !== nextObject[key]) {
         if (process.env.NODE_ENV !== "production") {
           if (!Object.isFrozen(nextObject)) {
-            /* $FlowFixMe[cannot-write] (>=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[cannot-write]
             nextObject[key] = nextValue;
           }
         } else {
-          /* $FlowFixMe[cannot-write] (>=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[cannot-write]
           nextObject[key] = nextValue;
         }
       }

package/lib/util/reportMissingRequiredFields.js

@@ -0,0 +1,48 @@
+/**
+ * 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.
+ *
+ * 
+ * @emails oncall+relay
+ * @format
+ */
+'use strict';
+
+function reportMissingRequiredFields(environment, missingRequiredFields) {
+  switch (missingRequiredFields.action) {
+    case 'THROW':
+      {
+        var _missingRequiredField = missingRequiredFields.field,
+            path = _missingRequiredField.path,
+            owner = _missingRequiredField.owner; // This gives the consumer the chance to throw their own error if they so wish.
+
+        environment.requiredFieldLogger({
+          kind: 'missing_field.throw',
+          owner: owner,
+          fieldPath: path
+        });
+        throw new Error("Relay: Missing @required value at path '".concat(path, "' in '").concat(owner, "'."));
+      }
+
+    case 'LOG':
+      missingRequiredFields.fields.forEach(function (_ref) {
+        var path = _ref.path,
+            owner = _ref.owner;
+        environment.requiredFieldLogger({
+          kind: 'missing_field.log',
+          owner: owner,
+          fieldPath: path
+        });
+      });
+      break;
+
+    default:
+      {
+        missingRequiredFields.action;
+      }
+  }
+}
+
+module.exports = reportMissingRequiredFields;

package/mutations/commitMutation.js.flow

@@ -13,7 +13,6 @@
 'use strict';
 
 const RelayDeclarativeMutationConfig = require('./RelayDeclarativeMutationConfig');
-const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 
 const invariant = require('invariant');
 const isRelayModernEnvironment = require('../store/isRelayModernEnvironment');
@@ -115,6 +114,7 @@ function commitMutation<T: MutationParameters>(
   const operation = createOperationDescriptor(
     mutation,
     variables,
+    cacheConfig,
     generateUniqueClientID(),
   );
   // TODO: remove this check after we fix flow.
@@ -142,7 +142,6 @@ function commitMutation<T: MutationParameters>(
   const errors = [];
   const subscription = environment
     .executeMutation({
-      cacheConfig,
       operation,
       optimisticResponse,
       optimisticUpdater,