@graphql-eslint/eslint-plugin 3.0.0-alpha-0a66b90.0 → 3.0.0-alpha-2918431.0

package/index.mjs

@@ -1,4 +1,4 @@
-import { Kind, validate, isScalarType, TokenKind, isNonNullType, isListType, isObjectType as isObjectType$1, visit, visitWithTypeInfo, GraphQLObjectType, GraphQLInterfaceType, TypeInfo, isInterfaceType, Source, GraphQLError } from 'graphql';
+import { Kind, validate, TokenKind, isScalarType, isNonNullType, isListType, isObjectType as isObjectType$1, visit, visitWithTypeInfo, GraphQLObjectType, GraphQLInterfaceType, TypeInfo, isInterfaceType, Source, GraphQLError } from 'graphql';
 import { validateSDL } from 'graphql/validation/validate';
 import { processImport, parseImportLine } from '@graphql-tools/import';
 import { statSync, existsSync, readFileSync } from 'fs';
@@ -12,14 +12,89 @@ import { CodeFileLoader } from '@graphql-tools/code-file-loader';
 import { RuleTester, Linter } from 'eslint';
 import { codeFrameColumns } from '@babel/code-frame';
 
+const base = {
+    parser: '@graphql-eslint/eslint-plugin',
+    plugins: ['@graphql-eslint'],
+};
+
 /*
  * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
  */
