shuttlepro-shared 1.1.73 → 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 { client: redisClient } = require("./redis"); // Import shared Redis client
+const { publisher, subscriber, connectRedis } = require("./redis"); // Use separate Redis Pub/Sub clients
 require("dotenv").config();
 
 let io;
@@ -25,18 +25,16 @@ const initializeSocket = async (
   const namespace = io.of(`/${namespaceParam}`);
   namespaceSockets[namespaceParam] = namespace;
 
-  // Ensure Redis client is connected
-  if (!redisClient.isOpen) {
-    await redisClient.connect();
-  }
+  // Ensure Redis is connected
+  await connectRedis();
 
   // Subscribe to Redis events for this namespace
-  await redisClient.subscribe(redisChannel, (message) => {
+  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);
+      console.error("❌ Error parsing Redis message:", err);
     }
   });
 
@@ -56,6 +54,9 @@ const initializeSocket = async (
     socket.join(workspaceId); // Join workspace room
 
     socket.on("disconnect", () => {
+      console.log(
+        `❌ Client disconnected: ${socket.id} (Workspace: ${workspaceId})`
+      );
       socket.leave(workspaceId);
     });
   });
@@ -63,6 +64,14 @@ const initializeSocket = async (
   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 ({
   workspaceId,
   event,
@@ -70,12 +79,15 @@ const sendEventToServer = async ({
   redisChannel = "socket_events",
 }) => {
   try {
-    await redisClient.publish(
+    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);
+    console.error("❌ Error publishing to Redis:", err);
   }
 };
 

package/package.json

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