@graphql-eslint/eslint-plugin 4.0.0-alpha-20220821140530-e968cfc → 4.0.0-alpha-20230810155929-e89edf7

package/cjs/siblings.js

@@ -0,0 +1,96 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var siblings_exports = {};
+__export(siblings_exports, {
+  getSiblings: () => getSiblings
+});
+module.exports = __toCommonJS(siblings_exports);
+var import_graphql = require("graphql"), import_utils2 = require("./utils.js");
+const siblingOperationsCache = /* @__PURE__ */ new Map();
+function getSiblings(documents) {
+  if (documents.length === 0) {
+    let printed = !1;
+    const noopWarn = () => (printed || (import_utils2.logger.warn(
+      "getSiblingOperations was called without any operations. Make sure to set graphql-config `documents` field to make this feature available! See https://the-guild.dev/graphql/config/docs/user/documents for more info"
+    ), printed = !0), []);
+    return {
+      available: !1,
+      getFragment: noopWarn,
+      getFragments: noopWarn,
+      getFragmentByType: noopWarn,
+      getFragmentsInUse: noopWarn,
+      getOperation: noopWarn,
+      getOperations: noopWarn,
+      getOperationByType: noopWarn
+    };
+  }
+  const value = siblingOperationsCache.get(documents);
+  if (value)
+    return value;
+  let fragmentsCache = null;
+  const getFragments = () => {
+    if (fragmentsCache === null) {
+      const result = [];
+      for (const source of documents)
+        for (const definition of source.document?.definitions || [])
+          definition.kind === import_graphql.Kind.FRAGMENT_DEFINITION && result.push({
+            filePath: source.location,
+            document: definition
+          });
+      fragmentsCache = result;
+    }
+    return fragmentsCache;
+  };
+  let cachedOperations = null;
+  const getOperations = () => {
+    if (cachedOperations === null) {
+      const result = [];
+      for (const source of documents)
+        for (const definition of source.document?.definitions || [])
+          definition.kind === import_graphql.Kind.OPERATION_DEFINITION && result.push({
+            filePath: source.location,
+            document: definition
+          });
+      cachedOperations = result;
+    }
+    return cachedOperations;
+  }, getFragment = (name) => getFragments().filter((f) => f.document.name.value === name), collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => ((0, import_graphql.visit)(selectable, {
+    FragmentSpread(spread) {
+      const fragmentName = spread.name.value, [fragment] = getFragment(fragmentName);
+      if (!fragment) {
+        import_utils2.logger.warn(
+          `Unable to locate fragment named "${fragmentName}", please make sure it's loaded using "parserOptions.operations"`
+        );
+        return;
+      }
+      collected.has(fragmentName) || (collected.set(fragmentName, fragment.document), recursive && collectFragments(fragment.document, recursive, collected));
+    }
+  }), collected), siblingOperations = {
+    available: !0,
+    getFragment,
+    getFragments,
+    getFragmentByType: (typeName) => getFragments().filter((f) => f.document.typeCondition.name.value === typeName),
+    getFragmentsInUse: (selectable, recursive = !0) => Array.from(collectFragments(selectable, recursive).values()),
+    getOperation: (name) => getOperations().filter((o) => o.document.name?.value === name),
+    getOperations,
+    getOperationByType: (type) => getOperations().filter((o) => o.document.operation === type)
+  };
+  return siblingOperationsCache.set(documents, siblingOperations), siblingOperations;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSiblings
+});

package/cjs/types.d.ts

