@tsed/apollo 8.0.0 → 8.0.2

package/package.json

@@ -2,13 +2,14 @@
   "name": "@tsed/apollo",
   "description": "Apollo package for Ts.ED framework",
   "type": "module",
-  "version": "8.0.0",
+  "version": "8.0.2",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
   "typings": "./lib/types/index.d.ts",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "import": "./lib/esm/index.js",
       "default": "./lib/esm/index.js"
@@ -28,12 +29,12 @@
     "@apollo/datasource-rest": "6.3.0",
     "@apollo/server": "^4.11.0",
     "@as-integrations/koa": "1.1.1",
-    "@tsed/barrels": "8.0.0",
-    "@tsed/core": "8.0.0",
-    "@tsed/di": "8.0.0",
+    "@tsed/barrels": "8.0.2",
+    "@tsed/core": "8.0.2",
+    "@tsed/di": "8.0.2",
     "@tsed/logger": "^6.7.8",
-    "@tsed/platform-http": "8.0.0",
-    "@tsed/typescript": "8.0.0",
+    "@tsed/platform-http": "8.0.2",
+    "@tsed/typescript": "8.0.2",
     "apollo-datasource-http": "0.21.0",
     "apollo-server-testing": "2.26.2",
     "eslint": "9.12.0",
@@ -43,10 +44,10 @@
   },
   "peerDependencies": {
     "@apollo/server": ">=4.10.4",
-    "@tsed/core": "8.0.0",
-    "@tsed/di": "8.0.0",
+    "@tsed/core": "8.0.2",
+    "@tsed/di": "8.0.2",
     "@tsed/logger": ">=6.7.5",
-    "@tsed/platform-http": "8.0.0",
+    "@tsed/platform-http": "8.0.2",
     "graphql": ">16.0.0"
   },
   "repository": "https://github.com/tsedio/tsed",

package/src/ApolloModule.ts

@@ -0,0 +1,59 @@
+import {Configuration, Inject, InjectorService, Module} from "@tsed/di";
+import {Logger} from "@tsed/logger";
+import {AfterListen, OnRoutesInit, PlatformConfiguration} from "@tsed/platform-http";
+
+import {ApolloSettings} from "./interfaces/ApolloSettings.js";
+import {ApolloService} from "./services/ApolloService.js";
+
+@Module()
+export class ApolloModule implements OnRoutesInit, AfterListen {
+  @Inject()
+  protected logger: Logger;
+
+  @Inject()
+  protected service: ApolloService;
+
+  @Configuration()
+  protected configuration: PlatformConfiguration;
+
+  @Inject(InjectorService)
+  protected injector: InjectorService;
+
+  get settings(): {[key: string]: ApolloSettings} | undefined {
+    return this.configuration.get("apollo", this.configuration.get("graphql", this.configuration.get("typegraphql")));
+  }
+
+  async $onRoutesInit(): Promise<void> {
+    const {settings, injector} = this;
+
+    if (settings) {
+      const promises = Object.entries(settings).map(async ([id, options]) => {
+        options = await injector.alterAsync("$alterApolloSettings", {id, ...options});
+
+        return this.service.createServer(id, options);
+      });
+
+      await Promise.all(promises);
+    }
+  }
+
+  $afterListen(): Promise<any> | void {
+    const host = this.configuration.getBestHost();
+
+    const displayLog = (key: string, path: string) => {
+      const url = "port" in host && typeof host.port === "number" ? `${host.protocol}://${host.address}:${host.port}` : "";
+
+      this.logger.info(`[${key}] Apollo server is available on ${url}/${path.replace(/^\//, "")}`);
+    };
+
+    const {settings} = this;
+
+    if (settings) {
+      Object.entries(settings).map(([key, options]) => {
+        const {path} = options;
+
+        displayLog(key, path);
+      });
+    }
+  }
+}

package/src/constants/constants.ts

@@ -0,0 +1,2 @@
+export const DATASOURCES_PROVIDERS = "graphql:datasources";
+export const APOLLO_CONTEXT = Symbol.for("APOLLO_CONTEXT");

package/src/decorators/dataSource.ts

