@luvio/graphql-parser 0.135.2 → 0.135.4

package/dist/luvioGraphqlParser.js

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 /**
  * Returns true if the value acts like a Promise, i.e. has a "then" function,
  * otherwise returns false.
@@ -120,11 +118,11 @@ function leftPad(len, str) {
 
 function _typeof$3(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$3 = function _typeof(obj) { return typeof obj; }; } else { _typeof$3 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$3(obj); }
 
-function ownKeys$3(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 ownKeys$1(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$3(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$3(Object(source), true).forEach(function (key) { _defineProperty$4(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$3(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty$2(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-function _defineProperty$4(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _defineProperty$2(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
@@ -244,7 +242,7 @@ var GraphQLError = /*#__PURE__*/function (_Error) {
     var originalExtensions = originalError === null || originalError === void 0 ? void 0 : originalError.extensions;
 
     if (extensions == null && isObjectLike(originalExtensions)) {
-      _this.extensions = _objectSpread$3({}, originalExtensions);
+      _this.extensions = _objectSpread$1({}, originalExtensions);
     } else {
       _this.extensions = extensions !== null && extensions !== void 0 ? extensions : {};
     } // By being enumerable, JSON.stringify will include bellow properties in the resulting output.
@@ -4359,13 +4357,6 @@ function isLeafType(type) {
  * These types may describe the parent context of a selection set.
  */
 
-function isCompositeType(type) {
-  return isObjectType(type) || isInterfaceType(type) || isUnionType(type);
-}
-/**
- * These types may describe the parent context of a selection set.
- */
-
 function isAbstractType(type) {
   return isInterfaceType(type) || isUnionType(type);
 }
@@ -4498,14 +4489,6 @@ function assertNullableType(type) {
 
   return type;
 }
-/* eslint-disable no-redeclare */
-
-function getNullableType(type) {
-  /* eslint-enable no-redeclare */
-  if (type) {
-    return isNonNullType(type) ? type.ofType : type;
-  }
-}
 /**
  * These named types do not include modifiers like List or NonNull.
  */
@@ -5335,43 +5318,6 @@ function isTypeSubTypeOf(schema, maybeSubType, superType) {
 
   return isAbstractType(superType) && (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) && schema.isSubType(superType, maybeSubType);
 }
-/**
- * Provided two composite types, determine if they "overlap". Two composite
- * types overlap when the Sets of possible concrete types for each intersect.
- *
- * This is often used to determine if a fragment of a given type could possibly
- * be visited in a context of another type.
- *
- * This function is commutative.
- */
-
-function doTypesOverlap(schema, typeA, typeB) {
-  // Equivalent types overlap
-  if (typeA === typeB) {
-    return true;
-  }
-
-  if (isAbstractType(typeA)) {
-    if (isAbstractType(typeB)) {
-      // If both types are abstract, then determine if there is any intersection
-      // between possible concrete types of each.
-      return schema.getPossibleTypes(typeA).some(function (type) {
-        return schema.isSubType(typeB, type);
-      });
-    } // Determine if the latter type is a possible concrete type of the former.
-
-
-    return schema.isSubType(typeA, typeB);
-  }
-
-  if (isAbstractType(typeB)) {
-    // Determine if the former type is a possible concrete type of the latter.
-    return schema.isSubType(typeB, typeA);
-  } // Otherwise the types do not overlap.
-
-
-  return false;
-}
 
 /* eslint-disable no-redeclare */
 // $FlowFixMe[name-already-bound]
@@ -7544,9 +7490,6 @@ function typeFromAST(schema, typeNode) {
   invariant(0, 'Unexpected type node: ' + inspect(typeNode));
 }
 
-function isExecutableDefinitionNode(node) {
-  return node.kind === Kind.OPERATION_DEFINITION || node.kind === Kind.FRAGMENT_DEFINITION;
-}
 function isTypeSystemDefinitionNode(node) {
   return node.kind === Kind.SCHEMA_DEFINITION || isTypeDefinitionNode(node) || node.kind === Kind.DIRECTIVE_DEFINITION;
 }
@@ -7560,95 +7503,6 @@ function isTypeExtensionNode(node) {
   return node.kind === Kind.SCALAR_TYPE_EXTENSION || node.kind === Kind.OBJECT_TYPE_EXTENSION || node.kind === Kind.INTERFACE_TYPE_EXTENSION || node.kind === Kind.UNION_TYPE_EXTENSION || node.kind === Kind.ENUM_TYPE_EXTENSION || node.kind === Kind.INPUT_OBJECT_TYPE_EXTENSION;
 }
 
-/**
- * Executable definitions
- *
- * A GraphQL document is only valid for execution if all definitions are either
- * operation or fragment definitions.
- */
-function ExecutableDefinitionsRule(context) {
-  return {
-    Document: function Document(node) {
-      for (var _i2 = 0, _node$definitions2 = node.definitions; _i2 < _node$definitions2.length; _i2++) {
-        var definition = _node$definitions2[_i2];
-
-        if (!isExecutableDefinitionNode(definition)) {
-          var defName = definition.kind === Kind.SCHEMA_DEFINITION || definition.kind === Kind.SCHEMA_EXTENSION ? 'schema' : '"' + definition.name.value + '"';
-          context.reportError(new GraphQLError("The ".concat(defName, " definition is not executable."), definition));
-        }
-      }
-
-      return false;
-    }
-  };
-}
-
-/**
- * Unique operation names
- *
- * A GraphQL document is only valid if all defined operations have unique names.
- */
-function UniqueOperationNamesRule(context) {
-  var knownOperationNames = Object.create(null);
-  return {
-    OperationDefinition: function OperationDefinition(node) {
-      var operationName = node.name;
-
-      if (operationName) {
-        if (knownOperationNames[operationName.value]) {
-          context.reportError(new GraphQLError("There can be only one operation named \"".concat(operationName.value, "\"."), [knownOperationNames[operationName.value], operationName]));
-        } else {
-          knownOperationNames[operationName.value] = operationName;
-        }
-      }
-
-      return false;
-    },
-    FragmentDefinition: function FragmentDefinition() {
-      return false;
-    }
-  };
-}
-
-/**
- * Lone anonymous operation
- *
- * A GraphQL document is only valid if when it contains an anonymous operation
- * (the query short-hand) that it contains only that one operation definition.
- */
-function LoneAnonymousOperationRule(context) {
-  var operationCount = 0;
-  return {
-    Document: function Document(node) {
-      operationCount = node.definitions.filter(function (definition) {
-        return definition.kind === Kind.OPERATION_DEFINITION;
-      }).length;
-    },
-    OperationDefinition: function OperationDefinition(node) {
-      if (!node.name && operationCount > 1) {
-        context.reportError(new GraphQLError('This anonymous operation must be the only defined operation.', node));
-      }
-    }
-  };
-}
-
-/**
- * Subscriptions must only include one field.
- *
- * A GraphQL subscription is valid only if it contains a single root field.
- */
-function SingleFieldSubscriptionsRule(context) {
-  return {
-    OperationDefinition: function OperationDefinition(node) {
-      if (node.operation === 'subscription') {
-        if (node.selectionSet.selections.length !== 1) {
-          context.reportError(new GraphQLError(node.name ? "Subscription \"".concat(node.name.value, "\" must select only one top level field.") : 'Anonymous Subscription must select only one top level field.', node.selectionSet.selections.slice(1)));
-        }
-      }
-    }
-  };
-}
-
 /**
  * Known type names
  *
@@ -7702,1653 +7556,351 @@ function isSDLNode(value) {
 }
 
 /**
- * Fragments on composite type
+ * Known directives
  *
- * Fragments use a type condition to determine if they apply, since fragments
- * can only be spread into a composite type (object, interface, or union), the
- * type condition must also be a composite type.
+ * A GraphQL document is only valid if all `@directives` are known by the
+ * schema and legally positioned.
  */
-function FragmentsOnCompositeTypesRule(context) {
-  return {
-    InlineFragment: function InlineFragment(node) {
-      var typeCondition = node.typeCondition;
+function KnownDirectivesRule(context) {
+  var locationsMap = Object.create(null);
+  var schema = context.getSchema();
+  var definedDirectives = schema ? schema.getDirectives() : specifiedDirectives;
 
-      if (typeCondition) {
-        var type = typeFromAST(context.getSchema(), typeCondition);
+  for (var _i2 = 0; _i2 < definedDirectives.length; _i2++) {
+    var directive = definedDirectives[_i2];
+    locationsMap[directive.name] = directive.locations;
+  }
 
-        if (type && !isCompositeType(type)) {
-          var typeStr = print(typeCondition);
-          context.reportError(new GraphQLError("Fragment cannot condition on non composite type \"".concat(typeStr, "\"."), typeCondition));
-        }
-      }
-    },
-    FragmentDefinition: function FragmentDefinition(node) {
-      var type = typeFromAST(context.getSchema(), node.typeCondition);
+  var astDefinitions = context.getDocument().definitions;
 
-      if (type && !isCompositeType(type)) {
-        var typeStr = print(node.typeCondition);
-        context.reportError(new GraphQLError("Fragment \"".concat(node.name.value, "\" cannot condition on non composite type \"").concat(typeStr, "\"."), node.typeCondition));
-      }
+  for (var _i4 = 0; _i4 < astDefinitions.length; _i4++) {
+    var def = astDefinitions[_i4];
+
+    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+      locationsMap[def.name.value] = def.locations.map(function (name) {
+        return name.value;
+      });
     }
-  };
-}
+  }
 
-/**
- * Variables are input types
- *
- * A GraphQL operation is only valid if all the variables it defines are of
- * input types (scalar, enum, or input object).
- */
-function VariablesAreInputTypesRule(context) {
   return {
-    VariableDefinition: function VariableDefinition(node) {
-      var type = typeFromAST(context.getSchema(), node.type);
+    Directive: function Directive(node, _key, _parent, _path, ancestors) {
+      var name = node.name.value;
+      var locations = locationsMap[name];
 
-      if (type && !isInputType(type)) {
-        var variableName = node.variable.name.value;
-        var typeName = print(node.type);
-        context.reportError(new GraphQLError("Variable \"$".concat(variableName, "\" cannot be non-input type \"").concat(typeName, "\"."), node.type));
+      if (!locations) {
+        context.reportError(new GraphQLError("Unknown directive \"@".concat(name, "\"."), node));
+        return;
       }
-    }
-  };
-}
-
-/**
- * Scalar leafs
- *
- * A GraphQL document is valid only if all leaf fields (fields without
- * sub selections) are of scalar or enum types.
- */
-function ScalarLeafsRule(context) {
-  return {
-    Field: function Field(node) {
-      var type = context.getType();
-      var selectionSet = node.selectionSet;
-
-      if (type) {
-        if (isLeafType(getNamedType(type))) {
-          if (selectionSet) {
-            var fieldName = node.name.value;
-            var typeStr = inspect(type);
-            context.reportError(new GraphQLError("Field \"".concat(fieldName, "\" must not have a selection since type \"").concat(typeStr, "\" has no subfields."), selectionSet));
-          }
-        } else if (!selectionSet) {
-          var _fieldName = node.name.value;
 
-          var _typeStr = inspect(type);
+      var candidateLocation = getDirectiveLocationForASTPath(ancestors);
 
-          context.reportError(new GraphQLError("Field \"".concat(_fieldName, "\" of type \"").concat(_typeStr, "\" must have a selection of subfields. Did you mean \"").concat(_fieldName, " { ... }\"?"), node));
-        }
+      if (candidateLocation && locations.indexOf(candidateLocation) === -1) {
+        context.reportError(new GraphQLError("Directive \"@".concat(name, "\" may not be used on ").concat(candidateLocation, "."), node));
       }
     }
   };
 }
 
-/**
- * Fields on correct type
- *
- * A GraphQL document is only valid if all fields selected are defined by the
- * parent type, or are an allowed meta field such as __typename.
- */
-function FieldsOnCorrectTypeRule(context) {
-  return {
-    Field: function Field(node) {
-      var type = context.getParentType();
-
-      if (type) {
-        var fieldDef = context.getFieldDef();
+function getDirectiveLocationForASTPath(ancestors) {
+  var appliedTo = ancestors[ancestors.length - 1];
+  !Array.isArray(appliedTo) || invariant(0);
 
-        if (!fieldDef) {
-          // This field doesn't exist, lets look for suggestions.
-          var schema = context.getSchema();
-          var fieldName = node.name.value; // First determine if there are any suggested types to condition on.
+  switch (appliedTo.kind) {
+    case Kind.OPERATION_DEFINITION:
+      return getDirectiveLocationForOperation(appliedTo.operation);
 
-          var suggestion = didYouMean('to use an inline fragment on', getSuggestedTypeNames(schema, type, fieldName)); // If there are no suggested types, then perhaps this was a typo?
+    case Kind.FIELD:
+      return DirectiveLocation.FIELD;
 
-          if (suggestion === '') {
-            suggestion = didYouMean(getSuggestedFieldNames(type, fieldName));
-          } // Report an error, including helpful suggestions.
+    case Kind.FRAGMENT_SPREAD:
+      return DirectiveLocation.FRAGMENT_SPREAD;
 
+    case Kind.INLINE_FRAGMENT:
+      return DirectiveLocation.INLINE_FRAGMENT;
 
-          context.reportError(new GraphQLError("Cannot query field \"".concat(fieldName, "\" on type \"").concat(type.name, "\".") + suggestion, node));
-        }
-      }
-    }
-  };
-}
-/**
- * Go through all of the implementations of type, as well as the interfaces that
- * they implement. If any of those types include the provided field, suggest them,
- * sorted by how often the type is referenced.
- */
+    case Kind.FRAGMENT_DEFINITION:
+      return DirectiveLocation.FRAGMENT_DEFINITION;
 
-function getSuggestedTypeNames(schema, type, fieldName) {
-  if (!isAbstractType(type)) {
-    // Must be an Object type, which does not have possible fields.
-    return [];
-  }
+    case Kind.VARIABLE_DEFINITION:
+      return DirectiveLocation.VARIABLE_DEFINITION;
 
-  var suggestedTypes = new Set();
-  var usageCount = Object.create(null);
+    case Kind.SCHEMA_DEFINITION:
+    case Kind.SCHEMA_EXTENSION:
+      return DirectiveLocation.SCHEMA;
 
-  for (var _i2 = 0, _schema$getPossibleTy2 = schema.getPossibleTypes(type); _i2 < _schema$getPossibleTy2.length; _i2++) {
-    var possibleType = _schema$getPossibleTy2[_i2];
+    case Kind.SCALAR_TYPE_DEFINITION:
+    case Kind.SCALAR_TYPE_EXTENSION:
+      return DirectiveLocation.SCALAR;
 
-    if (!possibleType.getFields()[fieldName]) {
-      continue;
-    } // This object type defines this field.
+    case Kind.OBJECT_TYPE_DEFINITION:
+    case Kind.OBJECT_TYPE_EXTENSION:
+      return DirectiveLocation.OBJECT;
 
+    case Kind.FIELD_DEFINITION:
+      return DirectiveLocation.FIELD_DEFINITION;
 
-    suggestedTypes.add(possibleType);
-    usageCount[possibleType.name] = 1;
+    case Kind.INTERFACE_TYPE_DEFINITION:
+    case Kind.INTERFACE_TYPE_EXTENSION:
+      return DirectiveLocation.INTERFACE;
 
-    for (var _i4 = 0, _possibleType$getInte2 = possibleType.getInterfaces(); _i4 < _possibleType$getInte2.length; _i4++) {
-      var _usageCount$possibleI;
+    case Kind.UNION_TYPE_DEFINITION:
+    case Kind.UNION_TYPE_EXTENSION:
+      return DirectiveLocation.UNION;
 
-      var possibleInterface = _possibleType$getInte2[_i4];
+    case Kind.ENUM_TYPE_DEFINITION:
+    case Kind.ENUM_TYPE_EXTENSION:
+      return DirectiveLocation.ENUM;
 
-      if (!possibleInterface.getFields()[fieldName]) {
-        continue;
-      } // This interface type defines this field.
+    case Kind.ENUM_VALUE_DEFINITION:
+      return DirectiveLocation.ENUM_VALUE;
 
+    case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+    case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+      return DirectiveLocation.INPUT_OBJECT;
 
-      suggestedTypes.add(possibleInterface);
-      usageCount[possibleInterface.name] = ((_usageCount$possibleI = usageCount[possibleInterface.name]) !== null && _usageCount$possibleI !== void 0 ? _usageCount$possibleI : 0) + 1;
-    }
+    case Kind.INPUT_VALUE_DEFINITION:
+      {
+        var parentNode = ancestors[ancestors.length - 3];
+        return parentNode.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION ? DirectiveLocation.INPUT_FIELD_DEFINITION : DirectiveLocation.ARGUMENT_DEFINITION;
+      }
   }
+}
 
-  return arrayFrom$1(suggestedTypes).sort(function (typeA, typeB) {
-    // Suggest both interface and object types based on how common they are.
-    var usageCountDiff = usageCount[typeB.name] - usageCount[typeA.name];
-
-    if (usageCountDiff !== 0) {
-      return usageCountDiff;
-    } // Suggest super types first followed by subtypes
+function getDirectiveLocationForOperation(operation) {
+  switch (operation) {
+    case 'query':
+      return DirectiveLocation.QUERY;
 
+    case 'mutation':
+      return DirectiveLocation.MUTATION;
 
-    if (isInterfaceType(typeA) && schema.isSubType(typeA, typeB)) {
-      return -1;
-    }
+    case 'subscription':
+      return DirectiveLocation.SUBSCRIPTION;
+  } // istanbul ignore next (Not reachable. All possible types have been considered)
 
-    if (isInterfaceType(typeB) && schema.isSubType(typeB, typeA)) {
-      return 1;
-    }
 
-    return naturalCompare(typeA.name, typeB.name);
-  }).map(function (x) {
-    return x.name;
-  });
+  invariant(0, 'Unexpected operation: ' + inspect(operation));
 }
+
 /**
- * For the field name provided, determine if there are any similar field names
- * that may be the result of a typo.
+ * Unique directive names per location
+ *
+ * A GraphQL document is only valid if all non-repeatable directives at
+ * a given location are uniquely named.
  */
+function UniqueDirectivesPerLocationRule(context) {
+  var uniqueDirectiveMap = Object.create(null);
+  var schema = context.getSchema();
+  var definedDirectives = schema ? schema.getDirectives() : specifiedDirectives;
 
+  for (var _i2 = 0; _i2 < definedDirectives.length; _i2++) {
+    var directive = definedDirectives[_i2];
+    uniqueDirectiveMap[directive.name] = !directive.isRepeatable;
+  }
 
-function getSuggestedFieldNames(type, fieldName) {
-  if (isObjectType(type) || isInterfaceType(type)) {
-    var possibleFieldNames = Object.keys(type.getFields());
-    return suggestionList(fieldName, possibleFieldNames);
-  } // Otherwise, must be a Union type, which does not define fields.
+  var astDefinitions = context.getDocument().definitions;
 
+  for (var _i4 = 0; _i4 < astDefinitions.length; _i4++) {
+    var def = astDefinitions[_i4];
 
-  return [];
-}
+    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+      uniqueDirectiveMap[def.name.value] = !def.repeatable;
+    }
+  }
 
-/**
- * Unique fragment names
- *
- * A GraphQL document is only valid if all defined fragments have unique names.
- */
-function UniqueFragmentNamesRule(context) {
-  var knownFragmentNames = Object.create(null);
+  var schemaDirectives = Object.create(null);
+  var typeDirectivesMap = Object.create(null);
   return {
-    OperationDefinition: function OperationDefinition() {
-      return false;
-    },
-    FragmentDefinition: function FragmentDefinition(node) {
-      var fragmentName = node.name.value;
-
-      if (knownFragmentNames[fragmentName]) {
-        context.reportError(new GraphQLError("There can be only one fragment named \"".concat(fragmentName, "\"."), [knownFragmentNames[fragmentName], node.name]));
-      } else {
-        knownFragmentNames[fragmentName] = node.name;
+    // Many different AST nodes may contain directives. Rather than listing
+    // them all, just listen for entering any node, and check to see if it
+    // defines any directives.
+    enter: function enter(node) {
+      if (node.directives == null) {
+        return;
       }
 
-      return false;
-    }
-  };
-}
+      var seenDirectives;
 
-/**
- * Known fragment names
- *
- * A GraphQL document is only valid if all `...Fragment` fragment spreads refer
- * to fragments defined in the same document.
- */
-function KnownFragmentNamesRule(context) {
-  return {
-    FragmentSpread: function FragmentSpread(node) {
-      var fragmentName = node.name.value;
-      var fragment = context.getFragment(fragmentName);
-
-      if (!fragment) {
-        context.reportError(new GraphQLError("Unknown fragment \"".concat(fragmentName, "\"."), node.name));
-      }
-    }
-  };
-}
-
-/**
- * No unused fragments
- *
- * A GraphQL document is only valid if all fragment definitions are spread
- * within operations, or spread within other fragments spread within operations.
- */
-function NoUnusedFragmentsRule(context) {
-  var operationDefs = [];
-  var fragmentDefs = [];
-  return {
-    OperationDefinition: function OperationDefinition(node) {
-      operationDefs.push(node);
-      return false;
-    },
-    FragmentDefinition: function FragmentDefinition(node) {
-      fragmentDefs.push(node);
-      return false;
-    },
-    Document: {
-      leave: function leave() {
-        var fragmentNameUsed = Object.create(null);
-
-        for (var _i2 = 0; _i2 < operationDefs.length; _i2++) {
-          var operation = operationDefs[_i2];
-
-          for (var _i4 = 0, _context$getRecursive2 = context.getRecursivelyReferencedFragments(operation); _i4 < _context$getRecursive2.length; _i4++) {
-            var fragment = _context$getRecursive2[_i4];
-            fragmentNameUsed[fragment.name.value] = true;
-          }
-        }
-
-        for (var _i6 = 0; _i6 < fragmentDefs.length; _i6++) {
-          var fragmentDef = fragmentDefs[_i6];
-          var fragName = fragmentDef.name.value;
-
-          if (fragmentNameUsed[fragName] !== true) {
-            context.reportError(new GraphQLError("Fragment \"".concat(fragName, "\" is never used."), fragmentDef));
-          }
-        }
-      }
-    }
-  };
-}
-
-/**
- * Possible fragment spread
- *
- * A fragment spread is only valid if the type condition could ever possibly
- * be true: if there is a non-empty intersection of the possible parent types,
- * and possible types which pass the type condition.
- */
-function PossibleFragmentSpreadsRule(context) {
-  return {
-    InlineFragment: function InlineFragment(node) {
-      var fragType = context.getType();
-      var parentType = context.getParentType();
-
-      if (isCompositeType(fragType) && isCompositeType(parentType) && !doTypesOverlap(context.getSchema(), fragType, parentType)) {
-        var parentTypeStr = inspect(parentType);
-        var fragTypeStr = inspect(fragType);
-        context.reportError(new GraphQLError("Fragment cannot be spread here as objects of type \"".concat(parentTypeStr, "\" can never be of type \"").concat(fragTypeStr, "\"."), node));
-      }
-    },
-    FragmentSpread: function FragmentSpread(node) {
-      var fragName = node.name.value;
-      var fragType = getFragmentType(context, fragName);
-      var parentType = context.getParentType();
-
-      if (fragType && parentType && !doTypesOverlap(context.getSchema(), fragType, parentType)) {
-        var parentTypeStr = inspect(parentType);
-        var fragTypeStr = inspect(fragType);
-        context.reportError(new GraphQLError("Fragment \"".concat(fragName, "\" cannot be spread here as objects of type \"").concat(parentTypeStr, "\" can never be of type \"").concat(fragTypeStr, "\"."), node));
-      }
-    }
-  };
-}
-
-function getFragmentType(context, name) {
-  var frag = context.getFragment(name);
-
-  if (frag) {
-    var type = typeFromAST(context.getSchema(), frag.typeCondition);
-
-    if (isCompositeType(type)) {
-      return type;
-    }
-  }
-}
-
-function NoFragmentCyclesRule(context) {
-  // Tracks already visited fragments to maintain O(N) and to ensure that cycles
-  // are not redundantly reported.
-  var visitedFrags = Object.create(null); // Array of AST nodes used to produce meaningful errors
-
-  var spreadPath = []; // Position in the spread path
-
-  var spreadPathIndexByName = Object.create(null);
-  return {
-    OperationDefinition: function OperationDefinition() {
-      return false;
-    },
-    FragmentDefinition: function FragmentDefinition(node) {
-      detectCycleRecursive(node);
-      return false;
-    }
-  }; // This does a straight-forward DFS to find cycles.
-  // It does not terminate when a cycle was found but continues to explore
-  // the graph to find all possible cycles.
-
-  function detectCycleRecursive(fragment) {
-    if (visitedFrags[fragment.name.value]) {
-      return;
-    }
-
-    var fragmentName = fragment.name.value;
-    visitedFrags[fragmentName] = true;
-    var spreadNodes = context.getFragmentSpreads(fragment.selectionSet);
-
-    if (spreadNodes.length === 0) {
-      return;
-    }
-
-    spreadPathIndexByName[fragmentName] = spreadPath.length;
-
-    for (var _i2 = 0; _i2 < spreadNodes.length; _i2++) {
-      var spreadNode = spreadNodes[_i2];
-      var spreadName = spreadNode.name.value;
-      var cycleIndex = spreadPathIndexByName[spreadName];
-      spreadPath.push(spreadNode);
-
-      if (cycleIndex === undefined) {
-        var spreadFragment = context.getFragment(spreadName);
-
-        if (spreadFragment) {
-          detectCycleRecursive(spreadFragment);
-        }
-      } else {
-        var cyclePath = spreadPath.slice(cycleIndex);
-        var viaPath = cyclePath.slice(0, -1).map(function (s) {
-          return '"' + s.name.value + '"';
-        }).join(', ');
-        context.reportError(new GraphQLError("Cannot spread fragment \"".concat(spreadName, "\" within itself") + (viaPath !== '' ? " via ".concat(viaPath, ".") : '.'), cyclePath));
-      }
-
-      spreadPath.pop();
-    }
-
-    spreadPathIndexByName[fragmentName] = undefined;
-  }
-}
-
-/**
- * Unique variable names
- *
- * A GraphQL operation is only valid if all its variables are uniquely named.
- */
-function UniqueVariableNamesRule(context) {
-  var knownVariableNames = Object.create(null);
-  return {
-    OperationDefinition: function OperationDefinition() {
-      knownVariableNames = Object.create(null);
-    },
-    VariableDefinition: function VariableDefinition(node) {
-      var variableName = node.variable.name.value;
-
-      if (knownVariableNames[variableName]) {
-        context.reportError(new GraphQLError("There can be only one variable named \"$".concat(variableName, "\"."), [knownVariableNames[variableName], node.variable.name]));
-      } else {
-        knownVariableNames[variableName] = node.variable.name;
-      }
-    }
-  };
-}
-
-/**
- * No undefined variables
- *
- * A GraphQL operation is only valid if all variables encountered, both directly
- * and via fragment spreads, are defined by that operation.
- */
-function NoUndefinedVariablesRule(context) {
-  var variableNameDefined = Object.create(null);
-  return {
-    OperationDefinition: {
-      enter: function enter() {
-        variableNameDefined = Object.create(null);
-      },
-      leave: function leave(operation) {
-        var usages = context.getRecursiveVariableUsages(operation);
-
-        for (var _i2 = 0; _i2 < usages.length; _i2++) {
-          var _ref2 = usages[_i2];
-          var node = _ref2.node;
-          var varName = node.name.value;
-
-          if (variableNameDefined[varName] !== true) {
-            context.reportError(new GraphQLError(operation.name ? "Variable \"$".concat(varName, "\" is not defined by operation \"").concat(operation.name.value, "\".") : "Variable \"$".concat(varName, "\" is not defined."), [node, operation]));
-          }
-        }
-      }
-    },
-    VariableDefinition: function VariableDefinition(node) {
-      variableNameDefined[node.variable.name.value] = true;
-    }
-  };
-}
-
-/**
- * No unused variables
- *
- * A GraphQL operation is only valid if all variables defined by an operation
- * are used, either directly or within a spread fragment.
- */
-function NoUnusedVariablesRule(context) {
-  var variableDefs = [];
-  return {
-    OperationDefinition: {
-      enter: function enter() {
-        variableDefs = [];
-      },
-      leave: function leave(operation) {
-        var variableNameUsed = Object.create(null);
-        var usages = context.getRecursiveVariableUsages(operation);
-
-        for (var _i2 = 0; _i2 < usages.length; _i2++) {
-          var _ref2 = usages[_i2];
-          var node = _ref2.node;
-          variableNameUsed[node.name.value] = true;
-        }
-
-        for (var _i4 = 0, _variableDefs2 = variableDefs; _i4 < _variableDefs2.length; _i4++) {
-          var variableDef = _variableDefs2[_i4];
-          var variableName = variableDef.variable.name.value;
-
-          if (variableNameUsed[variableName] !== true) {
-            context.reportError(new GraphQLError(operation.name ? "Variable \"$".concat(variableName, "\" is never used in operation \"").concat(operation.name.value, "\".") : "Variable \"$".concat(variableName, "\" is never used."), variableDef));
-          }
-        }
-      }
-    },
-    VariableDefinition: function VariableDefinition(def) {
-      variableDefs.push(def);
-    }
-  };
-}
-
-/**
- * Known directives
- *
- * A GraphQL document is only valid if all `@directives` are known by the
- * schema and legally positioned.
- */
-function KnownDirectivesRule(context) {
-  var locationsMap = Object.create(null);
-  var schema = context.getSchema();
-  var definedDirectives = schema ? schema.getDirectives() : specifiedDirectives;
-
-  for (var _i2 = 0; _i2 < definedDirectives.length; _i2++) {
-    var directive = definedDirectives[_i2];
-    locationsMap[directive.name] = directive.locations;
-  }
-
-  var astDefinitions = context.getDocument().definitions;
-
-  for (var _i4 = 0; _i4 < astDefinitions.length; _i4++) {
-    var def = astDefinitions[_i4];
-
-    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
-      locationsMap[def.name.value] = def.locations.map(function (name) {
-        return name.value;
-      });
-    }
-  }
-
-  return {
-    Directive: function Directive(node, _key, _parent, _path, ancestors) {
-      var name = node.name.value;
-      var locations = locationsMap[name];
-
-      if (!locations) {
-        context.reportError(new GraphQLError("Unknown directive \"@".concat(name, "\"."), node));
-        return;
-      }
-
-      var candidateLocation = getDirectiveLocationForASTPath(ancestors);
-
-      if (candidateLocation && locations.indexOf(candidateLocation) === -1) {
-        context.reportError(new GraphQLError("Directive \"@".concat(name, "\" may not be used on ").concat(candidateLocation, "."), node));
-      }
-    }
-  };
-}
-
-function getDirectiveLocationForASTPath(ancestors) {
-  var appliedTo = ancestors[ancestors.length - 1];
-  !Array.isArray(appliedTo) || invariant(0);
-
-  switch (appliedTo.kind) {
-    case Kind.OPERATION_DEFINITION:
-      return getDirectiveLocationForOperation(appliedTo.operation);
-
-    case Kind.FIELD:
-      return DirectiveLocation.FIELD;
-
-    case Kind.FRAGMENT_SPREAD:
-      return DirectiveLocation.FRAGMENT_SPREAD;
-
-    case Kind.INLINE_FRAGMENT:
-      return DirectiveLocation.INLINE_FRAGMENT;
-
-    case Kind.FRAGMENT_DEFINITION:
-      return DirectiveLocation.FRAGMENT_DEFINITION;
-
-    case Kind.VARIABLE_DEFINITION:
-      return DirectiveLocation.VARIABLE_DEFINITION;
-
-    case Kind.SCHEMA_DEFINITION:
-    case Kind.SCHEMA_EXTENSION:
-      return DirectiveLocation.SCHEMA;
-
-    case Kind.SCALAR_TYPE_DEFINITION:
-    case Kind.SCALAR_TYPE_EXTENSION:
-      return DirectiveLocation.SCALAR;
-
-    case Kind.OBJECT_TYPE_DEFINITION:
-    case Kind.OBJECT_TYPE_EXTENSION:
-      return DirectiveLocation.OBJECT;
-
-    case Kind.FIELD_DEFINITION:
-      return DirectiveLocation.FIELD_DEFINITION;
-
-    case Kind.INTERFACE_TYPE_DEFINITION:
-    case Kind.INTERFACE_TYPE_EXTENSION:
-      return DirectiveLocation.INTERFACE;
-
-    case Kind.UNION_TYPE_DEFINITION:
-    case Kind.UNION_TYPE_EXTENSION:
-      return DirectiveLocation.UNION;
-
-    case Kind.ENUM_TYPE_DEFINITION:
-    case Kind.ENUM_TYPE_EXTENSION:
-      return DirectiveLocation.ENUM;
-
-    case Kind.ENUM_VALUE_DEFINITION:
-      return DirectiveLocation.ENUM_VALUE;
-
-    case Kind.INPUT_OBJECT_TYPE_DEFINITION:
-    case Kind.INPUT_OBJECT_TYPE_EXTENSION:
-      return DirectiveLocation.INPUT_OBJECT;
-
-    case Kind.INPUT_VALUE_DEFINITION:
-      {
-        var parentNode = ancestors[ancestors.length - 3];
-        return parentNode.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION ? DirectiveLocation.INPUT_FIELD_DEFINITION : DirectiveLocation.ARGUMENT_DEFINITION;
-      }
-  }
-}
-
-function getDirectiveLocationForOperation(operation) {
-  switch (operation) {
-    case 'query':
-      return DirectiveLocation.QUERY;
-
-    case 'mutation':
-      return DirectiveLocation.MUTATION;
-
-    case 'subscription':
-      return DirectiveLocation.SUBSCRIPTION;
-  } // istanbul ignore next (Not reachable. All possible types have been considered)
-
-
-  invariant(0, 'Unexpected operation: ' + inspect(operation));
-}
-
-/**
- * Unique directive names per location
- *
- * A GraphQL document is only valid if all non-repeatable directives at
- * a given location are uniquely named.
- */
-function UniqueDirectivesPerLocationRule(context) {
-  var uniqueDirectiveMap = Object.create(null);
-  var schema = context.getSchema();
-  var definedDirectives = schema ? schema.getDirectives() : specifiedDirectives;
-
-  for (var _i2 = 0; _i2 < definedDirectives.length; _i2++) {
-    var directive = definedDirectives[_i2];
-    uniqueDirectiveMap[directive.name] = !directive.isRepeatable;
-  }
-
-  var astDefinitions = context.getDocument().definitions;
-
-  for (var _i4 = 0; _i4 < astDefinitions.length; _i4++) {
-    var def = astDefinitions[_i4];
-
-    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
-      uniqueDirectiveMap[def.name.value] = !def.repeatable;
-    }
-  }
-
-  var schemaDirectives = Object.create(null);
-  var typeDirectivesMap = Object.create(null);
-  return {
-    // Many different AST nodes may contain directives. Rather than listing
-    // them all, just listen for entering any node, and check to see if it
-    // defines any directives.
-    enter: function enter(node) {
-      if (node.directives == null) {
-        return;
-      }
-
-      var seenDirectives;
-
-      if (node.kind === Kind.SCHEMA_DEFINITION || node.kind === Kind.SCHEMA_EXTENSION) {
-        seenDirectives = schemaDirectives;
-      } else if (isTypeDefinitionNode(node) || isTypeExtensionNode(node)) {
-        var typeName = node.name.value;
-        seenDirectives = typeDirectivesMap[typeName];
-
-        if (seenDirectives === undefined) {
-          typeDirectivesMap[typeName] = seenDirectives = Object.create(null);
-        }
-      } else {
-        seenDirectives = Object.create(null);
-      }
-
-      for (var _i6 = 0, _node$directives2 = node.directives; _i6 < _node$directives2.length; _i6++) {
-        var _directive = _node$directives2[_i6];
-        var directiveName = _directive.name.value;
-
-        if (uniqueDirectiveMap[directiveName]) {
-          if (seenDirectives[directiveName]) {
-            context.reportError(new GraphQLError("The directive \"@".concat(directiveName, "\" can only be used once at this location."), [seenDirectives[directiveName], _directive]));
-          } else {
-            seenDirectives[directiveName] = _directive;
-          }
-        }
-      }
-    }
-  };
-}
-
-function ownKeys$2(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$2(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$2(Object(source), true).forEach(function (key) { _defineProperty$3(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$2(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty$3(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-/**
- * Known argument names
- *
- * A GraphQL field is only valid if all supplied arguments are defined by
- * that field.
- */
-function KnownArgumentNamesRule(context) {
-  return _objectSpread$2(_objectSpread$2({}, KnownArgumentNamesOnDirectivesRule(context)), {}, {
-    Argument: function Argument(argNode) {
-      var argDef = context.getArgument();
-      var fieldDef = context.getFieldDef();
-      var parentType = context.getParentType();
-
-      if (!argDef && fieldDef && parentType) {
-        var argName = argNode.name.value;
-        var knownArgsNames = fieldDef.args.map(function (arg) {
-          return arg.name;
-        });
-        var suggestions = suggestionList(argName, knownArgsNames);
-        context.reportError(new GraphQLError("Unknown argument \"".concat(argName, "\" on field \"").concat(parentType.name, ".").concat(fieldDef.name, "\".") + didYouMean(suggestions), argNode));
-      }
-    }
-  });
-}
-/**
- * @internal
- */
-
-function KnownArgumentNamesOnDirectivesRule(context) {
-  var directiveArgs = Object.create(null);
-  var schema = context.getSchema();
-  var definedDirectives = schema ? schema.getDirectives() : specifiedDirectives;
-
-  for (var _i2 = 0; _i2 < definedDirectives.length; _i2++) {
-    var directive = definedDirectives[_i2];
-    directiveArgs[directive.name] = directive.args.map(function (arg) {
-      return arg.name;
-    });
-  }
-
-  var astDefinitions = context.getDocument().definitions;
-
-  for (var _i4 = 0; _i4 < astDefinitions.length; _i4++) {
-    var def = astDefinitions[_i4];
-
-    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
-      var _def$arguments;
-
-      // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
-      var argsNodes = (_def$arguments = def.arguments) !== null && _def$arguments !== void 0 ? _def$arguments : [];
-      directiveArgs[def.name.value] = argsNodes.map(function (arg) {
-        return arg.name.value;
-      });
-    }
-  }
-
-  return {
-    Directive: function Directive(directiveNode) {
-      var directiveName = directiveNode.name.value;
-      var knownArgs = directiveArgs[directiveName];
-
-      if (directiveNode.arguments && knownArgs) {
-        for (var _i6 = 0, _directiveNode$argume2 = directiveNode.arguments; _i6 < _directiveNode$argume2.length; _i6++) {
-          var argNode = _directiveNode$argume2[_i6];
-          var argName = argNode.name.value;
-
-          if (knownArgs.indexOf(argName) === -1) {
-            var suggestions = suggestionList(argName, knownArgs);
-            context.reportError(new GraphQLError("Unknown argument \"".concat(argName, "\" on directive \"@").concat(directiveName, "\".") + didYouMean(suggestions), argNode));
-          }
-        }
-      }
-
-      return false;
-    }
-  };
-}
-
-/**
- * Unique argument names
- *
- * A GraphQL field or directive is only valid if all supplied arguments are
- * uniquely named.
- */
-function UniqueArgumentNamesRule(context) {
-  var knownArgNames = Object.create(null);
-  return {
-    Field: function Field() {
-      knownArgNames = Object.create(null);
-    },
-    Directive: function Directive() {
-      knownArgNames = Object.create(null);
-    },
-    Argument: function Argument(node) {
-      var argName = node.name.value;
-
-      if (knownArgNames[argName]) {
-        context.reportError(new GraphQLError("There can be only one argument named \"".concat(argName, "\"."), [knownArgNames[argName], node.name]));
-      } else {
-        knownArgNames[argName] = node.name;
-      }
-
-      return false;
-    }
-  };
-}
-
-/**
- * Value literals of correct type
- *
- * A GraphQL document is only valid if all value literals are of the type
- * expected at their position.
- */
-function ValuesOfCorrectTypeRule(context) {
-  return {
-    ListValue: function ListValue(node) {
-      // Note: TypeInfo will traverse into a list's item type, so look to the
-      // parent input type to check if it is a list.
-      var type = getNullableType(context.getParentInputType());
-
-      if (!isListType(type)) {
-        isValidValueNode(context, node);
-        return false; // Don't traverse further.
-      }
-    },
-    ObjectValue: function ObjectValue(node) {
-      var type = getNamedType(context.getInputType());
-
-      if (!isInputObjectType(type)) {
-        isValidValueNode(context, node);
-        return false; // Don't traverse further.
-      } // Ensure every required field exists.
-
-
-      var fieldNodeMap = keyMap(node.fields, function (field) {
-        return field.name.value;
-      });
-
-      for (var _i2 = 0, _objectValues2 = objectValues$1(type.getFields()); _i2 < _objectValues2.length; _i2++) {
-        var fieldDef = _objectValues2[_i2];
-        var fieldNode = fieldNodeMap[fieldDef.name];
-
-        if (!fieldNode && isRequiredInputField(fieldDef)) {
-          var typeStr = inspect(fieldDef.type);
-          context.reportError(new GraphQLError("Field \"".concat(type.name, ".").concat(fieldDef.name, "\" of required type \"").concat(typeStr, "\" was not provided."), node));
-        }
-      }
-    },
-    ObjectField: function ObjectField(node) {
-      var parentType = getNamedType(context.getParentInputType());
-      var fieldType = context.getInputType();
-
-      if (!fieldType && isInputObjectType(parentType)) {
-        var suggestions = suggestionList(node.name.value, Object.keys(parentType.getFields()));
-        context.reportError(new GraphQLError("Field \"".concat(node.name.value, "\" is not defined by type \"").concat(parentType.name, "\".") + didYouMean(suggestions), node));
-      }
-    },
-    NullValue: function NullValue(node) {
-      var type = context.getInputType();
-
-      if (isNonNullType(type)) {
-        context.reportError(new GraphQLError("Expected value of type \"".concat(inspect(type), "\", found ").concat(print(node), "."), node));
-      }
-    },
-    EnumValue: function EnumValue(node) {
-      return isValidValueNode(context, node);
-    },
-    IntValue: function IntValue(node) {
-      return isValidValueNode(context, node);
-    },
-    FloatValue: function FloatValue(node) {
-      return isValidValueNode(context, node);
-    },
-    StringValue: function StringValue(node) {
-      return isValidValueNode(context, node);
-    },
-    BooleanValue: function BooleanValue(node) {
-      return isValidValueNode(context, node);
-    }
-  };
-}
-/**
- * Any value literal may be a valid representation of a Scalar, depending on
- * that scalar type.
- */
-
-function isValidValueNode(context, node) {
-  // Report any error at the full type expected by the location.
-  var locationType = context.getInputType();
-
-  if (!locationType) {
-    return;
-  }
-
-  var type = getNamedType(locationType);
-
-  if (!isLeafType(type)) {
-    var typeStr = inspect(locationType);
-    context.reportError(new GraphQLError("Expected value of type \"".concat(typeStr, "\", found ").concat(print(node), "."), node));
-    return;
-  } // Scalars and Enums determine if a literal value is valid via parseLiteral(),
-  // which may throw or return an invalid value to indicate failure.
-
-
-  try {
-    var parseResult = type.parseLiteral(node, undefined
-    /* variables */
-    );
-
-    if (parseResult === undefined) {
-      var _typeStr = inspect(locationType);
-
-      context.reportError(new GraphQLError("Expected value of type \"".concat(_typeStr, "\", found ").concat(print(node), "."), node));
-    }
-  } catch (error) {
-    var _typeStr2 = inspect(locationType);
-
-    if (error instanceof GraphQLError) {
-      context.reportError(error);
-    } else {
-      context.reportError(new GraphQLError("Expected value of type \"".concat(_typeStr2, "\", found ").concat(print(node), "; ") + error.message, node, undefined, undefined, undefined, error));
-    }
-  }
-}
-
-function ownKeys$1(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$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty$2(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty$2(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-/**
- * Provided required arguments
- *
- * A field or directive is only valid if all required (non-null without a
- * default value) field arguments have been provided.
- */
-function ProvidedRequiredArgumentsRule(context) {
-  return _objectSpread$1(_objectSpread$1({}, ProvidedRequiredArgumentsOnDirectivesRule(context)), {}, {
-    Field: {
-      // Validate on leave to allow for deeper errors to appear first.
-      leave: function leave(fieldNode) {
-        var _fieldNode$arguments;
-
-        var fieldDef = context.getFieldDef();
-
-        if (!fieldDef) {
-          return false;
-        } // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
-
-
-        var argNodes = (_fieldNode$arguments = fieldNode.arguments) !== null && _fieldNode$arguments !== void 0 ? _fieldNode$arguments : [];
-        var argNodeMap = keyMap(argNodes, function (arg) {
-          return arg.name.value;
-        });
-
-        for (var _i2 = 0, _fieldDef$args2 = fieldDef.args; _i2 < _fieldDef$args2.length; _i2++) {
-          var argDef = _fieldDef$args2[_i2];
-          var argNode = argNodeMap[argDef.name];
-
-          if (!argNode && isRequiredArgument(argDef)) {
-            var argTypeStr = inspect(argDef.type);
-            context.reportError(new GraphQLError("Field \"".concat(fieldDef.name, "\" argument \"").concat(argDef.name, "\" of type \"").concat(argTypeStr, "\" is required, but it was not provided."), fieldNode));
-          }
-        }
-      }
-    }
-  });
-}
-/**
- * @internal
- */
-
-function ProvidedRequiredArgumentsOnDirectivesRule(context) {
-  var requiredArgsMap = Object.create(null);
-  var schema = context.getSchema();
-  var definedDirectives = schema ? schema.getDirectives() : specifiedDirectives;
-
-  for (var _i4 = 0; _i4 < definedDirectives.length; _i4++) {
-    var directive = definedDirectives[_i4];
-    requiredArgsMap[directive.name] = keyMap(directive.args.filter(isRequiredArgument), function (arg) {
-      return arg.name;
-    });
-  }
-
-  var astDefinitions = context.getDocument().definitions;
-
-  for (var _i6 = 0; _i6 < astDefinitions.length; _i6++) {
-    var def = astDefinitions[_i6];
-
-    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
-      var _def$arguments;
-
-      // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
-      var argNodes = (_def$arguments = def.arguments) !== null && _def$arguments !== void 0 ? _def$arguments : [];
-      requiredArgsMap[def.name.value] = keyMap(argNodes.filter(isRequiredArgumentNode), function (arg) {
-        return arg.name.value;
-      });
-    }
-  }
-
-  return {
-    Directive: {
-      // Validate on leave to allow for deeper errors to appear first.
-      leave: function leave(directiveNode) {
-        var directiveName = directiveNode.name.value;
-        var requiredArgs = requiredArgsMap[directiveName];
-
-        if (requiredArgs) {
-          var _directiveNode$argume;
-
-          // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
-          var _argNodes = (_directiveNode$argume = directiveNode.arguments) !== null && _directiveNode$argume !== void 0 ? _directiveNode$argume : [];
-
-          var argNodeMap = keyMap(_argNodes, function (arg) {
-            return arg.name.value;
-          });
-
-          for (var _i8 = 0, _Object$keys2 = Object.keys(requiredArgs); _i8 < _Object$keys2.length; _i8++) {
-            var argName = _Object$keys2[_i8];
-
-            if (!argNodeMap[argName]) {
-              var argType = requiredArgs[argName].type;
-              var argTypeStr = isType(argType) ? inspect(argType) : print(argType);
-              context.reportError(new GraphQLError("Directive \"@".concat(directiveName, "\" argument \"").concat(argName, "\" of type \"").concat(argTypeStr, "\" is required, but it was not provided."), directiveNode));
-            }
-          }
-        }
-      }
-    }
-  };
-}
-
-function isRequiredArgumentNode(arg) {
-  return arg.type.kind === Kind.NON_NULL_TYPE && arg.defaultValue == null;
-}
-
-/**
- * Variables passed to field arguments conform to type
- */
-function VariablesInAllowedPositionRule(context) {
-  var varDefMap = Object.create(null);
-  return {
-    OperationDefinition: {
-      enter: function enter() {
-        varDefMap = Object.create(null);
-      },
-      leave: function leave(operation) {
-        var usages = context.getRecursiveVariableUsages(operation);
-
-        for (var _i2 = 0; _i2 < usages.length; _i2++) {
-          var _ref2 = usages[_i2];
-          var node = _ref2.node;
-          var type = _ref2.type;
-          var defaultValue = _ref2.defaultValue;
-          var varName = node.name.value;
-          var varDef = varDefMap[varName];
-
-          if (varDef && type) {
-            // A var type is allowed if it is the same or more strict (e.g. is
-            // a subtype of) than the expected type. It can be more strict if
-            // the variable type is non-null when the expected type is nullable.
-            // If both are list types, the variable item type can be more strict
-            // than the expected item type (contravariant).
-            var schema = context.getSchema();
-            var varType = typeFromAST(schema, varDef.type);
-
-            if (varType && !allowedVariableUsage(schema, varType, varDef.defaultValue, type, defaultValue)) {
-              var varTypeStr = inspect(varType);
-              var typeStr = inspect(type);
-              context.reportError(new GraphQLError("Variable \"$".concat(varName, "\" of type \"").concat(varTypeStr, "\" used in position expecting type \"").concat(typeStr, "\"."), [varDef, node]));
-            }
-          }
-        }
-      }
-    },
-    VariableDefinition: function VariableDefinition(node) {
-      varDefMap[node.variable.name.value] = node;
-    }
-  };
-}
-/**
- * Returns true if the variable is allowed in the location it was found,
- * which includes considering if default values exist for either the variable
- * or the location at which it is located.
- */
-
-function allowedVariableUsage(schema, varType, varDefaultValue, locationType, locationDefaultValue) {
-  if (isNonNullType(locationType) && !isNonNullType(varType)) {
-    var hasNonNullVariableDefaultValue = varDefaultValue != null && varDefaultValue.kind !== Kind.NULL;
-    var hasLocationDefaultValue = locationDefaultValue !== undefined;
-
-    if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) {
-      return false;
-    }
-
-    var nullableLocationType = locationType.ofType;
-    return isTypeSubTypeOf(schema, varType, nullableLocationType);
-  }
-
-  return isTypeSubTypeOf(schema, varType, locationType);
-}
-
-function reasonMessage(reason) {
-  if (Array.isArray(reason)) {
-    return reason.map(function (_ref) {
-      var responseName = _ref[0],
-          subReason = _ref[1];
-      return "subfields \"".concat(responseName, "\" conflict because ") + reasonMessage(subReason);
-    }).join(' and ');
-  }
-
-  return reason;
-}
-/**
- * Overlapping fields can be merged
- *
- * A selection set is only valid if all fields (including spreading any
- * fragments) either correspond to distinct response names or can be merged
- * without ambiguity.
- */
-
-
-function OverlappingFieldsCanBeMergedRule(context) {
-  // A memoization for when two fragments are compared "between" each other for
-  // conflicts. Two fragments may be compared many times, so memoizing this can
-  // dramatically improve the performance of this validator.
-  var comparedFragmentPairs = new PairSet(); // A cache for the "field map" and list of fragment names found in any given
-  // selection set. Selection sets may be asked for this information multiple
-  // times, so this improves the performance of this validator.
-
-  var cachedFieldsAndFragmentNames = new Map();
-  return {
-    SelectionSet: function SelectionSet(selectionSet) {
-      var conflicts = findConflictsWithinSelectionSet(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, context.getParentType(), selectionSet);
-
-      for (var _i2 = 0; _i2 < conflicts.length; _i2++) {
-        var _ref3 = conflicts[_i2];
-        var _ref2$ = _ref3[0];
-        var responseName = _ref2$[0];
-        var reason = _ref2$[1];
-        var fields1 = _ref3[1];
-        var fields2 = _ref3[2];
-        var reasonMsg = reasonMessage(reason);
-        context.reportError(new GraphQLError("Fields \"".concat(responseName, "\" conflict because ").concat(reasonMsg, ". Use different aliases on the fields to fetch both if this was intentional."), fields1.concat(fields2)));
-      }
-    }
-  };
-}
-
-/**
- * Algorithm:
- *
- * Conflicts occur when two fields exist in a query which will produce the same
- * response name, but represent differing values, thus creating a conflict.
- * The algorithm below finds all conflicts via making a series of comparisons
- * between fields. In order to compare as few fields as possible, this makes
- * a series of comparisons "within" sets of fields and "between" sets of fields.
- *
- * Given any selection set, a collection produces both a set of fields by
- * also including all inline fragments, as well as a list of fragments
- * referenced by fragment spreads.
- *
- * A) Each selection set represented in the document first compares "within" its
- * collected set of fields, finding any conflicts between every pair of
- * overlapping fields.
- * Note: This is the *only time* that a the fields "within" a set are compared
- * to each other. After this only fields "between" sets are compared.
- *
- * B) Also, if any fragment is referenced in a selection set, then a
- * comparison is made "between" the original set of fields and the
- * referenced fragment.
- *
- * C) Also, if multiple fragments are referenced, then comparisons
- * are made "between" each referenced fragment.
- *
- * D) When comparing "between" a set of fields and a referenced fragment, first
- * a comparison is made between each field in the original set of fields and
- * each field in the the referenced set of fields.
- *
- * E) Also, if any fragment is referenced in the referenced selection set,
- * then a comparison is made "between" the original set of fields and the
- * referenced fragment (recursively referring to step D).
- *
- * F) When comparing "between" two fragments, first a comparison is made between
- * each field in the first referenced set of fields and each field in the the
- * second referenced set of fields.
- *
- * G) Also, any fragments referenced by the first must be compared to the
- * second, and any fragments referenced by the second must be compared to the
- * first (recursively referring to step F).
- *
- * H) When comparing two fields, if both have selection sets, then a comparison
- * is made "between" both selection sets, first comparing the set of fields in
- * the first selection set with the set of fields in the second.
- *
- * I) Also, if any fragment is referenced in either selection set, then a
- * comparison is made "between" the other set of fields and the
- * referenced fragment.
- *
- * J) Also, if two fragments are referenced in both selection sets, then a
- * comparison is made "between" the two fragments.
- *
- */
-// Find all conflicts found "within" a selection set, including those found
-// via spreading in fragments. Called when visiting each SelectionSet in the
-// GraphQL Document.
-function findConflictsWithinSelectionSet(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, parentType, selectionSet) {
-  var conflicts = [];
-
-  var _getFieldsAndFragment = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType, selectionSet),
-      fieldMap = _getFieldsAndFragment[0],
-      fragmentNames = _getFieldsAndFragment[1]; // (A) Find find all conflicts "within" the fields of this selection set.
-  // Note: this is the *only place* `collectConflictsWithin` is called.
-
-
-  collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, fieldMap);
-
-  if (fragmentNames.length !== 0) {
-    // (B) Then collect conflicts between these fields and those represented by
-    // each spread fragment name found.
-    for (var i = 0; i < fragmentNames.length; i++) {
-      collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, false, fieldMap, fragmentNames[i]); // (C) Then compare this fragment with all other fragments found in this
-      // selection set to collect conflicts between fragments spread together.
-      // This compares each item in the list of fragment names to every other
-      // item in that same list (except for itself).
-
-      for (var j = i + 1; j < fragmentNames.length; j++) {
-        collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, false, fragmentNames[i], fragmentNames[j]);
-      }
-    }
-  }
-
-  return conflicts;
-} // Collect all conflicts found between a set of fields and a fragment reference
-// including via spreading in any nested fragments.
-
-
-function collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap, fragmentName) {
-  var fragment = context.getFragment(fragmentName);
-
-  if (!fragment) {
-    return;
-  }
-
-  var _getReferencedFieldsA = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment),
-      fieldMap2 = _getReferencedFieldsA[0],
-      fragmentNames2 = _getReferencedFieldsA[1]; // Do not compare a fragment's fieldMap to itself.
-
-
-  if (fieldMap === fieldMap2) {
-    return;
-  } // (D) First collect any conflicts between the provided collection of fields
-  // and the collection of fields represented by the given fragment.
-
-
-  collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap, fieldMap2); // (E) Then collect any conflicts between the provided collection of fields
-  // and any fragment names found in the given fragment.
-
-  for (var i = 0; i < fragmentNames2.length; i++) {
-    collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap, fragmentNames2[i]);
-  }
-} // Collect all conflicts found between two fragments, including via spreading in
-// any nested fragments.
-
-
-function collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentName1, fragmentName2) {
-  // No need to compare a fragment to itself.
-  if (fragmentName1 === fragmentName2) {
-    return;
-  } // Memoize so two fragments are not compared for conflicts more than once.
-
-
-  if (comparedFragmentPairs.has(fragmentName1, fragmentName2, areMutuallyExclusive)) {
-    return;
-  }
-
-  comparedFragmentPairs.add(fragmentName1, fragmentName2, areMutuallyExclusive);
-  var fragment1 = context.getFragment(fragmentName1);
-  var fragment2 = context.getFragment(fragmentName2);
-
-  if (!fragment1 || !fragment2) {
-    return;
-  }
-
-  var _getReferencedFieldsA2 = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment1),
-      fieldMap1 = _getReferencedFieldsA2[0],
-      fragmentNames1 = _getReferencedFieldsA2[1];
-
-  var _getReferencedFieldsA3 = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment2),
-      fieldMap2 = _getReferencedFieldsA3[0],
-      fragmentNames2 = _getReferencedFieldsA3[1]; // (F) First, collect all conflicts between these two collections of fields
-  // (not including any nested fragments).
-
-
-  collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap1, fieldMap2); // (G) Then collect conflicts between the first fragment and any nested
-  // fragments spread in the second fragment.
-
-  for (var j = 0; j < fragmentNames2.length; j++) {
-    collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentName1, fragmentNames2[j]);
-  } // (G) Then collect conflicts between the second fragment and any nested
-  // fragments spread in the first fragment.
-
-
-  for (var i = 0; i < fragmentNames1.length; i++) {
-    collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentNames1[i], fragmentName2);
-  }
-} // Find all conflicts found between two selection sets, including those found
-// via spreading in fragments. Called when determining if conflicts exist
-// between the sub-fields of two overlapping fields.
-
-
-function findConflictsBetweenSubSelectionSets(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, parentType1, selectionSet1, parentType2, selectionSet2) {
-  var conflicts = [];
-
-  var _getFieldsAndFragment2 = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType1, selectionSet1),
-      fieldMap1 = _getFieldsAndFragment2[0],
-      fragmentNames1 = _getFieldsAndFragment2[1];
-
-  var _getFieldsAndFragment3 = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType2, selectionSet2),
-      fieldMap2 = _getFieldsAndFragment3[0],
-      fragmentNames2 = _getFieldsAndFragment3[1]; // (H) First, collect all conflicts between these two collections of field.
+      if (node.kind === Kind.SCHEMA_DEFINITION || node.kind === Kind.SCHEMA_EXTENSION) {
+        seenDirectives = schemaDirectives;
+      } else if (isTypeDefinitionNode(node) || isTypeExtensionNode(node)) {
+        var typeName = node.name.value;
+        seenDirectives = typeDirectivesMap[typeName];
 
+        if (seenDirectives === undefined) {
+          typeDirectivesMap[typeName] = seenDirectives = Object.create(null);
+        }
+      } else {
+        seenDirectives = Object.create(null);
+      }
 