@@ -0,0 +1,75 @@
+import { Linter, Rule, AST } from 'eslint';
+import * as ESTree from 'estree';
+import { GraphQLSchema, ASTKindToNode } from 'graphql';
+import { JSONSchema } from 'json-schema-to-ts';
+import { SiblingOperations } from './siblings.js';
+import { GraphQLESTreeNode } from './estree-converter/types.js';
+import { IGraphQLConfig } from 'graphql-config';
+import '@graphql-tools/utils';
+
+type Schema = GraphQLSchema | null;
+type Pointer = string | string[];
+interface ParserOptions {
+    graphQLConfig?: IGraphQLConfig;
+    filePath: string;
+}
+type ParserServices = {
+    schema: Schema;
+    siblingOperations: SiblingOperations;
+};
+type GraphQLESLintParseResult = Linter.ESLintParseResult & {
+    services: ParserServices;
+};
+type Location = AST.SourceLocation | ESTree.Position;
+type ReportDescriptorLocation = {
+    loc: Location;
+} | {
+    node: {
+        loc: Location;
+    };
+};
+type ReportDescriptor = ReportDescriptorLocation & Rule.ReportDescriptorMessage & Rule.ReportDescriptorOptions;
+type GraphQLESLintRuleContext<Options = any[]> = Omit<Rule.RuleContext, 'options' | 'parserServices' | 'report'> & {
+    options: Options;
+    parserServices: ParserServices;
+    report(descriptor: ReportDescriptor): void;
+};
+type CategoryType = 'Operations' | 'Schema';
+type RuleMetaDataDocs = Required<Rule.RuleMetaData>['docs'];
+type RuleDocsInfo<T> = Omit<RuleMetaDataDocs, 'category' | 'suggestion'> & {
+    category: CategoryType | CategoryType[];
+    requiresSchema?: true;
+    requiresSiblings?: true;
+    examples?: {
+        title: string;
+        code: string;
+        usage?: T;
+    }[];
+    configOptions?: T | {
+        schema?: T;
+        operations?: T;
+    };
+    graphQLJSRuleName?: string;
+    isDisabledForAllConfig?: true;
+};
+type GraphQLESLintRuleListener<WithTypeInfo extends boolean = false> = Record<string, any> & {
+    [K in keyof ASTKindToNode]?: (node: GraphQLESTreeNode<ASTKindToNode[K], WithTypeInfo>) => void;
+};
+type GraphQLESLintRule<Options = [], WithTypeInfo extends boolean = false> = {
+    meta: Omit<Rule.RuleMetaData, 'docs' | 'schema'> & {
+        docs?: RuleDocsInfo<Options>;
+        schema: Readonly<JSONSchema> | [];
+    };
+    create(context: GraphQLESLintRuleContext<Options>): GraphQLESLintRuleListener<WithTypeInfo>;
+};
+type ValueOf<T> = T[keyof T];
+type Id<T> = {
+    [P in keyof T]: T[P];
+} & {};
+type OmitDistributive<T, K extends PropertyKey> = T extends object ? Id<OmitRecursively<T, K>> : T;
+type OmitRecursively<T extends object, K extends PropertyKey> = Omit<{
+    [P in keyof T]: OmitDistributive<T[P], K>;
+}, K>;
+type ConfigName = 'operations-all' | 'operations-recommended' | 'schema-all' | 'schema-recommended' | 'schema-relay';
+
+export { CategoryType, ConfigName, GraphQLESLintParseResult, GraphQLESLintRule, GraphQLESLintRuleContext, GraphQLESLintRuleListener, OmitRecursively, ParserOptions, ParserServices, Pointer, ReportDescriptor, RuleDocsInfo, Schema, ValueOf };

package/cjs/types.js

@@ -0,0 +1,14 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/cjs/utils.d.ts

@@ -0,0 +1,45 @@
+import { AST } from 'eslint';
+import { Position } from 'estree';
+import { GraphQLSchema, ASTNode, Kind } from 'graphql';
+import { SiblingOperations } from './siblings.js';
+import { GraphQLESLintRuleContext } from './types.js';
+import { GraphQLESTreeNode } from './estree-converter/types.js';
+import '@graphql-tools/utils';
+import 'json-schema-to-ts';
+import 'graphql-config';
+
+declare function requireSiblingsOperations(ruleId: string, context: GraphQLESLintRuleContext): SiblingOperations | never;
+declare function requireGraphQLSchemaFromContext(ruleId: string, context: GraphQLESLintRuleContext): GraphQLSchema | never;
+declare const logger: {
+    error: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+};
+declare const normalizePath: (path: string) => string;
+declare const VIRTUAL_DOCUMENT_REGEX: RegExp;
+declare const CWD: string;
+declare const getTypeName: (node: ASTNode) => string;
+declare const TYPES_KINDS: readonly [Kind.OBJECT_TYPE_DEFINITION, Kind.INTERFACE_TYPE_DEFINITION, Kind.ENUM_TYPE_DEFINITION, Kind.SCALAR_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.UNION_TYPE_DEFINITION];
+type CaseStyle = 'camelCase' | 'kebab-case' | 'PascalCase' | 'snake_case' | 'UPPER_CASE';
+declare const pascalCase: (str: string) => string;
+declare const camelCase: (str: string) => string;
+declare const convertCase: (style: CaseStyle, str: string) => string;
+declare function getLocation(start: Position, fieldName?: string): AST.SourceLocation;
+declare const REPORT_ON_FIRST_CHARACTER: {
+    column: number;
+    line: number;
+};
+declare const ARRAY_DEFAULT_OPTIONS: {
+    readonly type: "array";
+    readonly uniqueItems: true;
+    readonly minItems: 1;
+    readonly items: {
+        readonly type: "string";
+    };
+};
+declare const englishJoinWords: (words: string[]) => string;
+type Truthy<T> = T extends '' | 0 | false | null | undefined ? never : T;
+declare function truthy<T>(value: T): value is Truthy<T>;
+declare function displayNodeName(node: GraphQLESTreeNode<ASTNode>): string;
+declare function getNodeName(node: GraphQLESTreeNode<ASTNode>): string;
+
+export { ARRAY_DEFAULT_OPTIONS, CWD, CaseStyle, REPORT_ON_FIRST_CHARACTER, TYPES_KINDS, VIRTUAL_DOCUMENT_REGEX, camelCase, convertCase, displayNodeName, englishJoinWords, getLocation, getNodeName, getTypeName, logger, normalizePath, pascalCase, requireGraphQLSchemaFromContext, requireSiblingsOperations, truthy };

