@graphql-eslint/eslint-plugin 3.14.0-alpha-20221222211346-788e7eb → 3.14.0-alpha-20221223011223-bd3e820

package/esm/rules/naming-convention.js

@@ -0,0 +1,307 @@
+import { Kind } from 'graphql';
+import { TYPES_KINDS, convertCase, ARRAY_DEFAULT_OPTIONS } from '../utils.js';
+const KindToDisplayName = {
+    // types
+    [Kind.OBJECT_TYPE_DEFINITION]: 'Type',
+    [Kind.INTERFACE_TYPE_DEFINITION]: 'Interface',
+    [Kind.ENUM_TYPE_DEFINITION]: 'Enumerator',
+    [Kind.SCALAR_TYPE_DEFINITION]: 'Scalar',
+    [Kind.INPUT_OBJECT_TYPE_DEFINITION]: 'Input type',
+    [Kind.UNION_TYPE_DEFINITION]: 'Union',
+    // fields
+    [Kind.FIELD_DEFINITION]: 'Field',
+    [Kind.INPUT_VALUE_DEFINITION]: 'Input property',
+    [Kind.ARGUMENT]: 'Argument',
+    [Kind.DIRECTIVE_DEFINITION]: 'Directive',
+    // rest
+    [Kind.ENUM_VALUE_DEFINITION]: 'Enumeration value',
+    [Kind.OPERATION_DEFINITION]: 'Operation',
+    [Kind.FRAGMENT_DEFINITION]: 'Fragment',
+    [Kind.VARIABLE_DEFINITION]: 'Variable',
+};
+const StyleToRegex = {
+    camelCase: /^[a-z][\dA-Za-z]*$/,
+    PascalCase: /^[A-Z][\dA-Za-z]*$/,
+    snake_case: /^[a-z][\d_a-z]*[\da-z]*$/,
+    UPPER_CASE: /^[A-Z][\dA-Z_]*[\dA-Z]*$/,
+};
+const ALLOWED_KINDS = Object.keys(KindToDisplayName).sort();
+const ALLOWED_STYLES = Object.keys(StyleToRegex);
+const schemaOption = {
+    oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
+};
+const schema = {
+    definitions: {
+        asString: {
+            enum: ALLOWED_STYLES,
+            description: `One of: ${ALLOWED_STYLES.map(t => `\`${t}\``).join(', ')}`,
+        },
+        asObject: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                style: { enum: ALLOWED_STYLES },
+                prefix: { type: 'string' },
+                suffix: { type: 'string' },
+                forbiddenPrefixes: ARRAY_DEFAULT_OPTIONS,
+                forbiddenSuffixes: ARRAY_DEFAULT_OPTIONS,
+                ignorePattern: {
+                    type: 'string',
+                    description: 'Option to skip validation of some words, e.g. acronyms',
+                },
+            },
+        },
+    },
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            types: {
+                ...schemaOption,
+                description: `Includes:\n${TYPES_KINDS.map(kind => `- \`${kind}\``).join('\n')}`,
+            },
+            ...Object.fromEntries(ALLOWED_KINDS.map(kind => [
+                kind,
+                {
+                    ...schemaOption,
+                    description: `Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#${kind}).`,
+                },
+            ])),
+            allowLeadingUnderscore: {
+                type: 'boolean',
+                default: false,
+            },
+            allowTrailingUnderscore: {
+                type: 'boolean',
+                default: false,
+            },
+        },
+        patternProperties: {
+            [`^(${ALLOWED_KINDS.join('|')})(.+)?$`]: schemaOption,
+        },
+        description: [
+            "> It's possible to use a [`selector`](https://eslint.org/docs/developer-guide/selectors) that starts with allowed `ASTNode` names which are described below.",
+            '>',
+            '> Paste or drop code into the editor in [ASTExplorer](https://astexplorer.net) and inspect the generated AST to compose your selector.',
+            '>',
+            '> Example: pattern property `FieldDefinition[parent.name.value=Query]` will match only fields for type `Query`.',
+        ].join('\n'),
+    },
+};
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Require names to follow specified conventions.',
+            category: ['Schema', 'Operations'],
+            recommended: true,
+            url: 'https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/naming-convention.md',
+            examples: [
+                {
+                    title: 'Incorrect',
+                    usage: [{ types: 'PascalCase', FieldDefinition: 'camelCase' }],
+                    code: /* GraphQL */ `
+            type user {
+              first_name: String!
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    usage: [{ FragmentDefinition: { style: 'PascalCase', forbiddenSuffixes: ['Fragment'] } }],
+                    code: /* GraphQL */ `
+            fragment UserFragment on User {
+              # ...
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    usage: [{ 'FieldDefinition[parent.name.value=Query]': { forbiddenPrefixes: ['get'] } }],
+                    code: /* GraphQL */ `
+            type Query {
+              getUsers: [User!]!
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ types: 'PascalCase', FieldDefinition: 'camelCase' }],
+                    code: /* GraphQL */ `
+            type User {
+              firstName: String
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ FragmentDefinition: { style: 'PascalCase', forbiddenSuffixes: ['Fragment'] } }],
+                    code: /* GraphQL */ `
+            fragment UserFields on User {
+              # ...
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ 'FieldDefinition[parent.name.value=Query]': { forbiddenPrefixes: ['get'] } }],
+                    code: /* GraphQL */ `
+            type Query {
+              users: [User!]!
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ FieldDefinition: { style: 'camelCase', ignorePattern: '^(EAN13|UPC|UK)' } }],
+                    code: /* GraphQL */ `
+            type Product {
+              EAN13: String
+              UPC: String
+              UKFlag: String
+            }
+          `,
+                },
+            ],
+            configOptions: {
+                schema: [
+                    {
+                        types: 'PascalCase',
+                        FieldDefinition: 'camelCase',
+                        InputValueDefinition: 'camelCase',
+                        Argument: 'camelCase',
+                        DirectiveDefinition: 'camelCase',
+                        EnumValueDefinition: 'UPPER_CASE',
+                        'FieldDefinition[parent.name.value=Query]': {
+                            forbiddenPrefixes: ['query', 'get'],
+                            forbiddenSuffixes: ['Query'],
+                        },
+                        'FieldDefinition[parent.name.value=Mutation]': {
+                            forbiddenPrefixes: ['mutation'],
+                            forbiddenSuffixes: ['Mutation'],
+                        },
+                        'FieldDefinition[parent.name.value=Subscription]': {
+                            forbiddenPrefixes: ['subscription'],
+                            forbiddenSuffixes: ['Subscription'],
+                        },
+                    },
+                ],
+                operations: [
+                    {
+                        VariableDefinition: 'camelCase',
+                        OperationDefinition: {
+                            style: 'PascalCase',
+                            forbiddenPrefixes: ['Query', 'Mutation', 'Subscription', 'Get'],
+                            forbiddenSuffixes: ['Query', 'Mutation', 'Subscription'],
+                        },
+                        FragmentDefinition: {
+                            style: 'PascalCase',
+                            forbiddenPrefixes: ['Fragment'],
+                            forbiddenSuffixes: ['Fragment'],
+                        },
+                    },
+                ],
+            },
+        },
+        hasSuggestions: true,
+        schema,
+    },
+    create(context) {
+        const options = context.options[0] || {};
+        const { allowLeadingUnderscore, allowTrailingUnderscore, types, ...restOptions } = options;
+        function normalisePropertyOption(kind) {
+            const style = restOptions[kind] || types;
+            return typeof style === 'object' ? style : { style };
+        }
+        function report(node, message, suggestedName) {
+            context.report({
+                node,
+                message,
+                suggest: [
+                    {
+                        desc: `Rename to \`${suggestedName}\``,
+                        fix: fixer => fixer.replaceText(node, suggestedName),
+                    },
+                ],
+            });
+        }
+        const checkNode = (selector) => (n) => {
+            const { name: node } = n.kind === Kind.VARIABLE_DEFINITION ? n.variable : n;
+            if (!node) {
+                return;
+            }
+            const { prefix, suffix, forbiddenPrefixes, forbiddenSuffixes, style, ignorePattern } = normalisePropertyOption(selector);
+            const nodeType = KindToDisplayName[n.kind] || n.kind;
+            const nodeName = node.value;
+            const error = getError();
+            if (error) {
+                const { errorMessage, renameToName } = error;
+                const [leadingUnderscores] = nodeName.match(/^_*/);
+                const [trailingUnderscores] = nodeName.match(/_*$/);
+                const suggestedName = leadingUnderscores + renameToName + trailingUnderscores;
+                report(node, `${nodeType} "${nodeName}" should ${errorMessage}`, suggestedName);
+            }
+            function getError() {
+                const name = nodeName.replace(/(^_+)|(_+$)/g, '');
+                if (ignorePattern && new RegExp(ignorePattern, 'u').test(name)) {
+                    return;
+                }
+                if (prefix && !name.startsWith(prefix)) {
+                    return {
+                        errorMessage: `have "${prefix}" prefix`,
+                        renameToName: prefix + name,
+                    };
+                }
+                if (suffix && !name.endsWith(suffix)) {
+                    return {
+                        errorMessage: `have "${suffix}" suffix`,
+                        renameToName: name + suffix,
+                    };
+                }
+                const forbiddenPrefix = forbiddenPrefixes === null || forbiddenPrefixes === void 0 ? void 0 : forbiddenPrefixes.find(prefix => name.startsWith(prefix));
+                if (forbiddenPrefix) {
+                    return {
+                        errorMessage: `not have "${forbiddenPrefix}" prefix`,
+                        renameToName: name.replace(new RegExp(`^${forbiddenPrefix}`), ''),
+                    };
+                }
+                const forbiddenSuffix = forbiddenSuffixes === null || forbiddenSuffixes === void 0 ? void 0 : forbiddenSuffixes.find(suffix => name.endsWith(suffix));
+                if (forbiddenSuffix) {
+                    return {
+                        errorMessage: `not have "${forbiddenSuffix}" suffix`,
+                        renameToName: name.replace(new RegExp(`${forbiddenSuffix}$`), ''),
+                    };
+                }
+                // Style is optional
+                if (!style) {
+                    return;
+                }
+                const caseRegex = StyleToRegex[style];
+                if (!caseRegex.test(name)) {
+                    return {
+                        errorMessage: `be in ${style} format`,
+                        renameToName: convertCase(style, name),
+                    };
+                }
+            }
+        };
+        const checkUnderscore = (isLeading) => (node) => {
+            const suggestedName = node.value.replace(isLeading ? /^_+/ : /_+$/, '');
+            report(node, `${isLeading ? 'Leading' : 'Trailing'} underscores are not allowed`, suggestedName);
+        };
+        const listeners = {};
+        if (!allowLeadingUnderscore) {
+            listeners['Name[value=/^_/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] = checkUnderscore(true);
+        }
+        if (!allowTrailingUnderscore) {
+            listeners['Name[value=/_$/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] = checkUnderscore(false);
+        }
+        const selectors = new Set([types && TYPES_KINDS, Object.keys(restOptions)].flat().filter(Boolean));
+        for (const selector of selectors) {
+            listeners[selector] = checkNode(selector);
+        }
+        return listeners;
+    },
+};

package/esm/rules/no-anonymous-operations.js

@@ -0,0 +1,64 @@
+import { Kind } from 'graphql';
+import { getLocation } from '../utils.js';
+const RULE_ID = 'no-anonymous-operations';
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            category: 'Operations',
+            description: 'Require name for your GraphQL operations. This is useful since most GraphQL client libraries are using the operation name for caching purposes.',
+            recommended: true,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            query {
+              # ...
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            query user {
+              # ...
+            }
+          `,
+                },
+            ],
+        },
+        messages: {
+            [RULE_ID]: 'Anonymous GraphQL operations are forbidden. Make sure to name your {{ operation }}!',
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            'OperationDefinition[name=undefined]'(node) {
+                const [firstSelection] = node.selectionSet.selections;
+                const suggestedName = firstSelection.kind === Kind.FIELD
+                    ? (firstSelection.alias || firstSelection.name).value
+                    : node.operation;
+                context.report({
+                    loc: getLocation(node.loc.start, node.operation),
+                    messageId: RULE_ID,
+                    data: {
+                        operation: node.operation,
+                    },
+                    suggest: [
+                        {
+                            desc: `Rename to \`${suggestedName}\``,
+                            fix(fixer) {
+                                const sourceCode = context.getSourceCode();
+                                const hasQueryKeyword = sourceCode.getText({ range: [node.range[0], node.range[0] + 1] }) !== '{';
+                                return fixer.insertTextAfterRange([node.range[0], node.range[0] + (hasQueryKeyword ? node.operation.length : 0)], `${hasQueryKeyword ? '' : 'query'} ${suggestedName}${hasQueryKeyword ? '' : ' '}`);
+                            },
+                        },
+                    ],
+                });
+            },
+        };
+    },
+};

