relay-compiler 10.0.1 → 10.1.0

package/lib/transforms/ReactFlightComponentTransform.js

@@ -0,0 +1,162 @@
+/**
+ * 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 _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 IRTransformer = require('../core/IRTransformer');
+
+var _require = require('../core/CompilerError'),
+    createUserError = _require.createUserError,
+    createCompilerError = _require.createCompilerError;
+
+var _require2 = require('relay-runtime'),
+    RelayFeatureFlags = _require2.RelayFeatureFlags;
+
+var FLIGHT_FIELD_COMPONENT_ARGUMENT_TYPE = 'String';
+var FLIGHT_FIELD_COMPONENT_ARGUMENT_NAME = 'component';
+var FLIGHT_FIELD_PROPS_ARGUMENT_NAME = 'props';
+var FLIGHT_FIELD_PROPS_TYPE = 'ReactFlightProps';
+var FLIGHT_FIELD_RETURN_TYPE = 'ReactFlightComponent';
+
+/**
+ * Experimental transform for React Flight.
+ */
+function reactFlightComponentTransform(context) {
+  var schema = context.getSchema();
+  var propsType = schema.getTypeFromString(FLIGHT_FIELD_PROPS_TYPE);
+  propsType = propsType ? schema.asInputType(propsType) : null;
+  var componentType = schema.getTypeFromString(FLIGHT_FIELD_RETURN_TYPE);
+  componentType = componentType ? schema.asScalarFieldType(componentType) : null;
+
+  if (!RelayFeatureFlags.ENABLE_REACT_FLIGHT_COMPONENT_FIELD || propsType == null || componentType == null) {
+    return context;
+  }
+
+  var types = {
+    propsType: propsType,
+    componentType: componentType
+  };
+  return IRTransformer.transform(context, {
+    ScalarField: visitScalarField,
+    LinkedField: visitLinkedField,
+    InlineFragment: visitInlineFragment
+  }, function (node) {
+    return {
+      parentType: node.type,
+      types: types
+    };
+  });
+}
+
+function visitInlineFragment(fragment, state) {
+  var _fragment$typeConditi;
+
+  return this.traverse(fragment, {
+    parentType: (_fragment$typeConditi = fragment.typeCondition) !== null && _fragment$typeConditi !== void 0 ? _fragment$typeConditi : state.parentType,
+    types: state.types
+  });
+}
+
+function visitLinkedField(field, state) {
+  return this.traverse(field, {
+    parentType: field.type,
+    types: state.types
+  });
+}
+
+function visitScalarField(field, state) {
+  // use the return type to quickly determine if this is a flight field
+  var schema = this.getContext().getSchema();
+
+  if (schema.getRawType(field.type) !== state.types.componentType) {
+    return field;
+  } // get the name of the component that provides this field
+
+
+  var clientField = schema.getFieldByName(state.parentType, field.name);
+
+  if (clientField == null) {
+    throw createCompilerError("Definition not found for field '".concat(schema.getTypeString(state.parentType), ".").concat(field.name, "'"), [field.loc]);
+  }
+
+  var componentDirective = clientField.directives.find(function (directive) {
+    return directive.name === 'react_flight_component';
+  });
+  var componentNameArg = componentDirective === null || componentDirective === void 0 ? void 0 : componentDirective.args.find(function (arg) {
+    return arg.name === 'name';
+  });
+
+  if (componentNameArg == null || componentNameArg.value.kind !== 'StringValue' || typeof componentNameArg.value.value !== 'string') {
+    throw createUserError('Invalid Flight field, expected the schema extension to specify ' + "the component's module name with the '@react_flight_component' directive", [field.loc]);
+  }
+
+  var componentName = componentNameArg.value.value; // validate that the parent type has a `flight(component, props)` field
+
+  var flightField = schema.getFieldByName(state.parentType, 'flight');
+
+  if (flightField == null) {
+    throw createUserError("Invalid Flight field, expected the parent type '".concat(schema.getTypeString(state.parentType), "' ") + "to define a 'flight(component: String, props: ReactFlightProps): ReactFlightComponent' field", [field.loc]);
+  }
+
+  var componentArg = flightField.args.get(FLIGHT_FIELD_COMPONENT_ARGUMENT_NAME);
+  var propsArg = flightField.args.get(FLIGHT_FIELD_PROPS_ARGUMENT_NAME);
+
+  if (componentArg == null || propsArg == null || schema.getRawType(componentArg.type) !== schema.getTypeFromString(FLIGHT_FIELD_COMPONENT_ARGUMENT_TYPE) || schema.getRawType(propsArg.type) !== state.types.propsType || schema.getRawType(flightField.type) !== state.types.componentType) {
+    throw createUserError("Invalid Flight field, expected the parent type '".concat(schema.getTypeString(state.parentType), "' ") + "to define a 'flight(component: String, props: ReactFlightProps): ReactFlightComponent' field", [field.loc]);
+  }
+
+  return _objectSpread(_objectSpread({}, field), {}, {
+    name: 'flight',
+    args: [{
+      kind: 'Argument',
+      loc: field.loc,
+      name: FLIGHT_FIELD_COMPONENT_ARGUMENT_NAME,
+      type: schema.getTypeFromString(FLIGHT_FIELD_COMPONENT_ARGUMENT_TYPE),
+      value: {
+        kind: 'Literal',
+        value: componentName,
+        loc: field.loc
+      }
+    }, {
+      kind: 'Argument',
+      loc: field.loc,
+      name: FLIGHT_FIELD_PROPS_ARGUMENT_NAME,
+      type: state.types.propsType,
+      value: {
+        kind: 'ObjectValue',
+        fields: field.args.map(function (arg) {
+          return {
+            kind: 'ObjectFieldValue',
+            loc: arg.loc,
+            name: arg.name,
+            value: arg.value
+          };
+        }),
+        loc: field.loc
+      }
+    }],
+    metadata: _objectSpread(_objectSpread({}, field.metadata || {}), {}, {
+      flight: true
+    }),
+    type: state.types.componentType
+  });
+}
+
+module.exports = {
+  transform: reactFlightComponentTransform
+};

