shuttlepro-shared 1.1.72 → 1.1.74

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,5 +1,5 @@
 const { Server } = require("socket.io");
-const { createClient } = require("redis");
+const { publisher, subscriber, connectRedis } = require("./redis"); // Use separate Redis Pub/Sub clients
 require("dotenv").config();
 
 let io;
@@ -16,40 +16,33 @@ const initializeSocket = async (
     });
   }
 
-  // If namespace is already initialized, return it
+  // Return existing namespace if already initialized
   if (namespaceSockets[namespaceParam]) {
-    console.log(`⚡ Namespace ${namespaceParam} already initialized`);
     return namespaceSockets[namespaceParam];
   }
 
-  // Create new namespace
+  // Create and store namespace
   const namespace = io.of(`/${namespaceParam}`);
   namespaceSockets[namespaceParam] = namespace;
-  console.log(`✅ WebSocket Namespace Initialized: /${namespaceParam}`);
 
-  // Create Redis subscriber for this namespace
-  const subClient = createClient({ url: process.env.REDIS_URL });
-  await subClient.connect();
-  await subClient.subscribe(redisChannel);
+  // Ensure Redis is connected
+  await connectRedis();
 
-  subClient.on("message", (channel, message) => {
-    console.log(
-      `🔔 Redis Event on ${channel} for /${namespaceParam}:`,
-      message
-    );
-    const { workspaceId, event, data } = JSON.parse(message);
-
-    namespace.to(workspaceId).emit(event, data);
+  // Subscribe to Redis events for this namespace
+  await subscriber.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);
+    }
   });
 
-  // Handle socket connections per namespace
+  // Handle new socket connections
   namespace.on("connection", (socket) => {
     const { workspaceId } = socket.handshake.query;
 
     if (!workspaceId) {
-      console.warn(
-        `❌ Client ${socket.id} rejected due to missing workspaceId`
-      );
       socket.disconnect(true);
       return;
     }
@@ -62,33 +55,40 @@ const initializeSocket = async (
 
     socket.on("disconnect", () => {
       console.log(
-        `❌ Client disconnected: ${socket.id} (Workspace: ${workspaceId}) in /${namespaceParam}`
+        `❌ Client disconnected: ${socket.id} (Workspace: ${workspaceId})`
       );
+      socket.leave(workspaceId);
     });
   });
 
   return namespace;
 };
 
+/**
+ * ✅ Publish Event to Redis Channel
+ * @param {object} params - Event data
+ * @param {string} params.workspaceId - Target workspace ID
+ * @param {string} params.event - Event name
+ * @param {any} params.data - Event data
+ * @param {string} [params.redisChannel="socket_events"] - Redis channel (optional)
+ */
 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 })
-  );
-
-  await redisClient.disconnect();
+  try {
+    await publisher.publish(
+      redisChannel,
+      JSON.stringify({ workspaceId, event, data })
+    );
+    console.log(
+      `📢 Event published to Redis: ${event} (Workspace: ${workspaceId})`
+    );
+  } catch (err) {
+    console.error("❌ Error publishing to Redis:", err);
+  }
 };
 
 module.exports = { initializeSocket, sendEventToServer };

package/package.json

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