Added websocket router, handlers, and basic rooms

server/package-lock.json

@@ -11,7 +11,8 @@
       "dependencies": {
         "@types/ws": "^8.5.9",
         "express": "^4.18.2",
-        "ws": "^8.14.2"
+        "ws": "^8.14.2",
+        "zod": "^3.22.4"
       },
       "devDependencies": {
         "@types/express": "^4.17.21",
@@ -1399,6 +1400,14 @@
       "engines": {
         "node": ">=6"
       }
+    },
+    "node_modules/zod": {
+      "version": "3.22.4",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.22.4.tgz",
+      "integrity": "sha512-iC+8Io04lddc+mVqQ9AZ7OQ2MrUKGN+oIQyq1vemgt46jwCwLfhq7/pwnBnNXXXZb8VTVLKwp9EDkx+ryxIWmg==",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
     }
   }
 }

server/package.json

@@ -23,6 +23,7 @@
   "dependencies": {
     "@types/ws": "^8.5.9",
     "express": "^4.18.2",
-    "ws": "^8.14.2"
+    "ws": "^8.14.2",
+    "zod": "^3.22.4"
   }
 }

server/src/helpers.ts

@@ -0,0 +1,6 @@
+import * as crypto from "crypto";
+
+export function generateSessionToken(length: number): string {
+    return crypto.randomBytes(length).toString("hex");
+}
+

server/src/index.ts

@@ -1,6 +1,8 @@
 import express, { Application, Request, Response } from "express";
 import * as http from "http";
 import * as WebSocket from "ws";
+import { HapticLinkServer } from "./socket/hapticLinkServer";
+import { registerRoutes } from "./socket/routes";
 
 const port: number = parseInt(process.env.PORT as string, 10) || 3000;
 
@@ -12,13 +14,30 @@ app.get("/", (_req: Request, res: Response) => {
     res.send("Bonjour");
 });
 
+// Routes are in socket/routes/*.ts
+// registerRoutes imports and adds them all to router
+const hapticLink = new HapticLinkServer();
+registerRoutes(hapticLink);
+
+// When a user sends a message, the router checks if that route is available
+// and then calls the handler. It also generates a User object for them to store
+// data for later requests such as an ID
 wss.on("connection", (ws: WebSocket) => {
     console.log("Client Connected");
 
     ws.on("message", (message: string) => {
         console.log(`Received Message: ${message}`);
+        hapticLink.handleRoute(ws, message);
     });
 
+    // When a user disconnects, their account is removed, and they are removed from all groups
+    ws.on("close", () => {
+        hapticLink.removeUser(ws);
+    })
+    ws.on("error", () => {
+        hapticLink.removeUser(ws);
+    })
+
     ws.send("Welcome");
 });
 

server/src/socket/hapticLinkServer.ts

@@ -0,0 +1,114 @@
+import * as WebSocket from "ws";
+import { ZodSchema } from "zod";
+import { generateSessionToken } from "../helpers";
+import { Room } from "./room";
+
+type RouteHandler<T> = (context: Context<T>) => void;
+
+export interface Route<T> {
+    name: string;
+    schema: ZodSchema<T>
+    handler: RouteHandler<T>;
+}
+
+export class User {
+    id: string;
+    username?: string;
+    socket: WebSocket;
+    currentRoom?: Room;
+    rooms: Room[];
+
+    constructor(socket: WebSocket) {
+        this.id = generateSessionToken(16);
+        this.socket = socket;
+        this.rooms = [];
+    }
+}
+
+export interface Context<T> {
+    ws: WebSocket;
+    user: User;
+    payload: T;
+    server: HapticLinkServer;
+}
+
+export class HapticLinkServer {
+    routes: { [key: string]: Route<any> }
+    rooms: { [key: string]: Room }
+    users: Map<WebSocket, User>;
+
+    constructor() {
+        this.routes = {};
+        this.users = new Map();
+        this.rooms = {};
+    }
+
+    removeUser(ws: WebSocket): boolean {
+        const user = this.users.get(ws);
+        if (!user) return false;
+        user.rooms.forEach((room) => {
+            room.removeUserById(user.id);
+        })
+
+        return true;
+    }
+
+    addRoute(route: Route<any>): boolean {
+        if (route.name in this.routes) {
+            return false
+        }
+
+        this.routes[route.name] = route;
+
+        return true;
+    }
+
+    handleRoute(ws: WebSocket, 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" }));
+        }
+
+        if (typeof payload != "object" || !Object.keys(payload).includes("route")) {
+            return ws.send(JSON.stringify({ error: "missing route" }));
+        }
+
+        if (!(payload.route in this.routes)) {
+            return ws.send(JSON.stringify({ error: "route not found" }));
+        }
+
+        if (!(payload.route in this.routes)) {
+            return ws.send(JSON.stringify({ error: "route not found" }));
+        }
+
+
+        const route = this.routes[payload.route];
+        delete payload.route;
+
+        let user: User;
+
+        if (this.users.has(ws)) {
+            user = this.users.get(ws)!;
+        } else {
+            const newUser = new User(ws);
+            this.users.set(ws, newUser);
+            user = newUser;
+        }
+
+        let context: Context<any> = {
+            ws,
+            payload,
+            server: this,
+            user
+        }
+
+        if (route && route.schema.safeParse(payload).success) {
+            route.handler(context);
+        } else {
+            return ws.send(JSON.stringify({ error: "invalid payload format" }));
+        }
+    }
+}

server/src/socket/room.ts

