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

package/cjs/rules/input-name/index.js

@@ -6,46 +6,49 @@ const schema = {
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     properties: {
       checkInputType: {
         type: "boolean",
-        default: !1,
+        default: false,
         description: "Check that the input type name follows the convention \\<mutationName>Input"
       },
       caseSensitiveInputType: {
         type: "boolean",
-        default: !0,
+        default: true,
         description: "Allow for case discrepancies in the input type name"
       },
       checkQueries: {
         type: "boolean",
-        default: !1,
+        default: false,
         description: "Apply the rule to Queries"
       },
       checkMutations: {
         type: "boolean",
-        default: !0,
+        default: true,
         description: "Apply the rule to Mutations"
       }
     }
   }
-}, isObjectType = (node) => (
+};
+const isObjectType = (node) => (
   // TODO: remove `as any` when drop support of graphql@15
   [_graphql.Kind.OBJECT_TYPE_DEFINITION, _graphql.Kind.OBJECT_TYPE_EXTENSION].includes(node.type)
-), isQueryType = (node) => isObjectType(node) && node.name.value === "Query", isMutationType = (node) => isObjectType(node) && node.name.value === "Mutation", rule = exports.rule = {
+);
+const isQueryType = (node) => isObjectType(node) && node.name.value === "Query";
+const isMutationType = (node) => isObjectType(node) && node.name.value === "Mutation";
+const rule = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
-      description: `Require mutation argument to be always called "input" and input type to be called Mutation name + "Input".
-Using the same name for all input parameters will make your schemas easier to consume and more predictable. Using the same name as mutation for InputType will make it easier to find mutations that InputType belongs to.`,
+      description: 'Require mutation argument to be always called "input" and input type to be called Mutation name + "Input".\nUsing the same name for all input parameters will make your schemas easier to consume and more predictable. Using the same name as mutation for InputType will make it easier to find mutations that InputType belongs to.',
       category: "Schema",
       url: "https://the-guild.dev/graphql/eslint/rules/input-name",
       examples: [
         {
           title: "Incorrect",
-          usage: [{ checkInputType: !0 }],
+          usage: [{ checkInputType: true }],
           code: (
             /* GraphQL */
             `
@@ -57,7 +60,7 @@ Using the same name for all input parameters will make your schemas easier to co
         },
         {
           title: "Correct (with `checkInputType`)",
-          usage: [{ checkInputType: !0 }],
+          usage: [{ checkInputType: true }],
           code: (
             /* GraphQL */
             `
@@ -69,7 +72,7 @@ Using the same name for all input parameters will make your schemas easier to co
         },
         {
           title: "Correct (without `checkInputType`)",
-          usage: [{ checkInputType: !1 }],
+          usage: [{ checkInputType: false }],
           code: (
             /* GraphQL */
             `
@@ -85,11 +88,13 @@ Using the same name for all input parameters will make your schemas easier to co
   },
   create(context) {
     const options = {
-      checkInputType: !1,
-      caseSensitiveInputType: !0,
-      checkMutations: !0,
+      checkInputType: false,
+      caseSensitiveInputType: true,
+      checkMutations: true,
       ...context.options[0]
-    }, shouldCheckType = (node) => options.checkMutations && isMutationType(node) || options.checkQueries && isQueryType(node) || !1, listeners = {
+    };
+    const shouldCheckType = (node) => options.checkMutations && isMutationType(node) || options.checkQueries && isQueryType(node) || false;
+    const listeners = {
       "FieldDefinition > InputValueDefinition[name.value!=input] > Name"(node) {
         const fieldDef = node.parent.parent;
         if (shouldCheckType(fieldDef.parent)) {
@@ -107,27 +112,35 @@ Using the same name for all input parameters will make your schemas easier to co
         }
       }
     };
-    return options.checkInputType && (listeners["FieldDefinition > InputValueDefinition NamedType"] = (node) => {
-      const inputValueNode = ((item) => {
-        let currentNode = item;
-        for (; currentNode.type !== _graphql.Kind.INPUT_VALUE_DEFINITION; )
-          currentNode = currentNode.parent;
-        return currentNode;
-      })(node);
-      if (shouldCheckType(inputValueNode.parent.parent)) {
-        const mutationName = `${inputValueNode.parent.name.value}Input`, name = node.name.value;
-        (options.caseSensitiveInputType && node.name.value !== mutationName || name.toLowerCase() !== mutationName.toLowerCase()) && context.report({
-          node: node.name,
-          message: `Input type \`${name}\` name should be \`${mutationName}\`.`,
-          suggest: [
-            {
-              desc: `Rename to \`${mutationName}\``,
-              fix: (fixer) => fixer.replaceText(node, mutationName)
-            }
-          ]
-        });
-      }
-    }), listeners;
+    if (options.checkInputType) {
+      listeners["FieldDefinition > InputValueDefinition NamedType"] = (node) => {
+        const findInputType = (item) => {
+          let currentNode = item;
+          while (currentNode.type !== _graphql.Kind.INPUT_VALUE_DEFINITION) {
+            currentNode = currentNode.parent;
+          }
+          return currentNode;
+        };
+        const inputValueNode = findInputType(node);
+        if (shouldCheckType(inputValueNode.parent.parent)) {
+          const mutationName = `${inputValueNode.parent.name.value}Input`;
+          const name = node.name.value;
+          if (options.caseSensitiveInputType && node.name.value !== mutationName || name.toLowerCase() !== mutationName.toLowerCase()) {
+            context.report({
+              node: node.name,
+              message: `Input type \`${name}\` name should be \`${mutationName}\`.`,
+              suggest: [
+                {
+                  desc: `Rename to \`${mutationName}\``,
+                  fix: (fixer) => fixer.replaceText(node, mutationName)
+                }
+              ]
+            });
+          }
+        }
+      };
+    }
+    return listeners;
   }
 };
 

