relay-runtime 9.0.0 → 9.1.0

package/lib/store/RelayRecordSourceMapImpl.js

@@ -10,6 +10,12 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
+function _createForOfIteratorHelper(o) { if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { 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 it, 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(n); 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 RelayRecordState = require('./RelayRecordState');
 
 var EXISTENT = RelayRecordState.EXISTENT,
@@ -20,9 +26,7 @@ var EXISTENT = RelayRecordState.EXISTENT,
  * `RelayStoreTypes`) that holds all records in memory (JS Map).
  */
 
-var RelayMapRecordSourceMapImpl =
-/*#__PURE__*/
-function () {
+var RelayMapRecordSourceMapImpl = /*#__PURE__*/function () {
   function RelayMapRecordSourceMapImpl(records) {
     var _this = this;
 
@@ -79,30 +83,21 @@ function () {
 
   _proto.toJSON = function toJSON() {
     var obj = {};
-    var _iteratorNormalCompletion = true;
-    var _didIteratorError = false;
-    var _iteratorError = undefined;
+
+    var _iterator = _createForOfIteratorHelper(this._records),
+        _step;
 
     try {
-      for (var _iterator = this._records[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
         var _step$value = _step.value,
             key = _step$value[0],
             value = _step$value[1];
         obj[key] = value;
       }
     } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
+      _iterator.e(err);
     } finally {
-      try {
-        if (!_iteratorNormalCompletion && _iterator["return"] != null) {
-          _iterator["return"]();
-        }
-      } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
-        }
-      }
+      _iterator.f();
     }
 
     return obj;

package/lib/store/RelayReferenceMarker.js

@@ -46,13 +46,9 @@ function mark(recordSource, selector, references, operationLoader) {
  */
 
 
-var RelayReferenceMarker =
-/*#__PURE__*/
-function () {
+var RelayReferenceMarker = /*#__PURE__*/function () {
   function RelayReferenceMarker(recordSource, variables, references, operationLoader) {
-    var _operationLoader;
-
-    this._operationLoader = (_operationLoader = operationLoader) !== null && _operationLoader !== void 0 ? _operationLoader : null;
+    this._operationLoader = operationLoader !== null && operationLoader !== void 0 ? operationLoader : null;
     this._recordSource = recordSource;
     this._references = references;
     this._variables = variables;

package/lib/store/RelayResponseNormalizer.js

@@ -47,7 +47,8 @@ var _require4 = require('./RelayStoreUtils'),
     getModuleComponentKey = _require4.getModuleComponentKey,
     getModuleOperationKey = _require4.getModuleOperationKey,
     getStorageKey = _require4.getStorageKey,
-    TYPENAME_KEY = _require4.TYPENAME_KEY;
+    TYPENAME_KEY = _require4.TYPENAME_KEY,
+    ROOT_ID = _require4.ROOT_ID;
 
 /**
  * Normalizes the results of a query and standard GraphQL response, writing the
@@ -67,12 +68,11 @@ 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._moduleImportPayloads = [];
@@ -240,16 +240,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({
@@ -270,7 +268,7 @@ function () {
     var fieldValue = data[responseKey];
 
     if (fieldValue == null) {
-      if (fieldValue === undefined) {
+      if (!this._treatMissingFieldsAsNull && fieldValue === undefined) {
         // Fields that are missing in the response are not set on the record.
         // There are three main cases where this can occur:
         // - Inside a client extension: the server will not generally return
@@ -413,7 +411,8 @@ 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;
   };
 
   return RelayResponseNormalizer;

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];
 
@@ -163,10 +167,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/normalizeRelayPayload.js

@@ -12,7 +12,11 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));
+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 RelayModernRecord = require('./RelayModernRecord');
 
@@ -27,7 +31,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 (0, _objectSpread2["default"])({}, relayPayload, {
+  return _objectSpread({}, relayPayload, {
     errors: errors
   });
 }

package/lib/subscription/requestSubscription.js

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

package/lib/util/RelayFeatureFlags.js

@@ -14,7 +14,7 @@ var RelayFeatureFlags = {
   // T45504512: new connection model
   ENABLE_VARIABLE_CONNECTION_KEY: false,
   ENABLE_PARTIAL_RENDERING_DEFAULT: false,
-  ENABLE_RELAY_CONTAINERS_SUSPENSE: true,
+  ENABLE_RELAY_CONTAINERS_SUSPENSE: false,
   ENABLE_UNIQUE_MUTATION_ROOT: true
 };
 module.exports = RelayFeatureFlags;

package/lib/util/RelayReplaySubject.js

@@ -24,9 +24,7 @@ var invariant = require("fbjs/lib/invariant");
  * Records events provided and synchronously plays them back to new subscribers,
  * as well as forwarding new asynchronous events.
  */
-var RelayReplaySubject =
-/*#__PURE__*/
-function () {
+var RelayReplaySubject = /*#__PURE__*/function () {
   function RelayReplaySubject() {
     var _this = this;
 

package/lib/util/createPayloadFor3DField.js

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

package/mutations/RelayDeclarativeMutationConfig.js.flow

@@ -0,0 +1,380 @@
+/**
+ * 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.
+ *
+ * @flow
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const ConnectionHandler = require('../handlers/connection/ConnectionHandler');
+
+const warning = require('warning');
+
+import type {
+  RecordSourceSelectorProxy,
+  SelectorData,
+  SelectorStoreUpdater,
+} from '../store/RelayStoreTypes';
+import type {ConcreteRequest} from '../util/RelayConcreteNode';
+import type {Variables} from '../util/RelayRuntimeTypes';
+
+const MutationTypes = Object.freeze({
+  RANGE_ADD: 'RANGE_ADD',
+  RANGE_DELETE: 'RANGE_DELETE',
+  NODE_DELETE: 'NODE_DELETE',
+});
+export type MutationType = $Values<typeof MutationTypes>;
+
+const RangeOperations = Object.freeze({
+  APPEND: 'append',
+  PREPEND: 'prepend',
+});
+export type RangeOperation = $Values<typeof RangeOperations>;
+
+type RangeBehaviorsFunction = (connectionArgs: {
+  [name: string]: $FlowFixMe,
+  ...,
+}) => RangeOperation;
+type RangeBehaviorsObject = {[key: string]: RangeOperation, ...};
+export type RangeBehaviors = RangeBehaviorsFunction | RangeBehaviorsObject;
+
+type RangeAddConfig = {|
+  type: 'RANGE_ADD',
+  parentName?: string,
+  parentID?: string,
+  connectionInfo?: Array<{|
+    key: string,
+    filters?: Variables,
+    rangeBehavior: string,
+  |}>,
+  connectionName?: string,
+  edgeName: string,
+  rangeBehaviors?: RangeBehaviors,
+|};
+
+type RangeDeleteConfig = {|
+  type: 'RANGE_DELETE',
+  parentName?: string,
+  parentID?: string,
+  connectionKeys?: Array<{|
+    key: string,
+    filters?: Variables,
+  |}>,
+  connectionName?: string,
+  deletedIDFieldName: string | Array<string>,
+  pathToConnection: Array<string>,
+|};
+
+type NodeDeleteConfig = {|
+  type: 'NODE_DELETE',
+  parentName?: string,
+  parentID?: string,
+  connectionName?: string,
+  deletedIDFieldName: string,
+|};
+
+export type DeclarativeMutationConfig =
+  | RangeAddConfig
+  | RangeDeleteConfig
+  | NodeDeleteConfig;
+
+function convert(
+  configs: Array<DeclarativeMutationConfig>,
+  request: ConcreteRequest,
+  optimisticUpdater?: ?SelectorStoreUpdater,
+  updater?: ?SelectorStoreUpdater,
+): {
+  optimisticUpdater: SelectorStoreUpdater,
+  updater: SelectorStoreUpdater,
+  ...
+} {
+  const configOptimisticUpdates = optimisticUpdater ? [optimisticUpdater] : [];
+  const configUpdates = updater ? [updater] : [];
+  configs.forEach(config => {
+    switch (config.type) {
+      case 'NODE_DELETE':
+        const nodeDeleteResult = nodeDelete(config, request);
+        if (nodeDeleteResult) {
+          configOptimisticUpdates.push(nodeDeleteResult);
+          configUpdates.push(nodeDeleteResult);
+        }
+        break;
+      case 'RANGE_ADD':
+        const rangeAddResult = rangeAdd(config, request);
+        if (rangeAddResult) {
+          configOptimisticUpdates.push(rangeAddResult);
+          configUpdates.push(rangeAddResult);
+        }
+        break;
+      case 'RANGE_DELETE':
+        const rangeDeleteResult = rangeDelete(config, request);
+        if (rangeDeleteResult) {
+          configOptimisticUpdates.push(rangeDeleteResult);
+          configUpdates.push(rangeDeleteResult);
+        }
+        break;
+    }
+  });
+  return {
+    optimisticUpdater: (
+      store: RecordSourceSelectorProxy,
+      data: ?SelectorData,
+    ) => {
+      configOptimisticUpdates.forEach(eachOptimisticUpdater => {
+        eachOptimisticUpdater(store, data);
+      });
+    },
+    updater: (store: RecordSourceSelectorProxy, data: ?SelectorData) => {
+      configUpdates.forEach(eachUpdater => {
+        eachUpdater(store, data);
+      });
+    },
+  };
+}
+
+function nodeDelete(
+  config: NodeDeleteConfig,
+  request: ConcreteRequest,
+): ?SelectorStoreUpdater {
+  const {deletedIDFieldName} = config;
+  const rootField = getRootField(request);
+  if (!rootField) {
+    return null;
+  }
+  return (store: RecordSourceSelectorProxy, data: ?SelectorData) => {
+    const payload = store.getRootField(rootField);
+    if (!payload) {
+      return;
+    }
+    const deleteID = payload.getValue(deletedIDFieldName);
+    const deleteIDs = Array.isArray(deleteID) ? deleteID : [deleteID];
+    deleteIDs.forEach(id => {
+      if (id && typeof id === 'string') {
+        store.delete(id);
+      }
+    });
+  };
+}
+
+function rangeAdd(
+  config: RangeAddConfig,
+  request: ConcreteRequest,
+): ?SelectorStoreUpdater {
+  const {parentID, connectionInfo, edgeName} = config;
+  if (!parentID) {
+    warning(
+      false,
+      'RelayDeclarativeMutationConfig: For mutation config RANGE_ADD ' +
+        'to work you must include a parentID',
+    );
+    return null;
+  }
+  const rootField = getRootField(request);
+  if (!connectionInfo || !rootField) {
+    return null;
+  }
+  return (store: RecordSourceSelectorProxy, data: ?SelectorData) => {
+    const parent = store.get(parentID);
+    if (!parent) {
+      return;
+    }
+    const payload = store.getRootField(rootField);
+    if (!payload) {
+      return;
+    }
+    const serverEdge = payload.getLinkedRecord(edgeName);
+    for (const info of connectionInfo) {
+      if (!serverEdge) {
+        continue;
+      }
+      const connection = ConnectionHandler.getConnection(
+        parent,
+        info.key,
+        info.filters,
+      );
+      if (!connection) {
+        continue;
+      }
+      const clientEdge = ConnectionHandler.buildConnectionEdge(
+        store,
+        connection,
+        serverEdge,
+      );
+      if (!clientEdge) {
+        continue;
+      }
+      switch (info.rangeBehavior) {
+        case 'append':
+          ConnectionHandler.insertEdgeAfter(connection, clientEdge);
+          break;
+        case 'prepend':
+          ConnectionHandler.insertEdgeBefore(connection, clientEdge);
+          break;
+        default:
+          warning(
+            false,
+            'RelayDeclarativeMutationConfig: RANGE_ADD range behavior `%s` ' +
+              'will not work as expected in RelayModern, supported range ' +
+              "behaviors are 'append', 'prepend'.",
+            info.rangeBehavior,
+          );
+          break;
+      }
+    }
+  };
+}
+
+function rangeDelete(
+  config: RangeDeleteConfig,
+  request: ConcreteRequest,
+): ?SelectorStoreUpdater {
+  const {
+    parentID,
+    connectionKeys,
+    pathToConnection,
+    deletedIDFieldName,
+  } = config;
+  if (!parentID) {
+    warning(
+      false,
+      'RelayDeclarativeMutationConfig: For mutation config RANGE_DELETE ' +
+        'to work you must include a parentID',
+    );
+    return null;
+  }
+  const rootField = getRootField(request);
+  if (!rootField) {
+    return null;
+  }
+  return (store: RecordSourceSelectorProxy, data: ?SelectorData) => {
+    if (!data) {
+      return;
+    }
+    const deleteIDs = [];
+    let deletedIDField = data[rootField];
+    if (deletedIDField && Array.isArray(deletedIDFieldName)) {
+      for (const eachField of deletedIDFieldName) {
+        if (deletedIDField && typeof deletedIDField === 'object') {
+          deletedIDField = deletedIDField[eachField];
+        }
+      }
+      if (Array.isArray(deletedIDField)) {
+        deletedIDField.forEach(idObject => {
+          if (
+            idObject &&
+            idObject.id &&
+            typeof idObject === 'object' &&
+            typeof idObject.id === 'string'
+          ) {
+            deleteIDs.push(idObject.id);
+          }
+        });
+      } else if (
+        deletedIDField &&
+        deletedIDField.id &&
+        typeof deletedIDField.id === 'string'
+      ) {
+        deleteIDs.push(deletedIDField.id);
+      }
+    } else if (
+      deletedIDField &&
+      typeof deletedIDFieldName === 'string' &&
+      typeof deletedIDField === 'object'
+    ) {
+      deletedIDField = deletedIDField[deletedIDFieldName];
+      if (typeof deletedIDField === 'string') {
+        deleteIDs.push(deletedIDField);
+      } else if (Array.isArray(deletedIDField)) {
+        deletedIDField.forEach(id => {
+          if (typeof id === 'string') {
+            deleteIDs.push(id);
+          }
+        });
+      }
+    }
+    deleteNode(parentID, connectionKeys, pathToConnection, store, deleteIDs);
+  };
+}
+
+function deleteNode(
+  parentID: string,
+  connectionKeys: ?Array<{|
+    key: string,
+    filters?: Variables,
+  |}>,
+  pathToConnection: Array<string>,
+  store: RecordSourceSelectorProxy,
+  deleteIDs: Array<string>,
+): void {
+  warning(
+    connectionKeys != null,
+    'RelayDeclarativeMutationConfig: RANGE_DELETE must provide a ' +
+      'connectionKeys',
+  );
+  const parent = store.get(parentID);
+  if (!parent) {
+    return;
+  }
+  if (pathToConnection.length < 2) {
+    warning(
+      false,
+      'RelayDeclarativeMutationConfig: RANGE_DELETE ' +
+        'pathToConnection must include at least parent and connection',
+    );
+    return;
+  }
+  let recordProxy = parent;
+  for (let i = 1; i < pathToConnection.length - 1; i++) {
+    if (recordProxy) {
+      recordProxy = recordProxy.getLinkedRecord(pathToConnection[i]);
+    }
+  }
+  // Should never enter loop except edge cases
+  if (!connectionKeys || !recordProxy) {
+    warning(
+      false,
+      'RelayDeclarativeMutationConfig: RANGE_DELETE ' +
+        'pathToConnection is incorrect. Unable to find connection with ' +
+        'parentID: %s and path: %s',
+      parentID,
+      pathToConnection.toString(),
+    );
+    return;
+  }
+  for (const key of connectionKeys) {
+    const connection = ConnectionHandler.getConnection(
+      recordProxy,
+      key.key,
+      key.filters,
+    );
+    if (connection) {
+      deleteIDs.forEach(deleteID => {
+        ConnectionHandler.deleteNode(connection, deleteID);
+      });
+    }
+  }
+}
+
+function getRootField(request: ConcreteRequest): ?string {
+  if (
+    request.fragment.selections &&
+    request.fragment.selections.length > 0 &&
+    request.fragment.selections[0].kind === 'LinkedField'
+  ) {
+    return request.fragment.selections[0].name;
+  }
+  return null;
+}
+
+module.exports = {
+  MutationTypes,
+  RangeOperations,
+
+  convert,
+};