feat(ws): implements parser for websocket

jmcdo29 · jmcdo29 · commit 9de8c96ab1b7 · 2020-04-19T13:16:18.000-07:00
The WsParser is now written in its entirity. There are a few hardcoded values, though those could be overriden by dev if they choose by extending the parser itself. Tests are written (P.S. writing tests to satisfy Socket.io **and** Websocket was almost impossible, but I got it done). Only thing to do from here is to finish off the microservice parsers 😄 fix #24
diff --git a/integration/src/ws/ws.filter.ts b/integration/src/ws/ws.filter.ts
@@ -1,10 +1,15 @@
 import { ArgumentsHost, Catch, HttpException } from '@nestjs/common';
 import { BaseWsExceptionFilter } from '@nestjs/websockets';
+import WebSocket = require('ws');
 
 @Catch()
 export class ExceptionFilter extends BaseWsExceptionFilter {
   catch(exception: HttpException, host: ArgumentsHost) {
     const client = host.switchToWs().getClient();
-    client.emit('exception', exception.message);
+    if (client instanceof WebSocket) {
+      return client.send('exception');
+    } else {
+      return client.emit('exception', exception.message);
+    }
   }
 }
diff --git a/integration/test/utils/ws-promise.ts b/integration/test/utils/ws-promise.ts
@@ -1,26 +1,53 @@
 import * as WebSocket from 'ws';
 
