@graphql-eslint/eslint-plugin 2.4.0-alpha-0617395.0 → 2.4.0

package/index.js

@@ -15,6 +15,8 @@ const depthLimit = _interopDefault(require('graphql-depth-limit'));
 const graphqlTagPluck = require('@graphql-tools/graphql-tag-pluck');
 const graphqlConfig$1 = require('graphql-config');
 const codeFileLoader = require('@graphql-tools/code-file-loader');
+const eslint = require('eslint');
+const codeFrame = require('@babel/code-frame');
 
 /*
  * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
@@ -147,7 +149,7 @@ function getLexer(source) {
     throw new Error(`Unsupported GraphQL version! Please make sure to use GraphQL v14 or newer!`);
 }
 function extractTokens(source) {
-    const lexer = getLexer(new graphql.Source(source));
+    const lexer = getLexer(source);
     const tokens = [];
     let token = lexer.advance();
     while (token && token.kind !== '<EOF>') {
@@ -242,6 +244,24 @@ 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:/) || [];
@@ -255,7 +275,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}`,
                 });
             }
@@ -292,6 +312,7 @@ const validationToRule = (name, ruleName, docs, getDocumentNode) => {
             meta: {
                 docs: {
                     ...docs,
+                    graphQLJSRuleName: ruleName,
                     category: 'Validation',
                     recommended: true,
                     requiresSchema,
@@ -591,7 +612,7 @@ const rule = {
             ],
         },
         messages: {
-            [ALPHABETIZE]: '"{{ currName }}" should be before "{{ prevName }}".',
+            [ALPHABETIZE]: '"{{ currName }}" should be before "{{ prevName }}"',
         },
         schema: {
             type: 'array',
@@ -648,16 +669,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 === graphql.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
                             ? {
@@ -723,35 +737,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
               }
             }
           `,
@@ -759,7 +760,7 @@ const rule$1 = {
                 {
                     title: 'Incorrect',
                     code: /* GraphQL */ `
-            query getUsers {
+            query {
               users(
                 first: 100
                 skip: 50
@@ -774,9 +775,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
               }
             }
@@ -785,58 +788,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 === graphql.Kind.FIELD && node.alias ? node.alias : node).loc, fieldName, {
+                        offsetEnd: node.kind === graphql.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 === graphql.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);
                     }
                 }
             },
@@ -967,16 +959,20 @@ const rule$3 = {
         if (!mutationType) {
             return {};
         }
-        const selector = `:matches(${graphql.Kind.OBJECT_TYPE_DEFINITION}, ${graphql.Kind.OBJECT_TYPE_EXTENSION})[name.value=${mutationType.name}] > ${graphql.Kind.FIELD_DEFINITION}`;
+        const selector = [
+            `:matches(${graphql.Kind.OBJECT_TYPE_DEFINITION}, ${graphql.Kind.OBJECT_TYPE_EXTENSION})[name.value=${mutationType.name}]`,
+            '>',
+            graphql.Kind.FIELD_DEFINITION,
+            graphql.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 (graphql.isScalarType(graphQLType)) {
                     context.report({
-                        node,
-                        message: `Unexpected scalar result type "${typeName}".`,
+                        loc: getLocation(node.loc, typeName),
+                        message: `Unexpected scalar result type "${typeName}"`,
                     });
                 }
             },
@@ -1025,23 +1021,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),
                         });
                     }
                 }
@@ -1101,7 +1087,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`,
                     });
                 }
@@ -1188,10 +1174,11 @@ const rule$6 = {
         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)) {
+                const name = node.name.value;
+                if (name !== 'input' && shouldCheckType(node.parent.parent)) {
                     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"`,
                     });
                 }
             },
@@ -1208,11 +1195,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}"`,
                         });
                     }
                 }
