@graphql-eslint/eslint-plugin 3.8.0-alpha-a8fcc7b.0 → 3.8.0-alpha-8ddf2a4.0

package/index.js

@@ -17,7 +17,6 @@ const graphqlConfig = require('graphql-config');
 const codeFileLoader = require('@graphql-tools/code-file-loader');
 const eslint = require('eslint');
 const codeFrame = require('@babel/code-frame');
-const dedent = _interopDefault(require('dedent'));
 
 const base = {
     parser: '@graphql-eslint/eslint-plugin',
@@ -209,43 +208,6 @@ function requireUsedFieldsFromContext(ruleName, context) {
     const siblings = requireSiblingsOperations(ruleName, context);
     return context.parserServices.usedFields(schema, siblings);
 }
-function getLexer(source) {
-    // GraphQL v14
-    const gqlLanguage = require('graphql/language');
-    if (gqlLanguage && gqlLanguage.createLexer) {
-        return gqlLanguage.createLexer(source, {});
-    }
-    // GraphQL v15
-    const { Lexer: LexerCls } = require('graphql');
-    if (LexerCls && typeof LexerCls === 'function') {
-        return new LexerCls(source);
-    }
-    throw new Error(`Unsupported GraphQL version! Please make sure to use GraphQL v14 or newer!`);
-}
-function extractTokens(source) {
-    const lexer = getLexer(source);
-    const tokens = [];
-    let token = lexer.advance();
-    while (token && token.kind !== '<EOF>') {
-        tokens.push({
-            type: token.kind,
-            loc: {
-                start: {
-                    line: token.line,
-                    column: token.column,
-                },
-                end: {
-                    line: token.line,
-                    column: token.column,
-                },
-            },
-            value: token.value,
-            range: [token.start, token.end],
-        });
-        token = lexer.advance();
-    }
-    return tokens;
-}
 const normalizePath = (path) => (path || '').replace(/\\/g, '/');
 /**
  * https://github.com/prettier/eslint-plugin-prettier/blob/76bd45ece6d56eb52f75db6b4a1efdd2efb56392/eslint-plugin-prettier.js#L71
@@ -315,21 +277,16 @@ 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 : {};
+function getLocation(loc, fieldName = '') {
+    const { line, column } = loc.start;
     return {
         start: {
-            line: start.line,
-            column: start.column - offsetStart,
+            line,
+            column,
         },
         end: {
-            line: start.line,
-            column: start.column - offsetEnd + fieldName.length,
+            line,
+            column: column + fieldName.length,
         },
     };
 }
@@ -343,23 +300,16 @@ function validateDocument(context, schema = null, documentNode, rule) {
             ? graphql.validate(schema, documentNode, [rule])
             : validate.validateSDL(documentNode, null, [rule]);
         for (const error of validationErrors) {
-            /*
-             * TODO: Fix ESTree-AST converter because currently it's incorrectly convert loc.end
-             * Example: loc.end always equal loc.start
-             *  {
-             *    token: {
-             *      type: 'Name',
-             *      loc: { start: { line: 4, column: 13 }, end: { line: 4, column: 13 } },
-             *      value: 'veryBad',
-             *      range: [ 40, 47 ]
-             *    }
-             *  }
-             */
             const { line, column } = error.locations[0];
             const ancestors = context.getAncestors();
-            const token = ancestors[0].tokens.find(token => token.loc.start.line === line && token.loc.start.column === column);
+            const token = ancestors[0].tokens.find(token => token.loc.start.line === line && token.loc.start.column === column - 1);
             context.report({
-                loc: getLocation({ start: error.locations[0] }, token === null || token === void 0 ? void 0 : token.value),
+                loc: token
+                    ? token.loc
+                    : {
+                        line,
+                        column: column - 1,
+                    },
                 message: error.message,
             });
         }
