@graphql-eslint/eslint-plugin 3.14.0-alpha-20221222211539-5e993f5 → 3.14.0-alpha-20221223011700-eed94bd

package/esm/rules/no-hashtag-description.js

@@ -0,0 +1,86 @@
+import { TokenKind } from 'graphql';
+const HASHTAG_COMMENT = 'HASHTAG_COMMENT';
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            [HASHTAG_COMMENT]: 'Using hashtag `#` for adding GraphQL descriptions is not allowed. Prefer using `"""` for multiline, or `"` for a single line description.',
+        },
+        docs: {
+            description: 'Requires to use `"""` or `"` for adding a GraphQL description instead of `#`.\nAllows to use hashtag for comments, as long as it\'s not attached to an AST definition.',
+            category: 'Schema',
+            url: 'https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/no-hashtag-description.md',
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            # Represents a user
+            type User {
+              id: ID!
+              name: String
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            " Represents a user "
+            type User {
+              id: ID!
+              name: String
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            # This file defines the basic User type.
+            # This comment is valid because it's not attached specifically to an AST object.
+
+            " Represents a user "
+            type User {
+              id: ID! # This one is also valid, since it comes after the AST object
+              name: String
+            }
+          `,
+                },
+            ],
+            recommended: true,
+        },
+    },
+    create(context) {
+        const selector = 'Document[definitions.0.kind!=/^(OperationDefinition|FragmentDefinition)$/]';
+        return {
+            [selector](node) {
+                const rawNode = node.rawNode();
+                let token = rawNode.loc.startToken;
+                while (token) {
+                    const { kind, prev, next, value, line, column } = token;
+                    if (kind === TokenKind.COMMENT && prev && next) {
+                        const isEslintComment = value.trimStart().startsWith('eslint');
+                        const linesAfter = next.line - line;
+                        if (!isEslintComment &&
+                            line !== prev.line &&
+                            next.kind === TokenKind.NAME &&
+                            linesAfter < 2) {
+                            context.report({
+                                messageId: HASHTAG_COMMENT,
+                                loc: {
+                                    line,
+                                    column: column - 1,
+                                },
+                                suggest: ['"""', '"'].map(descriptionSyntax => ({
+                                    desc: `Replace with \`${descriptionSyntax}\` description syntax`,
+                                    fix: fixer => fixer.replaceTextRange([token.start, token.end], [descriptionSyntax, value.trim(), descriptionSyntax].join('')),
+                                })),
+                            });
+                        }
+                    }
+                    token = next;
+                }
+            },
+        };
+    },
+};

package/esm/rules/no-one-place-fragments.js

