shuttlepro-shared 1.1.70 → 1.1.72

package/config/socket.js

@@ -1,116 +1,94 @@
 const { Server } = require("socket.io");
-const { client: redisClient, connectRedis } = require("./redis");
 const { createClient } = require("redis");
 require("dotenv").config();
 
 let io;
+const namespaceSockets = {}; // Store different namespace sockets
 
-/**
- * ✅ Initialize WebSocket Server with Redis Pub/Sub
- * @param {Object} server - HTTP Server instance
- * @param {string|null} namespace - Optional namespace (passed from `index.js`)
- * @param {string} [redisChannel="socket_events"] - Custom Redis Pub/Sub Channel
- */
 const initializeSocket = async (
   server,
-  namespace = null,
+  namespaceParam = "conversation",
   redisChannel = "socket_events"
 ) => {
-  await connectRedis(); // Ensure Redis is connected
+  if (!io) {
+    io = new Server(server, {
+      cors: { origin: "*" },
+    });
+  }
 
-  io = new Server(server, {
-    cors: { origin: "*" },
-  });
+  // If namespace is already initialized, return it
+  if (namespaceSockets[namespaceParam]) {
+    console.log(`⚡ Namespace ${namespaceParam} already initialized`);
+    return namespaceSockets[namespaceParam];
+  }
 
-  console.log(
-    `✅ WebSocket Server Initialized ${
-      namespace ? `with namespace: ${namespace}` : "globally"
-    }, using Redis channel: ${redisChannel}`
-  );
+  // Create new namespace
+  const namespace = io.of(`/${namespaceParam}`);
+  namespaceSockets[namespaceParam] = namespace;
+  console.log(`✅ WebSocket Namespace Initialized: /${namespaceParam}`);
 
-  // Create Redis Pub/Sub Clients
-  const pubClient = redisClient;
+  // Create Redis subscriber for this namespace
   const subClient = createClient({ url: process.env.REDIS_URL });
   await subClient.connect();
+  await subClient.subscribe(redisChannel);
 
-  // ✅ Subscribe to the dynamic Redis channel
-  await subClient.subscribe(redisChannel, (message) => {
+  subClient.on("message", (channel, message) => {
+    console.log(
+      `🔔 Redis Event on ${channel} for /${namespaceParam}:`,
+      message
+    );
     const { workspaceId, event, data } = JSON.parse(message);
 
-    if (namespace) {
-      io.of(namespace).to(workspaceId).emit(event, data);
-    } else {
-      io.to(workspaceId).emit(event, data);
-    }
+    namespace.to(workspaceId).emit(event, data);
   });
 
-  // ✅ Handle WebSocket Connection (Global or Namespace)
-  const socketServer = namespace ? io.of(namespace) : io;
-  socketServer.on("connection", (socket) =>
-    handleConnection(socket, namespace)
-  );
-};
-
-/**
- * ✅ Handle WebSocket Connection
- * @param {Object} socket - WebSocket client socket
- * @param {string} [namespace] - Optional 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;
-  }
+  // Handle socket connections per namespace
+  namespace.on("connection", (socket) => {
+    const { workspaceId } = socket.handshake.query;
 
-  console.log(
-    `✅ Client connected: ${socket.id} (Workspace: ${workspaceId}) Namespace: ${
-      namespace || "Global"
-    }`
-  );
-
-  await redisClient.hSet(
-    `${workspaceId}:sockets`,
-    socket.id,
-    JSON.stringify({
-      id: socket.id,
-      workspaceId,
-      namespace,
-      connectedAt: new Date().toISOString(),
-    })
-  );
+    if (!workspaceId) {
+      console.warn(
+        `❌ Client ${socket.id} rejected due to missing workspaceId`
+      );
+      socket.disconnect(true);
+      return;
+    }
 
-  // ✅ Handle Disconnection
-  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", () => {
+      console.log(
+        `❌ Client disconnected: ${socket.id} (Workspace: ${workspaceId}) in /${namespaceParam}`
+      );
+    });
   });
+
+  return namespace;
 };
 
-/**
- * ✅ Publish WebSocket Events via Redis
- * @param {string} workspaceId - Target workspace ID
- * @param {string} event - Event name
- * @param {Object} data - Event payload
- * @param {string} [redisChannel="socket_events"] - Custom Redis Pub/Sub Channel
- */
 const sendEventToServer = async ({
+  namespace = "conversation",
   workspaceId,
   event,
   data,
   redisChannel = "socket_events",
 }) => {
+  const redisClient = createClient({ url: process.env.REDIS_URL });
+  await redisClient.connect();
+
+  console.log(
+    `📤 Sending event '${event}' to namespace '/${namespace}' for workspace '${workspaceId}'`
+  );
   await redisClient.publish(
     redisChannel,
     JSON.stringify({ workspaceId, event, data })
   );
-};
 
-module.exports = {
-  initializeSocket,
-  sendEventToServer,
+  await redisClient.disconnect();
 };
+
+module.exports = { initializeSocket, sendEventToServer };

package/package.json

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