graphql 14.0.0 → 14.1.1

package/validation/rules/OverlappingFieldsCanBeMerged.mjs

@@ -1,22 +1,21 @@
-function _defineProperty(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; }
-
 /**
  * Copyright (c) 2015-present, Facebook, Inc.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
+import find from '../../polyfills/find';
+import objectEntries from '../../polyfills/objectEntries';
 import { GraphQLError } from '../../error/GraphQLError';
 import inspect from '../../jsutils/inspect';
-import find from '../../jsutils/find';
 import { Kind } from '../../language/kinds';
 import { print } from '../../language/printer';
 import { getNamedType, isNonNullType, isLeafType, isObjectType, isListType, isInterfaceType } from '../../type/definition';
 import { typeFromAST } from '../../utilities/typeFromAST';
 export function fieldsConflictMessage(responseName, reason) {
-  return "Fields \"".concat(responseName, "\" conflict because ").concat(reasonMessage(reason)) + '. Use different aliases on the fields to fetch both if this was ' + 'intentional.';
+  return "Fields \"".concat(responseName, "\" conflict because ").concat(reasonMessage(reason), ". ") + 'Use different aliases on the fields to fetch both if this was intentional.';
 }
 
 function reasonMessage(reason) {
@@ -285,27 +284,45 @@ function collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames
   // 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.
-  var _arr = Object.keys(fieldMap);
-
-  for (var _i3 = 0; _i3 < _arr.length; _i3++) {
-    var responseName = _arr[_i3];
-    var fields = fieldMap[responseName]; // 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 (conflict) {
-            conflicts.push(conflict);
+  var _iteratorNormalCompletion = true;
+  var _didIteratorError = false;
+  var _iteratorError = undefined;
+
+  try {
+    for (var _iterator = objectEntries(fieldMap)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var _ref5 = _step.value;
+      var responseName = _ref5[0];
+      var fields = _ref5[1];
+
+      // 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 (conflict) {
+              conflicts.push(conflict);
+            }
           }
         }
       }
     }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
   }
 } // Collect all Conflicts between two collections of fields. This is similar to,
 // but different from the `collectConflictsWithin` function above. This check
@@ -320,10 +337,10 @@ function collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentName
   // 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.
-  var _arr2 = Object.keys(fieldMap1);
+  var _arr = Object.keys(fieldMap1);
 
-  for (var _i4 = 0; _i4 < _arr2.length; _i4++) {
-    var responseName = _arr2[_i4];
+  for (var _i3 = 0; _i3 < _arr.length; _i3++) {
+    var responseName = _arr[_i3];
     var fields2 = fieldMap2[responseName];
 
     if (fields2) {
@@ -518,14 +535,14 @@ function _collectFieldsAndFragmentNames(context, parentType, selectionSet, nodeA
 
 function subfieldConflicts(conflicts, responseName, node1, node2) {
   if (conflicts.length > 0) {
-    return [[responseName, conflicts.map(function (_ref4) {
-      var reason = _ref4[0];
+    return [[responseName, conflicts.map(function (_ref6) {
+      var reason = _ref6[0];
       return reason;
-    })], conflicts.reduce(function (allFields, _ref5) {
-      var fields1 = _ref5[1];
+    })], conflicts.reduce(function (allFields, _ref7) {
+      var fields1 = _ref7[1];
       return allFields.concat(fields1);
-    }, [node1]), conflicts.reduce(function (allFields, _ref6) {
-      var fields2 = _ref6[2];
+    }, [node1]), conflicts.reduce(function (allFields, _ref8) {
+      var fields2 = _ref8[2];
       return allFields.concat(fields2);
     }, [node2])];
   }
@@ -540,8 +557,6 @@ var PairSet =
 /*#__PURE__*/
 function () {
   function PairSet() {
-    _defineProperty(this, "_data", void 0);
-
     this._data = Object.create(null);
   }
 

package/validation/rules/PossibleFragmentSpreads.js

@@ -25,7 +25,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 function typeIncompatibleSpreadMessage(fragName, parentType, fragType) {
   return "Fragment \"".concat(fragName, "\" cannot be spread here as objects of ") + "type \"".concat(parentType, "\" can never be of type \"").concat(fragType, "\".");

package/validation/rules/PossibleFragmentSpreads.mjs

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 import inspect from '../../jsutils/inspect';
 import { GraphQLError } from '../../error/GraphQLError';

package/validation/rules/PossibleTypeExtensions.js

@@ -0,0 +1,158 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extendingUnknownTypeMessage = extendingUnknownTypeMessage;
+exports.extendingDifferentTypeKindMessage = extendingDifferentTypeKindMessage;
+exports.PossibleTypeExtensions = PossibleTypeExtensions;
+
+var _quotedOrList = _interopRequireDefault(require("../../jsutils/quotedOrList"));
+
+var _suggestionList = _interopRequireDefault(require("../../jsutils/suggestionList"));
+
+var _GraphQLError = require("../../error/GraphQLError");
+
+var _kinds = require("../../language/kinds");
+
+var _predicates = require("../../language/predicates");
+
+var _definition = require("../../type/definition");
+
+var _defKindToExtKind;
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(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 extendingUnknownTypeMessage(typeName, suggestedTypes) {
+  var message = "Cannot extend type \"".concat(typeName, "\" because it does not defined.");
+
+  if (suggestedTypes.length) {
+    message += " Did you mean ".concat((0, _quotedOrList.default)(suggestedTypes), "?");
+  }
+
+  return message;
+}
+
+function extendingDifferentTypeKindMessage(typeName, kind) {
+  return "Cannot extend non-".concat(kind, " type \"").concat(typeName, "\".");
+}
+/**
+ * Possible type extension
+ *
+ * A type extension is only valid if the type defined and have the same kind.
+ */
+
+
+function PossibleTypeExtensions(context) {
+  var schema = context.getSchema();
+  var definedTypes = Object.create(null);
+  var _iteratorNormalCompletion = true;
+  var _didIteratorError = false;
+  var _iteratorError = undefined;
+
+  try {
+    for (var _iterator = context.getDocument().definitions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var def = _step.value;
+
+      if ((0, _predicates.isTypeDefinitionNode)(def)) {
+        definedTypes[def.name.value] = def;
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+
+  return {
+    ScalarTypeExtension: checkExtension,
+    ObjectTypeExtension: checkExtension,
+    InterfaceTypeExtension: checkExtension,
+    UnionTypeExtension: checkExtension,
+    EnumTypeExtension: checkExtension,
+    InputObjectTypeExtension: checkExtension
+  };
+
+  function checkExtension(node) {
+    var typeName = node.name.value;
+    var defNode = definedTypes[typeName];
+    var existingType = schema && schema.getType(typeName);
+
+    if (defNode) {
+      var expectedKind = defKindToExtKind[defNode.kind];
+
+      if (expectedKind !== node.kind) {
+        context.reportError(new _GraphQLError.GraphQLError(extendingDifferentTypeKindMessage(typeName, extensionKindToTypeName(expectedKind)), [defNode, node]));
+      }
+    } else if (existingType) {
+      var _expectedKind = typeToExtKind(existingType);
+
+      if (_expectedKind !== node.kind) {
+        context.reportError(new _GraphQLError.GraphQLError(extendingDifferentTypeKindMessage(typeName, extensionKindToTypeName(_expectedKind)), node));
+      }
+    } else {
+      var allTypeNames = Object.keys(definedTypes);
+
+      if (schema) {
+        allTypeNames = allTypeNames.concat(Object.keys(schema.getTypeMap()));
+      }
+
+      var suggestedTypes = (0, _suggestionList.default)(typeName, allTypeNames);
+      context.reportError(new _GraphQLError.GraphQLError(extendingUnknownTypeMessage(typeName, suggestedTypes), node.name));
+    }
+  }
+}
+
+var defKindToExtKind = (_defKindToExtKind = {}, _defineProperty(_defKindToExtKind, _kinds.Kind.SCALAR_TYPE_DEFINITION, _kinds.Kind.SCALAR_TYPE_EXTENSION), _defineProperty(_defKindToExtKind, _kinds.Kind.OBJECT_TYPE_DEFINITION, _kinds.Kind.OBJECT_TYPE_EXTENSION), _defineProperty(_defKindToExtKind, _kinds.Kind.INTERFACE_TYPE_DEFINITION, _kinds.Kind.INTERFACE_TYPE_EXTENSION), _defineProperty(_defKindToExtKind, _kinds.Kind.UNION_TYPE_DEFINITION, _kinds.Kind.UNION_TYPE_EXTENSION), _defineProperty(_defKindToExtKind, _kinds.Kind.ENUM_TYPE_DEFINITION, _kinds.Kind.ENUM_TYPE_EXTENSION), _defineProperty(_defKindToExtKind, _kinds.Kind.INPUT_OBJECT_TYPE_DEFINITION, _kinds.Kind.INPUT_OBJECT_TYPE_EXTENSION), _defKindToExtKind);
+
+function typeToExtKind(type) {
+  if ((0, _definition.isScalarType)(type)) {
+    return _kinds.Kind.SCALAR_TYPE_EXTENSION;
+  } else if ((0, _definition.isObjectType)(type)) {
+    return _kinds.Kind.OBJECT_TYPE_EXTENSION;
+  } else if ((0, _definition.isInterfaceType)(type)) {
+    return _kinds.Kind.INTERFACE_TYPE_EXTENSION;
+  } else if ((0, _definition.isUnionType)(type)) {
+    return _kinds.Kind.UNION_TYPE_EXTENSION;
+  } else if ((0, _definition.isEnumType)(type)) {
+    return _kinds.Kind.ENUM_TYPE_EXTENSION;
+  } else if ((0, _definition.isInputObjectType)(type)) {
+    return _kinds.Kind.INPUT_OBJECT_TYPE_EXTENSION;
+  }
+}
+
+function extensionKindToTypeName(kind) {
+  switch (kind) {
+    case _kinds.Kind.SCALAR_TYPE_EXTENSION:
+      return 'scalar';
+
+    case _kinds.Kind.OBJECT_TYPE_EXTENSION:
+      return 'object';
+
+    case _kinds.Kind.INTERFACE_TYPE_EXTENSION:
+      return 'interface';
+
+    case _kinds.Kind.UNION_TYPE_EXTENSION:
+      return 'union';
+
+    case _kinds.Kind.ENUM_TYPE_EXTENSION:
+      return 'enum';
+
+    case _kinds.Kind.INPUT_OBJECT_TYPE_EXTENSION:
+      return 'input object';
+
+    default:
+      return 'unknown type';
+  }
+}

package/validation/rules/PossibleTypeExtensions.js.flow

@@ -0,0 +1,160 @@
+/**
+ * Copyright (c) 2018-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ */
+
+import quotedOrList from '../../jsutils/quotedOrList';
+import suggestionList from '../../jsutils/suggestionList';
+import type { SDLValidationContext } from '../ValidationContext';
+import { GraphQLError } from '../../error/GraphQLError';
+import { Kind } from '../../language/kinds';
+import { isTypeDefinitionNode } from '../../language/predicates';
+import type { ASTVisitor } from '../../language/visitor';
+import {
+  isScalarType,
+  isObjectType,
+  isInterfaceType,
+  isUnionType,
+  isEnumType,
+  isInputObjectType,
+} from '../../type/definition';
+
+export function extendingUnknownTypeMessage(
+  typeName: string,
+  suggestedTypes: Array<string>,
+): string {
+  let message = `Cannot extend type "${typeName}" because it does not defined.`;
+  if (suggestedTypes.length) {
+    message += ` Did you mean ${quotedOrList(suggestedTypes)}?`;
+  }
+  return message;
+}
+
+export function extendingDifferentTypeKindMessage(
+  typeName: string,
+  kind: string,
+): string {
+  return `Cannot extend non-${kind} type "${typeName}".`;
+}
+
+/**
+ * Possible type extension
+ *
+ * A type extension is only valid if the type defined and have the same kind.
+ */
+export function PossibleTypeExtensions(
+  context: SDLValidationContext,
+): ASTVisitor {
+  const schema = context.getSchema();
+  const definedTypes = Object.create(null);
+
+  for (const def of context.getDocument().definitions) {
+    if (isTypeDefinitionNode(def)) {
+      definedTypes[def.name.value] = def;
+    }
+  }
+
+  return {
+    ScalarTypeExtension: checkExtension,
+    ObjectTypeExtension: checkExtension,
+    InterfaceTypeExtension: checkExtension,
+    UnionTypeExtension: checkExtension,
+    EnumTypeExtension: checkExtension,
+    InputObjectTypeExtension: checkExtension,
+  };
+
+  function checkExtension(node) {
+    const typeName = node.name.value;
+    const defNode = definedTypes[typeName];
+    const existingType = schema && schema.getType(typeName);
+
+    if (defNode) {
+      const expectedKind = defKindToExtKind[defNode.kind];
+      if (expectedKind !== node.kind) {
+        context.reportError(
+          new GraphQLError(
+            extendingDifferentTypeKindMessage(
+              typeName,
+              extensionKindToTypeName(expectedKind),
+            ),
+            [defNode, node],
+          ),
+        );
+      }
+    } else if (existingType) {
+      const expectedKind = typeToExtKind(existingType);
+      if (expectedKind !== node.kind) {
+        context.reportError(
+          new GraphQLError(
+            extendingDifferentTypeKindMessage(
+              typeName,
+              extensionKindToTypeName(expectedKind),
+            ),
+            node,
+          ),
+        );
+      }
+    } else {
+      let allTypeNames = Object.keys(definedTypes);
+      if (schema) {
+        allTypeNames = allTypeNames.concat(Object.keys(schema.getTypeMap()));
+      }
+
+      const suggestedTypes = suggestionList(typeName, allTypeNames);
+      context.reportError(
+        new GraphQLError(
+          extendingUnknownTypeMessage(typeName, suggestedTypes),
+          node.name,
+        ),
+      );
+    }
+  }
+}
+
+const defKindToExtKind = {
+  [Kind.SCALAR_TYPE_DEFINITION]: Kind.SCALAR_TYPE_EXTENSION,
+  [Kind.OBJECT_TYPE_DEFINITION]: Kind.OBJECT_TYPE_EXTENSION,
+  [Kind.INTERFACE_TYPE_DEFINITION]: Kind.INTERFACE_TYPE_EXTENSION,
+  [Kind.UNION_TYPE_DEFINITION]: Kind.UNION_TYPE_EXTENSION,
+  [Kind.ENUM_TYPE_DEFINITION]: Kind.ENUM_TYPE_EXTENSION,
+  [Kind.INPUT_OBJECT_TYPE_DEFINITION]: Kind.INPUT_OBJECT_TYPE_EXTENSION,
+};
+
+function typeToExtKind(type) {
+  if (isScalarType(type)) {
+    return Kind.SCALAR_TYPE_EXTENSION;
+  } else if (isObjectType(type)) {
+    return Kind.OBJECT_TYPE_EXTENSION;
+  } else if (isInterfaceType(type)) {
+    return Kind.INTERFACE_TYPE_EXTENSION;
+  } else if (isUnionType(type)) {
+    return Kind.UNION_TYPE_EXTENSION;
+  } else if (isEnumType(type)) {
+    return Kind.ENUM_TYPE_EXTENSION;
+  } else if (isInputObjectType(type)) {
+    return Kind.INPUT_OBJECT_TYPE_EXTENSION;
+  }
+}
+
+function extensionKindToTypeName(kind) {
+  switch (kind) {
+    case Kind.SCALAR_TYPE_EXTENSION:
+      return 'scalar';
+    case Kind.OBJECT_TYPE_EXTENSION:
+      return 'object';
+    case Kind.INTERFACE_TYPE_EXTENSION:
+      return 'interface';
+    case Kind.UNION_TYPE_EXTENSION:
+      return 'union';
+    case Kind.ENUM_TYPE_EXTENSION:
+      return 'enum';
+    case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+      return 'input object';
+    default:
+      return 'unknown type';
+  }
+}

package/validation/rules/PossibleTypeExtensions.mjs

@@ -0,0 +1,146 @@
+var _defKindToExtKind;
+
+function _defineProperty(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; }
+
+/**
+ * Copyright (c) 2018-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+import quotedOrList from '../../jsutils/quotedOrList';
+import suggestionList from '../../jsutils/suggestionList';
+import { GraphQLError } from '../../error/GraphQLError';
+import { Kind } from '../../language/kinds';
+import { isTypeDefinitionNode } from '../../language/predicates';
+import { isScalarType, isObjectType, isInterfaceType, isUnionType, isEnumType, isInputObjectType } from '../../type/definition';
+export function extendingUnknownTypeMessage(typeName, suggestedTypes) {
+  var message = "Cannot extend type \"".concat(typeName, "\" because it does not defined.");
+
+  if (suggestedTypes.length) {
+    message += " Did you mean ".concat(quotedOrList(suggestedTypes), "?");
+  }
+
+  return message;
+}
+export function extendingDifferentTypeKindMessage(typeName, kind) {
+  return "Cannot extend non-".concat(kind, " type \"").concat(typeName, "\".");
+}
+/**
+ * Possible type extension
+ *
+ * A type extension is only valid if the type defined and have the same kind.
+ */
+
+export function PossibleTypeExtensions(context) {
+  var schema = context.getSchema();
+  var definedTypes = Object.create(null);
+  var _iteratorNormalCompletion = true;
+  var _didIteratorError = false;
+  var _iteratorError = undefined;
+
+  try {
+    for (var _iterator = context.getDocument().definitions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var def = _step.value;
+
+      if (isTypeDefinitionNode(def)) {
+        definedTypes[def.name.value] = def;
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+
+  return {
+    ScalarTypeExtension: checkExtension,
+    ObjectTypeExtension: checkExtension,
+    InterfaceTypeExtension: checkExtension,
+    UnionTypeExtension: checkExtension,
+    EnumTypeExtension: checkExtension,
+    InputObjectTypeExtension: checkExtension
+  };
+
+  function checkExtension(node) {
+    var typeName = node.name.value;
+    var defNode = definedTypes[typeName];
+    var existingType = schema && schema.getType(typeName);
+
+    if (defNode) {
+      var expectedKind = defKindToExtKind[defNode.kind];
+
+      if (expectedKind !== node.kind) {
+        context.reportError(new GraphQLError(extendingDifferentTypeKindMessage(typeName, extensionKindToTypeName(expectedKind)), [defNode, node]));
+      }
+    } else if (existingType) {
+      var _expectedKind = typeToExtKind(existingType);
+
+      if (_expectedKind !== node.kind) {
+        context.reportError(new GraphQLError(extendingDifferentTypeKindMessage(typeName, extensionKindToTypeName(_expectedKind)), node));
+      }
+    } else {
+      var allTypeNames = Object.keys(definedTypes);
+
+      if (schema) {
+        allTypeNames = allTypeNames.concat(Object.keys(schema.getTypeMap()));
+      }
+
+      var suggestedTypes = suggestionList(typeName, allTypeNames);
+      context.reportError(new GraphQLError(extendingUnknownTypeMessage(typeName, suggestedTypes), node.name));
+    }
+  }
+}
+var defKindToExtKind = (_defKindToExtKind = {}, _defineProperty(_defKindToExtKind, Kind.SCALAR_TYPE_DEFINITION, Kind.SCALAR_TYPE_EXTENSION), _defineProperty(_defKindToExtKind, Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION), _defineProperty(_defKindToExtKind, Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION), _defineProperty(_defKindToExtKind, Kind.UNION_TYPE_DEFINITION, Kind.UNION_TYPE_EXTENSION), _defineProperty(_defKindToExtKind, Kind.ENUM_TYPE_DEFINITION, Kind.ENUM_TYPE_EXTENSION), _defineProperty(_defKindToExtKind, Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_EXTENSION), _defKindToExtKind);
+
+function typeToExtKind(type) {
+  if (isScalarType(type)) {
+    return Kind.SCALAR_TYPE_EXTENSION;
+  } else if (isObjectType(type)) {
+    return Kind.OBJECT_TYPE_EXTENSION;
+  } else if (isInterfaceType(type)) {
+    return Kind.INTERFACE_TYPE_EXTENSION;
+  } else if (isUnionType(type)) {
+    return Kind.UNION_TYPE_EXTENSION;
+  } else if (isEnumType(type)) {
+    return Kind.ENUM_TYPE_EXTENSION;
+  } else if (isInputObjectType(type)) {
+    return Kind.INPUT_OBJECT_TYPE_EXTENSION;
+  }
+}
+
+function extensionKindToTypeName(kind) {
+  switch (kind) {
+    case Kind.SCALAR_TYPE_EXTENSION:
+      return 'scalar';
+
+    case Kind.OBJECT_TYPE_EXTENSION:
+      return 'object';
+
+    case Kind.INTERFACE_TYPE_EXTENSION:
+      return 'interface';
+
+    case Kind.UNION_TYPE_EXTENSION:
+      return 'union';
+
+    case Kind.ENUM_TYPE_EXTENSION:
+      return 'enum';
+
+    case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+      return 'input object';
+
+    default:
+      return 'unknown type';
+  }
+}

package/validation/rules/ProvidedRequiredArguments.mjs

@@ -8,7 +8,7 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 import { GraphQLError } from '../../error/GraphQLError';
 import { Kind } from '../../language/kinds';

package/validation/rules/ScalarLeafs.js

@@ -21,7 +21,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 function noSubselectionAllowedMessage(fieldName, type) {
   return "Field \"".concat(fieldName, "\" must not have a selection since ") + "type \"".concat(type, "\" has no subfields.");

package/validation/rules/ScalarLeafs.mjs

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 import inspect from '../../jsutils/inspect';
 import { GraphQLError } from '../../error/GraphQLError';

package/validation/rules/SingleFieldSubscriptions.js

@@ -14,7 +14,7 @@ var _GraphQLError = require("../../error/GraphQLError");
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 function singleFieldOnlyMessage(name) {
   return (name ? "Subscription \"".concat(name, "\" ") : 'Anonymous Subscription ') + 'must select only one top level field.';

package/validation/rules/SingleFieldSubscriptions.mjs

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 import { GraphQLError } from '../../error/GraphQLError';
 export function singleFieldOnlyMessage(name) {

package/validation/rules/UniqueArgumentNames.js

@@ -14,7 +14,7 @@ var _GraphQLError = require("../../error/GraphQLError");
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 function duplicateArgMessage(argName) {
   return "There can be only one argument named \"".concat(argName, "\".");