@graphitation/supermassive 2.6.0 → 3.0.0-alpha.1

package/lib/supermassive-ast/TypedAST.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/supermassive-ast/TypedAST.ts"],
+  "sourcesContent": ["/**\n * Taken from node_modules/graphql/language/ast.d.ts\n * License: MIT License\n * Copyright (c): GraphQL Contributors\n *\n * Our changes MUST be annotated inline for ease of future merging.\n */\n\n/**\n * [SUPERMASSIVE]\n *\n * We don't need `Location`, `Token`, and `isNode` , so remove it and its dependencies.\n */\ntype Location = unknown;\n\n/**\n * The list of all possible AST node types.\n */\nexport type ASTNode =\n  | NameNode\n  | DocumentNode\n  | OperationDefinitionNode\n  | VariableDefinitionNode\n  | VariableNode\n  | SelectionSetNode\n  | FieldNode\n  | ArgumentNode\n  | FragmentSpreadNode\n  | InlineFragmentNode\n  | FragmentDefinitionNode\n  | IntValueNode\n  | FloatValueNode\n  | StringValueNode\n  | BooleanValueNode\n  | NullValueNode\n  | EnumValueNode\n  | ListValueNode\n  | ObjectValueNode\n  | ObjectFieldNode\n  | DirectiveNode\n  | NamedTypeNode\n  | ListTypeNode\n  | NonNullTypeNode\n  | SchemaDefinitionNode\n  | OperationTypeDefinitionNode\n  | ScalarTypeDefinitionNode\n  | ObjectTypeDefinitionNode\n  | FieldDefinitionNode\n  | InputValueDefinitionNode\n  | InterfaceTypeDefinitionNode\n  | UnionTypeDefinitionNode\n  | EnumTypeDefinitionNode\n  | EnumValueDefinitionNode\n  | InputObjectTypeDefinitionNode\n  | DirectiveDefinitionNode\n  | SchemaExtensionNode\n  | ScalarTypeExtensionNode\n  | ObjectTypeExtensionNode\n  | InterfaceTypeExtensionNode\n  | UnionTypeExtensionNode\n  | EnumTypeExtensionNode\n  | InputObjectTypeExtensionNode;\n\n/**\n * Utility type listing all nodes indexed by their kind.\n */\nexport interface ASTKindToNode {\n  Name: NameNode;\n  Document: DocumentNode;\n  OperationDefinition: OperationDefinitionNode;\n  VariableDefinition: VariableDefinitionNode;\n  Variable: VariableNode;\n  SelectionSet: SelectionSetNode;\n  Field: FieldNode;\n  Argument: ArgumentNode;\n  FragmentSpread: FragmentSpreadNode;\n  InlineFragment: InlineFragmentNode;\n  FragmentDefinition: FragmentDefinitionNode;\n  IntValue: IntValueNode;\n  FloatValue: FloatValueNode;\n  StringValue: StringValueNode;\n  BooleanValue: BooleanValueNode;\n  NullValue: NullValueNode;\n  EnumValue: EnumValueNode;\n  ListValue: ListValueNode;\n  ObjectValue: ObjectValueNode;\n  ObjectField: ObjectFieldNode;\n  Directive: DirectiveNode;\n  NamedType: NamedTypeNode;\n  ListType: ListTypeNode;\n  NonNullType: NonNullTypeNode;\n  SchemaDefinition: SchemaDefinitionNode;\n  OperationTypeDefinition: OperationTypeDefinitionNode;\n  ScalarTypeDefinition: ScalarTypeDefinitionNode;\n  ObjectTypeDefinition: ObjectTypeDefinitionNode;\n  FieldDefinition: FieldDefinitionNode;\n  InputValueDefinition: InputValueDefinitionNode;\n  InterfaceTypeDefinition: InterfaceTypeDefinitionNode;\n  UnionTypeDefinition: UnionTypeDefinitionNode;\n  EnumTypeDefinition: EnumTypeDefinitionNode;\n  EnumValueDefinition: EnumValueDefinitionNode;\n  InputObjectTypeDefinition: InputObjectTypeDefinitionNode;\n  DirectiveDefinition: DirectiveDefinitionNode;\n  SchemaExtension: SchemaExtensionNode;\n  ScalarTypeExtension: ScalarTypeExtensionNode;\n  ObjectTypeExtension: ObjectTypeExtensionNode;\n  InterfaceTypeExtension: InterfaceTypeExtensionNode;\n  UnionTypeExtension: UnionTypeExtensionNode;\n  EnumTypeExtension: EnumTypeExtensionNode;\n  InputObjectTypeExtension: InputObjectTypeExtensionNode;\n}\n\n// Name\n\nexport interface NameNode {\n  readonly kind: \"Name\";\n  readonly loc?: Location;\n  readonly value: string;\n}\n\n// Document\n\nexport interface DocumentNode {\n  readonly kind: \"Document\";\n  readonly loc?: Location;\n  readonly definitions: ReadonlyArray<DefinitionNode>;\n}\n\nexport type DefinitionNode =\n  | ExecutableDefinitionNode\n  | TypeSystemDefinitionNode\n  | TypeSystemExtensionNode;\n\nexport type ExecutableDefinitionNode =\n  | OperationDefinitionNode\n  | FragmentDefinitionNode;\n\nexport interface OperationDefinitionNode {\n  readonly kind: \"OperationDefinition\";\n  readonly loc?: Location;\n  readonly operation: OperationTypeNode;\n  readonly name?: NameNode;\n  readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly selectionSet: SelectionSetNode;\n}\n\nexport enum OperationTypeNode {\n  QUERY = \"query\",\n  MUTATION = \"mutation\",\n  SUBSCRIPTION = \"subscription\",\n}\nexport interface VariableDefinitionNode {\n  readonly kind: \"VariableDefinition\";\n  readonly loc?: Location;\n  readonly variable: VariableNode;\n  readonly type: TypeNode;\n  readonly defaultValue?: ValueNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n}\n\nexport interface VariableNode {\n  readonly kind: \"Variable\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n}\n\nexport interface SelectionSetNode {\n  kind: \"SelectionSet\";\n  loc?: Location;\n  selections: ReadonlyArray<SelectionNode>;\n}\n\nexport type SelectionNode = FieldNode | FragmentSpreadNode | InlineFragmentNode;\n\nexport interface FieldNode {\n  readonly __type: TypeNode; // [SUPERMASSIVE] Add the return type\n  readonly kind: \"Field\";\n  readonly loc?: Location;\n  readonly alias?: NameNode;\n  readonly name: NameNode;\n  readonly arguments?: ReadonlyArray<ArgumentNode>;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly selectionSet?: SelectionSetNode;\n}\n\nexport interface ArgumentNode {\n  readonly __type: TypeNode; // [SUPERMASSIVE] Add the value type\n  readonly __defaultValue?: ValueNode | null; // [SUPERMASSIVE] Add default value\n  readonly kind: \"Argument\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly value: ValueNode;\n}\n\n// Fragments\n\nexport interface FragmentSpreadNode {\n  readonly kind: \"FragmentSpread\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n}\n\nexport interface InlineFragmentNode {\n  readonly kind: \"InlineFragment\";\n  readonly loc?: Location;\n  readonly typeCondition?: NamedTypeNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly selectionSet: SelectionSetNode;\n}\n\nexport interface FragmentDefinitionNode {\n  readonly kind: \"FragmentDefinition\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  // Note: fragment variable definitions are experimental and may be changed\n  // or removed in the future.\n  readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;\n  readonly typeCondition: NamedTypeNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly selectionSet: SelectionSetNode;\n}\n\n// Values\n\nexport type ValueNode =\n  | VariableNode\n  | IntValueNode\n  | FloatValueNode\n  | StringValueNode\n  | BooleanValueNode\n  | NullValueNode\n  | EnumValueNode\n  | ListValueNode\n  | ObjectValueNode;\n\nexport interface IntValueNode {\n  readonly kind: \"IntValue\";\n  readonly loc?: Location;\n  readonly value: string;\n}\n\nexport interface FloatValueNode {\n  readonly kind: \"FloatValue\";\n  readonly loc?: Location;\n  readonly value: string;\n}\n\nexport interface StringValueNode {\n  readonly kind: \"StringValue\";\n  readonly loc?: Location;\n  readonly value: string;\n  readonly block?: boolean;\n}\n\nexport interface BooleanValueNode {\n  readonly kind: \"BooleanValue\";\n  readonly loc?: Location;\n  readonly value: boolean;\n}\n\nexport interface NullValueNode {\n  readonly kind: \"NullValue\";\n  readonly loc?: Location;\n}\n\nexport interface EnumValueNode {\n  readonly kind: \"EnumValue\";\n  readonly loc?: Location;\n  readonly value: string;\n}\n\nexport interface ListValueNode {\n  readonly kind: \"ListValue\";\n  readonly loc?: Location;\n  readonly values: ReadonlyArray<ValueNode>;\n}\n\nexport interface ObjectValueNode {\n  readonly kind: \"ObjectValue\";\n  readonly loc?: Location;\n  readonly fields: ReadonlyArray<ObjectFieldNode>;\n}\n\nexport interface ObjectFieldNode {\n  readonly kind: \"ObjectField\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly value: ValueNode;\n}\n\n// Directives\n\nexport interface DirectiveNode {\n  readonly kind: \"Directive\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly arguments?: ReadonlyArray<ArgumentNode>;\n}\n\n// Type Reference\n\nexport type TypeNode = NamedTypeNode | ListTypeNode | NonNullTypeNode;\n\nexport interface NamedTypeNode {\n  readonly kind: \"NamedType\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n}\n\nexport interface ListTypeNode {\n  readonly kind: \"ListType\";\n  readonly loc?: Location;\n  readonly type: TypeNode;\n}\n\nexport interface NonNullTypeNode {\n  readonly kind: \"NonNullType\";\n  readonly loc?: Location;\n  readonly type: NamedTypeNode | ListTypeNode;\n}\n\n// Type System Definition\n\nexport type TypeSystemDefinitionNode =\n  | SchemaDefinitionNode\n  | TypeDefinitionNode\n  | DirectiveDefinitionNode;\n\nexport interface SchemaDefinitionNode {\n  readonly kind: \"SchemaDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly operationTypes: ReadonlyArray<OperationTypeDefinitionNode>;\n}\n\nexport interface OperationTypeDefinitionNode {\n  readonly kind: \"OperationTypeDefinition\";\n  readonly loc?: Location;\n  readonly operation: OperationTypeNode;\n  readonly type: NamedTypeNode;\n}\n\n// Type Definition\n\nexport type TypeDefinitionNode =\n  | ScalarTypeDefinitionNode\n  | ObjectTypeDefinitionNode\n  | InterfaceTypeDefinitionNode\n  | UnionTypeDefinitionNode\n  | EnumTypeDefinitionNode\n  | InputObjectTypeDefinitionNode;\n\nexport interface ScalarTypeDefinitionNode {\n  readonly kind: \"ScalarTypeDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n}\n\nexport interface ObjectTypeDefinitionNode {\n  readonly kind: \"ObjectTypeDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly interfaces?: ReadonlyArray<NamedTypeNode>;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly fields?: ReadonlyArray<FieldDefinitionNode>;\n}\n\nexport interface FieldDefinitionNode {\n  readonly kind: \"FieldDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;\n  readonly type: TypeNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n}\n\nexport interface InputValueDefinitionNode {\n  readonly kind: \"InputValueDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly type: TypeNode;\n  readonly defaultValue?: ValueNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n}\n\nexport interface InterfaceTypeDefinitionNode {\n  readonly kind: \"InterfaceTypeDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly interfaces?: ReadonlyArray<NamedTypeNode>;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly fields?: ReadonlyArray<FieldDefinitionNode>;\n}\n\nexport interface UnionTypeDefinitionNode {\n  readonly kind: \"UnionTypeDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly types?: ReadonlyArray<NamedTypeNode>;\n}\n\nexport interface EnumTypeDefinitionNode {\n  readonly kind: \"EnumTypeDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly values?: ReadonlyArray<EnumValueDefinitionNode>;\n}\n\nexport interface EnumValueDefinitionNode {\n  readonly kind: \"EnumValueDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n}\n\nexport interface InputObjectTypeDefinitionNode {\n  readonly kind: \"InputObjectTypeDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly fields?: ReadonlyArray<InputValueDefinitionNode>;\n}\n\n// Directive Definitions\n\nexport interface DirectiveDefinitionNode {\n  readonly kind: \"DirectiveDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;\n  readonly repeatable: boolean;\n  readonly locations: ReadonlyArray<NameNode>;\n}\n\n// Type System Extensions\n\nexport type TypeSystemExtensionNode = SchemaExtensionNode | TypeExtensionNode;\n\nexport interface SchemaExtensionNode {\n  readonly kind: \"SchemaExtension\";\n  readonly loc?: Location;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly operationTypes?: ReadonlyArray<OperationTypeDefinitionNode>;\n}\n\n// Type Extensions\n\nexport type TypeExtensionNode =\n  | ScalarTypeExtensionNode\n  | ObjectTypeExtensionNode\n  | InterfaceTypeExtensionNode\n  | UnionTypeExtensionNode\n  | EnumTypeExtensionNode\n  | InputObjectTypeExtensionNode;\n\nexport interface ScalarTypeExtensionNode {\n  readonly kind: \"ScalarTypeExtension\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n}\n\nexport interface ObjectTypeExtensionNode {\n  readonly kind: \"ObjectTypeExtension\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly interfaces?: ReadonlyArray<NamedTypeNode>;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly fields?: ReadonlyArray<FieldDefinitionNode>;\n}\n\nexport interface InterfaceTypeExtensionNode {\n  readonly kind: \"InterfaceTypeExtension\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly interfaces?: ReadonlyArray<NamedTypeNode>;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly fields?: ReadonlyArray<FieldDefinitionNode>;\n}\n\nexport interface UnionTypeExtensionNode {\n  readonly kind: \"UnionTypeExtension\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly types?: ReadonlyArray<NamedTypeNode>;\n}\n\nexport interface EnumTypeExtensionNode {\n  readonly kind: \"EnumTypeExtension\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly values?: ReadonlyArray<EnumValueDefinitionNode>;\n}\n\nexport interface InputObjectTypeExtensionNode {\n  readonly kind: \"InputObjectTypeExtension\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly fields?: ReadonlyArray<InputValueDefinitionNode>;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAmJO,IAAK,oBAAL,kBAAKA,uBAAL;AACL,EAAAA,mBAAA,WAAQ;AACR,EAAAA,mBAAA,cAAW;AACX,EAAAA,mBAAA,kBAAe;AAHL,SAAAA;AAAA,GAAA;",
+  "names": ["OperationTypeNode"]
+}