-  collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap1, fieldMap2); // (I) Then collect conflicts between the first collection of fields and
-  // those referenced by each fragment name associated with the second.
+      for (var _i6 = 0, _node$directives2 = node.directives; _i6 < _node$directives2.length; _i6++) {
+        var _directive = _node$directives2[_i6];
+        var directiveName = _directive.name.value;
 
-  if (fragmentNames2.length !== 0) {
-    for (var j = 0; j < fragmentNames2.length; j++) {
-      collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap1, fragmentNames2[j]);
+        if (uniqueDirectiveMap[directiveName]) {
+          if (seenDirectives[directiveName]) {
+            context.reportError(new GraphQLError("The directive \"@".concat(directiveName, "\" can only be used once at this location."), [seenDirectives[directiveName], _directive]));
+          } else {
+            seenDirectives[directiveName] = _directive;
+          }
+        }
+      }
     }
-  } // (I) Then collect conflicts between the second collection of fields and
-  // those referenced by each fragment name associated with the first.
-
+  };
+}
 
-  if (fragmentNames1.length !== 0) {
-    for (var i = 0; i < fragmentNames1.length; i++) {
-      collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap2, fragmentNames1[i]);
-    }
-  } // (J) Also collect conflicts between any fragment names by the first and
-  // fragment names by the second. This compares each item in the first set of
-  // names to each item in the second set of names.
+/**
+ * @internal
+ */
 
