shuttlepro-shared 1.1.71 → 1.1.73

package/config/socket.js

@@ -1,82 +1,66 @@
 const { Server } = require("socket.io");
-const { client: redisClient, connectRedis } = require("./redis");
-const { createClient } = require("redis");
+const { client: redisClient } = require("./redis"); // Import shared Redis client
 require("dotenv").config();
 
 let io;
+const namespaceSockets = {}; // Store different namespace sockets
 
 const initializeSocket = async (
   server,
-  namespace = null,
+  namespaceParam = "conversation",
   redisChannel = "socket_events"
 ) => {
-  await connectRedis(); // Ensure Redis is connected
-
-  io = new Server(server, {
-    cors: { origin: "*" },
-  });
-
-  io.listen(server); // Ensure server listens for WebSocket connections
+  if (!io) {
+    io = new Server(server, {
+      cors: { origin: "*" },
+    });
+  }
 
-  console.log(
-    `✅ WebSocket Server Initialized ${
-      namespace ? `with namespace: ${namespace}` : "globally"
-    }, using Redis channel: ${redisChannel}`
-  );
+  // Return existing namespace if already initialized
+  if (namespaceSockets[namespaceParam]) {
+    return namespaceSockets[namespaceParam];
+  }
 
-  const subClient = createClient({ url: process.env.REDIS_URL });
-  await subClient.connect();
-  await subClient.subscribe(redisChannel);
+  // Create and store namespace
+  const namespace = io.of(`/${namespaceParam}`);
+  namespaceSockets[namespaceParam] = namespace;
 
-  subClient.on("message", (channel, message) => {
-    console.log(`🔔 Received event from Redis channel ${channel}:`, message);
-    const { workspaceId, event, data } = JSON.parse(message);
+  // Ensure Redis client is connected
+  if (!redisClient.isOpen) {
+    await redisClient.connect();
+  }
 
-    if (namespace) {
-      io.of(namespace).to(workspaceId).emit(event, data);
-    } else {
-      io.to(workspaceId).emit(event, data);
+  // Subscribe to Redis events for this namespace
+  await redisClient.subscribe(redisChannel, (message) => {
+    try {
+      const { workspaceId, event, data } = JSON.parse(message);
+      namespace.to(workspaceId).emit(event, data);
+    } catch (err) {
+      console.error("Error parsing Redis message:", err);
     }
   });
 
-  const socketServer = namespace ? io.of(namespace) : io;
-  socketServer.on("connection", (socket) =>
-    handleConnection(socket, namespace)
-  );
-};
-
-const handleConnection = async (socket, namespace = null) => {
-  const { workspaceId } = socket.handshake.query;
-
-  if (!workspaceId) {
-    console.warn(`❌ Client ${socket.id} rejected due to missing workspaceId`);
-    socket.disconnect(true);
-    return;
-  }
-
-  console.log(
-    `✅ Client connected: ${socket.id} (Workspace: ${workspaceId}) Namespace: ${
-      namespace || "Global"
-    }`
-  );
+  // Handle new socket connections
+  namespace.on("connection", (socket) => {
+    const { workspaceId } = socket.handshake.query;
 
-  await redisClient.hSet(
-    `${workspaceId}:sockets`,
-    socket.id,
-    JSON.stringify({
-      id: socket.id,
-      workspaceId,
-      namespace,
-      connectedAt: new Date().toISOString(),
-    })
-  );
+    if (!workspaceId) {
+      socket.disconnect(true);
+      return;
+    }
 
-  socket.on("disconnect", async () => {
     console.log(
-      `❌ Client disconnected: ${socket.id} (Workspace: ${workspaceId})`
+      `✅ Client connected: ${socket.id} (Workspace: ${workspaceId}) in /${namespaceParam}`
     );
-    await redisClient.hDel(`${workspaceId}:sockets`, socket.id);
+
+    socket.join(workspaceId); // Join workspace room
+
+    socket.on("disconnect", () => {
+      socket.leave(workspaceId);
+    });
   });
+
+  return namespace;
 };
 
 const sendEventToServer = async ({
@@ -85,17 +69,14 @@ const sendEventToServer = async ({
   data,
   redisChannel = "socket_events",
 }) => {
-  if (!redisClient.isReady) {
-    await redisClient.connect();
+  try {
+    await redisClient.publish(
+      redisChannel,
+      JSON.stringify({ workspaceId, event, data })
+    );
+  } catch (err) {
+    console.error("Error publishing to Redis:", err);
   }
-
-  await redisClient.publish(
-    redisChannel,
-    JSON.stringify({ workspaceId, event, data })
-  );
 };
 
-module.exports = {
-  initializeSocket,
-  sendEventToServer,
-};
+module.exports = { initializeSocket, sendEventToServer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shuttlepro-shared",
-  "version": "1.1.71",
+  "version": "1.1.73",
   "description": "",
   "main": "index.js",
   "scripts": {