package/lib/supermassive-ast/TypedAST.mjs

@@ -0,0 +1,10 @@
+// src/supermassive-ast/TypedAST.ts
+var OperationTypeNode = /* @__PURE__ */ ((OperationTypeNode2) => {
+  OperationTypeNode2["QUERY"] = "query";
+  OperationTypeNode2["MUTATION"] = "mutation";
+  OperationTypeNode2["SUBSCRIPTION"] = "subscription";
+  return OperationTypeNode2;
+})(OperationTypeNode || {});
+export {
+  OperationTypeNode
+};

package/lib/supermassive-ast/TypedAST.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/supermassive-ast/TypedAST.ts"],
+  "sourcesContent": ["/**\n * Taken from node_modules/graphql/language/ast.d.ts\n * License: MIT License\n * Copyright (c): GraphQL Contributors\n *\n * Our changes MUST be annotated inline for ease of future merging.\n */\n\n/**\n * [SUPERMASSIVE]\n *\n * We don't need `Location`, `Token`, and `isNode` , so remove it and its dependencies.\n */\ntype Location = unknown;\n\n/**\n * The list of all possible AST node types.\n */\nexport type ASTNode =\n  | NameNode\n  | DocumentNode\n  | OperationDefinitionNode\n  | VariableDefinitionNode\n  | VariableNode\n  | SelectionSetNode\n  | FieldNode\n  | ArgumentNode\n  | FragmentSpreadNode\n  | InlineFragmentNode\n  | FragmentDefinitionNode\n  | IntValueNode\n  | FloatValueNode\n  | StringValueNode\n  | BooleanValueNode\n  | NullValueNode\n  | EnumValueNode\n  | ListValueNode\n  | ObjectValueNode\n  | ObjectFieldNode\n  | DirectiveNode\n  | NamedTypeNode\n  | ListTypeNode\n  | NonNullTypeNode\n  | SchemaDefinitionNode\n  | OperationTypeDefinitionNode\n  | ScalarTypeDefinitionNode\n  | ObjectTypeDefinitionNode\n  | FieldDefinitionNode\n  | InputValueDefinitionNode\n  | InterfaceTypeDefinitionNode\n  | UnionTypeDefinitionNode\n  | EnumTypeDefinitionNode\n  | EnumValueDefinitionNode\n  | InputObjectTypeDefinitionNode\n  | DirectiveDefinitionNode\n  | SchemaExtensionNode\n  | ScalarTypeExtensionNode\n  | ObjectTypeExtensionNode\n  | InterfaceTypeExtensionNode\n  | UnionTypeExtensionNode\n  | EnumTypeExtensionNode\n  | InputObjectTypeExtensionNode;\n\n/**\n * Utility type listing all nodes indexed by their kind.\n */\nexport interface ASTKindToNode {\n  Name: NameNode;\n  Document: DocumentNode;\n  OperationDefinition: OperationDefinitionNode;\n  VariableDefinition: VariableDefinitionNode;\n  Variable: VariableNode;\n  SelectionSet: SelectionSetNode;\n  Field: FieldNode;\n  Argument: ArgumentNode;\n  FragmentSpread: FragmentSpreadNode;\n  InlineFragment: InlineFragmentNode;\n  FragmentDefinition: FragmentDefinitionNode;\n  IntValue: IntValueNode;\n  FloatValue: FloatValueNode;\n  StringValue: StringValueNode;\n  BooleanValue: BooleanValueNode;\n  NullValue: NullValueNode;\n  EnumValue: EnumValueNode;\n  ListValue: ListValueNode;\n  ObjectValue: ObjectValueNode;\n  ObjectField: ObjectFieldNode;\n  Directive: DirectiveNode;\n  NamedType: NamedTypeNode;\n  ListType: ListTypeNode;\n  NonNullType: NonNullTypeNode;\n  SchemaDefinition: SchemaDefinitionNode;\n  OperationTypeDefinition: OperationTypeDefinitionNode;\n  ScalarTypeDefinition: ScalarTypeDefinitionNode;\n  ObjectTypeDefinition: ObjectTypeDefinitionNode;\n  FieldDefinition: FieldDefinitionNode;\n  InputValueDefinition: InputValueDefinitionNode;\n  InterfaceTypeDefinition: InterfaceTypeDefinitionNode;\n  UnionTypeDefinition: UnionTypeDefinitionNode;\n  EnumTypeDefinition: EnumTypeDefinitionNode;\n  EnumValueDefinition: EnumValueDefinitionNode;\n  InputObjectTypeDefinition: InputObjectTypeDefinitionNode;\n  DirectiveDefinition: DirectiveDefinitionNode;\n  SchemaExtension: SchemaExtensionNode;\n  ScalarTypeExtension: ScalarTypeExtensionNode;\n  ObjectTypeExtension: ObjectTypeExtensionNode;\n  InterfaceTypeExtension: InterfaceTypeExtensionNode;\n  UnionTypeExtension: UnionTypeExtensionNode;\n  EnumTypeExtension: EnumTypeExtensionNode;\n  InputObjectTypeExtension: InputObjectTypeExtensionNode;\n}\n\n// Name\n\nexport interface NameNode {\n  readonly kind: \"Name\";\n  readonly loc?: Location;\n  readonly value: string;\n}\n\n// Document\n\nexport interface DocumentNode {\n  readonly kind: \"Document\";\n  readonly loc?: Location;\n  readonly definitions: ReadonlyArray<DefinitionNode>;\n}\n\nexport type DefinitionNode =\n  | ExecutableDefinitionNode\n  | TypeSystemDefinitionNode\n  | TypeSystemExtensionNode;\n\nexport type ExecutableDefinitionNode =\n  | OperationDefinitionNode\n  | FragmentDefinitionNode;\n\nexport interface OperationDefinitionNode {\n  readonly kind: \"OperationDefinition\";\n  readonly loc?: Location;\n  readonly operation: OperationTypeNode;\n  readonly name?: NameNode;\n  readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly selectionSet: SelectionSetNode;\n}\n\nexport enum OperationTypeNode {\n  QUERY = \"query\",\n  MUTATION = \"mutation\",\n  SUBSCRIPTION = \"subscription\",\n}\nexport interface VariableDefinitionNode {\n  readonly kind: \"VariableDefinition\";\n  readonly loc?: Location;\n  readonly variable: VariableNode;\n  readonly type: TypeNode;\n  readonly defaultValue?: ValueNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n}\n\nexport interface VariableNode {\n  readonly kind: \"Variable\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n}\n\nexport interface SelectionSetNode {\n  kind: \"SelectionSet\";\n  loc?: Location;\n  selections: ReadonlyArray<SelectionNode>;\n}\n\nexport type SelectionNode = FieldNode | FragmentSpreadNode | InlineFragmentNode;\n\nexport interface FieldNode {\n  readonly __type: TypeNode; // [SUPERMASSIVE] Add the return type\n  readonly kind: \"Field\";\n  readonly loc?: Location;\n  readonly alias?: NameNode;\n  readonly name: NameNode;\n  readonly arguments?: ReadonlyArray<ArgumentNode>;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly selectionSet?: SelectionSetNode;\n}\n\nexport interface ArgumentNode {\n  readonly __type: TypeNode; // [SUPERMASSIVE] Add the value type\n  readonly __defaultValue?: ValueNode | null; // [SUPERMASSIVE] Add default value\n  readonly kind: \"Argument\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly value: ValueNode;\n}\n\n// Fragments\n\nexport interface FragmentSpreadNode {\n  readonly kind: \"FragmentSpread\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n}\n\nexport interface InlineFragmentNode {\n  readonly kind: \"InlineFragment\";\n  readonly loc?: Location;\n  readonly typeCondition?: NamedTypeNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly selectionSet: SelectionSetNode;\n}\n\nexport interface FragmentDefinitionNode {\n  readonly kind: \"FragmentDefinition\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  // Note: fragment variable definitions are experimental and may be changed\n  // or removed in the future.\n  readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;\n  readonly typeCondition: NamedTypeNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly selectionSet: SelectionSetNode;\n}\n\n// Values\n\nexport type ValueNode =\n  | VariableNode\n  | IntValueNode\n  | FloatValueNode\n  | StringValueNode\n  | BooleanValueNode\n  | NullValueNode\n  | EnumValueNode\n  | ListValueNode\n  | ObjectValueNode;\n\nexport interface IntValueNode {\n  readonly kind: \"IntValue\";\n  readonly loc?: Location;\n  readonly value: string;\n}\n\nexport interface FloatValueNode {\n  readonly kind: \"FloatValue\";\n  readonly loc?: Location;\n  readonly value: string;\n}\n\nexport interface StringValueNode {\n  readonly kind: \"StringValue\";\n  readonly loc?: Location;\n  readonly value: string;\n  readonly block?: boolean;\n}\n\nexport interface BooleanValueNode {\n  readonly kind: \"BooleanValue\";\n  readonly loc?: Location;\n  readonly value: boolean;\n}\n\nexport interface NullValueNode {\n  readonly kind: \"NullValue\";\n  readonly loc?: Location;\n}\n\nexport interface EnumValueNode {\n  readonly kind: \"EnumValue\";\n  readonly loc?: Location;\n  readonly value: string;\n}\n\nexport interface ListValueNode {\n  readonly kind: \"ListValue\";\n  readonly loc?: Location;\n  readonly values: ReadonlyArray<ValueNode>;\n}\n\nexport interface ObjectValueNode {\n  readonly kind: \"ObjectValue\";\n  readonly loc?: Location;\n  readonly fields: ReadonlyArray<ObjectFieldNode>;\n}\n\nexport interface ObjectFieldNode {\n  readonly kind: \"ObjectField\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly value: ValueNode;\n}\n\n// Directives\n\nexport interface DirectiveNode {\n  readonly kind: \"Directive\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly arguments?: ReadonlyArray<ArgumentNode>;\n}\n\n// Type Reference\n\nexport type TypeNode = NamedTypeNode | ListTypeNode | NonNullTypeNode;\n\nexport interface NamedTypeNode {\n  readonly kind: \"NamedType\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n}\n\nexport interface ListTypeNode {\n  readonly kind: \"ListType\";\n  readonly loc?: Location;\n  readonly type: TypeNode;\n}\n\nexport interface NonNullTypeNode {\n  readonly kind: \"NonNullType\";\n  readonly loc?: Location;\n  readonly type: NamedTypeNode | ListTypeNode;\n}\n\n// Type System Definition\n\nexport type TypeSystemDefinitionNode =\n  | SchemaDefinitionNode\n  | TypeDefinitionNode\n  | DirectiveDefinitionNode;\n\nexport interface SchemaDefinitionNode {\n  readonly kind: \"SchemaDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly operationTypes: ReadonlyArray<OperationTypeDefinitionNode>;\n}\n\nexport interface OperationTypeDefinitionNode {\n  readonly kind: \"OperationTypeDefinition\";\n  readonly loc?: Location;\n  readonly operation: OperationTypeNode;\n  readonly type: NamedTypeNode;\n}\n\n// Type Definition\n\nexport type TypeDefinitionNode =\n  | ScalarTypeDefinitionNode\n  | ObjectTypeDefinitionNode\n  | InterfaceTypeDefinitionNode\n  | UnionTypeDefinitionNode\n  | EnumTypeDefinitionNode\n  | InputObjectTypeDefinitionNode;\n\nexport interface ScalarTypeDefinitionNode {\n  readonly kind: \"ScalarTypeDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n}\n\nexport interface ObjectTypeDefinitionNode {\n  readonly kind: \"ObjectTypeDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly interfaces?: ReadonlyArray<NamedTypeNode>;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly fields?: ReadonlyArray<FieldDefinitionNode>;\n}\n\nexport interface FieldDefinitionNode {\n  readonly kind: \"FieldDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;\n  readonly type: TypeNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n}\n\nexport interface InputValueDefinitionNode {\n  readonly kind: \"InputValueDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly type: TypeNode;\n  readonly defaultValue?: ValueNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n}\n\nexport interface InterfaceTypeDefinitionNode {\n  readonly kind: \"InterfaceTypeDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly interfaces?: ReadonlyArray<NamedTypeNode>;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly fields?: ReadonlyArray<FieldDefinitionNode>;\n}\n\nexport interface UnionTypeDefinitionNode {\n  readonly kind: \"UnionTypeDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly types?: ReadonlyArray<NamedTypeNode>;\n}\n\nexport interface EnumTypeDefinitionNode {\n  readonly kind: \"EnumTypeDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly values?: ReadonlyArray<EnumValueDefinitionNode>;\n}\n\nexport interface EnumValueDefinitionNode {\n  readonly kind: \"EnumValueDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n}\n\nexport interface InputObjectTypeDefinitionNode {\n  readonly kind: \"InputObjectTypeDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly fields?: ReadonlyArray<InputValueDefinitionNode>;\n}\n\n// Directive Definitions\n\nexport interface DirectiveDefinitionNode {\n  readonly kind: \"DirectiveDefinition\";\n  readonly loc?: Location;\n  readonly description?: StringValueNode;\n  readonly name: NameNode;\n  readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;\n  readonly repeatable: boolean;\n  readonly locations: ReadonlyArray<NameNode>;\n}\n\n// Type System Extensions\n\nexport type TypeSystemExtensionNode = SchemaExtensionNode | TypeExtensionNode;\n\nexport interface SchemaExtensionNode {\n  readonly kind: \"SchemaExtension\";\n  readonly loc?: Location;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly operationTypes?: ReadonlyArray<OperationTypeDefinitionNode>;\n}\n\n// Type Extensions\n\nexport type TypeExtensionNode =\n  | ScalarTypeExtensionNode\n  | ObjectTypeExtensionNode\n  | InterfaceTypeExtensionNode\n  | UnionTypeExtensionNode\n  | EnumTypeExtensionNode\n  | InputObjectTypeExtensionNode;\n\nexport interface ScalarTypeExtensionNode {\n  readonly kind: \"ScalarTypeExtension\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n}\n\nexport interface ObjectTypeExtensionNode {\n  readonly kind: \"ObjectTypeExtension\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly interfaces?: ReadonlyArray<NamedTypeNode>;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly fields?: ReadonlyArray<FieldDefinitionNode>;\n}\n\nexport interface InterfaceTypeExtensionNode {\n  readonly kind: \"InterfaceTypeExtension\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly interfaces?: ReadonlyArray<NamedTypeNode>;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly fields?: ReadonlyArray<FieldDefinitionNode>;\n}\n\nexport interface UnionTypeExtensionNode {\n  readonly kind: \"UnionTypeExtension\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly types?: ReadonlyArray<NamedTypeNode>;\n}\n\nexport interface EnumTypeExtensionNode {\n  readonly kind: \"EnumTypeExtension\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly values?: ReadonlyArray<EnumValueDefinitionNode>;\n}\n\nexport interface InputObjectTypeExtensionNode {\n  readonly kind: \"InputObjectTypeExtension\";\n  readonly loc?: Location;\n  readonly name: NameNode;\n  readonly directives?: ReadonlyArray<DirectiveNode>;\n  readonly fields?: ReadonlyArray<InputValueDefinitionNode>;\n}\n"],
+  "mappings": ";AAmJO,IAAK,oBAAL,kBAAKA,uBAAL;AACL,EAAAA,mBAAA,WAAQ;AACR,EAAAA,mBAAA,cAAW;AACX,EAAAA,mBAAA,kBAAe;AAHL,SAAAA;AAAA,GAAA;",
+  "names": ["OperationTypeNode"]
+}

