@graphql-eslint/eslint-plugin 3.8.0-alpha-c1d1797.0 → 3.8.0-alpha-2d2b247.0

package/docs/rules/alphabetize.md

@@ -1,5 +1,7 @@
 # `alphabetize`
 
+🔧 The `--fix` option on the [command line](https://eslint.org/docs/user-guide/command-line-interface#--fix) can automatically fix some of the problems reported by this rule.
+
 - Category: `Schema & Operations`
 - Rule name: `@graphql-eslint/alphabetize`
 - Requires GraphQL Schema: `false` [ℹ️](../../README.md#extended-linting-rules-with-graphql-schema)

package/index.js

@@ -17,6 +17,7 @@ const graphqlConfig = require('graphql-config');
 const codeFileLoader = require('@graphql-tools/code-file-loader');
 const eslint = require('eslint');
 const codeFrame = require('@babel/code-frame');
+const dedent = _interopDefault(require('dedent'));
 
 const base = {
     parser: '@graphql-eslint/eslint-plugin',
@@ -688,9 +689,10 @@ const argumentsEnum = [
 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.',
+            description: `Enforce arrange in alphabetical order for type fields, enum values, input object fields, operation selections and more.`,
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/alphabetize.md',
             examples: [
                 {
@@ -848,24 +850,56 @@ const rule = {
     },
     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));
+            }
+            return commentsBefore;
+        }
+        function getRangeWithComments(node) {
+            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) {
-            let prevName = null;
-            for (const node of nodes) {
-                const currName = node.name.value;
-                if (prevName && prevName > currName) {
-                    const isVariableNode = node.kind === graphql.Kind.VARIABLE;
-                    context.report({
-                        loc: getLocation(node.loc, node.name.value, { offsetEnd: isVariableNode ? 0 : 1 }),
-                        messageId: ALPHABETIZE,
-                        data: isVariableNode
-                            ? {
-                                currName: `$${currName}`,
-                                prevName: `$${prevName}`,
-                            }
-                            : { currName, prevName },
-                    });
+            // Starts from 1, ignore nodes.length <= 1
+            for (let i = 1; i < nodes.length; i += 1) {
+                const prevNode = nodes[i - 1];
+                const currNode = nodes[i];
+                const prevName = prevNode.name.value;
+                const currName = currNode.name.value;
+                // Compare with lexicographic order
+                if (prevName.localeCompare(currName) !== 1) {
+                    continue;
                 }
-                prevName = currName;
+                const isVariableNode = currNode.kind === graphql.Kind.VARIABLE;
+                context.report({
+                    loc: getLocation(currNode.name.loc, currName, { offsetStart: isVariableNode ? 2 : 1 }),
+                    messageId: ALPHABETIZE,
+                    data: isVariableNode
+                        ? {
+                            currName: `$${currName}`,
+                            prevName: `$${prevName}`,
+                        }
+                        : { currName, prevName },
+                    *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];
@@ -3975,19 +4009,30 @@ class GraphQLRuleTester extends eslint.RuleTester {
         }
         const linter = new eslint.Linter();
         linter.defineRule(name, rule);
+        const hasOnlyTest = tests.invalid.some(t => t.only);
         for (const testCase of tests.invalid) {
+            const { only, code, filename } = testCase;
+            if (hasOnlyTest && !only) {
+                continue;
+            }
             const verifyConfig = getVerifyConfig(name, this.config, testCase);
             defineParser(linter, verifyConfig.parser);
-            const { code, filename } = testCase;
             const messages = linter.verify(code, verifyConfig, { filename });
-            for (const message of messages) {
+            const messageForSnapshot = [];
+            for (const [index, message] of messages.entries()) {
                 if (message.fatal) {
                     throw new Error(message.message);
                 }
-                const messageForSnapshot = visualizeEslintMessage(code, message);
-                // eslint-disable-next-line no-undef
-                expect(messageForSnapshot).toMatchSnapshot();
+                messageForSnapshot.push(`Error ${index + 1}/${messages.length}`, visualizeEslintMessage(code, message));
+            }
+            if (rule.meta.fixable) {
+                const { fixed, output } = linter.verifyAndFix(code, verifyConfig, { filename });
+                if (fixed) {
+                    messageForSnapshot.push('Autofix output', dedent(output));
+                }
             }
+            // eslint-disable-next-line no-undef
+            expect(messageForSnapshot.join('\n\n')).toMatchSnapshot();
         }
     }
 }

package/index.mjs

@@ -11,6 +11,7 @@ import { loadConfigSync, GraphQLConfig } from 'graphql-config';
 import { CodeFileLoader } from '@graphql-tools/code-file-loader';
 import { RuleTester, Linter } from 'eslint';
 import { codeFrameColumns } from '@babel/code-frame';
+import dedent from 'dedent';
 
 const base = {
     parser: '@graphql-eslint/eslint-plugin',
@@ -682,9 +683,10 @@ const argumentsEnum = [
 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.',
+            description: `Enforce arrange in alphabetical order for type fields, enum values, input object fields, operation selections and more.`,
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/alphabetize.md',
             examples: [
                 {
@@ -842,24 +844,56 @@ const rule = {
     },
     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));
+            }
+            return commentsBefore;
+        }
+        function getRangeWithComments(node) {
+            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) {
-            let prevName = null;
-            for (const node of nodes) {
-                const currName = node.name.value;
-                if (prevName && prevName > currName) {
-                    const isVariableNode = node.kind === Kind.VARIABLE;
-                    context.report({
-                        loc: getLocation(node.loc, node.name.value, { offsetEnd: isVariableNode ? 0 : 1 }),
-                        messageId: ALPHABETIZE,
-                        data: isVariableNode
-                            ? {
-                                currName: `$${currName}`,
-                                prevName: `$${prevName}`,
-                            }
-                            : { currName, prevName },
-                    });
+            // Starts from 1, ignore nodes.length <= 1
+            for (let i = 1; i < nodes.length; i += 1) {
+                const prevNode = nodes[i - 1];
+                const currNode = nodes[i];
+                const prevName = prevNode.name.value;
+                const currName = currNode.name.value;
+                // Compare with lexicographic order
+                if (prevName.localeCompare(currName) !== 1) {
+                    continue;
                 }
-                prevName = currName;
+                const isVariableNode = currNode.kind === Kind.VARIABLE;
+                context.report({
+                    loc: getLocation(currNode.name.loc, currName, { offsetStart: isVariableNode ? 2 : 1 }),
+                    messageId: ALPHABETIZE,
+                    data: isVariableNode
+                        ? {
+                            currName: `$${currName}`,
+                            prevName: `$${prevName}`,
+                        }
+                        : { currName, prevName },
+                    *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];
@@ -3969,19 +4003,30 @@ class GraphQLRuleTester extends RuleTester {
         }
         const linter = new Linter();
         linter.defineRule(name, rule);
+        const hasOnlyTest = tests.invalid.some(t => t.only);
         for (const testCase of tests.invalid) {
+            const { only, code, filename } = testCase;
+            if (hasOnlyTest && !only) {
+                continue;
+            }
             const verifyConfig = getVerifyConfig(name, this.config, testCase);
             defineParser(linter, verifyConfig.parser);
-            const { code, filename } = testCase;
             const messages = linter.verify(code, verifyConfig, { filename });
-            for (const message of messages) {
+            const messageForSnapshot = [];
+            for (const [index, message] of messages.entries()) {
                 if (message.fatal) {
                     throw new Error(message.message);
                 }
-                const messageForSnapshot = visualizeEslintMessage(code, message);
-                // eslint-disable-next-line no-undef
-                expect(messageForSnapshot).toMatchSnapshot();
+                messageForSnapshot.push(`Error ${index + 1}/${messages.length}`, visualizeEslintMessage(code, message));
+            }
+            if (rule.meta.fixable) {
+                const { fixed, output } = linter.verifyAndFix(code, verifyConfig, { filename });
+                if (fixed) {
+                    messageForSnapshot.push('Autofix output', dedent(output));
+                }
             }
+            // eslint-disable-next-line no-undef
+            expect(messageForSnapshot.join('\n\n')).toMatchSnapshot();
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-eslint/eslint-plugin",
-  "version": "3.8.0-alpha-c1d1797.0",
+  "version": "3.8.0-alpha-2d2b247.0",
   "description": "GraphQL plugin for ESLint",
   "sideEffects": false,
   "peerDependencies": {
@@ -12,6 +12,7 @@
     "@graphql-tools/graphql-tag-pluck": "7.1.5",
     "@graphql-tools/utils": "8.6.1",
     "chalk": "4.1.2",
+    "dedent": "0.7.0",
     "graphql-config": "4.1.0",
     "graphql-depth-limit": "1.1.0",
     "lodash.lowercase": "4.3.0"

package/rules/alphabetize.d.ts

@@ -4,7 +4,7 @@ declare const valuesEnum: ['EnumTypeDefinition'];
 declare const selectionsEnum: ('OperationDefinition' | 'FragmentDefinition')[];
 declare const variablesEnum: ['OperationDefinition'];
 declare const argumentsEnum: ('FieldDefinition' | 'Field' | 'DirectiveDefinition' | 'Directive')[];
-declare type AlphabetizeConfig = {
+export declare type AlphabetizeConfig = {
     fields?: typeof fieldsEnum;
     values?: typeof valuesEnum;
     selections?: typeof selectionsEnum;

package/rules/index.d.ts

@@ -1,11 +1,5 @@
 export declare const rules: {
-    alphabetize: import("..").GraphQLESLintRule<[{
-        fields?: ("ObjectTypeDefinition" | "InterfaceTypeDefinition" | "InputObjectTypeDefinition")[];
-        values?: ["EnumTypeDefinition"];
-        selections?: ("OperationDefinition" | "FragmentDefinition")[];
-        variables?: ["OperationDefinition"];
-        arguments?: ("Field" | "Directive" | "FieldDefinition" | "DirectiveDefinition")[];
-    }], false>;
+    alphabetize: import("..").GraphQLESLintRule<[import("./alphabetize").AlphabetizeConfig], false>;
     'description-style': import("..").GraphQLESLintRule<[{
         style: "block" | "inline";
     }], false>;

package/testkit.d.ts

@@ -6,7 +6,6 @@ export declare type GraphQLESLintRuleListener<WithTypeInfo extends boolean = fal
     [K in keyof ASTKindToNode]?: (node: GraphQLESTreeNode<ASTKindToNode[K], WithTypeInfo>) => void;
 } & Record<string, any>;
 export declare type GraphQLValidTestCase<Options> = Omit<RuleTester.ValidTestCase, 'options' | 'parserOptions'> & {
-    name?: string;
     options?: Options;
     parserOptions?: ParserOptions;
 };