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

package/docs/rules/require-description.md

@@ -12,7 +12,7 @@ Enforce descriptions in your type definitions.
 ### Incorrect
 
 ```graphql
-# eslint @graphql-eslint/require-description: ['error', { on: ['ObjectTypeDefinition', 'FieldDefinition'] }]
+# eslint @graphql-eslint/require-description: ['error', { types: true, overrides: { FieldDefinition: true } }]
 
 type someTypeName {
   name: String
@@ -22,7 +22,7 @@ type someTypeName {
 ### Correct
 
 ```graphql
-# eslint @graphql-eslint/require-description: ['error', { on: ['ObjectTypeDefinition', 'FieldDefinition'] }]
+# eslint @graphql-eslint/require-description: ['error', { types: true, overrides: { FieldDefinition: true } }]
 
 """
 Some type description
@@ -39,13 +39,42 @@ type someTypeName {
 
 The schema defines the following properties:
 
-### `on` (array)
+### `types` (boolean)
 
-The object is an array with all elements of the type `string`.
+Includes:
 
-Additional restrictions:
+- [ObjectTypeDefinition](https://spec.graphql.org/October2021/#ObjectTypeDefinition)
+- [InterfaceTypeDefinition](https://spec.graphql.org/October2021/#InterfaceTypeDefinition)
+- [EnumTypeDefinition](https://spec.graphql.org/October2021/#EnumTypeDefinition)
+- [ScalarTypeDefinition](https://spec.graphql.org/October2021/#ScalarTypeDefinition)
+- [InputObjectTypeDefinition](https://spec.graphql.org/October2021/#InputObjectTypeDefinition)
+- [UnionTypeDefinition](https://spec.graphql.org/October2021/#UnionTypeDefinition)
 
-* Minimum items: `1`
+### `overrides` (object)
+
+Configuration for precise `ASTNode`
+
+Properties of the `overrides` object:
+
+#### `ObjectTypeDefinition` (boolean)
+
+#### `InterfaceTypeDefinition` (boolean)
+
+#### `EnumTypeDefinition` (boolean)
+
+#### `ScalarTypeDefinition` (boolean)
+
+#### `InputObjectTypeDefinition` (boolean)
+
+#### `UnionTypeDefinition` (boolean)
+
+#### `FieldDefinition` (boolean)
+
+#### `InputValueDefinition` (boolean)
+
+#### `EnumValueDefinition` (boolean)
+
+#### `DirectiveDefinition` (boolean)
 
 ## Resources
 

package/estree-parser/converter.d.ts

@@ -1,7 +1,6 @@
 import { GraphQLESTreeNode } from './estree-ast';
 import { ASTNode, TypeInfo } from 'graphql';
-import { Comment } from 'estree';
 export declare function convertToESTree<T extends ASTNode>(node: T, typeInfo?: TypeInfo): {
-    rootTree: GraphQLESTreeNode<T>;
-    comments: Comment[];
+    rootTree: GraphQLESTreeNode<T, false>;
+    comments: import("estree").Comment[];
 };

package/index.js

@@ -118,10 +118,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',
@@ -176,7 +177,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 graphql.Source(source));
+    const lexer = getLexer(source);
     const tokens = [];
     let token = lexer.advance();
     while (token && token.kind !== '<EOF>') {
@@ -545,11 +546,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',
@@ -1582,11 +1595,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',
@@ -1602,7 +1615,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",
                             '>',
@@ -1885,7 +1898,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),
@@ -1902,7 +1915,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),
@@ -2059,9 +2072,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(${graphql.Kind.OBJECT_TYPE_DEFINITION}, ${graphql.Kind.OBJECT_TYPE_EXTENSION})`,
+            '>',
+            `${graphql.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`,
@@ -2137,7 +2241,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`,
@@ -2326,7 +2430,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: {
@@ -2429,7 +2533,7 @@ const rule$g = {
     },
 };
 
-const rule$h = {
+const rule$i = {
     meta: {
         docs: {
             description: `Require all deprecation directives to specify a reason.`,
@@ -2484,41 +2588,23 @@ const rule$h = {
 };
 
 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$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
@@ -2527,7 +2613,7 @@ const rule$i = {
                 },
                 {
                     title: 'Correct',
-                    usage: [{ on: ['ObjectTypeDefinition', 'FieldDefinition'] }],
+                    usage: [{ types: true, overrides: { FieldDefinition: true } }],
                     code: /* GraphQL */ `
             """
             Some type description
@@ -2541,40 +2627,74 @@ const rule$i = {
           `,
                 },
             ],
+            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$j = {
+const rule$k = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2742,7 +2862,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: {
@@ -2878,7 +2998,7 @@ const rule$k = {
     },
 };
 
-const rule$l = {
+const rule$m = {
     meta: {
         docs: {
             category: 'Best Practices',
@@ -3000,7 +3120,7 @@ const shouldIgnoreNode = ({ node, exceptions }) => {
     }
     return false;
 };
-const rule$m = {
+const rule$n = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -3177,7 +3297,7 @@ const checkNode = (context, node, ruleName, messageId) => {
         });
     }
 };
-const rule$n = {
+const rule$o = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -3236,7 +3356,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: {
@@ -3316,17 +3436,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 */'];
@@ -3629,7 +3750,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) {
             graphql.visit(type.astNode, visitor);
         }
@@ -3688,7 +3814,7 @@ function parseForESLint(code, options = {}) {
             noLocation: false,
         });
         const { rootTree, comments } = convertToESTree(graphqlAst.document, schema ? new graphql.TypeInfo(schema) : null);
-        const tokens = extractTokens(code);
+        const tokens = extractTokens(new graphql.Source(code, filePath));
         return {
             services: parserServices,
             parserServices,