@graphql-eslint/eslint-plugin 3.7.0 → 3.7.1-alpha-d9a3c78.0

package/index.mjs

@@ -202,43 +202,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
@@ -308,21 +271,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,
         },
     };
 }
@@ -336,23 +294,16 @@ function validateDocument(context, schema = null, documentNode, rule) {
             ? validate(schema, documentNode, [rule])
             : 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,
             });
         }
@@ -682,9 +633,10 @@ const argumentsEnum = [
 const rule = {
     meta: {
         type: 'suggestion',
+        fixable: 'code',
         docs: {
             category: ['Schema', 'Operations'],
-            description: 'Enforce arrange in alphabetical order for type fields, enum values, input object fields, operation selections and more.',
+            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: [
                 {
@@ -842,24 +794,56 @@ const rule = {
     },
     create(context) {
         var _a, _b, _c, _d, _e;
+        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) {
-            let prevName = null;
-            for (const node of nodes) {
-                const currName = node.name.value;
-                if (prevName && prevName > currName) {
-                    const isVariableNode = node.kind === Kind.VARIABLE;
-                    context.report({
-                        loc: getLocation(node.loc, node.name.value, { offsetEnd: isVariableNode ? 0 : 1 }),
-                        messageId: ALPHABETIZE,
-                        data: isVariableNode
-                            ? {
-                                currName: `$${currName}`,
-                                prevName: `$${prevName}`,
-                            }
-                            : { currName, prevName },
-                    });
+            // Starts from 1, ignore nodes.length <= 1
+            for (let i = 1; i < nodes.length; i += 1) {
+                const prevNode = nodes[i - 1];
+                const currNode = nodes[i];
+                const prevName = prevNode.name.value;
+                const currName = currNode.name.value;
+                // Compare with lexicographic order
+                if (prevName.localeCompare(currName) !== 1) {
+                    continue;
                 }
-                prevName = currName;
+                const isVariableNode = currNode.kind === 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];
@@ -1056,7 +1040,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"`,
                     });
                 }
@@ -1078,7 +1062,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}"`,
                         });
                     }
@@ -1092,7 +1076,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' }],
 };
@@ -1266,7 +1250,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({
@@ -1523,7 +1514,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: [
                         {
@@ -1581,7 +1572,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: [
                     {
@@ -1697,7 +1688,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}"`,
                     });
                 }
@@ -1791,9 +1782,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',
@@ -1808,9 +1798,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',
@@ -1882,12 +1871,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 === Kind.FIELD && node.alias ? node.alias : node).loc, fieldName, {
-                        offsetEnd: node.kind === Kind.VARIABLE_DEFINITION ? 0 : 1,
-                    }),
+                    node,
                     messageId: NO_DUPLICATE_FIELDS,
                     data: {
                         type,
@@ -1903,21 +1891,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 === 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);
                     }
                 }
             },
