Refactored messaging system. Now messages about room state sent from user and server are same. Added "broadcasting" of room state update

back/src/db/model.ts

@@ -1,27 +1,27 @@
 import { Entity, Column, PrimaryGeneratedColumn } from "typeorm";
 
 @Entity()
-export class Room {
+export abstract class Room {
   @PrimaryGeneratedColumn()
-  id: number;
+  abstract id: number;
 
   @Column({
     length: 100,
   })
-  title: string;
+  abstract title: string;
 
   @Column()
-  free: boolean;
+  abstract free: boolean;
 
   @Column()
-  x: number;
+  abstract x: number;
 
   @Column()
-  y: number;
+  abstract y: number;
 
   @Column()
-  width: number;
+  abstract width: number;
 
   @Column()
-  height: number;
+  abstract height: number;
 }

back/src/index.ts

@@ -1,9 +1,9 @@
 import "reflect-metadata";
-import { Server } from "ws";
+import { Server, OPEN } from "ws";
 import { connect, getRoomList, updateFree } from "./db";
-import { isIdMessage, isMessage } from "./types";
+import { isMessage, isUpdateMessage } from "./types";
 
-(async () => {
+const main = async () => {
   const connection = await connect();
 
   const wss = new Server({
@@ -13,12 +13,25 @@ import { isIdMessage, isMessage } from "./types";
   wss.on("connection", async (ws) => {
     ws.send(JSON.stringify(await getRoomList(connection)));
 
-    ws.on("message", (data) => {
+    ws.on("message", async (data) => {
-      const message: unknown = JSON.parse(data.toString());
+      try {
-      if (!isMessage(message)) throw new Error("Message corrupted");
+        const message: unknown = JSON.parse(data.toString());
+        if (!isMessage(message)) throw new Error("Message corrupted");
 
-      if (isIdMessage(message))
+        if (isUpdateMessage(message)) {
-        updateFree(connection, message.args.id, message.type === "freed");
+          const { id, value } = message.args;
+          await updateFree(connection, id, value);
+
+          wss.clients.forEach((client) => {
+            if (client.readyState === OPEN)
+              client.send(JSON.stringify(message));
+          });
+        }
+      } catch (err) {
+        console.log("Error processing message", err);
+      }
     });
   });
-})();
+};
+
+main();

back/src/types.ts

@@ -1,32 +1,33 @@
-import { idMsgTypes } from "./constants";
-
-export type IdMsgTypes = typeof idMsgTypes[number];
-
 export type Message = {
   type: string;
   args: unknown;
 };
 
-export type IdMessage = Message & {
+export type UpdateMessage = Message & {
-  type: IdMsgTypes;
+  type: "update";
   args: {
     id: number;
+    value: boolean;
   };
 };
 
+const isObjLike = (obj: unknown): obj is object =>
+  Boolean(obj) && typeof obj === "object";
+
 const hasProperty = <T extends {}, U extends PropertyKey>(
   obj: T,
   prop: U
 ): obj is T & Record<U, unknown> => prop in obj;
 
 export const isMessage = (obj: unknown): obj is Message =>
-  typeof obj === "object" &&
+  isObjLike(obj) &&
   hasProperty(obj, "type") &&
   typeof obj.type === "string" &&
   hasProperty(obj, "args");
 
-export const isIdMessage = (message: Message): message is IdMessage =>
+export const isUpdateMessage = (message: Message): message is UpdateMessage =>
-  idMsgTypes.reduce((prev, curr) => prev || curr === message.type, false) &&
+  isObjLike(message.args) &&
-  typeof message.args === "object" &&
   hasProperty(message.args, "id") &&
-  typeof message.args.id === "number";
+  typeof message.args.id === "number" &&
+  hasProperty(message.args, "value") &&
+  typeof message.args.value === "boolean";

back/tsconfig.json

@@ -5,7 +5,7 @@
     "esModuleInterop": true,
     "moduleResolution": "node",
     "forceConsistentCasingInFileNames": true,
-    "strict": false,
+    "strict": true,
     "skipLibCheck": true,
     "emitDecoratorMetadata": true,
     "experimentalDecorators": true,