graphql 0.0.1-test.1

package/validation/index.js

@@ -0,0 +1,317 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+Object.defineProperty(exports, 'ExecutableDefinitionsRule', {
+  enumerable: true,
+  get: function () {
+    return _ExecutableDefinitionsRule.ExecutableDefinitionsRule;
+  },
+});
+Object.defineProperty(exports, 'FieldsOnCorrectTypeRule', {
+  enumerable: true,
+  get: function () {
+    return _FieldsOnCorrectTypeRule.FieldsOnCorrectTypeRule;
+  },
+});
+Object.defineProperty(exports, 'FragmentsOnCompositeTypesRule', {
+  enumerable: true,
+  get: function () {
+    return _FragmentsOnCompositeTypesRule.FragmentsOnCompositeTypesRule;
+  },
+});
+Object.defineProperty(exports, 'KnownArgumentNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _KnownArgumentNamesRule.KnownArgumentNamesRule;
+  },
+});
+Object.defineProperty(exports, 'KnownDirectivesRule', {
+  enumerable: true,
+  get: function () {
+    return _KnownDirectivesRule.KnownDirectivesRule;
+  },
+});
+Object.defineProperty(exports, 'KnownFragmentNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _KnownFragmentNamesRule.KnownFragmentNamesRule;
+  },
+});
+Object.defineProperty(exports, 'KnownTypeNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _KnownTypeNamesRule.KnownTypeNamesRule;
+  },
+});
+Object.defineProperty(exports, 'LoneAnonymousOperationRule', {
+  enumerable: true,
+  get: function () {
+    return _LoneAnonymousOperationRule.LoneAnonymousOperationRule;
+  },
+});
+Object.defineProperty(exports, 'LoneSchemaDefinitionRule', {
+  enumerable: true,
+  get: function () {
+    return _LoneSchemaDefinitionRule.LoneSchemaDefinitionRule;
+  },
+});
+Object.defineProperty(exports, 'NoDeprecatedCustomRule', {
+  enumerable: true,
+  get: function () {
+    return _NoDeprecatedCustomRule.NoDeprecatedCustomRule;
+  },
+});
+Object.defineProperty(exports, 'NoFragmentCyclesRule', {
+  enumerable: true,
+  get: function () {
+    return _NoFragmentCyclesRule.NoFragmentCyclesRule;
+  },
+});
+Object.defineProperty(exports, 'NoSchemaIntrospectionCustomRule', {
+  enumerable: true,
+  get: function () {
+    return _NoSchemaIntrospectionCustomRule.NoSchemaIntrospectionCustomRule;
+  },
+});
+Object.defineProperty(exports, 'NoUndefinedVariablesRule', {
+  enumerable: true,
+  get: function () {
+    return _NoUndefinedVariablesRule.NoUndefinedVariablesRule;
+  },
+});
+Object.defineProperty(exports, 'NoUnusedFragmentsRule', {
+  enumerable: true,
+  get: function () {
+    return _NoUnusedFragmentsRule.NoUnusedFragmentsRule;
+  },
+});
+Object.defineProperty(exports, 'NoUnusedVariablesRule', {
+  enumerable: true,
+  get: function () {
+    return _NoUnusedVariablesRule.NoUnusedVariablesRule;
+  },
+});
+Object.defineProperty(exports, 'OverlappingFieldsCanBeMergedRule', {
+  enumerable: true,
+  get: function () {
+    return _OverlappingFieldsCanBeMergedRule.OverlappingFieldsCanBeMergedRule;
+  },
+});
+Object.defineProperty(exports, 'PossibleFragmentSpreadsRule', {
+  enumerable: true,
+  get: function () {
+    return _PossibleFragmentSpreadsRule.PossibleFragmentSpreadsRule;
+  },
+});
+Object.defineProperty(exports, 'PossibleTypeExtensionsRule', {
+  enumerable: true,
+  get: function () {
+    return _PossibleTypeExtensionsRule.PossibleTypeExtensionsRule;
+  },
+});
+Object.defineProperty(exports, 'ProvidedRequiredArgumentsRule', {
+  enumerable: true,
+  get: function () {
+    return _ProvidedRequiredArgumentsRule.ProvidedRequiredArgumentsRule;
+  },
+});
+Object.defineProperty(exports, 'ScalarLeafsRule', {
+  enumerable: true,
+  get: function () {
+    return _ScalarLeafsRule.ScalarLeafsRule;
+  },
+});
+Object.defineProperty(exports, 'SingleFieldSubscriptionsRule', {
+  enumerable: true,
+  get: function () {
+    return _SingleFieldSubscriptionsRule.SingleFieldSubscriptionsRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueArgumentDefinitionNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueArgumentDefinitionNamesRule.UniqueArgumentDefinitionNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueArgumentNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueArgumentNamesRule.UniqueArgumentNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueDirectiveNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueDirectiveNamesRule.UniqueDirectiveNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueDirectivesPerLocationRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueDirectivesPerLocationRule.UniqueDirectivesPerLocationRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueEnumValueNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueEnumValueNamesRule.UniqueEnumValueNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueFieldDefinitionNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueFieldDefinitionNamesRule.UniqueFieldDefinitionNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueFragmentNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueFragmentNamesRule.UniqueFragmentNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueInputFieldNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueInputFieldNamesRule.UniqueInputFieldNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueOperationNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueOperationNamesRule.UniqueOperationNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueOperationTypesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueOperationTypesRule.UniqueOperationTypesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueTypeNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueTypeNamesRule.UniqueTypeNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueVariableNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueVariableNamesRule.UniqueVariableNamesRule;
+  },
+});
+Object.defineProperty(exports, 'ValidationContext', {
+  enumerable: true,
+  get: function () {
+    return _ValidationContext.ValidationContext;
+  },
+});
+Object.defineProperty(exports, 'ValuesOfCorrectTypeRule', {
+  enumerable: true,
+  get: function () {
+    return _ValuesOfCorrectTypeRule.ValuesOfCorrectTypeRule;
+  },
+});
+Object.defineProperty(exports, 'VariablesAreInputTypesRule', {
+  enumerable: true,
+  get: function () {
+    return _VariablesAreInputTypesRule.VariablesAreInputTypesRule;
+  },
+});
+Object.defineProperty(exports, 'VariablesInAllowedPositionRule', {
+  enumerable: true,
+  get: function () {
+    return _VariablesInAllowedPositionRule.VariablesInAllowedPositionRule;
+  },
+});
+Object.defineProperty(exports, 'specifiedRules', {
+  enumerable: true,
+  get: function () {
+    return _specifiedRules.specifiedRules;
+  },
+});
+Object.defineProperty(exports, 'validate', {
+  enumerable: true,
+  get: function () {
+    return _validate.validate;
+  },
+});
+
+var _validate = require('./validate.js');
+
+var _ValidationContext = require('./ValidationContext.js');
+
+var _specifiedRules = require('./specifiedRules.js');
+
+var _ExecutableDefinitionsRule = require('./rules/ExecutableDefinitionsRule.js');
+
+var _FieldsOnCorrectTypeRule = require('./rules/FieldsOnCorrectTypeRule.js');
+
+var _FragmentsOnCompositeTypesRule = require('./rules/FragmentsOnCompositeTypesRule.js');
+
+var _KnownArgumentNamesRule = require('./rules/KnownArgumentNamesRule.js');
+
+var _KnownDirectivesRule = require('./rules/KnownDirectivesRule.js');
+
+var _KnownFragmentNamesRule = require('./rules/KnownFragmentNamesRule.js');
+
+var _KnownTypeNamesRule = require('./rules/KnownTypeNamesRule.js');
+
+var _LoneAnonymousOperationRule = require('./rules/LoneAnonymousOperationRule.js');
+
+var _NoFragmentCyclesRule = require('./rules/NoFragmentCyclesRule.js');
+
+var _NoUndefinedVariablesRule = require('./rules/NoUndefinedVariablesRule.js');
+
+var _NoUnusedFragmentsRule = require('./rules/NoUnusedFragmentsRule.js');
+
+var _NoUnusedVariablesRule = require('./rules/NoUnusedVariablesRule.js');
+
+var _OverlappingFieldsCanBeMergedRule = require('./rules/OverlappingFieldsCanBeMergedRule.js');
+
+var _PossibleFragmentSpreadsRule = require('./rules/PossibleFragmentSpreadsRule.js');
+
+var _ProvidedRequiredArgumentsRule = require('./rules/ProvidedRequiredArgumentsRule.js');
+
+var _ScalarLeafsRule = require('./rules/ScalarLeafsRule.js');
+
+var _SingleFieldSubscriptionsRule = require('./rules/SingleFieldSubscriptionsRule.js');
+
+var _UniqueArgumentNamesRule = require('./rules/UniqueArgumentNamesRule.js');
+
+var _UniqueDirectivesPerLocationRule = require('./rules/UniqueDirectivesPerLocationRule.js');
+
+var _UniqueFragmentNamesRule = require('./rules/UniqueFragmentNamesRule.js');
+
+var _UniqueInputFieldNamesRule = require('./rules/UniqueInputFieldNamesRule.js');
+
+var _UniqueOperationNamesRule = require('./rules/UniqueOperationNamesRule.js');
+
+var _UniqueVariableNamesRule = require('./rules/UniqueVariableNamesRule.js');
+
+var _ValuesOfCorrectTypeRule = require('./rules/ValuesOfCorrectTypeRule.js');
+
+var _VariablesAreInputTypesRule = require('./rules/VariablesAreInputTypesRule.js');
+
+var _VariablesInAllowedPositionRule = require('./rules/VariablesInAllowedPositionRule.js');
+
+var _LoneSchemaDefinitionRule = require('./rules/LoneSchemaDefinitionRule.js');
+
+var _UniqueOperationTypesRule = require('./rules/UniqueOperationTypesRule.js');
+
+var _UniqueTypeNamesRule = require('./rules/UniqueTypeNamesRule.js');
+
+var _UniqueEnumValueNamesRule = require('./rules/UniqueEnumValueNamesRule.js');
+
+var _UniqueFieldDefinitionNamesRule = require('./rules/UniqueFieldDefinitionNamesRule.js');
+
+var _UniqueArgumentDefinitionNamesRule = require('./rules/UniqueArgumentDefinitionNamesRule.js');
+
+var _UniqueDirectiveNamesRule = require('./rules/UniqueDirectiveNamesRule.js');
+
+var _PossibleTypeExtensionsRule = require('./rules/PossibleTypeExtensionsRule.js');
+
+var _NoDeprecatedCustomRule = require('./rules/custom/NoDeprecatedCustomRule.js');
+
+var _NoSchemaIntrospectionCustomRule = require('./rules/custom/NoSchemaIntrospectionCustomRule.js');

