@peopl-health/nexus 3.16.3 → 4.0.0

package/lib/adapters/TwilioProvider.js

@@ -130,9 +130,9 @@ class TwilioProvider extends MessageProvider {
           timestamp: new Date(), 
           fromMe: true,
           processed: messageData.processed ?? false,
-          statusInfo: { 
-            status: result.status?.toLowerCase() || null, 
-            updatedAt: result.dateCreated || new Date() 
+          statusInfo: {
+            status: result.status?.toLowerCase() || null,
+            updatedAt: new Date()
           }
         });
       } catch (err) {
@@ -153,9 +153,33 @@ class TwilioProvider extends MessageProvider {
         if (i < chunks.length - 1) await new Promise(r => setTimeout(r, 100));
       }
     } else {
-      result = await this.twilioClient.messages.create(messageParams);
-      await saveMessage(messageParams.body || messageData.body, result);
-      await recordDeliveryAttempt({ messageData, twilioResult: result, kind });
+      let pending = null;
+      if (!messageData._skipStorage && this.messageStorage?.savePendingMessage) {
+        pending = await this.messageStorage.savePendingMessage({
+          ...messageData, code: formattedCode, from: formattedFrom,
+          provider: 'twilio', timestamp: new Date(), fromMe: true,
+          processed: messageData.processed ?? false
+        });
+      }
+
+      try {
+        result = await this.twilioClient.messages.create(messageParams);
+      } catch (twilioErr) {
+        await recordDeliveryAttempt({
+          messageData, messageId: pending?._id, kind,
+          errorSource: 'twilio_sync',
+          errorCode: twilioErr.code, errorMessage: twilioErr.message
+        });
+        throw twilioErr;
+      }
+
+      if (pending) {
+        await this.messageStorage.finalizePendingMessage(pending._id, result.sid, {
+          status: result.status?.toLowerCase() || null,
+          updatedAt: new Date()
+        });
+      }
+      await recordDeliveryAttempt({ messageData, messageId: pending?._id, twilioResult: result, kind });
     }
     
     return {

package/lib/helpers/deliveryAttemptHelper.js

@@ -3,41 +3,49 @@ const { logger } = require('../utils/logger');
 const { Message } = require('../models/messageModel');
 const { DeliveryAttempt } = require('../models/deliveryAttemptModel');
 
-async function recordDeliveryAttempt({ messageData, twilioResult, kind }) {
-  if (messageData?._skipStorage) return null;
-  if (!twilioResult?.sid) return null;
+async function recordDeliveryAttempt({
+  messageData = null, messageId = null, twilioResult = null, kind,
+  errorSource = null, errorCode = null, errorMessage = null
+}) {
+  const sid = twilioResult?.sid || null;
+  if (!sid && !errorSource) return null;
 
-  try {
-    const msgDoc = await Message.findOne({ message_id: twilioResult.sid }, '_id').lean();
+  let targetId = messageId;
+  if (!targetId) {
+    if (messageData?._skipStorage) return null;
+    if (!sid) return null;
+    const msgDoc = await Message.findOne({ message_id: sid }, '_id').lean();
     if (!msgDoc) {
-      logger.warn('[deliveryAttemptHelper] Message not found for SID; skipping attempt record', {
-        twilioSid: twilioResult.sid
-      });
+      logger.warn('[deliveryAttemptHelper] Message not found for SID; skipping attempt record', { twilioSid: sid });
       return null;
     }
+    targetId = msgDoc._id;
+  }
 
-    const status = twilioResult.status?.toLowerCase() || 'sent';
+  try {
+    const status = errorSource ? 'failed' : (twilioResult?.status?.toLowerCase() || null);
 
     const attempt = await DeliveryAttempt.create({
-      messageId: msgDoc._id,
+      messageId: targetId,
       kind,
-      twilioSid: twilioResult.sid,
+      twilioSid: sid,
       contentSid: messageData?.contentSid || null,
       status,
+      errorSource,
+      errorCode,
+      errorMessage,
       completedAt: new Date()
     });
 
     await Message.updateOne(
-      { _id: msgDoc._id },
+      { _id: targetId },
       { $set: { 'statusInfo.latestDeliveryStatus': status } }
     );
 
     return attempt;
   } catch (error) {
     logger.error('[deliveryAttemptHelper] Failed to record delivery attempt', {
-      twilioSid: twilioResult?.sid,
-      kind,
-      error: error.message
+      twilioSid: sid, kind, error: error.message
     });
     return null;
   }

package/lib/helpers/messageStatusHelper.js

@@ -82,11 +82,12 @@ async function handleStatusCallback(twilioStatusData, { eventBus } = {}) {
 
   if (updated && eventBus) {
     safeEmit(eventBus, 'message:status', createEvent('message:status', {
-      messageId: updated.message_id,
+      messageId: String(updated._id),
       to: updated.numero,
       status: MessageStatus.toLowerCase(),
       errorCode: ErrorCode || null,
-      errorMessage: ErrorMessage || null
+      errorMessage: ErrorMessage || null,
+      twilioSid: MessageSid
     }));
   }
 

package/lib/jobs/TemplateApprovalJob.js

@@ -1,5 +1,6 @@
 const { logger } = require('../utils/logger');
 const { Message } = require('../models/messageModel');
+const { recordDeliveryAttempt } = require('../helpers/deliveryAttemptHelper');
 const { BaseJob } = require('./BaseJob');
 
 const QUEUE_NAME = 'template-approval';
@@ -110,8 +111,9 @@ class TemplateApprovalJob extends BaseJob {
     }
 
     let recoveryMessageId;
+    let sendResult;
     try {
-      const sendResult = await this.sendMessage({
+      sendResult = await this.sendMessage({
         code: message.numero,
         contentSid: templateSid,
         variables: {},
@@ -142,6 +144,13 @@ class TemplateApprovalJob extends BaseJob {
       });
     }
 
+    await recordDeliveryAttempt({
+      messageData: { contentSid: templateSid },
+      messageId: message._id,
+      twilioResult: { sid: recoveryMessageId, status: sendResult?.status },
+      kind: 'recovery_template'
+    });
+
     provider.deleteTemplate(templateSid).catch((deleteErr) =>
       logger.warn('[TemplateApprovalJob] Failed to delete template after send', { templateSid, error: deleteErr.message })
     );

package/lib/models/deliveryAttemptModel.js

@@ -2,6 +2,7 @@ const mongoose = require('mongoose');
 
 const KIND_VALUES = ['freeform', 'template', 'recovery_template'];
 const STATUS_VALUES = [null, 'queued', 'sending', 'sent', 'delivered', 'undelivered', 'failed', 'read'];
+const ERROR_SOURCE_VALUES = [null, 'twilio_sync', 'twilio_async', 'server'];
 
 const deliveryAttemptSchema = new mongoose.Schema({
   messageId: {
@@ -23,6 +24,11 @@ const deliveryAttemptSchema = new mongoose.Schema({
   },
   errorCode: { type: String, default: null },
   errorMessage: { type: String, default: null },
+  errorSource: {
+    type: String,
+    enum: ERROR_SOURCE_VALUES,
+    default: null
+  },
   attemptedAt: { type: Date, default: Date.now, required: true },
   completedAt: { type: Date, default: null },
   raw: { type: mongoose.Schema.Types.Mixed, default: null }
@@ -37,5 +43,6 @@ const DeliveryAttempt = mongoose.model('DeliveryAttempt', deliveryAttemptSchema)
 module.exports = {
   DeliveryAttempt,
   DELIVERY_ATTEMPT_KINDS: KIND_VALUES,
-  DELIVERY_ATTEMPT_STATUSES: STATUS_VALUES
+  DELIVERY_ATTEMPT_STATUSES: STATUS_VALUES,
+  DELIVERY_ATTEMPT_ERROR_SOURCES: ERROR_SOURCE_VALUES
 };

package/lib/models/messageModel.js

@@ -132,28 +132,27 @@ async function insertMessage(values) {
       values.clinical_context = clinicalContext;
     }
     const messageData = Object.fromEntries(
-      Object.entries(values)
-        .filter(([k, v]) => v !== undefined && !k.startsWith('delivery_'))
+      Object.entries(values).filter(([, v]) => v !== undefined)
     );
 
-    if (!messageData.statusInfo && values.delivery_status) {
-      messageData.statusInfo = {
-        status: values.delivery_status,
-        errorCode: values.delivery_error_code || null,
-        errorMessage: values.delivery_error_message || null,
-        updatedAt: values.delivery_status_updated_at || null
-      };
-    }
     if (!Array.isArray(messageData.tools_executed)) {
       messageData.tools_executed = [];
     }
 
-    const result = await Message.findOneAndUpdate(
-      { message_id: values.message_id, body: values.body },
-      { $setOnInsert: messageData },
-      { upsert: true, new: true, setDefaultsOnInsert: true, includeResultMetadata: true }
-    );
-    const isNew = !result?.lastErrorObject?.updatedExisting;
+    let doc;
+    let isNew;
+    if (values.message_id == null) {
+      doc = await Message.create(messageData);
+      isNew = true;
+    } else {
+      const result = await Message.findOneAndUpdate(
+        { message_id: values.message_id, body: values.body },
+        { $setOnInsert: messageData },
+        { upsert: true, new: true, setDefaultsOnInsert: true, includeResultMetadata: true }
+      );
+      doc = result.value;
+      isNew = !result.lastErrorObject?.updatedExisting;
+    }
 
     if (isNew && values.numero && !INTERNAL_ORIGINS.has(values.origin)) {
       Thread.findOneAndUpdate(
@@ -180,7 +179,7 @@ async function insertMessage(values) {
     }).catch(err => logger.error('[MongoStorage] Failed to update message_monitor table', { numero: values.numero, error: err.message }));
 
     logger.info('[MongoStorage] Message inserted or updated successfully');
-    return { isNew };
+    return { isNew, doc };
   } catch (err) {
     logger.error('[MongoStorage] Error inserting message', { error: err.message, stack: err.stack });
     throw err;

package/lib/storage/MongoStorage.js

@@ -37,29 +37,9 @@ class MongoStorage {
   async saveMessage(messageData) {
     try {
       const values = this.buildMessageValues(messageData);
-      await insertMessage(values);
+      const { doc } = await insertMessage(values);
       logger.info('[MongoStorage] Message stored');
-
-      const chatId = messageData.from;
-      const messageId = messageData.messageId;
-
-      if (chatId && messageId) {
-        safeEmit(getStatusEventBus(), 'message:new', createEvent('message:new', {
-          messageId,
-          from: chatId,
-          code: values.numero,
-          name: values.nombre_whatsapp,
-          origin: values.origin,
-          body: values.body,
-          media: values.media,
-          type: values.interactive_type ? 'interactive' : values.media ? 'media' : 'message',
-          triggeredBy: values.triggeredBy,
-          ...(messageData.frontendId && { frontendId: messageData.frontendId })
-        }));
-      } else {
-        logger.warn('[processIncomingMessage] Skipping event emission: missing chatId or messageId', { chatId, messageId });
-      }
-
+      this._emitMessageNew(doc, messageData.from, messageData.frontendId);
       return values;
     } catch (error) {
       logger.error('Error saving message', { error });
@@ -67,9 +47,45 @@ class MongoStorage {
     }
   }
 
+  async savePendingMessage(messageData) {
+    const values = this.buildMessageValues(messageData);
+    const { doc } = await insertMessage(values);
+    this._emitMessageNew(doc, messageData.from, messageData.frontendId, 'queued');
+    return doc;
+  }
+
+  async finalizePendingMessage(docId, sid, statusInfo = null) {
+    await Message.updateOne(
+      { _id: docId },
+      { $set: { message_id: sid, ...(statusInfo && { statusInfo }) } }
+    );
+    safeEmit(getStatusEventBus(), 'message:status', createEvent('message:status', {
+      messageId: String(docId),
+      status: statusInfo?.status || null,
+      twilioSid: sid
+    }));
+  }
+
+  _emitMessageNew(doc, from, frontendId, status = null) {
+    if (!from || !doc?._id) return;
+    safeEmit(getStatusEventBus(), 'message:new', createEvent('message:new', {
+      messageId: String(doc._id),
+      from,
+      code: doc.numero,
+      name: doc.nombre_whatsapp,
+      origin: doc.origin,
+      body: doc.body,
+      media: doc.media,
+      type: doc.interactive_type ? 'interactive' : doc.media ? 'media' : 'message',
+      triggeredBy: doc.triggeredBy,
+      status,
+      ...(frontendId && { frontendId })
+    }));
+  }
+
   buildMessageValues(messageData = {}) {
     const now = new Date();
-    const messageId = messageData.messageId || `pending-${now.getTime()}-${Math.floor(Math.random()*1000)}`;
+    const messageId = messageData.messageId ?? null;
     const fromMe = messageData.fromMe !== undefined ? messageData.fromMe : true;
 
     const values = {

package/lib/storage/NoopStorage.js

@@ -4,6 +4,8 @@ class NoopStorage {
   }
   async connect() {}
   async saveMessage() { return null; }
+  async savePendingMessage() { return null; }
+  async finalizePendingMessage() { return null; }
   async saveInteractive() { return null; }
   async getMessages() { return []; }
   async getThread() { return null; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "3.16.3",
+  "version": "4.0.0",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",