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

package/esm/processor.js

@@ -0,0 +1,75 @@
+import { gqlPluckFromCodeStringSync, } from '@graphql-tools/graphql-tag-pluck';
+import { asArray } from '@graphql-tools/utils';
+import { loadOnDiskGraphQLConfig } from './graphql-config.js';
+const blocksMap = new Map();
+let onDiskConfig;
+let onDiskConfigLoaded = false;
+const RELEVANT_KEYWORDS = ['gql', 'graphql', 'GraphQL'];
+export const processor = {
+    supportsAutofix: true,
+    preprocess(code, filePath) {
+        if (!onDiskConfigLoaded) {
+            onDiskConfig = loadOnDiskGraphQLConfig(filePath);
+            onDiskConfigLoaded = true;
+        }
+        let keywords = RELEVANT_KEYWORDS;
+        const pluckConfig = onDiskConfig === null || onDiskConfig === void 0 ? void 0 : onDiskConfig.getProjectForFile(filePath).extensions.pluckConfig;
+        if (pluckConfig) {
+            const { modules = [], globalGqlIdentifierName = ['gql', 'graphql'], gqlMagicComment = 'GraphQL', } = pluckConfig;
+            keywords = [
+                ...new Set([
+                    ...modules.map(({ identifier }) => identifier),
+                    ...asArray(globalGqlIdentifierName),
+                    gqlMagicComment,
+                ].filter(Boolean)),
+            ];
+        }
+        if (keywords.every(keyword => !code.includes(keyword))) {
+            return [code];
+        }
+        try {
+            const sources = gqlPluckFromCodeStringSync(filePath, code, {
+                skipIndent: true,
+                ...pluckConfig,
+            });
+            const isSvelte = filePath.endsWith('.svelte');
+            const blocks = sources.map(item => ({
+                filename: 'document.graphql',
+                text: item.body,
+                lineOffset: item.locationOffset.line - (isSvelte ? 3 : 1),
+                // @ts-expect-error -- `index` field exist but show ts error
+                offset: item.locationOffset.index + (isSvelte ? -52 : 1),
+            }));
+            blocksMap.set(filePath, blocks);
+            return [...blocks, code /* source code must be provided and be last */];
+        }
+        catch (_a) {
+            // in case of parsing error return code as is
+            return [code];
+        }
+    },
+    postprocess(messages, filePath) {
+        const blocks = blocksMap.get(filePath) || [];
+        for (let i = 0; i < blocks.length; i += 1) {
+            const { lineOffset, offset } = blocks[i];
+            for (const message of messages[i]) {
+                message.line += lineOffset;
+                // endLine can not exist if only `loc: { start, column }` was provided to context.report
+                if (typeof message.endLine === 'number') {
+                    message.endLine += lineOffset;
+                }
+                if (message.fix) {
+                    message.fix.range[0] += offset;
+                    message.fix.range[1] += offset;
+                }
+                for (const suggestion of message.suggestions || []) {
+                    suggestion.fix.range[0] += offset;
+                    suggestion.fix.range[1] += offset;
+                }
+            }
+        }
+        const result = messages.flat();
+        // sort eslint/graphql-eslint messages by line/column
+        return result.sort((a, b) => a.line - b.line || a.column - b.column);
+    },
+};

package/esm/rules/alphabetize.js

