Glm

src/realtime/events/connection.js

@@ -0,0 +1,48 @@
+const roomService = require("../services/roomService");
+const notificationService = require("../services/notificationService");
+
+function registerConnectionHandler(io) {
+  io.on("connection", (socket) => {
+    console.log(`client connected: ${socket.id}`);
+
+    socket.on("join-room", ({ roomId, userId }) => {
+      if (!roomId || !userId) {
+        socket.emit("event-error", {
+          message: "roomId and userId are required",
+        });
+        return;
+      }
+
+      roomService.joinRoom(socket, roomId, userId);
+
+      socket.emit("room-joined", {
+        roomId,
+        userId,
+        socketId: socket.id,
+      });
+    });
+
+    socket.on("broadcast-notification", ({ roomId, message, type }) => {
+      if (!roomId || !message) {
+        socket.emit("event-error", {
+          message: "roomId and message are required",
+        });
+        return;
+      }
+
+      notificationService.broadcastToRoom(io, roomId, {
+        type: type || "info",
+        message,
+        senderId: socket.id,
+        timestamp: new Date().toISOString(),
+      });
+    });
+
+    socket.on("disconnect", () => {
+      roomService.removeSocket(socket.id);
+      console.log(`client disconnected: ${socket.id}`);
+    });
+  });
+}
+
+module.exports = registerConnectionHandler;

src/realtime/services/notificationService.js

@@ -0,0 +1,15 @@
+class NotificationService {
+  broadcastToRoom(io, roomId, payload) {
+    io.to(roomId).emit("receive-notification", payload);
+  }
+
+  broadcastToAll(io, payload) {
+    io.emit("receive-notification", payload);
+  }
+
+  sendToClient(socket, payload) {
+    socket.emit("receive-notification", payload);
+  }
+}
+
+module.exports = new NotificationService();

src/realtime/services/roomService.js

@@ -0,0 +1,45 @@
+class RoomService {
+  constructor() {
+    this.rooms = new Map();
+  }
+
+  joinRoom(socket, roomId, userId) {
+    socket.join(roomId);
+
+    if (!this.rooms.has(roomId)) {
+      this.rooms.set(roomId, new Set());
+    }
+
+    this.rooms.get(roomId).add(
+      JSON.stringify({
+        socketId: socket.id,
+        userId,
+      })
+    );
+  }
+
+  removeSocket(socketId) {
+    for (const [roomId, members] of this.rooms.entries()) {
+      const filteredMembers = [...members].filter((member) => {
+        const parsed = JSON.parse(member);
+        return parsed.socketId !== socketId;
+      });
+
+      if (filteredMembers.length === 0) {
+        this.rooms.delete(roomId);
+      } else {
+        this.rooms.set(roomId, new Set(filteredMembers));
+      }
+    }
+  }
+
+  getRoomMembers(roomId) {
+    if (!this.rooms.has(roomId)) {
+      return [];
+    }
+
+    return [...this.rooms.get(roomId)].map((member) => JSON.parse(member));
+  }
+}
+
+module.exports = new RoomService();

src/realtime/socketServer.js

@@ -0,0 +1,16 @@
+const { Server } = require("socket.io");
+const registerConnectionHandler = require("./events/connection");
+
+function createSocketServer(httpServer) {
+  const io = new Server(httpServer, {
+    cors: {
+      origin: "*",
+    },
+  });
+
+  registerConnectionHandler(io);
+
+  return io;
+}
+
+module.exports = createSocketServer;

tests/realtime.test.js

@@ -0,0 +1,38 @@
+const roomService = require("../src/realtime/services/roomService");
+
+describe("Realtime notification system", () => {
+  beforeEach(() => {
+    roomService.rooms = new Map();
+  });
+
+  it("should allow client to join room", () => {
+    const mockSocket = {
+      id: "socket-1",
+      join: jest.fn(),
+    };
+
+    roomService.joinRoom(mockSocket, "room-a", "user-1");
+
+    const members = roomService.getRoomMembers("room-a");
+
+    expect(mockSocket.join).toHaveBeenCalledWith("room-a");
+    expect(members).toHaveLength(1);
+    expect(members[0]).toEqual({
+      socketId: "socket-1",
+      userId: "user-1",
+    });
+  });
+
+  it("should clean up room members on disconnect", () => {
+    const mockSocket = {
+      id: "socket-2",
+      join: jest.fn(),
+    };
+
+    roomService.joinRoom(mockSocket, "room-b", "user-2");
+    roomService.removeSocket("socket-2");
+
+    const members = roomService.getRoomMembers("room-b");
+    expect(members).toHaveLength(0);
+  });
+});