package/cjs/rules/lone-executable-definition/index.js

@@ -1,12 +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 _graphql = require('graphql');
 var _utilsjs = require('../../utils.js');
-const RULE_ID = "lone-executable-definition", definitionTypes = ["fragment", ...Object.values(_graphql.OperationTypeNode)], schema = {
+const RULE_ID = "lone-executable-definition";
+const definitionTypes = ["fragment", ...Object.values(_graphql.OperationTypeNode)];
+const schema = {
   type: "array",
   maxItems: 1,
   items: {
     type: "object",
     minProperties: 1,
-    additionalProperties: !1,
+    additionalProperties: false,
     properties: {
       ignore: {
         ..._utilsjs.ARRAY_DEFAULT_OPTIONS,
@@ -19,7 +21,8 @@ const RULE_ID = "lone-executable-definition", definitionTypes = ["fragment", ...
       }
     }
   }
-}, rule = exports.rule = {
+};
+const rule = {
   meta: {
     type: "suggestion",
     docs: {
@@ -60,17 +63,23 @@ const RULE_ID = "lone-executable-definition", definitionTypes = ["fragment", ...
     schema
   },
   create(context) {
-    const ignore = new Set(_optionalChain([context, 'access', _ => _.options, 'access', _2 => _2[0], 'optionalAccess', _3 => _3.ignore]) || []), definitions = [];
+    const ignore = new Set(_optionalChain([context, 'access', _ => _.options, 'access', _2 => _2[0], 'optionalAccess', _3 => _3.ignore]) || []);
+    const definitions = [];
     return {
       ":matches(OperationDefinition, FragmentDefinition)"(node) {
         const type = "operation" in node ? node.operation : "fragment";
-        ignore.has(type) || definitions.push({ type, node });
+        if (!ignore.has(type)) {
+          definitions.push({ type, node });
+        }
       },
       "Document:exit"() {
         for (const { node, type } of definitions.slice(1)) {
           let name = _utilsjs.pascalCase.call(void 0, type);
           const definitionName = _optionalChain([node, 'access', _4 => _4.name, 'optionalAccess', _5 => _5.value]);
-          definitionName && (name += ` "${definitionName}"`), context.report({
+          if (definitionName) {
+            name += ` "${definitionName}"`;
+          }
+          context.report({
             loc: _optionalChain([node, 'access', _6 => _6.name, 'optionalAccess', _7 => _7.loc]) || _utilsjs.getLocation.call(void 0, node.loc.start, type),
             messageId: RULE_ID,
             data: { name }

package/cjs/rules/match-document-filename/index.d.cts

@@ -13,8 +13,8 @@ type CaseStyle = CaseStyle$1 | 'matchDocumentStyle';
 declare const schema: {
     readonly definitions: {
         readonly asString: {
-            readonly enum: CaseStyle[];
-            readonly description: `One of: ${string}`;
+            enum: CaseStyle[];
+            description: string;
         };
         readonly asObject: {
             readonly type: "object";
@@ -22,7 +22,8 @@ declare const schema: {
             readonly minProperties: 1;
             readonly properties: {
                 readonly style: {
-                    readonly enum: CaseStyle[];
+                    enum: CaseStyle[];
+                    description: string;
                 };
                 readonly suffix: {
                     readonly type: "string";

package/cjs/rules/match-document-filename/index.js

@@ -5,27 +5,32 @@ var _graphql = require('graphql');
 
 
 var _utilsjs = require('../../utils.js');
-const MATCH_EXTENSION = "MATCH_EXTENSION", MATCH_STYLE = "MATCH_STYLE", CASE_STYLES = [
+const MATCH_EXTENSION = "MATCH_EXTENSION";
+const MATCH_STYLE = "MATCH_STYLE";
+const CASE_STYLES = [
   "camelCase",
   "PascalCase",
   "snake_case",
   "UPPER_CASE",
   "kebab-case",
   "matchDocumentStyle"
-], schemaOption = {
+];
+const schemaOption = {
   oneOf: [{ $ref: "#/definitions/asString" }, { $ref: "#/definitions/asObject" }]
-}, schema = {
+};
+const caseSchema = {
+  enum: CASE_STYLES,
+  description: `One of: ${CASE_STYLES.map((t) => `\`${t}\``).join(", ")}`
+};
+const schema = {
   definitions: {
-    asString: {
-      enum: CASE_STYLES,
-      description: `One of: ${CASE_STYLES.map((t) => `\`${t}\``).join(", ")}`
-    },
+    asString: caseSchema,
     asObject: {
       type: "object",
-      additionalProperties: !1,
+      additionalProperties: false,
       minProperties: 1,
       properties: {
-        style: { enum: CASE_STYLES },
+        style: caseSchema,
         suffix: { type: "string" },
         prefix: { type: "string" }
       }
@@ -36,7 +41,7 @@ const MATCH_EXTENSION = "MATCH_EXTENSION", MATCH_STYLE = "MATCH_STYLE", CASE_STY
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     minProperties: 1,
     properties: {
       fileExtension: { enum: [".gql", ".graphql"] },
@@ -46,7 +51,8 @@ const MATCH_EXTENSION = "MATCH_EXTENSION", MATCH_STYLE = "MATCH_STYLE", CASE_STY
       fragment: schemaOption
     }
   }
-}, rule = exports.rule = {
+};
+const rule = {
   meta: {
     type: "suggestion",
     docs: {
@@ -186,47 +192,67 @@ const MATCH_EXTENSION = "MATCH_EXTENSION", MATCH_STYLE = "MATCH_STYLE", CASE_STY
   create(context) {
     const options = context.options[0] || {
       fileExtension: null
-    }, filePath = context.filename, isVirtualFile = _utilsjs.VIRTUAL_DOCUMENT_REGEX.test(filePath);
-    if (process.env.NODE_ENV !== "test" && isVirtualFile)
+    };
+    const filePath = context.filename;
+    const isVirtualFile = _utilsjs.VIRTUAL_DOCUMENT_REGEX.test(filePath);
+    if (process.env.NODE_ENV !== "test" && isVirtualFile) {
       return {};
-    const fileExtension = _nodepath.extname.call(void 0, filePath), filename = _nodepath.basename.call(void 0, filePath, fileExtension);
+    }
+    const fileExtension = _nodepath.extname.call(void 0, filePath);
+    const filename = _nodepath.basename.call(void 0, filePath, fileExtension);
     return {
       Document(documentNode) {
-        options.fileExtension && options.fileExtension !== fileExtension && context.report({
-          loc: _utilsjs.REPORT_ON_FIRST_CHARACTER,
-          messageId: MATCH_EXTENSION,
-          data: {
-            fileExtension,
-            expectedFileExtension: options.fileExtension
-          }
-        });
+        if (options.fileExtension && options.fileExtension !== fileExtension) {
+          context.report({
+            loc: _utilsjs.REPORT_ON_FIRST_CHARACTER,
+            messageId: MATCH_EXTENSION,
+            data: {
+              fileExtension,
+              expectedFileExtension: options.fileExtension
+            }
+          });
+        }
         const firstOperation = documentNode.definitions.find(
           (n) => n.kind === _graphql.Kind.OPERATION_DEFINITION
-        ), firstFragment = documentNode.definitions.find(
+        );
+        const firstFragment = documentNode.definitions.find(
           (n) => n.kind === _graphql.Kind.FRAGMENT_DEFINITION
-        ), node = firstOperation || firstFragment;
-        if (!node)
+        );
+        const node = firstOperation || firstFragment;
+        if (!node) {
           return;
+        }
         const docName = _optionalChain([node, 'access', _ => _.name, 'optionalAccess', _2 => _2.value]);
-        if (!docName)
+        if (!docName) {
           return;
+        }
         const docType = "operation" in node ? node.operation : "fragment";
         let option = options[docType];
-        if (!option)
+        if (!option) {
           return;
-        typeof option == "string" && (option = { style: option });
+        }
+        if (typeof option === "string") {
+          option = { style: option };
+        }
         const expectedExtension = options.fileExtension || fileExtension;
         let expectedFilename = option.prefix || "";
-        option.style ? expectedFilename += option.style === "matchDocumentStyle" ? docName : _utilsjs.convertCase.call(void 0, option.style, docName) : expectedFilename += filename, expectedFilename += (option.suffix || "") + expectedExtension;
+        if (option.style) {
+          expectedFilename += option.style === "matchDocumentStyle" ? docName : _utilsjs.convertCase.call(void 0, option.style, docName);
+        } else {
+          expectedFilename += filename;
+        }
+        expectedFilename += (option.suffix || "") + expectedExtension;
         const filenameWithExtension = filename + expectedExtension;
-        expectedFilename !== filenameWithExtension && context.report({
-          loc: _utilsjs.REPORT_ON_FIRST_CHARACTER,
-          messageId: MATCH_STYLE,
-          data: {
-            expectedFilename,
-            filename: filenameWithExtension
-          }
-        });
+        if (expectedFilename !== filenameWithExtension) {
+          context.report({
+            loc: _utilsjs.REPORT_ON_FIRST_CHARACTER,
+            messageId: MATCH_STYLE,
+            data: {
+              expectedFilename,
+              filename: filenameWithExtension
+            }
+          });
+        }
       }
     };
   }

package/cjs/rules/naming-convention/index.d.cts

@@ -12,15 +12,16 @@ type AllowedStyle = 'camelCase' | 'PascalCase' | 'snake_case' | 'UPPER_CASE';
 declare const schema: {
     readonly definitions: {
         readonly asString: {
-            readonly enum: AllowedStyle[];
-            readonly description: `One of: ${string}`;
+            enum: AllowedStyle[];
+            description: string;
         };
         readonly asObject: {
             readonly type: "object";
             readonly additionalProperties: false;
             readonly properties: {
                 readonly style: {
-                    readonly enum: AllowedStyle[];
+                    enum: AllowedStyle[];
+                    description: string;
                 };
                 readonly prefix: {
                     readonly type: "string";
@@ -37,14 +38,9 @@ declare const schema: {
                     readonly uniqueItems: true;
                     readonly minItems: 1;
                 };
-                readonly requiredPatterns: {
-                    readonly items: {
-                        readonly type: "object";
-                    };
+                readonly requiredPattern: {
+                    readonly type: "object";
                     readonly description: "Should be of instance of `RegEx`";
-                    readonly type: "array";
-                    readonly uniqueItems: true;
-                    readonly minItems: 1;
                 };
                 readonly forbiddenPrefixes: {
                     readonly description: string;