@@ -0,0 +1,80 @@
+import { CWD, requireSiblingsOperations } from '../utils.js';
+import { relative } from 'path';
+import { visit } from 'graphql';
+const RULE_ID = 'no-one-place-fragments';
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            category: 'Operations',
+            description: 'Disallow fragments that are used only in one place.',
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            fragment UserFields on User {
+              id
+            }
+
+            {
+              user {
+                ...UserFields
+                friends {
+                  ...UserFields
+                }
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            fragment UserFields on User {
+              id
+            }
+
+            {
+              user {
+                ...UserFields
+              }
+            }
+          `,
+                },
+            ],
+            requiresSiblings: true,
+        },
+        messages: {
+            [RULE_ID]: 'Fragment `{{fragmentName}}` used only once. Inline him in "{{filePath}}".',
+        },
+        schema: [],
+    },
+    create(context) {
+        const operations = requireSiblingsOperations(RULE_ID, context);
+        const allDocuments = [...operations.getOperations(), ...operations.getFragments()];
+        const usedFragmentsMap = Object.create(null);
+        for (const { document, filePath } of allDocuments) {
+            const relativeFilePath = relative(CWD, filePath);
+            visit(document, {
+                FragmentSpread({ name }) {
+                    const spreadName = name.value;
+                    usedFragmentsMap[spreadName] || (usedFragmentsMap[spreadName] = []);
+                    usedFragmentsMap[spreadName].push(relativeFilePath);
+                },
+            });
+        }
+        return {
+            'FragmentDefinition > Name'(node) {
+                const fragmentName = node.value;
+                const fragmentUsage = usedFragmentsMap[fragmentName];
+                if (fragmentUsage.length === 1) {
+                    context.report({
+                        node,
+                        messageId: RULE_ID,
+                        data: { fragmentName, filePath: fragmentUsage[0] },
+                    });
+                }
+            },
+        };
+    },
+};

package/esm/rules/no-root-type.js

@@ -0,0 +1,83 @@
+import { ARRAY_DEFAULT_OPTIONS, requireGraphQLSchemaFromContext } from '../utils.js';
+const schema = {
+    type: 'array',
+    minItems: 1,
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['disallow'],
+        properties: {
+            disallow: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                items: {
+                    enum: ['mutation', 'subscription'],
+                },
+            },
+        },
+    },
+};
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            category: 'Schema',
+            description: 'Disallow using root types `mutation` and/or `subscription`.',
+            url: 'https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/no-root-type.md',
+            requiresSchema: true,
+            isDisabledForAllConfig: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    usage: [{ disallow: ['mutation', 'subscription'] }],
+                    code: /* GraphQL */ `
+            type Mutation {
+              createUser(input: CreateUserInput!): User!
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ disallow: ['mutation', 'subscription'] }],
+                    code: /* GraphQL */ `
+            type Query {
+              users: [User!]!
+            }
+          `,
+                },
+            ],
+        },
+        schema,
+    },
+    create(context) {
+        const schema = requireGraphQLSchemaFromContext('no-root-type', context);
+        const disallow = new Set(context.options[0].disallow);
+        const rootTypeNames = [
+            disallow.has('mutation') && schema.getMutationType(),
+            disallow.has('subscription') && schema.getSubscriptionType(),
+        ]
+            .filter(Boolean)
+            .map(type => type.name)
+            .join('|');
+        if (!rootTypeNames) {
+            return {};
+        }
+        const selector = `:matches(ObjectTypeDefinition, ObjectTypeExtension) > .name[value=/^(${rootTypeNames})$/]`;
+        return {
+            [selector](node) {
+                const typeName = node.value;
+                context.report({
+                    node,
+                    message: `Root type \`${typeName}\` is forbidden.`,
+                    suggest: [
+                        {
+                            desc: `Remove \`${typeName}\` type`,
+                            fix: fixer => fixer.remove(node.parent),
+                        },
+                    ],
+                });
+            },
+        };
+    },
+};

package/esm/rules/no-scalar-result-type-on-mutation.js

@@ -0,0 +1,63 @@
+import { isScalarType } from 'graphql';
+import { requireGraphQLSchemaFromContext } from '../utils.js';
+const RULE_ID = 'no-scalar-result-type-on-mutation';
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            category: 'Schema',
+            description: 'Avoid scalar result type on mutation type to make sure to return a valid state.',
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.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(RULE_ID, context);
+        const mutationType = schema.getMutationType();
+        if (!mutationType) {
+            return {};
+        }
+        const selector = [
+            `:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=${mutationType.name}]`,
+            '> FieldDefinition > .gqlType Name',
+        ].join(' ');
+        return {
+            [selector](node) {
+                const typeName = node.value;
+                const graphQLType = schema.getType(typeName);
+                if (isScalarType(graphQLType)) {
+                    context.report({
+                        node,
+                        message: `Unexpected scalar result type \`${typeName}\`.`,
+                        suggest: [
+                            {
+                                desc: `Remove \`${typeName}\``,
+                                fix: fixer => fixer.remove(node),
+                            },
+                        ],
+                    });
+                }
+            },
+        };
+    },
+};

package/esm/rules/no-typename-prefix.js

@@ -0,0 +1,62 @@
+const NO_TYPENAME_PREFIX = 'NO_TYPENAME_PREFIX';
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            category: 'Schema',
+            description: 'Enforces users to avoid using the type name in a field name while defining your schema.',
+            recommended: true,
+            url: 'https://github.com/B2o5T/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,
+                            node: field.name,
+                            suggest: [
+                                {
+                                    desc: `Remove \`${fieldName.slice(0, typeName.length)}\` prefix`,
+                                    fix: fixer => fixer.replaceText(field.name, fieldName.replace(new RegExp(`^${typeName}`, 'i'), '')),
+                                },
+                            ],
+                        });
+                    }
+                }
+            },
+        };
+    },
+};

package/esm/rules/no-unreachable-types.js

