@graphql-eslint/eslint-plugin 4.0.0-alpha.0 → 4.0.0-alpha.10

package/esm/graphql-config.js

@@ -1,8 +1,8 @@
-import "./chunk-U3TKCM4X.js";
+import "./chunk-UIAXBAMD.js";
 import path from "node:path";
-import { CodeFileLoader } from "@graphql-tools/code-file-loader";
 import debugFactory from "debug";
 import { GraphQLConfig, loadConfigSync } from "graphql-config";
+import { CodeFileLoader } from "@graphql-tools/code-file-loader";
 const debug = debugFactory("graphql-eslint:graphql-config");
 let graphQLConfig;
 function loadOnDiskGraphQLConfig(filePath) {
@@ -17,7 +17,7 @@ function loadGraphQLConfig({
   graphQLConfig: config,
   filePath
 }) {
-  if (graphQLConfig)
+  if (process.env.NODE_ENV !== "test" && graphQLConfig)
     return graphQLConfig;
   debug("parserOptions.graphQLConfig: %o", config);
   const onDiskConfig = !config && loadOnDiskGraphQLConfig(filePath);

package/esm/index.d.ts

@@ -0,0 +1,184 @@
+import { RuleOptions } from './rules/require-description/index.js';
+import { CaseStyle } from './utils.js';
+export { requireGraphQLSchemaFromContext, requireSiblingsOperations } from './utils.js';
+import * as graphql from 'graphql';
+import { GraphQLESLintRule } from './types.js';
+export { CategoryType, ConfigName, GraphQLESLintParseResult, GraphQLESLintRuleContext, GraphQLESLintRuleListener, OmitRecursively, ParserOptions, ParserServices, Pointer, ReportDescriptor, RuleDocsInfo, Schema, ValueOf } from './types.js';
+import * as eslint from 'eslint';
+import { Block } from './processor.js';
+export { configs } from './configs/index.js';
+import { parseForESLint } from './parser.js';
+export { parser } from './parser.js';
+export { rules } from './rules/index.js';
+export { GraphQLESTreeNode } from './estree-converter/types.js';
+import 'estree';
+import './siblings.js';
+import '@graphql-tools/utils';
+import 'graphql-config';
+import 'json-schema-to-ts';
+
+declare const processors: {
+    graphql: {
+        meta: {
+            name: string;
+            version: string | undefined;
+        };
+        supportsAutofix: true;
+        preprocess(code: string, filePath: string): (string | Block)[];
+        postprocess(messages: eslint.Linter.LintMessage[][], filePath: string): eslint.Linter.LintMessage[];
+    };
+};
+
+declare const _default: {
+    parser: {
+        parseForESLint: typeof parseForESLint;
+        meta: {
+            name: string;
+            version: string | undefined;
+        };
+    };
+    processor: {
+        meta: {
+            name: string;
+            version: string | undefined;
+        };
+        supportsAutofix: true;
+        preprocess(code: string, filePath: string): (string | Block)[];
+        postprocess(messages: eslint.Linter.LintMessage[][], filePath: string): eslint.Linter.LintMessage[];
+    };
+    rules: {
+        alphabetize: GraphQLESLintRule<{
+            values?: boolean | undefined;
+            definitions?: boolean | undefined;
+            selections?: ("OperationDefinition" | "FragmentDefinition")[] | undefined;
+            arguments?: ("Field" | "Directive" | "FieldDefinition" | "DirectiveDefinition")[] | undefined;
+            fields?: ("ObjectTypeDefinition" | "InterfaceTypeDefinition" | "InputObjectTypeDefinition")[] | undefined;
+            variables?: boolean | undefined;
+            groups?: string[] | undefined;
+        }[]>;
+        'description-style': GraphQLESLintRule<{
+            style: "block" | "inline";
+        }[]>;
+        'input-name': GraphQLESLintRule<{
+            checkInputType?: boolean | undefined;
+            caseSensitiveInputType?: boolean | undefined;
+            checkQueries?: boolean | undefined;
+            checkMutations?: boolean | undefined;
+        }[]>;
+        'lone-executable-definition': GraphQLESLintRule<{
+            ignore?: (graphql.OperationTypeNode | "fragment")[] | undefined;
+        }[]>;
+        'match-document-filename': GraphQLESLintRule<{
+            fragment?: (CaseStyle | "matchDocumentStyle") | {
+                style?: (CaseStyle | "matchDocumentStyle") | undefined;
+                suffix?: string | undefined;
+                prefix?: string | undefined;
+            } | undefined;
+            mutation?: (CaseStyle | "matchDocumentStyle") | {
+                style?: (CaseStyle | "matchDocumentStyle") | undefined;
+                suffix?: string | undefined;
+                prefix?: string | undefined;
+            } | undefined;
+            subscription?: (CaseStyle | "matchDocumentStyle") | {
+                style?: (CaseStyle | "matchDocumentStyle") | undefined;
+                suffix?: string | undefined;
+                prefix?: string | undefined;
+            } | undefined;
+            query?: (CaseStyle | "matchDocumentStyle") | {
+                style?: (CaseStyle | "matchDocumentStyle") | undefined;
+                suffix?: string | undefined;
+                prefix?: string | undefined;
+            } | undefined;
+            fileExtension?: ".gql" | ".graphql" | undefined;
+        }[]>;
+        'naming-convention': GraphQLESLintRule<{
+            [x: string]: unknown;
+            types?: ("camelCase" | "PascalCase" | "snake_case" | "UPPER_CASE") | {
+                style?: ("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-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;
+        }[], 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-import-fragment': GraphQLESLintRule;
+        'require-nullable-fields-with-oneof': GraphQLESLintRule;
+        'require-nullable-result-in-root': GraphQLESLintRule;
+        'require-selections': GraphQLESLintRule<{
+            fieldName: string | string[];
+        }[], true>;
+        '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-enum-value-names': GraphQLESLintRule;
+        'unique-fragment-name': GraphQLESLintRule;
+        'unique-operation-name': GraphQLESLintRule;
+    };
+    configs: {
+        'schema-recommended': any;
+        'schema-all': any;
+        'schema-relay': any;
+        'operations-recommended': any;
+        'operations-all': any;
+        'flat/schema-recommended': {
+            rules: any;
+        };
+        'flat/schema-all': {
+            rules: any;
+        };
+        'flat/schema-relay': {
+            rules: any;
+        };
+        'flat/operations-recommended': {
+            rules: any;
+        };
+        'flat/operations-all': {
+            rules: any;
+        };
+    };
+};
+
+export { GraphQLESLintRule, _default as default, parseForESLint, processors };

package/esm/index.js

@@ -1,16 +1,22 @@
-import "./chunk-U3TKCM4X.js";
+import "./chunk-UIAXBAMD.js";
+import { configs } from "./configs/index.js";
+import { parseForESLint, parser } from "./parser.js";
 import { processor } from "./processor.js";
-import { parseForESLint } from "./parser.js";
 import { rules } from "./rules/index.js";
 export * from "./types.js";
 import { requireGraphQLSchemaFromContext, requireSiblingsOperations } from "./utils.js";
 const processors = { graphql: processor };
-import { configs } from "./configs/index.js";
-import { flatConfigs } from "./flat-configs.js";
+var src_default = {
+  parser,
+  processor,
+  rules,
+  configs
+};
 export {
   configs,
-  flatConfigs,
+  src_default as default,
   parseForESLint,
+  parser,
   processors,
   requireGraphQLSchemaFromContext,
   requireSiblingsOperations,

package/esm/meta.d.ts

@@ -0,0 +1,3 @@
+declare const version: string | undefined;
+
+export { version };

package/esm/meta.js

@@ -0,0 +1,5 @@
+import "./chunk-UIAXBAMD.js";
+const version = "4.0.0-alpha.10";
+export {
+  version
+};

package/{cjs → esm}/parser.d.ts

@@ -2,12 +2,19 @@ import { ParserOptions, GraphQLESLintParseResult } from './types.js';
 import 'eslint';
 import 'estree';
 import 'graphql';
+import 'graphql-config';
 import 'json-schema-to-ts';
+import './estree-converter/types.js';
 import './siblings.js';
 import '@graphql-tools/utils';
-import './estree-converter/types.js';
-import 'graphql-config';
 
 declare function parseForESLint(code: string, options: ParserOptions): GraphQLESLintParseResult;
+declare const parser: {
+    parseForESLint: typeof parseForESLint;
+    meta: {
+        name: string;
+        version: string | undefined;
+    };
+};
 
-export { parseForESLint };
+export { parseForESLint, parser };

package/esm/parser.js

@@ -1,13 +1,14 @@
-import "./chunk-U3TKCM4X.js";
-import { parseGraphQLSDL } from "@graphql-tools/utils";
+import "./chunk-UIAXBAMD.js";
 import debugFactory from "debug";
 import { GraphQLError } from "graphql";
+import { parseGraphQLSDL } from "@graphql-tools/utils";
+import { getDocuments } from "./documents.js";
 import { convertToESTree, extractComments, extractTokens } from "./estree-converter/index.js";
 import { loadGraphQLConfig } from "./graphql-config.js";
+import { version } from "./meta.js";
 import { getSchema } from "./schema.js";
 import { getSiblings } from "./siblings.js";
 import { CWD, VIRTUAL_DOCUMENT_REGEX } from "./utils.js";
-import { getDocuments } from "./documents.js";
 const debug = debugFactory("graphql-eslint:parser");
 debug("cwd %o", CWD);
 const LEGACY_PARSER_OPTIONS_KEYS = [
@@ -71,6 +72,14 @@ function parseForESLint(code, options) {
     throw error;
   }
 }
+const parser = {
+  parseForESLint,
+  meta: {
+    name: "@graphql-eslint/parser",
+    version
+  }
+};
 export {
-  parseForESLint
+  parseForESLint,
+  parser
 };

package/{cjs → esm}/processor.d.ts

@@ -5,9 +5,13 @@ type Block = Linter.ProcessorFile & {
     offset: number;
 };
 declare const processor: {
+    meta: {
+        name: string;
+        version: string | undefined;
+    };
     supportsAutofix: true;
     preprocess(code: string, filePath: string): (string | Block)[];
     postprocess(messages: Linter.LintMessage[][], filePath: string): Linter.LintMessage[];
 };
 
-export { Block, processor };
+export { type Block, processor };

package/esm/processor.js

@@ -1,14 +1,19 @@
-import "./chunk-U3TKCM4X.js";
+import "./chunk-UIAXBAMD.js";
 import { relative } from "node:path";
 import {
   gqlPluckFromCodeStringSync
 } from "@graphql-tools/graphql-tag-pluck";
 import { asArray } from "@graphql-tools/utils";
 import { loadOnDiskGraphQLConfig } from "./graphql-config.js";
+import { version } from "./meta.js";
 import { CWD, REPORT_ON_FIRST_CHARACTER, truthy } from "./utils.js";
 const blocksMap = /* @__PURE__ */ new Map();
 let onDiskConfig, onDiskConfigLoaded = !1;
 const RELEVANT_KEYWORDS = ["gql", "graphql", "GraphQL"], processor = {
+  meta: {
+    name: "@graphql-eslint/processor",
+    version
+  },
   supportsAutofix: !0,
   preprocess(code, filePath) {
     onDiskConfigLoaded || (onDiskConfig = loadOnDiskGraphQLConfig(filePath), onDiskConfigLoaded = !0);

package/esm/rules/{alphabetize.d.mts → alphabetize/index.d.ts}

@@ -1,12 +1,12 @@
 import { FromSchema } from 'json-schema-to-ts';
-import { GraphQLESLintRule } from '../types.mjs';
+import { GraphQLESLintRule } from '../../types.js';
 import 'eslint';
 import 'estree';
 import 'graphql';
-import '../siblings.mjs';
-import '@graphql-tools/utils';
-import '../estree-converter/types.mjs';
 import 'graphql-config';
+import '../../estree-converter/types.js';
+import '../../siblings.js';
+import '@graphql-tools/utils';
 
 declare const schema: {
     readonly type: "array";
@@ -58,7 +58,7 @@ declare const schema: {
             };
             readonly groups: {
                 readonly minItems: 2;
-                readonly description: "Custom order group. Example: `['id', '*', 'createdAt', 'updatedAt']` where `*` says for everything else.";
+                readonly description: string;
                 readonly type: "array";
                 readonly uniqueItems: true;
                 readonly items: {
@@ -71,4 +71,4 @@ declare const schema: {
 type RuleOptions = FromSchema<typeof schema>;
 declare const rule: GraphQLESLintRule<RuleOptions>;
 
-export { RuleOptions, rule };
+export { type RuleOptions, rule };

package/esm/rules/{alphabetize.js → alphabetize/index.js}

@@ -1,9 +1,9 @@
-import "../chunk-U3TKCM4X.js";
+import "../../chunk-UIAXBAMD.js";
 import {
   Kind
 } from "graphql";
 import lowerCase from "lodash.lowercase";
-import { ARRAY_DEFAULT_OPTIONS, displayNodeName, truthy } from "../utils.js";
+import { ARRAY_DEFAULT_OPTIONS, displayNodeName, truthy } from "../../utils.js";
 const RULE_ID = "alphabetize", fieldsEnum = [
   Kind.OBJECT_TYPE_DEFINITION,
   Kind.INTERFACE_TYPE_DEFINITION,
@@ -61,7 +61,14 @@ const RULE_ID = "alphabetize", fieldsEnum = [
       groups: {
         ...ARRAY_DEFAULT_OPTIONS,
         minItems: 2,
-        description: "Custom order group. Example: `['id', '*', 'createdAt', 'updatedAt']` where `*` says for everything else."
+        description: [
+          "Order group. Example: `['...', 'id', '*', '{']` where:",
+          "- `...` stands for fragment spreads",
+          "- `id` stands for field with name `id`",
+          "- `*` stands for everything else",
+          "- `{` stands for fields `selection set`"
+        ].join(`
+`)
       }
     }
   }
@@ -183,7 +190,7 @@ const RULE_ID = "alphabetize", fieldsEnum = [
             selections: selectionsEnum,
             variables: !0,
             arguments: [Kind.FIELD, Kind.DIRECTIVE],
-            groups: ["id", "*", "createdAt", "updatedAt"]
+            groups: ["...", "id", "*", "{"]
           }
         ]
       }
@@ -221,20 +228,18 @@ const RULE_ID = "alphabetize", fieldsEnum = [
     }
     function checkNodes(nodes = []) {
       for (let i = 1; i < nodes.length; i += 1) {
-        const currNode = nodes[i], currName = "alias" in currNode && currNode.alias?.value || "name" in currNode && currNode.name?.value;
+        const currNode = nodes[i], currName = getName(currNode);
         if (!currName)
           continue;
-        const prevNode = nodes[i - 1], prevName = "alias" in prevNode && prevNode.alias?.value || "name" in prevNode && prevNode.name?.value;
+        const prevNode = nodes[i - 1], prevName = getName(prevNode);
         if (prevName) {
           const compareResult = prevName.localeCompare(currName), { groups } = opts;
           let shouldSortByGroup = !1;
           if (groups?.length) {
             if (!groups.includes("*"))
               throw new Error("`groups` option should contain `*` string.");
-            let indexForPrev = groups.indexOf(prevName);
-            indexForPrev === -1 && (indexForPrev = groups.indexOf("*"));
-            let indexForCurr = groups.indexOf(currName);
-            if (indexForCurr === -1 && (indexForCurr = groups.indexOf("*")), shouldSortByGroup = indexForPrev - indexForCurr > 0, indexForPrev < indexForCurr)
+            const indexForPrev = getIndex({ node: prevNode, groups }), indexForCurr = getIndex({ node: currNode, groups });
+            if (shouldSortByGroup = indexForPrev - indexForCurr > 0, indexForPrev < indexForCurr)
               continue;
           }
           if (!shouldSortByGroup && !(compareResult === 1) && (!(compareResult === 0) || !prevNode.kind.endsWith("Extension") || currNode.kind.endsWith("Extension")))
@@ -294,6 +299,17 @@ const RULE_ID = "alphabetize", fieldsEnum = [
     }), listeners;
   }
 };
+function getIndex({
+  node,
+  groups
+}) {
+  let index = groups.indexOf(getName(node));
+  return index === -1 && "selectionSet" in node && node.selectionSet && (index = groups.indexOf("{")), index === -1 && node.kind === Kind.FRAGMENT_SPREAD && (index = groups.indexOf("...")), index === -1 && (index = groups.indexOf("*")), index;
+}
+function getName(node) {
+  return "alias" in node && node.alias?.value || //
+  "name" in node && node.name?.value || "";
+}
 export {
   rule
 };

package/{cjs/rules/description-style.d.ts → esm/rules/description-style/index.d.ts}

@@ -1,12 +1,12 @@
 import { FromSchema } from 'json-schema-to-ts';
-import { GraphQLESLintRule } from '../types.js';
+import { GraphQLESLintRule } from '../../types.js';
 import 'eslint';
 import 'estree';
 import 'graphql';
-import '../siblings.js';
-import '@graphql-tools/utils';
-import '../estree-converter/types.js';
 import 'graphql-config';
+import '../../estree-converter/types.js';
+import '../../siblings.js';
+import '@graphql-tools/utils';
 
 declare const schema: {
     readonly type: "array";
@@ -26,4 +26,4 @@ declare const schema: {
 type RuleOptions = FromSchema<typeof schema>;
 declare const rule: GraphQLESLintRule<RuleOptions>;
 
-export { RuleOptions, rule };
+export { type RuleOptions, rule };

package/esm/rules/{description-style.js → description-style/index.js}

@@ -1,5 +1,5 @@
-import "../chunk-U3TKCM4X.js";
-import { getNodeName } from "../utils.js";
+import "../../chunk-UIAXBAMD.js";
+import { getNodeName } from "../../utils.js";
 const schema = {
   type: "array",
   maxItems: 1,

package/esm/rules/graphql-js-validation.js

@@ -1,4 +1,4 @@
-import "../chunk-U3TKCM4X.js";
+import "../chunk-UIAXBAMD.js";
 import {
   Kind,
   validate,

package/{cjs → esm}/rules/index.d.ts

@@ -1,28 +1,27 @@
-import { RuleOptions } from './require-description.js';
+import { RuleOptions } from './require-description/index.js';
 import { CaseStyle } from '../utils.js';
-import * as graphql_language_ast_js from 'graphql/language/ast.js';
+import * as graphql from 'graphql';
 import { GraphQLESLintRule } from '../types.js';
-import 'graphql';
 import 'eslint';
 import 'estree';
+import '../estree-converter/types.js';
 import '../siblings.js';
 import '@graphql-tools/utils';
-import '../estree-converter/types.js';
-import 'json-schema-to-ts';
 import 'graphql-config';
+import 'json-schema-to-ts';
 
 declare const rules: {
     alphabetize: GraphQLESLintRule<{
+        values?: boolean | undefined;
         definitions?: boolean | undefined;
         selections?: ("OperationDefinition" | "FragmentDefinition")[] | undefined;
         arguments?: ("Field" | "Directive" | "FieldDefinition" | "DirectiveDefinition")[] | undefined;
-        values?: boolean | undefined;
         fields?: ("ObjectTypeDefinition" | "InterfaceTypeDefinition" | "InputObjectTypeDefinition")[] | undefined;
         variables?: boolean | undefined;
         groups?: string[] | undefined;
     }[]>;
     'description-style': GraphQLESLintRule<{
-        style?: "block" | "inline" | undefined;
+        style: "block" | "inline";
     }[]>;
     'input-name': GraphQLESLintRule<{
         checkInputType?: boolean | undefined;
@@ -31,7 +30,7 @@ declare const rules: {
         checkMutations?: boolean | undefined;
     }[]>;
     'lone-executable-definition': GraphQLESLintRule<{
-        ignore?: (graphql_language_ast_js.OperationTypeNode | "fragment")[] | undefined;
+        ignore?: (graphql.OperationTypeNode | "fragment")[] | undefined;
     }[]>;
     'match-document-filename': GraphQLESLintRule<{
         fragment?: (CaseStyle | "matchDocumentStyle") | {
@@ -84,7 +83,7 @@ declare const rules: {
     'no-unreachable-types': GraphQLESLintRule;
     'no-unused-fields': GraphQLESLintRule;
     'relay-arguments': GraphQLESLintRule<{
-        includeBoth?: boolean | undefined;
+        includeBoth: boolean;
     }[], true>;
     'relay-connection-types': GraphQLESLintRule;
     'relay-edge-types': GraphQLESLintRule<{
@@ -103,7 +102,7 @@ declare const rules: {
     'require-nullable-fields-with-oneof': GraphQLESLintRule;
     'require-nullable-result-in-root': GraphQLESLintRule;
     'require-selections': GraphQLESLintRule<{
-        fieldName?: string | string[] | undefined;
+        fieldName: string | string[];
     }[], true>;
     'require-type-pattern-with-oneof': GraphQLESLintRule;
     'selection-set-depth': GraphQLESLintRule<{

package/esm/rules/index.js

@@ -1,39 +1,39 @@
-import "../chunk-U3TKCM4X.js";
+import "../chunk-UIAXBAMD.js";
+import { rule as alphabetize } from "./alphabetize/index.js";
+import { rule as descriptionStyle } from "./description-style/index.js";
 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 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 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 requireSelections } from "./require-selections.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 uniqueEnumValueNames } from "./unique-enum-value-names.js";
-import { rule as uniqueFragmentName } from "./unique-fragment-name.js";
-import { rule as uniqueOperationName } from "./unique-operation-name.js";
+import { rule as inputName } from "./input-name/index.js";
+import { rule as loneExecutableDefinition } from "./lone-executable-definition/index.js";
+import { rule as matchDocumentFilename } from "./match-document-filename/index.js";
+import { rule as namingConvention } from "./naming-convention/index.js";
+import { rule as noAnonymousOperations } from "./no-anonymous-operations/index.js";
+import { rule as noDeprecated } from "./no-deprecated/index.js";
+import { rule as noDuplicateFields } from "./no-duplicate-fields/index.js";
+import { rule as noHashtagDescription } from "./no-hashtag-description/index.js";
+import { rule as noOnePlaceFragments } from "./no-one-place-fragments/index.js";
+import { rule as noRootType } from "./no-root-type/index.js";
+import { rule as noScalarResultTypeOnMutation } from "./no-scalar-result-type-on-mutation/index.js";
+import { rule as noTypenamePrefix } from "./no-typename-prefix/index.js";
+import { rule as noUnreachableTypes } from "./no-unreachable-types/index.js";
+import { rule as noUnusedFields } from "./no-unused-fields/index.js";
+import { rule as relayArguments } from "./relay-arguments/index.js";
+import { rule as relayConnectionTypes } from "./relay-connection-types/index.js";
+import { rule as relayEdgeTypes } from "./relay-edge-types/index.js";
+import { rule as relayPageInfo } from "./relay-page-info/index.js";
+import { rule as requireDeprecationDate } from "./require-deprecation-date/index.js";
+import { rule as requireDeprecationReason } from "./require-deprecation-reason/index.js";
+import { rule as requireDescription } from "./require-description/index.js";
+import { rule as requireFieldOfTypeQueryInMutationResult } from "./require-field-of-type-query-in-mutation-result/index.js";
+import { rule as requireImportFragment } from "./require-import-fragment/index.js";
+import { rule as requireNullableFieldsWithOneof } from "./require-nullable-fields-with-oneof/index.js";
+import { rule as requireNullableResultInRoot } from "./require-nullable-result-in-root/index.js";
+import { rule as requireSelections } from "./require-selections/index.js";
+import { rule as requireTypePatternWithOneof } from "./require-type-pattern-with-oneof/index.js";
+import { rule as selectionSetDepth } from "./selection-set-depth/index.js";
+import { rule as strictIdInTypes } from "./strict-id-in-types/index.js";
+import { rule as uniqueEnumValueNames } from "./unique-enum-value-names/index.js";
+import { rule as uniqueFragmentName } from "./unique-fragment-name/index.js";
+import { rule as uniqueOperationName } from "./unique-operation-name/index.js";
 const rules = {
   ...GRAPHQL_JS_VALIDATIONS,
   alphabetize,