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

package/esm/configs/operations-all.d.mts

@@ -0,0 +1,23 @@
+declare const _default: {
+    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 { _default as default };

package/esm/configs/operations-all.js

@@ -0,0 +1,35 @@
+import {
+  __commonJS
+} from "../chunk-U3TKCM4X.js";
+var require_operations_all = __commonJS({
+  "src/configs/operations-all.ts"(exports, module) {
+    module.exports = {
+      extends: "./configs/operations-recommended",
+      rules: {
+        "@graphql-eslint/alphabetize": [
+          "error",
+          {
+            definitions: !0,
+            selections: ["OperationDefinition", "FragmentDefinition"],
+            variables: !0,
+            arguments: ["Field", "Directive"],
+            groups: ["id", "*", "createdAt", "updatedAt"]
+          }
+        ],
+        "@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"
+      }
+    };
+  }
+});
+export default require_operations_all();

package/esm/configs/operations-recommended.d.mts

@@ -0,0 +1,54 @@
+declare const _default: {
+    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;
+    };
+};
+
+export { _default as default };

package/esm/configs/operations-recommended.js

@@ -0,0 +1,61 @@
+import {
+  __commonJS
+} from "../chunk-U3TKCM4X.js";
+var require_operations_recommended = __commonJS({
+  "src/configs/operations-recommended.ts"(exports, module) {
+    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"
+      }
+    };
+  }
+});
+export default require_operations_recommended();

package/esm/configs/schema-all.d.mts

@@ -0,0 +1,24 @@
+declare const _default: {
+    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;
+    };
+};
+
+export { _default as default };

package/esm/configs/schema-all.js

@@ -0,0 +1,31 @@
+import {
+  __commonJS
+} from "../chunk-U3TKCM4X.js";
+var require_schema_all = __commonJS({
+  "src/configs/schema-all.ts"(exports, module) {
+    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"
+      }
+    };
+  }
+});
+export default require_schema_all();

package/esm/configs/schema-recommended.d.mts

@@ -0,0 +1,67 @@
+declare const _default: {
+    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;
+    };
+};
+
+export { _default as default };

package/esm/configs/schema-recommended.js

@@ -0,0 +1,75 @@
+import {
+  __commonJS
+} from "../chunk-U3TKCM4X.js";
+var require_schema_recommended = __commonJS({
+  "src/configs/schema-recommended.ts"(exports, module) {
+    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"
+      }
+    };
+  }
+});
+export default require_schema_recommended();

package/esm/configs/schema-relay.d.mts

@@ -0,0 +1,12 @@
+declare const _default: {
+    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;
+    };
+};
+
+export { _default as default };

package/esm/configs/schema-relay.js

@@ -0,0 +1,18 @@
+import {
+  __commonJS
+} from "../chunk-U3TKCM4X.js";
+var require_schema_relay = __commonJS({
+  "src/configs/schema-relay.ts"(exports, module) {
+    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"
+      }
+    };
+  }
+});
+export default require_schema_relay();

package/esm/documents.d.mts

@@ -0,0 +1,6 @@
+import { Source } from '@graphql-tools/utils';
+import { GraphQLProjectConfig } from 'graphql-config';
+
+declare const getDocuments: (project: GraphQLProjectConfig) => Source[];
+
+export { getDocuments };

package/esm/documents.js

@@ -0,0 +1,41 @@
+import "./chunk-U3TKCM4X.js";
+import { resolve } from "node:path";
+import debugFactory from "debug";
+import fg from "fast-glob";
+import { ModuleCache } from "./cache.js";
+const debug = debugFactory("graphql-eslint:operations"), operationsCache = new ModuleCache(), handleVirtualPath = (documents) => {
+  const filepathMap = /* @__PURE__ */ Object.create(null);
+  return documents.map((source) => {
+    const location = source.location;
+    if ([".gql", ".graphql"].some((extension) => location.endsWith(extension)))
+      return source;
+    filepathMap[location] ??= -1;
+    const index = filepathMap[location] += 1;
+    return {
+      ...source,
+      location: resolve(location, `${index}_document.graphql`)
+    };
+  });
+}, getDocuments = (project) => {
+  const documentsKey = project.documents;
+  if (!documentsKey)
+    return [];
+  let siblings = operationsCache.get(documentsKey);
+  if (!siblings) {
+    debug("Loading operations from %o", project.documents);
+    const documents = project.loadDocumentsSync(project.documents, {
+      skipGraphQLImport: !0,
+      pluckConfig: project.extensions.pluckConfig
+    });
+    if (debug.enabled) {
+      debug("Loaded %d operations", documents.length);
+      const operationsPaths = fg.sync(project.documents, { absolute: !0 });
+      debug("Operations pointers %O", operationsPaths);
+    }
+    siblings = handleVirtualPath(documents), operationsCache.set(documentsKey, siblings);
+  }
+  return siblings;
+};
+export {
+  getDocuments
+};

