import { devAssert } from './jsutils/devAssert' ; import { isPromise } from './jsutils/isPromise' ; import type { Maybe } from './jsutils/Maybe' ; import type { PromiseOrValue } from './jsutils/PromiseOrValue' ; import { parse } from './language/parser' ; import type { Source } from './language/source' ; import type { GraphQLFieldResolver , GraphQLTypeResolver , } from './type/definition' ; import type { GraphQLSchema } from './type/schema' ; import { validateSchema } from './type/validate' ; import { validate } from './validation/validate' ; import type { ExecutionResult } from './execution/execute' ; import { execute } from './execution/execute' ; /**
 * This is the primary entry point function for fulfilling GraphQL operations
 * by parsing, validating, and executing a GraphQL document along side a
 * GraphQL schema.
 *
 * More sophisticated GraphQL servers, such as those which persist queries,
 * may wish to separate the validation and execution phases to a static time
 * tooling step, and a server runtime step.
 *
 * Accepts either an object with named arguments, or individual arguments:
 *
 * schema:
 *    The GraphQL type system to use when validating and executing a query.
 * source:
 *    A GraphQL language formatted string representing the requested operation.
 * rootValue:
 *    The value provided as the first argument to resolver functions on the top
 *    level type (e.g. the query object type).
 * contextValue:
 *    The context value is provided as an argument to resolver functions after
 *    field arguments. It is used to pass shared information useful at any point
 *    during executing this query, for example the currently logged in user and
 *    connections to databases or other services.
 * variableValues:
 *    A mapping of variable name to runtime value to use for all variables
 *    defined in the requestString.
 * operationName:
 *    The name of the operation to use if requestString contains multiple
 *    possible operations. Can be omitted if requestString contains only
 *    one operation.
 * fieldResolver:
 *    A resolver function to use when one is not provided by the schema.
 *    If not provided, the default field resolver is used (which looks for a
 *    value or method on the source value with the field's name).
 * typeResolver:
 *    A type resolver function to use when none is provided by the schema.
 *    If not provided, the default type resolver is used (which looks for a
 *    `__typename` field or alternatively calls the `isTypeOf` method).
 */ export interface GraphQLArgs { schema : GraphQLSchema ; source : string | Source ; rootValue ? : unknown ; contextValue ? : unknown ; variableValues ? : Maybe < { readonly [ variable ] : unknown ; } > ; operationName ? : Maybe < string > ; fieldResolver ? : Maybe < GraphQLFieldResolver < any , any > > ; typeResolver ? : Maybe < GraphQLTypeResolver < any , any > > ; } export function graphql ( args ) { return new Promise ( ( resolve ) => resolve ( graphqlImpl ( args ) ) ) ; } /**
 * The graphqlSync function also fulfills GraphQL operations by parsing,
 * validating, and executing a GraphQL document along side a GraphQL schema.
 * However, it guarantees to complete synchronously (or throw an error) assuming
 * that all field resolvers are also synchronous.
 */ export function graphqlSync ( args ) { const result = graphqlImpl ( args ) ; if ( isPromise ( result ) ) { throw new Error ( 'GraphQL execution failed to complete synchronously.' ) ; } return result ; } function graphqlImpl ( args ) { devAssert ( arguments . length < 2 , 'graphql@16 dropped long-deprecated support for positional arguments, please pass an object instead.' ) ; const { schema , source , rootValue , contextValue , variableValues , operationName , fieldResolver , typeResolver , } = args ; const schemaValidationErrors = validateSchema ( schema ) ; if ( schemaValidationErrors . length > 0 ) { return { errors : schemaValidationErrors } ; } let document ; try { document = parse ( source ) ; } catch ( syntaxError ) { return { errors : [ syntaxError ] } ; } const validationErrors = validate ( schema , document ) ; if ( validationErrors . length > 0 ) { return { errors : validationErrors } ; } return execute ( { schema , document , rootValue , contextValue , variableValues , operationName , fieldResolver , typeResolver , } ) ; }