@graphql-eslint/eslint-plugin 3.0.0-alpha-5388f29.0 → 3.0.0-alpha-580615a.0

package/index.mjs

@@ -1,4 +1,4 @@
-import { Kind, Source, validate, isScalarType, TokenKind, isNonNullType, isListType, isObjectType as isObjectType$1, visit, visitWithTypeInfo, GraphQLObjectType, GraphQLInterfaceType, TypeInfo, isInterfaceType, GraphQLError } from 'graphql';
+import { Kind, validate, isScalarType, TokenKind, isNonNullType, isListType, isObjectType as isObjectType$1, visit, visitWithTypeInfo, GraphQLObjectType, GraphQLInterfaceType, TypeInfo, isInterfaceType, Source, GraphQLError } from 'graphql';
 import { validateSDL } from 'graphql/validation/validate';
 import { processImport, parseImportLine } from '@graphql-tools/import';
 import { statSync, existsSync, readFileSync } from 'fs';
@@ -112,10 +112,11 @@ const allConfig = {
         '@graphql-eslint/match-document-filename': 'error',
         '@graphql-eslint/no-deprecated': 'error',
         '@graphql-eslint/no-hashtag-description': 'error',
+        '@graphql-eslint/no-root-type': ['error', { disallow: ['subscription'] }],
         '@graphql-eslint/no-unreachable-types': 'error',
         '@graphql-eslint/no-unused-fields': 'error',
         '@graphql-eslint/require-deprecation-date': 'error',
-        '@graphql-eslint/require-description': 'error',
+        '@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',
@@ -170,7 +171,7 @@ function getLexer(source) {
     throw new Error(`Unsupported GraphQL version! Please make sure to use GraphQL v14 or newer!`);
 }
 function extractTokens(source) {
-    const lexer = getLexer(new Source(source));
+    const lexer = getLexer(source);
     const tokens = [];
     let token = lexer.advance();
     while (token && token.kind !== '<EOF>') {
@@ -539,11 +540,23 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
 }));
 
 const ALPHABETIZE = 'ALPHABETIZE';
-const fieldsEnum = [Kind.OBJECT_TYPE_DEFINITION, Kind.INTERFACE_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_DEFINITION];
+const fieldsEnum = [
+    Kind.OBJECT_TYPE_DEFINITION,
+    Kind.INTERFACE_TYPE_DEFINITION,
+    Kind.INPUT_OBJECT_TYPE_DEFINITION,
+];
 const valuesEnum = [Kind.ENUM_TYPE_DEFINITION];
-const selectionsEnum = [Kind.OPERATION_DEFINITION, Kind.FRAGMENT_DEFINITION];
+const selectionsEnum = [
+    Kind.OPERATION_DEFINITION,
+    Kind.FRAGMENT_DEFINITION,
+];
 const variablesEnum = [Kind.OPERATION_DEFINITION];
