Resolver
The most interesting class in graphql-compose. The main goal of Resolver is to keep available resolve methods for Type and use them for building relation with other types.
Properties
schemaComposer
schemaComposer: SchemaComposer<TContext>; type
type: ComposeOutputType<TContext>; args
args: ObjectTypeComposerArgumentConfigMap<any>; name
name: string; displayName
displayName: string | undefined; kind
kind: ResolverKinds | undefined; description
description: string | undefined; deprecationReason
deprecationReason: string | null | undefined; projection
projection: ProjectionType; parent
parent: Resolver<TSource, TContext, any> | undefined; extensions
extensions: Extensions | undefined; directives
directives: Directive[] | undefined; resolve
resolve: ResolverRpCbPartial<TSource, TContext, TArgs>; Output type methods
getType()
getType(): GraphQLOutputType getTypeName()
getTypeName(): string getTypeComposer()
getTypeComposer(): ComposeNamedOutputType<TContext> getOTC()
getOTC(): ObjectTypeComposer<TReturn, TContext> Almost alias for getTypeComposer, but returns only ObjectTypeComposer. It will throw an error if resolver has another kind of type.
setType()
setType<TNewReturn>( typeDef: ThunkWithSchemaComposer<Readonly<ComposeOutputType<TContext>> | ComposeOutputTypeDefinition<TContext> | Readonly<Resolver<any, TContext, any>>, SchemaComposer<TContext>> ): Resolver<TSource, TContext, TArgs, TNewReturn> Args methods
hasArg()
hasArg( argName: string ): boolean getArg()
getArg( argName: string ): ObjectTypeComposerArgumentConfig getArgConfig()
getArgConfig( argName: string ): GraphQLArgumentConfig getArgType()
getArgType( argName: string ): GraphQLInputType getArgTypeName()
getArgTypeName( fieldName: string ): string getArgs()
getArgs(): ObjectTypeComposerArgumentConfigMap<TArgs> getArgNames()
getArgNames(): string[] setArgs()
setArgs<TNewArgs>( args: ObjectTypeComposerArgumentConfigMapDefinition<TNewArgs> ): Resolver<TSource, TContext, TNewArgs> setArg()
setArg( argName: string, argConfig: ObjectTypeComposerArgumentConfigDefinition ): this setArgType()
setArgType( argName: string, typeDef: Thunk<ComposeInputTypeDefinition> ): this extendArg()
extendArg( argName: string, partialArgConfig: Partial<ObjectTypeComposerArgumentConfigAsObjectDefinition> ): this addArgs()
addArgs( newArgs: ObjectTypeComposerArgumentConfigMapDefinition<any> ): this removeArg()
removeArg( argNameOrArray: string | string[] ): this removeOtherArgs()
removeOtherArgs( argNameOrArray: string | string[] ): this reorderArgs()
reorderArgs( names: string[] ): this getArgTC()
getArgTC( argName: string ): ComposeNamedInputType<TContext> getArgITC()
getArgITC( argName: string ): InputTypeComposer<TContext> Alias for getArgTC() but returns statically checked InputTypeComposer. If field have other type then error will be thrown.
isArgNonNull()
isArgNonNull( argName: string ): boolean makeArgNonNull()
makeArgNonNull( argNameOrArray: string | string[] ): this makeRequired()
makeRequired( argNameOrArray: string | string[] ): this makeArgNullable()
makeArgNullable( argNameOrArray: string | string[] ): this makeOptional()
makeOptional( argNameOrArray: string | string[] ): this isArgPlural()
isArgPlural( argName: string ): boolean makeArgPlural()
makeArgPlural( argNameOrArray: string | string[] ): this makeArgNonPlural()
makeArgNonPlural( argNameOrArray: string | string[] ): this cloneArg()
cloneArg( argName: string, newTypeName: string ): this addFilterArg()
addFilterArg( opts: ResolverFilterArgConfigDefinition<TSource, TContext, TArgs> ): this addSortArg()
addSortArg( opts: ResolverSortArgConfig<TSource, TContext, TArgs> ): this Resolve methods
getResolve()
getResolve(): ResolverRpCb<TSource, TContext, TArgs> setResolve()
setResolve( resolve: ResolverRpCb<TSource, TContext, TArgs> ): this Wrap methods
withMiddlewares()
withMiddlewares( middlewares: Array<ResolverMiddleware<TSource, TContext, TArgs>> ): Resolver<TSource, TContext, TArgs> You may construct a new resolver with wrapped logic:
const log = []; const mw1 = async (resolve, source, args, context, info) => { log.push('m1.before'); const res = await resolve(source, args, context, info); log.push('m1.after'); return res; }; const mw2 = async (resolve, source, args, context, info) => { log.push('m2.before'); const res = await resolve(source, args, context, info); log.push('m2.after'); return res; }; const newResolver = Resolver.withMiddlewares([mw1, mw2]); await newResolver.resolve({}); expect(log).toEqual([ 'm1.before', 'm2.before', 'call resolve', 'm2.after', 'm1.after' ]); wrap()
wrap<TNewSource, TNewArgs>( cb: ResolverWrapCb<TNewSource, TSource, TContext, TNewArgs, TArgs> | null, newResolverOpts: Partial<ResolverDefinition<TNewSource, TContext, TNewArgs>> ): Resolver<TNewSource, TContext, TNewArgs> wrapResolve()
wrapResolve( cb: ResolverNextRpCb<TSource, TContext, TArgs>, wrapperName: string ): Resolver<TSource, TContext, TArgs> wrapArgs()
wrapArgs<TNewArgs>( cb: (prevArgs: GraphQLFieldConfigArgumentMap) => ObjectTypeComposerArgumentConfigMapDefinition<TArgs>, wrapperName: string ): Resolver<TSource, TContext, TNewArgs> wrapCloneArg()
wrapCloneArg( argName: string, newTypeName: string ): Resolver<TSource, TContext, TArgs> wrapType()
wrapType( cb: (prevType: ComposeOutputType<TContext>) => ComposeOutputTypeDefinition<TContext>, wrapperName: string ): Resolver<TSource, TContext, TArgs> Misc methods
getFieldConfig()
getFieldConfig( opts: { projection?: ProjectionType; } ): GraphQLFieldConfig<TSource, TContext, TArgs> getFieldResolver()
getFieldResolver( opts: { projection?: ProjectionType; } ): GraphQLFieldResolver<TSource, TContext, TArgs> getKind()
getKind(): ResolverKinds | void setKind()
setKind( kind: string ): this getDescription()
getDescription(): string | undefined setDescription()
setDescription( description: string | undefined ): this getDeprecationReason()
getDeprecationReason(): string | undefined | null setDeprecationReason()
setDeprecationReason( reason: string | undefined ): this get()
get( path: string | string[] ): TypeInPath<TContext> | void clone()
clone<TNewSource, TNewArgs>( opts: Partial<ResolverDefinition<TNewSource, TContext, TNewArgs>> ): Resolver<TNewSource, TContext, TNewArgs> Clone this Resolver with overriding of some options. Internally it just copies all properties. But for args and projection it recreates objects with the same type & values (it allows to add or remove properties without affection old Resolver).
cloneTo()
cloneTo( anotherSchemaComposer: SchemaComposer<any>, cloneMap: Map<any, any> ): Resolver<any, any, any> Clone this resolver to another SchemaComposer. Also will be cloned all sub-types.
Extensions methods
getExtensions()
getExtensions(): Extensions setExtensions()
setExtensions( extensions: Extensions ): this extendExtensions()
extendExtensions( extensions: Extensions ): this clearExtensions()
clearExtensions(): this getExtension()
getExtension( extensionName: string ): unknown hasExtension()
hasExtension( extensionName: string ): boolean setExtension()
setExtension( extensionName: string, value: unknown ): this removeExtension()
removeExtension( extensionName: string ): this Debug methods
getNestedName()
getNestedName(): string toString()
toString(): string setDisplayName()
setDisplayName( name: string ): this toDebugStructure()
toDebugStructure(): Record<string, any> debugExecTime()
debugExecTime(): Resolver<TSource, TContext, TArgs> debugParams()
debugParams( filterPaths: string | string[] | undefined | null, opts: ResolverDebugOpts ): Resolver<TSource, TContext, TArgs> debugPayload()
debugPayload( filterPaths: string | string[] | undefined | null, opts: ResolverDebugOpts ): Resolver<TSource, TContext, TArgs> debug()
debug( filterDotPaths: { params?: string | string[] | undefined | null; payload?: string | string[] | undefined | null; }, opts: ResolverDebugOpts ): Resolver<TSource, TContext, TArgs> Internal type definitions
ResolverKinds
export type ResolverKinds = 'query' | 'mutation' | 'subscription'; ResolverDefinition
export type ResolverDefinition<TSource, TContext, TArgs = any> = { type?: ThunkWithSchemaComposer< | Readonly<ComposeOutputType<TContext>> | ComposeOutputTypeDefinition<TContext> | Readonly<Resolver<any, TContext, any>>, SchemaComposer<TContext> >; resolve?: ResolverRpCb<TSource, TContext, TArgs>; args?: ObjectTypeComposerArgumentConfigMapDefinition<TArgs>; name?: string; displayName?: string; kind?: ResolverKinds; description?: string; deprecationReason?: string | null; projection?: ProjectionType; parent?: Resolver<any, TContext, any>; extensions?: Extensions; directives?: Directive[]; }; ResolverResolveParams
export type ResolverResolveParams<TSource, TContext, TArgs = any> = { source: TSource; args: TArgs; context: TContext; info: GraphQLResolveInfo; projection: Partial<ProjectionType>; [opt: string]: any; }; ResolverFilterArgFn
export type ResolverFilterArgFn<TSource, TContext, TArgs = any> = ( query: any, value: any, resolveParams: ResolverResolveParams<TSource, TContext, TArgs> ) => any; ResolverFilterArgConfigDefinition
export type ResolverFilterArgConfigDefinition<TSource, TContext, TArgs = any> = { name: string; type: ComposeInputTypeDefinition; description?: string | null | void; query?: ResolverFilterArgFn<TSource, TContext, TArgs>; filterTypeNameFallback?: string; defaultValue?: any; }; ResolverSortArgFn
export type ResolverSortArgFn<TSource, TContext, TArgs = any> = ( resolveParams: ResolverResolveParams<TSource, TContext, TArgs> ) => any; ResolverSortArgConfig
export type ResolverSortArgConfig<TSource, TContext, TArgs = any> = { name: string; sortTypeNameFallback?: string; value: | { [key: string]: any } | ResolverSortArgFn<TSource, TContext, TArgs> | string | number | boolean | any[]; deprecationReason?: string | null; description?: string | null; }; ResolverWrapCb
export type ResolverWrapCb<TNewSource, TPrevSource, TContext, TNewArgs = any, TPrevArgs = any> = ( newResolver: Resolver<TNewSource, TContext, TNewArgs>, prevResolver: Resolver<TPrevSource, TContext, TPrevArgs> ) => Resolver<TNewSource, TContext, TNewArgs>; ResolverRpCb
export type ResolverRpCb<TSource, TContext, TArgs = any> = ( resolveParams: ResolverResolveParams<TSource, TContext, TArgs> ) => Promise<any> | any; ResolverRpCbPartial
export type ResolverRpCbPartial<TSource, TContext, TArgs = any> = ( resolveParams: Partial<ResolverResolveParams<TSource, TContext, TArgs>> ) => Promise<any> | any; ResolverNextRpCb
export type ResolverNextRpCb<TSource, TContext, TArgs = any> = ( next: ResolverRpCb<TSource, TContext, TArgs> ) => ResolverRpCb<TSource, TContext, TArgs>; ResolverDebugOpts
export type ResolverDebugOpts = { showHidden?: boolean; depth?: number; colors?: boolean; }; ResolverMiddleware
export type ResolverMiddleware<TSource, TContext, TArgs = any> = ( resolve: (source: TSource, args: TArgs, context: TContext, info: GraphQLResolveInfo) => any, source: TSource, args: TArgs, context: TContext, info: GraphQLResolveInfo ) => any;