@aws-amplify/graphql-api-construct 1.1.0

package/node_modules/graphql/validation/index.js.flow

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

package/node_modules/graphql/validation/index.mjs

@@ -0,0 +1,67 @@
+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 { 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/node_modules/graphql/validation/rules/ExecutableDefinitions.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @deprecated and will be removed in v16
+ * Please use either:
+ *   import { ExecutableDefinitionsRule } from 'graphql'
+ * or
+ *   import { ExecutableDefinitionsRule } from 'graphql/validation'
+ */
+export { ExecutableDefinitionsRule as ExecutableDefinitions } from './ExecutableDefinitionsRule';

package/node_modules/graphql/validation/rules/ExecutableDefinitions.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ExecutableDefinitions", {
+  enumerable: true,
+  get: function get() {
+    return _ExecutableDefinitionsRule.ExecutableDefinitionsRule;
+  }
+});
+
+var _ExecutableDefinitionsRule = require("./ExecutableDefinitionsRule.js");

package/node_modules/graphql/validation/rules/ExecutableDefinitions.js.flow

@@ -0,0 +1,9 @@
+// @flow strict
+/**
+ * @deprecated and will be removed in v16
+ * Please use either:
+ *   import { ExecutableDefinitionsRule } from 'graphql'
+ * or
+ *   import { ExecutableDefinitionsRule } from 'graphql/validation'
+ */
+export { ExecutableDefinitionsRule as ExecutableDefinitions } from './ExecutableDefinitionsRule';

package/node_modules/graphql/validation/rules/ExecutableDefinitions.mjs

@@ -0,0 +1,8 @@
+/**
+ * @deprecated and will be removed in v16
+ * Please use either:
+ *   import { ExecutableDefinitionsRule } from 'graphql'
+ * or
+ *   import { ExecutableDefinitionsRule } from 'graphql/validation'
+ */
+export { ExecutableDefinitionsRule as ExecutableDefinitions } from "./ExecutableDefinitionsRule.mjs";

package/node_modules/graphql/validation/rules/ExecutableDefinitionsRule.d.ts

@@ -0,0 +1,12 @@
+import { ASTVisitor } from '../../language/visitor';
+import { ASTValidationContext } from '../ValidationContext';
+
+/**
+ * Executable definitions
+ *
+ * A GraphQL document is only valid for execution if all definitions are either
+ * operation or fragment definitions.
+ */
+export function ExecutableDefinitionsRule(
+  context: ASTValidationContext,
+): ASTVisitor;

package/node_modules/graphql/validation/rules/ExecutableDefinitionsRule.js

@@ -0,0 +1,35 @@
+"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.
+ */
+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 (!(0, _predicates.isExecutableDefinitionNode)(definition)) {
+          var defName = definition.kind === _kinds.Kind.SCHEMA_DEFINITION || definition.kind === _kinds.Kind.SCHEMA_EXTENSION ? 'schema' : '"' + definition.name.value + '"';
+          context.reportError(new _GraphQLError.GraphQLError("The ".concat(defName, " definition is not executable."), definition));
+        }
+      }
+
+      return false;
+    }
+  };
+}

package/node_modules/graphql/validation/rules/ExecutableDefinitionsRule.js.flow

@@ -0,0 +1,39 @@
+// @flow strict
+import { GraphQLError } from '../../error/GraphQLError';
+
+import type { ASTVisitor } from '../../language/visitor';
+import { Kind } from '../../language/kinds';
+import { isExecutableDefinitionNode } from '../../language/predicates';
+
+import type { ASTValidationContext } from '../ValidationContext';
+
+/**
+ * Executable definitions
+ *
+ * A GraphQL document is only valid for execution if all definitions are either
+ * operation or fragment definitions.
+ */
+export function ExecutableDefinitionsRule(
+  context: ASTValidationContext,
+): ASTVisitor {
+  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/node_modules/graphql/validation/rules/ExecutableDefinitionsRule.mjs

@@ -0,0 +1,26 @@
+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.
+ */
+export 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;
+    }
+  };
+}

package/node_modules/graphql/validation/rules/FieldsOnCorrectTypeRule.d.ts