+export const createConnection = (
+  client: (url: string) => SocketIOClient.Socket | WebSocket,
+  url: string,
+): Promise<SocketIOClient.Socket | WebSocket> =>
+  new Promise((resolve, reject) => {
+    const socket = client(url);
+    if (Object.getOwnPropertyDescriptor(socket, 'io')) {
+      resolve(socket);
+    }
+    socket.on('open', () => {
+      resolve(socket);
+    });
+    socket.on('error', (err) => {
+      reject(err);
+    });
+  });
+
 export const wsPromise = (
   ws: WebSocket | SocketIOClient.Socket,
   message: string,
+  sendMethod: 'send' | 'emit',
 ): Promise<any> =>
   new Promise((resolve, reject) => {
-    ws.emit(message, '', (data) => resolve(data));
-    ws.on('error', (err) => {
-      console.error(err);
-      reject(err);
+    ws[sendMethod](message, {}, (data: any) => {
+      if (data) {
+        resolve(data);
+      }
     });
     ws.on('message', (data) => {
-      console.log(`Got data ${data}`);
       resolve(data);
+      return false;
     });
-    ws.on('ping', () => {
-      resolve('ping');
-    });
-    ws.on('pong', () => {
-      resolve('pong');
+    ws.on('error', (err) => {
+      console.error(err);
+      reject(err);
     });
     ws.on('exception' as any, (...args) => {
       resolve(args);
     });
+    ws.on('unexpected-response', () => {
+      reject('Unexpected-response');
+    });
+  });
+export const wsClose = (ws: WebSocket | SocketIOClient.Socket): Promise<void> =>
+  new Promise((resolve, reject) => {
+    ws.close();
+    ws.on('close', () => {
+      resolve();
+    });
+    ws.on('error', (err) => reject(err));
   });
diff --git a/integration/test/ws.spec.ts b/integration/test/ws.spec.ts
@@ -1,5 +1,6 @@
 import { INestApplication, WebSocketAdapter } from '@nestjs/common';
 import { IoAdapter } from '@nestjs/platform-socket.io';
+import { WsAdapter } from '@nestjs/platform-ws';
 import { Test } from '@nestjs/testing';
 import { color } from '@ogma/logger';
 import {
@@ -8,14 +9,22 @@ import {
   Type,
 } from '@ogma/nestjs-module';
 import { SocketIOParser } from '@ogma/platform-socket.io';
+import { WsParser } from '@ogma/platform-ws';
 import * as Io from 'socket.io-client';
 import * as WebSocket from 'ws';
 import { WsModule } from '../src/ws/ws.module';
-import { hello, serviceOptionsFactory, wsPromise } from './utils';
+import {
+  createConnection,
+  hello,
+  serviceOptionsFactory,
+  wsClose,
+  wsPromise,
+} from './utils';
 
 describe.each`
-  adapter      | server         | parser            | client                      | protocol
-  ${IoAdapter} | ${'socket.io'} | ${SocketIOParser} | ${(url: string) => Io(url)} | ${'http'}
+  adapter      | server         | parser            | client                                 | protocol  | sendMethod | serializer
+  ${IoAdapter} | ${'Socket.io'} | ${SocketIOParser} | ${(url: string) => Io(url)}            | ${'http'} | ${'emit'}  | ${(message: string) => message}
+  ${WsAdapter} | ${'Websocket'} | ${WsParser}       | ${(url: string) => new WebSocket(url)} | ${'ws'}   | ${'send'}  | ${(message: string) => JSON.stringify({ event: message })}
 `(
   '$server server',
   ({
@@ -24,12 +33,16 @@ describe.each`
     parser,
     client,
     protocol,
+    sendMethod,
+    serializer,
   }: {
     adapter: Type<WebSocketAdapter>;
     server: string;
     parser: Type<AbstractInterceptorService>;
     client: (url: string) => SocketIOClient.Socket | WebSocket;
     protocol: 'http' | 'ws';
+    sendMethod: 'send' | 'emit';
+    serializer: (message: string) => string;
   }) => {
     let app: INestApplication;
     let interceptor: OgmaInterceptor;
@@ -62,11 +75,11 @@ describe.each`
       beforeAll(async () => {
         let baseUrl = await app.getUrl();
         baseUrl = baseUrl.replace('http', protocol);
-        ws = client(baseUrl);
+        ws = await createConnection(client, baseUrl);
       });
 
-      afterAll(() => {
-        ws.close();
+      afterAll(async () => {
+        await wsClose(ws);
       });
 
       beforeEach(() => {
@@ -84,15 +97,22 @@ describe.each`
       `(
         '$message',
         async ({ message, status }: { message: string; status: string }) => {
-          await wsPromise(ws, message);
+          await wsPromise(ws, serializer(message), sendMethod);
           expect(logSpy).toHaveBeenCalledTimes(1);
           const logObject = logSpy.mock.calls[0][0];
-          expect(logObject).toBeALogObject(server, message, 'WS', status);
+          expect(logObject).toBeALogObject(
+            server.toLowerCase(),
+            message,
+            'WS',
+            status,
+          );
         },
       );
       it('should get the data from skip but not log', async () => {
-        const data = await wsPromise(ws, 'skip');
-        expect(data).toEqual(JSON.parse(hello));
+        const data = await wsPromise(ws, serializer('skip'), sendMethod);
+        expect(data).toEqual(
+          server === 'Websocket' ? hello : JSON.parse(hello),
+        );
         expect(logSpy).toHaveBeenCalledTimes(0);
       });
     });
diff --git a/packages/platform-socket.io/README.md b/packages/platform-socket.io/README.md
@@ -20,3 +20,7 @@ This plugin is to be used in the `OgmaInterceptorOptions` portion of the `OgmaMo
 )
 export class AppModule {}
 ```
+
+### Note
+
+As the Gateway/Websocket context runs in parallel with the HTTP Context, and as the application configuration is not shared between the two, to bind the `OgmaInterceptor` to the GateWay, you **must** use `@UseInterceptor(OgmaInterceptor)` **and** have `OgmaModule.forFeature()` in the `imports` array of the same module.
diff --git a/packages/platform-ws/README.md b/packages/platform-ws/README.md
@@ -1,11 +1,26 @@
 # `@ogma/platform-ws`
 
-> TODO: description
+The `WsParser` parser for the `OgmaInterceptor`. This plugin class parses TCP request and response object to be able to successfully log the data about the request. For more information, check out [the @ogma/nestjs-module](../nestjs-module/README.md) documentation.
+
+## Installation
+
+Nothing special, standard `npm i @ogma/platform-ws` or `yarn add @ogma/platform-ws`
 
 ## Usage
 
-```
-const platformWs = require('@ogma/platform-ws');
+This plugin is to be used in the `OgmaInterceptorOptions` portion of the `OgmaModule` during `forRoot` or `forRootAsync` registration. It can be used like so:
 
-// TODO: DEMONSTRATE API
+```ts
+@Module(
+  OgmaModule.forRoot({
+    interceptor: {
+      ws: WsParser
+    }
+  })
+)
+export class AppModule {}
 ```
+
+### Note
+
+As the Gateway/Websocket context runs in parallel with the HTTP Context, and as the application configuration is not shared between the two, to bind the `OgmaInterceptor` to the GateWay, you **must** use `@UseInterceptor(OgmaInterceptor)` **and** have `OgmaModule.forFeature()` in the `imports` array of the same module.
diff --git a/packages/platform-ws/package.json b/packages/platform-ws/package.json
@@ -26,7 +26,11 @@
     "url": "git+https://github.com/jmcdo29/ogma.git"
   },
   "scripts": {
-    "test": "echo \"No tests to run\""
+    "prebuild": "rimraf lib",
+    "build": "tsc -p tsconfig.build.json",
+    "postbuild": "mv ./lib/src/* ./lib && rmdir lib/src",
+    "test": "jest",
+    "test:cov": "jest --coverage"
   },
   "bugs": {
     "url": "https://github.com/jmcdo29/ogma/issues"
diff --git a/packages/platform-ws/src/index.ts b/packages/platform-ws/src/index.ts
@@ -0,0 +1 @@
+export * from './ws-interceptor.service';
diff --git a/packages/platform-ws/src/ws-interceptor.service.ts b/packages/platform-ws/src/ws-interceptor.service.ts
@@ -0,0 +1,35 @@
+import { ExecutionContext, HttpException, Injectable } from '@nestjs/common';
+import { MESSAGE_METADATA } from '@nestjs/websockets/constants';
+import { AbstractInterceptorService } from '@ogma/nestjs-module';
+import WebSocket = require('ws');
+
+@Injectable()
+export class WsParser extends AbstractInterceptorService {
+  getCallPoint(context: ExecutionContext): string {
+    return this.reflector.get<string>(MESSAGE_METADATA, context.getHandler());
+  }
+
+  getCallerIp(context: ExecutionContext): string {
+    return (this.getClient(context) as any)._socket.remoteAddress;
+  }
+
+  getProtocol(): string {
+    return 'WS';
+  }
+
+  getMethod(): string {
+    return 'websocket';
+  }
+
+  getStatus(
+    context: ExecutionContext,
+    inColor: boolean,
+    error?: HttpException | Error,
+  ): string {
+    const status = error ? 500 : 200;
+    return inColor ? this.wrapInColor(status) : status.toString();
+  }
+  private getClient(context: ExecutionContext): WebSocket {
+    return context.switchToWs().getClient<WebSocket>();
+  }
+}

Original file line number	Diff line number	Diff line change
@@ -20,3 +20,7 @@ This plugin is to be used in the `OgmaInterceptorOptions` portion of the `OgmaMo
`20`	`20`	`)`
`21`	`21`	`export class AppModule {}`
`22`	`22`	```
	`23`	`+`
	`24`	`+### Note`
	`25`	`+`
	`26`	+As the Gateway/Websocket context runs in parallel with the HTTP Context, and as the application configuration is not shared between the two, to bind the `OgmaInterceptor` to the GateWay, you must use `@UseInterceptor(OgmaInterceptor)` and have `OgmaModule.forFeature()` in the `imports` array of the same module.
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+export * from './ws-interceptor.service';`