@peopl-health/nexus 1.1.6 → 1.1.8

package/lib/adapters/TwilioProvider.js

@@ -113,6 +113,25 @@ class TwilioProvider extends MessageProvider {
     const targetTime = new Date(sendTime);
     return Math.max(0, targetTime.getTime() - now.getTime());
   }
+
+  /**
+   * List templates from Twilio Content API
+   * @param {Object} options - Query options
+   * @returns {Promise<Array>} Array of templates
+   */
+  async listTemplates(options = {}) {
+    if (!this.isConnected || !this.twilioClient) {
+      throw new Error('Twilio provider not initialized');
+    }
+
+    try {
+      const { limit = 50 } = options;
+      const templates = await this.twilioClient.content.v1.contents.list({ limit });
+      return templates;
+    } catch (error) {
+      throw new Error(`Failed to list templates: ${error.message}`);
+    }
+  }
 }
 
 module.exports = { TwilioProvider };

package/lib/config/llmConfig.js

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

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/index.js

@@ -2,15 +2,8 @@ const { NexusMessaging } = require('./core/NexusMessaging');
 const { TwilioProvider } = require('./adapters/TwilioProvider');
 const { BaileysProvider } = require('./adapters/BaileysProvider');
 const { MongoStorage } = require('./storage/MongoStorage');