@@ -1976,7 +1963,7 @@ const rule$9 = {
         schema: [],
     },
     create(context) {
-        const selector = `${Kind.DOCUMENT}[definitions.0.kind!=/^(${Kind.OPERATION_DEFINITION}|${Kind.FRAGMENT_DEFINITION})$/]`;
+        const selector = 'Document[definitions.0.kind!=/^(OperationDefinition|FragmentDefinition)$/]';
         return {
             [selector](node) {
                 const rawNode = node.rawNode();
@@ -1989,7 +1976,10 @@ const rule$9 = {
                         if (!isEslintComment && line !== prev.line && next.kind === TokenKind.NAME && linesAfter < 2) {
                             context.report({
                                 messageId: HASHTAG_COMMENT,
-                                loc: getLocation({ start: { line, column } }),
+                                loc: {
+                                    line,
+                                    column: column - 1,
+                                },
                             });
                         }
                     }
@@ -2072,7 +2062,7 @@ const rule$a = {
             [selector](node) {
                 const typeName = node.value;
                 context.report({
-                    loc: getLocation(node.loc, typeName),
+                    node,
                     message: `Root type "${typeName}" is forbidden`,
                 });
             },
@@ -2125,7 +2115,7 @@ const rule$b = {
                 const graphQLType = schema.getType(typeName);
                 if (isScalarType(graphQLType)) {
                     context.report({
-                        loc: getLocation(node.loc, typeName),
+                        node,
                         message: `Unexpected scalar result type "${typeName}"`,
                     });
                 }
@@ -2181,7 +2171,7 @@ const rule$c = {
                                 typeName,
                             },
                             messageId: NO_TYPENAME_PREFIX,
-                            loc: getLocation(field.loc, lowerTypeName),
+                            node: field.name,
                         });
                     }
                 }
@@ -2259,7 +2249,7 @@ const rule$d = {
                 const typeName = node.name.value;
                 if (!reachableTypes.has(typeName)) {
                     context.report({
-                        loc: getLocation(node.name.loc, typeName, { offsetStart: node.kind === Kind.DIRECTIVE_DEFINITION ? 2 : 1 }),
+                        node: node.name,
                         messageId: UNREACHABLE_TYPE,
                         data: { typeName },
                         suggest: [
@@ -2348,7 +2338,7 @@ const rule$e = {
                     return;
                 }
                 context.report({
-                    loc: getLocation(node.loc, fieldName),
+                    node: node.name,
                     messageId: UNUSED_FIELD,
                     data: { fieldName },
                     suggest: [
@@ -2401,8 +2391,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 !== TokenKind.EOF) {
+        const result = convertToken(token, token.kind);
+        tokens.push(result);
+        token = lexer.advance();
+    }
+    return tokens;
 }
 function extractCommentsFromAst(loc) {
     if (!loc) {
@@ -2411,35 +2444,16 @@ function extractCommentsFromAst(loc) {
     const comments = [];
     let token = loc.startToken;
     while (token !== null) {
-        const { kind, value, line, column, start, end, next } = token;
-        if (kind === TokenKind.COMMENT) {
-            comments.push({
-                type: 'Block',
-                value,
-                loc: {
-                    start: { line, column },
-                    end: { line, column },
-                },
-                range: [start, end],
-            });
+        if (token.kind === 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;
@@ -2525,7 +2539,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;
@@ -2553,7 +2567,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,
@@ -2610,7 +2624,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!',
                     });
                 }
@@ -2619,20 +2633,49 @@ const rule$g = {
     },
 };
 
-const REQUIRE_DESCRIPTION_ERROR = 'REQUIRE_DESCRIPTION_ERROR';
+const RULE_ID$2 = 'require-description';
 const ALLOWED_KINDS$1 = [
     ...TYPES_KINDS,
+    Kind.DIRECTIVE_DEFINITION,
     Kind.FIELD_DEFINITION,
     Kind.INPUT_VALUE_DEFINITION,
     Kind.ENUM_VALUE_DEFINITION,
-    Kind.DIRECTIVE_DEFINITION,
+    Kind.OPERATION_DEFINITION,
 ];
+function getNodeName(node) {
+    const DisplayNodeNameMap = {
+        [Kind.OBJECT_TYPE_DEFINITION]: 'type',
+        [Kind.INTERFACE_TYPE_DEFINITION]: 'interface',
+        [Kind.ENUM_TYPE_DEFINITION]: 'enum',
+        [Kind.SCALAR_TYPE_DEFINITION]: 'scalar',
+        [Kind.INPUT_OBJECT_TYPE_DEFINITION]: 'input',
+        [Kind.UNION_TYPE_DEFINITION]: 'union',
+        [Kind.DIRECTIVE_DEFINITION]: 'directive',
+    };
+    switch (node.kind) {
+        case Kind.OBJECT_TYPE_DEFINITION:
+        case Kind.INTERFACE_TYPE_DEFINITION:
+        case Kind.ENUM_TYPE_DEFINITION:
+        case Kind.SCALAR_TYPE_DEFINITION:
+        case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+        case Kind.UNION_TYPE_DEFINITION:
+            return `${DisplayNodeNameMap[node.kind]} ${node.name.value}`;
+        case Kind.DIRECTIVE_DEFINITION:
+            return `${DisplayNodeNameMap[node.kind]} @${node.name.value}`;
+        case Kind.FIELD_DEFINITION:
+        case Kind.INPUT_VALUE_DEFINITION:
+        case Kind.ENUM_VALUE_DEFINITION:
+            return `${node.parent.name.value}.${node.name.value}`;
+        case Kind.OPERATION_DEFINITION:
+            return node.name ? `${node.operation} ${node.name.value}` : node.operation;
+    }
+}
 const rule$h = {
     meta: {
         docs: {
             category: 'Schema',
-            description: 'Enforce descriptions in your type definitions.',
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/require-description.md',
+            description: 'Enforce descriptions in type definitions and operations.',
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$2}.md`,
             examples: [
                 {
                     title: 'Incorrect',
@@ -2656,6 +2699,16 @@ const rule$h = {
               """
               name: String
             }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ OperationDefinition: true }],
+                    code: /* GraphQL */ `
+            # Create a new user
+            mutation createUser {
+              # ...
+            }
           `,
                 },
             ],
@@ -2669,7 +2722,7 @@ const rule$h = {
         },
         type: 'suggestion',
         messages: {
-            [REQUIRE_DESCRIPTION_ERROR]: 'Description is required for nodes of type "{{ nodeType }}"',
+            [RULE_ID$2]: 'Description is required for `{{ nodeName }}`.',
         },
         schema: {
             type: 'array',
@@ -2684,19 +2737,19 @@ const rule$h = {
                         type: 'boolean',
                         description: `Includes:\n\n${TYPES_KINDS.map(kind => `- \`${kind}\``).join('\n')}`,
                     },
-                    ...Object.fromEntries([...ALLOWED_KINDS$1].sort().map(kind => [
-                        kind,
-                        {
-                            type: 'boolean',
-                            description: `Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#${kind}).`,
-                        },
-                    ])),
+                    ...Object.fromEntries([...ALLOWED_KINDS$1].sort().map(kind => {
+                        let description = `Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#${kind}).`;
+                        if (kind === Kind.OPERATION_DEFINITION) {
+                            description += '\n\n> You must use only comment syntax `#` and not description syntax `"""` or `"`.';
+                        }
+                        return [kind, { type: 'boolean', description }];
+                    })),
                 },
             },
         },
     },
     create(context) {
-        const { types, ...restOptions } = context.options[0];
+        const { types, ...restOptions } = context.options[0] || {};
         const kinds = new Set(types ? TYPES_KINDS : []);
         for (const [kind, isEnabled] of Object.entries(restOptions)) {
             if (isEnabled) {
@@ -2710,13 +2763,28 @@ const rule$h = {
         return {
             [selector](node) {
                 var _a;
-                const description = ((_a = node.description) === null || _a === void 0 ? void 0 : _a.value) || '';
-                if (description.trim().length === 0) {
+                let description = '';
+                const isOperation = node.kind === Kind.OPERATION_DEFINITION;
+                if (isOperation) {
+                    const rawNode = node.rawNode();
+                    const { prev, line } = rawNode.loc.startToken;
+                    if (prev.kind === TokenKind.COMMENT) {
+                        const value = prev.value.trim();
+                        const linesBefore = line - prev.line;
+                        if (!value.startsWith('eslint') && linesBefore === 1) {
+                            description = value;
+                        }
+                    }
+                }
+                else {
+                    description = ((_a = node.description) === null || _a === void 0 ? void 0 : _a.value.trim()) || '';
+                }
+                if (description.length === 0) {
                     context.report({
-                        loc: getLocation(node.name.loc, node.name.value),
-                        messageId: REQUIRE_DESCRIPTION_ERROR,
+                        loc: isOperation ? getLocation(node.loc, node.operation) : node.name.loc,
+                        messageId: RULE_ID$2,
                         data: {
-                            nodeType: node.kind,
+                            nodeName: getNodeName(node),
                         },
                     });
                 }
@@ -2786,7 +2854,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}"`,
                         });
                     }
@@ -2806,16 +2874,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
@@ -2835,7 +2917,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;
@@ -2860,7 +2942,6 @@ const convertNode = (typeInfo) => (node, key, parent) => {
                 }
                 return parent[key];
             },
-            gqlLocation: stripTokens(gqlLocation),
         };
         return estreeNode;
     }
@@ -2884,13 +2965,12 @@ const convertNode = (typeInfo) => (node, key, parent) => {
                 }
                 return parent[key];
             },
-            gqlLocation: stripTokens(gqlLocation),
         };
         return estreeNode;
     }
 };
 
