@peopl-health/nexus 4.1.7 → 4.2.0

package/lib/adapters/TwilioProvider.js

@@ -120,16 +120,7 @@ class TwilioProvider extends MessageProvider {
     const chunks = messageParams.body?.length > 1600 && !messageParams.mediaUrl && !messageParams.contentSid
       ? this._splitMessageAtWordBoundaries(messageParams.body) : null;
     const sends = chunks ? chunks.map(body => ({ ...messageParams, body })) : [messageParams];
-
-    let parentId = messageData.parentMessageId || null;
-    if (!parentId && this.messageStorage?.savePendingMessage) {
-      const pending = await this.messageStorage.savePendingMessage({
-        ...messageData, code: formattedCode, from: formattedFrom,
-        provider: 'twilio', timestamp: new Date(), fromMe: true,
-        processed: messageData.processed ?? false
-      });
-      parentId = pending?._id || null;
-    }
+    const parentId = messageData.parentMessageId || null;
 
     let result;
     for (let i = 0; i < sends.length; i++) {
@@ -147,19 +138,13 @@ class TwilioProvider extends MessageProvider {
       if (i < sends.length - 1) await new Promise(r => setTimeout(r, 100));
     }
 
-    if (parentId && this.messageStorage?.finalizePendingMessage) {
-      await this.messageStorage.finalizePendingMessage(parentId, chunks ? null : result.sid, {
-        status: result.status?.toLowerCase() || null,
-        updatedAt: new Date()
-      });
-    }
-    
     return {
       success: true,
       messageId: result.sid,
       provider: 'twilio',
       status: result.status,
-      result
+      result,
+      finalize: { sid: chunks ? null : result.sid, status: result.status?.toLowerCase() || null }
     };
   }
 

package/lib/core/NexusMessaging.js

@@ -11,6 +11,8 @@ const { Thread } = require('../models/threadModel');
 
 const { ensureThreadExists } = require('../helpers/threadHelper');
 const { storeRunMetrics } = require('../helpers/metricsHelper');
+const { isWithin24HourWindow } = require('../helpers/conversationWindowHelper');
+const { triggerTemplateRecovery } = require('../helpers/templateRecoveryHelper');
 
 const { createMessagingProvider } = require('../adapters/registry');
 
@@ -235,17 +237,43 @@ class NexusMessaging {
 
     if (messageData._fromConversationReply) messageData.processed = true;
 
-    const result = await this.provider.sendMessage(messageData);
+    if (this._needsTemplateRoute(messageData) && !(await isWithin24HourWindow(messageData.code))) {
+      const parent = await this.messageStorage.savePendingMessage({
+        ...messageData,
+        provider: 'twilio', timestamp: new Date(), fromMe: true,
+        processed: messageData.processed ?? false
+      });
+      await triggerTemplateRecovery(parent, { source: 'preemptive' });
+      return { success: true, messageId: String(parent._id), status: 'queued', preemptive: true };
+    }
+
     const providerStores = this.provider.supportsMessageStorage?.() ?? false;
+    let parentId = messageData.parentMessageId || null;
+    if (!parentId && providerStores && this.messageStorage?.savePendingMessage) {
+      const pending = await this.messageStorage.savePendingMessage({
+        ...messageData,
+        provider: 'twilio',
+        timestamp: new Date(), fromMe: true,
+        processed: messageData.processed ?? false
+      });
+      parentId = pending?._id || null;
+    }
+
+    const result = await this.provider.sendMessage({ ...messageData, parentMessageId: parentId });
+
+    if (parentId && result?.finalize && this.messageStorage?.finalizePendingMessage) {
+      await this.messageStorage.finalizePendingMessage(parentId, result.finalize.sid, {
+        status: result.finalize.status,
+        updatedAt: new Date()
+      });
+    }
 
     if (this.messageStorage && !providerStores) {
       await this.messageStorage.saveMessage({
         ...messageData,
         messageId: result.messageId,
         provider: result.provider,
-        timestamp: new Date(),
-        fromMe: true,
-        processed: true
+        timestamp: new Date(), fromMe: true, processed: true
       });
     }
 
@@ -274,6 +302,14 @@ class NexusMessaging {
     return result;
   }
 
+  _needsTemplateRoute(messageData) {
+    if (this.provider?.supportsMessageStorage?.() !== true) return false;
+    if (messageData.contentSid) return false;
+    if (messageData.parentMessageId) return false;
+    if (!messageData.code) return false;
+    return true;
+  }
+
   async sendScheduledMessage(scheduledMessage) {
     if (!scheduledMessage?._id) {
       throw new Error('sendScheduledMessage requires a persisted ScheduledMessage with _id');

package/lib/helpers/conversationWindowHelper.js

@@ -0,0 +1,15 @@
+const { Message } = require('../models/messageModel');
+
+const WINDOW_MS = 24 * 60 * 60 * 1000;
+
+async function isWithin24HourWindow(code) {
+  if (!code) return false;
+  const cutoff = new Date(Date.now() - WINDOW_MS);
+  const recent = await Message.findOne(
+    { numero: code, from_me: false, createdAt: { $gte: cutoff } },
+    '_id'
+  ).lean();
+  return !!recent;
+}
+
+module.exports = { isWithin24HourWindow };

package/lib/helpers/templateRecoveryHelper.js

@@ -1,18 +1,20 @@
 const { logger } = require('../utils/logger');
 const { Message } = require('../models/messageModel');
+const TemplateModel = require('../models/templateModel');
 const { Template } = require('../templates/templateStructure');
 const { recordDeliveryAttempt } = require('./deliveryAttemptHelper');
 
 const getMessaging = () => require('../core/NexusMessaging');
 
-async function handle24HourWindowError(message, messageSid) {
+async function triggerTemplateRecovery(messageDoc, { source = 'reactive', messageSid = null } = {}) {
   try {
-    if (!message?.body || !message?.numero || !message?._id) return;
+    if (!messageDoc?.body || !messageDoc?.numero || !messageDoc?._id) return;
 
-    const messageDocId = message._id;
+    const messageDocId = messageDoc._id;
+    const logCtx = { source, messageSid, messageDocId: String(messageDocId) };
 
-    if (message?.statusInfo?.recoveryTemplateSid || message?.statusInfo?.recoverySentAt) {
-      logger.info('[TemplateRecovery] Recovery already completed or in progress', { messageSid });
+    if (messageDoc?.statusInfo?.recoveryTemplateSid || messageDoc?.statusInfo?.recoverySentAt) {
+      logger.info('[TemplateRecovery] Already completed or in progress', logCtx);
       return;
     }
 
@@ -22,24 +24,24 @@ async function handle24HourWindowError(message, messageSid) {
         { $set: { 'statusInfo.recoveryStartedAt': new Date() } }
       );
       if (!claim.modifiedCount && !claim.nModified) {
-        logger.info('[TemplateRecovery] Recovery already in progress', { messageSid });
+        logger.info('[TemplateRecovery] Already in progress', logCtx);
         return;
       }
     } catch (claimErr) {
-      logger.warn('[TemplateRecovery] Could not set recovery flag', { messageSid, error: claimErr.message });
+      logger.warn('[TemplateRecovery] Could not set recovery flag', { ...logCtx, error: claimErr.message });
       return;
     }
 
     const { requireProvider, scheduleTemplateApproval } = getMessaging();
     const provider = requireProvider();
     if (typeof provider.createTemplate !== 'function') {
-      logger.warn('[TemplateRecovery] Provider does not support createTemplate, skipping', { messageSid });
+      logger.warn('[TemplateRecovery] Provider does not support createTemplate, skipping', logCtx);
       return;
     }
 
     const templateName = `auto_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
     const template = new Template(templateName, 'UTILITY', 'es');
-    template.setBody(message.body, []);
+    template.setBody(messageDoc.body, []);
 
     let twilioContent;
     let setupErr = null;
@@ -54,22 +56,36 @@ async function handle24HourWindowError(message, messageSid) {
     await recordDeliveryAttempt({
       messageId: messageDocId,
       kind: 'recovery_template_setup',
-      body: message.body,
+      body: messageDoc.body,
       twilioResult: twilioContent?.sid ? { sid: twilioContent.sid } : null,
       ...(setupErr && { errorSource: 'server', errorMessage: setupErr.message })
     });
 
     if (setupErr) {
-      logger.error('[TemplateRecovery] Setup failed', { messageSid, error: setupErr.message });
+      logger.error('[TemplateRecovery] Setup failed', { ...logCtx, error: setupErr.message });
       return;
     }
 
+    await TemplateModel.create({
+      sid: twilioContent.sid,
+      name: templateName,
+      friendlyName: twilioContent.friendlyName || templateName,
+      category: 'UTILITY',
+      language: 'es',
+      status: 'PENDING',
+      body: messageDoc.body,
+      variables: [],
+      components: twilioContent.components || [],
+      dateCreated: new Date(),
+      lastUpdated: new Date()
+    }).catch(err => logger.warn('[TemplateRecovery] TemplateModel.create failed (non-fatal)', { ...logCtx, error: err.message }));
+
     await Message.updateOne(
       { _id: messageDocId },
       { $set: { 'statusInfo.recoveryTemplateSid': twilioContent.sid } }
     );
 
-    logger.info('[TemplateRecovery] Template created', { messageSid, templateSid: twilioContent.sid });
+    logger.info('[TemplateRecovery] Template created', { ...logCtx, templateSid: twilioContent.sid });
 
     await scheduleTemplateApproval({
       templateSid: twilioContent.sid,
@@ -77,8 +93,12 @@ async function handle24HourWindowError(message, messageSid) {
       originalMessageSid: messageSid
     });
   } catch (error) {
-    logger.error('[TemplateRecovery] Error', { messageSid, error: error.message });
+    logger.error('[TemplateRecovery] Error', { source, messageSid, error: error.message });
   }
 }
 
-module.exports = { handle24HourWindowError };
+async function handle24HourWindowError(message, messageSid) {
+  return triggerTemplateRecovery(message, { source: 'reactive', messageSid });
+}
+
+module.exports = { handle24HourWindowError, triggerTemplateRecovery };

package/package.json

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