added decorators to handle namespace params

rustamwin · rustamwin · commit 1b864bede326 · 2019-01-26T21:24:33.000+05:00
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -31,6 +31,7 @@
   },
   "dependencies": {
     "class-transformer": "^0.1.6",
+    "path-to-regexp": "^3.0.0",
     "reflect-metadata": "^0.1.10",
     "socket.io": "^2.0.1"
   },
diff --git a/sample/sample6-dynamic-namespaces/Message.ts b/sample/sample6-dynamic-namespaces/Message.ts
@@ -0,0 +1,6 @@
+export class Message {
+
+    id: number;
+    text: string;
+
+}
diff --git a/sample/sample6-dynamic-namespaces/MessageController.ts b/sample/sample6-dynamic-namespaces/MessageController.ts
@@ -0,0 +1,34 @@
+import {
+    OnConnect,
+    SocketController,
+    ConnectedSocket,
+    OnDisconnect,
+    MessageBody,
+    OnMessage,
+    NspParams
+} from "../../src/decorators";
+import {Message} from "./Message";
+
+@SocketController("/messages/:id")
+export class MessageController {
+
+    @OnConnect()
+    connection(@ConnectedSocket() socket: any) {
+        console.log("client connected");
+    }
+
+    @OnDisconnect()
+    disconnect(@ConnectedSocket() socket: any) {
+        console.log("client disconnected");
+    }
+
+    @OnMessage("save")
+    async save(@ConnectedSocket() socket: any, @MessageBody() message: Message, @NspParams() params: any[]) {
+        console.log("received message:", message);
+        console.log("namespace params:", params);
+        console.log("setting id to the message and sending it back to the client");
+        message.id = 1;
+        socket.emit("message_saved", message);
+    }
+
+}
diff --git a/sample/sample6-dynamic-namespaces/app.ts b/sample/sample6-dynamic-namespaces/app.ts
@@ -0,0 +1,7 @@
+import "reflect-metadata";
+import {createSocketServer} from "../../src/index";
+import "./MessageController";
+
+createSocketServer(3001); // creates socket.io server and registers all controllers there
+
+console.log("Socket.io is up and running on port 3001. Send messages via socket-io client.");
diff --git a/sample/sample6-dynamic-namespaces/index.html b/sample/sample6-dynamic-namespaces/index.html
@@ -0,0 +1,19 @@
+<html>
+<script src="../../node_modules/socket.io-client/dist/socket.io.js"></script>
+<script>
+    var socket = io("http://localhost:3001/messages/1");
+    socket.on("message_saved", function (message) {
+        console.log("Saved message received back: ", message);
+    });
+
+    function onClick() {
+        socket.emit("save", { text: "Hello this is message" });
+    }
+</script>
+<body>
+
+Watch console for events.<br/>
+<button onclick="onClick()">Click to send a save event to the /messages/1 namespace.</button>
+
+</body>
+</html>
diff --git a/src/SocketControllerExecutor.ts b/src/SocketControllerExecutor.ts
@@ -6,6 +6,7 @@ import {ParamMetadata} from "./metadata/ParamMetadata";
 import {ParameterParseJsonError} from "./error/ParameterParseJsonError";
 import {ParamTypes} from "./metadata/types/ParamTypes";
 import {ControllerMetadata} from "./metadata/ControllerMetadata";
