@graphql-eslint/eslint-plugin 3.19.3-alpha-20230702093957-98f7783 → 3.20.0-alpha-20230703154330-0d51273

package/esm/rules/index.d.mts

@@ -0,0 +1,125 @@
+import { RuleOptions } from './require-description.mjs';
+import { CaseStyle } from '../utils.mjs';
+import { i as GraphQLESLintRule } from '../types-2e1afd7c.js';
+import * as json_schema_to_ts_lib_types_type_utils_writable_js from 'json-schema-to-ts/lib/types/type-utils/writable.js';
+import 'graphql';
+import 'eslint';
+import 'estree';
+import '../estree-converter/types.mjs';
+import '@graphql-tools/utils';
+import 'graphql-config';
+import 'json-schema-to-ts';
+
+declare const rules: {
+    alphabetize: GraphQLESLintRule<{
+        definitions?: boolean | undefined;
+        selections?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<"OperationDefinition" | "FragmentDefinition">[] | undefined;
+        arguments?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<"Field" | "Directive" | "FieldDefinition" | "DirectiveDefinition">[] | undefined;
+        values?: "EnumTypeDefinition"[] | undefined;
+        fields?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<"ObjectTypeDefinition" | "InterfaceTypeDefinition" | "InputObjectTypeDefinition">[] | undefined;
+        variables?: "OperationDefinition"[] | undefined;
+        groups?: string[] | undefined;
+    }[]>;
+    'description-style': GraphQLESLintRule<{
+        style?: "block" | "inline" | undefined;
+    }[]>;
+    'input-name': GraphQLESLintRule<{
+        checkInputType?: boolean | undefined;
+        caseSensitiveInputType?: boolean | undefined;
+        checkQueries?: boolean | undefined;
+        checkMutations?: boolean | undefined;
+    }[]>;
+    'lone-executable-definition': GraphQLESLintRule<{
+        ignore?: ("fragment" | "query" | "mutation" | "subscription")[] | undefined;
+    }[]>;
+    'match-document-filename': GraphQLESLintRule<{
+        fragment?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<CaseStyle | "matchDocumentStyle"> | {
+            style?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<CaseStyle | "matchDocumentStyle"> | undefined;
+            suffix?: string | undefined;
+            prefix?: string | undefined;
+        } | undefined;
+        query?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<CaseStyle | "matchDocumentStyle"> | {
+            style?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<CaseStyle | "matchDocumentStyle"> | undefined;
+            suffix?: string | undefined;
+            prefix?: string | undefined;
+        } | undefined;
+        mutation?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<CaseStyle | "matchDocumentStyle"> | {
+            style?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<CaseStyle | "matchDocumentStyle"> | undefined;
+            suffix?: string | undefined;
+            prefix?: string | undefined;
+        } | undefined;
+        subscription?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<CaseStyle | "matchDocumentStyle"> | {
+            style?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<CaseStyle | "matchDocumentStyle"> | undefined;
+            suffix?: string | undefined;
+            prefix?: string | undefined;
+        } | undefined;
+        fileExtension?: ".gql" | ".graphql" | undefined;
+    }[]>;
+    'naming-convention': GraphQLESLintRule<{
+        [x: string]: unknown;
+        types?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<"camelCase" | "PascalCase" | "snake_case" | "UPPER_CASE"> | {
+            style?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<"camelCase" | "PascalCase" | "snake_case" | "UPPER_CASE"> | undefined;
+            suffix?: string | undefined;
+            prefix?: string | undefined;
+            forbiddenPrefixes?: string[] | undefined;
+            forbiddenSuffixes?: string[] | undefined;
+            requiredPrefixes?: string[] | undefined;
+            requiredSuffixes?: string[] | undefined;
+            ignorePattern?: string | undefined;
+        } | undefined;
+        allowLeadingUnderscore?: boolean | undefined;
+        allowTrailingUnderscore?: boolean | undefined;
+    }[]>;
+    'no-anonymous-operations': GraphQLESLintRule;
+    'no-case-insensitive-enum-values-duplicates': GraphQLESLintRule;
+    'no-deprecated': GraphQLESLintRule<[], true>;
+    'no-duplicate-fields': GraphQLESLintRule;
+    'no-hashtag-description': GraphQLESLintRule;
+    'no-one-place-fragments': GraphQLESLintRule;
+    'no-root-type': GraphQLESLintRule<{
+        disallow: ("mutation" | "subscription")[];
+    }[]>;
+    'no-scalar-result-type-on-mutation': GraphQLESLintRule;
+    'no-typename-prefix': GraphQLESLintRule;
+    'no-unreachable-types': GraphQLESLintRule;
+    'no-unused-fields': GraphQLESLintRule;
+    'relay-arguments': GraphQLESLintRule<{
+        includeBoth?: boolean | undefined;
+    }[], true>;
+    'relay-connection-types': GraphQLESLintRule;
+    'relay-edge-types': GraphQLESLintRule<{
+        withEdgeSuffix?: boolean | undefined;
+        shouldImplementNode?: boolean | undefined;
+        listTypeCanWrapOnlyEdgeType?: boolean | undefined;
+    }[], true>;
+    'relay-page-info': GraphQLESLintRule;
+    'require-deprecation-date': GraphQLESLintRule<{
+        argumentName?: string | undefined;
+    }[]>;
+    'require-deprecation-reason': GraphQLESLintRule;
+    'require-description': GraphQLESLintRule<RuleOptions>;
+    'require-field-of-type-query-in-mutation-result': GraphQLESLintRule;
+    'require-id-when-available': GraphQLESLintRule<{
+        fieldName?: string | string[] | undefined;
+    }[], true>;
+    'require-import-fragment': GraphQLESLintRule;
+    'require-nullable-fields-with-oneof': GraphQLESLintRule;
+    'require-nullable-result-in-root': GraphQLESLintRule;
+    'require-type-pattern-with-oneof': GraphQLESLintRule;
+    'selection-set-depth': GraphQLESLintRule<{
+        ignore?: string[] | undefined;
+        maxDepth: number;
+    }[]>;
+    'strict-id-in-types': GraphQLESLintRule<{
+        acceptedIdNames?: string[] | undefined;
+        acceptedIdTypes?: string[] | undefined;
+        exceptions?: {
+            types?: string[] | undefined;
+            suffixes?: string[] | undefined;
+        } | undefined;
+    }[]>;
+    'unique-fragment-name': GraphQLESLintRule;
+    'unique-operation-name': GraphQLESLintRule;
+};
+
+export { rules };

