@graphql-eslint/eslint-plugin 3.2.0-alpha-6aa2721.0 → 3.2.0-alpha-45f5fcb.0

package/index.js

@@ -6,6 +6,7 @@ function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'defau
 
 const graphql = require('graphql');
 const validate = require('graphql/validation/validate');
+const _import = require('@graphql-tools/import');
 const fs = require('fs');
 const path = require('path');
 const utils = require('@graphql-tools/utils');
@@ -285,14 +286,6 @@ const TYPES_KINDS = [
     graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
     graphql.Kind.UNION_TYPE_DEFINITION,
 ];
-var CaseStyle;
-(function (CaseStyle) {
-    CaseStyle["camelCase"] = "camelCase";
-    CaseStyle["pascalCase"] = "PascalCase";
-    CaseStyle["snakeCase"] = "snake_case";
-    CaseStyle["upperCase"] = "UPPER_CASE";
-    CaseStyle["kebabCase"] = "kebab-case";
-})(CaseStyle || (CaseStyle = {}));
 const pascalCase = (str) => lowerCase(str)
     .split(' ')
     .map(word => word.charAt(0).toUpperCase() + word.slice(1))
@@ -303,15 +296,15 @@ const camelCase = (str) => {
 };
 const convertCase = (style, str) => {
     switch (style) {
-        case CaseStyle.camelCase:
+        case 'camelCase':
             return camelCase(str);
-        case CaseStyle.pascalCase:
+        case 'PascalCase':
             return pascalCase(str);
-        case CaseStyle.snakeCase:
+        case 'snake_case':
             return lowerCase(str).replace(/ /g, '_');
-        case CaseStyle.upperCase:
+        case 'UPPER_CASE':
             return lowerCase(str).replace(/ /g, '_').toUpperCase();
-        case CaseStyle.kebabCase:
+        case 'kebab-case':
             return lowerCase(str).replace(/ /g, '-');
     }
 };
@@ -334,99 +327,59 @@ function getLocation(loc, fieldName = '', offset) {
     };
 }
 
