shuttlepro-shared 1.4.35 → 1.4.36

package/common/repositories/index.js

@@ -15,7 +15,6 @@ const notificationSettingsRepository = require("./notificationSettings.repositor
 const customerProfileRepository = require("./customerProfile.repository");
 const customerTimelineRepository = require("./customerTimeline.repository");
 const shopRepository = require("./shop.repository");
-const callRepository = require("./call.repository");
 const interactiveRepository = require("./interactive.repository");
 const workflowRunRepository = require("./workflowRun.repository");
 exports.module = {
@@ -36,7 +35,6 @@ exports.module = {
   customerProfileRepository,
   customerTimelineRepository,
   shopRepository,
-  callRepository,
   interactiveRepository,
   workflowRunRepository,
 };

package/common/repositories/workflowRun.repository.js

@@ -14,6 +14,31 @@ class WorkflowRunRepository {
     return await WorkflowRun.find(filter).sort({ createdAt: -1 });
   }
 
+  async findPaginated(filter = {}, page = 1, limit = 100, options = {}) {
+    const skip = Math.max(0, (Number(page) - 1) * Number(limit));
+    const query = WorkflowRun.find(filter)
+      .sort({ createdAt: -1 })
+      .skip(skip)
+      .limit(Number(limit))
+      // include essential fields from relations for UI
+      .populate({
+        path: "workflowId",
+        select: options.workflowSelect || "name business",
+      })
+      .populate({
+        path: "initialMessageId",
+        select: options.templateSelect || "name subject type",
+      })
+      .lean();
+
+    const [data, total] = await Promise.all([
+      query.exec(),
+      WorkflowRun.countDocuments(filter),
+    ]);
+
+    return { data, total };
+  }
+
   async update(id, updates) {
     return await WorkflowRun.findByIdAndUpdate(id, updates, { new: true });
   }

package/config/socket.js

@@ -4,47 +4,27 @@ require("dotenv").config();
 
 let io;
 const namespaceSockets = {}; // Store different namespace sockets
-const namespaceHandlers = {}; // Store custom handlers for each namespace
-
-/**
- * Register custom event handlers for a specific namespace
- * @param {string} namespace - Namespace name
- * @param {Function} handlerFunction - Function that sets up socket event handlers
- */
-const registerNamespaceHandlers = (namespace, handlerFunction) => {
-  namespaceHandlers[namespace] = handlerFunction;
-  console.log(`📋 Registered custom handlers for namespace: /${namespace}`);
-};
 
 /**
  * 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")
- * @param {Object} options - Additional options for namespace configuration
- * @param {Function} options.customHandlers - Custom socket event handlers for this namespace
- * @param {boolean} options.requireWorkspaceId - Whether workspace ID is required (default: true)
  * @returns {SocketIO.Namespace} - The initialized namespace
  */
 const initializeSocket = async (
   server,
   namespaceParam = "conversation",
-  redisChannel = "socket_events",
-  path = "/whatsapp-calling",
-  options = {}
+  redisChannel = "socket_events"
 ) => {
-  const {
-    customHandlers,
-    requireWorkspaceId = true,
-    cors = {
-      origin: "*",
-      methods: ["GET", "POST"],
-    },
-  } = options;
-
   // Initialize Socket.IO server if not already done
   if (!io) {
-    io = new Server(server, { path, cors });
+    io = new Server(server, {
+      cors: {
+        origin: "*",
+        methods: ["GET", "POST"],
+      },
+    });
     console.log("✅ Socket.IO server initialized");
   }
 
@@ -69,36 +49,21 @@ const initializeSocket = async (
   await subscriber.subscribe(nsRedisChannel, (messageStr) => {
     try {
       const message = JSON.parse(messageStr);
-      const { workspaceId, event, data, target } = message;
+      const { workspaceId, event, data } = message;
 
       console.log(`📥 Redis message received on ${nsRedisChannel}:`, {
         workspaceId,
         event,
-        target,
       });
 
-      // Handle different targeting options
-      if (target === "broadcast") {
-        // Broadcast to all clients in this namespace
-        namespace.emit(event, data);
-        console.log(
-          `📢 Event ${event} broadcasted to all clients in /${namespaceParam}`
-        );
-      } else if (target && target.startsWith("socket:")) {
-        // Target specific socket ID
-        const socketId = target.replace("socket:", "");
-        namespace.to(socketId).emit(event, data);
-        console.log(
-          `📢 Event ${event} emitted to socket ${socketId} in /${namespaceParam}`
-        );
-      } else if (workspaceId) {
-        // Emit to specific workspace room in this namespace
+      // 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 {
-        // Default: broadcast to all clients in this namespace
+        // 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}`
@@ -114,44 +79,20 @@ const initializeSocket = async (
 
   // Handle new socket connections to this namespace
   namespace.on("connection", (socket) => {
-    const { workspaceId, callId, agentId } = socket.handshake.query;
+    const { workspaceId } = socket.handshake.query;
 
-    // Workspace ID validation (can be disabled for certain namespaces)
-    if (requireWorkspaceId && !workspaceId) {
-      console.warn(
-        `⚠️ Connection rejected: No workspaceId provided for namespace /${namespaceParam}`
-      );
+    if (!workspaceId) {
+      console.warn(`⚠️ Connection rejected: No workspaceId provided`);
       socket.disconnect(true);
       return;
     }
 
     console.log(
-      `✅ Client connected: ${socket.id} (Workspace: ${
-        workspaceId || "N/A"
-      }, CallId: ${callId || "N/A"}) in /${namespaceParam}`
+      `✅ Client connected: ${socket.id} (Workspace: ${workspaceId}) in /${namespaceParam}`
     );
 
-    // Join workspace room if workspaceId is provided
-    if (workspaceId) {
-      socket.join(workspaceId);
-    }
-
-    // Join additional rooms based on query parameters
-    if (callId) {
-      socket.join(`call:${callId}`);
-    }
-    if (agentId) {
-      socket.join(`agent:${agentId}`);
-    }
-
-    // Store socket metadata
-    socket.metadata = {
-      workspaceId,
-      callId,
-      agentId,
-      namespace: namespaceParam,
-      connectedAt: new Date(),
-    };
+    // Join workspace room
+    socket.join(workspaceId);
 
     // Send connection confirmation to client
     socket.emit("connected", {
@@ -159,70 +100,25 @@ const initializeSocket = async (
       socketId: socket.id,
       namespace: namespaceParam,
       workspaceId,
-      callId,
-      agentId,
     });
 
-    // Apply custom handlers if provided
-    if (customHandlers && typeof customHandlers === "function") {
-      try {
-        customHandlers(socket, namespace);
-        console.log(
-          `📋 Applied custom handlers for socket ${socket.id} in /${namespaceParam}`
-        );
-      } catch (error) {
-        console.error(
-          `❌ Error applying custom handlers for socket ${socket.id}:`,
-          error
-        );
-      }
-    }
-
-    // Apply registered namespace handlers
-    if (namespaceHandlers[namespaceParam]) {
-      try {
-        namespaceHandlers[namespaceParam](socket, namespace);
-        console.log(
-          `📋 Applied registered handlers for socket ${socket.id} in /${namespaceParam}`
-        );
-      } catch (error) {
-        console.error(
-          `❌ Error applying registered handlers for socket ${socket.id}:`,
-          error
-        );
-      }
-    }
-
-    // Default event handlers for backward compatibility
-    setupDefaultHandlers(socket, namespace, namespaceParam);
+    // 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 || "N/A"
-        }, Reason: ${reason}) from /${namespaceParam}`
+        `❌ Client disconnected: ${socket.id} (Workspace: ${workspaceId}, Reason: ${reason})`
       );
-
-      // Leave all rooms
-      if (workspaceId) socket.leave(workspaceId);
-      if (callId) socket.leave(`call:${callId}`);
-      if (agentId) socket.leave(`agent:${agentId}`);
-
-      // Emit disconnect event to namespace for cleanup
-      namespace.emit("client_disconnected", {
-        socketId: socket.id,
-        metadata: socket.metadata,
-        reason,
-      });
+      socket.leave(workspaceId);
     });
 
     // Handle errors
     socket.on("error", (error) => {
-      console.error(
-        `❌ Socket error for ${socket.id} in /${namespaceParam}:`,
-        error
-      );
+      console.error(`❌ Socket error for ${socket.id}:`, error);
     });
   });
 
@@ -232,64 +128,15 @@ const initializeSocket = async (
   return namespace;
 };
 
-/**
- * Setup default event handlers for backward compatibility
- * @param {Socket} socket - Socket.IO socket instance
- * @param {Namespace} namespace - Socket.IO namespace instance
- * @param {string} namespaceParam - Namespace name
- */
-const setupDefaultHandlers = (socket, namespace, namespaceParam) => {
-  // Handle custom events from clients (backward compatibility)
-  socket.on("client_event", (data) => {
-    console.log(
-      `📥 Client event from ${socket.id} in /${namespaceParam}:`,
-      data
-    );
-
-    // Emit to Redis for other instances to handle
-    sendEventToServer({
-      workspaceId: socket.metadata.workspaceId,
-      event: "client_event_received",
-      data: {
-        socketId: socket.id,
-        originalData: data,
-        metadata: socket.metadata,
-      },
-      namespace: namespaceParam,
-    }).catch((err) => {
-      console.error(`❌ Error publishing client_event to Redis:`, err);
-    });
-  });
-
-  // Handle room join requests
-  socket.on("join_room", (roomName) => {
-    if (roomName && typeof roomName === "string") {
-      socket.join(roomName);
-      socket.emit("room_joined", { room: roomName, success: true });
-      console.log(`📥 Socket ${socket.id} joined room: ${roomName}`);
-    }
-  });
-
-  // Handle room leave requests
-  socket.on("leave_room", (roomName) => {
-    if (roomName && typeof roomName === "string") {
-      socket.leave(roomName);
-      socket.emit("room_left", { room: roomName, success: true });
-      console.log(`📤 Socket ${socket.id} left room: ${roomName}`);
-    }
-  });
-};
-
 /**
  * Send event to clients via Redis pub/sub
  * @param {object} params - Event parameters
- * @param {string} [params.workspaceId] - Target workspace ID
+ * @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
- * @param {string} [params.target] - Specific target (broadcast, socket:socketId, etc.)
- * @returns {Promise<boolean>}
+ * @returns {Promise<void>}
  */
 const sendEventToServer = async ({
   workspaceId,
@@ -297,7 +144,6 @@ const sendEventToServer = async ({
   data,
   namespace = "conversation",
   redisChannel = "socket_events",
-  target,
 }) => {
   try {
     // Create namespace-specific Redis channel
@@ -307,21 +153,13 @@ const sendEventToServer = async ({
     await connectRedis();
 
     // Create message payload
-    const message = JSON.stringify({
-      workspaceId,
-      event,
-      data,
-      target,
-      timestamp: new Date().toISOString(),
-    });
+    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 || "N/A"
-      }, Target: ${target || "default"})`
+      `📢 Event published to Redis channel ${nsRedisChannel}: ${event} (Workspace: ${workspaceId})`
     );
 
     return true;
@@ -331,62 +169,4 @@ const sendEventToServer = async ({
   }
 };
 
-/**
- * Get a specific namespace instance
- * @param {string} namespace - Namespace name
- * @returns {SocketIO.Namespace|null} - Namespace instance or null if not found
- */
-const getNamespace = (namespace) => {
-  return namespaceSockets[namespace] || null;
-};
-
-/**
- * Get all active namespaces
- * @returns {Object} - Object containing all active namespaces
- */
-const getAllNamespaces = () => {
-  return { ...namespaceSockets };
-};
-
-/**
- * Get Socket.IO server instance
- * @returns {SocketIO.Server|null} - Server instance or null if not initialized
- */
-const getSocketServer = () => {
-  return io || null;
-};
-
-/**
- * Emit event to specific room in a namespace
- * @param {string} namespace - Namespace name
- * @param {string} room - Room name
- * @param {string} event - Event name
- * @param {any} data - Event data
- * @returns {boolean} - Success status
- */
-const emitToRoom = (namespace, room, event, data) => {
-  try {
-    const ns = namespaceSockets[namespace];
-    if (!ns) {
-      console.warn(`❌ Namespace /${namespace} not found`);
-      return false;
-    }
-
-    ns.to(room).emit(event, data);
-    console.log(`📢 Event ${event} emitted to room ${room} in /${namespace}`);
-    return true;
-  } catch (error) {
-    console.error(`❌ Error emitting to room ${room} in /${namespace}:`, error);
-    return false;
-  }
-};
-
-module.exports = {
-  initializeSocket,
-  sendEventToServer,
-  registerNamespaceHandlers,
-  getNamespace,
-  getAllNamespaces,
-  getSocketServer,
-  emitToRoom,
-};
+module.exports = { initializeSocket, sendEventToServer };

package/models.js

@@ -106,7 +106,6 @@ const WorkflowRun = require("./models/WorkflowRun");
 const Workflow = require("./models/Workflow");
 const Workspace = require("./models/Workspace");
 const Shop = require("./models/Shop");
-const Call = require("./models/Call");
 
 module.exports = {
   Activity,
@@ -217,5 +216,4 @@ module.exports = {
   Workspace,
   WorkflowRun,
   Shop,
-  Call,
 };

package/package.json

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

package/common/repositories/call.repository.js

@@ -1,432 +0,0 @@
-const Call = require("../../models/Call");
-const { Types } = require("mongoose");
-
-class CallRepository {
-  /* -----------------  Internal Helpers ----------------- */
-
-  _utcDayBounds(from, to) {
-    const f = new Date(from);
-    const t = new Date(to);
-
-    return {
-      from: new Date(
-        Date.UTC(
-          f.getUTCFullYear(),
-          f.getUTCMonth(),
-          f.getUTCDate(),
-          0,
-          0,
-          0,
-          0
-        )
-      ),
-      to: new Date(
-        Date.UTC(
-          t.getUTCFullYear(),
-          t.getUTCMonth(),
-          t.getUTCDate(),
-          23,
-          59,
-          59,
-          999
-        )
-      ),
-    };
-  }
-
-  _filterAllowedFields(data, allowed) {
-    return Object.keys(data).reduce((acc, key) => {
-      if (allowed.includes(key)) acc[key] = data[key];
-      return acc;
-    }, {});
-  }
-
-  _historyEntry({
-    action,
-    agentId = null,
-    details = "",
-    direction = "user",
-    platformTimestamp = "",
-    actionBy = null,
-  }) {
-    return {
-      timestamp: new Date(),
-      platformTimestamp,
-      action,
-      agentId,
-      details,
-      direction,
-      actionBy,
-    };
-  }
-
-  async _safeExec(promise, errorMsg, fallback = null) {
-    try {
-      return await promise;
-    } catch (error) {
-      console.error(`❌ ${errorMsg}`, error);
-      return fallback;
-    }
-  }
-
-  /* -----------------  Core CRUD ----------------- */
-
-  createCall(callData) {
-    const entry = this._historyEntry({
-      action: "created",
-      direction: callData?.direction || "user",
-      details: callData?.details || "Incomming call from whatsapp user",
-      platformTimestamp: callData.platformTimestamp || "",
-      agentId: callData.agentId || null,
-      actionBy: callData.userId || null,
-    });
-
-    return this._safeExec(
-      Call.create({
-        callId: callData.callId,
-        callerName: callData.callerName,
-        callerNumber: callData.callerNumber,
-        receiver: callData.receiver || "",
-        platformId: callData.platformId || null,
-        workspaceId: callData.workspaceId || null,
-        profileId: callData.profileId || null,
-        status: callData.status || "pending",
-        agentId: callData.agentId || null,
-        queuePosition: callData.queuePosition || 0,
-        whatsappSdp: callData.whatsappSdp || null,
-        metadata: callData.metadata || {},
-        tags: callData.tags || [],
-        callHistory: [entry],
-      }),
-      `Failed to create call ${callData.callId}`
-    );
-  }
-
-  getCall(callId) {
-    return this._safeExec(
-      Call.findOne({ callId }).lean().exec(),
-      `Failed to get call ${callId}`
-    );
-  }
-
-  endCall(callId, updateObj = {}, history = {}) {
-    return this._safeExec(
-      Call.findOneAndUpdate(
-        { callId },
-        { $set: { ...updateObj }, $push: { callHistory: history } },
-        { new: true }
-      ),
-      `Failed to end call ${callId}`
-    );
-  }
-
-  updateCall(callId, updateData, history = {}) {
-    const updateOps = {
-      $set: { ...updateData },
-    };
-    updateOps.$push = {
-      callHistory: history,
-    };
-    return this._safeExec(
-      Call.findOneAndUpdate({ callId }, updateOps, { new: true }),
-      `Failed to update call ${callId}`
-    );
-  }
-
-  assignCallToAgent(callId, agentId) {
-    const entry = this._historyEntry({
-      action: "answered",
-      agentId,
-      details: "Call answered by agent",
-    });
-
-    return this._safeExec(
-      Call.findOneAndUpdate(
-        { callId, status: { $in: ["pending", "hold"] } },
-        {
-          $set: {
-            agentId,
-            status: "active",
-            startTime: new Date(),
-            "connectionMetadata.lastHeartbeat": new Date(),
-          },
-          $push: { callHistory: entry },
-        },
-        { new: true }
-      ),
-      `Failed to assign call ${callId}`
-    );
-  }
-
-  bulkUpdateCalls(operations) {
-    const bulkOps = operations.map((op) => ({
-      updateOne: {
-        filter: { callId: op.callId },
-        update: {
-          $set: {
-            ...op.updateData,
-            "connectionMetadata.lastHeartbeat": new Date(),
-          },
-          $push: {
-            callHistory: this._historyEntry({
-              action: op.action || "bulk_update",
-              agentId: op.agentId,
-              details: op.details || "Bulk operation",
-            }),
-          },
-        },
-      },
-    }));
-
-    return this._safeExec(Call.bulkWrite(bulkOps), "Bulk update failed", []);
-  }
-
-  moveCallToHoldQueue(callId, reason = "Agent disconnected") {
-    const entry = this._historyEntry({
-      action: "disconnected",
-      details: reason,
-    });
-
-    return this._safeExec(
-      Call.findOneAndUpdate(
-        { callId },
-        {
-          $set: {
-            agentId: null,
-            status: "hold",
-            autoAccepted: true,
-            "connectionMetadata.lastHeartbeat": new Date(),
-          },
-          $push: { callHistory: entry },
-        },
-        { new: true }
-      ),
-      `Failed to move call ${callId} to hold queue`
-    );
-  }
-
-  /* -----------------  Queries ----------------- */
-
-  async getCallsByWorkspace(
-    { workspaceId, from, to },
-    {
-      filters = {},
-      select = null,
-      sortBy = { createdAt: -1 },
-      limit,
-      skip,
-    } = {}
-  ) {
-    const { from: fromDate, to: toDate } = this._utcDayBounds(from, to);
-
-    console.log(
-      {
-        workspaceId,
-        createdAt: { $gte: fromDate, $lte: toDate },
-        ...filters,
-      },
-      "query"
-    );
-
-    let query = Call.find({
-      workspaceId,
-      createdAt: { $gte: fromDate, $lte: toDate },
-      ...filters,
-    })
-      .select(select || {})
-      .sort(sortBy)
-      .lean();
-
-    if (limit) query = query.limit(limit);
-    if (skip) query = query.skip(skip);
-
-    return query.exec();
-  }
-
-  async addCallHistory(callId, historyData = {}) {
-    const entry = historyData;
-    return this._safeExec(
-      Call.findOneAndUpdate(
-        { callId },
-        { $push: { callHistory: entry } },
-        { new: true }
-      ),
-      `Failed to add call history for ${callId}`
-    );
-  }
-
-  getCallsByAgent(
-    agentId,
-    {
-      filters = {},
-      select = null,
-      sortBy = { createdAt: -1 },
-      limit,
-      skip,
-    } = {}
-  ) {
-    let query = Call.find({ agentId, ...filters })
-      .select(select || {})
-      .sort(sortBy)
-      .lean();
-    if (limit) query = query.limit(limit);
-    if (skip) query = query.skip(skip);
-    return query.exec();
-  }
-
-  getCallsByReceiver(receiver, filters = {}) {
-    return Call.find({ receiver, ...filters })
-      .sort({ createdAt: -1 })
-      .lean()
-      .exec();
-  }
-
-  getActiveCalls(workspaceId, filters = {}) {
-    return Call.find({
-      workspaceId,
-      status: { $in: ["active"] },
-      ...filters,
-    })
-      .lean()
-      .exec();
-  }
-
-  getPendingCalls(workspaceId) {
-    return Call.find({
-      workspaceId,
-      status: { $in: ["pending", "hold"] },
-      ...filters,
-    })
-      .lean()
-      .exec();
-  }
-
-  getCallByFilter(filters = {}) {
-    return Call.findOne(filters).lean().exec();
-  }
-
-  getStaleCalls(timeoutMinutes = 5) {
-    const timeout = new Date(Date.now() - timeoutMinutes * 60 * 1000);
-    return Call.find({
-      status: { $in: ["active", "hold", "pending"] },
-      "connectionMetadata.lastHeartbeat": { $lt: timeout },
-    })
-      .lean()
-      .exec();
-  }
-
-  /* -----------------  Reporting ----------------- */
-
-  async getAgentStats({ from, to }, filters = {}) {
-    const { from: fromDate, to: toDate } = this._utcDayBounds(from, to);
-
-    const match = { createdAt: { $gte: fromDate, $lte: toDate }, ...filters };
-    if (match.workspaceId && typeof match.workspaceId === "string")
-      match.workspaceId = new Types.ObjectId(match.workspaceId);
-    if (match.agentId && typeof match.agentId === "string")
-      match.agentId = match.agentId;
-
-    const [stats] = await Call.aggregate([
-      { $match: match },
-      {
-        $group: {
-          _id: filters.agentId ? "$agentId" : null,
-          totalCalls: { $sum: 1 },
-
-          pending: {
-            $sum: {
-              $cond: [{ $in: ["$status", ["pending", "hold"]] }, 1, 0],
-            },
-          },
-
-          active: {
-            $sum: {
-              $cond: [{ $eq: ["$status", "active"] }, 1, 0],
-            },
-          },
-
-          abandoned: {
-            $sum: { $cond: [{ $eq: ["$status", "abandoned"] }, 1, 0] },
-          },
-          ended: {
-            $sum: { $cond: [{ $eq: ["$status", "ended"] }, 1, 0] },
-          },
-        },
-      },
-      {
-        $project: {
-          _id: 0,
-          totalCalls: 1,
-          pending: 1,
-          active: 1,
-          abandoned: 1,
-          ended: 1,
-        },
-      },
-    ]);
-
-    return (
-      stats || { totalCalls: 0, pending: 0, active: 0, abandoned: 0, ended: 0 }
-    );
-  }
-
-  getDailySummary(workspaceId, from, to, filters = {}, groupBy = null) {
-    const matchStage = {
-      workspaceId,
-      createdAt: { $gte: from, $lte: to },
-      ...filters,
-    };
-
-    const groupId = {
-      day: { $dateToString: { format: "%Y-%m-%d", date: "$createdAt" } },
-    };
-    if (groupBy && ["agentId", "receiver", "platformId"].includes(groupBy))
-      groupId[groupBy] = `$${groupBy}`;
-
-    return Call.aggregate([
-      { $match: matchStage },
-      {
-        $group: {
-          _id: groupId,
-          total: { $sum: 1 },
-          ended: { $sum: { $cond: [{ $eq: ["$status", "ended"] }, 1, 0] } },
-          abandoned: {
-            $sum: { $cond: [{ $eq: ["$status", "abandoned"] }, 1, 0] },
-          },
-          avgDuration: { $avg: "$duration" },
-          minDuration: { $min: "$duration" },
-          maxDuration: { $max: "$duration" },
-        },
-      },
-      {
-        $project: {
-          _id: 0,
-          day: "$_id.day",
-          groupBy: groupBy ? `$_id.${groupBy}` : null,
-          total: 1,
-          ended: 1,
-          abandoned: 1,
-          avgDuration: { $round: ["$avgDuration", 2] },
-          minDuration: 1,
-          maxDuration: 1,
-        },
-      },
-      { $sort: { day: 1 } },
-    ]);
-  }
-
-  getQueueStats(workspaceId) {
-    return Call.aggregate([
-      { $match: { workspaceId, status: "hold" } },
-      {
-        $group: {
-          _id: "$receiver",
-          count: { $sum: 1 },
-          avgQueuePosition: { $avg: "$queuePosition" },
-        },
-      },
-    ]);
-  }
-}
-
-module.exports = new CallRepository();

package/models/Call.js

@@ -1,193 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-
-const callSchema = new mongoose.Schema(
-  {
-    workspaceId: { type: Schema.Types.ObjectId, ref: "Workspace" },
-    callId: {
-      type: String,
-      required: true,
-      unique: true,
-      index: true,
-    },
-    callerName: {
-      type: String,
-      required: true,
-    },
-    callerNumber: {
-      type: String,
-      required: true,
-      index: true,
-    },
-    profileId: { type: Schema.Types.ObjectId, ref: "Profile" },
-    receiver: {
-      type: String,
-      default: "",
-    },
-    platformId: {
-      type: Schema.Types.ObjectId,
-      ref: "Integration",
-      default: null,
-    },
-    type: { type: String, default: "inbound" },
-    status: {
-      type: String,
-      enum: ["pending", "hold", "active", "ended", "disconnected", "abandoned"],
-      default: "pending",
-      index: true,
-    },
-    queuePosition: {
-      type: Number,
-      default: 0,
-    },
-    agentId: {
-      type: String,
-      default: null,
-      index: true,
-    },
-    startTime: {
-      type: Date,
-      default: null,
-    },
-    endTime: {
-      type: Date,
-      default: null,
-    },
-    duration: {
-      type: Number,
-      default: 0,
-    },
-    whatsappSdp: {
-      type: String,
-      default: null,
-    },
-    browserSdp: {
-      type: String,
-      default: null,
-    },
-    callHistory: [
-      {
-        action: {
-          type: String,
-          enum: [
-            "created",
-            "answered",
-            "held",
-            "unheld",
-            "transferred",
-            "ended",
-            "disconnected",
-            "reconnected",
-            "abandoned",
-          ],
-        },
-        direction: String, // USER INITIATED // AGENT INITIATED
-        agentId: String, // agent id
-        actionBy: String,
-        details: String, //  "Status changed to hold"
-        startTime: String, // platform start time
-        endTime: String, // platform endTime time
-        duration: Number, // platform call duration
-        timestamp: {
-          // system timestamp
-          type: Date,
-          default: Date.now,
-        },
-        platformTimestamp: String, // platformtimestamp
-      },
-    ],
-    metadata: {},
-    tags: [],
-    connectionMetadata: {
-      browserConnectionState: {
-        type: String,
-        default: "new",
-      },
-      whatsappConnectionState: {
-        type: String,
-        default: "new",
-      },
-      lastHeartbeat: {
-        type: Date,
-        default: Date.now,
-      },
-    },
-    rating: {
-      type: Number,
-      default: 0,
-    },
-  },
-  {
-    timestamps: true,
-    collection: "calls",
-  }
-);
-
-// Indexes for performance
-callSchema.index({ status: 1, createdAt: 1 });
-callSchema.index({ agentId: 1, status: 1 });
-callSchema.index({ callerNumber: 1, createdAt: -1 });
-callSchema.index({ isOnHold: 1, status: 1 });
-
-// Virtual for call duration calculation
-callSchema.virtual("currentDuration").get(function () {
-  if (this.startTime) {
-    const endTime = this.endTime || new Date();
-    return Math.floor((endTime - this.startTime) / 1000);
-  }
-  return 0;
-});
-
-// Methods
-callSchema.methods.addToHistory = function (
-  action,
-  agentId = null,
-  details = null
-) {
-  this.callHistory.push({
-    action,
-    agentId,
-    details,
-    timestamp: new Date(),
-  });
-};
-
-callSchema.methods.updateHeartbeat = function () {
-  this.connectionMetadata.lastHeartbeat = new Date();
-};
-
-callSchema.methods.isStale = function (timeoutMinutes = 5) {
-  const timeout = timeoutMinutes * 60 * 1000; // Convert to milliseconds
-  return new Date() - this.connectionMetadata.lastHeartbeat > timeout;
-};
-
-// Static methods
-callSchema.statics.getActiveCallsForAgent = function (agentId) {
-  return this.find({
-    agentId,
-    status: { $in: ["active", "hold"] },
-  }).sort({ createdAt: 1 });
-};
-
-callSchema.statics.getHoldQueue = function () {
-  return this.find({
-    status: "hold",
-    agentId: null,
-  }).sort({ createdAt: 1 });
-};
-
-callSchema.statics.getPendingCalls = function () {
-  return this.find({
-    status: "pending",
-  }).sort({ createdAt: 1 });
-};
-
-callSchema.statics.getStaleConnections = function (timeoutMinutes = 5) {
-  const timeout = new Date(Date.now() - timeoutMinutes * 60 * 1000);
-  return this.find({
-    status: { $in: ["active", "hold", "pending"] },
-    "connectionMetadata.lastHeartbeat": { $lt: timeout },
-  });
-};
-
-module.exports = mongoose.model("Call", callSchema);