@graphql-tools/delegate

What is @graphql-tools/delegate?

@graphql-tools/delegate is a package that provides utilities for schema delegation in GraphQL. It allows you to delegate execution of a query to a different schema, enabling schema stitching, remote schema execution, and more.

What are @graphql-tools/delegate's main functionalities?

Schema Delegation

This feature allows you to delegate a query to another schema. In this example, a simple schema is created and a query is delegated to it, returning 'Hello world!'.

const { delegateToSchema } = require('@graphql-tools/delegate');
const { makeExecutableSchema } = require('@graphql-tools/schema');

const schema = makeExecutableSchema({
  typeDefs: `
    type Query {
      hello: String
    }
  `,
  resolvers: {
    Query: {
      hello: () => 'Hello world!'
    }
  }
});

const result = await delegateToSchema({
  schema,
  operation: 'query',
  fieldName: 'hello',
  context: {},
  info: {}
});

console.log(result); // Outputs: Hello world!

Remote Schema Execution

This feature allows you to execute queries against a remote schema. In this example, a remote schema is made executable and a query is delegated to it.

const { makeRemoteExecutableSchema } = require('@graphql-tools/wrap');
const { HttpLink } = require('apollo-link-http');
const fetch = require('node-fetch');

const link = new HttpLink({ uri: 'http://remote-graphql-server.com/graphql', fetch });
const schema = makeRemoteExecutableSchema({ link });

const result = await delegateToSchema({
  schema,
  operation: 'query',
  fieldName: 'remoteField',
  context: {},
  info: {}
});

console.log(result);

Schema Stitching

This feature allows you to stitch multiple schemas together into a single schema. In this example, two schemas are stitched together and queries are delegated to each of them.

const { stitchSchemas } = require('@graphql-tools/stitch');

const schemaA = makeExecutableSchema({
  typeDefs: `
    type Query {
      fieldA: String
    }
  `,
  resolvers: {
    Query: {
      fieldA: () => 'Field A'
    }
  }
});

const schemaB = makeExecutableSchema({
  typeDefs: `
    type Query {
      fieldB: String
    }
  `,
  resolvers: {
    Query: {
      fieldB: () => 'Field B'
    }
  }
});

const stitchedSchema = stitchSchemas({
  subschemas: [
    { schema: schemaA },
    { schema: schemaB }
  ]
});

const resultA = await delegateToSchema({
  schema: stitchedSchema,
  operation: 'query',
  fieldName: 'fieldA',
  context: {},
  info: {}
});

const resultB = await delegateToSchema({
  schema: stitchedSchema,
  operation: 'query',
  fieldName: 'fieldB',
  context: {},
  info: {}
});

console.log(resultA); // Outputs: Field A
console.log(resultB); // Outputs: Field B

Other packages similar to @graphql-tools/delegate

apollo-server

Apollo Server is a community-maintained open-source GraphQL server that works with any GraphQL schema. It provides a straightforward setup for creating a GraphQL server and supports schema stitching and remote schema execution, similar to @graphql-tools/delegate.

graphql-yoga

GraphQL Yoga is a fully-featured GraphQL server with focus on easy setup, performance, and great developer experience. It supports schema stitching and remote schema execution, making it comparable to @graphql-tools/delegate.

graphql-tools

GraphQL Tools is a set of utilities to build and maintain GraphQL schemas and resolvers. It includes schema stitching and delegation capabilities, similar to @graphql-tools/delegate.

README

Check API Reference for more information about this package; https://www.graphql-tools.com/docs/api/modules/delegate_src

You can also learn more about Schema Delegation in this chapter; https://www.graphql-tools.com/docs/schema-delegation