@graphql-eslint/eslint-plugin 3.0.0-alpha-7462f3d.0 → 3.0.0-alpha-636cc2a.0

package/index.mjs

@@ -12,12 +12,88 @@ 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/require-description': ['error', { types: true, DirectiveDefinition: true }],
+        '@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-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/executable-definitions': 'error',
         '@graphql-eslint/fields-on-correct-type': 'error',
@@ -27,58 +103,35 @@ 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'],
-                    },
+                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-typename-prefix': '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',
@@ -89,43 +142,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/description-style': 'error',
-        '@graphql-eslint/input-name': 'error',
-        '@graphql-eslint/match-document-filename': 'error',
-        '@graphql-eslint/no-deprecated': 'error',
-        '@graphql-eslint/no-duplicate-fields': 'error',
-        '@graphql-eslint/no-hashtag-description': 'error',
-        '@graphql-eslint/no-root-type': ['error', { disallow: ['subscription'] }],
-        '@graphql-eslint/no-scalar-result-type-on-mutation': 'error',
-        '@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) {
@@ -338,7 +380,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`,
@@ -375,16 +416,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: [
         {
@@ -451,17 +498,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 => {
@@ -491,49 +544,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.`,
 }));
 
@@ -559,7 +631,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: [
@@ -638,15 +710,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 }}"',
@@ -811,34 +890,32 @@ const rule$1 = {
                 },
             ],
             description: 'Require all comments to follow the same style (either block or inline).',
-            category: 'Stylistic Issues',
+            category: 'Schema',
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/description-style.md',
+            recommended: true,
         },
         schema: [
             {
                 type: 'object',
+                additionalProperties: false,
                 properties: {
                     style: {
-                        type: 'string',
                         enum: ['block', 'inline'],
-                        default: 'inline',
+                        default: 'block',
                     },
                 },
-                additionalProperties: false,
             },
         ],
     },
     create(context) {
-        const { style } = context.options[0] || { style: 'inline' };
-        const wrongDescriptionType = style === 'block' ? 'inline' : 'block';
+        const { style = 'block' } = context.options[0] || {};
+        const isBlock = style === 'block';
         return {
-            '[description.type="StringValue"]': node => {
-                if (node.description.block !== (style === 'block')) {
-                    context.report({
-                        loc: getLocation(node.description.loc),
-                        message: `Unexpected ${wrongDescriptionType} description`,
-                    });
-                }
+            [`.description[type=StringValue][block!=${isBlock}]`](node) {
+                context.report({
+                    loc: getLocation(node.loc),
+                    message: `Unexpected ${isBlock ? 'inline' : 'block'} description`,
+                });
             },
         };
     },
@@ -852,7 +929,7 @@ const rule$2 = {
         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',
+            category: 'Schema',
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/input-name.md',
             examples: [
                 {
@@ -977,7 +1054,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: [
@@ -1051,6 +1128,14 @@ const rule$3 = {
           `,
                 },
             ],
+            configOptions: [
+                {
+                    query: CaseStyle.kebabCase,
+                    mutation: CaseStyle.kebabCase,
+                    subscription: CaseStyle.kebabCase,
+                    fragment: CaseStyle.kebabCase,
+                },
+            ],
         },
         messages: {
             [MATCH_EXTENSION]: `File extension "{{ fileExtension }}" don't match extension "{{ expectedFileExtension }}"`,
@@ -1059,27 +1144,29 @@ const rule$3 = {
         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,
@@ -1154,13 +1241,7 @@ const rule$3 = {
     },
 };
 
-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',
@@ -1172,13 +1253,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]*$/,
@@ -1196,7 +1277,7 @@ const rule$4 = {
         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: [
@@ -1207,6 +1288,24 @@ const rule$4 = {
             type user {
               first_name: String!
             }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    usage: [{ FragmentDefinition: { style: 'PascalCase', forbiddenSuffixes: ['Fragment'] } }],
+                    code: /* GraphQL */ `
+            fragment UserFragment on User {
+              # ...
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    usage: [{ 'FieldDefinition[parent.name.value=Query]': { forbiddenPrefixes: ['get'] } }],
+                    code: /* GraphQL */ `
+            type Query {
+              getUsers: [User!]!
+            }
           `,
                 },
                 {
@@ -1218,23 +1317,31 @@ const rule$4 = {
             }
           `,
                 },
-            ],
-            optionsForConfig: [
                 {
-                    types: 'PascalCase',
-                    fields: 'camelCase',
-                    overrides: {
+                    title: 'Correct',
+                    usage: [{ FragmentDefinition: { style: 'PascalCase', forbiddenSuffixes: ['Fragment'] } }],
+                    code: /* GraphQL */ `
+            fragment UserFields on User {
+              # ...
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ 'FieldDefinition[parent.name.value=Query]': { forbiddenPrefixes: ['get'] } }],
+                    code: /* GraphQL */ `
+            type Query {
+              users: [User!]!
+            }
+          `,
+                },
+            ],
+            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'],
@@ -1248,8 +1355,23 @@ const rule$4 = {
                             forbiddenSuffixes: ['Subscription'],
                         },
                     },
-                },
-            ],
+                ],
+                operations: [
+                    {
+                        VariableDefinition: 'camelCase',
+                        OperationDefinition: {
+                            style: 'PascalCase',
+                            forbiddenPrefixes: ['Query', 'Mutation', 'Subscription', 'Get'],
+                            forbiddenSuffixes: ['Query', 'Mutation', 'Subscription'],
+                        },
+                        FragmentDefinition: {
+                            style: 'PascalCase',
+                            forbiddenPrefixes: ['Fragment'],
+                            forbiddenSuffixes: ['Fragment'],
+                        },
+                    },
+                ],
+            },
         },
         schema: {
             definitions: {
@@ -1287,12 +1409,19 @@ const rule$4 = {
                 properties: {
                     types: {
                         ...schemaOption$1,
-                        description: `Includes:\n\n${TYPES_KINDS.map(kind => `- [${kind}](https://spec.graphql.org/October2021/#${kind})`).join('\n')}`,
+                        description: `Includes:\n\n${TYPES_KINDS.map(kind => `- \`${kind}\``).join('\n')}`,
                     },
                     fields: {
                         ...schemaOption$1,
-                        description: `Includes:\n\n${FIELDS_KINDS.map(kind => `- [${kind}](https://spec.graphql.org/October2021/#${kind})`).join('\n')}`,
+                        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}).`,
+                        },
+                    ])),
                     allowLeadingUnderscore: {
                         type: 'boolean',
                         default: false,
@@ -1301,35 +1430,27 @@ const rule$4 = {
                         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,
-                        },
-                    },
                 },
+                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 };
         }
@@ -1350,10 +1471,10 @@ const rule$4 = {
             }
             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)) {
@@ -1387,15 +1508,13 @@ const rule$4 = {
             });
         };
         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);
         }