-function validateDocument(sourceNode, context, schema, documentNode, rule) {
-    if (documentNode.definitions.length === 0) {
-        return;
-    }
-    try {
-        const validationErrors = schema
-            ? graphql.validate(schema, documentNode, [rule])
-            : validate.validateSDL(documentNode, null, [rule]);
-        for (const error of validationErrors) {
-            context.report({
-                loc: getLocation({ start: error.locations[0] }),
-                message: error.message,
-            });
-        }
-    }
-    catch (e) {
-        context.report({
-            node: sourceNode,
-            message: e.message,
-        });
-    }
+function extractRuleName(stack) {
+    const match = (stack || '').match(/validation[/\\]rules[/\\](.*?)\.js:/) || [];
+    return match[1] || null;
 }
-const getFragmentDefsAndFragmentSpreads = (schema, node) => {
-    const typeInfo = new graphql.TypeInfo(schema);
-    const fragmentDefs = new Set();
-    const fragmentSpreads = new Set();
-    const visitor = graphql.visitWithTypeInfo(typeInfo, {
-        FragmentDefinition(node) {
-            fragmentDefs.add(`${node.name.value}:${node.typeCondition.name.value}`);
-        },
-        FragmentSpread(node) {
-            const parentType = typeInfo.getParentType();
-            if (parentType) {
-                fragmentSpreads.add(`${node.name.value}:${parentType.name}`);
+function validateDoc(sourceNode, context, schema, documentNode, rules, ruleName = null) {
+    var _a;
+    if (((_a = documentNode === null || documentNode === void 0 ? void 0 : documentNode.definitions) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+        try {
+            const validationErrors = schema ? graphql.validate(schema, documentNode, rules) : validate.validateSDL(documentNode, null, rules);
+            for (const error of validationErrors) {
+                const validateRuleName = ruleName || `[${extractRuleName(error.stack)}]`;
+                context.report({
+                    loc: getLocation({ start: error.locations[0] }),
+                    message: ruleName ? error.message : `${validateRuleName} ${error.message}`,
+                });
             }
-        },
-    });
-    graphql.visit(node, visitor);
-    return { fragmentDefs, fragmentSpreads };
-};
-const getMissingFragments = (schema, node) => {
-    const { fragmentDefs, fragmentSpreads } = getFragmentDefsAndFragmentSpreads(schema, node);
-    return [...fragmentSpreads].filter(name => !fragmentDefs.has(name));
-};
-const handleMissingFragments = ({ ruleId, context, schema, node }) => {
-    const missingFragments = getMissingFragments(schema, node);
-    if (missingFragments.length > 0) {
-        const siblings = requireSiblingsOperations(ruleId, context);
-        const fragmentsToAdd = [];
-        for (const missingFragment of missingFragments) {
-            const [fragmentName, fragmentTypeName] = missingFragment.split(':');
-            const fragments = siblings
-                .getFragment(fragmentName)
-                .map(source => source.document)
-                .filter(fragment => fragment.typeCondition.name.value === fragmentTypeName);
-            fragmentsToAdd.push(fragments[0]);
         }
-        if (fragmentsToAdd.length > 0) {
-            // recall fn to make sure to add fragments inside fragments
-            return handleMissingFragments({
-                ruleId,
-                context,
-                schema,
-                node: {
-                    kind: graphql.Kind.DOCUMENT,
-                    definitions: [...node.definitions, ...fragmentsToAdd],
-                },
+        catch (e) {
+            context.report({
+                node: sourceNode,
+                message: e.message,
             });
         }
     }
-    return node;
+}
+const isGraphQLImportFile = rawSDL => {
+    const trimmedRawSDL = rawSDL.trimLeft();
+    return trimmedRawSDL.startsWith('# import') || trimmedRawSDL.startsWith('#import');
 };
-const validationToRule = (ruleId, ruleName, docs, getDocumentNode) => {
+const validationToRule = (name, ruleName, docs, getDocumentNode) => {
+    var _a;
     let ruleFn = null;
     try {
         ruleFn = require(`graphql/validation/rules/${ruleName}Rule`)[`${ruleName}Rule`];
     }
-    catch (_a) {
+    catch (e) {
         try {
             ruleFn = require(`graphql/validation/rules/${ruleName}`)[`${ruleName}Rule`];
         }
-        catch (_b) {
+        catch (e) {
             ruleFn = require('graphql/validation')[`${ruleName}Rule`];
         }
     }
+    const requiresSchema = (_a = docs.requiresSchema) !== null && _a !== void 0 ? _a : true;
     return {
-        [ruleId]: {
+        [name]: {
             meta: {
                 docs: {
                     recommended: true,
                     ...docs,
                     graphQLJSRuleName: ruleName,
-                    url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${ruleId}.md`,
+                    requiresSchema,
+                    url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${name}.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).`,
                 },
             },
@@ -435,53 +388,56 @@ const validationToRule = (ruleId, ruleName, docs, getDocumentNode) => {
                     Document(node) {
                         if (!ruleFn) {
                             // eslint-disable-next-line no-console
-                            console.warn(`You rule "${ruleId}" depends on a GraphQL validation rule "${ruleName}" but it's not available in the "graphql-js" version you are using. Skipping...`);
+                            console.warn(`You rule "${name}" depends on a GraphQL validation rule ("${ruleName}") but it's not available in the "graphql-js" version you are using. Skipping...`);
                             return;
                         }
-                        const schema = docs.requiresSchema ? requireGraphQLSchemaFromContext(ruleId, context) : null;
-                        const documentNode = getDocumentNode
-                            ? getDocumentNode({ ruleId, context, schema, node: node.rawNode() })
-                            : node.rawNode();
-                        validateDocument(node, context, schema, documentNode, ruleFn);
+                        const schema = requiresSchema ? requireGraphQLSchemaFromContext(name, context) : null;
+                        let documentNode;
+                        const isRealFile = fs.existsSync(context.getFilename());
+                        if (isRealFile && getDocumentNode) {
+                            documentNode = getDocumentNode(context);
+                        }
+                        validateDoc(node, context, schema, documentNode || node.rawNode(), [ruleFn], ruleName);
                     },
                 };
             },
         },
     };
 };
+const importFiles = (context) => {
+    const code = context.getSourceCode().text;
+    if (!isGraphQLImportFile(code)) {
+        return null;
+    }
+    // Import documents because file contains '#import' comments
+    return _import.processImport(context.getFilename());
+};
 const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-definitions', 'ExecutableDefinitions', {
     category: 'Operations',
     description: `A GraphQL document is only valid for execution if all definitions are either operation or fragment definitions.`,
-    requiresSchema: true,
 }), validationToRule('fields-on-correct-type', 'FieldsOnCorrectType', {
     category: 'Operations',
     description: 'A GraphQL document is only valid if all fields selected are defined by the parent type, or are an allowed meta field such as `__typename`.',
-    requiresSchema: true,
 }), validationToRule('fragments-on-composite-type', 'FragmentsOnCompositeTypes', {
     category: 'Operations',
     description: `Fragments use a type condition to determine if they apply, since fragments can only be spread into a composite type (object, interface, or union), the type condition must also be a composite type.`,
-    requiresSchema: true,
 }), validationToRule('known-argument-names', 'KnownArgumentNames', {
     category: ['Schema', 'Operations'],
     description: `A GraphQL field is only valid if all supplied arguments are defined by that field.`,
-    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.`,
-    requiresSchema: true,
 }), 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.`,
-    requiresSchema: true,
-    requiresSiblings: true,
     examples: [
         {
-            title: 'Incorrect',
+            title: 'Incorrect (fragment not defined in the document)',
             code: /* GraphQL */ `
             query {
               user {
                 id
-                ...UserFields # fragment not defined in the document
+                ...UserFields
               }
             }
           `,
@@ -503,151 +459,153 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
           `,
         },
         {
-            title: 'Correct (`UserFields` fragment located in a separate file)',
+            title: 'Correct (existing import to UserFields fragment)',
             code: /* GraphQL */ `
-            # user.gql
+            #import '../UserFields.gql'
+
             query {
               user {
                 id
                 ...UserFields
               }
             }
-
-            # user-fields.gql
-            fragment UserFields on User {
-              id
-            }
           `,
         },
+        {
+            title: "False positive case\n\nFor extracting documents from code under the hood we use [graphql-tag-pluck](https://graphql-tools.com/docs/graphql-tag-pluck) that [don't support string interpolation](https://stackoverflow.com/questions/62749847/graphql-codegen-dynamic-fields-with-interpolation/62751311#62751311) for this moment.",
+            code: `
+            const USER_FIELDS = gql\`
+              fragment UserFields on User {
+                id
+              }
+            \`
+            
+            const GET_USER = /* GraphQL */ \`
+              # eslint @graphql-eslint/known-fragment-names: 'error'
+
+              query User {
+                user {
+                  ...UserFields
+                }
+              }
+
+              # Will give false positive error 'Unknown fragment "UserFields"'
+              \${USER_FIELDS}
+            \``,
+        },
     ],
-}, handleMissingFragments), validationToRule('known-type-names', 'KnownTypeNames', {
+}, importFiles), validationToRule('known-type-names', 'KnownTypeNames', {
     category: ['Schema', 'Operations'],
     description: `A GraphQL document is only valid if referenced types (specifically variable definitions and fragment conditions) are defined by the type schema.`,
-    requiresSchema: true,
 }), validationToRule('lone-anonymous-operation', 'LoneAnonymousOperation', {
     category: 'Operations',
     description: `A GraphQL document is only valid if when it contains an anonymous operation (the query short-hand) that it contains only that one operation definition.`,
-    requiresSchema: true,
 }), validationToRule('lone-schema-definition', 'LoneSchemaDefinition', {
     category: 'Schema',
     description: `A GraphQL document is only valid if it contains only one schema definition.`,
+    requiresSchema: false,
 }), validationToRule('no-fragment-cycles', 'NoFragmentCycles', {
     category: 'Operations',
     description: `A GraphQL fragment is only valid when it does not have cycles in fragments usage.`,
-    requiresSchema: true,
 }), validationToRule('no-undefined-variables', 'NoUndefinedVariables', {
     category: 'Operations',
     description: `A GraphQL operation is only valid if all variables encountered, both directly and via fragment spreads, are defined by that operation.`,
-    requiresSchema: true,
-    requiresSiblings: true,
-}, handleMissingFragments), validationToRule('no-unused-fragments', 'NoUnusedFragments', {
+}, importFiles), validationToRule('no-unused-fragments', 'NoUnusedFragments', {
     category: 'Operations',
     description: `A GraphQL document is only valid if all fragment definitions are spread within operations, or spread within other fragments spread within operations.`,
-    requiresSchema: true,
     requiresSiblings: true,
-}, ({ ruleId, context, schema, node }) => {
-    const siblings = requireSiblingsOperations(ruleId, context);
-    const FilePathToDocumentsMap = [...siblings.getOperations(), ...siblings.getFragments()].reduce((map, { filePath, document }) => {
-        var _a;
-        (_a = map[filePath]) !== null && _a !== void 0 ? _a : (map[filePath] = []);
-        map[filePath].push(document);
-        return map;
-    }, Object.create(null));
-    const getParentNode = (currentFilePath, node) => {
-        const { fragmentDefs } = getFragmentDefsAndFragmentSpreads(schema, node);
-        if (fragmentDefs.size === 0) {
-            return node;
+}, context => {
+    const siblings = requireSiblingsOperations('no-unused-fragments', context);
+    const documents = [...siblings.getOperations(), ...siblings.getFragments()]
+        .filter(({ document }) => isGraphQLImportFile(document.loc.source.body))
+        .map(({ filePath, document }) => ({
+        filePath,
+        code: document.loc.source.body,
+    }));
+    const getParentNode = (filePath) => {
+        for (const { filePath: docFilePath, code } of documents) {
+            const isFileImported = code
+                .split('\n')
+                .filter(isGraphQLImportFile)
+                .map(line => _import.parseImportLine(line.replace('#', '')))
+                .some(o => filePath === path.join(path.dirname(docFilePath), o.from));
+            if (!isFileImported) {
+                continue;
+            }
+            // Import first file that import this file
+            const document = _import.processImport(docFilePath);
+            // Import most top file that import this file
+            return getParentNode(docFilePath) || document;
         }
-        // skip iteration over documents for current filepath
-        delete FilePathToDocumentsMap[currentFilePath];
-        for (const [filePath, documents] of Object.entries(FilePathToDocumentsMap)) {
-            const missingFragments = getMissingFragments(schema, {
-                kind: graphql.Kind.DOCUMENT,
-                definitions: documents,
-            });
-            const isCurrentFileImportFragment = missingFragments.some(fragment => fragmentDefs.has(fragment));
-            if (isCurrentFileImportFragment) {
-                return getParentNode(filePath, {
-                    kind: graphql.Kind.DOCUMENT,
-                    definitions: [...node.definitions, ...documents],
-                });
-            }
-        }
-        return node;
+        return null;
     };
-    return getParentNode(context.getFilename(), node);
+    return getParentNode(context.getFilename());
 }), validationToRule('no-unused-variables', 'NoUnusedVariables', {
     category: 'Operations',
     description: `A GraphQL operation is only valid if all variables defined by an operation are used, either directly or within a spread fragment.`,
-    requiresSchema: true,
-    requiresSiblings: true,
-}, handleMissingFragments), validationToRule('overlapping-fields-can-be-merged', 'OverlappingFieldsCanBeMerged', {
+}, importFiles), validationToRule('overlapping-fields-can-be-merged', 'OverlappingFieldsCanBeMerged', {
     category: 'Operations',
     description: `A selection set is only valid if all fields (including spreading any fragments) either correspond to distinct response names or can be merged without ambiguity.`,
-    requiresSchema: true,
 }), validationToRule('possible-fragment-spread', 'PossibleFragmentSpreads', {
     category: 'Operations',
     description: `A fragment spread is only valid if the type condition could ever possibly be true: if there is a non-empty intersection of the possible parent types, and possible types which pass the type condition.`,
-    requiresSchema: true,
 }), validationToRule('possible-type-extension', 'PossibleTypeExtensions', {
     category: 'Schema',
     description: `A type extension is only valid if the type is defined and has the same kind.`,
+    requiresSchema: false,
     recommended: false, // TODO: enable after https://github.com/dotansimha/graphql-eslint/issues/787 will be fixed
 }), 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.`,
-    requiresSchema: true,
 }), validationToRule('scalar-leafs', 'ScalarLeafs', {
     category: 'Operations',
     description: `A GraphQL document is valid only if all leaf fields (fields without sub selections) are of scalar or enum types.`,
-    requiresSchema: true,
 }), validationToRule('one-field-subscriptions', 'SingleFieldSubscriptions', {
     category: 'Operations',
     description: `A GraphQL subscription is valid only if it contains a single root field.`,
-    requiresSchema: true,
 }), validationToRule('unique-argument-names', 'UniqueArgumentNames', {
     category: 'Operations',
     description: `A GraphQL field or directive is only valid if all supplied arguments are uniquely named.`,
-    requiresSchema: true,
 }), validationToRule('unique-directive-names', 'UniqueDirectiveNames', {
     category: 'Schema',
     description: `A GraphQL document is only valid if all defined directives have unique names.`,
+    requiresSchema: false,
 }), validationToRule('unique-directive-names-per-location', 'UniqueDirectivesPerLocation', {
     category: ['Schema', 'Operations'],
     description: `A GraphQL document is only valid if all non-repeatable directives at a given location are uniquely named.`,
-    requiresSchema: true,
 }), validationToRule('unique-enum-value-names', 'UniqueEnumValueNames', {
     category: 'Schema',
     description: `A GraphQL enum type is only valid if all its values are uniquely named.`,
+    requiresSchema: false,
     recommended: false,
 }), validationToRule('unique-field-definition-names', 'UniqueFieldDefinitionNames', {
     category: 'Schema',
     description: `A GraphQL complex type is only valid if all its fields are uniquely named.`,
+    requiresSchema: false,
 }), validationToRule('unique-input-field-names', 'UniqueInputFieldNames', {
     category: 'Operations',
     description: `A GraphQL input object value is only valid if all supplied fields are uniquely named.`,
+    requiresSchema: false,
 }), validationToRule('unique-operation-types', 'UniqueOperationTypes', {
     category: 'Schema',
     description: `A GraphQL document is only valid if it has only one type per operation.`,
+    requiresSchema: false,
 }), validationToRule('unique-type-names', 'UniqueTypeNames', {
     category: 'Schema',
     description: `A GraphQL document is only valid if all defined types have unique names.`,
+    requiresSchema: false,
 }), validationToRule('unique-variable-names', 'UniqueVariableNames', {
     category: 'Operations',
     description: `A GraphQL operation is only valid if all its variables are uniquely named.`,
-    requiresSchema: true,
 }), validationToRule('value-literals-of-correct-type', 'ValuesOfCorrectType', {
     category: 'Operations',
     description: `A GraphQL document is only valid if all value literals are of the type expected at their position.`,
-    requiresSchema: true,
 }), validationToRule('variables-are-input-types', 'VariablesAreInputTypes', {
     category: 'Operations',
     description: `A GraphQL operation is only valid if all the variables it defines are of input types (scalar, enum, or input object).`,
-    requiresSchema: true,
 }), validationToRule('variables-in-allowed-position', 'VariablesInAllowedPosition', {
     category: 'Operations',
     description: `Variables passed to field arguments conform to type.`,
-    requiresSchema: true,
 }));
 
 const ALPHABETIZE = 'ALPHABETIZE';
@@ -1081,13 +1039,7 @@ const rule$2 = {
 const MATCH_EXTENSION = 'MATCH_EXTENSION';
 const MATCH_STYLE = 'MATCH_STYLE';
 const ACCEPTED_EXTENSIONS = ['.gql', '.graphql'];
-const CASE_STYLES = [
-    CaseStyle.camelCase,
-    CaseStyle.pascalCase,
-    CaseStyle.snakeCase,
-    CaseStyle.upperCase,
-    CaseStyle.kebabCase,
-];
+const CASE_STYLES = ['camelCase', 'PascalCase', 'snake_case', 'UPPER_CASE', 'kebab-case'];
 const schemaOption = {
     oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
 };
@@ -1111,7 +1063,7 @@ const rule$3 = {
                 },
                 {
                     title: 'Correct',
-                    usage: [{ query: CaseStyle.snakeCase }],
+                    usage: [{ query: 'snake_case' }],
                     code: /* GraphQL */ `
             # user_by_id.gql
             query UserById {
@@ -1125,7 +1077,7 @@ const rule$3 = {
                 },
                 {
                     title: 'Correct',
-                    usage: [{ fragment: { style: CaseStyle.kebabCase, suffix: '.fragment' } }],
+                    usage: [{ fragment: { style: 'kebab-case', suffix: '.fragment' } }],
                     code: /* GraphQL */ `
             # user-fields.fragment.gql
             fragment user_fields on User {
@@ -1136,7 +1088,7 @@ const rule$3 = {
                 },
                 {
                     title: 'Correct',
-                    usage: [{ mutation: { style: CaseStyle.pascalCase, suffix: 'Mutation' } }],
+                    usage: [{ mutation: { style: 'PascalCase', suffix: 'Mutation' } }],
                     code: /* GraphQL */ `
             # DeleteUserMutation.gql
             mutation DELETE_USER {
@@ -1156,7 +1108,7 @@ const rule$3 = {
                 },
                 {
                     title: 'Incorrect',
-                    usage: [{ query: CaseStyle.pascalCase }],
+                    usage: [{ query: 'PascalCase' }],
                     code: /* GraphQL */ `
             # user-by-id.gql
             query UserById {
@@ -1171,10 +1123,10 @@ const rule$3 = {
             ],
             configOptions: [
                 {
-                    query: CaseStyle.kebabCase,
-                    mutation: CaseStyle.kebabCase,
-                    subscription: CaseStyle.kebabCase,
-                    fragment: CaseStyle.kebabCase,
+                    query: 'kebab-case',
+                    mutation: 'kebab-case',
+                    subscription: 'kebab-case',
+                    fragment: 'kebab-case',
                 },
             ],
         },
@@ -1191,25 +1143,22 @@ const rule$3 = {
                 asObject: {
                     type: 'object',
                     additionalProperties: false,
+                    minProperties: 1,
                     properties: {
-                        style: {
-                            enum: CASE_STYLES,
-                        },
-                        suffix: {
-                            type: 'string',
-                        },
+                        style: { enum: CASE_STYLES },
+                        suffix: { type: 'string' },
                     },
                 },
             },
             type: 'array',
+            minItems: 1,
             maxItems: 1,
             items: {
                 type: 'object',
                 additionalProperties: false,
+                minProperties: 1,
                 properties: {
-                    fileExtension: {
-                        enum: ACCEPTED_EXTENSIONS,
-                    },
+                    fileExtension: { enum: ACCEPTED_EXTENSIONS },
                     query: schemaOption,
                     mutation: schemaOption,
                     subscription: schemaOption,
@@ -1264,7 +1213,7 @@ const rule$3 = {
                     option = { style: option };
                 }
                 const expectedExtension = options.fileExtension || fileExtension;
-                const expectedFilename = convertCase(option.style, docName) + (option.suffix || '') + expectedExtension;
+                const expectedFilename = (option.style ? convertCase(option.style, docName) : filename) + (option.suffix || '') + expectedExtension;
                 const filenameWithExtension = filename + expectedExtension;
                 if (expectedFilename !== filenameWithExtension) {
                     context.report({
@@ -1416,6 +1365,7 @@ const rule$4 = {
                 ],
             },
         },
+        hasSuggestions: true,
         schema: {
             definitions: {
                 asString: {
@@ -1490,65 +1440,87 @@ const rule$4 = {
             const style = restOptions[kind] || types;
             return typeof style === 'object' ? style : { style };
         }
-        const checkNode = (selector) => (node) => {
-            const { name } = node.kind === graphql.Kind.VARIABLE_DEFINITION ? node.variable : node;
-            if (!name) {
+        const checkNode = (selector) => (n) => {
+            const { name: node } = n.kind === graphql.Kind.VARIABLE_DEFINITION ? n.variable : n;
+            if (!node) {
                 return;
             }
             const { prefix, suffix, forbiddenPrefixes, forbiddenSuffixes, style } = normalisePropertyOption(selector);
-            const nodeType = KindToDisplayName[node.kind] || node.kind;
-            const nodeName = name.value;
-            const errorMessage = getErrorMessage();
-            if (errorMessage) {
+            const nodeType = KindToDisplayName[n.kind] || n.kind;
+            const nodeName = node.value;
+            const error = getError();
+            if (error) {
+                const { errorMessage, renameToName } = error;
                 context.report({
-                    loc: getLocation(name.loc, name.value),
+                    loc: getLocation(node.loc, node.value),
                     message: `${nodeType} "${nodeName}" should ${errorMessage}`,
+                    suggest: [
+                        {
+                            desc: `Rename to "${renameToName}"`,
+                            fix: fixer => fixer.replaceText(node, renameToName),
+                        },
+                    ],
                 });
             }
-            function getErrorMessage() {
-                let name = nodeName;
-                if (allowLeadingUnderscore) {
-                    name = name.replace(/^_*/, '');
-                }
-                if (allowTrailingUnderscore) {
-                    name = name.replace(/_*$/, '');
-                }
+            function getError() {
+                const name = nodeName.replace(/(^_+)|(_+$)/g, '');
                 if (prefix && !name.startsWith(prefix)) {
-                    return `have "${prefix}" prefix`;
+                    return {
+                        errorMessage: `have "${prefix}" prefix`,
+                        renameToName: prefix + nodeName,
+                    };
                 }
                 if (suffix && !name.endsWith(suffix)) {
-                    return `have "${suffix}" suffix`;
+                    return {
+                        errorMessage: `have "${suffix}" suffix`,
+                        renameToName: nodeName + suffix,
+                    };
                 }
                 const forbiddenPrefix = forbiddenPrefixes === null || forbiddenPrefixes === void 0 ? void 0 : forbiddenPrefixes.find(prefix => name.startsWith(prefix));
                 if (forbiddenPrefix) {
-                    return `not have "${forbiddenPrefix}" prefix`;
+                    return {
+                        errorMessage: `not have "${forbiddenPrefix}" prefix`,
+                        renameToName: nodeName.replace(new RegExp(`^${forbiddenPrefix}`), ''),
+                    };
                 }
                 const forbiddenSuffix = forbiddenSuffixes === null || forbiddenSuffixes === void 0 ? void 0 : forbiddenSuffixes.find(suffix => name.endsWith(suffix));
                 if (forbiddenSuffix) {
-                    return `not have "${forbiddenSuffix}" suffix`;
-                }
-                if (style && !ALLOWED_STYLES.includes(style)) {
-                    return `be in one of the following options: ${ALLOWED_STYLES.join(', ')}`;
+                    return {
+                        errorMessage: `not have "${forbiddenSuffix}" suffix`,
+                        renameToName: nodeName.replace(new RegExp(`${forbiddenSuffix}$`), ''),
+                    };
                 }
                 const caseRegex = StyleToRegex[style];
                 if (caseRegex && !caseRegex.test(name)) {
-                    return `be in ${style} format`;
+                    return {
+                        errorMessage: `be in ${style} format`,
+                        renameToName: convertCase(style, nodeName),
+                    };
                 }
             }
         };
-        const checkUnderscore = (node) => {
+        const checkUnderscore = (isLeading) => (node) => {
             const name = node.value;
+            const renameToName = name.replace(new RegExp(isLeading ? '^_+' : '_+$'), '');
             context.report({
                 loc: getLocation(node.loc, name),
-                message: `${name.startsWith('_') ? 'Leading' : 'Trailing'} underscores are not allowed`,
+                message: `${isLeading ? 'Leading' : 'Trailing'} underscores are not allowed`,
+                suggest: [
+                    {
+                        desc: `Rename to "${renameToName}"`,
+                        fix: fixer => fixer.replaceText(node, renameToName),
+                    },
+                ],
             });
         };
         const listeners = {};
         if (!allowLeadingUnderscore) {
-            listeners['Name[value=/^_/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] = checkUnderscore;
+            listeners['Name[value=/^_/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] =
+                checkUnderscore(true);
         }
         if (!allowTrailingUnderscore) {
-            listeners['Name[value=/_$/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] = checkUnderscore;
+            listeners['Name[value=/_$/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] =
+                checkUnderscore(false);
         }
         const selectors = new Set([types && TYPES_KINDS, Object.keys(restOptions)].flat().filter(Boolean));
         for (const selector of selectors) {