-const { MessageParser } = require('./utils/MessageParser');
-const { DefaultLLMProvider } = require('./utils/DefaultLLMProvider');
-
-// Export individual components
-const adapters = require('./adapters');
-const core = require('./core');
-const storage = require('./storage');
-const utils = require('./utils');
-const models = require('./models');
+const { MessageParser } = require('./utils/messageParser');
+const { DefaultLLMProvider } = require('./utils/defaultLLMProvider');
 
 /**
  * Main Nexus class that orchestrates all components

package/lib/models/templateModel.js

@@ -0,0 +1,72 @@
+const mongoose = require('mongoose');
+
+const TemplateSchema = new mongoose.Schema({
+  sid: {
+    type: String,
+    required: true,
+    unique: true
+  },
+  name: {
+    type: String,
+    required: true
+  },
+  friendlyName: String,
+  category: {
+    type: String,
+    default: 'UTILITY',
+    enum: ['UTILITY', 'MARKETING', 'AUTHENTICATION']
+  },
+  language: {
+    type: String,
+    default: 'es'
+  },
+  status: {
+    type: String,
+    default: 'DRAFT',
+    enum: ['DRAFT', 'PENDING', 'APPROVED', 'REJECTED', 'UNKNOWN']
+  },
+  body: String,
+  footer: String,
+  variables: [
+    {
+      name: String,
+      description: String,
+      example: String
+    }
+  ],
+  buttons: [
+    {
+      type: {
+        type: String,
+        enum: ['quick_reply', 'url']
+      },
+      text: String,
+      url: String
+    }
+  ],
+  approvalRequest: {
+    sid: String,
+    status: String,
+    dateSubmitted: Date,
+    dateUpdated: Date,
+    rejectionReason: String
+  },
+  dateCreated: {
+    type: Date,
+    default: Date.now
+  },
+  lastUpdated: {
+    type: Date,
+    default: Date.now
+  }
+});
+
+// Pre-save middleware to update lastUpdated
+TemplateSchema.pre('save', function(next) {
+  this.lastUpdated = new Date();
+  next();
+});
+
+const Template = mongoose.model('Template', TemplateSchema);
+
+module.exports = Template;

package/lib/routes/index.js

@@ -70,6 +70,8 @@ const conversationController = require('../controllers/conversationController');
 const mediaController = require('../controllers/mediaController');
 const messageController = require('../controllers/messageController');
 const templateController = require('../controllers/templateController');
+const templateFlowController = require('../controllers/templateFlowController');
+const uploadController = require('../controllers/uploadController');
 
 // Built-in controllers mapping
 const builtInControllers = {
@@ -95,7 +97,7 @@ const builtInControllers = {
   
   // Media controllers
   getMediaController: mediaController.getMediaController,
-  handleFileUpload: mediaController.handleFileUpload,
+  handleFileUpload: uploadController.handleFileUpload,
   
   // Message controllers
   sendMessageController: messageController.sendMessageController,
@@ -108,8 +110,8 @@ const builtInControllers = {
   getPredefinedTemplates: templateController.getPredefinedTemplates,
   getTemplate: templateController.getTemplate,
   getCompleteTemplate: templateController.getCompleteTemplate,
-  createFlow: templateController.createFlow,
-  deleteFlow: templateController.deleteFlow,
+  createFlow: templateFlowController.createFlow,
+  deleteFlow: templateFlowController.deleteFlow,
   submitForApproval: templateController.submitForApproval,
   checkApprovalStatus: templateController.checkApprovalStatus,
   deleteTemplate: templateController.deleteTemplate

package/lib/services/twilioService.js

@@ -0,0 +1,56 @@
+// TwilioService that connects to Nexus Twilio provider
+let nexusProvider = null;
+
+// Configure the Nexus provider
+const configureNexusProvider = (provider) => {
+  nexusProvider = provider;
+};
+
+// Check if provider is configured and supports Twilio operations
+const checkTwilioSupport = () => {
+  if (!nexusProvider) {
+    throw new Error('Nexus provider not configured. Call configureNexusProvider() first.');
+  }
+  
+  if (!nexusProvider.listTemplates || typeof nexusProvider.listTemplates !== 'function') {
+    throw new Error('Twilio operations are only supported with Twilio provider');
+  }
+};
+
+// TwilioService wrapper that delegates to Nexus provider
+const TwilioService = {
+  async listTemplates(options = {}) {
+    checkTwilioSupport();
+    return await nexusProvider.listTemplates(options);
+  },
+
+  async getTemplate(sid) {
+    checkTwilioSupport();
+    return await nexusProvider.getTemplate(sid);
+  },
+
+  async checkApprovalStatus(sid) {
+    checkTwilioSupport();
+    return await nexusProvider.checkApprovalStatus(sid);
+  },
+
+  async submitForApproval(contentSid, name, category) {
+    checkTwilioSupport();
+    return await nexusProvider.submitForApproval(contentSid, name, category);
+  },
+
+  async deleteTemplate(sid) {
+    checkTwilioSupport();
+    return await nexusProvider.deleteTemplate(sid);
+  },
+
+  async createTemplate(templateData) {
+    checkTwilioSupport();
+    return await nexusProvider.createTemplate(templateData);
+  },
+
+  // Add any other Twilio operations as needed
+  configureNexusProvider
+};
+
+module.exports = TwilioService;

package/lib/templates/predefinedTemplates.js

@@ -0,0 +1,81 @@
+const { Template } = require('./templateStructure');
+
+const predefinedTemplates = {
+  citaDrLimon: () => {
+    const template = new Template('cita_dr_limon', 'UTILITY', 'es');
+        
+    const patientVars = [
+      {
+        name: 'Nombre del paciente',
+        description: 'Nombre completo del paciente',
+        example: 'Juan Pérez'
+      },
+      {
+        name: 'Fecha de la cita',
+        description: 'Fecha en formato DD/MM',
+        example: '18/05'
+      },
+      {
+        name: 'Hora de la cita',
+        description: 'Hora en formato HH:MM am/pm',
+        example: '9:30 am'
+      }
+    ];
+        
+    template.addBodyVariation(
+      'Hola buenos días {{1}}, \n\nSoy Briggite del equipo del Dr Limón \n\n📆 Tienes programado una cita con el dr Limón para mañana {{2}} a las {{3}}\n\n✅ Confirma tu asistencia por favor',
+      patientVars
+    );
+        
+    template.addBodyVariation(
+      'Hola {{1}}, buenos días\n\nLe saluda Briggite del equipo médico del Dr Limón\n\n📆 Su cita con el Dr Limón está programada para mañana {{2}} a las {{3}}\n\n✅ Por favor confirme su asistencia',
+      patientVars
+    );
+        
+    template.addBodyVariation(
+      'Buenos días {{1}}\n\nSoy Briggite, asistente del Dr Limón\n\n📆 Le recordamos su cita para mañana {{2}} a las {{3}} con el Dr Limón\n\n✅ Agradecemos su confirmación',
+      patientVars
+    );
+        
+    template.setBody('Hola buenos días {{1}}, \n\nSoy Briggite del equipo del Dr Limón \n\n📆 Tienes programado una cita con el dr Limón para mañana {{2}} a las {{3}}\n\n✅ Confirma tu asistencia por favor', 
+      patientVars);
+                 
+    return template;
+  },
+    
+  seguimientoDrLimon: () => {
+    const template = new Template('seguimiento_dr_limon', 'UTILITY', 'es');
+        
+    const followUpVars = [
+      {
+        name: 'Nombre del paciente',
+        description: 'Nombre completo del paciente',
+        example: 'Carmen Rodríguez'
+      }
+    ];
+        
+    template.addBodyVariation(
+      'Hola {{1}} buenos días ¿cómo han amanecido? ¿cómo les fue con las recomendaciones?',
+      followUpVars
+    );
+        
+    template.addBodyVariation(
+      'Buenos días {{1}}, ¿cómo se encuentra hoy? ¿ha podido seguir las recomendaciones médicas?',
+      followUpVars
+    );
+        
+    template.addBodyVariation(
+      'Hola {{1}}, buenos días. Seguimiento médico: ¿cómo se ha sentido? ¿pudo implementar las recomendaciones indicadas?',
+      followUpVars
+    );
+        
+    template.setBody('Hola {{1}} buenos días ¿cómo han amanecido? ¿cómo les fue con las recomendaciones?', 
+      followUpVars);
+                 
+    return template;
+  }
+};
+
+module.exports = {
+  predefinedTemplates
+};

package/lib/templates/templateStructure.js

@@ -0,0 +1,204 @@
+const { v4: uuidv4 } = require('uuid');
+
+// 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');
+  }
+};
+
+class Template {
+  constructor(name, category = 'UTILITY', language = 'es') {
+    this.name = name;
+    this.category = category.toUpperCase();
+    this.language = language;
+    this.components = {
+      header: [],
+      body: [],
+      footer: [],
+      buttons: []
+    };
+    this.variables = [];
+        
+    const timestamp = Date.now().toString();
+    const uniqueId = uuidv4().substring(0, 6);
+    this.friendlyName = `${name}_${timestamp}_${uniqueId}`;
+    this.templateName = `${name}_${Date.now().toString().substring(0, 10)}`;
+    this.approvalName = this.name || `template_${name}_${Math.floor(Math.random() * 1000)}`;
+    this.status = 'DRAFT';
+        
+    this.variations = [];
+  }
+
+  addBodyVariation(text, variableDescriptions = []) {
+    this.variations.push({
+      text: text,
+      variables: variableDescriptions
+    });
+    return this;
+  }
+    
+  setBody(text, variableDescriptions = []) {
+    this.addBodyVariation(text, variableDescriptions);
+        
+    const selectedVariation = this.variations.length > 1 ?
+      this.variations[Math.floor(Math.random() * this.variations.length)] :
+      { text, variables: variableDescriptions };
+        
+    const enhancedText = `${selectedVariation.text}`;
+        
+    const processedVariables = selectedVariation.variables.map((desc, i) => {
+      if (typeof desc === 'string') {
+        return {
+          name: `var_${i + 1}`,
+          description: desc,
+          example: `Ejemplo ${i + 1}`
+        };
+      }
+      return {
+        name: desc.name || `var_${i + 1}`,
+        description: desc.description || `Variable ${i + 1}`,
+        example: desc.example || `Ejemplo ${i + 1}`
+      };
+    });
+        
+    this.components.body = [{
+      type: 'BODY',
+      text: enhancedText,
+      example: {
+        body_text: processedVariables.map(v => v.example)
+      }
+    }];
+        
+    this.variables = processedVariables;
+        
+    return this;
+  }
+
+  addQuickReply(text) {
+    if (this.components.buttons.length >= 3) {
+      throw new Error('Maximum of 3 buttons allowed');
+    }
+    this.components.buttons.push({
+      type: 'QUICK_REPLY',
+      text: text
+    });
+    return this;
+  }
+
+  addCallToAction(text, url) {
+    if (this.components.buttons.length >= 3) {
+      throw new Error('Maximum of 3 buttons allowed');
+    }
+    this.components.buttons.push({
+      type: 'URL',
+      text: text,
+      url: url
+    });
+    return this;
+  }
+
+  setFooter(text) {
+    if (text.length > 60) {
+      throw new Error('Footer text must be 60 characters or less');
+    }
+    this.components.footer = [{
+      type: 'FOOTER',
+      text: text
+    }];
+    return this;
+  }
+
+  generateTemplateName(baseName) {
+    const timestamp = new Date().toISOString().replace(/[^0-9]/g, '').slice(-8);
+    return `${baseName}_${timestamp}`.toUpperCase();
+  }
+
+  validate() {
+    if (!this.components.body || !this.components.body[0]?.text) {
+      throw new Error('Template body is required');
+    }
+        
+    const varMatches = this.components.body[0].text.match(/\{\{\d+\}\}/g) || [];
+    const varCount = new Set(varMatches.map(m => m.match(/\d+/)[0])).size;
+        
+    if (varCount !== this.variables.length) {
+      throw new Error(`Mismatch between variable placeholders (${varCount}) and variable definitions (${this.variables.length})`);
+    }
+        
+    return true;
+  }
+
+  toTwilioFormat() {
+    this.validate();
+        
+    const variables = {};
+    this.variables.forEach((variable, i) => {
+      variables[`${i + 1}`] = variable.example;
+    });
+        
+    const template = {
+      friendly_name: this.friendlyName,
+      language: this.language,
+      variables: variables,
+      types: {
+        'twilio/text': {
+          body: this.components.body[0].text
+        }
+      }
+    };
+        
+    if (this.category) {
+      template.categories = [this.category];
+    }
+        
+    if (this.components.buttons && this.components.buttons.length > 0) {
+      const actions = this.components.buttons.map((button, index) => {
+        return {
+          title: button.text,
+          id: `button_${index + 1}`
+        };
+      });
+            
+      template.types['twilio/quick-reply'] = {
+        body: this.components.body[0].text,
+        actions: actions
+      };
+    }
+        
+    if (this.components.footer && this.components.footer.length > 0) {
+      const textTypes = ['twilio/text', 'twilio/quick-reply'];
+      textTypes.forEach(type => {
+        if (template.types[type]) {
+          template.types[type].footer = this.components.footer[0].text;
+        }
+      });
+    }
+        
+    return template;
+  }
+    
+  async save() {
+    checkTemplateSupport();
+    const twilioFormat = this.toTwilioFormat();
+    const createdTemplate = await nexusProvider.createTemplate(twilioFormat);
+    return createdTemplate;
+  }
+}
+
+module.exports = {
+  Template,
+  configureNexusProvider
+};

package/lib/utils/dateUtils.js

@@ -0,0 +1,26 @@
+const moment = require('moment-timezone');
+
+const ISO_DATE = 'YYYY-MM-DD';
+
+const parseStartTime = (startTime) => {
+  return moment(startTime);
+};
+
+const addDays = (date, days) => {
+  return moment(date).add(days, 'days');
+};
+
+const dateAndTimeFromStart = (startTime) => {
+  const momentTime = moment(startTime);
+  return {
+    date: momentTime.format(ISO_DATE),
+    time: momentTime.format('HH:mm')
+  };
+};
+
+module.exports = {
+  ISO_DATE,
+  parseStartTime,
+  addDays,
+  dateAndTimeFromStart
+};

package/lib/utils/errorHandler.js

@@ -0,0 +1,8 @@
+const handleApiError = (res, error, message) => {
+  console.error(message, error);
+  return res.status(500).json({ success: false, error: message });
+};
+
+module.exports = {
+  handleApiError
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "publishConfig": {
     "access": "public"
@@ -56,6 +56,7 @@
     "dotenv": "^16.4.7",
     "moment-timezone": "^0.5.43",
     "mongoose": "^7.5.0",
+    "multer": "1.4.5-lts.1",
     "pdf-lib": "1.17.1",
     "pino": "^8.15.0",
     "pino-pretty": "^10.2.0",

package/lib/utils/AssistantManager.js

@@ -1,218 +0,0 @@
-/**
- * Configurable assistant manager for handling AI interactions
- */
-class AssistantManager {
-  constructor(config = {}) {
-    this.config = config;
-    this.assistants = new Map();
-    this.llmClient = null;
-    this.handlers = {
-      onRequiresAction: null,
-      onCompleted: null,
-      onFailed: null
-    };
-  }
-
-  /**
-   * Initialize with LLM client (OpenAI, etc.)
-   * @param {Object} llmClient - LLM client instance
-   */
-  setLLMClient(llmClient) {
-    this.llmClient = llmClient;
-  }
-
-  /**
-   * Register assistant configurations
-   * @param {Object} assistantConfigs - Map of assistant IDs to configurations
-   */
-  registerAssistants(assistantConfigs) {
-    Object.entries(assistantConfigs).forEach(([key, config]) => {
-      this.assistants.set(key, config);
-    });
-  }
-
-  /**
-   * Set event handlers for assistant interactions
-   * @param {Object} handlers - Handler functions
-   */
-  setHandlers(handlers) {
-    this.handlers = { ...this.handlers, ...handlers };
-  }
-
-  /**
-   * Create a new thread for a conversation
-   * @param {string} code - User/conversation identifier
-   * @param {string} assistantId - Assistant ID to use
-   * @param {Array} initialMessages - Initial messages for context
-   */
-  async createThread(code, assistantId, initialMessages = []) {
-    if (!this.llmClient) {
-      throw new Error('LLM client not configured');
-    }
-
-    try {
-      const thread = await this.llmClient.beta.threads.create();
-      
-      // Add initial messages if provided
-      for (const message of initialMessages) {
-        await this.llmClient.beta.threads.messages.create(
-          thread.id, 
-          { role: 'assistant', content: message }
-        );
-      }
-
-      return {
-        code,
-        assistantId,
-        threadId: thread.id,
-        active: true,
-        createdAt: new Date()
-      };
-    } catch (error) {
-      throw new Error(`Failed to create thread: ${error.message}`);
-    }
-  }
-
-  /**
-   * Send message to assistant and get response
-   * @param {Object} threadData - Thread information
-   * @param {string} message - User message
-   * @param {Object} runOptions - Additional run options
-   */
-  async sendMessage(threadData, message, runOptions = {}) {
-    if (!this.llmClient) {
-      throw new Error('LLM client not configured');
-    }
-
-    try {
-      // Add user message to thread
-      await this.llmClient.beta.threads.messages.create(
-        threadData.threadId,
-        { role: 'user', content: message }
-      );
-
-      // Create run
-      const run = await this.llmClient.beta.threads.runs.create(
-        threadData.threadId,
-        {
-          assistant_id: threadData.assistantId,
-          ...runOptions
-        }
-      );
-
-      // Wait for completion and handle actions
-      const result = await this.waitForCompletion(threadData.threadId, run.id);
-      
-      if (result.status === 'completed') {
-        const messages = await this.llmClient.beta.threads.messages.list(
-          threadData.threadId, 
-          { run_id: run.id }
-        );
-        return messages.data[0]?.content[0]?.text?.value || '';
-      } else if (result.status === 'requires_action') {
-        if (this.handlers.onRequiresAction) {
-          return await this.handlers.onRequiresAction(result, threadData);
-        }
-      }
-
-      return null;
-    } catch (error) {
-      throw new Error(`Assistant interaction failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Wait for run completion and handle different statuses
-   * @param {string} threadId - Thread ID
-   * @param {string} runId - Run ID
-   */
-  async waitForCompletion(threadId, runId) {
-    const maxAttempts = 30;
-    let attempts = 0;
-
-    while (attempts < maxAttempts) {
-      const run = await this.llmClient.beta.threads.runs.retrieve(threadId, runId);
-      
-      if (run.status === 'completed') {
-        return { status: 'completed', run };
-      } else if (run.status === 'requires_action') {
-        return { status: 'requires_action', run };
-      } else if (run.status === 'failed' || run.status === 'cancelled' || run.status === 'expired') {
-        if (this.handlers.onFailed) {
-          await this.handlers.onFailed(run);
-        }
-        return { status: 'failed', run };
-      }
-
-      // Wait before next check
-      await new Promise(resolve => setTimeout(resolve, 2000));
-      attempts++;
-    }
-
-    throw new Error('Assistant run timeout');
-  }
-
-  /**
-   * Submit tool outputs for function calls
-   * @param {string} threadId - Thread ID
-   * @param {string} runId - Run ID
-   * @param {Array} toolOutputs - Tool outputs array
-   */
-  async submitToolOutputs(threadId, runId, toolOutputs) {
-    if (!this.llmClient) {
-      throw new Error('LLM client not configured');
-    }
-
-    try {
-      const run = await this.llmClient.beta.threads.runs.submitToolOutputs(
-        threadId,
-        runId,
-        { tool_outputs: toolOutputs }
-      );
-
-      return await this.waitForCompletion(threadId, run.id);
-    } catch (error) {
-      throw new Error(`Failed to submit tool outputs: ${error.message}`);
-    }
-  }
-
-  /**
-   * Add instruction to existing thread
-   * @param {Object} threadData - Thread information
-   * @param {string} instruction - Additional instruction
-   */
-  async addInstruction(threadData, instruction) {
-    if (!this.llmClient) {
-      throw new Error('LLM client not configured');
-    }
-
-    try {
-      const run = await this.llmClient.beta.threads.runs.create(
-        threadData.threadId,
-        {
-          assistant_id: threadData.assistantId,
-          additional_instructions: instruction,
-          additional_messages: [
-            { role: 'user', content: instruction }
-          ]
-        }
-      );
-
-      const result = await this.waitForCompletion(threadData.threadId, run.id);
-      
-      if (result.status === 'completed') {
-        const messages = await this.llmClient.beta.threads.messages.list(
-          threadData.threadId, 
-          { run_id: run.id }
-        );
-        return messages.data[0]?.content[0]?.text?.value || '';
-      }
-
-      return null;
-    } catch (error) {
-      throw new Error(`Failed to add instruction: ${error.message}`);
-    }
-  }
-}
-
-module.exports = { AssistantManager };