@peopl-health/nexus 1.1.5 → 1.1.7

package/lib/adapters/BaileysProvider.js

@@ -15,7 +15,7 @@ class BaileysProvider extends MessageProvider {
   async initialize() {
     try {
       const { default: makeWASocket, useMultiFileAuthState } = require('baileys');
-      const { useMongoDBAuthState } = require('../utils/mongoAuthConfig');
+      const { useMongoDBAuthState } = require('../config/mongoAuthConfig');
       const pino = require('pino');
       
       const logger = pino({ level: 'warn' });

package/lib/config/awsConfig.js

@@ -0,0 +1,103 @@
+const AWS = require('aws-sdk');
+const fs = require('fs');
+const path = require('path');
+
+AWS.config.update({
+  accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+  secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+  region: 'us-east-1',
+  signatureVersion: 'v4'
+});
+
+const s3 = new AWS.S3();
+
+
+async function uploadBufferToS3(buffer, bucketName, key, contentType, isWhatsAppMedia = false) {
+  const params = {
+    Bucket: bucketName,
+    Key: key,
+    Body: buffer,
+    ContentType: contentType,
+    Metadata: isWhatsAppMedia ? {
+      'x-amz-meta-whatsapp': 'true',
+      'x-amz-meta-expiry': new Date(new Date().getTime() + (7 * 24 * 60 * 60 * 1000)).toISOString() // 7 days expiry
+    } : {}
+  };
+
+  try {
+    const data = await s3.upload(params).promise();
+    console.log(`File uploaded successfully at ${data.Location}`);
+    return data.Location;
+  } catch (error) {
+    console.error(`Error uploading file: ${error.message}`);
+    throw error;
+  }
+}
+
+async function downloadFileFromS3(bucketName, key, downloadPath) {
+  console.log(`[S3] Attempting to download file from S3 - Bucket: ${bucketName}, Key: ${key}`);
+    
+  const headParams = {
+    Bucket: bucketName,
+    Key: key
+  };
+    
+  try {
+    await s3.headObject(headParams).promise();
+    console.log(`[S3] Key exists in bucket: ${key}`);
+  } catch (headErr) {
+    console.error(`[S3] Object check failed - Key: ${key}, Error: ${headErr.code} - ${headErr.message}`);
+    if (headErr.code === 'NotFound') {
+      console.log(`[S3] Key does not exist in bucket: ${key}`);
+    }
+    throw headErr;
+  }
+    
+  const params = {
+    Bucket: bucketName,
+    Key: key
+  };
+
+  try {
+    console.log(`[S3] Downloading file data - Key: ${key}`);
+    const data = await s3.getObject(params).promise();
+    console.log(`[S3] Successfully retrieved file - Key: ${key}, ContentType: ${data.ContentType}, Size: ${data.ContentLength} bytes`);
+        
+    if (downloadPath) {
+      const directory = path.dirname(downloadPath);
+      fs.mkdirSync(directory, { recursive: true });
+      fs.writeFileSync(downloadPath, data.Body);
+      console.log(`[S3] File saved to disk at: ${downloadPath}`);
+      return;
+    }
+        
+    return data;
+  } catch (error) {
+    console.error(`[S3] Error downloading file - Key: ${key}, Error: ${error.code} - ${error.message}`);
+    throw error;
+  }
+}
+
+async function generatePresignedUrl(bucketName, key, expiration = 300) {
+  const params = {
+    Bucket: bucketName,
+    Key: key,
+    Expires: expiration
+  };
+
+  try {
+    const url = s3.getSignedUrlPromise('getObject', params);
+    console.log(`Presigned URL generated: ${url}`);
+    return url;
+  } catch (error) {
+    console.error(`Error generating presigned URL: ${error.message}`);
+    throw error;
+  }
+}
+
+module.exports = {
+  s3,
+  uploadBufferToS3,
+  downloadFileFromS3,
+  generatePresignedUrl
+};

package/lib/config/llmConfig.js

@@ -0,0 +1,4 @@
+// Temporary stub for llmConfig - should be replaced with Nexus LLM provider
+module.exports = {
+  openaiClient: null // This will be replaced with Nexus LLM provider
+};

package/lib/controllers/assistantController.js

@@ -1,30 +1,11 @@
-// Optional config - will be undefined if not available
-let Config_ID;
-try {
-  Config_ID = require('../config/airtableConfig')?.Config_ID;
-} catch (e) {
-  Config_ID = null;
-}
-
-// Optional model imports
-let updateThreadActive, updateThreadStop, Thread;
-try {
-  const threadModel = require('../models/threadModel');
-  updateThreadActive = threadModel.updateThreadActive;
-  updateThreadStop = threadModel.updateThreadStop;
-  Thread = threadModel.Thread;
-} catch (e) {
-  // Models not available
-}
-
-// Optional service imports - stub functions for missing services
-const getRecordByFilter = () => Promise.resolve(null);
-const createAssistant = () => Promise.resolve({ success: false, error: 'Service not available' });
-const addMsgAssistant = () => Promise.resolve({ success: false, error: 'Service not available' });
-const addInsAssistant = () => Promise.resolve({ success: false, error: 'Service not available' });
-const getThreadInfo = () => Promise.resolve(null);
-const switchAssistant = () => Promise.resolve({ success: false, error: 'Service not available' });
-const sendMessage = () => Promise.resolve({ success: false, error: 'Service not available' });
+const { Config_ID } = require('../config/airtableConfig');
+
+const { updateThreadActive, updateThreadStop, Thread } = require('../models/threadModel');
+
+const { getRecordByFilter } = require('../services/airtableService');
+const { createAssistant, addMsgAssistant, addInsAssistant } = require('../services/assistantService');
+const { getThreadInfo, switchAssistant } = require('../services/assistantService');
+const { sendMessage } = require('../core/NexusMessaging');
 
 
 const activeAssistantController = async (req, res) => {
@@ -96,7 +77,7 @@ const createAssistantController = async (req, res) => {
 };
 
 const getInfoAssistantController = async (req, res) => {
-  const { code } = req.query;
+  const { code } = req.body;
 
   try {
     let threadInfo = await getThreadInfo(code);

package/lib/controllers/conversationController.js

@@ -1,7 +1,10 @@
-const { Message } = require('../models/messageModel');
+// Use mongoose models directly to avoid conflicts
+const mongoose = require('mongoose');
 const { fetchConversationData, processConversations } = require('../services/conversationService');
 const { sendMessage } = require('../core/NexusMessaging');  
 
+const Message = mongoose.models.Message;
+
 const getConversationController = async (req, res) => {
   const startTime = Date.now();
   console.log('Starting getConversationController at', new Date().toISOString());
@@ -15,7 +18,15 @@ const getConversationController = async (req, res) => {
 
     console.log(`Pagination: page ${page}, limit ${limit}, skip ${skip}, filter: ${filter}`);
 
-    // Check if messages exist
+    if (!Message) {
+      console.log('Message model not found, returning empty conversations list');
+      return res.status(200).json({
+        success: true,
+        conversations: [],
+        emptyDatabase: true
+      });
+    }
+    
     const messageCount = await Message.countDocuments({});
     console.log('Total message count:', messageCount);
     

package/lib/controllers/templateController.js

@@ -1,23 +1,51 @@
-// Stub functions for missing services
-const TwilioService = {
-  createTemplate: () => Promise.resolve({ success: false, error: 'Service not available' }),
-  deleteTemplate: () => Promise.resolve({ success: false, error: 'Service not available' }),
-  listTemplates: () => Promise.resolve([]),
-  getTemplate: () => Promise.resolve(null)
+// Nexus provider will be injected - templates only work with Twilio
+let nexusProvider = null;
+
+// Configure Nexus provider
+const configureNexusProvider = (provider) => {
+  nexusProvider = provider;
 };
-const handleApiError = (res, error, message) => {
-  console.error(message, error);
-  return res.status(500).json({ success: false, error: message });
+
+// Check if provider supports templates
+const checkTemplateSupport = () => {
+  if (!nexusProvider) {
+    throw new Error('Nexus provider not configured');
+  }
+  
+  // Only Twilio provider supports template operations
+  if (!nexusProvider.listTemplates || typeof nexusProvider.listTemplates !== 'function') {
+    throw new Error('Template operations are only supported with Twilio provider');
+  }
 };
+const mongoose = require('mongoose');
+const { handleApiError } = require('../utils/errorHandler');
 
-// Stub imports for missing dependencies
-const Template = class { constructor() {} };
-const TemplateModel = {
-  create: () => Promise.resolve({ success: false, error: 'Model not available' }),
-  find: () => Promise.resolve([]),
-  findById: () => Promise.resolve(null)
+const { Template } = require('../templates/templateStructure');
+const predefinedTemplates = require('../templates/predefinedTemplates');
+
+// Use mongoose models to avoid conflicts
+const getTemplateModel = () => {
+  if (mongoose.models.Template) {
+    return mongoose.models.Template;
+  }
+  
+  // If not in mongoose.models, require and return the model
+  try {
+    const TemplateModel = require('../models/templateModel');
+    return TemplateModel;
+  } catch (error) {
+    console.error('Failed to load Template model:', error);
+    // Return a stub model with required methods
+    return {
+      deleteMany: () => Promise.resolve({ deletedCount: 0 }),
+      find: () => ({ sort: () => ({ limit: () => ({ lean: () => Promise.resolve([]) }) }) }),
+      findOne: () => Promise.resolve(null),
+      create: () => Promise.resolve({}),
+      updateOne: () => Promise.resolve({}),
+      deleteOne: () => Promise.resolve({})
+    };
+  }
 };
-const predefinedTemplates = [];
 
 /**
  * Create a new template and store it in both Twilio and our database
@@ -109,6 +137,7 @@ const createTemplate = async (req, res) => {
       dateCreated = currentDate;
     }
     
+    const TemplateModel = getTemplateModel();
     const newDbTemplate = await TemplateModel.create({
       sid: twilioContent.sid,
       name: (twilioContent.friendlyName || `template_${twilioContent.sid}`).replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase(),
@@ -152,8 +181,13 @@ const createTemplate = async (req, res) => {
 const listTemplates = async (req, res) => {
   try {
     const { status: queryStatus, type, limit = 50, showFlows: queryShowFlows } = req.query;
+    const TemplateModel = getTemplateModel();
 
-    const twilioRawTemplates = await TwilioService.listTemplates({ limit: parseInt(limit, 10) });
+    console.log('nexusProvider:', nexusProvider ? 'configured' : 'not configured');
+    console.log('nexusProvider methods:', nexusProvider ? Object.keys(nexusProvider) : 'none');
+    
+    checkTemplateSupport();
+    const twilioRawTemplates = await nexusProvider.listTemplates({ limit: parseInt(limit, 10) });
 
     const showFlows = type === 'flow' || queryShowFlows === 'true';
     const filteredTwilioTemplates = twilioRawTemplates.filter(template => {
@@ -176,7 +210,7 @@ const listTemplates = async (req, res) => {
       };
 
       try {
-        const approvalInfo = await TwilioService.checkApprovalStatus(twilioTemplate.sid);
+        const approvalInfo = await nexusProvider.checkApprovalStatus(twilioTemplate.sid);
         if (approvalInfo && approvalInfo.approvalRequest) {
           const reqData = approvalInfo.approvalRequest;
           updateFields.approvalRequest = {
@@ -260,10 +294,12 @@ const getTemplate = async (req, res) => {
   try {
     const { id } = req.params;
     
+    const TemplateModel = getTemplateModel();
     let template = await TemplateModel.findOne({ sid: id });
     let twilioTemplate;
     
-    twilioTemplate = await TwilioService.getTemplate(id);
+    checkTemplateSupport();
+    twilioTemplate = await nexusProvider.getTemplate(id);
     
     if (!template) {
       // If template wasn't in our database, create it based on Twilio data
@@ -345,7 +381,8 @@ const submitForApproval = async (req, res) => {
     const approvalName = `${name || 'template'}_${timestamp}_${randomSuffix}`.toLowerCase().replace(/[^a-z0-9_]/g, '_');
     const approvalCategory = category || 'UTILITY';
     
-    const response = await TwilioService.submitForApproval(contentSid, approvalName, approvalCategory);
+    checkTemplateSupport();
+    const response = await nexusProvider.submitForApproval(contentSid, approvalName, approvalCategory);
     
     const dateCreated = response.date_created || response.dateCreated;
     const dateUpdated = response.date_updated || response.dateUpdated || dateCreated;
@@ -356,6 +393,7 @@ const submitForApproval = async (req, res) => {
     const validSubmittedDate = !isNaN(submittedDate.getTime()) ? submittedDate : new Date();
     const validUpdatedDate = !isNaN(updatedDate.getTime()) ? updatedDate : new Date();
     
+    const TemplateModel = getTemplateModel();
     await TemplateModel.updateOne(
       { sid: contentSid },
       { 
@@ -397,10 +435,12 @@ const checkApprovalStatus = async (req, res) => {
       return res.status(400).json({ success: false, error: 'Content SID is required' });
     }
     
+    const TemplateModel = getTemplateModel();
     const dbTemplate = await TemplateModel.findOne({ sid: contentSid });
     
     try {
-      const status = await TwilioService.checkApprovalStatus(contentSid);
+      checkTemplateSupport();
+      const status = await nexusProvider.checkApprovalStatus(contentSid);
       
       if (dbTemplate) {
         // Use approval status as the authoritative source if available
@@ -475,8 +515,10 @@ const deleteTemplate = async (req, res) => {
   try {
     const { id } = req.params;
     
-    await TwilioService.deleteTemplate(id);
+    checkTemplateSupport();
+    await nexusProvider.deleteTemplate(id);
     
+    const TemplateModel = getTemplateModel();
     await TemplateModel.deleteOne({ sid: id });
     
     return res.json({
@@ -529,6 +571,7 @@ const getCompleteTemplate = async (req, res) => {
   try {
     const { sid } = req.params;
     
+    const TemplateModel = getTemplateModel();
     let template = await TemplateModel.findOne({ sid }).lean();
     
     if (!template) {
@@ -540,7 +583,8 @@ const getCompleteTemplate = async (req, res) => {
     
     if (!template.body || !template.variables || template.variables.length === 0) {
       try {
-        const twilioTemplate = await TwilioService.getTemplate(sid);
+        checkTemplateSupport();
+        const twilioTemplate = await nexusProvider.getTemplate(sid);
         console.log('Fetched template from Twilio:', twilioTemplate);
         
         let body = '';
@@ -603,6 +647,7 @@ const getCompleteTemplate = async (req, res) => {
             updateData.actions = template.actions;
           }
           
+          const TemplateModel = getTemplateModel();
           await TemplateModel.updateOne(
             { sid },
             { $set: updateData }
@@ -628,15 +673,6 @@ const getCompleteTemplate = async (req, res) => {
   }
 };
 
-// Flow functions (inline since templateFlowController was removed)
-const createFlow = async (req, res) => {
-  return res.status(501).json({ success: false, error: 'Flow creation not available' });
-};
-
-const deleteFlow = async (req, res) => {
-  return res.status(501).json({ success: false, error: 'Flow deletion not available' });
-};
-
 module.exports = {
   createTemplate,
   listTemplates,
@@ -646,6 +682,5 @@ module.exports = {
   checkApprovalStatus,
   deleteTemplate,
   getCompleteTemplate,
-  createFlow,
-  deleteFlow
+  configureNexusProvider
 };

package/lib/controllers/templateFlowController.js

@@ -0,0 +1,108 @@
+// Nexus provider will be injected
+let nexusProvider = null;
+
+// Configure Nexus provider
+const configureNexusProvider = (provider) => {
+  nexusProvider = provider;
+};
+
+// Check if provider supports templates
+const checkTemplateSupport = () => {
+  if (!nexusProvider) {
+    throw new Error('Nexus provider not configured. Call configureNexusProvider() first.');
+  }
+  
+  if (!nexusProvider.createTemplate || typeof nexusProvider.createTemplate !== 'function') {
+    throw new Error('Template operations are only supported with Twilio provider');
+  }
+};
+const { handleApiError } = require('../utils/errorHandler');
+
+
+const createFlow = async (req, res) => {
+  try {
+    const { friendlyName, language, flowType, body, buttonText, subtitle, pages } = req.body;
+
+    const missingParams = [];
+    if (!friendlyName) missingParams.push('friendlyName');
+    if (!language) missingParams.push('language');
+    if (!pages || !Array.isArray(pages)) missingParams.push('pages');
+        
+    if (missingParams.length > 0) {
+      return res.status(400).json({
+        success: false,
+        error: `Missing required parameters: ${missingParams.join(', ')}`
+      });
+    }
+
+    // Generate unique identifiers for anti-rejection
+    const timestamp = Date.now().toString();
+    const uniqueId = require('uuid').v4().substring(0, 6);
+    const uniqueFriendlyName = `${friendlyName}_${timestamp}_${uniqueId}`;
+
+    // Match Twilio's expected structure for flex templates
+    checkTemplateSupport();
+    const content = await nexusProvider.createTemplate({
+      friendly_name: uniqueFriendlyName,
+      language,
+      categories: ['UTILITY'],
+      types: {
+        'twilio/flows': {
+          body: body,
+          button_text: buttonText,
+          subtitle: subtitle || null,
+          pages: pages,
+          type: flowType
+        }
+      }
+    });
+
+    return res.status(201).json({
+      success: true,
+      message: 'Flow template created successfully',
+      contentSid: content.sid,
+      friendlyName: content.friendly_name,
+      approvalStatus: 'Pending review',
+      approvalLinks: content.links
+    });
+  } catch (error) {
+    return handleApiError(res, error, 'Error creating WhatsApp flow template');
+  }
+};
+
+
+const deleteFlow = async (req, res) => {
+  try {
+    const { sid: contentSid } = req.params;
+        
+    if (!contentSid) {
+      return res.status(400).json({
+        success: false,
+        error: 'Content SID is required'
+      });
+    }
+
+    checkTemplateSupport();
+    await nexusProvider.deleteTemplate(contentSid);
+
+    return res.status(200).json({
+      success: true,
+      message: 'Template deleted successfully'
+    });
+  } catch (error) {
+    if (error.code === 20404) {
+      return res.status(404).json({
+        success: false,
+        error: 'Template not found'
+      });
+    }
+        
+    return handleApiError(res, error, 'Error deleting template');
+  }
+};
+
+module.exports = {
+  createFlow,
+  deleteFlow,
+  configureNexusProvider
+};

package/lib/controllers/uploadController.js

@@ -0,0 +1,82 @@
+const multer = require('multer');
+const { v4: uuidv4 } = require('uuid');
+const { generatePresignedUrl, uploadBufferToS3 } = require('../config/awsConfig');
+const bucketName = process.env.AWS_S3_BUCKET_NAME;
+
+const storage = multer.memoryStorage();
+
+const fileFilter = (req, file, cb) => {
+  if (file.mimetype.startsWith('image/') || 
+        file.mimetype.startsWith('application/') || 
+        file.mimetype.startsWith('audio/') ||
+        file.mimetype.startsWith('video/')) {
+    cb(null, true);
+  } else {
+    cb(new Error('Unsupported file type'), false);
+  }
+};
+
+const upload = multer({ 
+  storage: storage,
+  fileFilter: fileFilter,
+  limits: {
+    fileSize: 50 * 1024 * 1024, // Increased to 50MB
+  }
+});
+
+const handleFileUpload = async (req, res) => {
+  try {
+    if (!req.file) {
+      return res.status(400).json({
+        success: false,
+        error: 'No file provided'
+      });
+    }
+
+    const file = req.file;
+        
+    let filePrefix = 'document';
+    if (file.mimetype.startsWith('image/')) {
+      filePrefix = 'image';
+    } else if (file.mimetype.startsWith('video/')) {
+      filePrefix = 'video';
+    } else if (file.mimetype.startsWith('audio/')) {
+      filePrefix = 'audio';
+    }
+        
+    const uniqueId = uuidv4();
+    const originalFileName = file.originalname;
+    const sanitizedFileName = file.originalname.replace(/[^a-zA-Z0-9.]/g, '_').replace('.pdf', '');
+        
+    const key = `${filePrefix}/${sanitizedFileName}_${uniqueId}`;
+
+    await uploadBufferToS3(file.buffer, bucketName, key, file.mimetype, true);
+    const whatsappExpirationSeconds = 7 * 24 * 60 * 60;
+    const presignedUrl = await generatePresignedUrl(bucketName, key, whatsappExpirationSeconds);
+        
+    res.status(200).json({
+      success: true,
+      message: 'File uploaded successfully',
+      fileUrl: presignedUrl,
+      key: key,
+      fileType: filePrefix,
+      fileName: originalFileName,
+      sanitizedFileName: sanitizedFileName,
+      fileSize: file.size,
+      contentType: file.mimetype
+    });
+  } catch (error) {
+    console.error('Error uploading file:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to upload file'
+    });
+  }
+};
+
+const uploadSingleFile = upload.single('file');
+
+module.exports = {
+  uploadSingleFile,
+  handleFileUpload
+};

package/lib/core/NexusMessaging.js

@@ -325,4 +325,18 @@ class NexusMessaging {
   }
 }
 
-module.exports = { NexusMessaging };
+const defaultInstance = new NexusMessaging();
+
+const sendMessage = async (messageData) => {
+  return await defaultInstance.sendMessage(messageData);
+};
+
+const sendScheduledMessage = async (scheduledMessage) => {
+  return await defaultInstance.sendScheduledMessage(scheduledMessage);
+};
+
+module.exports = { 
+  NexusMessaging,
+  sendMessage,
+  sendScheduledMessage
+};