package/cjs/utils.js

@@ -0,0 +1,188 @@
+"use strict";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __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
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  ARRAY_DEFAULT_OPTIONS: () => ARRAY_DEFAULT_OPTIONS,
+  CWD: () => CWD,
+  REPORT_ON_FIRST_CHARACTER: () => REPORT_ON_FIRST_CHARACTER,
+  TYPES_KINDS: () => TYPES_KINDS,
+  VIRTUAL_DOCUMENT_REGEX: () => VIRTUAL_DOCUMENT_REGEX,
+  camelCase: () => camelCase,
+  convertCase: () => convertCase,
+  displayNodeName: () => displayNodeName,
+  englishJoinWords: () => englishJoinWords,
+  getLocation: () => getLocation,
+  getNodeName: () => getNodeName,
+  getTypeName: () => getTypeName,
+  logger: () => logger,
+  normalizePath: () => normalizePath,
+  pascalCase: () => pascalCase,
+  requireGraphQLSchemaFromContext: () => requireGraphQLSchemaFromContext,
+  requireSiblingsOperations: () => requireSiblingsOperations,
+  truthy: () => truthy
+});
+module.exports = __toCommonJS(utils_exports);
+var import_graphql = require("graphql"), import_lodash = __toESM(require("lodash.lowercase"));
+function requireSiblingsOperations(ruleId, context) {
+  const { 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`
+    );
+  return siblingOperations;
+}
+function requireGraphQLSchemaFromContext(ruleId, context) {
+  const { schema } = context.sourceCode.parserServices;
+  if (!schema)
+    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`
+    );
+  return schema;
+}
+const chalk = {
+  red: (str) => `\x1B[31m${str}\x1B[39m`,
+  yellow: (str) => `\x1B[33m${str}\x1B[39m`
+}, logger = {
+  error: (...args) => (
+    // eslint-disable-next-line no-console
+    console.error(chalk.red("error"), "[graphql-eslint]", ...args)
+  ),
+  warn: (...args) => (
+    // eslint-disable-next-line no-console
+    console.warn(chalk.yellow("warning"), "[graphql-eslint]", ...args)
+  )
+}, normalizePath = (path) => (path || "").replace(/\\/g, "/"), VIRTUAL_DOCUMENT_REGEX = /\/\d+_document.graphql$/, CWD = process.cwd(), getTypeName = (node) => "type" in node ? getTypeName(node.type) : "name" in node && node.name ? node.name.value : "", TYPES_KINDS = [
+  import_graphql.Kind.OBJECT_TYPE_DEFINITION,
+  import_graphql.Kind.INTERFACE_TYPE_DEFINITION,
+  import_graphql.Kind.ENUM_TYPE_DEFINITION,
+  import_graphql.Kind.SCALAR_TYPE_DEFINITION,
+  import_graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+  import_graphql.Kind.UNION_TYPE_DEFINITION
+], pascalCase = (str) => (0, import_lodash.default)(str).split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(""), camelCase = (str) => {
+  const result = pascalCase(str);
+  return result.charAt(0).toLowerCase() + result.slice(1);
+}, convertCase = (style, str) => {
+  switch (style) {
+    case "camelCase":
+      return camelCase(str);
+    case "PascalCase":
+      return pascalCase(str);
+    case "snake_case":
+      return (0, import_lodash.default)(str).replace(/ /g, "_");
+    case "UPPER_CASE":
+      return (0, import_lodash.default)(str).replace(/ /g, "_").toUpperCase();
+    case "kebab-case":
+      return (0, import_lodash.default)(str).replace(/ /g, "-");
+  }
+};
+function getLocation(start, fieldName = "") {
+  const { line, column } = start;
+  return {
+    start: {
+      line,
+      column
+    },
+    end: {
+      line,
+      column: column + fieldName.length
+    }
+  };
+}
+const REPORT_ON_FIRST_CHARACTER = { column: 0, line: 1 }, ARRAY_DEFAULT_OPTIONS = {
+  type: "array",
+  uniqueItems: !0,
+  minItems: 1,
+  items: {
+    type: "string"
+  }
+}, englishJoinWords = (words) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(words);
+function truthy(value) {
+  return !!value;
+}
+const DisplayNodeNameMap = {
+  [import_graphql.Kind.OBJECT_TYPE_DEFINITION]: "type",
+  [import_graphql.Kind.OBJECT_TYPE_EXTENSION]: "type",
+  [import_graphql.Kind.INTERFACE_TYPE_DEFINITION]: "interface",
+  [import_graphql.Kind.INTERFACE_TYPE_EXTENSION]: "interface",
+  [import_graphql.Kind.ENUM_TYPE_DEFINITION]: "enum",
+  [import_graphql.Kind.ENUM_TYPE_EXTENSION]: "enum",
+  [import_graphql.Kind.SCALAR_TYPE_DEFINITION]: "scalar",
+  [import_graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION]: "input",
+  [import_graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION]: "input",
+  [import_graphql.Kind.UNION_TYPE_DEFINITION]: "union",
+  [import_graphql.Kind.UNION_TYPE_EXTENSION]: "union",
+  [import_graphql.Kind.DIRECTIVE_DEFINITION]: "directive",
+  [import_graphql.Kind.FIELD_DEFINITION]: "field",
+  [import_graphql.Kind.ENUM_VALUE_DEFINITION]: "enum value",
+  [import_graphql.Kind.INPUT_VALUE_DEFINITION]: "input value",
+  [import_graphql.Kind.ARGUMENT]: "argument",
+  [import_graphql.Kind.VARIABLE]: "variable",
+  [import_graphql.Kind.FRAGMENT_DEFINITION]: "fragment",
+  [import_graphql.Kind.OPERATION_DEFINITION]: "operation",
+  [import_graphql.Kind.FIELD]: "field"
+};
+function displayNodeName(node) {
+  return `${node.kind === import_graphql.Kind.OPERATION_DEFINITION ? node.operation : DisplayNodeNameMap[node.kind]} "${"alias" in node && node.alias?.value || "name" in node && node.name?.value}"`;
+}
+function getNodeName(node) {
+  switch (node.kind) {
+    case import_graphql.Kind.OBJECT_TYPE_DEFINITION:
+    case import_graphql.Kind.OBJECT_TYPE_EXTENSION:
+    case import_graphql.Kind.INTERFACE_TYPE_DEFINITION:
+    case import_graphql.Kind.ENUM_TYPE_DEFINITION:
+    case import_graphql.Kind.SCALAR_TYPE_DEFINITION:
+    case import_graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+    case import_graphql.Kind.UNION_TYPE_DEFINITION:
+    case import_graphql.Kind.DIRECTIVE_DEFINITION:
+      return displayNodeName(node);
+    case import_graphql.Kind.FIELD_DEFINITION:
+    case import_graphql.Kind.INPUT_VALUE_DEFINITION:
+    case import_graphql.Kind.ENUM_VALUE_DEFINITION:
+      return `${displayNodeName(node)} in ${displayNodeName(node.parent)}`;
+    case import_graphql.Kind.OPERATION_DEFINITION:
+      return node.name ? displayNodeName(node) : node.operation;
+  }
+  return "";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ARRAY_DEFAULT_OPTIONS,
+  CWD,
+  REPORT_ON_FIRST_CHARACTER,
+  TYPES_KINDS,
+  VIRTUAL_DOCUMENT_REGEX,
+  camelCase,
+  convertCase,
+  displayNodeName,
+  englishJoinWords,
+  getLocation,
+  getNodeName,
+  getTypeName,
+  logger,
+  normalizePath,
+  pascalCase,
+  requireGraphQLSchemaFromContext,
+  requireSiblingsOperations,
+  truthy
+});