package/validation/index.mjs

@@ -0,0 +1,68 @@
+export { validate } from './validate.mjs';
+export { ValidationContext } from './ValidationContext.mjs';
+// All validation rules in the GraphQL Specification.
+export { specifiedRules } from './specifiedRules.mjs'; // Spec Section: "Executable Definitions"
+
+export { ExecutableDefinitionsRule } from './rules/ExecutableDefinitionsRule.mjs'; // Spec Section: "Field Selections on Objects, Interfaces, and Unions Types"
+
+export { FieldsOnCorrectTypeRule } from './rules/FieldsOnCorrectTypeRule.mjs'; // Spec Section: "Fragments on Composite Types"
+
+export { FragmentsOnCompositeTypesRule } from './rules/FragmentsOnCompositeTypesRule.mjs'; // Spec Section: "Argument Names"
+
+export { KnownArgumentNamesRule } from './rules/KnownArgumentNamesRule.mjs'; // Spec Section: "Directives Are Defined"
+
+export { KnownDirectivesRule } from './rules/KnownDirectivesRule.mjs'; // Spec Section: "Fragment spread target defined"
+
+export { KnownFragmentNamesRule } from './rules/KnownFragmentNamesRule.mjs'; // Spec Section: "Fragment Spread Type Existence"
+
+export { KnownTypeNamesRule } from './rules/KnownTypeNamesRule.mjs'; // Spec Section: "Lone Anonymous Operation"
+
+export { LoneAnonymousOperationRule } from './rules/LoneAnonymousOperationRule.mjs'; // Spec Section: "Fragments must not form cycles"
+
+export { NoFragmentCyclesRule } from './rules/NoFragmentCyclesRule.mjs'; // Spec Section: "All Variable Used Defined"
+
+export { NoUndefinedVariablesRule } from './rules/NoUndefinedVariablesRule.mjs'; // Spec Section: "Fragments must be used"
+
+export { NoUnusedFragmentsRule } from './rules/NoUnusedFragmentsRule.mjs'; // Spec Section: "All Variables Used"
+
+export { NoUnusedVariablesRule } from './rules/NoUnusedVariablesRule.mjs'; // Spec Section: "Field Selection Merging"
+
+export { OverlappingFieldsCanBeMergedRule } from './rules/OverlappingFieldsCanBeMergedRule.mjs'; // Spec Section: "Fragment spread is possible"
+
+export { PossibleFragmentSpreadsRule } from './rules/PossibleFragmentSpreadsRule.mjs'; // Spec Section: "Argument Optionality"
+
+export { ProvidedRequiredArgumentsRule } from './rules/ProvidedRequiredArgumentsRule.mjs'; // Spec Section: "Leaf Field Selections"
+
+export { ScalarLeafsRule } from './rules/ScalarLeafsRule.mjs'; // Spec Section: "Subscriptions with Single Root Field"
+
+export { SingleFieldSubscriptionsRule } from './rules/SingleFieldSubscriptionsRule.mjs'; // Spec Section: "Argument Uniqueness"
+
+export { UniqueArgumentNamesRule } from './rules/UniqueArgumentNamesRule.mjs'; // Spec Section: "Directives Are Unique Per Location"
+
+export { UniqueDirectivesPerLocationRule } from './rules/UniqueDirectivesPerLocationRule.mjs'; // Spec Section: "Fragment Name Uniqueness"
+
+export { UniqueFragmentNamesRule } from './rules/UniqueFragmentNamesRule.mjs'; // Spec Section: "Input Object Field Uniqueness"
+
+export { UniqueInputFieldNamesRule } from './rules/UniqueInputFieldNamesRule.mjs'; // Spec Section: "Operation Name Uniqueness"
+
+export { UniqueOperationNamesRule } from './rules/UniqueOperationNamesRule.mjs'; // Spec Section: "Variable Uniqueness"
+
+export { UniqueVariableNamesRule } from './rules/UniqueVariableNamesRule.mjs'; // Spec Section: "Values Type Correctness"
+
+export { ValuesOfCorrectTypeRule } from './rules/ValuesOfCorrectTypeRule.mjs'; // Spec Section: "Variables are Input Types"
+
+export { VariablesAreInputTypesRule } from './rules/VariablesAreInputTypesRule.mjs'; // Spec Section: "All Variable Usages Are Allowed"
+
+export { VariablesInAllowedPositionRule } from './rules/VariablesInAllowedPositionRule.mjs'; // SDL-specific validation rules
+
+export { LoneSchemaDefinitionRule } from './rules/LoneSchemaDefinitionRule.mjs';
+export { UniqueOperationTypesRule } from './rules/UniqueOperationTypesRule.mjs';
+export { UniqueTypeNamesRule } from './rules/UniqueTypeNamesRule.mjs';
+export { UniqueEnumValueNamesRule } from './rules/UniqueEnumValueNamesRule.mjs';
+export { UniqueFieldDefinitionNamesRule } from './rules/UniqueFieldDefinitionNamesRule.mjs';
+export { UniqueArgumentDefinitionNamesRule } from './rules/UniqueArgumentDefinitionNamesRule.mjs';
+export { UniqueDirectiveNamesRule } from './rules/UniqueDirectiveNamesRule.mjs';
+export { PossibleTypeExtensionsRule } from './rules/PossibleTypeExtensionsRule.mjs'; // Optional rules not defined by the GraphQL Specification
+
+export { NoDeprecatedCustomRule } from './rules/custom/NoDeprecatedCustomRule.mjs';
+export { NoSchemaIntrospectionCustomRule } from './rules/custom/NoSchemaIntrospectionCustomRule.mjs';