@@ -0,0 +1,154 @@
+import { isInterfaceType, Kind, visit, DirectiveLocation, } from 'graphql';
+import lowerCase from 'lodash.lowercase';
+import { getTypeName, requireGraphQLSchemaFromContext } from '../utils.js';
+const RULE_ID = 'no-unreachable-types';
+const KINDS = [
+    Kind.DIRECTIVE_DEFINITION,
+    Kind.OBJECT_TYPE_DEFINITION,
+    Kind.OBJECT_TYPE_EXTENSION,
+    Kind.INTERFACE_TYPE_DEFINITION,
+    Kind.INTERFACE_TYPE_EXTENSION,
+    Kind.SCALAR_TYPE_DEFINITION,
+    Kind.SCALAR_TYPE_EXTENSION,
+    Kind.INPUT_OBJECT_TYPE_DEFINITION,
+    Kind.INPUT_OBJECT_TYPE_EXTENSION,
+    Kind.UNION_TYPE_DEFINITION,
+    Kind.UNION_TYPE_EXTENSION,
+    Kind.ENUM_TYPE_DEFINITION,
+    Kind.ENUM_TYPE_EXTENSION,
+];
+let reachableTypesCache;
+const RequestDirectiveLocations = new Set([
+    DirectiveLocation.QUERY,
+    DirectiveLocation.MUTATION,
+    DirectiveLocation.SUBSCRIPTION,
+    DirectiveLocation.FIELD,
+    DirectiveLocation.FRAGMENT_DEFINITION,
+    DirectiveLocation.FRAGMENT_SPREAD,
+    DirectiveLocation.INLINE_FRAGMENT,
+    DirectiveLocation.VARIABLE_DEFINITION,
+]);
+function getReachableTypes(schema) {
+    // We don't want cache reachableTypes on test environment
+    // Otherwise reachableTypes will be same for all tests
+    if (process.env.NODE_ENV !== 'test' && reachableTypesCache) {
+        return reachableTypesCache;
+    }
+    const reachableTypes = new Set();
+    const collect = (node) => {
+        const typeName = getTypeName(node);
+        if (reachableTypes.has(typeName)) {
+            return;
+        }
+        reachableTypes.add(typeName);
+        const type = schema.getType(typeName) || schema.getDirective(typeName);
+        if (isInterfaceType(type)) {
+            const { objects, interfaces } = schema.getImplementations(type);
+            for (const { astNode } of [...objects, ...interfaces]) {
+                visit(astNode, visitor);
+            }
+        }
+        else if (type.astNode) {
+            // astNode can be undefined for ID, String, Boolean
+            visit(type.astNode, visitor);
+        }
+    };
+    const visitor = {
+        InterfaceTypeDefinition: collect,
+        ObjectTypeDefinition: collect,
+        InputValueDefinition: collect,
+        UnionTypeDefinition: collect,
+        FieldDefinition: collect,
+        Directive: collect,
+        NamedType: collect,
+    };
+    for (const type of [
+        schema,
+        schema.getQueryType(),
+        schema.getMutationType(),
+        schema.getSubscriptionType(),
+    ]) {
+        // if schema don't have Query type, schema.astNode will be undefined
+        if (type === null || type === void 0 ? void 0 : type.astNode) {
+            visit(type.astNode, visitor);
+        }
+    }
+    for (const node of schema.getDirectives()) {
+        if (node.locations.some(location => RequestDirectiveLocations.has(location))) {
+            reachableTypes.add(node.name);
+        }
+    }
+    reachableTypesCache = reachableTypes;
+    return reachableTypesCache;
+}
+export const rule = {
+    meta: {
+        messages: {
+            [RULE_ID]: '{{ type }} `{{ typeName }}` is unreachable.',
+        },
+        docs: {
+            description: 'Requires all types to be reachable at some level by root level fields.',
+            category: 'Schema',
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            requiresSchema: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type User {
+              id: ID!
+              name: String
+            }
+
+            type Query {
+              me: String
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            type User {
+              id: ID!
+              name: String
+            }
+
+            type Query {
+              me: User
+            }
+          `,
+                },
+            ],
+            recommended: true,
+        },
+        type: 'suggestion',
+        schema: [],
+        hasSuggestions: true,
+    },
+    create(context) {
+        const schema = requireGraphQLSchemaFromContext(RULE_ID, context);
+        const reachableTypes = getReachableTypes(schema);
+        return {
+            [`:matches(${KINDS}) > .name`](node) {
+                const typeName = node.value;
+                if (!reachableTypes.has(typeName)) {
+                    const type = lowerCase(node.parent.kind.replace(/(Extension|Definition)$/, ''));
+                    context.report({
+                        node,
+                        messageId: RULE_ID,
+                        data: {
+                            type: type[0].toUpperCase() + type.slice(1),
+                            typeName,
+                        },
+                        suggest: [
+                            {
+                                desc: `Remove \`${typeName}\``,
+                                fix: fixer => fixer.remove(node.parent),
+                            },
+                        ],
+                    });
+                }
+            },
+        };
+    },
+};

