Formatted with prettier

server/.prettierrc

@@ -2,5 +2,6 @@
   "trailingComma": "es5",
   "tabWidth": 4,
   "singleQuote": false,
-  "semi": true
+  "semi": true,
+  "printWidth": 100
 }

server/src/index.ts

@@ -7,66 +7,66 @@ import WebSocketWrapper from "./socket/WebSocketAdapter";
 import pino from "pino";
 
 (() => {
-  const args = process.argv;
-  if (args.includes("--silent")) {
-    return main(false);
-  }
+    const args = process.argv;
+    if (args.includes("--silent")) {
+        return main(false);
+    }
 
-  return main(true);
+    return main(true);
 })();
 
 function main(logging: boolean = true) {
-  const port: number = parseInt(process.env.PORT as string, 10) || 3000;
-  const logger = pino({
-    level: logging ? "info" : "silent",
-    formatters: {
-      bindings(bindings) {
-        return {
-          level: bindings.level,
-          time: bindings.time,
-          msg: bindings.msg,
-        };
-      },
-    },
-  });
+    const port: number = parseInt(process.env.PORT as string, 10) || 3000;
+    const logger = pino({
+        level: logging ? "info" : "silent",
+        formatters: {
+            bindings(bindings) {
+                return {
+                    level: bindings.level,
+                    time: bindings.time,
+                    msg: bindings.msg,
+                };
+            },
+        },
+    });
 
-  const app: Application = express();
-  const server = http.createServer(app);
-  const wss = new WebSocket.Server({ server });
+    const app: Application = express();
+    const server = http.createServer(app);
+    const wss = new WebSocket.Server({ server });
 
-  app.get("/", (_req: Request, res: Response) => {
-    res.send("Bonjour");
-  });
+    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);
+    // 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) => {
-    logger.info("Client Connected");
-    const wsw = new WebSocketWrapper(ws);
+    // 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) => {
+        logger.info("Client Connected");
+        const wsw = new WebSocketWrapper(ws);
 
