# Apollo

Unlock microservices potential with Apollo GraphQL. Seamlessly integrate APIs, manage data, and enhance performance. Explore Apollo's innovative solutions. Ts.ED provides a module to create multiple Apollo server and bind it with Ts.ED server (Express or Koa).

# Feature

# Installation

    import {Configuration} from "@tsed/common";
    import "@tsed/platform-express";
    import "@tsed/apollo";
    import {join} from "path";
    
    @Configuration({
      apollo: {
        server1: {
          // GraphQL server configuration
          path: "/",
          playground: true, // enable playground GraphQL IDE. Set false to use Apollo Studio
          plugins: [] // Apollo plugins
          // Give custom server instance
          // server?: (config: Config) => ApolloServer;
    
          // ApolloServer options
          // ...
          // See options descriptions on https://www.apollographql.com/docs/apollo-server/api/apollo-server.html
        }
      }
    })
    export class Server {}
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22

    # Register plugins

    You can register plugins with the plugins property. The plugins are executed in the order of declaration.

    import {Configuration} from "@tsed/common";
    import "@tsed/platform-express";
    import "@tsed/apollo";
    import {join} from "path";
    
    @Configuration({
      apollo: {
        server1: {
          plugins: [] // Apollo plugins
        }
      }
    })
    export class Server {}
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13

    But if you need to register and access to the injector, you can use the $alterApolloServerPlugins hook. For example, you can register the graphql-ws necessary to support the subscription feature of GraphQL like this:

    import {Constant, Inject, InjectorService, Module} from "@tsed/di";
    import {useServer} from "graphql-ws/lib/use/ws";
    import Http from "http";
    import Https from "https";
    import {WebSocketServer} from "ws";
    import {GraphQLWSOptions} from "./GraphQLWSOptions";
    
    @Module()
    export class GraphQLWSModule {
      @Constant("graphqlWs", {})
      private settings: GraphQLWSOptions;
    
      @Inject(Http.Server)
      private httpServer: Http.Server | null;
    
      @Inject(Https.Server)
      private httpsServer: Https.Server | null;
    
      @Inject()
      private injector: InjectorService;
    
      async $alterApolloServerPlugins(plugins: any[], settings: GraphQLWSOptions) {
        const wsServer = await this.createWSServer(settings);
    
        this.injector.logger.info(`Create GraphQL WS server on: ${settings.path}`);
    
        return plugins.concat({
          serverWillStart() {
            return {
              async drainServer() {
                await wsServer.dispose();
              }
            };
          }
        } as any);
      }
    
      protected createWSServer(settings: GraphQLWSOptions) {
        const wsServer = new WebSocketServer({
          ...(this.settings.wsServerOptions || {}),
          ...settings.wsServerOptions,
          server: this.httpsServer || this.httpServer!,
          path: settings.path
        });
    
        return useServer(
          {
            ...(this.settings.wsUseServerOptions || {}),
            ...settings.wsUseServerOptions,
            schema: settings.schema
          },
          wsServer
        );
      }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55

    Note

    Ts.ED provide a @tsed/graphql-ws package to support the subscription feature of GraphQL. See here (opens new window) for more details.

    # Get Server instance

    ApolloService (or TypeGraphQLService) lets you retrieve an instance of ApolloServer.

    import {AfterRoutesInit} from "@tsed/common";
    import {Inject, Injectable} from "@tsed/di";
    import {ApolloService} from "@tsed/apollo";
    import {ApolloServerBase} from "apollo-server-core";
    
    @Injectable()
    export class UsersService implements AfterRoutesInit {
      @Inject()
      private ApolloService: ApolloService;
      // or private typeGraphQLService: TypeGraphQLService;
    
      private server: ApolloServerBase;
    
      $afterRoutesInit() {
        this.server = this.apolloService.get("server1")!;
      }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17

    For more information about ApolloServer, look at its documentation here (opens new window);

    # Author

      # Maintainers

        Last Updated: 5/27/2024, 3:27:38 PM

        Other topics