package/validation/rules/ExecutableDefinitionsRule.d.ts

@@ -0,0 +1,13 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type { ASTValidationContext } from '../ValidationContext';
+/**
+ * Executable definitions
+ *
+ * A GraphQL document is only valid for execution if all definitions are either
+ * operation or fragment definitions.
+ *
+ * See https://spec.graphql.org/draft/#sec-Executable-Definitions
+ */
+export declare function ExecutableDefinitionsRule(
+  context: ASTValidationContext,
+): ASTVisitor;

package/validation/rules/ExecutableDefinitionsRule.js

@@ -0,0 +1,44 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.ExecutableDefinitionsRule = ExecutableDefinitionsRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+var _kinds = require('../../language/kinds.js');
+
+var _predicates = require('../../language/predicates.js');
+
+/**
+ * Executable definitions
+ *
+ * A GraphQL document is only valid for execution if all definitions are either
+ * operation or fragment definitions.
+ *
+ * See https://spec.graphql.org/draft/#sec-Executable-Definitions
+ */
+function ExecutableDefinitionsRule(context) {
+  return {
+    Document(node) {
+      for (const definition of node.definitions) {
+        if (!(0, _predicates.isExecutableDefinitionNode)(definition)) {
+          const defName =
+            definition.kind === _kinds.Kind.SCHEMA_DEFINITION ||
+            definition.kind === _kinds.Kind.SCHEMA_EXTENSION
+              ? 'schema'
+              : '"' + definition.name.value + '"';
+          context.reportError(
+            new _GraphQLError.GraphQLError(
+              `The ${defName} definition is not executable.`,
+              definition,
+            ),
+          );
+        }
+      }
+
+      return false;
+    },
+  };
+}

