/
socketMiddlewareError.ts
69 lines (66 loc) · 1.77 KB
/
socketMiddlewareError.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
import {Middleware} from "@tsed/common";
import {Store, Type} from "@tsed/core";
import {SocketProviderTypes} from "../interfaces/ISocketProviderMetadata";
/**
* Declare a new SocketMiddlewareError.
*
* ### Example
*
* A middleware can be also used on a `SocketService` either on a class or on a method.
*
* Here an example of a middleware:
*
* ```typescript
* import {SocketMiddlewareError, SocketErr, Socket, Args} from "@tsed/socketio";
*
* @SocketMiddlewareError()
* export class ErrorHandlerSocketMiddleware {
* async use(@SocketEventName, @SocketErr err: any, @Socket socket: SocketIO.Socket) {
* console.error(err);
* socket.emit("error", {message: "An error has occured"})
* }
* }
* ```
*
* Then:
*
* ```typescript
* import {SocketService, SocketUseAfter, SocketUseBefore, Emit, Input, Args} from "@tsed/socketio";
* import {ErrorHandlerSocketMiddleware} from "../middlewares";
* import {User} from "../models/User";
*
* @SocketService("/my-namespace")
* @SocketUseAfter(ErrorHandlerSocketMiddleware) // global version
* export class MySocketService {
*
* @Input("eventName")
* @Emit("responseEventName") // or Broadcast or BroadcastOthers
* @SocketUseAfter(ErrorHandlerSocketMiddleware)
* async myMethod(@Args(0) userName: User) {
*
* console.log(user);
* throw new Error("Error");
*
* return user;
* }
* }
* ```
*
* @returns {Function}
* @decorator
* @experimental
*/
export function SocketMiddlewareError(): Function {
return (target: Type<any>) => {
Store.from(target).merge("socketIO", {
type: SocketProviderTypes.MIDDLEWARE,
error: true,
handlers: {
use: {
methodClassName: "use"
}
}
});
return Middleware()(target);
};
}