@graphql-eslint/eslint-plugin 3.8.0 → 3.9.0

package/index.mjs

@@ -1,10 +1,11 @@
-import { Kind, validate, TypeInfo, visitWithTypeInfo, visit, TokenKind, isScalarType, isNonNullType, isListType, isObjectType as isObjectType$1, GraphQLObjectType, GraphQLInterfaceType, isInterfaceType, Source, GraphQLError } from 'graphql';
+import { Kind, visit, validate, TypeInfo, visitWithTypeInfo, TokenKind, isScalarType, isInterfaceType, isNonNullType, isListType, isObjectType as isObjectType$1, GraphQLObjectType, GraphQLInterfaceType, Source, GraphQLError } from 'graphql';
 import { validateSDL } from 'graphql/validation/validate';
 import { statSync, existsSync, readFileSync } from 'fs';
 import { dirname, extname, basename, relative, resolve } from 'path';
 import { asArray, parseGraphQLSDL } from '@graphql-tools/utils';
 import lowerCase from 'lodash.lowercase';
 import chalk from 'chalk';
+import { valueFromASTUntyped } from 'graphql/utilities/valueFromASTUntyped';
 import depthLimit from 'graphql-depth-limit';
 import { parseCode } from '@graphql-tools/graphql-tag-pluck';
 import { loadConfigSync, GraphQLConfig } from 'graphql-config';
@@ -12,163 +13,6 @@ import { CodeFileLoader } from '@graphql-tools/code-file-loader';
 import { RuleTester, Linter } from 'eslint';
 import { codeFrameColumns } from '@babel/code-frame';
 
-const base = {
-    parser: '@graphql-eslint/eslint-plugin',
-    plugins: ['@graphql-eslint'],
-};
-
-/*
- * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
- */
-const schemaRecommendedConfig = {
-    extends: ['plugin:@graphql-eslint/base'],
-    rules: {
-        '@graphql-eslint/description-style': 'error',
-        '@graphql-eslint/known-argument-names': 'error',
-        '@graphql-eslint/known-directives': 'error',
-        '@graphql-eslint/known-type-names': 'error',
-        '@graphql-eslint/lone-schema-definition': 'error',
-        '@graphql-eslint/naming-convention': [
-            'error',
-            {
-                types: 'PascalCase',
-                FieldDefinition: 'camelCase',
-                InputValueDefinition: 'camelCase',
-                Argument: 'camelCase',
-                DirectiveDefinition: 'camelCase',
-                EnumValueDefinition: 'UPPER_CASE',
-                'FieldDefinition[parent.name.value=Query]': {
-                    forbiddenPrefixes: ['query', 'get'],
-                    forbiddenSuffixes: ['Query'],
-                },
-                'FieldDefinition[parent.name.value=Mutation]': {
-                    forbiddenPrefixes: ['mutation'],
-                    forbiddenSuffixes: ['Mutation'],
-                },
-                'FieldDefinition[parent.name.value=Subscription]': {
-                    forbiddenPrefixes: ['subscription'],
-                    forbiddenSuffixes: ['Subscription'],
-                },
-            },
-        ],
-        '@graphql-eslint/no-case-insensitive-enum-values-duplicates': 'error',
-        '@graphql-eslint/no-hashtag-description': 'error',
-        '@graphql-eslint/no-typename-prefix': 'error',
-        '@graphql-eslint/no-unreachable-types': 'error',
-        '@graphql-eslint/provided-required-arguments': 'error',
-        '@graphql-eslint/require-deprecation-reason': 'error',
-        '@graphql-eslint/require-description': ['error', { types: true, DirectiveDefinition: true }],
-        '@graphql-eslint/strict-id-in-types': 'error',
-        '@graphql-eslint/unique-directive-names': 'error',
-        '@graphql-eslint/unique-directive-names-per-location': 'error',
-        '@graphql-eslint/unique-field-definition-names': 'error',
-        '@graphql-eslint/unique-operation-types': 'error',
-        '@graphql-eslint/unique-type-names': 'error',
-    },
-};
-
-/*
- * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
- */
-const schemaAllConfig = {
-    extends: ['plugin:@graphql-eslint/base', 'plugin:@graphql-eslint/schema-recommended'],
-    rules: {
-        '@graphql-eslint/alphabetize': [
-            'error',
-            {
-                fields: ['ObjectTypeDefinition', 'InterfaceTypeDefinition', 'InputObjectTypeDefinition'],
-                values: ['EnumTypeDefinition'],
-                arguments: ['FieldDefinition', 'Field', 'DirectiveDefinition', 'Directive'],
-            },
-        ],
-        '@graphql-eslint/input-name': 'error',
-        '@graphql-eslint/no-scalar-result-type-on-mutation': 'error',
-        '@graphql-eslint/require-deprecation-date': 'error',
-        '@graphql-eslint/require-field-of-type-query-in-mutation-result': 'error',
-    },
-};
-
-/*
- * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
- */
-const operationsRecommendedConfig = {
-    extends: ['plugin:@graphql-eslint/base'],
-    rules: {
-        '@graphql-eslint/executable-definitions': 'error',
-        '@graphql-eslint/fields-on-correct-type': 'error',
-        '@graphql-eslint/fragments-on-composite-type': 'error',
-        '@graphql-eslint/known-argument-names': 'error',
-        '@graphql-eslint/known-directives': 'error',
-        '@graphql-eslint/known-fragment-names': 'error',
-        '@graphql-eslint/known-type-names': 'error',
-        '@graphql-eslint/lone-anonymous-operation': 'error',
-        '@graphql-eslint/naming-convention': [
-            'error',
-            {
-                VariableDefinition: 'camelCase',
-                OperationDefinition: {
-                    style: 'PascalCase',
-                    forbiddenPrefixes: ['Query', 'Mutation', 'Subscription', 'Get'],
-                    forbiddenSuffixes: ['Query', 'Mutation', 'Subscription'],
-                },
-                FragmentDefinition: { style: 'PascalCase', forbiddenPrefixes: ['Fragment'], forbiddenSuffixes: ['Fragment'] },
-            },
-        ],
-        '@graphql-eslint/no-anonymous-operations': 'error',
-        '@graphql-eslint/no-deprecated': 'error',
-        '@graphql-eslint/no-duplicate-fields': 'error',
-        '@graphql-eslint/no-fragment-cycles': 'error',
-        '@graphql-eslint/no-undefined-variables': 'error',
-        '@graphql-eslint/no-unused-fragments': 'error',
-        '@graphql-eslint/no-unused-variables': 'error',
-        '@graphql-eslint/one-field-subscriptions': 'error',
-        '@graphql-eslint/overlapping-fields-can-be-merged': 'error',
-        '@graphql-eslint/possible-fragment-spread': 'error',
-        '@graphql-eslint/provided-required-arguments': 'error',
-        '@graphql-eslint/require-id-when-available': 'error',
-        '@graphql-eslint/scalar-leafs': 'error',
-        '@graphql-eslint/selection-set-depth': ['error', { maxDepth: 7 }],
-        '@graphql-eslint/unique-argument-names': 'error',
-        '@graphql-eslint/unique-directive-names-per-location': 'error',
-        '@graphql-eslint/unique-input-field-names': 'error',
-        '@graphql-eslint/unique-variable-names': 'error',
-        '@graphql-eslint/value-literals-of-correct-type': 'error',
-        '@graphql-eslint/variables-are-input-types': 'error',
-        '@graphql-eslint/variables-in-allowed-position': 'error',
-    },
-};
-
-/*
- * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
- */
-const operationsAllConfig = {
-    extends: ['plugin:@graphql-eslint/base', 'plugin:@graphql-eslint/operations-recommended'],
-    rules: {
-        '@graphql-eslint/alphabetize': [
-            'error',
-            {
-                selections: ['OperationDefinition', 'FragmentDefinition'],
-                variables: ['OperationDefinition'],
-                arguments: ['Field', 'Directive'],
-            },
-        ],
-        '@graphql-eslint/match-document-filename': [
-            'error',
-            { query: 'kebab-case', mutation: 'kebab-case', subscription: 'kebab-case', fragment: 'kebab-case' },
-        ],
-        '@graphql-eslint/unique-fragment-name': 'error',
-        '@graphql-eslint/unique-operation-name': 'error',
-    },
-};
-
-const configs = {
-    base,
-    'schema-recommended': schemaRecommendedConfig,
-    'schema-all': schemaAllConfig,
-    'operations-recommended': operationsRecommendedConfig,
-    'operations-all': operationsAllConfig,
-};
-
 function requireSiblingsOperations(ruleName, context) {
     if (!context.parserServices) {
         throw new Error(`Rule '${ruleName}' requires 'parserOptions.operations' to be set and loaded. See http://bit.ly/graphql-eslint-operations for more info`);
@@ -193,15 +37,6 @@ const logger = {
     // eslint-disable-next-line no-console
     warn: (...args) => console.warn(chalk.yellow('warning'), '[graphql-eslint]', chalk(...args)),
 };
-function requireReachableTypesFromContext(ruleName, context) {
-    const schema = requireGraphQLSchemaFromContext(ruleName, context);
-    return context.parserServices.reachableTypes(schema);
-}
-function requireUsedFieldsFromContext(ruleName, context) {
-    const schema = requireGraphQLSchemaFromContext(ruleName, context);
-    const siblings = requireSiblingsOperations(ruleName, context);
-    return context.parserServices.usedFields(schema, siblings);
-}
 const normalizePath = (path) => (path || '').replace(/\\/g, '/');
 /**
  * https://github.com/prettier/eslint-plugin-prettier/blob/76bd45ece6d56eb52f75db6b4a1efdd2efb56392/eslint-plugin-prettier.js#L71
@@ -271,8 +106,8 @@ const convertCase = (style, str) => {
             return lowerCase(str).replace(/ /g, '-');
     }
 };
-function getLocation(loc, fieldName = '') {
-    const { line, column } = loc.start;
+function getLocation(start, fieldName = '') {
+    const { line, column } = start;
     return {
         start: {
             line,
@@ -284,6 +119,15 @@ function getLocation(loc, fieldName = '') {
         },
     };
 }
+const REPORT_ON_FIRST_CHARACTER = { column: 0, line: 1 };
+const ARRAY_DEFAULT_OPTIONS = {
+    type: 'array',
+    uniqueItems: true,
+    minItems: 1,
+    items: {
+        type: 'string',
+    },
+};
 
 function validateDocument(context, schema = null, documentNode, rule) {
     if (documentNode.definitions.length === 0) {
@@ -295,23 +139,27 @@ function validateDocument(context, schema = null, documentNode, rule) {
             : validateSDL(documentNode, null, [rule]);
         for (const error of validationErrors) {
             const { line, column } = error.locations[0];
-            const ancestors = context.getAncestors();
-            const token = ancestors[0].tokens.find(token => token.loc.start.line === line && token.loc.start.column === column - 1);
+            const sourceCode = context.getSourceCode();
+            const { tokens } = sourceCode.ast;
+            const token = tokens.find(token => token.loc.start.line === line && token.loc.start.column === column - 1);
+            let loc = {
+                line,
+                column: column - 1,
+            };
+            if (token) {
+                loc =
+                    // if cursor on `@` symbol than use next node
+                    token.type === '@' ? sourceCode.getNodeByRangeIndex(token.range[1] + 1).loc : token.loc;
+            }
             context.report({
-                loc: token
-                    ? token.loc
-                    : {
-                        line,
-                        column: column - 1,
-                    },
+                loc,
                 message: error.message,
             });
         }
     }
     catch (e) {
         context.report({
-            // Report on first character
-            loc: { column: 0, line: 1 },
+            loc: REPORT_ON_FIRST_CHARACTER,
             message: e.message,
         });
     }
@@ -368,7 +216,7 @@ const handleMissingFragments = ({ ruleId, context, schema, node }) => {
     }
     return node;
 };
-const validationToRule = (ruleId, ruleName, docs, getDocumentNode) => {
+const validationToRule = (ruleId, ruleName, docs, getDocumentNode, schema = []) => {
     let ruleFn = null;
     try {
         ruleFn = require(`graphql/validation/rules/${ruleName}Rule`)[`${ruleName}Rule`];
@@ -389,8 +237,9 @@ const validationToRule = (ruleId, ruleName, docs, getDocumentNode) => {
                     ...docs,
                     graphQLJSRuleName: ruleName,
                     url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${ruleId}.md`,
-                    description: `${docs.description}\n\n> This rule is a wrapper around a \`graphql-js\` validation function. [You can find its source code here](https://github.com/graphql/graphql-js/blob/main/src/validation/rules/${ruleName}Rule.ts).`,
+                    description: `${docs.description}\n\n> This rule is a wrapper around a \`graphql-js\` validation function.`,
                 },
+                schema,
             },
             create(context) {
                 if (!ruleFn) {
@@ -428,8 +277,45 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
     requiresSchema: true,
 }), validationToRule('known-directives', 'KnownDirectives', {
     category: ['Schema', 'Operations'],
-    description: `A GraphQL document is only valid if all \`@directives\` are known by the schema and legally positioned.`,
+    description: `A GraphQL document is only valid if all \`@directive\`s are known by the schema and legally positioned.`,
     requiresSchema: true,
+    examples: [
+        {
+            title: 'Valid',
+            usage: [{ ignoreClientDirectives: ['client'] }],
+            code: /* GraphQL */ `
+            {
+              product {
+                someClientField @client
+              }
+            }
+          `,
+        },
+    ],
+}, ({ context, node: documentNode }) => {
+    const { ignoreClientDirectives = [] } = context.options[0] || {};
+    if (ignoreClientDirectives.length === 0) {
+        return documentNode;
+    }
+    return visit(documentNode, {
+        Field(node) {
+            return {
+                ...node,
+                directives: node.directives.filter(directive => !ignoreClientDirectives.includes(directive.name.value)),
+            };
+        },
+    });
+}, {
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['ignoreClientDirectives'],
+        properties: {
+            ignoreClientDirectives: ARRAY_DEFAULT_OPTIONS,
+        },
+    },
 }), validationToRule('known-fragment-names', 'KnownFragmentNames', {
     category: 'Operations',
     description: `A GraphQL document is only valid if all \`...Fragment\` fragment spreads refer to fragments defined in the same document.`,
@@ -553,8 +439,10 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
 }), validationToRule('possible-type-extension', 'PossibleTypeExtensions', {
     category: 'Schema',
     description: `A type extension is only valid if the type is defined and has the same kind.`,
+    // TODO: add in graphql-eslint v4
     recommended: false,
     requiresSchema: true,
+    isDisabledForAllConfig: true,
 }), validationToRule('provided-required-arguments', 'ProvidedRequiredArguments', {
     category: ['Schema', 'Operations'],
     description: `A field or directive is only valid if all required (non-null without a default value) field arguments have been provided.`,
@@ -582,6 +470,7 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
     category: 'Schema',
     description: `A GraphQL enum type is only valid if all its values are uniquely named.`,
     recommended: false,
+    isDisabledForAllConfig: true,
 }), validationToRule('unique-field-definition-names', 'UniqueFieldDefinitionNames', {
     category: 'Schema',
     description: `A GraphQL complex type is only valid if all its fields are uniquely named.`,
@@ -612,7 +501,7 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
     requiresSchema: true,
 }));
 
