@peopl-health/nexus 1.0.3 → 1.1.0

package/lib/controllers/templateController.js

@@ -0,0 +1,631 @@
+const TwilioService = require('../services/twilioService');
+const { handleApiError } = require('../utils/errorHandler');
+
+// Import flow functions from templateFlowController
+const { createFlow, deleteFlow } = require('./templateFlowController');
+const { Template } = require('../templates/templateStructure');
+const TemplateModel = require('../models/templateModel');
+const predefinedTemplates = require('../templates/predefinedTemplates');
+
+/**
+ * Create a new template and store it in both Twilio and our database
+ */
+const createTemplate = async (req, res) => {
+  try {
+    const { name, category, language, body, variables, footer, buttons, templateId } = req.body;
+    
+    let template;
+    
+    // Handle predefined templates if a templateId is provided
+    if (templateId) {
+      const templateFn = predefinedTemplates[templateId];
+      if (!templateFn) {
+        return res.status(404).json({
+          success: false,
+          error: `Predefined template ${templateId} not found`
+        });
+      }
+      template = templateFn();
+    } else {
+      // Validate required fields
+      if (!name || !language) {
+        return res.status(400).json({
+          success: false,
+          error: 'Name and language are required for creating a template'
+        });
+      }
+
+      // Create a new template
+      const timestamp = Date.now().toString().substring(0, 10);
+      const templateName = `${name}_${timestamp}`;
+      template = new Template(templateName, category, language);
+      
+      if (!body) return res.status(400).json({ success: false, error: 'Template body is required' });
+      
+      template.setBody(body, variables);
+      if (footer) template.setFooter(footer);
+      
+      if (buttons && Array.isArray(buttons)) {
+        buttons.forEach(button => {
+          if (button.type === 'quick_reply') template.addQuickReply(button.text);
+          else if (button.type === 'url') template.addCallToAction(button.text, button.url);
+        });
+      }
+    }
+    
+    // Save to Twilio
+    const twilioContent = await template.save();
+    
+    // Save to our database
+    let processedVariables = [];
+    
+    // Handle variables - can be array or object format
+    if (variables) {
+      if (Array.isArray(variables)) {
+        // Handle array format
+        processedVariables = variables.map((variable, index) => {
+          if (typeof variable === 'string') {
+            return {
+              name: `var_${index + 1}`,
+              description: variable,
+              example: `Example ${index + 1}`
+            };
+          }
+          return variable;
+        });
+      } else if (typeof variables === 'object') {
+        // Handle object format with keys as variable placeholders
+        processedVariables = Object.entries(variables).map(([key, value]) => {
+          return {
+            name: `var_${key}`,
+            description: value,
+            example: `Example ${key}`
+          };
+        });
+      }
+    }
+    
+    // CRITICAL FIX: Save the new template to the local MongoDB
+    // Ensure we have valid dates for created and updated
+    const currentDate = new Date();
+    let dateCreated = twilioContent.dateCreated ? new Date(twilioContent.dateCreated) : currentDate;
+    const lastUpdated = currentDate;
+    
+    // Make sure the dates are valid before saving
+    if (isNaN(dateCreated.getTime())) {
+      console.log('Invalid dateCreated, using current date');
+      dateCreated = currentDate;
+    }
+    
+    const newDbTemplate = await TemplateModel.create({
+      sid: twilioContent.sid,
+      name: (twilioContent.friendlyName || `template_${twilioContent.sid}`).replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase(),
+      friendlyName: twilioContent.friendlyName,
+      category: category || 'UTILITY', // Use category from request, default if not provided
+      language: language, // Use language from request
+      status: twilioContent.status,
+      body: body, // Use body from request
+      footer: footer, // Use footer from request
+      variables: processedVariables, // Use processed variables from request
+      components: twilioContent.components || [], // Assuming components might come from Twilio response or be empty
+      dateCreated: dateCreated,
+      lastUpdated: lastUpdated
+    });
+
+    return res.status(201).json({
+      success: true,
+      message: 'Template created successfully',
+      template: {
+        id: newDbTemplate.sid, // Use newDbTemplate fields for response consistency
+        sid: newDbTemplate.sid,
+        friendlyName: newDbTemplate.friendlyName,
+        name: newDbTemplate.name, // This was original 'name', should be consistent with DB name
+        status: newDbTemplate.status,
+        variables: newDbTemplate.variables,
+        body: newDbTemplate.body,
+        footer: newDbTemplate.footer,
+        category: newDbTemplate.category,
+        language: newDbTemplate.language,
+        components: newDbTemplate.components
+      }
+    });
+  } catch (error) {
+    return handleApiError(res, error, 'Failed to create template');
+  }
+};
+
+/**
+ * List all templates from both Twilio and our database
+ */
+const listTemplates = async (req, res) => {
+  try {
+    const { status: queryStatus, type, limit = 50, showFlows: queryShowFlows } = req.query;
+
+    const twilioRawTemplates = await TwilioService.listTemplates({ limit: parseInt(limit, 10) });
+
+    const showFlows = type === 'flow' || queryShowFlows === 'true';
+    const filteredTwilioTemplates = twilioRawTemplates.filter(template => {
+      const isFlow = template.types && template.types['twilio/flex'];
+      const statusMatch = queryStatus ? template.status === queryStatus : true;
+      return (showFlows || !isFlow) && statusMatch;
+    });
+
+    const validTwilioSids = filteredTwilioTemplates.map(t => t.sid);
+
+    await TemplateModel.deleteMany({ sid: { $nin: validTwilioSids } });
+
+    for (const twilioTemplate of filteredTwilioTemplates) {
+      const updateFields = {
+        friendlyName: twilioTemplate.friendlyName,
+        category: twilioTemplate.types?.['twilio/text']?.categories?.[0] || 'UTILITY',
+        language: twilioTemplate.language || 'es',
+        status: twilioTemplate.status || 'DRAFT',
+        lastUpdated: new Date(),
+      };
+
+      try {
+        const approvalInfo = await TwilioService.checkApprovalStatus(twilioTemplate.sid);
+        if (approvalInfo && approvalInfo.approvalRequest) {
+          const reqData = approvalInfo.approvalRequest;
+          updateFields.approvalRequest = {
+            sid: reqData.sid,
+            status: reqData.status || 'PENDING',
+            dateSubmitted: reqData.dateCreated ? new Date(reqData.dateCreated) : new Date(),
+            dateUpdated: reqData.dateUpdated ? new Date(reqData.dateUpdated) : new Date(),
+            rejectionReason: reqData.rejectionReason || ''
+          };
+          if (reqData.status === 'APPROVED') updateFields.status = 'APPROVED';
+          else if (reqData.status === 'REJECTED') updateFields.status = 'REJECTED';
+          else if (reqData.status === 'PENDING') updateFields.status = 'PENDING';
+        }
+      } catch (err) {
+        console.warn(`Could not fetch approval status for template ${twilioTemplate.sid}:`, err.message);
+      }
+
+      const onInsertFields = {
+        sid: twilioTemplate.sid,
+        name: (twilioTemplate.friendlyName || `template_${twilioTemplate.sid}`).replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase(),
+        dateCreated: new Date(twilioTemplate.dateCreated),
+        body: '', 
+        footer: '',
+        variables: [],
+        components: []
+      };
+
+      await TemplateModel.updateOne(
+        { sid: twilioTemplate.sid },
+        {
+          $set: updateFields,
+          $setOnInsert: onInsertFields
+        },
+        { upsert: true }
+      );
+    }
+
+    const findCriteria = { sid: { $in: validTwilioSids } };
+    if (queryStatus) {
+      findCriteria.status = queryStatus;
+    }
+
+    let finalTemplates = await TemplateModel.find(findCriteria)
+      .sort({ dateCreated: -1 })
+      .limit(parseInt(limit, 10))
+      .lean();
+
+    const formattedTemplates = finalTemplates.map(template => ({
+      id: template.sid,
+      sid: template.sid,
+      name: template.name,
+      friendlyName: template.friendlyName,
+      status: template.status,
+      language: template.language,
+      created: template.dateCreated,
+      updated: template.lastUpdated,
+      category: template.category,
+      body: template.body,
+      footer: template.footer,
+      variables: template.variables,
+      components: template.components,
+      approvalRequest: template.approvalRequest
+    }));
+
+    return res.status(200).json({
+      success: true,
+      templates: formattedTemplates,
+      count: formattedTemplates.length
+    });
+
+  } catch (error) {
+    console.error('Error in listTemplates:', error);
+    return handleApiError(res, error, 'Failed to list templates');
+  }
+};
+
+/**
+ * Get a specific template by ID
+ */
+const getTemplate = async (req, res) => {
+  try {
+    const { id } = req.params;
+    
+    let template = await TemplateModel.findOne({ sid: id });
+    let twilioTemplate;
+    
+    twilioTemplate = await TwilioService.getTemplate(id);
+    
+    if (!template) {
+      // If template wasn't in our database, create it based on Twilio data
+      template = await TemplateModel.create({
+        sid: twilioTemplate.sid,
+        name: (twilioTemplate.friendlyName || `template_${twilioTemplate.sid}`).replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase(),
+        friendlyName: twilioTemplate.friendlyName,
+        category: twilioTemplate.types?.['twilio/text']?.categories?.[0] || 'UTILITY',
+        language: twilioTemplate.language,
+        status: twilioTemplate.status,
+        body: twilioTemplate.types?.['twilio/text']?.body || '',
+        variables: Object.keys(twilioTemplate.variables || {}).map(key => ({
+          name: key,
+          description: `Variable ${key}`,
+          example: twilioTemplate.variables[key] || `Example ${key}`
+        })),
+        dateCreated: new Date(twilioTemplate.dateCreated),
+        lastUpdated: new Date(twilioTemplate.dateUpdated || twilioTemplate.dateCreated)
+      });
+    } else {
+      // CRITICAL FIX: Update existing template with latest Twilio data more comprehensively
+      template.friendlyName = twilioTemplate.friendlyName || template.friendlyName;
+      template.language = twilioTemplate.language || template.language;
+      template.status = twilioTemplate.status || template.status;
+      template.category = twilioTemplate.types?.['twilio/text']?.categories?.[0] || template.category;
+      template.body = twilioTemplate.types?.['twilio/text']?.body || template.body;
+      template.variables = Object.keys(twilioTemplate.variables || {}).map(key => ({
+        name: key,
+        description: `Variable ${key}`,
+        example: twilioTemplate.variables[key] || `Example ${key}`
+      })) || template.variables;
+      template.lastUpdated = new Date(twilioTemplate.dateUpdated || Date.now());
+      await template.save();
+    }
+
+    if (!template) {
+      return handleApiError(res, 'Template not found', 'Template not found');
+    }
+    
+    const formattedTemplate = {
+      id: template.sid,
+      sid: template.sid,
+      name: template.name,
+      friendlyName: template.friendlyName,
+      status: template.status,
+      language: template.language,
+      created: template.dateCreated,
+      updated: template.lastUpdated,
+      category: template.category,
+      body: template.body,
+      footer: template.footer,
+      variables: template.variables,
+      buttons: template.buttons,
+      approvalRequest: template.approvalRequest
+    };
+    
+    return res.json({
+      success: true,
+      template: formattedTemplate
+    });
+  } catch (error) {
+    return handleApiError(res, error, 'Failed to retrieve template');
+  }
+};
+
+/**
+ * Submit a template for approval and update our database
+ */
+const submitForApproval = async (req, res) => {
+  try {
+    const { contentSid, name, category } = req.body;
+    if (!contentSid) return res.status(400).json({ success: false, error: 'Content SID is required' });
+
+    // Generate a random suffix to ensure uniqueness
+    const timestamp = Date.now().toString();
+    const randomSuffix = Math.floor(Math.random() * 1000).toString().padStart(3, '0');
+    
+    // Create name pattern with underscores: template_name_123456789_123
+    const approvalName = `${name || 'template'}_${timestamp}_${randomSuffix}`.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+    const approvalCategory = category || 'UTILITY';
+    
+    const response = await TwilioService.submitForApproval(contentSid, approvalName, approvalCategory);
+    
+    const dateCreated = response.date_created || response.dateCreated;
+    const dateUpdated = response.date_updated || response.dateUpdated || dateCreated;
+    
+    const submittedDate = dateCreated ? new Date(dateCreated) : new Date();
+    const updatedDate = dateUpdated ? new Date(dateUpdated) : new Date();
+    
+    const validSubmittedDate = !isNaN(submittedDate.getTime()) ? submittedDate : new Date();
+    const validUpdatedDate = !isNaN(updatedDate.getTime()) ? updatedDate : new Date();
+    
+    await TemplateModel.updateOne(
+      { sid: contentSid },
+      { 
+        status: 'PENDING',
+        approvalRequest: {
+          sid: response.sid,
+          status: response.status || 'PENDING',
+          dateSubmitted: validSubmittedDate,
+          dateUpdated: validUpdatedDate,
+          rejectionReason: response.rejection_reason || ''
+        }
+      },
+      { upsert: true }
+    );
+
+    return res.status(200).json({
+      success: true,
+      message: 'Template submitted for approval',
+      contentSid,
+      approvalRequestSid: response.sid,
+      approvalName: response.name,
+      approvalCategory: response.category,
+      approvalStatus: response.status,
+      approvalSubmitted: response.date_created
+    });
+  } catch (error) {
+    return handleApiError(res, error, 'Error submitting template for approval');
+  }
+};
+
+/**
+ * Check the approval status of a template
+ */
+const checkApprovalStatus = async (req, res) => {
+  try {
+    const { sid: contentSid } = req.params;
+    
+    if (!contentSid) {
+      return res.status(400).json({ success: false, error: 'Content SID is required' });
+    }
+    
+    const dbTemplate = await TemplateModel.findOne({ sid: contentSid });
+    
+    try {
+      const status = await TwilioService.checkApprovalStatus(contentSid);
+      
+      if (dbTemplate) {
+        // Use approval status as the authoritative source if available
+        let finalStatus = status.content.status || dbTemplate.status;
+
+        if (status.approvalRequest) {
+          if (status.approvalRequest.status === 'APPROVED') {
+            finalStatus = 'APPROVED';
+          } else if (status.approvalRequest.status === 'REJECTED') {
+            finalStatus = 'REJECTED';
+          } else if (status.approvalRequest.status === 'PENDING') {
+            finalStatus = 'PENDING';
+          }
+        }
+
+        dbTemplate.status = finalStatus;
+        
+        if (status.approvalRequest) {
+          // Use content dates as fallback since approval request doesn't have its own dates
+          const dateSubmitted = status.approvalRequest.date_created || status.approvalRequest.dateCreated || status.content.dateCreated ? 
+            new Date(status.approvalRequest.date_created || status.approvalRequest.dateCreated || status.content.dateCreated) : 
+            new Date();
+          const dateUpdated = status.approvalRequest.date_updated || status.approvalRequest.dateUpdated || status.content.dateUpdated ? 
+            new Date(status.approvalRequest.date_updated || status.approvalRequest.dateUpdated || status.content.dateUpdated) : 
+            dateSubmitted;
+          dbTemplate.approvalRequest = {
+            sid: status.approvalRequest.sid,
+            status: status.approvalRequest.status,
+            dateSubmitted: dateSubmitted,
+            dateUpdated: dateUpdated,
+            rejectionReason: status.approvalRequest.rejection_reason
+          };
+        }
+        
+        await dbTemplate.save();
+      }
+      
+      return res.status(200).json({
+        success: true,
+        contentSid,
+        content: status.content,
+        approvalRequest: status.approvalRequest,
+        template: dbTemplate
+      });
+    } catch (err) {
+      // If Twilio check fails but we have DB record, return what we know
+      if (dbTemplate) {
+        return res.status(200).json({
+          success: true,
+          contentSid,
+          content: {
+            sid: dbTemplate.sid,
+            status: dbTemplate.status
+          },
+          approvalRequest: dbTemplate.approvalRequest,
+          template: dbTemplate,
+          warning: 'Could not fetch latest status from Twilio'
+        });
+      }
+      
+      throw err;
+    }
+  } catch (error) {
+    return handleApiError(res, error, 'Error checking template status');
+  }
+};
+
+/**
+ * Delete a template
+ */
+const deleteTemplate = async (req, res) => {
+  try {
+    const { id } = req.params;
+    
+    await TwilioService.deleteTemplate(id);
+    
+    await TemplateModel.deleteOne({ sid: id });
+    
+    return res.json({
+      success: true,
+      message: 'Template deleted successfully'
+    });
+  } catch (error) {
+    return handleApiError(res, error, 'Failed to delete template');
+  }
+};
+
+const getPredefinedTemplates = (req, res) => {
+  try {        
+    const templatesList = Object.entries(predefinedTemplates).map(([key, createTemplateFn]) => {
+      const template = createTemplateFn();
+      return {
+        id: key,
+        name: template.name,
+        category: template.category,
+        description: `Template for ${key.replace(/_/g, ' ')}`,
+        language: template.language,
+        body: template.components.body[0]?.text || '',
+        variables: template.variables.map(v => ({
+          name: v.name,
+          description: v.description,
+          example: v.example,
+        })),
+        variationCount: template.variations.length
+      };
+    });
+        
+    return res.json({
+      success: true,
+      templates: {
+        predefined: templatesList
+      }
+    });
+        
+  } catch (error) {
+    console.error('Error getting predefined templates:', error);
+    res.status(500).json({
+      success: false,
+      error: 'Failed to retrieve predefined templates',
+      message: error.message
+    });
+  }
+};
+
+const getCompleteTemplate = async (req, res) => {
+  try {
+    const { sid } = req.params;
+    
+    let template = await TemplateModel.findOne({ sid }).lean();
+    
+    if (!template) {
+      return res.status(404).json({
+        success: false,
+        error: 'Template not found'
+      });
+    }
+    
+    if (!template.body || !template.variables || template.variables.length === 0) {
+      try {
+        const twilioTemplate = await TwilioService.getTemplate(sid);
+        console.log('Fetched template from Twilio:', twilioTemplate);
+        
+        let body = '';
+        let footer = '';
+        let variables = [];
+        let type = 'text';
+        
+        if (twilioTemplate.types && twilioTemplate.types['twilio/flows']) {
+          type = 'flow';
+          body = twilioTemplate.types['twilio/flows'].body || '';
+        } else if (twilioTemplate.types && twilioTemplate.types['twilio/quick-reply']) {
+          type = 'quick-reply';
+          body = twilioTemplate.types['twilio/quick-reply'].body || '';
+          
+          if (twilioTemplate.types['twilio/quick-reply'].actions && 
+              Array.isArray(twilioTemplate.types['twilio/quick-reply'].actions)) {
+            const actions = twilioTemplate.types['twilio/quick-reply'].actions;
+            template.actions = actions;
+          }
+        } else if (twilioTemplate.types && twilioTemplate.types['twilio/text']) {
+          body = twilioTemplate.types['twilio/text'].body || '';
+        }
+        
+        const variableMatches = body.match(/\{\{([^}]+)\}\}/g) || [];
+        variables = variableMatches.map(match => {
+          const varName = match.replace(/[{}]/g, '');
+          
+          const exampleValue = twilioTemplate.variables && twilioTemplate.variables[varName] 
+            ? twilioTemplate.variables[varName] 
+            : `Example ${varName}`;
+          
+          return {
+            name: varName,
+            placeholder: `Variable ${varName}`,
+            example: exampleValue
+          };
+        });
+        
+        const components = [];
+        
+        if (body) {
+          components.push({ type: 'BODY', text: body });
+        }
+        
+        if (footer) {
+          components.push({ type: 'FOOTER', text: footer });
+        }
+        
+        if (body) {
+          const updateData = { 
+            body,
+            footer,
+            variables,
+            components,
+            type,
+            lastUpdated: new Date()
+          };
+          
+          if (type === 'quick-reply' && template.actions) {
+            updateData.actions = template.actions;
+          }
+          
+          await TemplateModel.updateOne(
+            { sid },
+            { $set: updateData }
+          );
+          
+          template.body = body;
+          template.footer = footer;
+          template.variables = variables;
+          template.components = components;
+          template.type = type;
+        }
+      } catch (twilioError) {
+        console.error('Error fetching complete template from Twilio:', twilioError);
+      }
+    }
+    
+    return res.status(200).json({
+      success: true,
+      template
+    });
+  } catch (error) {
+    return handleApiError(res, error, 'Failed to get complete template');
+  }
+};
+
+module.exports = {
+  createTemplate,
+  listTemplates,
+  getTemplate,
+  getPredefinedTemplates,
+  submitForApproval,
+  checkApprovalStatus,
+  deleteTemplate,
+  getCompleteTemplate,
+  // Flow functions from templateFlowController
+  createFlow,
+  deleteFlow
+};

package/lib/index.js

@@ -188,17 +188,19 @@ class Nexus {
   }
 }
 
+// Import routes
+const routes = require('./routes');
+
 // Export main class and individual components
 module.exports = {
   Nexus,
-  NexusMessaging,
   TwilioProvider,
   BaileysProvider,
   MongoStorage,
   MessageParser,
-  adapters,
-  core,
-  storage,
-  utils,
-  models
+  DefaultLLMProvider,
+  routes,
+  // Direct access to route utilities for convenience
+  setupDefaultRoutes: routes.setupDefaultRoutes,
+  createRouter: routes.createRouter
 };