package/esm/rules/no-unused-fields.js

@@ -0,0 +1,127 @@
+import { TypeInfo, visit, visitWithTypeInfo } from 'graphql';
+import { requireGraphQLSchemaFromContext, requireSiblingsOperations } from '../utils.js';
+const RULE_ID = 'no-unused-fields';
+let usedFieldsCache;
+function getUsedFields(schema, operations) {
+    // We don't want cache usedFields on test environment
+    // Otherwise usedFields will be same for all tests
+    if (process.env.NODE_ENV !== 'test' && usedFieldsCache) {
+        return usedFieldsCache;
+    }
+    const usedFields = Object.create(null);
+    const typeInfo = new TypeInfo(schema);
+    const visitor = visitWithTypeInfo(typeInfo, {
+        Field(node) {
+            var _a;
+            const fieldDef = typeInfo.getFieldDef();
+            if (!fieldDef) {
+                // skip visiting this node if field is not defined in schema
+                return false;
+            }
+            const parentTypeName = typeInfo.getParentType().name;
+            const fieldName = node.name.value;
+            (_a = usedFields[parentTypeName]) !== null && _a !== void 0 ? _a : (usedFields[parentTypeName] = new Set());
+            usedFields[parentTypeName].add(fieldName);
+        },
+    });
+    const allDocuments = [...operations.getOperations(), ...operations.getFragments()];
+    for (const { document } of allDocuments) {
+        visit(document, visitor);
+    }
+    usedFieldsCache = usedFields;
+    return usedFieldsCache;
+}
+export const rule = {
+    meta: {
+        messages: {
+            [RULE_ID]: 'Field "{{fieldName}}" is unused',
+        },
+        docs: {
+            description: 'Requires all fields to be used at some level by siblings operations.',
+            category: 'Schema',
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            requiresSiblings: true,
+            requiresSchema: true,
+            isDisabledForAllConfig: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type User {
+              id: ID!
+              name: String
+              someUnusedField: String
+            }
+
+            type Query {
+              me: User
+            }
+
+            query {
+              me {
+                id
+                name
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            type User {
+              id: ID!
+              name: String
+            }
+
+            type Query {
+              me: User
+            }
+
+            query {
+              me {
+                id
+                name
+              }
+            }
+          `,
+                },
+            ],
+        },
+        type: 'suggestion',
+        schema: [],
+        hasSuggestions: true,
+    },
+    create(context) {
+        const schema = requireGraphQLSchemaFromContext(RULE_ID, context);
+        const siblingsOperations = requireSiblingsOperations(RULE_ID, context);
+        const usedFields = getUsedFields(schema, siblingsOperations);
+        return {
+            FieldDefinition(node) {
+                var _a;
+                const fieldName = node.name.value;
+                const parentTypeName = node.parent.name.value;
+                const isUsed = (_a = usedFields[parentTypeName]) === null || _a === void 0 ? void 0 : _a.has(fieldName);
+                if (isUsed) {
+                    return;
+                }
+                context.report({
+                    node: node.name,
+                    messageId: RULE_ID,
+                    data: { fieldName },
+                    suggest: [
+                        {
+                            desc: `Remove \`${fieldName}\` field`,
+                            fix(fixer) {
+                                const sourceCode = context.getSourceCode();
+                                const tokenBefore = sourceCode.getTokenBefore(node);
+                                const tokenAfter = sourceCode.getTokenAfter(node);
+                                const isEmptyType = tokenBefore.type === '{' && tokenAfter.type === '}';
+                                return fixer.remove((isEmptyType ? node.parent : node));
+                            },
+                        },
+                    ],
+                });
+            },
+        };
+    },
+};