@@ -0,0 +1,344 @@
+import { Kind, } from 'graphql';
+import lowerCase from 'lodash.lowercase';
+import { ARRAY_DEFAULT_OPTIONS } from '../utils.js';
+const RULE_ID = 'alphabetize';
+const fieldsEnum = [
+    Kind.OBJECT_TYPE_DEFINITION,
+    Kind.INTERFACE_TYPE_DEFINITION,
+    Kind.INPUT_OBJECT_TYPE_DEFINITION,
+];
+const valuesEnum = [Kind.ENUM_TYPE_DEFINITION];
+const selectionsEnum = [
+    Kind.OPERATION_DEFINITION,
+    Kind.FRAGMENT_DEFINITION,
+];
+const variablesEnum = [Kind.OPERATION_DEFINITION];
+const argumentsEnum = [
+    Kind.FIELD_DEFINITION,
+    Kind.FIELD,
+    Kind.DIRECTIVE_DEFINITION,
+    Kind.DIRECTIVE,
+];
+const schema = {
+    type: 'array',
+    minItems: 1,
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        minProperties: 1,
+        properties: {
+            fields: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                items: {
+                    enum: fieldsEnum,
+                },
+                description: 'Fields of `type`, `interface`, and `input`.',
+            },
+            values: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                items: {
+                    enum: valuesEnum,
+                },
+                description: 'Values of `enum`.',
+            },
+            selections: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                items: {
+                    enum: selectionsEnum,
+                },
+                description: 'Selections of `fragment` and operations `query`, `mutation` and `subscription`.',
+            },
+            variables: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                items: {
+                    enum: variablesEnum,
+                },
+                description: 'Variables of operations `query`, `mutation` and `subscription`.',
+            },
+            arguments: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                items: {
+                    enum: argumentsEnum,
+                },
+                description: 'Arguments of fields and directives.',
+            },
+            definitions: {
+                type: 'boolean',
+                description: 'Definitions – `type`, `interface`, `enum`, `scalar`, `input`, `union` and `directive`.',
+                default: false,
+            },
+            groups: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                minItems: 2,
+                description: "Custom order group. Example: `['id', '*', 'createdAt', 'updatedAt']` where `*` says for everything else.",
+            },
+        },
+    },
+};
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            category: ['Schema', 'Operations'],
+            description: 'Enforce arrange in alphabetical order for type fields, enum values, input object fields, operation selections and more.',
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    usage: [{ fields: [Kind.OBJECT_TYPE_DEFINITION] }],
+                    code: /* GraphQL */ `
+            type User {
+              password: String
+              firstName: String! # should be before "password"
+              age: Int # should be before "firstName"
+              lastName: String!
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ fields: [Kind.OBJECT_TYPE_DEFINITION] }],
+                    code: /* GraphQL */ `
+            type User {
+              age: Int
+              firstName: String!
+              lastName: String!
+              password: String
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    usage: [{ values: [Kind.ENUM_TYPE_DEFINITION] }],
+                    code: /* GraphQL */ `
+            enum Role {
+              SUPER_ADMIN
+              ADMIN # should be before "SUPER_ADMIN"
+              USER
+              GOD # should be before "USER"
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ values: [Kind.ENUM_TYPE_DEFINITION] }],
+                    code: /* GraphQL */ `
+            enum Role {
+              ADMIN
+              GOD
+              SUPER_ADMIN
+              USER
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    usage: [{ selections: [Kind.OPERATION_DEFINITION] }],
+                    code: /* GraphQL */ `
+            query {
+              me {
+                firstName
+                lastName
+                email # should be before "lastName"
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ selections: [Kind.OPERATION_DEFINITION] }],
+                    code: /* GraphQL */ `
+            query {
+              me {
+                email
+                firstName
+                lastName
+              }
+            }
+          `,
+                },
+            ],
+            configOptions: {
+                schema: [
+                    {
+                        fields: fieldsEnum,
+                        values: valuesEnum,
+                        arguments: argumentsEnum,
+                        // TODO: add in graphql-eslint v4
+                        // definitions: true,
+                        // groups: ['id', '*', 'createdAt', 'updatedAt']
+                    },
+                ],
+                operations: [
+                    {
+                        selections: selectionsEnum,
+                        variables: variablesEnum,
+                        arguments: [Kind.FIELD, Kind.DIRECTIVE],
+                    },
+                ],
+            },
+        },
+        messages: {
+            [RULE_ID]: '`{{ currName }}` should be before {{ prevName }}.',
+        },
+        schema,
+    },
+    create(context) {
+        var _a, _b, _c, _d, _e;
+        const sourceCode = context.getSourceCode();
+        function isNodeAndCommentOnSameLine(node, comment) {
+            return node.loc.end.line === comment.loc.start.line;
+        }
+        function getBeforeComments(node) {
+            const commentsBefore = sourceCode.getCommentsBefore(node);
+            if (commentsBefore.length === 0) {
+                return [];
+            }
+            const tokenBefore = sourceCode.getTokenBefore(node);
+            if (tokenBefore) {
+                return commentsBefore.filter(comment => !isNodeAndCommentOnSameLine(tokenBefore, comment));
+            }
+            const filteredComments = [];
+            const nodeLine = node.loc.start.line;
+            // Break on comment that not attached to node
+            for (let i = commentsBefore.length - 1; i >= 0; i -= 1) {
+                const comment = commentsBefore[i];
+                if (nodeLine - comment.loc.start.line - filteredComments.length > 1) {
+                    break;
+                }
+                filteredComments.unshift(comment);
+            }
+            return filteredComments;
+        }
+        function getRangeWithComments(node) {
+            if (node.kind === Kind.VARIABLE) {
+                node = node.parent;
+            }
+            const [firstBeforeComment] = getBeforeComments(node);
+            const [firstAfterComment] = sourceCode.getCommentsAfter(node);
+            const from = firstBeforeComment || node;
+            const to = firstAfterComment && isNodeAndCommentOnSameLine(node, firstAfterComment)
+                ? firstAfterComment
+                : node;
+            return [from.range[0], to.range[1]];
+        }
+        function checkNodes(nodes) {
+            var _a, _b, _c, _d;
+            // Starts from 1, ignore nodes.length <= 1
+            for (let i = 1; i < nodes.length; i += 1) {
+                const currNode = nodes[i];
+                const currName = ('alias' in currNode && ((_a = currNode.alias) === null || _a === void 0 ? void 0 : _a.value)) ||
+                    ('name' in currNode && ((_b = currNode.name) === null || _b === void 0 ? void 0 : _b.value));
+                if (!currName) {
+                    // we don't move unnamed current nodes
+                    continue;
+                }
+                const prevNode = nodes[i - 1];
+                const prevName = ('alias' in prevNode && ((_c = prevNode.alias) === null || _c === void 0 ? void 0 : _c.value)) ||
+                    ('name' in prevNode && ((_d = prevNode.name) === null || _d === void 0 ? void 0 : _d.value));
+                if (prevName) {
+                    // Compare with lexicographic order
+                    const compareResult = prevName.localeCompare(currName);
+                    const { groups } = opts;
+                    let shouldSortByGroup = false;
+                    if (groups === null || groups === void 0 ? void 0 : groups.length) {
+                        if (!groups.includes('*')) {
+                            throw new Error('`groups` option should contain `*` string.');
+                        }
+                        let indexForPrev = groups.indexOf(prevName);
+                        if (indexForPrev === -1)
+                            indexForPrev = groups.indexOf('*');
+                        let indexForCurr = groups.indexOf(currName);
+                        if (indexForCurr === -1)
+                            indexForCurr = groups.indexOf('*');
+                        shouldSortByGroup = indexForPrev - indexForCurr > 0;
+                        if (indexForPrev < indexForCurr) {
+                            continue;
+                        }
+                    }
+                    const shouldSort = compareResult === 1;
+                    if (!shouldSortByGroup && !shouldSort) {
+                        const isSameName = compareResult === 0;
+                        if (!isSameName ||
+                            !prevNode.kind.endsWith('Extension') ||
+                            currNode.kind.endsWith('Extension')) {
+                            continue;
+                        }
+                    }
+                }
+                context.report({
+                    node: ('alias' in currNode && currNode.alias) || currNode.name,
+                    messageId: RULE_ID,
+                    data: {
+                        currName,
+                        prevName: prevName ? `\`${prevName}\`` : lowerCase(prevNode.kind),
+                    },
+                    *fix(fixer) {
+                        const prevRange = getRangeWithComments(prevNode);
+                        const currRange = getRangeWithComments(currNode);
+                        yield fixer.replaceTextRange(prevRange, sourceCode.getText({ range: currRange }));
+                        yield fixer.replaceTextRange(currRange, sourceCode.getText({ range: prevRange }));
+                    },
+                });
+            }
+        }
+        const opts = context.options[0];
+        const fields = new Set((_a = opts.fields) !== null && _a !== void 0 ? _a : []);
+        const listeners = {};
+        const kinds = [
+            fields.has(Kind.OBJECT_TYPE_DEFINITION) && [
+                Kind.OBJECT_TYPE_DEFINITION,
+                Kind.OBJECT_TYPE_EXTENSION,
+            ],
+            fields.has(Kind.INTERFACE_TYPE_DEFINITION) && [
+                Kind.INTERFACE_TYPE_DEFINITION,
+                Kind.INTERFACE_TYPE_EXTENSION,
+            ],
+            fields.has(Kind.INPUT_OBJECT_TYPE_DEFINITION) && [
+                Kind.INPUT_OBJECT_TYPE_DEFINITION,
+                Kind.INPUT_OBJECT_TYPE_EXTENSION,
+            ],
+        ]
+            .filter(Boolean)
+            .flat();
+        const fieldsSelector = kinds.join(',');
+        const hasEnumValues = ((_b = opts.values) === null || _b === void 0 ? void 0 : _b[0]) === Kind.ENUM_TYPE_DEFINITION;
+        const selectionsSelector = (_c = opts.selections) === null || _c === void 0 ? void 0 : _c.join(',');
+        const hasVariables = ((_d = opts.variables) === null || _d === void 0 ? void 0 : _d[0]) === Kind.OPERATION_DEFINITION;
+        const argumentsSelector = (_e = opts.arguments) === null || _e === void 0 ? void 0 : _e.join(',');
+        if (fieldsSelector) {
+            listeners[fieldsSelector] = (node) => {
+                checkNodes(node.fields);
+            };
+        }
+        if (hasEnumValues) {
+            const enumValuesSelector = [Kind.ENUM_TYPE_DEFINITION, Kind.ENUM_TYPE_EXTENSION].join(',');
+            listeners[enumValuesSelector] = (node) => {
+                checkNodes(node.values);
+            };
+        }
+        if (selectionsSelector) {
+            listeners[`:matches(${selectionsSelector}) SelectionSet`] = (node) => {
+                checkNodes(node.selections);
+            };
+        }
+        if (hasVariables) {
+            listeners.OperationDefinition = (node) => {
+                checkNodes(node.variableDefinitions.map(varDef => varDef.variable));
+            };
+        }
+        if (argumentsSelector) {
+            listeners[argumentsSelector] = (node) => {
+                checkNodes(node.arguments);
+            };
+        }
+        if (opts.definitions) {
+            listeners.Document = node => {
+                checkNodes(node.definitions);
+            };
+        }
+        return listeners;
+    },
+};

