@peopl-health/nexus 3.3.9 → 3.3.10

package/examples/basic-usage.js

@@ -172,7 +172,6 @@ async function startServer() {
   // Example using Airtable
   app.get('/airtable-test', async (req, res) => {
     try {
-      const calendarBase = nexus.getAirtableBase('calendar');
       // Use calendarBase to interact with Airtable
       res.json({ success: true, message: 'Airtable connection ready' });
     } catch (error) {

package/lib/adapters/BaileysProvider.js

@@ -1,7 +1,7 @@
 const { logger } = require('../utils/logger');
 const { calculateDelay } = require('../utils/scheduleUtils');
 
-const { MessageProvider } = require('../core/MessageProvider');
+const { MessageProvider } = require('../adapters/MessageProvider');
 
 class BaileysProvider extends MessageProvider {
   constructor(config) {

package/lib/adapters/TwilioProvider.js

@@ -1,18 +1,21 @@
 const axios = require('axios');
 const { v4: uuidv4 } = require('uuid');
+const twilio = require('twilio');
 
 const runtimeConfig = require('../config/runtimeConfig');
 const { generatePresignedUrl } = require('../config/awsConfig');
 
-const { sanitizeMediaFilename } = require('../utils/inputSanitizer');
+const { sanitizeMediaFilename } = require('../utils/sanitizerUtils');
 const { validateMedia, getMediaType } = require('../utils/mediaValidator');
 const { logger } = require('../utils/logger');
 const { calculateDelay } = require('../utils/scheduleUtils');
 
+const { ScheduledMessage } = require('../models/agendaMessageModel');
+
 const { ensureWhatsAppFormat } = require('../helpers/twilioHelper');
 const { uploadMediaToS3, getFileExtension } = require('../helpers/mediaHelper');
 
-const { MessageProvider } = require('../core/MessageProvider');
+const { MessageProvider } = require('../adapters/MessageProvider');
 
 class TwilioProvider extends MessageProvider {
   constructor(config) {
@@ -30,7 +33,6 @@ class TwilioProvider extends MessageProvider {
     }
 
     try {
-      const twilio = require('twilio');
       this.twilioClient = twilio(this.accountSid, this.authToken);
       this.isConnected = true;
     } catch (error) {
@@ -89,7 +91,7 @@ class TwilioProvider extends MessageProvider {
     }
 
     if (fileUrl && fileType !== 'text') {
-      const mediaPrep = await this.prepareOutboundMedia(messageData, formattedCode);
+      const mediaPrep = await this._prepareOutboundMedia(messageData, formattedCode);
       const outboundMediaUrl = mediaPrep.mediaUrl || fileUrl;
       messageParams.mediaUrl = [outboundMediaUrl];
       if (!messageParams.body || messageParams.body.trim() === '') {
@@ -108,69 +110,42 @@ class TwilioProvider extends MessageProvider {
       throw new Error('Message must have body, media URL, or content SID');
     }
 
+    const saveMessage = async (body, result) => {
+      if (!this.messageStorage?.saveMessage) return;
+      try {
+        await this.messageStorage.saveMessage({
+          ...messageData, 
+          body, 
+          code: formattedCode, 
+          from: formattedFrom, 
+          messageId: result.sid,
+          provider: 'twilio', 
+          timestamp: new Date(), 
+          fromMe: true,
+          processed: messageData.processed ?? false,
+          statusInfo: { 
+            status: result.status?.toLowerCase() || null, 
+            updatedAt: result.dateCreated || new Date() 
+          }
+        });
+      } catch (err) {
+        logger.error('[TwilioProvider] Storage failed:', err);
+      }
+    };
+
     let result;
-    const chunks = messageParams.body && messageParams.body.length > 1600 && !messageParams.mediaUrl && !messageParams.contentSid
-      ? this.splitMessageAtWordBoundaries(messageParams.body)
-      : null;
+    const chunks = messageParams.body?.length > 1600 && !messageParams.mediaUrl && !messageParams.contentSid
+      ? this._splitMessageAtWordBoundaries(messageParams.body) : null;
     
     if (chunks) {
       for (let i = 0; i < chunks.length; i++) {
-        const chunkParams = { ...messageParams, body: chunks[i] };
-        result = await this.twilioClient.messages.create(chunkParams);
-        if (this.messageStorage && typeof this.messageStorage.saveMessage === 'function') {
-          try {
-            await this.messageStorage.saveMessage({
-              ...messageData,
-              body: chunks[i],
-              code: formattedCode,
-              from: formattedFrom,
-              messageId: result.sid,
-              provider: 'twilio',
-              timestamp: new Date(),
-              fromMe: true,
-              processed: messageData.processed !== undefined ? messageData.processed : false,
-              statusInfo: {
-                status: result.status ? result.status.toLowerCase() : null,
-                updatedAt: result.dateCreated || new Date()
-              }
-            });
-            logger.info('[TwilioProvider] Message chunk persisted', { messageId: result.sid, chunk: i + 1, total: chunks.length });
-          } catch (storageError) {
-            logger.error('TwilioProvider storage failed:', storageError);
-          }
-        }
-        if (i < chunks.length - 1) {
-          await new Promise(resolve => setTimeout(resolve, 100));
-        }
+        result = await this.twilioClient.messages.create({ ...messageParams, body: chunks[i] });
+        await saveMessage(chunks[i], result);
+        if (i < chunks.length - 1) await new Promise(r => setTimeout(r, 100));
       }
     } else {
-      logger.info('[TwilioProvider] Sending message', messageParams);
-      try {
-        result = await this.twilioClient.messages.create(messageParams);
-      } catch (error) {
-        throw new Error(`Twilio send failed: ${error.message}`);
-      }
-      if (this.messageStorage && typeof this.messageStorage.saveMessage === 'function') {
-        try {
-          await this.messageStorage.saveMessage({
-            ...messageData,
-            code: formattedCode,
-            from: formattedFrom,
-            messageId: result.sid,
-            provider: 'twilio',
-            timestamp: new Date(),
-            fromMe: true,
-            processed: messageData.processed !== undefined ? messageData.processed : false,
-            statusInfo: {
-              status: result.status ? result.status.toLowerCase() : null,
-              updatedAt: result.dateCreated || new Date()
-            }
-          });
-          logger.info('[TwilioProvider] Message persisted successfully', { messageId: result.sid });
-        } catch (storageError) {
-          logger.error('TwilioProvider storage failed:', storageError);
-        }
-      }
+      result = await this.twilioClient.messages.create(messageParams);
+      await saveMessage(messageParams.body, result);
     }
     
     return {
@@ -232,61 +207,31 @@ class TwilioProvider extends MessageProvider {
     });
 
     const updateStatus = async (status, messageId = null, error = null) => {
-      if (!scheduledMessage) return;
-
       const now = new Date();
-      const errorCode = error?.code || error?.status || error?.errorCode || null;
-      const errorMessage = error?.message || error?.statusMessage || null;
-      const statusEntry = { status, at: now, errorCode, errorMessage };
-      const baseUpdate = {
-        status,
-        lastStatus: status,
-        lastStatusAt: now,
-        errorCode,
-        errorMessage
-      };
-
-      if (messageId) baseUpdate.wa_id = messageId;
-
-      const ScheduledMessageModel = (() => {
-        if (scheduledMessage.constructor && typeof scheduledMessage.constructor.updateOne === 'function') {
-          return scheduledMessage.constructor;
-        }
-        try {
-          return require('../models/agendaMessageModel').ScheduledMessage;
-        } catch (e) {
-          return null;
-        }
-      })();
-
-      if (!ScheduledMessageModel) {
-        logger.warn('[TwilioProvider] Scheduled message model unavailable for status update');
-        return;
-      }
-
-      const query = (() => {
-        if (scheduledMessage._id) return { _id: scheduledMessage._id };
-        if (messageId) return { wa_id: messageId };
-        if (scheduledMessage.wa_id) return { wa_id: scheduledMessage.wa_id };
-        return null;
-      })();
-
-      if (!query) {
-        logger.warn('[TwilioProvider] Scheduled message status update skipped: no identifier', {
-          hasId: Boolean(scheduledMessage._id),
-          messageId,
-          existingWaId: scheduledMessage.wa_id
-        });
-        return;
-      }
-
       try {
-        await ScheduledMessageModel.updateOne(query, {
-          $set: baseUpdate,
-          $push: { statusHistory: statusEntry }
-        });
-      } catch (statusErr) {
-        logger.warn('[TwilioProvider] Failed to update scheduled message status', statusErr?.message || statusErr);
+        await ScheduledMessage.updateOne(
+          { _id: scheduledMessage._id },
+          {
+            $set: { 
+              status, 
+              lastStatus: status, 
+              lastStatusAt: now, 
+              ...(messageId && { wa_id: messageId }),
+              errorCode: error?.code || null, 
+              errorMessage: error?.message || null 
+            },
+            $push: { 
+              statusHistory: { 
+                status, 
+                at: now, 
+                errorCode: error?.code || null, 
+                errorMessage: error?.message || null 
+              } 
+            }
+          }
+        );
+      } catch (err) {
+        logger.warn('[TwilioProvider] Failed to update scheduled message status', err?.message);
       }
     };
 
@@ -319,8 +264,8 @@ class TwilioProvider extends MessageProvider {
     return true;
   }
 
-  async prepareOutboundMedia(messageData, formattedCode) {
-    const bucketName = runtimeConfig.get('AWS_S3_BUCKET_NAME') || process.env.AWS_S3_BUCKET_NAME;
+  async _prepareOutboundMedia(messageData, formattedCode) {
+    const bucketName = runtimeConfig.get('AWS_S3_BUCKET_NAME');
     const fileUrl = messageData.fileUrl;
 
     if (!fileUrl) {
@@ -346,7 +291,7 @@ class TwilioProvider extends MessageProvider {
       const response = await axios.get(fileUrl, { responseType: 'arraybuffer' });
       const buffer = Buffer.from(response.data);
       let contentType = messageData.contentType || response.headers['content-type'];
-      const declaredType = typeof messageData.fileType === 'string' ? messageData.fileType : null;
+      const declaredType = messageData.fileType || null;
 
       if (!contentType) {
         const fallbackType = declaredType ? {
@@ -368,17 +313,15 @@ class TwilioProvider extends MessageProvider {
         });
       }
 
-      const existingFileName = messageData.fileName || (() => {
-        try {
-          const parsed = new URL(fileUrl);
-          const segments = parsed.pathname.split('/').filter(Boolean);
-          return segments.length ? segments[segments.length - 1] : null;
-        } catch (err) {
-          return null;
+      let existingFileName = messageData.fileName;
+      if (!existingFileName) {
+        try { 
+          existingFileName = new URL(fileUrl).pathname.split('/').pop() || null; 
+        } catch { 
+          existingFileName = null; 
         }
-      })();
-
-      const baseName = existingFileName ? existingFileName.split('.').slice(0, -1).join('.') : `${mediaType}_${Date.now()}`;
+      }
+      const baseName = existingFileName?.split('.').slice(0, -1).join('.') || `${mediaType}_${Date.now()}`;
       const sanitizedBase = sanitizeMediaFilename(baseName) || `${mediaType}_${Date.now()}`;
       const extension = getFileExtension(contentType) || 'bin';
       const uploadId = uuidv4();
@@ -420,7 +363,7 @@ class TwilioProvider extends MessageProvider {
     }
   }
 
-  splitMessageAtWordBoundaries(text, maxLength = 1600) {
+  _splitMessageAtWordBoundaries(text, maxLength = 1600) {
     if (!text || text.length <= maxLength) return [text];
     const chunks = [];
     let remaining = text;
@@ -492,15 +435,15 @@ class TwilioProvider extends MessageProvider {
         return null;
       }
 
-      let textContent = this.extractTextFromTemplate(template);
+      let textContent = this._extractTextFromTemplate(template);
 
       if (!textContent) {
         logger.warn('[TwilioProvider] No text content found in template:', contentSid);
         return null;
       }
 
-      if (variables && typeof variables === 'object' && Object.keys(variables).length > 0) {
-        return this.renderTemplateWithVariables(textContent, variables);
+      if (variables && Object.keys(variables).length > 0) {
+        return this._renderTemplateWithVariables(textContent, variables);
       }
 
       return textContent.trim();
@@ -510,90 +453,42 @@ class TwilioProvider extends MessageProvider {
     }
   }
 
-  extractTextFromTemplate(template) {
+  _extractTextFromTemplate(template) {
     const types = template.types || {};
     
-    if (types['twilio/text']) {
-      return types['twilio/text'].body || '';
-    }
+    const appendItems = (text, items, formatter) => {
+      const formatted = (items || []).filter(i => i.title).map(formatter).join('\n');
+      return formatted ? text + (text ? '\n\n' : '') + formatted : text;
+    };
+    
+    if (types['twilio/text']) return types['twilio/text'].body || '';
     
     if (types['twilio/quick-reply']) {
-      const quickReply = types['twilio/quick-reply'];
-      let text = quickReply.body || '';
-      
-      if (quickReply.actions && Array.isArray(quickReply.actions)) {
-        const options = quickReply.actions
-          .filter(action => action.title)
-          .map(action => `• ${action.title}`)
-          .join('\n');
-        if (options) {
-          text += (text ? '\n\n' : '') + options;
-        }
-      }
-      
-      return text;
+      const qr = types['twilio/quick-reply'];
+      return appendItems(qr.body || '', qr.actions, a => `• ${a.title}`);
     }
     
     if (types['twilio/list']) {
       const list = types['twilio/list'];
-      let text = list.body || '';
-      
-      if (list.items && Array.isArray(list.items)) {
-        const items = list.items
-          .filter(item => item.title)
-          .map((item, index) => `${index + 1}. ${item.title}`)
-          .join('\n');
-        if (items) {
-          text += (text ? '\n\n' : '') + items;
-        }
-      }
-      
-      return text;
+      return appendItems(list.body || '', list.items, (item, i) => `${i + 1}. ${item.title}`);
     }
     
     if (types['twilio/button']) {
-      const button = types['twilio/button'];
-      let text = button.body || '';
-      
-      if (button.actions && Array.isArray(button.actions)) {
-        const buttons = button.actions
-          .filter(action => action.title)
-          .map(action => `[${action.title}]`)
-          .join(' ');
-        if (buttons) {
-          text += (text ? '\n\n' : '') + buttons;
-        }
-      }
-      
-      return text;
-    }
-    
-    if (types['twilio/flows']) {
-      return types['twilio/flows'].body || '';
-    }
-    
-    if (types['twilio/media']) {
-      return types['twilio/media'].caption || '';
+      const btn = types['twilio/button'];
+      const buttons = (btn.actions || []).filter(a => a.title).map(a => `[${a.title}]`).join(' ');
+      return buttons ? (btn.body || '') + ((btn.body && buttons) ? '\n\n' : '') + buttons : (btn.body || '');
     }
     
-    for (const typeKey of Object.keys(types)) {
-      const type = types[typeKey];
-      if (type && typeof type === 'object' && type.body) {
-        return type.body;
-      }
-    }
+    if (types['twilio/flows']) return types['twilio/flows'].body || '';
+    if (types['twilio/media']) return types['twilio/media'].caption || '';
     
-    return '';
+    const fallback = Object.values(types).find(t => t?.body);
+    return fallback?.body || '';
   }
 
-  renderTemplateWithVariables(templateBody, variables) {
-    if (!templateBody || typeof templateBody !== 'string') {
-      return '';
-    }
-
-    if (!variables || typeof variables !== 'object') {
-      return templateBody;
-    }
+  _renderTemplateWithVariables(templateBody, variables) {
+    if (!templateBody) return '';
+    if (!variables) return templateBody;
 
     try {
       let rendered = templateBody;
@@ -620,60 +515,26 @@ class TwilioProvider extends MessageProvider {
     }
     if (!sid) throw new Error('Content SID is required');
 
-    try {
-      const content = await this.twilioClient.content.v1.contents(sid).fetch();
-      let processedApprovalRequest = null;
-
-      try {
-        const approvalRequest = await this.twilioClient.content.v1
-          .contents(sid)
-          .approvalFetch()
-          .fetch();
-
-        if (approvalRequest) {
-          processedApprovalRequest = {
-            sid: approvalRequest.sid,
-            status: 'UNKNOWN'
-          };
-
-          if (approvalRequest.whatsapp) {
-            processedApprovalRequest.status = approvalRequest.whatsapp.status?.toUpperCase() || 'UNKNOWN';
-            processedApprovalRequest.category = approvalRequest.whatsapp.category;
-            processedApprovalRequest.name = approvalRequest.whatsapp.name;
-            processedApprovalRequest.rejectionReason = approvalRequest.whatsapp.rejection_reason;
-            processedApprovalRequest.contentType = approvalRequest.whatsapp.content_type;
-          } else {
-            processedApprovalRequest.status = approvalRequest.status || 'PENDING';
-          }
-
-          if (processedApprovalRequest.status === 'approved') {
-            processedApprovalRequest.status = 'APPROVED';
-          } else if (processedApprovalRequest.status === 'rejected') {
-            processedApprovalRequest.status = 'REJECTED';
-          } else if (processedApprovalRequest.status === 'pending') {
-            processedApprovalRequest.status = 'PENDING';
-          }
-
-          if (approvalRequest.dateCreated || approvalRequest.date_created) {
-            processedApprovalRequest.dateCreated = approvalRequest.dateCreated || approvalRequest.date_created;
-          }
+    const content = await this.twilioClient.content.v1.contents(sid).fetch();
+    let approvalRequest = null;
 
-          if (approvalRequest.dateUpdated || approvalRequest.date_updated) {
-            processedApprovalRequest.dateUpdated = approvalRequest.dateUpdated || approvalRequest.date_updated;
-          }
-        }
-      } catch (approvalError) {
-        logger.warn('Approval request fetch failed:', approvalError?.message || approvalError);
+    try {
+      const req = await this.twilioClient.content.v1.contents(sid).approvalFetch().fetch();
+      if (req) {
+        const wa = req.whatsapp;
+        approvalRequest = {
+          sid: req.sid,
+          status: (wa?.status || req.status || 'UNKNOWN').toUpperCase(),
+          ...(wa && { category: wa.category, name: wa.name, rejectionReason: wa.rejection_reason, contentType: wa.content_type }),
+          dateCreated: req.dateCreated || req.date_created,
+          dateUpdated: req.dateUpdated || req.date_updated
+        };
       }
-
-      return {
-        content,
-        approvalRequest: processedApprovalRequest
-      };
-    } catch (error) {
-      logger.error('Error checking approval status:', error);
-      throw error;
+    } catch (err) {
+      logger.warn('Approval request fetch failed:', err?.message);
     }
+
+    return { content, approvalRequest };
   }
 
   async submitForApproval(contentSid, name, category) {

package/lib/adapters/index.js

@@ -1,7 +1,12 @@
 const { TwilioProvider } = require('./TwilioProvider');
 const { BaileysProvider } = require('./BaileysProvider');
+const { MessageProvider } = require('./MessageProvider');
+const { createProvider, registerProvider } = require('./registry');
 
 module.exports = {
   TwilioProvider,
-  BaileysProvider
+  BaileysProvider,
+  MessageProvider,
+  createProvider,
+  registerProvider
 };