-const ALPHABETIZE = 'ALPHABETIZE';
+const RULE_ID = 'alphabetize';
 const fieldsEnum = [
     Kind.OBJECT_TYPE_DEFINITION,
     Kind.INTERFACE_TYPE_DEFINITION,
@@ -637,7 +526,7 @@ const rule = {
         docs: {
             category: ['Schema', 'Operations'],
             description: `Enforce arrange in alphabetical order for type fields, enum values, input object fields, operation selections and more.`,
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/alphabetize.md',
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
             examples: [
                 {
                     title: 'Incorrect',
@@ -720,6 +609,8 @@ const rule = {
                         fields: fieldsEnum,
                         values: valuesEnum,
                         arguments: argumentsEnum,
+                        // TODO: add in graphql-eslint v4
+                        // definitions: true,
                     },
                 ],
                 operations: [
@@ -732,7 +623,7 @@ const rule = {
             },
         },
         messages: {
-            [ALPHABETIZE]: '"{{ currName }}" should be before "{{ prevName }}"',
+            [RULE_ID]: '`{{ currName }}` should be before {{ prevName }}.',
         },
         schema: {
             type: 'array',
@@ -744,49 +635,44 @@ const rule = {
                 minProperties: 1,
                 properties: {
                     fields: {
-                        type: 'array',
-                        uniqueItems: true,
-                        minItems: 1,
+                        ...ARRAY_DEFAULT_OPTIONS,
                         items: {
                             enum: fieldsEnum,
                         },
-                        description: 'Fields of `type`, `interface`, and `input`',
+                        description: 'Fields of `type`, `interface`, and `input`.',
                     },
                     values: {
-                        type: 'array',
-                        uniqueItems: true,
-                        minItems: 1,
+                        ...ARRAY_DEFAULT_OPTIONS,
                         items: {
                             enum: valuesEnum,
                         },
-                        description: 'Values of `enum`',
+                        description: 'Values of `enum`.',
                     },
                     selections: {
-                        type: 'array',
-                        uniqueItems: true,
-                        minItems: 1,
+                        ...ARRAY_DEFAULT_OPTIONS,
                         items: {
                             enum: selectionsEnum,
                         },
-                        description: 'Selections of operations (`query`, `mutation` and `subscription`) and `fragment`',
+                        description: 'Selections of `fragment` and operations `query`, `mutation` and `subscription`.',
                     },
                     variables: {
-                        type: 'array',
-                        uniqueItems: true,
-                        minItems: 1,
+                        ...ARRAY_DEFAULT_OPTIONS,
                         items: {
                             enum: variablesEnum,
                         },
-                        description: 'Variables of operations (`query`, `mutation` and `subscription`)',
+                        description: 'Variables of operations `query`, `mutation` and `subscription`.',
                     },
                     arguments: {
-                        type: 'array',
-                        uniqueItems: true,
-                        minItems: 1,
+                        ...ARRAY_DEFAULT_OPTIONS,
                         items: {
                             enum: argumentsEnum,
                         },
-                        description: 'Arguments of fields and directives',
+                        description: 'Arguments of fields and directives.',
+                    },
+                    definitions: {
+                        type: 'boolean',
+                        description: 'Definitions – `type`, `interface`, `enum`, `scalar`, `input`, `union` and `directive`.',
+                        default: false,
                     },
                 },
             },
@@ -807,9 +693,22 @@ const rule = {
             if (tokenBefore) {
                 return commentsBefore.filter(comment => !isNodeAndCommentOnSameLine(tokenBefore, comment));
             }
-            return commentsBefore;
+            const filteredComments = [];
+            const nodeLine = node.loc.start.line;
+            // Break on comment that not attached to node
+            for (let i = commentsBefore.length - 1; i >= 0; i -= 1) {
+                const comment = commentsBefore[i];
+                if (nodeLine - comment.loc.start.line - filteredComments.length > 1) {
+                    break;
+                }
+                filteredComments.unshift(comment);
+            }
+            return filteredComments;
         }
         function getRangeWithComments(node) {
+            if (node.kind === Kind.VARIABLE) {
+                node = node.parent;
+            }
             const [firstBeforeComment] = getBeforeComments(node);
             const [firstAfterComment] = sourceCode.getCommentsAfter(node);
             const from = firstBeforeComment || node;
@@ -817,26 +716,35 @@ const rule = {
             return [from.range[0], to.range[1]];
         }
         function checkNodes(nodes) {
+            var _a, _b;
             // Starts from 1, ignore nodes.length <= 1
             for (let i = 1; i < nodes.length; i += 1) {
-                const prevNode = nodes[i - 1];
                 const currNode = nodes[i];
-                const prevName = prevNode.name.value;
-                const currName = currNode.name.value;
-                // Compare with lexicographic order
-                if (prevName.localeCompare(currName) !== 1) {
+                const currName = 'name' in currNode && ((_a = currNode.name) === null || _a === void 0 ? void 0 : _a.value);
+                if (!currName) {
+                    // we don't move unnamed current nodes
                     continue;
                 }
-                const isVariableNode = currNode.kind === Kind.VARIABLE;
+                const prevNode = nodes[i - 1];
+                const prevName = 'name' in prevNode && ((_b = prevNode.name) === null || _b === void 0 ? void 0 : _b.value);
+                if (prevName) {
+                    // Compare with lexicographic order
+                    const compareResult = prevName.localeCompare(currName);
+                    const shouldSort = compareResult === 1;
+                    if (!shouldSort) {
+                        const isSameName = compareResult === 0;
+                        if (!isSameName || !prevNode.kind.endsWith('Extension') || currNode.kind.endsWith('Extension')) {
+                            continue;
+                        }
+                    }
+                }
                 context.report({
                     node: currNode.name,
-                    messageId: ALPHABETIZE,
-                    data: isVariableNode
-                        ? {
-                            currName: `$${currName}`,
-                            prevName: `$${prevName}`,
-                        }
-                        : { currName, prevName },
+                    messageId: RULE_ID,
+                    data: {
+                        currName,
+                        prevName: prevName ? `\`${prevName}\`` : lowerCase(prevNode.kind),
+                    },
                     *fix(fixer) {
                         const prevRange = getRangeWithComments(prevNode);
                         const currRange = getRangeWithComments(currNode);
@@ -877,10 +785,7 @@ const rule = {
         }
         if (selectionsSelector) {
             listeners[`:matches(${selectionsSelector}) SelectionSet`] = (node) => {
-                checkNodes(node.selections
-                    // inline fragment don't have name, so we skip them
-                    .filter(selection => selection.kind !== Kind.INLINE_FRAGMENT)
-                    .map(selection => 
+                checkNodes(node.selections.map(selection => 
                 // sort by alias is field is renamed
                 'alias' in selection && selection.alias ? { name: selection.alias } : selection));
             };
@@ -895,6 +800,11 @@ const rule = {
                 checkNodes(node.arguments);
             };
         }
+        if (opts.definitions) {
+            listeners.Document = node => {
+                checkNodes(node.definitions);
+            };
+        }
         return listeners;
     },
 };
@@ -902,6 +812,7 @@ const rule = {
 const rule$1 = {
     meta: {
         type: 'suggestion',
+        hasSuggestions: true,
         docs: {
             examples: [
                 {
@@ -949,8 +860,21 @@ const rule$1 = {
         return {
             [`.description[type=StringValue][block!=${isBlock}]`](node) {
                 context.report({
-                    loc: getLocation(node.loc),
-                    message: `Unexpected ${isBlock ? 'inline' : 'block'} description`,
+                    loc: isBlock ? node.loc : node.loc.start,
+                    message: `Unexpected ${isBlock ? 'inline' : 'block'} description.`,
+                    suggest: [
+                        {
+                            desc: `Change to ${isBlock ? 'block' : 'inline'} style description`,
+                            fix(fixer) {
+                                const sourceCode = context.getSourceCode();
+                                const originalText = sourceCode.getText(node);
+                                const newText = isBlock
+                                    ? originalText.replace(/(^")|("$)/g, '"""')
+                                    : originalText.replace(/(^""")|("""$)/g, '"').replace(/\s+/g, ' ');
+                                return fixer.replaceText(node, newText);
+                            },
+                        },
+                    ],
                 });
             },
         };
@@ -963,6 +887,7 @@ const isMutationType = (node) => isObjectType(node) && node.name.value === 'Muta
 const rule$2 = {
     meta: {
         type: 'suggestion',
+        hasSuggestions: true,
         docs: {
             description: 'Require mutation argument to be always called "input" and input type to be called Mutation name + "Input".\nUsing the same name for all input parameters will make your schemas easier to consume and more predictable. Using the same name as mutation for InputType will make it easier to find mutations that InputType belongs to.',
             category: 'Schema',
@@ -1036,12 +961,18 @@ const rule$2 = {
         };
         const shouldCheckType = node => (options.checkMutations && isMutationType(node)) || (options.checkQueries && isQueryType(node));
         const listeners = {
-            'FieldDefinition > InputValueDefinition[name.value!=input]'(node) {
-                if (shouldCheckType(node.parent.parent)) {
-                    const name = node.name.value;
+            'FieldDefinition > InputValueDefinition[name.value!=input] > Name'(node) {
+                if (shouldCheckType(node.parent.parent.parent)) {
+                    const inputName = node.value;
                     context.report({
-                        node: node.name,
-                        message: `Input "${name}" should be called "input"`,
+                        node,
+                        message: `Input \`${inputName}\` should be called \`input\`.`,
+                        suggest: [
+                            {
+                                desc: 'Rename to `input`',
+                                fix: fixer => fixer.replaceText(node, 'input'),
+                            },
+                        ],
                     });
                 }
             },
@@ -1063,7 +994,13 @@ const rule$2 = {
                         name.toLowerCase() !== mutationName.toLowerCase()) {
                         context.report({
                             node: node.name,
-                            message: `InputType "${name}" name should be "${mutationName}"`,
+                            message: `Input type \`${name}\` name should be \`${mutationName}\`.`,
+                            suggest: [
+                                {
+                                    desc: `Rename to \`${mutationName}\``,
+                                    fix: fixer => fixer.replaceText(node, mutationName),
+                                },
+                            ],
                         });
                     }
                 }
@@ -1076,7 +1013,14 @@ const rule$2 = {
 const MATCH_EXTENSION = 'MATCH_EXTENSION';
 const MATCH_STYLE = 'MATCH_STYLE';
 const ACCEPTED_EXTENSIONS = ['.gql', '.graphql'];
-const CASE_STYLES = ['camelCase', 'PascalCase', 'snake_case', 'UPPER_CASE', 'kebab-case', 'matchDocumentStyle'];
+const CASE_STYLES = [
+    'camelCase',
+    'PascalCase',
+    'snake_case',
+    'UPPER_CASE',
+    'kebab-case',
+    'matchDocumentStyle',
+];
 const schemaOption = {
     oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
 };
@@ -1221,8 +1165,7 @@ const rule$3 = {
                 var _a;
                 if (options.fileExtension && options.fileExtension !== fileExtension) {
                     context.report({
-                        // Report on first character
-                        loc: { column: 0, line: 1 },
+                        loc: REPORT_ON_FIRST_CHARACTER,
                         messageId: MATCH_EXTENSION,
                         data: {
                             fileExtension,
@@ -1261,8 +1204,7 @@ const rule$3 = {
                 const filenameWithExtension = filename + expectedExtension;
                 if (expectedFilename !== filenameWithExtension) {
                     context.report({
-                        // Report on first character
-                        loc: { column: 0, line: 1 },
+                        loc: REPORT_ON_FIRST_CHARACTER,
                         messageId: MATCH_STYLE,
                         data: {
                             expectedFilename,
@@ -1434,18 +1376,8 @@ const rule$4 = {
                         style: { enum: ALLOWED_STYLES },
                         prefix: { type: 'string' },
                         suffix: { type: 'string' },
-                        forbiddenPrefixes: {
-                            type: 'array',
-                            uniqueItems: true,
-                            minItems: 1,
-                            items: { type: 'string' },
-                        },
-                        forbiddenSuffixes: {
-                            type: 'array',
-                            uniqueItems: true,
-                            minItems: 1,
-                            items: { type: 'string' },
-                        },
+                        forbiddenPrefixes: ARRAY_DEFAULT_OPTIONS,
+                        forbiddenSuffixes: ARRAY_DEFAULT_OPTIONS,
                         ignorePattern: {
                             type: 'string',
                             description: 'Option to skip validation of some words, e.g. acronyms',
@@ -1499,6 +1431,18 @@ const rule$4 = {
             const style = restOptions[kind] || types;
             return typeof style === 'object' ? style : { style };
         }
+        function report(node, message, suggestedName) {
+            context.report({
+                node,
+                message,
+                suggest: [
+                    {
+                        desc: `Rename to \`${suggestedName}\``,
+                        fix: fixer => fixer.replaceText(node, suggestedName),
+                    },
+                ],
+            });
+        }
         const checkNode = (selector) => (n) => {
             const { name: node } = n.kind === Kind.VARIABLE_DEFINITION ? n.variable : n;
             if (!node) {
@@ -1513,16 +1457,7 @@ const rule$4 = {
                 const [leadingUnderscores] = nodeName.match(/^_*/);
                 const [trailingUnderscores] = nodeName.match(/_*$/);
                 const suggestedName = leadingUnderscores + renameToName + trailingUnderscores;
-                context.report({
-                    node,
-                    message: `${nodeType} "${nodeName}" should ${errorMessage}`,
-                    suggest: [
-                        {
-                            desc: `Rename to "${suggestedName}"`,
-                            fix: fixer => fixer.replaceText(node, suggestedName),
-                        },
-                    ],
-                });
+                report(node, `${nodeType} "${nodeName}" should ${errorMessage}`, suggestedName);
             }
             function getError() {
                 const name = nodeName.replace(/(^_+)|(_+$)/g, '');
@@ -1569,18 +1504,8 @@ const rule$4 = {
             }
         };
         const checkUnderscore = (isLeading) => (node) => {
-            const name = node.value;
-            const renameToName = name.replace(new RegExp(isLeading ? '^_+' : '_+$'), '');
-            context.report({
-                node,
-                message: `${isLeading ? 'Leading' : 'Trailing'} underscores are not allowed`,
-                suggest: [
-                    {
-                        desc: `Rename to "${renameToName}"`,
-                        fix: fixer => fixer.replaceText(node, renameToName),
-                    },
-                ],
-            });
+            const suggestedName = node.value.replace(isLeading ? /^_+/ : /_+$/, '');
+            report(node, `${isLeading ? 'Leading' : 'Trailing'} underscores are not allowed`, suggestedName);
         };
         const listeners = {};
         if (!allowLeadingUnderscore) {
@@ -1599,15 +1524,16 @@ const rule$4 = {
     },
 };
 
-const NO_ANONYMOUS_OPERATIONS = 'NO_ANONYMOUS_OPERATIONS';
+const RULE_ID$1 = 'no-anonymous-operations';
 const rule$5 = {
     meta: {
         type: 'suggestion',
+        hasSuggestions: true,
         docs: {
             category: 'Operations',
             description: 'Require name for your GraphQL operations. This is useful since most GraphQL client libraries are using the operation name for caching purposes.',
             recommended: true,
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-anonymous-operations.md',
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$1}.md`,
             examples: [
                 {
                     title: 'Incorrect',
@@ -1628,19 +1554,27 @@ const rule$5 = {
             ],
         },
         messages: {
-            [NO_ANONYMOUS_OPERATIONS]: `Anonymous GraphQL operations are forbidden. Please make sure to name your {{ operation }}!`,
+            [RULE_ID$1]: `Anonymous GraphQL operations are forbidden. Make sure to name your {{ operation }}!`,
         },
         schema: [],
     },
     create(context) {
         return {
             'OperationDefinition[name=undefined]'(node) {
+                const [firstSelection] = node.selectionSet.selections;
+                const suggestedName = firstSelection.type === Kind.FIELD ? (firstSelection.alias || firstSelection.name).value : node.operation;
                 context.report({
-                    loc: getLocation(node.loc, node.operation),
+                    loc: getLocation(node.loc.start, node.operation),
+                    messageId: RULE_ID$1,
                     data: {
                         operation: node.operation,
                     },
-                    messageId: NO_ANONYMOUS_OPERATIONS,
+                    suggest: [
+                        {
+                            desc: `Rename to \`${suggestedName}\``,
+                            fix: fixer => fixer.insertTextAfterRange([node.range[0], node.range[0] + node.operation.length], ` ${suggestedName}`),
+                        },
+                    ],
                 });
             },
         };
@@ -1650,6 +1584,7 @@ const rule$5 = {
 const rule$6 = {
     meta: {
         type: 'suggestion',
+        hasSuggestions: true,
         docs: {
             url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-case-insensitive-enum-values-duplicates.md`,
             category: 'Schema',
@@ -1689,7 +1624,13 @@ const rule$6 = {
                     const enumName = duplicate.name.value;
                     context.report({
                         node: duplicate.name,
-                        message: `Case-insensitive enum values duplicates are not allowed! Found: "${enumName}"`,
+                        message: `Case-insensitive enum values duplicates are not allowed! Found: \`${enumName}\`.`,
+                        suggest: [
+                            {
+                                desc: `Remove \`${enumName}\` enum value`,
+                                fix: fixer => fixer.remove(duplicate),
+                            },
+                        ],
                     });
                 }
             },
@@ -1697,14 +1638,15 @@ const rule$6 = {
     },
 };
 
-const NO_DEPRECATED = 'NO_DEPRECATED';
+const RULE_ID$2 = 'no-deprecated';
 const rule$7 = {
     meta: {
         type: 'suggestion',
+        hasSuggestions: true,
         docs: {
             category: 'Operations',
             description: `Enforce that deprecated fields or enum values are not in use by operations.`,
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-deprecated.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$2}.md`,
             requiresSchema: true,
             examples: [
                 {
@@ -1771,56 +1713,60 @@ const rule$7 = {
             recommended: true,
         },
         messages: {
-            [NO_DEPRECATED]: `This {{ type }} is marked as deprecated in your GraphQL schema {{ reason }}`,
+            [RULE_ID$2]: 'This {{ type }} is marked as deprecated in your GraphQL schema (reason: {{ reason }})',
         },
         schema: [],
     },
     create(context) {
+        requireGraphQLSchemaFromContext(RULE_ID$2, context);
+        function report(node, reason) {
+            const nodeName = node.type === Kind.ENUM ? node.value : node.name.value;
+            const nodeType = node.type === Kind.ENUM ? 'enum value' : 'field';
+            context.report({
+                node,
+                messageId: RULE_ID$2,
+                data: {
+                    type: nodeType,
+                    reason,
+                },
+                suggest: [
+                    {
+                        desc: `Remove \`${nodeName}\` ${nodeType}`,
+                        fix: fixer => fixer.remove(node),
+                    },
+                ],
+            });
+        }
         return {
             EnumValue(node) {
-                requireGraphQLSchemaFromContext('no-deprecated', context);
+                var _a;
                 const typeInfo = node.typeInfo();
-                if (typeInfo && typeInfo.enumValue) {
-                    if (typeInfo.enumValue.deprecationReason) {
-                        context.report({
-                            node,
-                            messageId: NO_DEPRECATED,
-                            data: {
-                                type: 'enum value',
-                                reason: typeInfo.enumValue.deprecationReason ? `(reason: ${typeInfo.enumValue.deprecationReason})` : '',
-                            },
-                        });
-                    }
+                const reason = (_a = typeInfo.enumValue) === null || _a === void 0 ? void 0 : _a.deprecationReason;
+                if (reason) {
+                    report(node, reason);
                 }
             },
             Field(node) {
-                requireGraphQLSchemaFromContext('no-deprecated', context);
+                var _a;
                 const typeInfo = node.typeInfo();
-                if (typeInfo && typeInfo.fieldDef) {
-                    if (typeInfo.fieldDef.deprecationReason) {
-                        context.report({
-                            node: node.name,
-                            messageId: NO_DEPRECATED,
-                            data: {
-                                type: 'field',
-                                reason: typeInfo.fieldDef.deprecationReason ? `(reason: ${typeInfo.fieldDef.deprecationReason})` : '',
-                            },
-                        });
-                    }
+                const reason = (_a = typeInfo.fieldDef) === null || _a === void 0 ? void 0 : _a.deprecationReason;
+                if (reason) {
+                    report(node, reason);
                 }
             },
         };
     },
 };
 
-const NO_DUPLICATE_FIELDS = 'NO_DUPLICATE_FIELDS';
+const RULE_ID$3 = 'no-duplicate-fields';
 const rule$8 = {
     meta: {
         type: 'suggestion',
+        hasSuggestions: true,
         docs: {
             description: `Checks for duplicate fields in selection set, variables in operation definition, or in arguments set of a field.`,
             category: 'Operations',
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-duplicate-fields.md',
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$3}.md`,
             recommended: true,
             examples: [
                 {
@@ -1866,21 +1812,30 @@ const rule$8 = {
             ],
         },
         messages: {
-            [NO_DUPLICATE_FIELDS]: `{{ type }} "{{ fieldName }}" defined multiple times`,
+            [RULE_ID$3]: '{{ type }} `{{ fieldName }}` defined multiple times.',
         },
         schema: [],
     },
     create(context) {
-        function checkNode(usedFields, type, node) {
+        function checkNode(usedFields, node) {
             const fieldName = node.value;
             if (usedFields.has(fieldName)) {
+                const { parent } = node;
                 context.report({
                     node,
-                    messageId: NO_DUPLICATE_FIELDS,
+                    messageId: RULE_ID$3,
                     data: {
-                        type,
+                        type: parent.type,
                         fieldName,
                     },
+                    suggest: [
+                        {
+                            desc: `Remove \`${fieldName}\` ${parent.type.toLowerCase()}`,
+                            fix(fixer) {
+                                return fixer.remove(parent.type === Kind.VARIABLE ? parent.parent : parent);
+                            },
+                        },
+                    ],
                 });
             }
             else {
@@ -1891,20 +1846,20 @@ const rule$8 = {
             OperationDefinition(node) {
                 const set = new Set();
                 for (const varDef of node.variableDefinitions) {
-                    checkNode(set, 'Operation variable', varDef.variable.name);
+                    checkNode(set, varDef.variable.name);
                 }
             },
             Field(node) {
                 const set = new Set();
                 for (const arg of node.arguments) {
-                    checkNode(set, 'Field argument', arg.name);
+                    checkNode(set, arg.name);
                 }
             },
             SelectionSet(node) {
                 const set = new Set();
                 for (const selection of node.selections) {
                     if (selection.kind === Kind.FIELD) {
-                        checkNode(set, 'Field', selection.alias || selection.name);
+                        checkNode(set, selection.alias || selection.name);
                     }
                 }
             },
@@ -1915,8 +1870,11 @@ const rule$8 = {
 const HASHTAG_COMMENT = 'HASHTAG_COMMENT';
 const rule$9 = {
     meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        schema: [],
         messages: {
-            [HASHTAG_COMMENT]: `Using hashtag (#) for adding GraphQL descriptions is not allowed. Prefer using """ for multiline, or " for a single line description.`,
+            [HASHTAG_COMMENT]: 'Using hashtag `#` for adding GraphQL descriptions is not allowed. Prefer using `"""` for multiline, or `"` for a single line description.',
         },
         docs: {
             description: 'Requires to use `"""` or `"` for adding a GraphQL description instead of `#`.\nAllows to use hashtag for comments, as long as it\'s not attached to an AST definition.',
@@ -1959,8 +1917,6 @@ const rule$9 = {
             ],
             recommended: true,
         },
-        type: 'suggestion',
-        schema: [],
     },
     create(context) {
         const selector = 'Document[definitions.0.kind!=/^(OperationDefinition|FragmentDefinition)$/]';
@@ -1968,7 +1924,7 @@ const rule$9 = {
             [selector](node) {
                 const rawNode = node.rawNode();
                 let token = rawNode.loc.startToken;
-                while (token !== null) {
+                while (token) {
                     const { kind, prev, next, value, line, column } = token;
                     if (kind === TokenKind.COMMENT && prev && next) {
                         const isEslintComment = value.trimStart().startsWith('eslint');
@@ -1980,6 +1936,10 @@ const rule$9 = {
                                     line,
                                     column: column - 1,
                                 },
+                                suggest: ['"""', '"'].map(descriptionSyntax => ({
+                                    desc: `Replace with \`${descriptionSyntax}\` description syntax`,
+                                    fix: fixer => fixer.replaceTextRange([token.start, token.end], [descriptionSyntax, value.trim(), descriptionSyntax].join('')),
+                                })),
                             });
                         }
                     }
@@ -1994,11 +1954,13 @@ const ROOT_TYPES = ['mutation', 'subscription'];
 const rule$a = {
     meta: {
         type: 'suggestion',
+        hasSuggestions: true,
         docs: {
             category: 'Schema',
             description: 'Disallow using root types `mutation` and/or `subscription`.',
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-root-type.md',
             requiresSchema: true,
+            isDisabledForAllConfig: true,
             examples: [
                 {
                     title: 'Incorrect',
@@ -2030,9 +1992,7 @@ const rule$a = {
                 required: ['disallow'],
                 properties: {
                     disallow: {
-                        type: 'array',
-                        uniqueItems: true,
-                        minItems: 1,
+                        ...ARRAY_DEFAULT_OPTIONS,
                         items: {
                             enum: ROOT_TYPES,
                         },
@@ -2054,29 +2014,37 @@ const rule$a = {
             return {};
         }
         const selector = [
-            `:matches(${Kind.OBJECT_TYPE_DEFINITION}, ${Kind.OBJECT_TYPE_EXTENSION})`,
+            `:matches(ObjectTypeDefinition, ObjectTypeExtension)`,
             '>',
-            `${Kind.NAME}[value=/^(${rootTypeNames.join('|')})$/]`,
+            `Name[value=/^(${rootTypeNames.join('|')})$/]`,
         ].join(' ');
         return {
             [selector](node) {
                 const typeName = node.value;
                 context.report({
                     node,
-                    message: `Root type "${typeName}" is forbidden`,
+                    message: `Root type \`${typeName}\` is forbidden.`,
+                    suggest: [
+                        {
+                            desc: `Remove \`${typeName}\` type`,
+                            fix: fixer => fixer.remove(node.parent),
+                        },
+                    ],
                 });
             },
         };
     },
 };
 
+const RULE_ID$4 = 'no-scalar-result-type-on-mutation';
 const rule$b = {
     meta: {
         type: 'suggestion',
+        hasSuggestions: true,
         docs: {
             category: 'Schema',
             description: 'Avoid scalar result type on mutation type to make sure to return a valid state.',
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-scalar-result-type-on-mutation.md',
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$4}.md`,
             requiresSchema: true,
             examples: [
                 {
@@ -2100,14 +2068,14 @@ const rule$b = {
         schema: [],
     },
     create(context) {
-        const schema = requireGraphQLSchemaFromContext('no-scalar-result-type-on-mutation', context);
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$4, context);
         const mutationType = schema.getMutationType();
         if (!mutationType) {
             return {};
         }
         const selector = [
-            `:matches(${Kind.OBJECT_TYPE_DEFINITION}, ${Kind.OBJECT_TYPE_EXTENSION})[name.value=${mutationType.name}]`,
-            `> ${Kind.FIELD_DEFINITION} > .gqlType ${Kind.NAME}`,
+            `:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=${mutationType.name}]`,
+            '> FieldDefinition > .gqlType Name',
         ].join(' ');
         return {
             [selector](node) {
@@ -2116,7 +2084,13 @@ const rule$b = {
                 if (isScalarType(graphQLType)) {
                     context.report({
                         node,
-                        message: `Unexpected scalar result type "${typeName}"`,
+                        message: `Unexpected scalar result type \`${typeName}\`.`,
+                        suggest: [
+                            {
+                                desc: `Remove \`${typeName}\``,
+                                fix: fixer => fixer.remove(node),
+                            },
+                        ],
                     });
                 }
             },
@@ -2128,6 +2102,7 @@ const NO_TYPENAME_PREFIX = 'NO_TYPENAME_PREFIX';
 const rule$c = {
     meta: {
         type: 'suggestion',
+        hasSuggestions: true,
         docs: {
             category: 'Schema',
             description: 'Enforces users to avoid using the type name in a field name while defining your schema.',
@@ -2172,6 +2147,12 @@ const rule$c = {
                             },
                             messageId: NO_TYPENAME_PREFIX,
                             node: field.name,
+                            suggest: [
+                                {
+                                    desc: `Remove \`${fieldName.slice(0, typeName.length)}\` prefix`,
+                                    fix: fixer => fixer.replaceText(field.name, fieldName.replace(new RegExp(`^${typeName}`, 'i'), '')),
+                                },
+                            ],
                         });
                     }
                 }
@@ -2180,8 +2161,7 @@ const rule$c = {
     },
 };
 
-const UNREACHABLE_TYPE = 'UNREACHABLE_TYPE';
-const RULE_ID = 'no-unreachable-types';
+const RULE_ID$5 = 'no-unreachable-types';
 const KINDS = [
     Kind.DIRECTIVE_DEFINITION,
     Kind.OBJECT_TYPE_DEFINITION,
@@ -2197,36 +2177,85 @@ const KINDS = [
     Kind.ENUM_TYPE_DEFINITION,
     Kind.ENUM_TYPE_EXTENSION,
 ];
-const rule$d = {
-    meta: {
-        messages: {
-            [UNREACHABLE_TYPE]: 'Type "{{ typeName }}" is unreachable',
-        },
-        docs: {
-            description: `Requires all types to be reachable at some level by root level fields.`,
-            category: 'Schema',
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
-            requiresSchema: true,
-            examples: [
-                {
-                    title: 'Incorrect',
-                    code: /* GraphQL */ `
-            type User {
-              id: ID!
-              name: String
-            }
-
-            type Query {
-              me: String
+let reachableTypesCache;
+function getReachableTypes(schema) {
+    // We don't want cache reachableTypes on test environment
+    // Otherwise reachableTypes will be same for all tests
+    if (process.env.NODE_ENV !== 'test' && reachableTypesCache) {
+        return reachableTypesCache;
+    }
+    const reachableTypes = new Set();
+    const collect = (node) => {
+        const typeName = getTypeName(node);
+        if (reachableTypes.has(typeName)) {
+            return;
+        }
+        reachableTypes.add(typeName);
+        const type = schema.getType(typeName) || schema.getDirective(typeName);
+        if (isInterfaceType(type)) {
+            const { objects, interfaces } = schema.getImplementations(type);
+            for (const { astNode } of [...objects, ...interfaces]) {
+                visit(astNode, visitor);
             }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    code: /* GraphQL */ `
-            type User {
-              id: ID!
-              name: String
+        }
+        else if (type.astNode) {
+            // astNode can be undefined for ID, String, Boolean
+            visit(type.astNode, visitor);
+        }
+    };
+    const visitor = {
+        InterfaceTypeDefinition: collect,
+        ObjectTypeDefinition: collect,
+        InputValueDefinition: collect,
+        UnionTypeDefinition: collect,
+        FieldDefinition: collect,
+        Directive: collect,
+        NamedType: collect,
+    };
+    for (const type of [
+        schema,
+        schema.getQueryType(),
+        schema.getMutationType(),
+        schema.getSubscriptionType(),
+    ]) {
+        // if schema don't have Query type, schema.astNode will be undefined
+        if (type === null || type === void 0 ? void 0 : type.astNode) {
+            visit(type.astNode, visitor);
+        }
+    }
+    reachableTypesCache = reachableTypes;
+    return reachableTypesCache;
+}
+const rule$d = {
+    meta: {
+        messages: {
+            [RULE_ID$5]: '{{ type }} `{{ typeName }}` is unreachable.',
+        },
+        docs: {
+            description: `Requires all types to be reachable at some level by root level fields.`,
+            category: 'Schema',
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$5}.md`,
+            requiresSchema: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type User {
+              id: ID!
+              name: String
+            }
+
+            type Query {
+              me: String
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            type User {
+              id: ID!
+              name: String
             }
 
             type Query {
@@ -2242,19 +2271,24 @@ const rule$d = {
         hasSuggestions: true,
     },
     create(context) {
-        const reachableTypes = requireReachableTypesFromContext(RULE_ID, context);
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$5, context);
+        const reachableTypes = getReachableTypes(schema);
         const selector = KINDS.join(',');
         return {
             [selector](node) {
                 const typeName = node.name.value;
                 if (!reachableTypes.has(typeName)) {
+                    const type = lowerCase(node.kind.replace(/(Extension|Definition)$/, ''));
                     context.report({
                         node: node.name,
-                        messageId: UNREACHABLE_TYPE,
-                        data: { typeName },
+                        messageId: RULE_ID$5,
+                        data: {
+                            type: type[0].toUpperCase() + type.slice(1),
+                            typeName
+                        },
                         suggest: [
                             {
-                                desc: `Remove ${typeName}`,
+                                desc: `Remove \`${typeName}\``,
                                 fix: fixer => fixer.remove(node),
                             },
                         ],
@@ -2265,19 +2299,49 @@ const rule$d = {
     },
 };
 
-const UNUSED_FIELD = 'UNUSED_FIELD';
-const RULE_ID$1 = 'no-unused-fields';
+const RULE_ID$6 = 'no-unused-fields';
+let usedFieldsCache;
+function getUsedFields(schema, operations) {
+    // We don't want cache usedFields on test environment
+    // Otherwise usedFields will be same for all tests
+    if (process.env.NODE_ENV !== 'test' && usedFieldsCache) {
+        return usedFieldsCache;
+    }
+    const usedFields = Object.create(null);
+    const typeInfo = new TypeInfo(schema);
+    const visitor = visitWithTypeInfo(typeInfo, {
+        Field(node) {
+            var _a;
+            const fieldDef = typeInfo.getFieldDef();
+            if (!fieldDef) {
+                // skip visiting this node if field is not defined in schema
+                return false;
+            }
+            const parentTypeName = typeInfo.getParentType().name;
+            const fieldName = node.name.value;
+            (_a = usedFields[parentTypeName]) !== null && _a !== void 0 ? _a : (usedFields[parentTypeName] = new Set());
+            usedFields[parentTypeName].add(fieldName);
+        },
+    });
+    const allDocuments = [...operations.getOperations(), ...operations.getFragments()];
+    for (const { document } of allDocuments) {
+        visit(document, visitor);
+    }
+    usedFieldsCache = usedFields;
+    return usedFieldsCache;
+}
 const rule$e = {
     meta: {
         messages: {
-            [UNUSED_FIELD]: `Field "{{fieldName}}" is unused`,
+            [RULE_ID$6]: `Field "{{fieldName}}" is unused`,
         },
         docs: {
             description: `Requires all fields to be used at some level by siblings operations.`,
             category: 'Schema',
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$1}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$6}.md`,
             requiresSiblings: true,
             requiresSchema: true,
+            isDisabledForAllConfig: true,
             examples: [
                 {
                     title: 'Incorrect',
@@ -2327,7 +2391,9 @@ const rule$e = {
         hasSuggestions: true,
     },
     create(context) {
-        const usedFields = requireUsedFieldsFromContext(RULE_ID$1, context);
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$6, context);
+        const siblingsOperations = requireSiblingsOperations(RULE_ID$6, context);
+        const usedFields = getUsedFields(schema, siblingsOperations);
         return {
             FieldDefinition(node) {
                 var _a;
@@ -2339,11 +2405,11 @@ const rule$e = {
                 }
                 context.report({
                     node: node.name,
-                    messageId: UNUSED_FIELD,
+                    messageId: RULE_ID$6,
                     data: { fieldName },
                     suggest: [
                         {
-                            desc: `Remove "${fieldName}" field`,
+                            desc: `Remove \`${fieldName}\` field`,
                             fix(fixer) {
                                 const sourceCode = context.getSourceCode();
                                 const tokenBefore = sourceCode.getTokenBefore(node);
@@ -2359,32 +2425,9 @@ const rule$e = {
     },
 };
 
-function keyValMap(list, keyFn, valFn) {
-    return list.reduce((map, item) => {
-        map[keyFn(item)] = valFn(item);
-        return map;
-    }, Object.create(null));
-}
-function valueFromNode(valueNode, variables) {
-    switch (valueNode.type) {
-        case Kind.NULL:
-            return null;
-        case Kind.INT:
-            return parseInt(valueNode.value, 10);
-        case Kind.FLOAT:
-            return parseFloat(valueNode.value);
-        case Kind.STRING:
-        case Kind.ENUM:
-        case Kind.BOOLEAN:
-            return valueNode.value;
-        case Kind.LIST:
-            return valueNode.values.map(node => valueFromNode(node, variables));
-        case Kind.OBJECT:
-            return keyValMap(valueNode.fields, field => field.name.value, field => valueFromNode(field.value, variables));
-        case Kind.VARIABLE:
-            return variables === null || variables === void 0 ? void 0 : variables[valueNode.name.value];
-    }
-}
+const valueFromNode = (...args) => {
+    return valueFromASTUntyped(...args);
+};
 function getBaseType(type) {
     if (isNonNullType(type) || isListType(type)) {
         return getBaseType(type.ofType);
@@ -2454,21 +2497,93 @@ function extractCommentsFromAst(loc) {
     }
     return comments;
 }
-function isNodeWithDescription(obj) {
-    var _a;
-    return (_a = obj) === null || _a === void 0 ? void 0 : _a.description;
+
+function convertToESTree(node, typeInfo) {
+    const visitor = { leave: convertNode(typeInfo) };
+    return {
+        rootTree: visit(node, typeInfo ? visitWithTypeInfo(typeInfo, visitor) : visitor),
+        comments: extractCommentsFromAst(node.loc),
+    };
+}
+function hasTypeField(node) {
+    return 'type' in node && Boolean(node.type);
+}
+function convertLocation(location) {
+    const { startToken, endToken, source, start, end } = location;
+    /*
+     * ESLint has 0-based column number
+     * https://eslint.org/docs/developer-guide/working-with-rules#contextreport
+     */
+    const loc = {
+        start: {
+            /*
+             * Kind.Document has startToken: { line: 0, column: 0 }, we set line as 1 and column as 0
+             */
+            line: startToken.line === 0 ? 1 : startToken.line,
+            column: startToken.column === 0 ? 0 : startToken.column - 1,
+        },
+        end: {
+            line: endToken.line,
+            column: endToken.column - 1,
+        },
+        source: source.body,
+    };
+    if (loc.start.column === loc.end.column) {
+        loc.end.column += end - start;
+    }
+    return loc;
 }
-function convertDescription(node) {
-    if (isNodeWithDescription(node)) {
-        return [
+const convertNode = (typeInfo) => (node, key, parent) => {
+    const leadingComments = 'description' in node && node.description
+        ? [
             {
                 type: node.description.block ? 'Block' : 'Line',
                 value: node.description.value,
             },
-        ];
-    }
-    return [];
-}
+        ]
+        : [];
+    const calculatedTypeInfo = typeInfo
+        ? {
+            argument: typeInfo.getArgument(),
+            defaultValue: typeInfo.getDefaultValue(),
+            directive: typeInfo.getDirective(),
+            enumValue: typeInfo.getEnumValue(),
+            fieldDef: typeInfo.getFieldDef(),
+            inputType: typeInfo.getInputType(),
+            parentInputType: typeInfo.getParentInputType(),
+            parentType: typeInfo.getParentType(),
+            gqlType: typeInfo.getType(),
+        }
+        : {};
+    const rawNode = () => {
+        if (parent && key !== undefined) {
+            return parent[key];
+        }
+        return node.kind === Kind.DOCUMENT
+            ? {
+                kind: node.kind,
+                loc: node.loc,
+                definitions: node.definitions.map(d => d.rawNode()),
+            }
+            : node;
+    };
+    const commonFields = {
+        ...node,
+        type: node.kind,
+        loc: convertLocation(node.loc),
+        range: [node.loc.start, node.loc.end],
+        leadingComments,
+        // Use function to prevent RangeError: Maximum call stack size exceeded
+        typeInfo: () => calculatedTypeInfo,
+        rawNode,
+    };
+    return hasTypeField(node)
+        ? {
+            ...commonFields,
+            gqlType: node.type,
+        }
+        : commonFields;
+};
 
 // eslint-disable-next-line unicorn/better-regex
 const DATE_REGEX = /^\d{2}\/\d{2}\/\d{4}$/;
@@ -2479,6 +2594,7 @@ const MESSAGE_CAN_BE_REMOVED = 'MESSAGE_CAN_BE_REMOVED';
 const rule$f = {
     meta: {
         type: 'suggestion',
+        hasSuggestions: true,
         docs: {
             category: 'Schema',
             description: 'Require deletion date on `@deprecated` directive. Suggest removing deprecated things after deprecated date.',
@@ -2566,12 +2682,18 @@ const rule$f = {
                 }
                 const canRemove = Date.now() > deletionDateInMS;
                 if (canRemove) {
+                    const { parent } = node;
+                    const nodeName = parent.name.value;
                     context.report({
-                        node: node.parent.name,
+                        node: parent.name,
                         messageId: MESSAGE_CAN_BE_REMOVED,
-                        data: {
-                            nodeName: node.parent.name.value,
-                        },
+                        data: { nodeName },
+                        suggest: [
+                            {
+                                desc: `Remove \`${nodeName}\``,
+                                fix: fixer => fixer.remove(parent),
+                            },
+                        ],
                     });
                 }
             },
@@ -2633,7 +2755,7 @@ const rule$g = {
     },
 };
 
-const RULE_ID$2 = 'require-description';
+const RULE_ID$7 = 'require-description';
 const ALLOWED_KINDS$1 = [
     ...TYPES_KINDS,
     Kind.DIRECTIVE_DEFINITION,
@@ -2675,7 +2797,7 @@ const rule$h = {
         docs: {
             category: 'Schema',
             description: 'Enforce descriptions in type definitions and operations.',
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$2}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$7}.md`,
             examples: [
                 {
                     title: 'Incorrect',
@@ -2722,7 +2844,7 @@ const rule$h = {
         },
         type: 'suggestion',
         messages: {
-            [RULE_ID$2]: 'Description is required for `{{ nodeName }}`.',
+            [RULE_ID$7]: 'Description is required for `{{ nodeName }}`.',
         },
         schema: {
             type: 'array',
@@ -2781,8 +2903,8 @@ const rule$h = {
                 }
                 if (description.length === 0) {
                     context.report({
-                        loc: isOperation ? getLocation(node.loc, node.operation) : node.name.loc,
-                        messageId: RULE_ID$2,
+                        loc: isOperation ? getLocation(node.loc.start, node.operation) : node.name.loc,
+                        messageId: RULE_ID$7,
                         data: {
                             nodeName: getNodeName(node),
                         },
@@ -2864,122 +2986,18 @@ const rule$i = {
     },
 };
 
-function convertToESTree(node, typeInfo) {
-    const visitor = { leave: convertNode(typeInfo) };
-    return {
-        rootTree: visit(node, typeInfo ? visitWithTypeInfo(typeInfo, visitor) : visitor),
-        comments: extractCommentsFromAst(node.loc),
-    };
-}
-function hasTypeField(obj) {
-    return obj && !!obj.type;
-}
-function convertLocation(location) {
-    const { startToken, endToken, source, start, end } = location;
-    /*
-     * ESLint has 0-based column number
-     * https://eslint.org/docs/developer-guide/working-with-rules#contextreport
-     */
-    const loc = {
-        start: {
-            /*
-             * Kind.Document has startToken: { line: 0, column: 0 }, we set line as 1 and column as 0
-             */
-            line: startToken.line === 0 ? 1 : startToken.line,
-            column: startToken.column === 0 ? 0 : startToken.column - 1,
-        },
-        end: {
-            line: endToken.line,
-            column: endToken.column - 1,
-        },
-        source: source.body,
-    };
-    if (loc.start.column === loc.end.column) {
-        loc.end.column += end - start;
-    }
-    return loc;
-}
-const convertNode = (typeInfo) => (node, key, parent) => {
-    const calculatedTypeInfo = typeInfo
-        ? {
-            argument: typeInfo.getArgument(),
-            defaultValue: typeInfo.getDefaultValue(),
-            directive: typeInfo.getDirective(),
-            enumValue: typeInfo.getEnumValue(),
-            fieldDef: typeInfo.getFieldDef(),
-            inputType: typeInfo.getInputType(),
-            parentInputType: typeInfo.getParentInputType(),
-            parentType: typeInfo.getParentType(),
-            gqlType: typeInfo.getType(),
-        }
-        : {};
-    const commonFields = {
-        typeInfo: () => calculatedTypeInfo,
-        leadingComments: convertDescription(node),
-        loc: convertLocation(node.loc),
-        range: [node.loc.start, node.loc.end],
-    };
-    if (hasTypeField(node)) {
-        const { type: gqlType, loc: gqlLocation, ...rest } = node;
-        const typeFieldSafe = {
-            ...rest,
-            gqlType,
-        };
-        const estreeNode = {
-            ...typeFieldSafe,
-            ...commonFields,
-            type: node.kind,
-            rawNode: () => {
-                if (!parent || key === undefined) {
-                    if (node && node.definitions) {
-                        return {
-                            loc: gqlLocation,
-                            kind: Kind.DOCUMENT,
-                            definitions: node.definitions.map(d => d.rawNode()),
-                        };
-                    }
-                    return node;
-                }
-                return parent[key];
-            },
-        };
-        return estreeNode;
-    }
-    else {
-        const { loc: gqlLocation, ...rest } = node;
-        const typeFieldSafe = rest;
-        const estreeNode = {
-            ...typeFieldSafe,
-            ...commonFields,
-            type: node.kind,
-            rawNode: () => {
-                if (!parent || key === undefined) {
-                    if (node && node.definitions) {
-                        return {
-                            loc: gqlLocation,
-                            kind: Kind.DOCUMENT,
-                            definitions: node.definitions.map(d => d.rawNode()),
-                        };
-                    }
-                    return node;
-                }
-                return parent[key];
-            },
-        };
-        return estreeNode;
-    }
-};
-
-const RULE_ID$3 = 'require-id-when-available';
-const MESSAGE_ID = 'REQUIRE_ID_WHEN_AVAILABLE';
+const RULE_ID$8 = 'require-id-when-available';
 const DEFAULT_ID_FIELD_NAME = 'id';
+const englishJoinWords = words => new Intl.ListFormat('en-US', { type: 'disjunction' }).format(words);
 const rule$j = {
     meta: {
         type: 'suggestion',
+        // eslint-disable-next-line eslint-plugin/require-meta-has-suggestions
+        hasSuggestions: true,
         docs: {
             category: 'Operations',
             description: 'Enforce selecting specific fields when they are available on the GraphQL type.',
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$3}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$8}.md`,
             requiresSchema: true,
             requiresSiblings: true,
             examples: [
@@ -3022,21 +3040,14 @@ const rule$j = {
             recommended: true,
         },
         messages: {
-            [MESSAGE_ID]: [
-                `Field {{ fieldName }} must be selected when it's available on a type. Please make sure to include it in your selection set!`,
-                `If you are using fragments, make sure that all used fragments {{ checkedFragments }}specifies the field {{ fieldName }}.`,
-            ].join('\n'),
+            [RULE_ID$8]: `Field{{ pluralSuffix }} {{ fieldName }} must be selected when it's available on a type.\nInclude it in your selection set{{ addition }}.`,
         },
         schema: {
             definitions: {
                 asString: {
                     type: 'string',
                 },
-                asArray: {
-                    type: 'array',
-                    minItems: 1,
-                    uniqueItems: true,
-                },
+                asArray: ARRAY_DEFAULT_OPTIONS,
             },
             type: 'array',
             maxItems: 1,
@@ -3053,76 +3064,121 @@ const rule$j = {
         },
     },
     create(context) {
-        requireGraphQLSchemaFromContext(RULE_ID$3, context);
-        const siblings = requireSiblingsOperations(RULE_ID$3, context);
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$8, context);
+        const siblings = requireSiblingsOperations(RULE_ID$8, context);
         const { fieldName = DEFAULT_ID_FIELD_NAME } = context.options[0] || {};
         const idNames = asArray(fieldName);
-        const isFound = (s) => s.kind === Kind.FIELD && idNames.includes(s.name.value);
-        // Skip check selections in FragmentDefinition
-        const selector = 'OperationDefinition SelectionSet[parent.kind!=OperationDefinition]';
-        return {
-            [selector](node) {
-                var _a;
-                const typeInfo = node.typeInfo();
-                if (!typeInfo.gqlType) {
-                    return;
-                }
-                const rawType = getBaseType(typeInfo.gqlType);
-                const isObjectType = rawType instanceof GraphQLObjectType;
-                const isInterfaceType = rawType instanceof GraphQLInterfaceType;
-                if (!isObjectType && !isInterfaceType) {
-                    return;
+        // Check selections only in OperationDefinition,
+        // skip selections of OperationDefinition and InlineFragment
+        const selector = 'OperationDefinition SelectionSet[parent.kind!=/(^OperationDefinition|InlineFragment)$/]';
+        const typeInfo = new TypeInfo(schema);
+        function checkFragments(node) {
+            for (const selection of node.selections) {
+                if (selection.kind !== Kind.FRAGMENT_SPREAD) {
+                    continue;
                 }
-                const fields = rawType.getFields();
-                const hasIdFieldInType = idNames.some(name => fields[name]);
-                if (!hasIdFieldInType) {
-                    return;
+                const [foundSpread] = siblings.getFragment(selection.name.value);
+                if (!foundSpread) {
+                    continue;
                 }
                 const checkedFragmentSpreads = new Set();
-                for (const selection of node.selections) {
-                    if (isFound(selection)) {
-                        return;
+                const visitor = visitWithTypeInfo(typeInfo, {
+                    SelectionSet(node, key, parent) {
+                        if (parent.kind === Kind.FRAGMENT_DEFINITION) {
+                            checkedFragmentSpreads.add(parent.name.value);
+                        }
+                        else if (parent.kind !== Kind.INLINE_FRAGMENT) {
+                            checkSelections(node, typeInfo.getType(), selection.loc.start, parent, checkedFragmentSpreads);
+                        }
+                    },
+                });
+                visit(foundSpread.document, visitor);
+            }
+        }
+        function checkSelections(node, type, 
+        // Fragment can be placed in separate file
+        // Provide actual fragment spread location instead of location in fragment
+        loc, 
+        // Can't access to node.parent in GraphQL AST.Node, so pass as argument
+        parent, checkedFragmentSpreads = new Set()) {
+            const rawType = getBaseType(type);
+            const isObjectType = rawType instanceof GraphQLObjectType;
+            const isInterfaceType = rawType instanceof GraphQLInterfaceType;
+            if (!isObjectType && !isInterfaceType) {
+                return;
+            }
+            const fields = rawType.getFields();
+            const hasIdFieldInType = idNames.some(name => fields[name]);
+            if (!hasIdFieldInType) {
+                return;
+            }
+            function hasIdField({ selections }) {
+                return selections.some(selection => {
+                    if (selection.kind === Kind.FIELD) {
+                        return idNames.includes(selection.name.value);
                     }
-                    if (selection.kind === Kind.INLINE_FRAGMENT && selection.selectionSet.selections.some(isFound)) {
-                        return;
+                    if (selection.kind === Kind.INLINE_FRAGMENT) {
+                        return hasIdField(selection.selectionSet);
                     }
                     if (selection.kind === Kind.FRAGMENT_SPREAD) {
                         const [foundSpread] = siblings.getFragment(selection.name.value);
                         if (foundSpread) {
-                            checkedFragmentSpreads.add(foundSpread.document.name.value);
-                            if (foundSpread.document.selectionSet.selections.some(isFound)) {
-                                return;
-                            }
+                            const fragmentSpread = foundSpread.document;
+                            checkedFragmentSpreads.add(fragmentSpread.name.value);
+                            return hasIdField(fragmentSpread.selectionSet);
                         }
                     }
-                }
-                const { parent } = node;
-                const hasIdFieldInInterfaceSelectionSet = (parent === null || parent === void 0 ? void 0 : parent.kind) === Kind.INLINE_FRAGMENT &&
-                    ((_a = parent.parent) === null || _a === void 0 ? void 0 : _a.kind) === Kind.SELECTION_SET &&
-                    parent.parent.selections.some(isFound);
-                if (hasIdFieldInInterfaceSelectionSet) {
-                    return;
-                }
-                context.report({
-                    loc: getLocation(node.loc),
-                    messageId: MESSAGE_ID,
-                    data: {
-                        checkedFragments: checkedFragmentSpreads.size === 0 ? '' : `(${[...checkedFragmentSpreads].join(', ')}) `,
-                        fieldName: idNames.map(name => `"${name}"`).join(' or '),
-                    },
+                    return false;
                 });
+            }
+            const hasId = hasIdField(node);
+            checkFragments(node);
+            if (hasId) {
+                return;
+            }
+            const pluralSuffix = idNames.length > 1 ? 's' : '';
+            const fieldName = englishJoinWords(idNames.map(name => `\`${(parent.alias || parent.name).value}.${name}\``));
+            const addition = checkedFragmentSpreads.size === 0
+                ? ''
+                : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? 's' : ''} ${englishJoinWords([...checkedFragmentSpreads].map(name => `\`${name}\``))}`;
+            const problem = {
+                loc,
+                messageId: RULE_ID$8,
+                data: {
+                    pluralSuffix,
+                    fieldName,
+                    addition,
+                },
+            };
+            // Don't provide suggestions for selections in fragments as fragment can be in a separate file
+            if ('type' in node) {
+                problem.suggest = idNames.map(idName => ({
+                    desc: `Add \`${idName}\` selection`,
+                    fix: fixer => fixer.insertTextBefore(node.selections[0], `${idName} `),
+                }));
+            }
+            context.report(problem);
+        }
+        return {
+            [selector](node) {
+                const typeInfo = node.typeInfo();
+                if (typeInfo.gqlType) {
+                    checkSelections(node, typeInfo.gqlType, node.loc.start, node.parent);
+                }
             },
         };
     },
 };
 
-const RULE_ID$4 = 'selection-set-depth';
+const RULE_ID$9 = 'selection-set-depth';
 const rule$k = {
     meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
         docs: {
             category: 'Operations',
             description: `Limit the complexity of the GraphQL operations solely by their depth. Based on [graphql-depth-limit](https://github.com/stems/graphql-depth-limit).`,
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$4}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$9}.md`,
             requiresSiblings: true,
             examples: [
                 {
@@ -3168,7 +3224,6 @@ const rule$k = {
             recommended: true,
             configOptions: [{ maxDepth: 7 }],
         },
-        type: 'suggestion',
         schema: {
             type: 'array',
             minItems: 1,
@@ -3181,14 +3236,7 @@ const rule$k = {
                     maxDepth: {
                         type: 'number',
                     },
-                    ignore: {
-                        type: 'array',
-                        uniqueItems: true,
-                        minItems: 1,
-                        items: {
-                            type: 'string',
-                        },
-                    },
+                    ignore: ARRAY_DEFAULT_OPTIONS,
                 },
             },
         },
@@ -3196,10 +3244,10 @@ const rule$k = {
     create(context) {
         let siblings = null;
         try {
-            siblings = requireSiblingsOperations(RULE_ID$4, context);
+            siblings = requireSiblingsOperations(RULE_ID$9, context);
         }
         catch (e) {
-            logger.warn(`Rule "${RULE_ID$4}" works best with siblings operations loaded. For more info: http://bit.ly/graphql-eslint-operations`);
+            logger.warn(`Rule "${RULE_ID$9}" works best with siblings operations loaded. For more info: http://bit.ly/graphql-eslint-operations`);
         }
         const { maxDepth } = context.options[0];
         const ignore = context.options[0].ignore || [];
@@ -3208,7 +3256,7 @@ const rule$k = {
             'OperationDefinition, FragmentDefinition'(node) {
                 try {
                     const rawNode = node.rawNode();
-                    const fragmentsInUse = siblings ? siblings.getFragmentsInUse(rawNode, true) : [];
+                    const fragmentsInUse = siblings ? siblings.getFragmentsInUse(rawNode) : [];
                     const document = {
                         kind: Kind.DOCUMENT,
                         definitions: [rawNode, ...fragmentsInUse],
@@ -3223,19 +3271,32 @@ const rule$k = {
                                     column: column - 1,
                                 },
                                 message: error.message,
+                                suggest: [
+                                    {
+                                        desc: 'Remove selections',
+                                        fix(fixer) {
+                                            const ancestors = context.getAncestors();
+                                            const token = ancestors[0].tokens.find(token => token.loc.start.line === line && token.loc.start.column === column - 1);
+                                            const sourceCode = context.getSourceCode();
+                                            const foundNode = sourceCode.getNodeByRangeIndex(token.range[0]);
+                                            const parentNode = foundNode.parent.parent;
+                                            return fixer.remove(foundNode.kind === 'Name' ? parentNode.parent : parentNode);
+                                        },
+                                    },
+                                ],
                             });
                         },
                     });
                 }
                 catch (e) {
-                    logger.warn(`Rule "${RULE_ID$4}" check failed due to a missing siblings operations. For more info: http://bit.ly/graphql-eslint-operations`, e);
+                    logger.warn(`Rule "${RULE_ID$9}" check failed due to a missing siblings operations. For more info: http://bit.ly/graphql-eslint-operations`, e);
                 }
             },
         };
     },
 };
 
-const RULE_ID$5 = 'strict-id-in-types';
+const RULE_ID$a = 'strict-id-in-types';
 const rule$l = {
     meta: {
         type: 'suggestion',
@@ -3243,7 +3304,7 @@ const rule$l = {
             description: `Requires output types to have one unique identifier unless they do not have a logical one. Exceptions can be used to ignore output types that do not have unique identifiers.`,
             category: 'Schema',
             recommended: true,
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$5}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$a}.md`,
             requiresSchema: true,
             examples: [
                 {
@@ -3334,22 +3395,12 @@ const rule$l = {
                         type: 'object',
                         properties: {
                             types: {
-                                type: 'array',
-                                uniqueItems: true,
-                                minItems: 1,
+                                ...ARRAY_DEFAULT_OPTIONS,
                                 description: 'This is used to exclude types with names that match one of the specified values.',
-                                items: {
-                                    type: 'string',
-                                },
                             },
                             suffixes: {
-                                type: 'array',
-                                uniqueItems: true,
-                                minItems: 1,
+                                ...ARRAY_DEFAULT_OPTIONS,
                                 description: 'This is used to exclude types with names with suffixes that match one of the specified values.',
-                                items: {
-                                    type: 'string',
-                                },
                             },
                         },
                     },
@@ -3357,7 +3408,7 @@ const rule$l = {
             },
         },
         messages: {
-            [RULE_ID$5]: `{{ typeName }} must have exactly one non-nullable unique identifier. Accepted name(s): {{ acceptedNamesString }}; Accepted type(s): {{ acceptedTypesString }}.`,
+            [RULE_ID$a]: `{{ typeName }} must have exactly one non-nullable unique identifier. Accepted name(s): {{ acceptedNamesString }}; Accepted type(s): {{ acceptedTypesString }}.`,
         },
     },
     create(context) {
@@ -3367,7 +3418,7 @@ const rule$l = {
             exceptions: {},
             ...context.options[0],
         };
-        const schema = requireGraphQLSchemaFromContext(RULE_ID$5, context);
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$a, context);
         const rootTypeNames = [schema.getQueryType(), schema.getMutationType(), schema.getSubscriptionType()]
             .filter(Boolean)
             .map(type => type.name);
@@ -3397,7 +3448,7 @@ const rule$l = {
                 if (validIds.length !== 1) {
                     context.report({
                         node: node.name,
-                        messageId: RULE_ID$5,
+                        messageId: RULE_ID$a,
                         data: {
                             typeName,
                             acceptedNamesString: options.acceptedIdNames.join(', '),
@@ -3730,13 +3781,13 @@ function getSiblingOperations(options, gqlConfig) {
         };
         return {
             available: false,
-            getFragments: noopWarn,
-            getOperations: noopWarn,
             getFragment: noopWarn,
+            getFragments: noopWarn,
             getFragmentByType: noopWarn,
+            getFragmentsInUse: noopWarn,
             getOperation: noopWarn,
+            getOperations: noopWarn,
             getOperationByType: noopWarn,
-            getFragmentsInUse: noopWarn,
         };
     }
     // Since the siblings array is cached, we can use it as cache key.
@@ -3749,7 +3800,7 @@ function getSiblingOperations(options, gqlConfig) {
             if (fragmentsCache === null) {
                 const result = [];
                 for (const source of siblings) {
-                    for (const definition of source.document.definitions || []) {
+                    for (const definition of source.document.definitions) {
                         if (definition.kind === Kind.FRAGMENT_DEFINITION) {
                             result.push({
                                 filePath: source.location,
@@ -3767,7 +3818,7 @@ function getSiblingOperations(options, gqlConfig) {
             if (cachedOperations === null) {
                 const result = [];
                 for (const source of siblings) {
-                    for (const definition of source.document.definitions || []) {
+                    for (const definition of source.document.definitions) {
                         if (definition.kind === Kind.OPERATION_DEFINITION) {
                             result.push({
                                 filePath: source.location,
@@ -3781,19 +3832,17 @@ function getSiblingOperations(options, gqlConfig) {
             return cachedOperations;
         };
         const getFragment = (name) => getFragments().filter(f => { var _a; return ((_a = f.document.name) === null || _a === void 0 ? void 0 : _a.value) === name; });
-        const collectFragments = (selectable, recursive = true, collected = new Map()) => {
+        const collectFragments = (selectable, recursive, collected = new Map()) => {
             visit(selectable, {
                 FragmentSpread(spread) {
-                    const name = spread.name.value;
-                    const fragmentInfo = getFragment(name);
-                    if (fragmentInfo.length === 0) {
-                        logger.warn(`Unable to locate fragment named "${name}", please make sure it's loaded using "parserOptions.operations"`);
+                    const fragmentName = spread.name.value;
+                    const [fragment] = getFragment(fragmentName);
+                    if (!fragment) {
+                        logger.warn(`Unable to locate fragment named "${fragmentName}", please make sure it's loaded using "parserOptions.operations"`);
                         return;
                     }
-                    const fragment = fragmentInfo[0];
-                    const alreadyVisited = collected.has(name);
-                    if (!alreadyVisited) {
-                        collected.set(name, fragment.document);
+                    if (!collected.has(fragmentName)) {
+                        collected.set(fragmentName, fragment.document);
                         if (recursive) {
                             collectFragments(fragment.document, recursive, collected);
                         }
@@ -3804,13 +3853,13 @@ function getSiblingOperations(options, gqlConfig) {
         };
         siblingOperations = {
             available: true,
-            getFragments,
-            getOperations,
             getFragment,
+            getFragments,
             getFragmentByType: typeName => getFragments().filter(f => { var _a, _b; return ((_b = (_a = f.document.typeCondition) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.value) === typeName; }),
+            getFragmentsInUse: (selectable, recursive = true) => Array.from(collectFragments(selectable, recursive).values()),
             getOperation: name => getOperations().filter(o => { var _a; return ((_a = o.document.name) === null || _a === void 0 ? void 0 : _a.value) === name; }),
+            getOperations,
             getOperationByType: type => getOperations().filter(o => o.document.operation === type),
-            getFragmentsInUse: (selectable, recursive = true) => Array.from(collectFragments(selectable, recursive).values()),
         };
         siblingOperationsCache.set(siblings, siblingOperations);
     }
@@ -3856,86 +3905,6 @@ const addCodeFileLoaderExtension = api => {
     return { name: 'graphql-eslint-loaders' };
 };
 
-let reachableTypesCache;
-function getReachableTypes(schema) {
-    // We don't want cache reachableTypes on test environment
-    // Otherwise reachableTypes will be same for all tests
-    if (process.env.NODE_ENV !== 'test' && reachableTypesCache) {
-        return reachableTypesCache;
-    }
-    const reachableTypes = new Set();
-    const collect = (node) => {
-        const typeName = getTypeName(node);
-        if (reachableTypes.has(typeName)) {
-            return;
-        }
-        reachableTypes.add(typeName);
-        const type = schema.getType(typeName) || schema.getDirective(typeName);
-        if (isInterfaceType(type)) {
-            const { objects, interfaces } = schema.getImplementations(type);
-            for (const { astNode } of [...objects, ...interfaces]) {
-                visit(astNode, visitor);
-            }
-        }
-        else if (type.astNode) {
-            // astNode can be undefined for ID, String, Boolean
-            visit(type.astNode, visitor);
-        }
-    };
-    const visitor = {
-        InterfaceTypeDefinition: collect,
-        ObjectTypeDefinition: collect,
-        InputValueDefinition: collect,
-        UnionTypeDefinition: collect,
-        FieldDefinition: collect,
-        Directive: collect,
-        NamedType: collect,
-    };
-    for (const type of [
-        schema,
-        schema.getQueryType(),
-        schema.getMutationType(),
-        schema.getSubscriptionType(),
-    ]) {
-        // if schema don't have Query type, schema.astNode will be undefined
-        if (type === null || type === void 0 ? void 0 : type.astNode) {
-            visit(type.astNode, visitor);
-        }
-    }
-    reachableTypesCache = reachableTypes;
-    return reachableTypesCache;
-}
-let usedFieldsCache;
-function getUsedFields(schema, operations) {
-    // We don't want cache usedFields on test environment
-    // Otherwise usedFields will be same for all tests
-    if (process.env.NODE_ENV !== 'test' && usedFieldsCache) {
-        return usedFieldsCache;
-    }
-    const usedFields = Object.create(null);
-    const typeInfo = new TypeInfo(schema);
-    const visitor = visitWithTypeInfo(typeInfo, {
-        Field(node) {
-            var _a;
-            const fieldDef = typeInfo.getFieldDef();
-            if (!fieldDef) {
-                // skip visiting this node if field is not defined in schema
-                return false;
-            }
-            const parentTypeName = typeInfo.getParentType().name;
-            const fieldName = node.name.value;
-            (_a = usedFields[parentTypeName]) !== null && _a !== void 0 ? _a : (usedFields[parentTypeName] = new Set());
-            usedFields[parentTypeName].add(fieldName);
-        },
-    });
-    const allDocuments = [...operations.getOperations(), ...operations.getFragments()];
-    for (const { document } of allDocuments) {
-        visit(document, visitor);
-    }
-    usedFieldsCache = usedFields;
-    return usedFieldsCache;
-}
-
 function parse(code, options) {
     return parseForESLint(code, options).ast;
 }
@@ -3946,8 +3915,6 @@ function parseForESLint(code, options = {}) {
         hasTypeInfo: schema !== null,
         schema,
         siblingOperations: getSiblingOperations(options, gqlConfig),
-        reachableTypes: getReachableTypes,
-        usedFields: getUsedFields,
     };
     try {
         const filePath = options.filePath || '';
@@ -3988,6 +3955,7 @@ function parseForESLint(code, options = {}) {
     }
 }
 
+/* eslint-env jest */
 function indentCode(code, indent = 4) {
     return code.replace(/^/gm, ' '.repeat(indent));
 }
@@ -3997,6 +3965,11 @@ function printCode(code) {
         linesBelow: Number.POSITIVE_INFINITY,
     });
 }
+// A simple version of `SourceCodeFixer.applyFixes`
+// https://github.com/eslint/eslint/issues/14936#issuecomment-906746754
+function applyFix(code, fix) {
+    return [code.slice(0, fix.range[0]), fix.text, code.slice(fix.range[1])].join('');
+}
 class GraphQLRuleTester extends RuleTester {
     constructor(parserOptions = {}) {
         const config = {
@@ -4040,32 +4013,63 @@ class GraphQLRuleTester extends RuleTester {
         linter.defineRule(name, rule);
         const hasOnlyTest = tests.invalid.some(t => t.only);
         for (const testCase of tests.invalid) {
-            const { only, code, filename } = testCase;
+            const { only, filename, options } = testCase;
             if (hasOnlyTest && !only) {
                 continue;
             }
+            const code = removeTrailingBlankLines(testCase.code);
             const verifyConfig = getVerifyConfig(name, this.config, testCase);
             defineParser(linter, verifyConfig.parser);
             const messages = linter.verify(code, verifyConfig, { filename });
             const messageForSnapshot = [];
+            const hasMultipleMessages = messages.length > 1;
+            if (hasMultipleMessages) {
+                messageForSnapshot.push('Code', indentCode(printCode(code)));
+            }
+            if (options) {
+                const opts = JSON.stringify(options, null, 2).slice(1, -1);
+                messageForSnapshot.push('⚙️ Options', indentCode(removeTrailingBlankLines(opts), 2));
+            }
             for (const [index, message] of messages.entries()) {
                 if (message.fatal) {
                     throw new Error(message.message);
                 }
-                messageForSnapshot.push(`❌ Error ${index + 1}/${messages.length}`, visualizeEslintMessage(code, message));
+                const codeWithMessage = visualizeEslintMessage(code, message, hasMultipleMessages ? 1 : undefined);
+                messageForSnapshot.push(printWithIndex('❌ Error', index, messages.length), indentCode(codeWithMessage));
+                const { suggestions } = message;
+                // Don't print suggestions in snapshots for too big codes
+                if (suggestions && (code.match(/\n/g) || '').length < 1000) {
+                    for (const [i, suggestion] of message.suggestions.entries()) {
+                        const output = applyFix(code, suggestion.fix);
+                        const title = printWithIndex('💡 Suggestion', i, suggestions.length, suggestion.desc);
+                        messageForSnapshot.push(title, indentCode(printCode(output), 2));
+                    }
+                }
             }
             if (rule.meta.fixable) {
                 const { fixed, output } = linter.verifyAndFix(code, verifyConfig, { filename });
                 if (fixed) {
-                    messageForSnapshot.push('🔧 Autofix output', indentCode(printCode(output), 2));
+                    messageForSnapshot.push('🔧 Autofix output', indentCode(codeFrameColumns(output, {})));
                 }
             }
             expect(messageForSnapshot.join('\n\n')).toMatchSnapshot();
         }
     }
 }
+function removeTrailingBlankLines(text) {
+    return text.replace(/^\s*\n/, '').trimEnd();
+}
+function printWithIndex(title, index, total, description) {
+    if (total > 1) {
+        title += ` ${index + 1}/${total}`;
+    }
+    if (description) {
+        title += `: ${description}`;
+    }
+    return title;
+}
 function getVerifyConfig(ruleId, testerConfig, testCase) {
-    const { options, parserOptions, parser = testerConfig.parser } = testCase;
+    const { parser = testerConfig.parser, parserOptions, options } = testCase;
     return {
         ...testerConfig,
         parser,
@@ -4074,7 +4078,7 @@ function getVerifyConfig(ruleId, testerConfig, testCase) {
             ...parserOptions,
         },
         rules: {
-            [ruleId]: ['error', ...(Array.isArray(options) ? options : [])],
+            [ruleId]: Array.isArray(options) ? ['error', ...options] : 'error',
         },
     };
 }
@@ -4092,7 +4096,7 @@ function defineParser(linter, parser) {
         linter.defineParser(parser, require(parser));
     }
 }
-function visualizeEslintMessage(text, result) {
+function visualizeEslintMessage(text, result, linesOffset = Number.POSITIVE_INFINITY) {
     const { line, column, endLine, endColumn, message } = result;
     const location = {
         start: {
@@ -4107,10 +4111,15 @@ function visualizeEslintMessage(text, result) {
         };
     }
     return codeFrameColumns(text, location, {
-        linesAbove: Number.POSITIVE_INFINITY,
-        linesBelow: Number.POSITIVE_INFINITY,
+        linesAbove: linesOffset,
+        linesBelow: linesOffset,
         message,
     });
 }
 
-export { GraphQLRuleTester, configs, convertDescription, convertToESTree, convertToken, extractCommentsFromAst, extractTokens, getBaseType, isNodeWithDescription, parse, parseForESLint, processors, rules, valueFromNode };
+const configs = Object.fromEntries(['schema-recommended', 'schema-all', 'operations-recommended', 'operations-all'].map(configName => [
+    configName,
+    { extends: `./configs/${configName}.json` },
+]));
+
+export { GraphQLRuleTester, configs, parse, parseForESLint, processors, requireGraphQLSchemaFromContext, requireSiblingsOperations, rules };