package/esm/rules/no-case-insensitive-enum-values-duplicates.js

@@ -0,0 +1,58 @@
+import { Kind } from 'graphql';
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            url: 'https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/no-case-insensitive-enum-values-duplicates.md',
+            category: 'Schema',
+            recommended: true,
+            description: 'Disallow case-insensitive enum values duplicates.',
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            enum MyEnum {
+              Value
+              VALUE
+              ValuE
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            enum MyEnum {
+              Value1
+              Value2
+              Value3
+            }
+          `,
+                },
+            ],
+        },
+        schema: [],
+    },
+    create(context) {
+        const selector = [Kind.ENUM_TYPE_DEFINITION, Kind.ENUM_TYPE_EXTENSION].join(',');
+        return {
+            [selector](node) {
+                const duplicates = node.values.filter((item, index, array) => array.findIndex(v => v.name.value.toLowerCase() === item.name.value.toLowerCase()) !==
+                    index);
+                for (const duplicate of duplicates) {
+                    const enumName = duplicate.name.value;
+                    context.report({
+                        node: duplicate.name,
+                        message: `Case-insensitive enum values duplicates are not allowed! Found: \`${enumName}\`.`,
+                        suggest: [
+                            {
+                                desc: `Remove \`${enumName}\` enum value`,
+                                fix: fixer => fixer.remove(duplicate),
+                            },
+                        ],
+                    });
+                }
+            },
+        };
+    },
+};

