@graphql-eslint/eslint-plugin 3.4.0 → 3.7.0-alpha-a9b0ecf.0

package/docs/rules/require-description.md

@@ -37,6 +37,17 @@ type someTypeName {
 }
 ```
 
+### Correct
+
+```graphql
+# eslint @graphql-eslint/require-description: ['error', { OperationDefinition: true }]
+
+# Enforce description on operations
+query {
+  foo
+}
+```
+
 ## Config Schema
 
 The schema defines the following properties:
@@ -84,6 +95,10 @@ Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October
 
 Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#ObjectTypeDefinition).
 
+### `OperationDefinition` (boolean)
+
+Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#OperationDefinition).
+
 ### `ScalarTypeDefinition` (boolean)
 
 Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#ScalarTypeDefinition).

package/docs/rules/require-id-when-available.md

@@ -23,7 +23,7 @@ type User {
 }
 
 # Query
-query user {
+query {
   user {
     name
   }
@@ -42,7 +42,7 @@ type User {
 }
 
 # Query
-query user {
+query {
   user {
     id
     name

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

@@ -2625,20 +2625,21 @@ const rule$g = {
     },
 };
 
-const REQUIRE_DESCRIPTION_ERROR = 'REQUIRE_DESCRIPTION_ERROR';
+const RULE_ID$2 = 'require-description';
 const ALLOWED_KINDS$1 = [
     ...TYPES_KINDS,
     graphql.Kind.FIELD_DEFINITION,
     graphql.Kind.INPUT_VALUE_DEFINITION,
     graphql.Kind.ENUM_VALUE_DEFINITION,
     graphql.Kind.DIRECTIVE_DEFINITION,
+    graphql.Kind.OPERATION_DEFINITION,
 ];
 const rule$h = {
     meta: {
         docs: {
             category: 'Schema',
             description: 'Enforce descriptions in your type definitions.',
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/require-description.md',
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$2}.md`,
             examples: [
                 {
                     title: 'Incorrect',
@@ -2662,6 +2663,16 @@ const rule$h = {
               """
               name: String
             }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ OperationDefinition: true }],
+                    code: /* GraphQL */ `
+            # Enforce description on operations
+            query {
+              foo
+            }
           `,
                 },
             ],
@@ -2675,7 +2686,7 @@ const rule$h = {
         },
         type: 'suggestion',
         messages: {
-            [REQUIRE_DESCRIPTION_ERROR]: 'Description is required for nodes of type "{{ nodeType }}"',
+            [RULE_ID$2]: 'Description is required for nodes of type "{{ nodeType }}"',
         },
         schema: {
             type: 'array',
@@ -2702,7 +2713,7 @@ const rule$h = {
         },
     },
     create(context) {
-        const { types, ...restOptions } = context.options[0];
+        const { types, ...restOptions } = context.options[0] || {};
         const kinds = new Set(types ? TYPES_KINDS : []);
         for (const [kind, isEnabled] of Object.entries(restOptions)) {
             if (isEnabled) {
@@ -2716,11 +2727,26 @@ const rule$h = {
         return {
             [selector](node) {
                 var _a;
-                const description = ((_a = node.description) === null || _a === void 0 ? void 0 : _a.value) || '';
-                if (description.trim().length === 0) {
+                let description = '';
+                const isOperation = node.kind === graphql.Kind.OPERATION_DEFINITION;
+                if (isOperation) {
+                    const rawNode = node.rawNode();
+                    const { prev, line } = rawNode.loc.startToken;
+                    if (prev.kind === graphql.TokenKind.COMMENT) {
+                        const value = prev.value.trim();
+                        const linesBefore = line - prev.line;
+                        if (!value.startsWith('eslint') && linesBefore === 1) {
+                            description = value;
+                        }
+                    }
+                }
+                else {
+                    description = ((_a = node.description) === null || _a === void 0 ? void 0 : _a.value.trim()) || '';
+                }
+                if (description.length === 0) {
                     context.report({
-                        loc: getLocation(node.name.loc, node.name.value),
-                        messageId: REQUIRE_DESCRIPTION_ERROR,
+                        loc: isOperation ? getLocation(node.loc, node.operation) : getLocation(node.name.loc, node.name.value),
+                        messageId: RULE_ID$2,
                         data: {
                             nodeType: node.kind,
                         },
@@ -2896,7 +2922,8 @@ const convertNode = (typeInfo) => (node, key, parent) => {
     }
 };
 
-const REQUIRE_ID_WHEN_AVAILABLE = 'REQUIRE_ID_WHEN_AVAILABLE';
+const RULE_ID$3 = 'require-id-when-available';
+const MESSAGE_ID = 'REQUIRE_ID_WHEN_AVAILABLE';
 const DEFAULT_ID_FIELD_NAME = 'id';
 const rule$j = {
     meta: {
@@ -2904,7 +2931,7 @@ const rule$j = {
         docs: {
             category: 'Operations',
             description: 'Enforce selecting specific fields when they are available on the GraphQL type.',
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/require-id-when-available.md',
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$3}.md`,
             requiresSchema: true,
             requiresSiblings: true,
             examples: [
@@ -2918,7 +2945,7 @@ const rule$j = {
             }
 
             # Query
-            query user {
+            query {
               user {
                 name
               }
@@ -2935,7 +2962,7 @@ const rule$j = {
             }
 
             # Query
-            query user {
+            query {
               user {
                 id
                 name
@@ -2947,7 +2974,7 @@ const rule$j = {
             recommended: true,
         },
         messages: {
-            [REQUIRE_ID_WHEN_AVAILABLE]: [
+            [MESSAGE_ID]: [
                 `Field {{ fieldName }} must be selected when it's available on a type. Please make sure to include it in your selection set!`,
                 `If you are using fragments, make sure that all used fragments {{ checkedFragments }}specifies the field {{ fieldName }}.`,
             ].join('\n'),
@@ -2978,14 +3005,16 @@ const rule$j = {
         },
     },
     create(context) {
-        requireGraphQLSchemaFromContext('require-id-when-available', context);
-        const siblings = requireSiblingsOperations('require-id-when-available', context);
+        requireGraphQLSchemaFromContext(RULE_ID$3, context);
+        const siblings = requireSiblingsOperations(RULE_ID$3, context);
         const { fieldName = DEFAULT_ID_FIELD_NAME } = context.options[0] || {};
-        const idNames = Array.isArray(fieldName) ? fieldName : [fieldName];
+        const idNames = utils.asArray(fieldName);
         const isFound = (s) => s.kind === graphql.Kind.FIELD && idNames.includes(s.name.value);
+        // Skip check selections in FragmentDefinition
+        const selector = 'OperationDefinition SelectionSet[parent.kind!=OperationDefinition]';
         return {
-            SelectionSet(node) {
-                var _a, _b;
+            [selector](node) {
+                var _a;
                 const typeInfo = node.typeInfo();
                 if (!typeInfo.gqlType) {
                     return;
@@ -3002,53 +3031,50 @@ const rule$j = {
                     return;
                 }
                 const checkedFragmentSpreads = new Set();
-                let found = false;
                 for (const selection of node.selections) {
                     if (isFound(selection)) {
-                        found = true;
+                        return;
                     }
-                    else if (selection.kind === graphql.Kind.INLINE_FRAGMENT) {
-                        found = (_a = selection.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.some(s => isFound(s));
+                    if (selection.kind === graphql.Kind.INLINE_FRAGMENT && selection.selectionSet.selections.some(isFound)) {
+                        return;
                     }
-                    else if (selection.kind === graphql.Kind.FRAGMENT_SPREAD) {
+                    if (selection.kind === graphql.Kind.FRAGMENT_SPREAD) {
                         const [foundSpread] = siblings.getFragment(selection.name.value);
                         if (foundSpread) {
                             checkedFragmentSpreads.add(foundSpread.document.name.value);
-                            found = (_b = foundSpread.document.selectionSet) === null || _b === void 0 ? void 0 : _b.selections.some(s => isFound(s));
+                            if (foundSpread.document.selectionSet.selections.some(isFound)) {
+                                return;
+                            }
                         }
                     }
-                    if (found) {
-                        break;
-                    }
                 }
                 const { parent } = node;
-                const hasIdFieldInInterfaceSelectionSet = parent &&
-                    parent.kind === graphql.Kind.INLINE_FRAGMENT &&
-                    parent.parent &&
-                    parent.parent.kind === graphql.Kind.SELECTION_SET &&
-                    parent.parent.selections.some(s => isFound(s));
-                if (!found && !hasIdFieldInInterfaceSelectionSet) {
-                    context.report({
-                        loc: getLocation(node.loc),
-                        messageId: REQUIRE_ID_WHEN_AVAILABLE,
-                        data: {
-                            checkedFragments: checkedFragmentSpreads.size === 0 ? '' : `(${[...checkedFragmentSpreads].join(', ')}) `,
-                            fieldName: idNames.map(name => `"${name}"`).join(' or '),
-                        },
-                    });
+                const hasIdFieldInInterfaceSelectionSet = (parent === null || parent === void 0 ? void 0 : parent.kind) === graphql.Kind.INLINE_FRAGMENT &&
+                    ((_a = parent.parent) === null || _a === void 0 ? void 0 : _a.kind) === graphql.Kind.SELECTION_SET &&
+                    parent.parent.selections.some(isFound);
+                if (hasIdFieldInInterfaceSelectionSet) {
+                    return;
                 }
+                context.report({
+                    loc: getLocation(node.loc),
+                    messageId: MESSAGE_ID,
+                    data: {
+                        checkedFragments: checkedFragmentSpreads.size === 0 ? '' : `(${[...checkedFragmentSpreads].join(', ')}) `,
+                        fieldName: idNames.map(name => `"${name}"`).join(' or '),
+                    },
+                });
             },
         };
     },
 };
 
-const RULE_ID$2 = 'selection-set-depth';
+const RULE_ID$4 = 'selection-set-depth';
 const rule$k = {
     meta: {
         docs: {
             category: 'Operations',
             description: `Limit the complexity of the GraphQL operations solely by their depth. Based on [graphql-depth-limit](https://github.com/stems/graphql-depth-limit).`,
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$2}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$4}.md`,
             requiresSiblings: true,
             examples: [
                 {
@@ -3122,10 +3148,10 @@ const rule$k = {
     create(context) {
         let siblings = null;
         try {
-            siblings = requireSiblingsOperations(RULE_ID$2, context);
+            siblings = requireSiblingsOperations(RULE_ID$4, context);
         }
         catch (e) {
-            logger.warn(`Rule "${RULE_ID$2}" works best with siblings operations loaded. For more info: http://bit.ly/graphql-eslint-operations`);
+            logger.warn(`Rule "${RULE_ID$4}" works best with siblings operations loaded. For more info: http://bit.ly/graphql-eslint-operations`);
         }
         const { maxDepth } = context.options[0];
         const ignore = context.options[0].ignore || [];
@@ -3150,35 +3176,33 @@ const rule$k = {
                     });
                 }
                 catch (e) {
-                    logger.warn(`Rule "${RULE_ID$2}" check failed due to a missing siblings operations. For more info: http://bit.ly/graphql-eslint-operations`, e);
+                    logger.warn(`Rule "${RULE_ID$4}" check failed due to a missing siblings operations. For more info: http://bit.ly/graphql-eslint-operations`, e);
                 }
             },
         };
     },
 };
 
-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$5 = '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$5}.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 +3304,9 @@ const rule$l = {
                 },
             },
         },
+        messages: {
+            [RULE_ID$5]: `{{ typeName }} must have exactly one non-nullable unique identifier. Accepted name(s): {{ acceptedNamesString }}; Accepted type(s): {{ acceptedTypesString }}.`,
+        },
     },
     create(context) {
         const options = {
@@ -3288,9 +3315,18 @@ const rule$l = {
             exceptions: {},
             ...context.options[0],
         };
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$5, 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 +3339,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$5,
                         data: {
                             typeName,
-                            acceptedNamesString: options.acceptedIdNames.join(','),
-                            acceptedTypesString: options.acceptedIdTypes.join(','),
+                            acceptedNamesString: options.acceptedIdNames.join(', '),
+                            acceptedTypesString: options.acceptedIdTypes.join(', '),
                         },
                     });
                 }

package/index.mjs

@@ -2619,20 +2619,21 @@ const rule$g = {
     },
 };
 
-const REQUIRE_DESCRIPTION_ERROR = 'REQUIRE_DESCRIPTION_ERROR';
+const RULE_ID$2 = 'require-description';
 const ALLOWED_KINDS$1 = [
     ...TYPES_KINDS,
     Kind.FIELD_DEFINITION,
     Kind.INPUT_VALUE_DEFINITION,
     Kind.ENUM_VALUE_DEFINITION,
     Kind.DIRECTIVE_DEFINITION,
+    Kind.OPERATION_DEFINITION,
 ];
 const rule$h = {
     meta: {
         docs: {
             category: 'Schema',
             description: 'Enforce descriptions in your type definitions.',
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/require-description.md',
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$2}.md`,
             examples: [
                 {
                     title: 'Incorrect',
@@ -2656,6 +2657,16 @@ const rule$h = {
               """
               name: String
             }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ OperationDefinition: true }],
