@graphql-eslint/eslint-plugin 2.3.0-alpha-f7157af.0 → 2.3.2-alpha-2901045.0

package/index.mjs

@@ -9,6 +9,8 @@ import depthLimit from 'graphql-depth-limit';
 import { parseCode } from '@graphql-tools/graphql-tag-pluck';
 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';
 
 /*
  * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
@@ -236,6 +238,24 @@ const convertCase = (style, str) => {
             return lowerCase(str).replace(/ /g, '-');
     }
 };
+function getLocation(loc, fieldName = '', offset) {
+    const { start } = loc;
+    /*
+     * ESLint has 0-based column number
+     * https://eslint.org/docs/developer-guide/working-with-rules#contextreport
+     */
+    const { offsetStart = 1, offsetEnd = 1 } = offset !== null && offset !== void 0 ? offset : {};
+    return {
+        start: {
+            line: start.line,
+            column: start.column - offsetStart,
+        },
+        end: {
+            line: start.line,
+            column: start.column - offsetEnd + fieldName.length,
+        },
+    };
+}
 
 function extractRuleName(stack) {
     const match = (stack || '').match(/validation[/\\\\]rules[/\\\\](.*?)\.js:/) || [];
@@ -286,6 +306,7 @@ const validationToRule = (name, ruleName, docs, getDocumentNode) => {
             meta: {
                 docs: {
                     ...docs,
+                    graphQLJSRuleName: ruleName,
                     category: 'Validation',
                     recommended: true,
                     requiresSchema,
@@ -585,7 +606,7 @@ const rule = {
             ],
         },
         messages: {
-            [ALPHABETIZE]: '"{{ currName }}" should be before "{{ prevName }}".',
+            [ALPHABETIZE]: '"{{ currName }}" should be before "{{ prevName }}"',
         },
         schema: {
             type: 'array',
@@ -642,19 +663,9 @@ const rule = {
             for (const node of nodes) {
                 const currName = node.name.value;
                 if (prevName && prevName > currName) {
-                    const { start, end } = node.name.loc;
                     const isVariableNode = node.kind === Kind.VARIABLE;
                     context.report({
-                        loc: {
-                            start: {
-                                line: start.line,
-                                column: start.column - (isVariableNode ? 2 : 1),
-                            },
-                            end: {
-                                line: end.line,
-                                column: end.column,
-                            },
-                        },
+                        loc: getLocation(node.loc, node.name.value, { offsetEnd: isVariableNode ? 0 : 1 }),
                         messageId: ALPHABETIZE,
                         data: isVariableNode
                             ? {
@@ -784,6 +795,7 @@ const rule$1 = {
         messages: {
             [AVOID_DUPLICATE_FIELDS]: `{{ type }} "{{ fieldName }}" defined multiple times.`,
         },
+        schema: [],
     },
     create(context) {
         return {
@@ -903,15 +915,16 @@ const rule$2 = {
                         const testKeyword = caseSensitive ? keyword : keyword.toLowerCase();
                         const testName = caseSensitive ? node.name.value : node.name.value.toLowerCase();
                         if (testName.startsWith(testKeyword)) {
+                            const { start } = node.name.loc;
                             context.report({
                                 loc: {
                                     start: {
-                                        line: node.name.loc.start.line,
-                                        column: node.name.loc.start.column - 1,
+                                        line: start.line,
+                                        column: start.column - 1,
                                     },
                                     end: {
-                                        line: node.name.loc.start.line,
-                                        column: node.name.loc.start.column + testKeyword.length - 1,
+                                        line: start.line,
+                                        column: start.column - 1 + testKeyword.length,
                                     },
                                 },
                                 data: {
@@ -954,6 +967,7 @@ const rule$3 = {
                 },
             ],
         },
+        schema: [],
     },
     create(context) {
         const schema = requireGraphQLSchemaFromContext('avoid-scalar-result-type-on-mutation', context);
@@ -1009,22 +1023,33 @@ const rule$4 = {
         messages: {
             [AVOID_TYPENAME_PREFIX]: `Field "{{ fieldName }}" starts with the name of the parent type "{{ typeName }}"`,
         },
+        schema: [],
     },
     create(context) {
         return {
             'ObjectTypeDefinition, ObjectTypeExtension, InterfaceTypeDefinition, InterfaceTypeExtension'(node) {
                 const typeName = node.name.value;
-                const lowerTypeName = (typeName || '').toLowerCase();
+                const lowerTypeName = typeName.toLowerCase();
                 for (const field of node.fields) {
-                    const fieldName = field.name.value || '';
-                    if (fieldName && lowerTypeName && fieldName.toLowerCase().startsWith(lowerTypeName)) {
+                    const fieldName = field.name.value;
+                    if (fieldName.toLowerCase().startsWith(lowerTypeName)) {
+                        const { start } = field.loc;
                         context.report({
-                            node: field.name,
                             data: {
                                 fieldName,
                                 typeName,
                             },
                             messageId: AVOID_TYPENAME_PREFIX,
+                            loc: {
+                                start: {
+                                    line: start.line,
+                                    column: start.column - 1,
+                                },
+                                end: {
+                                    line: start.line,
+                                    column: start.column - 1 + lowerTypeName.length,
+                                },
+                            },
                         });
                     }
                 }
@@ -1352,7 +1377,8 @@ const rule$7 = {
                 var _a;
                 if (options.fileExtension && options.fileExtension !== fileExtension) {
                     context.report({
-                        node: documentNode,
+                        // Report on first character
+                        loc: { column: 0, line: 1 },
                         messageId: MATCH_EXTENSION,
                         data: {
                             fileExtension,
@@ -1384,7 +1410,8 @@ const rule$7 = {
                 const filenameWithExtension = filename + expectedExtension;
                 if (expectedFilename !== filenameWithExtension) {
                     context.report({
-                        node: documentNode,
+                        // Report on first character
+                        loc: { column: 0, line: 1 },
                         messageId: MATCH_STYLE,
                         data: {
                             expectedFilename,
@@ -1722,20 +1749,24 @@ const rule$9 = {
         messages: {
             [NO_ANONYMOUS_OPERATIONS]: `Anonymous GraphQL operations are forbidden. Please make sure to name your {{ operation }}!`,
         },
+        schema: [],
     },
     create(context) {
         return {
             OperationDefinition(node) {
-                if (node && (!node.name || node.name.value === '')) {
+                var _a;
+                const isAnonymous = (((_a = node.name) === null || _a === void 0 ? void 0 : _a.value) || '').length === 0;
+                if (isAnonymous) {
+                    const { start } = node.loc;
                     context.report({
                         loc: {
                             start: {
-                                column: node.loc.start.column - 1,
-                                line: node.loc.start.line,
+                                column: start.column - 1,
+                                line: start.line,
                             },
                             end: {
-                                column: node.loc.start.column + node.operation.length,
-                                line: node.loc.start.line,
+                                column: start.column - 1 + node.operation.length,
+                                line: start.line,
                             },
                         },
                         data: {
@@ -1785,6 +1816,7 @@ const rule$a = {
         messages: {
             [ERROR_MESSAGE_ID]: `Case-insensitive enum values duplicates are not allowed! Found: "{{ found }}"`,
         },
+        schema: [],
     },
     create(context) {
         return {
@@ -1879,6 +1911,7 @@ const rule$b = {
         messages: {
             [NO_DEPRECATED]: `This {{ type }} is marked as deprecated in your GraphQL schema {{ reason }}`,
         },
+        schema: [],
     },
     create(context) {
         return {
@@ -1965,6 +1998,7 @@ const rule$c = {
             ],
         },
         type: 'suggestion',
+        schema: [],
     },
     create(context) {
         return {
@@ -2025,15 +2059,28 @@ const rule$d = {
         messages: {
             [NO_OPERATION_NAME_SUFFIX]: `Unnecessary "{{ invalidSuffix }}" suffix in your operation name!`,
         },
+        schema: [],
     },
     create(context) {
         return {
             'OperationDefinition, FragmentDefinition'(node) {
-                if (node && node.name && node.name.value !== '') {
-                    const invalidSuffix = (node.type === 'OperationDefinition' ? node.operation : 'fragment').toLowerCase();
-                    if (node.name.value.toLowerCase().endsWith(invalidSuffix)) {
+                var _a;
+                const name = ((_a = node.name) === null || _a === void 0 ? void 0 : _a.value) || '';
+                if (name.length > 0) {
+                    const invalidSuffix = 'operation' in node ? node.operation : 'fragment';
+                    if (name.toLowerCase().endsWith(invalidSuffix)) {
+                        const { start, end } = node.name.loc;
                         context.report({
-                            node: node.name,
+                            loc: {
+                                start: {
+                                    column: start.column - 1 + name.length - invalidSuffix.length,
+                                    line: start.line,
+                                },
+                                end: {
+                                    column: end.column - 1 + name.length,
+                                    line: end.line,
+                                },
+                            },
                             data: {
                                 invalidSuffix,
                             },
@@ -2090,6 +2137,7 @@ const rule$e = {
         },
         fixable: 'code',
         type: 'suggestion',
+        schema: [],
     },
     create(context) {
         const reachableTypes = requireReachableTypesFromContext(RULE_NAME, context);
@@ -2181,6 +2229,7 @@ const rule$f = {
         },
         fixable: 'code',
         type: 'suggestion',
+        schema: [],
     },
     create(context) {
         const usedFields = requireUsedFieldsFromContext(RULE_NAME$1, context);
@@ -2446,6 +2495,7 @@ const rule$h = {
             ],
         },
         type: 'suggestion',
+        schema: [],
     },
     create(context) {
         return {
@@ -2482,15 +2532,18 @@ const DESCRIBABLE_NODES = [
 function verifyRule(context, node) {
     if (node) {
         if (!node.description || !node.description.value || node.description.value.trim().length === 0) {
+            const { start, end } = ('name' in node ? node.name : node).loc;
             context.report({
                 loc: {
                     start: {
-                        line: node.loc.start.line,
-                        column: node.loc.start.column - 1,
+                        line: start.line,
+                        column: start.column - 1,
                     },
                     end: {
-                        line: node.loc.end.line,
-                        column: node.loc.end.column,
+                        line: end.line,
+                        column: 
+                        // node.name don't exist on SchemaDefinition
+                        'name' in node ? end.column - 1 + node.name.value.length : end.column,
                     },
                 },
                 messageId: REQUIRE_DESCRIPTION_ERROR,
@@ -2604,6 +2657,7 @@ const rule$j = {
                 },
             ],
         },
+        schema: [],
     },
     create(context) {
         const schema = requireGraphQLSchemaFromContext(RULE_NAME$2, context);
@@ -3140,11 +3194,7 @@ const rule$m = {
 const RULE_NAME$3 = 'unique-fragment-name';
 const UNIQUE_FRAGMENT_NAME = 'UNIQUE_FRAGMENT_NAME';
 const checkNode = (context, node, ruleName, messageId) => {
-    var _a;
-    const documentName = (_a = node.name) === null || _a === void 0 ? void 0 : _a.value;
-    if (!documentName) {
-        return;
-    }
+    const documentName = node.name.value;
     const siblings = requireSiblingsOperations(ruleName, context);
     const siblingDocuments = node.kind === Kind.FRAGMENT_DEFINITION ? siblings.getFragment(documentName) : siblings.getOperation(documentName);
     const filepath = context.getFilename();
@@ -3155,7 +3205,6 @@ const checkNode = (context, node, ruleName, messageId) => {
         return isSameName && !isSamePath;
     });
     if (conflictingDocuments.length > 0) {
-        const { start, end } = node.name.loc;
         context.report({
             messageId,
             data: {
@@ -3164,16 +3213,7 @@ const checkNode = (context, node, ruleName, messageId) => {
                     .map(f => `\t${relative(process.cwd(), getOnDiskFilepath(f.filePath))}`)
                     .join('\n'),
             },
-            loc: {
-                start: {
-                    line: start.line,
-                    column: start.column - 1,
-                },
-                end: {
-                    line: end.line,
-                    column: end.column - 1,
-                },
-            },
+            loc: getLocation(node.name.loc, documentName),
         });
     }
 };
@@ -3223,6 +3263,7 @@ const rule$n = {
         messages: {
             [UNIQUE_FRAGMENT_NAME]: 'Fragment named "{{ documentName }}" already defined in:\n{{ summary }}',
         },
+        schema: [],
     },
     create(context) {
         return {
@@ -3285,10 +3326,11 @@ const rule$o = {
         messages: {
             [UNIQUE_OPERATION_NAME]: 'Operation named "{{ documentName }}" already defined in:\n{{ summary }}',
         },
+        schema: [],
     },
     create(context) {
         return {
-            OperationDefinition(node) {
+            'OperationDefinition[name!=undefined]'(node) {
                 checkNode(context, node, RULE_NAME$4, UNIQUE_OPERATION_NAME);
             },
         };
@@ -3718,22 +3760,92 @@ function parseForESLint(code, options = {}) {
     }
 }
 
-class GraphQLRuleTester extends require('eslint').RuleTester {
+class GraphQLRuleTester extends RuleTester {
     constructor(parserOptions = {}) {
-        super({
+        const config = {
             parser: require.resolve('@graphql-eslint/eslint-plugin'),
             parserOptions: {
                 ...parserOptions,
                 skipGraphQLConfig: true,
             },
-        });
+        };
+        super(config);
+        this.config = config;
     }
     fromMockFile(path) {
         return readFileSync(resolve(__dirname, `../tests/mocks/${path}`), 'utf-8');
     }
     runGraphQLTests(name, rule, tests) {
         super.run(name, rule, tests);
+        // Skip snapshot testing if `expect` variable is not defined
+        if (typeof expect === 'undefined') {
+            return;
+        }
+        const linter = new Linter();
+        linter.defineRule(name, rule);
+        for (const testCase of tests.invalid) {
+            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) {
+                if (message.fatal) {
+                    throw new Error(message.message);
+                }
+                const messageForSnapshot = visualizeEslintMessage(code, message);
+                // eslint-disable-next-line no-undef
+                expect(messageForSnapshot).toMatchSnapshot();
+            }
+        }
+    }
+}
+function getVerifyConfig(ruleId, testerConfig, testCase) {
+    const { options, parserOptions, parser = testerConfig.parser } = testCase;
+    return {
+        ...testerConfig,
+        parser,
+        parserOptions: {
+            ...testerConfig.parserOptions,
+            ...parserOptions,
+        },
+        rules: {
+            [ruleId]: ['error', ...(Array.isArray(options) ? options : [])],
+        },
+    };
+}
+const parsers = new WeakMap();
+function defineParser(linter, parser) {
+    if (!parser) {
+        return;
+    }
+    if (!parsers.has(linter)) {
+        parsers.set(linter, new Set());
+    }
+    const defined = parsers.get(linter);
+    if (!defined.has(parser)) {
+        defined.add(parser);
+        linter.defineParser(parser, require(parser));
     }
 }
+function visualizeEslintMessage(text, result) {
+    const { line, column, endLine, endColumn, message } = result;
+    const location = {
+        start: {
+            line,
+            column,
+        },
+    };
+    if (typeof endLine === 'number' && typeof endColumn === 'number') {
+        location.end = {
+            line: endLine,
+            column: endColumn,
+        };
+    }
+    return codeFrameColumns(text, location, {
+        linesAbove: Number.POSITIVE_INFINITY,
+        linesBelow: Number.POSITIVE_INFINITY,
+        message,
+    });
+}
 
 export { GraphQLRuleTester, configs, convertDescription, convertLocation, convertRange, convertToESTree, extractCommentsFromAst, getBaseType, isNodeWithDescription, parse, parseForESLint, processors, rules, valueFromNode };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-eslint/eslint-plugin",
-  "version": "2.3.0-alpha-f7157af.0",
+  "version": "2.3.2-alpha-2901045.0",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0"

package/testkit.d.ts

@@ -13,8 +13,11 @@ export declare type GraphQLInvalidTestCase<T> = GraphQLValidTestCase<T> & {
     errors: number | Array<RuleTester.TestCaseError | string>;
     output?: string | null;
 };
-declare const GraphQLRuleTester_base: any;
-export declare class GraphQLRuleTester extends GraphQLRuleTester_base {
+export declare class GraphQLRuleTester extends RuleTester {
+    config: {
+        parser: string;
+        parserOptions: ParserOptions;
+    };
     constructor(parserOptions?: ParserOptions);
     fromMockFile(path: string): string;
     runGraphQLTests<Config>(name: string, rule: GraphQLESLintRule, tests: {
@@ -22,4 +25,3 @@ export declare class GraphQLRuleTester extends GraphQLRuleTester_base {
         invalid: GraphQLInvalidTestCase<Config>[];
     }): void;
 }
-export {};

package/types.d.ts

@@ -56,9 +56,11 @@ export declare type RuleDocsInfo<T> = Rule.RuleMetaData & {
             usage?: T;
         }[];
         optionsForConfig?: T;
+        graphQLJSRuleName?: string;
     };
 };
 export declare type GraphQLESLintRule<Options = any[], WithTypeInfo extends boolean = false> = {
     create(context: GraphQLESLintRuleContext<Options>): GraphQLESLintRuleListener<WithTypeInfo>;
     meta: Rule.RuleMetaData & RuleDocsInfo<Options>;
 };
+export declare type ValueOf<T> = T[keyof T];

package/utils.d.ts

@@ -33,4 +33,8 @@ export declare enum CaseStyle {
 }
 export declare const camelCase: (str: string) => string;
 export declare const convertCase: (style: CaseStyle, str: string) => string;
+export declare function getLocation(loc: Partial<AST.SourceLocation>, fieldName?: string, offset?: {
+    offsetStart?: number;
+    offsetEnd?: number;
+}): AST.SourceLocation;
 export {};