-const argumentsEnum = [Kind.FIELD_DEFINITION, Kind.FIELD, Kind.DIRECTIVE_DEFINITION, Kind.DIRECTIVE];
+const argumentsEnum = [
+    Kind.FIELD_DEFINITION,
+    Kind.FIELD,
+    Kind.DIRECTIVE_DEFINITION,
+    Kind.DIRECTIVE,
+];
 const rule = {
     meta: {
         type: 'suggestion',
@@ -1576,11 +1589,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',
@@ -1596,7 +1609,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",
                             '>',
@@ -1879,7 +1892,7 @@ const rule$b = {
                 requireGraphQLSchemaFromContext('no-deprecated', context);
                 const typeInfo = node.typeInfo();
                 if (typeInfo && typeInfo.enumValue) {
-                    if (typeInfo.enumValue.isDeprecated) {
+                    if (typeInfo.enumValue.deprecationReason) {
                         const enumValueName = node.value;
                         context.report({
                             loc: getLocation(node.loc, enumValueName),
@@ -1896,7 +1909,7 @@ const rule$b = {
                 requireGraphQLSchemaFromContext('no-deprecated', context);
                 const typeInfo = node.typeInfo();
                 if (typeInfo && typeInfo.fieldDef) {
-                    if (typeInfo.fieldDef.isDeprecated) {
+                    if (typeInfo.fieldDef.deprecationReason) {
                         const fieldName = node.name.value;
                         context.report({
                             loc: getLocation(node.loc, fieldName),
@@ -2053,9 +2066,100 @@ const rule$d = {
     },
 };
 
+const ROOT_TYPES = ['query', 'mutation', 'subscription'];
+const rule$e = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            category: 'Validation',
+            description: 'Disallow using root types for `read-only` or `write-only` schemas.',
+            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-root-type.md',
+            requiresSchema: true,
+            examples: [
+                {
+                    title: 'Incorrect (`read-only` schema)',
+                    usage: [{ disallow: ['mutation', 'subscription'] }],
+                    code: /* GraphQL */ `
+            type Mutation {
+              createUser(input: CreateUserInput!): User!
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect (`write-only` schema)',
+                    usage: [{ disallow: ['query'] }],
+                    code: /* GraphQL */ `
+            type Query {
+              users: [User!]!
+            }
+          `,
+                },
+                {
+                    title: 'Correct (`read-only` schema)',
+                    usage: [{ disallow: ['mutation', 'subscription'] }],
+                    code: /* GraphQL */ `
+            type Query {
+              users: [User!]!
+            }
+          `,
+                },
+            ],
+            optionsForConfig: [{ disallow: ['subscription'] }],
+        },
+        schema: {
+            type: 'array',
+            minItems: 1,
+            maxItems: 1,
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['disallow'],
+                properties: {
+                    disallow: {
+                        type: 'array',
+                        uniqueItems: true,
+                        minItems: 1,
+                        items: {
+                            enum: ROOT_TYPES,
+                        },
+                    },
+                },
+            },
+        },
+    },
+    create(context) {
+        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(),
+        ]
+            .filter(Boolean)
+            .map(type => type.name);
+        if (rootTypeNames.length === 0) {
+            return {};
+        }
+        const selector = [
+            `:matches(${Kind.OBJECT_TYPE_DEFINITION}, ${Kind.OBJECT_TYPE_EXTENSION})`,
+            '>',
+            `${Kind.NAME}[value=/^(${rootTypeNames.join('|')})$/]`,
+        ].join(' ');
+        return {
+            [selector](node) {
+                const typeName = node.value;
+                context.report({
+                    loc: getLocation(node.loc, typeName),
+                    message: `Root type "${typeName}" is forbidden`,
+                });
+            },
+        };
+    },
+};
+
 const UNREACHABLE_TYPE = 'UNREACHABLE_TYPE';
 const RULE_NAME = 'no-unreachable-types';
-const rule$e = {
+const rule$f = {
     meta: {
         messages: {
             [UNREACHABLE_TYPE]: `Type "{{ typeName }}" is unreachable`,
@@ -2131,7 +2235,7 @@ const rule$e = {
 
 const UNUSED_FIELD = 'UNUSED_FIELD';
 const RULE_NAME$1 = 'no-unused-fields';
-const rule$f = {
+const rule$g = {
     meta: {
         messages: {
             [UNUSED_FIELD]: `Field "{{fieldName}}" is unused`,
@@ -2320,7 +2424,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$g = {
+const rule$h = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2423,7 +2527,7 @@ const rule$g = {
     },
 };
 
-const rule$h = {
+const rule$i = {
     meta: {
         docs: {
             description: `Require all deprecation directives to specify a reason.`,
@@ -2478,41 +2582,23 @@ const rule$h = {
 };
 
 const REQUIRE_DESCRIPTION_ERROR = 'REQUIRE_DESCRIPTION_ERROR';
-const DESCRIBABLE_NODES = [
-    Kind.SCHEMA_DEFINITION,
-    Kind.OBJECT_TYPE_DEFINITION,
+const ALLOWED_KINDS$1 = [
+    ...TYPES_KINDS,
     Kind.FIELD_DEFINITION,
     Kind.INPUT_VALUE_DEFINITION,
-    Kind.INTERFACE_TYPE_DEFINITION,
-    Kind.UNION_TYPE_DEFINITION,
-    Kind.ENUM_TYPE_DEFINITION,
     Kind.ENUM_VALUE_DEFINITION,
-    Kind.INPUT_OBJECT_TYPE_DEFINITION,
     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$i = {
+const rule$j = {
     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: ['ObjectTypeDefinition', 'FieldDefinition'] }],
+                    usage: [{ types: true, overrides: { FieldDefinition: true } }],
                     code: /* GraphQL */ `
             type someTypeName {
               name: String
@@ -2521,7 +2607,7 @@ const rule$i = {
                 },
                 {
                     title: 'Correct',
-                    usage: [{ on: ['ObjectTypeDefinition', 'FieldDefinition'] }],
+                    usage: [{ types: true, overrides: { FieldDefinition: true } }],
                     code: /* GraphQL */ `
             """
             Some type description
@@ -2535,40 +2621,74 @@ const rule$i = {
           `,
                 },
             ],
+            optionsForConfig: [
+                {
+                    types: true,
+                    overrides: {
+                        [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$j = {
+const rule$k = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2736,7 +2856,7 @@ const convertNode = (typeInfo) => (node, key, parent) => {
 
 const REQUIRE_ID_WHEN_AVAILABLE = 'REQUIRE_ID_WHEN_AVAILABLE';
 const DEFAULT_ID_FIELD_NAME = 'id';
-const rule$k = {
+const rule$l = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2872,7 +2992,7 @@ const rule$k = {
     },
 };
 
-const rule$l = {
+const rule$m = {
     meta: {
         docs: {
             category: 'Best Practices',
@@ -2994,7 +3114,7 @@ const shouldIgnoreNode = ({ node, exceptions }) => {
     }
     return false;
 };
-const rule$m = {
+const rule$n = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -3171,7 +3291,7 @@ const checkNode = (context, node, ruleName, messageId) => {
         });
     }
 };
-const rule$n = {
+const rule$o = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -3230,7 +3350,7 @@ const rule$n = {
 
 const RULE_NAME$4 = 'unique-operation-name';
 const UNIQUE_OPERATION_NAME = 'UNIQUE_OPERATION_NAME';
-const rule$o = {
+const rule$p = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -3310,17 +3430,18 @@ const rules = {
     'no-deprecated': rule$b,
     'no-hashtag-description': rule$c,
     'no-operation-name-suffix': rule$d,
-    'no-unreachable-types': rule$e,
-    'no-unused-fields': rule$f,
-    'require-deprecation-date': rule$g,
-    'require-deprecation-reason': rule$h,
-    'require-description': rule$i,
-    'require-field-of-type-query-in-mutation-result': rule$j,
-    'require-id-when-available': rule$k,
-    'selection-set-depth': rule$l,
-    'strict-id-in-types': rule$m,
-    'unique-fragment-name': rule$n,
-    'unique-operation-name': rule$o,
+    '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,
 };
 
 const RELEVANT_KEYWORDS = ['gql', 'graphql', '/* GraphQL */'];
@@ -3623,7 +3744,12 @@ function getReachableTypes(schema) {
         Directive: collect,
         NamedType: collect,
     };
-    for (const type of [schema.getQueryType(), schema.getMutationType(), schema.getSubscriptionType()]) {
+    for (const type of [
+        schema,
+        schema.getQueryType(),
+        schema.getMutationType(),
+        schema.getSubscriptionType(),
+    ]) {
         if (type) {
             visit(type.astNode, visitor);
         }
@@ -3682,7 +3808,7 @@ function parseForESLint(code, options = {}) {
             noLocation: false,
         });
         const { rootTree, comments } = convertToESTree(graphqlAst.document, schema ? new TypeInfo(schema) : null);
-        const tokens = extractTokens(code);
+        const tokens = extractTokens(new Source(code, filePath));
         return {
             services: parserServices,
             parserServices,

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "@graphql-eslint/eslint-plugin",
-  "version": "3.0.0-alpha-5388f29.0",
+  "version": "3.0.0-alpha-580615a.0",
   "sideEffects": false,
   "peerDependencies": {
-    "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0"
+    "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
   },
   "dependencies": {
-    "@graphql-tools/code-file-loader": "^7.0.2",
-    "@graphql-tools/graphql-tag-pluck": "^7.0.2",
-    "@graphql-tools/import": "^6.3.1",
-    "@graphql-tools/utils": "^8.0.2",
-    "graphql-config": "^4.0.1",
+    "@babel/code-frame": "7.16.0",
+    "@graphql-tools/code-file-loader": "7.2.2",
+    "@graphql-tools/graphql-tag-pluck": "7.1.3",
+    "@graphql-tools/import": "6.6.1",
+    "@graphql-tools/utils": "8.5.3",
+    "graphql-config": "4.1.0",
     "graphql-depth-limit": "1.1.0",
-    "lodash.lowercase": "^4.3.0"
+    "lodash.lowercase": "4.3.0"
   },
   "repository": "https://github.com/dotansimha/graphql-eslint",
   "author": "Dotan Simha <dotansimha@gmail.com>",

package/rules/alphabetize.d.ts

@@ -1,9 +1,9 @@
 import { GraphQLESLintRule } from '../types';
-declare const fieldsEnum: ("ObjectTypeDefinition" | "InterfaceTypeDefinition" | "InputObjectTypeDefinition")[];
-declare const valuesEnum: "EnumTypeDefinition"[];
-declare const selectionsEnum: ("OperationDefinition" | "FragmentDefinition")[];
-declare const variablesEnum: "OperationDefinition"[];
-declare const argumentsEnum: ("Field" | "Directive" | "FieldDefinition" | "DirectiveDefinition")[];
+declare const fieldsEnum: ('ObjectTypeDefinition' | 'InterfaceTypeDefinition' | 'InputObjectTypeDefinition')[];
+declare const valuesEnum: ['EnumTypeDefinition'];
+declare const selectionsEnum: ('OperationDefinition' | 'FragmentDefinition')[];
+declare const variablesEnum: ['OperationDefinition'];
+declare const argumentsEnum: ('FieldDefinition' | 'Field' | 'DirectiveDefinition' | 'Directive')[];
 declare type AlphabetizeConfig = [
     {
         fields?: typeof fieldsEnum;

package/rules/index.d.ts

@@ -1,9 +1,9 @@
 export declare const rules: {
     alphabetize: import("..").GraphQLESLintRule<[{
         fields?: ("ObjectTypeDefinition" | "InterfaceTypeDefinition" | "InputObjectTypeDefinition")[];
-        values?: "EnumTypeDefinition"[];
+        values?: ["EnumTypeDefinition"];
         selections?: ("OperationDefinition" | "FragmentDefinition")[];
-        variables?: "OperationDefinition"[];
+        variables?: ["OperationDefinition"];
         arguments?: ("Field" | "Directive" | "FieldDefinition" | "DirectiveDefinition")[];
     }], false>;
     'avoid-duplicate-fields': import("..").GraphQLESLintRule<any[], false>;
@@ -161,6 +161,9 @@ export declare const rules: {
     'no-deprecated': import("..").GraphQLESLintRule<[], true>;
     'no-hashtag-description': import("..").GraphQLESLintRule<any[], false>;
     'no-operation-name-suffix': import("..").GraphQLESLintRule<any[], false>;
+    'no-root-type': import("..").GraphQLESLintRule<[{
+        disallow: ("query" | "mutation" | "subscription")[];
+    }], false>;
     'no-unreachable-types': import("..").GraphQLESLintRule<any[], false>;
     'no-unused-fields': import("..").GraphQLESLintRule<any[], false>;
     'require-deprecation-date': import("..").GraphQLESLintRule<[{
@@ -168,7 +171,19 @@ export declare const rules: {
     }], false>;
     'require-deprecation-reason': import("..").GraphQLESLintRule<any[], false>;
     'require-description': import("..").GraphQLESLintRule<[{
-        on: ("SchemaDefinition" | "ObjectTypeDefinition" | "FieldDefinition" | "InputValueDefinition" | "InterfaceTypeDefinition" | "UnionTypeDefinition" | "EnumTypeDefinition" | "EnumValueDefinition" | "InputObjectTypeDefinition" | "DirectiveDefinition")[];
+        types?: boolean;
+        overrides?: {
+            ScalarTypeDefinition?: boolean;
+            ObjectTypeDefinition?: boolean;
+            FieldDefinition?: boolean;
+            InputValueDefinition?: boolean;
+            InterfaceTypeDefinition?: boolean;
+            UnionTypeDefinition?: boolean;
+            EnumTypeDefinition?: boolean;
+            EnumValueDefinition?: boolean;
+            InputObjectTypeDefinition?: boolean;
+            DirectiveDefinition?: boolean;
+        };
     }], false>;
     'require-field-of-type-query-in-mutation-result': import("..").GraphQLESLintRule<any[], false>;
     'require-id-when-available': import("..").GraphQLESLintRule<[{

package/rules/no-root-type.d.ts

@@ -0,0 +1,7 @@
+import { GraphQLESLintRule } from '../types';
+declare const ROOT_TYPES: ('query' | 'mutation' | 'subscription')[];
+declare type NoRootTypeConfig = {
+    disallow: typeof ROOT_TYPES;
+};
+declare const rule: GraphQLESLintRule<[NoRootTypeConfig]>;
+export default rule;

package/rules/require-description.d.ts

@@ -1,7 +1,12 @@
+import { Kind } from 'graphql';
 import { GraphQLESLintRule } from '../types';
-declare const DESCRIBABLE_NODES: ("SchemaDefinition" | "ObjectTypeDefinition" | "FieldDefinition" | "InputValueDefinition" | "InterfaceTypeDefinition" | "UnionTypeDefinition" | "EnumTypeDefinition" | "EnumValueDefinition" | "InputObjectTypeDefinition" | "DirectiveDefinition")[];
-declare type RequireDescriptionRuleConfig = [{
-    on: typeof DESCRIBABLE_NODES;
-}];
-declare const rule: GraphQLESLintRule<RequireDescriptionRuleConfig>;
+declare const ALLOWED_KINDS: readonly [Kind.OBJECT_TYPE_DEFINITION, Kind.INTERFACE_TYPE_DEFINITION, Kind.ENUM_TYPE_DEFINITION, Kind.SCALAR_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.UNION_TYPE_DEFINITION, Kind.FIELD_DEFINITION, Kind.INPUT_VALUE_DEFINITION, Kind.ENUM_VALUE_DEFINITION, Kind.DIRECTIVE_DEFINITION];
+declare type AllowedKind = typeof ALLOWED_KINDS[number];
+declare type RequireDescriptionRuleConfig = {
+    types?: boolean;
+    overrides?: {
+        [key in AllowedKind]?: boolean;
+    };
+};
+declare const rule: GraphQLESLintRule<[RequireDescriptionRuleConfig]>;
 export default rule;

package/utils.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from 'graphql';
+import { GraphQLSchema, Source, Kind } from 'graphql';
 import { AST } from 'eslint';
 import { Source as LoaderSource } from '@graphql-tools/utils';
 import { GraphQLESLintRuleContext } from './types';
@@ -8,7 +8,7 @@ export declare function requireSiblingsOperations(ruleName: string, context: Gra
 export declare function requireGraphQLSchemaFromContext(ruleName: string, context: GraphQLESLintRuleContext): GraphQLSchema | never;
 export declare function requireReachableTypesFromContext(ruleName: string, context: GraphQLESLintRuleContext): ReachableTypes | never;
 export declare function requireUsedFieldsFromContext(ruleName: string, context: GraphQLESLintRuleContext): UsedFields | never;
-export declare function extractTokens(source: string): AST.Token[];
+export declare function extractTokens(source: Source): AST.Token[];
 export declare const normalizePath: (path: string) => string;
 /**
  * https://github.com/prettier/eslint-plugin-prettier/blob/76bd45ece6d56eb52f75db6b4a1efdd2efb56392/eslint-plugin-prettier.js#L71
@@ -19,7 +19,7 @@ export declare const normalizePath: (path: string) => string;
 export declare const getOnDiskFilepath: (filepath: string) => string;
 export declare const getTypeName: (node: any) => any;
 export declare const loaderCache: Record<string, LoaderSource[]>;
-export declare const TYPES_KINDS: ("ScalarTypeDefinition" | "ObjectTypeDefinition" | "InterfaceTypeDefinition" | "UnionTypeDefinition" | "EnumTypeDefinition" | "InputObjectTypeDefinition")[];
+export declare const TYPES_KINDS: readonly [Kind.OBJECT_TYPE_DEFINITION, Kind.INTERFACE_TYPE_DEFINITION, Kind.ENUM_TYPE_DEFINITION, Kind.SCALAR_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.UNION_TYPE_DEFINITION];
 export declare enum CaseStyle {
     camelCase = "camelCase",
     pascalCase = "PascalCase",