@graphql-eslint/eslint-plugin 3.14.0-alpha-20221221142641-4e1a924 → 3.14.0-alpha-20221222012949-5caade4

package/cjs/rules/require-deprecation-reason.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const estree_converter_1 = require("../estree-converter");
+exports.rule = {
+    meta: {
+        docs: {
+            description: 'Require all deprecation directives to specify a reason.',
+            category: 'Schema',
+            url: 'https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/require-deprecation-reason.md',
+            recommended: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type MyType {
+              name: String @deprecated
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type MyType {
+              name: String @deprecated(reason: "")
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            type MyType {
+              name: String @deprecated(reason: "no longer relevant, please use fullName field")
+            }
+          `,
+                },
+            ],
+        },
+        type: 'suggestion',
+        schema: [],
+    },
+    create(context) {
+        return {
+            'Directive[name.value=deprecated]'(node) {
+                const reasonArgument = node.arguments.find(arg => arg.name.value === 'reason');
+                const value = reasonArgument && String((0, estree_converter_1.valueFromNode)(reasonArgument.value)).trim();
+                if (!value) {
+                    context.report({
+                        node: node.name,
+                        message: 'Directive "@deprecated" must have a reason!',
+                    });
+                }
+            },
+        };
+    },
+};

package/cjs/rules/require-description.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("../utils");
+const utils_2 = require("@graphql-tools/utils");
+const RULE_ID = 'require-description';
+const ALLOWED_KINDS = [
+    ...utils_1.TYPES_KINDS,
+    graphql_1.Kind.DIRECTIVE_DEFINITION,
+    graphql_1.Kind.FIELD_DEFINITION,
+    graphql_1.Kind.INPUT_VALUE_DEFINITION,
+    graphql_1.Kind.ENUM_VALUE_DEFINITION,
+    graphql_1.Kind.OPERATION_DEFINITION,
+];
+function getNodeName(node) {
+    const DisplayNodeNameMap = {
+        [graphql_1.Kind.OBJECT_TYPE_DEFINITION]: 'type',
+        [graphql_1.Kind.INTERFACE_TYPE_DEFINITION]: 'interface',
+        [graphql_1.Kind.ENUM_TYPE_DEFINITION]: 'enum',
+        [graphql_1.Kind.SCALAR_TYPE_DEFINITION]: 'scalar',
+        [graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION]: 'input',
+        [graphql_1.Kind.UNION_TYPE_DEFINITION]: 'union',
+        [graphql_1.Kind.DIRECTIVE_DEFINITION]: 'directive',
+    };
+    switch (node.kind) {
+        case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+        case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+        case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+        case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+        case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+        case graphql_1.Kind.UNION_TYPE_DEFINITION:
+            return `${DisplayNodeNameMap[node.kind]} ${node.name.value}`;
+        case graphql_1.Kind.DIRECTIVE_DEFINITION:
+            return `${DisplayNodeNameMap[node.kind]} @${node.name.value}`;
+        case graphql_1.Kind.FIELD_DEFINITION:
+        case graphql_1.Kind.INPUT_VALUE_DEFINITION:
+        case graphql_1.Kind.ENUM_VALUE_DEFINITION:
+            return `${node.parent.name.value}.${node.name.value}`;
+        case graphql_1.Kind.OPERATION_DEFINITION:
+            return node.name ? `${node.operation} ${node.name.value}` : node.operation;
+    }
+}
+const schema = {
+    type: 'array',
+    minItems: 1,
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        minProperties: 1,
+        properties: {
+            types: {
+                type: 'boolean',
+                description: `Includes:\n${utils_1.TYPES_KINDS.map(kind => `- \`${kind}\``).join('\n')}`,
+            },
+            rootField: {
+                type: 'boolean',
+                description: 'Definitions within `Query`, `Mutation`, and `Subscription` root types.',
+            },
+            ...Object.fromEntries([...ALLOWED_KINDS].sort().map(kind => {
+                let description = `Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#${kind}).`;
+                if (kind === graphql_1.Kind.OPERATION_DEFINITION) {
+                    description +=
+                        '\n> You must use only comment syntax `#` and not description syntax `"""` or `"`.';
+                }
+                return [kind, { type: 'boolean', description }];
+            })),
+        },
+    },
+};
+exports.rule = {
+    meta: {
+        docs: {
+            category: 'Schema',
+            description: 'Enforce descriptions in type definitions and operations.',
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    usage: [{ types: true, FieldDefinition: true }],
+                    code: /* GraphQL */ `
+            type someTypeName {
+              name: String
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ types: true, FieldDefinition: true }],
+                    code: /* GraphQL */ `
+            """
+            Some type description
+            """
+            type someTypeName {
+              """
+              Name description
+              """
+              name: String
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ OperationDefinition: true }],
+                    code: /* GraphQL */ `
+            # Create a new user
+            mutation createUser {
+              # ...
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ rootField: true }],
+                    code: /* GraphQL */ `
+            type Mutation {
+              "Create a new user"
+              createUser: User
+            }
+
+            type User {
+              name: String
+            }
+          `,
+                },
+            ],
+            configOptions: [
+                {
+                    types: true,
+                    [graphql_1.Kind.DIRECTIVE_DEFINITION]: true,
+                    // rootField: true TODO enable in graphql-eslint v4
+                },
+            ],
+            recommended: true,
+        },
+        type: 'suggestion',
+        messages: {
+            [RULE_ID]: 'Description is required for `{{ nodeName }}`.',
+        },
+        schema,
+    },
+    create(context) {
+        const { types, rootField, ...restOptions } = context.options[0] || {};
+        const kinds = new Set(types ? utils_1.TYPES_KINDS : []);
+        for (const [kind, isEnabled] of Object.entries(restOptions)) {
+            if (isEnabled) {
+                kinds.add(kind);
+            }
+            else {
+                kinds.delete(kind);
+            }
+        }
+        if (rootField) {
+            const schema = (0, utils_1.requireGraphQLSchemaFromContext)(RULE_ID, context);
+            const rootTypeNames = (0, utils_2.getRootTypeNames)(schema);
+            kinds.add(`:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/^(${[
+                ...rootTypeNames,
+            ].join(',')})$/] > FieldDefinition`);
+        }
+        const selector = [...kinds].join(',');
+        return {
+            [selector](node) {
+                var _a;
+                let description = '';
+                const isOperation = node.kind === graphql_1.Kind.OPERATION_DEFINITION;
+                if (isOperation) {
+                    const rawNode = node.rawNode();
+                    const { prev, line } = rawNode.loc.startToken;
+                    if (prev.kind === graphql_1.TokenKind.COMMENT) {
+                        const value = prev.value.trim();
+                        const linesBefore = line - prev.line;
+                        if (!value.startsWith('eslint') && linesBefore === 1) {
+                            description = value;
+                        }
+                    }
+                }
+                else {
+                    description = ((_a = node.description) === null || _a === void 0 ? void 0 : _a.value.trim()) || '';
+                }
+                if (description.length === 0) {
+                    context.report({
+                        loc: isOperation ? (0, utils_1.getLocation)(node.loc.start, node.operation) : node.name.loc,
+                        messageId: RULE_ID,
+                        data: {
+                            nodeName: getNodeName(node),
+                        },
+                    });
+                }
+            },
+        };
+    },
+};

package/cjs/rules/require-field-of-type-query-in-mutation-result.js

@@ -0,0 +1,72 @@
+"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 = 'require-field-of-type-query-in-mutation-result';
+exports.rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            category: 'Schema',
+            description: 'Allow the client in one round-trip not only to call mutation but also to get a wagon of data to update their application.\n> Currently, no errors are reported for result type `union`, `interface` and `scalar`.',
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            requiresSchema: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type User { ... }
+
+            type Mutation {
+              createUser: User!
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            type User { ... }
+
+            type Query { ... }
+
+            type CreateUserPayload {
+              user: User!
+              query: Query!
+            }
+
+            type Mutation {
+              createUser: CreateUserPayload!
+            }
+          `,
+                },
+            ],
+        },
+        schema: [],
+    },
+    create(context) {
+        const schema = (0, utils_1.requireGraphQLSchemaFromContext)(RULE_ID, context);
+        const mutationType = schema.getMutationType();
+        const queryType = schema.getQueryType();
+        if (!mutationType || !queryType) {
+            return {};
+        }
+        const selector = `:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=${mutationType.name}] > FieldDefinition > .gqlType Name`;
+        return {
+            [selector](node) {
+                const typeName = node.value;
+                const graphQLType = schema.getType(typeName);
+                if ((0, graphql_1.isObjectType)(graphQLType)) {
+                    const { fields } = graphQLType.astNode;
+                    const hasQueryType = fields.some(field => (0, utils_1.getTypeName)(field) === queryType.name);
+                    if (!hasQueryType) {
+                        context.report({
+                            node,
+                            message: `Mutation result type "${graphQLType.name}" must contain field of type "${queryType.name}"`,
+                        });
+                    }
+                }
+            },
+        };
+    },
+};