package/esm/rules/no-deprecated.js

@@ -0,0 +1,121 @@
+import { Kind } from 'graphql';
+import { requireGraphQLSchemaFromContext } from '../utils.js';
+const RULE_ID = 'no-deprecated';
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            category: 'Operations',
+            description: 'Enforce that deprecated fields or enum values are not in use by operations.',
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            requiresSchema: true,
+            examples: [
+                {
+                    title: 'Incorrect (field)',
+                    code: /* GraphQL */ `
+            # In your schema
+            type User {
+              id: ID!
+              name: String! @deprecated(reason: "old field, please use fullName instead")
+              fullName: String!
+            }
+
+            # Query
+            query user {
+              user {
+                name # This is deprecated, so you'll get an error
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect (enum value)',
+                    code: /* GraphQL */ `
+            # In your schema
+            type Mutation {
+              changeSomething(type: SomeType): Boolean!
+            }
+
+            enum SomeType {
+              NEW
+              OLD @deprecated(reason: "old field, please use NEW instead")
+            }
+
+            # Mutation
+            mutation {
+              changeSomething(
+                type: OLD # This is deprecated, so you'll get an error
+              ) {
+                ...
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            # In your schema
+            type User {
+              id: ID!
+              name: String! @deprecated(reason: "old field, please use fullName instead")
+              fullName: String!
+            }
+
+            # Query
+            query user {
+              user {
+                id
+                fullName
+              }
+            }
+          `,
+                },
+            ],
+            recommended: true,
+        },
+        messages: {
+            [RULE_ID]: 'This {{ type }} is marked as deprecated in your GraphQL schema (reason: {{ reason }})',
+        },
+        schema: [],
+    },
+    create(context) {
+        requireGraphQLSchemaFromContext(RULE_ID, context);
+        function report(node, reason) {
+            const nodeName = node.kind === Kind.ENUM ? node.value : node.name.value;
+            const nodeType = node.kind === Kind.ENUM ? 'enum value' : 'field';
+            context.report({
+                node,
+                messageId: RULE_ID,
+                data: {
+                    type: nodeType,
+                    reason,
+                },
+                suggest: [
+                    {
+                        desc: `Remove \`${nodeName}\` ${nodeType}`,
+                        fix: fixer => fixer.remove(node),
+                    },
+                ],
+            });
+        }
+        return {
+            EnumValue(node) {
+                var _a;
+                const typeInfo = node.typeInfo();
+                const reason = (_a = typeInfo.enumValue) === null || _a === void 0 ? void 0 : _a.deprecationReason;
+                if (reason) {
+                    report(node, reason);
+                }
+            },
+            Field(node) {
+                var _a;
+                const typeInfo = node.typeInfo();
+                const reason = (_a = typeInfo.fieldDef) === null || _a === void 0 ? void 0 : _a.deprecationReason;
+                if (reason) {
+                    report(node, reason);
+                }
+            },
+        };
+    },
+};

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