package/esm/rules/index.js

@@ -1,75 +1,75 @@
-/*
- * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
- */
-import { GRAPHQL_JS_VALIDATIONS } from './graphql-js-validation.js';
-import { rule as alphabetize } from './alphabetize.js';
-import { rule as descriptionStyle } from './description-style.js';
-import { rule as inputName } from './input-name.js';
-import { rule as loneExecutableDefinition } from './lone-executable-definition.js';
-import { rule as matchDocumentFilename } from './match-document-filename.js';
-import { rule as namingConvention } from './naming-convention.js';
-import { rule as noAnonymousOperations } from './no-anonymous-operations.js';
-import { rule as noCaseInsensitiveEnumValuesDuplicates } from './no-case-insensitive-enum-values-duplicates.js';
-import { rule as noDeprecated } from './no-deprecated.js';
-import { rule as noDuplicateFields } from './no-duplicate-fields.js';
-import { rule as noHashtagDescription } from './no-hashtag-description.js';
-import { rule as noOnePlaceFragments } from './no-one-place-fragments.js';
-import { rule as noRootType } from './no-root-type.js';
-import { rule as noScalarResultTypeOnMutation } from './no-scalar-result-type-on-mutation.js';
-import { rule as noTypenamePrefix } from './no-typename-prefix.js';
-import { rule as noUnreachableTypes } from './no-unreachable-types.js';
-import { rule as noUnusedFields } from './no-unused-fields.js';
-import { rule as relayArguments } from './relay-arguments.js';
-import { rule as relayConnectionTypes } from './relay-connection-types.js';
-import { rule as relayEdgeTypes } from './relay-edge-types.js';
-import { rule as relayPageInfo } from './relay-page-info.js';
-import { rule as requireDeprecationDate } from './require-deprecation-date.js';
-import { rule as requireDeprecationReason } from './require-deprecation-reason.js';
-import { rule as requireDescription } from './require-description.js';
-import { rule as requireFieldOfTypeQueryInMutationResult } from './require-field-of-type-query-in-mutation-result.js';
-import { rule as requireIdWhenAvailable } from './require-id-when-available.js';
-import { rule as requireImportFragment } from './require-import-fragment.js';
-import { rule as requireNullableFieldsWithOneof } from './require-nullable-fields-with-oneof.js';
-import { rule as requireNullableResultInRoot } from './require-nullable-result-in-root.js';
-import { rule as requireTypePatternWithOneof } from './require-type-pattern-with-oneof.js';
-import { rule as selectionSetDepth } from './selection-set-depth.js';
-import { rule as strictIdInTypes } from './strict-id-in-types.js';
-import { rule as uniqueFragmentName } from './unique-fragment-name.js';
-import { rule as uniqueOperationName } from './unique-operation-name.js';
-export const rules = {
-    ...GRAPHQL_JS_VALIDATIONS,
-    alphabetize,
-    'description-style': descriptionStyle,
-    'input-name': inputName,
-    'lone-executable-definition': loneExecutableDefinition,
-    'match-document-filename': matchDocumentFilename,
-    'naming-convention': namingConvention,
-    'no-anonymous-operations': noAnonymousOperations,
-    'no-case-insensitive-enum-values-duplicates': noCaseInsensitiveEnumValuesDuplicates,
-    'no-deprecated': noDeprecated,
-    'no-duplicate-fields': noDuplicateFields,
-    'no-hashtag-description': noHashtagDescription,
-    'no-one-place-fragments': noOnePlaceFragments,
-    'no-root-type': noRootType,
-    'no-scalar-result-type-on-mutation': noScalarResultTypeOnMutation,
-    'no-typename-prefix': noTypenamePrefix,
-    'no-unreachable-types': noUnreachableTypes,
-    'no-unused-fields': noUnusedFields,
-    'relay-arguments': relayArguments,
-    'relay-connection-types': relayConnectionTypes,
-    'relay-edge-types': relayEdgeTypes,
-    'relay-page-info': relayPageInfo,
-    'require-deprecation-date': requireDeprecationDate,
-    'require-deprecation-reason': requireDeprecationReason,
-    'require-description': requireDescription,
-    'require-field-of-type-query-in-mutation-result': requireFieldOfTypeQueryInMutationResult,
-    'require-id-when-available': requireIdWhenAvailable,
-    'require-import-fragment': requireImportFragment,
-    'require-nullable-fields-with-oneof': requireNullableFieldsWithOneof,
-    'require-nullable-result-in-root': requireNullableResultInRoot,
-    'require-type-pattern-with-oneof': requireTypePatternWithOneof,
-    'selection-set-depth': selectionSetDepth,
-    'strict-id-in-types': strictIdInTypes,
-    'unique-fragment-name': uniqueFragmentName,
-    'unique-operation-name': uniqueOperationName,
+import { GRAPHQL_JS_VALIDATIONS } from "./graphql-js-validation.js";
+import { rule as alphabetize } from "./alphabetize.js";
+import { rule as descriptionStyle } from "./description-style.js";
+import { rule as inputName } from "./input-name.js";
+import { rule as loneExecutableDefinition } from "./lone-executable-definition.js";
+import { rule as matchDocumentFilename } from "./match-document-filename.js";
+import { rule as namingConvention } from "./naming-convention.js";
+import { rule as noAnonymousOperations } from "./no-anonymous-operations.js";
+import { rule as noCaseInsensitiveEnumValuesDuplicates } from "./no-case-insensitive-enum-values-duplicates.js";
+import { rule as noDeprecated } from "./no-deprecated.js";
+import { rule as noDuplicateFields } from "./no-duplicate-fields.js";
+import { rule as noHashtagDescription } from "./no-hashtag-description.js";
+import { rule as noOnePlaceFragments } from "./no-one-place-fragments.js";
+import { rule as noRootType } from "./no-root-type.js";
+import { rule as noScalarResultTypeOnMutation } from "./no-scalar-result-type-on-mutation.js";
+import { rule as noTypenamePrefix } from "./no-typename-prefix.js";
+import { rule as noUnreachableTypes } from "./no-unreachable-types.js";
+import { rule as noUnusedFields } from "./no-unused-fields.js";
+import { rule as relayArguments } from "./relay-arguments.js";
+import { rule as relayConnectionTypes } from "./relay-connection-types.js";
+import { rule as relayEdgeTypes } from "./relay-edge-types.js";
+import { rule as relayPageInfo } from "./relay-page-info.js";
+import { rule as requireDeprecationDate } from "./require-deprecation-date.js";
+import { rule as requireDeprecationReason } from "./require-deprecation-reason.js";
+import { rule as requireDescription } from "./require-description.js";
+import { rule as requireFieldOfTypeQueryInMutationResult } from "./require-field-of-type-query-in-mutation-result.js";
+import { rule as requireIdWhenAvailable } from "./require-id-when-available.js";
+import { rule as requireImportFragment } from "./require-import-fragment.js";
+import { rule as requireNullableFieldsWithOneof } from "./require-nullable-fields-with-oneof.js";
+import { rule as requireNullableResultInRoot } from "./require-nullable-result-in-root.js";
+import { rule as requireTypePatternWithOneof } from "./require-type-pattern-with-oneof.js";
+import { rule as selectionSetDepth } from "./selection-set-depth.js";
+import { rule as strictIdInTypes } from "./strict-id-in-types.js";
+import { rule as uniqueFragmentName } from "./unique-fragment-name.js";
+import { rule as uniqueOperationName } from "./unique-operation-name.js";
+const rules = {
+  ...GRAPHQL_JS_VALIDATIONS,
+  alphabetize,
+  "description-style": descriptionStyle,
+  "input-name": inputName,
+  "lone-executable-definition": loneExecutableDefinition,
+  "match-document-filename": matchDocumentFilename,
+  "naming-convention": namingConvention,
+  "no-anonymous-operations": noAnonymousOperations,
+  "no-case-insensitive-enum-values-duplicates": noCaseInsensitiveEnumValuesDuplicates,
+  "no-deprecated": noDeprecated,
+  "no-duplicate-fields": noDuplicateFields,
+  "no-hashtag-description": noHashtagDescription,
+  "no-one-place-fragments": noOnePlaceFragments,
+  "no-root-type": noRootType,
+  "no-scalar-result-type-on-mutation": noScalarResultTypeOnMutation,
+  "no-typename-prefix": noTypenamePrefix,
+  "no-unreachable-types": noUnreachableTypes,
+  "no-unused-fields": noUnusedFields,
+  "relay-arguments": relayArguments,
+  "relay-connection-types": relayConnectionTypes,
+  "relay-edge-types": relayEdgeTypes,
+  "relay-page-info": relayPageInfo,
+  "require-deprecation-date": requireDeprecationDate,
+  "require-deprecation-reason": requireDeprecationReason,
+  "require-description": requireDescription,
+  "require-field-of-type-query-in-mutation-result": requireFieldOfTypeQueryInMutationResult,
+  "require-id-when-available": requireIdWhenAvailable,
+  "require-import-fragment": requireImportFragment,
+  "require-nullable-fields-with-oneof": requireNullableFieldsWithOneof,
+  "require-nullable-result-in-root": requireNullableResultInRoot,
+  "require-type-pattern-with-oneof": requireTypePatternWithOneof,
+  "selection-set-depth": selectionSetDepth,
+  "strict-id-in-types": strictIdInTypes,
+  "unique-fragment-name": uniqueFragmentName,
+  "unique-operation-name": uniqueOperationName
+};
+export {
+  rules
 };

package/{typings/rules/input-name.d.cts → esm/rules/input-name.d.mts}

@@ -1,5 +1,12 @@
 import { FromSchema } from 'json-schema-to-ts';
-import { GraphQLESLintRule } from '../types.cjs';
+import { i as GraphQLESLintRule } from '../types-2e1afd7c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import '../estree-converter/types.mjs';
+
 declare const schema: {
     readonly type: "array";
     readonly maxItems: 1;
@@ -30,6 +37,7 @@ declare const schema: {
         };
     };
 };
