@peopl-health/nexus 1.5.9 → 1.5.10

package/examples/basic-usage.js

@@ -1,12 +1,13 @@
 const express = require('express');
-const { NexusMessaging, setupDefaultRoutes } = require('@peopl-health/nexus');
+require('dotenv').config();
+const { Nexus, setupDefaultRoutes } = require('@peopl-health/nexus');
 
 const app = express();
 app.use(express.json());
 
 async function startServer() {
   // Initialize Nexus with all services
-  const nexus = new NexusMessaging();
+  const nexus = new Nexus();
   
   await nexus.initialize({
     // MongoDB connection
@@ -17,7 +18,7 @@ async function startServer() {
     providerConfig: {
       accountSid: process.env.TWILIO_ACCOUNT_SID,
       authToken: process.env.TWILIO_AUTH_TOKEN,
-      phoneNumber: process.env.TWILIO_PHONE_NUMBER
+      whatsappNumber: process.env.TWILIO_WHATSAPP_NUMBER
     }
   });
 
@@ -27,7 +28,7 @@ async function startServer() {
   // Add webhook endpoint for incoming messages
   app.post('/webhook', async (req, res) => {
     try {
-      await nexus.processIncomingMessage(req.body);
+      await nexus.messaging.processIncomingMessage(req.body);
       res.status(200).send('OK');
     } catch (error) {
       console.error('Webhook error:', error);
@@ -38,10 +39,10 @@ async function startServer() {
   // Custom endpoint example
   app.get('/status', (req, res) => {
     res.json({
-      connected: nexus.isConnected(),
+      connected: nexus.messaging.isConnected(),
       provider: 'twilio',
-      mongodb: nexus.mongodb?.readyState === 1,
-      airtable: !!nexus.airtable
+      mongodb: nexus.messaging.mongodb?.readyState === 1,
+      airtable: !!nexus.messaging.airtable
     });
   });
 

package/lib/adapters/TwilioProvider.js

@@ -44,10 +44,11 @@ class TwilioProvider extends MessageProvider {
       throw new Error('Twilio provider not initialized');
     }
 
-    const { to, message, fileUrl, fileType, variables, contentSid } = messageData;
+    const { code, message, fileUrl, fileType, variables, contentSid } = messageData;
 
     const formattedFrom = this.ensureWhatsAppFormat(this.whatsappNumber);
-    const formattedTo = this.ensureWhatsAppFormat(to);
+    const formattedTo = this.ensureWhatsAppFormat(code);
+
 
     if (!formattedFrom || !formattedTo) {
       throw new Error('Invalid sender or recipient number');
@@ -60,6 +61,12 @@ class TwilioProvider extends MessageProvider {
 
     // Handle template messages
     if (contentSid) {
+      // Render template and add to messageData for storage
+      const renderedMessage = await this.renderTemplate(contentSid, variables);
+      if (renderedMessage) {
+        messageData.body = renderedMessage; // Add rendered content for storage
+      }
+      
       messageParams.contentSid = contentSid;
       if (variables && Object.keys(variables).length > 0) {
         const formattedVariables = {};
@@ -140,17 +147,18 @@ class TwilioProvider extends MessageProvider {
       : async (payload) => await this.sendMessage(payload);
 
     console.log('[TwilioProvider] Scheduled message created', {
-      to: scheduledMessage.to || scheduledMessage.code,
+      to: scheduledMessage.code,
       delay,
       hasContentSid: Boolean(scheduledMessage.contentSid)
     });
 
     setTimeout(async () => {
       try {
-        const payload = { ...scheduledMessage };
+        // Convert Mongoose document to plain object if needed
+        const payload = scheduledMessage.toObject ? scheduledMessage.toObject() : { ...scheduledMessage };
         delete payload.__nexusSend;
         console.log('[TwilioProvider] Timer fired', {
-          to: payload.to || payload.code,
+          to: payload.code,
           hasMessage: Boolean(payload.message || payload.body),
           hasMedia: Boolean(payload.fileUrl)
         });
@@ -311,6 +319,170 @@ class TwilioProvider extends MessageProvider {
     }
   }
 
+  /**
+   * Render template content with variables
+   * @param {string} contentSid - The Twilio content SID
+   * @param {Object} variables - The variables object with keys like "1", "2"
+   * @returns {Promise<string|null>} The rendered message content or null if not found
+   */
+  async renderTemplate(contentSid, variables) {
+    try {
+      if (!contentSid) return null;
+
+      const template = await this.getTemplate(contentSid);
+      
+      if (!template || !template.types) {
+        console.warn('[TwilioProvider] Template not found or has no types:', contentSid);
+        return null;
+      }
+
+      // Extract text content from different template types
+      let textContent = this.extractTextFromTemplate(template);
+
+      if (!textContent) {
+        console.warn('[TwilioProvider] No text content found in template:', contentSid);
+        return null;
+      }
+
+      // Render variables if provided
+      if (variables && typeof variables === 'object' && Object.keys(variables).length > 0) {
+        return this.renderTemplateWithVariables(textContent, variables);
+      }
+
+      return textContent.trim();
+    } catch (error) {
+      console.error('[TwilioProvider] Error rendering template:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Extract text content from different template types
+   * @param {Object} template - The Twilio template object
+   * @returns {string} The extracted text content
+   */
+  extractTextFromTemplate(template) {
+    const types = template.types || {};
+    
+    // Handle plain text templates
+    if (types['twilio/text']) {
+      return types['twilio/text'].body || '';
+    }
+    
+    // Handle quick reply templates
+    if (types['twilio/quick-reply']) {
+      const quickReply = types['twilio/quick-reply'];
+      let text = quickReply.body || '';
+      
+      // Add quick reply options
+      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;
+    }
+    
+    // Handle list templates
+    if (types['twilio/list']) {
+      const list = types['twilio/list'];
+      let text = list.body || '';
+      
+      // Add list items
+      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;
+    }
+    
+    // Handle button templates
+    if (types['twilio/button']) {
+      const button = types['twilio/button'];
+      let text = button.body || '';
+      
+      // Add button options
+      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;
+    }
+    
+    // Handle flow templates (fallback to body)
+    if (types['twilio/flows']) {
+      return types['twilio/flows'].body || '';
+    }
+    
+    // Handle media templates (extract caption)
+    if (types['twilio/media']) {
+      return types['twilio/media'].caption || '';
+    }
+    
+    // Fallback: try to find any body content
+    for (const typeKey of Object.keys(types)) {
+      const type = types[typeKey];
+      if (type && typeof type === 'object' && type.body) {
+        return type.body;
+      }
+    }
+    
+    return '';
+  }
+
+  /**
+   * Render template content with variables
+   * @param {string} templateBody - The template body with placeholders like {{1}}, {{2}}
+   * @param {Object} variables - The variables object with keys like "1", "2"
+   * @returns {string} The rendered message content
+   */
+  renderTemplateWithVariables(templateBody, variables) {
+    if (!templateBody || typeof templateBody !== 'string') {
+      return '';
+    }
+
+    if (!variables || typeof variables !== 'object') {
+      return templateBody;
+    }
+
+    try {
+      let rendered = templateBody;
+      
+      // Replace placeholders like {{1}}, {{2}}, etc. with variable values
+      Object.keys(variables).forEach(key => {
+        const placeholder = `{{${key}}}`;
+        const value = variables[key] || '';
+        
+        // Simple string replacement - more reliable than regex for this use case
+        if (rendered.includes(placeholder)) {
+          rendered = rendered.replace(new RegExp(placeholder.replace(/[{}]/g, '\\$&'), 'g'), value);
+        }
+      });
+
+      return rendered.trim();
+    } catch (error) {
+      console.warn('[TwilioProvider] Error rendering template variables:', error.message);
+      return templateBody; // Return original template if rendering fails
+    }
+  }
+
   /**
    * Check template approval status using Twilio Content API helpers
    */

package/lib/models/messageModel.js

@@ -68,7 +68,8 @@ async function insertMessage(values) {
       reply_id: values.reply_id,
       from_me: values.from_me,
       processed: skipNumbers.includes(values.numero),
-      media: values.media ? values.media : null
+      media: values.media ? values.media : null,
+      content_sid: values.content_sid || null
     };
 
     await Message.findOneAndUpdate(

package/lib/storage/MongoStorage.js

@@ -66,10 +66,11 @@ class MongoStorage {
         from: messageData?.from,
         provider: messageData?.provider || 'unknown',
         hasRaw: Boolean(messageData?.raw),
-        hasMedia: Boolean(messageData?.media || messageData?.fileUrl)
+        hasMedia: Boolean(messageData?.media || messageData?.fileUrl),
+        hasContentSid: Boolean(messageData?.contentSid)
       });
       const enrichedMessage = await this._enrichTwilioMedia(messageData);
-      const values = this.buildLegacyMessageValues(enrichedMessage);
+      const values = this.buildMessageValues(enrichedMessage);
       const { insertMessage } = require('../models/messageModel');
       await insertMessage(values);
       console.log('[MongoStorage] Message stored', {
@@ -166,7 +167,8 @@ class MongoStorage {
     return trimmed;
   }
 
-  buildLegacyMessageValues(messageData = {}) {
+
+  buildMessageValues(messageData = {}) {
     const numero = messageData.to || messageData.code || messageData.numero || messageData.from;
     const rawNumero = typeof numero === 'string' ? numero : '';
     const normalizedNumero = this.normalizeNumero(rawNumero);
@@ -175,7 +177,16 @@ class MongoStorage {
     const now = new Date();
     const timestamp = now.toISOString();
     const nombre = messageData.nombre_whatsapp || messageData.author || messageData.fromName || runtimeConfig.get('USER_DB_MONGO') || process.env.USER_DB_MONGO || 'Nexus';
-    const textBody = messageData.message || messageData.body || (messageData.contentSid ? `[Template:${messageData.contentSid}]` : isMedia ? `[Media:${messageData.fileType || 'attachment'}]` : '');
+    
+    // Use message body directly (template rendering is now handled by the provider)
+    let textBody = messageData.message || messageData.body;
+    
+    if (!textBody && isMedia) {
+      textBody = `[Media:${messageData.fileType || 'attachment'}]`;
+    } else if (!textBody) {
+      textBody = '';
+    }
+    
     const providerId = messageData.messageId || messageData.sid || messageData.id || messageData._id || `pending-${now.getTime()}-${Math.floor(Math.random()*1000)}`;
 
     const media = messageData.media || (messageData.fileUrl ? {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "1.5.9",
+  "version": "1.5.10",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",
@@ -73,7 +73,7 @@
     "airtable": "^0.12.2",
     "aws-sdk": "2.1674.0",
     "axios": "^1.5.0",
-    "dotenv": "^16.4.7",
+    "dotenv": "^16.6.1",
     "moment-timezone": "^0.5.43",
     "mongoose": "^7.5.0",
     "multer": "1.4.5-lts.1",
@@ -102,4 +102,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}