shuttlepro-shared 1.1.67 → 1.1.69

package/config/index.js

@@ -2,10 +2,12 @@ const bullConfig = require("./bull");
 const redisConfig = require("./redis");
 const config = require("./config");
 const databaseConfig = require("./database");
+const socketConfig = require("./socket");
 
 module.exports = {
   bullConfig,
   redisConfig,
   config,
   databaseConfig,
+  socketConfig,
 };

package/config/redis.js

@@ -1,18 +1,40 @@
 const { createClient } = require("redis");
-const { redis } = require("./config");
+require("dotenv").config();
 
+const REDIS_URL = process.env.REDIS_URL || "redis://localhost:6379";
+
+// ✅ Create a single Redis client instance
 const client = createClient({
-  url: redis.url,
+  url: REDIS_URL,
+  socket: { reconnectStrategy: (retries) => Math.min(retries * 50, 1000) }, // Exponential backoff for reconnections
 });
-client.on("error", (err) => console.log("Redis Client Error", err));
 
+// ✅ 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"));
+
+// ✅ Ensure Redis is connected before performing operations
 const connectRedis = async () => {
   if (!client.isOpen) {
-    await client.connect();
+    try {
+      await client.connect();
+    } catch (err) {
+      console.error("❌ Failed to connect to Redis:", err);
+    }
   }
 };
 