package/esm/estree-converter/converter.d.mts

@@ -0,0 +1,8 @@
+import { DocumentNode, GraphQLSchema } from 'graphql';
+import { GraphQLESTreeNode } from './types.mjs';
+import 'eslint';
+import 'estree';
+
+declare function convertToESTree<T extends DocumentNode>(node: T, schema?: GraphQLSchema | null): GraphQLESTreeNode<T>;
+
+export { convertToESTree };

package/esm/estree-converter/converter.js

@@ -0,0 +1,56 @@
+import "../chunk-U3TKCM4X.js";
+import {
+  Kind,
+  TypeInfo,
+  visit,
+  visitWithTypeInfo
+} from "graphql";
+import { convertLocation } from "./utils.js";
+function convertToESTree(node, schema) {
+  const typeInfo = schema && new TypeInfo(schema), visitor = {
+    leave(node2, key, parent) {
+      const leadingComments = "description" in node2 && node2.description ? [
+        {
+          type: node2.description.block ? "Block" : "Line",
+          value: node2.description.value
+        }
+      ] : [], calculatedTypeInfo = typeInfo ? {
+        argument: typeInfo.getArgument(),
+        defaultValue: typeInfo.getDefaultValue(),
+        directive: typeInfo.getDirective(),
+        enumValue: typeInfo.getEnumValue(),
+        fieldDef: typeInfo.getFieldDef(),
+        inputType: typeInfo.getInputType(),
+        parentInputType: typeInfo.getParentInputType(),
+        parentType: typeInfo.getParentType(),
+        gqlType: typeInfo.getType()
+      } : {}, rawNode = () => parent && key !== void 0 ? parent[key] : node2.kind === Kind.DOCUMENT ? {
+        ...node2,
+        definitions: node2.definitions.map(
+          (definition) => definition.rawNode()
+        )
+      } : node2, commonFields = {
+        ...node2,
+        type: node2.kind,
+        loc: convertLocation(node2.loc),
+        range: [node2.loc.start, node2.loc.end],
+        leadingComments,
+        // Use function to prevent RangeError: Maximum call stack size exceeded
+        typeInfo: () => calculatedTypeInfo,
+        // Don't know if can fix error
+        rawNode
+      };
+      return "type" in node2 ? {
+        ...commonFields,
+        gqlType: node2.type
+      } : commonFields;
+    }
+  };
+  return visit(
+    node,
+    typeInfo ? visitWithTypeInfo(typeInfo, visitor) : visitor
+  );
+}
+export {
+  convertToESTree
+};

package/esm/estree-converter/index.d.mts

@@ -0,0 +1,8 @@
+export { convertToESTree } from './converter.mjs';
+export { GraphQLESTreeNode, TypeInformation } from './types.mjs';
+export { convertLocation, convertToken, extractComments, extractTokens, getBaseType, valueFromNode } from './utils.mjs';
+import 'graphql';
+import 'eslint';
+import 'estree';
+import 'graphql/jsutils/Maybe';
+import 'graphql/jsutils/ObjMap';

package/esm/estree-converter/index.js

@@ -0,0 +1,3 @@
+export * from "./converter.js";
+export * from "./types.js";
+export * from "./utils.js";

package/esm/estree-converter/types.d.mts