-export type RuleOptions = FromSchema<typeof schema>;
-export declare const rule: GraphQLESLintRule<RuleOptions>;
-export {};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions>;
+
+export { RuleOptions, rule };

package/esm/rules/input-name.js

@@ -1,137 +1,148 @@
-import { Kind, } from 'graphql';
+import {
+  Kind
+} from "graphql";
 const schema = {
-    type: 'array',
-    maxItems: 1,
-    items: {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-            checkInputType: {
-                type: 'boolean',
-                default: false,
-                description: 'Check that the input type name follows the convention \\<mutationName>Input',
-            },
-            caseSensitiveInputType: {
-                type: 'boolean',
-                default: true,
-                description: 'Allow for case discrepancies in the input type name',
-            },
-            checkQueries: {
-                type: 'boolean',
-                default: false,
-                description: 'Apply the rule to Queries',
-            },
-            checkMutations: {
-                type: 'boolean',
-                default: true,
-                description: 'Apply the rule to Mutations',
-            },
-        },
-    },
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      checkInputType: {
+        type: "boolean",
+        default: false,
+        description: "Check that the input type name follows the convention \\<mutationName>Input"
+      },
+      caseSensitiveInputType: {
+        type: "boolean",
+        default: true,
+        description: "Allow for case discrepancies in the input type name"
+      },
+      checkQueries: {
+        type: "boolean",
+        default: false,
+        description: "Apply the rule to Queries"
+      },
+      checkMutations: {
+        type: "boolean",
+        default: true,
+        description: "Apply the rule to Mutations"
+      }
+    }
+  }
 };
