You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
185 lines
6.1 KiB
185 lines
6.1 KiB
import type { Maybe } from '../jsutils/Maybe'; |
|
import type { ObjMap } from '../jsutils/ObjMap'; |
|
import type { Path } from '../jsutils/Path'; |
|
import type { PromiseOrValue } from '../jsutils/PromiseOrValue'; |
|
import type { GraphQLFormattedError } from '../error/GraphQLError'; |
|
import { GraphQLError } from '../error/GraphQLError'; |
|
import type { |
|
DocumentNode, |
|
FieldNode, |
|
FragmentDefinitionNode, |
|
OperationDefinitionNode, |
|
} from '../language/ast'; |
|
import type { |
|
GraphQLField, |
|
GraphQLFieldResolver, |
|
GraphQLObjectType, |
|
GraphQLResolveInfo, |
|
GraphQLTypeResolver, |
|
} from '../type/definition'; |
|
import type { GraphQLSchema } from '../type/schema'; |
|
/** |
|
* Terminology |
|
* |
|
* "Definitions" are the generic name for top-level statements in the document. |
|
* Examples of this include: |
|
* 1) Operations (such as a query) |
|
* 2) Fragments |
|
* |
|
* "Operations" are a generic name for requests in the document. |
|
* Examples of this include: |
|
* 1) query, |
|
* 2) mutation |
|
* |
|
* "Selections" are the definitions that can appear legally and at |
|
* single level of the query. These include: |
|
* 1) field references e.g `a` |
|
* 2) fragment "spreads" e.g. `...c` |
|
* 3) inline fragment "spreads" e.g. `...on Type { a }` |
|
*/ |
|
/** |
|
* 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: ObjMap<FragmentDefinitionNode>; |
|
rootValue: unknown; |
|
contextValue: unknown; |
|
operation: OperationDefinitionNode; |
|
variableValues: { |
|
[variable: string]: unknown; |
|
}; |
|
fieldResolver: GraphQLFieldResolver<any, any>; |
|
typeResolver: GraphQLTypeResolver<any, any>; |
|
subscribeFieldResolver: 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. |
|
* - `extensions` is reserved for adding non-standard properties. |
|
*/ |
|
export interface ExecutionResult< |
|
TData = ObjMap<unknown>, |
|
TExtensions = ObjMap<unknown>, |
|
> { |
|
errors?: ReadonlyArray<GraphQLError>; |
|
data?: TData | null; |
|
extensions?: TExtensions; |
|
} |
|
export interface FormattedExecutionResult< |
|
TData = ObjMap<unknown>, |
|
TExtensions = ObjMap<unknown>, |
|
> { |
|
errors?: ReadonlyArray<GraphQLFormattedError>; |
|
data?: TData | null; |
|
extensions?: TExtensions; |
|
} |
|
export interface ExecutionArgs { |
|
schema: GraphQLSchema; |
|
document: DocumentNode; |
|
rootValue?: unknown; |
|
contextValue?: unknown; |
|
variableValues?: Maybe<{ |
|
readonly [variable: string]: unknown; |
|
}>; |
|
operationName?: Maybe<string>; |
|
fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>; |
|
typeResolver?: Maybe<GraphQLTypeResolver<any, any>>; |
|
subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, any>>; |
|
} |
|
/** |
|
* Implements the "Executing 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. |
|
*/ |
|
export declare function execute( |
|
args: ExecutionArgs, |
|
): PromiseOrValue<ExecutionResult>; |
|
/** |
|
* Also implements the "Executing requests" section of the GraphQL specification. |
|
* However, it guarantees to complete synchronously (or throw an error) assuming |
|
* that all field resolvers are also synchronous. |
|
*/ |
|
export declare function executeSync(args: ExecutionArgs): ExecutionResult; |
|
/** |
|
* Essential assertions before executing to provide developer feedback for |
|
* improper use of the GraphQL library. |
|
* |
|
* @internal |
|
*/ |
|
export declare function assertValidExecutionArguments( |
|
schema: GraphQLSchema, |
|
document: DocumentNode, |
|
rawVariableValues: Maybe<{ |
|
readonly [variable: string]: unknown; |
|
}>, |
|
): 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. |
|
* |
|
* @internal |
|
*/ |
|
export declare function buildExecutionContext( |
|
args: ExecutionArgs, |
|
): ReadonlyArray<GraphQLError> | ExecutionContext; |
|
/** |
|
* @internal |
|
*/ |
|
export declare function buildResolveInfo( |
|
exeContext: ExecutionContext, |
|
fieldDef: GraphQLField<unknown, unknown>, |
|
fieldNodes: ReadonlyArray<FieldNode>, |
|
parentType: GraphQLObjectType, |
|
path: Path, |
|
): GraphQLResolveInfo; |
|
/** |
|
* 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 declare const defaultTypeResolver: GraphQLTypeResolver<unknown, unknown>; |
|
/** |
|
* 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 value. |
|
*/ |
|
export declare const defaultFieldResolver: GraphQLFieldResolver< |
|
unknown, |
|
unknown |
|
>; |
|
/** |
|
* This method looks up the field on the given type definition. |
|
* It has special casing for the three introspection fields, |
|
* __schema, __type 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 and __type |
|
* could get automatically added to the query type, but that would |
|
* require mutating type definitions, which would cause issues. |
|
* |
|
* @internal |
|
*/ |
|
export declare function getFieldDef( |
|
schema: GraphQLSchema, |
|
parentType: GraphQLObjectType, |
|
fieldNode: FieldNode, |
|
): Maybe<GraphQLField<unknown, unknown>>;
|
|
|