@graphql-eslint/eslint-plugin 3.19.3 → 3.20.0-alpha-20230703155329-a20556f

package/cjs/rules/index.d.ts

@@ -0,0 +1,125 @@
+import { RuleOptions } from './require-description.js';
+import { CaseStyle } from '../utils.js';
+import { i as GraphQLESLintRule } from '../types-e3367e3c.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.js';
+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/cjs/rules/index.js

@@ -1,78 +1,99 @@
 "use strict";
-/*
- * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rules = void 0;
-const graphql_js_validation_js_1 = require("./graphql-js-validation.js");
-const alphabetize_js_1 = require("./alphabetize.js");
-const description_style_js_1 = require("./description-style.js");
-const input_name_js_1 = require("./input-name.js");
-const lone_executable_definition_js_1 = require("./lone-executable-definition.js");
-const match_document_filename_js_1 = require("./match-document-filename.js");
-const naming_convention_js_1 = require("./naming-convention.js");
-const no_anonymous_operations_js_1 = require("./no-anonymous-operations.js");
-const no_case_insensitive_enum_values_duplicates_js_1 = require("./no-case-insensitive-enum-values-duplicates.js");
-const no_deprecated_js_1 = require("./no-deprecated.js");
-const no_duplicate_fields_js_1 = require("./no-duplicate-fields.js");
-const no_hashtag_description_js_1 = require("./no-hashtag-description.js");
-const no_one_place_fragments_js_1 = require("./no-one-place-fragments.js");
-const no_root_type_js_1 = require("./no-root-type.js");
-const no_scalar_result_type_on_mutation_js_1 = require("./no-scalar-result-type-on-mutation.js");
-const no_typename_prefix_js_1 = require("./no-typename-prefix.js");
-const no_unreachable_types_js_1 = require("./no-unreachable-types.js");
-const no_unused_fields_js_1 = require("./no-unused-fields.js");
-const relay_arguments_js_1 = require("./relay-arguments.js");
-const relay_connection_types_js_1 = require("./relay-connection-types.js");
-const relay_edge_types_js_1 = require("./relay-edge-types.js");
-const relay_page_info_js_1 = require("./relay-page-info.js");
-const require_deprecation_date_js_1 = require("./require-deprecation-date.js");
-const require_deprecation_reason_js_1 = require("./require-deprecation-reason.js");
-const require_description_js_1 = require("./require-description.js");
-const require_field_of_type_query_in_mutation_result_js_1 = require("./require-field-of-type-query-in-mutation-result.js");
-const require_id_when_available_js_1 = require("./require-id-when-available.js");
-const require_import_fragment_js_1 = require("./require-import-fragment.js");
-const require_nullable_fields_with_oneof_js_1 = require("./require-nullable-fields-with-oneof.js");
-const require_nullable_result_in_root_js_1 = require("./require-nullable-result-in-root.js");
-const require_type_pattern_with_oneof_js_1 = require("./require-type-pattern-with-oneof.js");
-const selection_set_depth_js_1 = require("./selection-set-depth.js");
-const strict_id_in_types_js_1 = require("./strict-id-in-types.js");
-const unique_fragment_name_js_1 = require("./unique-fragment-name.js");
-const unique_operation_name_js_1 = require("./unique-operation-name.js");
-exports.rules = {
-    ...graphql_js_validation_js_1.GRAPHQL_JS_VALIDATIONS,
-    alphabetize: alphabetize_js_1.rule,
-    'description-style': description_style_js_1.rule,
-    'input-name': input_name_js_1.rule,
-    'lone-executable-definition': lone_executable_definition_js_1.rule,
-    'match-document-filename': match_document_filename_js_1.rule,
-    'naming-convention': naming_convention_js_1.rule,
-    'no-anonymous-operations': no_anonymous_operations_js_1.rule,
-    'no-case-insensitive-enum-values-duplicates': no_case_insensitive_enum_values_duplicates_js_1.rule,
-    'no-deprecated': no_deprecated_js_1.rule,
-    'no-duplicate-fields': no_duplicate_fields_js_1.rule,
-    'no-hashtag-description': no_hashtag_description_js_1.rule,
-    'no-one-place-fragments': no_one_place_fragments_js_1.rule,
-    'no-root-type': no_root_type_js_1.rule,
-    'no-scalar-result-type-on-mutation': no_scalar_result_type_on_mutation_js_1.rule,
-    'no-typename-prefix': no_typename_prefix_js_1.rule,
-    'no-unreachable-types': no_unreachable_types_js_1.rule,
-    'no-unused-fields': no_unused_fields_js_1.rule,
-    'relay-arguments': relay_arguments_js_1.rule,
-    'relay-connection-types': relay_connection_types_js_1.rule,
-    'relay-edge-types': relay_edge_types_js_1.rule,
-    'relay-page-info': relay_page_info_js_1.rule,
-    'require-deprecation-date': require_deprecation_date_js_1.rule,
-    'require-deprecation-reason': require_deprecation_reason_js_1.rule,
-    'require-description': require_description_js_1.rule,
-    'require-field-of-type-query-in-mutation-result': require_field_of_type_query_in_mutation_result_js_1.rule,
-    'require-id-when-available': require_id_when_available_js_1.rule,
-    'require-import-fragment': require_import_fragment_js_1.rule,
-    'require-nullable-fields-with-oneof': require_nullable_fields_with_oneof_js_1.rule,
-    'require-nullable-result-in-root': require_nullable_result_in_root_js_1.rule,
-    'require-type-pattern-with-oneof': require_type_pattern_with_oneof_js_1.rule,
-    'selection-set-depth': selection_set_depth_js_1.rule,
-    'strict-id-in-types': strict_id_in_types_js_1.rule,
-    'unique-fragment-name': unique_fragment_name_js_1.rule,
-    'unique-operation-name': unique_operation_name_js_1.rule,
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rules_exports = {};
+__export(rules_exports, {
+  rules: () => rules
+});
+module.exports = __toCommonJS(rules_exports);
+var import_graphql_js_validation = require("./graphql-js-validation.js");
+var import_alphabetize = require("./alphabetize.js");
+var import_description_style = require("./description-style.js");
+var import_input_name = require("./input-name.js");
+var import_lone_executable_definition = require("./lone-executable-definition.js");
+var import_match_document_filename = require("./match-document-filename.js");
+var import_naming_convention = require("./naming-convention.js");
+var import_no_anonymous_operations = require("./no-anonymous-operations.js");
+var import_no_case_insensitive_enum_values_duplicates = require("./no-case-insensitive-enum-values-duplicates.js");
+var import_no_deprecated = require("./no-deprecated.js");
+var import_no_duplicate_fields = require("./no-duplicate-fields.js");
+var import_no_hashtag_description = require("./no-hashtag-description.js");
+var import_no_one_place_fragments = require("./no-one-place-fragments.js");
+var import_no_root_type = require("./no-root-type.js");
+var import_no_scalar_result_type_on_mutation = require("./no-scalar-result-type-on-mutation.js");
+var import_no_typename_prefix = require("./no-typename-prefix.js");
+var import_no_unreachable_types = require("./no-unreachable-types.js");
+var import_no_unused_fields = require("./no-unused-fields.js");
+var import_relay_arguments = require("./relay-arguments.js");
+var import_relay_connection_types = require("./relay-connection-types.js");
+var import_relay_edge_types = require("./relay-edge-types.js");
+var import_relay_page_info = require("./relay-page-info.js");
+var import_require_deprecation_date = require("./require-deprecation-date.js");
+var import_require_deprecation_reason = require("./require-deprecation-reason.js");
+var import_require_description = require("./require-description.js");
+var import_require_field_of_type_query_in_mutation_result = require("./require-field-of-type-query-in-mutation-result.js");
+var import_require_id_when_available = require("./require-id-when-available.js");
+var import_require_import_fragment = require("./require-import-fragment.js");
+var import_require_nullable_fields_with_oneof = require("./require-nullable-fields-with-oneof.js");
+var import_require_nullable_result_in_root = require("./require-nullable-result-in-root.js");
+var import_require_type_pattern_with_oneof = require("./require-type-pattern-with-oneof.js");
+var import_selection_set_depth = require("./selection-set-depth.js");
+var import_strict_id_in_types = require("./strict-id-in-types.js");
+var import_unique_fragment_name = require("./unique-fragment-name.js");
+var import_unique_operation_name = require("./unique-operation-name.js");
+const rules = {
+  ...import_graphql_js_validation.GRAPHQL_JS_VALIDATIONS,
+  alphabetize: import_alphabetize.rule,
+  "description-style": import_description_style.rule,
+  "input-name": import_input_name.rule,
+  "lone-executable-definition": import_lone_executable_definition.rule,
+  "match-document-filename": import_match_document_filename.rule,
+  "naming-convention": import_naming_convention.rule,
+  "no-anonymous-operations": import_no_anonymous_operations.rule,
+  "no-case-insensitive-enum-values-duplicates": import_no_case_insensitive_enum_values_duplicates.rule,
+  "no-deprecated": import_no_deprecated.rule,
+  "no-duplicate-fields": import_no_duplicate_fields.rule,
+  "no-hashtag-description": import_no_hashtag_description.rule,
+  "no-one-place-fragments": import_no_one_place_fragments.rule,
+  "no-root-type": import_no_root_type.rule,
+  "no-scalar-result-type-on-mutation": import_no_scalar_result_type_on_mutation.rule,
+  "no-typename-prefix": import_no_typename_prefix.rule,
+  "no-unreachable-types": import_no_unreachable_types.rule,
+  "no-unused-fields": import_no_unused_fields.rule,
+  "relay-arguments": import_relay_arguments.rule,
+  "relay-connection-types": import_relay_connection_types.rule,
+  "relay-edge-types": import_relay_edge_types.rule,
+  "relay-page-info": import_relay_page_info.rule,
+  "require-deprecation-date": import_require_deprecation_date.rule,
+  "require-deprecation-reason": import_require_deprecation_reason.rule,
+  "require-description": import_require_description.rule,
+  "require-field-of-type-query-in-mutation-result": import_require_field_of_type_query_in_mutation_result.rule,
+  "require-id-when-available": import_require_id_when_available.rule,
+  "require-import-fragment": import_require_import_fragment.rule,
+  "require-nullable-fields-with-oneof": import_require_nullable_fields_with_oneof.rule,
+  "require-nullable-result-in-root": import_require_nullable_result_in_root.rule,
+  "require-type-pattern-with-oneof": import_require_type_pattern_with_oneof.rule,
+  "selection-set-depth": import_selection_set_depth.rule,
+  "strict-id-in-types": import_strict_id_in_types.rule,
+  "unique-fragment-name": import_unique_fragment_name.rule,
+  "unique-operation-name": import_unique_operation_name.rule
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rules
+});

package/{typings → cjs}/rules/input-name.d.ts

@@ -1,5 +1,12 @@
 import { FromSchema } from 'json-schema-to-ts';
-import { GraphQLESLintRule } from '../types.js';
+import { i as GraphQLESLintRule } from '../types-e3367e3c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import '../estree-converter/types.js';
+
 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/cjs/rules/input-name.js

@@ -1,140 +1,170 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rule = void 0;
-const graphql_1 = require("graphql");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var input_name_exports = {};
+__export(input_name_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(input_name_exports);
+var import_graphql = require("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
-[graphql_1.Kind.OBJECT_TYPE_DEFINITION, graphql_1.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';
-exports.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
+  [import_graphql.Kind.OBJECT_TYPE_DEFINITION, import_graphql.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 !== import_graphql.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 !== graphql_1.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;
+  }
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/{typings → cjs}/rules/lone-executable-definition.d.ts

@@ -1,5 +1,12 @@
 import { FromSchema } from 'json-schema-to-ts';
-import { GraphQLESLintRule } from '../types.js';
+import { i as GraphQLESLintRule } from '../types-e3367e3c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import '../estree-converter/types.js';
+
 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 };