+function KnownArgumentNamesOnDirectivesRule(context) {
+  var directiveArgs = Object.create(null);
+  var schema = context.getSchema();
+  var definedDirectives = schema ? schema.getDirectives() : specifiedDirectives;
 
-  for (var _i3 = 0; _i3 < fragmentNames1.length; _i3++) {
-    for (var _j = 0; _j < fragmentNames2.length; _j++) {
-      collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentNames1[_i3], fragmentNames2[_j]);
-    }
+  for (var _i2 = 0; _i2 < definedDirectives.length; _i2++) {
+    var directive = definedDirectives[_i2];
+    directiveArgs[directive.name] = directive.args.map(function (arg) {
+      return arg.name;
+    });
   }
 
-  return conflicts;
-} // Collect all Conflicts "within" one collection of fields.
-
+  var astDefinitions = context.getDocument().definitions;
 
-function collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, fieldMap) {
-  // A field map is a keyed collection, where each key represents a response
-  // name and the value at that key is a list of all fields which provide that
-  // response name. For every response name, if there are multiple fields, they
-  // must be compared to find a potential conflict.
-  for (var _i5 = 0, _objectEntries2 = objectEntries$1(fieldMap); _i5 < _objectEntries2.length; _i5++) {
-    var _ref5 = _objectEntries2[_i5];
-    var responseName = _ref5[0];
-    var fields = _ref5[1];
+  for (var _i4 = 0; _i4 < astDefinitions.length; _i4++) {
+    var def = astDefinitions[_i4];
 
-    // This compares every field in the list to every other field in this list
-    // (except to itself). If the list only has one item, nothing needs to
-    // be compared.
-    if (fields.length > 1) {
-      for (var i = 0; i < fields.length; i++) {
-        for (var j = i + 1; j < fields.length; j++) {
-          var conflict = findConflict(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, false, // within one collection is never mutually exclusive
-          responseName, fields[i], fields[j]);
+    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+      var _def$arguments;
 
-          if (conflict) {
-            conflicts.push(conflict);
-          }
-        }
-      }
+      // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
+      var argsNodes = (_def$arguments = def.arguments) !== null && _def$arguments !== void 0 ? _def$arguments : [];
+      directiveArgs[def.name.value] = argsNodes.map(function (arg) {
+        return arg.name.value;
+      });
     }
   }
-} // Collect all Conflicts between two collections of fields. This is similar to,
-// but different from the `collectConflictsWithin` function above. This check
-// assumes that `collectConflictsWithin` has already been called on each
-// provided collection of fields. This is true because this validator traverses
-// each individual selection set.
-
-
-function collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, parentFieldsAreMutuallyExclusive, fieldMap1, fieldMap2) {
-  // A field map is a keyed collection, where each key represents a response
-  // name and the value at that key is a list of all fields which provide that
-  // response name. For any response name which appears in both provided field
-  // maps, each field from the first field map must be compared to every field
-  // in the second field map to find potential conflicts.
-  for (var _i7 = 0, _Object$keys2 = Object.keys(fieldMap1); _i7 < _Object$keys2.length; _i7++) {
-    var responseName = _Object$keys2[_i7];
-    var fields2 = fieldMap2[responseName];
 
-    if (fields2) {
-      var fields1 = fieldMap1[responseName];
+  return {
+    Directive: function Directive(directiveNode) {
+      var directiveName = directiveNode.name.value;
+      var knownArgs = directiveArgs[directiveName];
 
-      for (var i = 0; i < fields1.length; i++) {
-        for (var j = 0; j < fields2.length; j++) {
-          var conflict = findConflict(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, parentFieldsAreMutuallyExclusive, responseName, fields1[i], fields2[j]);
+      if (directiveNode.arguments && knownArgs) {
+        for (var _i6 = 0, _directiveNode$argume2 = directiveNode.arguments; _i6 < _directiveNode$argume2.length; _i6++) {
+          var argNode = _directiveNode$argume2[_i6];
+          var argName = argNode.name.value;
 
-          if (conflict) {
-            conflicts.push(conflict);
+          if (knownArgs.indexOf(argName) === -1) {
+            var suggestions = suggestionList(argName, knownArgs);
+            context.reportError(new GraphQLError("Unknown argument \"".concat(argName, "\" on directive \"@").concat(directiveName, "\".") + didYouMean(suggestions), argNode));
           }
         }
       }
-    }
-  }
-} // Determines if there is a conflict between two particular fields, including
-// comparing their sub-fields.
-
-
-function findConflict(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, parentFieldsAreMutuallyExclusive, responseName, field1, field2) {
-  var parentType1 = field1[0],
-      node1 = field1[1],
-      def1 = field1[2];
-  var parentType2 = field2[0],
-      node2 = field2[1],
-      def2 = field2[2]; // If it is known that two fields could not possibly apply at the same
-  // time, due to the parent types, then it is safe to permit them to diverge
-  // in aliased field or arguments used as they will not present any ambiguity
-  // by differing.
-  // It is known that two parent types could never overlap if they are
-  // different Object types. Interface or Union types might overlap - if not
-  // in the current state of the schema, then perhaps in some future version,
-  // thus may not safely diverge.
-
-  var areMutuallyExclusive = parentFieldsAreMutuallyExclusive || parentType1 !== parentType2 && isObjectType(parentType1) && isObjectType(parentType2);
 
-  if (!areMutuallyExclusive) {
-    var _node1$arguments, _node2$arguments;
-
-    // Two aliases must refer to the same field.
-    var name1 = node1.name.value;
-    var name2 = node2.name.value;
-
-    if (name1 !== name2) {
-      return [[responseName, "\"".concat(name1, "\" and \"").concat(name2, "\" are different fields")], [node1], [node2]];
-    } // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
-
-
-    var args1 = (_node1$arguments = node1.arguments) !== null && _node1$arguments !== void 0 ? _node1$arguments : []; // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
-
-    var args2 = (_node2$arguments = node2.arguments) !== null && _node2$arguments !== void 0 ? _node2$arguments : []; // Two field calls must have the same arguments.
-
-    if (!sameArguments(args1, args2)) {
-      return [[responseName, 'they have differing arguments'], [node1], [node2]];
+      return false;
     }
-  } // The return type for each field.
-
-
-  var type1 = def1 === null || def1 === void 0 ? void 0 : def1.type;
-  var type2 = def2 === null || def2 === void 0 ? void 0 : def2.type;
-
-  if (type1 && type2 && doTypesConflict(type1, type2)) {
-    return [[responseName, "they return conflicting types \"".concat(inspect(type1), "\" and \"").concat(inspect(type2), "\"")], [node1], [node2]];
-  } // Collect and compare sub-fields. Use the same "visited fragment names" list
-  // for both collections so fields in a fragment reference are never
-  // compared to themselves.
-
-
-  var selectionSet1 = node1.selectionSet;
-  var selectionSet2 = node2.selectionSet;
-
-  if (selectionSet1 && selectionSet2) {
-    var conflicts = findConflictsBetweenSubSelectionSets(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, getNamedType(type1), selectionSet1, getNamedType(type2), selectionSet2);
-    return subfieldConflicts(conflicts, responseName, node1, node2);
-  }
+  };
 }
 
-function sameArguments(arguments1, arguments2) {
-  if (arguments1.length !== arguments2.length) {
-    return false;
-  }
+/**
+ * Unique argument names
+ *
+ * A GraphQL field or directive is only valid if all supplied arguments are
+ * uniquely named.
+ */
+function UniqueArgumentNamesRule(context) {
+  var knownArgNames = Object.create(null);
+  return {
+    Field: function Field() {
+      knownArgNames = Object.create(null);
+    },
+    Directive: function Directive() {
+      knownArgNames = Object.create(null);
+    },
+    Argument: function Argument(node) {
+      var argName = node.name.value;
 
-  return arguments1.every(function (argument1) {
-    var argument2 = find$1(arguments2, function (argument) {
-      return argument.name.value === argument1.name.value;
-    });
+      if (knownArgNames[argName]) {
+        context.reportError(new GraphQLError("There can be only one argument named \"".concat(argName, "\"."), [knownArgNames[argName], node.name]));
+      } else {
+        knownArgNames[argName] = node.name;
+      }
 
-    if (!argument2) {
       return false;
     }
-
-    return sameValue(argument1.value, argument2.value);
-  });
+  };
 }
 
-function sameValue(value1, value2) {
-  return print(value1) === print(value2);
-} // Two types conflict if both types could not apply to a value simultaneously.
-// Composite types are ignored as their individual field types will be compared
-// later recursively. However List and Non-Null types must match.
-
-
-function doTypesConflict(type1, type2) {
-  if (isListType(type1)) {
-    return isListType(type2) ? doTypesConflict(type1.ofType, type2.ofType) : true;
-  }
-
-  if (isListType(type2)) {
-    return true;
-  }
-
-  if (isNonNullType(type1)) {
-    return isNonNullType(type2) ? doTypesConflict(type1.ofType, type2.ofType) : true;
-  }
-
-  if (isNonNullType(type2)) {
-    return true;
-  }
-
-  if (isLeafType(type1) || isLeafType(type2)) {
-    return type1 !== type2;
-  }
-
-  return false;
-} // Given a selection set, return the collection of fields (a mapping of response
-// name to field nodes and definitions) as well as a list of fragment names
-// referenced via fragment spreads.
-
-
-function getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType, selectionSet) {
-  var cached = cachedFieldsAndFragmentNames.get(selectionSet);
-
-  if (!cached) {
-    var nodeAndDefs = Object.create(null);
-    var fragmentNames = Object.create(null);
+/**
+ * @internal
+ */
 
-    _collectFieldsAndFragmentNames(context, parentType, selectionSet, nodeAndDefs, fragmentNames);
+function ProvidedRequiredArgumentsOnDirectivesRule(context) {
+  var requiredArgsMap = Object.create(null);
+  var schema = context.getSchema();
+  var definedDirectives = schema ? schema.getDirectives() : specifiedDirectives;
 
-    cached = [nodeAndDefs, Object.keys(fragmentNames)];
-    cachedFieldsAndFragmentNames.set(selectionSet, cached);
+  for (var _i4 = 0; _i4 < definedDirectives.length; _i4++) {
+    var directive = definedDirectives[_i4];
+    requiredArgsMap[directive.name] = keyMap(directive.args.filter(isRequiredArgument), function (arg) {
+      return arg.name;
+    });
   }
 
-  return cached;
-} // Given a reference to a fragment, return the represented collection of fields
-// as well as a list of nested fragment names referenced via fragment spreads.
+  var astDefinitions = context.getDocument().definitions;
 
+  for (var _i6 = 0; _i6 < astDefinitions.length; _i6++) {
+    var def = astDefinitions[_i6];
 
-function getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment) {
-  // Short-circuit building a type from the node if possible.
-  var cached = cachedFieldsAndFragmentNames.get(fragment.selectionSet);
+    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+      var _def$arguments;
 
-  if (cached) {
-    return cached;
+      // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
+      var argNodes = (_def$arguments = def.arguments) !== null && _def$arguments !== void 0 ? _def$arguments : [];
+      requiredArgsMap[def.name.value] = keyMap(argNodes.filter(isRequiredArgumentNode), function (arg) {
+        return arg.name.value;
+      });
+    }
   }
 
-  var fragmentType = typeFromAST(context.getSchema(), fragment.typeCondition);
-  return getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragmentType, fragment.selectionSet);
-}
+  return {
+    Directive: {
+      // Validate on leave to allow for deeper errors to appear first.
+      leave: function leave(directiveNode) {
+        var directiveName = directiveNode.name.value;
+        var requiredArgs = requiredArgsMap[directiveName];
 
-function _collectFieldsAndFragmentNames(context, parentType, selectionSet, nodeAndDefs, fragmentNames) {
-  for (var _i9 = 0, _selectionSet$selecti2 = selectionSet.selections; _i9 < _selectionSet$selecti2.length; _i9++) {
-    var selection = _selectionSet$selecti2[_i9];
+        if (requiredArgs) {
+          var _directiveNode$argume;
 
-    switch (selection.kind) {
-      case Kind.FIELD:
-        {
-          var fieldName = selection.name.value;
-          var fieldDef = void 0;
+          // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
+          var _argNodes = (_directiveNode$argume = directiveNode.arguments) !== null && _directiveNode$argume !== void 0 ? _directiveNode$argume : [];
 
-          if (isObjectType(parentType) || isInterfaceType(parentType)) {
-            fieldDef = parentType.getFields()[fieldName];
-          }
+          var argNodeMap = keyMap(_argNodes, function (arg) {
+            return arg.name.value;
+          });
 
-          var responseName = selection.alias ? selection.alias.value : fieldName;
+          for (var _i8 = 0, _Object$keys2 = Object.keys(requiredArgs); _i8 < _Object$keys2.length; _i8++) {
+            var argName = _Object$keys2[_i8];
 
-          if (!nodeAndDefs[responseName]) {
-            nodeAndDefs[responseName] = [];
+            if (!argNodeMap[argName]) {
+              var argType = requiredArgs[argName].type;
+              var argTypeStr = isType(argType) ? inspect(argType) : print(argType);
+              context.reportError(new GraphQLError("Directive \"@".concat(directiveName, "\" argument \"").concat(argName, "\" of type \"").concat(argTypeStr, "\" is required, but it was not provided."), directiveNode));
+            }
           }
-
-          nodeAndDefs[responseName].push([parentType, selection, fieldDef]);
-          break;
-        }
-
-      case Kind.FRAGMENT_SPREAD:
-        fragmentNames[selection.name.value] = true;
-        break;
-
-      case Kind.INLINE_FRAGMENT:
-        {
-          var typeCondition = selection.typeCondition;
-          var inlineFragmentType = typeCondition ? typeFromAST(context.getSchema(), typeCondition) : parentType;
-
-          _collectFieldsAndFragmentNames(context, inlineFragmentType, selection.selectionSet, nodeAndDefs, fragmentNames);
-
-          break;
         }
+      }
     }
-  }
-} // Given a series of Conflicts which occurred between two sub-fields, generate
-// a single Conflict.
-
-
-function subfieldConflicts(conflicts, responseName, node1, node2) {
-  if (conflicts.length > 0) {
-    return [[responseName, conflicts.map(function (_ref6) {
-      var reason = _ref6[0];
-      return reason;
-    })], conflicts.reduce(function (allFields, _ref7) {
-      var fields1 = _ref7[1];
-      return allFields.concat(fields1);
-    }, [node1]), conflicts.reduce(function (allFields, _ref8) {
-      var fields2 = _ref8[2];
-      return allFields.concat(fields2);
-    }, [node2])];
-  }
-}
-/**
- * A way to keep track of pairs of things when the ordering of the pair does
- * not matter. We do this by maintaining a sort of double adjacency sets.
- */
-
-
-var PairSet = /*#__PURE__*/function () {
-  function PairSet() {
-    this._data = Object.create(null);
-  }
-
-  var _proto = PairSet.prototype;
-
-  _proto.has = function has(a, b, areMutuallyExclusive) {
-    var first = this._data[a];
-    var result = first && first[b];
-
-    if (result === undefined) {
-      return false;
-    } // areMutuallyExclusive being false is a superset of being true,
-    // hence if we want to know if this PairSet "has" these two with no
-    // exclusivity, we have to ensure it was added as such.
-
-
-    if (areMutuallyExclusive === false) {
-      return result === false;
-    }
-
-    return true;
-  };
-
-  _proto.add = function add(a, b, areMutuallyExclusive) {
-    this._pairSetAdd(a, b, areMutuallyExclusive);
-
-    this._pairSetAdd(b, a, areMutuallyExclusive);
-  };
-
-  _proto._pairSetAdd = function _pairSetAdd(a, b, areMutuallyExclusive) {
-    var map = this._data[a];
-
-    if (!map) {
-      map = Object.create(null);
-      this._data[a] = map;
-    }
-
-    map[b] = areMutuallyExclusive;
   };
+}
 
-  return PairSet;
-}();
+function isRequiredArgumentNode(arg) {
+  return arg.type.kind === Kind.NON_NULL_TYPE && arg.defaultValue == null;
+}
 
 /**
  * Unique input field names
@@ -9731,14 +8283,6 @@ function extensionKindToTypeName(kind) {
 }
 
 // Spec Section: "Executable Definitions"
-/**
- * This set includes all validation rules defined by the GraphQL spec.
- *
- * The order of the rules in this list has been adjusted to lead to the
- * most clear output when encountering multiple validation errors.
- */
-
-Object.freeze([ExecutableDefinitionsRule, UniqueOperationNamesRule, LoneAnonymousOperationRule, SingleFieldSubscriptionsRule, KnownTypeNamesRule, FragmentsOnCompositeTypesRule, VariablesAreInputTypesRule, ScalarLeafsRule, FieldsOnCorrectTypeRule, UniqueFragmentNamesRule, KnownFragmentNamesRule, NoUnusedFragmentsRule, PossibleFragmentSpreadsRule, NoFragmentCyclesRule, UniqueVariableNamesRule, NoUndefinedVariablesRule, NoUnusedVariablesRule, KnownDirectivesRule, UniqueDirectivesPerLocationRule, KnownArgumentNamesRule, UniqueArgumentNamesRule, ValuesOfCorrectTypeRule, ProvidedRequiredArgumentsRule, VariablesInAllowedPositionRule, OverlappingFieldsCanBeMergedRule, UniqueInputFieldNamesRule]);
 /**
  * @internal
  */
@@ -12606,8 +11150,6 @@ function transform(root) {
     };
 }
 
-const { create, keys } = Object;
-
 /**
  * we should look into optimizing this before it turns into a memory hog
  * weakmaps, or limiting the size of the cache, or something
@@ -12643,16 +11185,15 @@ function parseDocument(inputString) {
         return cachedDoc;
     }
     // parse throws an GraphQLError in case of invalid query, should this be in try/catch?
-    const parsedDoc = parse(inputString);
+    const parsedDoc = parse(inputString, { noLocation: true });
     if (!parsedDoc || parsedDoc.kind !== 'Document') {
         if (process.env.NODE_ENV !== 'production') {
             throw new Error('Invalid graphql doc');
         }
         return null;
     }
-    const parsedDocNoLoc = stripLocation(parsedDoc);
-    docMap.set(operationKey, parsedDocNoLoc);
-    return parsedDocNoLoc;
+    docMap.set(operationKey, parsedDoc);
+    return parsedDoc;
 }
 /**
  * If the input string has fragment substitution
@@ -12717,22 +11258,6 @@ function processSubstitutions(inputString, substitutions) {
         fragments,
     };
 }
-/**
- * strips Document node and nested definitions of location references
- */
-function stripLocation(node) {
-    if (node.loc) {
-        delete node.loc;
-    }
-    const keys$1 = keys(node);
-    for (const key of keys$1) {
-        const subNode = node[key];
-        if (subNode && typeof subNode === 'object') {
-            stripLocation(subNode);
-        }
-    }
-    return node;
-}
 /**
  *
  * @param astReference - ast reference passed from user land
@@ -12933,7 +11458,7 @@ function metaschemaMapper(doc) {
  * @deprecated In favor of gql tagged template literal
  */
 function parseAndVisit(source) {
-    const ast = parse(source);
+    const ast = parse(source, { noLocation: true });
     const luvioDocumentNode = transform(ast);
     // In-place substitution of metaschema annotations
     metaschemaMapper(ast);