@graphql-eslint/eslint-plugin 2.3.0-alpha-6ba4002.0 → 2.3.2-alpha-99be3d2.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`
@@ -71,6 +73,16 @@ const allConfig = {
     ...recommendedConfig,
     rules: {
         ...recommendedConfig.rules,
+        '@graphql-eslint/alphabetize': [
+            'error',
+            {
+                fields: ['ObjectTypeDefinition', 'InterfaceTypeDefinition', 'InputObjectTypeDefinition'],
+                values: ['EnumTypeDefinition'],
+                selections: ['OperationDefinition', 'FragmentDefinition'],
+                variables: ['OperationDefinition'],
+                arguments: ['FieldDefinition', 'Field', 'DirectiveDefinition', 'Directive'],
+            },
+        ],
         '@graphql-eslint/avoid-duplicate-fields': 'error',
         '@graphql-eslint/avoid-operation-name-prefix': 'error',
         '@graphql-eslint/avoid-scalar-result-type-on-mutation': 'error',
@@ -232,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:/) || [];
@@ -282,6 +312,7 @@ const validationToRule = (name, ruleName, docs, getDocumentNode) => {
             meta: {
                 docs: {
                     ...docs,
+                    graphQLJSRuleName: ruleName,
                     category: 'Validation',
                     recommended: true,
                     requiresSchema,
@@ -405,7 +436,7 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
     description: `A GraphQL fragment is only valid when it does not have cycles in fragments usage.`,
 }), validationToRule('no-undefined-variables', 'NoUndefinedVariables', {
     description: `A GraphQL operation is only valid if all variables encountered, both directly and via fragment spreads, are defined by that operation.`,
-}), validationToRule('no-unused-fragments', 'NoUnusedFragments', {
+}, importFiles), validationToRule('no-unused-fragments', 'NoUnusedFragments', {
     description: `A GraphQL document is only valid if all fragment definitions are spread within operations, or spread within other fragments spread within operations.`,
     requiresSiblings: true,
 }, context => {
@@ -481,6 +512,237 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
     description: `Variables passed to field arguments conform to type.`,
 }));
 
+const ALPHABETIZE = 'ALPHABETIZE';
+const fieldsEnum = [graphql.Kind.OBJECT_TYPE_DEFINITION, graphql.Kind.INTERFACE_TYPE_DEFINITION, graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION];
+const valuesEnum = [graphql.Kind.ENUM_TYPE_DEFINITION];
+const selectionsEnum = [graphql.Kind.OPERATION_DEFINITION, graphql.Kind.FRAGMENT_DEFINITION];
+const variablesEnum = [graphql.Kind.OPERATION_DEFINITION];
+const argumentsEnum = [graphql.Kind.FIELD_DEFINITION, graphql.Kind.FIELD, graphql.Kind.DIRECTIVE_DEFINITION, graphql.Kind.DIRECTIVE];
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            category: 'Best Practices',
+            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: [
+                {
+                    title: 'Incorrect',
+                    usage: [{ fields: [graphql.Kind.OBJECT_TYPE_DEFINITION] }],
+                    code: /* GraphQL */ `
+            type User {
+              password: String
+              firstName: String! # should be before "password"
+              age: Int # should be before "firstName"
+              lastName: String!
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ fields: [graphql.Kind.OBJECT_TYPE_DEFINITION] }],
+                    code: /* GraphQL */ `
+            type User {
+              age: Int
+              firstName: String!
+              lastName: String!
+              password: String
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    usage: [{ values: [graphql.Kind.ENUM_TYPE_DEFINITION] }],
+                    code: /* GraphQL */ `
+            enum Role {
+              SUPER_ADMIN
+              ADMIN # should be before "SUPER_ADMIN"
+              USER
+              GOD # should be before "USER"
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ values: [graphql.Kind.ENUM_TYPE_DEFINITION] }],
+                    code: /* GraphQL */ `
+            enum Role {
+              ADMIN
+              GOD
+              SUPER_ADMIN
+              USER
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    usage: [{ selections: [graphql.Kind.OPERATION_DEFINITION] }],
+                    code: /* GraphQL */ `
+            query {
+              me {
+                firstName
+                lastName
+                email # should be before "lastName"
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ selections: [graphql.Kind.OPERATION_DEFINITION] }],
+                    code: /* GraphQL */ `
+            query {
+              me {
+                email
+                firstName
+                lastName
+              }
+            }
+          `,
+                },
+            ],
+            optionsForConfig: [
+                {
+                    fields: fieldsEnum,
+                    values: valuesEnum,
+                    selections: selectionsEnum,
+                    variables: variablesEnum,
+                    arguments: argumentsEnum,
+                },
+            ],
+        },
+        messages: {
+            [ALPHABETIZE]: '"{{ currName }}" should be before "{{ prevName }}".',
+        },
+        schema: {
+            type: 'array',
+            minItems: 1,
+            maxItems: 1,
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                minProperties: 1,
+                properties: {
+                    fields: {
+                        type: 'array',
+                        contains: {
+                            enum: fieldsEnum,
+                        },
+                        description: 'Fields of `type`, `interface`, and `input`.',
+                    },
+                    values: {
+                        type: 'array',
+                        contains: {
+                            enum: valuesEnum,
+                        },
+                        description: 'Values of `enum`.',
+                    },
+                    selections: {
+                        type: 'array',
+                        contains: {
+                            enum: selectionsEnum,
+                        },
+                        description: 'Selections of operations (`query`, `mutation` and `subscription`) and `fragment`.',
+                    },
+                    variables: {
+                        type: 'array',
+                        contains: {
+                            enum: variablesEnum,
+                        },
+                        description: 'Variables of operations (`query`, `mutation` and `subscription`).',
+                    },
+                    arguments: {
+                        type: 'array',
+                        contains: {
+                            enum: argumentsEnum,
+                        },
+                        description: 'Arguments of fields and directives.',
+                    },
+                },
+            },
+        },
+    },
+    create(context) {
+        var _a, _b, _c, _d, _e;
+        function checkNodes(nodes) {
+            let prevName = null;
+            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,
+                        },
+                        messageId: ALPHABETIZE,
+                        data: isVariableNode
+                            ? {
+                                currName: `$${currName}`,
+                                prevName: `$${prevName}`,
+                            }
+                            : { currName, prevName },
+                    });
+                }
+                prevName = currName;
+            }
+        }
+        const opts = context.options[0];
+        const fields = new Set((_a = opts.fields) !== null && _a !== void 0 ? _a : []);
+        const listeners = {};
+        const fieldsSelector = [
+            fields.has(graphql.Kind.OBJECT_TYPE_DEFINITION) && [graphql.Kind.OBJECT_TYPE_DEFINITION, graphql.Kind.OBJECT_TYPE_EXTENSION],
+            fields.has(graphql.Kind.INTERFACE_TYPE_DEFINITION) && [graphql.Kind.INTERFACE_TYPE_DEFINITION, graphql.Kind.INTERFACE_TYPE_EXTENSION],
+            fields.has(graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION) && [
+                graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+                graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION,
+            ],
+        ]
+            .flat()
+            .join(',');
+        const hasEnumValues = ((_b = opts.values) === null || _b === void 0 ? void 0 : _b[0]) === graphql.Kind.ENUM_TYPE_DEFINITION;
+        const selectionsSelector = (_c = opts.selections) === null || _c === void 0 ? void 0 : _c.join(',');
+        const hasVariables = ((_d = opts.variables) === null || _d === void 0 ? void 0 : _d[0]) === graphql.Kind.OPERATION_DEFINITION;
+        const argumentsSelector = (_e = opts.arguments) === null || _e === void 0 ? void 0 : _e.join(',');
+        if (fieldsSelector) {
+            listeners[fieldsSelector] = (node) => {
+                checkNodes(node.fields);
+            };
+        }
+        if (hasEnumValues) {
+            const enumValuesSelector = [graphql.Kind.ENUM_TYPE_DEFINITION, graphql.Kind.ENUM_TYPE_EXTENSION].join(',');
+            listeners[enumValuesSelector] = (node) => {
+                checkNodes(node.values);
+            };
+        }
+        if (selectionsSelector) {
+            listeners[`:matches(${selectionsSelector}) SelectionSet`] = (node) => {
+                checkNodes(node.selections
+                    // inline fragment don't have name, so we skip them
+                    .filter(selection => selection.kind !== graphql.Kind.INLINE_FRAGMENT)
+                    .map(selection => 
+                // sort by alias is field is renamed
+                'alias' in selection && selection.alias ? { name: selection.alias } : selection));
+            };
+        }
+        if (hasVariables) {
+            listeners.OperationDefinition = (node) => {
+                checkNodes(node.variableDefinitions.map(varDef => varDef.variable));
+            };
+        }
+        if (argumentsSelector) {
+            listeners[argumentsSelector] = (node) => {
+                checkNodes(node.arguments);
+            };
+        }
+        return listeners;
+    },
+};
+
 const AVOID_DUPLICATE_FIELDS = 'AVOID_DUPLICATE_FIELDS';
 const ensureUnique = () => {
     const set = new Set();
@@ -495,7 +757,7 @@ const ensureUnique = () => {
         },
     };
 };