@@ -0,0 +1,10 @@
+import { ASTVisitor } from '../../language/visitor';
+import { 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.
+ */
+export function FieldsOnCorrectTypeRule(context: ValidationContext): ASTVisitor;

package/node_modules/graphql/validation/rules/FieldsOnCorrectTypeRule.js

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FieldsOnCorrectTypeRule = FieldsOnCorrectTypeRule;
+
+var _arrayFrom = _interopRequireDefault(require("../../polyfills/arrayFrom.js"));
+
+var _didYouMean = _interopRequireDefault(require("../../jsutils/didYouMean.js"));
+
+var _suggestionList = _interopRequireDefault(require("../../jsutils/suggestionList.js"));
+
+var _naturalCompare = _interopRequireDefault(require("../../jsutils/naturalCompare.js"));
+
+var _GraphQLError = require("../../error/GraphQLError.js");
+
+var _definition = require("../../type/definition.js");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 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();
+
+        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.
+
+          var suggestion = (0, _didYouMean.default)('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.default)(getSuggestedFieldNames(type, fieldName));
+          } // Report an error, including helpful suggestions.
+
+
+          context.reportError(new _GraphQLError.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.
+ */
+
+
+function getSuggestedTypeNames(schema, type, fieldName) {
+  if (!(0, _definition.isAbstractType)(type)) {
+    // Must be an Object type, which does not have possible fields.
+    return [];
+  }
+
+  var suggestedTypes = new Set();
+  var usageCount = Object.create(null);
+
+  for (var _i2 = 0, _schema$getPossibleTy2 = schema.getPossibleTypes(type); _i2 < _schema$getPossibleTy2.length; _i2++) {
+    var possibleType = _schema$getPossibleTy2[_i2];
+
+    if (!possibleType.getFields()[fieldName]) {
+      continue;
+    } // This object type defines this field.
+
+
+    suggestedTypes.add(possibleType);
+    usageCount[possibleType.name] = 1;
+
+    for (var _i4 = 0, _possibleType$getInte2 = possibleType.getInterfaces(); _i4 < _possibleType$getInte2.length; _i4++) {
+      var _usageCount$possibleI;
+
+      var possibleInterface = _possibleType$getInte2[_i4];
+
+      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 (0, _arrayFrom.default)(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
+
+
+    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.default)(typeA.name, typeB.name);
+  }).map(function (x) {
+    return 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)) {
+    var possibleFieldNames = Object.keys(type.getFields());
+    return (0, _suggestionList.default)(fieldName, possibleFieldNames);
+  } // Otherwise, must be a Union type, which does not define fields.
+
+
+  return [];
+}

package/node_modules/graphql/validation/rules/FieldsOnCorrectTypeRule.js.flow

@@ -0,0 +1,146 @@
+// @flow strict
+import arrayFrom from '../../polyfills/arrayFrom';
+
+import didYouMean from '../../jsutils/didYouMean';
+import suggestionList from '../../jsutils/suggestionList';
+import naturalCompare from '../../jsutils/naturalCompare';
+
+import { GraphQLError } from '../../error/GraphQLError';
+
+import type { FieldNode } from '../../language/ast';
+import type { ASTVisitor } from '../../language/visitor';
+
+import type { GraphQLSchema } from '../../type/schema';
+import type {
+  GraphQLOutputType,
+  GraphQLObjectType,
+  GraphQLInterfaceType,
+} from '../../type/definition';
+import {
+  isObjectType,
+  isInterfaceType,
+  isAbstractType,
+} from '../../type/definition';
+
+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.
+ */
+export function FieldsOnCorrectTypeRule(
+  context: ValidationContext,
+): ASTVisitor {
+  return {
+    Field(node: FieldNode) {
+      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 = 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 = didYouMean(getSuggestedFieldNames(type, fieldName));
+          }
+
+          // Report an error, including helpful suggestions.
+          context.reportError(
+            new 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: GraphQLSchema,
+  type: GraphQLOutputType,
+  fieldName: string,
+): Array<string> {
+  if (!isAbstractType(type)) {
+    // Must be an Object type, which does not have possible fields.
+    return [];
+  }
+
+  const suggestedTypes: Set<
+    GraphQLObjectType | GraphQLInterfaceType,
+  > = 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()) {
+      if (!possibleInterface.getFields()[fieldName]) {
+        continue;
+      }
+
+      // This interface type defines this field.
+      suggestedTypes.add(possibleInterface);
+      usageCount[possibleInterface.name] =
+        (usageCount[possibleInterface.name] ?? 0) + 1;
+    }
+  }
+
+  return arrayFrom(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 (isInterfaceType(typeA) && schema.isSubType(typeA, typeB)) {
+        return -1;
+      }
+      if (isInterfaceType(typeB) && schema.isSubType(typeB, typeA)) {
+        return 1;
+      }
+
+      return 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: GraphQLOutputType,
+  fieldName: string,
+): Array<string> {
+  if (isObjectType(type) || isInterfaceType(type)) {
+    const possibleFieldNames = Object.keys(type.getFields());
+    return suggestionList(fieldName, possibleFieldNames);
+  }
+  // Otherwise, must be a Union type, which does not define fields.
+  return [];
+}