Merge branch 'master' into memory-leak-testing

Author: ardatan

docs/guides/development-environment.md

@@ -6,7 +6,7 @@ sidebar_label: Development Environment
 
 ## TypeScript
 
-### Basic Configuration
+### TS-Node ***(recommended way)***
 
 To setup your development environment easily, we recommend to use [TypeScript](http://www.typescriptlang.org/).
 
@@ -62,7 +62,7 @@ Next, add the following scripts to your `package.json`:
 - `build` will use `tsc` compiler to compile your code to JavaScript.
 - `start` will run the compiled server using pure Node.
 
-### `paths`
+#### `paths`
 
 TypeScript has an **[aliasing mechanism](https://www.typescriptlang.org/docs/handbook/module-resolution.html)** that can make it easier to work with modules directories.
 
@@ -104,7 +104,7 @@ This way, you can now import files between modules like that:
 import { SomeProvider } from '@modules/my-module';
 ```
 
-### Import from `.graphql` files
+#### Import from `.graphql` files
 
 You can also treat `.graphql` files as text files and import from them easily. It's useful because most IDEs detects `.graphql` files and have syntax highlighting for it.
 
@@ -119,7 +119,7 @@ import 'graphql-import-node'; // You should add this at the begininng of your en
 import * as UserTypeDefs from './user.graphql';
 ```
 
-## Webpack
+### Webpack
 
 If you are using Webpack, we recommend to use **[ts-loader](https://github.com/TypeStrong/ts-loader) or [awesome-typescript-loader](https://github.com/s-panferov/awesome-typescript-loader)** to load your TypeScript files.
 
@@ -149,6 +149,20 @@ module.exports = {
 };
 ```
 
+### Babel-TypeScript
+
+You can use Babel for TypeScript with GraphQL-Modules. [Check out this boilerplate](https://github.com/Microsoft/TypeScript-Babel-Starter)
+
+But if you use DI, you have to decorate each property and argument in the providers manually even for the classes like below;
+
+```ts
+import { Injectable, Inject } from '@graphql-modules/di';
+@Injectable()
+export class SomeProvider {
+  constructor(@Inject(OtherProvider) private otherProvider: OtherProvider){}
+}
+```
+
 ## JavaScript Usage
 
 If you are using JavaScript in your project and not TypeScript, you can either **[add support for TypeScript](https://www.typescriptlang.org/docs/handbook/migrating-from-javascript.html)**, or use GraphQL Modules with it's JavaScript API.
@@ -159,7 +173,7 @@ If you are using [Babel](http://babeljs.io) to transpile your JavaScript files,
 
 ### Without decorators
 
-You can use `Inject` and `Injectable` as regular functions to wrap your arguments and classes.
+You can use `Inject` and `Injectable` as regular functions to wrap your arguments and classes from `tslib
 
 ## Testing Environment
 

docs/introduction/dependency-injection.md

@@ -342,6 +342,9 @@ export class MyProvider implements OnDisconnect {
 > `OnDisconnect` hook is called once for each WebSocket GraphQL connection.
 [API of `OnDisconnect` is available here](/docs/api/core/api-interfaces-ondisconnect)
 
+> The other `OnOperation` and `OnOperationComplete` hooks work similar to GraphQL Subscription Server implementation;
+[See more in SubscriptionServer docs](https://github.com/apollographql/subscriptions-transport-ws)
+
 ## Provider Scopes
 
 You can define different life-time for your provider. You have three options;

docs/introduction/subscriptions.md

@@ -4,11 +4,12 @@ title: Subscriptions
 sidebar_label: Subscriptions
 ---
 
-Subscriptions are GraphQL operations that watch events emitted from your backend. GraphQL-Modules supports GraphQL subscriptions with a little modification in your server code. You can **[read more](https://www.apollographql.com/docs/apollo-server/features/subscriptions.html)** about subscriptions.
+Subscriptions are GraphQL operations that watch events emitted from your backend. GraphQL-Modules supports GraphQL subscriptions with a little modification in your server code. You can **[read more](https://github.com/apollographql/subscriptions-transport-ws)** about subscriptions.
 
 Subscriptions need to have defined `PubSub` implementation in your GraphQL-Modules application.
 
 ```typescript
+  import { PubSub } from 'graphql-subscriptions';
   export const CommonModule = new GraphQLModule({
     providers: [
       PubSub
@@ -72,12 +73,37 @@ You have to export `subscriptions` from your `AppModule`, and pass it to your Gr
     ]
   });
 
-  const server = new ApolloServer({
-    schema,
-    context: session => session,
-    subscriptions
+  import { createServer } from 'http';
+  import { SubscriptionServer } from 'subscriptions-transport-ws';
+  import { execute, subscribe } from 'graphql';
+  import { schema } from './my-schema';
+
+  const WS_PORT = 5000;
+
+  // Create WebSocket listener server
+  const websocketServer = createServer((request, response) => {
+    response.writeHead(404);
+    response.end();
   });
 
+  // Bind it to port and start listening
+  websocketServer.listen(WS_PORT, () => console.log(
+    `Websocket Server is now running on http://localhost:${WS_PORT}`
+  ));
+
+  const subscriptionServer = SubscriptionServer.create(
+    {
+      schema,
+      execute,
+      subscribe,
+      ...subscriptions,
+    },
+    {
+      server: websocketServer,
+      path: '/graphql',
+    },
+  );
+
   server.listen().then(({ url, subscriptionsUrl }) => {
     console.log(`🚀 Server ready at ${url}`);
     console.log(`🚀 Subscriptions ready at ${subscriptionsUrl}`);

package.json

@@ -26,7 +26,7 @@
     "@types/graphql": "14.2.0",
     "@types/jest": "24.0.11",
     "graphql": "14.2.1",
-    "jest": "24.6.0",
+    "jest": "24.7.0",
     "lerna": "2.11.0",
     "reflect-metadata": "0.1.13",
     "replace-in-file": "3.4.4",

packages/core/package.json

@@ -46,7 +46,7 @@
     "apollo-client": "2.5.1",
     "apollo-link-schema": "1.2.2",
     "graphql-tag": "2.10.1",
-    "jest": "24.6.0",
+    "jest": "24.7.0",
     "tslint": "5.15.0",
     "typescript": "3.4.1"
   },

packages/core/src/graphql-module.ts

@@ -28,6 +28,7 @@ import { ModuleSessionInfo } from './module-session-info';
 import { ModuleContext, SubscriptionHooks } from './types';
 import { asArray, normalizeSession } from './helpers';
 import { KeyValueCache, InMemoryLRUCache } from 'apollo-server-caching';
+import { ServerResponse } from 'http';
 
 type MaybePromise<T> = Promise<T> | T;
 
@@ -554,6 +555,8 @@ export class GraphQLModule<Config = any, Session extends object = any, Context =
     return this._cache.schemaDirectives;
   }
 
+  private paramsOnOperationResult$Map = new WeakMap<any, Promise<any>>();
+  private opIdOnOperationCompleteResult$Map = new WeakMap<any, Promise<any>>();
   get subscriptions(): SubscriptionHooks {
     if (typeof this._cache.subscriptionHooks === 'undefined') {
       const subscriptionHooks = new Array<SubscriptionHooks>();
@@ -565,17 +568,17 @@ export class GraphQLModule<Config = any, Session extends object = any, Context =
         }
       }
       this._cache.subscriptionHooks = {
-        onConnect: (connectionParams, websocket, connectionSession) => {
-          if (!this._sessionContext$Map.has(connectionSession)) {
-            this._sessionContext$Map.set(connectionSession, new Promise(async (resolve, reject) => {
+        onConnect: (connectionParams, websocket, connectionContext) => {
+          if (!this._sessionContext$Map.has(websocket)) {
+            this._sessionContext$Map.set(websocket, new Promise(async (resolve, reject) => {
               try {
                 const importsOnConnectHooks$ = subscriptionHooks.map(
-                  async ({ onConnect }) => onConnect && onConnect(connectionParams, websocket, connectionSession),
+                  async ({ onConnect }) => onConnect && onConnect(connectionParams, websocket, connectionContext),
                 );
                 const importsOnConnectHooks = await Promise.all(importsOnConnectHooks$);
                 const importsResult = importsOnConnectHooks.reduce((acc, curr) => ({ ...acc, ...(curr || {}) }), {});
-                const connectionContext = await this.context(connectionSession);
-                const sessionInjector = connectionContext.injector;
+                const connectionModuleContext = await this.context(websocket);
+                const sessionInjector = connectionModuleContext.injector;
                 const hookResult = await sessionInjector.callHookWithArgs({
                   hook: 'onConnect',
                   args: [
@@ -588,34 +591,111 @@ export class GraphQLModule<Config = any, Session extends object = any, Context =
                 });
                 resolve({
                   ...importsResult,
-                  ...connectionContext,
+                  ...connectionModuleContext,
                   ...hookResult,
                 });
               } catch (e) {
                 reject(e);
               }
             }));
           }
-          return this._sessionContext$Map.get(connectionSession);
+          return this._sessionContext$Map.get(websocket);
         },
-        onDisconnect: async (websocket, connectionSession) => {
-          const importsOnDisconnectHooks$ = subscriptionHooks.map(
-            async ({ onDisconnect }) => onDisconnect && onDisconnect(websocket, connectionSession),
-          );
-          const importsOnDisconnectHooks = await Promise.all(importsOnDisconnectHooks$);
-          importsOnDisconnectHooks.reduce((acc, curr) => ({ ...acc, ...(curr || {}) }), {});
-          const connectionContext = await this.context(connectionSession);
-          const sessionInjector = connectionContext.injector;
-          await sessionInjector.callHookWithArgs({
-            hook: 'onDisconnect',
-            args: [
-              websocket,
-              connectionContext,
-            ],
-            instantiate: true,
-            async: true,
-          });
-          this.destroySelfSession(connectionSession);
+        onOperation: (message, params, websocket) => {
+          if (!this.paramsOnOperationResult$Map.has(params)) {
+            this.paramsOnOperationResult$Map.set(params, new Promise(async (resolve, reject) => {
+              try {
+                const importsOnOperationHooks$ = subscriptionHooks.map(
+                  async ({ onOperation }) => onOperation && onOperation(message, params, websocket),
+                );
+                const importsOnOperationHooks = await Promise.all(importsOnOperationHooks$);
+                const importsResult = importsOnOperationHooks.reduce((acc, curr) => ({ ...acc, ...acc(curr || {})}), {});
+                const connectionModuleContext = await this.context(websocket);
+                const sessionInjector = connectionModuleContext.injector;
+                const moduleOnOperationResult = await sessionInjector.callHookWithArgs({
+                  hook: 'onOperation',
+                  args: [
+                    message,
+                    params,
+                    websocket,
+                  ],
+                  instantiate: true,
+                  async: true,
+                });
+                resolve({
+                  ...importsResult,
+                  ...moduleOnOperationResult,
+                });
+              } catch (e) {
+                reject(e);
+              }
+            }));
+          }
+          return this.paramsOnOperationResult$Map.get(params);
+        },
+        onOperationComplete: (websocket, opId: any) => {
+          // tslint:disable-next-line: no-construct
+          opId = new String(opId);
+          if (!this.opIdOnOperationCompleteResult$Map.has(opId)) {
+            this.opIdOnOperationCompleteResult$Map.set(opId, new Promise(async (resolve, reject) => {
+              try {
+                const importsOnOperationCompleteHooks$ = subscriptionHooks.map(
+                  async ({ onOperationComplete }) => onOperationComplete && onOperationComplete(websocket, opId),
+                );
+                const importsOnOperationCompleteHooks = await Promise.all(importsOnOperationCompleteHooks$);
+                const importsResult = importsOnOperationCompleteHooks.reduce((acc, curr) => ({ ...acc, ...acc(curr || {})}), {});
+                const connectionModuleContext = await this.context(websocket);
+                const sessionInjector = connectionModuleContext.injector;
+                const moduleOnOperationCompleteResult = await sessionInjector.callHookWithArgs({
+                  hook: 'onOperationComplete',
+                  args: [
+                    websocket,
+                    opId,
+                  ],
+                  instantiate: true,
+                  async: true,
+                });
+                resolve({
+                  ...importsResult,
+                  ...moduleOnOperationCompleteResult,
+                });
+              } catch (e) {
+                reject(e);
+              }
+            }));
+          }
+          return this.opIdOnOperationCompleteResult$Map.get(opId);
+        },
+        onDisconnect: (websocket, connectionContext) => {
+          websocket['_moduleOnDisconnect$Map'] = websocket['_moduleOnDisconnect$Map'] || new WeakMap();
+          const moduleOnDisconnect$Map: WeakMap<GraphQLModule, Promise<void>> = websocket['_moduleOnDisconnect$Map'];
+          if (!moduleOnDisconnect$Map.has(this)) {
+            moduleOnDisconnect$Map.set(this, new Promise(async (resolve, reject) => {
+              try {
+                const importsOnDisconnectHooks$ = subscriptionHooks.map(
+                  async ({ onDisconnect }) => onDisconnect && onDisconnect(websocket, connectionContext),
+                );
+                const importsOnDisconnectHooks = await Promise.all(importsOnDisconnectHooks$);
+                importsOnDisconnectHooks.reduce((acc, curr) => ({ ...acc, ...(curr || {}) }), {});
+                const connectionModuleContext = await this.context(websocket);
+                const sessionInjector = connectionModuleContext.injector;
+                await sessionInjector.callHookWithArgs({
+                  hook: 'onDisconnect',
+                  args: [
+                    websocket,
+                    connectionContext,
+                  ],
+                  instantiate: true,
+                  async: true,
+                });
+                this.destroySelfSession(websocket);
+                resolve();
+              } catch (e) {
+                reject(e);
+              }
+            }));
+          }
+          return moduleOnDisconnect$Map.get(this);
         },
       };
     }
@@ -1073,21 +1153,26 @@ export class GraphQLModule<Config = any, Session extends object = any, Context =
                   }
                 }
                 moduleSessionInfo.context = Object.assign<any, Context>(importsContext, moduleContext);
-                if ('res' in session && 'once' in session['res']) {
-                    if (!('_onceFinishListeners' in session['res'])) {
-                      session['res']['_onceFinishListeners'] = [];
-                      session['res'].once('finish', (e: any) => {
-                          const onceFinishListeners = session['res']['_onceFinishListeners'];
-                          onceFinishListeners.map((onceFinishListener: any) => onceFinishListener(e));
-                          delete session['res']['_onceFinishListeners'];
+                const res: ServerResponse = session && session['res'];
+                if (res && 'once' in res) {
+                    if (!('_onceFinishListeners' in res)) {
+                      res['_onceFinishListeners'] = [];
+                      res.once('finish', () => {
+                          const onceFinishListeners = res['_onceFinishListeners'];
+                          for (const onceFinishListener of onceFinishListeners) {
+                            onceFinishListener();
+                          }
+                          delete res['_onceFinishListeners'];
                       });
                     }
-                    session['res']['_onceFinishListeners'].push(() => {
-                        sessionInjector.callHookWithArgsAsync({
+                    res['_onceFinishListeners'].push(() => {
+                        sessionInjector.callHookWithArgs({
                             hook: 'onResponse',
                             args: [moduleSessionInfo],
                             instantiate: true,
-                        }).then(() => this.destroySelfSession(session));
+                            async: false,
+                        });
+                        this.destroySelfSession(session);
                     });
                 }
                 sessionInjector.onInstanceCreated = ({ instance }) => {