-const RULE_ID$2 = 'require-id-when-available';
+const RULE_ID$3 = 'require-id-when-available';
 const MESSAGE_ID = 'REQUIRE_ID_WHEN_AVAILABLE';
 const DEFAULT_ID_FIELD_NAME = 'id';
 const rule$j = {
@@ -2899,7 +2979,7 @@ const rule$j = {
         docs: {
             category: 'Operations',
             description: 'Enforce selecting specific fields when they are available on the GraphQL type.',
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$2}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$3}.md`,
             requiresSchema: true,
             requiresSiblings: true,
             examples: [
@@ -2973,8 +3053,8 @@ const rule$j = {
         },
     },
     create(context) {
-        requireGraphQLSchemaFromContext(RULE_ID$2, context);
-        const siblings = requireSiblingsOperations(RULE_ID$2, context);
+        requireGraphQLSchemaFromContext(RULE_ID$3, context);
+        const siblings = requireSiblingsOperations(RULE_ID$3, context);
         const { fieldName = DEFAULT_ID_FIELD_NAME } = context.options[0] || {};
         const idNames = asArray(fieldName);
         const isFound = (s) => s.kind === Kind.FIELD && idNames.includes(s.name.value);
@@ -3036,13 +3116,13 @@ const rule$j = {
     },
 };
 
-const RULE_ID$3 = 'selection-set-depth';
+const RULE_ID$4 = 'selection-set-depth';
 const rule$k = {
     meta: {
         docs: {
             category: 'Operations',
             description: `Limit the complexity of the GraphQL operations solely by their depth. Based on [graphql-depth-limit](https://github.com/stems/graphql-depth-limit).`,
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$3}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$4}.md`,
             requiresSiblings: true,
             examples: [
                 {
@@ -3116,10 +3196,10 @@ const rule$k = {
     create(context) {
         let siblings = null;
         try {
-            siblings = requireSiblingsOperations(RULE_ID$3, context);
+            siblings = requireSiblingsOperations(RULE_ID$4, context);
         }
         catch (e) {
-            logger.warn(`Rule "${RULE_ID$3}" works best with siblings operations loaded. For more info: http://bit.ly/graphql-eslint-operations`);
+            logger.warn(`Rule "${RULE_ID$4}" works best with siblings operations loaded. For more info: http://bit.ly/graphql-eslint-operations`);
         }
         const { maxDepth } = context.options[0];
         const ignore = context.options[0].ignore || [];