+                    code: /* GraphQL */ `
+            # Enforce description on operations
+            query {
+              foo
+            }
           `,
                 },
             ],
@@ -2669,7 +2680,7 @@ const rule$h = {
         },
         type: 'suggestion',
         messages: {
-            [REQUIRE_DESCRIPTION_ERROR]: 'Description is required for nodes of type "{{ nodeType }}"',
+            [RULE_ID$2]: 'Description is required for nodes of type "{{ nodeType }}"',
         },
         schema: {
             type: 'array',
@@ -2696,7 +2707,7 @@ const rule$h = {
         },
     },
     create(context) {
-        const { types, ...restOptions } = context.options[0];
+        const { types, ...restOptions } = context.options[0] || {};
         const kinds = new Set(types ? TYPES_KINDS : []);
         for (const [kind, isEnabled] of Object.entries(restOptions)) {
             if (isEnabled) {
@@ -2710,11 +2721,26 @@ const rule$h = {
         return {
             [selector](node) {
                 var _a;
-                const description = ((_a = node.description) === null || _a === void 0 ? void 0 : _a.value) || '';
-                if (description.trim().length === 0) {
+                let description = '';
+                const isOperation = node.kind === Kind.OPERATION_DEFINITION;
+                if (isOperation) {
+                    const rawNode = node.rawNode();
+                    const { prev, line } = rawNode.loc.startToken;
+                    if (prev.kind === TokenKind.COMMENT) {
+                        const value = prev.value.trim();
+                        const linesBefore = line - prev.line;
+                        if (!value.startsWith('eslint') && linesBefore === 1) {
+                            description = value;
+                        }
+                    }
+                }
+                else {
+                    description = ((_a = node.description) === null || _a === void 0 ? void 0 : _a.value.trim()) || '';
+                }
+                if (description.length === 0) {
                     context.report({
-                        loc: getLocation(node.name.loc, node.name.value),
-                        messageId: REQUIRE_DESCRIPTION_ERROR,
+                        loc: isOperation ? getLocation(node.loc, node.operation) : getLocation(node.name.loc, node.name.value),
+                        messageId: RULE_ID$2,
                         data: {
                             nodeType: node.kind,
                         },
@@ -2890,7 +2916,8 @@ const convertNode = (typeInfo) => (node, key, parent) => {
     }
 };
 
-const REQUIRE_ID_WHEN_AVAILABLE = 'REQUIRE_ID_WHEN_AVAILABLE';
+const RULE_ID$3 = 'require-id-when-available';
+const MESSAGE_ID = 'REQUIRE_ID_WHEN_AVAILABLE';
 const DEFAULT_ID_FIELD_NAME = 'id';
 const rule$j = {
     meta: {
@@ -2898,7 +2925,7 @@ const rule$j = {
         docs: {
             category: 'Operations',
             description: 'Enforce selecting specific fields when they are available on the GraphQL type.',
-            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/require-id-when-available.md',
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$3}.md`,
             requiresSchema: true,
             requiresSiblings: true,
             examples: [
@@ -2912,7 +2939,7 @@ const rule$j = {
             }
 
             # Query
-            query user {
+            query {
               user {
                 name
               }
@@ -2929,7 +2956,7 @@ const rule$j = {
             }
 
             # Query
-            query user {
+            query {
               user {
                 id
                 name
@@ -2941,7 +2968,7 @@ const rule$j = {
             recommended: true,
         },
         messages: {
-            [REQUIRE_ID_WHEN_AVAILABLE]: [
+            [MESSAGE_ID]: [
                 `Field {{ fieldName }} must be selected when it's available on a type. Please make sure to include it in your selection set!`,
                 `If you are using fragments, make sure that all used fragments {{ checkedFragments }}specifies the field {{ fieldName }}.`,
             ].join('\n'),
@@ -2972,14 +2999,16 @@ const rule$j = {
         },
     },
     create(context) {
-        requireGraphQLSchemaFromContext('require-id-when-available', context);
-        const siblings = requireSiblingsOperations('require-id-when-available', context);
+        requireGraphQLSchemaFromContext(RULE_ID$3, context);
+        const siblings = requireSiblingsOperations(RULE_ID$3, context);
         const { fieldName = DEFAULT_ID_FIELD_NAME } = context.options[0] || {};
-        const idNames = Array.isArray(fieldName) ? fieldName : [fieldName];
+        const idNames = asArray(fieldName);
         const isFound = (s) => s.kind === Kind.FIELD && idNames.includes(s.name.value);
+        // Skip check selections in FragmentDefinition
+        const selector = 'OperationDefinition SelectionSet[parent.kind!=OperationDefinition]';
         return {
-            SelectionSet(node) {
-                var _a, _b;
+            [selector](node) {
+                var _a;
                 const typeInfo = node.typeInfo();
                 if (!typeInfo.gqlType) {
                     return;
@@ -2996,53 +3025,50 @@ const rule$j = {
                     return;
                 }
                 const checkedFragmentSpreads = new Set();
-                let found = false;
                 for (const selection of node.selections) {
                     if (isFound(selection)) {
-                        found = true;
+                        return;
                     }
-                    else if (selection.kind === Kind.INLINE_FRAGMENT) {
-                        found = (_a = selection.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.some(s => isFound(s));
+                    if (selection.kind === Kind.INLINE_FRAGMENT && selection.selectionSet.selections.some(isFound)) {
+                        return;
                     }
-                    else if (selection.kind === Kind.FRAGMENT_SPREAD) {
+                    if (selection.kind === Kind.FRAGMENT_SPREAD) {
                         const [foundSpread] = siblings.getFragment(selection.name.value);
                         if (foundSpread) {
                             checkedFragmentSpreads.add(foundSpread.document.name.value);
-                            found = (_b = foundSpread.document.selectionSet) === null || _b === void 0 ? void 0 : _b.selections.some(s => isFound(s));
+                            if (foundSpread.document.selectionSet.selections.some(isFound)) {
+                                return;
+                            }
                         }
                     }
-                    if (found) {
-                        break;
-                    }
                 }
                 const { parent } = node;
-                const hasIdFieldInInterfaceSelectionSet = parent &&
-                    parent.kind === Kind.INLINE_FRAGMENT &&
-                    parent.parent &&
-                    parent.parent.kind === Kind.SELECTION_SET &&
-                    parent.parent.selections.some(s => isFound(s));
-                if (!found && !hasIdFieldInInterfaceSelectionSet) {
-                    context.report({
-                        loc: getLocation(node.loc),
-                        messageId: REQUIRE_ID_WHEN_AVAILABLE,
-                        data: {
-                            checkedFragments: checkedFragmentSpreads.size === 0 ? '' : `(${[...checkedFragmentSpreads].join(', ')}) `,
-                            fieldName: idNames.map(name => `"${name}"`).join(' or '),
-                        },
-                    });
+                const hasIdFieldInInterfaceSelectionSet = (parent === null || parent === void 0 ? void 0 : parent.kind) === Kind.INLINE_FRAGMENT &&
+                    ((_a = parent.parent) === null || _a === void 0 ? void 0 : _a.kind) === Kind.SELECTION_SET &&
+                    parent.parent.selections.some(isFound);
+                if (hasIdFieldInInterfaceSelectionSet) {
+                    return;
                 }
+                context.report({
+                    loc: getLocation(node.loc),
+                    messageId: MESSAGE_ID,
+                    data: {
+                        checkedFragments: checkedFragmentSpreads.size === 0 ? '' : `(${[...checkedFragmentSpreads].join(', ')}) `,
+                        fieldName: idNames.map(name => `"${name}"`).join(' or '),
+                    },
+                });
             },
         };
     },
 };
 
-const RULE_ID$2 = 'selection-set-depth';
+const RULE_ID$4 = 'selection-set-depth';
 const rule$k = {
     meta: {
         docs: {
             category: 'Operations',
             description: `Limit the complexity of the GraphQL operations solely by their depth. Based on [graphql-depth-limit](https://github.com/stems/graphql-depth-limit).`,
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$2}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$4}.md`,
             requiresSiblings: true,
             examples: [
                 {
@@ -3116,10 +3142,10 @@ const rule$k = {
     create(context) {
         let siblings = null;
         try {
-            siblings = requireSiblingsOperations(RULE_ID$2, context);
+            siblings = requireSiblingsOperations(RULE_ID$4, context);
         }
         catch (e) {
-            logger.warn(`Rule "${RULE_ID$2}" works best with siblings operations loaded. For more info: http://bit.ly/graphql-eslint-operations`);
+            logger.warn(`Rule "${RULE_ID$4}" works best with siblings operations loaded. For more info: http://bit.ly/graphql-eslint-operations`);
         }
         const { maxDepth } = context.options[0];
         const ignore = context.options[0].ignore || [];
@@ -3144,35 +3170,33 @@ const rule$k = {
                     });
                 }
                 catch (e) {
-                    logger.warn(`Rule "${RULE_ID$2}" check failed due to a missing siblings operations. For more info: http://bit.ly/graphql-eslint-operations`, e);
+                    logger.warn(`Rule "${RULE_ID$4}" check failed due to a missing siblings operations. For more info: http://bit.ly/graphql-eslint-operations`, e);
                 }
             },
         };
     },
 };
 
-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$5 = '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$5}.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 +3298,9 @@ const rule$l = {
                 },
             },
         },
+        messages: {
+            [RULE_ID$5]: `{{ typeName }} must have exactly one non-nullable unique identifier. Accepted name(s): {{ acceptedNamesString }}; Accepted type(s): {{ acceptedTypesString }}.`,
+        },
     },
     create(context) {
         const options = {
@@ -3282,9 +3309,18 @@ const rule$l = {
             exceptions: {},
             ...context.options[0],
         };
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$5, 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 +3333,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$5,
                         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.4.0",
+  "version": "3.7.0-alpha-a9b0ecf.0",
   "description": "GraphQL plugin for ESLint",
   "sideEffects": false,
   "peerDependencies": {
@@ -9,8 +9,8 @@
   "dependencies": {
     "@babel/code-frame": "7.16.7",
     "@graphql-tools/code-file-loader": "7.2.3",
-    "@graphql-tools/graphql-tag-pluck": "7.1.4",
-    "@graphql-tools/utils": "8.5.5",
+    "@graphql-tools/graphql-tag-pluck": "7.1.5",
+    "@graphql-tools/utils": "8.6.1",
     "chalk": "4.1.2",
     "graphql-config": "4.1.0",
     "graphql-depth-limit": "1.1.0",

package/rules/index.d.ts

@@ -33,33 +33,14 @@ export declare const rules: {
         argumentName?: string;
     }], false>;
     'require-deprecation-reason': import("..").GraphQLESLintRule<any[], false>;
-    'require-description': import("..").GraphQLESLintRule<[{
-        types?: boolean;
-    } & {
-        ScalarTypeDefinition?: boolean;
-        ObjectTypeDefinition?: boolean;
-        FieldDefinition?: boolean;
-        InputValueDefinition?: boolean;
-        InterfaceTypeDefinition?: boolean;
-        UnionTypeDefinition?: boolean;
-        EnumTypeDefinition?: boolean;
-        EnumValueDefinition?: boolean;
-        InputObjectTypeDefinition?: boolean;
-        DirectiveDefinition?: boolean;
-    }], false>;
+    'require-description': import("..").GraphQLESLintRule<[import("./require-description").RequireDescriptionRuleConfig], false>;
     'require-field-of-type-query-in-mutation-result': import("..").GraphQLESLintRule<any[], false>;
-    'require-id-when-available': import("..").GraphQLESLintRule<[{
-        fieldName: string;
-    }], true>;
+    'require-id-when-available': import("..").GraphQLESLintRule<[import("./require-id-when-available").RequireIdWhenAvailableRuleConfig], true>;
     'selection-set-depth': import("..").GraphQLESLintRule<[{
         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/require-description.d.ts

@@ -1,8 +1,8 @@
 import { Kind } from 'graphql';
 import { GraphQLESLintRule } from '../types';
-declare const ALLOWED_KINDS: readonly [Kind.OBJECT_TYPE_DEFINITION, Kind.INTERFACE_TYPE_DEFINITION, Kind.ENUM_TYPE_DEFINITION, Kind.SCALAR_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.UNION_TYPE_DEFINITION, Kind.FIELD_DEFINITION, Kind.INPUT_VALUE_DEFINITION, Kind.ENUM_VALUE_DEFINITION, Kind.DIRECTIVE_DEFINITION];
+declare const ALLOWED_KINDS: readonly [Kind.OBJECT_TYPE_DEFINITION, Kind.INTERFACE_TYPE_DEFINITION, Kind.ENUM_TYPE_DEFINITION, Kind.SCALAR_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.UNION_TYPE_DEFINITION, Kind.FIELD_DEFINITION, Kind.INPUT_VALUE_DEFINITION, Kind.ENUM_VALUE_DEFINITION, Kind.DIRECTIVE_DEFINITION, Kind.OPERATION_DEFINITION];
 declare type AllowedKind = typeof ALLOWED_KINDS[number];
-declare type RequireDescriptionRuleConfig = {
+export declare type RequireDescriptionRuleConfig = {
     types?: boolean;
 } & {
     [key in AllowedKind]?: boolean;

package/rules/require-id-when-available.d.ts

@@ -1,6 +1,6 @@
 import { GraphQLESLintRule } from '../types';
-declare type RequireIdWhenAvailableRuleConfig = {
-    fieldName: string;
+export declare type RequireIdWhenAvailableRuleConfig = {
+    fieldName: string | string[];
 };
 declare const rule: GraphQLESLintRule<[RequireIdWhenAvailableRuleConfig], true>;
 export default rule;

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;