Neatly Prepared Mustache

    This package has been deprecated

    Author message:

    graphql-tools-fork has been merged into upstream graphql-tools@5

    TypeScript icon, indicating that this package has built-in type declarations

    9.0.1 • Public • Published

    graphql-tools-fork: keep on stitching

    npm version Build Status Coverage Status

    This fork will hopefully provide more and more timely engagement with the community as we continue to support the following use cases, with the notable inclusion of schema stitching:

    1. Use the GraphQL schema language to generate a schema with full support for resolvers, interfaces, unions, and custom scalars. The schema produced is completely compatible with GraphQL.js.
    2. Mock your GraphQL API with fine-grained per-type mocking
    3. Automatically stitch multiple schemas together into one larger API


    Read the forked docs.

    See the changelog for recent changes:

    Read the original docs.

    Binding to HTTP

    If you want to bind your JavaScript GraphQL schema to an HTTP server, we recommend using Apollo Server, which supports every popular Node HTTP server library including Express, Koa, Hapi, and more.

    JavaScript GraphQL servers are often developed with graphql-tools and apollo-server-express together: One to write the schema and resolver code, and the other to connect it to a web server.


    When using graphql-tools, you describe the schema as a GraphQL type language string:

    const typeDefs = `
    type Author {
      id: ID! # the ! means that every author object _must_ have an id
      firstName: String
      lastName: String
      the list of Posts by this author
      posts: [Post]
    type Post {
      id: ID!
      title: String
      author: Author
      votes: Int
    # the schema allows the following query:
    type Query {
      posts: [Post]
    # this schema allows the following mutation:
    type Mutation {
      upvotePost (
        postId: ID!
      ): Post
    # we need to tell the server which types represent the root query
    # and root mutation types. We call them RootQuery and RootMutation by convention.
    schema {
      query: Query
      mutation: Mutation
    export default typeDefs;

    Then you define resolvers as a nested object that maps type and field names to resolver functions:

    const resolvers = {
      Query: {
        posts() {
          return posts;
      Mutation: {
        upvotePost(_, { postId }) {
          const post = find(posts, { id: postId });
          if (!post) {
            throw new Error(`Couldn't find post with id ${postId}`);
          post.votes += 1;
          return post;
      Author: {
        posts(author) {
          return filter(posts, { authorId: });
      Post: {
        author(post) {
          return find(authors, { id: post.authorId });
    export default resolvers;

    At the end, the schema and resolvers are combined using makeExecutableSchema:

    import { makeExecutableSchema } from 'graphql-tools';
    const executableSchema = makeExecutableSchema({

    This example has the entire type definition in one string and all resolvers in one file, but you can combine types and resolvers from multiple files and objects, as documented in the modularizing the schema section of the docs.


    Contributions, issues and feature requests are very welcome. If you are using this package and fixed a bug for yourself, please consider submitting a PR!



    npm i graphql-tools-fork

    DownloadsWeekly Downloads






    Unpacked Size

    1.02 MB

    Total Files


    Last publish


    • yaacovcr