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.
186 lines
6.1 KiB
186 lines
6.1 KiB
4 months ago
|
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>>;
|