-const rule = {
+const rule$1 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -546,6 +808,7 @@ const rule = {
         messages: {
             [AVOID_DUPLICATE_FIELDS]: `{{ type }} "{{ fieldName }}" defined multiple times.`,
         },
+        schema: [],
     },
     create(context) {
         return {
@@ -603,7 +866,7 @@ const rule = {
 };
 
 const AVOID_OPERATION_NAME_PREFIX = 'AVOID_OPERATION_NAME_PREFIX';
-const rule$1 = {
+const rule$2 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -665,15 +928,16 @@ const rule$1 = {
                         const testKeyword = caseSensitive ? keyword : keyword.toLowerCase();
                         const testName = caseSensitive ? node.name.value : node.name.value.toLowerCase();
                         if (testName.startsWith(testKeyword)) {
+                            const { start } = node.name.loc;
                             context.report({
                                 loc: {
                                     start: {
-                                        line: node.name.loc.start.line,
-                                        column: node.name.loc.start.column - 1,
+                                        line: start.line,
+                                        column: start.column - 1,
                                     },
                                     end: {
-                                        line: node.name.loc.start.line,
-                                        column: node.name.loc.start.column + testKeyword.length - 1,
+                                        line: start.line,
+                                        column: start.column - 1 + testKeyword.length,
                                     },
                                 },
                                 data: {
@@ -689,7 +953,7 @@ const rule$1 = {
     },
 };
 
-const rule$2 = {
+const rule$3 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -716,6 +980,7 @@ const rule$2 = {
                 },
             ],
         },
+        schema: [],
     },
     create(context) {
         const schema = requireGraphQLSchemaFromContext('avoid-scalar-result-type-on-mutation', context);
@@ -741,7 +1006,7 @@ const rule$2 = {
 };
 
 const AVOID_TYPENAME_PREFIX = 'AVOID_TYPENAME_PREFIX';
-const rule$3 = {
+const rule$4 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -771,22 +1036,33 @@ const rule$3 = {
         messages: {
             [AVOID_TYPENAME_PREFIX]: `Field "{{ fieldName }}" starts with the name of the parent type "{{ typeName }}"`,
         },
+        schema: [],
     },
     create(context) {
         return {
             'ObjectTypeDefinition, ObjectTypeExtension, InterfaceTypeDefinition, InterfaceTypeExtension'(node) {
                 const typeName = node.name.value;
-                const lowerTypeName = (typeName || '').toLowerCase();
+                const lowerTypeName = typeName.toLowerCase();
                 for (const field of node.fields) {
-                    const fieldName = field.name.value || '';
-                    if (fieldName && lowerTypeName && fieldName.toLowerCase().startsWith(lowerTypeName)) {
+                    const fieldName = field.name.value;
+                    if (fieldName.toLowerCase().startsWith(lowerTypeName)) {
+                        const { start } = field.loc;
                         context.report({
-                            node: field.name,
                             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,
+                                },
+                            },
                         });
                     }
                 }
@@ -795,7 +1071,7 @@ const rule$3 = {
     },
 };
 
-const rule$4 = {
+const rule$5 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -806,9 +1082,9 @@ const rule$4 = {
                     code: /* GraphQL */ `
             """ Description """
             type someTypeName {
-                ...
+              # ...
             }
-            `,
+          `,
                 },
                 {
                     title: 'Correct',
@@ -816,9 +1092,9 @@ const rule$4 = {
                     code: /* GraphQL */ `
             " Description "
             type someTypeName {
-                ...
+              # ...
             }
-            `,
+          `,
                 },
             ],
             description: 'Require all comments to follow the same style (either block or inline).',
@@ -855,7 +1131,7 @@ const rule$4 = {
     },
 };
 
-const rule$5 = {
+const rule$6 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -980,7 +1256,7 @@ const CASE_STYLES = [
 const schemaOption = {
     oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
 };
-const rule$6 = {
+const rule$7 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -1114,7 +1390,8 @@ const rule$6 = {
                 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,
@@ -1146,7 +1423,8 @@ const rule$6 = {
                 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,
@@ -1225,7 +1503,7 @@ function checkNameFormat(params) {
 const schemaOption$1 = {
     oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
 };
-const rule$7 = {
+const rule$8 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -1337,18 +1615,18 @@ const rule$7 = {
                 style,
                 leadingUnderscore: options.leadingUnderscore,
                 trailingUnderscore: options.trailingUnderscore,
-                prefix: prefix,
-                suffix: suffix,
-                forbiddenPrefixes: forbiddenPrefixes,
-                forbiddenSuffixes: forbiddenSuffixes,
+                prefix,
+                suffix,
+                forbiddenPrefixes,
+                forbiddenSuffixes,
             });
             if (result.ok === false) {
                 context.report({
                     node,
                     message: result.errorMessage,
                     data: {
-                        prefix: prefix,
-                        suffix: suffix,
+                        prefix,
+                        suffix,
                         format: style,
                         forbiddenPrefixes: forbiddenPrefixes.join(', '),
                         forbiddenSuffixes: forbiddenSuffixes.join(', '),
@@ -1454,7 +1732,7 @@ const rule$7 = {
 };
 
 const NO_ANONYMOUS_OPERATIONS = 'NO_ANONYMOUS_OPERATIONS';
-const rule$8 = {
+const rule$9 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -1484,20 +1762,24 @@ const rule$8 = {
         messages: {
             [NO_ANONYMOUS_OPERATIONS]: `Anonymous GraphQL operations are forbidden. Please make sure to name your {{ operation }}!`,
         },
+        schema: [],
     },
     create(context) {
         return {
             OperationDefinition(node) {
-                if (node && (!node.name || node.name.value === '')) {
+                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: node.loc.start.column - 1,
-                                line: node.loc.start.line,
+                                column: start.column - 1,
+                                line: start.line,
                             },
                             end: {
-                                column: node.loc.start.column + node.operation.length,
-                                line: node.loc.start.line,
+                                column: start.column - 1 + node.operation.length,
+                                line: start.line,
                             },
                         },
                         data: {
@@ -1512,7 +1794,7 @@ const rule$8 = {
 };
 
 const ERROR_MESSAGE_ID = 'NO_CASE_INSENSITIVE_ENUM_VALUES_DUPLICATES';
-const rule$9 = {
+const rule$a = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -1547,6 +1829,7 @@ const rule$9 = {
         messages: {
             [ERROR_MESSAGE_ID]: `Case-insensitive enum values duplicates are not allowed! Found: "{{ found }}"`,
         },
+        schema: [],
     },
     create(context) {
         return {
@@ -1567,7 +1850,7 @@ const rule$9 = {
 };
 
 const NO_DEPRECATED = 'NO_DEPRECATED';
-const rule$a = {
+const rule$b = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -1641,6 +1924,7 @@ const rule$a = {
         messages: {
             [NO_DEPRECATED]: `This {{ type }} is marked as deprecated in your GraphQL schema {{ reason }}`,
         },
+        schema: [],
     },
     create(context) {
         return {
@@ -1681,7 +1965,7 @@ const rule$a = {
 };
 
 const HASHTAG_COMMENT = 'HASHTAG_COMMENT';
-const rule$b = {
+const rule$c = {
     meta: {
         messages: {
             [HASHTAG_COMMENT]: 'Using hashtag (#) for adding GraphQL descriptions is not allowed. Prefer using """ for multiline, or " for a single line description.',
@@ -1727,6 +2011,7 @@ const rule$b = {
             ],
         },
         type: 'suggestion',
+        schema: [],
     },
     create(context) {
         return {
@@ -1756,7 +2041,7 @@ const rule$b = {
 };
 
 const NO_OPERATION_NAME_SUFFIX = 'NO_OPERATION_NAME_SUFFIX';
-const rule$c = {
+const rule$d = {
     meta: {
         fixable: 'code',
         type: 'suggestion',
@@ -1787,15 +2072,28 @@ const rule$c = {
         messages: {
             [NO_OPERATION_NAME_SUFFIX]: `Unnecessary "{{ invalidSuffix }}" suffix in your operation name!`,
         },
+        schema: [],
     },
     create(context) {
         return {
             'OperationDefinition, FragmentDefinition'(node) {
-                if (node && node.name && node.name.value !== '') {
-                    const invalidSuffix = (node.type === 'OperationDefinition' ? node.operation : 'fragment').toLowerCase();
-                    if (node.name.value.toLowerCase().endsWith(invalidSuffix)) {
+                var _a;
+                const name = ((_a = node.name) === null || _a === void 0 ? void 0 : _a.value) || '';
+                if (name.length > 0) {
+                    const invalidSuffix = 'operation' in node ? node.operation : 'fragment';
+                    if (name.toLowerCase().endsWith(invalidSuffix)) {
+                        const { start, end } = node.name.loc;
                         context.report({
-                            node: node.name,
+                            loc: {
+                                start: {
+                                    column: start.column - 1 + name.length - invalidSuffix.length,
+                                    line: start.line,
+                                },
+                                end: {
+                                    column: end.column - 1 + name.length,
+                                    line: end.line,
+                                },
+                            },
                             data: {
                                 invalidSuffix,
                             },
@@ -1811,7 +2109,7 @@ const rule$c = {
 
 const UNREACHABLE_TYPE = 'UNREACHABLE_TYPE';
 const RULE_NAME = 'no-unreachable-types';
-const rule$d = {
+const rule$e = {
     meta: {
         messages: {
             [UNREACHABLE_TYPE]: `Type "{{ typeName }}" is unreachable`,
@@ -1852,6 +2150,7 @@ const rule$d = {
         },
         fixable: 'code',
         type: 'suggestion',
+        schema: [],
     },
     create(context) {
         const reachableTypes = requireReachableTypesFromContext(RULE_NAME, context);
@@ -1886,7 +2185,7 @@ const rule$d = {
 
 const UNUSED_FIELD = 'UNUSED_FIELD';
 const RULE_NAME$1 = 'no-unused-fields';
-const rule$e = {
+const rule$f = {
     meta: {
         messages: {
             [UNUSED_FIELD]: `Field "{{fieldName}}" is unused`,
@@ -1943,6 +2242,7 @@ const rule$e = {
         },
         fixable: 'code',
         type: 'suggestion',
+        schema: [],
     },
     create(context) {
         const usedFields = requireUsedFieldsFromContext(RULE_NAME$1, context);
@@ -2073,7 +2373,7 @@ const MESSAGE_REQUIRE_DATE = 'MESSAGE_REQUIRE_DATE';
 const MESSAGE_INVALID_FORMAT = 'MESSAGE_INVALID_FORMAT';
 const MESSAGE_INVALID_DATE = 'MESSAGE_INVALID_DATE';
 const MESSAGE_CAN_BE_REMOVED = 'MESSAGE_CAN_BE_REMOVED';
-const rule$f = {
+const rule$g = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2173,7 +2473,7 @@ const rule$f = {
     },
 };
 
-const rule$g = {
+const rule$h = {
     meta: {
         docs: {
             description: `Require all deprecation directives to specify a reason.`,
@@ -2208,6 +2508,7 @@ const rule$g = {
             ],
         },
         type: 'suggestion',
+        schema: [],
     },
     create(context) {
         return {
@@ -2244,15 +2545,18 @@ 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: node.loc.start.line,
-                        column: node.loc.start.column - 1,
+                        line: start.line,
+                        column: start.column - 1,
                     },
                     end: {
-                        line: node.loc.end.line,
-                        column: node.loc.end.column,
+                        line: end.line,
+                        column: 
+                        // node.name don't exist on SchemaDefinition
+                        'name' in node ? end.column - 1 + node.name.value.length : end.column,
                     },
                 },
                 messageId: REQUIRE_DESCRIPTION_ERROR,
@@ -2263,7 +2567,7 @@ function verifyRule(context, node) {
         }
     }
 }
-const rule$h = {
+const rule$i = {
     meta: {
         docs: {
             category: 'Best Practices',
@@ -2328,7 +2632,7 @@ const rule$h = {
 };
 
 const RULE_NAME$2 = 'require-field-of-type-query-in-mutation-result';
-const rule$i = {
+const rule$j = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2366,6 +2670,7 @@ const rule$i = {
                 },
             ],
         },
+        schema: [],
     },
     create(context) {
         const schema = requireGraphQLSchemaFromContext(RULE_NAME$2, context);
@@ -2491,7 +2796,7 @@ const convertNode = (typeInfo) => (node, key, parent) => {
 
 const REQUIRE_ID_WHEN_AVAILABLE = 'REQUIRE_ID_WHEN_AVAILABLE';
 const DEFAULT_ID_FIELD_NAME = 'id';
-const rule$j = {
+const rule$k = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2627,7 +2932,7 @@ const rule$j = {
     },
 };
 
-const rule$k = {
+const rule$l = {
     meta: {
         docs: {
             category: 'Best Practices',
@@ -2749,7 +3054,7 @@ const shouldIgnoreNode = ({ node, exceptions }) => {
     }
     return false;
 };
-const rule$l = {
+const rule$m = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2902,11 +3207,7 @@ const rule$l = {
 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();
@@ -2917,7 +3218,6 @@ const checkNode = (context, node, ruleName, messageId) => {
         return isSameName && !isSamePath;
     });
     if (conflictingDocuments.length > 0) {
-        const { start, end } = node.name.loc;
         context.report({
             messageId,
             data: {
@@ -2926,20 +3226,11 @@ 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),
         });
     }
 };
-const rule$m = {
+const rule$n = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2985,6 +3276,7 @@ const rule$m = {
         messages: {
             [UNIQUE_FRAGMENT_NAME]: 'Fragment named "{{ documentName }}" already defined in:\n{{ summary }}',
         },
+        schema: [],
     },
     create(context) {
         return {
@@ -2997,7 +3289,7 @@ const rule$m = {
 
 const RULE_NAME$4 = 'unique-operation-name';
 const UNIQUE_OPERATION_NAME = 'UNIQUE_OPERATION_NAME';
-const rule$n = {
+const rule$o = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -3047,10 +3339,11 @@ const rule$n = {
         messages: {
             [UNIQUE_OPERATION_NAME]: 'Operation named "{{ documentName }}" already defined in:\n{{ summary }}',
         },
+        schema: [],
     },
     create(context) {
         return {
-            OperationDefinition(node) {
+            'OperationDefinition[name!=undefined]'(node) {
                 checkNode(context, node, RULE_NAME$4, UNIQUE_OPERATION_NAME);
             },
         };
@@ -3062,30 +3355,31 @@ const rule$n = {
  */
 const rules = {
     ...GRAPHQL_JS_VALIDATIONS,
-    'avoid-duplicate-fields': rule,
-    'avoid-operation-name-prefix': rule$1,
-    'avoid-scalar-result-type-on-mutation': rule$2,
-    'avoid-typename-prefix': rule$3,
-    'description-style': rule$4,
-    'input-name': rule$5,
-    'match-document-filename': rule$6,
-    'naming-convention': rule$7,
-    'no-anonymous-operations': rule$8,
-    'no-case-insensitive-enum-values-duplicates': rule$9,
-    'no-deprecated': rule$a,
-    'no-hashtag-description': rule$b,
-    'no-operation-name-suffix': rule$c,
-    'no-unreachable-types': rule$d,
-    'no-unused-fields': rule$e,
-    'require-deprecation-date': rule$f,
-    'require-deprecation-reason': rule$g,
-    'require-description': rule$h,
-    'require-field-of-type-query-in-mutation-result': rule$i,
-    'require-id-when-available': rule$j,
-    'selection-set-depth': rule$k,
-    'strict-id-in-types': rule$l,
-    'unique-fragment-name': rule$m,
-    'unique-operation-name': rule$n,
+    alphabetize: rule,
+    'avoid-duplicate-fields': rule$1,
+    'avoid-operation-name-prefix': rule$2,
+    'avoid-scalar-result-type-on-mutation': rule$3,
+    'avoid-typename-prefix': rule$4,
+    'description-style': rule$5,
+    'input-name': rule$6,
+    'match-document-filename': rule$7,
+    'naming-convention': rule$8,
+    'no-anonymous-operations': rule$9,
+    'no-case-insensitive-enum-values-duplicates': rule$a,
+    'no-deprecated': rule$b,
+    'no-hashtag-description': rule$c,
+    'no-operation-name-suffix': rule$d,
+    'no-unreachable-types': rule$e,
+    'no-unused-fields': rule$f,
+    'require-deprecation-date': rule$g,
+    'require-deprecation-reason': rule$h,
+    'require-description': rule$i,
+    'require-field-of-type-query-in-mutation-result': rule$j,
+    'require-id-when-available': rule$k,
+    'selection-set-depth': rule$l,
+    'strict-id-in-types': rule$m,
+    'unique-fragment-name': rule$n,
+    'unique-operation-name': rule$o,
 };
 
 const RELEVANT_KEYWORDS = ['gql', 'graphql', '/* GraphQL */'];
@@ -3479,23 +3773,93 @@ 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);
+        // 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;
 exports.configs = configs;