@graphql-eslint/eslint-plugin 4.3.0 → 4.3.1-alpha-20241209185034-de2d7397da8c26620a8930dd12b6dff42e43f537

package/esm/rules/require-description/index.js

@@ -8,57 +8,60 @@ import {
   requireGraphQLSchema,
   TYPES_KINDS
 } from "../../utils.js";
-const RULE_ID = "require-description", ALLOWED_KINDS = [
+const RULE_ID = "require-description";
+const ALLOWED_KINDS = [
   ...TYPES_KINDS,
   Kind.DIRECTIVE_DEFINITION,
   Kind.FIELD_DEFINITION,
   Kind.INPUT_VALUE_DEFINITION,
   Kind.ENUM_VALUE_DEFINITION,
   Kind.OPERATION_DEFINITION
-], schema = {
+];
+const schema = {
   type: "array",
   minItems: 1,
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     minProperties: 1,
     properties: {
       types: {
         type: "boolean",
-        enum: [!0],
+        enum: [true],
         description: `Includes:
-${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
-`)}`
+${TYPES_KINDS.map((kind) => `- \`${kind}\``).join("\n")}`
       },
       rootField: {
         type: "boolean",
-        enum: [!0],
+        enum: [true],
         description: "Definitions within `Query`, `Mutation`, and `Subscription` root types."
       },
       ignoredSelectors: {
         ...ARRAY_DEFAULT_OPTIONS,
-        description: ["Ignore specific selectors", eslintSelectorsTip].join(`
-`)
+        description: ["Ignore specific selectors", eslintSelectorsTip].join("\n")
       },
       ...Object.fromEntries(
         [...ALLOWED_KINDS].sort().map((kind) => {
           let description = `> [!NOTE]
 >
 > Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#${kind}).`;
-          return kind === Kind.OPERATION_DEFINITION && (description += [
-            "",
-            "",
-            "> [!WARNING]",
-            ">",
-            '> You must use only comment syntax `#` and not description syntax `"""` or `"`.'
-          ].join(`
-`)), [kind, { type: "boolean", description }];
+          if (kind === Kind.OPERATION_DEFINITION) {
+            description += [
+              "",
+              "",
+              "> [!WARNING]",
+              ">",
+              '> You must use only comment syntax `#` and not description syntax `"""` or `"`.'
+            ].join("\n");
+          }
+          return [kind, { type: "boolean", description }];
         })
       )
     }
   }