package/lib/supermassive-ast/addTypesToRequestDocument.d.ts

@@ -0,0 +1,56 @@
+import { GraphQLType, GraphQLSchema, GraphQLArgument, ASTVisitor, GraphQLCompositeType, GraphQLEnumValue, GraphQLField, GraphQLInputType, GraphQLOutputType, GraphQLDirective } from "graphql";
+import * as TypelessAST from "graphql/language/ast";
+import * as TypedAST from "./TypedAST";
+import { Maybe } from "graphql/jsutils/Maybe";
+export * from "./TypedAST";
+export declare function addTypesToRequestDocument(schema: GraphQLSchema, document: TypelessAST.DocumentNode, options?: {
+    ignoredDirectives?: string[];
+}): TypedAST.DocumentNode;
+/**
+ * TypeInfo is a utility class which, given a GraphQL schema, can keep track
+ * of the current field and type definitions at any point in a GraphQL document
+ * AST during a recursive descent by calling `enter(node)` and `leave(node)`.
+ */
+export declare class TypeInfo {
+    private _schema;
+    private _typeStack;
+    private _parentTypeStack;
+    private _inputTypeStack;
+    private _fieldDefStack;
+    private _defaultValueStack;
+    private _directive;
+    private _argument;
+    private _enumValue;
+    private _isInIgnoredDirective;
+    private _defaultDirectives;
+    private _ignoredDirectives;
+    constructor(schema: GraphQLSchema, 
+    /**
+     * Initial type may be provided in rare cases to facilitate traversals
+     *  beginning somewhere other than documents.
+     */
+    options?: {
+        initialType?: Maybe<GraphQLType>;
+        defaultDirectives?: ReadonlyArray<GraphQLDirective>;
+        ignoredDirectives?: ReadonlyArray<string>;
+    });
+    get [Symbol.toStringTag](): string;
+    getType(): Maybe<GraphQLOutputType>;
+    getParentType(): Maybe<GraphQLCompositeType>;
+    getInputType(): Maybe<GraphQLInputType>;
+    getParentInputType(): Maybe<GraphQLInputType>;
+    getFieldDef(): Maybe<GraphQLField<unknown, unknown>>;
+    getDefaultValue(): Maybe<unknown>;
+    getDirective(): Maybe<GraphQLDirective>;
+    getArgument(): Maybe<GraphQLArgument>;
+    getEnumValue(): Maybe<GraphQLEnumValue>;
+    isInIgnoredDirective(): boolean;
+    enter(node: TypelessAST.ASTNode): void;
+    leave(node: TypelessAST.ASTNode): void;
+}
+/**
+ * Creates a new visitor instance which maintains a provided TypeInfo instance
+ * along with visiting visitor.
+ */
+export declare function visitWithTypeInfo(typeInfo: TypeInfo, visitor: ASTVisitor): ASTVisitor;
+//# sourceMappingURL=addTypesToRequestDocument.d.ts.map