package/esm/cache.d.mts

@@ -0,0 +1,12 @@
+declare class ModuleCache<T, K = any> {
+    map: Map<K, {
+        lastSeen: [number, number];
+        result: T;
+    }>;
+    set(cacheKey: K, result: T): void;
+    get(cacheKey: K, settings?: {
+        lifetime: number;
+    }): T | void;
+}
+
+export { ModuleCache };

package/esm/cache.js

@@ -0,0 +1,25 @@
+import "./chunk-U3TKCM4X.js";
+import debugFactory from "debug";
+const log = debugFactory("graphql-eslint:ModuleCache");
+class ModuleCache {
+  map = /* @__PURE__ */ new Map();
+  set(cacheKey, result) {
+    this.map.set(cacheKey, { lastSeen: process.hrtime(), result }), log("setting entry for", cacheKey);
+  }
+  get(cacheKey, settings = {
+    lifetime: 10
+    /* seconds */
+  }) {
+    const value = this.map.get(cacheKey);
+    if (!value) {
+      log("cache miss for", cacheKey);
+      return;
+    }
+    const { lastSeen, result } = value;
+    if (process.env.NODE || process.hrtime(lastSeen)[0] < settings.lifetime)
+      return result;
+  }
+}
+export {
+  ModuleCache
+};