package/cjs/rules/require-id-when-available.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const utils_2 = require("../utils");
+const estree_converter_1 = require("../estree-converter");
+const RULE_ID = 'require-id-when-available';
+const DEFAULT_ID_FIELD_NAME = 'id';
+const schema = {
+    definitions: {
+        asString: {
+            type: 'string',
+        },
+        asArray: utils_2.ARRAY_DEFAULT_OPTIONS,
+    },
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            fieldName: {
+                oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asArray' }],
+                default: DEFAULT_ID_FIELD_NAME,
+            },
+        },
+    },
+};
+exports.rule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            category: 'Operations',
+            description: 'Enforce selecting specific fields when they are available on the GraphQL type.',
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            requiresSchema: true,
+            requiresSiblings: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            # In your schema
+            type User {
+              id: ID!
+              name: String!
+            }
+
+            # Query
+            query {
+              user {
+                name
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            # In your schema
+            type User {
+              id: ID!
+              name: String!
+            }
+
+            # Query
+            query {
+              user {
+                id
+                name
+              }
+            }
+
+            # Selecting \`id\` with an alias is also valid
+            query {
+              user {
+                id: name
+              }
+            }
+          `,
+                },
+            ],
+            recommended: true,
+        },
+        messages: {
+            [RULE_ID]: "Field{{ pluralSuffix }} {{ fieldName }} must be selected when it's available on a type.\nInclude it in your selection set{{ addition }}.",
+        },
+        schema,
+    },
+    create(context) {
+        const schema = (0, utils_2.requireGraphQLSchemaFromContext)(RULE_ID, context);
+        const siblings = (0, utils_2.requireSiblingsOperations)(RULE_ID, context);
+        const { fieldName = DEFAULT_ID_FIELD_NAME } = context.options[0] || {};
+        const idNames = (0, utils_1.asArray)(fieldName);
+        // Check selections only in OperationDefinition,
+        // skip selections of OperationDefinition and InlineFragment
+        const selector = 'OperationDefinition SelectionSet[parent.kind!=/(^OperationDefinition|InlineFragment)$/]';
+        const typeInfo = new graphql_1.TypeInfo(schema);
+        function checkFragments(node) {
+            for (const selection of node.selections) {
+                if (selection.kind !== graphql_1.Kind.FRAGMENT_SPREAD) {
+                    continue;
+                }
+                const [foundSpread] = siblings.getFragment(selection.name.value);
+                if (!foundSpread) {
+                    continue;
+                }
+                const checkedFragmentSpreads = new Set();
+                const visitor = (0, graphql_1.visitWithTypeInfo)(typeInfo, {
+                    SelectionSet(node, key, parent) {
+                        if (parent.kind === graphql_1.Kind.FRAGMENT_DEFINITION) {
+                            checkedFragmentSpreads.add(parent.name.value);
+                        }
+                        else if (parent.kind !== graphql_1.Kind.INLINE_FRAGMENT) {
+                            checkSelections(node, typeInfo.getType(), selection.loc.start, parent, checkedFragmentSpreads);
+                        }
+                    },
+                });
+                (0, graphql_1.visit)(foundSpread.document, visitor);
+            }
+        }
+        function checkSelections(node, type, 
+        // Fragment can be placed in separate file
+        // Provide actual fragment spread location instead of location in fragment
+        loc, 
+        // Can't access to node.parent in GraphQL AST.Node, so pass as argument
+        parent, checkedFragmentSpreads = new Set()) {
+            const rawType = (0, estree_converter_1.getBaseType)(type);
+            const isObjectType = rawType instanceof graphql_1.GraphQLObjectType;
+            const isInterfaceType = rawType instanceof graphql_1.GraphQLInterfaceType;
+            if (!isObjectType && !isInterfaceType) {
+                return;
+            }
+            const fields = rawType.getFields();
+            const hasIdFieldInType = idNames.some(name => fields[name]);
+            if (!hasIdFieldInType) {
+                return;
+            }
+            function hasIdField({ selections }) {
+                return selections.some(selection => {
+                    if (selection.kind === graphql_1.Kind.FIELD) {
+                        if (selection.alias && idNames.includes(selection.alias.value)) {
+                            return true;
+                        }
+                        return idNames.includes(selection.name.value);
+                    }
+                    if (selection.kind === graphql_1.Kind.INLINE_FRAGMENT) {
+                        return hasIdField(selection.selectionSet);
+                    }
+                    if (selection.kind === graphql_1.Kind.FRAGMENT_SPREAD) {
+                        const [foundSpread] = siblings.getFragment(selection.name.value);
+                        if (foundSpread) {
+                            const fragmentSpread = foundSpread.document;
+                            checkedFragmentSpreads.add(fragmentSpread.name.value);
+                            return hasIdField(fragmentSpread.selectionSet);
+                        }
+                    }
+                    return false;
+                });
+            }
+            const hasId = hasIdField(node);
+            checkFragments(node);
+            if (hasId) {
+                return;
+            }
+            const pluralSuffix = idNames.length > 1 ? 's' : '';
+            const fieldName = (0, utils_2.englishJoinWords)(idNames.map(name => `\`${(parent.alias || parent.name).value}.${name}\``));
+            const addition = checkedFragmentSpreads.size === 0
+                ? ''
+                : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? 's' : ''} ${(0, utils_2.englishJoinWords)([...checkedFragmentSpreads].map(name => `\`${name}\``))}`;
+            const problem = {
+                loc,
+                messageId: RULE_ID,
+                data: {
+                    pluralSuffix,
+                    fieldName,
+                    addition,
+                },
+            };
+            // Don't provide suggestions for selections in fragments as fragment can be in a separate file
+            if ('type' in node) {
+                problem.suggest = idNames.map(idName => ({
+                    desc: `Add \`${idName}\` selection`,
+                    fix: fixer => fixer.insertTextBefore(node.selections[0], `${idName} `),
+                }));
+            }
+            context.report(problem);
+        }
+        return {
+            [selector](node) {
+                const typeInfo = node.typeInfo();
+                if (typeInfo.gqlType) {
+                    checkSelections(node, typeInfo.gqlType, node.loc.start, node.parent);
+                }
+            },
+        };
+    },
+};

