@graphql-eslint/eslint-plugin 3.5.0 → 3.6.0-alpha-56305a5.0

package/docs/rules/strict-id-in-types.md

@@ -4,7 +4,7 @@
 
 - Category: `Schema`
 - Rule name: `@graphql-eslint/strict-id-in-types`
-- Requires GraphQL Schema: `false` [ℹ️](../../README.md#extended-linting-rules-with-graphql-schema)
+- Requires GraphQL Schema: `true` [ℹ️](../../README.md#extended-linting-rules-with-graphql-schema)
 - Requires GraphQL Operations: `false` [ℹ️](../../README.md#extended-linting-rules-with-siblings-operations)
 
 Requires output types to have one unique identifier unless they do not have a logical one. Exceptions can be used to ignore output types that do not have unique identifiers.

package/index.js

@@ -3157,28 +3157,26 @@ const rule$k = {
     },
 };
 
-const shouldIgnoreNode = ({ node, exceptions }) => {
-    const rawNode = node.rawNode();
-    if (exceptions.types && exceptions.types.includes(rawNode.name.value)) {
-        return true;
-    }
-    if (exceptions.suffixes && exceptions.suffixes.some(suffix => rawNode.name.value.endsWith(suffix))) {
-        return true;
-    }
-    return false;
-};
+const RULE_ID$4 = 'strict-id-in-types';
 const rule$l = {
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Requires output types to have one unique identifier unless they do not have a logical one. Exceptions can be used to ignore output types that do not have unique identifiers.',
+            description: `Requires output types to have one unique identifier unless they do not have a logical one. Exceptions can be used to ignore output types that do not have unique identifiers.`,
             category: 'Schema',
             recommended: true,
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/strict-id-in-types.md',
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$4}.md`,
+            requiresSchema: true,
             examples: [
                 {
                     title: 'Incorrect',
-                    usage: [{ acceptedIdNames: ['id', '_id'], acceptedIdTypes: ['ID'], exceptions: { suffixes: ['Payload'] } }],
+                    usage: [
+                        {
+                            acceptedIdNames: ['id', '_id'],
+                            acceptedIdTypes: ['ID'],
+                            exceptions: { suffixes: ['Payload'] },
+                        },
+                    ],
                     code: /* GraphQL */ `
             # Incorrect field name
             type InvalidFieldName {
@@ -3280,6 +3278,9 @@ const rule$l = {
                 },
             },
         },
+        messages: {
+            [RULE_ID$4]: `{{ typeName }} must have exactly one non-nullable unique identifier. Accepted name(s): {{ acceptedNamesString }}; Accepted type(s): {{ acceptedTypesString }}.`,
+        },
     },
     create(context) {
         const options = {
@@ -3288,9 +3289,18 @@ const rule$l = {
             exceptions: {},
             ...context.options[0],
         };
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$4, context);
+        const rootTypeNames = [schema.getQueryType(), schema.getMutationType(), schema.getSubscriptionType()]
+            .filter(Boolean)
+            .map(type => type.name);
+        const selector = `ObjectTypeDefinition[name.value!=/^(${rootTypeNames.join('|')})$/]`;
         return {
-            ObjectTypeDefinition(node) {
-                if (shouldIgnoreNode({ node, exceptions: options.exceptions })) {
+            [selector](node) {
+                var _a, _b;
+                const typeName = node.name.value;
+                const shouldIgnoreNode = ((_a = options.exceptions.types) === null || _a === void 0 ? void 0 : _a.includes(typeName)) ||
+                    ((_b = options.exceptions.suffixes) === null || _b === void 0 ? void 0 : _b.some(suffix => typeName.endsWith(suffix)));
+                if (shouldIgnoreNode) {
                     return;
                 }
                 const validIds = node.fields.filter(field => {
@@ -3303,18 +3313,17 @@ const rule$l = {
                     }
                     return isValidIdName && isValidIdType;
                 });
-                const typeName = node.name.value;
                 // Usually, there should be only one unique identifier field per type.
                 // Some clients allow multiple fields to be used. If more people need this,
                 // we can extend this rule later.
                 if (validIds.length !== 1) {
                     context.report({
                         loc: getLocation(node.name.loc, typeName),
-                        message: `{{ typeName }} must have exactly one non-nullable unique identifier. Accepted name(s): {{ acceptedNamesString }} ; Accepted type(s): {{ acceptedTypesString }}`,
+                        messageId: RULE_ID$4,
                         data: {
                             typeName,
-                            acceptedNamesString: options.acceptedIdNames.join(','),
-                            acceptedTypesString: options.acceptedIdTypes.join(','),
+                            acceptedNamesString: options.acceptedIdNames.join(', '),
+                            acceptedTypesString: options.acceptedIdTypes.join(', '),
                         },
                     });
                 }

package/index.mjs

@@ -3151,28 +3151,26 @@ const rule$k = {
     },
 };
 
-const shouldIgnoreNode = ({ node, exceptions }) => {
-    const rawNode = node.rawNode();
-    if (exceptions.types && exceptions.types.includes(rawNode.name.value)) {
-        return true;
-    }
-    if (exceptions.suffixes && exceptions.suffixes.some(suffix => rawNode.name.value.endsWith(suffix))) {
-        return true;
-    }
-    return false;
-};
+const RULE_ID$4 = 'strict-id-in-types';
 const rule$l = {
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Requires output types to have one unique identifier unless they do not have a logical one. Exceptions can be used to ignore output types that do not have unique identifiers.',
+            description: `Requires output types to have one unique identifier unless they do not have a logical one. Exceptions can be used to ignore output types that do not have unique identifiers.`,
             category: 'Schema',
             recommended: true,
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/strict-id-in-types.md',
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$4}.md`,
+            requiresSchema: true,
             examples: [
                 {
                     title: 'Incorrect',
-                    usage: [{ acceptedIdNames: ['id', '_id'], acceptedIdTypes: ['ID'], exceptions: { suffixes: ['Payload'] } }],
+                    usage: [
+                        {
+                            acceptedIdNames: ['id', '_id'],
+                            acceptedIdTypes: ['ID'],
+                            exceptions: { suffixes: ['Payload'] },
+                        },
+                    ],
                     code: /* GraphQL */ `
             # Incorrect field name
             type InvalidFieldName {
@@ -3274,6 +3272,9 @@ const rule$l = {
                 },
             },
         },
+        messages: {
+            [RULE_ID$4]: `{{ typeName }} must have exactly one non-nullable unique identifier. Accepted name(s): {{ acceptedNamesString }}; Accepted type(s): {{ acceptedTypesString }}.`,
+        },
     },
     create(context) {
         const options = {
@@ -3282,9 +3283,18 @@ const rule$l = {
             exceptions: {},
             ...context.options[0],
         };
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$4, context);
+        const rootTypeNames = [schema.getQueryType(), schema.getMutationType(), schema.getSubscriptionType()]
+            .filter(Boolean)
+            .map(type => type.name);
+        const selector = `ObjectTypeDefinition[name.value!=/^(${rootTypeNames.join('|')})$/]`;
         return {
-            ObjectTypeDefinition(node) {
-                if (shouldIgnoreNode({ node, exceptions: options.exceptions })) {
+            [selector](node) {
+                var _a, _b;
+                const typeName = node.name.value;
+                const shouldIgnoreNode = ((_a = options.exceptions.types) === null || _a === void 0 ? void 0 : _a.includes(typeName)) ||
+                    ((_b = options.exceptions.suffixes) === null || _b === void 0 ? void 0 : _b.some(suffix => typeName.endsWith(suffix)));
+                if (shouldIgnoreNode) {
                     return;
                 }
                 const validIds = node.fields.filter(field => {
@@ -3297,18 +3307,17 @@ const rule$l = {
                     }
                     return isValidIdName && isValidIdType;
                 });
-                const typeName = node.name.value;
                 // Usually, there should be only one unique identifier field per type.
                 // Some clients allow multiple fields to be used. If more people need this,
                 // we can extend this rule later.
                 if (validIds.length !== 1) {
                     context.report({
                         loc: getLocation(node.name.loc, typeName),
-                        message: `{{ typeName }} must have exactly one non-nullable unique identifier. Accepted name(s): {{ acceptedNamesString }} ; Accepted type(s): {{ acceptedTypesString }}`,
+                        messageId: RULE_ID$4,
                         data: {
                             typeName,
-                            acceptedNamesString: options.acceptedIdNames.join(','),
-                            acceptedTypesString: options.acceptedIdTypes.join(','),
+                            acceptedNamesString: options.acceptedIdNames.join(', '),
+                            acceptedTypesString: options.acceptedIdTypes.join(', '),
                         },
                     });
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-eslint/eslint-plugin",
-  "version": "3.5.0",
+  "version": "3.6.0-alpha-56305a5.0",
   "description": "GraphQL plugin for ESLint",
   "sideEffects": false,
   "peerDependencies": {

package/rules/index.d.ts

@@ -53,11 +53,7 @@ export declare const rules: {
         maxDepth: number;
         ignore?: string[];
     }], false>;
-    'strict-id-in-types': import("..").GraphQLESLintRule<[{
-        acceptedIdNames?: string[];
-        acceptedIdTypes?: string[];
-        exceptions?: import("./strict-id-in-types").ExceptionRule;
-    }], false>;
+    'strict-id-in-types': import("..").GraphQLESLintRule<[import("./strict-id-in-types").StrictIdInTypesRuleConfig], false>;
     'unique-fragment-name': import("..").GraphQLESLintRule<any[], false>;
     'unique-operation-name': import("..").GraphQLESLintRule<any[], false>;
 };

package/rules/strict-id-in-types.d.ts

@@ -1,12 +1,11 @@
 import { GraphQLESLintRule } from '../types';
-export interface ExceptionRule {
-    types?: string[];
-    suffixes?: string[];
-}
-declare type StrictIdInTypesRuleConfig = {
+export declare type StrictIdInTypesRuleConfig = {
     acceptedIdNames?: string[];
     acceptedIdTypes?: string[];
-    exceptions?: ExceptionRule;
+    exceptions?: {
+        types?: string[];
+        suffixes?: string[];
+    };
 };
 declare const rule: GraphQLESLintRule<[StrictIdInTypesRuleConfig]>;
 export default rule;