add the authenticated user to the websocket

src/interfaces/extendedWebsocket.ts

@@ -1,7 +1,9 @@
 import { WebSocket } from "ws";
 import { DecodedToken } from "./decodedToken";
+import {IUser} from "../db/models/user";
 
 export interface ExtendedWebSocket extends WebSocket {
   payload: DecodedToken;
   isAlive: boolean;
+  user:IUser;
 }

src/utils/websocket/websocketEventHandler.ts

@@ -1,5 +1,4 @@
 import {ExtendedWebSocket} from "../../interfaces/extendedWebsocket";
-import {UserService} from "../../db/services/UserService";
 
 export class WebsocketEventHandler {
     constructor(private webSocket: ExtendedWebSocket) {
@@ -25,16 +24,12 @@ export class WebsocketEventHandler {
     }
 
     public enableMessageEvent() {
-        this.webSocket.on("message", async (data) => {
+        this.webSocket.on("message", (data) => {
             const message = data.toString();
             console.log("Received message:", message);
 
             if (message === "GET_STATE") {
-                const userService = await UserService.create();
-
-                const user = await userService.getUserByUUID(this.webSocket.payload._id);
-
-                this.webSocket.send(JSON.stringify(user?.lastState), {binary: false});
+                this.webSocket.send(JSON.stringify(this.webSocket.user.lastState), {binary: false});
             }
         });
     }

src/utils/websocket/websocketServerEventHandler.ts

@@ -1,42 +1,47 @@
-import { ExtendedWebSocket } from "../../interfaces/extendedWebsocket";
-import { ExtendedIncomingMessage } from "../../interfaces/extendedIncomingMessage";
-import { Server as WebSocketServer } from "ws";
-import { heartbeat } from "./websocketServerHeartbeatInterval";
+import {ExtendedWebSocket} from "../../interfaces/extendedWebsocket";
+import {ExtendedIncomingMessage} from "../../interfaces/extendedIncomingMessage";
+import {Server as WebSocketServer} from "ws";
+import {heartbeat} from "./websocketServerHeartbeatInterval";
+import {UserService} from "../../db/services/db/UserService";
 
 export class WebsocketServerEventHandler {
-  private readonly heartbeat: () => void;
+    private readonly heartbeat: () => void;
 
-  constructor(private webSocketServer: WebSocketServer) {
-    this.heartbeat = heartbeat(this.webSocketServer);
-  }
+    constructor(private webSocketServer: WebSocketServer) {
+        this.heartbeat = heartbeat(this.webSocketServer);
+    }
 
-  public enableConnectionEvent(
-    callback: (ws: ExtendedWebSocket, request: ExtendedIncomingMessage) => void,
-  ) {
-    this.webSocketServer.on(
-      "connection",
-      (ws: ExtendedWebSocket, request: ExtendedIncomingMessage) => {
-        // first: map the payload from the request to the ws object
-        ws.payload = request.payload;
-        // second: set the isAlive flag to true
-        ws.isAlive = true;
+    public enableConnectionEvent(
+        callback: (ws: ExtendedWebSocket, request: ExtendedIncomingMessage) => void,
+    ) {
+        this.webSocketServer.on(
+            "connection",
+            async (ws: ExtendedWebSocket, request: ExtendedIncomingMessage) => {
+                const user = await (await UserService.create()).getUserByUUID(ws.payload._id);
 
-        // last: call the callback function
-        callback(ws, request);
-      },
-    );
-  }
+                ws.user = user!;
 
-  public enableHeartbeat(interval: number) {
-    return setInterval(() => {
-      this.heartbeat();
-    }, interval);
-  }
+                // first: map the payload from the request to the ws object (is payloed needed anymore?)
+                ws.payload = request.payload;
+                // second: set the isAlive flag to true
+                ws.isAlive = true;
 
-  public enableCloseEvent(callback: () => void) {
-    this.webSocketServer.on("close", () => {
-      console.log("WebSocket server closed");
-      callback();
-    });
-  }
+                // last: call the callback function
+                callback(ws, request);
+            },
+        );
+    }
+
+    public enableHeartbeat(interval: number) {
+        return setInterval(() => {
+            this.heartbeat();
+        }, interval);
+    }
+
+    public enableCloseEvent(callback: () => void) {
+        this.webSocketServer.on("close", () => {
+            console.log("WebSocket server closed");
+            callback();
+        });
+    }
 }