@graphql-eslint/eslint-plugin 4.3.0 → 4.3.1-alpha-20241207204625-6a4230707a78900a6339b03afe904b9dd6c31561

package/esm/rules/naming-convention/index.js

@@ -24,26 +24,33 @@ const KindToDisplayName = {
   [Kind.OPERATION_DEFINITION]: "Operation",
   [Kind.FRAGMENT_DEFINITION]: "Fragment",
   [Kind.VARIABLE_DEFINITION]: "Variable"
-}, StyleToRegex = {
+};
+const StyleToRegex = {
   camelCase: /^[a-z][\dA-Za-z]*$/,
   PascalCase: /^[A-Z][\dA-Za-z]*$/,
   snake_case: /^[a-z][\d_a-z]*[\da-z]*$/,
   UPPER_CASE: /^[A-Z][\dA-Z_]*[\dA-Z]*$/
-}, ALLOWED_KINDS = Object.keys(KindToDisplayName).sort(), ALLOWED_STYLES = Object.keys(StyleToRegex), schemaOption = {
+};
+const ALLOWED_KINDS = Object.keys(KindToDisplayName).sort();
+const ALLOWED_STYLES = Object.keys(StyleToRegex);
+const schemaOption = {
   oneOf: [{ $ref: "#/definitions/asString" }, { $ref: "#/definitions/asObject" }]
-}, descriptionPrefixesSuffixes = (name) => `> [!WARNING]
+};
+const descriptionPrefixesSuffixes = (name, id) => `> [!WARNING]
 >
-> This option is deprecated and will be removed in the next major release. Use [\`${name}\`](#${name.toLowerCase()}-array) instead.`, schema = {
+> This option is deprecated and will be removed in the next major release. Use [\`${name}\`](#${id}) instead.`;
+const caseSchema = {
+  enum: ALLOWED_STYLES,
+  description: `One of: ${ALLOWED_STYLES.map((t) => `\`${t}\``).join(", ")}`
+};
+const schema = {
   definitions: {
-    asString: {
-      enum: ALLOWED_STYLES,
-      description: `One of: ${ALLOWED_STYLES.map((t) => `\`${t}\``).join(", ")}`
-    },
+    asString: caseSchema,
     asObject: {
       type: "object",
-      additionalProperties: !1,
+      additionalProperties: false,
       properties: {
-        style: { enum: ALLOWED_STYLES },
+        style: caseSchema,
         prefix: { type: "string" },
         suffix: { type: "string" },
         forbiddenPatterns: {
@@ -53,28 +60,25 @@ const KindToDisplayName = {
           },
           description: "Should be of instance of `RegEx`"
         },
-        requiredPatterns: {
-          ...ARRAY_DEFAULT_OPTIONS,
-          items: {
-            type: "object"
-          },
+        requiredPattern: {
+          type: "object",
           description: "Should be of instance of `RegEx`"
         },
         forbiddenPrefixes: {
           ...ARRAY_DEFAULT_OPTIONS,
-          description: descriptionPrefixesSuffixes("forbiddenPatterns")
+          description: descriptionPrefixesSuffixes("forbiddenPatterns", "forbiddenpatterns-array")
         },
         forbiddenSuffixes: {
           ...ARRAY_DEFAULT_OPTIONS,
-          description: descriptionPrefixesSuffixes("forbiddenPatterns")
+          description: descriptionPrefixesSuffixes("forbiddenPatterns", "forbiddenpatterns-array")
         },
         requiredPrefixes: {
           ...ARRAY_DEFAULT_OPTIONS,
-          description: descriptionPrefixesSuffixes("requiredPatterns")
+          description: descriptionPrefixesSuffixes("requiredPattern", "requiredpattern-object")
         },
         requiredSuffixes: {
           ...ARRAY_DEFAULT_OPTIONS,
-          description: descriptionPrefixesSuffixes("requiredPatterns")
+          description: descriptionPrefixesSuffixes("requiredPattern", "requiredpattern-object")
         },
         ignorePattern: {
           type: "string",
@@ -87,13 +91,12 @@ const KindToDisplayName = {
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     properties: {
       types: {
         ...schemaOption,
         description: `Includes:
-${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
-`)}`
+${TYPES_KINDS.map((kind) => `- \`${kind}\``).join("\n")}`
       },
       ...Object.fromEntries(
         ALLOWED_KINDS.map((kind) => [
@@ -108,11 +111,11 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
       ),
       allowLeadingUnderscore: {
         type: "boolean",
-        default: !1
+        default: false
       },
       allowTrailingUnderscore: {
         type: "boolean",
-        default: !1
+        default: false
       }
     },
     patternProperties: {
@@ -124,16 +127,16 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
       "> Paste or drop code into the editor in [ASTExplorer](https://astexplorer.net) and inspect the generated AST to compose your selector.",
       ">",
       "> Example: pattern property `FieldDefinition[parent.name.value=Query]` will match only fields for type `Query`."
-    ].join(`
-`)
+    ].join("\n")
   }
-}, rule = {
+};
+const rule = {
   meta: {
     type: "suggestion",
     docs: {
       description: "Require names to follow specified conventions.",
       category: ["Schema", "Operations"],
-      recommended: !0,
+      recommended: true,
       url: "https://the-guild.dev/graphql/eslint/rules/naming-convention",
       examples: [
         {
@@ -267,6 +270,30 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
             }
           `
           )
+        },
+        {
+          title: "Correct (Relay fragment convention `<module_name>_<property_name>`)",
+          usage: [
+            {
+              FragmentDefinition: {
+                style: "PascalCase",
+                requiredPattern: /_(?<camelCase>.+?)$/
+              }
+            }
+          ],
+          code: (
+            /* GraphQL */
+            `
+            # schema
+            type User {
+              # ...
+            }
+            # operations
+            fragment UserFields_data on User {
+              # ...
+            }
+          `
+          )
         }
       ],
       configOptions: {
@@ -325,14 +352,16 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         ]
       }
     },