-exports.setRedisData = async (
+/**
+ * ✅ Set Data in Redis (Supports String & Hash)
+ * @param {string} key - The Redis key
+ * @param {any} value - The value to store
+ * @param {string|null} field - Optional field for Hash storage
+ * @param {number} expiryInSeconds - Expiry time in seconds (default: 3600)
+ */
+const setRedisData = async (
   key,
   value,
   field = null,
@@ -20,59 +42,78 @@ exports.setRedisData = async (
 ) => {
   try {
     await connectRedis();
-    let resp;
+    let result;
     if (field) {
-      resp = await client.hSet(key, field, JSON.stringify(value));
+      result = await client.hSet(key, field, JSON.stringify(value));
     } else {
-      resp = await client.set(key, JSON.stringify(value));
+      result = await client.set(key, JSON.stringify(value), {
+        EX: expiryInSeconds,
+      });
     }
-    await client.expire(key, expiryInSeconds); // Set expiry for the key
-    return resp;
+    return result;
   } catch (err) {
-    console.error("Error setting Redis data:", err);
+    console.error("❌ Error setting Redis data:", err);
     throw err;
   }
 };
 
-exports.getRedisData = async (key, field = null) => {
+/**
+ * ✅ Get Data from Redis (Supports String & Hash)
+ * @param {string} key - The Redis key
+ * @param {string|null} field - Optional field for Hash retrieval
+ */
+const getRedisData = async (key, field = null) => {
   try {
     await connectRedis();
-    let resp;
-    if (field) {
-      resp = await client.hGet(key, field);
-    } else {
-      resp = await client.get(key);
-    }
-    return resp ? JSON.parse(resp) : null;
+    let result = field ? await client.hGet(key, field) : await client.get(key);
+    return result ? JSON.parse(result) : null;
   } catch (err) {
-    console.error("Error getting Redis data:", err);
+    console.error("❌ Error getting Redis data:", err);
     throw err;
   }
 };
 
-exports.deleteRedisData = async (key) => {
+/**
+ * ✅ Delete Data from Redis (Supports String & Hash)
+ * @param {string} key - The Redis key
+ * @param {string|null} field - Optional field for Hash deletion
+ */
+const deleteRedisData = async (key, field = null) => {
   try {
     await connectRedis();
-    return await client.del(key);
+    return field ? await client.hDel(key, field) : await client.del(key);
   } catch (err) {
-    console.error("Error deleting Redis data:", err);
+    console.error("❌ Error deleting Redis data:", err);
     throw err;
   }
 };
 
-// Ensure the Redis client is closed when the application exits
-const closeClient = () => {
+/**
+ * ✅ Graceful Shutdown Handling
+ */
+const closeClient = async () => {
   if (client.isOpen) {
-    client.quit();
+    await client.quit();
+    console.log("❗ Redis Disconnected Gracefully");
   }
 };
 
+// ✅ Ensure Redis disconnects properly on process exit
 process.on("exit", closeClient);
-process.on("SIGINT", () => {
-  closeClient();
+process.on("SIGINT", async () => {
+  await closeClient();
   process.exit();
 });
-process.on("SIGTERM", () => {
-  closeClient();
+process.on("SIGTERM", async () => {
+  await closeClient();
   process.exit();
 });
+
+// ✅ Export Functions
+module.exports = {
+  client, // Export Redis client for reuse
+  setRedisData,
+  getRedisData,
+  deleteRedisData,
+  connectRedis,
+};

package/config/socket.js

@@ -0,0 +1,106 @@
+const { Server } = require("socket.io");
+const { client: redisClient, connectRedis } = require("./redis");
+const { createClient } = require("redis");
+require("dotenv").config();
+
+const REDIS_CHANNEL = "socket_events"; // Redis Pub/Sub Channel
+let io;
+
+/**
+ * ✅ Initialize WebSocket Server with Redis Pub/Sub
+ * @param {Object} server - HTTP Server instance
+ * @param {string|null} namespace - Optional namespace (passed from `index.js`)
+ */
+const initializeSocket = async (server, namespace = null) => {
+  await connectRedis(); // Ensure Redis is connected
+
+  io = new Server(server, {
+    cors: { origin: "*" },
+  });
+
+  console.log(
+    `✅ WebSocket Server Initialized ${
+      namespace ? `with namespace: ${namespace}` : "globally"
+    }`
+  );
+
+  // Create Redis Pub/Sub Clients
+  const pubClient = redisClient;
+  const subClient = createClient({ url: process.env.REDIS_URL });
+  await subClient.connect();
+
+  // ✅ Subscribe to Redis channel
+  await subClient.subscribe(REDIS_CHANNEL, (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);
+    }
+  });
+
+  // ✅ 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;
+  }
+
+  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(),
+    })
+  );
+
+  // ✅ Handle Disconnection
+  socket.on("disconnect", async () => {
+    console.log(
+      `❌ Client disconnected: ${socket.id} (Workspace: ${workspaceId})`
+    );
+    await redisClient.hDel(`${workspaceId}:sockets`, socket.id);
+  });
+};
+
+/**
+ * ✅ Publish WebSocket Events via Redis
+ * @param {string} workspaceId - Target workspace ID
+ * @param {string} event - Event name
+ * @param {Object} data - Event payload
+ */
+const sendEventToServer = async ({ workspaceId, event, data }) => {
+  await redisClient.publish(
+    REDIS_CHANNEL,
+    JSON.stringify({ workspaceId, event, data })
+  );
+};
+
+module.exports = {
+  initializeSocket,
+  sendEventToServer,
+};

package/models/Profile.js

@@ -0,0 +1,120 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const { setRedisData, getRedisData } = require("../utils");
+
+const ProfileSchema = new Schema(
+  {
+    name: { type: String, default: "" },
+    userName: { type: String, default: "" },
+    profilePicture: { type: String, default: "" },
+    profileId: { type: String, default: "" },
+    isSpam: { type: Boolean, default: false },
+    workspaceId: { type: String, default: "" },
+    email: { type: String, default: "" },
+    phoneNo: { type: String, default: "" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+const Profile = mongoose.model("Profile", ProfileSchema);
+
+const addOrUpdateProfilesInRedis = async (profile) => {
+  try {
+    const docId = profile?._id.toString();
+    let profiles = await fetchProfiles(profile?.workspaceId);
+    const profilesMap = profiles.reduce((map, p) => {
+      map[p._id.toString()] = p;
+      return map;
+    }, {});
+    profilesMap[docId] = profile.toObject();
+    profiles = Object.values(profilesMap);
+    setRedisData(`${profile?.workspaceId}-profiles`, profiles);
+    return { code: 200 };
+  } catch (err) {
+    return { code: 400 };
+  }
+};
+
+const fetchProfiles = async (workspaceId) => {
+  try {
+    let profiles = await getRedisData(`${workspaceId}-profiles`);
+    if (!profiles || profiles.length === 0) {
+      profiles = await Profile.find({ workspaceId }).lean().exec();
+      setRedisData(`${workspaceId}-profiles`, profiles);
+    }
+    return profiles;
+  } catch (err) {
+    return [];
+  }
+};
+
+const fetchByProfileIdAndWorkspaceId = async (id, workspaceId) => {
+  try {
+    let profiles = await fetchProfiles(workspaceId);
+    let profile = profiles.find(
+      (p) =>
+        (p?.profileId === id || p._id.toString() === id.toString()) &&
+        p?.workspaceId.toString() === workspaceId.toString()
+    );
+    return profile || null;
+  } catch (err) {
+    return null;
+  }
+};
+
+const fetchProfileByEmailAndWorkspaceId = async (
+  workspaceId,
+  userName = ""
+) => {
+  try {
+    let profiles = await fetchProfiles(workspaceId);
+    let profile = profiles.find(
+      (p) => p?.userName === userName && p?.workspaceId === workspaceId
+    );
+    return profile || null;
+  } catch (err) {
+    console.log(err, "err");
+    return null;
+  }
+};
+
+const createProfile = async (obj) => {
+  try {
+    let profile = await Profile.create(obj);
+    await addOrUpdateProfilesInRedis(profile);
+    return profile;
+  } catch (err) {
+    console.log(err, "err");
+    return null;
+  }
+};
+const createUpdateProfileModified = async (filter, obj) => {
+  try {
+    let profile = await Profile.findOneAndUpdate(filter, obj, { new: true });
+    await addOrUpdateProfilesInRedis(profile);
+    return profile;
+  } catch (err) {
+    console.log(err, "err");
+    return null;
+  }
+};
+const updateProfile = async (query, payload) => {
+  try {
+    const profile = await Profile.findOneAndUpdate(query, payload, {
+      new: true,
+    });
+    await addOrUpdateProfilesInRedis(profile);
+    return profile;
+  } catch (err) {
+    return null;
+  }
+};
+
+module.exports = {
+  fetchByProfileIdAndWorkspaceId,
+  fetchProfileByEmailAndWorkspaceId,
+  createProfile,
+  updateProfile,
+  fetchProfiles,
+  Profile,
+  createUpdateProfileModified,
+};

package/models.js

@@ -34,6 +34,7 @@ const StatusType = require("./models/StatusType");
 const Type = require("./models/Type");
 const Workspace = require("./models/Workspace");
 const Card = require("./models/Card");
+const Profile = require("./models/Profile");
 
 module.exports = {
   Website,
@@ -72,4 +73,5 @@ module.exports = {
   StatusType,
   Card,
   DescriptionTemplate,
+  Profile,
 };

package/package.json

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