package/validation/rules/ExecutableDefinitionsRule.mjs

@@ -0,0 +1,35 @@
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+import { Kind } from '../../language/kinds.mjs';
+import { isExecutableDefinitionNode } from '../../language/predicates.mjs';
+
+/**
+ * Executable definitions
+ *
+ * A GraphQL document is only valid for execution if all definitions are either
+ * operation or fragment definitions.
+ *
+ * See https://spec.graphql.org/draft/#sec-Executable-Definitions
+ */
+export function ExecutableDefinitionsRule(context) {
+  return {
+    Document(node) {
+      for (const definition of node.definitions) {
+        if (!isExecutableDefinitionNode(definition)) {
+          const defName =
+            definition.kind === Kind.SCHEMA_DEFINITION ||
+            definition.kind === Kind.SCHEMA_EXTENSION
+              ? 'schema'
+              : '"' + definition.name.value + '"';
+          context.reportError(
+            new GraphQLError(
+              `The ${defName} definition is not executable.`,
+              definition,
+            ),
+          );
+        }
+      }
+
+      return false;
+    },
+  };
+}

package/validation/rules/FieldsOnCorrectTypeRule.d.ts

@@ -0,0 +1,13 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type { ValidationContext } from '../ValidationContext';
+/**
+ * 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.
+ *
+ * See https://spec.graphql.org/draft/#sec-Field-Selections
+ */
+export declare function FieldsOnCorrectTypeRule(
+  context: ValidationContext,
+): ASTVisitor;