@@ -0,0 +1,70 @@
+import {StoreSet, useDecorators} from "@tsed/core";
+import {Injectable, ProviderScope} from "@tsed/di";
+
+import {DATASOURCES_PROVIDERS} from "../constants/constants.js";
+
+/**
+ * Create a new injectable DataSource.
+ *
+ * ```typescript
+ * import { DataSourceService } from "@tsed/graphql";
+ * import { RESTDataSource } from '@apollo/datasource-rest';
+ *
+ * @DataSource()
+ * export class MyDataSource extends RESTDataSource {
+ *    constructor() {
+ *      super();
+ *      this.baseURL = 'https://awesome-api.example.com';
+ *    }
+ *
+ *    willSendRequest(request) {
+ *      request.headers.set('Authorization', this.context.token);
+ *    }
+ *
+ *    getMyData(id: string) {
+ *      return this.get(`/v1/my_rest_data/${id}`);
+ *    }
+ * }
+ * ```
+ *
+ * @decorator
+ * @graphql
+ */
+export function DataSource(name?: string): ClassDecorator {
+  return useDecorators(
+    Injectable({
+      type: DATASOURCES_PROVIDERS,
+      scope: ProviderScope.INSTANCE
+    }),
+    StoreSet(DATASOURCES_PROVIDERS, {name})
+  );
+}
+
+/**
+ * Create a new injectable DataSource.
+ *
+ * ```typescript
+ * import { DataSourceService } from "@tsed/graphql";
+ * import { RESTDataSource } from '@apollo/datasource-rest';
+ *
+ * @DataSource()
+ * export class MyDataSource extends RESTDataSource {
+ *    constructor() {
+ *      super();
+ *      this.baseURL = 'https://awesome-api.example.com';
+ *    }
+ *
+ *    willSendRequest(request) {
+ *      request.headers.set('Authorization', this.context.token);
+ *    }
+ *
+ *    getMyData(id: string) {
+ *      return this.get(`/v1/my_rest_data/${id}`);
+ *    }
+ * }
+ * ```
+ *
+ * @decorator
+ * @graphql
+ */
+export const DataSourceService = DataSource;

package/src/decorators/injectApolloContext.ts