-    hasSuggestions: !0,
+    hasSuggestions: true,
     schema
   },
   create(context) {
-    const options = context.options[0] || {}, { allowLeadingUnderscore, allowTrailingUnderscore, types, ...restOptions } = options, ignoredNodes = /* @__PURE__ */ new Set();
+    const options = context.options[0] || {};
+    const { allowLeadingUnderscore, allowTrailingUnderscore, types, ...restOptions } = options;
+    const ignoredNodes = /* @__PURE__ */ new Set();
     function normalisePropertyOption(kind) {
       const style = restOptions[kind] || types;
-      return typeof style == "object" ? style : { style };
+      return typeof style === "object" ? style : { style };
     }
     function report(node, message, suggestedNames) {
       context.report({
@@ -346,8 +375,9 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
     }
     const checkNode = (selector) => (n) => {
       const { name: node } = n.kind === Kind.VARIABLE_DEFINITION ? n.variable : n;
-      if (!node)
+      if (!node) {
         return;
+      }
       const {
         prefix,
         suffix,
@@ -358,12 +388,18 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         requiredPrefixes,
         requiredSuffixes,
         forbiddenPatterns,
-        requiredPatterns
-      } = normalisePropertyOption(selector), nodeName = node.value, error = getError();
+        requiredPattern
+      } = normalisePropertyOption(selector);
+      const nodeName = node.value;
+      const error = getError();
       if (error) {
-        const { errorMessage, renameToNames } = error, [leadingUnderscores] = nodeName.match(/^_*/), [trailingUnderscores] = nodeName.match(/_*$/), suggestedNames = renameToNames.map(
+        const { errorMessage, renameToNames } = error;
+        const [leadingUnderscores] = nodeName.match(/^_*/);
+        const [trailingUnderscores] = nodeName.match(/_*$/);
+        const suggestedNames = renameToNames.map(
           (renameToName) => leadingUnderscores + renameToName + trailingUnderscores
-        ), name = displayNodeName(n);
+        );
+        const name = displayNodeName(n);
         report(
           node,
           `${name[0].toUpperCase()}${name.slice(1)} should ${errorMessage}`,
@@ -371,80 +407,133 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         );
       }
       function getError() {
-        const name = nodeName.replace(/(^_+)|(_+$)/g, "");
+        let name = nodeName;
+        if (allowLeadingUnderscore) name = name.replace(/^_+/, "");
+        if (allowTrailingUnderscore) name = name.replace(/_+$/, "");
         if (ignorePattern && new RegExp(ignorePattern, "u").test(name)) {
-          "name" in n && ignoredNodes.add(n.name);
+          if ("name" in n) {
+            ignoredNodes.add(n.name);
+          }
           return;
         }
-        if (prefix && !name.startsWith(prefix))
+        if (prefix && !name.startsWith(prefix)) {
           return {
             errorMessage: `have "${prefix}" prefix`,
             renameToNames: [prefix + name]
           };
-        if (suffix && !name.endsWith(suffix))
+        }
+        if (suffix && !name.endsWith(suffix)) {
           return {
             errorMessage: `have "${suffix}" suffix`,
             renameToNames: [name + suffix]
           };
+        }
+        if (requiredPattern) {
+          if (requiredPattern.source.includes("(?<")) {
+            try {
+              name = name.replace(requiredPattern, (originalString, ...args) => {
+                const groups = args.at(-1);
+                for (const [styleName, value] of Object.entries(groups)) {
+                  if (!(styleName in StyleToRegex)) {
+                    throw new Error("Invalid case style in `requiredPatterns` option");
+                  }
+                  if (value === convertCase(styleName, value)) {
+                    return "";
+                  }
+                  throw new Error(`contain the required pattern: ${requiredPattern}`);
+                }
+                return originalString;
+              });
+              if (name === nodeName) {
+                throw new Error(`contain the required pattern: ${requiredPattern}`);
+              }
+            } catch (error2) {
+              return {
+                errorMessage: error2.message,
+                renameToNames: []
+              };
+            }
+          } else if (!requiredPattern.test(name)) {
+            return {
+              errorMessage: `contain the required pattern: ${requiredPattern}`,
+              renameToNames: []
+            };
+          }
+        }
         const forbidden = forbiddenPatterns?.find((pattern) => pattern.test(name));
-        if (forbidden)
+        if (forbidden) {
           return {
             errorMessage: `not contain the forbidden pattern "${forbidden}"`,
             renameToNames: [name.replace(forbidden, "")]
           };
-        if (requiredPatterns && !requiredPatterns.some((pattern) => pattern.test(name)))
-          return {
-            errorMessage: `contain the required pattern: ${englishJoinWords(requiredPatterns.map((re) => re.source))}`,
-            renameToNames: []
-          };
+        }
         const forbiddenPrefix = forbiddenPrefixes?.find((prefix2) => name.startsWith(prefix2));
-        if (forbiddenPrefix)
+        if (forbiddenPrefix) {
           return {
             errorMessage: `not have "${forbiddenPrefix}" prefix`,
             renameToNames: [name.replace(new RegExp(`^${forbiddenPrefix}`), "")]
           };
+        }
         const forbiddenSuffix = forbiddenSuffixes?.find((suffix2) => name.endsWith(suffix2));
-        if (forbiddenSuffix)
+        if (forbiddenSuffix) {
           return {
             errorMessage: `not have "${forbiddenSuffix}" suffix`,
             renameToNames: [name.replace(new RegExp(`${forbiddenSuffix}$`), "")]
           };
-        if (requiredPrefixes && !requiredPrefixes.some((requiredPrefix) => name.startsWith(requiredPrefix)))
+        }
+        if (requiredPrefixes && !requiredPrefixes.some((requiredPrefix) => name.startsWith(requiredPrefix))) {
           return {
             errorMessage: `have one of the following prefixes: ${englishJoinWords(
               requiredPrefixes
             )}`,
             renameToNames: style ? requiredPrefixes.map((prefix2) => convertCase(style, `${prefix2} ${name}`)) : requiredPrefixes.map((prefix2) => `${prefix2}${name}`)
           };
-        if (requiredSuffixes && !requiredSuffixes.some((requiredSuffix) => name.endsWith(requiredSuffix)))
+        }
+        if (requiredSuffixes && !requiredSuffixes.some((requiredSuffix) => name.endsWith(requiredSuffix))) {
           return {
             errorMessage: `have one of the following suffixes: ${englishJoinWords(
               requiredSuffixes
             )}`,
             renameToNames: style ? requiredSuffixes.map((suffix2) => convertCase(style, `${name} ${suffix2}`)) : requiredSuffixes.map((suffix2) => `${name}${suffix2}`)
           };
-        if (!style)
+        }
+        if (!style) {
           return;
-        if (!StyleToRegex[style].test(name))
+        }
+        const caseRegex = StyleToRegex[style];
+        if (!caseRegex.test(name)) {
           return {
             errorMessage: `be in ${style} format`,
             renameToNames: [convertCase(style, name)]
           };
+        }
       }
-    }, checkUnderscore = (isLeading) => (node) => {
-      if (ignoredNodes.has(node) || node.parent.kind === "Field" && node.parent.alias !== node)
+    };
+    const checkUnderscore = (isLeading) => (node) => {
+      if (ignoredNodes.has(node)) {
         return;
+      }
+      if (node.parent.kind === "Field" && node.parent.alias !== node) {
+        return;
+      }
       const suggestedName = node.value.replace(isLeading ? /^_+/ : /_+$/, "");
       report(node, `${isLeading ? "Leading" : "Trailing"} underscores are not allowed`, [
         suggestedName
       ]);
-    }, listeners = {};
-    allowLeadingUnderscore || (listeners["Name[value=/^_/]"] = checkUnderscore(!0)), allowTrailingUnderscore || (listeners["Name[value=/_$/]"] = checkUnderscore(!1));
+    };
+    const listeners = {};
+    if (!allowLeadingUnderscore) {
+      listeners["Name[value=/^_/]"] = checkUnderscore(true);
+    }
+    if (!allowTrailingUnderscore) {
+      listeners["Name[value=/_$/]"] = checkUnderscore(false);
+    }
     const selectors = new Set(
       [types && TYPES_KINDS, Object.keys(restOptions)].filter((v) => !!v).flat()
     );
-    for (const selector of selectors)
+    for (const selector of selectors) {
       listeners[selector] = checkNode(selector);
+    }
     return listeners;
   }
 };