package/esm/chunk-U3TKCM4X.js

@@ -0,0 +1,8 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+export {
+  __commonJS
+};

package/esm/configs/index.d.mts

@@ -0,0 +1,174 @@
+declare const configs: {
+    'schema-recommended': {
+        parser: string;
+        plugins: string[];
+        rules: {
+            '@graphql-eslint/description-style': string;
+            '@graphql-eslint/known-argument-names': string;
+            '@graphql-eslint/known-directives': string;
+            '@graphql-eslint/known-type-names': string;
+            '@graphql-eslint/lone-schema-definition': string;
+            '@graphql-eslint/naming-convention': (string | {
+                types: string;
+                FieldDefinition: string;
+                InputValueDefinition: string;
+                Argument: string;
+                DirectiveDefinition: string;
+                EnumValueDefinition: string;
+                'FieldDefinition[parent.name.value=Query]': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'FieldDefinition[parent.name.value=Mutation]': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'FieldDefinition[parent.name.value=Subscription]': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'EnumTypeDefinition,EnumTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'InterfaceTypeDefinition,InterfaceTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'UnionTypeDefinition,UnionTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'ObjectTypeDefinition,ObjectTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+            })[];
+            '@graphql-eslint/no-hashtag-description': string;
+            '@graphql-eslint/no-typename-prefix': string;
+            '@graphql-eslint/no-unreachable-types': string;
+            '@graphql-eslint/possible-type-extension': string;
+            '@graphql-eslint/provided-required-arguments': string;
+            '@graphql-eslint/require-deprecation-reason': string;
+            '@graphql-eslint/require-description': (string | {
+                types: boolean;
+                DirectiveDefinition: boolean;
+                rootField: boolean;
+            })[];
+            '@graphql-eslint/strict-id-in-types': string;
+            '@graphql-eslint/unique-directive-names': string;
+            '@graphql-eslint/unique-directive-names-per-location': string;
+            '@graphql-eslint/unique-enum-value-names': string;
+            '@graphql-eslint/unique-field-definition-names': string;
+            '@graphql-eslint/unique-operation-types': string;
+            '@graphql-eslint/unique-type-names': string;
+        };
+    };
+    'schema-all': {
+        extends: string;
+        rules: {
+            '@graphql-eslint/alphabetize': (string | {
+                definitions: boolean;
+                fields: string[];
+                values: boolean;
+                arguments: string[];
+                groups: string[];
+            })[];
+            '@graphql-eslint/input-name': string;
+            '@graphql-eslint/no-root-type': (string | {
+                disallow: string[];
+            })[];
+            '@graphql-eslint/no-scalar-result-type-on-mutation': string;
+            '@graphql-eslint/require-deprecation-date': string;
+            '@graphql-eslint/require-field-of-type-query-in-mutation-result': string;
+            '@graphql-eslint/require-nullable-fields-with-oneof': string;
+            '@graphql-eslint/require-nullable-result-in-root': string;
+            '@graphql-eslint/require-type-pattern-with-oneof': string;
+        };
+    };
+    'schema-relay': {
+        parser: string;
+        plugins: string[];
+        rules: {
+            '@graphql-eslint/relay-arguments': string;
+            '@graphql-eslint/relay-connection-types': string;
+            '@graphql-eslint/relay-edge-types': string;
+            '@graphql-eslint/relay-page-info': string;
+        };
+    };
+    'operations-recommended': {
+        parser: string;
+        plugins: string[];
+        rules: {
+            '@graphql-eslint/executable-definitions': string;
+            '@graphql-eslint/fields-on-correct-type': string;
+            '@graphql-eslint/fragments-on-composite-type': string;
+            '@graphql-eslint/known-argument-names': string;
+            '@graphql-eslint/known-directives': string;
+            '@graphql-eslint/known-fragment-names': string;
+            '@graphql-eslint/known-type-names': string;
+            '@graphql-eslint/lone-anonymous-operation': string;
+            '@graphql-eslint/naming-convention': (string | {
+                VariableDefinition: string;
+                OperationDefinition: {
+                    style: string;
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                FragmentDefinition: {
+                    style: string;
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+            })[];
+            '@graphql-eslint/no-anonymous-operations': string;
+            '@graphql-eslint/no-deprecated': string;
+            '@graphql-eslint/no-duplicate-fields': string;
+            '@graphql-eslint/no-fragment-cycles': string;
+            '@graphql-eslint/no-undefined-variables': string;
+            '@graphql-eslint/no-unused-fragments': string;
+            '@graphql-eslint/no-unused-variables': string;
+            '@graphql-eslint/one-field-subscriptions': string;
+            '@graphql-eslint/overlapping-fields-can-be-merged': string;
+            '@graphql-eslint/possible-fragment-spread': string;
+            '@graphql-eslint/provided-required-arguments': string;
+            '@graphql-eslint/require-selections': string;
+            '@graphql-eslint/scalar-leafs': string;
+            '@graphql-eslint/selection-set-depth': (string | {
+                maxDepth: number;
+            })[];
+            '@graphql-eslint/unique-argument-names': string;
+            '@graphql-eslint/unique-directive-names-per-location': string;
+            '@graphql-eslint/unique-fragment-name': string;
+            '@graphql-eslint/unique-input-field-names': string;
+            '@graphql-eslint/unique-operation-name': string;
+            '@graphql-eslint/unique-variable-names': string;
+            '@graphql-eslint/value-literals-of-correct-type': string;
+            '@graphql-eslint/variables-are-input-types': string;
+            '@graphql-eslint/variables-in-allowed-position': string;
+        };
+    };
+    'operations-all': {
+        extends: string;
+        rules: {
+            '@graphql-eslint/alphabetize': (string | {
+                definitions: boolean;
+                selections: string[];
+                variables: boolean;
+                arguments: string[];
+                groups: string[];
+            })[];
+            '@graphql-eslint/lone-executable-definition': string;
+            '@graphql-eslint/match-document-filename': (string | {
+                query: string;
+                mutation: string;
+                subscription: string;
+                fragment: string;
+            })[];
+            '@graphql-eslint/no-one-place-fragments': string;
+            '@graphql-eslint/require-import-fragment': string;
+        };
+    };
+};
+
+export { configs };

package/esm/configs/index.js

@@ -0,0 +1,16 @@
+import "../chunk-U3TKCM4X.js";
+import operationsAllConfig from "./operations-all.js";
+import operationsRecommendedConfig from "./operations-recommended.js";
+import schemaAllConfig from "./schema-all.js";
+import schemaRecommendedConfig from "./schema-recommended.js";
+import relayConfig from "./schema-relay.js";
+const configs = {
+  "schema-recommended": schemaRecommendedConfig,
+  "schema-all": schemaAllConfig,
+  "schema-relay": relayConfig,
+  "operations-recommended": operationsRecommendedConfig,
+  "operations-all": operationsAllConfig
+};
+export {
+  configs
+};