-    ws.on("message", (message: string) => {
-      logger.info(`Received Message: ${message}`);
-      hapticLink.handleRoute(wsw, message);
-    });
+        ws.on("message", (message: string) => {
+            logger.info(`Received Message: ${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(wsw);
-    });
-    ws.on("error", () => {
-      hapticLink.removeUser(wsw);
-    });
+        // When a user disconnects, their account is removed, and they are removed from all groups
+        ws.on("close", () => {
+            hapticLink.removeUser(wsw);
+        });
+        ws.on("error", () => {
+            hapticLink.removeUser(wsw);
+        });
 
-    ws.send("Welcome");
-  });
+        ws.send("Welcome");
+    });
 
-  server.listen(port, () => {
-    logger.info(`Server is running on port ${port}`);
-  });
+    server.listen(port, () => {
+        logger.info(`Server is running on port ${port}`);
+    });
 }

server/src/socket/WebSocketAdapter.ts

@@ -6,7 +6,7 @@ export interface WebSocketInterface {
 }
 
 export default class WebSocketWrapper implements WebSocketInterface {
-    ws: WebSocket
+    ws: WebSocket;
 
     constructor(ws: WebSocket) {
         this.ws = ws;
@@ -17,6 +17,6 @@ export default class WebSocketWrapper implements WebSocketInterface {
     }
 
     readyState() {
-        return this.ws.readyState
+        return this.ws.readyState;
     }
 }

server/src/socket/hapticLinkServer.ts

@@ -12,7 +12,7 @@ export interface Route<T> {
 }
 
 export class User {
-    static userIdLength: number = 32
+    static userIdLength: number = 32;
     id: string;
     username?: string;
     socket: WebSocketInterface;
@@ -51,11 +51,7 @@ 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;
         }
@@ -75,15 +71,10 @@ export class HapticLinkServer {
         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" }));
         }
 

server/src/socket/room.ts

@@ -26,24 +26,24 @@ export class Room {
 
     removeUserById(id: string): boolean {
         const oldSize = this.users.length;
-        this.users = this.users.filter(user => user.id != id);
+        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);
+        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
-    **/
+     * @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 => {
+        this.users.forEach((user) => {
             if (filter.includes(user.id)) return;
             user.socket.send(message);
-        })
+        });
     }
 
     updateRoom() {
@@ -54,13 +54,15 @@ export class Room {
                 id: user.id,
                 online: true,
                 lastOnline: 0,
-            })
-        })
+            });
+        });
 
-        this.broadcast(JSON.stringify({
-            message: "room_update",
-            roomId: this.id,
-            users: usersData,
-        }))
+        this.broadcast(
+            JSON.stringify({
+                message: "room_update",
+                roomId: this.id,
+                users: usersData,
+            })
+        );
     }
 }

server/src/socket/routes/join_room.ts

@@ -9,7 +9,7 @@ export interface JoinRoomPayload {
 export const JoinRoomSchema = z.object({
     roomId: z.string().optional(),
     username: z.string().optional(),
-})
+});
 
 export function JoinRoomHandler(ctx: Context<JoinRoomPayload>) {
     // Set username if payload has it
@@ -23,30 +23,32 @@ export function JoinRoomHandler(ctx: Context<JoinRoomPayload>) {
 
     if (ctx.payload.roomId && !ctx.server.rooms[ctx.payload.roomId]) {
         // User sent roomId, but room doesn't exist
-        return ctx.ws.send(JSON.stringify({
-            "message": "join_room_response",
-            "status": "room doesn't exist",
-        }))
+        return ctx.ws.send(
+            JSON.stringify({
+                message: "join_room_response",
+                status: "room doesn't exist",
+            })
+        );
         // Custom ID Code:
         // room = new Room(ctx.payload.roomId);
         // room.id = room.id.toUpperCase();
         // ctx.server.rooms[room.id] = room;
-
     } else if (!ctx.payload.roomId) {
         // Didn't include RoomID, creating new one
         room = new Room(ctx.payload.roomId);
         room.id = room.id.toUpperCase();
         ctx.payload.roomId = room.id;
         ctx.server.rooms[room.id] = room;
-
     } else {
         // RoomId included and room exists, joining...
-        room = ctx.server.rooms[ctx.payload.roomId]
+        room = ctx.server.rooms[ctx.payload.roomId];
         if (room.hasUser(ctx.user.id)) {
-            return ctx.ws.send(JSON.stringify({
-                "message": "join_room_response",
-                "status": "failed, you are already part of this room",
-            }))
+            return ctx.ws.send(
+                JSON.stringify({
+                    message: "join_room_response",
+                    status: "failed, you are already part of this room",
+                })
+            );
         }
     }
 

server/src/socket/routes/leave_room.ts

@@ -7,21 +7,25 @@ export interface LeaveRoomPayload {
 
 export const LeaveRoomSchema = z.object({
     roomId: z.string(),
-})
+});
 
 export function LeaveRoomHandler(ctx: Context<LeaveRoomPayload>) {
     const room = ctx.user.currentRoom;
 
     if (!room) {
-        return ctx.ws.send(JSON.stringify({
-            message: "leave_room_response",
-            status: "you are not part of that 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);
-        return ctx.ws.send(JSON.stringify({
-            message: "leave_room_response",
-            status: "room left"
-        }))
+        return ctx.ws.send(
+            JSON.stringify({
+                message: "leave_room_response",
+                status: "room left",
+            })
+        );
     }
 }

server/src/socket/routes/send_touch.ts

@@ -5,8 +5,8 @@ export interface SendVibrationPayload {
     id: number;
     type: "enabled" | "disabled";
     position: {
-        x: number,
-        y: number,
+        x: number;
+        y: number;
     };
     color?: string;
     intensity?: number;
@@ -25,27 +25,31 @@ export const SendVibrationSchema = z.object({
 
 export function SendVibrationHandler(ctx: Context<SendVibrationPayload>) {
     if (!ctx.user.currentRoom) {
-        return ctx.ws.send(JSON.stringify({
-            "message": "send_vibration_response",
-            "status": "not part of a room",
-        }))
+        return ctx.ws.send(
+            JSON.stringify({
+                message: "send_vibration_response",
+                status: "not part of a room",
+            })
+        );
     }
 
     const p = ctx.payload;
 
-    ctx.user.currentRoom.broadcast(JSON.stringify({
-        message: "receive_touch",
-        id: ctx.user.id + "_" + p.id,
-        type: p.type,
-        user: {
-            username: ctx.user.username,
-            id: ctx.user.id,
-        },
-        position: {
-            x: p.position.x,
-            y: p.position.y
-        },
-        color: p.color || "#FF0000",
-        intensity: p.intensity ?? 1,
-    }))
+    ctx.user.currentRoom.broadcast(
+        JSON.stringify({
+            message: "receive_touch",
+            id: ctx.user.id + "_" + p.id,
+            type: p.type,
+            user: {
+                username: ctx.user.username,
+                id: ctx.user.id,
+            },
+            position: {
+                x: p.position.x,
+                y: p.position.y,
+            },
+            color: p.color || "#FF0000",
+            intensity: p.intensity ?? 1,
+        })
+    );
 }

server/src/socket/routes/set_username.ts

@@ -6,19 +6,20 @@ export interface SetUsernamePayload {
 }
 export const SetUsernameSchema = z.object({
     username: z.string(),
-})
+});
 
 export function SetUsernameHandler(ctx: Context<SetUsernamePayload>) {
     ctx.user.username = ctx.payload.username;
 
-    return ctx.ws.send(JSON.stringify({
-        "message": "set_username_response",
-        "status": "success",
-        "user": {
-            id: ctx.user.id,
-            username: ctx.user.username,
-            currentRoom: ctx.user.currentRoom
-        }
-    }))
+    return ctx.ws.send(
+        JSON.stringify({
+            message: "set_username_response",
+            status: "success",
+            user: {
+                id: ctx.user.id,
+                username: ctx.user.username,
+                currentRoom: ctx.user.currentRoom,
+            },
+        })
+    );
 }
-

server/test/socket/routes/send_touch.spec.ts

@@ -1,4 +1,3 @@
-
 import { expect } from "chai";
 import { Context, HapticLinkServer, User } from "../../../src/socket/hapticLinkServer";
 import { JoinRoomHandler, JoinRoomPayload } from "../../../src/socket/routes/join_room";
@@ -6,72 +5,71 @@ import { WebSocketWrapper } from "../hapticLinkServer.spec";
 import { SendVibrationHandler, SendVibrationPayload } from "../../../src/socket/routes/send_touch";
 
 describe("Send Vibration", () => {
-  let server: HapticLinkServer;
-  let ws: WebSocketWrapper;
-  let user: User;
-  let ws2: WebSocketWrapper;
-  let user2: User;
-  let ctx: Context<JoinRoomPayload>;
-  let ctx2: Context<JoinRoomPayload>;
-  let ctx3: Context<SendVibrationPayload>;
-
-  beforeEach(() => {
-    server = new HapticLinkServer();
-    ws = new WebSocketWrapper();
-    user = new User(ws);
-    ws2 = new WebSocketWrapper();
-    user2 = new User(ws2);
-    ctx = {
-      ws: ws,
-      user: user,
-      payload: { username: "test" },
-      server: server,
-    };
-    ctx2 = {
-      ws: ws2,
-      user: user2,
-      payload: { username: "test2" },
-      server: server,
-    };
+    let server: HapticLinkServer;
+    let ws: WebSocketWrapper;
+    let user: User;
+    let ws2: WebSocketWrapper;
+    let user2: User;
+    let ctx: Context<JoinRoomPayload>;
+    let ctx2: Context<JoinRoomPayload>;
+    let ctx3: Context<SendVibrationPayload>;
 
+    beforeEach(() => {
+        server = new HapticLinkServer();
+        ws = new WebSocketWrapper();
+        user = new User(ws);
+        ws2 = new WebSocketWrapper();
+        user2 = new User(ws2);
+        ctx = {
+            ws: ws,
+            user: user,
+            payload: { username: "test" },
+            server: server,
+        };
+        ctx2 = {
+            ws: ws2,
+            user: user2,
+            payload: { username: "test2" },
+            server: server,
+        };
 
-    ctx3 = {
-      ws: ws,
-      user: user,
-      server: server,
-      payload: {
-        id: 1,
-        type: "enabled",
-        position: {
-          x: 3,
-          y: 10,
-        },
-        color: "#FFF",
-        intensity: 1,
-      }
-    }
-  });
+        ctx3 = {
+            ws: ws,
+            user: user,
+            server: server,
+            payload: {
+                id: 1,
+                type: "enabled",
+                position: {
+                    x: 3,
+                    y: 10,
+                },
+                color: "#FFF",
+                intensity: 1,
+            },
+        };
+    });
 
-  it("should broadcast vibration", () => {
-    JoinRoomHandler(ctx)
-    const resData = JSON.parse(ws.sendData as string)
-    ctx2.payload.roomId = resData.roomId
-    JoinRoomHandler(ctx2)
-    ws.sendData = "";
-    ws2.sendData = "";
-    SendVibrationHandler(ctx3);
+    it("should broadcast vibration", () => {
+        JoinRoomHandler(ctx);
+        const resData = JSON.parse(ws.sendData as string);
+        ctx2.payload.roomId = resData.roomId;
+        JoinRoomHandler(ctx2);
+        ws.sendData = "";
+        ws2.sendData = "";
+        SendVibrationHandler(ctx3);
 
-    const res = JSON.parse(ws2.sendData as string)
+        const res = JSON.parse(ws2.sendData as string);
 
-    expect(ws.sendData).to.equal(ws2.sendData, "vibration wasn't broadcasted correctly");
-    expect(res.message).to.equal("receive_touch", "invalid response");
-    expect(res.id).to.equal(user.id + "_" + "1", "invalid touch id");
-    expect(res.type).to.equal("enabled", "invalid touch type");
-    expect(res.user.username).to.equal("test", "wrong username");
-    expect(res.user.id).to.equal(user.id, "wrong user id");
-    expect(res.position.x).to.equal(3, "wrong x position");
-    expect(res.position.y).to.equal(10, "wrong y position");
-    expect(res.color).to.equal("#FFF", "wrong color");
-    expect(res.intensity).to.equal(1, "wrong intensity");
-  });
+        expect(ws.sendData).to.equal(ws2.sendData, "vibration wasn't broadcasted correctly");
+        expect(res.message).to.equal("receive_touch", "invalid response");
+        expect(res.id).to.equal(user.id + "_" + "1", "invalid touch id");
+        expect(res.type).to.equal("enabled", "invalid touch type");
+        expect(res.user.username).to.equal("test", "wrong username");
+        expect(res.user.id).to.equal(user.id, "wrong user id");
+        expect(res.position.x).to.equal(3, "wrong x position");
+        expect(res.position.y).to.equal(10, "wrong y position");
+        expect(res.color).to.equal("#FFF", "wrong color");
+        expect(res.intensity).to.equal(1, "wrong intensity");
+    });
 });

server/test/socket/routes/set_username.spec.ts

@@ -4,27 +4,27 @@ import { SetUsernameHandler, SetUsernamePayload } from "../../../src/socket/rout
 import { WebSocketWrapper } from "../hapticLinkServer.spec";
 
 describe("Set Username", () => {
-  let server: HapticLinkServer;
-  let ws: WebSocketWrapper;
-  let user: User;
-  let ctx: Context<SetUsernamePayload>;
+    let server: HapticLinkServer;
+    let ws: WebSocketWrapper;
+    let user: User;
+    let ctx: Context<SetUsernamePayload>;
 
-  beforeEach(() => {
-    server = new HapticLinkServer();
-    ws = new WebSocketWrapper();
-    user = new User(ws);
-    user.username = "old username"
-    ctx = {
-      ws: ws,
-      user: user,
-      payload: { username: "new username" },
-      server: server,
-    };
-  });
+    beforeEach(() => {
+        server = new HapticLinkServer();
+        ws = new WebSocketWrapper();
+        user = new User(ws);
+        user.username = "old username";
+        ctx = {
+            ws: ws,
+            user: user,
+            payload: { username: "new username" },
+            server: server,
+        };
+    });
 
-  it("should change username", (done) => {
-    SetUsernameHandler(ctx);
-    expect(user.username).to.equal("new username", "name wasn't changed correctly")
-    done();
-  })
-})
+    it("should change username", (done) => {
+        SetUsernameHandler(ctx);
+        expect(user.username).to.equal("new username", "name wasn't changed correctly");
+        done();
+    });
+});

server/test/socket/routes/test_connection.spec.ts

@@ -1,28 +1,30 @@
 import { expect } from "chai";
-import { Context, HapticLinkServer, User } from "../../../src/socket/hapticLinkServer"
-import { TestConnectionHandler, TestConnectionPayload } from "../../../src/socket/routes/test_connection"
+import { Context, HapticLinkServer, User } from "../../../src/socket/hapticLinkServer";
+import {
+    TestConnectionHandler,
+    TestConnectionPayload,
+} from "../../../src/socket/routes/test_connection";
 import { WebSocketWrapper } from "../hapticLinkServer.spec";
 
-
 describe("Test Connection", () => {
-  let server: HapticLinkServer = new HapticLinkServer();
-  const ws = new WebSocketWrapper();
-  const user = new User(ws);
-  user.username = "test"
-  let ctx: Context<TestConnectionPayload> = {
-    ws: ws,
-    user: user,
-    payload: {
-      route: "test_connection",
-    },
-    server: server,
-  }
+    let server: HapticLinkServer = new HapticLinkServer();
+    const ws = new WebSocketWrapper();
+    const user = new User(ws);
+    user.username = "test";
+    let ctx: Context<TestConnectionPayload> = {
+        ws: ws,
+        user: user,
+        payload: {
+            route: "test_connection",
+        },
+        server: server,
+    };
 
-  it("should return connection response with user", (done) => {
-    TestConnectionHandler(ctx);
-    const res = JSON.parse(ws.sendData as string);
-    expect(res.message).to.equal("test_connection_response", "didn't return message")
-    expect(res.username).to.equal("test", "didn't return message")
-    done();
-  })
-})
+    it("should return connection response with user", (done) => {
+        TestConnectionHandler(ctx);
+        const res = JSON.parse(ws.sendData as string);
+        expect(res.message).to.equal("test_connection_response", "didn't return message");
+        expect(res.username).to.equal("test", "didn't return message");
+        done();
+    });
+});