123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186
import Maybe from '../tsutils/Maybe.d.ts';import { PromiseOrValue } from '../jsutils/PromiseOrValue.d.ts';import { Path } from '../jsutils/Path.d.ts';
import { GraphQLError } from '../error/GraphQLError.d.ts';
import {  DocumentNode,  OperationDefinitionNode,  SelectionSetNode,  FieldNode,  FragmentDefinitionNode,} from '../language/ast.d.ts';import { GraphQLSchema } from '../type/schema.d.ts';import {  GraphQLField,  GraphQLFieldResolver,  GraphQLResolveInfo,  GraphQLTypeResolver,  GraphQLObjectType,} from '../type/definition.d.ts';
/** * Data that must be available at all points during query execution. * * Namely, schema of the type system that is currently executing, * and the fragments defined in the query document */export interface ExecutionContext {  schema: GraphQLSchema;  fragments: { [key: string]: FragmentDefinitionNode };  rootValue: any;  contextValue: any;  operation: OperationDefinitionNode;  variableValues: { [key: string]: any };  fieldResolver: GraphQLFieldResolver<any, any>;  errors: Array<GraphQLError>;}
/** * The result of GraphQL execution. * *   - `errors` is included when any errors occurred as a non-empty array. *   - `data` is the result of a successful execution of the query. */export interface ExecutionResult {  errors?: ReadonlyArray<GraphQLError>;  data?: { [key: string]: any } | null;}
export type ExecutionArgs = {  schema: GraphQLSchema;  document: DocumentNode;  rootValue?: any;  contextValue?: any;  variableValues?: Maybe<{ [key: string]: any }>;  operationName?: Maybe<string>;  fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;  typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;};
/** * Implements the "Evaluating requests" section of the GraphQL specification. * * Returns either a synchronous ExecutionResult (if all encountered resolvers * are synchronous), or a Promise of an ExecutionResult that will eventually be * resolved and never rejected. * * If the arguments to this function do not result in a legal execution context, * a GraphQLError will be thrown immediately explaining the invalid input. * * Accepts either an object with named arguments, or individual arguments. */export function execute(args: ExecutionArgs): PromiseOrValue<ExecutionResult>;export function execute(  schema: GraphQLSchema,  document: DocumentNode,  rootValue?: any,  contextValue?: any,  variableValues?: Maybe<{ [key: string]: any }>,  operationName?: Maybe<string>,  fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>,  typeResolver?: Maybe<GraphQLTypeResolver<any, any>>,): PromiseOrValue<ExecutionResult>;
/** * Essential assertions before executing to provide developer feedback for * improper use of the GraphQL library. */export function assertValidExecutionArguments(  schema: GraphQLSchema,  document: DocumentNode,  rawVariableValues: Maybe<{ [key: string]: any }>,): void;
/** * Constructs a ExecutionContext object from the arguments passed to * execute, which we will pass throughout the other execution methods. * * Throws a GraphQLError if a valid execution context cannot be created. */export function buildExecutionContext(  schema: GraphQLSchema,  document: DocumentNode,  rootValue: any,  contextValue: any,  rawVariableValues: Maybe<{ [key: string]: any }>,  operationName: Maybe<string>,  fieldResolver: Maybe<GraphQLFieldResolver<any, any>>,  typeResolver?: Maybe<GraphQLTypeResolver<any, any>>,): ReadonlyArray<GraphQLError> | ExecutionContext;
/** * Given a selectionSet, adds all of the fields in that selection to * the passed in map of fields, and returns it at the end. * * CollectFields requires the "runtime type" of an object. For a field which * returns an Interface or Union type, the "runtime type" will be the actual * Object type returned by that field. */export function collectFields(  exeContext: ExecutionContext,  runtimeType: GraphQLObjectType,  selectionSet: SelectionSetNode,  fields: { [key: string]: Array<FieldNode> },  visitedFragmentNames: { [key: string]: boolean },): { [key: string]: Array<FieldNode> };
export function buildResolveInfo(  exeContext: ExecutionContext,  fieldDef: GraphQLField<any, any>,  fieldNodes: ReadonlyArray<FieldNode>,  parentType: GraphQLObjectType,  path: Path,): GraphQLResolveInfo;
/** * Isolates the "ReturnOrAbrupt" behavior to not de-opt the `resolveField` * function. Returns the result of resolveFn or the abrupt-return Error object. * * @internal */export function resolveFieldValueOrError(  exeContext: ExecutionContext,  fieldDef: GraphQLField<any, any>,  fieldNodes: ReadonlyArray<FieldNode>,  resolveFn: GraphQLFieldResolver<any, any>,  source: any,  info: GraphQLResolveInfo,): Error | any;
/** * If a resolveType function is not given, then a default resolve behavior is * used which attempts two strategies: * * First, See if the provided value has a `__typename` field defined, if so, use * that value as name of the resolved type. * * Otherwise, test each possible type for the abstract type by calling * isTypeOf for the object being coerced, returning the first type that matches. */export const defaultTypeResolver: GraphQLTypeResolver<any, any>;
/** * If a resolve function is not given, then a default resolve behavior is used * which takes the property of the source object of the same name as the field * and returns it as the result, or if it's a function, returns the result * of calling that function while passing along args and context. */export const defaultFieldResolver: GraphQLFieldResolver<any, any>;
/** * This method looks up the field on the given type definition. * It has special casing for the two introspection fields, __schema * and __typename. __typename is special because it can always be * queried as a field, even in situations where no other fields * are allowed, like on a Union. __schema could get automatically * added to the query type, but that would require mutating type * definitions, which would cause issues. */export function getFieldDef(  schema: GraphQLSchema,  parentType: GraphQLObjectType,  fieldName: string,): Maybe<GraphQLField<any, any>>;