shuttlepro-shared 1.1.91 → 1.1.93

package/common/repositories/workspace.repository.js

@@ -1,95 +0,0 @@
-const { getRedisData, setRedisData } = require("../../config/redis");
-const Workspace = require("../../models/Workspace");
-
-const CACHE_KEY_ALL = "workspaces_all";
-
-const getCachedWorkspaces = async () => {
-  let workspaces = await getRedisData(CACHE_KEY_ALL);
-  if (!workspaces) {
-    workspaces = await Workspace.find().exec();
-    await setRedisData(CACHE_KEY_ALL, JSON.stringify(workspaces));
-  } else {
-    workspaces = JSON.parse(workspaces);
-  }
-  return workspaces;
-};
-
-const updateCachedWorkspaces = async () => {
-  const workspaces = await Workspace.find().exec();
-  await setRedisData(CACHE_KEY_ALL, JSON.stringify(workspaces));
-};
-
-const createWorkspace = async (data) => {
-  const newWorkspace = new Workspace(data);
-  const savedWorkspace = await newWorkspace.save();
-  await updateCachedWorkspaces();
-  return savedWorkspace;
-};
-
-const findWorkspaceById = async (id, select = []) => {
-  const workspaces = await getCachedWorkspaces();
-  const workspace = workspaces.find((ws) => ws._id.toString() === id) || null;
-
-  if (workspace && select.length > 0) {
-    return select.reduce((result, field) => {
-      if (workspace[field] !== undefined) {
-        result[field] = workspace[field];
-      }
-      return result;
-    }, {});
-  }
-
-  return workspace;
-};
-
-const findWorkspace = async (filter) => {
-  const workspaces = await getCachedWorkspaces();
-  return (
-    workspaces.find((ws) =>
-      Object.entries(filter).every(([key, value]) => ws[key] === value)
-    ) || null
-  );
-};
-
-const findWorkspaceByIdAndQueueTracking = async (id) => {
-  const workspaces = await getCachedWorkspaces();
-  return (
-    workspaces.find((ws) => ws._id.toString() === id && ws.queueTracking) ||
-    null
-  );
-};
-
-const findAllWorkspaces = async (filter = {}) => {
-  const workspaces = await getCachedWorkspaces();
-  return workspaces.filter((ws) =>
-    Object.entries(filter).every(([key, value]) => ws[key] === value)
-  );
-};
-
-const updateWorkspace = async (id, data) => {
-  const updatedWorkspace = await Workspace.findByIdAndUpdate(id, data, {
-    new: true,
-  }).exec();
-  if (updatedWorkspace) {
-    await updateCachedWorkspaces();
-  }
-  return updatedWorkspace;
-};
-
-const deleteWorkspace = async (id) => {
-  const deletedWorkspace = await Workspace.findByIdAndDelete(id).exec();
-  if (deletedWorkspace) {
-    await updateCachedWorkspaces();
-  }
-  return deletedWorkspace;
-};
-
-module.exports = {
-  createWorkspace,
-  findWorkspaceById,
-  findWorkspace,
-  findWorkspaceByIdAndQueueTracking,
-  findAllWorkspaces,
-  updateWorkspace,
-  deleteWorkspace,
-};

package/config/bull.js

