shuttlepro-shared 1.1.73 → 1.1.75

package/config/redis.js

@@ -3,16 +3,19 @@ require("dotenv").config();
 
 const REDIS_URL = process.env.REDIS_URL || "redis://localhost:6379";
 
-// ✅ Create a single Redis client instance
+// ✅ Create main Redis client
 const client = createClient({
   url: REDIS_URL,
-  socket: { reconnectStrategy: (retries) => Math.min(retries * 50, 1000) }, // Exponential backoff for reconnections
+  socket: { reconnectStrategy: (retries) => Math.min(retries * 50, 1000) }, // Exponential backoff
 });
 
+// ✅ Create separate Pub/Sub clients
+const publisher = client.duplicate();
+const subscriber = client.duplicate();
+
 // ✅ Handle Redis Connection Events
 client.on("error", (err) => console.error("❌ Redis Error:", err));
 client.on("connect", () => console.log("✅ Redis Connected"));
-client.on("reconnecting", () => console.warn("⚠️ Redis Reconnecting..."));
 client.on("ready", () => console.log("🚀 Redis Ready to use"));
 client.on("end", () => console.log("❗ Redis Connection Closed"));
 
@@ -21,12 +24,46 @@ const connectRedis = async () => {
   if (!client.isOpen) {
     try {
       await client.connect();
+      await publisher.connect();
+      await subscriber.connect();
     } catch (err) {
       console.error("❌ Failed to connect to Redis:", err);
     }
   }
 };
 
+/**
+ * ✅ Publish Data to a Channel
+ * @param {string} channel - The Redis Pub/Sub channel
+ * @param {any} message - The message to send
+ */
+const publishToChannel = async (channel, message) => {
+  try {
+    await connectRedis();
+    await publisher.publish(channel, JSON.stringify(message));
+    console.log(`📢 Message published to channel: ${channel}`);
+  } catch (err) {
+    console.error("❌ Error publishing message:", err);
+  }
+};
+
+/**
+ * ✅ Subscribe & Listen for Messages
+ * @param {string} channel - The Redis Pub/Sub channel
+ * @param {function} callback - Callback function to handle messages
+ */
+const subscribeToChannel = async (channel, callback) => {
+  try {
+    await connectRedis();
+    await subscriber.subscribe(channel, (message) => {
+      console.log(`📥 Message received on channel: ${channel}`);
+      callback(JSON.parse(message));
+    });
+  } catch (err) {
+    console.error("❌ Error subscribing to channel:", err);
+  }
+};
+
 /**
  * ✅ Set Data in Redis (Supports String & Hash)
  * @param {string} key - The Redis key
@@ -91,29 +128,33 @@ const deleteRedisData = async (key, field = null) => {
 /**
  * ✅ Graceful Shutdown Handling
  */
