Added websocket to wrapper for easier testing

server/src/index.ts

@@ -3,6 +3,7 @@ import * as http from "http";
 import * as WebSocket from "ws";
 import { HapticLinkServer } from "./socket/hapticLinkServer";
 import { registerRoutes } from "./socket/routes";
+import WebSocketWrapper from "./socket/WebSocketAdapter";
 
 const port: number = parseInt(process.env.PORT as string, 10) || 3000;
 
@@ -24,18 +25,19 @@ registerRoutes(hapticLink);
 // data for later requests such as an ID
 wss.on("connection", (ws: WebSocket) => {
     console.log("Client Connected");
+    const wsw = new WebSocketWrapper(ws);
 
     ws.on("message", (message: string) => {
         console.log(`Received Message: ${message}`);
-        hapticLink.handleRoute(ws, message);
+        hapticLink.handleRoute(wsw, message);
     });
 
     // When a user disconnects, their account is removed, and they are removed from all groups
     ws.on("close", () => {
-        hapticLink.removeUser(ws);
+        hapticLink.removeUser(wsw);
     })
     ws.on("error", () => {
-        hapticLink.removeUser(ws);
+        hapticLink.removeUser(wsw);
     })
 
     ws.send("Welcome");

server/src/socket/WebSocketAdapter.ts

@@ -0,0 +1,25 @@
+import { WebSocket } from "ws";
+
+export default class WebSocketWrapper {
+    ws: WebSocket
+
+    constructor(ws: WebSocket) {
+        this.ws = ws;
+    }
+
+    send(data: string | Buffer) {
+        this.ws.send(data);
+    }
+
+    get OPEN() {
+        return this.ws.OPEN;
+    }
+
+    get CLOSED() {
+        return this.ws.CLOSED;
+    }
+
+    get CLOSING() {
+        return this.ws.CLOSING;
+    }
+}

server/src/socket/hapticLinkServer.ts

@@ -1,39 +1,39 @@
-import * as WebSocket from "ws";
 import { ZodSchema } from "zod";
 import { generateSessionToken } from "../helpers";
 import { Room } from "./room";
+import WebSocketWrapper from "./WebSocketAdapter";
 
 type RouteHandler<T> = (context: Context<T>) => void;
 
 export interface Route<T> {
     name: string;
-    schema: ZodSchema<T>
+    schema: ZodSchema<T>;
     handler: RouteHandler<T>;
 }
 
 export class User {
     id: string;
     username?: string;
-    socket: WebSocket;
+    socket: WebSocketWrapper;
     currentRoom?: Room;
 
-    constructor(socket: WebSocket) {
+    constructor(socket: WebSocketWrapper) {
         this.id = generateSessionToken(16);
         this.socket = socket;
     }
 }
 
 export interface Context<T> {
-    ws: WebSocket;
+    ws: WebSocketWrapper;
     user: User;
     payload: T;
     server: HapticLinkServer;
 }
 
 export class HapticLinkServer {
-    routes: { [key: string]: Route<any> }
-    rooms: { [key: string]: Room }
-    users: Map<WebSocket, User>;
+    routes: { [key: string]: Route<any> };
+    rooms: { [key: string]: Room };
+    users: Map<WebSocketWrapper, User>;
 
     constructor() {
         this.routes = {};
@@ -41,7 +41,7 @@ export class HapticLinkServer {
         this.rooms = {};
     }
 
-    removeUser(ws: WebSocket): boolean {
+    removeUser(ws: WebSocketWrapper): boolean {
         const user = this.users.get(ws);
         if (!user) return false;
         if (user.currentRoom) {
@@ -50,30 +50,39 @@ export class HapticLinkServer {
         return true;
     }
 
-    addRoute<T>(name: string, schema: ZodSchema<T>, handler: RouteHandler<T>): boolean {
+    addRoute<T>(
+        name: string,
+        schema: ZodSchema<T>,
+        handler: RouteHandler<T>
+    ): boolean {
         if (name in this.routes) {
-            return false
+            return false;
         }
 
         this.routes[name] = {
             name,
             schema,
-            handler
-        }
+            handler,
+        };
 
         return true;
     }
 
-    handleRoute(ws: WebSocket, message: string) {
+    handleRoute(ws: WebSocketWrapper, message: string) {
         // Parse JSON
         let payload: any;
         try {
             payload = JSON.parse(message);
         } catch (e) {
-            return ws.send(JSON.stringify({ error: "message not in JSON format" }));
+            return ws.send(
+                JSON.stringify({ error: "message not in JSON format" })
+            );
         }
 
-        if (typeof payload != "object" || !Object.keys(payload).includes("route")) {
+        if (
+            typeof payload != "object" ||
+            !Object.keys(payload).includes("route")
+        ) {
             return ws.send(JSON.stringify({ error: "missing route" }));
         }
 
@@ -81,7 +90,6 @@ export class HapticLinkServer {
             return ws.send(JSON.stringify({ error: "route not found" }));
         }
 
-
         const route = this.routes[payload.route];
         delete payload.route;
 
@@ -99,8 +107,8 @@ export class HapticLinkServer {
             ws,
             payload,
             server: this,
-            user
-        }
+            user,
+        };
 
         if (route && route.schema.safeParse(payload).success) {
             route.handler(context);