@@ -0,0 +1,42 @@
+import { AST } from 'eslint';
+import { SourceLocation, Comment } from 'estree';
+import { TypeInfo, ASTNode, TypeNode, DocumentNode, DefinitionNode, EnumValueDefinitionNode, EnumTypeDefinitionNode, EnumTypeExtensionNode, InputValueDefinitionNode, DirectiveDefinitionNode, FieldDefinitionNode, InputObjectTypeDefinitionNode, InputObjectTypeExtensionNode, InterfaceTypeDefinitionNode, InterfaceTypeExtensionNode, ObjectTypeDefinitionNode, ObjectTypeExtensionNode, SelectionSetNode, ExecutableDefinitionNode, FieldNode, InlineFragmentNode, SelectionNode, NameNode, DirectiveNode, VariableNode, VariableDefinitionNode, ArgumentNode, FragmentSpreadNode, NamedTypeNode, TypeDefinitionNode, TypeExtensionNode, ListTypeNode, NonNullTypeNode, OperationTypeDefinitionNode } from 'graphql';
+
+type SafeGraphQLType<T extends ASTNode> = T extends {
+    type: TypeNode;
+} ? Omit<T, 'loc' | 'type'> & {
+    gqlType: T['type'];
+} : Omit<T, 'loc'>;
+type Writeable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+type TypeInformation = {
+    argument: ReturnType<TypeInfo['getArgument']>;
+    defaultValue: ReturnType<TypeInfo['getDefaultValue']>;
+    directive: ReturnType<TypeInfo['getDirective']>;
+    enumValue: ReturnType<TypeInfo['getEnumValue']>;
+    fieldDef: ReturnType<TypeInfo['getFieldDef']>;
+    inputType: ReturnType<TypeInfo['getInputType']>;
+    parentInputType: ReturnType<TypeInfo['getParentInputType']>;
+    parentType: ReturnType<TypeInfo['getParentType']>;
+    gqlType: ReturnType<TypeInfo['getType']>;
+};
+type NodeWithName = ArgumentNode | DirectiveDefinitionNode | EnumValueDefinitionNode | ExecutableDefinitionNode | FieldDefinitionNode | FieldNode | FragmentSpreadNode | NamedTypeNode | TypeDefinitionNode | TypeExtensionNode | VariableNode;
+type NodeWithType = FieldDefinitionNode | InputValueDefinitionNode | ListTypeNode | NonNullTypeNode | OperationTypeDefinitionNode | VariableDefinitionNode;
+type ParentNode<T> = T extends DocumentNode ? AST.Program : T extends DefinitionNode ? DocumentNode : T extends EnumValueDefinitionNode ? EnumTypeDefinitionNode | EnumTypeExtensionNode : T extends InputValueDefinitionNode ? DirectiveDefinitionNode | FieldDefinitionNode | InputObjectTypeDefinitionNode | InputObjectTypeExtensionNode : T extends FieldDefinitionNode ? InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode | ObjectTypeDefinitionNode | ObjectTypeExtensionNode : T extends SelectionSetNode ? ExecutableDefinitionNode | FieldNode | InlineFragmentNode : T extends SelectionNode ? SelectionSetNode : T extends TypeNode ? NodeWithType : T extends NameNode ? NodeWithName : T extends DirectiveNode ? InputObjectTypeDefinitionNode | ObjectTypeDefinitionNode : T extends VariableNode ? VariableDefinitionNode : unknown;
+type Node<T extends ASTNode, WithTypeInfo extends boolean> = Writeable<SafeGraphQLType<T>> & {
+    type: T['kind'];
+    loc: SourceLocation;
+    range: AST.Range;
+    leadingComments: Comment[];
+    typeInfo: () => WithTypeInfo extends true ? TypeInformation : Record<string, never>;
+    rawNode: () => T;
+    parent: GraphQLESTreeNode<ParentNode<T>>;
+};
+type GraphQLESTreeNode<T, W extends boolean = false> = T extends ASTNode ? {
+    [K in keyof Node<T, W>]: Node<T, W>[K] extends ReadonlyArray<infer ArrayItem> | undefined ? GraphQLESTreeNode<ArrayItem, W>[] : GraphQLESTreeNode<Node<T, W>[K], W>;
+} : T extends AST.Program ? T & {
+    parent: null;
+} : T;
+
+export { GraphQLESTreeNode, TypeInformation };

package/esm/estree-converter/utils.d.mts

@@ -0,0 +1,17 @@
+import * as graphql_jsutils_Maybe from 'graphql/jsutils/Maybe';
+import * as graphql_jsutils_ObjMap from 'graphql/jsutils/ObjMap';
+import * as graphql from 'graphql';
+import { GraphQLOutputType, GraphQLNamedType, TokenKind, Token, Location } from 'graphql';
+import { AST } from 'eslint';
+import { Comment, SourceLocation } from 'estree';
+
+declare const valueFromNode: (valueNode: graphql.ValueNode, variables?: graphql_jsutils_Maybe.Maybe<graphql_jsutils_ObjMap.ObjMap<unknown>>) => any;
+declare function getBaseType(type: GraphQLOutputType): GraphQLNamedType;
+declare function convertToken<T extends TokenKind | 'Block' | 'Line'>(token: Token, type: T): Omit<AST.Token, 'type'> & {
+    type: T;
+};
+declare function extractTokens(filePath: string, code: string): AST.Token[];
+declare function extractComments(loc?: Location): Comment[];
+declare function convertLocation(location: Location): SourceLocation;
+
+export { convertLocation, convertToken, extractComments, extractTokens, getBaseType, valueFromNode };