-const closeClient = async () => {
-  if (client.isOpen) {
-    await client.quit();
-    console.log("❗ Redis Disconnected Gracefully");
-  }
+const closeClients = async () => {
+  if (client.isOpen) await client.quit();
+  if (publisher.isOpen) await publisher.quit();
+  if (subscriber.isOpen) await subscriber.quit();
+  console.log("❗ Redis Clients Disconnected Gracefully");
 };
 
 // ✅ Ensure Redis disconnects properly on process exit
-process.on("exit", closeClient);
+process.on("exit", closeClients);
 process.on("SIGINT", async () => {
-  await closeClient();
+  await closeClients();
   process.exit();
 });
 process.on("SIGTERM", async () => {
-  await closeClient();
+  await closeClients();
   process.exit();
 });
 
 // ✅ Export Functions
 module.exports = {
-  client, // Export Redis client for reuse
+  client,
+  publisher,
+  subscriber,
   setRedisData,
   getRedisData,
   deleteRedisData,
+  publishToChannel,
+  subscribeToChannel,
   connectRedis,
 };

package/config/socket.js

@@ -1,50 +1,88 @@
 const { Server } = require("socket.io");
-const { client: redisClient } = require("./redis"); // Import shared Redis client
+const { publisher, subscriber, connectRedis } = require("./redis");
 require("dotenv").config();
 
 let io;
 const namespaceSockets = {}; // Store different namespace sockets
 
+/**
+ * Initialize Socket.IO server with namespaces
+ * @param {http.Server} server - HTTP server instance
+ * @param {string} namespaceParam - Socket namespace name (default: "conversation")
+ * @param {string} redisChannel - Redis channel for this namespace (default: "socket_events")
+ * @returns {SocketIO.Namespace} - The initialized namespace
+ */
 const initializeSocket = async (
   server,
   namespaceParam = "conversation",
   redisChannel = "socket_events"
 ) => {
+  // Initialize Socket.IO server if not already done
   if (!io) {
     io = new Server(server, {
-      cors: { origin: "*" },
+      cors: {
+        origin: "*",
+        methods: ["GET", "POST"],
+      },
     });
+    console.log("✅ Socket.IO server initialized");
   }
 
   // Return existing namespace if already initialized
   if (namespaceSockets[namespaceParam]) {
+    console.log(`📢 Using existing namespace: /${namespaceParam}`);
     return namespaceSockets[namespaceParam];
   }
 
-  // Create and store namespace
+  // Create and store new namespace
   const namespace = io.of(`/${namespaceParam}`);
   namespaceSockets[namespaceParam] = namespace;
+  console.log(`🚀 Created new namespace: /${namespaceParam}`);
 
-  // Ensure Redis client is connected
-  if (!redisClient.isOpen) {
-    await redisClient.connect();
-  }
+  // Ensure Redis is connected
+  await connectRedis();
+
+  // Create a unique Redis channel for this namespace
+  const nsRedisChannel = `${redisChannel}_${namespaceParam}`;
 
   // Subscribe to Redis events for this namespace
-  await redisClient.subscribe(redisChannel, (message) => {
+  await subscriber.subscribe(nsRedisChannel, (messageStr) => {
     try {
-      const { workspaceId, event, data } = JSON.parse(message);
-      namespace.to(workspaceId).emit(event, data);
+      const message = JSON.parse(messageStr);
+      const { workspaceId, event, data } = message;
+
+      console.log(`📥 Redis message received on ${nsRedisChannel}:`, {
+        workspaceId,
+        event,
+      });
+
+      // Emit to specific workspace room in this namespace
+      if (workspaceId) {
+        namespace.to(workspaceId).emit(event, data);
+        console.log(
+          `📢 Event ${event} emitted to workspace ${workspaceId} in /${namespaceParam}`
+        );
+      } else {
+        // Broadcast to all clients in this namespace if no workspaceId specified
+        namespace.emit(event, data);
+        console.log(
+          `📢 Event ${event} broadcasted to all clients in /${namespaceParam}`
+        );
+      }
     } catch (err) {
-      console.error("Error parsing Redis message:", err);
+      console.error(
+        `❌ Error handling Redis message on ${nsRedisChannel}:`,
+        err
+      );
     }
   });
 
-  // Handle new socket connections
+  // Handle new socket connections to this namespace
   namespace.on("connection", (socket) => {
     const { workspaceId } = socket.handshake.query;
 
     if (!workspaceId) {
+      console.warn(`⚠️ Connection rejected: No workspaceId provided`);
       socket.disconnect(true);
       return;
     }
@@ -53,29 +91,81 @@ const initializeSocket = async (
       `✅ Client connected: ${socket.id} (Workspace: ${workspaceId}) in /${namespaceParam}`
     );
 
-    socket.join(workspaceId); // Join workspace room
+    // Join workspace room
+    socket.join(workspaceId);
+
+    // Send connection confirmation to client
+    socket.emit("connected", {
+      status: "connected",
+      socketId: socket.id,
+      namespace: namespaceParam,
+      workspaceId,
+    });
+
+    // Handle custom events from clients
+    socket.on("client_event", (data) => {
+      console.log(`📥 Client event from ${socket.id}:`, data);
+      // You can process client events here
+    });
 
-    socket.on("disconnect", () => {
+    // Handle disconnect
+    socket.on("disconnect", (reason) => {
+      console.log(
+        `❌ Client disconnected: ${socket.id} (Workspace: ${workspaceId}, Reason: ${reason})`
+      );
       socket.leave(workspaceId);
     });
+
+    // Handle errors
+    socket.on("error", (error) => {
+      console.error(`❌ Socket error for ${socket.id}:`, error);
+    });
   });
 
+  console.log(
+    `✅ Namespace /${namespaceParam} initialized and listening on Redis channel: ${nsRedisChannel}`
+  );
   return namespace;
 };
 
+/**
+ * Send event to clients via Redis pub/sub
+ * @param {object} params - Event parameters
+ * @param {string} params.workspaceId - Target workspace ID
+ * @param {string} params.event - Event name
+ * @param {any} params.data - Event data payload
+ * @param {string} [params.namespace="conversation"] - Target namespace
+ * @param {string} [params.redisChannel="socket_events"] - Base Redis channel
+ * @returns {Promise<void>}
+ */
 const sendEventToServer = async ({
   workspaceId,
   event,
   data,
+  namespace = "conversation",
   redisChannel = "socket_events",
 }) => {
   try {
-    await redisClient.publish(
-      redisChannel,
-      JSON.stringify({ workspaceId, event, data })
+    // Create namespace-specific Redis channel
+    const nsRedisChannel = `${redisChannel}_${namespace}`;
+
+    // Ensure Redis is connected
+    await connectRedis();
+
+    // Create message payload
+    const message = JSON.stringify({ workspaceId, event, data });
+
+    // Publish to Redis
+    await publisher.publish(nsRedisChannel, message);
+
+    console.log(
+      `📢 Event published to Redis channel ${nsRedisChannel}: ${event} (Workspace: ${workspaceId})`
     );
+
+    return true;
   } catch (err) {
-    console.error("Error publishing to Redis:", err);
+    console.error("❌ Error publishing to Redis:", err);
+    throw err;
   }
 };
 

package/package.json

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