@graphql-eslint/eslint-plugin 3.14.0-alpha-20221222211539-5e993f5 → 3.14.0-alpha-20221223011223-bd3e820

package/esm/rules/input-name.js

@@ -0,0 +1,133 @@
+import { Kind, } from 'graphql';
+const schema = {
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            checkInputType: {
+                type: 'boolean',
+                default: false,
+                description: 'Check that the input type name follows the convention <mutationName>Input',
+            },
+            caseSensitiveInputType: {
+                type: 'boolean',
+                default: true,
+                description: 'Allow for case discrepancies in the input type name',
+            },
+            checkQueries: {
+                type: 'boolean',
+                default: false,
+                description: 'Apply the rule to Queries',
+            },
+            checkMutations: {
+                type: 'boolean',
+                default: true,
+                description: 'Apply the rule to Mutations',
+            },
+        },
+    },
+};
+const isObjectType = (node) => [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION].includes(node.type);
+const isQueryType = (node) => isObjectType(node) && node.name.value === 'Query';
+const isMutationType = (node) => isObjectType(node) && node.name.value === 'Mutation';
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            description: 'Require mutation argument to be always called "input" and input type to be called Mutation name + "Input".\nUsing the same name for all input parameters will make your schemas easier to consume and more predictable. Using the same name as mutation for InputType will make it easier to find mutations that InputType belongs to.',
+            category: 'Schema',
+            url: 'https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/input-name.md',
+            examples: [
+                {
+                    title: 'Incorrect',
+                    usage: [{ checkInputType: true }],
+                    code: /* GraphQL */ `
+            type Mutation {
+              SetMessage(message: InputMessage): String
+            }
+          `,
+                },
+                {
+                    title: 'Correct (with checkInputType)',
+                    usage: [{ checkInputType: true }],
+                    code: /* GraphQL */ `
+            type Mutation {
+              SetMessage(input: SetMessageInput): String
+            }
+          `,
+                },
+                {
+                    title: 'Correct (without checkInputType)',
+                    usage: [{ checkInputType: false }],
+                    code: /* GraphQL */ `
+            type Mutation {
+              SetMessage(input: AnyInputTypeName): String
+            }
+          `,
+                },
+            ],
+        },
+        schema,
+    },
+    create(context) {
+        const options = {
+            checkInputType: false,
+            caseSensitiveInputType: true,
+            checkQueries: false,
+            checkMutations: true,
+            ...context.options[0],
+        };
+        const shouldCheckType = node => (options.checkMutations && isMutationType(node)) ||
+            (options.checkQueries && isQueryType(node));
+        const listeners = {
+            'FieldDefinition > InputValueDefinition[name.value!=input] > Name'(node) {
+                if (shouldCheckType(node.parent.parent.parent)) {
+                    const inputName = node.value;
+                    context.report({
+                        node,
+                        message: `Input \`${inputName}\` should be called \`input\`.`,
+                        suggest: [
+                            {
+                                desc: 'Rename to `input`',
+                                fix: fixer => fixer.replaceText(node, 'input'),
+                            },
+                        ],
+                    });
+                }
+            },
+        };
+        if (options.checkInputType) {
+            listeners['FieldDefinition > InputValueDefinition NamedType'] = (node) => {
+                const findInputType = item => {
+                    let currentNode = item;
+                    while (currentNode.type !== Kind.INPUT_VALUE_DEFINITION) {
+                        currentNode = currentNode.parent;
+                    }
+                    return currentNode;
+                };
+                const inputValueNode = findInputType(node);
+                if (shouldCheckType(inputValueNode.parent.parent)) {
+                    const mutationName = `${inputValueNode.parent.name.value}Input`;
+                    const name = node.name.value;
+                    if ((options.caseSensitiveInputType && node.name.value !== mutationName) ||
+                        name.toLowerCase() !== mutationName.toLowerCase()) {
+                        context.report({
+                            node: node.name,
+                            message: `Input type \`${name}\` name should be \`${mutationName}\`.`,
+                            suggest: [
+                                {
+                                    desc: `Rename to \`${mutationName}\``,
+                                    fix: fixer => fixer.replaceText(node, mutationName),
+                                },
+                            ],
+                        });
+                    }
+                }
+            };
+        }
+        return listeners;
+    },
+};

