@graphql-eslint/eslint-plugin 3.14.0-alpha-20221221133443-5be7fc6 → 3.14.0-alpha-20221222012949-5caade4

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const graphql_1 = require("graphql");
+const HASHTAG_COMMENT = 'HASHTAG_COMMENT';
+exports.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 === graphql_1.TokenKind.COMMENT && prev && next) {
+                        const isEslintComment = value.trimStart().startsWith('eslint');
+                        const linesAfter = next.line - line;
+                        if (!isEslintComment &&
+                            line !== prev.line &&
+                            next.kind === graphql_1.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/cjs/rules/no-root-type.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const utils_1 = require("../utils");
+const schema = {
+    type: 'array',
+    minItems: 1,
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['disallow'],
+        properties: {
+            disallow: {
+                ...utils_1.ARRAY_DEFAULT_OPTIONS,
+                items: {
+                    enum: ['mutation', 'subscription'],
+                },
+            },
+        },
+    },
+};
+exports.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 = (0, utils_1.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/cjs/rules/no-scalar-result-type-on-mutation.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("../utils");
+const RULE_ID = 'no-scalar-result-type-on-mutation';
+exports.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 = (0, utils_1.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 ((0, graphql_1.isScalarType)(graphQLType)) {
+                    context.report({
+                        node,
+                        message: `Unexpected scalar result type \`${typeName}\`.`,
+                        suggest: [
+                            {
+                                desc: `Remove \`${typeName}\``,
+                                fix: fixer => fixer.remove(node),
+                            },
+                        ],
+                    });
+                }
+            },
+        };
+    },
+};

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const NO_TYPENAME_PREFIX = 'NO_TYPENAME_PREFIX';
+exports.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/cjs/rules/no-unreachable-types.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const tslib_1 = require("tslib");
+const graphql_1 = require("graphql");
+const lodash_lowercase_1 = tslib_1.__importDefault(require("lodash.lowercase"));
+const utils_1 = require("../utils");
+const RULE_ID = 'no-unreachable-types';
+const KINDS = [
+    graphql_1.Kind.DIRECTIVE_DEFINITION,
+    graphql_1.Kind.OBJECT_TYPE_DEFINITION,
+    graphql_1.Kind.OBJECT_TYPE_EXTENSION,
+    graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
+    graphql_1.Kind.INTERFACE_TYPE_EXTENSION,
+    graphql_1.Kind.SCALAR_TYPE_DEFINITION,
+    graphql_1.Kind.SCALAR_TYPE_EXTENSION,
+    graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+    graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION,
+    graphql_1.Kind.UNION_TYPE_DEFINITION,
+    graphql_1.Kind.UNION_TYPE_EXTENSION,
+    graphql_1.Kind.ENUM_TYPE_DEFINITION,
+    graphql_1.Kind.ENUM_TYPE_EXTENSION,
+];
+let reachableTypesCache;
+const RequestDirectiveLocations = new Set([
+    graphql_1.DirectiveLocation.QUERY,
+    graphql_1.DirectiveLocation.MUTATION,
+    graphql_1.DirectiveLocation.SUBSCRIPTION,
+    graphql_1.DirectiveLocation.FIELD,
+    graphql_1.DirectiveLocation.FRAGMENT_DEFINITION,
+    graphql_1.DirectiveLocation.FRAGMENT_SPREAD,
+    graphql_1.DirectiveLocation.INLINE_FRAGMENT,
+    graphql_1.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 = (0, utils_1.getTypeName)(node);
+        if (reachableTypes.has(typeName)) {
+            return;
+        }
+        reachableTypes.add(typeName);
+        const type = schema.getType(typeName) || schema.getDirective(typeName);
+        if ((0, graphql_1.isInterfaceType)(type)) {
+            const { objects, interfaces } = schema.getImplementations(type);
+            for (const { astNode } of [...objects, ...interfaces]) {
+                (0, graphql_1.visit)(astNode, visitor);
+            }
+        }
+        else if (type.astNode) {
+            // astNode can be undefined for ID, String, Boolean
+            (0, graphql_1.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) {
+            (0, graphql_1.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;
+}
+exports.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 = (0, utils_1.requireGraphQLSchemaFromContext)(RULE_ID, context);
+        const reachableTypes = getReachableTypes(schema);
+        return {
+            [`:matches(${KINDS}) > .name`](node) {
+                const typeName = node.value;
+                if (!reachableTypes.has(typeName)) {
+                    const type = (0, lodash_lowercase_1.default)(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/cjs/rules/no-unused-fields.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("../utils");
+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 graphql_1.TypeInfo(schema);
+    const visitor = (0, graphql_1.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) {
+        (0, graphql_1.visit)(document, visitor);
+    }
+    usedFieldsCache = usedFields;
+    return usedFieldsCache;
+}
+exports.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 = (0, utils_1.requireGraphQLSchemaFromContext)(RULE_ID, context);
+        const siblingsOperations = (0, utils_1.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));
+                            },
+                        },
+                    ],
+                });
+            },
+        };
+    },
+};