-}, rule = {
+};
+const rule = {
   meta: {
     docs: {
       category: "Schema",
@@ -67,7 +70,7 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
       examples: [
         {
           title: "Incorrect",
-          usage: [{ types: !0, FieldDefinition: !0 }],
+          usage: [{ types: true, FieldDefinition: true }],
           code: (
             /* GraphQL */
             `
@@ -79,7 +82,7 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         },
         {
           title: "Correct",
-          usage: [{ types: !0, FieldDefinition: !0 }],
+          usage: [{ types: true, FieldDefinition: true }],
           code: (
             /* GraphQL */
             `
@@ -97,7 +100,7 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         },
         {
           title: "Correct",
-          usage: [{ OperationDefinition: !0 }],
+          usage: [{ OperationDefinition: true }],
           code: (
             /* GraphQL */
             `
@@ -110,7 +113,7 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         },
         {
           title: "Correct",
-          usage: [{ rootField: !0 }],
+          usage: [{ rootField: true }],
           code: (
             /* GraphQL */
             `
@@ -158,12 +161,12 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
       ],
       configOptions: [
         {
-          types: !0,
-          [Kind.DIRECTIVE_DEFINITION]: !0,
-          rootField: !0
+          types: true,
+          [Kind.DIRECTIVE_DEFINITION]: true,
+          rootField: true
         }
       ],
-      recommended: !0
+      recommended: true
     },
     type: "suggestion",
     messages: {
@@ -172,11 +175,18 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
     schema
   },
   create(context) {
-    const { types, rootField, ignoredSelectors = [], ...restOptions } = context.options[0] || {}, kinds = new Set(types ? TYPES_KINDS : []);
-    for (const [kind, isEnabled] of Object.entries(restOptions))
-      isEnabled ? kinds.add(kind) : kinds.delete(kind);
+    const { types, rootField, ignoredSelectors = [], ...restOptions } = context.options[0] || {};
+    const kinds = new Set(types ? TYPES_KINDS : []);
+    for (const [kind, isEnabled] of Object.entries(restOptions)) {
+      if (isEnabled) {
+        kinds.add(kind);
+      } else {
+        kinds.delete(kind);
+      }
+    }
     if (rootField) {
-      const schema2 = requireGraphQLSchema(RULE_ID, context), rootTypeNames = getRootTypeNames(schema2);
+      const schema2 = requireGraphQLSchema(RULE_ID, context);
+      const rootTypeNames = getRootTypeNames(schema2);
       kinds.add(
         `:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/^(${[
           ...rootTypeNames
@@ -184,27 +194,35 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
       );
     }
     let selector = `:matches(${[...kinds]})`;
-    for (const str of ignoredSelectors)
+    for (const str of ignoredSelectors) {
       selector += `:not(${str})`;
+    }
     return {
       [selector](node) {
         let description = "";
         const isOperation = node.kind === Kind.OPERATION_DEFINITION;
         if (isOperation) {
-          const rawNode = node.rawNode(), { prev, line } = rawNode.loc.startToken;
+          const rawNode = node.rawNode();
+          const { prev, line } = rawNode.loc.startToken;
           if (prev?.kind === TokenKind.COMMENT) {
-            const value = prev.value.trim(), linesBefore = line - prev.line;
-            !value.startsWith("eslint") && linesBefore === 1 && (description = value);
+            const value = prev.value.trim();
+            const linesBefore = line - prev.line;
+            if (!value.startsWith("eslint") && linesBefore === 1) {
+              description = value;
+            }
           }
-        } else
+        } else {
           description = node.description?.value.trim() || "";
-        description.length === 0 && context.report({
-          loc: isOperation ? getLocation(node.loc.start, node.operation) : node.name.loc,
-          messageId: RULE_ID,
-          data: {
-            nodeName: getNodeName(node)
-          }
-        });
+        }
+        if (description.length === 0) {
+          context.report({
+            loc: isOperation ? getLocation(node.loc.start, node.operation) : node.name.loc,
+            messageId: RULE_ID,
+            data: {
+              nodeName: getNodeName(node)
+            }
+          });
+        }
       }
     };
   }

package/esm/rules/require-field-of-type-query-in-mutation-result/index.js

@@ -1,13 +1,14 @@
 import { isObjectType } from "graphql";
 import { getTypeName, requireGraphQLSchema } from "../../utils.js";
-const RULE_ID = "require-field-of-type-query-in-mutation-result", rule = {
+const RULE_ID = "require-field-of-type-query-in-mutation-result";
+const rule = {
   meta: {
     type: "suggestion",
     docs: {
       category: "Schema",
       description: "Allow the client in one round-trip not only to call mutation but also to get a wagon of data to update their application.\n> Currently, no errors are reported for result type `union`, `interface` and `scalar`.",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-      requiresSchema: !0,
+      requiresSchema: true,
       examples: [
         {
           title: "Incorrect",
@@ -47,16 +48,26 @@ const RULE_ID = "require-field-of-type-query-in-mutation-result", rule = {
     schema: []
   },
   create(context) {
-    const schema = requireGraphQLSchema(RULE_ID, context), mutationType = schema.getMutationType(), queryType = schema.getQueryType();
-    return !mutationType || !queryType ? {} : {
-      [`:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=${mutationType.name}] > FieldDefinition > .gqlType Name`](node) {
-        const typeName = node.value, graphQLType = schema.getType(typeName);
+    const schema = requireGraphQLSchema(RULE_ID, context);
+    const mutationType = schema.getMutationType();
+    const queryType = schema.getQueryType();
+    if (!mutationType || !queryType) {
+      return {};
+    }
+    const selector = `:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=${mutationType.name}] > FieldDefinition > .gqlType Name`;
+    return {
+      [selector](node) {
+        const typeName = node.value;
+        const graphQLType = schema.getType(typeName);
         if (isObjectType(graphQLType)) {
           const { fields } = graphQLType.astNode;
-          fields?.some((field) => getTypeName(field) === queryType.name) || context.report({
-            node,
-            message: `Mutation result type "${graphQLType.name}" must contain field of type "${queryType.name}"`
-          });
+          const hasQueryType = fields?.some((field) => getTypeName(field) === queryType.name);
+          if (!hasQueryType) {
+            context.report({
+              node,
+              message: `Mutation result type "${graphQLType.name}" must contain field of type "${queryType.name}"`
+            });
+          }
         }
       }
     };

package/esm/rules/require-import-fragment/index.js

@@ -1,6 +1,8 @@
 import path from "node:path";
 import { requireGraphQLOperations, slash } from "../../utils.js";
-const RULE_ID = "require-import-fragment", SUGGESTION_ID = "add-import-expression", rule = {
+const RULE_ID = "require-import-fragment";
+const SUGGESTION_ID = "add-import-expression";
+const rule = {
   meta: {
     type: "suggestion",
     docs: {
@@ -64,9 +66,9 @@ const RULE_ID = "require-import-fragment", SUGGESTION_ID = "add-import-expressio
           )
         }
       ],
-      requiresSiblings: !0
+      requiresSiblings: true
     },
-    hasSuggestions: !0,
+    hasSuggestions: true,
     messages: {
       [RULE_ID]: 'Expected "{{fragmentName}}" fragment to be imported.',
       [SUGGESTION_ID]: 'Add import expression for "{{fragmentName}}".'
@@ -74,24 +76,31 @@ const RULE_ID = "require-import-fragment", SUGGESTION_ID = "add-import-expressio
     schema: []
   },
   create(context) {
-    const comments = context.getSourceCode().getAllComments(), siblings = requireGraphQLOperations(RULE_ID, context), filePath = context.filename;
+    const comments = context.getSourceCode().getAllComments();
+    const siblings = requireGraphQLOperations(RULE_ID, context);
+    const filePath = context.filename;
     return {
       "FragmentSpread > .name"(node) {
-        const fragmentName = node.value, fragmentsFromSiblings = siblings.getFragment(fragmentName);
+        const fragmentName = node.value;
+        const fragmentsFromSiblings = siblings.getFragment(fragmentName);
         for (const comment of comments) {
-          if (comment.type !== "Line" || !new RegExp(
+          if (comment.type !== "Line") continue;
+          const isPossibleImported = new RegExp(
             `^\\s*import\\s+(${fragmentName}\\s+from\\s+)?['"]`
-          ).test(comment.value)) continue;
+          ).test(comment.value);
+          if (!isPossibleImported) continue;
           const extractedImportPath = comment.value.match(/(["'])((?:\1|.)*?)\1/)?.[2];
           if (!extractedImportPath) continue;
           const importPath = path.join(filePath, "..", extractedImportPath);
-          if (fragmentsFromSiblings.some(
+          const hasInSiblings = fragmentsFromSiblings.some(
             (source) => source.filePath === importPath
-          )) return;
+          );
+          if (hasInSiblings) return;
         }
-        if (fragmentsFromSiblings.some(
+        const fragmentInSameFile = fragmentsFromSiblings.some(
           (source) => source.filePath === filePath
-        )) return;
+        );
+        if (fragmentInSameFile) return;
         const suggestedFilePaths = fragmentsFromSiblings.length ? fragmentsFromSiblings.map(
           (o) => (
             // Use always forward slash for suggested import path

package/esm/rules/require-nullable-fields-with-oneof/index.js

@@ -1,6 +1,7 @@
 import { Kind } from "graphql";
 import { getNodeName } from "../../utils.js";
-const RULE_ID = "require-nullable-fields-with-oneof", rule = {
+const RULE_ID = "require-nullable-fields-with-oneof";
+const rule = {
   meta: {
     type: "suggestion",
     docs: {
@@ -42,16 +43,22 @@ const RULE_ID = "require-nullable-fields-with-oneof", rule = {
   create(context) {
     return {
       "Directive[name.value=oneOf]"({ parent }) {
-        if ([
+        const isTypeOrInput = [
           Kind.OBJECT_TYPE_DEFINITION,
           Kind.INPUT_OBJECT_TYPE_DEFINITION
-        ].includes(parent.kind))
-          for (const field of parent.fields || [])
-            field.gqlType.kind === Kind.NON_NULL_TYPE && context.report({
+        ].includes(parent.kind);
+        if (!isTypeOrInput) {
+          return;
+        }
+        for (const field of parent.fields || []) {
+          if (field.gqlType.kind === Kind.NON_NULL_TYPE) {
+            context.report({
               node: field.name,
               messageId: RULE_ID,
               data: { nodeName: getNodeName(field) }
             });
+          }
+        }
       }
     };
   }

package/esm/rules/require-nullable-result-in-root/index.js

@@ -1,14 +1,15 @@
 import { Kind } from "graphql";
 import { getNodeName, requireGraphQLSchema } from "../../utils.js";
-const RULE_ID = "require-nullable-result-in-root", rule = {
+const RULE_ID = "require-nullable-result-in-root";
+const rule = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       category: "Schema",
       description: "Require nullable fields in root types.",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-      requiresSchema: !0,
+      requiresSchema: true,
       examples: [
         {
           title: "Incorrect",
@@ -42,34 +43,38 @@ const RULE_ID = "require-nullable-result-in-root", rule = {
     schema: []
   },
   create(context) {
-    const schema = requireGraphQLSchema(RULE_ID, context), rootTypeNames = new Set(
+    const schema = requireGraphQLSchema(RULE_ID, context);
+    const rootTypeNames = new Set(
       [schema.getQueryType(), schema.getMutationType()].filter((v) => !!v).map((type) => type.name)
-    ), sourceCode = context.getSourceCode();
+    );
+    const sourceCode = context.getSourceCode();
     return {
       "ObjectTypeDefinition,ObjectTypeExtension"(node) {
-        if (rootTypeNames.has(node.name.value))
-          for (const field of node.fields || []) {
-            if (field.gqlType.type !== Kind.NON_NULL_TYPE || field.gqlType.gqlType.type !== Kind.NAMED_TYPE)
-              continue;
-            const name = field.gqlType.gqlType.name.value, type = schema.getType(name), resultType = type?.astNode ? getNodeName(type.astNode) : type?.name;
-            context.report({
-              node: field.gqlType,
-              messageId: RULE_ID,
-              data: {
-                resultType: resultType || "",
-                rootType: getNodeName(node)
-              },
-              suggest: [
-                {
-                  desc: `Make ${resultType} nullable`,
-                  fix(fixer) {
-                    const text = sourceCode.getText(field.gqlType);
-                    return fixer.replaceText(field.gqlType, text.replace("!", ""));
-                  }
+        if (!rootTypeNames.has(node.name.value)) return;
+        for (const field of node.fields || []) {
+          if (field.gqlType.type !== Kind.NON_NULL_TYPE || field.gqlType.gqlType.type !== Kind.NAMED_TYPE)
+            continue;
+          const name = field.gqlType.gqlType.name.value;
+          const type = schema.getType(name);
+          const resultType = type?.astNode ? getNodeName(type.astNode) : type?.name;
+          context.report({
+            node: field.gqlType,
+            messageId: RULE_ID,
+            data: {
+              resultType: resultType || "",
+              rootType: getNodeName(node)
+            },
+            suggest: [
+              {
+                desc: `Make ${resultType} nullable`,
+                fix(fixer) {
+                  const text = sourceCode.getText(field.gqlType);
+                  return fixer.replaceText(field.gqlType, text.replace("!", ""));
                 }
-              ]
-            });
-          }
+              }
+            ]
+          });
+        }
       }
     };
   }

package/esm/rules/require-selections/index.js

@@ -15,7 +15,9 @@ import {
   requireGraphQLOperations,
   requireGraphQLSchema
 } from "../../utils.js";
-const RULE_ID = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema = {
+const RULE_ID = "require-selections";
+const DEFAULT_ID_FIELD_NAME = "id";
+const schema = {
   definitions: {
     asString: {
       type: "string"
@@ -26,7 +28,7 @@ const RULE_ID = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema = {
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     properties: {
       fieldName: {
         oneOf: [{ $ref: "#/definitions/asString" }, { $ref: "#/definitions/asArray" }],
@@ -38,16 +40,17 @@ const RULE_ID = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema = {
       }
     }
   }
-}, rule = {
+};
+const rule = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       category: "Operations",
       description: "Enforce selecting specific fields when they are available on the GraphQL type.",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-      requiresSchema: !0,
-      requiresSiblings: !0,
+      requiresSchema: true,
+      requiresSiblings: true,
       examples: [
         {
           title: "Incorrect",
@@ -98,34 +101,45 @@ const RULE_ID = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema = {
           )
         }
       ],
-      recommended: !0,
+      recommended: true,
       whenNotToUseIt: "Relay Compiler automatically adds an `id` field to any type that has an `id` field, even if it hasn't been explicitly requested. Requesting a field that is not used directly in the code can conflict with another Relay rule: `relay/unused-fields`."
     },
     messages: {
-      [RULE_ID]: `Field{{ pluralSuffix }} {{ fieldName }} must be selected when it's available on a type.
-Include it in your selection set{{ addition }}.`
+      [RULE_ID]: "Field{{ pluralSuffix }} {{ fieldName }} must be selected when it's available on a type.\nInclude it in your selection set{{ addition }}."
     },
     schema
   },
   create(context) {
-    const schema2 = requireGraphQLSchema(RULE_ID, context), siblings = requireGraphQLOperations(RULE_ID, context), { fieldName = DEFAULT_ID_FIELD_NAME, requireAllFields } = context.options[0] || {}, idNames = asArray(fieldName), selector = "SelectionSet[parent.kind!=/(^OperationDefinition|InlineFragment)$/]", typeInfo = new TypeInfo(schema2);
+    const schema2 = requireGraphQLSchema(RULE_ID, context);
+    const siblings = requireGraphQLOperations(RULE_ID, context);
+    const { fieldName = DEFAULT_ID_FIELD_NAME, requireAllFields } = context.options[0] || {};
+    const idNames = asArray(fieldName);
+    const selector = "SelectionSet[parent.kind!=/(^OperationDefinition|InlineFragment)$/]";
+    const typeInfo = new TypeInfo(schema2);
     function checkFragments(node) {
       for (const selection of node.selections) {
-        if (selection.kind !== Kind.FRAGMENT_SPREAD)
+        if (selection.kind !== Kind.FRAGMENT_SPREAD) {
           continue;
+        }
         const [foundSpread] = siblings.getFragment(selection.name.value);
-        if (!foundSpread)
+        if (!foundSpread) {
           continue;
-        const checkedFragmentSpreads = /* @__PURE__ */ new Set(), visitor = visitWithTypeInfo(typeInfo, {
+        }
+        const checkedFragmentSpreads = /* @__PURE__ */ new Set();
+        const visitor = visitWithTypeInfo(typeInfo, {
           SelectionSet(node2, key, _parent) {
             const parent = _parent;
-            parent.kind === Kind.FRAGMENT_DEFINITION ? checkedFragmentSpreads.add(parent.name.value) : parent.kind !== Kind.INLINE_FRAGMENT && checkSelections(
-              node2,
-              typeInfo.getType(),
-              selection.loc.start,
-              parent,
-              checkedFragmentSpreads
-            );
+            if (parent.kind === Kind.FRAGMENT_DEFINITION) {
+              checkedFragmentSpreads.add(parent.name.value);
+            } else if (parent.kind !== Kind.INLINE_FRAGMENT) {
+              checkSelections(
+                node2,
+                typeInfo.getType(),
+                selection.loc.start,
+                parent,
+                checkedFragmentSpreads
+              );
+            }
           }
         });
         visit(foundSpread.document, visitor);
@@ -133,52 +147,74 @@ Include it in your selection set{{ addition }}.`
     }
     function checkSelections(node, type, loc, parent, checkedFragmentSpreads = /* @__PURE__ */ new Set()) {
       const rawType = getBaseType(type);
-      if (rawType instanceof GraphQLObjectType || rawType instanceof GraphQLInterfaceType)
+      if (rawType instanceof GraphQLObjectType || rawType instanceof GraphQLInterfaceType) {
         checkFields(rawType);
-      else if (rawType instanceof GraphQLUnionType)
+      } else if (rawType instanceof GraphQLUnionType) {
         for (const selection of node.selections) {
           const types = rawType.getTypes();
           if (selection.kind === Kind.INLINE_FRAGMENT) {
             const t = types.find((t2) => t2.name === selection.typeCondition.name.value);
-            t && checkFields(t);
+            if (t) {
+              checkFields(t);
+            }
           } else if (selection.kind === Kind.FRAGMENT_SPREAD) {
             const [foundSpread] = siblings.getFragment(selection.name.value);
             if (!foundSpread) return;
-            const fragmentSpread = foundSpread.document, t = fragmentSpread.typeCondition.name.value === rawType.name ? rawType : types.find((t2) => t2.name === fragmentSpread.typeCondition.name.value);
-            checkedFragmentSpreads.add(fragmentSpread.name.value), checkSelections(fragmentSpread.selectionSet, t, loc, parent, checkedFragmentSpreads);
+            const fragmentSpread = foundSpread.document;
+            const t = fragmentSpread.typeCondition.name.value === rawType.name ? rawType : types.find((t2) => t2.name === fragmentSpread.typeCondition.name.value);
+            checkedFragmentSpreads.add(fragmentSpread.name.value);
+            checkSelections(fragmentSpread.selectionSet, t, loc, parent, checkedFragmentSpreads);
           }
         }
+      }
       function checkFields(rawType2) {
         const fields = rawType2.getFields();
-        if (idNames.some((name) => fields[name]))
-          if (checkFragments(node), requireAllFields)
-            for (const idName of idNames)
-              report([idName]);
-          else
-            report(idNames);
+        const hasIdFieldInType = idNames.some((name) => fields[name]);
+        if (!hasIdFieldInType) {
+          return;
+        }
+        checkFragments(node);
+        if (requireAllFields) {
+          for (const idName of idNames) {
+            report([idName]);
+          }
+        } else {
+          report(idNames);
+        }
       }
       function report(idNames2) {
         function hasIdField({ selections }) {
           return selections.some((selection) => {
-            if (selection.kind === Kind.FIELD)
-              return selection.alias && idNames2.includes(selection.alias.value) ? !0 : idNames2.includes(selection.name.value);
-            if (selection.kind === Kind.INLINE_FRAGMENT)
+            if (selection.kind === Kind.FIELD) {
+              if (selection.alias && idNames2.includes(selection.alias.value)) {
+                return true;
+              }
+              return idNames2.includes(selection.name.value);
+            }
+            if (selection.kind === Kind.INLINE_FRAGMENT) {
               return hasIdField(selection.selectionSet);
+            }
             if (selection.kind === Kind.FRAGMENT_SPREAD) {
               const [foundSpread] = siblings.getFragment(selection.name.value);
               if (foundSpread) {
                 const fragmentSpread = foundSpread.document;
-                return checkedFragmentSpreads.add(fragmentSpread.name.value), hasIdField(fragmentSpread.selectionSet);
+                checkedFragmentSpreads.add(fragmentSpread.name.value);
+                return hasIdField(fragmentSpread.selectionSet);
               }
             }
-            return !1;
+            return false;
           });
         }
-        if (hasIdField(node))
+        const hasId = hasIdField(node);
+        if (hasId) {
           return;
+        }
         const fieldName2 = englishJoinWords(
           idNames2.map((name) => `\`${(parent.alias || parent.name).value}.${name}\``)
-        ), pluralSuffix = idNames2.length > 1 ? "s" : "", addition = checkedFragmentSpreads.size === 0 ? "" : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? "s" : ""} ${englishJoinWords([...checkedFragmentSpreads].map((name) => `\`${name}\``))}`, problem = {
+        );
+        const pluralSuffix = idNames2.length > 1 ? "s" : "";
+        const addition = checkedFragmentSpreads.size === 0 ? "" : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? "s" : ""} ${englishJoinWords([...checkedFragmentSpreads].map((name) => `\`${name}\``))}`;
+        const problem = {
           loc,
           messageId: RULE_ID,
           data: {
@@ -187,19 +223,25 @@ Include it in your selection set{{ addition }}.`
             addition
           }
         };
-        "type" in node && (problem.suggest = idNames2.map((idName) => ({
-          desc: `Add \`${idName}\` selection`,
-          fix: (fixer) => {
-            let insertNode = node.selections[0];
-            return insertNode = insertNode.kind === Kind.INLINE_FRAGMENT ? insertNode.selectionSet.selections[0] : insertNode, fixer.insertTextBefore(insertNode, `${idName} `);
-          }
-        }))), context.report(problem);
+        if ("type" in node) {
+          problem.suggest = idNames2.map((idName) => ({
+            desc: `Add \`${idName}\` selection`,
+            fix: (fixer) => {
+              let insertNode = node.selections[0];
+              insertNode = insertNode.kind === Kind.INLINE_FRAGMENT ? insertNode.selectionSet.selections[0] : insertNode;
+              return fixer.insertTextBefore(insertNode, `${idName} `);
+            }
+          }));
+        }
+        context.report(problem);
       }
     }
     return {
       [selector](node) {
         const typeInfo2 = node.typeInfo();
-        typeInfo2.gqlType && checkSelections(node, typeInfo2.gqlType, node.loc.start, node.parent);
+        if (typeInfo2.gqlType) {
+          checkSelections(node, typeInfo2.gqlType, node.loc.start, node.parent);
+        }
       }
     };
   }