-const isObjectType = (node) => 
-// TODO: remove `as any` when drop support of graphql@15
-[Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION].includes(node.type);
-const isQueryType = (node) => isObjectType(node) && node.name.value === 'Query';
-const isMutationType = (node) => isObjectType(node) && node.name.value === 'Mutation';
-export const rule = {
-    meta: {
-        type: 'suggestion',
-        hasSuggestions: true,
-        docs: {
-            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: true }],
-                    code: /* GraphQL */ `
+const isObjectType = (node) => (
+  // TODO: remove `as any` when drop support of graphql@15
+  [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION].includes(node.type)
+);
+const isQueryType = (node) => isObjectType(node) && node.name.value === "Query";
+const isMutationType = (node) => isObjectType(node) && node.name.value === "Mutation";
+const rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: true,
+    docs: {
+      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: true }],
+          code: (
+            /* GraphQL */
+            `
             type Mutation {
               SetMessage(message: InputMessage): String
             }
-          `,
-                },
-                {
-                    title: 'Correct (with `checkInputType`)',
-                    usage: [{ checkInputType: true }],
-                    code: /* GraphQL */ `
+          `
+          )
+        },
+        {
+          title: "Correct (with `checkInputType`)",
+          usage: [{ checkInputType: true }],
+          code: (
+            /* GraphQL */
+            `
             type Mutation {
               SetMessage(input: SetMessageInput): String
             }
-          `,
-                },
-                {
-                    title: 'Correct (without `checkInputType`)',
-                    usage: [{ checkInputType: false }],
-                    code: /* GraphQL */ `
+          `
+          )
+        },
+        {
+          title: "Correct (without `checkInputType`)",
+          usage: [{ checkInputType: false }],
+          code: (
+            /* GraphQL */
+            `
             type Mutation {
               SetMessage(input: AnyInputTypeName): String
             }
-          `,
-                },
-            ],
-        },
-        schema,
+          `
+          )
+        }
+      ]
     },