@@ -3135,23 +3215,27 @@ 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,
                             });
                         },
                     });
                 }
                 catch (e) {
-                    logger.warn(`Rule "${RULE_ID$3}" check failed due to a missing siblings operations. For more info: http://bit.ly/graphql-eslint-operations`, e);
+                    logger.warn(`Rule "${RULE_ID$4}" check failed due to a missing siblings operations. For more info: http://bit.ly/graphql-eslint-operations`, e);
                 }
             },
         };
     },
 };
 
-const RULE_ID$4 = 'strict-id-in-types';
+const RULE_ID$5 = 'strict-id-in-types';
 const rule$l = {
     meta: {
         type: 'suggestion',
@@ -3159,7 +3243,7 @@ const rule$l = {
             description: `Requires output types to have one unique identifier unless they do not have a logical one. Exceptions can be used to ignore output types that do not have unique identifiers.`,
             category: 'Schema',
             recommended: true,
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$4}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$5}.md`,
             requiresSchema: true,
             examples: [
                 {
@@ -3273,7 +3357,7 @@ const rule$l = {
             },
         },
         messages: {
-            [RULE_ID$4]: `{{ typeName }} must have exactly one non-nullable unique identifier. Accepted name(s): {{ acceptedNamesString }}; Accepted type(s): {{ acceptedTypesString }}.`,
+            [RULE_ID$5]: `{{ typeName }} must have exactly one non-nullable unique identifier. Accepted name(s): {{ acceptedNamesString }}; Accepted type(s): {{ acceptedTypesString }}.`,
         },
     },
     create(context) {
@@ -3283,7 +3367,7 @@ const rule$l = {
             exceptions: {},
             ...context.options[0],
         };
-        const schema = requireGraphQLSchemaFromContext(RULE_ID$4, context);
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$5, context);
         const rootTypeNames = [schema.getQueryType(), schema.getMutationType(), schema.getSubscriptionType()]
             .filter(Boolean)
             .map(type => type.name);
@@ -3312,8 +3396,8 @@ const rule$l = {
                 // we can extend this rule later.
                 if (validIds.length !== 1) {
                     context.report({
-                        loc: getLocation(node.name.loc, typeName),
-                        messageId: RULE_ID$4,
+                        node: node.name,
+                        messageId: RULE_ID$5,
                         data: {
                             typeName,
                             acceptedNamesString: options.acceptedIdNames.join(', '),
@@ -3348,7 +3432,7 @@ const checkNode = (context, node, ruleName, messageId) => {
                     .map(f => `\t${relative(process.cwd(), getOnDiskFilepath(f.filePath))}`)
                     .join('\n'),
             },
-            loc: getLocation(node.name.loc, documentName),
+            node: node.name,
         });
     }
 };
@@ -3793,7 +3877,8 @@ function getReachableTypes(schema) {
                 visit(astNode, visitor);
             }
         }
-        else {
+        else if (type.astNode) {
+            // astNode can be undefined for ID, String, Boolean
             visit(type.astNode, visitor);
         }
     };
@@ -3812,7 +3897,8 @@ function getReachableTypes(schema) {
         schema.getMutationType(),
         schema.getSubscriptionType(),
     ]) {
-        if (type) {
+        // if schema don't have Query type, schema.astNode will be undefined
+        if (type === null || type === void 0 ? void 0 : type.astNode) {
             visit(type.astNode, visitor);
         }
     }
@@ -3902,6 +3988,15 @@ function parseForESLint(code, options = {}) {
     }
 }
 
+function indentCode(code, indent = 4) {
+    return code.replace(/^/gm, ' '.repeat(indent));
+}
+function printCode(code) {
+    return codeFrameColumns(code, { start: { line: 0, column: 0 } }, {
+        linesAbove: Number.POSITIVE_INFINITY,
+        linesBelow: Number.POSITIVE_INFINITY,
+    });
+}
 class GraphQLRuleTester extends RuleTester {
     constructor(parserOptions = {}) {
         const config = {
@@ -3943,19 +4038,29 @@ class GraphQLRuleTester extends RuleTester {
         }
         const linter = new Linter();
         linter.defineRule(name, rule);
+        const hasOnlyTest = tests.invalid.some(t => t.only);
         for (const testCase of tests.invalid) {
+            const { only, code, filename } = testCase;
+            if (hasOnlyTest && !only) {
+                continue;
+            }
             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) {
+            const messageForSnapshot = [];
+            for (const [index, message] of messages.entries()) {
                 if (message.fatal) {
                     throw new Error(message.message);
                 }
-                const messageForSnapshot = visualizeEslintMessage(code, message);
-                // eslint-disable-next-line no-undef
-                expect(messageForSnapshot).toMatchSnapshot();
+                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', indentCode(printCode(output), 2));
+                }
             }
+            expect(messageForSnapshot.join('\n\n')).toMatchSnapshot();
         }
     }
 }
@@ -4008,4 +4113,4 @@ function visualizeEslintMessage(text, result) {
     });
 }
 
-export { GraphQLRuleTester, configs, convertDescription, convertLocation, convertRange, convertToESTree, extractCommentsFromAst, getBaseType, isNodeWithDescription, parse, parseForESLint, processors, rules, valueFromNode };
+export { GraphQLRuleTester, configs, convertDescription, convertToESTree, convertToken, extractCommentsFromAst, extractTokens, getBaseType, isNodeWithDescription, parse, parseForESLint, processors, rules, valueFromNode };