@@ -1369,7 +1357,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,
@@ -1401,7 +1390,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,
@@ -1599,7 +1589,7 @@ const rule$8 = {
             });
             if (result.ok === false) {
                 context.report({
-                    node,
+                    loc: getLocation(node.loc, node.value),
                     message: result.errorMessage,
                     data: {
                         prefix,
@@ -1626,10 +1616,16 @@ const rule$8 = {
         return {
             Name: node => {
                 if (node.value.startsWith('_') && options.leadingUnderscore === 'forbid') {
-                    context.report({ node, message: 'Leading underscores are not allowed' });
+                    context.report({
+                        loc: getLocation(node.loc, node.value),
+                        message: 'Leading underscores are not allowed',
+                    });
                 }
                 if (node.value.endsWith('_') && options.trailingUnderscore === 'forbid') {
-                    context.report({ node, message: 'Trailing underscores are not allowed' });
+                    context.report({
+                        loc: getLocation(node.loc, node.value),
+                        message: 'Trailing underscores are not allowed',
+                    });
                 }
             },
             ObjectTypeDefinition: node => {
@@ -1743,28 +1739,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,
+                });
             },
         };
     },
@@ -1871,8 +1853,8 @@ const rule$b = {
             mutation {
               changeSomething(
                 type: OLD # This is deprecated, so you'll get an error
-              ) { 
-                ... 
+              ) {
+                ...
               }
             }
           `,
@@ -1910,8 +1892,9 @@ const rule$b = {
                 const typeInfo = node.typeInfo();
                 if (typeInfo && typeInfo.enumValue) {
                     if (typeInfo.enumValue.deprecationReason) {
+                        const enumValueName = node.value;
                         context.report({
-                            loc: node.loc,
+                            loc: getLocation(node.loc, enumValueName),
                             messageId: NO_DEPRECATED,
                             data: {
                                 type: 'enum value',
@@ -1926,8 +1909,9 @@ const rule$b = {
                 const typeInfo = node.typeInfo();
                 if (typeInfo && typeInfo.fieldDef) {
                     if (typeInfo.fieldDef.deprecationReason) {
+                        const fieldName = node.name.value;
                         context.report({
-                            loc: node.loc,
+                            loc: getLocation(node.loc, fieldName),
                             messageId: NO_DEPRECATED,
                             data: {
                                 type: 'field',
@@ -2003,10 +1987,7 @@ const rule$c = {
                         if (!isEslintComment && line !== prev.line && next.kind === graphql.TokenKind.NAME && linesAfter < 2) {
                             context.report({
                                 messageId: HASHTAG_COMMENT,
-                                loc: {
-                                    start: { line, column },
-                                    end: { line, column },
-                                },
+                                loc: getLocation({ start: { line, column } }),
                             });
                         }
                     }
@@ -2135,7 +2116,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 === graphql.Kind.DIRECTIVE_DEFINITION ? 2 : 1 }),
                     messageId: UNREACHABLE_TYPE,
                     data: { typeName },
                     fix: fixer => fixer.remove(node),
@@ -2233,7 +2214,7 @@ const rule$f = {
                     return;
                 }
                 context.report({
-                    node,
+                    loc: getLocation(node.loc, fieldName),
                     messageId: UNUSED_FIELD,
                     data: { fieldName },
                     fix(fixer) {
@@ -2388,10 +2369,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: [
             {
@@ -2412,13 +2393,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('/');
@@ -2427,7 +2411,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,
@@ -2438,7 +2422,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,
@@ -2489,17 +2473,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!',
+                    });
                 }
             },
         };
@@ -2522,20 +2504,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,
@@ -2656,18 +2626,22 @@ const rule$j = {
         if (!mutationType || !queryType) {
             return {};
         }
-        const selector = `:matches(${graphql.Kind.OBJECT_TYPE_DEFINITION}, ${graphql.Kind.OBJECT_TYPE_EXTENSION})[name.value=${mutationType.name}] > ${graphql.Kind.FIELD_DEFINITION}`;
+        const selector = [
+            `:matches(${graphql.Kind.OBJECT_TYPE_DEFINITION}, ${graphql.Kind.OBJECT_TYPE_EXTENSION})[name.value=${mutationType.name}]`,
+            '>',
+            graphql.Kind.FIELD_DEFINITION,
+            graphql.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 (graphql.isObjectType(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}".`,
                         });
                     }
@@ -3006,7 +2980,7 @@ const rule$l = {
                         getDocument: () => document,
                         reportError: (error) => {
                             context.report({
-                                loc: error.locations[0],
+                                loc: getLocation({ start: error.locations[0] }),
                                 message: error.message,
                             });
                         },
@@ -3162,15 +3136,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(','),
                         },
@@ -3184,11 +3159,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 === graphql.Kind.FRAGMENT_DEFINITION ? siblings.getFragment(documentName) : siblings.getOperation(documentName);
     const filepath = context.getFilename();
@@ -3199,7 +3170,6 @@ const checkNode = (context, node, ruleName, messageId) => {
         return isSameName && !isSamePath;
     });
     if (conflictingDocuments.length > 0) {
-        const { start, end } = node.name.loc;
         context.report({
             messageId,
             data: {
@@ -3208,16 +3178,7 @@ const checkNode = (context, node, ruleName, messageId) => {
                     .map(f => `\t${path.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),
         });
     }
 };
@@ -3334,7 +3295,7 @@ const rule$o = {
     },
     create(context) {
         return {
-            OperationDefinition(node) {
+            'OperationDefinition[name!=undefined]'(node) {
                 checkNode(context, node, RULE_NAME$4, UNIQUE_OPERATION_NAME);
             },
         };
@@ -3732,7 +3693,7 @@ function parseForESLint(code, options = {}) {
             noLocation: false,
         });
         const { rootTree, comments } = convertToESTree(graphqlAst.document, schema ? new graphql.TypeInfo(schema) : null);
-        const tokens = extractTokens(code);
+        const tokens = extractTokens(new graphql.Source(code, filePath));
         return {
             services: parserServices,
             parserServices,
@@ -3764,22 +3725,110 @@ function parseForESLint(code, options = {}) {
     }
 }
 
-class GraphQLRuleTester extends require('eslint').RuleTester {
+class GraphQLRuleTester extends eslint.RuleTester {
     constructor(parserOptions = {}) {
-        super({
+        const config = {
             parser: require.resolve('@graphql-eslint/eslint-plugin'),
             parserOptions: {
                 ...parserOptions,
                 skipGraphQLConfig: true,
             },
-        });
+        };
+        super(config);
+        this.config = config;
     }
     fromMockFile(path$1) {
         return fs.readFileSync(path.resolve(__dirname, `../tests/mocks/${path$1}`), 'utf-8');
     }
     runGraphQLTests(name, rule, tests) {
-        super.run(name, rule, tests);
+        const ruleTests = eslint.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 eslint.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 codeFrame.codeFrameColumns(text, location, {
+        linesAbove: Number.POSITIVE_INFINITY,
+        linesBelow: Number.POSITIVE_INFINITY,
+        message,
+    });
 }
 
 exports.GraphQLRuleTester = GraphQLRuleTester;