shuttlepro-shared 1.4.1 → 1.4.2

package/common/repositories/call.repository.js

@@ -1,5 +1,4 @@
 const Call = require("../../models/Call");
-const mongoose = require("mongoose");
 
 class CallRepository {
   constructor() {
@@ -9,39 +8,32 @@ class CallRepository {
     };
   }
 
-  // Create a new call with transaction support
+  // Create a new call without transaction
   async createCall(callData) {
-    const session = await mongoose.startSession();
-
     try {
-      return await session.withTransaction(async () => {
-        const call = new Call({
-          callId: callData.callId,
-          callerName: callData.callerName,
-          callerNumber: callData.callerNumber,
-          whatsappSdp: callData.whatsappSdp,
-          status: callData.status || "pending",
-          autoAccepted: callData.autoAccepted || false,
-          metadata: callData.metadata || {},
-          tags: callData.tags || [],
-          priority: callData.priority || 0,
-          platformId: callData.platformId || null,
-          workspaceId: callData.workspaceId || null,
-          profileId: callData.profileId || null,
-        });
-
-        call.addToHistory("created", null, "Call created in system");
-        await call.save({ session });
-
-        await this._updateCallMetrics("created", session);
-
-        return call;
+      const call = new Call({
+        callId: callData.callId,
+        callerName: callData.callerName,
+        callerNumber: callData.callerNumber,
+        whatsappSdp: callData.whatsappSdp,
+        status: callData.status || "pending",
+        autoAccepted: callData.autoAccepted || false,
+        metadata: callData.metadata || {},
+        tags: callData.tags || [],
+        priority: callData.priority || 0,
+        platformId: callData.platformId || null,
+        workspaceId: callData.workspaceId || null,
+        profileId: callData.profileId || null,
       });
+
+      call.addToHistory("created", null, "Call created in system");
+      await call.save();
+
+      await this._updateCallMetrics("created");
+      return call;
     } catch (error) {
       console.error(`Failed to create call ${callData.callId}:`, error);
       throw error;
-    } finally {
-      await session.endSession();
     }
   }
 
@@ -52,7 +44,6 @@ class CallRepository {
 
       if (options.lean) query.lean();
 
-      // Auto-populate unless explicitly disabled
       if (options.populate !== false) {
         query.populate([
           { path: "platformId", model: "Integration" },
@@ -72,7 +63,7 @@ class CallRepository {
     }
   }
 
-  // Bulk get calls with advanced filtering
+  // Bulk get calls
   async getCalls(filters = {}, options = {}) {
     try {
       const {
@@ -90,7 +81,6 @@ class CallRepository {
       } = filters;
 
       const query = {};
-
       if (status)
         query.status = Array.isArray(status) ? { $in: status } : status;
       if (agentId) query.agentId = agentId;
@@ -106,7 +96,7 @@ class CallRepository {
       }
 
       if (priority !== undefined) query.priority = { $gte: priority };
-      if (tags && tags.length > 0) query.tags = { $in: tags };
+      if (tags?.length > 0) query.tags = { $in: tags };
 
       const skip = (page - 1) * limit;
 
@@ -144,128 +134,108 @@ class CallRepository {
     }
   }
 
-  // Update call with optimistic locking
-  async updateCall(callId, updateData, options = {}) {
-    const session = options.session || (await mongoose.startSession());
-    const shouldCommitSession = !options.session;
-
+  // Update call
+  async updateCall(callId, updateData) {
     try {
-      return await session.withTransaction(async () => {
-        const call = await Call.findOne({ callId }).session(session);
-        if (!call) throw new Error(`Call ${callId} not found`);
+      const call = await Call.findOne({ callId });
+      if (!call) throw new Error(`Call ${callId} not found`);
 
-        if (updateData.__v !== undefined && call.__v !== updateData.__v) {
-          throw new Error(`Concurrent update detected for call ${callId}`);
-        }
+      if (updateData.__v !== undefined && call.__v !== updateData.__v) {
+        throw new Error(`Concurrent update detected for call ${callId}`);
+      }
 
-        const allowedFields = [
-          "status",
-          "agentId",
-          "callerName",
-          "callerNumber",
-          "priority",
-          "tags",
-          "metadata",
-          "isOnHold",
-          "platformId",
-          "workspaceId",
-          "profileId",
-        ];
-
-        Object.keys(updateData).forEach((key) => {
-          if (allowedFields.includes(key)) {
-            call[key] = updateData[key];
-          }
-        });
-
-        if (updateData.status && updateData.status !== call.status) {
-          call.addToHistory(
-            updateData.status,
-            updateData.agentId || call.agentId,
-            updateData.reason || `Status changed to ${updateData.status}`
-          );
+      const allowedFields = [
+        "status",
+        "agentId",
+        "callerName",
+        "callerNumber",
+        "priority",
+        "tags",
+        "metadata",
+        "isOnHold",
+        "platformId",
+        "workspaceId",
+        "profileId",
+      ];
+
+      Object.keys(updateData).forEach((key) => {
+        if (allowedFields.includes(key)) {
+          call[key] = updateData[key];
         }
+      });
 
-        call.updateHeartbeat();
-        await call.save({ session });
+      if (updateData.status && updateData.status !== call.status) {
+        call.addToHistory(
+          updateData.status,
+          updateData.agentId || call.agentId,
+          updateData.reason || `Status changed to ${updateData.status}`
+        );
+      }
 
-        return call;
-      });
+      call.updateHeartbeat();
+      await call.save();
+      return call;
     } catch (error) {
       console.error(`Failed to update call ${callId}:`, error);
       throw error;
-    } finally {
-      if (shouldCommitSession) await session.endSession();
     }
   }
 
   // Assign call to agent
-  async assignCallToAgent(callId, agentId, options = {}) {
-    const session = await mongoose.startSession();
-
+  async assignCallToAgent(callId, agentId) {
     try {
-      return await session.withTransaction(async () => {
-        const call = await Call.findOne({ callId }).session(session);
-        if (!call) throw new Error(`Call ${callId} not found`);
+      const call = await Call.findOne({ callId });
+      if (!call) throw new Error(`Call ${callId} not found`);
 
-        if (call.status !== "pending" && call.status !== "hold") {
-          throw new Error(`Call ${callId} is not available for assignment`);
-        }
+      if (call.status !== "pending" && call.status !== "hold") {
+        throw new Error(`Call ${callId} is not available for assignment`);
+      }
 
-        call.agentId = agentId;
-        call.status = "active";
-        call.startTime = new Date();
-        call.isOnHold = false;
-        call.addToHistory("answered", agentId, "Call answered by agent");
-        call.updateHeartbeat();
+      call.agentId = agentId;
+      call.status = "active";
+      call.startTime = new Date();
+      call.isOnHold = false;
+      call.addToHistory("answered", agentId, "Call answered by agent");
+      call.updateHeartbeat();
 
-        await call.save({ session });
-        return call;
-      });
+      await call.save();
+      return call;
     } catch (error) {
       console.error(
         `Failed to assign call ${callId} to agent ${agentId}:`,
         error
       );
       throw error;
-    } finally {
-      await session.endSession();
     }
   }
 
-  // Bulk operations for call management
+  // Bulk update calls
   async bulkUpdateCalls(operations) {
-    const session = await mongoose.startSession();
-
     try {
-      return await session.withTransaction(async () => {
-        const bulkOps = operations.map((op) => ({
-          updateOne: {
-            filter: { callId: op.callId },
-            update: {
-              $set: {
-                ...op.updateData,
-                lastHeartbeat: new Date(),
-              },
-              $push: {
-                callHistory: {
-                  timestamp: new Date(),
-                  action: op.action || "bulk_update",
-                  agentId: op.agentId,
-                  details: op.details || "Bulk operation",
-                },
+      const bulkOps = operations.map((op) => ({
+        updateOne: {
+          filter: { callId: op.callId },
+          update: {
+            $set: {
+              ...op.updateData,
+              lastHeartbeat: new Date(),
+            },
+            $push: {
+              callHistory: {
+                timestamp: new Date(),
+                action: op.action || "bulk_update",
+                agentId: op.agentId,
+                details: op.details || "Bulk operation",
               },
             },
           },
-        }));
+        },
+      }));
 
-        return await Call.bulkWrite(bulkOps, { session });
-      });
+      return await Call.bulkWrite(bulkOps);
     } catch (error) {
       console.error("Failed to perform bulk update:", error);
       throw error;
-    } finally {
-      await session.endSession();
     }
   }
 
@@ -374,43 +344,34 @@ class CallRepository {
 
   // Cleanup stale connections
   async cleanupStaleConnections(timeoutMinutes = 5) {
-    const session = await mongoose.startSession();
-
     try {
-      return await session.withTransaction(async () => {
-        const cutoffTime = new Date(Date.now() - timeoutMinutes * 60 * 1000);
-
-        const staleCalls = await Call.find({
-          status: { $in: ["active", "hold", "pending"] },
-          lastHeartbeat: { $lt: cutoffTime },
-        }).session(session);
-
-        const results = [];
-
-        for (const call of staleCalls) {
-          if (call.agentId) {
-            await this.moveCallToHoldQueue(call.callId, "Connection timeout", {
-              session,
-            });
-            results.push({ callId: call.callId, action: "moved_to_hold" });
-          } else {
-            await this.endCall(call.callId, null, { session });
-            results.push({ callId: call.callId, action: "ended" });
-          }
-        }
+      const cutoffTime = new Date(Date.now() - timeoutMinutes * 60 * 1000);
 
-        console.log(`Cleaned up ${results.length} stale connections`);
-        return results;
+      const staleCalls = await Call.find({
+        status: { $in: ["active", "hold", "pending"] },
+        lastHeartbeat: { $lt: cutoffTime },
       });
+
+      const results = [];
+
+      for (const call of staleCalls) {
+        if (call.agentId) {
+          await this.moveCallToHoldQueue(call.callId, "Connection timeout");
+          results.push({ callId: call.callId, action: "moved_to_hold" });
+        } else {
+          await this.endCall(call.callId);
+          results.push({ callId: call.callId, action: "ended" });
+        }
+      }
+
+      console.log(`Cleaned up ${results.length} stale connections`);
+      return results;
     } catch (error) {
       console.error("Failed to cleanup stale connections:", error);
       throw error;
-    } finally {
-      await session.endSession();
     }
   }
 
-  // Helper methods
   _buildDateFilter(timeframe) {
     const now = new Date();
     switch (timeframe) {
@@ -464,7 +425,7 @@ class CallRepository {
     };
   }
 
-  async _updateCallMetrics(action, session = null) {
+  async _updateCallMetrics(action) {
     try {
       console.log(`Updating metrics for action: ${action}`);
     } catch (error) {
@@ -472,67 +433,46 @@ class CallRepository {
     }
   }
 
-  async moveCallToHoldQueue(
-    callId,
-    reason = "Agent disconnected",
-    options = {}
-  ) {
-    const session = options.session || (await mongoose.startSession());
-    const shouldCommitSession = !options.session;
-
+  async moveCallToHoldQueue(callId, reason = "Agent disconnected") {
     try {
-      return await session.withTransaction(async () => {
-        const call = await Call.findOne({ callId }).session(session);
-        if (!call) throw new Error(`Call ${callId} not found`);
-
-        const previousAgentId = call.agentId;
-
-        call.agentId = null;
-        call.status = "hold";
-        call.isOnHold = true;
-        call.autoAccepted = true;
-        call.isHoldConnection = true;
-        call.priority = Math.min(call.priority + 1, 10);
-        call.addToHistory("disconnected", previousAgentId, reason);
-        call.updateHeartbeat();
-
-        await call.save({ session });
-
-        console.log(
-          `Call ${callId} moved back to hold queue due to: ${reason}`
-        );
-        return call;
-      });
+      const call = await Call.findOne({ callId });
+      if (!call) throw new Error(`Call ${callId} not found`);
+
+      const previousAgentId = call.agentId;
+
+      call.agentId = null;
+      call.status = "hold";
+      call.isOnHold = true;
+      call.autoAccepted = true;
+      call.isHoldConnection = true;
+      call.priority = Math.min(call.priority + 1, 10);
+      call.addToHistory("disconnected", previousAgentId, reason);
+      call.updateHeartbeat();
+
+      await call.save();
+      console.log(`Call ${callId} moved back to hold queue due to: ${reason}`);
+      return call;
     } catch (error) {
       console.error(`Failed to move call ${callId} to hold queue:`, error);
       throw error;
-    } finally {
-      if (shouldCommitSession) await session.endSession();
     }
   }
 
-  async endCall(callId, agentId = null, options = {}) {
-    const session = options.session || (await mongoose.startSession());
-    const shouldCommitSession = !options.session;
-
+  async endCall(callId, agentId = null) {
     try {
-      return await session.withTransaction(async () => {
-        const call = await Call.findOne({ callId }).session(session);
-        if (!call) throw new Error(`Call ${callId} not found`);
+      const call = await Call.findOne({ callId });
+      if (!call) throw new Error(`Call ${callId} not found`);
 
-        call.status = "ended";
-        call.endTime = new Date();
-        call.duration = call.currentDuration;
-        call.addToHistory("ended", agentId, "Call ended");
+      call.status = "ended";
+      call.endTime = new Date();
+      call.duration = call.currentDuration;
+      call.addToHistory("ended", agentId, "Call ended");
 
-        await call.save({ session });
-        return call;
-      });
+      await call.save();
+      return call;
     } catch (error) {
       console.error(`Failed to end call ${callId}:`, error);
       throw error;
-    } finally {
-      if (shouldCommitSession) await session.endSession();
     }
   }
 }

package/package.json

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