SchemaComposer
SchemaComposer is a class which helps to create GraphQLSchema.
Getters
Query
Query: ObjectTypeComposer<any, TContext>; Returns ObjectTypeComposer of Query root type.
import { schemaComposer } from 'graphql-compose'; schemaComposer.Query.addFields({ field1: 'String' }); Mutation
Mutation: ObjectTypeComposer<any, TContext>; Returns ObjectTypeComposer of Mutation root type.
import { schemaComposer } from 'graphql-compose'; schemaComposer.Mutation.addFields({ field1: 'String' }); Subscription
Subscription: ObjectTypeComposer<any, TContext>; Returns ObjectTypeComposer of Subscription root type.
import { schemaComposer } from 'graphql-compose'; schemaComposer.Subscription.addFields({ field1: 'String' }); Properties
typeMapper
typeMapper: TypeMapper<TContext>; Methods
buildSchema()
buildSchema( extraConfig: ExtraSchemaConfig ): GraphQLSchema Create GraphQLSchema instance from defined types. This instance can be provided to express-graphql, apollo-server, graphql-yoga etc.
addSchemaMustHaveType()
addSchemaMustHaveType( type: AnyType<TContext> ): this When using Interfaces you may have such Types which are hidden under Interface.resolveType method. In such cases you should add these types explicitly. Cause buildSchema() will take only real used types and types which added via addSchemaMustHaveType() method.
removeEmptyTypes()
removeEmptyTypes( tc: ObjectTypeComposer<any, TContext>, passedTypes: Set<string> ): void Deeply traverse fields in Query, Mutation, Subscription & sub-objects where will be removed all fields with empty object types (without sub-fields).
clone()
clone(): SchemaComposer<any> Clone schema with deep cloning of all its types. Except Scalar types which will be the same for both schemas.
merge()
merge( schema: GraphQLSchema | SchemaComposer<any> ): this Load all types from GraphQLSchema and merge with current SchemaComposer's types.
import { schemaComposer } from 'graphql-compose'; schemaComposer.merge(someSchema1); schemaComposer.merge(someSchema2); schemaComposer.merge(someSchema3); schemaComposer.getOTC('User').removeField('password'); const newSchema = schemaComposer.buildSchema(); getDescription()
getDescription(): string | undefined setDescription()
setDescription( description: string | undefined ): this Like graphql-tools methods
addTypeDefs()
addTypeDefs( typeDefs: string ): TypeStorage<string, NamedTypeComposer<any>> Add types to Schema via SDL string. Returns a Map of parsed types.
const schemaComposer = new SchemaComposer(); schemaComposer.addTypeDefs(` type Post { id: Int! title: String votes: Int } enum Sort { ASC DESC } `); After that your added types will be available for referencing via string, eg.
ObjectTypeComposer.create({ name: 'Author', fields: { posts: { type: '[Post!]', args: { sort: 'Sort' }, resolve: () => {} } } }); addResolveMethods()
addResolveMethods( typesFieldsResolve: GraphQLToolsResolveMethods<TContext> ): void Define resolve methods for Types in graphql-tools manner.
declare function addResolveMethods(typesFieldsResolve: { [typeName: string]: { [fieldName: string]: ( source: any, args: Object, context: TContext, info: GraphQLResolveInfo ) => any; }; }): void; More details can be found in issue #142.
Type methods
createObjectTC()
createObjectTC<TSource = any>( typeDef: ObjectTypeComposerDefinition<TSource, TContext> ): ObjectTypeComposer<TSource, TContext> createInputTC()
createInputTC( typeDef: InputTypeComposerDefinition ): InputTypeComposer<TContext> createEnumTC()
createEnumTC( typeDef: EnumTypeComposerDefinition ): EnumTypeComposer<TContext> createInterfaceTC()
createInterfaceTC<TSource = any>( typeDef: InterfaceTypeComposerDefinition<TSource, TContext> ): InterfaceTypeComposer<TSource, TContext> createUnionTC()
createUnionTC<TSource = any>( typeDef: UnionTypeComposerDefinition<TSource, TContext> ): UnionTypeComposer<TSource, TContext> createScalarTC()
createScalarTC<TInternal = any, TExternal = any>( typeDef: ScalarTypeComposerDefinition<TInternal, TExternal> ): ScalarTypeComposer<TContext> createResolver()
createResolver<TSource = any, TArgs = any>( opts: ResolverDefinition<TSource, TContext, TArgs> ): Resolver<any, TContext> createTC()
createTC( typeOrSDL: ComposeOutputTypeDefinition<any> | ComposeInputTypeDefinition ): NamedTypeComposer<TContext> Creates or return existed TypeComposer from SDL or object. If you call this method again with same params should be returned the same TypeComposer instance.
createTempTC()
createTempTC( typeOrSDL: ComposeOutputTypeDefinition<any> | ComposeInputTypeDefinition ): NamedTypeComposer<TContext> Creates TypeComposer from SDL or object without adding it to the type storage.
getOrCreateTC()
getOrCreateTC( typeName: string, onCreate: (tc: ObjectTypeComposer<any, TContext>) => any ): ObjectTypeComposer<any, TContext> getOrCreateOTC()
getOrCreateOTC( typeName: string, onCreate: (tc: ObjectTypeComposer<any, TContext>) => any ): ObjectTypeComposer<any, TContext> getOrCreateITC()
getOrCreateITC( typeName: string, onCreate: (tc: InputTypeComposer<TContext>) => any ): InputTypeComposer<TContext> getOrCreateETC()
getOrCreateETC( typeName: string, onCreate: (tc: EnumTypeComposer<TContext>) => any ): EnumTypeComposer<TContext> getOrCreateIFTC()
getOrCreateIFTC( typeName: string, onCreate: (tc: InterfaceTypeComposer<any, TContext>) => any ): InterfaceTypeComposer<any, TContext> getOrCreateUTC()
getOrCreateUTC( typeName: string, onCreate: (tc: UnionTypeComposer<any, TContext>) => any ): UnionTypeComposer<any, TContext> getOrCreateSTC()
getOrCreateSTC( typeName: string, onCreate: (tc: ScalarTypeComposer<TContext>) => any ): ScalarTypeComposer<TContext> getOTC()
getOTC( typeName: unknown ): ObjectTypeComposer<any, TContext> getITC()
getITC( typeName: unknown ): InputTypeComposer<TContext> getETC()
getETC( typeName: unknown ): EnumTypeComposer<TContext> getIFTC()
getIFTC( typeName: unknown ): InterfaceTypeComposer<any, TContext> getUTC()
getUTC( typeName: unknown ): UnionTypeComposer<any, TContext> getSTC()
getSTC( typeName: unknown ): ScalarTypeComposer<TContext> getAnyTC()
getAnyTC( typeOrName: string | AnyType<any> | GraphQLType ): NamedTypeComposer<TContext> addAsComposer()
addAsComposer( typeOrSDL: ComposeOutputTypeDefinition<any> | ComposeInputTypeDefinition ): string isObjectType()
isObjectType( type: string | AnyType<any> | GraphQLType ): boolean isInputObjectType()
isInputObjectType( type: string | AnyType<any> | GraphQLType ): boolean isScalarType()
isScalarType( type: string | AnyType<any> | GraphQLType ): boolean isEnumType()
isEnumType( type: string | AnyType<any> | GraphQLType ): boolean isInterfaceType()
isInterfaceType( type: string | AnyType<any> | GraphQLType ): boolean isUnionType()
isUnionType( type: string | AnyType<any> | GraphQLType ): boolean Storage methods
clear()
clear(): void add()
add( typeOrSDL: ComposeOutputTypeDefinition<any> | ComposeInputTypeDefinition ): string set()
set( key: unknown, value: NamedTypeComposer<TContext> ): this Directive methods
addDirective()
addDirective( directive: GraphQLDirective ): this removeDirective()
removeDirective( directive: GraphQLDirective ): this getDirectives()
getDirectives(): Array<GraphQLDirective> getDirective()
getDirective( name: string ): GraphQLDirective hasDirective()
hasDirective( directive: string | GraphQLDirective ): boolean Misc methods
toString()
toString(): string Returns a string representation of an object.
toJSON()
toJSON(): string inspect()
inspect(): string getTypeSDL()
getTypeSDL( typeName: string, opts: SchemaPrinterOptions & { deep?: boolean; exclude?: string[]; } ): string Prints SDL for any type in schema by its name.
Can print all used sub-types if provided deep: true option. Also you may omit some sub-types via exclude: string[] option.
toSDL()
toSDL( options: SchemaComposerPrinterOptions ): string Return schema as a SDL string. This SDL can be used with graphql-tools and Apollo Federation.
getResolveMethods()
getResolveMethods( opts: { exclude?: string[] | null; } ): GraphQLToolsResolveMethods<TContext> Returns a map of resolvers for each relevant GraphQL Object Type.
This map of Resolvers can be used with graphql-tools and Apollo Federation.
Internal type definitions
ExtraSchemaConfig
type ExtraSchemaConfig = { description?: string | null; types?: GraphQLNamedType[] | null; directives?: GraphQLDirective[] | null; extensions?: any | null; astNode?: SchemaDefinitionNode | null; extensionASTNodes?: ReadonlyArray<SchemaExtensionNode> | null; /** You may pass all unused types from type registry to GraphQL schema if set this option to `true` */ keepUnusedTypes?: boolean | null; }; GraphQLToolsResolveMethods
export type GraphQLToolsResolveMethods<TContext> = { [typeName: string]: | { [fieldName: string]: | (( source: any, args: Record<string, any>, context: TContext, info: GraphQLResolveInfo ) => any) | string | number | Record<string, any>; } | GraphQLNamedType | GraphQLScalarTypeConfig<any, any>; };