package/esm/rules/no-anonymous-operations/index.js

@@ -1,13 +1,14 @@
 import { Kind } from "graphql";
 import { getLocation } from "../../utils.js";
-const RULE_ID = "no-anonymous-operations", rule = {
+const RULE_ID = "no-anonymous-operations";
+const rule = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       category: "Operations",
       description: "Require name for your GraphQL operations. This is useful since most GraphQL client libraries are using the operation name for caching purposes.",
-      recommended: !0,
+      recommended: true,
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
       examples: [
         {
@@ -42,7 +43,8 @@ const RULE_ID = "no-anonymous-operations", rule = {
   create(context) {
     return {
       "OperationDefinition[name=undefined]"(node) {
-        const [firstSelection] = node.selectionSet.selections, suggestedName = firstSelection.kind === Kind.FIELD ? (firstSelection.alias || firstSelection.name).value : node.operation;
+        const [firstSelection] = node.selectionSet.selections;
+        const suggestedName = firstSelection.kind === Kind.FIELD ? (firstSelection.alias || firstSelection.name).value : node.operation;
         context.report({
           loc: getLocation(node.loc.start, node.operation),
           messageId: RULE_ID,
@@ -53,7 +55,8 @@ const RULE_ID = "no-anonymous-operations", rule = {
             {
               desc: `Rename to \`${suggestedName}\``,
               fix(fixer) {
-                const hasQueryKeyword = context.getSourceCode().getText({ range: [node.range[0], node.range[0] + 1] }) !== "{";
+                const sourceCode = context.getSourceCode();
+                const hasQueryKeyword = sourceCode.getText({ range: [node.range[0], node.range[0] + 1] }) !== "{";
                 return fixer.insertTextAfterRange(
                   [node.range[0], node.range[0] + (hasQueryKeyword ? node.operation.length : 0)],
                   `${hasQueryKeyword ? "" : "query"} ${suggestedName}${hasQueryKeyword ? "" : " "}`

package/esm/rules/no-deprecated/index.js

@@ -1,13 +1,14 @@
 import { displayNodeName, requireGraphQLSchema } from "../../utils.js";
-const RULE_ID = "no-deprecated", rule = {
+const RULE_ID = "no-deprecated";
+const rule = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       category: "Operations",
       description: "Enforce that deprecated fields or enum values are not in use by operations.",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-      requiresSchema: !0,
+      requiresSchema: true,
       examples: [
         {
           title: "Incorrect (field)",
@@ -79,7 +80,7 @@ const RULE_ID = "no-deprecated", rule = {
           )
         }
       ],
-      recommended: !0
+      recommended: true
     },
     messages: {
       [RULE_ID]: "{{ type }} is marked as deprecated in your GraphQL schema (reason: {{ reason }})"
@@ -107,24 +108,37 @@ const RULE_ID = "no-deprecated", rule = {
     }
     return {
       EnumValue(node) {
-        const reason = node.typeInfo().enumValue?.deprecationReason;
-        reason && report(node, reason);
+        const typeInfo = node.typeInfo();
+        const reason = typeInfo.enumValue?.deprecationReason;
+        if (reason) {
+          report(node, reason);
+        }
       },
       Field(node) {
-        const reason = node.typeInfo().fieldDef?.deprecationReason;
-        reason && report(node, reason);
+        const typeInfo = node.typeInfo();
+        const reason = typeInfo.fieldDef?.deprecationReason;
+        if (reason) {
+          report(node, reason);
+        }
       },
       Argument(node) {
-        const reason = node.typeInfo().argument?.deprecationReason;
-        reason && report(node, reason);
+        const typeInfo = node.typeInfo();
+        const reason = typeInfo.argument?.deprecationReason;
+        if (reason) {
+          report(node, reason);
+        }
       },
       ObjectValue(node) {
         const { inputType } = node.typeInfo();
-        if (inputType && "getFields" in inputType) {
+        if (!inputType) return;
+        if ("getFields" in inputType) {
           const fields = inputType.getFields();
           for (const field of node.fields) {
-            const fieldName = field.name.value, reason = fields[fieldName].deprecationReason;
-            reason && report(field, reason);
+            const fieldName = field.name.value;
+            const reason = fields[fieldName].deprecationReason;
+            if (reason) {
+              report(field, reason);
+            }
           }
         }
       }

package/esm/rules/no-duplicate-fields/index.js

@@ -1,13 +1,14 @@
 import { Kind } from "graphql";
-const RULE_ID = "no-duplicate-fields", rule = {
+const RULE_ID = "no-duplicate-fields";
+const rule = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       description: "Checks for duplicate fields in selection set, variables in operation definition, or in arguments set of a field.",
       category: "Operations",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-      recommended: !0,
+      recommended: true,
       examples: [
         {
           title: "Incorrect",
@@ -88,24 +89,30 @@ const RULE_ID = "no-duplicate-fields", rule = {
             }
           ]
         });
-      } else
+      } else {
         usedFields.add(fieldName);
+      }
     }
     return {
       OperationDefinition(node) {
         const set = /* @__PURE__ */ new Set();
-        for (const varDef of node.variableDefinitions || [])
+        for (const varDef of node.variableDefinitions || []) {
           checkNode(set, varDef.variable.name);
+        }
       },
       Field(node) {
         const set = /* @__PURE__ */ new Set();
-        for (const arg of node.arguments || [])
+        for (const arg of node.arguments || []) {
           checkNode(set, arg.name);
+        }
       },
       SelectionSet(node) {
         const set = /* @__PURE__ */ new Set();
-        for (const selection of node.selections)
-          selection.kind === Kind.FIELD && checkNode(set, selection.alias || selection.name);
+        for (const selection of node.selections) {
+          if (selection.kind === Kind.FIELD) {
+            checkNode(set, selection.alias || selection.name);
+          }
+        }
       }
     };
   }

package/esm/rules/no-hashtag-description/index.js

@@ -1,9 +1,10 @@
 import { TokenKind } from "graphql";
 import { getNodeName } from "../../utils.js";
-const RULE_ID = "HASHTAG_COMMENT", rule = {
+const RULE_ID = "HASHTAG_COMMENT";
+const rule = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     schema: [],
     messages: {
       [RULE_ID]: 'Unexpected GraphQL descriptions as hashtag `#` for {{ nodeName }}.\nPrefer using `"""` for multiline, or `"` for a single line description.'
@@ -56,21 +57,27 @@ const RULE_ID = "HASHTAG_COMMENT", rule = {
           )
         }
       ],
-      recommended: !0
+      recommended: true
     }
   },
   create(context) {
+    const selector = "Document[definitions.0.kind!=/^(OperationDefinition|FragmentDefinition)$/]";
     return {
-      ["Document[definitions.0.kind!=/^(OperationDefinition|FragmentDefinition)$/]"](node) {
-        let token = node.rawNode().loc.startToken;
-        for (; token; ) {
+      [selector](node) {
+        const rawNode = node.rawNode();
+        let token = rawNode.loc.startToken;
+        while (token) {
           const { kind, prev, next, value, line, column } = token;
           if (kind === TokenKind.COMMENT && prev && next) {
-            const isEslintComment = value.trimStart().startsWith("eslint"), linesAfter = next.line - line;
+            const isEslintComment = value.trimStart().startsWith("eslint");
+            const linesAfter = next.line - line;
             if (!isEslintComment && line !== prev.line && next.kind === TokenKind.NAME && linesAfter < 2) {
-              const sourceCode = context.getSourceCode(), { tokens } = sourceCode.ast, t = tokens.find(
+              const sourceCode = context.getSourceCode();
+              const { tokens } = sourceCode.ast;
+              const t = tokens.find(
                 (token2) => token2.loc.start.line === next.line && token2.loc.start.column === next.column - 1
-              ), nextNode = sourceCode.getNodeByRangeIndex(t.range[1] + 1);
+              );
+              const nextNode = sourceCode.getNodeByRangeIndex(t.range[1] + 1);
               context.report({
                 messageId: RULE_ID,
                 data: {
@@ -92,8 +99,9 @@ const RULE_ID = "HASHTAG_COMMENT", rule = {
               });
             }
           }
-          if (!next)
+          if (!next) {
             break;
+          }
           token = next;
         }
       }

package/esm/rules/no-one-place-fragments/index.js

@@ -1,7 +1,8 @@
 import { relative } from "node:path";
 import { visit } from "graphql";
 import { CWD, requireGraphQLOperations } from "../../utils.js";
-const RULE_ID = "no-one-place-fragments", rule = {
+const RULE_ID = "no-one-place-fragments";
+const rule = {
   meta: {
     type: "suggestion",
     docs: {
@@ -47,7 +48,7 @@ const RULE_ID = "no-one-place-fragments", rule = {
           )
         }
       ],
-      requiresSiblings: !0
+      requiresSiblings: true
     },
     messages: {
       [RULE_ID]: 'Fragment `{{fragmentName}}` used only once. Inline him in "{{filePath}}".'
@@ -55,24 +56,30 @@ const RULE_ID = "no-one-place-fragments", rule = {
     schema: []
   },
   create(context) {
-    const operations = requireGraphQLOperations(RULE_ID, context), allDocuments = [...operations.getOperations(), ...operations.getFragments()], usedFragmentsMap = /* @__PURE__ */ Object.create(null);
+    const operations = requireGraphQLOperations(RULE_ID, context);
+    const allDocuments = [...operations.getOperations(), ...operations.getFragments()];
+    const usedFragmentsMap = /* @__PURE__ */ Object.create(null);
     for (const { document, filePath } of allDocuments) {
       const relativeFilePath = relative(CWD, filePath);
       visit(document, {
         FragmentSpread({ name }) {
           const spreadName = name.value;
-          usedFragmentsMap[spreadName] ||= [], usedFragmentsMap[spreadName].push(relativeFilePath);
+          usedFragmentsMap[spreadName] ||= [];
+          usedFragmentsMap[spreadName].push(relativeFilePath);
         }
       });
     }
     return {
       "FragmentDefinition > Name"(node) {
-        const fragmentName = node.value, fragmentUsage = usedFragmentsMap[fragmentName];
-        fragmentUsage.length === 1 && context.report({
-          node,
-          messageId: RULE_ID,
-          data: { fragmentName, filePath: fragmentUsage[0] }
-        });
+        const fragmentName = node.value;
+        const fragmentUsage = usedFragmentsMap[fragmentName];
+        if (fragmentUsage.length === 1) {
+          context.report({
+            node,
+            messageId: RULE_ID,
+            data: { fragmentName, filePath: fragmentUsage[0] }
+          });
+        }
       }
     };
   }