package/lib/transforms/RefetchableFragmentTransform.js

@@ -64,8 +64,8 @@ function refetchableFragmentTransform(context) {
         transformedFragment = _buildRefetchOperatio.transformedFragment;
 
     var connectionMetadata = extractConnectionMetadata(context.getSchema(), transformedFragment);
-    nextContext = nextContext.replace(_objectSpread({}, transformedFragment, {
-      metadata: _objectSpread({}, transformedFragment.metadata || {}, {
+    nextContext = nextContext.replace(_objectSpread(_objectSpread({}, transformedFragment), {}, {
+      metadata: _objectSpread(_objectSpread({}, transformedFragment.metadata || {}), {}, {
         refetch: {
           connection: connectionMetadata !== null && connectionMetadata !== void 0 ? connectionMetadata : null,
           operation: refetchName,
@@ -74,8 +74,8 @@ function refetchableFragmentTransform(context) {
         }
       })
     }));
-    nextContext = nextContext.add(_objectSpread({}, node, {
-      metadata: _objectSpread({}, node.metadata || {}, {
+    nextContext = nextContext.add(_objectSpread(_objectSpread({}, node), {}, {
+      metadata: _objectSpread(_objectSpread({}, node.metadata || {}), {}, {
         derivedFrom: transformedFragment.name,
         isRefetchableQuery: true
       })

package/lib/transforms/RelayDirectiveTransform.js

@@ -51,12 +51,12 @@ function visitRelayMetadata(metadataFn) {
 
     var argValues = getLiteralArgumentValues(relayDirective.args);
     var metadata = metadataFn(argValues);
-    return this.traverse(_objectSpread({}, node, {
+    return this.traverse(_objectSpread(_objectSpread({}, node), {}, {
       directives: node.directives.filter(function (directive) {
         return directive !== relayDirective;
       }),
       // $FlowFixMe[cannot-spread-indexer]
-      metadata: _objectSpread({}, node.metadata || {}, {}, metadata)
+      metadata: _objectSpread(_objectSpread({}, node.metadata || {}), metadata)
     }));
   };
 }

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/SkipHandleFieldTransform.js

@@ -35,7 +35,7 @@ function visitField(field) {
   var transformedNode = this.traverse(field);
 
   if (transformedNode.handles) {
-    return _objectSpread({}, transformedNode, {
+    return _objectSpread(_objectSpread({}, transformedNode), {}, {
       handles: null
     });
   }

package/lib/transforms/SkipRedundantNodesTransform.js

@@ -159,6 +159,7 @@ function transformNode(schema, node, selectionMap) {
   var result;
 
   if (isEmptySelectionMap) {
+    // $FlowFixMe[escaped-generic]
     result = cache.get(node);
 
     if (result != null) {
@@ -219,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 ? _objectSpread({}, node, {
+  var nextNode = selections.length ? _objectSpread(_objectSpread({}, node), {}, {
     selections: selections
   }) : null;
   result = {
@@ -228,6 +229,7 @@ function transformNode(schema, node, selectionMap) {
   };
 
   if (isEmptySelectionMap) {
+    // $FlowFixMe[escaped-generic]
     cache.set(node, result);
   }
 

package/lib/transforms/SkipUnreachableNodeTransform.js

@@ -136,7 +136,7 @@ function transformNode(context, fragments, node) {
   }
 
   if (selections) {
-    return _objectSpread({}, node, {
+    return _objectSpread(_objectSpread({}, node), {}, {
       selections: selections
     });
   }

package/lib/transforms/SkipUnusedVariablesTransform.js

@@ -18,9 +18,9 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 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) { 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 _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(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+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; }
 
@@ -56,7 +56,7 @@ function skipUnusedVariablesTransform(context) {
         });
 
         if (usedArgumentDefinitions.length !== node.argumentDefinitions.length) {
-          nextContext = nextContext.replace(_objectSpread({}, node, {
+          nextContext = nextContext.replace(_objectSpread(_objectSpread({}, node), {}, {
             argumentDefinitions: usedArgumentDefinitions
           }));
         }

package/lib/transforms/TestOperationTransform.js

@@ -132,11 +132,11 @@ function visitRoot(node) {
   keys.forEach(function (key) {
     sortedSelectionsTypeInfo[key] = selectionsTypeInfo[key];
   });
-  return _objectSpread({}, node, {
+  return _objectSpread(_objectSpread({}, node), {}, {
     directives: node.directives.filter(function (directive) {
       return directive !== testDirective;
     }),
-    metadata: _objectSpread({}, node.metadata || {}, {
+    metadata: _objectSpread(_objectSpread({}, node.metadata || {}), {}, {
       relayTestingSelectionTypeInfo: sortedSelectionsTypeInfo
     })
   });