@@ -0,0 +1,21 @@
+import {DecoratorParameters, decoratorTypeOf, DecoratorTypes} from "@tsed/core";
+import {Inject, InjectContext} from "@tsed/di";
+
+import {APOLLO_CONTEXT} from "../constants/constants.js";
+
+/**
+ * Inject the Apollo context in the decorated property.
+ * @decorator
+ */
+export function InjectApolloContext(): any {
+  return (...args: DecoratorParameters) => {
+    switch (decoratorTypeOf(args)) {
+      case DecoratorTypes.PARAM_CTOR:
+        Inject(APOLLO_CONTEXT)(...args);
+        break;
+
+      case DecoratorTypes.PROP:
+        return InjectContext(($ctx) => $ctx.get(APOLLO_CONTEXT))(args[0], args[1]);
+    }
+  };
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./ApolloModule.js";
+export * from "./constants/constants.js";
+export * from "./decorators/dataSource.js";
+export * from "./decorators/injectApolloContext.js";
+export * from "./interfaces/AlterApolloContext.js";
+export * from "./interfaces/AlterApolloServerPlugins.js";
+export * from "./interfaces/AlterApolloSettings.js";
+export * from "./interfaces/ApolloContext.js";
+export * from "./interfaces/ApolloSettings.js";
+export * from "./services/ApolloService.js";

package/src/interfaces/AlterApolloContext.ts

@@ -0,0 +1,7 @@
+import type {PlatformContext} from "@tsed/platform-http";
+
+import type {ApolloContext} from "./ApolloContext.js";
+
+export interface AlterApolloContext<Context extends ApolloContext = ApolloContext> {
+  $alterApolloContext(context: Context, $ctx: PlatformContext): Context | Promise<Context>;
+}

package/src/interfaces/AlterApolloServerPlugins.ts

@@ -0,0 +1,10 @@
+import type {ApolloServerPlugin} from "@apollo/server";
+
+import type {ApolloSettings} from "./ApolloSettings.js";
+
+export interface AlterApolloServerPlugins {
+  $alterApolloServerPlugins(
+    plugins: ApolloServerPlugin[],
+    serverSettings: ApolloSettings
+  ): ApolloServerPlugin[] | Promise<ApolloServerPlugin[]>;
+}

package/src/interfaces/AlterApolloSettings.ts

@@ -0,0 +1,10 @@
+import type {ApolloContext} from "./ApolloContext.js";
+import type {ApolloSettingsWithID} from "./ApolloSettings.js";
+
+export interface AlterApolloSettings<Context extends ApolloContext = ApolloContext> {
+  $alterApolloSettings(settings: ApolloSettingsWithID<Context>):
+    | (ApolloSettingsWithID<Context> & {
+        id: string;
+      })
+    | Promise<ApolloSettingsWithID<Context>>;
+}

package/src/interfaces/ApolloContext.ts

@@ -0,0 +1,5 @@
+import type {BaseContext} from "@apollo/server";
+
+export interface ApolloContext extends BaseContext {
+  dataSources: Record<string, unknown>;
+}

package/src/interfaces/ApolloSettings.ts

@@ -0,0 +1,44 @@
+import type {ApolloServer, ApolloServerOptions, ApolloServerOptionsWithSchema} from "@apollo/server";
+import type {GatewayInterface} from "@apollo/server-gateway-interface";
+import type {IExecutableSchemaDefinition} from "@graphql-tools/schema";
+import type {GraphQLSchema} from "graphql/index.js";
+
+import type {ApolloContext} from "./ApolloContext.js";
+
+export type ApolloMiddlewareOptions = Record<string, any>;
+export type ApolloCustomServerCB<TContext extends ApolloContext> = (config: ApolloServerOptions<TContext>) => ApolloServer<TContext>;
+
+declare global {
+  namespace TsED {
+    interface ApolloSettings {}
+  }
+}
+
+export type ApolloServerOptionsBase<TContext extends ApolloContext = ApolloContext> = Omit<
+  ApolloServerOptionsWithSchema<TContext>,
+  "schema" | "typeDefs" | "resolvers" | "gateway"
+>;
+
+export type ApolloSettings<TContext extends ApolloContext = ApolloContext> = ApolloServerOptionsBase<TContext> &
+  TsED.ApolloSettings & {
+    // Basic options
+    path: string;
+    server?: ApolloCustomServerCB<TContext>;
+    playground?: boolean;
+    // ApplyMiddleware Options
+    // See options descriptions on https://www.apollographql.com/docs/apollo-server/api/apollo-server.html
+    serverRegistration?: ApolloMiddlewareOptions;
+    middlewareOptions?: ApolloMiddlewareOptions;
+    schema?: GraphQLSchema;
+    typeDefs?: IExecutableSchemaDefinition<TContext>["typeDefs"];
+    resolvers?: IExecutableSchemaDefinition<TContext>["resolvers"];
+    gateway?: GatewayInterface;
+    /**
+     * @deprecated use $alterApolloContext instead
+     */
+    dataSources?: () => Record<string, unknown>;
+  };
+
+export type ApolloSettingsWithID<TContext extends ApolloContext = ApolloContext> = ApolloSettings<TContext> & {
+  id: string;
+};

package/src/services/ApolloService.spec.ts

@@ -0,0 +1,319 @@
+import {RESTDataSource} from "@apollo/datasource-rest";
+import {ApolloServer, ApolloServerPlugin} from "@apollo/server";
+import {catchAsyncError} from "@tsed/core";
+import {Configuration, Constant, InjectContext, Module, runInContext} from "@tsed/di";
+import {Logger} from "@tsed/logger";
+import {PlatformApplication, PlatformContext} from "@tsed/platform-http";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import {HTTPDataSource} from "apollo-datasource-http";
+
+import {APOLLO_CONTEXT} from "../constants/constants.js";
+import {DataSource} from "../decorators/dataSource.js";
+import {InjectApolloContext} from "../decorators/injectApolloContext.js";
+import type {AlterApolloContext} from "../interfaces/AlterApolloContext.js";
+import type {AlterApolloServerPlugins} from "../interfaces/AlterApolloServerPlugins.js";
+import type {ApolloContext} from "../interfaces/ApolloContext.js";
+import type {ApolloSettings} from "../interfaces/ApolloSettings.js";
+import {ApolloService} from "./ApolloService.js";
+
+vi.mock("@apollo/server/express4", () => {
+  return {
+    __esModule: true,
+    expressMiddleware: vi.fn().mockReturnValue("expressMiddleware")
+  };
+});
+vi.mock("@as-integrations/koa", () => {
+  return {
+    __esModule: true,
+    koaMiddleware: vi.fn().mockReturnValue("koaMiddleware")
+  };
+});
+
+export interface CustomApolloContext extends ApolloContext {
+  token: string | undefined;
+}
+
+@Module()
+class MyModule implements AlterApolloContext, AlterApolloServerPlugins {
+  $alterApolloServerPlugins(
+    plugins: ApolloServerPlugin[],
+    serverSettings: ApolloSettings
+  ): ApolloServerPlugin[] | Promise<ApolloServerPlugin[]> {
+    return plugins.concat("extraPlugin" as never);
+  }
+
+  $alterApolloContext(context: ApolloContext, $ctx: PlatformContext): CustomApolloContext | Promise<CustomApolloContext> {
+    const header = $ctx.request.get("authorization");
+
+    return {
+      ...context,
+      token: header
+    } as CustomApolloContext;
+  }
+}
+
+@DataSource()
+export class MyDataSource extends RESTDataSource {
+  @InjectContext()
+  $ctx: PlatformContext;
+
+  @Constant("envs.MY_BACK_URL", "http://localhost:8001")
+  declare baseURL: string;
+
+  @InjectApolloContext()
+  protected context: CustomApolloContext;
+
+  constructor(server: ApolloServer, logger: Logger) {
+    super({
+      logger,
+      cache: server.cache
+    });
+  }
+
+  willSendRequest(path: string, request: any) {
+    request.headers["authorization"] = this.context.token;
+  }
+
+  getMyData(id: string) {
+    return this.get(`/rest/calendars/${id}`);
+  }
+}
+
+@DataSource("myName")
+export class MyDataSource2 extends RESTDataSource {
+  @InjectContext()
+  $ctx: PlatformContext;
+
+  constructor() {
+    super();
+    this.baseURL = "http://localhost:8001";
+  }
+
+  getMyData(id: string) {
+    return this.get(`/rest/calendars/${id}`);
+  }
+}
+
+@DataSource()
+class MoviesAPI extends HTTPDataSource {
+  constructor(
+    @InjectApolloContext() {token}: CustomApolloContext,
+    server: ApolloServer,
+    logger: Logger,
+    @Configuration() configuration: Configuration
+  ) {
+    // the necessary arguments for HTTPDataSource
+    super(configuration.get("envs.MOVIES_API_URL"), {
+      logger
+    });
+
+    // We need to call the initialize method in our data source's
+    // constructor, passing in our cache and contextValue.
+    this.initialize({cache: server.cache, context: token});
+  }
+
+  getMovie(id: string) {
+    return this.get(`movies/${encodeURIComponent(id)}`);
+  }
+}
+
+function getFixture() {
+  const service = PlatformTest.get<ApolloService>(ApolloService);
+  const logger = PlatformTest.get<Logger>(Logger);
+  const app = PlatformTest.get(PlatformApplication);
+
+  const serverMockInstance = {
+    start: vi.fn()
+  };
+  const serverMock = vi.fn().mockReturnValue(serverMockInstance);
+
+  vi.spyOn(app, "use").mockReturnThis();
+
+  return {
+    service,
+    logger,
+    app,
+    serverMock,
+    serverMockInstance
+  };
+}
+
+describe("ApolloService", () => {
+  describe("when platform is express", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        PLATFORM_NAME: "express",
+        envs: {
+          MOVIES_API_URL: "http://localhost:8001"
+        }
+      })
+    );
+    afterEach(() => {
+      return PlatformTest.reset();
+    });
+
+    describe("createServer()", () => {
+      it("should create a server", async () => {
+        // GIVEN
+        const {serverMock, service, app} = getFixture();
+
+        const opts = {
+          path: "/path",
+          server: serverMock,
+          schema: "schema",
+          typeDefs: "typeDefs",
+          resolvers: "resolvers"
+        } as never;
+
+        // WHEN
+        const result1 = await service.createServer("key", opts);
+        const result2 = await service.createServer("key", opts);
+
+        expect(service.getSchema("key")).toEqual("schema");
+        expect(service.getSchema()).toEqual(undefined);
+        expect(service.getResolvers("key")).toEqual("resolvers");
+        expect(service.getResolvers()).toEqual(undefined);
+        expect(service.getTypeDefs("key")).toEqual("typeDefs");
+        expect(service.getTypeDefs()).toEqual(undefined);
+        expect(service.has("key")).toEqual(true);
+        expect(service.has()).toEqual(false);
+        expect(result2).toEqual(result1);
+        expect(app.use).toHaveBeenCalledWith("/path", "expressMiddleware");
+        expect(serverMock).toHaveBeenCalledWith({
+          plugins: expect.any(Array),
+          schema: "schema",
+          typeDefs: "typeDefs",
+          resolvers: "resolvers"
+        });
+        expect(serverMock.mock.calls[0][0].plugins).toContain("extraPlugin");
+      });
+      it("should log server error", async () => {
+        // GIVEN
+        const {serverMock, logger, serverMockInstance, service, app} = getFixture();
+
+        const opts = {
+          path: "/path",
+          server: serverMock
+        } as never;
+
+        vi.spyOn(logger, "error");
+
+        serverMockInstance.start.mockRejectedValue(new Error("test"));
+
+        // WHEN
+        const result = await catchAsyncError(() => service.createServer("key", opts));
+
+        expect(result).toEqual(new Error("test"));
+        expect(logger.error).toHaveBeenCalledWith({
+          error_name: "Error",
+          event: "APOLLO_BOOTSTRAP_ERROR",
+          message: "test",
+          stack: expect.any(String)
+        });
+      });
+    });
+
+    describe("createContextHandler()", () => {
+      it("should create a context handler", async () => {
+        // GIVEN
+        const {service, serverMock} = getFixture();
+        const $ctx = PlatformTest.createRequestContext();
+
+        const opts = {
+          path: "/path",
+          server: serverMock
+        } as never;
+
+        // WHEN
+        const server = await service.createServer("key", opts);
+
+        // WHEN
+        const result = service.createContextHandler(server, {
+          dataSources: () => ({
+            myDataSource: MyDataSource
+          })
+        } as never);
+
+        $ctx.request.headers["authorization"] = "token";
+
+        const contextResult: CustomApolloContext = await runInContext($ctx, () => result());
+
+        expect(contextResult.token).toEqual("token");
+        expect(Object.keys(contextResult.dataSources)).toEqual(["myDataSource", "myName", "moviesAPI"]);
+
+        expect($ctx.get(APOLLO_CONTEXT)).toEqual(contextResult);
+      });
+    });
+  });
+  describe("when platform is koa", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        PLATFORM_NAME: "koa"
+      })
+    );
+    afterEach(() => {
+      return PlatformTest.reset();
+    });
+
+    describe("createServer()", () => {
+      it("should create a server", async () => {
+        // GIVEN
+        const {serverMock, app, service} = getFixture();
+
+        // WHEN
+        const opts = {
+          path: "/path",
+          server: serverMock
+        } as never;
+
+        const result1 = await service.createServer("key", opts);
+        const result2 = await service.createServer("key", {path: "/path"} as any);
+
+        expect(service.getSchema("key")).toEqual(undefined);
+        expect(service.getSchema()).toEqual(undefined);
+        expect(result2).toEqual(result1);
+        expect(app.use).toHaveBeenCalledWith("/path", "koaMiddleware");
+        expect(serverMock).toHaveBeenCalledWith({
+          plugins: expect.any(Array)
+        });
+      });
+    });
+  });
+  describe("when platform is unknown", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        PLATFORM_NAME: "unknown"
+      })
+    );
+    afterEach(() => {
+      return PlatformTest.reset();
+    });
+
+    describe("createServer()", () => {
+      it("should not create a server", async () => {
+        // GIVEN
+        const {serverMock, logger, service} = getFixture();
+
+        vi.spyOn(logger, "warn");
+        // WHEN
+        const opts = {
+          path: "/path",
+          server: serverMock
+        } as never;
+
+        // WHEN
+        const result1 = await service.createServer("key", opts);
+        const result2 = await service.createServer("key", opts);
+
+        expect(service.getSchema("key")).toEqual(undefined);
+        expect(service.getSchema("key")).toEqual(undefined);
+        expect(service.getSchema()).toEqual(undefined);
+        expect(result2).toEqual(result1);
+        expect(logger.warn).toHaveBeenCalledWith({
+          event: "APOLLO_UNKNOWN_PLATFORM",
+          message: "Platform not supported. Please use Ts.ED platform (express, koa)"
+        });
+      });
+    });
+  });
+});

