@graphql-tools/schema

Functions

• addResolversToSchema()
• assertResolversPresent()
• chainResolvers()
• checkForResolveTypeResolver()
• extendResolversFromInterfaces()
• makeExecutableSchema()
• mergeSchemas()

Interfaces

• GraphQLSchemaWithContext
• IExecutableSchemaDefinition

  • inheritResolversFromInterfaces
  • resolvers
  • resolverValidationOptions
  • schemaExtensions
  • typeDefs
  • updateResolversInPlace

Type Aliases

• MergeSchemasConfig

function addResolversToSchema

addResolversToSchema: ({
    schema,
    resolvers: inputResolvers,
    defaultFieldResolver,
    resolverValidationOptions,
    inheritResolversFromInterfaces,
    updateResolversInPlace,
}: IAddResolversToSchemaOptions) => GraphQLSchema;

function assertResolversPresent

assertResolversPresent: (
    schema: GraphQLSchema,
    resolverValidationOptions?: IResolverValidationOptions
) => void;

function chainResolvers

chainResolvers: <TArgs extends { [argName: string]: any }>(
    resolvers: Array<Maybe<GraphQLFieldResolver<any, any, TArgs>>>
) => (root: any, args: TArgs, ctx: any, info: GraphQLResolveInfo) => any;

function checkForResolveTypeResolver

checkForResolveTypeResolver: (
    schema: GraphQLSchema,
    requireResolversForResolveType?: ValidatorBehavior
) => void;

function extendResolversFromInterfaces

extendResolversFromInterfaces: (
    schema: GraphQLSchema,
    resolvers: IResolvers
) => IResolvers;

function makeExecutableSchema

makeExecutableSchema: <TContext = any>({
    typeDefs,
    resolvers,
    resolverValidationOptions,
    inheritResolversFromInterfaces,
    updateResolversInPlace,
    schemaExtensions,
    ...otherOptions
}: IExecutableSchemaDefinition<TContext>) => GraphQLSchema;

• Builds a schema from the provided type definitions and resolvers.

  The type definitions are written using Schema Definition Language (SDL). They can be provided as a string, a DocumentNode, a function, or an array of any of these. If a function is provided, it will be passed no arguments and should return an array of strings or DocumentNodes.

  Note: You can use GraphQL magic comment provide additional syntax highlighting in your editor (with the appropriate editor plugin).

  const typeDefs = /* GraphQL *\/ `
    type Query {
      posts: [Post]
      author(id: Int!): Author
    }
  `;

  The resolvers object should be a map of type names to nested object, which themselves map the type's fields to their appropriate resolvers. See the [Resolvers](/docs/resolvers) section of the documentation for more details.

  const resolvers = {
    Query: {
      posts: (obj, args, ctx, info) => getAllPosts(),
      author: (obj, args, ctx, info) => getAuthorById(args.id)
    }
  };

  Once you've defined both the typeDefs and resolvers, you can create your schema:

  const schema = makeExecutableSchema({
    typeDefs,
    resolvers,
  })

function mergeSchemas

mergeSchemas: (config: MergeSchemasConfig) => GraphQLSchema;

• Synchronously merges multiple schemas, typeDefinitions and/or resolvers into a single schema.

  Parameter config

  Configuration object

type MergeSchemasConfig

type MergeSchemasConfig<T = any> = Partial<IExecutableSchemaDefinition<T>> & {
    /**
     * The schemas to be merged
     */
    schemas?: GraphQLSchema[];
};

• Configuration object for schema merging