@tiledesk/tiledesk-server 2.27.2 → 2.28.1

package/CHANGELOG.md

@@ -5,9 +5,17 @@
 🚀        IN PRODUCTION                        🚀
 (https://www.npmjs.com/package/@tiledesk/tiledesk-server/v/2.3.77) 
 
+# 2.28.1
+- Bumped whatsapp-connector version to 1.0.30
+
+# 2.28.0
+- Group participant updates (setMembers, join, leave) for the same request are now queued and executed sequentially to prevent race conditions.
+- setMembers now reloads participants from the database at the time of execution, ensuring consistency with the actual request state.
+- Automatic retries for setMembers on error, with configurable max retries and delay via CHAT21_SET_MEMBERS_MAX_RETRIES and CHAT21_SET_MEMBERS_RETRY_DELAY_MS.
+- Removed participants’ conversations are now archived only after leave/setMembers completes, inside the same queue, to avoid premature archival while the participant is still in the Chat21 group.
+
 # 2.27.2
 - Improved chat21 sync tracing: traces are buffered in memory and saved in batches (insertMany) instead of one insert per trace
-- Added env variables CHAT21_SYNC_TRACE_FLUSH_INTERVAL_MS (default 1000), CHAT21_SYNC_TRACE_BATCH_SIZE (default 200) and CHAT21_SYNC_TRACE_MAX_BUFFER_SIZE (default 10000)
 
 # 2.27.1
 - Added tracing for chat21 events

package/channels/chat21/chat21Handler.js

@@ -42,7 +42,7 @@ function archiveConversation(event, request, user_id) {
 
   return chat21SyncTracer.traceCall(event, request, 'archive', { user_id: user_id }, () => {
     return chat21.conversations.archive(request.request_id, user_id);
-  }).then(function (data) {
+  }, chat21Outcome).then(function (data) {
     winston.verbose("[Chat21Handler] - " + event + " - Chat21 conversation archived for " + user_id + " result " + JSON.stringify(data));
     chat21Event.emit('conversation.archived', data);
   }).catch(function (err) {
@@ -61,6 +61,103 @@ function runTraced(event, request, fn) {
   }
 }
 
+function nonNegativeNumber(value, defaultValue) {
+  const parsed = parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : defaultValue;
+}
+
+const SET_MEMBERS_MAX_RETRIES = nonNegativeNumber(process.env.CHAT21_SET_MEMBERS_MAX_RETRIES, 2);
+const SET_MEMBERS_RETRY_DELAY_MS = nonNegativeNumber(process.env.CHAT21_SET_MEMBERS_RETRY_DELAY_MS, 1000);
+
+function isSameMembersResponse(response) {
+  const message = response && response.err && response.err.message;
+  return typeof message === 'string' && message.startsWith('Same members');
+}
+
+// chat21-http-server answers {success: true} on success: any other body is an error, even with a resolved sdk promise
+function chat21Outcome(response) {
+  if (response && response.success === true) {
+    return 'success';
+  }
+  if (isSameMembersResponse(response)) {
+    return 'skipped';
+  }
+  return 'error';
+}
+
+const groupSyncQueues = new Map();
+
+// Chains the chat21 group updates of the same request, so that this process sends them one at a time and in emission order
+function enqueueGroupSync(groupId, fn) {
+  const previous = groupSyncQueues.get(groupId) || Promise.resolve();
+  const current = previous.then(fn);
+  const tail = current.catch(() => { });
+  groupSyncQueues.set(groupId, tail);
+  tail.then(() => {
+    if (groupSyncQueues.get(groupId) === tail) {
+      groupSyncQueues.delete(groupId);
+    }
+  });
+  return current;
+}
+
+// The participants are read when the call is sent, not taken from the event: a later update,
+// possibly saved by another pod, would otherwise be overwritten on chat21 by stale members
+async function currentGroupMembers(request) {
+  let participants = request.participants;
+  try {
+    const current = await Request.findOne({ request_id: request.request_id, id_project: request.id_project })
+      .select('participants')
+      .lean()
+      .exec();
+    if (current) {
+      participants = current.participants;
+    }
+  } catch (err) {
+    winston.error("[Chat21Handler] - Error reading the current participants, using the event ones for request " + request.request_id, err);
+  }
+
+  const members = ["system", ...participants];
+  if (request.lead) {
+    members.push(request.lead.lead_id);
+  }
+  return members;
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function syncGroupMembers(event, request) {
+  const groupId = request.request_id;
+
+  for (let attempt = 0; ; attempt++) {
+    const members = await currentGroupMembers(request);
+    winston.verbose("[Chat21Handler] - " + event + " - Chat21 group " + groupId + " members (attempt " + attempt + "): ", members);
+
+    let error;
+    try {
+      chat21.auth.setAdminToken(adminToken);
+      const data = await chat21SyncTracer.traceCall(event, request, 'group.setMembers', { members: members, attempt: attempt }, () => {
+        return chat21.groups.setMembers(members, groupId);
+      }, chat21Outcome);
+
+      if (chat21Outcome(data) !== 'error') {
+        return data;
+      }
+      error = { message: "Chat21 setMembers failed", response: data };
+    } catch (err) {
+      error = err;
+    }
+
+    if (attempt >= SET_MEMBERS_MAX_RETRIES) {
+      throw error;
+    }
+    winston.warn("[Chat21Handler] - " + event + " - Chat21 setMembers failed for group " + groupId + " (attempt " + attempt + "), retrying: ", error);
+    await delay(SET_MEMBERS_RETRY_DELAY_MS * (attempt + 1));
+  }
+}
+
 
 class Chat21Handler {
 
@@ -494,26 +591,19 @@ class Chat21Handler {
         }
 
         chat21.auth.setAdminToken(adminToken);
-        let requestObj = request.toJSON();
-
-        winston.verbose("[Chat21Handler] - request.participants.update - Setting chat21 group for request with id: " + requestObj._id);
-
-        const groupId = request.request_id;
-
-        let members = [];
-        members.push("system");
-
-        request.participants.forEach(function (participant, index) {
-          members.push(participant);
-        });
 
-        if (request.lead) {
-          members.push(request.lead.lead_id);
-        }
-        winston.verbose("[Chat21Handler] - request.participants.update - Chat21 group with members for request.participants.update: ", members);
+        winston.verbose("[Chat21Handler] - request.participants.update - Setting chat21 group for request with id: " + request._id);
 
-        chat21SyncTracer.traceCall(traceEvent, request, 'group.setMembers', { members: members }, () => {
-          return chat21.groups.setMembers(members, groupId);
+        enqueueGroupSync(request.request_id, async () => {
+          try {
+            return await syncGroupMembers(traceEvent, request);
+          } finally {
+            // Archived only after leaving the chat21 group: until then the group messages (e.g. the
+            // TOUCHING_OPERATOR info sent on the same event) reach their timeline and set archived: false
+            removedParticipants.forEach(function (removedParticipant) {
+              archiveConversation(traceEvent, request, removedParticipant);
+            });
+          }
         }).then(function (data) {
           winston.verbose("[Chat21Handler] - request.participants.update - Chat21 group set for request.participants.update : " + JSON.stringify(data));
           chat21Event.emit('group.setMembers', data);
@@ -522,10 +612,6 @@ class Chat21Handler {
           chat21Event.emit('group.setMembers.error', err);
         });
 
-        removedParticipants.forEach(function (removedParticipant) {
-          archiveConversation(traceEvent, request, removedParticipant);
-        });
-
       }));
     });
 
@@ -550,9 +636,10 @@ class Chat21Handler {
         const groupId = request.request_id;
         winston.verbose("[Chat21Handler] - request.participants.join - Joining member " + member + " for chat21 group with request : " + groupId);
 
-        chat21SyncTracer.traceCall(traceEvent, request, 'group.join', { member: member }, () => {
+        enqueueGroupSync(groupId, () => chat21SyncTracer.traceCall(traceEvent, request, 'group.join', { member: member }, () => {
+          chat21.auth.setAdminToken(adminToken);
           return chat21.groups.join(member, groupId);
-        }).then(function (data) {
+        }, chat21Outcome)).then(function (data) {
           winston.verbose("[Chat21Handler] - request.participants.join - Chat21 group joined: " + JSON.stringify(data));
           chat21Event.emit('group.join', data);
         }).catch(function (err) {
@@ -584,8 +671,16 @@ class Chat21Handler {
 
         winston.verbose("[Chat21Handler] - request.participants.leave - Leaving " + member + " for chat21 group for request with id: " + groupId);
 
-        chat21SyncTracer.traceCall(traceEvent, request, 'group.leave', { member: member }, () => {
-          return chat21.groups.leave(member, groupId);
+        enqueueGroupSync(groupId, async () => {
+          try {
+            return await chat21SyncTracer.traceCall(traceEvent, request, 'group.leave', { member: member }, () => {
+              chat21.auth.setAdminToken(adminToken);
+              return chat21.groups.leave(member, groupId);
+            }, chat21Outcome);
+          } finally {
+            // Archived only after leaving the chat21 group, see request.participants.update
+            archiveConversation(traceEvent, request, member);
+          }
         }).then(function (data) {
           winston.verbose("[Chat21Handler] - request.participants.leave - Chat21 group left: " + JSON.stringify(data));
           chat21Event.emit('group.leave', data);
@@ -594,8 +689,6 @@ class Chat21Handler {
           chat21Event.emit('group.leave.error', err);
         });
 
-        archiveConversation(traceEvent, request, member);
-
       }));
     })
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.27.2",
+  "version": "2.28.1",
   "scripts": {
     "start": "node ./bin/www",
     "pretest": "mongodb-runner start",
@@ -52,7 +52,7 @@
     "@tiledesk/tiledesk-tybot-connector": "^2.1.15",
     "@tiledesk/tiledesk-voice-twilio-connector": "^0.3.2",
     "@tiledesk/tiledesk-vxml-connector": "^0.1.91",
-    "@tiledesk/tiledesk-whatsapp-connector": "1.0.26",
+    "@tiledesk/tiledesk-whatsapp-connector": "1.0.30",
     "@tiledesk/tiledesk-whatsapp-jobworker": "^0.0.13",
     "amqplib": "^0.5.5",
     "app-root-path": "^3.0.0",

package/services/chat21SyncTracer.js

@@ -134,11 +134,14 @@ function trace(event, ref, step, outcome, data) {
 /**
  * Traces a chat21 sdk call as <action>.sent, then <action>.response or <action>.error.
  * The returned promise settles exactly like the one returned by callFn.
+ * @param {function} [outcomeOf] maps the response body to the outcome of <action>.response, default 'success'.
+ * The chat21 sdk resolves on any HTTP status code, so a resolved call is not necessarily successful.
  */
-function traceCall(event, ref, action, data, callFn) {
+function traceCall(event, ref, action, data, callFn, outcomeOf) {
   trace(event, ref, action + '.sent', 'info', data);
   return callFn().then((response) => {
-    trace(event, ref, action + '.response', 'success', { ...data, response: describeResponse(response) });
+    const outcome = outcomeOf ? outcomeOf(response) : 'success';
+    trace(event, ref, action + '.response', outcome, { ...data, response: describeResponse(response) });
     return response;
   }, (err) => {
     trace(event, ref, action + '.error', 'error', { ...data, error: describeError(err) });

package/services/requestService.js

@@ -271,6 +271,15 @@ class RequestService {
       winston.debug("nobot:" + nobot);
       //winston.info("main_flow_cache_3 route");
 
+      const traceRef = { request_id: request_id, id_project: id_project };
+      chat21SyncTracer.trace('request.participants.update', traceRef, 'service.called', 'info', {
+        method: 'route',
+        departmentid: departmentid,
+        nobot: nobot,
+        assignmentType: options?.assignmentType,
+        source: options?.source
+      });
+
       // Find request
       // Cache disabled: a stale cached document can have an outdated __v and cause
       // Mongoose VersionError on save ("No matching document found for id ... version N").
@@ -304,7 +313,12 @@ class RequestService {
       ) {
 
         winston.verbose(`Request ${request.request_id} routed to same status/participants`);
-  
+        chat21SyncTracer.trace('request.participants.update', traceRef, 'service.unchanged', 'skipped', {
+          method: 'route',
+          ...chat21SyncTracer.describeRequest(request)
+        });
+
+        let abandonedStatusSaved = false;
         if (routedRequest.attributes?.fully_abandoned === true) {
           request.status = RequestConstants.ABANDONED;
           request.attributes.fully_abandoned = true;
@@ -313,6 +327,7 @@ class RequestService {
   
           try {
             await request.save();
+            abandonedStatusSaved = true;
             winston.verbose(`Status set to ABANDONED for request ${request._id}`);
           } catch (err) {
             winston.error("Error updating request to ABANDONED", err);
@@ -337,18 +352,13 @@ class RequestService {
           .populate("participatingAgents")
           .populate({ path: "requester", populate: { path: "id_user" } })
           .execPopulate();
-  
-        this.emitParticipantsEvents(
-          request,
-          requestComplete,
-          beforeParticipants,
-          options,
-          beforeDepartmentId !== afterDepartmentId ? {
-            previousDepartmentId: beforeDepartmentId,
-            departmentId: afterDepartmentId,
-            departmentName: requestComplete.department && requestComplete.department.name
-          } : undefined
-        );
+
+        // No participants events here: queues call route every few seconds on unassigned requests and each
+        // request.participants.update resends the chat21 members, the agent emails and the welcome message
+        if (abandonedStatusSaved) {
+          requestEvent.emit("request.update", requestComplete);
+          requestEvent.emit("request.updated", { comment: "STATUS_CHANGE", request: requestComplete, patch: { status: requestComplete.status } });
+        }
   
         return requestComplete;
       }
@@ -2627,6 +2637,7 @@ class RequestService {
       patch: { removedParticipants, addedParticipants }
     });
   
+    traceEventEmitted('request.participants.update', requestComplete, requestComplete, { removedParticipants, addedParticipants });
     requestEvent.emit("request.participants.update", {
       beforeRequest,
       removedParticipants,