@graphql-eslint/eslint-plugin 4.0.0-alpha.9 → 4.0.1-alpha-20241127205058-a4fec1a6cf7006ea913f13e6afbf7ed2d82503c3

package/index.browser.js

@@ -1,241 +1,3 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from == "object" || typeof from == "function")
-    for (let key of __getOwnPropNames(from))
-      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
-  mod
-));
-
-// src/configs/operations-all.ts
-var require_operations_all = __commonJS({
-  "src/configs/operations-all.ts"(exports, module) {
-    "use strict";
-    module.exports = {
-      extends: "./configs/operations-recommended",
-      rules: {
-        "@graphql-eslint/alphabetize": [
-          "error",
-          {
-            definitions: !0,
-            selections: ["OperationDefinition", "FragmentDefinition"],
-            variables: !0,
-            arguments: ["Field", "Directive"],
-            groups: ["...", "id", "*", "{"]
-          }
-        ],
-        "@graphql-eslint/lone-executable-definition": "error",
-        "@graphql-eslint/match-document-filename": [
-          "error",
-          {
-            query: "kebab-case",
-            mutation: "kebab-case",
-            subscription: "kebab-case",
-            fragment: "kebab-case"
-          }
-        ],
-        "@graphql-eslint/no-one-place-fragments": "error",
-        "@graphql-eslint/require-import-fragment": "error"
-      }
-    };
-  }
-});
-
-// src/configs/operations-recommended.ts
-var require_operations_recommended = __commonJS({
-  "src/configs/operations-recommended.ts"(exports, module) {
-    "use strict";
-    module.exports = {
-      parser: "@graphql-eslint/eslint-plugin",
-      plugins: ["@graphql-eslint"],
-      rules: {
-        "@graphql-eslint/executable-definitions": "error",
-        "@graphql-eslint/fields-on-correct-type": "error",
-        "@graphql-eslint/fragments-on-composite-type": "error",
-        "@graphql-eslint/known-argument-names": "error",
-        "@graphql-eslint/known-directives": "error",
-        "@graphql-eslint/known-fragment-names": "error",
-        "@graphql-eslint/known-type-names": "error",
-        "@graphql-eslint/lone-anonymous-operation": "error",
-        "@graphql-eslint/naming-convention": [
-          "error",
-          {
-            VariableDefinition: "camelCase",
-            OperationDefinition: {
-              style: "PascalCase",
-              forbiddenPrefixes: ["Query", "Mutation", "Subscription", "Get"],
-              forbiddenSuffixes: ["Query", "Mutation", "Subscription"]
-            },
-            FragmentDefinition: {
-              style: "PascalCase",
-              forbiddenPrefixes: ["Fragment"],
-              forbiddenSuffixes: ["Fragment"]
-            }
-          }
-        ],
-        "@graphql-eslint/no-anonymous-operations": "error",
-        "@graphql-eslint/no-deprecated": "error",
-        "@graphql-eslint/no-duplicate-fields": "error",
-        "@graphql-eslint/no-fragment-cycles": "error",
-        "@graphql-eslint/no-undefined-variables": "error",
-        "@graphql-eslint/no-unused-fragments": "error",
-        "@graphql-eslint/no-unused-variables": "error",
-        "@graphql-eslint/one-field-subscriptions": "error",
-        "@graphql-eslint/overlapping-fields-can-be-merged": "error",
-        "@graphql-eslint/possible-fragment-spread": "error",
-        "@graphql-eslint/provided-required-arguments": "error",
-        "@graphql-eslint/require-selections": "error",
-        "@graphql-eslint/scalar-leafs": "error",
-        "@graphql-eslint/selection-set-depth": ["error", { maxDepth: 7 }],
-        "@graphql-eslint/unique-argument-names": "error",
-        "@graphql-eslint/unique-directive-names-per-location": "error",
-        "@graphql-eslint/unique-fragment-name": "error",
-        "@graphql-eslint/unique-input-field-names": "error",
-        "@graphql-eslint/unique-operation-name": "error",
-        "@graphql-eslint/unique-variable-names": "error",
-        "@graphql-eslint/value-literals-of-correct-type": "error",
-        "@graphql-eslint/variables-are-input-types": "error",
-        "@graphql-eslint/variables-in-allowed-position": "error"
-      }
-    };
-  }
-});
-
-// src/configs/schema-all.ts
-var require_schema_all = __commonJS({
-  "src/configs/schema-all.ts"(exports, module) {
-    "use strict";
-    module.exports = {
-      extends: "./configs/schema-recommended",
-      rules: {
-        "@graphql-eslint/alphabetize": [
-          "error",
-          {
-            definitions: !0,
-            fields: ["ObjectTypeDefinition", "InterfaceTypeDefinition", "InputObjectTypeDefinition"],
-            values: !0,
-            arguments: ["FieldDefinition", "Field", "DirectiveDefinition", "Directive"],
-            groups: ["id", "*", "createdAt", "updatedAt"]
-          }
-        ],
-        "@graphql-eslint/input-name": "error",
-        "@graphql-eslint/no-root-type": ["error", { disallow: ["mutation", "subscription"] }],
-        "@graphql-eslint/no-scalar-result-type-on-mutation": "error",
-        "@graphql-eslint/require-deprecation-date": "error",
-        "@graphql-eslint/require-field-of-type-query-in-mutation-result": "error",
-        "@graphql-eslint/require-nullable-fields-with-oneof": "error",
-        "@graphql-eslint/require-nullable-result-in-root": "error",
-        "@graphql-eslint/require-type-pattern-with-oneof": "error"
-      }
-    };
-  }
-});
-
-// src/configs/schema-recommended.ts
-var require_schema_recommended = __commonJS({
-  "src/configs/schema-recommended.ts"(exports, module) {
-    "use strict";
-    module.exports = {
-      parser: "@graphql-eslint/eslint-plugin",
-      plugins: ["@graphql-eslint"],
-      rules: {
-        "@graphql-eslint/description-style": "error",
-        "@graphql-eslint/known-argument-names": "error",
-        "@graphql-eslint/known-directives": "error",
-        "@graphql-eslint/known-type-names": "error",
-        "@graphql-eslint/lone-schema-definition": "error",
-        "@graphql-eslint/naming-convention": [
-          "error",
-          {
-            types: "PascalCase",
-            FieldDefinition: "camelCase",
-            InputValueDefinition: "camelCase",
-            Argument: "camelCase",
-            DirectiveDefinition: "camelCase",
-            EnumValueDefinition: "UPPER_CASE",
-            "FieldDefinition[parent.name.value=Query]": {
-              forbiddenPrefixes: ["query", "get"],
-              forbiddenSuffixes: ["Query"]
-            },
-            "FieldDefinition[parent.name.value=Mutation]": {
-              forbiddenPrefixes: ["mutation"],
-              forbiddenSuffixes: ["Mutation"]
-            },
-            "FieldDefinition[parent.name.value=Subscription]": {
-              forbiddenPrefixes: ["subscription"],
-              forbiddenSuffixes: ["Subscription"]
-            },
-            "EnumTypeDefinition,EnumTypeExtension": {
-              forbiddenPrefixes: ["Enum"],
-              forbiddenSuffixes: ["Enum"]
-            },
-            "InterfaceTypeDefinition,InterfaceTypeExtension": {
-              forbiddenPrefixes: ["Interface"],
-              forbiddenSuffixes: ["Interface"]
-            },
-            "UnionTypeDefinition,UnionTypeExtension": {
-              forbiddenPrefixes: ["Union"],
-              forbiddenSuffixes: ["Union"]
-            },
-            "ObjectTypeDefinition,ObjectTypeExtension": {
-              forbiddenPrefixes: ["Type"],
-              forbiddenSuffixes: ["Type"]
-            }
-          }
-        ],
-        "@graphql-eslint/no-hashtag-description": "error",
-        "@graphql-eslint/no-typename-prefix": "error",
-        "@graphql-eslint/no-unreachable-types": "error",
-        "@graphql-eslint/possible-type-extension": "error",
-        "@graphql-eslint/provided-required-arguments": "error",
-        "@graphql-eslint/require-deprecation-reason": "error",
-        "@graphql-eslint/require-description": [
-          "error",
-          { types: !0, DirectiveDefinition: !0, rootField: !0 }
-        ],
-        "@graphql-eslint/strict-id-in-types": "error",
-        "@graphql-eslint/unique-directive-names": "error",
-        "@graphql-eslint/unique-directive-names-per-location": "error",
-        "@graphql-eslint/unique-enum-value-names": "error",
-        "@graphql-eslint/unique-field-definition-names": "error",
-        "@graphql-eslint/unique-operation-types": "error",
-        "@graphql-eslint/unique-type-names": "error"
-      }
-    };
-  }
-});
-
-// src/configs/schema-relay.ts
-var require_schema_relay = __commonJS({
-  "src/configs/schema-relay.ts"(exports, module) {
-    "use strict";
-    module.exports = {
-      parser: "@graphql-eslint/eslint-plugin",
-      plugins: ["@graphql-eslint"],
-      rules: {
-        "@graphql-eslint/relay-arguments": "error",
-        "@graphql-eslint/relay-connection-types": "error",
-        "@graphql-eslint/relay-edge-types": "error",
-        "@graphql-eslint/relay-page-info": "error"
-      }
-    };
-  }
-});
-
 // src/parser.ts
 import debugFactory2 from "debug";
 import { buildSchema, GraphQLError } from "graphql";
@@ -341,8 +103,8 @@ function convertLocation(location) {
 }
 
 // src/estree-converter/converter.ts