-    create(context) {
-        const options = {
-            checkInputType: false,
-            caseSensitiveInputType: true,
-            checkMutations: true,
-            ...context.options[0],
-        };
-        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)) {
-                    const inputName = node.value;
-                    context.report({
-                        node,
-                        message: `Input "${inputName}" should be named "input" for "${fieldDef.parent.name.value}.${fieldDef.name.value}"`,
-                        suggest: [
-                            {
-                                desc: 'Rename to `input`',
-                                fix: fixer => fixer.replaceText(node, 'input'),
-                            },
-                        ],
-                    });
-                }
-            },
+    schema
+  },
+  create(context) {
+    const options = {
+      checkInputType: false,
+      caseSensitiveInputType: true,
+      checkMutations: true,
+      ...context.options[0]
+    };
+    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)) {
+          const inputName = node.value;
+          context.report({
+            node,
+            message: `Input "${inputName}" should be named "input" for "${fieldDef.parent.name.value}.${fieldDef.name.value}"`,
+            suggest: [
+              {
+                desc: "Rename to `input`",
+                fix: (fixer) => fixer.replaceText(node, "input")
+              }
+            ]
+          });
+        }
+      }
+    };
+    if (options.checkInputType) {
+      listeners["FieldDefinition > InputValueDefinition NamedType"] = (node) => {
+        const findInputType = (item) => {
+          let currentNode = item;
+          while (currentNode.type !== Kind.INPUT_VALUE_DEFINITION) {
+            currentNode = currentNode.parent;
+          }
+          return currentNode;
         };
-        if (options.checkInputType) {
-            listeners['FieldDefinition > InputValueDefinition NamedType'] = (node) => {
-                const findInputType = (item) => {
-                    let currentNode = item;
-                    while (currentNode.type !== Kind.INPUT_VALUE_DEFINITION) {
-                        // @ts-expect-error TODO try fix type error
-                        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),
-                                },
-                            ],
-                        });
-                    }
+        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;
-    },
+      };
+    }
+    return listeners;
+  }
+};
+export {
+  rule
 };

package/{typings/rules/lone-executable-definition.d.cts → esm/rules/lone-executable-definition.d.mts}

@@ -1,5 +1,12 @@
 import { FromSchema } from 'json-schema-to-ts';
-import { GraphQLESLintRule } from '../types.cjs';
+import { i as GraphQLESLintRule } from '../types-2e1afd7c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import '../estree-converter/types.mjs';
+
 declare const schema: {
     readonly type: "array";
     readonly maxItems: 1;
@@ -21,6 +28,7 @@ declare const schema: {
         };
     };
 };
-export type RuleOptions = FromSchema<typeof schema>;
-export declare const rule: GraphQLESLintRule<RuleOptions>;
-export {};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions>;
+
+export { RuleOptions, rule };