@@ -1,78 +0,0 @@
-const Queue = require("bull");
-const config = require("./config");
-
-/**
- * Create a new queue.
- * @param {string} queueName - The name of the queue.
- * @param {Object} [redisConfig=config.redis] - Redis configuration.
- * @returns {Object} - A collection of queue-related functions.
- */
-const createQueue = (queueName, redisConfig = config.redis) => {
-  const queue = new Queue(queueName, { redis: redisConfig });
-
-  // Attach event listeners for logging
-  queue.on("completed", (job) => console.log(`Job ${job.id} completed.`));
-  queue.on("failed", (job, err) => console.error(`Job ${job.id} failed:`, err));
-
-  /**
-   * Add a job to the queue.
-   * @param {Object} data - Data to be processed by the job.
-   * @param {Object} [options] - Bull job options (e.g., delay, attempts).
-   * @returns {Promise<Job>} - The created job.
-   */
-  const addJob = async (
-    data,
-    options = {
-      attempts: 3,
-      removeOnComplete: true,
-    }
-  ) => {
-    return await queue.add(data, options);
-  };
-
-  /**
-   * Process jobs in the queue.
-   * @param {Function} processor - The function to process each job.
-   */
-  const processJobs = (processor) => {
-    queue.process(processor);
-  };
-
-  /**
-   * Close the queue connection.
-   * @returns {Promise<void>}
-   */
-  const closeConnection = async () => {
-    await queue.close();
-    console.log(`Queue "${queue.name}" connection closed.`);
-  };
-
-  /**
-   * Pause the queue.
-   * @returns {Promise<void>}
-   */
-  const pauseQueue = async () => {
-    await queue.pause();
-    console.log(`Queue "${queue.name}" paused.`);
-  };
-
-  /**
-   * Resume the queue.
-   * @returns {Promise<void>}
-   */
-  const resumeQueue = async () => {
-    await queue.resume();
-    console.log(`Queue "${queue.name}" resumed.`);
-  };
-
-  // Return the functional interface
-  return {
-    addJob,
-    processJobs,
-    closeConnection,
-    pauseQueue,
-    resumeQueue,
-  };
-};
-
-module.exports = { createQueue };

package/config/config.js

@@ -1,14 +0,0 @@
-const ALLOWED_URLS = process.env.ALLOWED_ORIGIN.split(",");
-const WEBHOOK_API_KEY = process.env.API_KEY || process.env.WEBHOOK_API_KEY;
-const mode = process.env.MODE || "production";
-
-const redis = {
-  url: process.env.REDIS_URI,
-};
-
-module.exports = {
-  WEBHOOK_API_KEY,
-  ALLOWED_URLS,
-  mode,
-  redis,
-};

package/config/database.js

@@ -1,7 +0,0 @@
-/* eslint-disable no-undef */
-module.exports = {
-  url:
-    process.env.NODE_ENV === "test"
-      ? process.env.TEST_DB_URL
-      : process.env.DB_URL,
-};

package/config/index.js

@@ -1,13 +0,0 @@
-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,160 +0,0 @@
-const { createClient } = require("redis");
-require("dotenv").config();
-
-const REDIS_URL = process.env.REDIS_URL || "redis://localhost:6379";
-
-// ✅ Create main Redis client
-const client = createClient({
-  url: REDIS_URL,
-  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("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) {
-    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
- * @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,
-  expiryInSeconds = 3600
-) => {
-  try {
-    await connectRedis();
-    let result;
-    if (field) {
-      result = await client.hSet(key, field, JSON.stringify(value));
-    } else {
-      result = await client.set(key, JSON.stringify(value), {
-        EX: expiryInSeconds,
-      });
-    }
-    return result;
-  } catch (err) {
-    console.error("❌ Error setting Redis data:", err);
-    return 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 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);
-    return null;
-  }
-};
-
-/**
- * ✅ 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 field ? await client.hDel(key, field) : await client.del(key);
-  } catch (err) {
-    console.error("❌ Error deleting Redis data:", err);
-    return null;
-  }
-};
-
-/**
- * ✅ Graceful Shutdown Handling
- */
-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", closeClients);
-process.on("SIGINT", async () => {
-  await closeClients();
-  process.exit();
-});
-process.on("SIGTERM", async () => {
-  await closeClients();
-  process.exit();
-});
-
-// ✅ Export Functions
-module.exports = {
-  client,
-  publisher,
-  subscriber,
-  setRedisData,
-  getRedisData,
-  deleteRedisData,
-  publishToChannel,
-  subscribeToChannel,
-  connectRedis,
-};

package/config/socket.js

@@ -1,172 +0,0 @@
-const { Server } = require("socket.io");
-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: "*",
-        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 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(nsRedisChannel, (messageStr) => {
-    try {
-      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 handling Redis message on ${nsRedisChannel}:`,
-        err
-      );
-    }
-  });
-
-  // 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;
-    }
-
-    console.log(
-      `✅ Client connected: ${socket.id} (Workspace: ${workspaceId}) in /${namespaceParam}`
-    );
-
-    // 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
-    });
-
-    // 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 {
-    // 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);
-    throw err;
-  }
-};
-
-module.exports = { initializeSocket, sendEventToServer };