-function convertToESTree(node, schema15) {
-  let typeInfo = schema15 && new TypeInfo(schema15), visitor = {
+function convertToESTree(node, schema16) {
+  let typeInfo = schema16 && new TypeInfo(schema16), visitor = {
     leave(node2, key, parent) {
       let leadingComments = "description" in node2 && node2.description ? [
         {
@@ -399,21 +161,21 @@ import {
 // src/utils.ts
 import { Kind as Kind2 } from "graphql";
 import lowerCase from "lodash.lowercase";
-function requireSiblingsOperations(ruleId, context) {
+function requireGraphQLOperations(ruleId, context) {
   let { siblingOperations } = context.sourceCode.parserServices;
   if (!siblingOperations.available)
     throw new Error(
-      `Rule \`${ruleId}\` requires graphql-config \`documents\` field to be set and loaded. See https://the-guild.dev/graphql/config/docs/user/documents for more info`
+      `Rule \`${ruleId}\` requires graphql-config \`documents\` field to be set and loaded. See https://the-guild.dev/graphql/eslint/docs/usage#providing-operations for more info`
     );
   return siblingOperations;
 }
-function requireGraphQLSchemaFromContext(ruleId, context) {
-  let { schema: schema15 } = context.sourceCode.parserServices;
-  if (!schema15)
+function requireGraphQLSchema(ruleId, context) {
+  let { schema: schema16 } = context.sourceCode.parserServices;
+  if (!schema16)
     throw new Error(
-      `Rule \`${ruleId}\` requires graphql-config \`schema\` field to be set and loaded. See https://the-guild.dev/graphql/config/docs/user/schema for more info`
+      `Rule \`${ruleId}\` requires graphql-config \`schema\` field to be set and loaded. See https://the-guild.dev/graphql/eslint/docs/usage#providing-schema for more info`
     );
-  return schema15;
+  return schema16;
 }
 var chalk = {
   red: (str) => `\x1B[31m${str}\x1B[39m`,
@@ -521,7 +283,7 @@ var DisplayNodeNameMap = {
   [Kind2.VARIABLE]: "variable"
 };
 function displayNodeName(node) {
-  return `${node.kind === Kind2.OPERATION_DEFINITION ? node.operation : DisplayNodeNameMap[node.kind]} "${"alias" in node && node.alias?.value || "name" in node && node.name?.value}"`;
+  return `${node.kind === Kind2.OPERATION_DEFINITION ? node.operation : DisplayNodeNameMap[node.kind]} "${"alias" in node && node.alias?.value || "name" in node && node.name?.value || node.value}"`;
 }
 function getNodeName(node) {
   switch (node.kind) {
@@ -635,7 +397,7 @@ function parseForESLint(code, options) {
         `\`parserOptions.${key}\` was removed in graphql-eslint@4. Use physical graphql-config for setting schema and documents or \`parserOptions.graphQLConfig\` for programmatic usage.`
       );
   try {
-    let { filePath } = options, { document } = parseGraphQLSDL(filePath, code, { noLocation: !1 }), project, schema15, documents;
+    let { filePath } = options, { document } = parseGraphQLSDL(filePath, code, { noLocation: !1 }), project, schema16, documents;
     documents = [
       parseGraphQLSDL(
         "operation.graphql",
@@ -644,14 +406,14 @@ function parseForESLint(code, options) {
       )
     ];
     try {
-      schema15 = buildSchema(options.graphQLConfig.schema);
+      schema16 = buildSchema(options.graphQLConfig.schema);
     } catch (error) {
       throw error instanceof Error && (error.message = `Error while loading schema: ${error.message}`), error;
     }
-    let rootTree = convertToESTree(document, schema15);
+    let rootTree = convertToESTree(document, schema16);
     return {
       services: {
-        schema: schema15,
+        schema: schema16,
         siblingOperations: getSiblings(documents)
       },
       ast: {
@@ -1118,14 +880,14 @@ import {
 import { validateSDL } from "graphql/validation/validate.js";
 function validateDocument({
   context,
-  schema: schema15 = null,
+  schema: schema16 = null,
   documentNode,
   rule: rule35,
   hasDidYouMeanSuggestions
 }) {
   if (documentNode.definitions.length !== 0)
     try {
-      let validationErrors = schema15 ? validate(schema15, documentNode, [rule35]) : validateSDL(documentNode, null, [rule35]);
+      let validationErrors = schema16 ? validate(schema16, documentNode, [rule35]) : validateSDL(documentNode, null, [rule35]);
       for (let error of validationErrors) {
         let { line, column } = error.locations[0], sourceCode = context.getSourceCode(), { tokens } = sourceCode.ast, token = tokens.find(
           (token2) => token2.loc.start.line === line && token2.loc.start.column === column - 1
@@ -1171,7 +933,7 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
 }, handleMissingFragments = ({ ruleId, context, node }) => {
   let missingFragments = getMissingFragments(node);
   if (missingFragments.length > 0) {
-    let siblings = requireSiblingsOperations(ruleId, context), fragmentsToAdd = [];
+    let siblings = requireGraphQLOperations(ruleId, context), fragmentsToAdd = [];
     for (let fragmentName of missingFragments) {
       let [foundFragment] = siblings.getFragment(fragmentName).map((source) => source.document);
       foundFragment && fragmentsToAdd.push(foundFragment);
@@ -1191,7 +953,7 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
   ruleId,
   rule: rule35,
   getDocumentNode,
-  schema: schema15 = [],
+  schema: schema16 = [],
   hasDidYouMeanSuggestions
 }, docs) => ({
   [ruleId]: {
@@ -1204,16 +966,16 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
         description: `${docs.description}
 > This rule is a wrapper around a \`graphql-js\` validation function.`
       },
-      schema: schema15,
+      schema: schema16,
       hasSuggestions: hasDidYouMeanSuggestions
     },
     create(context) {
       return {
         Document(node) {
-          let schema16 = docs.requiresSchema ? requireGraphQLSchemaFromContext(ruleId, context) : null, documentNode = getDocumentNode ? getDocumentNode({ ruleId, context, node: node.rawNode() }) : node.rawNode();
+          let schema17 = docs.requiresSchema ? requireGraphQLSchema(ruleId, context) : null, documentNode = getDocumentNode ? getDocumentNode({ ruleId, context, node: node.rawNode() }) : node.rawNode();
           validateDocument({
             context,
-            schema: schema16,
+            schema: schema17,
             documentNode,
             rule: rule35,
             hasDidYouMeanSuggestions
@@ -1454,7 +1216,7 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
       ruleId: "no-unused-fragments",
       rule: NoUnusedFragmentsRule,
       getDocumentNode: ({ ruleId, context, node }) => {
-        let siblings = requireSiblingsOperations(ruleId, context), FilePathToDocumentsMap = [
+        let siblings = requireGraphQLOperations(ruleId, context), FilePathToDocumentsMap = [
           ...siblings.getOperations(),
           ...siblings.getFragments()
         ].reduce((map, { filePath, document }) => (map[filePath] ??= [], map[filePath].push(document), map), /* @__PURE__ */ Object.create(null)), getParentNode = (currentFilePath, node2) => {
@@ -2509,12 +2271,14 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
           };
       }
     }, checkUnderscore = (isLeading) => (node) => {
+      if (node.parent.kind === "Field" && node.parent.alias !== node)
+        return;
       let suggestedName = node.value.replace(isLeading ? /^_+/ : /_+$/, "");
       report(node, `${isLeading ? "Leading" : "Trailing"} underscores are not allowed`, [
         suggestedName
       ]);
     }, listeners = {};
-    allowLeadingUnderscore || (listeners["Name[value=/^_/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])"] = checkUnderscore(!0)), allowTrailingUnderscore || (listeners["Name[value=/_$/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])"] = checkUnderscore(!1));
+    allowLeadingUnderscore || (listeners["Name[value=/^_/]"] = checkUnderscore(!0)), allowTrailingUnderscore || (listeners["Name[value=/_$/]"] = checkUnderscore(!1));
     let selectors = new Set(
       [types && TYPES_KINDS, Object.keys(restOptions)].flat().filter(truthy)
     );
@@ -2594,7 +2358,6 @@ var RULE_ID3 = "no-anonymous-operations", rule7 = {
 };
 
 // src/rules/no-deprecated/index.ts
-import { Kind as Kind10 } from "graphql";
 var RULE_ID4 = "no-deprecated", rule8 = {
   meta: {
     type: "suggestion",
@@ -2678,24 +2441,24 @@ var RULE_ID4 = "no-deprecated", rule8 = {
       recommended: !0
     },
     messages: {
-      [RULE_ID4]: "This {{ type }} is marked as deprecated in your GraphQL schema (reason: {{ reason }})"
+      [RULE_ID4]: "{{ type }} is marked as deprecated in your GraphQL schema (reason: {{ reason }})"
     },
     schema: []
   },
   create(context) {
-    requireGraphQLSchemaFromContext(RULE_ID4, context);
+    requireGraphQLSchema(RULE_ID4, context);
     function report(node, reason) {
-      let nodeName = node.kind === Kind10.ENUM ? node.value : node.name.value, nodeType = node.kind === Kind10.ENUM ? "enum value" : "field";
+      let nodeType = displayNodeName(node);
       context.report({
         node,
         messageId: RULE_ID4,
         data: {
-          type: nodeType,
+          type: nodeType[0].toUpperCase() + nodeType.slice(1),
           reason
         },
         suggest: [
           {
-            desc: `Remove \`${nodeName}\` ${nodeType}`,
+            desc: `Remove ${nodeType}`,
             fix: (fixer) => fixer.remove(node)
           }
         ]
@@ -2709,13 +2472,27 @@ var RULE_ID4 = "no-deprecated", rule8 = {
       Field(node) {
         let reason = node.typeInfo().fieldDef?.deprecationReason;
         reason && report(node, reason);
+      },
+      Argument(node) {
+        let reason = node.typeInfo().argument?.deprecationReason;
+        reason && report(node, reason);
+      },
+      ObjectValue(node) {
+        let { inputType } = node.typeInfo();
+        if (inputType && "getFields" in inputType) {
+          let fields = inputType.getFields();
+          for (let field of node.fields) {
+            let fieldName = field.name.value, reason = fields[fieldName].deprecationReason;
+            reason && report(field, reason);
+          }
+        }
       }
     };
   }
 };
 
 // src/rules/no-duplicate-fields/index.ts
-import { Kind as Kind11 } from "graphql";
+import { Kind as Kind10 } from "graphql";
 var RULE_ID5 = "no-duplicate-fields", rule9 = {
   meta: {
     type: "suggestion",
@@ -2799,7 +2576,7 @@ var RULE_ID5 = "no-duplicate-fields", rule9 = {
               desc: `Remove \`${fieldName}\` ${parent.type.toLowerCase()}`,
               fix(fixer) {
                 return fixer.remove(
-                  parent.type === Kind11.VARIABLE ? parent.parent : parent
+                  parent.type === Kind10.VARIABLE ? parent.parent : parent
                 );
               }
             }
@@ -2822,7 +2599,7 @@ var RULE_ID5 = "no-duplicate-fields", rule9 = {
       SelectionSet(node) {
         let set = /* @__PURE__ */ new Set();
         for (let selection of node.selections)
-          selection.kind === Kind11.FIELD && checkNode2(set, selection.alias || selection.name);
+          selection.kind === Kind10.FIELD && checkNode2(set, selection.alias || selection.name);
       }
     };
   }
@@ -2988,7 +2765,7 @@ var RULE_ID7 = "no-one-place-fragments", rule11 = {
     schema: []
   },
   create(context) {
-    let operations = requireSiblingsOperations(RULE_ID7, context), allDocuments = [...operations.getOperations(), ...operations.getFragments()], usedFragmentsMap = /* @__PURE__ */ Object.create(null);
+    let operations = requireGraphQLOperations(RULE_ID7, context), allDocuments = [...operations.getOperations(), ...operations.getFragments()], usedFragmentsMap = /* @__PURE__ */ Object.create(null);
     for (let { document, filePath } of allDocuments) {
       let relativeFilePath = relative(CWD, filePath);
       visit4(document, {
@@ -3069,9 +2846,9 @@ var schema7 = {
     schema: schema7
   },
   create(context) {
-    let schema15 = requireGraphQLSchemaFromContext("no-root-type", context), disallow = new Set(context.options[0].disallow), rootTypeNames = [
-      disallow.has("mutation") && schema15.getMutationType(),
-      disallow.has("subscription") && schema15.getSubscriptionType()
+    let schema16 = requireGraphQLSchema("no-root-type", context), disallow = new Set(context.options[0].disallow), rootTypeNames = [
+      disallow.has("mutation") && schema16.getMutationType(),
+      disallow.has("subscription") && schema16.getSubscriptionType()
     ].filter(truthy).map((type) => type.name).join("|");
     return rootTypeNames ? {
       [`:matches(ObjectTypeDefinition, ObjectTypeExtension) > .name[value=/^(${rootTypeNames})$/]`](node) {
@@ -3092,7 +2869,7 @@ var schema7 = {
 };
 
 // src/rules/no-scalar-result-type-on-mutation/index.ts
-import { isScalarType, Kind as Kind12 } from "graphql";
+import { isScalarType, Kind as Kind11 } from "graphql";
 var RULE_ID8 = "no-scalar-result-type-on-mutation", rule13 = {
   meta: {
     type: "suggestion",
@@ -3130,16 +2907,16 @@ var RULE_ID8 = "no-scalar-result-type-on-mutation", rule13 = {
     schema: []
   },
   create(context) {
-    let schema15 = requireGraphQLSchemaFromContext(RULE_ID8, context), mutationType = schema15.getMutationType();
+    let schema16 = requireGraphQLSchema(RULE_ID8, context), mutationType = schema16.getMutationType();
     return mutationType ? {
       [[
         `:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=${mutationType.name}]`,
         "> FieldDefinition > .gqlType Name"
       ].join(" ")](node) {
-        let typeName = node.value, graphQLType = schema15.getType(typeName);
+        let typeName = node.value, graphQLType = schema16.getType(typeName);
         if (isScalarType(graphQLType)) {
           let fieldDef = node.parent;
-          for (; fieldDef.kind !== Kind12.FIELD_DEFINITION; )
+          for (; fieldDef.kind !== Kind11.FIELD_DEFINITION; )
             fieldDef = fieldDef.parent;
           context.report({
             node,
@@ -3229,25 +3006,26 @@ var NO_TYPENAME_PREFIX = "NO_TYPENAME_PREFIX", rule14 = {
 // src/rules/no-unreachable-types/index.ts
 import {
   DirectiveLocation,
+  getNamedType,
   isInterfaceType,
-  Kind as Kind13,
+  Kind as Kind12,
   visit as visit5
 } from "graphql";
 import lowerCase3 from "lodash.lowercase";
 var RULE_ID9 = "no-unreachable-types", KINDS = [
-  Kind13.DIRECTIVE_DEFINITION,
-  Kind13.OBJECT_TYPE_DEFINITION,
-  Kind13.OBJECT_TYPE_EXTENSION,
-  Kind13.INTERFACE_TYPE_DEFINITION,
-  Kind13.INTERFACE_TYPE_EXTENSION,
-  Kind13.SCALAR_TYPE_DEFINITION,
-  Kind13.SCALAR_TYPE_EXTENSION,
-  Kind13.INPUT_OBJECT_TYPE_DEFINITION,
-  Kind13.INPUT_OBJECT_TYPE_EXTENSION,
-  Kind13.UNION_TYPE_DEFINITION,
-  Kind13.UNION_TYPE_EXTENSION,
-  Kind13.ENUM_TYPE_DEFINITION,
-  Kind13.ENUM_TYPE_EXTENSION
+  Kind12.DIRECTIVE_DEFINITION,
+  Kind12.OBJECT_TYPE_DEFINITION,
+  Kind12.OBJECT_TYPE_EXTENSION,
+  Kind12.INTERFACE_TYPE_DEFINITION,
+  Kind12.INTERFACE_TYPE_EXTENSION,
+  Kind12.SCALAR_TYPE_DEFINITION,
+  Kind12.SCALAR_TYPE_EXTENSION,
+  Kind12.INPUT_OBJECT_TYPE_DEFINITION,
+  Kind12.INPUT_OBJECT_TYPE_EXTENSION,
+  Kind12.UNION_TYPE_DEFINITION,
+  Kind12.UNION_TYPE_EXTENSION,
+  Kind12.ENUM_TYPE_DEFINITION,
+  Kind12.ENUM_TYPE_EXTENSION
 ], reachableTypesCache = new ModuleCache(), RequestDirectiveLocations = /* @__PURE__ */ new Set([
   DirectiveLocation.QUERY,
   DirectiveLocation.MUTATION,
@@ -3258,8 +3036,8 @@ var RULE_ID9 = "no-unreachable-types", KINDS = [
   DirectiveLocation.INLINE_FRAGMENT,
   DirectiveLocation.VARIABLE_DEFINITION
 ]);
-function getReachableTypes(schema15) {
-  let cachedValue = reachableTypesCache.get(schema15);
+function getReachableTypes(schema16) {
+  let cachedValue = reachableTypesCache.get(schema16);
   if (cachedValue)
     return cachedValue;
   let reachableTypes = /* @__PURE__ */ new Set(), collect = (node) => {
@@ -3267,9 +3045,9 @@ function getReachableTypes(schema15) {
     if (reachableTypes.has(typeName))
       return;
     reachableTypes.add(typeName);
-    let type = schema15.getType(typeName) || schema15.getDirective(typeName);
+    let type = schema16.getType(typeName) || schema16.getDirective(typeName);
     if (isInterfaceType(type)) {
-      let { objects, interfaces } = schema15.getImplementations(type);
+      let { objects, interfaces } = schema16.getImplementations(type);
       for (let { astNode } of [...objects, ...interfaces])
         visit5(astNode, visitor);
     } else type?.astNode && visit5(type.astNode, visitor);
@@ -3283,22 +3061,20 @@ function getReachableTypes(schema15) {
     NamedType: collect
   };
   for (let type of [
-    schema15,
+    schema16,
     // visiting SchemaDefinition node
-    schema15.getQueryType(),
-    schema15.getMutationType(),
-    schema15.getSubscriptionType()
+    schema16.getQueryType(),
+    schema16.getMutationType(),
+    schema16.getSubscriptionType()
   ])
     type?.astNode && visit5(type.astNode, visitor);
-  for (let node of schema15.getDirectives())
+  for (let node of schema16.getDirectives())
     if (node.locations.some((location) => RequestDirectiveLocations.has(location))) {
       reachableTypes.add(node.name);
-      for (let arg of node.args) {
-        let argTypeName = "name" in arg.type && arg.type.name;
-        argTypeName && reachableTypes.add(argTypeName);
-      }
+      for (let arg of node.args)
+        reachableTypes.add(getNamedType(arg.type).name);
     }
-  return reachableTypesCache.set(schema15, reachableTypes), reachableTypes;
+  return reachableTypesCache.set(schema16, reachableTypes), reachableTypes;
 }
 var rule15 = {
   meta: {
@@ -3351,7 +3127,7 @@ var rule15 = {
     hasSuggestions: !0
   },
   create(context) {
-    let schema15 = requireGraphQLSchemaFromContext(RULE_ID9, context), reachableTypes = getReachableTypes(schema15);
+    let schema16 = requireGraphQLSchema(RULE_ID9, context), reachableTypes = getReachableTypes(schema16);
     return {
       [`:matches(${KINDS}) > .name`](node) {
         let typeName = node.value;
@@ -3379,12 +3155,105 @@ var rule15 = {
 
 // src/rules/no-unused-fields/index.ts
 import { TypeInfo as TypeInfo2, visit as visit6, visitWithTypeInfo as visitWithTypeInfo2 } from "graphql";
-var RULE_ID10 = "no-unused-fields", usedFieldsCache = new ModuleCache();
-function getUsedFields(schema15, operations) {
-  let cachedValue = usedFieldsCache.get(schema15);
+var RULE_ID10 = "no-unused-fields", RELAY_SCHEMA = (
+  /* GraphQL */
+  `
+  # Root Query Type
+  type Query {
+    user: User
+  }
+
+  # User Type
+  type User {
+    id: ID!
+    name: String!
+    friends(first: Int, after: String): FriendConnection!
+  }
+
+  # FriendConnection Type (Relay Connection)
+  type FriendConnection {
+    edges: [FriendEdge]
+    pageInfo: PageInfo!
+  }
+
+  # FriendEdge Type
+  type FriendEdge {
+    cursor: String!
+    node: Friend!
+  }
+
+  # Friend Type
+  type Friend {
+    id: ID!
+    name: String!
+  }
+
+  # PageInfo Type (Relay Pagination)
+  type PageInfo {
+    hasPreviousPage: Boolean!
+    hasNextPage: Boolean!
+    startCursor: String
+    endCursor: String
+  }
+`
+), RELAY_QUERY = (
+  /* GraphQL */
+  `
+  query {
+    user {
+      id
+      name
+      friends(first: 10) {
+        edges {
+          node {
+            id
+            name
+          }
+        }
+      }
+    }
+  }
+`
+), RELAY_DEFAULT_IGNORED_FIELD_SELECTORS = [
+  "[parent.name.value=PageInfo][name.value=/(endCursor|startCursor|hasNextPage|hasPreviousPage)/]",
+  "[parent.name.value=/Edge$/][name.value=cursor]",
+  "[parent.name.value=/Connection$/][name.value=pageInfo]"
+], schema8 = {
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: !1,
+    properties: {
+      ignoredFieldSelectors: {
+        type: "array",
+        uniqueItems: !0,
+        minItems: 1,
+        description: [
+          "Fields that will be ignored and are allowed to be unused.",
+          "",
+          "E.g. The following selector will ignore all the relay pagination fields for every connection exposed in the schema:",
+          "```json",
+          JSON.stringify(RELAY_DEFAULT_IGNORED_FIELD_SELECTORS, null, 2),
+          "```",
+          "",
+          "> These fields are defined by ESLint [`selectors`](https://eslint.org/docs/developer-guide/selectors).",
+          "> Paste or drop code into the editor in [ASTExplorer](https://astexplorer.net) and inspect the generated AST to compose your selector."
+        ].join(`
+`),
+        items: {
+          type: "string",
+          pattern: "^\\[(.+)]$"
+        }
+      }
+    }
+  }
+}, usedFieldsCache = new ModuleCache();
+function getUsedFields(schema16, operations) {
+  let cachedValue = usedFieldsCache.get(schema16);
   if (cachedValue)
     return cachedValue;
-  let usedFields = /* @__PURE__ */ Object.create(null), typeInfo = new TypeInfo2(schema15), visitor = visitWithTypeInfo2(typeInfo, {
+  let usedFields = /* @__PURE__ */ Object.create(null), typeInfo = new TypeInfo2(schema16), visitor = visitWithTypeInfo2(typeInfo, {
     Field(node) {
       if (!typeInfo.getFieldDef())
         return !1;
@@ -3394,7 +3263,7 @@ function getUsedFields(schema15, operations) {
   }), allDocuments = [...operations.getOperations(), ...operations.getFragments()];
   for (let { document } of allDocuments)
     visit6(document, visitor);
-  return usedFieldsCache.set(schema15, usedFields), usedFields;
+  return usedFieldsCache.set(schema16, usedFields), usedFields;
 }
 var rule16 = {
   meta: {
@@ -3456,17 +3325,34 @@ var rule16 = {
             }
           `
           )
+        },
+        {
+          title: "Correct (ignoring fields)",
+          usage: [{ ignoredFieldSelectors: RELAY_DEFAULT_IGNORED_FIELD_SELECTORS }],
+          code: (
+            /* GraphQL */
+            `
+            ### 1\uFE0F\u20E3 YOUR SCHEMA
+            ${RELAY_SCHEMA}
+
+            ### 2\uFE0F\u20E3 YOUR QUERY
+            ${RELAY_QUERY}
+          `
+          )
         }
       ]
     },
     type: "suggestion",
-    schema: [],
+    schema: schema8,
     hasSuggestions: !0
   },
   create(context) {
-    let schema15 = requireGraphQLSchemaFromContext(RULE_ID10, context), siblingsOperations = requireSiblingsOperations(RULE_ID10, context), usedFields = getUsedFields(schema15, siblingsOperations);
+    let schema16 = requireGraphQLSchema(RULE_ID10, context), siblingsOperations = requireGraphQLOperations(RULE_ID10, context), usedFields = getUsedFields(schema16, siblingsOperations), { ignoredFieldSelectors } = context.options[0] || {};
     return {
-      FieldDefinition(node) {
+      [(ignoredFieldSelectors || []).reduce(
+        (acc, selector2) => `${acc}:not(${selector2})`,
+        "FieldDefinition"
+      )](node) {
         let fieldName = node.name.value, parentTypeName = node.parent.name.value;
         usedFields[parentTypeName]?.has(fieldName) || context.report({
           node: node.name,
@@ -3488,8 +3374,8 @@ var rule16 = {
 };
 
 // src/rules/relay-arguments/index.ts
-import { isScalarType as isScalarType2, Kind as Kind14 } from "graphql";
-var RULE_ID11 = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", schema8 = {
+import { isScalarType as isScalarType2, Kind as Kind13 } from "graphql";
+var RULE_ID11 = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", schema9 = {
   type: "array",
   maxItems: 1,
   items: {
@@ -3555,14 +3441,14 @@ var RULE_ID11 = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
     messages: {
       [MISSING_ARGUMENTS]: "A field that returns a Connection type must include forward pagination arguments (`first` and `after`), backward pagination arguments (`last` and `before`), or both."
     },
-    schema: schema8
+    schema: schema9
   },
   create(context) {
-    let schema15 = requireGraphQLSchemaFromContext(RULE_ID11, context), { includeBoth = !0 } = context.options[0] || {};
+    let schema16 = requireGraphQLSchema(RULE_ID11, context), { includeBoth = !0 } = context.options[0] || {};
     return {
       "FieldDefinition > .gqlType Name[value=/Connection$/]"(node) {
         let fieldNode = node.parent;
-        for (; fieldNode.kind !== Kind14.FIELD_DEFINITION; )
+        for (; fieldNode.kind !== Kind13.FIELD_DEFINITION; )
           fieldNode = fieldNode.parent;
         let args = Object.fromEntries(
           fieldNode.arguments?.map((argument) => [argument.name.value, argument]) || []
@@ -3576,7 +3462,7 @@ var RULE_ID11 = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
         }
         function checkField(typeName, argumentName) {
           let argument = args[argumentName], hasArgument = !!argument, type = argument;
-          if (hasArgument && type.gqlType.kind === Kind14.NON_NULL_TYPE && (type = type.gqlType), !(hasArgument && type.gqlType.kind === Kind14.NAMED_TYPE && (type.gqlType.name.value === typeName || typeName === "String" && isScalarType2(schema15.getType(type.gqlType.name.value))))) {
+          if (hasArgument && type.gqlType.kind === Kind13.NON_NULL_TYPE && (type = type.gqlType), !(hasArgument && type.gqlType.kind === Kind13.NAMED_TYPE && (type.gqlType.name.value === typeName || typeName === "String" && isScalarType2(schema16.getType(type.gqlType.name.value))))) {
             let returnType = typeName === "String" ? "String or Scalar" : typeName;
             context.report({
               node: (argument || fieldNode).name,
@@ -3591,17 +3477,17 @@ var RULE_ID11 = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
 };
 
 // src/rules/relay-connection-types/index.ts
-import { Kind as Kind15 } from "graphql";
+import { Kind as Kind14 } from "graphql";
 var MUST_BE_OBJECT_TYPE = "MUST_BE_OBJECT_TYPE", MUST_CONTAIN_FIELD_EDGES = "MUST_CONTAIN_FIELD_EDGES", MUST_CONTAIN_FIELD_PAGE_INFO = "MUST_CONTAIN_FIELD_PAGE_INFO", MUST_HAVE_CONNECTION_SUFFIX = "MUST_HAVE_CONNECTION_SUFFIX", EDGES_FIELD_MUST_RETURN_LIST_TYPE = "EDGES_FIELD_MUST_RETURN_LIST_TYPE", PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE = "PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE", NON_OBJECT_TYPES = [
-  Kind15.SCALAR_TYPE_DEFINITION,
-  Kind15.UNION_TYPE_DEFINITION,
-  Kind15.UNION_TYPE_EXTENSION,
-  Kind15.INPUT_OBJECT_TYPE_DEFINITION,
-  Kind15.INPUT_OBJECT_TYPE_EXTENSION,
-  Kind15.ENUM_TYPE_DEFINITION,
-  Kind15.ENUM_TYPE_EXTENSION,
-  Kind15.INTERFACE_TYPE_DEFINITION,
-  Kind15.INTERFACE_TYPE_EXTENSION
+  Kind14.SCALAR_TYPE_DEFINITION,
+  Kind14.UNION_TYPE_DEFINITION,
+  Kind14.UNION_TYPE_EXTENSION,
+  Kind14.INPUT_OBJECT_TYPE_DEFINITION,
+  Kind14.INPUT_OBJECT_TYPE_EXTENSION,
+  Kind14.ENUM_TYPE_DEFINITION,
+  Kind14.ENUM_TYPE_EXTENSION,
+  Kind14.INTERFACE_TYPE_DEFINITION,
+  Kind14.INTERFACE_TYPE_EXTENSION
 ], notConnectionTypesSelector = `:matches(${NON_OBJECT_TYPES})[name.value=/Connection$/] > .name`, hasEdgesField = (node) => node.fields?.some((field) => field.name.value === "edges"), hasPageInfoField = (node) => node.fields?.some((field) => field.name.value === "pageInfo"), rule18 = {
   meta: {
     type: "problem",
@@ -3668,10 +3554,10 @@ var MUST_BE_OBJECT_TYPE = "MUST_BE_OBJECT_TYPE", MUST_CONTAIN_FIELD_EDGES = "MUS
         hasEdgesField(node) || context.report({ node: node.name, messageId: MUST_CONTAIN_FIELD_EDGES }), hasPageInfoField(node) || context.report({ node: node.name, messageId: MUST_CONTAIN_FIELD_PAGE_INFO });
       },
       ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=edges] > .gqlType"(node) {
-        node.kind === Kind15.LIST_TYPE || node.kind === Kind15.NON_NULL_TYPE && node.gqlType.kind === Kind15.LIST_TYPE || context.report({ node, messageId: EDGES_FIELD_MUST_RETURN_LIST_TYPE });
+        node.kind === Kind14.LIST_TYPE || node.kind === Kind14.NON_NULL_TYPE && node.gqlType.kind === Kind14.LIST_TYPE || context.report({ node, messageId: EDGES_FIELD_MUST_RETURN_LIST_TYPE });
       },
       ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=pageInfo] > .gqlType"(node) {
-        node.kind === Kind15.NON_NULL_TYPE && node.gqlType.kind === Kind15.NAMED_TYPE && node.gqlType.name.value === "PageInfo" || context.report({ node, messageId: PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE });
+        node.kind === Kind14.NON_NULL_TYPE && node.gqlType.kind === Kind14.NAMED_TYPE && node.gqlType.name.value === "PageInfo" || context.report({ node, messageId: PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE });
       }
     };
   }
@@ -3681,12 +3567,12 @@ var MUST_BE_OBJECT_TYPE = "MUST_BE_OBJECT_TYPE", MUST_CONTAIN_FIELD_EDGES = "MUS
 import {
   isObjectType as isObjectType2,
   isScalarType as isScalarType3,
-  Kind as Kind16,
+  Kind as Kind15,
   visit as visit7
 } from "graphql";
 import { getDocumentNodeFromSchema } from "@graphql-tools/utils";
 var RULE_ID12 = "relay-edge-types", MESSAGE_MUST_BE_OBJECT_TYPE = "MESSAGE_MUST_BE_OBJECT_TYPE", MESSAGE_MISSING_EDGE_SUFFIX = "MESSAGE_MISSING_EDGE_SUFFIX", MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE = "MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE", MESSAGE_SHOULD_IMPLEMENTS_NODE = "MESSAGE_SHOULD_IMPLEMENTS_NODE", edgeTypesCache;
-function getEdgeTypes(schema15) {
+function getEdgeTypes(schema16) {
   if (edgeTypesCache)
     return edgeTypesCache;
   let edgeTypes = /* @__PURE__ */ new Set(), visitor = {
@@ -3695,14 +3581,14 @@ function getEdgeTypes(schema15) {
         return;
       let edges = node.fields?.find((field) => field.name.value === "edges");
       if (edges) {
-        let edgesTypeName = getTypeName(edges), edgesType = schema15.getType(edgesTypeName);
+        let edgesTypeName = getTypeName(edges), edgesType = schema16.getType(edgesTypeName);
         isObjectType2(edgesType) && edgeTypes.add(edgesTypeName);
       }
     }
-  }, astNode = getDocumentNodeFromSchema(schema15);
+  }, astNode = getDocumentNodeFromSchema(schema16);
   return visit7(astNode, visitor), edgeTypesCache = edgeTypes, edgeTypesCache;
 }
-var schema9 = {
+var schema10 = {
   type: "array",
   maxItems: 1,
   items: {
@@ -3768,15 +3654,15 @@ var schema9 = {
       [MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE]: "A list type should only wrap an edge type.",
       [MESSAGE_SHOULD_IMPLEMENTS_NODE]: "Edge type's field `node` must implement `Node` interface."
     },
-    schema: schema9
+    schema: schema10
   },
   create(context) {
-    let schema15 = requireGraphQLSchemaFromContext(RULE_ID12, context), edgeTypes = getEdgeTypes(schema15), options = {
+    let schema16 = requireGraphQLSchema(RULE_ID12, context), edgeTypes = getEdgeTypes(schema16), options = {
       withEdgeSuffix: !0,
       shouldImplementNode: !0,
       listTypeCanWrapOnlyEdgeType: !0,
       ...context.options[0]
-    }, isNamedOrNonNullNamed = (node) => node.kind === Kind16.NAMED_TYPE || node.kind === Kind16.NON_NULL_TYPE && node.gqlType.kind === Kind16.NAMED_TYPE, checkNodeField = (node) => {
+    }, isNamedOrNonNullNamed = (node) => node.kind === Kind15.NAMED_TYPE || node.kind === Kind15.NON_NULL_TYPE && node.gqlType.kind === Kind15.NAMED_TYPE, checkNodeField = (node) => {
       let nodeField = node.fields?.find((field) => field.name.value === "node"), message = "return either a Scalar, Enum, Object, Interface, Union, or a non-null wrapper around one of those types.";
       if (!nodeField)
         context.report({
@@ -3786,7 +3672,7 @@ var schema9 = {
       else if (!isNamedOrNonNullNamed(nodeField.gqlType))
         context.report({ node: nodeField.name, message: `Field \`node\` must ${message}` });
       else if (options.shouldImplementNode) {
-        let nodeReturnTypeName = getTypeName(nodeField.gqlType.rawNode()), type = schema15.getType(nodeReturnTypeName);
+        let nodeReturnTypeName = getTypeName(nodeField.gqlType.rawNode()), type = schema16.getType(nodeReturnTypeName);
         if (!isObjectType2(type))
           return;
         type.astNode.interfaces?.some((n) => n.name.value === "Node") || context.report({ node: node.name, messageId: MESSAGE_SHOULD_IMPLEMENTS_NODE });
@@ -3801,10 +3687,10 @@ var schema9 = {
         return;
       }
       let typeName = getTypeName(cursorField.rawNode());
-      (!isNamedOrNonNullNamed(cursorField.gqlType) || typeName !== "String" && !isScalarType3(schema15.getType(typeName))) && context.report({ node: cursorField.name, message: `Field \`cursor\` must ${message}` });
+      (!isNamedOrNonNullNamed(cursorField.gqlType) || typeName !== "String" && !isScalarType3(schema16.getType(typeName))) && context.report({ node: cursorField.name, message: `Field \`cursor\` must ${message}` });
     }, listeners = {
       ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=edges] > .gqlType Name"(node) {
-        let type = schema15.getType(node.value);
+        let type = schema16.getType(node.value);
         isObjectType2(type) || context.report({ node, messageId: MESSAGE_MUST_BE_OBJECT_TYPE });
       },
       ":matches(ObjectTypeDefinition, ObjectTypeExtension)"(node) {
@@ -3813,7 +3699,7 @@ var schema9 = {
       }
     };
     return options.listTypeCanWrapOnlyEdgeType && (listeners["FieldDefinition > .gqlType"] = (node) => {
-      if (node.kind === Kind16.LIST_TYPE || node.kind === Kind16.NON_NULL_TYPE && node.gqlType.kind === Kind16.LIST_TYPE) {
+      if (node.kind === Kind15.LIST_TYPE || node.kind === Kind15.NON_NULL_TYPE && node.gqlType.kind === Kind15.LIST_TYPE) {
         let typeName = getTypeName(node.rawNode());
         edgeTypes.has(typeName) || context.report({ node, messageId: MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE });
       }
@@ -3822,7 +3708,7 @@ var schema9 = {
 };
 
 // src/rules/relay-page-info/index.ts
-import { isScalarType as isScalarType4, Kind as Kind17 } from "graphql";
+import { isScalarType as isScalarType4, Kind as Kind16 } from "graphql";
 var RULE_ID13 = "relay-page-info", MESSAGE_MUST_EXIST = "MESSAGE_MUST_EXIST", MESSAGE_MUST_BE_OBJECT_TYPE2 = "MESSAGE_MUST_BE_OBJECT_TYPE", notPageInfoTypesSelector = `:matches(${NON_OBJECT_TYPES})[name.value=PageInfo] > .name`, hasPageInfoChecked = !1, rule20 = {
   meta: {
     type: "problem",
@@ -3863,8 +3749,8 @@ var RULE_ID13 = "relay-page-info", MESSAGE_MUST_EXIST = "MESSAGE_MUST_EXIST", ME
     schema: []
   },
   create(context) {
-    let schema15 = requireGraphQLSchemaFromContext(RULE_ID13, context);
-    return hasPageInfoChecked || (schema15.getType("PageInfo") || context.report({
+    let schema16 = requireGraphQLSchema(RULE_ID13, context);
+    return hasPageInfoChecked || (schema16.getType("PageInfo") || context.report({
       loc: REPORT_ON_FIRST_CHARACTER,
       messageId: MESSAGE_MUST_EXIST
     }), hasPageInfoChecked = !0), {
@@ -3878,7 +3764,7 @@ var RULE_ID13 = "relay-page-info", MESSAGE_MUST_EXIST = "MESSAGE_MUST_EXIST", ME
           let field = fieldMap[fieldName], isAllowedType = !1;
           if (field) {
             let type = field.gqlType;
-            typeName === "Boolean" ? isAllowedType = type.kind === Kind17.NON_NULL_TYPE && type.gqlType.kind === Kind17.NAMED_TYPE && type.gqlType.name.value === "Boolean" : type.kind === Kind17.NAMED_TYPE && (isAllowedType = type.name.value === "String" || isScalarType4(schema15.getType(type.name.value)));
+            typeName === "Boolean" ? isAllowedType = type.kind === Kind16.NON_NULL_TYPE && type.gqlType.kind === Kind16.NAMED_TYPE && type.gqlType.name.value === "Boolean" : type.kind === Kind16.NAMED_TYPE && (isAllowedType = type.name.value === "String" || isScalarType4(schema16.getType(type.name.value)));
           }
           if (!isAllowedType) {
             let returnType = typeName === "Boolean" ? "non-null Boolean" : "either String or Scalar, which can be null if there are no results";
@@ -3895,7 +3781,7 @@ var RULE_ID13 = "relay-page-info", MESSAGE_MUST_EXIST = "MESSAGE_MUST_EXIST", ME
 };
 
 // src/rules/require-deprecation-date/index.ts
-var DATE_REGEX = /^\d{2}\/\d{2}\/\d{4}$/, MESSAGE_REQUIRE_DATE = "MESSAGE_REQUIRE_DATE", MESSAGE_INVALID_FORMAT = "MESSAGE_INVALID_FORMAT", MESSAGE_INVALID_DATE = "MESSAGE_INVALID_DATE", MESSAGE_CAN_BE_REMOVED = "MESSAGE_CAN_BE_REMOVED", schema10 = {
+var DATE_REGEX = /^\d{2}\/\d{2}\/\d{4}$/, MESSAGE_REQUIRE_DATE = "MESSAGE_REQUIRE_DATE", MESSAGE_INVALID_FORMAT = "MESSAGE_INVALID_FORMAT", MESSAGE_INVALID_DATE = "MESSAGE_INVALID_DATE", MESSAGE_CAN_BE_REMOVED = "MESSAGE_CAN_BE_REMOVED", schema11 = {
   type: "array",
   maxItems: 1,
   items: {
@@ -3961,7 +3847,7 @@ var DATE_REGEX = /^\d{2}\/\d{2}\/\d{4}$/, MESSAGE_REQUIRE_DATE = "MESSAGE_REQUIR
       [MESSAGE_INVALID_DATE]: 'Invalid "{{ deletionDate }}" deletion date for {{ nodeName }}',
       [MESSAGE_CAN_BE_REMOVED]: "{{ nodeName }} \u0441an be removed"
     },
-    schema: schema10
+    schema: schema11
   },
   create(context) {
     return {
@@ -4082,16 +3968,16 @@ var rule22 = {
 };
 
 // src/rules/require-description/index.ts
-import { Kind as Kind18, TokenKind as TokenKind3 } from "graphql";
+import { Kind as Kind17, TokenKind as TokenKind3 } from "graphql";
 import { getRootTypeNames } from "@graphql-tools/utils";
 var RULE_ID14 = "require-description", ALLOWED_KINDS2 = [
   ...TYPES_KINDS,
-  Kind18.DIRECTIVE_DEFINITION,
-  Kind18.FIELD_DEFINITION,
-  Kind18.INPUT_VALUE_DEFINITION,
-  Kind18.ENUM_VALUE_DEFINITION,
-  Kind18.OPERATION_DEFINITION
-], schema11 = {
+  Kind17.DIRECTIVE_DEFINITION,
+  Kind17.FIELD_DEFINITION,
+  Kind17.INPUT_VALUE_DEFINITION,
+  Kind17.ENUM_VALUE_DEFINITION,
+  Kind17.OPERATION_DEFINITION
+], schema12 = {
   type: "array",
   minItems: 1,
   maxItems: 1,
@@ -4113,7 +3999,7 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
       ...Object.fromEntries(
         [...ALLOWED_KINDS2].sort().map((kind) => {
           let description = `Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#${kind}).`;
-          return kind === Kind18.OPERATION_DEFINITION && (description += '\n> You must use only comment syntax `#` and not description syntax `"""` or `"`.'), [kind, { type: "boolean", description }];
+          return kind === Kind17.OPERATION_DEFINITION && (description += '\n> You must use only comment syntax `#` and not description syntax `"""` or `"`.'), [kind, { type: "boolean", description }];
         })
       )
     }
@@ -4189,7 +4075,7 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
       configOptions: [
         {
           types: !0,
-          [Kind18.DIRECTIVE_DEFINITION]: !0,
+          [Kind17.DIRECTIVE_DEFINITION]: !0,
           rootField: !0
         }
       ],
@@ -4199,23 +4085,25 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
     messages: {
       [RULE_ID14]: "Description is required for {{ nodeName }}"
     },
-    schema: schema11
+    schema: schema12
   },
   create(context) {
     let { types, rootField, ...restOptions } = context.options[0] || {}, kinds = new Set(types ? TYPES_KINDS : []);
     for (let [kind, isEnabled] of Object.entries(restOptions))
       isEnabled ? kinds.add(kind) : kinds.delete(kind);
     if (rootField) {
-      let schema15 = requireGraphQLSchemaFromContext(RULE_ID14, context), rootTypeNames = getRootTypeNames(schema15);
+      let schema16 = requireGraphQLSchema(RULE_ID14, context), rootTypeNames = getRootTypeNames(schema16);
       kinds.add(
         `:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/^(${[
           ...rootTypeNames
         ].join(",")})$/] > FieldDefinition`
       );
     }
+    if (!kinds.size)
+      throw new Error("At least one kind must be enabled");
     return {
       [[...kinds].join(",")](node) {
-        let description = "", isOperation = node.kind === Kind18.OPERATION_DEFINITION;
+        let description = "", isOperation = node.kind === Kind17.OPERATION_DEFINITION;
         if (isOperation) {
           let rawNode = node.rawNode(), { prev, line } = rawNode.loc.startToken;
           if (prev?.kind === TokenKind3.COMMENT) {
@@ -4285,10 +4173,10 @@ var RULE_ID15 = "require-field-of-type-query-in-mutation-result", rule24 = {
     schema: []
   },
   create(context) {
-    let schema15 = requireGraphQLSchemaFromContext(RULE_ID15, context), mutationType = schema15.getMutationType(), queryType = schema15.getQueryType();
+    let schema16 = requireGraphQLSchema(RULE_ID15, context), mutationType = schema16.getMutationType(), queryType = schema16.getQueryType();
     return !mutationType || !queryType ? {} : {
       [`:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=${mutationType.name}] > FieldDefinition > .gqlType Name`](node) {
-        let typeName = node.value, graphQLType = schema15.getType(typeName);
+        let typeName = node.value, graphQLType = schema16.getType(typeName);
         if (isObjectType3(graphQLType)) {
           let { fields } = graphQLType.astNode;
           fields?.some((field) => getTypeName(field) === queryType.name) || context.report({
@@ -4377,7 +4265,7 @@ var RULE_ID16 = "require-import-fragment", SUGGESTION_ID = "add-import-expressio
     schema: []
   },
   create(context) {
-    let comments = context.getSourceCode().getAllComments(), siblings = requireSiblingsOperations(RULE_ID16, context), filePath = context.filename;
+    let comments = context.getSourceCode().getAllComments(), siblings = requireGraphQLOperations(RULE_ID16, context), filePath = context.filename;
     return {
       "FragmentSpread > .name"(node) {
         let fragmentName = node.value, fragmentsFromSiblings = siblings.getFragment(fragmentName);
@@ -4421,7 +4309,7 @@ var RULE_ID16 = "require-import-fragment", SUGGESTION_ID = "add-import-expressio
 };
 
 // src/rules/require-nullable-fields-with-oneof/index.ts
-import { Kind as Kind19 } from "graphql";
+import { Kind as Kind18 } from "graphql";
 var RULE_ID17 = "require-nullable-fields-with-oneof", rule26 = {
   meta: {
     type: "suggestion",
@@ -4465,11 +4353,11 @@ var RULE_ID17 = "require-nullable-fields-with-oneof", rule26 = {
     return {
       "Directive[name.value=oneOf]"({ parent }) {
         if ([
-          Kind19.OBJECT_TYPE_DEFINITION,
-          Kind19.INPUT_OBJECT_TYPE_DEFINITION
+          Kind18.OBJECT_TYPE_DEFINITION,
+          Kind18.INPUT_OBJECT_TYPE_DEFINITION
         ].includes(parent.kind))
           for (let field of parent.fields || [])
-            field.gqlType.kind === Kind19.NON_NULL_TYPE && context.report({
+            field.gqlType.kind === Kind18.NON_NULL_TYPE && context.report({
               node: field.name,
               messageId: RULE_ID17,
               data: { nodeName: getNodeName(field) }
@@ -4480,7 +4368,7 @@ var RULE_ID17 = "require-nullable-fields-with-oneof", rule26 = {
 };
 
 // src/rules/require-nullable-result-in-root/index.ts
-import { Kind as Kind20 } from "graphql";
+import { Kind as Kind19 } from "graphql";
 var RULE_ID18 = "require-nullable-result-in-root", rule27 = {
   meta: {
     type: "suggestion",
@@ -4523,16 +4411,16 @@ var RULE_ID18 = "require-nullable-result-in-root", rule27 = {
     schema: []
   },
   create(context) {
-    let schema15 = requireGraphQLSchemaFromContext(RULE_ID18, context), rootTypeNames = new Set(
-      [schema15.getQueryType(), schema15.getMutationType()].filter(truthy).map((type) => type.name)
+    let schema16 = requireGraphQLSchema(RULE_ID18, context), rootTypeNames = new Set(
+      [schema16.getQueryType(), schema16.getMutationType()].filter(truthy).map((type) => type.name)
     ), sourceCode = context.getSourceCode();
     return {
       "ObjectTypeDefinition,ObjectTypeExtension"(node) {
         if (rootTypeNames.has(node.name.value))
           for (let field of node.fields || []) {
-            if (field.gqlType.type !== Kind20.NON_NULL_TYPE || field.gqlType.gqlType.type !== Kind20.NAMED_TYPE)
+            if (field.gqlType.type !== Kind19.NON_NULL_TYPE || field.gqlType.gqlType.type !== Kind19.NAMED_TYPE)
               continue;
-            let name = field.gqlType.gqlType.name.value, type = schema15.getType(name), resultType = type?.astNode ? getNodeName(type.astNode) : type?.name;
+            let name = field.gqlType.gqlType.name.value, type = schema16.getType(name), resultType = type?.astNode ? getNodeName(type.astNode) : type?.name;
             context.report({
               node: field.gqlType,
               messageId: RULE_ID18,
@@ -4561,13 +4449,13 @@ import {
   GraphQLInterfaceType,
   GraphQLObjectType,
   GraphQLUnionType,
-  Kind as Kind21,
+  Kind as Kind20,
   TypeInfo as TypeInfo3,
   visit as visit8,
   visitWithTypeInfo as visitWithTypeInfo3
 } from "graphql";
 import { asArray } from "@graphql-tools/utils";
-var RULE_ID19 = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema12 = {
+var RULE_ID19 = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema13 = {
   definitions: {
     asString: {
       type: "string"
@@ -4646,19 +4534,20 @@ var RULE_ID19 = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema12 = {
           )
         }
       ],
-      recommended: !0
+      recommended: !0,
+      whenNotToUseIt: "Relay Compiler automatically adds an `id` field to any type that has an `id` field, even if it hasn't been explicitly requested. Requesting a field that is not used directly in the code can conflict with another Relay rule: `relay/unused-fields`."
     },
     messages: {
       [RULE_ID19]: `Field{{ pluralSuffix }} {{ fieldName }} must be selected when it's available on a type.
 Include it in your selection set{{ addition }}.`
     },
-    schema: schema12
+    schema: schema13
   },
   create(context) {
-    let schema15 = requireGraphQLSchemaFromContext(RULE_ID19, context), siblings = requireSiblingsOperations(RULE_ID19, context), { fieldName = DEFAULT_ID_FIELD_NAME } = context.options[0] || {}, idNames = asArray(fieldName), selector = "OperationDefinition SelectionSet[parent.kind!=/(^OperationDefinition|InlineFragment)$/]", typeInfo = new TypeInfo3(schema15);
+    let schema16 = requireGraphQLSchema(RULE_ID19, context), siblings = requireGraphQLOperations(RULE_ID19, context), { fieldName = DEFAULT_ID_FIELD_NAME } = context.options[0] || {}, idNames = asArray(fieldName), selector = "SelectionSet[parent.kind!=/(^OperationDefinition|InlineFragment)$/]", typeInfo = new TypeInfo3(schema16);
     function checkFragments(node) {
       for (let selection of node.selections) {
-        if (selection.kind !== Kind21.FRAGMENT_SPREAD)
+        if (selection.kind !== Kind20.FRAGMENT_SPREAD)
           continue;
         let [foundSpread] = siblings.getFragment(selection.name.value);
         if (!foundSpread)
@@ -4666,7 +4555,7 @@ Include it in your selection set{{ addition }}.`
         let checkedFragmentSpreads = /* @__PURE__ */ new Set(), visitor = visitWithTypeInfo3(typeInfo, {
           SelectionSet(node2, key, _parent) {
             let parent = _parent;
-            parent.kind === Kind21.FRAGMENT_DEFINITION ? checkedFragmentSpreads.add(parent.name.value) : parent.kind !== Kind21.INLINE_FRAGMENT && checkSelections(
+            parent.kind === Kind20.FRAGMENT_DEFINITION ? checkedFragmentSpreads.add(parent.name.value) : parent.kind !== Kind20.INLINE_FRAGMENT && checkSelections(
               node2,
               typeInfo.getType(),
               selection.loc.start,
@@ -4682,24 +4571,30 @@ Include it in your selection set{{ addition }}.`
       let rawType = getBaseType(type);
       if (rawType instanceof GraphQLObjectType || rawType instanceof GraphQLInterfaceType)
         checkFields(rawType);
-      else if (rawType instanceof GraphQLUnionType) {
-        for (let selection of node.selections)
-          if (selection.kind === Kind21.INLINE_FRAGMENT) {
-            let t = rawType.getTypes().find((t2) => t2.name === selection.typeCondition.name.value);
+      else if (rawType instanceof GraphQLUnionType)
+        for (let selection of node.selections) {
+          let types = rawType.getTypes();
+          if (selection.kind === Kind20.INLINE_FRAGMENT) {
+            let t = types.find((t2) => t2.name === selection.typeCondition.name.value);
             t && checkFields(t);
+          } else if (selection.kind === Kind20.FRAGMENT_SPREAD) {
+            let [foundSpread] = siblings.getFragment(selection.name.value);
+            if (!foundSpread) return;
+            let fragmentSpread = foundSpread.document, t = fragmentSpread.typeCondition.name.value === rawType.name ? rawType : types.find((t2) => t2.name === fragmentSpread.typeCondition.name.value);
+            checkedFragmentSpreads.add(fragmentSpread.name.value), checkSelections(fragmentSpread.selectionSet, t, loc, parent, checkedFragmentSpreads);
           }
-      }
+        }
       function checkFields(rawType2) {
         let fields = rawType2.getFields();
         if (!idNames.some((name) => fields[name]))
           return;
         function hasIdField({ selections }) {
           return selections.some((selection) => {
-            if (selection.kind === Kind21.FIELD)
+            if (selection.kind === Kind20.FIELD)
               return selection.alias && idNames.includes(selection.alias.value) ? !0 : idNames.includes(selection.name.value);
-            if (selection.kind === Kind21.INLINE_FRAGMENT)
+            if (selection.kind === Kind20.INLINE_FRAGMENT)
               return hasIdField(selection.selectionSet);
-            if (selection.kind === Kind21.FRAGMENT_SPREAD) {
+            if (selection.kind === Kind20.FRAGMENT_SPREAD) {
               let [foundSpread] = siblings.getFragment(selection.name.value);
               if (foundSpread) {
                 let fragmentSpread = foundSpread.document;
@@ -4727,7 +4622,7 @@ Include it in your selection set{{ addition }}.`
           desc: `Add \`${idName}\` selection`,
           fix: (fixer) => {
             let insertNode = node.selections[0];
-            return insertNode = insertNode.kind === Kind21.INLINE_FRAGMENT ? insertNode.selectionSet.selections[0] : insertNode, fixer.insertTextBefore(insertNode, `${idName} `);
+            return insertNode = insertNode.kind === Kind20.INLINE_FRAGMENT ? insertNode.selectionSet.selections[0] : insertNode, fixer.insertTextBefore(insertNode, `${idName} `);
           }
         }))), context.report(problem);
       }
@@ -4802,9 +4697,9 @@ var RULE_ID20 = "require-type-pattern-with-oneof", rule29 = {
 };
 
 // src/rules/selection-set-depth/index.ts
-import { Kind as Kind22 } from "graphql";
+import { Kind as Kind21 } from "graphql";
 import depthLimit from "graphql-depth-limit";
-var RULE_ID21 = "selection-set-depth", schema13 = {
+var RULE_ID21 = "selection-set-depth", schema14 = {
   type: "array",
   minItems: 1,
   maxItems: 1,
@@ -4872,15 +4767,15 @@ var RULE_ID21 = "selection-set-depth", schema13 = {
       recommended: !0,
       configOptions: [{ maxDepth: 7 }]
     },
-    schema: schema13
+    schema: schema14
   },
   create(context) {
     let siblings = null;
     try {
-      siblings = requireSiblingsOperations(RULE_ID21, context);
+      siblings = requireGraphQLOperations(RULE_ID21, context);
     } catch {
       logger.warn(
-        `Rule "${RULE_ID21}" works best with siblings operations loaded. For more info: https://bit.ly/graphql-eslint-operations`
+        `Rule "${RULE_ID21}" works best with siblings operations loaded. See https://the-guild.dev/graphql/eslint/docs/usage#providing-operations for more info`
       );
     }
     let { maxDepth, ignore = [] } = context.options[0], checkFn = depthLimit(maxDepth, { ignore });
@@ -4888,7 +4783,7 @@ var RULE_ID21 = "selection-set-depth", schema13 = {
       "OperationDefinition, FragmentDefinition"(node) {
         try {
           let rawNode = node.rawNode(), fragmentsInUse = siblings ? siblings.getFragmentsInUse(rawNode) : [], document = {
-            kind: Kind22.DOCUMENT,
+            kind: Kind21.DOCUMENT,
             definitions: [rawNode, ...fragmentsInUse]
           };
           checkFn({
@@ -4922,7 +4817,7 @@ var RULE_ID21 = "selection-set-depth", schema13 = {
           });
         } catch (e) {
           logger.warn(
-            `Rule "${RULE_ID21}" check failed due to a missing siblings operations. For more info: https://bit.ly/graphql-eslint-operations`,
+            `Rule "${RULE_ID21}" check failed due to a missing siblings operations. See https://the-guild.dev/graphql/eslint/docs/usage#providing-operations for more info`,
             e
           );
         }
@@ -4932,8 +4827,8 @@ var RULE_ID21 = "selection-set-depth", schema13 = {
 };
 
 // src/rules/strict-id-in-types/index.ts
-import { Kind as Kind23 } from "graphql";
-var RULE_ID22 = "strict-id-in-types", schema14 = {
+import { Kind as Kind22 } from "graphql";
+var RULE_ID22 = "strict-id-in-types", schema15 = {
   type: "array",
   maxItems: 1,
   items: {
@@ -5041,7 +4936,7 @@ var RULE_ID22 = "strict-id-in-types", schema14 = {
         }
       ]
     },
-    schema: schema14
+    schema: schema15
   },
   create(context) {
     let options = {
@@ -5049,19 +4944,19 @@ var RULE_ID22 = "strict-id-in-types", schema14 = {
       acceptedIdTypes: ["ID"],
       exceptions: {},
       ...context.options[0]
-    }, schema15 = requireGraphQLSchemaFromContext(RULE_ID22, context);
+    }, schema16 = requireGraphQLSchema(RULE_ID22, context);
     return {
       [`ObjectTypeDefinition[name.value!=/^(${[
-        schema15.getQueryType(),
-        schema15.getMutationType(),
-        schema15.getSubscriptionType()
+        schema16.getQueryType(),
+        schema16.getMutationType(),
+        schema16.getSubscriptionType()
       ].filter(truthy).map((type) => type.name).join("|")})$/]`](node) {
         let typeName = node.name.value;
         if (options.exceptions.types?.includes(typeName) || options.exceptions.suffixes?.some((suffix) => typeName.endsWith(suffix)))
           return;
         if (node.fields?.filter((field) => {
           let fieldNode = field.rawNode(), isValidIdName = options.acceptedIdNames.includes(fieldNode.name.value), isValidIdType = !1;
-          return fieldNode.type.kind === Kind23.NON_NULL_TYPE && fieldNode.type.type.kind === Kind23.NAMED_TYPE && (isValidIdType = options.acceptedIdTypes.includes(fieldNode.type.type.name.value)), isValidIdName && isValidIdType;
+          return fieldNode.type.kind === Kind22.NON_NULL_TYPE && fieldNode.type.type.kind === Kind22.NAMED_TYPE && (isValidIdType = options.acceptedIdTypes.includes(fieldNode.type.type.name.value)), isValidIdName && isValidIdType;
         })?.length !== 1) {
           let pluralNamesSuffix = options.acceptedIdNames.length > 1 ? "s" : "", pluralTypesSuffix = options.acceptedIdTypes.length > 1 ? "s" : "";
           context.report({
@@ -5077,7 +4972,7 @@ Accepted type${pluralTypesSuffix}: ${englishJoinWords(options.acceptedIdTypes)}.
 };
 
 // src/rules/unique-enum-value-names/index.ts
-import { Kind as Kind24 } from "graphql";
+import { Kind as Kind23 } from "graphql";
 var rule32 = {
   meta: {
     type: "suggestion",
@@ -5121,7 +5016,7 @@ var rule32 = {
   },
   create(context) {
     return {
-      [[Kind24.ENUM_TYPE_DEFINITION, Kind24.ENUM_TYPE_EXTENSION].join(",")](node) {
+      [[Kind23.ENUM_TYPE_DEFINITION, Kind23.ENUM_TYPE_EXTENSION].join(",")](node) {
         let duplicates = node.values?.filter(
           (item, index, array) => array.findIndex((v) => v.name.value.toLowerCase() === item.name.value.toLowerCase()) !== index
         );
@@ -5147,9 +5042,9 @@ var rule32 = {
 
 // src/rules/unique-fragment-name/index.ts
 import { relative as relative2 } from "node:path";
-import { Kind as Kind25 } from "graphql";
+import { Kind as Kind24 } from "graphql";
 var RULE_ID23 = "unique-fragment-name", checkNode = (context, node, ruleId) => {
-  let documentName = node.name.value, siblings = requireSiblingsOperations(ruleId, context), siblingDocuments = node.kind === Kind25.FRAGMENT_DEFINITION ? siblings.getFragment(documentName) : siblings.getOperation(documentName), filepath = context.filename, conflictingDocuments = siblingDocuments.filter((f) => {
+  let documentName = node.name.value, siblings = requireGraphQLOperations(ruleId, context), siblingDocuments = node.kind === Kind24.FRAGMENT_DEFINITION ? siblings.getFragment(documentName) : siblings.getOperation(documentName), filepath = context.filename, conflictingDocuments = siblingDocuments.filter((f) => {
     let isSameName = f.document.name?.value === documentName, isSamePath = slash(f.filePath) === slash(filepath);
     return isSameName && !isSamePath;
   });
@@ -5337,32 +5232,222 @@ var rules = {
   "unique-operation-name": rule34
 };
 
+// src/configs/operations-all.ts
+var operations_all_default = {
+  extends: "./configs/operations-recommended",
+  rules: {
+    "@graphql-eslint/alphabetize": [
+      "error",
+      {
+        definitions: !0,
+        selections: ["OperationDefinition", "FragmentDefinition"],
+        variables: !0,
+        arguments: ["Field", "Directive"],
+        groups: ["...", "id", "*", "{"]
+      }
+    ],
+    "@graphql-eslint/lone-executable-definition": "error",
+    "@graphql-eslint/match-document-filename": [
+      "error",
+      {
+        query: "kebab-case",
+        mutation: "kebab-case",
+        subscription: "kebab-case",
+        fragment: "kebab-case"
+      }
+    ],
+    "@graphql-eslint/no-one-place-fragments": "error",
+    "@graphql-eslint/require-import-fragment": "error"
+  }
+};
+
+// src/configs/operations-recommended.ts
+var operations_recommended_default = {
+  parser: "@graphql-eslint/eslint-plugin",
+  plugins: ["@graphql-eslint"],
+  rules: {
+    "@graphql-eslint/executable-definitions": "error",
+    "@graphql-eslint/fields-on-correct-type": "error",
+    "@graphql-eslint/fragments-on-composite-type": "error",
+    "@graphql-eslint/known-argument-names": "error",
+    "@graphql-eslint/known-directives": "error",
+    "@graphql-eslint/known-fragment-names": "error",
+    "@graphql-eslint/known-type-names": "error",
+    "@graphql-eslint/lone-anonymous-operation": "error",
+    "@graphql-eslint/naming-convention": [
+      "error",
+      {
+        VariableDefinition: "camelCase",
+        OperationDefinition: {
+          style: "PascalCase",
+          forbiddenPrefixes: ["Query", "Mutation", "Subscription", "Get"],
+          forbiddenSuffixes: ["Query", "Mutation", "Subscription"]
+        },
+        FragmentDefinition: {
+          style: "PascalCase",
+          forbiddenPrefixes: ["Fragment"],
+          forbiddenSuffixes: ["Fragment"]
+        }
+      }
+    ],
+    "@graphql-eslint/no-anonymous-operations": "error",
+    "@graphql-eslint/no-deprecated": "error",
+    "@graphql-eslint/no-duplicate-fields": "error",
+    "@graphql-eslint/no-fragment-cycles": "error",
+    "@graphql-eslint/no-undefined-variables": "error",
+    "@graphql-eslint/no-unused-fragments": "error",
+    "@graphql-eslint/no-unused-variables": "error",
+    "@graphql-eslint/one-field-subscriptions": "error",
+    "@graphql-eslint/overlapping-fields-can-be-merged": "error",
+    "@graphql-eslint/possible-fragment-spread": "error",
+    "@graphql-eslint/provided-required-arguments": "error",
+    "@graphql-eslint/require-selections": "error",
+    "@graphql-eslint/scalar-leafs": "error",
+    "@graphql-eslint/selection-set-depth": ["error", { maxDepth: 7 }],
+    "@graphql-eslint/unique-argument-names": "error",
+    "@graphql-eslint/unique-directive-names-per-location": "error",
+    "@graphql-eslint/unique-fragment-name": "error",
+    "@graphql-eslint/unique-input-field-names": "error",
+    "@graphql-eslint/unique-operation-name": "error",
+    "@graphql-eslint/unique-variable-names": "error",
+    "@graphql-eslint/value-literals-of-correct-type": "error",
+    "@graphql-eslint/variables-are-input-types": "error",
+    "@graphql-eslint/variables-in-allowed-position": "error"
+  }
+};
+
+// src/configs/schema-all.ts
+var schema_all_default = {
+  extends: "./configs/schema-recommended",
+  rules: {
+    "@graphql-eslint/alphabetize": [
+      "error",
+      {
+        definitions: !0,
+        fields: ["ObjectTypeDefinition", "InterfaceTypeDefinition", "InputObjectTypeDefinition"],
+        values: !0,
+        arguments: ["FieldDefinition", "Field", "DirectiveDefinition", "Directive"],
+        groups: ["id", "*", "createdAt", "updatedAt"]
+      }
+    ],
+    "@graphql-eslint/input-name": "error",
+    "@graphql-eslint/no-root-type": ["error", { disallow: ["mutation", "subscription"] }],
+    "@graphql-eslint/no-scalar-result-type-on-mutation": "error",
+    "@graphql-eslint/require-deprecation-date": "error",
+    "@graphql-eslint/require-field-of-type-query-in-mutation-result": "error",
+    "@graphql-eslint/require-nullable-fields-with-oneof": "error",
+    "@graphql-eslint/require-nullable-result-in-root": "error",
+    "@graphql-eslint/require-type-pattern-with-oneof": "error"
+  }
+};
+
+// src/configs/schema-recommended.ts
+var schema_recommended_default = {
+  parser: "@graphql-eslint/eslint-plugin",
+  plugins: ["@graphql-eslint"],
+  rules: {
+    "@graphql-eslint/description-style": "error",
+    "@graphql-eslint/known-argument-names": "error",
+    "@graphql-eslint/known-directives": "error",
+    "@graphql-eslint/known-type-names": "error",
+    "@graphql-eslint/lone-schema-definition": "error",
+    "@graphql-eslint/naming-convention": [
+      "error",
+      {
+        types: "PascalCase",
+        FieldDefinition: "camelCase",
+        InputValueDefinition: "camelCase",
+        Argument: "camelCase",
+        DirectiveDefinition: "camelCase",
+        EnumValueDefinition: "UPPER_CASE",
+        "FieldDefinition[parent.name.value=Query]": {
+          forbiddenPrefixes: ["query", "get"],
+          forbiddenSuffixes: ["Query"]
+        },
+        "FieldDefinition[parent.name.value=Mutation]": {
+          forbiddenPrefixes: ["mutation"],
+          forbiddenSuffixes: ["Mutation"]
+        },
+        "FieldDefinition[parent.name.value=Subscription]": {
+          forbiddenPrefixes: ["subscription"],
+          forbiddenSuffixes: ["Subscription"]
+        },
+        "EnumTypeDefinition,EnumTypeExtension": {
+          forbiddenPrefixes: ["Enum"],
+          forbiddenSuffixes: ["Enum"]
+        },
+        "InterfaceTypeDefinition,InterfaceTypeExtension": {
+          forbiddenPrefixes: ["Interface"],
+          forbiddenSuffixes: ["Interface"]
+        },
+        "UnionTypeDefinition,UnionTypeExtension": {
+          forbiddenPrefixes: ["Union"],
+          forbiddenSuffixes: ["Union"]
+        },
+        "ObjectTypeDefinition,ObjectTypeExtension": {
+          forbiddenPrefixes: ["Type"],
+          forbiddenSuffixes: ["Type"]
+        }
+      }
+    ],
+    "@graphql-eslint/no-hashtag-description": "error",
+    "@graphql-eslint/no-typename-prefix": "error",
+    "@graphql-eslint/no-unreachable-types": "error",
+    "@graphql-eslint/possible-type-extension": "error",
+    "@graphql-eslint/provided-required-arguments": "error",
+    "@graphql-eslint/require-deprecation-reason": "error",
+    "@graphql-eslint/require-description": [
+      "error",
+      { types: !0, DirectiveDefinition: !0, rootField: !0 }
+    ],
+    "@graphql-eslint/strict-id-in-types": "error",
+    "@graphql-eslint/unique-directive-names": "error",
+    "@graphql-eslint/unique-directive-names-per-location": "error",
+    "@graphql-eslint/unique-enum-value-names": "error",
+    "@graphql-eslint/unique-field-definition-names": "error",
+    "@graphql-eslint/unique-operation-types": "error",
+    "@graphql-eslint/unique-type-names": "error"
+  }
+};
+
+// src/configs/schema-relay.ts
+var schema_relay_default = {
+  parser: "@graphql-eslint/eslint-plugin",
+  plugins: ["@graphql-eslint"],
+  rules: {
+    "@graphql-eslint/relay-arguments": "error",
+    "@graphql-eslint/relay-connection-types": "error",
+    "@graphql-eslint/relay-edge-types": "error",
+    "@graphql-eslint/relay-page-info": "error"
+  }
+};
+
 // src/configs/index.ts
-var import_operations_all = __toESM(require_operations_all(), 1), import_operations_recommended = __toESM(require_operations_recommended(), 1), import_schema_all = __toESM(require_schema_all(), 1), import_schema_recommended = __toESM(require_schema_recommended(), 1), import_schema_relay = __toESM(require_schema_relay(), 1), configs = {
-  "schema-recommended": import_schema_recommended.default,
-  "schema-all": import_schema_all.default,
-  "schema-relay": import_schema_relay.default,
-  "operations-recommended": import_operations_recommended.default,
-  "operations-all": import_operations_all.default,
+var configs = {
+  "schema-recommended": schema_recommended_default,
+  "schema-all": schema_all_default,
+  "schema-relay": schema_relay_default,
+  "operations-recommended": operations_recommended_default,
+  "operations-all": operations_all_default,
   "flat/schema-recommended": {
-    rules: import_schema_recommended.default.rules
+    rules: schema_recommended_default.rules
   },
   "flat/schema-all": {
     rules: {
-      ...import_schema_recommended.default.rules,
-      ...import_schema_all.default.rules
+      ...schema_recommended_default.rules,
+      ...schema_all_default.rules
     }
   },
   "flat/schema-relay": {
-    rules: import_schema_relay.default.rules
+    rules: schema_relay_default.rules
   },
   "flat/operations-recommended": {
-    rules: import_operations_recommended.default.rules
+    rules: operations_recommended_default.rules
   },
   "flat/operations-all": {
     rules: {
-      ...import_operations_recommended.default.rules,
-      ...import_operations_all.default.rules
+      ...operations_recommended_default.rules,
+      ...operations_all_default.rules
     }
   }
 };