package/src/services/ApolloService.ts

@@ -0,0 +1,230 @@
+import {ApolloServer, ApolloServerOptions, ApolloServerPlugin} from "@apollo/server";
+import {ApolloServerPluginLandingPageDisabled} from "@apollo/server/plugin/disabled";
+import {ApolloServerPluginDrainHttpServer} from "@apollo/server/plugin/drainHttpServer";
+import {ApolloServerPluginLandingPageLocalDefault} from "@apollo/server/plugin/landingPage/default";
+import type {IExecutableSchemaDefinition} from "@graphql-tools/schema";
+import {Constant, context, Inject, InjectorService, LocalsContainer, Provider, Service} from "@tsed/di";
+import {Logger} from "@tsed/logger";
+import {PlatformApplication, PlatformContext} from "@tsed/platform-http";
+import type {GraphQLSchema} from "graphql";
+import Http from "http";
+import Https from "https";
+
+import {APOLLO_CONTEXT, DATASOURCES_PROVIDERS} from "../constants/constants.js";
+import {ApolloContext} from "../interfaces/ApolloContext.js";
+import type {ApolloCustomServerCB, ApolloSettings} from "../interfaces/ApolloSettings.js";
+
+@Service()
+export class ApolloService {
+  @Constant("PLATFORM_NAME")
+  platformName: string;
+
+  @Inject()
+  protected logger: Logger;
+
+  /**
+   *
+   * @type {Map<any, any>}
+   * @private
+   */
+  protected servers: Map<
+    string,
+    {
+      instance: ApolloServer<ApolloContext>;
+      schema?: GraphQLSchema;
+      typeDefs?: IExecutableSchemaDefinition<ApolloContext>["typeDefs"];
+      resolvers?: IExecutableSchemaDefinition<ApolloContext>["resolvers"];
+    }
+  > = new Map();
+
+  @Inject()
+  private app: PlatformApplication<any>;
+
+  @Inject(Http.Server)
+  private httpServer: Http.Server | null;
+
+  @Inject(Https.Server)
+  private httpsServer: Https.Server | null;
+
+  @Inject()
+  private injector: InjectorService;
+
+  async createServer(id: string, settings: ApolloSettings) {
+    if (!this.has(id)) {
+      try {
+        const {dataSources, path, middlewareOptions = {}, server: customServer, ...config} = settings;
+
+        this.logger.info(`Create server with Apollo for: ${id}`);
+        this.logger.debug(`options: ${JSON.stringify({path})}`);
+
+        const plugins = await this.getPlugins(settings);
+
+        const server = this.createInstance(
+          {
+            ...config,
+            plugins
+          } as never,
+          customServer
+        );
+
+        if (server) {
+          this.servers.set(id || "default", {
+            instance: server,
+            schema: settings.schema,
+            typeDefs: settings.typeDefs,
+            resolvers: settings.resolvers
+          });
+
+          await server.start();
+
+          const contextHandler = this.createContextHandler(server, settings);
+
+          switch (this.platformName) {
+            case "express":
+              const {expressMiddleware} = await import("@apollo/server/express4");
+
+              this.app.use(
+                path,
+                expressMiddleware(server as any, {
+                  ...middlewareOptions,
+                  context: contextHandler
+                })
+              );
+              break;
+
+            case "koa":
+              const {koaMiddleware} = await import("@as-integrations/koa");
+
+              this.app.use(
+                path,
+                koaMiddleware(server as any, {
+                  ...middlewareOptions,
+                  context: contextHandler
+                })
+              );
+              break;
+            default:
+              this.logger.warn({
+                event: "APOLLO_UNKNOWN_PLATFORM",
+                message: "Platform not supported. Please use Ts.ED platform (express, koa)"
+              });
+          }
+        }
+      } catch (er) {
+        this.logger.error({
+          event: "APOLLO_BOOTSTRAP_ERROR",
+          error_name: er.name,
+          message: er.message,
+          stack: er.stack
+        });
+        throw er;
+      }
+    }
+
+    return this.get(id)!;
+  }
+
+  /**
+   * Get an instance of ApolloServer from his id
+   * @returns ApolloServer
+   */
+  get(id: string = "default"): ApolloServer<ApolloContext> | undefined {
+    return this.servers.get(id)?.instance;
+  }
+
+  /**
+   * Get schema of the ApolloServer from his id
+   * @returns GraphQLSchema
+   */
+  getSchema(id: string = "default") {
+    return this.servers.get(id)?.schema;
+  }
+
+  /**
+   * Get TypeDefs of the ApolloServer from his id
+   */
+  getTypeDefs(id: string = "default") {
+    return this.servers.get(id)?.typeDefs;
+  }
+
+  getResolvers(id: string = "default") {
+    return this.servers.get(id)?.resolvers;
+  }
+
+  /**
+   *
+   * @param {string} id
+   * @returns {boolean}
+   */
+  has(id: string = "default"): boolean {
+    return this.servers.has(id);
+  }
+
+  /**
+   * create a new dataSources function to use with apollo server config
+   */
+  createContextHandler(server: ApolloServer<ApolloContext>, settings: ApolloSettings) {
+    const {injector} = this;
+    const dataSourcesContainer = injector.getProviders(DATASOURCES_PROVIDERS).reduce((map, provider) => {
+      let {name} = provider.store.get(DATASOURCES_PROVIDERS);
+
+      name = name || provider.className;
+
+      const sourceName = `${name[0].toLowerCase()}${name.slice(1)}`;
+      map.set(sourceName, provider);
+
+      return map;
+    }, new Map<string, Provider>());
+
+    return async () => {
+      const $ctx = context<PlatformContext>();
+      const apolloContext: ApolloContext = {
+        dataSources: {
+          ...(settings.dataSources?.() || {})
+        }
+      };
+
+      const alteredContext = await this.injector.alterAsync("$alterApolloContext", apolloContext, $ctx);
+
+      $ctx!.set(APOLLO_CONTEXT, alteredContext);
+
+      const locals = new LocalsContainer();
+      locals.set(APOLLO_CONTEXT, alteredContext);
+      locals.set(ApolloServer, server);
+
+      dataSourcesContainer.forEach((provider, key) => {
+        alteredContext.dataSources[key] = injector.invoke(provider.token, {locals});
+      });
+
+      return alteredContext;
+    };
+  }
+
+  protected createInstance(options: ApolloServerOptions<ApolloContext>, server?: ApolloCustomServerCB<ApolloContext>) {
+    return server ? server(options) : new ApolloServer(options);
+  }
+
+  private async getPlugins(serverSettings: ApolloSettings): Promise<ApolloServerPlugin[]> {
+    const playground = serverSettings.playground || (serverSettings.playground === undefined && process.env.NODE_ENV !== "production");
+
+    const result = await this.injector.alterAsync(
+      "$alterApolloServerPlugins",
+      [
+        this.httpServer &&
+          ApolloServerPluginDrainHttpServer({
+            httpServer: this.httpServer
+          }),
+        this.httpsServer &&
+          ApolloServerPluginDrainHttpServer({
+            httpServer: this.httpsServer
+          }),
+        ...(serverSettings.plugins || [])
+      ].filter(Boolean),
+      serverSettings
+    );
+
+    return result
+      .concat([playground ? ApolloServerPluginLandingPageLocalDefault({embed: true}) : ApolloServerPluginLandingPageDisabled()])
+      .filter(Boolean);
+  }
+}