package/lib/supermassive-ast/addTypesToRequestDocument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addTypesToRequestDocument.d.ts","sourceRoot":"","sources":["../../src/supermassive-ast/addTypesToRequestDocument.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,aAAa,EAOb,eAAe,EACf,UAAU,EACV,oBAAoB,EACpB,gBAAgB,EAChB,YAAY,EAEZ,gBAAgB,EAChB,iBAAiB,EAWjB,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,WAAW,MAAM,sBAAsB,CAAC;AACpD,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,cAAc,YAAY,CAAC;AAG3B,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,WAAW,CAAC,YAAY,EAClC,OAAO,GAAE;IACP,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB,GACL,QAAQ,CAAC,YAAY,CA2JvB;AA2DD;;;;GAIG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,UAAU,CAAkC;IACpD,OAAO,CAAC,gBAAgB,CAAqC;IAC7D,OAAO,CAAC,eAAe,CAAiC;IACxD,OAAO,CAAC,cAAc,CAA+C;IACrE,OAAO,CAAC,kBAAkB,CAAwB;IAClD,OAAO,CAAC,UAAU,CAA0B;IAC5C,OAAO,CAAC,SAAS,CAAyB;IAC1C,OAAO,CAAC,UAAU,CAA0B;IAC5C,OAAO,CAAC,qBAAqB,CAAU;IAEvC,OAAO,CAAC,kBAAkB,CAAgC;IAC1D,OAAO,CAAC,kBAAkB,CAAc;gBAGtC,MAAM,EAAE,aAAa;IACrB;;;OAGG;IACH,OAAO,GAAE;QACP,WAAW,CAAC,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;QACjC,iBAAiB,CAAC,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;QACpD,iBAAiB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;KACtC;IA8BR,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,WAEvB;IAED,OAAO,IAAI,KAAK,CAAC,iBAAiB,CAAC;IAInC,aAAa,IAAI,KAAK,CAAC,oBAAoB,CAAC;IAI5C,YAAY,IAAI,KAAK,CAAC,gBAAgB,CAAC;IAIvC,kBAAkB,IAAI,KAAK,CAAC,gBAAgB,CAAC;IAI7C,WAAW,IAAI,KAAK,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAIpD,eAAe,IAAI,KAAK,CAAC,OAAO,CAAC;IAIjC,YAAY,IAAI,KAAK,CAAC,gBAAgB,CAAC;IAIvC,WAAW,IAAI,KAAK,CAAC,eAAe,CAAC;IAIrC,YAAY,IAAI,KAAK,CAAC,gBAAgB,CAAC;IAIvC,oBAAoB,IAAI,OAAO;IAI/B,KAAK,CAAC,IAAI,EAAE,WAAW,CAAC,OAAO;IAyH/B,KAAK,CAAC,IAAI,EAAE,WAAW,CAAC,OAAO;CAsChC;AAUD;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,UAAU,GAClB,UAAU,CA4BZ"}

