@graphql-eslint/eslint-plugin 2.4.0-alpha-60dfe26.0 → 3.0.0-alpha-5388f29.0

package/index.mjs

@@ -9,6 +9,8 @@ import depthLimit from 'graphql-depth-limit';
 import { parseCode } from '@graphql-tools/graphql-tag-pluck';
 import { loadConfigSync, GraphQLConfig } from 'graphql-config';
 import { CodeFileLoader } from '@graphql-tools/code-file-loader';
+import { RuleTester, Linter } from 'eslint';
+import { codeFrameColumns } from '@babel/code-frame';
 
 /*
  * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
@@ -27,7 +29,34 @@ const recommendedConfig = {
         '@graphql-eslint/known-type-names': 'error',
         '@graphql-eslint/lone-anonymous-operation': 'error',
         '@graphql-eslint/lone-schema-definition': 'error',
-        '@graphql-eslint/naming-convention': 'error',
+        '@graphql-eslint/naming-convention': [
+            'error',
+            {
+                types: 'PascalCase',
+                fields: 'camelCase',
+                overrides: {
+                    EnumValueDefinition: 'UPPER_CASE',
+                    OperationDefinition: {
+                        style: 'PascalCase',
+                        forbiddenPrefixes: ['Query', 'Mutation', 'Subscription', 'Get'],
+                        forbiddenSuffixes: ['Query', 'Mutation', 'Subscription'],
+                    },
+                    FragmentDefinition: { style: 'PascalCase', forbiddenPrefixes: ['Fragment'], forbiddenSuffixes: ['Fragment'] },
+                    '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-anonymous-operations': 'error',
         '@graphql-eslint/no-case-insensitive-enum-values-duplicates': 'error',
         '@graphql-eslint/no-fragment-cycles': 'error',
@@ -203,9 +232,14 @@ const loaderCache = new Proxy(Object.create(null), {
         return true;
     },
 });
-const isObjectType = (node) => [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION].includes(node.type);
-const isQueryType = (node) => isObjectType(node) && node.name.value === 'Query';
-const isMutationType = (node) => isObjectType(node) && node.name.value === 'Mutation';
+const TYPES_KINDS = [
+    Kind.OBJECT_TYPE_DEFINITION,
+    Kind.INTERFACE_TYPE_DEFINITION,
+    Kind.ENUM_TYPE_DEFINITION,
+    Kind.SCALAR_TYPE_DEFINITION,
+    Kind.INPUT_OBJECT_TYPE_DEFINITION,
+    Kind.UNION_TYPE_DEFINITION,
+];
 var CaseStyle;
 (function (CaseStyle) {
     CaseStyle["camelCase"] = "camelCase";
@@ -236,9 +270,27 @@ const convertCase = (style, str) => {
             return lowerCase(str).replace(/ /g, '-');
     }
 };
+function getLocation(loc, fieldName = '', offset) {
+    const { start } = loc;
+    /*
+     * ESLint has 0-based column number
+     * https://eslint.org/docs/developer-guide/working-with-rules#contextreport
+     */
+    const { offsetStart = 1, offsetEnd = 1 } = offset !== null && offset !== void 0 ? offset : {};
+    return {
+        start: {
+            line: start.line,
+            column: start.column - offsetStart,
+        },
+        end: {
+            line: start.line,
+            column: start.column - offsetEnd + fieldName.length,
+        },
+    };
+}
 
 function extractRuleName(stack) {
-    const match = (stack || '').match(/validation[/\\\\]rules[/\\\\](.*?)\.js:/) || [];
+    const match = (stack || '').match(/validation[/\\]rules[/\\](.*?)\.js:/) || [];
     return match[1] || null;
 }
 function validateDoc(sourceNode, context, schema, documentNode, rules, ruleName = null) {
@@ -249,7 +301,7 @@ function validateDoc(sourceNode, context, schema, documentNode, rules, ruleName
             for (const error of validationErrors) {
                 const validateRuleName = ruleName || `[${extractRuleName(error.stack)}]`;
                 context.report({
-                    loc: error.locations[0],
+                    loc: getLocation({ start: error.locations[0] }),
                     message: ruleName ? error.message : `${validateRuleName} ${error.message}`,
                 });
             }
@@ -286,6 +338,7 @@ const validationToRule = (name, ruleName, docs, getDocumentNode) => {
             meta: {
                 docs: {
                     ...docs,
+                    graphQLJSRuleName: ruleName,
                     category: 'Validation',
                     recommended: true,
                     requiresSchema,
@@ -585,7 +638,7 @@ const rule = {
             ],
         },
         messages: {
-            [ALPHABETIZE]: '"{{ currName }}" should be before "{{ prevName }}".',
+            [ALPHABETIZE]: '"{{ currName }}" should be before "{{ prevName }}"',
         },
         schema: {
             type: 'array',
@@ -598,38 +651,48 @@ const rule = {
                 properties: {
                     fields: {
                         type: 'array',
-                        contains: {
+                        uniqueItems: true,
+                        minItems: 1,
+                        items: {
                             enum: fieldsEnum,
                         },
-                        description: 'Fields of `type`, `interface`, and `input`.',
+                        description: 'Fields of `type`, `interface`, and `input`',
                     },
                     values: {
                         type: 'array',
-                        contains: {
+                        uniqueItems: true,
+                        minItems: 1,
+                        items: {
                             enum: valuesEnum,
                         },
-                        description: 'Values of `enum`.',
+                        description: 'Values of `enum`',
                     },
                     selections: {
                         type: 'array',
-                        contains: {
+                        uniqueItems: true,
+                        minItems: 1,
+                        items: {
                             enum: selectionsEnum,
                         },
-                        description: 'Selections of operations (`query`, `mutation` and `subscription`) and `fragment`.',
+                        description: 'Selections of operations (`query`, `mutation` and `subscription`) and `fragment`',
                     },
                     variables: {
                         type: 'array',
-                        contains: {
+                        uniqueItems: true,
+                        minItems: 1,
+                        items: {
                             enum: variablesEnum,
                         },
-                        description: 'Variables of operations (`query`, `mutation` and `subscription`).',
+                        description: 'Variables of operations (`query`, `mutation` and `subscription`)',
                     },
                     arguments: {
                         type: 'array',
-                        contains: {
+                        uniqueItems: true,
+                        minItems: 1,
+                        items: {
                             enum: argumentsEnum,
                         },
-                        description: 'Arguments of fields and directives.',
+                        description: 'Arguments of fields and directives',
                     },
                 },
             },
@@ -642,16 +705,9 @@ const rule = {
             for (const node of nodes) {
                 const currName = node.name.value;
                 if (prevName && prevName > currName) {
-                    const { start, end } = node.name.loc;
                     const isVariableNode = node.kind === Kind.VARIABLE;
                     context.report({
-                        loc: {
-                            start: {
-                                line: start.line,
-                                column: start.column - (isVariableNode ? 2 : 1),
-                            },
-                            end,
-                        },
+                        loc: getLocation(node.loc, node.name.value, { offsetEnd: isVariableNode ? 0 : 1 }),
                         messageId: ALPHABETIZE,
                         data: isVariableNode
                             ? {
@@ -667,7 +723,7 @@ const rule = {
         const opts = context.options[0];
         const fields = new Set((_a = opts.fields) !== null && _a !== void 0 ? _a : []);
         const listeners = {};
-        const fieldsSelector = [
+        const kinds = [
             fields.has(Kind.OBJECT_TYPE_DEFINITION) && [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION],
             fields.has(Kind.INTERFACE_TYPE_DEFINITION) && [Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION],
             fields.has(Kind.INPUT_OBJECT_TYPE_DEFINITION) && [
@@ -675,8 +731,9 @@ const rule = {
                 Kind.INPUT_OBJECT_TYPE_EXTENSION,
             ],
         ]
-            .flat()
-            .join(',');
+            .filter(Boolean)
+            .flat();
+        const fieldsSelector = kinds.join(',');
         const hasEnumValues = ((_b = opts.values) === null || _b === void 0 ? void 0 : _b[0]) === Kind.ENUM_TYPE_DEFINITION;
         const selectionsSelector = (_c = opts.selections) === null || _c === void 0 ? void 0 : _c.join(',');
         const hasVariables = ((_d = opts.variables) === null || _d === void 0 ? void 0 : _d[0]) === Kind.OPERATION_DEFINITION;
@@ -717,35 +774,22 @@ const rule = {
 };
 
 const AVOID_DUPLICATE_FIELDS = 'AVOID_DUPLICATE_FIELDS';
-const ensureUnique = () => {
-    const set = new Set();
-    return {
-        add: (item, onError) => {
-            if (set.has(item)) {
-                onError();
-            }
-            else {
-                set.add(item);
-            }
-        },
-    };
-};
 const rule$1 = {
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Checks for duplicate fields in selection set, variables in operation definition, or in arguments set of a field.',
+            description: `Checks for duplicate fields in selection set, variables in operation definition, or in arguments set of a field.`,
             category: 'Stylistic Issues',
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/avoid-duplicate-fields.md',
             examples: [
                 {
                     title: 'Incorrect',
                     code: /* GraphQL */ `
-            query getUserDetails {
+            query {
               user {
-                name # first
+                name
                 email
-                name # second
+                name # duplicate field
               }
             }
           `,
@@ -753,7 +797,7 @@ const rule$1 = {
                 {
                     title: 'Incorrect',
                     code: /* GraphQL */ `
-            query getUsers {
+            query {
               users(
                 first: 100
                 skip: 50
@@ -768,9 +812,11 @@ const rule$1 = {
                 {
                     title: 'Incorrect',
                     code: /* GraphQL */ `
-            query getUsers($first: Int!, $first: Int!) {
-              # Duplicate variable
-              users(first: 100, skip: 50, after: "cji629tngfgou0b73kt7vi5jo") {
+            query (
+              $first: Int!
+              $first: Int! # duplicate variable
+            ) {
+              users(first: $first, skip: 50) {
                 id
               }
             }
@@ -779,58 +825,47 @@ const rule$1 = {
             ],
         },
         messages: {
-            [AVOID_DUPLICATE_FIELDS]: `{{ type }} "{{ fieldName }}" defined multiple times.`,
+            [AVOID_DUPLICATE_FIELDS]: `{{ type }} "{{ fieldName }}" defined multiple times`,
         },
         schema: [],
     },
     create(context) {
+        function checkNode(usedFields, fieldName, type, node) {
+            if (usedFields.has(fieldName)) {
+                context.report({
+                    loc: getLocation((node.kind === Kind.FIELD && node.alias ? node.alias : node).loc, fieldName, {
+                        offsetEnd: node.kind === Kind.VARIABLE_DEFINITION ? 0 : 1,
+                    }),
+                    messageId: AVOID_DUPLICATE_FIELDS,
+                    data: {
+                        type,
+                        fieldName,
+                    },
+                });
+            }
+            else {
+                usedFields.add(fieldName);
+            }
+        }
         return {
             OperationDefinition(node) {
-                const uniqueCheck = ensureUnique();
-                for (const arg of node.variableDefinitions || []) {
-                    uniqueCheck.add(arg.variable.name.value, () => {
-                        context.report({
-                            messageId: AVOID_DUPLICATE_FIELDS,
-                            data: {
-                                type: 'Operation variable',
-                                fieldName: arg.variable.name.value,
-                            },
-                            node: arg,
-                        });
-                    });
+                const set = new Set();
+                for (const varDef of node.variableDefinitions) {
+                    checkNode(set, varDef.variable.name.value, 'Operation variable', varDef);
                 }
             },
             Field(node) {
-                const uniqueCheck = ensureUnique();
-                for (const arg of node.arguments || []) {
-                    uniqueCheck.add(arg.name.value, () => {
-                        context.report({
-                            messageId: AVOID_DUPLICATE_FIELDS,
-                            data: {
-                                type: 'Field argument',
-                                fieldName: arg.name.value,
-                            },
-                            node: arg,
-                        });
-                    });
+                const set = new Set();
+                for (const arg of node.arguments) {
+                    checkNode(set, arg.name.value, 'Field argument', arg);
                 }
             },
             SelectionSet(node) {
                 var _a;
-                const uniqueCheck = ensureUnique();
-                for (const selection of node.selections || []) {
+                const set = new Set();
+                for (const selection of node.selections) {
                     if (selection.kind === Kind.FIELD) {
-                        const nameToCheck = ((_a = selection.alias) === null || _a === void 0 ? void 0 : _a.value) || selection.name.value;
-                        uniqueCheck.add(nameToCheck, () => {
-                            context.report({
-                                messageId: AVOID_DUPLICATE_FIELDS,
-                                data: {
-                                    type: 'Field',
-                                    fieldName: nameToCheck,
-                                },
-                                node: selection,
-                            });
-                        });
+                        checkNode(set, ((_a = selection.alias) === null || _a === void 0 ? void 0 : _a.value) || selection.name.value, 'Field', selection);
                     }
                 }
             },
@@ -961,16 +996,20 @@ const rule$3 = {
         if (!mutationType) {
             return {};
         }
-        const selector = `:matches(${Kind.OBJECT_TYPE_DEFINITION}, ${Kind.OBJECT_TYPE_EXTENSION})[name.value=${mutationType.name}] > ${Kind.FIELD_DEFINITION}`;
+        const selector = [
+            `:matches(${Kind.OBJECT_TYPE_DEFINITION}, ${Kind.OBJECT_TYPE_EXTENSION})[name.value=${mutationType.name}]`,
+            '>',
+            Kind.FIELD_DEFINITION,
+            Kind.NAMED_TYPE,
+        ].join(' ');
         return {
             [selector](node) {
-                const rawNode = node.rawNode();
-                const typeName = getTypeName(rawNode);
+                const typeName = node.name.value;
                 const graphQLType = schema.getType(typeName);
                 if (isScalarType(graphQLType)) {
                     context.report({
-                        node,
-                        message: `Unexpected scalar result type "${typeName}".`,
+                        loc: getLocation(node.loc, typeName),
+                        message: `Unexpected scalar result type "${typeName}"`,
                     });
                 }
             },
@@ -1019,23 +1058,13 @@ const rule$4 = {
                 for (const field of node.fields) {
                     const fieldName = field.name.value;
                     if (fieldName.toLowerCase().startsWith(lowerTypeName)) {
-                        const { start } = field.loc;
                         context.report({
                             data: {
                                 fieldName,
                                 typeName,
                             },
                             messageId: AVOID_TYPENAME_PREFIX,
-                            loc: {
-                                start: {
-                                    line: start.line,
-                                    column: start.column - 1,
-                                },
-                                end: {
-                                    line: start.line,
-                                    column: start.column - 1 + lowerTypeName.length,
-                                },
-                            },
+                            loc: getLocation(field.loc, lowerTypeName),
                         });
                     }
                 }
@@ -1095,7 +1124,7 @@ const rule$5 = {
             '[description.type="StringValue"]': node => {
                 if (node.description.block !== (style === 'block')) {
                     context.report({
-                        node: node.description,
+                        loc: getLocation(node.description.loc),
                         message: `Unexpected ${wrongDescriptionType} description`,
                     });
                 }
@@ -1104,6 +1133,9 @@ const rule$5 = {
     },
 };
 
+const isObjectType = (node) => [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION].includes(node.type);
+const isQueryType = (node) => isObjectType(node) && node.name.value === 'Query';
+const isMutationType = (node) => isObjectType(node) && node.name.value === 'Mutation';
 const rule$6 = {
     meta: {
         type: 'suggestion',
@@ -1144,6 +1176,7 @@ const rule$6 = {
         schema: [
             {
                 type: 'object',
+                additionalProperties: false,
                 properties: {
                     checkInputType: {
                         type: 'boolean',
@@ -1166,35 +1199,34 @@ const rule$6 = {
                         description: 'Apply the rule to Mutations',
                     },
                 },
-                additionalProperties: false,
             },
         ],
     },
     create(context) {
-        var _a;
         const options = {
-            caseSensitiveInputType: true,
             checkInputType: false,
-            checkMutations: true,
+            caseSensitiveInputType: true,
             checkQueries: false,
-            ...(_a = context === null || context === void 0 ? void 0 : context.options) === null || _a === void 0 ? void 0 : _a[0],
+            checkMutations: true,
+            ...context.options[0],
         };
         const shouldCheckType = node => (options.checkMutations && isMutationType(node)) || (options.checkQueries && isQueryType(node));
         const listeners = {
-            'FieldDefinition > InputValueDefinition': node => {
-                if (node.name.value !== 'input' && shouldCheckType(node.parent.parent)) {
+            'FieldDefinition > InputValueDefinition[name.value!=input]'(node) {
+                if (shouldCheckType(node.parent.parent)) {
+                    const name = node.name.value;
                     context.report({
-                        node: node.name,
-                        message: `Input "${node.name.value}" should be called "input"`,
+                        loc: getLocation(node.loc, name),
+                        message: `Input "${name}" should be called "input"`,
                     });
                 }
             },
         };
-        if (options === null || options === void 0 ? void 0 : options.checkInputType) {
-            listeners['FieldDefinition > InputValueDefinition NamedType'] = node => {
+        if (options.checkInputType) {
+            listeners['FieldDefinition > InputValueDefinition NamedType'] = (node) => {
                 const findInputType = item => {
                     let currentNode = item;
-                    while (currentNode.type !== 'InputValueDefinition') {
+                    while (currentNode.type !== Kind.INPUT_VALUE_DEFINITION) {
                         currentNode = currentNode.parent;
                     }
                     return currentNode;
@@ -1202,11 +1234,12 @@ const rule$6 = {
                 const inputValueNode = findInputType(node);
                 if (shouldCheckType(inputValueNode.parent.parent)) {
                     const mutationName = `${inputValueNode.parent.name.value}Input`;
+                    const name = node.name.value;
                     if ((options.caseSensitiveInputType && node.name.value !== mutationName) ||
-                        node.name.value.toLowerCase() !== mutationName.toLowerCase()) {
+                        name.toLowerCase() !== mutationName.toLowerCase()) {
                         context.report({
-                            node,
-                            message: `InputType "${node.name.value}" name should be "${mutationName}"`,
+                            loc: getLocation(node.loc, name),
+                            message: `InputType "${name}" name should be "${mutationName}"`,
                         });
                     }
                 }
@@ -1363,7 +1396,8 @@ const rule$7 = {
                 var _a;
                 if (options.fileExtension && options.fileExtension !== fileExtension) {
                     context.report({
-                        node: documentNode,
+                        // Report on first character
+                        loc: { column: 0, line: 1 },
                         messageId: MATCH_EXTENSION,
                         data: {
                             fileExtension,
@@ -1395,7 +1429,8 @@ const rule$7 = {
                 const filenameWithExtension = filename + expectedExtension;
                 if (expectedFilename !== filenameWithExtension) {
                     context.report({
-                        node: documentNode,
+                        // Report on first character
+                        loc: { column: 0, line: 1 },
                         messageId: MATCH_STYLE,
                         data: {
                             expectedFilename,
@@ -1408,69 +1443,40 @@ const rule$7 = {
     },
 };
 
-const formats = {
-    camelCase: /^[a-z][^_]*$/g,
-    PascalCase: /^[A-Z][^_]*$/g,
-    snake_case: /^[a-z_][a-z0-9_]*$/g,
-    UPPER_CASE: /^[A-Z_][A-Z0-9_]*$/g,
-};
-const acceptedStyles = [
-    'camelCase',
-    'PascalCase',
-    'snake_case',
-    'UPPER_CASE',
+const FIELDS_KINDS = [
+    Kind.FIELD_DEFINITION,
+    Kind.INPUT_VALUE_DEFINITION,
+    Kind.VARIABLE_DEFINITION,
+    Kind.ARGUMENT,
+    Kind.DIRECTIVE_DEFINITION,
 ];
-function checkNameFormat(params) {
-    const { value, style, leadingUnderscore, trailingUnderscore, suffix, prefix, forbiddenPrefixes, forbiddenSuffixes, } = params;
-    let name = value;
-    if (leadingUnderscore === 'allow') {
-        [, name] = name.match(/^_*(.*)$/);
-    }
-    if (trailingUnderscore === 'allow') {
-        name = name.replace(/_*$/, '');
-    }
-    if (prefix && !name.startsWith(prefix)) {
-        return {
-            ok: false,
-            errorMessage: '{{nodeType}} name "{{nodeName}}" should have "{{prefix}}" prefix',
-        };
-    }
-    if (suffix && !name.endsWith(suffix)) {
-        return {
-            ok: false,
-            errorMessage: '{{nodeType}} name "{{nodeName}}" should have "{{suffix}}" suffix',
-        };
-    }
-    if (style && !acceptedStyles.includes(style)) {
-        return {
-            ok: false,
-            errorMessage: `{{nodeType}} name "{{nodeName}}" should be in one of the following options: ${acceptedStyles.join(',')}`,
-        };
-    }
-    if (forbiddenPrefixes.some(forbiddenPrefix => name.startsWith(forbiddenPrefix))) {
-        return {
-            ok: false,
-            errorMessage: '{{nodeType}} "{{nodeName}}" should not have one of the following prefix(es): {{forbiddenPrefixes}}',
-        };
-    }
-    if (forbiddenSuffixes.some(forbiddenSuffix => name.endsWith(forbiddenSuffix))) {
-        return {
-            ok: false,
-            errorMessage: '{{nodeType}} "{{nodeName}}" should not have one of the following suffix(es): {{forbiddenSuffixes}}',
-        };
-    }
-    if (!formats[style]) {
-        return { ok: true };
-    }
-    const ok = new RegExp(formats[style]).test(name);
-    if (ok) {
-        return { ok: true };
-    }
-    return {
-        ok: false,
-        errorMessage: '{{nodeType}} name "{{nodeName}}" should be in {{format}} format',
-    };
-}
+const KindToDisplayName = {
+    // types
+    [Kind.OBJECT_TYPE_DEFINITION]: 'Type',
+    [Kind.INTERFACE_TYPE_DEFINITION]: 'Interface',
+    [Kind.ENUM_TYPE_DEFINITION]: 'Enumerator',
+    [Kind.SCALAR_TYPE_DEFINITION]: 'Scalar',
+    [Kind.INPUT_OBJECT_TYPE_DEFINITION]: 'Input type',
+    [Kind.UNION_TYPE_DEFINITION]: 'Union',
+    // fields
+    [Kind.FIELD_DEFINITION]: 'Field',
+    [Kind.INPUT_VALUE_DEFINITION]: 'Input property',
+    [Kind.VARIABLE_DEFINITION]: 'Variable',
+    [Kind.ARGUMENT]: 'Argument',
+    [Kind.DIRECTIVE_DEFINITION]: 'Directive',
+    // rest
+    [Kind.ENUM_VALUE_DEFINITION]: 'Enumeration value',
+    [Kind.OPERATION_DEFINITION]: 'Operation',
+    [Kind.FRAGMENT_DEFINITION]: 'Fragment',
+};
+const StyleToRegex = {
+    camelCase: /^[a-z][\dA-Za-z]*$/,
+    PascalCase: /^[A-Z][\dA-Za-z]*$/,
+    snake_case: /^[a-z][\d_a-z]*[\da-z]$/,
+    UPPER_CASE: /^[A-Z][\dA-Z_]*[\dA-Z]$/,
+};
+const ALLOWED_KINDS = Object.keys(KindToDisplayName).sort();
+const ALLOWED_STYLES = Object.keys(StyleToRegex);
 const schemaOption$1 = {
     oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
 };
@@ -1485,89 +1491,120 @@ const rule$8 = {
             examples: [
                 {
                     title: 'Incorrect',
-                    usage: [{ ObjectTypeDefinition: 'PascalCase' }],
+                    usage: [{ types: 'PascalCase', fields: 'camelCase' }],
                     code: /* GraphQL */ `
-            type someTypeName {
-              f: String!
+            type user {
+              first_name: String!
             }
           `,
                 },
                 {
                     title: 'Correct',
-                    usage: [{ FieldDefinition: 'camelCase', ObjectTypeDefinition: 'PascalCase' }],
+                    usage: [{ types: 'PascalCase', fields: 'camelCase' }],
                     code: /* GraphQL */ `
-            type SomeTypeName {
-              someFieldName: String
+            type User {
+              firstName: String
             }
           `,
                 },
             ],
+            optionsForConfig: [
+                {
+                    types: 'PascalCase',
+                    fields: 'camelCase',
+                    overrides: {
+                        EnumValueDefinition: 'UPPER_CASE',
+                        OperationDefinition: {
+                            style: 'PascalCase',
+                            forbiddenPrefixes: ['Query', 'Mutation', 'Subscription', 'Get'],
+                            forbiddenSuffixes: ['Query', 'Mutation', 'Subscription'],
+                        },
+                        FragmentDefinition: {
+                            style: 'PascalCase',
+                            forbiddenPrefixes: ['Fragment'],
+                            forbiddenSuffixes: ['Fragment'],
+                        },
+                        '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'],
+                        },
+                    },
+                },
+            ],
         },
         schema: {
             definitions: {
                 asString: {
-                    type: 'string',
-                    description: `One of: ${acceptedStyles.map(t => `\`${t}\``).join(', ')}`,
-                    enum: acceptedStyles,
+                    enum: ALLOWED_STYLES,
+                    description: `One of: ${ALLOWED_STYLES.map(t => `\`${t}\``).join(', ')}`,
                 },
                 asObject: {
                     type: 'object',
+                    additionalProperties: false,
                     properties: {
-                        style: {
-                            type: 'string',
-                            enum: acceptedStyles,
-                        },
-                        prefix: {
-                            type: 'string',
-                        },
-                        suffix: {
-                            type: 'string',
-                        },
+                        style: { enum: ALLOWED_STYLES },
+                        prefix: { type: 'string' },
+                        suffix: { type: 'string' },
                         forbiddenPrefixes: {
-                            additionalItems: false,
                             type: 'array',
+                            uniqueItems: true,
                             minItems: 1,
-                            items: {
-                                type: 'string',
-                            },
+                            items: { type: 'string' },
                         },
                         forbiddenSuffixes: {
-                            additionalItems: false,
                             type: 'array',
+                            uniqueItems: true,
                             minItems: 1,
-                            items: {
-                                type: 'string',
-                            },
+                            items: { type: 'string' },
                         },
                     },
                 },
             },
-            $schema: 'http://json-schema.org/draft-04/schema#',
             type: 'array',
+            maxItems: 1,
             items: {
                 type: 'object',
+                additionalProperties: false,
                 properties: {
-                    [Kind.FIELD_DEFINITION]: schemaOption$1,
-                    [Kind.INPUT_OBJECT_TYPE_DEFINITION]: schemaOption$1,
-                    [Kind.ENUM_VALUE_DEFINITION]: schemaOption$1,
-                    [Kind.INPUT_VALUE_DEFINITION]: schemaOption$1,
-                    [Kind.OBJECT_TYPE_DEFINITION]: schemaOption$1,
-                    [Kind.INTERFACE_TYPE_DEFINITION]: schemaOption$1,
-                    [Kind.ENUM_TYPE_DEFINITION]: schemaOption$1,
-                    [Kind.UNION_TYPE_DEFINITION]: schemaOption$1,
-                    [Kind.SCALAR_TYPE_DEFINITION]: schemaOption$1,
-                    [Kind.OPERATION_DEFINITION]: schemaOption$1,
-                    [Kind.FRAGMENT_DEFINITION]: schemaOption$1,
-                    QueryDefinition: schemaOption$1,
-                    leadingUnderscore: {
-                        type: 'string',
-                        enum: ['allow', 'forbid'],
-                        default: 'forbid',
+                    types: {
+                        ...schemaOption$1,
+                        description: `Includes:\n\n${TYPES_KINDS.map(kind => `- \`${kind}\``).join('\n')}`,
                     },
-                    trailingUnderscore: {
-                        type: 'string',
-                        enum: ['allow', 'forbid'],
-                        default: 'forbid',
+                    fields: {
+                        ...schemaOption$1,
+                        description: `Includes:\n\n${FIELDS_KINDS.map(kind => `- \`${kind}\``).join('\n')}`,
+                    },
+                    allowLeadingUnderscore: {
+                        type: 'boolean',
+                        default: false,
+                    },
+                    allowTrailingUnderscore: {
+                        type: 'boolean',
+                        default: false,
+                    },
+                    overrides: {
+                        type: 'object',
+                        additionalProperties: false,
+                        description: [
+                            'May contain the following `ASTNode` names:',
+                            '',
+                            ...ALLOWED_KINDS.map(kind => `- \`${kind}\``),
+                            '',
+                            "> It's also possible to use a [`selector`](https://eslint.org/docs/developer-guide/selectors) that starts with `ASTNode` name",
+                            '>',
+                            '> Example: pattern property `FieldDefinition[parent.name.value=Query]` will match only fields for type `Query`',
+                        ].join('\n'),
+                        patternProperties: {
+                            [`^(${ALLOWED_KINDS.join('|')})(.+)?$`]: schemaOption$1,
+                        },
                     },
                 },
             },
@@ -1575,130 +1612,83 @@ const rule$8 = {
     },
     create(context) {
         const options = {
-            leadingUnderscore: 'forbid',
-            trailingUnderscore: 'forbid',
-            ...(context.options[0] || {}),
+            overrides: {},
+            ...context.options[0],
         };
-        const checkNode = (node, property, nodeType) => {
-            const { style, suffix = '', prefix = '', forbiddenPrefixes = [], forbiddenSuffixes = [] } = property;
-            const result = checkNameFormat({
-                value: node.value,
-                style,
-                leadingUnderscore: options.leadingUnderscore,
-                trailingUnderscore: options.trailingUnderscore,
-                prefix,
-                suffix,
-                forbiddenPrefixes,
-                forbiddenSuffixes,
-            });
-            if (result.ok === false) {
+        function normalisePropertyOption(kind) {
+            let style = options.overrides[kind];
+            if (!style) {
+                style = TYPES_KINDS.includes(kind) ? options.types : options.fields;
+            }
+            return typeof style === 'object' ? style : { style };
+        }
+        const checkNode = (selector) => (node) => {
+            const { name } = node.kind === Kind.VARIABLE_DEFINITION ? node.variable : node;
+            if (!name) {
+                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) {
                 context.report({
-                    node,
-                    message: result.errorMessage,
-                    data: {
-                        prefix,
-                        suffix,
-                        format: style,
-                        forbiddenPrefixes: forbiddenPrefixes.join(', '),
-                        forbiddenSuffixes: forbiddenSuffixes.join(', '),
-                        nodeType,
-                        nodeName: node.value,
-                    },
+                    loc: getLocation(name.loc, name.value),
+                    message: `${nodeType} "${nodeName}" should ${errorMessage}`,
                 });
             }
-        };
-        const normalisePropertyOption = (value) => {
-            if (typeof value === 'object') {
-                return value;
-            }
-            return {
-                style: value,
-                prefix: '',
-                suffix: '',
-            };
-        };
-        return {
-            Name: node => {
-                if (node.value.startsWith('_') && options.leadingUnderscore === 'forbid') {
-                    context.report({ node, message: 'Leading underscores are not allowed' });
+            function getErrorMessage() {
+                let name = nodeName;
+                if (options.allowLeadingUnderscore) {
+                    name = name.replace(/^_*/, '');
                 }
-                if (node.value.endsWith('_') && options.trailingUnderscore === 'forbid') {
-                    context.report({ node, message: 'Trailing underscores are not allowed' });
+                if (options.allowTrailingUnderscore) {
+                    name = name.replace(/_*$/, '');
                 }
-            },
-            ObjectTypeDefinition: node => {
-                if (options.ObjectTypeDefinition) {
-                    const property = normalisePropertyOption(options.ObjectTypeDefinition);
-                    checkNode(node.name, property, 'Type');
+                if (prefix && !name.startsWith(prefix)) {
+                    return `have "${prefix}" prefix`;
                 }
-            },
-            InterfaceTypeDefinition: node => {
-                if (options.InterfaceTypeDefinition) {
-                    const property = normalisePropertyOption(options.InterfaceTypeDefinition);
-                    checkNode(node.name, property, 'Interface');
+                if (suffix && !name.endsWith(suffix)) {
+                    return `have "${suffix}" suffix`;
                 }
-            },
-            EnumTypeDefinition: node => {
-                if (options.EnumTypeDefinition) {
-                    const property = normalisePropertyOption(options.EnumTypeDefinition);
-                    checkNode(node.name, property, 'Enumerator');
+                const forbiddenPrefix = forbiddenPrefixes === null || forbiddenPrefixes === void 0 ? void 0 : forbiddenPrefixes.find(prefix => name.startsWith(prefix));
+                if (forbiddenPrefix) {
+                    return `not have "${forbiddenPrefix}" prefix`;
                 }
-            },
-            InputObjectTypeDefinition: node => {
-                if (options.InputObjectTypeDefinition) {
-                    const property = normalisePropertyOption(options.InputObjectTypeDefinition);
-                    checkNode(node.name, property, 'Input type');
+                const forbiddenSuffix = forbiddenSuffixes === null || forbiddenSuffixes === void 0 ? void 0 : forbiddenSuffixes.find(suffix => name.endsWith(suffix));
+                if (forbiddenSuffix) {
+                    return `not have "${forbiddenSuffix}" suffix`;
                 }
-            },
-            FieldDefinition: (node) => {
-                if (options.QueryDefinition && isQueryType(node.parent)) {
-                    const property = normalisePropertyOption(options.QueryDefinition);
-                    checkNode(node.name, property, 'Query');
+                if (style && !ALLOWED_STYLES.includes(style)) {
+                    return `be in one of the following options: ${ALLOWED_STYLES.join(', ')}`;
                 }
-                if (options.FieldDefinition && !isQueryType(node.parent)) {
-                    const property = normalisePropertyOption(options.FieldDefinition);
-                    checkNode(node.name, property, 'Field');
-                }
-            },
-            EnumValueDefinition: node => {
-                if (options.EnumValueDefinition) {
-                    const property = normalisePropertyOption(options.EnumValueDefinition);
-                    checkNode(node.name, property, 'Enumeration value');
-                }
-            },
-            InputValueDefinition: node => {
-                if (options.InputValueDefinition) {
-                    const property = normalisePropertyOption(options.InputValueDefinition);
-                    checkNode(node.name, property, 'Input property');
+                const caseRegex = StyleToRegex[style];
+                if (caseRegex && !caseRegex.test(name)) {
+                    return `be in ${style} format`;
                 }
-            },
-            OperationDefinition: node => {
-                if (options.OperationDefinition) {
-                    const property = normalisePropertyOption(options.OperationDefinition);
-                    if (node.name) {
-                        checkNode(node.name, property, 'Operation');
-                    }
-                }
-            },
-            FragmentDefinition: node => {
-                if (options.FragmentDefinition) {
-                    const property = normalisePropertyOption(options.FragmentDefinition);
-                    checkNode(node.name, property, 'Fragment');
-                }
-            },
-            ScalarTypeDefinition: node => {
-                if (options.ScalarTypeDefinition) {
-                    const property = normalisePropertyOption(options.ScalarTypeDefinition);
-                    checkNode(node.name, property, 'Scalar');
-                }
-            },
-            UnionTypeDefinition: node => {
-                if (options.UnionTypeDefinition) {
-                    const property = normalisePropertyOption(options.UnionTypeDefinition);
-                    checkNode(node.name, property, 'Union');
-                }
-            },
+            }
+        };
+        const checkUnderscore = (node) => {
+            const name = node.value;
+            context.report({
+                loc: getLocation(node.loc, name),
+                message: `${name.startsWith('_') ? 'Leading' : 'Trailing'} underscores are not allowed`,
+            });
         };
+        const listeners = {};
+        if (!options.allowLeadingUnderscore) {
+            listeners['Name[value=/^_/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] = checkUnderscore;
+        }
+        if (!options.allowTrailingUnderscore) {
+            listeners['Name[value=/_$/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] = checkUnderscore;
+        }
+        const selectors = new Set([options.types && TYPES_KINDS, options.fields && FIELDS_KINDS, Object.keys(options.overrides)]
+            .flat()
+            .filter(Boolean));
+        for (const selector of selectors) {
+            listeners[selector] = checkNode(selector);
+        }
+        return listeners;
     },
 };
 
@@ -1737,28 +1727,14 @@ const rule$9 = {
     },
     create(context) {
         return {
-            OperationDefinition(node) {
-                var _a;
-                const isAnonymous = (((_a = node.name) === null || _a === void 0 ? void 0 : _a.value) || '').length === 0;
-                if (isAnonymous) {
-                    const { start } = node.loc;
-                    context.report({
-                        loc: {
-                            start: {
-                                column: start.column - 1,
-                                line: start.line,
-                            },
-                            end: {
-                                column: start.column - 1 + node.operation.length,
-                                line: start.line,
-                            },
-                        },
-                        data: {
-                            operation: node.operation,
-                        },
-                        messageId: NO_ANONYMOUS_OPERATIONS,
-                    });
-                }
+            'OperationDefinition[name=undefined]'(node) {
+                context.report({
+                    loc: getLocation(node.loc, node.operation),
+                    data: {
+                        operation: node.operation,
+                    },
+                    messageId: NO_ANONYMOUS_OPERATIONS,
+                });
             },
         };
     },
@@ -1865,8 +1841,8 @@ const rule$b = {
             mutation {
               changeSomething(
                 type: OLD # This is deprecated, so you'll get an error
-              ) { 
-                ... 
+              ) {
+                ...
               }
             }
           `,
@@ -1903,9 +1879,10 @@ const rule$b = {
                 requireGraphQLSchemaFromContext('no-deprecated', context);
                 const typeInfo = node.typeInfo();
                 if (typeInfo && typeInfo.enumValue) {
-                    if (typeInfo.enumValue.deprecationReason) {
+                    if (typeInfo.enumValue.isDeprecated) {
+                        const enumValueName = node.value;
                         context.report({
-                            loc: node.loc,
+                            loc: getLocation(node.loc, enumValueName),
                             messageId: NO_DEPRECATED,
                             data: {
                                 type: 'enum value',
@@ -1919,9 +1896,10 @@ const rule$b = {
                 requireGraphQLSchemaFromContext('no-deprecated', context);
                 const typeInfo = node.typeInfo();
                 if (typeInfo && typeInfo.fieldDef) {
-                    if (typeInfo.fieldDef.deprecationReason) {
+                    if (typeInfo.fieldDef.isDeprecated) {
+                        const fieldName = node.name.value;
                         context.report({
-                            loc: node.loc,
+                            loc: getLocation(node.loc, fieldName),
                             messageId: NO_DEPRECATED,
                             data: {
                                 type: 'field',
@@ -1997,10 +1975,7 @@ const rule$c = {
                         if (!isEslintComment && line !== prev.line && next.kind === TokenKind.NAME && linesAfter < 2) {
                             context.report({
                                 messageId: HASHTAG_COMMENT,
-                                loc: {
-                                    start: { line, column },
-                                    end: { line, column },
-                                },
+                                loc: getLocation({ start: { line, column } }),
                             });
                         }
                     }
@@ -2129,7 +2104,7 @@ const rule$e = {
             const typeName = node.name.value;
             if (!reachableTypes.has(typeName)) {
                 context.report({
-                    node,
+                    loc: getLocation(node.name.loc, typeName, { offsetStart: node.kind === Kind.DIRECTIVE_DEFINITION ? 2 : 1 }),
                     messageId: UNREACHABLE_TYPE,
                     data: { typeName },
                     fix: fixer => fixer.remove(node),
@@ -2227,7 +2202,7 @@ const rule$f = {
                     return;
                 }
                 context.report({
-                    node,
+                    loc: getLocation(node.loc, fieldName),
                     messageId: UNUSED_FIELD,
                     data: { fieldName },
                     fix(fixer) {
@@ -2339,6 +2314,7 @@ function convertDescription(node) {
     return [];
 }
 
+// eslint-disable-next-line unicorn/better-regex
 const DATE_REGEX = /^\d{2}\/\d{2}\/\d{4}$/;
 const MESSAGE_REQUIRE_DATE = 'MESSAGE_REQUIRE_DATE';
 const MESSAGE_INVALID_FORMAT = 'MESSAGE_INVALID_FORMAT';
@@ -2382,10 +2358,10 @@ const rule$g = {
             ],
         },
         messages: {
-            [MESSAGE_REQUIRE_DATE]: 'Directive "@deprecated" must have a deletion date.',
-            [MESSAGE_INVALID_FORMAT]: 'Deletion date must be in format "DD/MM/YYYY".',
-            [MESSAGE_INVALID_DATE]: 'Invalid "{{ deletionDate }}" deletion date.',
-            [MESSAGE_CAN_BE_REMOVED]: '"{{ nodeName }}" сan be removed.',
+            [MESSAGE_REQUIRE_DATE]: 'Directive "@deprecated" must have a deletion date',
+            [MESSAGE_INVALID_FORMAT]: 'Deletion date must be in format "DD/MM/YYYY"',
+            [MESSAGE_INVALID_DATE]: 'Invalid "{{ deletionDate }}" deletion date',
+            [MESSAGE_CAN_BE_REMOVED]: '"{{ nodeName }}" сan be removed',
         },
         schema: [
             {
@@ -2406,13 +2382,16 @@ const rule$g = {
                 const argName = ((_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.argumentName) || 'deletionDate';
                 const deletionDateNode = node.arguments.find(arg => arg.name.value === argName);
                 if (!deletionDateNode) {
-                    context.report({ node: node.name, messageId: MESSAGE_REQUIRE_DATE });
+                    context.report({
+                        loc: getLocation(node.loc, node.name.value, { offsetEnd: 0 }),
+                        messageId: MESSAGE_REQUIRE_DATE,
+                    });
                     return;
                 }
                 const deletionDate = valueFromNode(deletionDateNode.value);
                 const isValidDate = DATE_REGEX.test(deletionDate);
                 if (!isValidDate) {
-                    context.report({ node: node.name, messageId: MESSAGE_INVALID_FORMAT });
+                    context.report({ node: deletionDateNode.value, messageId: MESSAGE_INVALID_FORMAT });
                     return;
                 }
                 let [day, month, year] = deletionDate.split('/');
@@ -2421,7 +2400,7 @@ const rule$g = {
                 const deletionDateInMS = Date.parse(`${year}-${month}-${day}`);
                 if (Number.isNaN(deletionDateInMS)) {
                     context.report({
-                        node: node.name,
+                        node: deletionDateNode.value,
                         messageId: MESSAGE_INVALID_DATE,
                         data: {
                             deletionDate,
@@ -2432,7 +2411,7 @@ const rule$g = {
                 const canRemove = Date.now() > deletionDateInMS;
                 if (canRemove) {
                     context.report({
-                        node: node.name,
+                        node,
                         messageId: MESSAGE_CAN_BE_REMOVED,
                         data: {
                             nodeName: node.parent.name.value,
@@ -2483,17 +2462,15 @@ const rule$h = {
     },
     create(context) {
         return {
-            Directive(node) {
-                if (node && node.name && node.name.value === 'deprecated') {
-                    const args = node.arguments || [];
-                    const reasonArg = args.find(arg => arg.name && arg.name.value === 'reason');
-                    const value = reasonArg ? String(valueFromNode(reasonArg.value) || '').trim() : null;
-                    if (!value) {
-                        context.report({
-                            node: node.name,
-                            message: 'Directive "@deprecated" must have a reason!',
-                        });
-                    }
+            'Directive[name.value=deprecated]'(node) {
+                const args = node.arguments || [];
+                const reasonArg = args.find(arg => arg.name && arg.name.value === 'reason');
+                const value = reasonArg ? String(valueFromNode(reasonArg.value) || '').trim() : null;
+                if (!value) {
+                    context.report({
+                        loc: getLocation(node.loc, node.name.value, { offsetEnd: 0 }),
+                        message: 'Directive "@deprecated" must have a reason!',
+                    });
                 }
             },
         };
@@ -2516,20 +2493,8 @@ const DESCRIBABLE_NODES = [
 function verifyRule(context, node) {
     if (node) {
         if (!node.description || !node.description.value || node.description.value.trim().length === 0) {
-            const { start, end } = ('name' in node ? node.name : node).loc;
             context.report({
-                loc: {
-                    start: {
-                        line: start.line,
-                        column: start.column - 1,
-                    },
-                    end: {
-                        line: end.line,
-                        column: 
-                        // node.name don't exist on SchemaDefinition
-                        'name' in node ? end.column - 1 + node.name.value.length : end.column,
-                    },
-                },
+                loc: getLocation(('name' in node ? node.name : node).loc, 'name' in node ? node.name.value : 'schema'),
                 messageId: REQUIRE_DESCRIPTION_ERROR,
                 data: {
                     nodeType: node.kind,
@@ -2547,7 +2512,7 @@ const rule$i = {
             examples: [
                 {
                     title: 'Incorrect',
-                    usage: [{ on: [Kind.OBJECT_TYPE_DEFINITION, Kind.FIELD_DEFINITION] }],
+                    usage: [{ on: ['ObjectTypeDefinition', 'FieldDefinition'] }],
                     code: /* GraphQL */ `
             type someTypeName {
               name: String
@@ -2556,7 +2521,7 @@ const rule$i = {
                 },
                 {
                     title: 'Correct',
-                    usage: [{ on: [Kind.OBJECT_TYPE_DEFINITION, Kind.FIELD_DEFINITION] }],
+                    usage: [{ on: ['ObjectTypeDefinition', 'FieldDefinition'] }],
                     code: /* GraphQL */ `
             """
             Some type description
@@ -2650,18 +2615,22 @@ const rule$j = {
         if (!mutationType || !queryType) {
             return {};
         }
-        const selector = `:matches(${Kind.OBJECT_TYPE_DEFINITION}, ${Kind.OBJECT_TYPE_EXTENSION})[name.value=${mutationType.name}] > ${Kind.FIELD_DEFINITION}`;
+        const selector = [
+            `:matches(${Kind.OBJECT_TYPE_DEFINITION}, ${Kind.OBJECT_TYPE_EXTENSION})[name.value=${mutationType.name}]`,
+            '>',
+            Kind.FIELD_DEFINITION,
+            Kind.NAMED_TYPE,
+        ].join(' ');
         return {
             [selector](node) {
-                const rawNode = node.rawNode();
-                const typeName = getTypeName(rawNode);
+                const typeName = node.name.value;
                 const graphQLType = schema.getType(typeName);
                 if (isObjectType$1(graphQLType)) {
                     const { fields } = graphQLType.astNode;
                     const hasQueryType = fields.some(field => getTypeName(field) === queryType.name);
                     if (!hasQueryType) {
                         context.report({
-                            node,
+                            loc: getLocation(node.loc, typeName),
                             message: `Mutation result type "${graphQLType.name}" must contain field of type "${queryType.name}".`,
                         });
                     }
@@ -3000,7 +2969,7 @@ const rule$l = {
                         getDocument: () => document,
                         reportError: (error) => {
                             context.report({
-                                loc: error.locations[0],
+                                loc: getLocation({ start: error.locations[0] }),
                                 message: error.message,
                             });
                         },
@@ -3139,7 +3108,7 @@ const rule$m = {
             acceptedIdNames: ['id'],
             acceptedIdTypes: ['ID'],
             exceptions: {},
-            ...(context.options[0] || {}),
+            ...context.options[0],
         };
         return {
             ObjectTypeDefinition(node) {
@@ -3156,15 +3125,16 @@ const rule$m = {
                     }
                     return isValidIdName && isValidIdType;
                 });
+                const typeName = node.name.value;
                 // Usually, there should be only one unique identifier field per type.
                 // Some clients allow multiple fields to be used. If more people need this,
                 // we can extend this rule later.
                 if (validIds.length !== 1) {
                     context.report({
-                        node,
-                        message: '{{nodeName}} must have exactly one non-nullable unique identifier. Accepted name(s): {{acceptedNamesString}} ; Accepted type(s): {{acceptedTypesString}}',
+                        loc: getLocation(node.name.loc, typeName),
+                        message: `{{ typeName }} must have exactly one non-nullable unique identifier. Accepted name(s): {{ acceptedNamesString }} ; Accepted type(s): {{ acceptedTypesString }}`,
                         data: {
-                            nodeName: node.name.value,
+                            typeName,
                             acceptedNamesString: options.acceptedIdNames.join(','),
                             acceptedTypesString: options.acceptedIdTypes.join(','),
                         },
@@ -3178,11 +3148,7 @@ const rule$m = {
 const RULE_NAME$3 = 'unique-fragment-name';
 const UNIQUE_FRAGMENT_NAME = 'UNIQUE_FRAGMENT_NAME';
 const checkNode = (context, node, ruleName, messageId) => {
-    var _a;
-    const documentName = (_a = node.name) === null || _a === void 0 ? void 0 : _a.value;
-    if (!documentName) {
-        return;
-    }
+    const documentName = node.name.value;
     const siblings = requireSiblingsOperations(ruleName, context);
     const siblingDocuments = node.kind === Kind.FRAGMENT_DEFINITION ? siblings.getFragment(documentName) : siblings.getOperation(documentName);
     const filepath = context.getFilename();
@@ -3193,7 +3159,6 @@ const checkNode = (context, node, ruleName, messageId) => {
         return isSameName && !isSamePath;
     });
     if (conflictingDocuments.length > 0) {
-        const { start, end } = node.name.loc;
         context.report({
             messageId,
             data: {
@@ -3202,16 +3167,7 @@ const checkNode = (context, node, ruleName, messageId) => {
                     .map(f => `\t${relative(process.cwd(), getOnDiskFilepath(f.filePath))}`)
                     .join('\n'),
             },
-            loc: {
-                start: {
-                    line: start.line,
-                    column: start.column - 1,
-                },
-                end: {
-                    line: end.line,
-                    column: end.column - 1,
-                },
-            },
+            loc: getLocation(node.name.loc, documentName),
         });
     }
 };
@@ -3328,7 +3284,7 @@ const rule$o = {
     },
     create(context) {
         return {
-            OperationDefinition(node) {
+            'OperationDefinition[name!=undefined]'(node) {
                 checkNode(context, node, RULE_NAME$4, UNIQUE_OPERATION_NAME);
             },
         };
@@ -3758,22 +3714,110 @@ function parseForESLint(code, options = {}) {
     }
 }
 
-class GraphQLRuleTester extends require('eslint').RuleTester {
+class GraphQLRuleTester extends RuleTester {
     constructor(parserOptions = {}) {
-        super({
+        const config = {
             parser: require.resolve('@graphql-eslint/eslint-plugin'),
             parserOptions: {
                 ...parserOptions,
                 skipGraphQLConfig: true,
             },
-        });
+        };
+        super(config);
+        this.config = config;
     }
     fromMockFile(path) {
         return readFileSync(resolve(__dirname, `../tests/mocks/${path}`), 'utf-8');
     }
     runGraphQLTests(name, rule, tests) {
-        super.run(name, rule, tests);
+        const ruleTests = Linter.version.startsWith('8')
+            ? tests
+            : {
+                valid: tests.valid.map(test => {
+                    if (typeof test === 'string') {
+                        return test;
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    const { name, ...testCaseOptions } = test;
+                    return testCaseOptions;
+                }),
+                invalid: tests.invalid.map(test => {
+                    // ESLint 7 throws an error on CI - Unexpected top-level property "name"
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    const { name, ...testCaseOptions } = test;
+                    return testCaseOptions;
+                }),
+            };
+        super.run(name, rule, ruleTests);
+        // Skip snapshot testing if `expect` variable is not defined
+        if (typeof expect === 'undefined') {
+            return;
+        }
+        const linter = new Linter();
+        linter.defineRule(name, rule);
+        for (const testCase of tests.invalid) {
+            const verifyConfig = getVerifyConfig(name, this.config, testCase);
+            defineParser(linter, verifyConfig.parser);
+            const { code, filename } = testCase;
+            const messages = linter.verify(code, verifyConfig, { filename });
+            for (const message of messages) {
+                if (message.fatal) {
+                    throw new Error(message.message);
+                }
+                const messageForSnapshot = visualizeEslintMessage(code, message);
+                // eslint-disable-next-line no-undef
+                expect(messageForSnapshot).toMatchSnapshot();
+            }
+        }
     }
 }
+function getVerifyConfig(ruleId, testerConfig, testCase) {
+    const { options, parserOptions, parser = testerConfig.parser } = testCase;
+    return {
+        ...testerConfig,
+        parser,
+        parserOptions: {
+            ...testerConfig.parserOptions,
+            ...parserOptions,
+        },
+        rules: {
+            [ruleId]: ['error', ...(Array.isArray(options) ? options : [])],
+        },
+    };
+}
+const parsers = new WeakMap();
+function defineParser(linter, parser) {
+    if (!parser) {
+        return;
+    }
+    if (!parsers.has(linter)) {
+        parsers.set(linter, new Set());
+    }
+    const defined = parsers.get(linter);
+    if (!defined.has(parser)) {
+        defined.add(parser);
+        linter.defineParser(parser, require(parser));
+    }
+}
+function visualizeEslintMessage(text, result) {
+    const { line, column, endLine, endColumn, message } = result;
+    const location = {
+        start: {
+            line,
+            column,
+        },
+    };
+    if (typeof endLine === 'number' && typeof endColumn === 'number') {
+        location.end = {
+            line: endLine,
+            column: endColumn,
+        };
+    }
+    return codeFrameColumns(text, location, {
+        linesAbove: Number.POSITIVE_INFINITY,
+        linesBelow: Number.POSITIVE_INFINITY,
+        message,
+    });
+}
 
 export { GraphQLRuleTester, configs, convertDescription, convertLocation, convertRange, convertToESTree, extractCommentsFromAst, getBaseType, isNodeWithDescription, parse, parseForESLint, processors, rules, valueFromNode };