@@ -0,0 +1,109 @@
+import { Kind } from 'graphql';
+const RULE_ID = 'no-duplicate-fields';
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            description: 'Checks for duplicate fields in selection set, variables in operation definition, or in arguments set of a field.',
+            category: 'Operations',
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            recommended: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            query {
+              user {
+                name
+                email
+                name # duplicate field
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            query {
+              users(
+                first: 100
+                skip: 50
+                after: "cji629tngfgou0b73kt7vi5jo"
+                first: 100 # duplicate argument
+              ) {
+                id
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            query (
+              $first: Int!
+              $first: Int! # duplicate variable
+            ) {
+              users(first: $first, skip: 50) {
+                id
+              }
+            }
+          `,
+                },
+            ],
+        },
+        messages: {
+            [RULE_ID]: '{{ type }} `{{ fieldName }}` defined multiple times.',
+        },
+        schema: [],
+    },
+    create(context) {
+        function checkNode(usedFields, node) {
+            const fieldName = node.value;
+            if (usedFields.has(fieldName)) {
+                const { parent } = node;
+                context.report({
+                    node,
+                    messageId: RULE_ID,
+                    data: {
+                        type: parent.type,
+                        fieldName,
+                    },
+                    suggest: [
+                        {
+                            desc: `Remove \`${fieldName}\` ${parent.type.toLowerCase()}`,
+                            fix(fixer) {
+                                return fixer.remove((parent.type === Kind.VARIABLE ? parent.parent : parent));
+                            },
+                        },
+                    ],
+                });
+            }
+            else {
+                usedFields.add(fieldName);
+            }
+        }
+        return {
+            OperationDefinition(node) {
+                const set = new Set();
+                for (const varDef of node.variableDefinitions) {
+                    checkNode(set, varDef.variable.name);
+                }
+            },
+            Field(node) {
+                const set = new Set();
+                for (const arg of node.arguments) {
+                    checkNode(set, arg.name);
+                }
+            },
+            SelectionSet(node) {
+                const set = new Set();
+                for (const selection of node.selections) {
+                    if (selection.kind === Kind.FIELD) {
+                        checkNode(set, selection.alias || selection.name);
+                    }
+                }
+            },
+        };
+    },
+};