@graphql-eslint/eslint-plugin 3.0.0-alpha-3168a9b.0 → 3.0.0-alpha-7462f3d.0

package/index.js

@@ -25,7 +25,6 @@ const recommendedConfig = {
     parser: '@graphql-eslint/eslint-plugin',
     plugins: ['@graphql-eslint'],
     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',
@@ -66,7 +65,7 @@ const recommendedConfig = {
         '@graphql-eslint/no-anonymous-operations': 'error',
         '@graphql-eslint/no-case-insensitive-enum-values-duplicates': 'error',
         '@graphql-eslint/no-fragment-cycles': 'error',
-        '@graphql-eslint/no-operation-name-suffix': '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',
@@ -110,19 +109,18 @@ const allConfig = {
                 arguments: ['FieldDefinition', 'Field', 'DirectiveDefinition', 'Directive'],
             },
         ],
-        '@graphql-eslint/avoid-duplicate-fields': 'error',
-        '@graphql-eslint/avoid-operation-name-prefix': 'error',
-        '@graphql-eslint/avoid-scalar-result-type-on-mutation': 'error',
         '@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',
+        '@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',
@@ -546,11 +544,23 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
 }));
 
 const ALPHABETIZE = 'ALPHABETIZE';
-const fieldsEnum = [graphql.Kind.OBJECT_TYPE_DEFINITION, graphql.Kind.INTERFACE_TYPE_DEFINITION, graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION];
+const fieldsEnum = [
+    graphql.Kind.OBJECT_TYPE_DEFINITION,
+    graphql.Kind.INTERFACE_TYPE_DEFINITION,
+    graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+];
 const valuesEnum = [graphql.Kind.ENUM_TYPE_DEFINITION];
-const selectionsEnum = [graphql.Kind.OPERATION_DEFINITION, graphql.Kind.FRAGMENT_DEFINITION];
+const selectionsEnum = [
+    graphql.Kind.OPERATION_DEFINITION,
+    graphql.Kind.FRAGMENT_DEFINITION,
+];
 const variablesEnum = [graphql.Kind.OPERATION_DEFINITION];
-const argumentsEnum = [graphql.Kind.FIELD_DEFINITION, graphql.Kind.FIELD, graphql.Kind.DIRECTIVE_DEFINITION, graphql.Kind.DIRECTIVE];
+const argumentsEnum = [
+    graphql.Kind.FIELD_DEFINITION,
+    graphql.Kind.FIELD,
+    graphql.Kind.DIRECTIVE_DEFINITION,
+    graphql.Kind.DIRECTIVE,
+];
 const rule = {
     meta: {
         type: 'suggestion',
@@ -780,307 +790,7 @@ 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',
-                    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: {
-            [AVOID_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 === graphql.Kind.FIELD && node.alias ? node.alias : node).loc, fieldName, {
-                        offsetEnd: node.kind === graphql.Kind.VARIABLE_DEFINITION ? 0 : 1,
-                    }),
-                    messageId: AVOID_DUPLICATE_FIELDS,
-                    data: {
-                        type,
-                        fieldName,
-                    },
-                });
-            }
-            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 === graphql.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 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',
-            examples: [
-                {
-                    title: 'Incorrect',
-                    usage: [{ keywords: ['get'] }],
-                    code: /* GraphQL */ `
-            query getUserDetails {
-              # ...
-            }`,
-                },
-                {
-                    title: 'Correct',
-                    usage: [{ keywords: ['get'] }],
-                    code: /* GraphQL */ `
-            query userDetails {
-              # ...
-            }`,
-                },
-            ],
-        },
-        messages: {
-            [AVOID_OPERATION_NAME_PREFIX]: `Forbidden operation name prefix: "{{ invalidPrefix }}"`,
-        },
-        schema: [
-            {
-                additionalProperties: false,
-                type: 'object',
-                required: ['keywords'],
-                properties: {
-                    caseSensitive: {
-                        default: false,
-                        type: 'boolean',
-                    },
-                    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(${graphql.Kind.OBJECT_TYPE_DEFINITION}, ${graphql.Kind.OBJECT_TYPE_EXTENSION})[name.value=${mutationType.name}]`,
-            '>',
-            graphql.Kind.FIELD_DEFINITION,
-            graphql.Kind.NAMED_TYPE,
-        ].join(' ');
-        return {
-            [selector](node) {
-                const typeName = node.name.value;
-                const graphQLType = schema.getType(typeName);
-                if (graphql.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: {
@@ -1143,7 +853,7 @@ const rule$5 = {
 const isObjectType = (node) => [graphql.Kind.OBJECT_TYPE_DEFINITION, graphql.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 = {
+const rule$2 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -1269,7 +979,7 @@ const CASE_STYLES = [
 const schemaOption = {
     oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
 };
-const rule$7 = {
+const rule$3 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -1487,7 +1197,7 @@ 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: {
@@ -1583,11 +1293,11 @@ const rule$8 = {
                 properties: {
                     types: {
                         ...schemaOption$1,
-                        description: `Includes:\n\n${TYPES_KINDS.map(kind => `- \`${kind}\``).join('\n')}`,
+                        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}\``).join('\n')}`,
+                        description: `Includes:\n\n${FIELDS_KINDS.map(kind => `- [${kind}](https://spec.graphql.org/October2021/#${kind})`).join('\n')}`,
                     },
                     allowLeadingUnderscore: {
                         type: 'boolean',
@@ -1603,7 +1313,7 @@ const rule$8 = {
                         description: [
                             'May contain the following `ASTNode` names:',
                             '',
-                            ...ALLOWED_KINDS.map(kind => `- \`${kind}\``),
+                            ...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",
                             '>',