package/esm/rules/lone-executable-definition.js

@@ -0,0 +1,85 @@
+import { ARRAY_DEFAULT_OPTIONS, pascalCase, getLocation } from '../utils.js';
+const RULE_ID = 'lone-executable-definition';
+const definitionTypes = ['fragment', 'query', 'mutation', 'subscription'];
+const schema = {
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        minProperties: 1,
+        additionalProperties: false,
+        properties: {
+            ignore: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                maxItems: 3,
+                items: {
+                    enum: definitionTypes,
+                },
+                description: 'Allow certain definitions to be placed alongside others.',
+            },
+        },
+    },
+};
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            category: 'Operations',
+            description: 'Require all queries, mutations, subscriptions and fragments to be located in separate files.',
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            query Foo {
+              id
+            }
+            fragment Bar on Baz {
+              id
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            query Foo {
+              id
+            }
+          `,
+                },
+            ],
+        },
+        messages: {
+            [RULE_ID]: '{{name}} should be in a separate file.',
+        },
+        schema,
+    },
+    create(context) {
+        var _a;
+        const ignore = new Set(((_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.ignore) || []);
+        const definitions = [];
+        return {
+            ':matches(OperationDefinition, FragmentDefinition)'(node) {
+                const type = 'operation' in node ? node.operation : 'fragment';
+                if (!ignore.has(type)) {
+                    definitions.push({ type, node });
+                }
+            },
+            'Program:exit'() {
+                var _a, _b;
+                for (const { node, type } of definitions.slice(1) /* ignore first definition */) {
+                    let name = pascalCase(type);
+                    const definitionName = (_a = node.name) === null || _a === void 0 ? void 0 : _a.value;
+                    if (definitionName) {
+                        name += ` "${definitionName}"`;
+                    }
+                    context.report({
+                        loc: ((_b = node.name) === null || _b === void 0 ? void 0 : _b.loc) || getLocation(node.loc.start, type),
+                        messageId: RULE_ID,
+                        data: { name },
+                    });
+                }
+            },
+        };
+    },
+};

package/esm/rules/match-document-filename.js

@@ -0,0 +1,232 @@
+import { basename, extname } from 'path';
+import { existsSync } from 'fs';
+import { Kind } from 'graphql';
+import { convertCase, REPORT_ON_FIRST_CHARACTER } from '../utils.js';
+const MATCH_EXTENSION = 'MATCH_EXTENSION';
+const MATCH_STYLE = 'MATCH_STYLE';
+const CASE_STYLES = [
+    'camelCase',
+    'PascalCase',
+    'snake_case',
+    'UPPER_CASE',
+    'kebab-case',
+    'matchDocumentStyle',
+];
+const schemaOption = {
+    oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
+};
+const schema = {
+    definitions: {
+        asString: {
+            enum: CASE_STYLES,
+            description: `One of: ${CASE_STYLES.map(t => `\`${t}\``).join(', ')}`,
+        },
+        asObject: {
+            type: 'object',
+            additionalProperties: false,
+            minProperties: 1,
+            properties: {
+                style: { enum: CASE_STYLES },
+                suffix: { type: 'string' },
+                prefix: { type: 'string' },
+            },
+        },
+    },
+    type: 'array',
+    minItems: 1,
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        minProperties: 1,
+        properties: {
+            fileExtension: { enum: ['.gql', '.graphql'] },
+            query: schemaOption,
+            mutation: schemaOption,
+            subscription: schemaOption,
+            fragment: schemaOption,
+        },
+    },
+};
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            category: 'Operations',
+            description: 'This rule allows you to enforce that the file name should match the operation name.',
+            url: 'https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/match-document-filename.md',
+            examples: [
+                {
+                    title: 'Correct',
+                    usage: [{ fileExtension: '.gql' }],
+                    code: /* GraphQL */ `
+            # user.gql
+            type User {
+              id: ID!
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ query: 'snake_case' }],
+                    code: /* GraphQL */ `
+            # user_by_id.gql
+            query UserById {
+              userById(id: 5) {
+                id
+                name
+                fullName
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ fragment: { style: 'kebab-case', suffix: '.fragment' } }],
+                    code: /* GraphQL */ `
+            # user-fields.fragment.gql
+            fragment user_fields on User {
+              id
+              email
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ mutation: { style: 'PascalCase', suffix: 'Mutation' } }],
+                    code: /* GraphQL */ `
+            # DeleteUserMutation.gql
+            mutation DELETE_USER {
+              deleteUser(id: 5)
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    usage: [{ fileExtension: '.graphql' }],
+                    code: /* GraphQL */ `
+            # post.gql
+            type Post {
+              id: ID!
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    usage: [{ query: 'PascalCase' }],
+                    code: /* GraphQL */ `
+            # user-by-id.gql
+            query UserById {
+              userById(id: 5) {
+                id
+                name
+                fullName
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ fragment: { style: 'kebab-case', prefix: 'mutation.' } }],
+                    code: /* GraphQL */ `
+            # mutation.add-alert.graphql
+            mutation addAlert {
+              foo
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ fragment: { prefix: 'query.' } }],
+                    code: /* GraphQL */ `
+            # query.me.graphql
+            query me {
+              foo
+            }
+          `,
+                },
+            ],
+            configOptions: [
+                {
+                    query: 'kebab-case',
+                    mutation: 'kebab-case',
+                    subscription: 'kebab-case',
+                    fragment: 'kebab-case',
+                },
+            ],
+        },
+        messages: {
+            [MATCH_EXTENSION]: 'File extension "{{ fileExtension }}" don\'t match extension "{{ expectedFileExtension }}"',
+            [MATCH_STYLE]: 'Unexpected filename "{{ filename }}". Rename it to "{{ expectedFilename }}"',
+        },
+        schema,
+    },
+    create(context) {
+        const options = context.options[0] || {
+            fileExtension: null,
+        };
+        const filePath = context.getFilename();
+        const isVirtualFile = !existsSync(filePath);
+        if (process.env.NODE_ENV !== 'test' && isVirtualFile) {
+            // Skip validation for code files
+            return {};
+        }
+        const fileExtension = extname(filePath);
+        const filename = basename(filePath, fileExtension);
+        return {
+            Document(documentNode) {
+                var _a;
+                if (options.fileExtension && options.fileExtension !== fileExtension) {
+                    context.report({
+                        loc: REPORT_ON_FIRST_CHARACTER,
+                        messageId: MATCH_EXTENSION,
+                        data: {
+                            fileExtension,
+                            expectedFileExtension: options.fileExtension,
+                        },
+                    });
+                }
+                const firstOperation = documentNode.definitions.find(n => n.kind === Kind.OPERATION_DEFINITION);
+                const firstFragment = documentNode.definitions.find(n => n.kind === Kind.FRAGMENT_DEFINITION);
+                const node = firstOperation || firstFragment;
+                if (!node) {
+                    return;
+                }
+                const docName = (_a = node.name) === null || _a === void 0 ? void 0 : _a.value;
+                if (!docName) {
+                    return;
+                }
+                const docType = 'operation' in node ? node.operation : 'fragment';
+                let option = options[docType];
+                if (!option) {
+                    // Config not provided
+                    return;
+                }
+                if (typeof option === 'string') {
+                    option = { style: option };
+                }
+                const expectedExtension = options.fileExtension || fileExtension;
+                let expectedFilename = option.prefix || '';
+                if (option.style) {
+                    expectedFilename +=
+                        option.style === 'matchDocumentStyle' ? docName : convertCase(option.style, docName);
+                }
+                else {
+                    expectedFilename += filename;
+                }
+                expectedFilename += (option.suffix || '') + expectedExtension;
+                const filenameWithExtension = filename + expectedExtension;
+                if (expectedFilename !== filenameWithExtension) {
+                    context.report({
+                        loc: REPORT_ON_FIRST_CHARACTER,
+                        messageId: MATCH_STYLE,
+                        data: {
+                            expectedFilename,
+                            filename: filenameWithExtension,
+                        },
+                    });
+                }
+            },
+        };
+    },
+};