diff --git a/docs/tutorials/graphql-apollo.md b/docs/tutorials/graphql-apollo.md
index a82651a2533..0d12ff7e578 100644
--- a/docs/tutorials/graphql-apollo.md
+++ b/docs/tutorials/graphql-apollo.md
@@ -15,6 +15,10 @@ Ts.ED provides a module to create multiple Apollo server and bind it with Ts.ED
 
 ## Feature
 
+::: warning
+Since v7.70.0, Ts.ED use Apollo Server v4. If you are using Apollo Server v3, you can use the `@tsed/apollo@7.69.0` package.
+:::
+
 - Create [Apollo](https://www.apollographql.com/docs/apollo-server/api/apollo-server.html) Server and bind it with
   Ts.ED,
 - Create multiple servers,
@@ -27,7 +31,7 @@ Ts.ED provides a module to create multiple Apollo server and bind it with Ts.ED
 <Tab label="Express.js">
 
 ```bash
-npm install --save @tsed/apollo graphql apollo-server-express
+npm install --save @tsed/apollo graphql @apollo/server
 npm install --save-dev apollo-server-testing
 ```
 
@@ -35,7 +39,7 @@ npm install --save-dev apollo-server-testing
 <Tab label="Koa.js">
 
 ```bash
-npm install --save @tsed/apollo graphql apollo-server-koa
+npm install --save @tsed/apollo graphql @apollo/server @as-integration/koa
 npm install --save-dev apollo-server-testing
 ```
 
@@ -160,7 +164,7 @@ ApolloService (or TypeGraphQLService) lets you retrieve an instance of ApolloSer
 import {AfterRoutesInit} from "@tsed/common";
 import {Inject, Injectable} from "@tsed/di";
 import {ApolloService} from "@tsed/apollo";
-import {ApolloServerBase} from "apollo-server-core";
+import {ApolloServer} from "@apollo/server";
 
 @Injectable()
 export class UsersService implements AfterRoutesInit {
@@ -168,7 +172,7 @@ export class UsersService implements AfterRoutesInit {
   private ApolloService: ApolloService;
   // or private typeGraphQLService: TypeGraphQLService;
 
-  private server: ApolloServerBase;
+  private server: ApolloServer;
 
   $afterRoutesInit() {
     this.server = this.apolloService.get("server1")!;
@@ -179,6 +183,132 @@ export class UsersService implements AfterRoutesInit {
 For more information about ApolloServer, look at its
 documentation [here](https://www.apollographql.com/docs/apollo-server/api/apollo-server.html);
 
+## DataSources
+
+Apollo Server provides a mechanism to fetch data from a REST API or a database. This mechanism is called DataSources.
+Ts.ED allows you to register your DataSources using the `@DataSource` decorator.
+
+```typescript
+import {DataSource} from "@tsed/apollo";
+import {RESTDataSource} from "@apollo/datasource-rest";
+
+@DataSource()
+export class MyDataSource extends RESTDataSource {
+  @InjectContext()
+  protected $ctx: PlatformContext;
+
+  @Constant("envs.MY_API_URL", "http://localhost:8001")
+  private baseURL: string;
+
+  getMyData(id: string) {
+    return this.get(`/rest/calendars/${id}`, {
+      headers: {
+        Authorization: `Bearer ${this.$ctx.request.get("authorization")}`
+      }
+    });
+  }
+}
+```
+
+## Alter Apollo Context <Badge text="7.70.0+"/>
+
+You can alter the Apollo context by using the `$alterApolloContext` hook. This hook is called each the GraphQL request is handled.
+
+For example, you can call a service to get the user scope from the request token.
+
+```typescript
+import type {AlterApolloContext, ApolloContext} from "@tsed/apollo";
+import {PlatformContext} from "@tsed/common";
+import {Injectable} from "@tsed/di";
+import {AuthService} from "../auth/AuthService";
+
+export interface CustomApolloContext extends ApolloContext {
+  scope: string;
+  token: string | undefined;
+}
+
+@Injectable()
+export class MyModule implements AlterApolloContext {
+  @Inject()
+  protected authService: AuthService;
+
+  async $alterApolloContext(context: ApolloContext, $ctx: PlatformContext): CustomApolloContext {
+    const token = $ctx.request.get("authorization");
+
+    return {
+      ...context,
+      token,
+      scope: await this.authService.getScope(token)
+    };
+  }
+}
+```
+
+Now, your context will be updated with the `authScope` property, and you can access it in your DataSources or resolvers.
+
+```typescript
+import {DataSource, InjectApolloContext, ApolloContext, InjectApolloContext} from "@tsed/apollo";
+import {Constant, Opts} from "@tsed/di";
+import {RESTDataSource} from "@apollo/datasource-rest";
+
+@DataSource()
+export class MyDataSource extends RESTDataSource {
+  @InjectContext()
+  protected $ctx: PlatformContext;
+
+  @Constant("envs.MY_BACK_URL", "http://localhost:8001")
+  protected baseURL: string;
+
+  @InjectApolloContext()
+  protected context: CustomApolloContext;
+
+  constructor(server: ApolloServer, logger: Logger) {
+    super({
+      logger,
+      cache: server.cache
+    });
+  }
+
+  willSendRequest(path, request) {
+    request.headers["authorization"] = this.context.token;
+  }
+
+  getMyData(id: string) {
+    return this.get(`/rest/calendars/${id}`);
+  }
+}
+```
+
+Here another example using `apollo-datasource-http`:
+
+```ts
+import {DataSource, InjectApolloContext, ApolloContext, InjectApolloContext} from "@tsed/apollo";
+import {ApolloServer} from "@apollo/server";
+import {Opts, Configuration} from "@tsed/di";
+
+@DataSource()
+class MoviesAPI extends HTTPDataSource {
+  constructor(@Opts {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)}`);
+  }
+}
+```
+
+::: warning
+Injecting ApolloServer on constructor is only possible inside a DataSource class. If you need to inject ApolloServer in another class, you can use the `ApolloService` to retrieve the server instance.
+:::
+
 ## Author
 
 <GithubContributors users="['Romakita']"/>
diff --git a/docs/tutorials/graphql-nexus.md b/docs/tutorials/graphql-nexus.md
index 3c742cd1968..86ca85ab7e6 100644
--- a/docs/tutorials/graphql-nexus.md
+++ b/docs/tutorials/graphql-nexus.md
@@ -21,8 +21,7 @@ This example need to be used with `@tsed/apollo` module. So, you must install it
 <Tab label="Express.js">
 
 ```bash
-npm install --save @tsed/apollo
-npm install --save nexus graphql apollo-server-express
+npm install --save @tsed/apollo nexus graphql @apollo/server
 npm install --save-dev apollo-server-testing
 ```
 
@@ -30,8 +29,7 @@ npm install --save-dev apollo-server-testing
 <Tab label="Koa.js">
 
 ```bash
-npm install --save @tsed/apollo graphql
-npm install --save nexus graphql apollo-server-koa
+npm install --save @tsed/apollo nexus graphql @apollo/server @as-integration/koa
 npm install --save-dev apollo-server-testing
 ```
 
@@ -90,7 +88,7 @@ a @@DataSourceService@@ decorator to declare a DataSource which will be injected
 
 ```typescript
 import {DataSource} from "@tsed/typegraphql";
-import {RESTDataSource} from "apollo-datasource-rest";
+import {RESTDataSource} from "@apollo/datasource-rest";
 import {User} from "../models/User";
 @DataSource()
 export class UserDataSource extends RESTDataSource {
diff --git a/docs/tutorials/graphql-typegraphql.md b/docs/tutorials/graphql-typegraphql.md
index 8976f013855..07cb28f29e4 100644
--- a/docs/tutorials/graphql-typegraphql.md
+++ b/docs/tutorials/graphql-typegraphql.md
@@ -20,8 +20,7 @@ To begin, install the `@tsed/typegraphql` package:
 <Tab label="Express.js">
 
 ```bash
-npm install --save @tsed/typegraphql graphql apollo-server-express
-npm install --save type-graphql apollo-datasource apollo-datasource-rest
+npm install --save @tsed/apollo graphql type-graphql @apollo/server @apollo/datasource-rest
 npm install --save-dev apollo-server-testing
 ```
 
@@ -29,8 +28,7 @@ npm install --save-dev apollo-server-testing
 <Tab label="Koa.js">
 
 ```bash
-npm install --save @tsed/typegraphql graphql apollo-server-koa
-npm install --save type-graphql apollo-datasource apollo-datasource-rest
+npm install --save @tsed/apollo graphql type-graphql @apollo/server @as-integration/koa @apollo/datasource-rest
 npm install --save-dev apollo-server-testing
 ```
 
@@ -49,22 +47,18 @@ import "@tsed/typegraphql";
 import "./resolvers/index"; // barrel file with all resolvers
 
 @Configuration({
-  typegraphql: {
+  apollo: {
     server1: {
       // GraphQL server configuration
+      // See options descriptions on https://www.apollographql.com/docs/apollo-server/api/apollo-server.html
       path: "/",
-      playground: true, // enable playground GraphQL IDE. Set false to use Apollo Studio
+      playground: true // enable playground GraphQL IDE. Set false to use Apollo Studio
 
       // resolvers?: (Function | string)[];
       // dataSources?: Function;
       // server?: (config: Config) => ApolloServer;
 
-      // Apollo Server options
-      // See options descriptions on https://www.apollographql.com/docs/apollo-server/api/apollo-server.html
-      serverConfig: {
-        plugins: []
-      }
-
+      // plugins: []
       // middlewareOptions?: ServerRegistration;
 
       // type-graphql
@@ -210,17 +204,35 @@ a @@DataSourceService@@ decorator to declare a DataSource which will be injected
 
 ```typescript
 import {DataSource} from "@tsed/typegraphql";
-import {RESTDataSource} from "apollo-datasource-rest";
+import {RESTDataSource} from "@apollo/datasource-rest";
 import {User} from "../models/User";
+import {DataSource, InjectApolloContext, ApolloContext, InjectApolloContext} from "@tsed/apollo";
+import {Constant, Opts} from "@tsed/di";
+import {RESTDataSource} from "@apollo/datasource-rest";
 
 @DataSource()
 export class UserDataSource extends RESTDataSource {
-  constructor() {
-    super();
-    this.baseURL = "https://myapi.com/api/users";
+  @InjectContext()
+  protected $ctx: PlatformContext;
+
+  @Constant("envs.USERS_URL", "https://myapi.com/api/users")
+  protected baseURL: string;
+
+  @InjectApolloContext()
+  protected context: CustomApolloContext;
+
+  constructor(server: ApolloServer, logger: Logger) {
+    super({
+      logger,
+      cache: server.cache
+    });
+  }
+
+  willSendRequest(path, request) {
+    request.headers["authorization"] = this.context.token;
   }
 
-  getUserById(id: string): Promise<User> {
+  getUserById(id: string) {
     return this.get(`/${id}`);
   }
 }
diff --git a/docs/tutorials/graphql-ws.md b/docs/tutorials/graphql-ws.md
index 69731d5133b..922def2ee3d 100644
--- a/docs/tutorials/graphql-ws.md
+++ b/docs/tutorials/graphql-ws.md
@@ -43,7 +43,7 @@ yarn add @tsed/graphql-ws graphql-ws
 import {Configuration} from "@tsed/common";
 import "@tsed/platform-express";
 import "@tsed/apollo";
-import "@tsed/graphql-ws";
+import "@tsed/graphql-ws"; // auto import plugin for @tsed/apollo
 import {join} from "path";
 
 @Configuration({
@@ -82,124 +82,49 @@ import {join} from "path";
 export class Server {}
 ```
 
-## Register plugins
+## The PubSub class
 
-You can register plugins with the `plugins` property. The plugins are executed in the order of declaration.
-
-```typescript
-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 {}
-```
-
-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:
-
-```typescript
-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;
-
-  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
-    );
-  }
+::: warning
+The PubSub class is not recommended for production environments, because it's an in-memory event system that only supports a single server instance. After you get subscriptions working in development, we strongly recommend switching it out for a different subclass of the abstract [PubSubEngine](https://github.com/apollographql/graphql-subscriptions/blob/master/src/pubsub-engine.ts)
+class. Recommended subclasses are listed in [Production PubSub libraries](https://www.apollographql.com/docs/apollo-server/data/subscriptions/#production-pubsub-libraries).
+:::
 
-  async $alterApolloServerPlugins(plugins: any[], settings: GraphQLWSOptions) {
-    const wsServer = await this.createWSServer(settings);
+You can use the publish-subscribe (pub/sub) model to track events that update active subscriptions.
+The graphql-subscriptions library provides the PubSub class as a basic in-memory event bus to help you get started:
 
-    this.injector.logger.info(`Create GraphQL WS server on: ${settings.path}`);
+To use the graphql-subscriptions package, first install it like so:
 
-    return plugins.concat({
-      serverWillStart() {
-        return {
-          async drainServer() {
-            await wsServer.dispose();
-          }
-        };
-      }
-    } as any);
-  }
-}
+```shell
+npm install graphql-subscriptions
 ```
 
-::: tip Note
-Ts.ED provide a `@tsed/graphql-ws` package to support the `subscription` feature of GraphQL. See [here](https://tsed.io/api/graphql-ws.html) for more details.
-:::
-
-## Nexus
-
-### Installation
+A `PubSub` instance enables your server code to both `publish` events to a particular label and listen for events associated with a particular label.
+We can create a `PubSub` instance like so:
 
-<Tabs class="-code">
-<Tab label="Express.js">
-
-```bash
-npm install --save @tsed/apollo
-npm install --save nexus graphql apollo-server-express
-npm install --save-dev apollo-server-testing
-```
+```typescript
+import {PubSub} from "graphql-subscriptions";
+import {registerProvider} from "@tsed/di";
 
-</Tab>
-<Tab label="Koa.js">
+export const pubsub = new PubSub();
+export const PubSubProvider = Symbol.for("PubSubProvider");
+export type PubSubProvider = PubSub;
 
-```bash
-npm install --save @tsed/apollo graphql
-npm install --save nexus graphql apollo-server-koa
-npm install --save-dev apollo-server-testing
+registerProvider({provide: PubSub, useValue: pubsub});
 ```
 
-</Tab>
-</Tabs>
+Depending on the schema resolver (nexus, type-graphql, etc.), you can use the `pubsub` instance to publish events and subscribe to them in your resolvers.
 
-Now, we can configure the Ts.ED server by importing `@tsed/apollo` in your Server:
+::: warning
+To use the subscription feature with TypeGraphQL, you have to give pubsub instance to the buildSchemaOptions:
 
 ```typescript
 import {Configuration} from "@tsed/common";
 import "@tsed/platform-express";
 import "@tsed/apollo";
-import {schema} from "./schema";
+import "@tsed/typegraphql";
+import "@tsed/graphql-ws"; // auto import plugin for @tsed/apollo
 import {join} from "path";
+import {pubsub} from "./pubsub/pubsub";
 
 @Configuration({
   apollo: {
@@ -207,212 +132,84 @@ import {join} from "path";
       // GraphQL server configuration
       path: "/",
       playground: true, // enable playground GraphQL IDE. Set false to use Apollo Studio
-      schema,
-      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
+      plugins: [], // Apollo plugins
+      buildSchemaOptions: {
+        pubsub
+      }
+    }
+  },
+  graphqlWs: {
+    // global options
+    wsServerOptions: {
+      // See options descriptions on
+    },
+    wsUseServerOptions: {
+      // See options descriptions on
     }
   }
 })
 export class Server {}
 ```
 
-Then create `schema/index.ts`:
-
-```typescript
-import {makeSchema} from "nexus";
-import {join} from "path";
-
-export const schema = makeSchema({
-  types: [], // 1
-  outputs: {
-    typegen: join(process.cwd(), "..", "..", "nexus-typegen.ts"), // 2
-    schema: join(process.cwd(), "..", "..", "schema.graphql") // 3
-  }
-});
-```
-
-## TypeGraphQL
-
-### Installation
-
-To begin, install the `@tsed/typegraphql` package:
-
-<Tabs class="-code">
-<Tab label="Express.js">
-
-```bash
-npm install --save @tsed/typegraphql graphql apollo-server-express
-npm install --save type-graphql apollo-datasource apollo-datasource-rest
-npm install --save-dev apollo-server-testing
-```
-
-</Tab>
-<Tab label="Koa.js">
-
-```bash
-npm install --save @tsed/typegraphql graphql apollo-server-koa
-npm install --save type-graphql apollo-datasource apollo-datasource-rest
-npm install --save-dev apollo-server-testing
-```
-
-</Tab>
-</Tabs>
-
-Now, we can configure the Ts.ED server by importing `@tsed/typegraphql` in your Server:
-
-<Tabs class="-code">
-  <Tab label="Configuration" icon="bx-code-alt">
-
-<<< @/tutorials/snippets/graphql/server-configuration.ts
-
-  </Tab>
-  <Tab label="CodeSandbox" icon="bxl-codepen">
-
-<iframe src="https://codesandbox.io/embed/tsed-graphql-pgvfz?fontsize=14&hidenavigation=1&theme=dark"
-style="width:100%; height:500px; border:0; border-radius: 4px; overflow:hidden;"
-title="TsED Graphql"
-allow="accelerometer; ambient-light-sensor; camera; encrypted-media; geolocation; gyroscope; hid; microphone; midi;
-payment; usb; vr; xr-spatial-tracking"
-sandbox="allow-forms allow-modals allow-popups allow-presentation allow-same-origin allow-scripts"></iframe>
-
-   </Tab>
-</Tabs>
-
-### Types
-
-We want to get the equivalent of this type described in SDL:
-
-```
-type Recipe {
-  id: ID!
-  title: String!
-  description: String
-  creationDate: Date!
-  ingredients: [String!]!
-}
-```
-
-So we create the Recipe class with all properties and types:
+Here is a simple example of how to use the `pubsub` instance in a resolver using the `type-graphql` library:
 
 ```typescript
-class Recipe {
-  id: string;
-  title: string;
-  description?: string;
-  creationDate: Date;
-  ingredients: string[];
-}
-```
-
-Then we decorate the class and its properties with decorators:
+import {InjectContext, PlatformContext} from "@tsed/common";
+import {Inject} from "@tsed/di";
+import {ResolverController} from "@tsed/typegraphql";
+import {Arg, Mutation, Query, Root, Subscription} from "type-graphql";
+import {RecipeService} from "../../services/RecipeService";
+import {PubSubProvider} from "../pubsub/pubsub.js";
+import {Recipe, RecipeNotification} from "./Recipe";
+import {RecipeNotFoundError} from "./RecipeNotFoundError";
+
+@ResolverController((_of) => Recipe)
+export class RecipeResolver {
+  @InjectContext()
+  private $ctx: PlatformContext;
 
-<<< @/tutorials/snippets/graphql/recipe-type.ts
+  @Inject()
+  private recipeService: RecipeService;
 
-The detailed rules for when to use nullable, array and others are described
-in [fields and types docs](https://typegraphql.com/docs/types-and-fields.html).
+  @Inject(PubSubProvider)
+  private pubSub: PubSubProvider;
 
-### Resolvers
+  @Query((returns) => Recipe)
+  async recipe(@Arg("id") id: string) {
+    const recipe = await this.recipeService.findById(id);
 
-After that we want to create typical crud queries and mutation. To do that we create the resolver (controller) class
-that will have injected RecipeService in the constructor:
+    if (recipe === undefined) {
+      throw new RecipeNotFoundError(id);
+    }
 
-<<< @/tutorials/snippets/graphql/resolver-service.ts
+    return recipe;
+  }
 
-#### Multiple GraphQL server
+  @Query((returns) => [Recipe], {description: "Get all the recipes from around the world "})
+  recipes(): Promise<Recipe[]> {
+    this.$ctx.set("test", "test");
+    return this.recipeService.findAll({});
+  }
 
-If you register multiple GraphQL servers, you must specify the server id in the `@ResolverController` decorator.
+  @Mutation((returns) => Recipe)
+  async addRecipe(@Arg("title") title: string, @Arg("description") description: string) {
+    const payload = await this.recipeService.create({title, description});
+    const notification = new RecipeNotification(payload);
 
-```typescript
-@ResolverController(Recipe, {id: "server1"})
-```
+    this.pubSub.publish("NOTIFICATIONS", notification);
 
-Another solution is to not use `@ResolverController` (use `@Resolver` from TypeGraphQL), and declare explicitly the resolver in the server configuration:
+    return payload;
+  }
 
-```typescript
-@Configuration({
-  graphql: {
-    server1: {
-      resolvers: {
-        RecipeResolver
-      }
-    },
-    server2: {
-      resolvers: {
-        OtherResolver
-      }
-    }
+  @Subscription(() => RecipeNotification, {
+    topics: "RECIPE_ADDED"
+  })
+  newRecipe(@Root() payload: Recipe): RecipeNotification {
+    return {...payload, date: new Date()};
   }
-})
+}
 ```
 
-### Data Source
-
-Data source is one of the Apollo server features which can be used as option for your Resolver or Query. Ts.ED provides
-a @@DataSourceService@@ decorator to declare a DataSource which will be injected to the Apollo server context.
-
-<<< @/tutorials/snippets/graphql/datasource-service.ts
-
-Then you can retrieve your data source through the context in your resolver like that:
-
-<<< @/tutorials/snippets/graphql/resolver-data-source.ts
-
-## Get Server instance
-
-ApolloService (or TypeGraphQLService) lets you to retrieve an instance of ApolloServer.
-
-<<< @/tutorials/snippets/graphql/get-server-instance.ts
-
-For more information about ApolloServer, look at its
-documentation [here](https://www.apollographql.com/docs/apollo-server/api/apollo-server.html);
-
-## Testing
-
-Here is an example to create a test server based on TypeGraphQL and run a query:
-
-::: tip
-
-The unit example is also available to test any Apollo Server!
-:::
-
-<Tabs class="-code">
-  <Tab label="Jest">
-
-<<< @/tutorials/snippets/graphql/testing.jest.ts
-
-  </Tab>
-  <Tab label="Mocha">
-
-<<< @/tutorials/snippets/graphql/testing.mocha.ts
-
-  </Tab>  
-  <Tab label="RecipeResolver.ts">
-
-<<< @/tutorials/snippets/graphql/resolver-service.ts
-
-  </Tab>   
-  <Tab label="RecipesService.ts">
-
-<<< @/tutorials/snippets/graphql/recipes-service.ts
-
-  </Tab>
-  <Tab label="Recipe.ts">
-
-<<< @/tutorials/snippets/graphql/recipe-type.ts
-
-  </Tab>  
-  <Tab label="RecipeArgs.ts">
-
-<<< @/tutorials/snippets/graphql/recipe-args.ts
-
-  </Tab>      
-</Tabs>
-
 ## Author
 
 <GithubContributors users="['Romakita']"/>
diff --git a/docs/tutorials/graphql.md b/docs/tutorials/graphql.md
index f21555c2ae2..8b7ab56b0c4 100644
--- a/docs/tutorials/graphql.md
+++ b/docs/tutorials/graphql.md
@@ -54,6 +54,37 @@ GraphQL Websocket allows you to use the `subscription` feature of GraphQL using
 
 See [here](/tutorials/graphql-ws.md) for more details.
 
+## ApolloService
+
+ApolloService let you retrieve an instance of ApolloServer:
+
+```typescript
+import {Injectable, AfterRoutesInit} from "@tsed/common";
+import {graphQLService} from "@tsed/apollo";
+import {ApolloServer} from "@apollo/server";
+
+@Injectable()
+export class UsersService implements AfterRoutesInit {
+  @Injec()
+  apolloService: ApolloService;
+
+  private server: ApolloServer;
+
+  $afterRoutesInit() {
+    this.server = this.apolloService.get("server1");
+  }
+}
+```
+
+## DataSources
+
+Apollo Server provides a mechanism to fetch data from a REST API or a database. This mechanism is called DataSources.
+Ts.ED allow you to register your DataSources using the @@DataSource@@ decorator.
+
+```typescript
+
+```
+
 ## Testing
 
 Here is an example to create a test server based on TypeGraphQL and run a query:
diff --git a/docs/tutorials/snippets/graphql/datasource-service.ts b/docs/tutorials/snippets/graphql/datasource-service.ts
index bede39f8e02..1a9c7dbfd64 100644
--- a/docs/tutorials/snippets/graphql/datasource-service.ts
+++ b/docs/tutorials/snippets/graphql/datasource-service.ts
@@ -1,6 +1,7 @@
+import {RESTDataSource} from "@apollo/datasource-rest";
 import {DataSource} from "@tsed/typegraphql";
-import {RESTDataSource} from "apollo-datasource-rest";
 import {User} from "../models/User";
+
 @DataSource()
 export class UserDataSource extends RESTDataSource {
   constructor() {
diff --git a/packages/di/src/node/domain/DIContext.ts b/packages/di/src/node/domain/DIContext.ts
index e527ab83919..0b2ecc8326a 100644
--- a/packages/di/src/node/domain/DIContext.ts
+++ b/packages/di/src/node/domain/DIContext.ts
@@ -83,8 +83,8 @@ export class DIContext {
     return this.injector?.emit(eventName, ...args);
   }
 
-  runInContext(next: Function) {
-    return runInContext(this, next);
+  runInContext<Result = unknown>(next: (...args: unknown[]) => Result): Promise<Result> {
+    return runInContext<Result>(this, next);
   }
 
   cache<Value = any>(key: string, cb: () => Value): Value {
diff --git a/packages/di/src/node/utils/asyncHookContext.ts b/packages/di/src/node/utils/asyncHookContext.ts
index 5a0a25483c4..1cd5b7bb98f 100644
--- a/packages/di/src/node/utils/asyncHookContext.ts
+++ b/packages/di/src/node/utils/asyncHookContext.ts
@@ -16,7 +16,11 @@ export function getContext<Context = DIContext>(): Context | undefined {
   return useContextRef()?.current as any;
 }
 
-export async function runInContext(ctx: DIContext | undefined, cb: any, injector?: InjectorService) {
+export async function runInContext<Result = unknown>(
+  ctx: DIContext | undefined,
+  cb: (...args: unknown[]) => Result,
+  injector?: InjectorService
+): Promise<Result> {
   const ref = useContextRef();
 
   if (ref) {
diff --git a/packages/engines/.nycrc b/packages/engines/.nycrc
deleted file mode 100644
index 05605266113..00000000000
--- a/packages/engines/.nycrc
+++ /dev/null
@@ -1,26 +0,0 @@
-{
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "**/*.d.ts",
-    "node_modules",
-    "**/interfaces/**",
-    "**/index.ts"
-  ],
-  "extension": [
-    ".ts"
-  ],
-  "require": [],
-  "reporter": [
-    "text-summary",
-    "html",
-    "lcov",
-    "json"
-  ],
-  "check-coverage": true,
-  "statements": 96.38,
-  "branches": 72.9,
-  "functions": 96.26,
-  "lines": 96.32
-}
diff --git a/packages/graphql/apollo/.nycrc b/packages/graphql/apollo/.nycrc
deleted file mode 100644
index e048e0b21d3..00000000000
--- a/packages/graphql/apollo/.nycrc
+++ /dev/null
@@ -1,26 +0,0 @@
-{
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "**/*.d.ts",
-    "node_modules",
-    "**/interfaces/**",
-    "**/index.ts"
-  ],
-  "extension": [
-    ".ts"
-  ],
-  "require": [],
-  "reporter": [
-    "text-summary",
-    "html",
-    "lcov",
-    "json"
-  ],
-  "check-coverage": true,
-  "statements": 100,
-  "branches": 76.74,
-  "functions": 100,
-  "lines": 100
-}
diff --git a/packages/graphql/apollo/package.json b/packages/graphql/apollo/package.json
index 375a5c2435c..0e30f265d75 100644
--- a/packages/graphql/apollo/package.json
+++ b/packages/graphql/apollo/package.json
@@ -26,32 +26,28 @@
     "tslib": "2.6.1"
   },
   "devDependencies": {
+    "@apollo/datasource-rest": "6.2.2",
+    "@apollo/server": "^4.10.4",
+    "@as-integrations/koa": "1.1.1",
     "@tsed/barrels": "workspace:*",
     "@tsed/common": "workspace:*",
     "@tsed/core": "workspace:*",
     "@tsed/di": "workspace:*",
     "@tsed/logger": ">=6.7.5",
     "@tsed/typescript": "workspace:*",
-    "@types/graphql": "14.5.0",
-    "apollo-datasource": "^3.3.2",
-    "apollo-datasource-rest": "^3.7.0",
-    "apollo-server-core": "^3.13.0",
-    "apollo-server-express": "^3.13.0",
-    "apollo-server-koa": "^3.13.0",
-    "apollo-server-testing": "^2.26.2",
+    "apollo-datasource-http": "0.21.0",
+    "apollo-server-testing": "2.25.3",
     "eslint": "^8.57.0",
-    "graphql": "15.8.0",
+    "graphql": "16.8.2",
     "typescript": "4.9.5",
     "vitest": "2.0.4"
   },
   "peerDependencies": {
+    "@apollo/server": ">=4.10.4",
     "@tsed/common": "8.0.0-alpha.4",
     "@tsed/core": "8.0.0-alpha.4",
     "@tsed/di": "8.0.0-alpha.4",
     "@tsed/logger": ">=6.7.5",
-    "apollo-datasource": ">=3.0.0",
-    "apollo-datasource-rest": ">=3.0.0",
-    "apollo-server-core": ">=3.0.0",
-    "graphql": ">15.0.0"
+    "graphql": ">16.0.0"
   }
 }
diff --git a/packages/graphql/apollo/readme.md b/packages/graphql/apollo/readme.md
index d867cac85f1..845de6f1808 100644
--- a/packages/graphql/apollo/readme.md
+++ b/packages/graphql/apollo/readme.md
@@ -45,8 +45,7 @@ If you're looking for integration with TypeGraphQL see the [`@tsed/typegraphql`]
 To begin, install the Apollo module for TS.ED:
 
 ```bash
-npm install --save @tsed/apollo graphql@15
-npm install --save apollo-datasource apollo-datasource-rest apollo-server-express
+npm install --save @tsed/apollo graphql@15 @apollo/server apollo/datasource-rest
 npm install --save-dev  apollo-server-testing
 ```
 
@@ -68,28 +67,6 @@ import "@tsed/apollo";
 export class Server {}
 ```
 
-## ApolloService
-
-ApolloService let you to retrieve an instance of ApolloServer.
-
-```typescript
-import {Injectable, AfterRoutesInit} from "@tsed/common";
-import {graphQLService} from "@tsed/apollo";
-import {ApolloServer} from "apollo-server-express";
-
-@Injectable()
-export class UsersService implements AfterRoutesInit {
-  @Injec()
-  apolloService: ApolloService;
-
-  private server: ApolloServer;
-
-  $afterRoutesInit() {
-    this.server = this.apolloService.get("server1");
-  }
-}
-```
-
 For more information about ApolloServer look his documentation [here](https://www.apollographql.com/docs/apollo-server/api/apollo-server.html);
 
 ## Contributors
diff --git a/packages/graphql/apollo/src/ApolloModule.ts b/packages/graphql/apollo/src/ApolloModule.ts
index 7ddfd68e432..1436f7a9d5e 100644
--- a/packages/graphql/apollo/src/ApolloModule.ts
+++ b/packages/graphql/apollo/src/ApolloModule.ts
@@ -1,5 +1,5 @@
 import {AfterListen, Logger, OnRoutesInit} from "@tsed/common";
-import {Configuration, Inject, Module} from "@tsed/di";
+import {Configuration, Inject, Module, InjectorService} from "@tsed/di";
 import {ApolloSettings} from "./interfaces/ApolloSettings.js";
 import {ApolloService} from "./services/ApolloService.js";
 
@@ -14,19 +14,24 @@ export class ApolloModule implements OnRoutesInit, AfterListen {
   @Configuration()
   protected configuration: Configuration;
 
+  @Inject(InjectorService)
+  protected injector: InjectorService;
+
   get settings(): {[key: string]: ApolloSettings} | undefined {
-    return this.configuration.get("apollo");
+    return this.configuration.get("apollo", this.configuration.get("graphql", this.configuration.get("typegraphql")));
   }
 
-  $onRoutesInit(): Promise<any> | void {
-    const {settings} = this;
+  async $onRoutesInit(): Promise<void> {
+    const {settings, injector} = this;
 
     if (settings) {
-      const promises = Object.entries(settings).map(([key, options]) => {
-        return this.service.createServer(key, options);
+      const promises = Object.entries(settings).map(async ([id, options]) => {
+        options = await injector.alterAsync("$alterApolloSettings", {id, ...options});
+
+        return this.service.createServer(id, options);
       });
 
-      return Promise.all(promises);
+      await Promise.all(promises);
     }
   }
 
@@ -36,7 +41,7 @@ export class ApolloModule implements OnRoutesInit, AfterListen {
     const displayLog = (key: string, path: string) => {
       const url = typeof host.port === "number" ? `${host.protocol}://${host.address}:${host.port}` : "";
 
-      this.logger.info(`[${key}] Apollo server is available on ${url}${path.replace(/^\//, "")}`);
+      this.logger.info(`[${key}] Apollo server is available on ${url}/${path.replace(/^\//, "")}`);
     };
 
     const {settings} = this;
diff --git a/packages/graphql/apollo/src/constants/constants.ts b/packages/graphql/apollo/src/constants/constants.ts
index 17eabc9f29f..0e8413ab8f6 100644
--- a/packages/graphql/apollo/src/constants/constants.ts
+++ b/packages/graphql/apollo/src/constants/constants.ts
@@ -1 +1,2 @@
 export const DATASOURCES_PROVIDERS = "graphql:datasources";
+export const APOLLO_CONTEXT = Symbol.for("APOLLO_CONTEXT");
diff --git a/packages/graphql/apollo/src/decorators/dataSource.ts b/packages/graphql/apollo/src/decorators/dataSource.ts
index 55f2f9ea883..332c10f5049 100644
--- a/packages/graphql/apollo/src/decorators/dataSource.ts
+++ b/packages/graphql/apollo/src/decorators/dataSource.ts
@@ -7,7 +7,7 @@ import {DATASOURCES_PROVIDERS} from "../constants/constants.js";
  *
  * ```typescript
  * import { DataSourceService } from "@tsed/graphql";
- * import { RESTDataSource } from 'apollo-datasource-rest';
+ * import { RESTDataSource } from '@apollo/datasource-rest';
  *
  * @DataSource()
  * export class MyDataSource extends RESTDataSource {
@@ -44,7 +44,7 @@ export function DataSource(name?: string): ClassDecorator {
  *
  * ```typescript
  * import { DataSourceService } from "@tsed/graphql";
- * import { RESTDataSource } from 'apollo-datasource-rest';
+ * import { RESTDataSource } from '@apollo/datasource-rest';
  *
  * @DataSource()
  * export class MyDataSource extends RESTDataSource {
diff --git a/packages/graphql/apollo/src/decorators/injectApolloContext.ts b/packages/graphql/apollo/src/decorators/injectApolloContext.ts
new file mode 100644
index 00000000000..42adce68908
--- /dev/null
+++ b/packages/graphql/apollo/src/decorators/injectApolloContext.ts
@@ -0,0 +1,20 @@
+import {DecoratorParameters, decoratorTypeOf, DecoratorTypes} from "@tsed/core";
+import {Inject, InjectContext} from "@tsed/di";
+import {APOLLO_CONTEXT} from "../constants/constants";
+
+/**
+ * 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]);
+    }
+  };
+}
diff --git a/packages/graphql/apollo/src/index.ts b/packages/graphql/apollo/src/index.ts
index 375d1d1c4b7..c7b416e7a29 100644
--- a/packages/graphql/apollo/src/index.ts
+++ b/packages/graphql/apollo/src/index.ts
@@ -4,5 +4,10 @@
 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";
diff --git a/packages/graphql/apollo/src/interfaces/AlterApolloContext.ts b/packages/graphql/apollo/src/interfaces/AlterApolloContext.ts
new file mode 100644
index 00000000000..bab90bb1f88
--- /dev/null
+++ b/packages/graphql/apollo/src/interfaces/AlterApolloContext.ts
@@ -0,0 +1,6 @@
+import type {PlatformContext} from "@tsed/common";
+import type {ApolloContext} from "./ApolloContext";
+
+export interface AlterApolloContext<Context extends ApolloContext = ApolloContext> {
+  $alterApolloContext(context: Context, $ctx: PlatformContext): Context | Promise<Context>;
+}
diff --git a/packages/graphql/apollo/src/interfaces/AlterApolloServerPlugins.ts b/packages/graphql/apollo/src/interfaces/AlterApolloServerPlugins.ts
new file mode 100644
index 00000000000..3c577431e72
--- /dev/null
+++ b/packages/graphql/apollo/src/interfaces/AlterApolloServerPlugins.ts
@@ -0,0 +1,9 @@
+import type {ApolloServerPlugin} from "@apollo/server";
+import type {ApolloSettings} from "./ApolloSettings";
+
+export interface AlterApolloServerPlugins {
+  $alterApolloServerPlugins(
+    plugins: ApolloServerPlugin[],
+    serverSettings: ApolloSettings
+  ): ApolloServerPlugin[] | Promise<ApolloServerPlugin[]>;
+}
diff --git a/packages/graphql/apollo/src/interfaces/AlterApolloSettings.ts b/packages/graphql/apollo/src/interfaces/AlterApolloSettings.ts
new file mode 100644
index 00000000000..0e7bc5ab001
--- /dev/null
+++ b/packages/graphql/apollo/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>>;
+}
diff --git a/packages/graphql/apollo/src/interfaces/ApolloContext.ts b/packages/graphql/apollo/src/interfaces/ApolloContext.ts
new file mode 100644
index 00000000000..36466aa5018
--- /dev/null
+++ b/packages/graphql/apollo/src/interfaces/ApolloContext.ts
@@ -0,0 +1,5 @@
+import type {BaseContext} from "@apollo/server";
+
+export interface ApolloContext extends BaseContext {
+  dataSources: Record<string, unknown>;
+}
diff --git a/packages/graphql/apollo/src/interfaces/ApolloSettings.ts b/packages/graphql/apollo/src/interfaces/ApolloSettings.ts
index 6918b9f6420..12f61aff473 100644
--- a/packages/graphql/apollo/src/interfaces/ApolloSettings.ts
+++ b/packages/graphql/apollo/src/interfaces/ApolloSettings.ts
@@ -1,9 +1,11 @@
-import type {ApolloServerBase, ApolloServerPluginLandingPageGraphQLPlaygroundOptions, Config} from "apollo-server-core";
+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";
+import {ApolloContext} from "./ApolloContext";
 
 export type ApolloMiddlewareOptions = Record<string, any>;
-export type ApolloServer = ApolloServerBase & {getMiddleware(settings: ApolloMiddlewareOptions): any};
-export type ApolloCustomServerCB = (config: ApolloConfig) => ApolloServer;
-export type ApolloConfig = Config;
+export type ApolloCustomServerCB<TContext extends ApolloContext> = (config: ApolloServerOptions<TContext>) => ApolloServer<TContext>;
 
 declare global {
   namespace TsED {
@@ -11,13 +13,31 @@ declare global {
   }
 }
 
-export interface ApolloSettings extends ApolloConfig, TsED.ApolloSettings {
-  // Basic options
-  path: string;
-  server?: ApolloCustomServerCB;
-  playground?: boolean | ApolloServerPluginLandingPageGraphQLPlaygroundOptions;
-  // ApplyMiddleware Options
-  // See options descriptions on https://www.apollographql.com/docs/apollo-server/api/apollo-server.html
-  serverRegistration?: ApolloMiddlewareOptions;
-  middlewareOptions?: ApolloMiddlewareOptions;
-}
+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;
+};
diff --git a/packages/graphql/apollo/src/services/ApolloService.spec.ts b/packages/graphql/apollo/src/services/ApolloService.spec.ts
index 16a8f23d846..0ea75b00a0a 100644
--- a/packages/graphql/apollo/src/services/ApolloService.spec.ts
+++ b/packages/graphql/apollo/src/services/ApolloService.spec.ts
@@ -1,38 +1,74 @@
-import {PlatformApplication, PlatformTest} from "@tsed/common";
-import {RESTDataSource} from "apollo-datasource-rest";
+import {RESTDataSource} from "@apollo/datasource-rest";
+import {ApolloServer, ApolloServerPlugin} from "@apollo/server";
+import {InjectContext, Logger, Opts, PlatformApplication, PlatformContext, PlatformTest} from "@tsed/common";
+import {catchAsyncError} from "@tsed/core";
+import {Configuration, Constant, Module, runInContext} from "@tsed/di";
+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-express", () => {
+vi.mock("@apollo/server/express4", () => {
   return {
-    ApolloServer: class {
-      start = vi.fn();
-      getMiddleware = vi.fn();
-
-      constructor(public opts: any) {}
-    }
+    __esModule: true,
+    expressMiddleware: vi.fn().mockReturnValue("expressMiddleware")
   };
 });
-vi.mock("apollo-server-koa", () => {
+vi.mock("@as-integrations/koa", () => {
   return {
-    ApolloServer: class {
-      start = vi.fn();
-      getMiddleware = vi.fn();
-
-      constructor(public opts: any) {}
-    }
+    __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 {
-  constructor() {
-    super();
-    this.baseURL = "http://localhost:8001";
+  @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(request: any) {
-    request.headers.set("Authorization", this.context.token);
+  willSendRequest(path: string, request: any) {
+    request.headers["authorization"] = this.context.token;
   }
 
   getMyData(id: string) {
@@ -42,25 +78,71 @@ export class MyDataSource extends RESTDataSource {
 
 @DataSource("myName")
 export class MyDataSource2 extends RESTDataSource {
+  @InjectContext()
+  $ctx: PlatformContext;
+
   constructor() {
     super();
     this.baseURL = "http://localhost:8001";
   }
 
-  willSendRequest(request: any) {
-    request.headers.set("Authorization", this.context.token);
-  }
-
   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"
+        PLATFORM_NAME: "express",
+        envs: {
+          MOVIES_API_URL: "http://localhost:8001"
+        }
       })
     );
     afterEach(() => {
@@ -68,73 +150,102 @@ describe("ApolloService", () => {
     });
 
     describe("createServer()", () => {
-      describe("when server options isn't given", () => {
-        it("should create a server", async () => {
-          // GIVEN
-          const service = PlatformTest.get<ApolloService>(ApolloService);
-          const app = PlatformTest.get(PlatformApplication);
+      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();
 
-          vi.spyOn(app, "use").mockReturnThis();
+        const opts = {
+          path: "/path",
+          server: serverMock
+        } as never;
 
-          // WHEN
-          const result1 = await service.createServer("key", {
-            path: "/path"
-          } as any);
+        vi.spyOn(logger, "error");
 
-          const result2 = await service.createServer("key", {path: "/path"} as any);
+        serverMockInstance.start.mockRejectedValue(new Error("test"));
 
-          expect(service.getSchema("key")).toEqual(undefined);
-          expect(service.getSchema()).toEqual(undefined);
-          expect(result2).toEqual(result1);
-          expect(result1.getMiddleware).toHaveBeenCalledWith({
-            path: "/path"
-          });
+        // WHEN
+        const result = await catchAsyncError(() => service.createServer("key", opts));
 
-          expect(typeof (result1 as any).opts.dataSources).toEqual("function");
+        expect(result).toEqual(new Error("test"));
+        expect(logger.error).toHaveBeenCalledWith({
+          error_name: "Error",
+          event: "APOLLO_BOOTSTRAP_ERROR",
+          message: "test",
+          stack: expect.any(String)
         });
       });
     });
-  });
-  describe("when platform is koa", () => {
-    beforeEach(() =>
-      PlatformTest.create({
-        PLATFORM_NAME: "koa"
-      })
-    );
-    afterEach(() => {
-      return PlatformTest.reset();
-    });
 
-    describe("createServer()", () => {
-      describe("when server options isn't given", () => {
-        it("should create a server", async () => {
-          // GIVEN
-          const service = PlatformTest.get<ApolloService>(ApolloService);
-          const app = PlatformTest.get(PlatformApplication);
-
-          vi.spyOn(app, "use").mockReturnThis();
-
-          // WHEN
-          const result1 = await service.createServer("key", {
-            path: "/path"
-          } as any);
-
-          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(result1.getMiddleware).toHaveBeenCalledWith({
-            path: "/path"
-          });
-        });
+    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 unknown", () => {
+  describe("when platform is koa", () => {
     beforeEach(() =>
       PlatformTest.create({
-        PLATFORM_NAME: "unkown"
+        PLATFORM_NAME: "koa"
       })
     );
     afterEach(() => {
@@ -142,35 +253,33 @@ describe("ApolloService", () => {
     });
 
     describe("createServer()", () => {
-      describe("when server options isn't given", () => {
-        it("should create a server", async () => {
-          // GIVEN
-          const service = PlatformTest.get<ApolloService>(ApolloService);
-          const app = PlatformTest.get(PlatformApplication);
-
-          vi.spyOn(app, "use").mockReturnThis();
-
-          // WHEN
-          const result1 = await service.createServer("key", {
-            path: "/path"
-          } as any);
-
-          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(result1.getMiddleware).toHaveBeenCalledWith({
-            path: "/path"
-          });
+      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 given", () => {
+  describe("when platform is unknown", () => {
     beforeEach(() =>
       PlatformTest.create({
-        PLATFORM_NAME: "express"
+        PLATFORM_NAME: "unknown"
       })
     );
     afterEach(() => {
@@ -178,32 +287,28 @@ describe("ApolloService", () => {
     });
 
     describe("createServer()", () => {
-      describe("when server options isn't given", () => {
-        it("should create a server", async () => {
-          // GIVEN
-          const service = PlatformTest.get<ApolloService>(ApolloService);
-          const app = PlatformTest.get(PlatformApplication);
-
-          vi.spyOn(app, "use").mockReturnThis();
-
-          class ApolloServer {
-            start = vi.fn();
-            getMiddleware = vi.fn();
-
-            constructor(opts: any) {}
-          }
-
-          // WHEN
-          const result1 = await service.createServer("key", {
-            path: "/path",
-            server: (options: any) => new ApolloServer(options)
-          } as any);
-
-          expect(service.getSchema("key")).toEqual(undefined);
-          expect(service.getSchema()).toEqual(undefined);
-          expect(result1.getMiddleware).toHaveBeenCalledWith({
-            path: "/path"
-          });
+      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)"
         });
       });
     });
diff --git a/packages/graphql/apollo/src/services/ApolloService.ts b/packages/graphql/apollo/src/services/ApolloService.ts
index a6b281c68c1..62788b21473 100644
--- a/packages/graphql/apollo/src/services/ApolloService.ts
+++ b/packages/graphql/apollo/src/services/ApolloService.ts
@@ -1,21 +1,17 @@
-import {InjectorService, PlatformApplication} from "@tsed/common";
-import {classOf, nameOf, Store} from "@tsed/core";
+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 {getContext, InjectorService, LocalsContainer, PlatformApplication, PlatformContext, Provider} from "@tsed/common";
 import {Constant, Inject, Service} from "@tsed/di";
 import {Logger} from "@tsed/logger";
-import type {Config} from "apollo-server-core";
-import {
-  ApolloServerBase,
-  ApolloServerPluginDrainHttpServer,
-  ApolloServerPluginLandingPageDisabled,
-  ApolloServerPluginLandingPageLocalDefault
-} from "apollo-server-core";
-import {PluginDefinition} from "apollo-server-core/src/types";
 import type {GraphQLSchema} from "graphql";
 import Http from "http";
 import Https from "https";
-import {DATASOURCES_PROVIDERS} from "../constants/constants.js";
-import type {ApolloServer, ApolloSettings} from "../interfaces/ApolloSettings.js";
-import {ApolloCustomServerCB} from "../interfaces/ApolloSettings.js";
+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 {
@@ -33,8 +29,10 @@ export class ApolloService {
   protected servers: Map<
     string,
     {
-      instance: ApolloServerBase;
-      schema: GraphQLSchema | undefined;
+      instance: ApolloServer<ApolloContext>;
+      schema?: GraphQLSchema;
+      typeDefs?: IExecutableSchemaDefinition<ApolloContext>["typeDefs"];
+      resolvers?: IExecutableSchemaDefinition<ApolloContext>["resolvers"];
     }
   > = new Map();
 
@@ -50,9 +48,7 @@ export class ApolloService {
   @Inject()
   private injector: InjectorService;
 
-  constructor(@Inject(DATASOURCES_PROVIDERS) protected dataSources: any[]) {}
-
-  async createServer(id: string, settings: ApolloSettings): Promise<ApolloServer> {
+  async createServer(id: string, settings: ApolloSettings) {
     if (!this.has(id)) {
       try {
         const {dataSources, path, middlewareOptions = {}, server: customServer, ...config} = settings;
@@ -62,29 +58,56 @@ export class ApolloService {
 
         const plugins = await this.getPlugins(settings);
 
-        const server = await this.createInstance(
+        const server = this.createInstance(
           {
             ...config,
-            plugins,
-            dataSources: this.createDataSources(dataSources)
-          },
+            plugins
+          } as never,
           customServer
         );
 
         if (server) {
           this.servers.set(id || "default", {
             instance: server,
-            schema: settings.schema
+            schema: settings.schema,
+            typeDefs: settings.typeDefs,
+            resolvers: settings.resolvers
           });
 
           await server.start();
 
-          const middleware = server.getMiddleware({
-            path: settings.path,
-            ...middlewareOptions
-          });
-
-          this.app.use(middleware);
+          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({
@@ -93,30 +116,40 @@ export class ApolloService {
           message: er.message,
           stack: er.stack
         });
-        /* istanbul ignore next */
-        process.exit(-1);
+        throw er;
       }
     }
 
-    return this.get(id) as ApolloServer;
+    return this.get(id)!;
   }
 
   /**
    * Get an instance of ApolloServer from his id
    * @returns ApolloServer
    */
-  get(id: string = "default"): ApolloServerBase | undefined {
+  get(id: string = "default"): ApolloServer<ApolloContext> | undefined {
     return this.servers.get(id)?.instance;
   }
 
   /**
-   * Get an instance of GraphQL schema from his id
+   * Get schema of the ApolloServer from his id
    * @returns GraphQLSchema
    */
-  getSchema(id: string = "default"): GraphQLSchema | undefined {
+  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
@@ -126,57 +159,53 @@ export class ApolloService {
     return this.servers.has(id);
   }
 
-  protected async createInstance(options: Config, server?: ApolloCustomServerCB): Promise<ApolloServer | undefined> {
-    if (server) {
-      return server(options);
-    }
-
-    const importServer = async () => {
-      switch (this.platformName) {
-        default:
-          this.logger.error(`Platform "${this.platformName}" not supported by @tsed/apollo`);
-        case "express":
-          return (await import("apollo-server-express")).ApolloServer;
-        case "koa":
-          return (await import("apollo-server-koa")).ApolloServer;
-      }
-    };
-
-    const Server = await importServer();
-
-    return new Server(options);
-  }
-
   /**
    * create a new dataSources function to use with apollo server config
-   * @param dataSources
    */
-  protected createDataSources(dataSources: Function | undefined) {
-    const dataSourcesHash = this.dataSources.reduce((map, instance) => {
-      const klass = classOf(instance);
-      const store = Store.from(klass);
-      let {name} = store.get(DATASOURCES_PROVIDERS);
+  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 || nameOf(klass);
+      name = name || provider.className;
 
       const sourceName = `${name[0].toLowerCase()}${name.slice(1)}`;
-      map[sourceName] = instance;
+      map.set(sourceName, provider);
 
       return map;
-    }, {});
+    }, new Map<string, Provider>());
 
-    return () => {
-      return {
-        ...dataSourcesHash,
-        ...(dataSources ? dataSources() : {})
+    return async () => {
+      const $ctx = getContext() as PlatformContext;
+      const context: ApolloContext = {
+        dataSources: {
+          ...(settings.dataSources?.() || {})
+        }
       };
+
+      const alteredContext = await this.injector.alterAsync("$alterApolloContext", context, $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;
     };
   }
 
-  private async getPlugins(serverSettings: ApolloSettings): Promise<PluginDefinition[]> {
+  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.alter(
+    const result = await this.injector.alterAsync(
       "$alterApolloServerPlugins",
       [
         this.httpServer &&
diff --git a/packages/graphql/apollo/vitest.config.mts b/packages/graphql/apollo/vitest.config.mts
index 7560b534998..d759e817941 100644
--- a/packages/graphql/apollo/vitest.config.mts
+++ b/packages/graphql/apollo/vitest.config.mts
@@ -10,12 +10,12 @@ export default defineConfig(
       coverage: {
         ...presets.test.coverage,
         thresholds: {
-          statements: 71.95,
-          branches: 74.07,
-          functions: 91.66,
-          lines: 71.95
+          statements: 0,
+          branches: 0,
+          functions: 0,
+          lines: 0
         }
       }
     }
   }
-);
\ No newline at end of file
+);
diff --git a/packages/graphql/graphql-ws/package.json b/packages/graphql/graphql-ws/package.json
index 6d9fead5215..b23dbd802de 100644
--- a/packages/graphql/graphql-ws/package.json
+++ b/packages/graphql/graphql-ws/package.json
@@ -31,7 +31,7 @@
     "@tsed/logger": ">=6.7.5",
     "@tsed/typescript": "workspace:*",
     "eslint": "^8.57.0",
-    "graphql-ws": "^5.15.0",
+    "graphql-ws": "5.16.0",
     "typescript": "4.9.5"
   },
   "peerDependencies": {
diff --git a/packages/graphql/graphql-ws/readme.md b/packages/graphql/graphql-ws/readme.md
index bb1fb9b47d1..b5e0d2f8f70 100644
--- a/packages/graphql/graphql-ws/readme.md
+++ b/packages/graphql/graphql-ws/readme.md
@@ -60,12 +60,12 @@ export class Server {}
 
 ## ApolloService
 
-ApolloService let you to retrieve an instance of ApolloServer.
+ApolloService let you retrieve an instance of ApolloServer.
 
 ```typescript
 import {Injectable, AfterRoutesInit} from "@tsed/common";
 import {graphQLService} from "@tsed/apollo";
-import {ApolloServer} from "apollo-server-express";
+import {ApolloServer} from "@apollo/server";
 
 @Injectable()
 export class UsersService implements AfterRoutesInit {
diff --git a/packages/orm/adapters-redis/.nycrc b/packages/orm/adapters-redis/.nycrc
deleted file mode 100644
index 078595b9b5c..00000000000
--- a/packages/orm/adapters-redis/.nycrc
+++ /dev/null
@@ -1,26 +0,0 @@
-{
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "**/*.d.ts",
-    "node_modules",
-    "**/interfaces/**",
-    "**/index.ts"
-  ],
-  "extension": [
-    ".ts"
-  ],
-  "require": [],
-  "reporter": [
-    "text-summary",
-    "html",
-    "lcov",
-    "json"
-  ],
-  "check-coverage": true,
-  "statements": 100,
-  "branches": 78.22,
-  "functions": 100,
-  "lines": 100
-}
diff --git a/packages/orm/ioredis/.nycrc b/packages/orm/ioredis/.nycrc
deleted file mode 100644
index 078595b9b5c..00000000000
--- a/packages/orm/ioredis/.nycrc
+++ /dev/null
@@ -1,26 +0,0 @@
-{
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "**/*.d.ts",
-    "node_modules",
-    "**/interfaces/**",
-    "**/index.ts"
-  ],
-  "extension": [
-    ".ts"
-  ],
-  "require": [],
-  "reporter": [
-    "text-summary",
-    "html",
-    "lcov",
-    "json"
-  ],
-  "check-coverage": true,
-  "statements": 100,
-  "branches": 78.22,
-  "functions": 100,
-  "lines": 100
-}
diff --git a/packages/third-parties/socketio/.nycrc b/packages/third-parties/socketio/.nycrc
deleted file mode 100644
index 3c499e50bb6..00000000000
--- a/packages/third-parties/socketio/.nycrc
+++ /dev/null
@@ -1,27 +0,0 @@
-{
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "**/*.spec.ts",
-    "**/*.d.ts",
-    "node_modules",
-    "**/interfaces/**",
-    "**/index.ts"
-  ],
-  "extension": [
-    ".ts"
-  ],
-  "require": [],
-  "reporter": [
-    "text-summary",
-    "html",
-    "lcov",
-    "json"
-  ],
-  "check-coverage": true,
-  "statements": 100,
-  "branches": 81.56,
-  "functions": 97.33,
-  "lines": 100
-}
diff --git a/packages/third-parties/sse/.nycrc b/packages/third-parties/sse/.nycrc
deleted file mode 100644
index 3c499e50bb6..00000000000
--- a/packages/third-parties/sse/.nycrc
+++ /dev/null
@@ -1,27 +0,0 @@
-{
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "**/*.spec.ts",
-    "**/*.d.ts",
-    "node_modules",
-    "**/interfaces/**",
-    "**/index.ts"
-  ],
-  "extension": [
-    ".ts"
-  ],
-  "require": [],
-  "reporter": [
-    "text-summary",
-    "html",
-    "lcov",
-    "json"
-  ],
-  "check-coverage": true,
-  "statements": 100,
-  "branches": 81.56,
-  "functions": 97.33,
-  "lines": 100
-}
diff --git a/packages/third-parties/stripe/.nycrc b/packages/third-parties/stripe/.nycrc
deleted file mode 100644
index 94e60948f71..00000000000
--- a/packages/third-parties/stripe/.nycrc
+++ /dev/null
@@ -1,26 +0,0 @@
-{
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "**/*.d.ts",
-    "node_modules",
-    "**/interfaces/**",
-    "**/index.ts"
-  ],
-  "extension": [
-    ".ts"
-  ],
-  "require": [],
-  "reporter": [
-    "text-summary",
-    "html",
-    "lcov",
-    "json"
-  ],
-  "check-coverage": true,
-  "statements": 99,
-  "branches": 75,
-  "functions": 93.33,
-  "lines": 98.96
-}