@peopl-health/nexus 3.15.4 → 3.15.6

package/lib/core/NexusMessaging.js

@@ -22,6 +22,8 @@ const { ProcessingPipeline } = require('../core/ProcessingPipeline');
 const { AssistantProcessor } = require('../core/AssistantProcessor');
 
 const { createQueueAdapter } = require('../queue');
+const { ScheduledMessageJob } = require('../jobs/ScheduledMessageJob');
+const { TemplateApprovalJob } = require('../jobs/TemplateApprovalJob');
 
 /**
  * Core messaging orchestrator for providers, storage, and assistant processing.
@@ -77,6 +79,21 @@ class NexusMessaging {
       sendMessage: this.sendMessage.bind(this),
       storeRunMetrics,
     });
+
+    this.scheduledMessageJob = new ScheduledMessageJob({
+      queueAdapter: this.queueAdapter,
+      sendMessage: this.sendMessage.bind(this)
+    });
+
+    this.templateApprovalJob = new TemplateApprovalJob({
+      queueAdapter: this.queueAdapter,
+      sendMessage: this.sendMessage.bind(this),
+      requireProvider: () => {
+        const provider = this.getProvider();
+        if (!provider) throw new Error('Nexus provider not configured');
+        return provider;
+      }
+    });
   }
 
   async initialize(options = {}) {
@@ -257,10 +274,25 @@ class NexusMessaging {
   }
 
   async sendScheduledMessage(scheduledMessage) {
-    if (!this.provider) {
-      throw new Error('No provider initialized');
+    if (!scheduledMessage?._id) {
+      throw new Error('sendScheduledMessage requires a persisted ScheduledMessage with _id');
     }
-    return await this.provider.sendScheduledMessage(scheduledMessage);
+    if (!scheduledMessage?.sendTime) {
+      throw new Error('sendScheduledMessage requires sendTime');
+    }
+    return await this.scheduledMessageJob.schedule({
+      scheduledMessageId: scheduledMessage._id,
+      sendTime: scheduledMessage.sendTime
+    });
+  }
+
+  async scheduleTemplateApproval({ templateSid, messageId, originalMessageSid = null, attempt = 0 }) {
+    return await this.templateApprovalJob.schedule({
+      templateSid,
+      messageId,
+      originalMessageSid,
+      attempt
+    });
   }
 
   /*
@@ -546,6 +578,10 @@ const sendScheduledMessage = async (scheduledMessage) => {
   return await requireDefaultInstance().sendScheduledMessage(scheduledMessage);
 };
 
+const scheduleTemplateApproval = async (options) => {
+  return await requireDefaultInstance().scheduleTemplateApproval(options);
+};
+
 const processInstruction = async (code, instruction, role, options) => {
   return await requireDefaultInstance().processInstruction(code, instruction, role, options);
 };
@@ -562,6 +598,7 @@ module.exports = {
   NexusMessaging,
   sendMessage,
   sendScheduledMessage,
+  scheduleTemplateApproval,
   processInstruction,
   processSystemMessage,
   setDefaultInstance,

package/lib/helpers/templateRecoveryHelper.js

@@ -1,7 +1,6 @@
 const { logger } = require('../utils/logger');
 const { Message } = require('../models/messageModel');
 const { Template } = require('../templates/templateStructure');
-const { pollTemplateApproval } = require('./templateApprovalPoller');
 
 const getMessaging = () => require('../core/NexusMessaging');
 
@@ -30,7 +29,7 @@ async function handle24HourWindowError(message, messageSid) {
       return;
     }
 
-    const { requireProvider } = getMessaging();
+    const { requireProvider, scheduleTemplateApproval } = getMessaging();
     const provider = requireProvider();
     if (typeof provider.createTemplate !== 'function') {
       logger.warn('[TemplateRecovery] Provider does not support createTemplate, skipping', { messageSid });
@@ -52,65 +51,11 @@ async function handle24HourWindowError(message, messageSid) {
 
     logger.info('[TemplateRecovery] Template created', { messageSid, templateSid: twilioContent.sid });
 
-    pollTemplateApproval(twilioContent.sid, {
-      label: '[TemplateRecovery]',
-      logContext: { messageSid },
-      onApproved: async (prov) => {
-        const claimSend = await Message.updateOne(
-          { _id: messageDocId, 'statusInfo.recoverySentAt': { $exists: false } },
-          { $set: { 'statusInfo.recoverySentAt': new Date() } }
-        );
-        if (!claimSend?.modifiedCount && !claimSend?.nModified) {
-          logger.info('[TemplateRecovery] Send already claimed by another process', { messageSid, templateSid: twilioContent.sid });
-          return;
-        }
-
-        let newMessageId;
-        try {
-          const sendResult = await provider.sendMessage({
-            code: message.numero,
-            contentSid: twilioContent.sid,
-            variables: {},
-            _skipStorage: true
-          });
-          newMessageId = sendResult?.messageId;
-          if (!newMessageId) throw new Error('Provider did not return a messageId for the recovery send');
-        } catch (sendErr) {
-          await Message.updateOne(
-            { _id: messageDocId },
-            { $unset: { 'statusInfo.recoverySentAt': '' } }
-          );
-          logger.error('[TemplateRecovery] Error sending approved template', { messageSid, templateSid: twilioContent.sid, error: sendErr.message });
-          return;
-        }
-
-        try {
-          await Message.updateOne(
-            { _id: messageDocId },
-            { $set: { 'statusInfo.recoveryMessageId': newMessageId } }
-          );
-          logger.info('[TemplateRecovery] Recovered', { originalMessageId: messageSid, recoveryMessageId: newMessageId, templateSid: twilioContent.sid });
-        } catch (dbErr) {
-          logger.error('[TemplateRecovery] CRITICAL: send succeeded but DB update failed — status tracking lost for recovery delivery', {
-            messageSid, newMessageId, templateSid: twilioContent.sid, error: dbErr.message
-          });
-        }
-
-        prov.deleteTemplate(twilioContent.sid).catch(deleteErr =>
-          logger.warn('[TemplateRecovery] Failed to delete template after send', { newMessageId, templateSid: twilioContent.sid, error: deleteErr.message })
-        );
-      },
-      onRejected: async (prov) => {
-        logger.warn('[TemplateRecovery] Template rejected', { messageSid, templateSid: twilioContent.sid });
-        try {
-          await prov.deleteTemplate(twilioContent.sid);
-          logger.info('[TemplateRecovery] Rejected template deleted', { messageSid, templateSid: twilioContent.sid });
-        } catch (deleteErr) {
-          logger.warn('[TemplateRecovery] Failed to delete rejected template', { messageSid, templateSid: twilioContent.sid, error: deleteErr.message });
-        }
-      }
+    await scheduleTemplateApproval({
+      templateSid: twilioContent.sid,
+      messageId: messageDocId,
+      originalMessageSid: messageSid
     });
-
   } catch (error) {
     logger.error('[TemplateRecovery] Error', { messageSid, error: error.message });
   }

package/lib/jobs/ScheduledMessageJob.js

@@ -1,4 +1,5 @@
 const { logger } = require('../utils/logger');
+const { ScheduledMessage } = require('../models/agendaMessageModel');
 const { BaseJob } = require('./BaseJob');
 
 const QUEUE_NAME = 'scheduled-messages';
@@ -10,9 +11,16 @@ const DEFAULT_JOB_OPTIONS = {
   removeOnFail: 50
 };
 
+const TERMINAL_STATUSES = ['sent', 'cancelled'];
+const STALE_SENDING_MS = 5 * 60 * 1000;
+
 class ScheduledMessageJob extends BaseJob {
-  constructor({ queueAdapter } = {}) {
+  constructor({ queueAdapter, sendMessage } = {}) {
     super({ queueAdapter, queueName: QUEUE_NAME });
+    if (typeof sendMessage !== 'function') {
+      throw new Error('ScheduledMessageJob requires a sendMessage function');
+    }
+    this.sendMessage = sendMessage;
   }
 
   async schedule({ scheduledMessageId, sendTime }) {
@@ -47,9 +55,79 @@ class ScheduledMessageJob extends BaseJob {
     return `scheduled-msg-${scheduledMessageId}`;
   }
 
-  async _process(data) {
-    logger.warn('[ScheduledMessageJob] Processor stub invoked; real implementation pending', data);
-    return { success: false, reason: 'not_implemented' };
+  async _process({ scheduledMessageId }) {
+    const msg = await ScheduledMessage.findById(scheduledMessageId);
+
+    if (!msg) {
+      logger.warn('[ScheduledMessageJob] Scheduled message not found', { scheduledMessageId });
+      return { success: false, reason: 'not_found' };
+    }
+
+    if (TERMINAL_STATUSES.includes(msg.status)) {
+      logger.info('[ScheduledMessageJob] Already processed', { scheduledMessageId, status: msg.status });
+      return { success: false, reason: 'already_processed', status: msg.status };
+    }
+
+    const staleThreshold = new Date(Date.now() - STALE_SENDING_MS);
+    const claim = await ScheduledMessage.updateOne(
+      {
+        _id: scheduledMessageId,
+        $or: [
+          { status: { $nin: TERMINAL_STATUSES.concat(['sending']) } },
+          { status: 'sending', sendingAt: { $lt: staleThreshold } }
+        ]
+      },
+      { $set: { status: 'sending', sendingAt: new Date() } }
+    );
+    if (!claim.modifiedCount && !claim.nModified) {
+      logger.info('[ScheduledMessageJob] Send already claimed by another worker', { scheduledMessageId });
+      return { success: false, reason: 'already_claimed' };
+    }
+    if (msg.status === 'sending') {
+      logger.warn('[ScheduledMessageJob] Re-claimed stale sending state, prior worker likely crashed', {
+        scheduledMessageId,
+        priorSendingAt: msg.sendingAt
+      });
+    }
+
+    try {
+      const result = await this.sendMessage({
+        code: msg.code,
+        body: msg.message,
+        fileUrl: msg.fileUrl,
+        fileType: msg.fileType,
+        contentSid: msg.contentSid,
+        variables: msg.variables,
+        hidePreview: msg.hidePreview
+      });
+
+      const messageId = result?.messageId || result?.sid || null;
+
+      await ScheduledMessage.updateOne(
+        { _id: scheduledMessageId },
+        { $set: { status: 'sent', sentAt: new Date(), wa_id: messageId } }
+      );
+
+      logger.info('[ScheduledMessageJob] Sent', { scheduledMessageId, messageId });
+
+      return { success: true, messageId };
+    } catch (error) {
+      await ScheduledMessage.updateOne(
+        { _id: scheduledMessageId },
+        {
+          $set: {
+            status: 'failed',
+            failedAt: new Date(),
+            errorCode: error?.code || null,
+            errorMessage: error?.message || null
+          }
+        }
+      );
+
+      logger.error('[ScheduledMessageJob] Send failed', { scheduledMessageId, error: error.message });
+
+      throw error;
+    }
   }
 }
 

package/lib/jobs/TemplateApprovalJob.js

@@ -1,8 +1,10 @@
 const { logger } = require('../utils/logger');
+const { Message } = require('../models/messageModel');
 const { BaseJob } = require('./BaseJob');
 
 const QUEUE_NAME = 'template-approval';
 const DEFAULT_DELAY_MS = 15 * 60 * 1000;
+const MAX_ATTEMPTS = 40;
 
 const DEFAULT_JOB_OPTIONS = {
   attempts: 3,
@@ -12,8 +14,16 @@ const DEFAULT_JOB_OPTIONS = {
 };
 
 class TemplateApprovalJob extends BaseJob {
-  constructor({ queueAdapter } = {}) {
+  constructor({ queueAdapter, sendMessage, requireProvider } = {}) {
     super({ queueAdapter, queueName: QUEUE_NAME });
+    if (typeof sendMessage !== 'function') {
+      throw new Error('TemplateApprovalJob requires a sendMessage function');
+    }
+    if (typeof requireProvider !== 'function') {
+      throw new Error('TemplateApprovalJob requires a requireProvider function');
+    }
+    this.sendMessage = sendMessage;
+    this.requireProvider = requireProvider;
   }
 
   async schedule({ templateSid, messageId, originalMessageSid = null, attempt = 0, delayMs = DEFAULT_DELAY_MS }) {
@@ -36,9 +46,123 @@ class TemplateApprovalJob extends BaseJob {
     return `template-approval-${templateSid}-${attempt}`;
   }
 
-  async _process(data) {
-    logger.warn('[TemplateApprovalJob] Processor stub invoked; real implementation pending', data);
-    return { success: false, reason: 'not_implemented' };
+  async _process({ templateSid, messageId, originalMessageSid, attempt = 0 }) {
+    const message = await Message.findById(messageId).lean();
+
+    if (!message) {
+      logger.warn('[TemplateApprovalJob] Message not found', { messageId, templateSid });
+      return { success: false, reason: 'not_found' };
+    }
+
+    const recovery = message.statusInfo || {};
+    if (recovery.recoveryMessageId || recovery.recoveryRejectedAt) {
+      logger.info('[TemplateApprovalJob] Recovery already completed', { messageId, templateSid });
+      return { success: false, reason: 'already_completed' };
+    }
+    if (recovery.recoveryTemplateSid && recovery.recoveryTemplateSid !== templateSid) {
+      logger.info('[TemplateApprovalJob] Template superseded', { messageId, templateSid, currentTemplateSid: recovery.recoveryTemplateSid });
+      return { success: false, reason: 'template_superseded' };
+    }
+
+    let provider;
+    let approvalStatus;
+    try {
+      provider = this.requireProvider();
+      const status = await provider.checkApprovalStatus(templateSid);
+      approvalStatus = status?.approvalRequest?.status?.toUpperCase();
+    } catch (err) {
+      logger.error('[TemplateApprovalJob] Provider error during approval check, treating as transient', {
+        templateSid, messageId, attempt, error: err.message
+      });
+      return await this._rescheduleOrGiveUp({ templateSid, messageId, originalMessageSid, attempt, reason: 'error' });
+    }
+
+    logger.info('[TemplateApprovalJob] Approval status', { templateSid, approvalStatus, attempt, messageId, originalMessageSid });
+
+    if (approvalStatus === 'APPROVED') {
+      return await this._handleApproved({ provider, message, templateSid, originalMessageSid });
+    }
+    if (approvalStatus === 'REJECTED') {
+      return await this._handleRejected({ provider, message, templateSid });
+    }
+
+    return await this._rescheduleOrGiveUp({ templateSid, messageId, originalMessageSid, attempt, reason: 'pending' });
+  }
+
+  async _rescheduleOrGiveUp({ templateSid, messageId, originalMessageSid, attempt, reason }) {
+    const nextAttempt = attempt + 1;
+    if (nextAttempt >= MAX_ATTEMPTS) {
+      logger.warn('[TemplateApprovalJob] Max attempts reached, giving up', { templateSid, messageId, attempt, reason });
+      return { success: false, reason: 'max_attempts', priorReason: reason };
+    }
+    await this.schedule({ templateSid, messageId, originalMessageSid, attempt: nextAttempt });
+    return { success: false, reason, nextAttempt };
+  }
+
+  async _handleApproved({ provider, message, templateSid, originalMessageSid }) {
+    const claim = await Message.updateOne(
+      { _id: message._id, 'statusInfo.recoverySentAt': { $exists: false } },
+      { $set: { 'statusInfo.recoverySentAt': new Date() } }
+    );
+    if (!claim.modifiedCount && !claim.nModified) {
+      logger.info('[TemplateApprovalJob] Send already claimed by another worker', { templateSid, messageId: message._id });
+      return { success: false, reason: 'already_claimed' };
+    }
+
+    let recoveryMessageId;
+    try {
+      const sendResult = await this.sendMessage({
+        code: message.numero,
+        contentSid: templateSid,
+        variables: {},
+        _skipStorage: true
+      });
+      recoveryMessageId = sendResult?.messageId;
+      if (!recoveryMessageId) {
+        throw new Error('Provider did not return a messageId for the recovery send');
+      }
+    } catch (sendErr) {
+      await Message.updateOne(
+        { _id: message._id },
+        { $unset: { 'statusInfo.recoverySentAt': '' } }
+      );
+      logger.error('[TemplateApprovalJob] Send failed', { templateSid, messageId: message._id, error: sendErr.message });
+      throw sendErr;
+    }
+
+    try {
+      await Message.updateOne(
+        { _id: message._id },
+        { $set: { 'statusInfo.recoveryMessageId': recoveryMessageId } }
+      );
+      logger.info('[TemplateApprovalJob] Recovered', { originalMessageSid, recoveryMessageId, templateSid });
+    } catch (dbErr) {
+      logger.error('[TemplateApprovalJob] CRITICAL: send succeeded but DB update failed', {
+        messageId: message._id, templateSid, recoveryMessageId, error: dbErr.message
+      });
+    }
+
+    provider.deleteTemplate(templateSid).catch((deleteErr) =>
+      logger.warn('[TemplateApprovalJob] Failed to delete template after send', { templateSid, error: deleteErr.message })
+    );
+
+    return { success: true, recoveryMessageId };
+  }
+
+  async _handleRejected({ provider, message, templateSid }) {
+    await Message.updateOne(
+      { _id: message._id },
+      { $set: { 'statusInfo.recoveryRejectedAt': new Date() } }
+    );
+
+    try {
+      await provider.deleteTemplate(templateSid);
+      logger.info('[TemplateApprovalJob] Rejected template deleted', { templateSid, messageId: message._id });
+    } catch (deleteErr) {
+      logger.warn('[TemplateApprovalJob] Failed to delete rejected template', { templateSid, error: deleteErr.message });
+    }
+
+    return { success: false, reason: 'rejected' };
   }
 }
 

package/lib/models/messageModel.js

@@ -84,7 +84,8 @@ const messageSchema = new mongoose.Schema({
     recoveryTemplateSid: { type: String, default: null },
     recoveryStartedAt: { type: Date, default: null },
     recoverySentAt: { type: Date, default: null },
-    recoveryMessageId: { type: String, default: null }
+    recoveryMessageId: { type: String, default: null },
+    recoveryRejectedAt: { type: Date, default: null }
   },
   prompt: { type: Object, default: null },
   preset: { type: Object, default: null },

package/lib/queue/LocalQueueAdapter.js

@@ -11,7 +11,14 @@ class LocalQueueAdapter extends QueueAdapter {
   }
 
   async enqueue(jobType, payload, options = {}) {
-    const jobId = `local_${++this.jobCounter}_${Date.now()}`;
+    if (options.jobId && this.jobs.has(options.jobId)) {
+      const existing = this.jobs.get(options.jobId);
+      if (existing.status === 'pending' || existing.status === 'delayed') {
+        return existing.id;
+      }
+    }
+
+    const jobId = options.jobId || `local_${++this.jobCounter}_${Date.now()}`;
     const job = {
       id: jobId,
       type: jobType,
@@ -21,12 +28,16 @@ class LocalQueueAdapter extends QueueAdapter {
       result: null,
       error: null,
       createdAt: new Date(),
-      completedAt: null
+      completedAt: null,
+      timeoutHandle: null
     };
 
     this.jobs.set(jobId, job);
 
-    setImmediate(async () => {
+    const runHandler = async () => {
+      job.timeoutHandle = null;
+      if (job.status === 'cancelled') return;
+
       const handler = this.handlers.get(jobType);
       if (!handler) {
         job.status = 'failed';
@@ -46,7 +57,14 @@ class LocalQueueAdapter extends QueueAdapter {
       }
       this.events.emit(`job:${jobId}`, job);
       this.jobs.delete(jobId);
-    });
+    };
+
+    if (options.delay && options.delay > 0) {
+      job.status = 'delayed';
+      job.timeoutHandle = setTimeout(runHandler, options.delay);
+    } else {
+      setImmediate(runHandler);
+    }
 
     return jobId;
   }
@@ -63,7 +81,11 @@ class LocalQueueAdapter extends QueueAdapter {
 
   async cancelJob(jobId) {
     const job = this.jobs.get(jobId);
-    if (!job || job.status !== 'pending') return false;
+    if (!job || (job.status !== 'pending' && job.status !== 'delayed')) return false;
+    if (job.timeoutHandle) {
+      clearTimeout(job.timeoutHandle);
+      job.timeoutHandle = null;
+    }
     job.status = 'cancelled';
     this.events.emit(`job:${jobId}`, job);
     this.jobs.delete(jobId);
@@ -95,6 +117,12 @@ class LocalQueueAdapter extends QueueAdapter {
   }
 
   async shutdown() {
+    for (const job of this.jobs.values()) {
+      if (job.timeoutHandle) {
+        clearTimeout(job.timeoutHandle);
+        job.timeoutHandle = null;
+      }
+    }
     this.jobs.clear();
     this.handlers.clear();
     this.events.removeAllListeners();

package/package.json

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