+import * as pathToRegexp from "path-to-regexp";
 
 /**
  * Registers controllers and actions in the given server framework.
@@ -91,7 +92,11 @@ export class SocketControllerExecutor {
 
         // register controllers with namespaces
         controllersWithNamespaces.forEach(controller => {
-            this.io.of(controller.namespace).on("connection", (socket: any) => this.handleConnection([controller], socket));
+            let namespace: string | RegExp = controller.namespace;
+            if (!(namespace instanceof RegExp)) {
+                namespace = pathToRegexp(namespace);
+            }
+            this.io.of(namespace).on("connection", (socket: any) => this.handleConnection([controller], socket));
         });
 
         return this;
@@ -101,20 +106,20 @@ export class SocketControllerExecutor {
         controllers.forEach(controller => {
             controller.actions.forEach(action => {
                 if (action.type === ActionTypes.CONNECT) {
-                    this.handleAction(action, { socket: socket })
+                    this.handleAction(action, {socket: socket})
                         .then(result => this.handleSuccessResult(result, action, socket))
                         .catch(error => this.handleFailResult(error, action, socket));
 
                 } else if (action.type === ActionTypes.DISCONNECT) {
                     socket.on("disconnect", () => {
-                        this.handleAction(action, { socket: socket })
+                        this.handleAction(action, {socket: socket})
                             .then(result => this.handleSuccessResult(result, action, socket))
                             .catch(error => this.handleFailResult(error, action, socket));
                     });
 
                 } else if (action.type === ActionTypes.MESSAGE) {
                     socket.on(action.name, (data: any) => {
-                        this.handleAction(action, { socket: socket, data: data })
+                        this.handleAction(action, {socket: socket, data: data})
                             .then(result => this.handleSuccessResult(result, action, socket))
                             .catch(error => this.handleFailResult(error, action, socket));
                     });
@@ -123,8 +128,8 @@ export class SocketControllerExecutor {
         });
     }
 
-    private handleAction(action: ActionMetadata, options: { socket?: any, data?: any }): Promise<any> {
-        
+    private handleAction(action: ActionMetadata, options: {socket?: any, data?: any}): Promise<any> {
+
         // compute all parameters
         const paramsPromises = action.params
             .sort((param1, param2) => param1.index - param2.index)
@@ -147,6 +152,13 @@ export class SocketControllerExecutor {
                 } else if (param.type === ParamTypes.SOCKET_ROOMS) {
                     return options.socket.rooms;
 
+                } else if (param.type === ParamTypes.NAMESPACE_PARAMS) {
+                    return this.handleNamespaceParams(options.socket, action, param);
+
+                } else if (param.type === ParamTypes.NAMESPACE_PARAM) {
+                    const params: any[] = this.handleNamespaceParams(options.socket, action, param);
+                    return params[param.value];
+
                 } else {
                     return this.handleParam(param, options);
                 }
@@ -162,7 +174,7 @@ export class SocketControllerExecutor {
         });
     }
 
-    private handleParam(param: ParamMetadata, options: { socket?: any, data?: any }) {
+    private handleParam(param: ParamMetadata, options: {socket?: any, data?: any}) {
 
         let value = options.data;
         if (value !== null && value !== undefined && value !== "")
@@ -241,4 +253,15 @@ export class SocketControllerExecutor {
         }
     }
 
+    private handleNamespaceParams(socket: any, action: ActionMetadata, param: ParamMetadata): any[] {
+        const keys: any[] = [];
+        const regexp = pathToRegexp(action.controllerMetadata.namespace, keys);
+        const parts: any[] = regexp.exec(socket.nsp.name);
+        const params: any[] = [];
+        keys.forEach((key: any, index: number) => {
+            params[key.name] = this.handleParamFormat(parts[index + 1], param);
+        });
+        return params;
+    }
+
 }
diff --git a/src/decorators.ts b/src/decorators.ts
@@ -171,6 +171,41 @@ export function SocketRequest() {
     };
 }
 
+/**
+ * Injects parameters of the connected socket namespace.
+ */
+export function NspParams() {
+    return function (object: Object, methodName: string, index: number) {
+        let format = (Reflect as any).getMetadata("design:paramtypes", object, methodName)[index];
+        const metadata: ParamMetadataArgs = {
+            target: object.constructor,
+            method: methodName,
+            index: index,
+            type: ParamTypes.NAMESPACE_PARAMS,
+            reflectedType: format
+        };
+        defaultMetadataArgsStorage().params.push(metadata);
+    };
+}
+
+/**
+ * Injects named param from the connected socket namespace.
+ */
+export function NspParam(name: string) {
+    return function (object: Object, methodName: string, index: number) {
+        let format = (Reflect as any).getMetadata("design:paramtypes", object, methodName)[index];
+        const metadata: ParamMetadataArgs = {
+            target: object.constructor,
+            method: methodName,
+            index: index,
+            type: ParamTypes.NAMESPACE_PARAM,
+            reflectedType: format,
+            value: name
+        };
+        defaultMetadataArgsStorage().params.push(metadata);
+    };
+}
+
 /**
  * Injects rooms of the connected socket client.
  */
diff --git a/src/metadata/types/ParamTypes.ts b/src/metadata/types/ParamTypes.ts
@@ -8,7 +8,9 @@ export type ParamType = "custom"
     | "socket-io"
     | "socket-id"
     | "socket-request"
-    | "socket-rooms";
+    | "socket-rooms"
+    | "namespace-params"
+    | "namespace-param";
 
 /**
  * Controller action's parameter type.
@@ -18,8 +20,10 @@ export class ParamTypes {
     static CONNECTED_SOCKET: ParamType = "connected-socket";
     static SOCKET_BODY: ParamType = "socket-body";
     static SOCKET_QUERY_PARAM: ParamType = "socket-query-param";
-    static SOCKET_IO = "socket-io";
-    static SOCKET_ID = "socket-id";
-    static SOCKET_REQUEST = "socket-request";
-    static SOCKET_ROOMS = "socket-rooms";
+    static SOCKET_IO: ParamType = "socket-io";
+    static SOCKET_ID: ParamType = "socket-id";
+    static SOCKET_REQUEST: ParamType = "socket-request";
+    static SOCKET_ROOMS: ParamType = "socket-rooms";
+    static NAMESPACE_PARAMS: ParamType = "namespace-params";
+    static NAMESPACE_PARAM: ParamType = "namespace-param";
 }
