@graphql-eslint/eslint-plugin 4.3.0 → 4.4.0-alpha-20241207210859-41eb4549764dc0314b5bd4f257ea6667b178540e

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

@@ -24,26 +24,33 @@ const KindToDisplayName = {
   [_graphql.Kind.OPERATION_DEFINITION]: "Operation",
   [_graphql.Kind.FRAGMENT_DEFINITION]: "Fragment",
   [_graphql.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: {
-          ..._utilsjs.ARRAY_DEFAULT_OPTIONS,
-          items: {
-            type: "object"
-          },
+        requiredPattern: {
+          type: "object",
           description: "Should be of instance of `RegEx`"
         },
         forbiddenPrefixes: {
           ..._utilsjs.ARRAY_DEFAULT_OPTIONS,
-          description: descriptionPrefixesSuffixes("forbiddenPatterns")
+          description: descriptionPrefixesSuffixes("forbiddenPatterns", "forbiddenpatterns-array")
         },
         forbiddenSuffixes: {
           ..._utilsjs.ARRAY_DEFAULT_OPTIONS,
-          description: descriptionPrefixesSuffixes("forbiddenPatterns")
+          description: descriptionPrefixesSuffixes("forbiddenPatterns", "forbiddenpatterns-array")
         },
         requiredPrefixes: {
           ..._utilsjs.ARRAY_DEFAULT_OPTIONS,
-          description: descriptionPrefixesSuffixes("requiredPatterns")
+          description: descriptionPrefixesSuffixes("requiredPattern", "requiredpattern-object")
         },
         requiredSuffixes: {
           ..._utilsjs.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:
-${_utilsjs.TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
-`)}`
+${_utilsjs.TYPES_KINDS.map((kind) => `- \`${kind}\``).join("\n")}`
       },
       ...Object.fromEntries(
         ALLOWED_KINDS.map((kind) => [
@@ -108,11 +111,11 @@ ${_utilsjs.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 @@ ${_utilsjs.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 = exports.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: [
         {
@@ -150,7 +153,14 @@ ${_utilsjs.TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         },
         {
           title: "Incorrect",
-          usage: [{ FragmentDefinition: { style: "PascalCase", forbiddenSuffixes: ["Fragment"] } }],
+          usage: [
+            {
+              FragmentDefinition: {
+                style: "PascalCase",
+                forbiddenPatterns: [/(^fragment)|(fragment$)/i]
+              }
+            }
+          ],
           code: (
             /* GraphQL */
             `
@@ -162,7 +172,7 @@ ${_utilsjs.TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         },
         {
           title: "Incorrect",
-          usage: [{ "FieldDefinition[parent.name.value=Query]": { forbiddenPrefixes: ["get"] } }],
+          usage: [{ "FieldDefinition[parent.name.value=Query]": { forbiddenPatterns: [/^get/i] } }],
           code: (
             /* GraphQL */
             `
@@ -186,7 +196,14 @@ ${_utilsjs.TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         },
         {
           title: "Correct",
-          usage: [{ FragmentDefinition: { style: "PascalCase", forbiddenSuffixes: ["Fragment"] } }],
+          usage: [
+            {
+              FragmentDefinition: {
+                style: "PascalCase",
+                forbiddenPatterns: [/(^fragment)|(fragment$)/i]
+              }
+            }
+          ],
           code: (
             /* GraphQL */
             `
@@ -198,7 +215,7 @@ ${_utilsjs.TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         },
         {
           title: "Correct",
-          usage: [{ "FieldDefinition[parent.name.value=Query]": { forbiddenPrefixes: ["get"] } }],
+          usage: [{ "FieldDefinition[parent.name.value=Query]": { forbiddenPatterns: [/^get/i] } }],
           code: (
             /* GraphQL */
             `
@@ -228,11 +245,11 @@ ${_utilsjs.TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
             {
               "FieldDefinition[gqlType.name.value=Boolean]": {
                 style: "camelCase",
-                requiredPrefixes: ["is", "has"]
+                requiredPattern: /^(is|has)/
               },
               "FieldDefinition[gqlType.gqlType.name.value=Boolean]": {
                 style: "camelCase",
-                requiredPrefixes: ["is", "has"]
+                requiredPattern: /^(is|has)/
               }
             }
           ],
@@ -253,7 +270,7 @@ ${_utilsjs.TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
             {
               "FieldDefinition[gqlType.gqlType.name.value=SensitiveSecret]": {
                 style: "camelCase",
-                requiredSuffixes: ["SensitiveSecret"]
+                requiredPattern: /SensitiveSecret$/
               }
             }
           ],
@@ -267,6 +284,30 @@ ${_utilsjs.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: {
@@ -279,32 +320,25 @@ ${_utilsjs.TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
             DirectiveDefinition: "camelCase",
             EnumValueDefinition: "UPPER_CASE",
             "FieldDefinition[parent.name.value=Query]": {
-              forbiddenPrefixes: ["query", "get"],
-              forbiddenSuffixes: ["Query"]
+              forbiddenPatterns: [/^(query|get)/i, /query$/i]
             },
             "FieldDefinition[parent.name.value=Mutation]": {
-              forbiddenPrefixes: ["mutation"],
-              forbiddenSuffixes: ["Mutation"]
+              forbiddenPatterns: [/(^mutation)|(mutation$)/i]
             },
             "FieldDefinition[parent.name.value=Subscription]": {
-              forbiddenPrefixes: ["subscription"],
-              forbiddenSuffixes: ["Subscription"]
+              forbiddenPatterns: [/(^subscription)|(subscription$)/i]
             },
             "EnumTypeDefinition,EnumTypeExtension": {
-              forbiddenPrefixes: ["Enum"],
-              forbiddenSuffixes: ["Enum"]
+              forbiddenPatterns: [/(^enum)|(enum$)/i]
             },
             "InterfaceTypeDefinition,InterfaceTypeExtension": {
-              forbiddenPrefixes: ["Interface"],
-              forbiddenSuffixes: ["Interface"]
+              forbiddenPatterns: [/(^interface)|(interface$)/i]
             },
             "UnionTypeDefinition,UnionTypeExtension": {
-              forbiddenPrefixes: ["Union"],
-              forbiddenSuffixes: ["Union"]
+              forbiddenPatterns: [/(^union)|(union$)/i]
             },
             "ObjectTypeDefinition,ObjectTypeExtension": {
-              forbiddenPrefixes: ["Type"],
-              forbiddenSuffixes: ["Type"]
+              forbiddenPatterns: [/(^type)|(type$)/i]
             }
           }
         ],
@@ -313,26 +347,29 @@ ${_utilsjs.TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
             VariableDefinition: "camelCase",
             OperationDefinition: {
               style: "PascalCase",
-              forbiddenPrefixes: ["Query", "Mutation", "Subscription", "Get"],
-              forbiddenSuffixes: ["Query", "Mutation", "Subscription"]
+              forbiddenPatterns: [
+                /^(query|mutation|subscription|get)/i,
+                /(query|mutation|subscription)$/i
+              ]
             },
             FragmentDefinition: {
               style: "PascalCase",
-              forbiddenPrefixes: ["Fragment"],
-              forbiddenSuffixes: ["Fragment"]
+              forbiddenPatterns: [/(^fragment)|(fragment$)/i]
             }
           }
         ]
       }
     },
-    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 +383,9 @@ ${_utilsjs.TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
     }
     const checkNode = (selector) => (n) => {
       const { name: node } = n.kind === _graphql.Kind.VARIABLE_DEFINITION ? n.variable : n;
-      if (!node)
+      if (!node) {
         return;
+      }
       const {
         prefix,
         suffix,
@@ -358,12 +396,18 @@ ${_utilsjs.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 = _utilsjs.displayNodeName.call(void 0, n);
+        );
+        const name = _utilsjs.displayNodeName.call(void 0, n);
         report(
           node,
           `${name[0].toUpperCase()}${name.slice(1)} should ${errorMessage}`,
@@ -371,80 +415,133 @@ ${_utilsjs.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 === _utilsjs.convertCase.call(void 0, 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 = _optionalChain([forbiddenPatterns, 'optionalAccess', _ => _.find, 'call', _2 => _2((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: ${_utilsjs.englishJoinWords.call(void 0, requiredPatterns.map((re) => re.source))}`,
-            renameToNames: []
-          };
+        }
         const forbiddenPrefix = _optionalChain([forbiddenPrefixes, 'optionalAccess', _3 => _3.find, 'call', _4 => _4((prefix2) => name.startsWith(prefix2))]);
-        if (forbiddenPrefix)
+        if (forbiddenPrefix) {
           return {
             errorMessage: `not have "${forbiddenPrefix}" prefix`,
             renameToNames: [name.replace(new RegExp(`^${forbiddenPrefix}`), "")]
           };
+        }
         const forbiddenSuffix = _optionalChain([forbiddenSuffixes, 'optionalAccess', _5 => _5.find, 'call', _6 => _6((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: ${_utilsjs.englishJoinWords.call(void 0, 
               requiredPrefixes
             )}`,
             renameToNames: style ? requiredPrefixes.map((prefix2) => _utilsjs.convertCase.call(void 0, 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: ${_utilsjs.englishJoinWords.call(void 0, 
               requiredSuffixes
             )}`,
             renameToNames: style ? requiredSuffixes.map((suffix2) => _utilsjs.convertCase.call(void 0, 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: [_utilsjs.convertCase.call(void 0, style, name)]
           };
+        }
+      }
+    };
+    const checkUnderscore = (isLeading) => (node) => {
+      if (ignoredNodes.has(node)) {
+        return;
       }
-    }, checkUnderscore = (isLeading) => (node) => {
-      if (ignoredNodes.has(node) || node.parent.kind === "Field" && node.parent.alias !== node)
+      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 && _utilsjs.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/cjs/rules/no-anonymous-operations/index.js

@@ -1,13 +1,14 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});var _graphql = require('graphql');
 var _utilsjs = require('../../utils.js');
-const RULE_ID = "no-anonymous-operations", rule = exports.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 = exports.rule = {
   create(context) {
     return {
       "OperationDefinition[name=undefined]"(node) {
-        const [firstSelection] = node.selectionSet.selections, suggestedName = firstSelection.kind === _graphql.Kind.FIELD ? (firstSelection.alias || firstSelection.name).value : node.operation;
+        const [firstSelection] = node.selectionSet.selections;
+        const suggestedName = firstSelection.kind === _graphql.Kind.FIELD ? (firstSelection.alias || firstSelection.name).value : node.operation;
         context.report({
           loc: _utilsjs.getLocation.call(void 0, node.loc.start, node.operation),
           messageId: RULE_ID,
@@ -53,7 +55,8 @@ const RULE_ID = "no-anonymous-operations", rule = exports.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/cjs/rules/no-deprecated/index.js

@@ -1,13 +1,14 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var _utilsjs = require('../../utils.js');
-const RULE_ID = "no-deprecated", rule = exports.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 = exports.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 = exports.rule = {
     }
     return {
       EnumValue(node) {
-        const reason = _optionalChain([node, 'access', _ => _.typeInfo, 'call', _2 => _2(), 'access', _3 => _3.enumValue, 'optionalAccess', _4 => _4.deprecationReason]);
-        reason && report(node, reason);
+        const typeInfo = node.typeInfo();
+        const reason = _optionalChain([typeInfo, 'access', _ => _.enumValue, 'optionalAccess', _2 => _2.deprecationReason]);
+        if (reason) {
+          report(node, reason);
+        }
       },
       Field(node) {
-        const reason = _optionalChain([node, 'access', _5 => _5.typeInfo, 'call', _6 => _6(), 'access', _7 => _7.fieldDef, 'optionalAccess', _8 => _8.deprecationReason]);
-        reason && report(node, reason);
+        const typeInfo = node.typeInfo();
+        const reason = _optionalChain([typeInfo, 'access', _3 => _3.fieldDef, 'optionalAccess', _4 => _4.deprecationReason]);
+        if (reason) {
+          report(node, reason);
+        }
       },
       Argument(node) {
-        const reason = _optionalChain([node, 'access', _9 => _9.typeInfo, 'call', _10 => _10(), 'access', _11 => _11.argument, 'optionalAccess', _12 => _12.deprecationReason]);
-        reason && report(node, reason);
+        const typeInfo = node.typeInfo();
+        const reason = _optionalChain([typeInfo, 'access', _5 => _5.argument, 'optionalAccess', _6 => _6.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/cjs/rules/no-duplicate-fields/index.js

@@ -1,13 +1,14 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});var _graphql = require('graphql');
-const RULE_ID = "no-duplicate-fields", rule = exports.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 = exports.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 === _graphql.Kind.FIELD && checkNode(set, selection.alias || selection.name);
+        for (const selection of node.selections) {
+          if (selection.kind === _graphql.Kind.FIELD) {
+            checkNode(set, selection.alias || selection.name);
+          }
+        }
       }
     };
   }