@@ -1700,7 +1410,7 @@ const rule$8 = {
 };
 
 const NO_ANONYMOUS_OPERATIONS = 'NO_ANONYMOUS_OPERATIONS';
-const rule$9 = {
+const rule$5 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -1748,7 +1458,7 @@ const rule$9 = {
 };
 
 const ERROR_MESSAGE_ID = 'NO_CASE_INSENSITIVE_ENUM_VALUES_DUPLICATES';
-const rule$a = {
+const rule$6 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -1804,7 +1514,7 @@ const rule$a = {
 };
 
 const NO_DEPRECATED = 'NO_DEPRECATED';
-const rule$b = {
+const rule$7 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -1900,19 +1610,119 @@ const rule$b = {
                 }
             },
             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})` : '',
-                            },
-                        });
+                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: 'Stylistic Issues',
+            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-duplicate-fields.md',
+            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 === graphql.Kind.FIELD && node.alias ? node.alias : node).loc, fieldName, {
+                        offsetEnd: node.kind === graphql.Kind.VARIABLE_DEFINITION ? 0 : 1,
+                    }),
+                    messageId: NO_DUPLICATE_FIELDS,
+                    data: {
+                        type,
+                        fieldName,
+                    },
+                });
+            }
+            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 === graphql.Kind.FIELD) {
+                        checkNode(set, ((_a = selection.alias) === null || _a === void 0 ? void 0 : _a.value) || selection.name.value, 'Field', selection);
                     }
                 }
             },
@@ -1921,7 +1731,7 @@ 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.',
@@ -1993,75 +1803,8 @@ 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 rule$a = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2151,9 +1894,121 @@ const rule$e = {
     },
 };
 
+const rule$b = {
+    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/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(${graphql.Kind.OBJECT_TYPE_DEFINITION}, ${graphql.Kind.OBJECT_TYPE_EXTENSION})[name.value=${mutationType.name}]`,
+            '>',
+            graphql.Kind.FIELD_DEFINITION,
+            graphql.Kind.NAMED_TYPE,
+        ].join(' ');
+        return {
+            [selector](node) {
+                const typeName = node.name.value;
+                const graphQLType = schema.getType(typeName);
+                if (graphql.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: '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/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`,
@@ -2229,7 +2084,7 @@ 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`,
@@ -2418,7 +2273,7 @@ const MESSAGE_REQUIRE_DATE = 'MESSAGE_REQUIRE_DATE';
 const MESSAGE_INVALID_FORMAT = 'MESSAGE_INVALID_FORMAT';
 const MESSAGE_INVALID_DATE = 'MESSAGE_INVALID_DATE';
 const MESSAGE_CAN_BE_REMOVED = 'MESSAGE_CAN_BE_REMOVED';
-const rule$h = {
+const rule$f = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2521,7 +2376,7 @@ const rule$h = {
     },
 };
 
-const rule$i = {
+const rule$g = {
     meta: {
         docs: {
             description: `Require all deprecation directives to specify a reason.`,
@@ -2576,41 +2431,23 @@ const rule$i = {
 };
 
 const REQUIRE_DESCRIPTION_ERROR = 'REQUIRE_DESCRIPTION_ERROR';
-const DESCRIBABLE_NODES = [
-    graphql.Kind.SCHEMA_DEFINITION,
-    graphql.Kind.OBJECT_TYPE_DEFINITION,
+const ALLOWED_KINDS$1 = [
+    ...TYPES_KINDS,
     graphql.Kind.FIELD_DEFINITION,
     graphql.Kind.INPUT_VALUE_DEFINITION,
-    graphql.Kind.INTERFACE_TYPE_DEFINITION,
-    graphql.Kind.UNION_TYPE_DEFINITION,
-    graphql.Kind.ENUM_TYPE_DEFINITION,
     graphql.Kind.ENUM_VALUE_DEFINITION,
-    graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
     graphql.Kind.DIRECTIVE_DEFINITION,
 ];
-function verifyRule(context, node) {
-    if (node) {
-        if (!node.description || !node.description.value || node.description.value.trim().length === 0) {
-            context.report({
-                loc: getLocation(('name' in node ? node.name : node).loc, 'name' in node ? node.name.value : 'schema'),
-                messageId: REQUIRE_DESCRIPTION_ERROR,
-                data: {
-                    nodeType: node.kind,
-                },
-            });
-        }
-    }
-}
-const rule$j = {
+const rule$h = {
     meta: {
         docs: {
             category: 'Best Practices',
-            description: `Enforce descriptions in your type definitions.`,
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/require-description.md`,
+            description: 'Enforce descriptions in your type definitions.',
+            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/require-description.md',
             examples: [
                 {
                     title: 'Incorrect',
-                    usage: [{ on: [graphql.Kind.OBJECT_TYPE_DEFINITION, graphql.Kind.FIELD_DEFINITION] }],
+                    usage: [{ types: true, overrides: { FieldDefinition: true } }],
                     code: /* GraphQL */ `
             type someTypeName {
               name: String
@@ -2619,7 +2456,7 @@ const rule$j = {
                 },
                 {
                     title: 'Correct',
-                    usage: [{ on: [graphql.Kind.OBJECT_TYPE_DEFINITION, graphql.Kind.FIELD_DEFINITION] }],
+                    usage: [{ types: true, overrides: { FieldDefinition: true } }],
                     code: /* GraphQL */ `
             """
             Some type description
@@ -2633,40 +2470,74 @@ const rule$j = {
           `,
                 },
             ],
+            optionsForConfig: [
+                {
+                    types: true,
+                    overrides: {
+                        [graphql.Kind.DIRECTIVE_DEFINITION]: true,
+                    },
+                },
+            ],
         },
         type: 'suggestion',
         messages: {
-            [REQUIRE_DESCRIPTION_ERROR]: `Description is required for nodes of type "{{ nodeType }}"`,
+            [REQUIRE_DESCRIPTION_ERROR]: 'Description is required for nodes of type "{{ nodeType }}"',
         },
         schema: {
             type: 'array',
-            additionalItems: false,
             minItems: 1,
             maxItems: 1,
             items: {
                 type: 'object',
-                require: ['on'],
+                additionalProperties: false,
+                minProperties: 1,
                 properties: {
-                    on: {
-                        type: 'array',
-                        minItems: 1,
-                        additionalItems: false,
-                        items: {
-                            type: 'string',
-                            enum: DESCRIBABLE_NODES,
-                        },
+                    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' }])),
                     },
                 },
             },
         },
     },
     create(context) {
-        return Object.fromEntries(context.options[0].on.map(optionKey => [optionKey, node => verifyRule(context, node)]));
+        const { types, overrides = {} } = context.options[0];
+        const kinds = new Set(types ? TYPES_KINDS : []);
+        for (const [kind, isEnabled] of Object.entries(overrides)) {
+            if (isEnabled) {
+                kinds.add(kind);
+            }
+            else {
+                kinds.delete(kind);
+            }
+        }
+        const selector = [...kinds].join(',');
+        return {
+            [selector](node) {
+                var _a;
+                const description = ((_a = node.description) === null || _a === void 0 ? void 0 : _a.value) || '';
+                if (description.trim().length === 0) {
+                    context.report({
+                        loc: getLocation(node.name.loc, node.name.value),
+                        messageId: REQUIRE_DESCRIPTION_ERROR,
+                        data: {
+                            nodeType: node.kind,
+                        },
+                    });
+                }
+            },
+        };
     },
 };
 
 const RULE_NAME$2 = 'require-field-of-type-query-in-mutation-result';
-const rule$k = {
+const rule$i = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2834,7 +2705,7 @@ 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: {
@@ -2970,7 +2841,7 @@ const rule$l = {
     },
 };
 
-const rule$m = {
+const rule$k = {
     meta: {
         docs: {
             category: 'Best Practices',
@@ -3092,7 +2963,7 @@ const shouldIgnoreNode = ({ node, exceptions }) => {
     }
     return false;
 };
-const rule$n = {
+const rule$l = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -3269,7 +3140,7 @@ const checkNode = (context, node, ruleName, messageId) => {
         });
     }
 };
-const rule$o = {
+const rule$m = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -3328,7 +3199,7 @@ 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: {
@@ -3395,31 +3266,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 */'];