package/validation/rules/FieldsOnCorrectTypeRule.js

@@ -0,0 +1,143 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.FieldsOnCorrectTypeRule = FieldsOnCorrectTypeRule;
+
+var _didYouMean = require('../../jsutils/didYouMean.js');
+
+var _naturalCompare = require('../../jsutils/naturalCompare.js');
+
+var _suggestionList = require('../../jsutils/suggestionList.js');
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+var _definition = require('../../type/definition.js');
+
+/**
+ * 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.
+ *
+ * See https://spec.graphql.org/draft/#sec-Field-Selections
+ */
+function FieldsOnCorrectTypeRule(context) {
+  return {
+    Field(node) {
+      const type = context.getParentType();
+
+      if (type) {
+        const fieldDef = context.getFieldDef();
+
+        if (!fieldDef) {
+          // This field doesn't exist, lets look for suggestions.
+          const schema = context.getSchema();
+          const fieldName = node.name.value; // First determine if there are any suggested types to condition on.
+
+          let suggestion = (0, _didYouMean.didYouMean)(
+            'to use an inline fragment on',
+            getSuggestedTypeNames(schema, type, fieldName),
+          ); // If there are no suggested types, then perhaps this was a typo?
+
+          if (suggestion === '') {
+            suggestion = (0, _didYouMean.didYouMean)(
+              getSuggestedFieldNames(type, fieldName),
+            );
+          } // Report an error, including helpful suggestions.
+
+          context.reportError(
+            new _GraphQLError.GraphQLError(
+              `Cannot query field "${fieldName}" on type "${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.
+ */
+
+function getSuggestedTypeNames(schema, type, fieldName) {
+  if (!(0, _definition.isAbstractType)(type)) {
+    // Must be an Object type, which does not have possible fields.
+    return [];
+  }
+
+  const suggestedTypes = new Set();
+  const usageCount = Object.create(null);
+
+  for (const possibleType of schema.getPossibleTypes(type)) {
+    if (!possibleType.getFields()[fieldName]) {
+      continue;
+    } // This object type defines this field.
+
+    suggestedTypes.add(possibleType);
+    usageCount[possibleType.name] = 1;
+
+    for (const possibleInterface of possibleType.getInterfaces()) {
+      var _usageCount$possibleI;
+
+      if (!possibleInterface.getFields()[fieldName]) {
+        continue;
+      } // This interface type defines this field.
+
+      suggestedTypes.add(possibleInterface);
+      usageCount[possibleInterface.name] =
+        ((_usageCount$possibleI = usageCount[possibleInterface.name]) !==
+          null && _usageCount$possibleI !== void 0
+          ? _usageCount$possibleI
+          : 0) + 1;
+    }
+  }
+
+  return [...suggestedTypes]
+    .sort((typeA, typeB) => {
+      // Suggest both interface and object types based on how common they are.
+      const usageCountDiff = usageCount[typeB.name] - usageCount[typeA.name];
+
+      if (usageCountDiff !== 0) {
+        return usageCountDiff;
+      } // Suggest super types first followed by subtypes
+
+      if (
+        (0, _definition.isInterfaceType)(typeA) &&
+        schema.isSubType(typeA, typeB)
+      ) {
+        return -1;
+      }
+
+      if (
+        (0, _definition.isInterfaceType)(typeB) &&
+        schema.isSubType(typeB, typeA)
+      ) {
+        return 1;
+      }
+
+      return (0, _naturalCompare.naturalCompare)(typeA.name, typeB.name);
+    })
+    .map((x) => x.name);
+}
+/**
+ * For the field name provided, determine if there are any similar field names
+ * that may be the result of a typo.
+ */
+
+function getSuggestedFieldNames(type, fieldName) {
+  if (
+    (0, _definition.isObjectType)(type) ||
+    (0, _definition.isInterfaceType)(type)
+  ) {
+    const possibleFieldNames = Object.keys(type.getFields());
+    return (0, _suggestionList.suggestionList)(fieldName, possibleFieldNames);
+  } // Otherwise, must be a Union type, which does not define fields.
+
+  return [];
+}