-const recommendedConfig = {
-    parser: '@graphql-eslint/eslint-plugin',
-    plugins: ['@graphql-eslint'],
+const schemaRecommendedConfig = {
+    extends: ['plugin:@graphql-eslint/base'],
+    rules: {
+        '@graphql-eslint/description-style': 'error',
+        '@graphql-eslint/known-argument-names': 'error',
+        '@graphql-eslint/known-directives': 'error',
+        '@graphql-eslint/known-type-names': 'error',
+        '@graphql-eslint/lone-schema-definition': 'error',
+        '@graphql-eslint/naming-convention': [
+            'error',
+            {
+                types: 'PascalCase',
+                fields: 'camelCase',
+                EnumValueDefinition: 'UPPER_CASE',
+                'FieldDefinition[parent.name.value=Query]': {
+                    forbiddenPrefixes: ['query', 'get'],
+                    forbiddenSuffixes: ['Query'],
+                },
+                'FieldDefinition[parent.name.value=Mutation]': {
+                    forbiddenPrefixes: ['mutation'],
+                    forbiddenSuffixes: ['Mutation'],
+                },
+                'FieldDefinition[parent.name.value=Subscription]': {
+                    forbiddenPrefixes: ['subscription'],
+                    forbiddenSuffixes: ['Subscription'],
+                },
+            },
+        ],
+        '@graphql-eslint/no-case-insensitive-enum-values-duplicates': 'error',
+        '@graphql-eslint/no-hashtag-description': 'error',
+        '@graphql-eslint/no-typename-prefix': 'error',
+        '@graphql-eslint/no-unreachable-types': 'error',
+        '@graphql-eslint/possible-type-extension': 'error',
+        '@graphql-eslint/provided-required-arguments': 'error',
+        '@graphql-eslint/require-deprecation-reason': 'error',
+        '@graphql-eslint/strict-id-in-types': 'error',
+        '@graphql-eslint/unique-directive-names': 'error',
+        '@graphql-eslint/unique-directive-names-per-location': 'error',
+        '@graphql-eslint/unique-enum-value-names': 'error',
+        '@graphql-eslint/unique-field-definition-names': 'error',
+        '@graphql-eslint/unique-operation-types': 'error',
+        '@graphql-eslint/unique-type-names': 'error',
+    },
+};
+
+/*
+ * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
+ */
+const schemaAllConfig = {
+    extends: ['plugin:@graphql-eslint/base', 'plugin:@graphql-eslint/schema-recommended'],
+    rules: {
+        '@graphql-eslint/alphabetize': [
+            'error',
+            {
+                fields: ['ObjectTypeDefinition', 'InterfaceTypeDefinition', 'InputObjectTypeDefinition'],
+                values: ['EnumTypeDefinition'],
+                arguments: ['FieldDefinition', 'Field', 'DirectiveDefinition', 'Directive'],
+            },
+        ],
+        '@graphql-eslint/input-name': 'error',
+        '@graphql-eslint/no-root-type': 'off',
+        '@graphql-eslint/no-scalar-result-type-on-mutation': 'error',
+        '@graphql-eslint/no-unused-fields': 'off',
+        '@graphql-eslint/require-deprecation-date': 'error',
+        '@graphql-eslint/require-description': ['error', { types: true, DirectiveDefinition: true }],
+        '@graphql-eslint/require-field-of-type-query-in-mutation-result': 'error',
+    },
+};
+
+/*
+ * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
+ */
+const operationsRecommendedConfig = {
+    extends: ['plugin:@graphql-eslint/base'],
     rules: {
-        '@graphql-eslint/avoid-typename-prefix': 'error',
         '@graphql-eslint/executable-definitions': 'error',
         '@graphql-eslint/fields-on-correct-type': 'error',
         '@graphql-eslint/fragments-on-composite-type': 'error',
@@ -28,58 +103,36 @@ const recommendedConfig = {
         '@graphql-eslint/known-fragment-names': 'error',
         '@graphql-eslint/known-type-names': 'error',
         '@graphql-eslint/lone-anonymous-operation': 'error',
-        '@graphql-eslint/lone-schema-definition': 'error',
         '@graphql-eslint/naming-convention': [
             'error',
             {
-                types: 'PascalCase',
-                fields: 'camelCase',
-                overrides: {
-                    EnumValueDefinition: 'UPPER_CASE',
-                    OperationDefinition: {
-                        style: 'PascalCase',
-                        forbiddenPrefixes: ['Query', 'Mutation', 'Subscription', 'Get'],
-                        forbiddenSuffixes: ['Query', 'Mutation', 'Subscription'],
-                    },
-                    FragmentDefinition: { style: 'PascalCase', forbiddenPrefixes: ['Fragment'], forbiddenSuffixes: ['Fragment'] },
-                    'FieldDefinition[parent.name.value=Query]': {
-                        forbiddenPrefixes: ['query', 'get'],
-                        forbiddenSuffixes: ['Query'],
-                    },
-                    'FieldDefinition[parent.name.value=Mutation]': {
-                        forbiddenPrefixes: ['mutation'],
-                        forbiddenSuffixes: ['Mutation'],
-                    },
-                    'FieldDefinition[parent.name.value=Subscription]': {
-                        forbiddenPrefixes: ['subscription'],
-                        forbiddenSuffixes: ['Subscription'],
-                    },
-                },
+                Argument: 'camelCase',
+                VariableDefinition: 'camelCase',
+                OperationDefinition: {
+                    style: 'PascalCase',
+                    forbiddenPrefixes: ['Query', 'Mutation', 'Subscription', 'Get'],
+                    forbiddenSuffixes: ['Query', 'Mutation', 'Subscription'],
+                },
+                FragmentDefinition: { style: 'PascalCase', forbiddenPrefixes: ['Fragment'], forbiddenSuffixes: ['Fragment'] },
             },
         ],
         '@graphql-eslint/no-anonymous-operations': 'error',
-        '@graphql-eslint/no-case-insensitive-enum-values-duplicates': 'error',
+        '@graphql-eslint/no-deprecated': 'error',
+        '@graphql-eslint/no-duplicate-fields': 'error',
         '@graphql-eslint/no-fragment-cycles': 'error',
-        '@graphql-eslint/no-operation-name-suffix': 'error',
         '@graphql-eslint/no-undefined-variables': 'error',
         '@graphql-eslint/no-unused-fragments': 'error',
         '@graphql-eslint/no-unused-variables': 'error',
         '@graphql-eslint/one-field-subscriptions': 'error',
         '@graphql-eslint/overlapping-fields-can-be-merged': 'error',
         '@graphql-eslint/possible-fragment-spread': 'error',
-        '@graphql-eslint/possible-type-extension': 'error',
         '@graphql-eslint/provided-required-arguments': 'error',
-        '@graphql-eslint/require-deprecation-reason': 'error',
+        '@graphql-eslint/require-id-when-available': 'error',
         '@graphql-eslint/scalar-leafs': 'error',
-        '@graphql-eslint/strict-id-in-types': 'error',
+        '@graphql-eslint/selection-set-depth': ['error', { maxDepth: 7 }],
         '@graphql-eslint/unique-argument-names': 'error',
-        '@graphql-eslint/unique-directive-names': 'error',
         '@graphql-eslint/unique-directive-names-per-location': 'error',
-        '@graphql-eslint/unique-enum-value-names': 'error',
-        '@graphql-eslint/unique-field-definition-names': 'error',
         '@graphql-eslint/unique-input-field-names': 'error',
-        '@graphql-eslint/unique-operation-types': 'error',
-        '@graphql-eslint/unique-type-names': 'error',
         '@graphql-eslint/unique-variable-names': 'error',
         '@graphql-eslint/value-literals-of-correct-type': 'error',
         '@graphql-eslint/variables-are-input-types': 'error',
@@ -90,44 +143,32 @@ const recommendedConfig = {
 /*
  * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
  */
-const allConfig = {
-    ...recommendedConfig,
+const operationsAllConfig = {
+    extends: ['plugin:@graphql-eslint/base', 'plugin:@graphql-eslint/operations-recommended'],
     rules: {
-        ...recommendedConfig.rules,
         '@graphql-eslint/alphabetize': [
             'error',
             {
-                fields: ['ObjectTypeDefinition', 'InterfaceTypeDefinition', 'InputObjectTypeDefinition'],
-                values: ['EnumTypeDefinition'],
                 selections: ['OperationDefinition', 'FragmentDefinition'],
                 variables: ['OperationDefinition'],
-                arguments: ['FieldDefinition', 'Field', 'DirectiveDefinition', 'Directive'],
+                arguments: ['Field', 'Directive'],
             },
         ],
-        '@graphql-eslint/avoid-duplicate-fields': 'error',
-        '@graphql-eslint/avoid-operation-name-prefix': 'error',
-        '@graphql-eslint/avoid-scalar-result-type-on-mutation': 'error',
-        '@graphql-eslint/description-style': 'error',
-        '@graphql-eslint/input-name': 'error',
-        '@graphql-eslint/match-document-filename': 'error',
-        '@graphql-eslint/no-deprecated': 'error',
-        '@graphql-eslint/no-hashtag-description': 'error',
-        '@graphql-eslint/no-root-type': ['error', { disallow: ['subscription'] }],
-        '@graphql-eslint/no-unreachable-types': 'error',
-        '@graphql-eslint/no-unused-fields': 'error',
-        '@graphql-eslint/require-deprecation-date': 'error',
-        '@graphql-eslint/require-description': ['error', { types: true, overrides: { DirectiveDefinition: true } }],
-        '@graphql-eslint/require-field-of-type-query-in-mutation-result': 'error',
-        '@graphql-eslint/require-id-when-available': 'error',
-        '@graphql-eslint/selection-set-depth': 'error',
+        '@graphql-eslint/match-document-filename': [
+            'error',
+            { query: 'kebab-case', mutation: 'kebab-case', subscription: 'kebab-case', fragment: 'kebab-case' },
+        ],
         '@graphql-eslint/unique-fragment-name': 'error',
         '@graphql-eslint/unique-operation-name': 'error',
     },
 };
 
 const configs = {
-    all: allConfig,
-    recommended: recommendedConfig,
+    base,
+    'schema-recommended': schemaRecommendedConfig,
+    'schema-all': schemaAllConfig,
+    'operations-recommended': operationsRecommendedConfig,
+    'operations-all': operationsAllConfig,
 };
 
 function requireSiblingsOperations(ruleName, context) {
@@ -340,7 +381,6 @@ const validationToRule = (name, ruleName, docs, getDocumentNode) => {
                 docs: {
                     ...docs,
                     graphQLJSRuleName: ruleName,
-                    category: 'Validation',
                     recommended: true,
                     requiresSchema,
                     url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${name}.md`,
@@ -377,16 +417,22 @@ const importFiles = (context) => {
     return processImport(context.getFilename());
 };
 const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-definitions', 'ExecutableDefinitions', {
+    category: 'Operations',
     description: `A GraphQL document is only valid for execution if all definitions are either operation or fragment definitions.`,
 }), validationToRule('fields-on-correct-type', 'FieldsOnCorrectType', {
+    category: 'Operations',
     description: 'A GraphQL document is only valid if all fields selected are defined by the parent type, or are an allowed meta field such as `__typename`.',
 }), validationToRule('fragments-on-composite-type', 'FragmentsOnCompositeTypes', {
+    category: 'Operations',
     description: `Fragments use a type condition to determine if they apply, since fragments can only be spread into a composite type (object, interface, or union), the type condition must also be a composite type.`,
 }), validationToRule('known-argument-names', 'KnownArgumentNames', {
+    category: ['Schema', 'Operations'],
     description: `A GraphQL field is only valid if all supplied arguments are defined by that field.`,
 }), validationToRule('known-directives', 'KnownDirectives', {
+    category: ['Schema', 'Operations'],
     description: `A GraphQL document is only valid if all \`@directives\` are known by the schema and legally positioned.`,
 }), validationToRule('known-fragment-names', 'KnownFragmentNames', {
+    category: 'Operations',
     description: `A GraphQL document is only valid if all \`...Fragment\` fragment spreads refer to fragments defined in the same document.`,
     examples: [
         {
@@ -453,17 +499,23 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
         },
     ],
 }, importFiles), validationToRule('known-type-names', 'KnownTypeNames', {
+    category: ['Schema', 'Operations'],
     description: `A GraphQL document is only valid if referenced types (specifically variable definitions and fragment conditions) are defined by the type schema.`,
 }), validationToRule('lone-anonymous-operation', 'LoneAnonymousOperation', {
+    category: 'Operations',
     description: `A GraphQL document is only valid if when it contains an anonymous operation (the query short-hand) that it contains only that one operation definition.`,
 }), validationToRule('lone-schema-definition', 'LoneSchemaDefinition', {
+    category: 'Schema',
     description: `A GraphQL document is only valid if it contains only one schema definition.`,
     requiresSchema: false,
 }), validationToRule('no-fragment-cycles', 'NoFragmentCycles', {
+    category: 'Operations',
     description: `A GraphQL fragment is only valid when it does not have cycles in fragments usage.`,
 }), validationToRule('no-undefined-variables', 'NoUndefinedVariables', {
+    category: 'Operations',
     description: `A GraphQL operation is only valid if all variables encountered, both directly and via fragment spreads, are defined by that operation.`,
 }, importFiles), validationToRule('no-unused-fragments', 'NoUnusedFragments', {
+    category: 'Operations',
     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 => {
@@ -493,49 +545,68 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
     };
     return getParentNode(context.getFilename());
 }), validationToRule('no-unused-variables', 'NoUnusedVariables', {
+    category: 'Operations',
     description: `A GraphQL operation is only valid if all variables defined by an operation are used, either directly or within a spread fragment.`,
 }, importFiles), validationToRule('overlapping-fields-can-be-merged', 'OverlappingFieldsCanBeMerged', {
+    category: 'Operations',
     description: `A selection set is only valid if all fields (including spreading any fragments) either correspond to distinct response names or can be merged without ambiguity.`,
 }), validationToRule('possible-fragment-spread', 'PossibleFragmentSpreads', {
+    category: 'Operations',
     description: `A fragment spread is only valid if the type condition could ever possibly be true: if there is a non-empty intersection of the possible parent types, and possible types which pass the type condition.`,
 }), validationToRule('possible-type-extension', 'PossibleTypeExtensions', {
+    category: 'Schema',
     description: `A type extension is only valid if the type is defined and has the same kind.`,
     requiresSchema: false,
 }), validationToRule('provided-required-arguments', 'ProvidedRequiredArguments', {
+    category: ['Schema', 'Operations'],
     description: `A field or directive is only valid if all required (non-null without a default value) field arguments have been provided.`,
 }), validationToRule('scalar-leafs', 'ScalarLeafs', {
+    category: 'Operations',
     description: `A GraphQL document is valid only if all leaf fields (fields without sub selections) are of scalar or enum types.`,
 }), validationToRule('one-field-subscriptions', 'SingleFieldSubscriptions', {
+    category: 'Operations',
     description: `A GraphQL subscription is valid only if it contains a single root field.`,
 }), validationToRule('unique-argument-names', 'UniqueArgumentNames', {
+    category: 'Operations',
     description: `A GraphQL field or directive is only valid if all supplied arguments are uniquely named.`,
 }), validationToRule('unique-directive-names', 'UniqueDirectiveNames', {
+    category: 'Schema',
     description: `A GraphQL document is only valid if all defined directives have unique names.`,
     requiresSchema: false,
 }), validationToRule('unique-directive-names-per-location', 'UniqueDirectivesPerLocation', {
+    category: ['Schema', 'Operations'],
     description: `A GraphQL document is only valid if all non-repeatable directives at a given location are uniquely named.`,
 }), validationToRule('unique-enum-value-names', 'UniqueEnumValueNames', {
+    category: 'Schema',
     description: `A GraphQL enum type is only valid if all its values are uniquely named.`,
     requiresSchema: false,
 }), validationToRule('unique-field-definition-names', 'UniqueFieldDefinitionNames', {
+    category: 'Schema',
     description: `A GraphQL complex type is only valid if all its fields are uniquely named.`,
     requiresSchema: false,
 }), validationToRule('unique-input-field-names', 'UniqueInputFieldNames', {
+    category: 'Operations',
     description: `A GraphQL input object value is only valid if all supplied fields are uniquely named.`,
     requiresSchema: false,
 }), validationToRule('unique-operation-types', 'UniqueOperationTypes', {
+    category: 'Schema',
     description: `A GraphQL document is only valid if it has only one type per operation.`,
     requiresSchema: false,
 }), validationToRule('unique-type-names', 'UniqueTypeNames', {
+    category: 'Schema',
     description: `A GraphQL document is only valid if all defined types have unique names.`,
     requiresSchema: false,
 }), validationToRule('unique-variable-names', 'UniqueVariableNames', {
+    category: 'Operations',
     description: `A GraphQL operation is only valid if all its variables are uniquely named.`,
 }), validationToRule('value-literals-of-correct-type', 'ValuesOfCorrectType', {
+    category: 'Operations',
     description: `A GraphQL document is only valid if all value literals are of the type expected at their position.`,
 }), validationToRule('variables-are-input-types', 'VariablesAreInputTypes', {
+    category: 'Operations',
     description: `A GraphQL operation is only valid if all the variables it defines are of input types (scalar, enum, or input object).`,
 }), validationToRule('variables-in-allowed-position', 'VariablesInAllowedPosition', {
+    category: 'Operations',
     description: `Variables passed to field arguments conform to type.`,
 }));
 
@@ -561,7 +632,7 @@ const rule = {
     meta: {
         type: 'suggestion',
         docs: {
-            category: 'Best Practices',
+            category: ['Schema', 'Operations'],
             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: [
@@ -640,15 +711,22 @@ const rule = {
           `,
                 },
             ],
-            optionsForConfig: [
-                {
-                    fields: fieldsEnum,
-                    values: valuesEnum,
-                    selections: selectionsEnum,
-                    variables: variablesEnum,
-                    arguments: argumentsEnum,
-                },
-            ],
+            configOptions: {
+                schema: [
+                    {
+                        fields: fieldsEnum,
+                        values: valuesEnum,
+                        arguments: argumentsEnum,
+                    },
+                ],
+                operations: [
+                    {
+                        selections: selectionsEnum,
+                        variables: variablesEnum,
+                        arguments: [Kind.FIELD, Kind.DIRECTIVE],
+                    },
+                ],
+            },
         },
         messages: {
             [ALPHABETIZE]: '"{{ currName }}" should be before "{{ prevName }}"',
@@ -786,430 +864,128 @@ const rule = {
     },
 };
 
-const AVOID_DUPLICATE_FIELDS = 'AVOID_DUPLICATE_FIELDS';
 const rule$1 = {
     meta: {
         type: 'suggestion',
         docs: {
-            description: `Checks for duplicate fields in selection set, variables in operation definition, or in arguments set of a field.`,
-            category: 'Stylistic Issues',
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/avoid-duplicate-fields.md',
             examples: [
                 {
                     title: 'Incorrect',
+                    usage: [{ style: 'inline' }],
                     code: /* GraphQL */ `
-            query {
-              user {
-                name
-                email
-                name # duplicate field
-              }
-            }
-          `,
-                },
-                {
-                    title: 'Incorrect',
-                    code: /* GraphQL */ `
-            query {
-              users(
-                first: 100
-                skip: 50
-                after: "cji629tngfgou0b73kt7vi5jo"
-                first: 100 # duplicate argument
-              ) {
-                id
-              }
+            """ Description """
+            type someTypeName {
+              # ...
             }
           `,
                 },
                 {
-                    title: 'Incorrect',
+                    title: 'Correct',
+                    usage: [{ style: 'inline' }],
                     code: /* GraphQL */ `
-            query (
-              $first: Int!
-              $first: Int! # duplicate variable
-            ) {
-              users(first: $first, skip: 50) {
-                id
-              }
+            " Description "
+            type someTypeName {
+              # ...
             }
           `,
                 },
             ],
+            description: 'Require all comments to follow the same style (either block or inline).',
+            category: 'Schema',
+            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/description-style.md',
+            recommended: true,
         },
-        messages: {
-            [AVOID_DUPLICATE_FIELDS]: `{{ type }} "{{ fieldName }}" defined multiple times`,
-        },
-        schema: [],
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    style: {
+                        enum: ['block', 'inline'],
+                        default: 'block',
+                    },
+                },
+            },
+        ],
     },
     create(context) {
-        function checkNode(usedFields, fieldName, type, node) {
-            if (usedFields.has(fieldName)) {
+        const { style = 'block' } = context.options[0] || {};
+        const isBlock = style === 'block';
+        return {
+            [`.description[type=StringValue][block!=${isBlock}]`](node) {
                 context.report({
-                    loc: getLocation((node.kind === Kind.FIELD && node.alias ? node.alias : node).loc, fieldName, {
-                        offsetEnd: node.kind === Kind.VARIABLE_DEFINITION ? 0 : 1,
-                    }),
-                    messageId: AVOID_DUPLICATE_FIELDS,
-                    data: {
-                        type,
-                        fieldName,
-                    },
+                    loc: getLocation(node.loc),
+                    message: `Unexpected ${isBlock ? 'inline' : 'block'} description`,
                 });
-            }
-            else {
-                usedFields.add(fieldName);
-            }
-        }
-        return {
-            OperationDefinition(node) {
-                const set = new Set();
-                for (const varDef of node.variableDefinitions) {
-                    checkNode(set, varDef.variable.name.value, 'Operation variable', varDef);
-                }
-            },
-            Field(node) {
-                const set = new Set();
-                for (const arg of node.arguments) {
-                    checkNode(set, arg.name.value, 'Field argument', arg);
-                }
-            },
-            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);
-                    }
-                }
             },
         };
     },
 };
 
-const AVOID_OPERATION_NAME_PREFIX = 'AVOID_OPERATION_NAME_PREFIX';
+const isObjectType = (node) => [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION].includes(node.type);
+const isQueryType = (node) => isObjectType(node) && node.name.value === 'Query';
+const isMutationType = (node) => isObjectType(node) && node.name.value === 'Mutation';
 const rule$2 = {
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce/avoid operation name prefix, useful if you wish to avoid prefix in your root fields, or avoid using REST terminology in your schema.',
-            category: 'Stylistic Issues',
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/avoid-operation-name-prefix.md',
+            description: 'Require mutation argument to be always called "input" and input type to be called Mutation name + "Input".\nUsing the same name for all input parameters will make your schemas easier to consume and more predictable. Using the same name as mutation for InputType will make it easier to find mutations that InputType belongs to.',
+            category: 'Schema',
+            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/input-name.md',
             examples: [
                 {
                     title: 'Incorrect',
-                    usage: [{ keywords: ['get'] }],
+                    usage: [{ checkInputType: true }],
                     code: /* GraphQL */ `
-            query getUserDetails {
-              # ...
-            }`,
+            type Mutation {
+              SetMessage(message: InputMessage): String
+            }
+          `,
                 },
                 {
-                    title: 'Correct',
-                    usage: [{ keywords: ['get'] }],
+                    title: 'Correct (with checkInputType)',
+                    usage: [{ checkInputType: true }],
                     code: /* GraphQL */ `
-            query userDetails {
-              # ...
-            }`,
+            type Mutation {
+              SetMessage(input: SetMessageInput): String
+            }
+          `,
+                },
+                {
+                    title: 'Correct (without checkInputType)',
+                    usage: [{ checkInputType: false }],
+                    code: /* GraphQL */ `
+            type Mutation {
+              SetMessage(input: AnyInputTypeName): String
+            }
+          `,
                 },
             ],
         },
-        messages: {
-            [AVOID_OPERATION_NAME_PREFIX]: `Forbidden operation name prefix: "{{ invalidPrefix }}"`,
-        },
         schema: [
             {
-                additionalProperties: false,
                 type: 'object',
-                required: ['keywords'],
+                additionalProperties: false,
                 properties: {
-                    caseSensitive: {
+                    checkInputType: {
+                        type: 'boolean',
                         default: false,
+                        description: 'Check that the input type name follows the convention <mutationName>Input',
+                    },
+                    caseSensitiveInputType: {
                         type: 'boolean',
+                        default: true,
+                        description: 'Allow for case discrepancies in the input type name',
                     },
-                    keywords: {
-                        additionalItems: false,
-                        type: 'array',
-                        minItems: 1,
-                        items: {
-                            type: 'string',
-                        },
-                    },
-                },
-            },
-        ],
-    },
-    create(context) {
-        return {
-            'OperationDefinition, FragmentDefinition'(node) {
-                const config = context.options[0] || { keywords: [], caseSensitive: false };
-                const caseSensitive = config.caseSensitive;
-                const keywords = config.keywords || [];
-                if (node && node.name && node.name.value !== '') {
-                    for (const keyword of keywords) {
-                        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: start.line,
-                                        column: start.column - 1,
-                                    },
-                                    end: {
-                                        line: start.line,
-                                        column: start.column - 1 + testKeyword.length,
-                                    },
-                                },
-                                data: {
-                                    invalidPrefix: keyword,
-                                },
-                                messageId: AVOID_OPERATION_NAME_PREFIX,
-                            });
-                        }
-                    }
-                }
-            },
-        };
-    },
-};
-
-const rule$3 = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            category: 'Best Practices',
-            description: 'Avoid scalar result type on mutation type to make sure to return a valid state.',
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/avoid-scalar-result-type-on-mutation.md',
-            requiresSchema: true,
-            examples: [
-                {
-                    title: 'Incorrect',
-                    code: /* GraphQL */ `
-            type Mutation {
-              createUser: Boolean
-            }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    code: /* GraphQL */ `
-            type Mutation {
-              createUser: User!
-            }
-          `,
-                },
-            ],
-        },
-        schema: [],
-    },
-    create(context) {
-        const schema = requireGraphQLSchemaFromContext('avoid-scalar-result-type-on-mutation', context);
-        const mutationType = schema.getMutationType();
-        if (!mutationType) {
-            return {};
-        }
-        const selector = [
-            `:matches(${Kind.OBJECT_TYPE_DEFINITION}, ${Kind.OBJECT_TYPE_EXTENSION})[name.value=${mutationType.name}]`,
-            '>',
-            Kind.FIELD_DEFINITION,
-            Kind.NAMED_TYPE,
-        ].join(' ');
-        return {
-            [selector](node) {
-                const typeName = node.name.value;
-                const graphQLType = schema.getType(typeName);
-                if (isScalarType(graphQLType)) {
-                    context.report({
-                        loc: getLocation(node.loc, typeName),
-                        message: `Unexpected scalar result type "${typeName}"`,
-                    });
-                }
-            },
-        };
-    },
-};
-
-const AVOID_TYPENAME_PREFIX = 'AVOID_TYPENAME_PREFIX';
-const rule$4 = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            category: 'Best Practices',
-            description: 'Enforces users to avoid using the type name in a field name while defining your schema.',
-            recommended: true,
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/avoid-typename-prefix.md',
-            examples: [
-                {
-                    title: 'Incorrect',
-                    code: /* GraphQL */ `
-            type User {
-              userId: ID!
-            }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    code: /* GraphQL */ `
-            type User {
-              id: ID!
-            }
-          `,
-                },
-            ],
-        },
-        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();
-                for (const field of node.fields) {
-                    const fieldName = field.name.value;
-                    if (fieldName.toLowerCase().startsWith(lowerTypeName)) {
-                        context.report({
-                            data: {
-                                fieldName,
-                                typeName,
-                            },
-                            messageId: AVOID_TYPENAME_PREFIX,
-                            loc: getLocation(field.loc, lowerTypeName),
-                        });
-                    }
-                }
-            },
-        };
-    },
-};
-
-const rule$5 = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            examples: [
-                {
-                    title: 'Incorrect',
-                    usage: [{ style: 'inline' }],
-                    code: /* GraphQL */ `
-            """ Description """
-            type someTypeName {
-              # ...
-            }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    usage: [{ style: 'inline' }],
-                    code: /* GraphQL */ `
-            " Description "
-            type someTypeName {
-              # ...
-            }
-          `,
-                },
-            ],
-            description: 'Require all comments to follow the same style (either block or inline).',
-            category: 'Stylistic Issues',
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/description-style.md',
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    style: {
-                        type: 'string',
-                        enum: ['block', 'inline'],
-                        default: 'inline',
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-    },
-    create(context) {
-        const { style } = context.options[0] || { style: 'inline' };
-        const wrongDescriptionType = style === 'block' ? 'inline' : 'block';
-        return {
-            '[description.type="StringValue"]': node => {
-                if (node.description.block !== (style === 'block')) {
-                    context.report({
-                        loc: getLocation(node.description.loc),
-                        message: `Unexpected ${wrongDescriptionType} description`,
-                    });
-                }
-            },
-        };
-    },
-};
-
-const isObjectType = (node) => [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION].includes(node.type);
-const isQueryType = (node) => isObjectType(node) && node.name.value === 'Query';
-const isMutationType = (node) => isObjectType(node) && node.name.value === 'Mutation';
-const rule$6 = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Require mutation argument to be always called "input" and input type to be called Mutation name + "Input".\nUsing the same name for all input parameters will make your schemas easier to consume and more predictable. Using the same name as mutation for InputType will make it easier to find mutations that InputType belongs to.',
-            category: 'Stylistic Issues',
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/input-name.md',
-            examples: [
-                {
-                    title: 'Incorrect',
-                    usage: [{ checkInputType: true }],
-                    code: /* GraphQL */ `
-            type Mutation {
-              SetMessage(message: InputMessage): String
-            }
-          `,
-                },
-                {
-                    title: 'Correct (with checkInputType)',
-                    usage: [{ checkInputType: true }],
-                    code: /* GraphQL */ `
-            type Mutation {
-              SetMessage(input: SetMessageInput): String
-            }
-          `,
-                },
-                {
-                    title: 'Correct (without checkInputType)',
-                    usage: [{ checkInputType: false }],
-                    code: /* GraphQL */ `
-            type Mutation {
-              SetMessage(input: AnyInputTypeName): String
-            }
-          `,
-                },
-            ],
-        },
-        schema: [
-            {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                    checkInputType: {
-                        type: 'boolean',
-                        default: false,
-                        description: 'Check that the input type name follows the convention <mutationName>Input',
-                    },
-                    caseSensitiveInputType: {
-                        type: 'boolean',
-                        default: true,
-                        description: 'Allow for case discrepancies in the input type name',
-                    },
-                    checkQueries: {
-                        type: 'boolean',
-                        default: false,
-                        description: 'Apply the rule to Queries',
-                    },
-                    checkMutations: {
-                        type: 'boolean',
-                        default: true,
-                        description: 'Apply the rule to Mutations',
+                    checkQueries: {
+                        type: 'boolean',
+                        default: false,
+                        description: 'Apply the rule to Queries',
+                    },
+                    checkMutations: {
+                        type: 'boolean',
+                        default: true,
+                        description: 'Apply the rule to Mutations',
                     },
                 },
             },
@@ -1275,11 +1051,11 @@ const CASE_STYLES = [
 const schemaOption = {
     oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
 };
-const rule$7 = {
+const rule$3 = {
     meta: {
         type: 'suggestion',
         docs: {
-            category: 'Best Practices',
+            category: 'Operations',
             description: 'This rule allows you to enforce that the file name should match the operation name.',
             url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/match-document-filename.md`,
             examples: [
@@ -1353,6 +1129,14 @@ const rule$7 = {
           `,
                 },
             ],
+            configOptions: [
+                {
+                    query: CaseStyle.kebabCase,
+                    mutation: CaseStyle.kebabCase,
+                    subscription: CaseStyle.kebabCase,
+                    fragment: CaseStyle.kebabCase,
+                },
+            ],
         },
         messages: {
             [MATCH_EXTENSION]: `File extension "{{ fileExtension }}" don't match extension "{{ expectedFileExtension }}"`,
@@ -1361,27 +1145,29 @@ const rule$7 = {
         schema: {
             definitions: {
                 asString: {
-                    type: 'string',
-                    description: `One of: ${CASE_STYLES.map(t => `\`${t}\``).join(', ')}`,
                     enum: CASE_STYLES,
+                    description: `One of: ${CASE_STYLES.map(t => `\`${t}\``).join(', ')}`,
                 },
                 asObject: {
                     type: 'object',
+                    additionalProperties: false,
                     properties: {
                         style: {
-                            type: 'string',
                             enum: CASE_STYLES,
                         },
+                        suffix: {
+                            type: 'string',
+                        },
                     },
                 },
             },
-            $schema: 'http://json-schema.org/draft-04/schema#',
             type: 'array',
+            maxItems: 1,
             items: {
                 type: 'object',
+                additionalProperties: false,
                 properties: {
                     fileExtension: {
-                        type: 'string',
                         enum: ACCEPTED_EXTENSIONS,
                     },
                     query: schemaOption,
@@ -1456,13 +1242,7 @@ const rule$7 = {
     },
 };
 
-const FIELDS_KINDS = [
-    Kind.FIELD_DEFINITION,
-    Kind.INPUT_VALUE_DEFINITION,
-    Kind.VARIABLE_DEFINITION,
-    Kind.ARGUMENT,
-    Kind.DIRECTIVE_DEFINITION,
-];
+const FIELDS_KINDS = [Kind.FIELD_DEFINITION, Kind.INPUT_VALUE_DEFINITION, Kind.ARGUMENT, Kind.DIRECTIVE_DEFINITION];
 const KindToDisplayName = {
     // types
     [Kind.OBJECT_TYPE_DEFINITION]: 'Type',
@@ -1474,13 +1254,13 @@ const KindToDisplayName = {
     // fields
     [Kind.FIELD_DEFINITION]: 'Field',
     [Kind.INPUT_VALUE_DEFINITION]: 'Input property',
-    [Kind.VARIABLE_DEFINITION]: 'Variable',
     [Kind.ARGUMENT]: 'Argument',
     [Kind.DIRECTIVE_DEFINITION]: 'Directive',
     // rest
     [Kind.ENUM_VALUE_DEFINITION]: 'Enumeration value',
     [Kind.OPERATION_DEFINITION]: 'Operation',
     [Kind.FRAGMENT_DEFINITION]: 'Fragment',
+    [Kind.VARIABLE_DEFINITION]: 'Variable',
 };
 const StyleToRegex = {
     camelCase: /^[a-z][\dA-Za-z]*$/,
@@ -1493,12 +1273,12 @@ const ALLOWED_STYLES = Object.keys(StyleToRegex);
 const schemaOption$1 = {
     oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
 };
-const rule$8 = {
+const rule$4 = {
     meta: {
         type: 'suggestion',
         docs: {
             description: 'Require names to follow specified conventions.',
-            category: 'Best Practices',
+            category: ['Schema', 'Operations'],
             recommended: true,
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/naming-convention.md',
             examples: [
@@ -1521,22 +1301,12 @@ const rule$8 = {
           `,
                 },
             ],
-            optionsForConfig: [
-                {
-                    types: 'PascalCase',
-                    fields: 'camelCase',
-                    overrides: {
+            configOptions: {
+                schema: [
+                    {
+                        types: 'PascalCase',
+                        fields: 'camelCase',
                         EnumValueDefinition: 'UPPER_CASE',
-                        OperationDefinition: {
-                            style: 'PascalCase',
-                            forbiddenPrefixes: ['Query', 'Mutation', 'Subscription', 'Get'],
-                            forbiddenSuffixes: ['Query', 'Mutation', 'Subscription'],
-                        },
-                        FragmentDefinition: {
-                            style: 'PascalCase',
-                            forbiddenPrefixes: ['Fragment'],
-                            forbiddenSuffixes: ['Fragment'],
-                        },
                         'FieldDefinition[parent.name.value=Query]': {
                             forbiddenPrefixes: ['query', 'get'],
                             forbiddenSuffixes: ['Query'],
@@ -1550,8 +1320,24 @@ const rule$8 = {
                             forbiddenSuffixes: ['Subscription'],
                         },
                     },
-                },
-            ],
+                ],
+                operations: [
+                    {
+                        Argument: 'camelCase',
+                        VariableDefinition: 'camelCase',
+                        OperationDefinition: {
+                            style: 'PascalCase',
+                            forbiddenPrefixes: ['Query', 'Mutation', 'Subscription', 'Get'],
+                            forbiddenSuffixes: ['Query', 'Mutation', 'Subscription'],
+                        },
+                        FragmentDefinition: {
+                            style: 'PascalCase',
+                            forbiddenPrefixes: ['Fragment'],
+                            forbiddenSuffixes: ['Fragment'],
+                        },
+                    },
+                ],
+            },
         },
         schema: {
             definitions: {
@@ -1587,14 +1373,6 @@ const rule$8 = {
                 type: 'object',
                 additionalProperties: false,
                 properties: {
-                    types: {
-                        ...schemaOption$1,
-                        description: `Includes:\n\n${TYPES_KINDS.map(kind => `- [${kind}](https://spec.graphql.org/October2021/#${kind})`).join('\n')}`,
-                    },
-                    fields: {
-                        ...schemaOption$1,
-                        description: `Includes:\n\n${FIELDS_KINDS.map(kind => `- [${kind}](https://spec.graphql.org/October2021/#${kind})`).join('\n')}`,
-                    },
                     allowLeadingUnderscore: {
                         type: 'boolean',
                         default: false,
@@ -1603,35 +1381,42 @@ const rule$8 = {
                         type: 'boolean',
                         default: false,
                     },
-                    overrides: {
-                        type: 'object',
-                        additionalProperties: false,
-                        description: [
-                            'May contain the following `ASTNode` names:',
-                            '',
-                            ...ALLOWED_KINDS.map(kind => `- [${kind}](https://spec.graphql.org/October2021/#${kind})`),
-                            '',
-                            "> It's also possible to use a [`selector`](https://eslint.org/docs/developer-guide/selectors) that starts with `ASTNode` name",
-                            '>',
-                            '> Example: pattern property `FieldDefinition[parent.name.value=Query]` will match only fields for type `Query`',
-                        ].join('\n'),
-                        patternProperties: {
-                            [`^(${ALLOWED_KINDS.join('|')})(.+)?$`]: schemaOption$1,
-                        },
+                    types: {
+                        ...schemaOption$1,
+                        description: `Includes:\n\n${TYPES_KINDS.map(kind => `- \`${kind}\``).join('\n')}`,
                     },
-                },
+                    fields: {
+                        ...schemaOption$1,
+                        description: `Includes:\n\n${FIELDS_KINDS.map(kind => `- \`${kind}\``).join('\n')}`,
+                    },
+                    ...Object.fromEntries(ALLOWED_KINDS.map(kind => [
+                        kind,
+                        {
+                            ...schemaOption$1,
+                            description: `Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#${kind}).`,
+                        },
+                    ])),
+                },
+                patternProperties: {
+                    [`^(${ALLOWED_KINDS.join('|')})(.+)?$`]: schemaOption$1,
+                },
+                description: [
+                    "> It's possible to use a [`selector`](https://eslint.org/docs/developer-guide/selectors) that starts with allowed `ASTNode` names which are described below.",
+                    '>',
+                    '> Paste or drop code into the editor in [ASTExplorer](https://astexplorer.net) and inspect the generated AST to compose your selector.',
+                    '>',
+                    '> Example: pattern property `FieldDefinition[parent.name.value=Query]` will match only fields for type `Query`.',
+                ].join('\n'),
             },
         },
     },
     create(context) {
-        const options = {
-            overrides: {},
-            ...context.options[0],
-        };
+        const options = context.options[0] || {};
+        const { allowLeadingUnderscore, allowTrailingUnderscore, types, fields, ...restOptions } = options;
         function normalisePropertyOption(kind) {
-            let style = options.overrides[kind];
+            let style = options[kind];
             if (!style) {
-                style = TYPES_KINDS.includes(kind) ? options.types : options.fields;
+                style = TYPES_KINDS.includes(kind) ? types : fields;
             }
             return typeof style === 'object' ? style : { style };
         }
@@ -1652,10 +1437,10 @@ const rule$8 = {
             }
             function getErrorMessage() {
                 let name = nodeName;
-                if (options.allowLeadingUnderscore) {
+                if (allowLeadingUnderscore) {
                     name = name.replace(/^_*/, '');
                 }
-                if (options.allowTrailingUnderscore) {
+                if (allowTrailingUnderscore) {
                     name = name.replace(/_*$/, '');
                 }
                 if (prefix && !name.startsWith(prefix)) {
@@ -1689,15 +1474,13 @@ const rule$8 = {
             });
         };
         const listeners = {};
-        if (!options.allowLeadingUnderscore) {
+        if (!allowLeadingUnderscore) {
             listeners['Name[value=/^_/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] = checkUnderscore;
         }
-        if (!options.allowTrailingUnderscore) {
+        if (!allowTrailingUnderscore) {
             listeners['Name[value=/_$/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] = checkUnderscore;
         }
-        const selectors = new Set([options.types && TYPES_KINDS, options.fields && FIELDS_KINDS, Object.keys(options.overrides)]
-            .flat()
-            .filter(Boolean));
+        const selectors = new Set([types && TYPES_KINDS, fields && FIELDS_KINDS, Object.keys(restOptions)].flat().filter(Boolean));
         for (const selector of selectors) {
             listeners[selector] = checkNode(selector);
         }
@@ -1706,11 +1489,11 @@ const rule$8 = {
 };
 
 const NO_ANONYMOUS_OPERATIONS = 'NO_ANONYMOUS_OPERATIONS';
-const rule$9 = {
+const rule$5 = {
     meta: {
         type: 'suggestion',
         docs: {
-            category: 'Best Practices',
+            category: 'Operations',
             description: 'Require name for your GraphQL operations. This is useful since most GraphQL client libraries are using the operation name for caching purposes.',
             recommended: true,
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-anonymous-operations.md',
@@ -1754,12 +1537,12 @@ const rule$9 = {
 };
 
 const ERROR_MESSAGE_ID = 'NO_CASE_INSENSITIVE_ENUM_VALUES_DUPLICATES';
-const rule$a = {
+const rule$6 = {
     meta: {
         type: 'suggestion',
         docs: {
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-case-insensitive-enum-values-duplicates.md',
-            category: 'Best Practices',
+            category: 'Schema',
             recommended: true,
             description: 'Disallow case-insensitive enum values duplicates.',
             examples: [
@@ -1810,11 +1593,11 @@ const rule$a = {
 };
 
 const NO_DEPRECATED = 'NO_DEPRECATED';
-const rule$b = {
+const rule$7 = {
     meta: {
         type: 'suggestion',
         docs: {
-            category: 'Best Practices',
+            category: 'Operations',
             description: `Enforce that deprecated fields or enum values are not in use by operations.`,
             url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-deprecated.md`,
             requiresSchema: true,
@@ -1877,48 +1660,150 @@ const rule$b = {
                 fullName
               }
             }
-          `,
-                },
-            ],
-        },
-        messages: {
-            [NO_DEPRECATED]: `This {{ type }} is marked as deprecated in your GraphQL schema {{ reason }}`,
-        },
-        schema: [],
-    },
-    create(context) {
+          `,
+                },
+            ],
+            recommended: true,
+        },
+        messages: {
+            [NO_DEPRECATED]: `This {{ type }} is marked as deprecated in your GraphQL schema {{ reason }}`,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            EnumValue(node) {
+                requireGraphQLSchemaFromContext('no-deprecated', context);
+                const typeInfo = node.typeInfo();
+                if (typeInfo && typeInfo.enumValue) {
+                    if (typeInfo.enumValue.deprecationReason) {
+                        const enumValueName = node.value;
+                        context.report({
+                            loc: getLocation(node.loc, enumValueName),
+                            messageId: NO_DEPRECATED,
+                            data: {
+                                type: 'enum value',
+                                reason: typeInfo.enumValue.deprecationReason ? `(reason: ${typeInfo.enumValue.deprecationReason})` : '',
+                            },
+                        });
+                    }
+                }
+            },
+            Field(node) {
+                requireGraphQLSchemaFromContext('no-deprecated', context);
+                const typeInfo = node.typeInfo();
+                if (typeInfo && typeInfo.fieldDef) {
+                    if (typeInfo.fieldDef.deprecationReason) {
+                        const fieldName = node.name.value;
+                        context.report({
+                            loc: getLocation(node.loc, fieldName),
+                            messageId: NO_DEPRECATED,
+                            data: {
+                                type: 'field',
+                                reason: typeInfo.fieldDef.deprecationReason ? `(reason: ${typeInfo.fieldDef.deprecationReason})` : '',
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+
+const NO_DUPLICATE_FIELDS = 'NO_DUPLICATE_FIELDS';
+const rule$8 = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Checks for duplicate fields in selection set, variables in operation definition, or in arguments set of a field.`,
+            category: 'Operations',
+            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-duplicate-fields.md',
+            recommended: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            query {
+              user {
+                name
+                email
+                name # duplicate field
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            query {
+              users(
+                first: 100
+                skip: 50
+                after: "cji629tngfgou0b73kt7vi5jo"
+                first: 100 # duplicate argument
+              ) {
+                id
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            query (
+              $first: Int!
+              $first: Int! # duplicate variable
+            ) {
+              users(first: $first, skip: 50) {
+                id
+              }
+            }
+          `,
+                },
+            ],
+        },
+        messages: {
+            [NO_DUPLICATE_FIELDS]: `{{ type }} "{{ fieldName }}" defined multiple times`,
+        },
+        schema: [],
+    },
+    create(context) {
+        function checkNode(usedFields, fieldName, type, node) {
+            if (usedFields.has(fieldName)) {
+                context.report({
+                    loc: getLocation((node.kind === Kind.FIELD && node.alias ? node.alias : node).loc, fieldName, {
+                        offsetEnd: node.kind === Kind.VARIABLE_DEFINITION ? 0 : 1,
+                    }),
+                    messageId: NO_DUPLICATE_FIELDS,
+                    data: {
+                        type,
+                        fieldName,
+                    },
+                });
+            }
+            else {
+                usedFields.add(fieldName);
+            }
+        }
         return {
-            EnumValue(node) {
-                requireGraphQLSchemaFromContext('no-deprecated', context);
-                const typeInfo = node.typeInfo();
-                if (typeInfo && typeInfo.enumValue) {
-                    if (typeInfo.enumValue.deprecationReason) {
-                        const enumValueName = node.value;
-                        context.report({
-                            loc: getLocation(node.loc, enumValueName),
-                            messageId: NO_DEPRECATED,
-                            data: {
-                                type: 'enum value',
-                                reason: typeInfo.enumValue.deprecationReason ? `(reason: ${typeInfo.enumValue.deprecationReason})` : '',
-                            },
-                        });
-                    }
+            OperationDefinition(node) {
+                const set = new Set();
+                for (const varDef of node.variableDefinitions) {
+                    checkNode(set, varDef.variable.name.value, 'Operation variable', varDef);
                 }
             },
             Field(node) {
-                requireGraphQLSchemaFromContext('no-deprecated', context);
-                const typeInfo = node.typeInfo();
-                if (typeInfo && typeInfo.fieldDef) {
-                    if (typeInfo.fieldDef.deprecationReason) {
-                        const fieldName = node.name.value;
-                        context.report({
-                            loc: getLocation(node.loc, fieldName),
-                            messageId: NO_DEPRECATED,
-                            data: {
-                                type: 'field',
-                                reason: typeInfo.fieldDef.deprecationReason ? `(reason: ${typeInfo.fieldDef.deprecationReason})` : '',
-                            },
-                        });
+                const set = new Set();
+                for (const arg of node.arguments) {
+                    checkNode(set, arg.name.value, 'Field argument', arg);
+                }
+            },
+            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);
                     }
                 }
             },
@@ -1927,14 +1812,14 @@ const rule$b = {
 };
 
 const HASHTAG_COMMENT = 'HASHTAG_COMMENT';
-const rule$c = {
+const rule$9 = {
     meta: {
         messages: {
             [HASHTAG_COMMENT]: 'Using hashtag (#) for adding GraphQL descriptions is not allowed. Prefer using """ for multiline, or " for a single line description.',
         },
         docs: {
             description: 'Requires to use `"""` or `"` for adding a GraphQL description instead of `#`.\nAllows to use hashtag for comments, as long as it\'s not attached to an AST definition.',
-            category: 'Best Practices',
+            category: 'Schema',
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-hashtag-description.md',
             examples: [
                 {
@@ -1971,6 +1856,7 @@ const rule$c = {
           `,
                 },
             ],
+            recommended: true,
         },
         type: 'suggestion',
         schema: [],
@@ -1999,85 +1885,18 @@ const rule$c = {
     },
 };
 
-const NO_OPERATION_NAME_SUFFIX = 'NO_OPERATION_NAME_SUFFIX';
-const rule$d = {
-    meta: {
-        fixable: 'code',
-        type: 'suggestion',
-        docs: {
-            category: 'Stylistic Issues',
-            recommended: true,
-            description: `Makes sure you are not adding the operation type to the name of the operation.`,
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-operation-name-suffix.md`,
-            examples: [
-                {
-                    title: 'Incorrect',
-                    code: /* GraphQL */ `
-            query userQuery {
-              # ...
-            }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    code: /* GraphQL */ `
-            query user {
-              # ...
-            }
-          `,
-                },
-            ],
-        },
-        messages: {
-            [NO_OPERATION_NAME_SUFFIX]: `Unnecessary "{{ invalidSuffix }}" suffix in your operation name!`,
-        },
-        schema: [],
-    },
-    create(context) {
-        return {
-            'OperationDefinition, FragmentDefinition'(node) {
-                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({
-                            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,
-                            },
-                            fix: fixer => fixer.removeRange([node.name.range[1] - invalidSuffix.length, node.name.range[1]]),
-                            messageId: NO_OPERATION_NAME_SUFFIX,
-                        });
-                    }
-                }
-            },
-        };
-    },
-};
-
-const ROOT_TYPES = ['query', 'mutation', 'subscription'];
-const rule$e = {
+const ROOT_TYPES = ['mutation', 'subscription'];
+const rule$a = {
     meta: {
         type: 'suggestion',
         docs: {
-            category: 'Validation',
-            description: 'Disallow using root types for `read-only` or `write-only` schemas.',
+            category: 'Schema',
+            description: 'Disallow using root types `mutation` and/or `subscription`.',
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-root-type.md',
             requiresSchema: true,
             examples: [
                 {
-                    title: 'Incorrect (`read-only` schema)',
+                    title: 'Incorrect',
                     usage: [{ disallow: ['mutation', 'subscription'] }],
                     code: /* GraphQL */ `
             type Mutation {
@@ -2086,16 +1905,7 @@ const rule$e = {
           `,
                 },
                 {
-                    title: 'Incorrect (`write-only` schema)',
-                    usage: [{ disallow: ['query'] }],
-                    code: /* GraphQL */ `
-            type Query {
-              users: [User!]!
-            }
-          `,
-                },
-                {
-                    title: 'Correct (`read-only` schema)',
+                    title: 'Correct',
                     usage: [{ disallow: ['mutation', 'subscription'] }],
                     code: /* GraphQL */ `
             type Query {
@@ -2104,7 +1914,6 @@ const rule$e = {
           `,
                 },
             ],
-            optionsForConfig: [{ disallow: ['subscription'] }],
         },
         schema: {
             type: 'array',
@@ -2131,7 +1940,6 @@ const rule$e = {
         const schema = requireGraphQLSchemaFromContext('no-root-type', context);
         const disallow = new Set(context.options[0].disallow);
         const rootTypeNames = [
-            disallow.has('query') && schema.getQueryType(),
             disallow.has('mutation') && schema.getMutationType(),
             disallow.has('subscription') && schema.getSubscriptionType(),
         ]
@@ -2157,16 +1965,128 @@ const rule$e = {
     },
 };
 
+const rule$b = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            category: 'Schema',
+            description: 'Avoid scalar result type on mutation type to make sure to return a valid state.',
+            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-scalar-result-type-on-mutation.md',
+            requiresSchema: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type Mutation {
+              createUser: Boolean
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            type Mutation {
+              createUser: User!
+            }
+          `,
+                },
+            ],
+        },
+        schema: [],
+    },
+    create(context) {
+        const schema = requireGraphQLSchemaFromContext('no-scalar-result-type-on-mutation', context);
+        const mutationType = schema.getMutationType();
+        if (!mutationType) {
+            return {};
+        }
+        const selector = [
+            `:matches(${Kind.OBJECT_TYPE_DEFINITION}, ${Kind.OBJECT_TYPE_EXTENSION})[name.value=${mutationType.name}]`,
+            '>',
+            Kind.FIELD_DEFINITION,
+            Kind.NAMED_TYPE,
+        ].join(' ');
+        return {
+            [selector](node) {
+                const typeName = node.name.value;
+                const graphQLType = schema.getType(typeName);
+                if (isScalarType(graphQLType)) {
+                    context.report({
+                        loc: getLocation(node.loc, typeName),
+                        message: `Unexpected scalar result type "${typeName}"`,
+                    });
+                }
+            },
+        };
+    },
+};
+
+const NO_TYPENAME_PREFIX = 'NO_TYPENAME_PREFIX';
+const rule$c = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            category: 'Schema',
+            description: 'Enforces users to avoid using the type name in a field name while defining your schema.',
+            recommended: true,
+            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-typename-prefix.md',
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type User {
+              userId: ID!
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            type User {
+              id: ID!
+            }
+          `,
+                },
+            ],
+        },
+        messages: {
+            [NO_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();
+                for (const field of node.fields) {
+                    const fieldName = field.name.value;
+                    if (fieldName.toLowerCase().startsWith(lowerTypeName)) {
+                        context.report({
+                            data: {
+                                fieldName,
+                                typeName,
+                            },
+                            messageId: NO_TYPENAME_PREFIX,
+                            loc: getLocation(field.loc, lowerTypeName),
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+
 const UNREACHABLE_TYPE = 'UNREACHABLE_TYPE';
 const RULE_NAME = 'no-unreachable-types';
-const rule$f = {
+const rule$d = {
     meta: {
         messages: {
-            [UNREACHABLE_TYPE]: `Type "{{ typeName }}" is unreachable`,
+            [UNREACHABLE_TYPE]: 'Type "{{ typeName }}" is unreachable',
         },
         docs: {
             description: `Requires all types to be reachable at some level by root level fields.`,
-            category: 'Best Practices',
+            category: 'Schema',
             url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME}.md`,
             requiresSchema: true,
             examples: [
@@ -2197,6 +2117,7 @@ const rule$f = {
           `,
                 },
             ],
+            recommended: true,
         },
         fixable: 'code',
         type: 'suggestion',
@@ -2235,14 +2156,14 @@ const rule$f = {
 
 const UNUSED_FIELD = 'UNUSED_FIELD';
 const RULE_NAME$1 = 'no-unused-fields';
-const rule$g = {
+const rule$e = {
     meta: {
         messages: {
             [UNUSED_FIELD]: `Field "{{fieldName}}" is unused`,
         },
         docs: {
             description: `Requires all fields to be used at some level by siblings operations.`,
-            category: 'Best Practices',
+            category: 'Schema',
             url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME$1}.md`,
             requiresSiblings: true,
             requiresSchema: true,
@@ -2424,11 +2345,11 @@ 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$h = {
+const rule$f = {
     meta: {
         type: 'suggestion',
         docs: {
-            category: 'Best Practices',
+            category: 'Schema',
             description: 'Require deletion date on `@deprecated` directive. Suggest removing deprecated things after deprecated date.',
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/require-deprecation-date.md',
             examples: [
@@ -2527,11 +2448,11 @@ const rule$h = {
     },
 };
 
-const rule$i = {
+const rule$g = {
     meta: {
         docs: {
             description: `Require all deprecation directives to specify a reason.`,
-            category: 'Best Practices',
+            category: 'Schema',
             url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/require-deprecation-reason.md`,
             recommended: true,
             examples: [
@@ -2589,16 +2510,16 @@ const ALLOWED_KINDS$1 = [
     Kind.ENUM_VALUE_DEFINITION,
     Kind.DIRECTIVE_DEFINITION,
 ];
-const rule$j = {
+const rule$h = {
     meta: {
         docs: {
-            category: 'Best Practices',
+            category: 'Schema',
             description: 'Enforce descriptions in your type definitions.',
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/require-description.md',
             examples: [
                 {
                     title: 'Incorrect',
-                    usage: [{ types: true, overrides: { FieldDefinition: true } }],
+                    usage: [{ types: true, FieldDefinition: true }],
                     code: /* GraphQL */ `
             type someTypeName {
               name: String
@@ -2607,7 +2528,7 @@ const rule$j = {
                 },
                 {
                     title: 'Correct',
-                    usage: [{ types: true, overrides: { FieldDefinition: true } }],
+                    usage: [{ types: true, FieldDefinition: true }],
                     code: /* GraphQL */ `
             """
             Some type description
@@ -2621,12 +2542,10 @@ const rule$j = {
           `,
                 },
             ],
-            optionsForConfig: [
+            configOptions: [
                 {
                     types: true,
-                    overrides: {
-                        [Kind.DIRECTIVE_DEFINITION]: true,
-                    },
+                    [Kind.DIRECTIVE_DEFINITION]: true,
                 },
             ],
         },
@@ -2645,22 +2564,23 @@ const rule$j = {
                 properties: {
                     types: {
                         type: 'boolean',
-                        description: `Includes:\n\n${TYPES_KINDS.map(kind => `- [${kind}](https://spec.graphql.org/October2021/#${kind})`).join('\n')}`,
-                    },
-                    overrides: {
-                        type: 'object',
-                        description: 'Configuration for precise `ASTNode`',
-                        additionalProperties: false,
-                        properties: Object.fromEntries(ALLOWED_KINDS$1.map(kind => [kind, { 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}).`,
+                        },
+                    ])),
                 },
             },
         },
     },
     create(context) {
-        const { types, overrides = {} } = context.options[0];
+        const { types, ...restOptions } = context.options[0];
         const kinds = new Set(types ? TYPES_KINDS : []);
-        for (const [kind, isEnabled] of Object.entries(overrides)) {
+        for (const [kind, isEnabled] of Object.entries(restOptions)) {
             if (isEnabled) {
                 kinds.add(kind);
             }
@@ -2688,11 +2608,11 @@ const rule$j = {
 };
 
 const RULE_NAME$2 = 'require-field-of-type-query-in-mutation-result';
-const rule$k = {
+const rule$i = {
     meta: {
         type: 'suggestion',
         docs: {
-            category: 'Best Practices',
+            category: 'Schema',
             description: 'Allow the client in one round-trip not only to call mutation but also to get a wagon of data to update their application.\n> Currently, no errors are reported for result type `union`, `interface` and `scalar`.',
             url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME$2}.md`,
             requiresSchema: true,
@@ -2856,13 +2776,13 @@ const convertNode = (typeInfo) => (node, key, parent) => {
 
 const REQUIRE_ID_WHEN_AVAILABLE = 'REQUIRE_ID_WHEN_AVAILABLE';
 const DEFAULT_ID_FIELD_NAME = 'id';
-const rule$l = {
+const rule$j = {
     meta: {
         type: 'suggestion',
         docs: {
-            category: 'Best Practices',
-            description: `Enforce selecting specific fields when they are available on the GraphQL type.`,
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/require-id-when-available.md`,
+            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/require-id-when-available.md',
             requiresSchema: true,
             requiresSiblings: true,
             examples: [
@@ -2902,17 +2822,17 @@ const rule$l = {
           `,
                 },
             ],
+            recommended: true,
         },
         messages: {
-            [REQUIRE_ID_WHEN_AVAILABLE]: `Field "{{ fieldName }}" must be selected when it's available on a type. Please make sure to include it in your selection set!\nIf you are using fragments, make sure that all used fragments {{checkedFragments}} specifies the field "{{ fieldName }}".`,
+            [REQUIRE_ID_WHEN_AVAILABLE]: `Field "{{ fieldName }}" must be selected when it's available on a type. Please make sure to include it in your selection set!\nIf you are using fragments, make sure that all used fragments {{ checkedFragments }} specifies the field "{{ fieldName }}".`,
         },
         schema: {
             type: 'array',
-            additionalItems: false,
-            minItems: 0,
             maxItems: 1,
             items: {
                 type: 'object',
+                additionalProperties: false,
                 properties: {
                     fieldName: {
                         type: 'string',
@@ -2992,12 +2912,12 @@ const rule$l = {
     },
 };
 
-const rule$m = {
+const rule$k = {
     meta: {
         docs: {
-            category: 'Best Practices',
+            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/selection-set-depth.md`,
+            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/selection-set-depth.md',
             requiresSiblings: true,
             examples: [
                 {
@@ -3040,22 +2960,26 @@ const rule$m = {
           `,
                 },
             ],
+            recommended: true,
+            configOptions: [{ maxDepth: 7 }],
         },
         type: 'suggestion',
         schema: {
             type: 'array',
-            additionalItems: false,
             minItems: 1,
             maxItems: 1,
             items: {
                 type: 'object',
-                require: ['maxDepth'],
+                additionalProperties: false,
+                required: ['maxDepth'],
                 properties: {
                     maxDepth: {
                         type: 'number',
                     },
                     ignore: {
                         type: 'array',
+                        uniqueItems: true,
+                        minItems: 1,
                         items: {
                             type: 'string',
                         },
@@ -3114,12 +3038,12 @@ const shouldIgnoreNode = ({ node, exceptions }) => {
     }
     return false;
 };
-const rule$n = {
+const rule$l = {
     meta: {
         type: 'suggestion',
         docs: {
             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: 'Best Practices',
+            category: 'Schema',
             recommended: true,
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/strict-id-in-types.md',
             examples: [
@@ -3179,13 +3103,15 @@ const rule$n = {
             ],
         },
         schema: {
-            $schema: 'http://json-schema.org/draft-04/schema#',
             type: 'array',
+            maxItems: 1,
             items: {
                 type: 'object',
+                additionalProperties: false,
                 properties: {
                     acceptedIdNames: {
                         type: 'array',
+                        uniqueItems: true,
                         items: {
                             type: 'string',
                         },
@@ -3193,6 +3119,7 @@ const rule$n = {
                     },
                     acceptedIdTypes: {
                         type: 'array',
+                        uniqueItems: true,
                         items: {
                             type: 'string',
                         },
@@ -3203,19 +3130,21 @@ const rule$n = {
                         properties: {
                             types: {
                                 type: 'array',
+                                uniqueItems: true,
+                                minItems: 1,
                                 description: 'This is used to exclude types with names that match one of the specified values.',
                                 items: {
                                     type: 'string',
                                 },
-                                default: [],
                             },
                             suffixes: {
                                 type: 'array',
+                                uniqueItems: true,
+                                minItems: 1,
                                 description: 'This is used to exclude types with names with suffixes that match one of the specified values.',
                                 items: {
                                     type: 'string',
                                 },
-                                default: [],
                             },
                         },
                     },
@@ -3291,11 +3220,11 @@ const checkNode = (context, node, ruleName, messageId) => {
         });
     }
 };
-const rule$o = {
+const rule$m = {
     meta: {
         type: 'suggestion',
         docs: {
-            category: 'Best Practices',
+            category: 'Operations',
             description: `Enforce unique fragment names across your project.`,
             url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME$3}.md`,
             requiresSiblings: true,
@@ -3350,11 +3279,11 @@ const rule$o = {
 
 const RULE_NAME$4 = 'unique-operation-name';
 const UNIQUE_OPERATION_NAME = 'UNIQUE_OPERATION_NAME';
-const rule$p = {
+const rule$n = {
     meta: {
         type: 'suggestion',
         docs: {
-            category: 'Best Practices',
+            category: 'Operations',
             description: `Enforce unique operation names across your project.`,
             url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME$4}.md`,
             requiresSiblings: true,
@@ -3417,31 +3346,29 @@ const rule$p = {
 const rules = {
     ...GRAPHQL_JS_VALIDATIONS,
     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-root-type': rule$e,
-    'no-unreachable-types': rule$f,
-    'no-unused-fields': rule$g,
-    'require-deprecation-date': rule$h,
-    'require-deprecation-reason': rule$i,
-    'require-description': rule$j,
-    'require-field-of-type-query-in-mutation-result': rule$k,
-    'require-id-when-available': rule$l,
-    'selection-set-depth': rule$m,
-    'strict-id-in-types': rule$n,
-    'unique-fragment-name': rule$o,
-    'unique-operation-name': rule$p,
+    'description-style': rule$1,
+    'input-name': rule$2,
+    'match-document-filename': rule$3,
+    'naming-convention': rule$4,
+    'no-anonymous-operations': rule$5,
+    'no-case-insensitive-enum-values-duplicates': rule$6,
+    'no-deprecated': rule$7,
+    'no-duplicate-fields': rule$8,
+    'no-hashtag-description': rule$9,
+    'no-root-type': rule$a,
+    'no-scalar-result-type-on-mutation': rule$b,
+    'no-typename-prefix': 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,
 };
 
 const RELEVANT_KEYWORDS = ['gql', 'graphql', '/* GraphQL */'];