@@ -0,0 +1,64 @@
+import { generateSessionToken } from "../helpers";
+import { User } from "./hapticLinkServer";
+
+interface UserData {
+    username: string;
+    id: string;
+    online: boolean;
+    lastOnline: number;
+}
+
+export class Room {
+    id: string;
+    users: User[];
+    constructor(roomId?: string) {
+        this.id = roomId || generateSessionToken(16);
+        this.users = [];
+    }
+
+    addUser(user: User) {
+        this.users.push(user);
+        user.rooms.push(this);
+        this.updateRoom();
+    }
+
+    removeUserById(id: string): boolean {
+        const oldSize = this.users.length;
+        this.users = this.users.filter(user => user.id != id);
+        this.updateRoom();
+        return oldSize > this.users.length;
+    }
+
+    hasUser(id: string): boolean {
+        return this.users.some(user => user.id == id);
+    }
+
+    /**
+    * @param message Message to send to users
+    * @param filter Array of user ID to ignore when sending
+    **/
+    broadcast(message: string, filter: string[] = []) {
+        this.users.forEach(user => {
+            if (filter.includes(user.id)) return;
+            user.socket.send(message);
+        })
+    }
+
+    updateRoom() {
+        const usersData: UserData[] = [];
+        this.users.forEach((user) => {
+            usersData.push({
+                username: user.username || "Unknown",
+                id: user.id,
+                online: true,
+                lastOnline: 0,
+            })
+        })
+
+        this.broadcast(JSON.stringify({
+            message: "room_update",
+            roomId: this.id,
+            users: usersData,
+        }))
+    }
+}

server/src/socket/routes.ts

@@ -0,0 +1,10 @@
+import { HapticLinkServer } from "./hapticLinkServer";
+import JoinRoomRoute from "./routes/join_room";
+import LeaveRoomRoute from "./routes/leave_room";
+import TestConnectionRoute from "./routes/test_connection";
+
+export function registerRoutes(router: HapticLinkServer) {
+    router.addRoute(TestConnectionRoute);
+    router.addRoute(JoinRoomRoute);
+    router.addRoute(LeaveRoomRoute);
+}

server/src/socket/routes/join_room.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { Context, Route } from "../hapticLinkServer";
+import { generateSessionToken } from "../../helpers";
+import { Room } from "../room";
+
+interface JoinRoomPayload {
+    roomId?: string;
+    username?: string;
+}
+const JoinRoomSchema = z.object({
+    roomId: z.string().optional(),
+    username: z.string().optional(),
+})
+
+const JoinRoomRoute: Route<JoinRoomPayload> = {
+    name: "join_room",
+    handler: function(ctx: Context<JoinRoomPayload>) {
+        // Set username if payload has it
+        if (ctx.payload.username) {
+            ctx.user.username = ctx.payload.username;
+        }
+
+        if (ctx.user.rooms.length > 4) {
+            return ctx.ws.send(JSON.stringify({
+                message: "join_room_response",
+                status: "you are already part of 5 groups. leave one to join another."
+            }))
+        }
+
+        let room: Room;
+
+        if (ctx.payload.roomId && !ctx.server.rooms[ctx.payload.roomId]) {
+            room = new Room(ctx.payload.roomId);
+            ctx.server.rooms[room.id] = room;
+        } else if (!ctx.payload.roomId) {
+            ctx.payload.roomId = generateSessionToken(12);
+            room = new Room(ctx.payload.roomId);
+            ctx.server.rooms[room.id] = room;
+        } else {
+            room = ctx.server.rooms[ctx.payload.roomId]
+        }
+
+        // Broadcasts message to room
+        room.addUser(ctx.user);
+    },
+    schema: JoinRoomSchema,
+}
+
+export default JoinRoomRoute;

server/src/socket/routes/leave_room.ts

@@ -0,0 +1,38 @@
+
+import { z } from "zod";
+import { Context, Route } from "../hapticLinkServer";
+
+interface LeaveRoomPayload {
+    roomId: string;
+}
+const LeaveRoomSchema = z.object({
+    roomId: z.string(),
+})
+
+const LeaveRoomRoute: Route<LeaveRoomPayload> = {
+    name: "leave_room",
+    handler: function(ctx: Context<LeaveRoomPayload>) {
+        const room = ctx.user.rooms.find((r) => {
+            return ctx.payload.roomId == r.id;
+        })
+
+        if (!room) {
+            return ctx.ws.send(JSON.stringify({
+                message: "leave_room_response",
+                status: "you are not part of that room"
+            }))
+        } else {
+            room.removeUserById(ctx.user.id);
+            ctx.user.rooms = ctx.user.rooms.filter((r) => {
+                return r != room
+            })
+            return ctx.ws.send(JSON.stringify({
+                message: "leave_room_response",
+                status: "room left"
+            }))
+        }
+    },
+    schema: LeaveRoomSchema,
+}
+
+export default LeaveRoomRoute;

server/src/socket/routes/test_connection.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { Context, Route } from "../hapticLinkServer";
+
+interface TestConnectionPayload { }
+const TestConnnectionSchema = z.object({})
+
+const TestConnectionRoute: Route<TestConnectionPayload> = {
+    name: "test_connection",
+    handler: function (ctx: Context<TestConnectionPayload>) {
+        if (ctx.user) {
+            return ctx.ws.send(JSON.stringify({
+                "message": "test_connection_response",
+                "authenticated": true,
+                "username": ctx.user.username
+            }))
+        }
+        return ctx.ws.send(JSON.stringify({
+            "message": "test_connection_response",
+            "authenticated": false,
+        }))
+    },
+    schema: TestConnnectionSchema,
+}
+
+export default TestConnectionRoute;