feat: error specific @EmitOnFail() (#539)

Author: attilaorosz

README.md

@@ -258,6 +258,8 @@ import { SocketController, OnMessage, EmitOnSuccess, EmitOnFail } from 'socket-c
 export class MessageController {
   @OnMessage('save')
   @EmitOnSuccess('save_successfully')
+  @EmitOnFail('save_error_range', {errorType: RangeError})
+  @EmitOnFail('save_error_type', {errorType: TypeError})
   @EmitOnFail('save_error')
   save() {
     if (1 === 1) {
@@ -272,6 +274,7 @@ export class MessageController {
 ```
 
 In this case `save_error` message will be sent to the client with `One is equal to one! Fatal error!` error message.
+The order is important when defining multiple `@EmitOnFail()` decorators, the first matching errorType will be served
 
 Sometimes you may want to not emit success/error message if returned result is null or undefined.
 In such cases you can use `@SkipEmitOnEmptyResult()` decorator.

src/SocketControllers.ts

@@ -222,13 +222,26 @@ export class SocketControllers {
   }
 
   private handleActionResult(socket: Socket, action: ActionMetadata, result: any, resultType: ResultType) {
-    const onResultActions = action.results?.filter(result => result.type === resultType) || [];
+    const allOnResultActions = action.results?.filter(result => result.type === resultType) || [];
     const skipOnEmpty = action.results?.some(result => result.type === ResultType.SKIP_EMIT_ON_EMPTY_RESULT);
 
     if (result == null && skipOnEmpty) {
       return;
     }
 
+    let onResultActions = allOnResultActions;
+    if (onResultActions.some(action => action.options.errorType)) {
+      const firstFittingAction = allOnResultActions.find(
+        action => action.options.errorType && result instanceof (action.options.errorType as Function)
+      );
+
+      if (!firstFittingAction) {
+        onResultActions = allOnResultActions.filter(action => !action.options.errorType);
+      } else {
+        onResultActions = [firstFittingAction];
+      }
+    }
+
     for (const onResultAction of onResultActions) {
       const transformedValue =
         result instanceof Error

src/decorators/EmitOnFail.ts

@@ -2,7 +2,7 @@ import { addResultToActionMetadata } from '../util/add-result-to-action-metadata
 import { ResultType } from '../types/enums/ResultType';
 import { ActionTransformOptions } from '../types/ActionTransformOptions';
 
-export function EmitOnFail(messageName: string, options?: ActionTransformOptions): Function {
+export function EmitOnFail(messageName: string, options?: ActionTransformOptions & { errorType: unknown }): Function {
   return function (object: Object, methodName: string) {
     addResultToActionMetadata(object.constructor, methodName, {
       type: ResultType.EMIT_ON_FAIL,

test/functional/emit-on-fail.spec.ts

@@ -8,6 +8,7 @@ import { OnConnect } from '../../src/decorators/OnConnect';
 import { ConnectedSocket } from '../../src/decorators/ConnectedSocket';
 import { waitForEvent } from '../utilities/waitForEvent';
 import { EmitOnFail, OnMessage } from '../../src';
+import { waitForTime } from '../utilities/waitForTime';
 
 describe('EmitOnFail', () => {
   const PORT = 8080;
@@ -124,4 +125,83 @@ describe('EmitOnFail', () => {
     expect(errors[0]).toEqual('error string');
     expect(errors.length).toEqual(1);
   });
+
+  it('Emit defined event on failing with specific error type', async () => {
+    @SocketController('/string')
+    @Service()
+    class TestController {
+      @OnConnect()
+      connected(@ConnectedSocket() socket: Socket) {
+        socket.emit('connected');
+      }
+
+      @OnMessage('request')
+      @EmitOnFail('fail1', { errorType: RangeError })
+      @EmitOnFail('fail2', { errorType: TypeError })
+      @EmitOnFail('fail3')
+      async testEvent() {
+        throw new RangeError('range error');
+      }
+
+      @OnMessage('request2')
+      @EmitOnFail('fail1', { errorType: RangeError })
+      @EmitOnFail('fail2', { errorType: TypeError })
+      @EmitOnFail('fail3')
+      async testEvent2() {
+        throw new TypeError('type error');
+      }
+
+      @OnMessage('request3')
+      @EmitOnFail('fail1', { errorType: RangeError })
+      @EmitOnFail('fail2', { errorType: TypeError })
+      @EmitOnFail('fail3')
+      async testEvent3() {
+        throw new Error('test error');
+      }
+
+      @OnMessage('request4')
+      @EmitOnFail('fail1', { errorType: Error })
+      @EmitOnFail('fail2', { errorType: TypeError })
+      @EmitOnFail('fail3')
+      async testEvent4() {
+        throw new TypeError('type error 2');
+      }
+    }
+
+    socketControllers = new SocketControllers({
+      io: wsApp,
+      container: Container,
+      controllers: [TestController],
+    });
+    wsClient = io(PATH_FOR_CLIENT + '/string', { reconnection: false, timeout: 5000, forceNew: true });
+
+    const errors = { fail1: [], fail2: [], fail3: [] };
+
+    wsClient.on('fail1', data => {
+      errors.fail1.push(data);
+    });
+
+    wsClient.on('fail2', data => {
+      errors.fail2.push(data);
+    });
+
+    wsClient.on('fail3', data => {
+      errors.fail3.push(data);
+    });
+
+    await waitForEvent(wsClient, 'connected');
+
+    wsClient.emit('request');
+    wsClient.emit('request2');
+    wsClient.emit('request3');
+    wsClient.emit('request4');
+
+    await waitForTime(1000);
+
+    expect(errors).toEqual({
+      fail1: ['range error', 'type error 2'],
+      fail2: ['type error'],
+      fail3: ['test error'],
+    });
+  });
 });