Introduce new hooks

Author: ardatan

docs/guides/apollo-server.md

@@ -22,6 +22,11 @@ const AppModule = new GraphQLModule({
     /*...*/
 });
 
+const server = new ApolloServer({
+  schema: AppModule.schema,
+  context: session => session,
+})
+// or use `modules` in `ApolloServer`
 const server = new ApolloServer({
   modules: [
     AppModule

docs/guides/data-sources.md

@@ -115,11 +115,10 @@ As described in Apollo Server docs, GraphQL-Modules also uses in-memory caching
 You can share GraphQL-Modules cache mechanism with your GraphQL Server;
 
 ```typescript
-  const { schema, context, cache } = YourGraphQLModule;
+  const { schema, cache } = YourGraphQLModule;
 
   new ApolloServer({
     schema,
-    context,
     cache
   });
 ```

docs/introduction/context.md

@@ -92,21 +92,18 @@ export interface User {
   lastName: string;
 }
 
-export interface IAuthModuleContext {
-  currentUser: User;
-}
-
-export interface IAuthModuleRequest {
+export interface ISession {
   req: express.Request;
+  res: express.Response;
 }
 
-export const AuthModule = new GraphQLModule<{}, IAuthModuleRequest, IAuthModuleContext>({
+export const AuthModule = new GraphQLModule({
     typeDefs,
     resolvers,
     providers: [
       AuthenticationProvider,
     ],
-    async context(session, currentContext, { injector }) {
+    async context(session: ISession, currentContext, { injector }) {
         const authToken = session.req.headers.authentication;
         const currentUser = injector.get(AuthenticationProvider).authorizeUser(authToken);
         return {

docs/introduction/dependency-injection.md

@@ -220,18 +220,44 @@ export const MyModule = new GraphQLModule({
 
 ## Hooks
 
-### `OnRequest hook`
+### `OnInit` hook
+
+This hook is called once when your application is started.
+
+Example;
+
+```typescript
+import { Injectable } from '@graphql-modules/di';
+import { OnRequest } from '@graphql-modules/core';
+@Injectable()
+export class DatabaseProvider implements OnInit {
+    constructor(private dbClient: DbClient) {}
+    onInit() {
+        this.dbClient.connect();
+        console.info('Database Client is connected!');
+    }
+}
+```
+
+### `OnRequest` hook
 
 You can get access to useful information: the top `GraphQLModule` instance, GraphQL Context, and the network session by defining this hook as a method in your class provider.
 
 ```typescript
 import { Injectable, OnRequest } from '@graphql-modules/core';
 
-@Injectable()
-export class MyProvider implements OnRequest {
+Example;
 
+@Injectable({
+    scope: ProviderScope.Session
+})
+export class AuthProvider implements OnRequest {
+    userId: string;
     onRequest(moduleSessionInfo: ModuleSessionInfo) {
         // ...do your magic...
+        // Let's assume you have your network request object under req property of network session
+        const authToken = moduleSessionInfo.session.req.headers.authentication;
+        this.userId = someFnForTokenExchange(authToken);
     }
 }
 ```
@@ -240,26 +266,93 @@ export class MyProvider implements OnRequest {
 [API of `OnRequest` is available here](/docs/api/core/api-interfaces-onrequest)
 [API of `ModuleSessionInfo` is available here](/docs/api/core/api-classes-modulesessioninfo)
 
+### `OnResponse` hook (experimental)
+
+It takes same parameter like `OnRequest` hook but it gets called even before the server sends HTTP response to the client.
+
+Example;
+
+```typescript
+import { Injectable, OnResponse } from '@graphql-modules/core';
+
+@Injectable()
+export class MyProvider implements OnResponse {
+
+    onResponse(moduleSessionInfo: ModuleSessionInfo) {
+        // ...do your magic...
+        clearDatabasePool(moduleSessionInfo.session);
+    }
+}
+```
+
+#### Note:
+> For now it only works with Apollo-Server, and you need to pass `formatResponse` from GraphQL-Modules.
+```typescript
+const { schema, formatResponse } = new GraphQLModule({
+    providers: [MyProvider],
+    ...
+});
+
+new ApolloServer({
+    schema,
+    context: session => session,
+    formatResponse
+});
+```
+
+
+> `OnResponse` hook is called on each HTTP GraphQL request with a single `ModuleSessionInfo` parameter.
+[API of `OnResponse` is available here](/docs/api/core/api-interfaces-onresponse)
+[API of `ModuleSessionInfo` is available here](/docs/api/core/api-classes-modulesessioninfo)
+
 ### `OnConnect hook`
 
 This hook is similar to `OnRequest` hook, but this is called on the initialization of WebSockets connection. It is exactly same with `OnConnect` hook that is passed to `subscriptions` in **Apollo Server**.
 
 [You can learn more from Apollo docs.](https://www.apollographql.com/docs/graphql-subscriptions/authentication.html)
 
+Example;
+
 ```typescript
 import { Injectable, OnConnect } from '@graphql-modules/core';
 
+@Injectable({
+    scope: ProviderScope.Session
+})
+export class AuthProvider implements OnConnect {
+    userId: string;
+    onConnect(connectionParams) {
+        // ...do your magic...
+        const authToken = connectionParams.authentication;
+        this.userId = someFnForTokenExchange(authToken);
+    }
+}
+```
+
+> `OnConnect` hook is called once for each WebSocket GraphQL connection.
+[API of `OnConnect` is available here](/docs/api/core/api-interfaces-onconnct)
+
+### `OnDisconnect hook`
+
+This hook is similar to `OnResponse` hook, but this is called on the termination of WebSockets connection. It is exactly same with `OnDisconnect` hook that is passed to `subscriptions` in **Apollo Server**.
+
+[You can learn more from Apollo docs.](https://www.apollographql.com/docs/graphql-subscriptions/authentication.html)
+
+```typescript
+import { Injectable, OnDisconnect } from '@graphql-modules/core';
+
 @Injectable()
-export class MyProvider implements OnConnect {
+export class MyProvider implements OnDisconnect {
 
-    onConnect(connectionParams, webSocket) {
+    onDisconnect(connectionParams, webSocket) {
         // ...do your magic...
+        clearSomeSubscriptions(moduleSessionInfo.session);
     }
 }
 ```
 
-> `OnConnect` hook is called once for each WebSocket GraphQL connection.
-[API of `OnConnect` is available here](/docs/api/core/api-interfaces-onrequest)
+> `OnDisconnect` hook is called once for each WebSocket GraphQL connection.
+[API of `OnDisconnect` is available here](/docs/api/core/api-interfaces-ondisconnect)
 
 ## Provider Scopes
 

docs/introduction/subscriptions.md

@@ -65,7 +65,7 @@ Subscriptions need to have defined `PubSub` implementation in your GraphQL-Modul
 You have to export `subscriptions` from your `AppModule`, and pass it to your GraphQL Server.
 
 ```typescript
-  const { schema, context, subscriptions } = new GraphQLModule({
+  const { schema, subscriptions } = new GraphQLModule({
     imports: [
       CommonModule,
       PostsModule
@@ -74,7 +74,7 @@ You have to export `subscriptions` from your `AppModule`, and pass it to your Gr
 
   const server = new ApolloServer({
     schema,
-    context,
+    context: session => session,
     subscriptions
   });
 

docs/introduction/understanding-session.md

@@ -0,0 +1,134 @@
+---
+id: understanding-session
+title: Understanding Session
+sidebar_label: Understanding Session
+---
+
+When a GraphQL request arrives in GraphQL-Modules, GraphQL-Modules creates a scope only for that network request. GraphQL-Modules identifies this scope by a unique object that is given in the global application context. Global application context defined in your GraphQL server or library is not the same with module's context; because every resolvers, context builders, dependency injection and all other logics like these are encapsulated.
+
+You can decide how you want to pass this session object like in your application context building phase.
+
+GraphQL-Modules tries to get `session` property of your global application context first, but if there is no `session` property, it takes all application context object as your network session object.
+
+### Using in `express-graphql`
+For example `express-graphql` passes `express.Request` by default as global application context;
+
+```typescript
+    const MyModule = new GraphQLModule({
+        context(session: express.Request) {
+            return {
+                authToken: session.headers.authorization,
+            };
+        }
+    });
+
+    // Some express code
+    app.use('/graphql', graphqlHTTP({
+        schema: MyModule.schema
+    }));
+```
+
+What if we need more stuff in network session;
+
+```typescript
+    interface MyModuleSession {
+        req: express.Request,
+        res: express.Response
+    }
+    const MyModule = new GraphQLModule({
+        context(session: MyModuleSession) {
+            res.on('finish', () => {
+                // Some cleanup
+            });
+            return {
+                authToken: session.req.headers.authorization,
+            };
+        }
+    });
+    // Some express code
+    app.use('/graphql', graphqlHTTP((req, res) => ({
+        schema: MyModule.schema,
+        context: { session: { req, res }, otherThingsWillBeIgnored: ... }
+        // or without session property
+        context: { req, res }
+    })));
+```
+
+### Using in `apollo-server`
+
+On the other hand, `apollo-server` needs to be passed it like below;
+
+```typescript
+new ApolloServer({
+    modules: [
+        MyModule
+    ],
+    context: ({ req, res }) => ({ req, res }),
+    // or
+    context: ({ req, res }) => ({ session: { req, res } }),
+    // or 
+    context: session => ({ session }),
+    // or 
+    context: session => session,
+})
+```
+
+### Using in another application that doesn't use GraphQL Modules on the top
+
+If you want to use a `GraphQLModule` in a non-GraphQLModules application, you can safely pass context builder of `GraphQLModule`. 
+And you can use internal context of your `GraphQLModule` including **Dependency Injection**.
+GraphQL-Modules internally handles `session` without the need of passing `session` specifically.
+
+#### Using `modules` of `ApolloServer`
+
+```typescript
+const MyAccountsModule = AccountsModule.forRoot({ ... });
+new ApolloServer({
+    modules: [ MyAccountsModule ]
+    typeDefs: myTypeDefs,
+    resolvers: myResolvers,
+    context: ({ req, res }) => {
+        // My Context Stuff
+        return {
+            myContextProp: {...},
+            ...MyAccountsModule.context({ req, res })
+        }
+    }
+})
+```
+
+#### Using schema stitching
+
+You can safely extract reusable `typeDefs`, `resolvers` and `context` from your `GraphQLModule`, and use it outside `GraphQLModule`.
+
+```typescript
+const MyAccountsModule = AccountsModule.forRoot({ ... });
+
+const typeDefs = mergeTypeDefs([
+    MyAccountsModule.typeDefs,
+    gql`
+        type Query {
+            someField: SomeType
+        }
+    `
+]);
+
+const resolvers = mergeResolvers([
+    MyAccountsModule.resolvers,
+    {
+        Query: {
+            someField: ...
+        }
+    }
+]);
+
+const schema = makeExecutableSchema({ typeDefs, resolvers });
+
+const server = new ApolloServer({
+    schema,
+    introspection: true,
+    playground: true,
+});
+```
+
+This is what `Session` means in GraphQL-Modules. You can read more about **Provider Scopes** in **Dependency Injection** and **Provider Scopes** sections of our documentation.

package.json

@@ -13,6 +13,7 @@
     "test": "lerna run test",
     "build": "lerna run build",
     "build:api-docs": "./generate-api-docs.sh",
+    "precommit": "lint-staged",
     "lint": "lerna run lint",
     "clean": "lerna clean --yes && rm -rf node_modules",
     "prerelease": "yarn build && yarn test",
@@ -32,9 +33,25 @@
     "rimraf": "2.6.3",
     "ts-jest": "24.0.0",
     "typedoc": "0.13.0",
-    "typedoc-plugin-docusaurus": "1.0.14"
+    "typedoc-plugin-docusaurus": "1.0.14",
+    "husky": "1.3.1",
+    "lint-staged": "8.1.5"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "tslint --fix",
+      "git add"
+    ],
+    "*.{js,json,css,md,ts,tsx}": [
+      "prettier --write",
+      "git add -f"
+    ]
+  },
+  "prettier": {
+    "printWidth": 120,
+    "singleQuote": true
   }
 }

packages/core/package.json

@@ -45,6 +45,7 @@
     "tslint": "5.14.0",
     "typescript": "3.3.3333"
   },
+  "sideEffects": false,
   "main": "dist/commonjs/index.js",
   "module": "dist/esnext/index.js",
   "typings": "dist/esnext/index.d.ts",