Introduction to GraphQL Modules

GraphQL Modules is a powerful tool for building flexible and scalable GraphQL APIs. It is designed to provide a modular framework, offering the ability to split your GraphQL server implementation into small, reusable, and composable pieces. This approach makes it easier to manage and scale large GraphQL projects.

Setting Up GraphQL Modules

To start using GraphQL Modules, you need to install the necessary packages:

  
    npm install @graphql-modules/core @graphql-tools/schema graphql
  

Creating a Basic Module

Here’s a simple example of creating and using a basic GraphQL Module:

  
    import { createModule, gql } from 'graphql-modules';

    const UserModule = createModule({
      id: 'user',
      dirname: __dirname,
      typeDefs: gql`
        type User {
          id: ID!
          name: String!
        }
        type Query {
          users: [User]
        }
      `,
      resolvers: {
        Query: {
          users: () => [
            { id: '1', name: 'John Doe' },
            { id: '2', name: 'Jane Doe' }
          ]
        }
      }
    });
  

Combining Multiple Modules

You can also combine multiple modules to create a cohesive GraphQL schema. Here’s how:

  
    import { createModule, gql } from 'graphql-modules';

    const PostModule = createModule({
      id: 'post',
      dirname: __dirname,
      typeDefs: gql`
        type Post {
          id: ID!
          title: String!
          content: String!
        }
        type Query {
          posts: [Post]
        }
      `,
      resolvers: {
        Query: {
          posts: () => [
            { id: '1', title: 'First Post', content: 'Content of the first post' },
            { id: '2', title: 'Second Post', content: 'Content of the second post' }
          ]
        }
      }
    });

    import { createApplication } from 'graphql-modules';

    const app = createApplication({
      modules: [UserModule, PostModule]
    });

    import { ApolloServer } from 'apollo-server';

    const server = new ApolloServer({
      schema: app.schema,
      context: app.createContext()
    });

    server.listen().then(({ url }) => {
      console.log(`🚀  Server ready at ${url}`);
    });
  

Advanced Features and API Explanations

GraphQL Modules offers several advanced features, including dependency injection, isolation, and more. Here are some useful APIs:

Dependency Injection

  
    import { InjectionToken } from 'graphql-modules';

    export const UserProviderToken = new InjectionToken('UserProvider');

    const UserModule = createModule({
      id: 'user',
      providers: [
        {
          provide: UserProviderToken,
          useValue: {
            getUser: (id) => ({ id, name: 'John Doe' })
          }
        }
      ]
    });
  

Isolation and Overriding

  
    import { createModule, gql } from 'graphql-modules';

    const AdminModule = createModule({
      id: 'admin',
      typeDefs: gql`
        extend type User {
          role: String!
        }
        extend type Query {
          adminUsers: [User]
        }
      `,
      resolvers: {
        Query: {
          adminUsers: () => [
            { id: '1', name: 'Admin User', role: 'admin' }
          ]
        }
      }
    });
  

A Complete App Example

Here’s a complete example that integrates all the discussed features:

  
    import { createModule, gql, InjectionToken, createApplication } from 'graphql-modules';
    import { ApolloServer } from 'apollo-server';

    const UserProviderToken = new InjectionToken('UserProvider');

    const UserModule = createModule({
      id: 'user',
      providers: [
        {
          provide: UserProviderToken,
          useValue: {
            getUser: (id) => ({ id, name: 'John Doe' })
          }
        }
      ],
      typeDefs: gql`
        type User {
          id: ID!
          name: String!
          role: String
        }
        type Query {
          users: [User]
        }
      `,
      resolvers: {
        Query: {
          users: (parent, args, { injector }) => {
            const userProvider = injector.get(UserProviderToken);
            return [userProvider.getUser('1')];
          }
        }
      }
    });

    const PostModule = createModule({
      id: 'post',
      typeDefs: gql`
        type Post {
          id: ID!
          title: String!
          content: String!
        }
        type Query {
          posts: [Post]
        }
      `,
      resolvers: {
        Query: {
          posts: () => [
            { id: '1', title: 'First Post', content: 'Content of the first post' },
            { id: '2', title: 'Second Post', content: 'Content of the second post' }
          ]
        }
      }
    });

    const AdminModule = createModule({
      id: 'admin',
      typeDefs: gql`
        extend type User {
          role: String!
        }
        extend type Query {
          adminUsers: [User]
        }
      `,
      resolvers: {
        Query: {
          adminUsers: () => [
            { id: '1', name: 'Admin User', role: 'admin' }
          ]
        }
      }
    });

    const app = createApplication({
      modules: [UserModule, PostModule, AdminModule]
    });

    const server = new ApolloServer({
      schema: app.schema,
      context: app.createContext()
    });

    server.listen().then(({ url }) => {
      console.log(`🚀  Server ready at ${url}`);
    });
  

This example demonstrates how you can leverage GraphQL Modules to create a structured and scalable GraphQL server.

Hash: d42223fb65b5efd53a27ab1425b931403939e79225cf5d3bb90fe33db0375d17