graphql 14.4.2 → 14.5.3

package/type/validate.mjs

@@ -2,14 +2,14 @@ import find from '../polyfills/find';
 import flatMap from '../polyfills/flatMap';
 import objectValues from '../polyfills/objectValues';
 import objectEntries from '../polyfills/objectEntries';
-import { isObjectType, isInterfaceType, isUnionType, isEnumType, isInputObjectType, isNamedType, isNonNullType, isInputType, isOutputType, isRequiredArgument } from './definition';
-import { isDirective } from './directives';
-import { isIntrospectionType } from './introspection';
-import { assertSchema } from './schema';
 import inspect from '../jsutils/inspect';
 import { GraphQLError } from '../error/GraphQLError';
 import { isValidNameError } from '../utilities/assertValidName';
 import { isEqualType, isTypeSubTypeOf } from '../utilities/typeComparators';
+import { isDirective } from './directives';
+import { isIntrospectionType } from './introspection';
+import { assertSchema } from './schema';
+import { isObjectType, isInterfaceType, isUnionType, isEnumType, isInputObjectType, isNamedType, isNonNullType, isInputType, isOutputType, isRequiredArgument } from './definition';
 /**
  * Implements the "Type Validation" sub-sections of the specification's
  * "Type System" section.
@@ -106,30 +106,12 @@ function getOperationTypeNode(schema, type, operation) {
   var operationNodes = getAllSubNodes(schema, function (node) {
     return node.operationTypes;
   });
-  var _iteratorNormalCompletion = true;
-  var _didIteratorError = false;
-  var _iteratorError = undefined;
 
-  try {
-    for (var _iterator = operationNodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-      var node = _step.value;
+  for (var _i2 = 0; _i2 < operationNodes.length; _i2++) {
+    var node = operationNodes[_i2];
 
-      if (node.operation === operation) {
-        return node.type;
-      }
-    }
-  } catch (err) {
-    _didIteratorError = true;
-    _iteratorError = err;
-  } finally {
-    try {
-      if (!_iteratorNormalCompletion && _iterator.return != null) {
-        _iterator.return();
-      }
-    } finally {
-      if (_didIteratorError) {
-        throw _iteratorError;
-      }
+    if (node.operation === operation) {
+      return node.type;
     }
   }
 
@@ -137,86 +119,49 @@ function getOperationTypeNode(schema, type, operation) {
 }
 
 function validateDirectives(context) {
-  var _iteratorNormalCompletion2 = true;
-  var _didIteratorError2 = false;
-  var _iteratorError2 = undefined;
-
-  try {
-    for (var _iterator2 = context.schema.getDirectives()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-      var directive = _step2.value;
-
-      // Ensure all directives are in fact GraphQL directives.
-      if (!isDirective(directive)) {
-        context.reportError("Expected directive but got: ".concat(inspect(directive), "."), directive && directive.astNode);
-        continue;
-      } // Ensure they are named correctly.
-
-
-      validateName(context, directive); // TODO: Ensure proper locations.
-      // Ensure the arguments are valid.
-
-      var argNames = Object.create(null);
-      var _iteratorNormalCompletion3 = true;
-      var _didIteratorError3 = false;
-      var _iteratorError3 = undefined;
-
-      try {
-        var _loop = function _loop() {
-          var arg = _step3.value;
-          var argName = arg.name; // Ensure they are named correctly.
-
-          validateName(context, arg); // Ensure they are unique per directive.
-
-          if (argNames[argName]) {
-            context.reportError("Argument @".concat(directive.name, "(").concat(argName, ":) can only be defined once."), directive.astNode && directive.args.filter(function (_ref) {
-              var name = _ref.name;
-              return name === argName;
-            }).map(function (_ref2) {
-              var astNode = _ref2.astNode;
-              return astNode;
-            }));
-            return "continue";
-          }
-
-          argNames[argName] = true; // Ensure the type is an input type.
-
-          if (!isInputType(arg.type)) {
-            context.reportError("The type of @".concat(directive.name, "(").concat(argName, ":) must be Input Type ") + "but got: ".concat(inspect(arg.type), "."), arg.astNode);
-          }
-        };
-
-        for (var _iterator3 = directive.args[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
-          var _ret = _loop();
-
-          if (_ret === "continue") continue;
-        }
-      } catch (err) {
-        _didIteratorError3 = true;
-        _iteratorError3 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-            _iterator3.return();
-          }
-        } finally {
-          if (_didIteratorError3) {
-            throw _iteratorError3;
-          }
-        }
-      }
-    }
-  } catch (err) {
-    _didIteratorError2 = true;
-    _iteratorError2 = err;
-  } finally {
-    try {
-      if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-        _iterator2.return();
+  for (var _i4 = 0, _context$schema$getDi2 = context.schema.getDirectives(); _i4 < _context$schema$getDi2.length; _i4++) {
+    var directive = _context$schema$getDi2[_i4];
+
+    // Ensure all directives are in fact GraphQL directives.
+    if (!isDirective(directive)) {
+      context.reportError("Expected directive but got: ".concat(inspect(directive), "."), directive && directive.astNode);
+      continue;
+    } // Ensure they are named correctly.
+
+
+    validateName(context, directive); // TODO: Ensure proper locations.
+    // Ensure the arguments are valid.
+
+    var argNames = Object.create(null);
+
+    var _loop = function _loop(_i6, _directive$args2) {
+      var arg = _directive$args2[_i6];
+      var argName = arg.name; // Ensure they are named correctly.
+
+      validateName(context, arg); // Ensure they are unique per directive.
+
+      if (argNames[argName]) {
+        context.reportError("Argument @".concat(directive.name, "(").concat(argName, ":) can only be defined once."), directive.astNode && directive.args.filter(function (_ref) {
+          var name = _ref.name;
+          return name === argName;
+        }).map(function (_ref2) {
+          var astNode = _ref2.astNode;
+          return astNode;
+        }));
+        return "continue";
       }
-    } finally {
-      if (_didIteratorError2) {
-        throw _iteratorError2;
+
+      argNames[argName] = true; // Ensure the type is an input type.
+
+      if (!isInputType(arg.type)) {
+        context.reportError("The type of @".concat(directive.name, "(").concat(argName, ":) must be Input Type ") + "but got: ".concat(inspect(arg.type), "."), arg.astNode);
       }
+    };
+
+    for (var _i6 = 0, _directive$args2 = directive.args; _i6 < _directive$args2.length; _i6++) {
+      var _ret = _loop(_i6, _directive$args2);
+
+      if (_ret === "continue") continue;
     }
   }
 }
@@ -239,58 +184,40 @@ function validateName(context, node) {
 function validateTypes(context) {
   var validateInputObjectCircularRefs = createInputObjectCircularRefsValidator(context);
   var typeMap = context.schema.getTypeMap();
-  var _iteratorNormalCompletion4 = true;
-  var _didIteratorError4 = false;
-  var _iteratorError4 = undefined;
-
-  try {
-    for (var _iterator4 = objectValues(typeMap)[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
-      var type = _step4.value;
 
-      // Ensure all provided types are in fact GraphQL type.
-      if (!isNamedType(type)) {
-        context.reportError("Expected GraphQL named type but got: ".concat(inspect(type), "."), type && type.astNode);
-        continue;
-      } // Ensure it is named correctly (excluding introspection types).
+  for (var _i8 = 0, _objectValues2 = objectValues(typeMap); _i8 < _objectValues2.length; _i8++) {
+    var type = _objectValues2[_i8];
 
+    // Ensure all provided types are in fact GraphQL type.
+    if (!isNamedType(type)) {
+      context.reportError("Expected GraphQL named type but got: ".concat(inspect(type), "."), type && type.astNode);
+      continue;
+    } // Ensure it is named correctly (excluding introspection types).
 
-      if (!isIntrospectionType(type)) {
-        validateName(context, type);
-      }
 
-      if (isObjectType(type)) {
-        // Ensure fields are valid
-        validateFields(context, type); // Ensure objects implement the interfaces they claim to.
-
-        validateObjectInterfaces(context, type);
-      } else if (isInterfaceType(type)) {
-        // Ensure fields are valid.
-        validateFields(context, type);
-      } else if (isUnionType(type)) {
-        // Ensure Unions include valid member types.
-        validateUnionMembers(context, type);
-      } else if (isEnumType(type)) {
-        // Ensure Enums have valid values.
-        validateEnumValues(context, type);
-      } else if (isInputObjectType(type)) {
-        // Ensure Input Object fields are valid.
-        validateInputFields(context, type); // Ensure Input Objects do not contain non-nullable circular references
-
-        validateInputObjectCircularRefs(type);
-      }
+    if (!isIntrospectionType(type)) {
+      validateName(context, type);
     }
-  } catch (err) {
-    _didIteratorError4 = true;
-    _iteratorError4 = err;
-  } finally {
-    try {
-      if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
-        _iterator4.return();
-      }
-    } finally {
-      if (_didIteratorError4) {
-        throw _iteratorError4;
-      }
+
+    if (isObjectType(type)) {
+      // Ensure fields are valid
+      validateFields(context, type); // Ensure objects implement the interfaces they claim to.
+
+      validateObjectInterfaces(context, type);
+    } else if (isInterfaceType(type)) {
+      // Ensure fields are valid.
+      validateFields(context, type);
+    } else if (isUnionType(type)) {
+      // Ensure Unions include valid member types.
+      validateUnionMembers(context, type);
+    } else if (isEnumType(type)) {
+      // Ensure Enums have valid values.
+      validateEnumValues(context, type);
+    } else if (isInputObjectType(type)) {
+      // Ensure Input Object fields are valid.
+      validateInputFields(context, type); // Ensure Input Objects do not contain non-nullable circular references
+
+      validateInputObjectCircularRefs(type);
     }
   }
 }
@@ -302,120 +229,65 @@ function validateFields(context, type) {
     context.reportError("Type ".concat(type.name, " must define one or more fields."), getAllNodes(type));
   }
 
-  var _iteratorNormalCompletion5 = true;
-  var _didIteratorError5 = false;
-  var _iteratorError5 = undefined;
-
-  try {
-    for (var _iterator5 = fields[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
-      var field = _step5.value;
-      // Ensure they are named correctly.
-      validateName(context, field); // Ensure the type is an output type
-
-      if (!isOutputType(field.type)) {
-        context.reportError("The type of ".concat(type.name, ".").concat(field.name, " must be Output Type ") + "but got: ".concat(inspect(field.type), "."), field.astNode && field.astNode.type);
-      } // Ensure the arguments are valid
+  for (var _i10 = 0; _i10 < fields.length; _i10++) {
+    var field = fields[_i10];
+    // Ensure they are named correctly.
+    validateName(context, field); // Ensure the type is an output type
 
+    if (!isOutputType(field.type)) {
+      context.reportError("The type of ".concat(type.name, ".").concat(field.name, " must be Output Type ") + "but got: ".concat(inspect(field.type), "."), field.astNode && field.astNode.type);
+    } // Ensure the arguments are valid
 
-      var argNames = Object.create(null);
-      var _iteratorNormalCompletion6 = true;
-      var _didIteratorError6 = false;
-      var _iteratorError6 = undefined;
 
-      try {
-        var _loop2 = function _loop2() {
-          var arg = _step6.value;
-          var argName = arg.name; // Ensure they are named correctly.
+    var argNames = Object.create(null);
 
-          validateName(context, arg); // Ensure they are unique per field.
+    var _loop2 = function _loop2(_i12, _field$args2) {
+      var arg = _field$args2[_i12];
+      var argName = arg.name; // Ensure they are named correctly.
 
-          if (argNames[argName]) {
-            context.reportError("Field argument ".concat(type.name, ".").concat(field.name, "(").concat(argName, ":) can only be defined once."), field.args.filter(function (_ref3) {
-              var name = _ref3.name;
-              return name === argName;
-            }).map(function (_ref4) {
-              var astNode = _ref4.astNode;
-              return astNode;
-            }));
-          }
+      validateName(context, arg); // Ensure they are unique per field.
 
-          argNames[argName] = true; // Ensure the type is an input type
+      if (argNames[argName]) {
+        context.reportError("Field argument ".concat(type.name, ".").concat(field.name, "(").concat(argName, ":) can only be defined once."), field.args.filter(function (_ref3) {
+          var name = _ref3.name;
+          return name === argName;
+        }).map(function (_ref4) {
+          var astNode = _ref4.astNode;
+          return astNode;
+        }));
+      }
 
-          if (!isInputType(arg.type)) {
-            context.reportError("The type of ".concat(type.name, ".").concat(field.name, "(").concat(argName, ":) must be Input ") + "Type but got: ".concat(inspect(arg.type), "."), arg.astNode && arg.astNode.type);
-          }
-        };
+      argNames[argName] = true; // Ensure the type is an input type
 
-        for (var _iterator6 = field.args[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
-          _loop2();
-        }
-      } catch (err) {
-        _didIteratorError6 = true;
-        _iteratorError6 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
-            _iterator6.return();
-          }
-        } finally {
-          if (_didIteratorError6) {
-            throw _iteratorError6;
-          }
-        }
-      }
-    }
-  } catch (err) {
-    _didIteratorError5 = true;
-    _iteratorError5 = err;
-  } finally {
-    try {
-      if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
-        _iterator5.return();
-      }
-    } finally {
-      if (_didIteratorError5) {
-        throw _iteratorError5;
+      if (!isInputType(arg.type)) {
+        context.reportError("The type of ".concat(type.name, ".").concat(field.name, "(").concat(argName, ":) must be Input ") + "Type but got: ".concat(inspect(arg.type), "."), arg.astNode && arg.astNode.type);
       }
+    };
+
+    for (var _i12 = 0, _field$args2 = field.args; _i12 < _field$args2.length; _i12++) {
+      _loop2(_i12, _field$args2);
     }
   }
 }
 
 function validateObjectInterfaces(context, object) {
   var implementedTypeNames = Object.create(null);
-  var _iteratorNormalCompletion7 = true;
-  var _didIteratorError7 = false;
-  var _iteratorError7 = undefined;
-
-  try {
-    for (var _iterator7 = object.getInterfaces()[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
-      var iface = _step7.value;
 
-      if (!isInterfaceType(iface)) {
-        context.reportError("Type ".concat(inspect(object), " must only implement Interface types, ") + "it cannot implement ".concat(inspect(iface), "."), getAllImplementsInterfaceNodes(object, iface));
-        continue;
-      }
-
-      if (implementedTypeNames[iface.name]) {
-        context.reportError("Type ".concat(object.name, " can only implement ").concat(iface.name, " once."), getAllImplementsInterfaceNodes(object, iface));
-        continue;
-      }
+  for (var _i14 = 0, _object$getInterfaces2 = object.getInterfaces(); _i14 < _object$getInterfaces2.length; _i14++) {
+    var iface = _object$getInterfaces2[_i14];
 
-      implementedTypeNames[iface.name] = true;
-      validateObjectImplementsInterface(context, object, iface);
+    if (!isInterfaceType(iface)) {
+      context.reportError("Type ".concat(inspect(object), " must only implement Interface types, ") + "it cannot implement ".concat(inspect(iface), "."), getAllImplementsInterfaceNodes(object, iface));
+      continue;
     }
-  } catch (err) {
-    _didIteratorError7 = true;
-    _iteratorError7 = err;
-  } finally {
-    try {
-      if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
-        _iterator7.return();
-      }
-    } finally {
-      if (_didIteratorError7) {
-        throw _iteratorError7;
-      }
+
+    if (implementedTypeNames[iface.name]) {
+      context.reportError("Type ".concat(object.name, " can only implement ").concat(iface.name, " once."), getAllImplementsInterfaceNodes(object, iface));
+      continue;
     }
+
+    implementedTypeNames[iface.name] = true;
+    validateObjectImplementsInterface(context, object, iface);
   }
 }
 
@@ -423,123 +295,66 @@ function validateObjectImplementsInterface(context, object, iface) {
   var objectFieldMap = object.getFields();
   var ifaceFieldMap = iface.getFields(); // Assert each interface field is implemented.
 
-  var _iteratorNormalCompletion8 = true;
-  var _didIteratorError8 = false;
-  var _iteratorError8 = undefined;
-
-  try {
-    for (var _iterator8 = objectEntries(ifaceFieldMap)[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
-      var _ref6 = _step8.value;
-      var fieldName = _ref6[0];
-      var ifaceField = _ref6[1];
-      var objectField = objectFieldMap[fieldName]; // Assert interface field exists on object.
-
-      if (!objectField) {
-        context.reportError("Interface field ".concat(iface.name, ".").concat(fieldName, " expected but ").concat(object.name, " does not provide it."), [ifaceField.astNode].concat(getAllNodes(object)));
-        continue;
-      } // Assert interface field type is satisfied by object field type, by being
-      // a valid subtype. (covariant)
-
-
-      if (!isTypeSubTypeOf(context.schema, objectField.type, ifaceField.type)) {
-        context.reportError("Interface field ".concat(iface.name, ".").concat(fieldName, " expects type ") + "".concat(inspect(ifaceField.type), " but ").concat(object.name, ".").concat(fieldName, " ") + "is type ".concat(inspect(objectField.type), "."), [ifaceField.astNode && ifaceField.astNode.type, objectField.astNode && objectField.astNode.type]);
-      } // Assert each interface field arg is implemented.
-
-
-      var _iteratorNormalCompletion9 = true;
-      var _didIteratorError9 = false;
-      var _iteratorError9 = undefined;
-
-      try {
-        var _loop3 = function _loop3() {
-          var ifaceArg = _step9.value;
-          var argName = ifaceArg.name;
-          var objectArg = find(objectField.args, function (arg) {
-            return arg.name === argName;
-          }); // Assert interface field arg exists on object field.
-
-          if (!objectArg) {
-            context.reportError("Interface field argument ".concat(iface.name, ".").concat(fieldName, "(").concat(argName, ":) expected but ").concat(object.name, ".").concat(fieldName, " does not provide it."), [ifaceArg.astNode, objectField.astNode]);
-            return "continue";
-          } // Assert interface field arg type matches object field arg type.
-          // (invariant)
-          // TODO: change to contravariant?
-
-
-          if (!isEqualType(ifaceArg.type, objectArg.type)) {
-            context.reportError("Interface field argument ".concat(iface.name, ".").concat(fieldName, "(").concat(argName, ":) ") + "expects type ".concat(inspect(ifaceArg.type), " but ") + "".concat(object.name, ".").concat(fieldName, "(").concat(argName, ":) is type ") + "".concat(inspect(objectArg.type), "."), [ifaceArg.astNode && ifaceArg.astNode.type, objectArg.astNode && objectArg.astNode.type]);
-          } // TODO: validate default values?
-
-        };
-
-        for (var _iterator9 = ifaceField.args[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
-          var _ret2 = _loop3();
-
-          if (_ret2 === "continue") continue;
-        } // Assert additional arguments must not be required.
-
-      } catch (err) {
-        _didIteratorError9 = true;
-        _iteratorError9 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion9 && _iterator9.return != null) {
-            _iterator9.return();
-          }
-        } finally {
-          if (_didIteratorError9) {
-            throw _iteratorError9;
-          }
-        }
-      }
+  for (var _i16 = 0, _objectEntries2 = objectEntries(ifaceFieldMap); _i16 < _objectEntries2.length; _i16++) {
+    var _ref6 = _objectEntries2[_i16];
+    var fieldName = _ref6[0];
+    var ifaceField = _ref6[1];
+    var objectField = objectFieldMap[fieldName]; // Assert interface field exists on object.
 
-      var _iteratorNormalCompletion10 = true;
-      var _didIteratorError10 = false;
-      var _iteratorError10 = undefined;
-
-      try {
-        var _loop4 = function _loop4() {
-          var objectArg = _step10.value;
-          var argName = objectArg.name;
-          var ifaceArg = find(ifaceField.args, function (arg) {
-            return arg.name === argName;
-          });
-
-          if (!ifaceArg && isRequiredArgument(objectArg)) {
-            context.reportError("Object field ".concat(object.name, ".").concat(fieldName, " includes required argument ").concat(argName, " that is missing from the Interface field ").concat(iface.name, ".").concat(fieldName, "."), [objectArg.astNode, ifaceField.astNode]);
-          }
-        };
-
-        for (var _iterator10 = objectField.args[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
-          _loop4();
-        }
-      } catch (err) {
-        _didIteratorError10 = true;
-        _iteratorError10 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion10 && _iterator10.return != null) {
-            _iterator10.return();
-          }
-        } finally {
-          if (_didIteratorError10) {
-            throw _iteratorError10;
-          }
-        }
-      }
-    }
-  } catch (err) {
-    _didIteratorError8 = true;
-    _iteratorError8 = err;
-  } finally {
-    try {
-      if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
-        _iterator8.return();
-      }
-    } finally {
-      if (_didIteratorError8) {
-        throw _iteratorError8;
+    if (!objectField) {
+      context.reportError("Interface field ".concat(iface.name, ".").concat(fieldName, " expected but ").concat(object.name, " does not provide it."), [ifaceField.astNode].concat(getAllNodes(object)));
+      continue;
+    } // Assert interface field type is satisfied by object field type, by being
+    // a valid subtype. (covariant)
+
+
+    if (!isTypeSubTypeOf(context.schema, objectField.type, ifaceField.type)) {
+      context.reportError("Interface field ".concat(iface.name, ".").concat(fieldName, " expects type ") + "".concat(inspect(ifaceField.type), " but ").concat(object.name, ".").concat(fieldName, " ") + "is type ".concat(inspect(objectField.type), "."), [ifaceField.astNode && ifaceField.astNode.type, objectField.astNode && objectField.astNode.type]);
+    } // Assert each interface field arg is implemented.
+
+
+    var _loop3 = function _loop3(_i18, _ifaceField$args2) {
+      var ifaceArg = _ifaceField$args2[_i18];
+      var argName = ifaceArg.name;
+      var objectArg = find(objectField.args, function (arg) {
+        return arg.name === argName;
+      }); // Assert interface field arg exists on object field.
+
+      if (!objectArg) {
+        context.reportError("Interface field argument ".concat(iface.name, ".").concat(fieldName, "(").concat(argName, ":) expected but ").concat(object.name, ".").concat(fieldName, " does not provide it."), [ifaceArg.astNode, objectField.astNode]);
+        return "continue";
+      } // Assert interface field arg type matches object field arg type.
+      // (invariant)
+      // TODO: change to contravariant?
+
+
+      if (!isEqualType(ifaceArg.type, objectArg.type)) {
+        context.reportError("Interface field argument ".concat(iface.name, ".").concat(fieldName, "(").concat(argName, ":) ") + "expects type ".concat(inspect(ifaceArg.type), " but ") + "".concat(object.name, ".").concat(fieldName, "(").concat(argName, ":) is type ") + "".concat(inspect(objectArg.type), "."), [ifaceArg.astNode && ifaceArg.astNode.type, objectArg.astNode && objectArg.astNode.type]);
+      } // TODO: validate default values?
+
+    };
+
+    for (var _i18 = 0, _ifaceField$args2 = ifaceField.args; _i18 < _ifaceField$args2.length; _i18++) {
+      var _ret2 = _loop3(_i18, _ifaceField$args2);
+
+      if (_ret2 === "continue") continue;
+    } // Assert additional arguments must not be required.
+
+
+    var _loop4 = function _loop4(_i20, _objectField$args2) {
+      var objectArg = _objectField$args2[_i20];
+      var argName = objectArg.name;
+      var ifaceArg = find(ifaceField.args, function (arg) {
+        return arg.name === argName;
+      });
+
+      if (!ifaceArg && isRequiredArgument(objectArg)) {
+        context.reportError("Object field ".concat(object.name, ".").concat(fieldName, " includes required argument ").concat(argName, " that is missing from the Interface field ").concat(iface.name, ".").concat(fieldName, "."), [objectArg.astNode, ifaceField.astNode]);
       }
+    };
+
+    for (var _i20 = 0, _objectField$args2 = objectField.args; _i20 < _objectField$args2.length; _i20++) {
+      _loop4(_i20, _objectField$args2);
     }
   }
 }
@@ -552,37 +367,19 @@ function validateUnionMembers(context, union) {
   }
 
   var includedTypeNames = Object.create(null);
-  var _iteratorNormalCompletion11 = true;
-  var _didIteratorError11 = false;
-  var _iteratorError11 = undefined;
 
-  try {
-    for (var _iterator11 = memberTypes[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
-      var memberType = _step11.value;
+  for (var _i22 = 0; _i22 < memberTypes.length; _i22++) {
+    var memberType = memberTypes[_i22];
 
-      if (includedTypeNames[memberType.name]) {
-        context.reportError("Union type ".concat(union.name, " can only include type ").concat(memberType.name, " once."), getUnionMemberTypeNodes(union, memberType.name));
-        continue;
-      }
+    if (includedTypeNames[memberType.name]) {
+      context.reportError("Union type ".concat(union.name, " can only include type ").concat(memberType.name, " once."), getUnionMemberTypeNodes(union, memberType.name));
+      continue;
+    }
 
-      includedTypeNames[memberType.name] = true;
+    includedTypeNames[memberType.name] = true;
 
-      if (!isObjectType(memberType)) {
-        context.reportError("Union type ".concat(union.name, " can only include Object types, ") + "it cannot include ".concat(inspect(memberType), "."), getUnionMemberTypeNodes(union, String(memberType)));
-      }
-    }
-  } catch (err) {
-    _didIteratorError11 = true;
-    _iteratorError11 = err;
-  } finally {
-    try {
-      if (!_iteratorNormalCompletion11 && _iterator11.return != null) {
-        _iterator11.return();
-      }
-    } finally {
-      if (_didIteratorError11) {
-        throw _iteratorError11;
-      }
+    if (!isObjectType(memberType)) {
+      context.reportError("Union type ".concat(union.name, " can only include Object types, ") + "it cannot include ".concat(inspect(memberType), "."), getUnionMemberTypeNodes(union, String(memberType)));
     }
   }
 }
@@ -594,33 +391,14 @@ function validateEnumValues(context, enumType) {
     context.reportError("Enum type ".concat(enumType.name, " must define one or more values."), getAllNodes(enumType));
   }
 
-  var _iteratorNormalCompletion12 = true;
-  var _didIteratorError12 = false;
-  var _iteratorError12 = undefined;
-
-  try {
-    for (var _iterator12 = enumValues[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
-      var enumValue = _step12.value;
-      var valueName = enumValue.name; // Ensure valid name.
+  for (var _i24 = 0; _i24 < enumValues.length; _i24++) {
+    var enumValue = enumValues[_i24];
+    var valueName = enumValue.name; // Ensure valid name.
 
-      validateName(context, enumValue);
+    validateName(context, enumValue);
 
-      if (valueName === 'true' || valueName === 'false' || valueName === 'null') {
-        context.reportError("Enum type ".concat(enumType.name, " cannot include value: ").concat(valueName, "."), enumValue.astNode);
-      }
-    }
-  } catch (err) {
-    _didIteratorError12 = true;
-    _iteratorError12 = err;
-  } finally {
-    try {
-      if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
-        _iterator12.return();
-      }
-    } finally {
-      if (_didIteratorError12) {
-        throw _iteratorError12;
-      }
+    if (valueName === 'true' || valueName === 'false' || valueName === 'null') {
+      context.reportError("Enum type ".concat(enumType.name, " cannot include value: ").concat(valueName, "."), enumValue.astNode);
     }
   }
 }
@@ -633,32 +411,13 @@ function validateInputFields(context, inputObj) {
   } // Ensure the arguments are valid
 
 
-  var _iteratorNormalCompletion13 = true;
-  var _didIteratorError13 = false;
-  var _iteratorError13 = undefined;
-
-  try {
-    for (var _iterator13 = fields[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true) {
-      var field = _step13.value;
-      // Ensure they are named correctly.
-      validateName(context, field); // Ensure the type is an input type
+  for (var _i26 = 0; _i26 < fields.length; _i26++) {
+    var field = fields[_i26];
+    // Ensure they are named correctly.
+    validateName(context, field); // Ensure the type is an input type
 
-      if (!isInputType(field.type)) {
-        context.reportError("The type of ".concat(inputObj.name, ".").concat(field.name, " must be Input Type ") + "but got: ".concat(inspect(field.type), "."), field.astNode && field.astNode.type);
-      }
-    }
-  } catch (err) {
-    _didIteratorError13 = true;
-    _iteratorError13 = err;
-  } finally {
-    try {
-      if (!_iteratorNormalCompletion13 && _iterator13.return != null) {
-        _iterator13.return();
-      }
-    } finally {
-      if (_didIteratorError13) {
-        throw _iteratorError13;
-      }
+    if (!isInputType(field.type)) {
+      context.reportError("The type of ".concat(inputObj.name, ".").concat(field.name, " must be Input Type ") + "but got: ".concat(inspect(field.type), "."), field.astNode && field.astNode.type);
     }
   }
 }
@@ -684,46 +443,28 @@ function createInputObjectCircularRefsValidator(context) {
     visitedTypes[inputObj.name] = true;
     fieldPathIndexByTypeName[inputObj.name] = fieldPath.length;
     var fields = objectValues(inputObj.getFields());
-    var _iteratorNormalCompletion14 = true;
-    var _didIteratorError14 = false;
-    var _iteratorError14 = undefined;
-
-    try {
-      for (var _iterator14 = fields[Symbol.iterator](), _step14; !(_iteratorNormalCompletion14 = (_step14 = _iterator14.next()).done); _iteratorNormalCompletion14 = true) {
-        var field = _step14.value;
-
-        if (isNonNullType(field.type) && isInputObjectType(field.type.ofType)) {
-          var fieldType = field.type.ofType;
-          var cycleIndex = fieldPathIndexByTypeName[fieldType.name];
-          fieldPath.push(field);
-
-          if (cycleIndex === undefined) {
-            detectCycleRecursive(fieldType);
-          } else {
-            var cyclePath = fieldPath.slice(cycleIndex);
-            var pathStr = cyclePath.map(function (fieldObj) {
-              return fieldObj.name;
-            }).join('.');
-            context.reportError("Cannot reference Input Object \"".concat(fieldType.name, "\" within itself through a series of non-null fields: \"").concat(pathStr, "\"."), cyclePath.map(function (fieldObj) {
-              return fieldObj.astNode;
-            }));
-          }
-
-          fieldPath.pop();
-        }
-      }
-    } catch (err) {
-      _didIteratorError14 = true;
-      _iteratorError14 = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion14 && _iterator14.return != null) {
-          _iterator14.return();
-        }
-      } finally {
-        if (_didIteratorError14) {
-          throw _iteratorError14;
+
+    for (var _i28 = 0; _i28 < fields.length; _i28++) {
+      var field = fields[_i28];
+
+      if (isNonNullType(field.type) && isInputObjectType(field.type.ofType)) {
+        var fieldType = field.type.ofType;
+        var cycleIndex = fieldPathIndexByTypeName[fieldType.name];
+        fieldPath.push(field);
+
+        if (cycleIndex === undefined) {
+          detectCycleRecursive(fieldType);
+        } else {
+          var cyclePath = fieldPath.slice(cycleIndex);
+          var pathStr = cyclePath.map(function (fieldObj) {
+            return fieldObj.name;
+          }).join('.');
+          context.reportError("Cannot reference Input Object \"".concat(fieldType.name, "\" within itself through a series of non-null fields: \"").concat(pathStr, "\"."), cyclePath.map(function (fieldObj) {
+            return fieldObj.astNode;
+          }));
         }
+
+        fieldPath.pop();
       }
     }