shuttlepro-shared 1.1.74 → 1.1.76

package/config/socket.js

@@ -1,48 +1,88 @@
 const { Server } = require("socket.io");
-const { publisher, subscriber, connectRedis } = require("./redis"); // Use separate Redis Pub/Sub clients
+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 is connected
   await connectRedis();
 
+  // Create a unique Redis channel for this namespace
+  const nsRedisChannel = `${redisChannel}_${namespaceParam}`;
+
   // Subscribe to Redis events for this namespace
-  await subscriber.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;
     }
@@ -51,43 +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})`
+        `❌ 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;
 };
 
 /**
- * ✅ Publish Event to Redis Channel
- * @param {object} params - Event data
+ * 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
- * @param {string} [params.redisChannel="socket_events"] - Redis channel (optional)
+ * @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 publisher.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: ${event} (Workspace: ${workspaceId})`
+      `📢 Event published to Redis channel ${nsRedisChannel}: ${event} (Workspace: ${workspaceId})`
     );
+
+    return true;
   } catch (err) {
     console.error("❌ Error publishing to Redis:", err);
+    throw err;
   }
 };
 

package/models/Profile.js

@@ -89,7 +89,14 @@ const createProfile = async (obj) => {
 };
 const createUpdateProfileModified = async (filter, obj) => {
   try {
-    let profile = await Profile.findOneAndUpdate(filter, obj, { new: true });
+    let profile = await Profile.findOneAndUpdate(
+      filter,
+      { ...obj, ...filter },
+      {
+        new: true,
+        upsert: true,
+      }
+    );
     await addOrUpdateProfilesInRedis(profile);
     return profile;
   } catch (err) {

package/package.json

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