relay-compiler 9.0.0 → 10.1.0

package/lib/transforms/RequiredFieldTransform.js

@@ -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.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+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; }
+
+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 IRTransformer = require('../core/IRTransformer');
+
+var partitionArray = require('../util/partitionArray');
+
+var _require = require('../core/CompilerError'),
+    createUserError = _require.createUserError,
+    createCompilerError = _require.createCompilerError;
+
+var _require2 = require('relay-runtime'),
+    RelayFeatureFlags = _require2.RelayFeatureFlags;
+
+var SCHEMA_EXTENSION = "\n  enum RequiredFieldAction {\n    NONE\n    LOG\n    THROW\n  }\n  directive @required(\n    action: RequiredFieldAction!\n  ) on FIELD\n";
+/**
+ * This transform rewrites ScalarField and LinkedField nodes with a @required
+ * directive into fields with the directives stripped and sets the `required`
+ * and `path` metadata values.
+ */
+
+function requiredFieldTransform(context) {
+  var schema = context.getSchema();
+  return IRTransformer.transform(context, {
+    LinkedField: visitLinkedField,
+    ScalarField: vistitScalarField,
+    InlineFragment: visitInlineFragment,
+    Fragment: visitFragment,
+    Root: visitRoot
+  }, function (node) {
+    return {
+      schema: schema,
+      documentName: node.name,
+      path: [],
+      pathRequiredMap: new Map(),
+      currentNodeRequiredChildren: new Map(),
+      requiredChildrenMap: new Map(),
+      parentAbstractInlineFragment: null
+    };
+  });
+}
+
+function visitFragment(fragment, state) {
+  return addChildrenCanBubbleMetadata(this.traverse(fragment, state), state);
+}
+
+function visitRoot(root, state) {
+  return addChildrenCanBubbleMetadata(this.traverse(root, state), state);
+}
+
+function visitInlineFragment(fragment, state) {
+  var _state$parentAbstract;
+
+  // Ideally we could allow @required when the direct parent inline fragment was
+  // on a concrete type, but we would need to solve this bug in our Flow type
+  // generation first: T65695438
+  var parentAbstractInlineFragment = (_state$parentAbstract = state.parentAbstractInlineFragment) !== null && _state$parentAbstract !== void 0 ? _state$parentAbstract : getAbstractInlineFragment(fragment, state.schema);
+  return this.traverse(fragment, _objectSpread(_objectSpread({}, state), {}, {
+    parentAbstractInlineFragment: parentAbstractInlineFragment
+  }));
+}
+
+function getAbstractInlineFragment(fragment, schema) {
+  var typeCondition = fragment.typeCondition;
+
+  if (schema.isAbstractType(typeCondition)) {
+    return fragment;
+  }
+
+  return null;
+} // Convert action to a number so that we can numerically compare their severity.
+
+
+function getActionSeverity(action) {
+  switch (action) {
+    case 'NONE':
+      return 0;
+
+    case 'LOG':
+      return 1;
+
+    case 'THROW':
+      return 2;
+
+    default:
+      action;
+      throw createCompilerError("Unhandled action type ".concat(action));
+  }
+}
+
+function visitLinkedField(field, state) {
+  var path = [].concat((0, _toConsumableArray2["default"])(state.path), [field.alias]);
+
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    currentNodeRequiredChildren: new Map(),
+    path: path,
+    parentAbstractInlineFragment: null
+  });
+
+  var newField = this.traverse(field, newState);
+  var pathName = path.join('.');
+  assertCompatibleRequiredChildren(field, pathName, newState);
+  newField = applyDirectives(newField, pathName, state.documentName);
+  assertCompatibleNullability(newField, pathName, newState.pathRequiredMap);
+  var directiveMetadata = getRequiredDirectiveMetadata(newField);
+
+  if (directiveMetadata != null) {
+    assertParentIsNotInvalidInlineFragmet(state.schema, directiveMetadata, state.parentAbstractInlineFragment);
+    state.currentNodeRequiredChildren.set(field.alias, newField);
+    var severity = getActionSeverity(directiveMetadata.action); // Assert that all @required children have at least this severity.
+
+    newState.currentNodeRequiredChildren.forEach(function (childField) {
+      var childMetadata = getRequiredDirectiveMetadata(childField);
+
+      if (childMetadata == null) {
+        return;
+      }
+
+      if (getActionSeverity(childMetadata.action) < severity) {
+        throw createUserError("The @required field [1] may not have an `action` less severe than that of its @required parent [2]. [1] should probably be `action: ".concat(directiveMetadata.action, "`."), [childMetadata.actionLoc, directiveMetadata.actionLoc]);
+      }
+    });
+  }
+
+  state.requiredChildrenMap.set(pathName, newState.currentNodeRequiredChildren);
+  return addChildrenCanBubbleMetadata(newField, newState);
+}
+
+function vistitScalarField(field, state) {
+  var pathName = [].concat((0, _toConsumableArray2["default"])(state.path), [field.alias]).join('.');
+  var newField = applyDirectives(field, pathName, state.documentName);
+  var directiveMetadata = getRequiredDirectiveMetadata(newField);
+
+  if (directiveMetadata != null) {
+    assertParentIsNotInvalidInlineFragmet(state.schema, directiveMetadata, state.parentAbstractInlineFragment);
+    state.currentNodeRequiredChildren.set(field.alias, newField);
+  }
+
+  assertCompatibleNullability(newField, pathName, state.pathRequiredMap);
+  return newField;
+}
+
+function addChildrenCanBubbleMetadata(node, state) {
+  var _iterator = _createForOfIteratorHelper(state.currentNodeRequiredChildren.values()),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var child = _step.value;
+      var requiredMetadata = getRequiredDirectiveMetadata(child);
+
+      if (requiredMetadata != null && requiredMetadata.action !== 'THROW') {
+        var metadata = _objectSpread(_objectSpread({}, node.metadata), {}, {
+          childrenCanBubbleNull: true
+        });
+
+        return _objectSpread(_objectSpread({}, node), {}, {
+          metadata: metadata
+        });
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return node;
+}
+
+function assertParentIsNotInvalidInlineFragmet(schema, directiveMetadata, parentAbstractInlineFragment) {
+  if (parentAbstractInlineFragment == null) {
+    return;
+  }
+
+  var typeCondition = parentAbstractInlineFragment.typeCondition;
+
+  if (schema.isUnion(typeCondition)) {
+    throw createUserError('The @required directive [1] may not be used anywhere within an inline fragment on a union type [2].', [directiveMetadata.directiveLoc, parentAbstractInlineFragment.loc]);
+  } else if (schema.isInterface(typeCondition)) {
+    throw createUserError('The @required directive [1] may not be used anywhere within an inline fragment on an interface type [2].', [directiveMetadata.directiveLoc, parentAbstractInlineFragment.loc]);
+  } else {
+    throw createCompilerError('Unexpected abstract inline fragment type.', [parentAbstractInlineFragment.loc]);
+  }
+} // Check that this field's nullability matches all other instances.
+
+
+function assertCompatibleNullability(field, pathName, pathRequiredMap) {
+  var existingField = pathRequiredMap.get(pathName);
+
+  if (existingField == null) {
+    pathRequiredMap.set(pathName, field);
+    return;
+  }
+
+  var requiredMetadata = getRequiredDirectiveMetadata(field);
+  var existingRequiredMetadata = getRequiredDirectiveMetadata(existingField);
+
+  if ((requiredMetadata === null || requiredMetadata === void 0 ? void 0 : requiredMetadata.action) === (existingRequiredMetadata === null || existingRequiredMetadata === void 0 ? void 0 : existingRequiredMetadata.action)) {
+    return;
+  }
+
+  if (requiredMetadata == null) {
+    throw createUserError("The field \"".concat(field.alias, "\" is @required in [1] but not in [2]."), [existingField.loc, field.loc]);
+  }
+
+  if (existingRequiredMetadata == null) {
+    throw createUserError("The field \"".concat(field.alias, "\" is @required in [1] but not in [2]."), [field.loc, existingField.loc]);
+  }
+
+  throw createUserError("The field \"".concat(field.alias, "\" has a different @required action in [1] than in [2]."), [requiredMetadata.actionLoc, existingRequiredMetadata.actionLoc]);
+} // Metadata is untyped, so we use this utility function to do the type coersion.
+
+
+function getRequiredDirectiveMetadata(field) {
+  var _field$metadata;
+
+  return (_field$metadata = field.metadata) === null || _field$metadata === void 0 ? void 0 : _field$metadata.required;
+} // Check that this field has the same required children as all other instances.
+
+
+function assertCompatibleRequiredChildren(field, fieldPath, _ref) {
+  var currentNodeRequiredChildren = _ref.currentNodeRequiredChildren,
+      pathRequiredMap = _ref.pathRequiredMap,
+      requiredChildrenMap = _ref.requiredChildrenMap;
+  var previouslyRequiredChildren = requiredChildrenMap.get(fieldPath);
+
+  if (previouslyRequiredChildren == null) {
+    return;
+  } // Check if this field has a required child field which was previously omitted.
+
+
+  var _iterator2 = _createForOfIteratorHelper(currentNodeRequiredChildren),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _step2$value = _step2.value,
+          path = _step2$value[0],
+          childField = _step2$value[1];
+
+      if (!previouslyRequiredChildren.has(path)) {
+        var otherParent = pathRequiredMap.get(fieldPath);
+
+        if (otherParent == null) {
+          throw createCompilerError("Could not find other parent node at path \"".concat(fieldPath, "\"."), [childField.loc]);
+        }
+
+        throw createMissingRequiredFieldError(childField, otherParent);
+      }
+    } // Check if a previous reference to this field had a required child field which we are missing.
+
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+
+  var _iterator3 = _createForOfIteratorHelper(previouslyRequiredChildren),
+      _step3;
+
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _step3$value = _step3.value,
+          _path = _step3$value[0],
+          _childField = _step3$value[1];
+
+      if (!currentNodeRequiredChildren.has(_path)) {
+        throw createMissingRequiredFieldError(_childField, field);
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+}
+
+function createMissingRequiredFieldError(requiredChild, missingParent) {
+  var alias = requiredChild.alias;
+  return createUserError("The field \"".concat(alias, "\" is marked as @required in [1] but is missing in [2]."), [requiredChild.loc, missingParent.loc]);
+} // TODO T74397896: Remove prefix gating once @required is rolled out more broadly.
+
+
+function featureIsEnabled(documentName) {
+  var featureFlag = RelayFeatureFlags.ENABLE_REQUIRED_DIRECTIVES;
+
+  if (typeof featureFlag === 'boolean') {
+    return featureFlag;
+  } else if (featureFlag === 'LIMITED') {
+    return documentName.startsWith('RelayRequiredTest');
+  } else if (typeof featureFlag === 'string') {
+    return featureFlag.split('|').some(function (prefix) {
+      return documentName.startsWith(prefix);
+    });
+  }
+
+  return false;
+} // Strip and validate @required directives, and convert them to metadata.
+
+
+function applyDirectives(field, pathName, documentName) {
+  var _partitionArray = partitionArray(field.directives, function (directive) {
+    return directive.name === 'required';
+  }),
+      requiredDirectives = _partitionArray[0],
+      otherDirectives = _partitionArray[1];
+
+  if (requiredDirectives.length === 0) {
+    return field;
+  }
+
+  if (!featureIsEnabled(documentName)) {
+    throw new createUserError( // Purposefully don't include details in this error message, since we
+    // don't want folks adopting this feature until it's been tested more.
+    'The @required directive is experimental and not yet supported for use in product code', requiredDirectives.map(function (x) {
+      return x.loc;
+    }));
+  }
+
+  if (requiredDirectives.length > 1) {
+    throw new createUserError('Did not expect multiple @required directives.', requiredDirectives.map(function (x) {
+      return x.loc;
+    }));
+  }
+
+  var requiredDirective = requiredDirectives[0];
+  var arg = requiredDirective.args[0]; // I would expect this check to be handled by the schema validation, but...
+
+  if (arg == null) {
+    throw createUserError('The @required directive requires an `action` argument.', [requiredDirective.loc]);
+  }
+
+  if (arg.value.kind !== 'Literal') {
+    throw createUserError('Expected @required `action` argument to be a literal.', [arg.value.loc]);
+  }
+
+  return _objectSpread(_objectSpread({}, field), {}, {
+    directives: otherDirectives,
+    metadata: _objectSpread(_objectSpread({}, field.metadata), {}, {
+      required: {
+        action: arg.value.value,
+        actionLoc: arg.loc,
+        directiveLoc: requiredDirective.loc,
+        path: pathName
+      }
+    })
+  });
+} // Transform @required directive to metadata
+
+
+module.exports = {
+  SCHEMA_EXTENSION: SCHEMA_EXTENSION,
+  transform: requiredFieldTransform
+};

package/lib/transforms/SkipClientExtensionsTransform.js

@@ -15,6 +15,7 @@ var IRTransformer = require('../core/IRTransformer');
 function skipClientExtensionTransform(context) {
   return IRTransformer.transform(context, {
     Fragment: visitFragment,
+    FragmentSpread: vistFragmentSpread,
     ClientExtension: visitClientExtension
   });
 }
@@ -29,6 +30,13 @@ function visitFragment(node) {
   return null;
 }
 
+function vistFragmentSpread(node) {
+  var context = this.getContext();
+  var fragment = context.getFragment(node.name, node.loc);
+  var isServer = context.getSchema().isServerType(fragment.type);
+  return isServer ? node : null;
+}
+
 function visitClientExtension(node, state) {
   return null;
 }

package/lib/transforms/SkipHandleFieldTransform.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 IRTransformer = require('../core/IRTransformer');
 
@@ -31,7 +35,7 @@ function visitField(field) {
   var transformedNode = this.traverse(field);
 
   if (transformedNode.handles) {
-    return (0, _objectSpread2["default"])({}, transformedNode, {
+    return _objectSpread(_objectSpread({}, transformedNode), {}, {
       handles: null
     });
   }

package/lib/transforms/SkipRedundantNodesTransform.js

@@ -12,10 +12,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 IRTransformer = require('../core/IRTransformer');
 
 var IMap = require('immutable').Map;
@@ -120,6 +124,7 @@ var invariant = require("fbjs/lib/invariant");
 function skipRedundantNodesTransform(context) {
   return IRTransformer.transform(context, {
     Root: visitNode,
+    SplitOperation: visitNode,
     Fragment: visitNode
   });
 }
@@ -154,6 +159,7 @@ function transformNode(schema, node, selectionMap) {
   var result;
 
   if (isEmptySelectionMap) {
+    // $FlowFixMe[escaped-generic]
     result = cache.get(node);
 
     if (result != null) {
@@ -214,7 +220,7 @@ function transformNode(schema, node, selectionMap) {
         !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'SkipRedundantNodesTransform: Unexpected node kind `%s`.', selection.kind) : invariant(false) : void 0;
     }
   });
-  var nextNode = selections.length ? (0, _objectSpread2["default"])({}, node, {
+  var nextNode = selections.length ? _objectSpread(_objectSpread({}, node), {}, {
     selections: selections
   }) : null;
   result = {
@@ -223,6 +229,7 @@ function transformNode(schema, node, selectionMap) {
   };
 
   if (isEmptySelectionMap) {
+    // $FlowFixMe[escaped-generic]
     cache.set(node, result);
   }
 

package/lib/transforms/SkipSplitOperationTransform.js

@@ -0,0 +1,32 @@
+/**
+ * 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 IRTransformer = require('../core/IRTransformer');
+
+function skipNode() {
+  return null;
+}
+/**
+ * A transform that removes field `splitOperations`. Intended for use when e.g.
+ * printing queries to send to a GraphQL server.
+ */
+
+
+function skipSplitOperationTransform(context) {
+  return IRTransformer.transform(context, {
+    SplitOperation: skipNode
+  });
+}
+
+module.exports = {
+  transform: skipSplitOperationTransform
+};

package/lib/transforms/SkipUnreachableNodeTransform.js

@@ -12,10 +12,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 IRTransformer = require('../core/IRTransformer');
 
 var invariant = require("fbjs/lib/invariant");
@@ -37,6 +41,9 @@ function skipUnreachableNodeTransform(context) {
     Root: function Root(node) {
       return transformNode(context, fragments, node);
     },
+    SplitOperation: function SplitOperation(node) {
+      return transformNode(context, fragments, node);
+    },
     // Fragments are included below where referenced.
     // Unreferenced fragments are not included.
     Fragment: function Fragment(id) {
@@ -129,7 +136,7 @@ function transformNode(context, fragments, node) {
   }
 
   if (selections) {
-    return (0, _objectSpread2["default"])({}, node, {
+    return _objectSpread(_objectSpread({}, node), {}, {
       selections: selections
     });
   }

package/lib/transforms/SkipUnusedVariablesTransform.js

@@ -12,7 +12,17 @@
 
 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; }
+
+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 inferRootArgumentDefinitions = require('../core/inferRootArgumentDefinitions');
 
@@ -25,9 +35,9 @@ function skipUnusedVariablesTransform(context) {
   var contextWithUsedArguments = inferRootArgumentDefinitions(context);
   return context.withMutations(function (ctx) {
     var nextContext = ctx;
-    var _iteratorNormalCompletion = true;
-    var _didIteratorError = false;
-    var _iteratorError = undefined;
+
+    var _iterator = _createForOfIteratorHelper(nextContext.documents()),
+        _step;
 
     try {
       var _loop = function _loop() {
@@ -46,30 +56,21 @@ function skipUnusedVariablesTransform(context) {
         });
 
         if (usedArgumentDefinitions.length !== node.argumentDefinitions.length) {
-          nextContext = nextContext.replace((0, _objectSpread2["default"])({}, node, {
+          nextContext = nextContext.replace(_objectSpread(_objectSpread({}, node), {}, {
             argumentDefinitions: usedArgumentDefinitions
           }));
         }
       };
 
-      for (var _iterator = nextContext.documents()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
         var _ret = _loop();
 
         if (_ret === "continue") continue;
       }
     } 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 nextContext;

package/lib/transforms/SplitModuleImportTransform.js

@@ -54,7 +54,7 @@ function visitModuleImport(node, state) {
   var createdSplitOperation = state.splitOperations.get(normalizationName);
 
   if (createdSplitOperation) {
-    createdSplitOperation.parentSources.add(node.documentName);
+    createdSplitOperation.parentSources.add(node.sourceDocument);
     return node;
   }
 
@@ -67,7 +67,7 @@ function visitModuleImport(node, state) {
       kind: 'Derived',
       source: node.loc
     },
-    parentSources: new Set([node.documentName]),
+    parentSources: new Set([node.sourceDocument]),
     metadata: {
       derivedFrom: transformedNode.name
     },