package/esm/rules/description-style.js

@@ -0,0 +1,75 @@
+const schema = {
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        minProperties: 1,
+        properties: {
+            style: {
+                enum: ['block', 'inline'],
+                default: 'block',
+            },
+        },
+    },
+};
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            examples: [
+                {
+                    title: 'Incorrect',
+                    usage: [{ style: 'inline' }],
+                    code: /* GraphQL */ `
+            """ Description """
+            type someTypeName {
+              # ...
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ style: 'inline' }],
+                    code: /* GraphQL */ `
+            " Description "
+            type someTypeName {
+              # ...
+            }
+          `,
+                },
+            ],
+            description: 'Require all comments to follow the same style (either block or inline).',
+            category: 'Schema',
+            url: 'https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/description-style.md',
+            recommended: true,
+        },
+        schema,
+    },
+    create(context) {
+        const { style = 'block' } = context.options[0] || {};
+        const isBlock = style === 'block';
+        return {
+            [`.description[type=StringValue][block!=${isBlock}]`](node) {
+                context.report({
+                    loc: isBlock ? node.loc : node.loc.start,
+                    message: `Unexpected ${isBlock ? 'inline' : 'block'} description.`,
+                    suggest: [
+                        {
+                            desc: `Change to ${isBlock ? 'block' : 'inline'} style description`,
+                            fix(fixer) {
+                                const sourceCode = context.getSourceCode();
+                                const originalText = sourceCode.getText(node);
+                                const newText = isBlock
+                                    ? originalText.replace(/(^")|("$)/g, '"""')
+                                    : originalText.replace(/(^""")|("""$)/g, '"').replace(/\s+/g, ' ');
+                                return fixer.replaceText(node, newText);
+                            },
+                        },
+                    ],
+                });
+            },
+        };
+    },
+};