@@ -692,10 +642,7 @@ const rule = {
         fixable: 'code',
         docs: {
             category: ['Schema', 'Operations'],
-            description: [
-                'Enforce arrange in alphabetical order for type fields, enum values, input object fields, operation selections and more.',
-                '> Note: autofix will work only for fields without comments (between or around)',
-            ].join('\n\n'),
+            description: `Enforce arrange in alphabetical order for type fields, enum values, input object fields, operation selections and more.`,
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/alphabetize.md',
             examples: [
                 {
@@ -853,8 +800,27 @@ const rule = {
     },
     create(context) {
         var _a, _b, _c, _d, _e;
-        function isOnSameLineNodeAndComment(beforeNode, afterNode) {
-            return beforeNode.loc.end.line === afterNode.loc.start.line;
+        const sourceCode = context.getSourceCode();
+        function isNodeAndCommentOnSameLine(node, comment) {
+            return node.loc.end.line === comment.loc.start.line;
+        }
+        function getBeforeComments(node) {
+            const commentsBefore = sourceCode.getCommentsBefore(node);
+            if (commentsBefore.length === 0) {
+                return [];
+            }
+            const tokenBefore = sourceCode.getTokenBefore(node);
+            if (tokenBefore) {
+                return commentsBefore.filter(comment => !isNodeAndCommentOnSameLine(tokenBefore, comment));
+            }
+            return commentsBefore;
+        }
+        function getRangeWithComments(node) {
+            const [firstBeforeComment] = getBeforeComments(node);
+            const [firstAfterComment] = sourceCode.getCommentsAfter(node);
+            const from = firstBeforeComment || node;
+            const to = firstAfterComment && isNodeAndCommentOnSameLine(node, firstAfterComment) ? firstAfterComment : node;
+            return [from.range[0], to.range[1]];
         }
         function checkNodes(nodes) {
             // Starts from 1, ignore nodes.length <= 1
@@ -863,39 +829,27 @@ const rule = {
                 const currNode = nodes[i];
                 const prevName = prevNode.name.value;
                 const currName = currNode.name.value;
-                if (prevName.localeCompare(currName) === 1) {
-                    const isVariableNode = currNode.kind === graphql.Kind.VARIABLE;
-                    context.report({
-                        loc: getLocation(currNode.loc, currName, { offsetEnd: isVariableNode ? 0 : 1 }),
-                        messageId: ALPHABETIZE,
-                        data: isVariableNode
-                            ? {
-                                currName: `$${currName}`,
-                                prevName: `$${prevName}`,
-                            }
-                            : { currName, prevName },
-                        *fix(fixer) {
-                            const prev = prevNode;
-                            const curr = currNode;
-                            const sourceCode = context.getSourceCode();
-                            const beforeComments = sourceCode.getCommentsBefore(prev);
-                            if (beforeComments.length > 0) {
-                                const tokenBefore = sourceCode.getTokenBefore(prev);
-                                const lastBeforeComment = beforeComments.at(-1);
-                                if (!tokenBefore || !isOnSameLineNodeAndComment(tokenBefore, lastBeforeComment))
-                                    return;
-                            }
-                            const betweenComments = sourceCode.getCommentsBefore(curr);
-                            if (betweenComments.length > 0)
-                                return;
-                            const [firstAfterComment] = sourceCode.getCommentsAfter(curr);
-                            if (firstAfterComment && isOnSameLineNodeAndComment(curr, firstAfterComment))
-                                return;
-                            yield fixer.replaceText(prev, sourceCode.getText(curr));
-                            yield fixer.replaceText(curr, sourceCode.getText(prev));
-                        },
-                    });
+                // Compare with lexicographic order
+                if (prevName.localeCompare(currName) !== 1) {
+                    continue;
                 }
+                const isVariableNode = currNode.kind === graphql.Kind.VARIABLE;
+                context.report({
+                    node: currNode.name,
+                    messageId: ALPHABETIZE,
+                    data: isVariableNode
+                        ? {
+                            currName: `$${currName}`,
+                            prevName: `$${prevName}`,
+                        }
+                        : { currName, prevName },
+                    *fix(fixer) {
+                        const prevRange = getRangeWithComments(prevNode);
+                        const currRange = getRangeWithComments(currNode);
+                        yield fixer.replaceTextRange(prevRange, sourceCode.getText({ range: currRange }));
+                        yield fixer.replaceTextRange(currRange, sourceCode.getText({ range: prevRange }));
+                    },
+                });
             }
         }
         const opts = context.options[0];
@@ -1092,7 +1046,7 @@ const rule$2 = {
                 if (shouldCheckType(node.parent.parent)) {
                     const name = node.name.value;
                     context.report({
-                        loc: getLocation(node.loc, name),
+                        node: node.name,
                         message: `Input "${name}" should be called "input"`,
                     });
                 }
@@ -1114,7 +1068,7 @@ const rule$2 = {
                     if ((options.caseSensitiveInputType && node.name.value !== mutationName) ||
                         name.toLowerCase() !== mutationName.toLowerCase()) {
                         context.report({
-                            loc: getLocation(node.loc, name),
+                            node: node.name,
                             message: `InputType "${name}" name should be "${mutationName}"`,
                         });
                     }
@@ -1128,7 +1082,7 @@ const rule$2 = {
 const MATCH_EXTENSION = 'MATCH_EXTENSION';
 const MATCH_STYLE = 'MATCH_STYLE';
 const ACCEPTED_EXTENSIONS = ['.gql', '.graphql'];
-const CASE_STYLES = ['camelCase', 'PascalCase', 'snake_case', 'UPPER_CASE', 'kebab-case'];
+const CASE_STYLES = ['camelCase', 'PascalCase', 'snake_case', 'UPPER_CASE', 'kebab-case', 'matchDocumentStyle'];
 const schemaOption = {
     oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
 };
@@ -1302,7 +1256,14 @@ const rule$3 = {
                     option = { style: option };
                 }
                 const expectedExtension = options.fileExtension || fileExtension;
-                const expectedFilename = (option.style ? convertCase(option.style, docName) : filename) + (option.suffix || '') + expectedExtension;
+                let expectedFilename;
+                if (option.style) {
+                    expectedFilename = option.style === 'matchDocumentStyle' ? docName : convertCase(option.style, docName);
+                }
+                else {
+                    expectedFilename = filename;
+                }
+                expectedFilename += (option.suffix || '') + expectedExtension;
                 const filenameWithExtension = filename + expectedExtension;
                 if (expectedFilename !== filenameWithExtension) {
                     context.report({
@@ -1559,7 +1520,7 @@ const rule$4 = {
                 const [trailingUnderscores] = nodeName.match(/_*$/);
                 const suggestedName = leadingUnderscores + renameToName + trailingUnderscores;
                 context.report({
-                    loc: getLocation(node.loc, node.value),
+                    node,
                     message: `${nodeType} "${nodeName}" should ${errorMessage}`,
                     suggest: [
                         {
@@ -1617,7 +1578,7 @@ const rule$4 = {
             const name = node.value;
             const renameToName = name.replace(new RegExp(isLeading ? '^_+' : '_+$'), '');
             context.report({
-                loc: getLocation(node.loc, name),
+                node,
                 message: `${isLeading ? 'Leading' : 'Trailing'} underscores are not allowed`,
                 suggest: [
                     {
@@ -1733,7 +1694,7 @@ const rule$6 = {
                 for (const duplicate of duplicates) {
                     const enumName = duplicate.name.value;
                     context.report({
-                        loc: getLocation(duplicate.loc, enumName),
+                        node: duplicate.name,
                         message: `Case-insensitive enum values duplicates are not allowed! Found: "${enumName}"`,
                     });
                 }
@@ -1827,9 +1788,8 @@ const rule$7 = {
                 const typeInfo = node.typeInfo();
                 if (typeInfo && typeInfo.enumValue) {
                     if (typeInfo.enumValue.deprecationReason) {
-                        const enumValueName = node.value;
                         context.report({
-                            loc: getLocation(node.loc, enumValueName),
+                            node,
                             messageId: NO_DEPRECATED,
                             data: {
                                 type: 'enum value',
@@ -1844,9 +1804,8 @@ const rule$7 = {
                 const typeInfo = node.typeInfo();
                 if (typeInfo && typeInfo.fieldDef) {
                     if (typeInfo.fieldDef.deprecationReason) {
-                        const fieldName = node.name.value;
                         context.report({
-                            loc: getLocation(node.loc, fieldName),
+                            node: node.name,
                             messageId: NO_DEPRECATED,
                             data: {
                                 type: 'field',
@@ -1918,12 +1877,11 @@ const rule$8 = {
         schema: [],
     },
     create(context) {
-        function checkNode(usedFields, fieldName, type, node) {
+        function checkNode(usedFields, type, node) {
+            const fieldName = node.value;
             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,
-                    }),
+                    node,
                     messageId: NO_DUPLICATE_FIELDS,
                     data: {
                         type,
@@ -1939,21 +1897,20 @@ const rule$8 = {
             OperationDefinition(node) {
                 const set = new Set();
                 for (const varDef of node.variableDefinitions) {
-                    checkNode(set, varDef.variable.name.value, 'Operation variable', varDef);
+                    checkNode(set, 'Operation variable', varDef.variable.name);
                 }
             },
             Field(node) {
                 const set = new Set();
                 for (const arg of node.arguments) {
-                    checkNode(set, arg.name.value, 'Field argument', arg);
+                    checkNode(set, 'Field argument', arg.name);
                 }
             },
             SelectionSet(node) {
-                var _a;
                 const set = new Set();
                 for (const selection of node.selections) {
                     if (selection.kind === graphql.Kind.FIELD) {
-                        checkNode(set, ((_a = selection.alias) === null || _a === void 0 ? void 0 : _a.value) || selection.name.value, 'Field', selection);
+                        checkNode(set, 'Field', selection.alias || selection.name);
                     }
                 }
             },
@@ -2012,7 +1969,7 @@ const rule$9 = {
         schema: [],
     },
     create(context) {
-        const selector = `${graphql.Kind.DOCUMENT}[definitions.0.kind!=/^(${graphql.Kind.OPERATION_DEFINITION}|${graphql.Kind.FRAGMENT_DEFINITION})$/]`;
+        const selector = 'Document[definitions.0.kind!=/^(OperationDefinition|FragmentDefinition)$/]';
         return {
             [selector](node) {
                 const rawNode = node.rawNode();
@@ -2025,7 +1982,10 @@ const rule$9 = {
                         if (!isEslintComment && line !== prev.line && next.kind === graphql.TokenKind.NAME && linesAfter < 2) {
                             context.report({
                                 messageId: HASHTAG_COMMENT,
-                                loc: getLocation({ start: { line, column } }),
+                                loc: {
+                                    line,
+                                    column: column - 1,
+                                },
                             });
                         }
                     }
@@ -2108,7 +2068,7 @@ const rule$a = {
             [selector](node) {
                 const typeName = node.value;
                 context.report({
-                    loc: getLocation(node.loc, typeName),
+                    node,
                     message: `Root type "${typeName}" is forbidden`,
                 });
             },
@@ -2161,7 +2121,7 @@ const rule$b = {
                 const graphQLType = schema.getType(typeName);
                 if (graphql.isScalarType(graphQLType)) {
                     context.report({
-                        loc: getLocation(node.loc, typeName),
+                        node,
                         message: `Unexpected scalar result type "${typeName}"`,
                     });
                 }
@@ -2217,7 +2177,7 @@ const rule$c = {
                                 typeName,
                             },
                             messageId: NO_TYPENAME_PREFIX,
-                            loc: getLocation(field.loc, lowerTypeName),
+                            node: field.name,
                         });
                     }
                 }
@@ -2295,7 +2255,7 @@ const rule$d = {
                 const typeName = node.name.value;
                 if (!reachableTypes.has(typeName)) {
                     context.report({
-                        loc: getLocation(node.name.loc, typeName, { offsetStart: node.kind === graphql.Kind.DIRECTIVE_DEFINITION ? 2 : 1 }),
+                        node: node.name,
                         messageId: UNREACHABLE_TYPE,
                         data: { typeName },
                         suggest: [
@@ -2384,7 +2344,7 @@ const rule$e = {
                     return;
                 }
                 context.report({
-                    loc: getLocation(node.loc, fieldName),
+                    node: node.name,
                     messageId: UNUSED_FIELD,
                     data: { fieldName },
                     suggest: [
@@ -2437,8 +2397,51 @@ function getBaseType(type) {
     }
     return type;
 }
-function convertRange(gqlLocation) {
-    return [gqlLocation.start, gqlLocation.end];
+function convertToken(token, type) {
+    const { line, column, end, start, value } = token;
+    return {
+        type,
+        value,
+        /*
+         * ESLint has 0-based column number
+         * https://eslint.org/docs/developer-guide/working-with-rules#contextreport
+         */
+        loc: {
+            start: {
+                line,
+                column: column - 1,
+            },
+            end: {
+                line,
+                column: column - 1 + (end - start),
+            },
+        },
+        range: [start, end],
+    };
+}
+function getLexer(source) {
+    // GraphQL v14
+    const gqlLanguage = require('graphql/language');
+    if (gqlLanguage && gqlLanguage.createLexer) {
+        return gqlLanguage.createLexer(source, {});
+    }
+    // GraphQL v15
+    const { Lexer: LexerCls } = require('graphql');
+    if (LexerCls && typeof LexerCls === 'function') {
+        return new LexerCls(source);
+    }
+    throw new Error('Unsupported GraphQL version! Please make sure to use GraphQL v14 or newer!');
+}
+function extractTokens(source) {
+    const lexer = getLexer(source);
+    const tokens = [];
+    let token = lexer.advance();
+    while (token && token.kind !== graphql.TokenKind.EOF) {
+        const result = convertToken(token, token.kind);
+        tokens.push(result);
+        token = lexer.advance();
+    }
+    return tokens;
 }
 function extractCommentsFromAst(loc) {
     if (!loc) {
@@ -2447,35 +2450,16 @@ function extractCommentsFromAst(loc) {
     const comments = [];
     let token = loc.startToken;
     while (token !== null) {
-        const { kind, value, line, column, start, end, next } = token;
-        if (kind === graphql.TokenKind.COMMENT) {
-            comments.push({
-                type: 'Block',
-                value,
-                loc: {
-                    start: { line, column },
-                    end: { line, column },
-                },
-                range: [start, end],
-            });
+        if (token.kind === graphql.TokenKind.COMMENT) {
+            const comment = convertToken(token, 
+            // `eslint-disable` directive works only with `Block` type comment
+            token.value.trimStart().startsWith('eslint') ? 'Block' : 'Line');
+            comments.push(comment);
         }
-        token = next;
+        token = token.next;
     }
     return comments;
 }
-function convertLocation(gqlLocation) {
-    return {
-        start: {
-            column: gqlLocation.startToken.column,
-            line: gqlLocation.startToken.line,
-        },
-        end: {
-            column: gqlLocation.endToken.column,
-            line: gqlLocation.endToken.line,
-        },
-        source: gqlLocation.source.body,
-    };
-}
 function isNodeWithDescription(obj) {
     var _a;
     return (_a = obj) === null || _a === void 0 ? void 0 : _a.description;
@@ -2561,7 +2545,7 @@ const rule$f = {
                 const deletionDateNode = node.arguments.find(arg => arg.name.value === argName);
                 if (!deletionDateNode) {
                     context.report({
-                        loc: getLocation(node.loc, node.name.value, { offsetEnd: 0 }),
+                        node: node.name,
                         messageId: MESSAGE_REQUIRE_DATE,
                     });
                     return;
@@ -2589,7 +2573,7 @@ const rule$f = {
                 const canRemove = Date.now() > deletionDateInMS;
                 if (canRemove) {
                     context.report({
-                        node,
+                        node: node.parent.name,
                         messageId: MESSAGE_CAN_BE_REMOVED,
                         data: {
                             nodeName: node.parent.name.value,
@@ -2646,7 +2630,7 @@ const rule$g = {
                 const value = reasonArg ? String(valueFromNode(reasonArg.value) || '').trim() : null;
                 if (!value) {
                     context.report({
-                        loc: getLocation(node.loc, node.name.value, { offsetEnd: 0 }),
+                        node: node.name,
                         message: 'Directive "@deprecated" must have a reason!',
                     });
                 }
@@ -2658,12 +2642,40 @@ const rule$g = {
 const RULE_ID$2 = 'require-description';
 const ALLOWED_KINDS$1 = [
     ...TYPES_KINDS,
+    graphql.Kind.DIRECTIVE_DEFINITION,
     graphql.Kind.FIELD_DEFINITION,
     graphql.Kind.INPUT_VALUE_DEFINITION,
     graphql.Kind.ENUM_VALUE_DEFINITION,
-    graphql.Kind.DIRECTIVE_DEFINITION,
     graphql.Kind.OPERATION_DEFINITION,
 ];
+function getNodeName(node) {
+    const DisplayNodeNameMap = {
+        [graphql.Kind.OBJECT_TYPE_DEFINITION]: 'type',
+        [graphql.Kind.INTERFACE_TYPE_DEFINITION]: 'interface',
+        [graphql.Kind.ENUM_TYPE_DEFINITION]: 'enum',
+        [graphql.Kind.SCALAR_TYPE_DEFINITION]: 'scalar',
+        [graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION]: 'input',
+        [graphql.Kind.UNION_TYPE_DEFINITION]: 'union',
+        [graphql.Kind.DIRECTIVE_DEFINITION]: 'directive',
+    };
+    switch (node.kind) {
+        case graphql.Kind.OBJECT_TYPE_DEFINITION:
+        case graphql.Kind.INTERFACE_TYPE_DEFINITION:
+        case graphql.Kind.ENUM_TYPE_DEFINITION:
+        case graphql.Kind.SCALAR_TYPE_DEFINITION:
+        case graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+        case graphql.Kind.UNION_TYPE_DEFINITION:
+            return `${DisplayNodeNameMap[node.kind]} ${node.name.value}`;
+        case graphql.Kind.DIRECTIVE_DEFINITION:
+            return `${DisplayNodeNameMap[node.kind]} @${node.name.value}`;
+        case graphql.Kind.FIELD_DEFINITION:
+        case graphql.Kind.INPUT_VALUE_DEFINITION:
+        case graphql.Kind.ENUM_VALUE_DEFINITION:
+            return `${node.parent.name.value}.${node.name.value}`;
+        case graphql.Kind.OPERATION_DEFINITION:
+            return node.name ? `${node.operation} ${node.name.value}` : node.operation;
+    }
+}
 const rule$h = {
     meta: {
         docs: {
@@ -2716,7 +2728,7 @@ const rule$h = {
         },
         type: 'suggestion',
         messages: {
-            [RULE_ID$2]: 'Description is required for nodes of type "{{ nodeType }}"',
+            [RULE_ID$2]: 'Description is required for `{{ nodeName }}`.',
         },
         schema: {
             type: 'array',
@@ -2775,10 +2787,10 @@ const rule$h = {
                 }
                 if (description.length === 0) {
                     context.report({
-                        loc: isOperation ? getLocation(node.loc, node.operation) : getLocation(node.name.loc, node.name.value),
+                        loc: isOperation ? getLocation(node.loc, node.operation) : node.name.loc,
                         messageId: RULE_ID$2,
                         data: {
-                            nodeType: node.kind,
+                            nodeName: getNodeName(node),
                         },
                     });
                 }
@@ -2848,7 +2860,7 @@ const rule$i = {
                     const hasQueryType = fields.some(field => getTypeName(field) === queryType.name);
                     if (!hasQueryType) {
                         context.report({
-                            loc: getLocation(node.loc, typeName),
+                            node,
                             message: `Mutation result type "${graphQLType.name}" must contain field of type "${queryType.name}"`,
                         });
                     }
@@ -2868,16 +2880,30 @@ function convertToESTree(node, typeInfo) {
 function hasTypeField(obj) {
     return obj && !!obj.type;
 }
-/**
- * Strips tokens information from `location` object - this is needed since it's created as linked list in GraphQL-JS,
- * causing eslint to fail on circular JSON
- * @param location
- */
-function stripTokens(location) {
-    return {
-        end: location.end,
-        start: location.start,
+function convertLocation(location) {
+    const { startToken, endToken, source, start, end } = location;
+    /*
+     * ESLint has 0-based column number
+     * https://eslint.org/docs/developer-guide/working-with-rules#contextreport
+     */
+    const loc = {
+        start: {
+            /*
+             * Kind.Document has startToken: { line: 0, column: 0 }, we set line as 1 and column as 0
+             */
+            line: startToken.line === 0 ? 1 : startToken.line,
+            column: startToken.column === 0 ? 0 : startToken.column - 1,
+        },
+        end: {
+            line: endToken.line,
+            column: endToken.column - 1,
+        },
+        source: source.body,
     };
+    if (loc.start.column === loc.end.column) {
+        loc.end.column += end - start;
+    }
+    return loc;
 }
 const convertNode = (typeInfo) => (node, key, parent) => {
     const calculatedTypeInfo = typeInfo
@@ -2897,7 +2923,7 @@ const convertNode = (typeInfo) => (node, key, parent) => {
         typeInfo: () => calculatedTypeInfo,
         leadingComments: convertDescription(node),
         loc: convertLocation(node.loc),
-        range: convertRange(node.loc),
+        range: [node.loc.start, node.loc.end],
     };
     if (hasTypeField(node)) {
         const { type: gqlType, loc: gqlLocation, ...rest } = node;
@@ -2922,7 +2948,6 @@ const convertNode = (typeInfo) => (node, key, parent) => {
                 }
                 return parent[key];
             },
-            gqlLocation: stripTokens(gqlLocation),
         };
         return estreeNode;
     }
@@ -2946,7 +2971,6 @@ const convertNode = (typeInfo) => (node, key, parent) => {
                 }
                 return parent[key];
             },
-            gqlLocation: stripTokens(gqlLocation),
         };
         return estreeNode;
     }
@@ -3197,9 +3221,13 @@ const rule$k = {
                     };
                     checkFn({
                         getDocument: () => document,
-                        reportError: (error) => {
+                        reportError(error) {
+                            const { line, column } = error.locations[0];
                             context.report({
-                                loc: getLocation({ start: error.locations[0] }),
+                                loc: {
+                                    line,
+                                    column: column - 1,
+                                },
                                 message: error.message,
                             });
                         },
@@ -3374,7 +3402,7 @@ const rule$l = {
                 // we can extend this rule later.
                 if (validIds.length !== 1) {
                     context.report({
-                        loc: getLocation(node.name.loc, typeName),
+                        node: node.name,
                         messageId: RULE_ID$5,
                         data: {
                             typeName,
@@ -3410,7 +3438,7 @@ const checkNode = (context, node, ruleName, messageId) => {
                     .map(f => `\t${path.relative(process.cwd(), getOnDiskFilepath(f.filePath))}`)
                     .join('\n'),
             },
-            loc: getLocation(node.name.loc, documentName),
+            node: node.name,
         });
     }
 };
@@ -3964,6 +3992,15 @@ function parseForESLint(code, options = {}) {
     }
 }
 
+function indentCode(code, indent = 4) {
+    return code.replace(/^/gm, ' '.repeat(indent));
+}
+function printCode(code) {
+    return codeFrame.codeFrameColumns(code, { start: { line: 0, column: 0 } }, {
+        linesAbove: Number.POSITIVE_INFINITY,
+        linesBelow: Number.POSITIVE_INFINITY,
+    });
+}
 class GraphQLRuleTester extends eslint.RuleTester {
     constructor(parserOptions = {}) {
         const config = {
@@ -4019,15 +4056,14 @@ class GraphQLRuleTester extends eslint.RuleTester {
                 if (message.fatal) {
                     throw new Error(message.message);
                 }
-                messageForSnapshot.push(`Error ${index + 1}/${messages.length}`, visualizeEslintMessage(code, message));
+                messageForSnapshot.push(`❌ Error ${index + 1}/${messages.length}`, visualizeEslintMessage(code, message));
             }
             if (rule.meta.fixable) {
                 const { fixed, output } = linter.verifyAndFix(code, verifyConfig, { filename });
                 if (fixed) {
-                    messageForSnapshot.push('Autofix output', dedent(output));
+                    messageForSnapshot.push('🔧 Autofix output', indentCode(printCode(output), 2));
                 }
             }
-            // eslint-disable-next-line no-undef
             expect(messageForSnapshot.join('\n\n')).toMatchSnapshot();
         }
     }
@@ -4084,10 +4120,10 @@ function visualizeEslintMessage(text, result) {
 exports.GraphQLRuleTester = GraphQLRuleTester;
 exports.configs = configs;
 exports.convertDescription = convertDescription;
-exports.convertLocation = convertLocation;
-exports.convertRange = convertRange;
 exports.convertToESTree = convertToESTree;
+exports.convertToken = convertToken;
 exports.extractCommentsFromAst = extractCommentsFromAst;
+exports.extractTokens = extractTokens;
 exports.getBaseType = getBaseType;
 exports.isNodeWithDescription = isNodeWithDescription;
 exports.parse = parse;