@@ -1408,7 +1527,7 @@ 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',
@@ -1457,7 +1576,7 @@ const rule$6 = {
         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: [
@@ -1512,7 +1631,7 @@ 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,
@@ -1578,6 +1697,7 @@ const rule$7 = {
           `,
                 },
             ],
+            recommended: true,
         },
         messages: {
             [NO_DEPRECATED]: `This {{ type }} is marked as deprecated in your GraphQL schema {{ reason }}`,
@@ -1630,8 +1750,9 @@ const rule$8 = {
         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',
+            category: 'Operations',
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-duplicate-fields.md',
+            recommended: true,
             examples: [
                 {
                     title: 'Incorrect',
@@ -1732,7 +1853,7 @@ const rule$9 = {
         },
         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: [
                 {
@@ -1769,6 +1890,7 @@ const rule$9 = {
           `,
                 },
             ],
+            recommended: true,
         },
         type: 'suggestion',
         schema: [],
@@ -1797,18 +1919,18 @@ const rule$9 = {
     },
 };
 
-const ROOT_TYPES = ['query', 'mutation', 'subscription'];
+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 {
@@ -1817,16 +1939,7 @@ const rule$a = {
           `,
                 },
                 {
-                    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 {
@@ -1835,7 +1948,6 @@ const rule$a = {
           `,
                 },
             ],
-            optionsForConfig: [{ disallow: ['subscription'] }],
         },
         schema: {
             type: 'array',
@@ -1862,7 +1974,6 @@ const rule$a = {
         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(),
         ]
@@ -1892,7 +2003,7 @@ const rule$b = {
     meta: {
         type: 'suggestion',
         docs: {
-            category: 'Best Practices',
+            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,
@@ -1949,7 +2060,7 @@ const rule$c = {
     meta: {
         type: 'suggestion',
         docs: {
-            category: 'Best Practices',
+            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',
@@ -2005,11 +2116,11 @@ const RULE_NAME = 'no-unreachable-types';
 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: [
@@ -2040,6 +2151,7 @@ const rule$d = {
           `,
                 },
             ],
+            recommended: true,
         },
         fixable: 'code',
         type: 'suggestion',
@@ -2085,7 +2197,7 @@ const rule$e = {
         },
         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,
@@ -2271,7 +2383,7 @@ 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: [
@@ -2374,7 +2486,7 @@ 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: [
@@ -2435,13 +2547,13 @@ const ALLOWED_KINDS$1 = [
 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
@@ -2450,7 +2562,7 @@ const rule$h = {
                 },
                 {
                     title: 'Correct',
-                    usage: [{ types: true, overrides: { FieldDefinition: true } }],
+                    usage: [{ types: true, FieldDefinition: true }],
                     code: /* GraphQL */ `
             """
             Some type description
@@ -2464,14 +2576,13 @@ const rule$h = {
           `,
                 },
             ],
-            optionsForConfig: [
+            configOptions: [
                 {
                     types: true,
-                    overrides: {
-                        [Kind.DIRECTIVE_DEFINITION]: true,
-                    },
+                    [Kind.DIRECTIVE_DEFINITION]: true,
                 },
             ],
+            recommended: true,
         },
         type: 'suggestion',
         messages: {
@@ -2488,22 +2599,23 @@ const rule$h = {
                 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);
             }
@@ -2535,7 +2647,7 @@ 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,
@@ -2703,9 +2815,9 @@ 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: [
@@ -2745,17 +2857,17 @@ const rule$j = {
           `,
                 },
             ],
+            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',
@@ -2838,9 +2950,9 @@ const rule$j = {
 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: [
                 {
@@ -2883,22 +2995,26 @@ const rule$k = {
           `,
                 },
             ],
+            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',
                         },
@@ -2962,7 +3078,7 @@ const rule$l = {
         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: [
@@ -3022,13 +3138,15 @@ const rule$l = {
             ],
         },
         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',
                         },
@@ -3036,6 +3154,7 @@ const rule$l = {
                     },
                     acceptedIdTypes: {
                         type: 'array',
+                        uniqueItems: true,
                         items: {
                             type: 'string',
                         },
@@ -3046,19 +3165,21 @@ const rule$l = {
                         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: [],
                             },
                         },
                     },
@@ -3138,7 +3259,7 @@ 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,
@@ -3197,7 +3318,7 @@ 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,