@peopl-health/nexus 4.1.7 → 4.2.1

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/lib/services/conversationService.js

@@ -1,18 +1,12 @@
 const { Historial_Clinico_ID, Symptoms_ID } = require('../config/airtableConfig');
 
 const { logger } = require('../utils/logger');
-const { parseDate } = require('../utils/dateUtils');
 
 const { Thread } = require('../models/threadModel');
-const TemplateModel = require('../models/templateModel');
-
-const { pollTemplateApproval } = require('../helpers/templateApprovalPoller');
 
 const { getRecordByFilter } = require('../services/airtableService');
 
-const { sendMessage, requireProvider } = require('../core/NexusMessaging');
-
-const { Template } = require('../templates/templateStructure');
+const { sendMessage } = require('../core/NexusMessaging');
 
 const toMap = (arr, keyFn, valFn) => arr.reduce((m, item) => {
   const key = keyFn(item);
@@ -131,7 +125,6 @@ const processConversations = async (threads, airtableNameMap) => {
 };
 
 const startConversation = async (phoneNumber, message, name, { triggeredBy } = {}) => {
-
   const existing = await Thread.findOne({ code: phoneNumber });
   if (existing) {
     const err = new Error('Conversation already exists');
@@ -139,93 +132,17 @@ const startConversation = async (phoneNumber, message, name, { triggeredBy } = {
     throw err;
   }
 
-  const provider = requireProvider();
-  const templateName = `auto_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
-  const template = new Template(templateName, 'UTILITY', 'es');
-  template.setBody(message, []);
-  const twilioContent = await template.save();
-
-  const currentDate = new Date();
-  const dateCreated = parseDate(twilioContent.dateCreated, currentDate);
-
-  await TemplateModel.create({
-    sid: twilioContent.sid,
-    name: (twilioContent.friendlyName || `template_${twilioContent.sid}`).replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase(),
-    friendlyName: twilioContent.friendlyName,
-    category: 'UTILITY',
-    language: 'es',
-    status: twilioContent.status,
-    body: message,
-    variables: [],
-    components: twilioContent.components || [],
-    dateCreated,
-    lastUpdated: currentDate
-  });
-
-  const timestamp = Date.now().toString();
-  const randomSuffix = Math.floor(Math.random() * 1000).toString().padStart(3, '0');
-  const approvalName = `${templateName}_${timestamp}_${randomSuffix}`.toLowerCase().replace(/[^a-z0-9_]/g, '_');
-  const approvalResponse = await provider.submitForApproval(twilioContent.sid, approvalName, 'UTILITY');
-
-  const validSubmittedDate = parseDate(approvalResponse.date_created || approvalResponse.dateCreated);
-  const validUpdatedDate = parseDate(approvalResponse.date_updated || approvalResponse.dateUpdated, validSubmittedDate);
-
-  await TemplateModel.updateOne(
-    { sid: twilioContent.sid },
-    {
-      status: 'PENDING',
-      approvalRequest: {
-        sid: approvalResponse.sid,
-        status: approvalResponse.status || 'PENDING',
-        dateSubmitted: validSubmittedDate,
-        dateUpdated: validUpdatedDate,
-        rejectionReason: approvalResponse.rejection_reason || ''
-      }
-    }
+  await Thread.findOneAndUpdate(
+    { code: phoneNumber },
+    { code: phoneNumber, ...(name && { nombre: name }), active: true },
+    { upsert: true, new: true }
   );
 
-  logger.info('[StartConversation] Template created and submitted for approval', {
-    phoneNumber,
-    templateSid: twilioContent.sid,
-    approvalStatus: approvalResponse.status
-  });
-
-  pollTemplateApproval(twilioContent.sid, {
-    label: '[StartConversation]',
-    logContext: { phoneNumber },
-    onApproved: async (prov) => {
-      const thread = await Thread.findOneAndUpdate(
-        { code: phoneNumber },
-        { code: phoneNumber, ...(name && { nombre: name }), active: true },
-        { upsert: true, new: true }
-      );
-      logger.info('[StartConversation] Thread ready', { phoneNumber, threadId: thread._id });
-      await sendMessage({ code: phoneNumber, contentSid: twilioContent.sid, variables: {}, triggeredBy: triggeredBy || null });
-      logger.info('[StartConversation] Template sent successfully', { phoneNumber, templateSid: twilioContent.sid });
-      await TemplateModel.updateOne({ sid: twilioContent.sid }, { status: 'APPROVED' });
-      try {
-        await prov.deleteTemplate(twilioContent.sid);
-        logger.info('[StartConversation] Template cleaned up', { templateSid: twilioContent.sid });
-      } catch (deleteErr) {
-        logger.warn('[StartConversation] Failed to delete template after send', { templateSid: twilioContent.sid, error: deleteErr.message });
-      }
-    },
-    onRejected: async (prov) => {
-      logger.warn('[StartConversation] Template rejected', { phoneNumber, templateSid: twilioContent.sid });
-      await TemplateModel.updateOne({ sid: twilioContent.sid }, { status: 'REJECTED' });
-      try {
-        await prov.deleteTemplate(twilioContent.sid);
-      } catch (deleteErr) {
-        logger.warn('[StartConversation] Failed to delete rejected template', { templateSid: twilioContent.sid, error: deleteErr.message });
-      }
-    }
-  });
+  const result = await sendMessage({ code: phoneNumber, body: message, triggeredBy: triggeredBy || null });
 
-  return {
-    phoneNumber,
-    contentSid: twilioContent.sid,
-    approvalStatus: approvalResponse.status || 'PENDING'
-  };
+  logger.info('[StartConversation] Send routed', { phoneNumber, messageId: result?.messageId, status: result?.status });
+
+  return { phoneNumber, messageId: result?.messageId, status: result?.status || null };
 };
 
 module.exports = {

package/package.json

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

package/lib/helpers/templateApprovalPoller.js

@@ -1,59 +0,0 @@
-const { logger } = require('../utils/logger');
-
-const getMessaging = () => require('../core/NexusMessaging');
-
-const MAX_ATTEMPTS = 40;
-const POLL_INTERVAL_MS = 15 * 60 * 1000;
-
-function pollTemplateApproval(templateSid, { label, logContext = {}, onApproved, onRejected }) {
-  const { requireProvider } = getMessaging();
-  const provider = requireProvider();
-
-  const poll = (attempt = 0) => {
-    if (attempt >= MAX_ATTEMPTS) {
-      logger.warn(`${label} Max approval poll attempts reached, giving up`, { ...logContext, templateSid, attempts: MAX_ATTEMPTS });
-      return;
-    }
-
-    logger.info(`${label} Scheduling approval check`, { ...logContext, templateSid, attempt, nextCheckInMs: POLL_INTERVAL_MS });
-
-    setTimeout(() => {
-      (async () => {
-        logger.info(`${label} Checking approval status`, { ...logContext, templateSid, attempt });
-
-        const status = await provider.checkApprovalStatus(templateSid);
-        const approvalStatus = status?.approvalRequest?.status?.toUpperCase();
-
-        logger.info(`${label} Approval status received`, { ...logContext, templateSid, approvalStatus, attempt });
-
-        if (approvalStatus === 'APPROVED') {
-          await onApproved(provider);
-        } else if (approvalStatus === 'REJECTED') {
-          if (onRejected) {
-            await onRejected(provider);
-          } else {
-            logger.warn(`${label} Template rejected`, { ...logContext, templateSid });
-            try {
-              await provider.deleteTemplate(templateSid);
-              logger.info(`${label} Rejected template deleted`, { ...logContext, templateSid });
-            } catch (deleteErr) {
-              logger.warn(`${label} Failed to delete rejected template`, { ...logContext, templateSid, error: deleteErr.message });
-            }
-          }
-        } else {
-          logger.info(`${label} Still pending, will retry`, { ...logContext, templateSid, approvalStatus, attempt });
-          poll(attempt + 1);
-        }
-      })().catch((err) => {
-        logger.error(`${label} Error during approval poll`, { ...logContext, templateSid, error: err.message, attempt });
-        if (attempt + 1 < MAX_ATTEMPTS) {
-          poll(attempt + 1);
-        }
-      });
-    }, POLL_INTERVAL_MS);
-  };
-
-  poll();
-}
-
-module.exports = { pollTemplateApproval };