package/cjs/rules/selection-set-depth.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const tslib_1 = require("tslib");
+const graphql_depth_limit_1 = tslib_1.__importDefault(require("graphql-depth-limit"));
+const graphql_1 = require("graphql");
+const utils_1 = require("../utils");
+const RULE_ID = 'selection-set-depth';
+const schema = {
+    type: 'array',
+    minItems: 1,
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['maxDepth'],
+        properties: {
+            maxDepth: {
+                type: 'number',
+            },
+            ignore: utils_1.ARRAY_DEFAULT_OPTIONS,
+        },
+    },
+};
+exports.rule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            category: 'Operations',
+            description: 'Limit the complexity of the GraphQL operations solely by their depth. Based on [graphql-depth-limit](https://npmjs.com/package/graphql-depth-limit).',
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            requiresSiblings: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    usage: [{ maxDepth: 1 }],
+                    code: `
+            query deep2 {
+              viewer { # Level 0
+                albums { # Level 1
+                  title # Level 2
+                }
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ maxDepth: 4 }],
+                    code: `
+            query deep2 {
+              viewer { # Level 0
+                albums { # Level 1
+                  title # Level 2
+                }
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Correct (ignored field)',
+                    usage: [{ maxDepth: 1, ignore: ['albums'] }],
+                    code: `
+            query deep2 {
+              viewer { # Level 0
+                albums { # Level 1
+                  title # Level 2
+                }
+              }
+            }
+          `,
+                },
+            ],
+            recommended: true,
+            configOptions: [{ maxDepth: 7 }],
+        },
+        schema,
+    },
+    create(context) {
+        let siblings = null;
+        try {
+            siblings = (0, utils_1.requireSiblingsOperations)(RULE_ID, context);
+        }
+        catch (_a) {
+            utils_1.logger.warn(`Rule "${RULE_ID}" works best with siblings operations loaded. For more info: https://bit.ly/graphql-eslint-operations`);
+        }
+        const { maxDepth, ignore = [] } = context.options[0];
+        const checkFn = (0, graphql_depth_limit_1.default)(maxDepth, { ignore });
+        return {
+            'OperationDefinition, FragmentDefinition'(node) {
+                try {
+                    const rawNode = node.rawNode();
+                    const fragmentsInUse = siblings ? siblings.getFragmentsInUse(rawNode) : [];
+                    const document = {
+                        kind: graphql_1.Kind.DOCUMENT,
+                        definitions: [rawNode, ...fragmentsInUse],
+                    };
+                    checkFn({
+                        getDocument: () => document,
+                        reportError(error) {
+                            const { line, column } = error.locations[0];
+                            const ancestors = context.getAncestors();
+                            const token = ancestors[0].tokens.find(token => token.loc.start.line === line && token.loc.start.column === column - 1);
+                            context.report({
+                                loc: {
+                                    line,
+                                    column: column - 1,
+                                },
+                                message: error.message,
+                                // Don't provide suggestions for fragment that can be in a separate file
+                                ...(token && {
+                                    suggest: [
+                                        {
+                                            desc: 'Remove selections',
+                                            fix(fixer) {
+                                                const sourceCode = context.getSourceCode();
+                                                const foundNode = sourceCode.getNodeByRangeIndex(token.range[0]);
+                                                const parentNode = foundNode.parent.parent;
+                                                return fixer.remove(foundNode.kind === 'Name' ? parentNode.parent : parentNode);
+                                            },
+                                        },
+                                    ],
+                                }),
+                            });
+                        },
+                    });
+                }
+                catch (e) {
+                    utils_1.logger.warn(`Rule "${RULE_ID}" check failed due to a missing siblings operations. For more info: https://bit.ly/graphql-eslint-operations`, e);
+                }
+            },
+        };
+    },
+};