package/lib/supermassive-ast/addTypesToRequestDocument.js

@@ -0,0 +1,473 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var addTypesToRequestDocument_exports = {};
+__export(addTypesToRequestDocument_exports, {
+  TypeInfo: () => TypeInfo,
+  addTypesToRequestDocument: () => addTypesToRequestDocument,
+  visitWithTypeInfo: () => visitWithTypeInfo
+});
+module.exports = __toCommonJS(addTypesToRequestDocument_exports);
+var import_graphql = require("graphql");
+var TypelessAST = __toESM(require("graphql/language/ast"));
+__reExport(addTypesToRequestDocument_exports, require("./TypedAST"), module.exports);
+var import_directives = require("./directives");
+function addTypesToRequestDocument(schema, document, options = {}) {
+  const typeInfo = new TypeInfo(schema, {
+    defaultDirectives: import_directives.specifiedDirectives,
+    ignoredDirectives: options.ignoredDirectives
+  });
+  return (0, import_graphql.visit)(
+    document,
+    visitWithTypeInfo(typeInfo, {
+      Argument: {
+        leave(node, _key, _parent, _path, ancestors) {
+          const argument = typeInfo.getArgument();
+          if (argument) {
+            const typeNode = generateTypeNode(argument.type);
+            const newNode = __spreadProps(__spreadValues({}, node), {
+              __type: typeNode
+            });
+            if (argument.defaultValue && node.value.kind === import_graphql.Kind.VARIABLE) {
+              newNode.__defaultValue = (0, import_graphql.astFromValue)(
+                argument.defaultValue,
+                argument.type
+              );
+            }
+            return newNode;
+          }
+          if (!typeInfo.isInIgnoredDirective()) {
+            const errorPath = makeReadableErrorPath(ancestors);
+            throw new Error(
+              `Cannot find type for argument: ${errorPath.join(".")}.${node.name.value}`
+            );
+          }
+        }
+      },
+      Directive: {
+        leave(node, _key, _parent, _path, ancestors) {
+          const directiveDef = typeInfo.getDirective();
+          if (directiveDef) {
+            const missingArgs = directiveDef.args.filter(
+              (argDef) => {
+                var _a;
+                return argDef.defaultValue != null && ((_a = node.arguments) == null ? void 0 : _a.findIndex(
+                  (arg) => arg.name.value === argDef.name
+                )) === -1;
+              }
+            );
+            if (missingArgs) {
+              const newNode = __spreadValues({}, node);
+              newNode.arguments = (newNode.arguments || []).concat(
+                missingArgs.map((arg) => ({
+                  __type: generateTypeNode(arg.type),
+                  kind: import_graphql.Kind.ARGUMENT,
+                  name: {
+                    kind: import_graphql.Kind.NAME,
+                    value: arg.name
+                  },
+                  value: (0, import_graphql.astFromValue)(
+                    arg.defaultValue,
+                    arg.type
+                  )
+                }))
+              );
+              return newNode;
+            }
+            return node;
+          }
+          if (!typeInfo.isInIgnoredDirective()) {
+            const errorPath = makeReadableErrorPath(ancestors);
+            throw new Error(
+              `Cannot find type for directive: ${errorPath.join(".")}.${node.name.value}`
+            );
+          }
+        }
+      },
+      Field: {
+        leave(node, _key, _parent, _path, ancestors) {
+          const fieldDef = typeInfo.getFieldDef();
+          if (fieldDef) {
+            const type = fieldDef.type;
+            if (type) {
+              const typeNode = generateTypeNode(type);
+              const missingArgs = fieldDef.args.filter(
+                (argDef) => {
+                  var _a;
+                  return argDef.defaultValue != null && ((_a = node.arguments) == null ? void 0 : _a.findIndex(
+                    (arg) => arg.name.value === argDef.name
+                  )) === -1;
+                }
+              );
+              const newNode = __spreadProps(__spreadValues({}, node), {
+                __type: typeNode
+              });
+              if (missingArgs) {
+                newNode.arguments = (newNode.arguments || []).concat(
+                  missingArgs.map((arg) => ({
+                    __type: generateTypeNode(arg.type),
+                    kind: import_graphql.Kind.ARGUMENT,
+                    name: {
+                      kind: import_graphql.Kind.NAME,
+                      value: arg.name
+                    },
+                    value: (0, import_graphql.astFromValue)(
+                      arg.defaultValue,
+                      arg.type
+                    )
+                  }))
+                );
+              }
+              return newNode;
+            }
+          }
+          const errorPath = makeReadableErrorPath(ancestors);
+          throw new Error(
+            `Cannot find type for field: ${errorPath.join(".")}.${node.name.value}`
+          );
+        }
+      }
+    })
+  );
+}
+function generateTypeNode(type) {
+  if ((0, import_graphql.isNonNullType)(type)) {
+    const typeNode = generateTypeNode(type.ofType);
+    return {
+      kind: "NonNullType",
+      type: typeNode
+    };
+  } else if ((0, import_graphql.isListType)(type)) {
+    const typeNode = generateTypeNode(type.ofType);
+    return {
+      kind: "ListType",
+      type: typeNode
+    };
+  } else if ((0, import_graphql.isNamedType)(type)) {
+    return {
+      kind: "NamedType",
+      name: {
+        kind: "Name",
+        value: type.name
+      }
+    };
+  }
+  throw new Error(`Can't generate TypeNode for type: ${type}`);
+}
+function makeReadableErrorPath(ancestors) {
+  const path = [];
+  ancestors.forEach((ancestorOrArray) => {
+    let ancestor;
+    if (!Array.isArray(ancestorOrArray)) {
+      ancestor = ancestorOrArray;
+      if (ancestor && ancestor.kind === import_graphql.Kind.FIELD) {
+        path.push(ancestor.name.value);
+      } else if (ancestor && ancestor.kind === import_graphql.Kind.DIRECTIVE) {
+        path.push(`@${ancestor.name.value}`);
+      } else if (ancestor && ancestor.kind === import_graphql.Kind.OPERATION_DEFINITION) {
+        let name;
+        if (ancestor.name) {
+          name = `${ancestor.operation} ${ancestor.name.value}`;
+        } else {
+          name = ancestor.operation;
+        }
+        path.push(name);
+      }
+    }
+  });
+  return path;
+}
+class TypeInfo {
+  constructor(schema, options = {}) {
+    this._schema = schema;
+    this._typeStack = [];
+    this._parentTypeStack = [];
+    this._inputTypeStack = [];
+    this._fieldDefStack = [];
+    this._defaultValueStack = [];
+    this._directive = null;
+    this._isInIgnoredDirective = false;
+    this._argument = null;
+    this._enumValue = null;
+    if (options.initialType) {
+      if ((0, import_graphql.isInputType)(options.initialType)) {
+        this._inputTypeStack.push(options.initialType);
+      }
+      if ((0, import_graphql.isCompositeType)(options.initialType)) {
+        this._parentTypeStack.push(options.initialType);
+      }
+      if ((0, import_graphql.isOutputType)(options.initialType)) {
+        this._typeStack.push(options.initialType);
+      }
+    }
+    this._defaultDirectives = /* @__PURE__ */ new Map();
+    for (const directive of options.defaultDirectives || []) {
+      this._defaultDirectives.set(directive.name, directive);
+    }
+    this._ignoredDirectives = new Set(options.ignoredDirectives || []);
+  }
+  get [Symbol.toStringTag]() {
+    return "TypeInfo";
+  }
+  getType() {
+    return at(this._typeStack, -1);
+  }
+  getParentType() {
+    return at(this._parentTypeStack, -1);
+  }
+  getInputType() {
+    return at(this._inputTypeStack, -1);
+  }
+  getParentInputType() {
+    return at(this._inputTypeStack, -2);
+  }
+  getFieldDef() {
+    return at(this._fieldDefStack, -1);
+  }
+  getDefaultValue() {
+    return at(this._defaultValueStack, -1);
+  }
+  getDirective() {
+    return this._directive;
+  }
+  getArgument() {
+    return this._argument;
+  }
+  getEnumValue() {
+    return this._enumValue;
+  }
+  isInIgnoredDirective() {
+    return this._isInIgnoredDirective;
+  }
+  enter(node) {
+    var _a;
+    const schema = this._schema;
+    switch (node.kind) {
+      case import_graphql.Kind.SELECTION_SET: {
+        const namedType = (0, import_graphql.getNamedType)(this.getType());
+        this._parentTypeStack.push(
+          (0, import_graphql.isCompositeType)(namedType) ? namedType : void 0
+        );
+        break;
+      }
+      case import_graphql.Kind.FIELD: {
+        const parentType = this.getParentType();
+        let fieldDef;
+        let fieldType;
+        if (parentType) {
+          fieldDef = getFieldDef(schema, parentType, node);
+          if (fieldDef) {
+            fieldType = fieldDef.type;
+          }
+        }
+        this._fieldDefStack.push(fieldDef);
+        this._typeStack.push((0, import_graphql.isOutputType)(fieldType) ? fieldType : void 0);
+        break;
+      }
+      case import_graphql.Kind.DIRECTIVE: {
+        const name = node.name.value;
+        this._directive = schema.getDirective(name);
+        if (!this._directive) {
+          if (this._defaultDirectives.has(name)) {
+            this._directive = this._defaultDirectives.get(name);
+          }
+          if (this._ignoredDirectives.has(name)) {
+            this._isInIgnoredDirective = true;
+          }
+        }
+        break;
+      }
+      case import_graphql.Kind.OPERATION_DEFINITION: {
+        const rootType = schema.getRootType(node.operation);
+        this._typeStack.push((0, import_graphql.isObjectType)(rootType) ? rootType : void 0);
+        break;
+      }
+      case import_graphql.Kind.INLINE_FRAGMENT:
+      case import_graphql.Kind.FRAGMENT_DEFINITION: {
+        const typeConditionAST = node.typeCondition;
+        const outputType = typeConditionAST ? (0, import_graphql.typeFromAST)(schema, typeConditionAST) : (0, import_graphql.getNamedType)(this.getType());
+        this._typeStack.push((0, import_graphql.isOutputType)(outputType) ? outputType : void 0);
+        break;
+      }
+      case import_graphql.Kind.VARIABLE_DEFINITION: {
+        const inputType = (0, import_graphql.typeFromAST)(schema, node.type);
+        this._inputTypeStack.push(
+          (0, import_graphql.isInputType)(inputType) ? inputType : void 0
+        );
+        break;
+      }
+      case import_graphql.Kind.ARGUMENT: {
+        let argDef;
+        let argType;
+        const fieldOrDirective = (_a = this.getDirective()) != null ? _a : this.getFieldDef();
+        if (fieldOrDirective) {
+          argDef = fieldOrDirective.args.find(
+            (arg) => arg.name === node.name.value
+          );
+          if (argDef) {
+            argType = argDef.type;
+          }
+        }
+        this._argument = argDef;
+        this._defaultValueStack.push(argDef ? argDef.defaultValue : void 0);
+        this._inputTypeStack.push((0, import_graphql.isInputType)(argType) ? argType : void 0);
+        break;
+      }
+      case import_graphql.Kind.LIST: {
+        const listType = (0, import_graphql.getNullableType)(this.getInputType());
+        const itemType = (0, import_graphql.isListType)(listType) ? listType.ofType : listType;
+        this._defaultValueStack.push(void 0);
+        this._inputTypeStack.push((0, import_graphql.isInputType)(itemType) ? itemType : void 0);
+        break;
+      }
+      case import_graphql.Kind.OBJECT_FIELD: {
+        const objectType = (0, import_graphql.getNamedType)(this.getInputType());
+        let inputFieldType;
+        let inputField;
+        if ((0, import_graphql.isInputObjectType)(objectType)) {
+          inputField = objectType.getFields()[node.name.value];
+          if (inputField != null) {
+            inputFieldType = inputField.type;
+          }
+        }
+        this._defaultValueStack.push(
+          inputField ? inputField.defaultValue : void 0
+        );
+        this._inputTypeStack.push(
+          (0, import_graphql.isInputType)(inputFieldType) ? inputFieldType : void 0
+        );
+        break;
+      }
+      case import_graphql.Kind.ENUM: {
+        const enumType = (0, import_graphql.getNamedType)(this.getInputType());
+        let enumValue;
+        if ((0, import_graphql.isEnumType)(enumType)) {
+          enumValue = enumType.getValue(node.value);
+        }
+        this._enumValue = enumValue;
+        break;
+      }
+      default:
+    }
+  }
+  leave(node) {
+    switch (node.kind) {
+      case import_graphql.Kind.SELECTION_SET:
+        this._parentTypeStack.pop();
+        break;
+      case import_graphql.Kind.FIELD:
+        this._fieldDefStack.pop();
+        this._typeStack.pop();
+        break;
+      case import_graphql.Kind.DIRECTIVE:
+        this._directive = null;
+        this._isInIgnoredDirective = false;
+        break;
+      case import_graphql.Kind.OPERATION_DEFINITION:
+      case import_graphql.Kind.INLINE_FRAGMENT:
+      case import_graphql.Kind.FRAGMENT_DEFINITION:
+        this._typeStack.pop();
+        break;
+      case import_graphql.Kind.VARIABLE_DEFINITION:
+        this._inputTypeStack.pop();
+        break;
+      case import_graphql.Kind.ARGUMENT:
+        this._argument = null;
+        this._defaultValueStack.pop();
+        this._inputTypeStack.pop();
+        break;
+      case import_graphql.Kind.LIST:
+      case import_graphql.Kind.OBJECT_FIELD:
+        this._defaultValueStack.pop();
+        this._inputTypeStack.pop();
+        break;
+      case import_graphql.Kind.ENUM:
+        this._enumValue = null;
+        break;
+      default:
+    }
+  }
+}
+function getFieldDef(schema, parentType, fieldNode) {
+  return schema.getField(parentType, fieldNode.name.value);
+}
+function visitWithTypeInfo(typeInfo, visitor) {
+  return {
+    enter(...args) {
+      const node = args[0];
+      typeInfo.enter(node);
+      const fn = (0, import_graphql.getEnterLeaveForKind)(visitor, node.kind).enter;
+      if (fn) {
+        const result = fn.apply(visitor, args);
+        if (result !== void 0) {
+          typeInfo.leave(node);
+          if (TypelessAST.isNode(result)) {
+            typeInfo.enter(result);
+          }
+        }
+        return result;
+      }
+    },
+    leave(...args) {
+      const node = args[0];
+      const fn = (0, import_graphql.getEnterLeaveForKind)(visitor, node.kind).leave;
+      let result;
+      if (fn) {
+        result = fn.apply(visitor, args);
+      }
+      typeInfo.leave(node);
+      return result;
+    }
+  };
+}
+function at(arr, index) {
+  const len = arr.length;
+  const relativeIndex = index >= 0 ? index : len + index;
+  if (relativeIndex < 0 || relativeIndex >= len) {
+    return void 0;
+  }
+  return arr[relativeIndex];
+}