@peopl-health/nexus 3.5.2 → 3.5.4

package/lib/adapters/TwilioProvider.js

@@ -524,7 +524,7 @@ class TwilioProvider extends MessageProvider {
         const wa = req.whatsapp;
         approvalRequest = {
           sid: req.sid,
-          status: (wa?.status || req.status || 'UNKNOWN').toUpperCase(),
+          status: (wa?.status || req.status).toUpperCase(),
           ...(wa && { category: wa.category, name: wa.name, rejectionReason: wa.rejection_reason, contentType: wa.content_type }),
           dateCreated: req.dateCreated || req.date_created,
           dateUpdated: req.dateUpdated || req.date_updated

package/lib/controllers/bugReportController.js

@@ -3,11 +3,10 @@ const { Logging_ID } = require('../config/airtableConfig');
 const { logger } = require('../utils/logger');
 
 const { Message } = require('../models/messageModel');
+const { getBug, VALID_SEVERITIES } = require('../models/bugModel');
 
 const { addRecord, getRecordByFilter } = require('../services/airtableService');
 
-const VALID_SEVERITIES = ['low', 'medium', 'high', 'critical'];
-
 async function logBugReportToAirtable(reporter, whatsapp_id, description, severity, messageIds = []) {
   try {
     let conversation = null;
@@ -46,18 +45,68 @@ const reportBugController = async (req, res) => {
     if (!reporter) return res.status(400).json({ success: false, error: 'Reporter username is required' });
     if (!whatsapp_id) return res.status(400).json({ success: false, error: 'WhatsApp ID is required' });
     if (!VALID_SEVERITIES.includes(severity)) {
-      return res.status(400).json({ success: false, error: 'Severity must be low, medium, high, or critical' });
+      return res.status(400).json({ success: false, error: `Severity must be one of: ${VALID_SEVERITIES.join(', ')}` });
     }
 
+    const Bug = getBug();
+    const bug = await Bug.create({ reporter, whatsapp_id, description, severity, messages: messages || [] });
+
     logBugReportToAirtable(reporter, whatsapp_id, description, severity, messages).catch(err =>
       logger.error('Background bug report logging failed:', { error: err.message })
     );
 
-    res.status(201).json({ success: true, message: 'Bug report submitted successfully' });
+    res.status(201).json({ success: true, message: 'Bug report submitted successfully', bug });
   } catch (error) {
     logger.error('Error submitting bug report:', { error: error.message });
     res.status(500).json({ success: false, error: error.message });
   }
 };
 
-module.exports = { reportBugController };
+const getBugByWhatsappIdController = async (req, res) => {
+  try {
+    const { whatsapp_id } = req.params;
+
+    if (!whatsapp_id || whatsapp_id.trim().length === 0) {
+      return res.status(400).json({ success: false, error: 'WhatsApp ID is required' });
+    }
+
+    const maxLimit = 100;
+    const limit = Math.min(Math.max(parseInt(req.query.limit) || 50, 1), maxLimit);
+    const page = Math.max(parseInt(req.query.page) || 1, 1);
+    const skip = (page - 1) * limit;
+
+    const Bug = getBug();
+    const total = await Bug.countDocuments({ whatsapp_id: whatsapp_id });
+    const bugs = await Bug.find({ whatsapp_id: whatsapp_id })
+      .populate('messages')
+      .sort({ createdAt: -1 })
+      .skip(skip)
+      .limit(limit);
+
+    const bugsWithCount = bugs.map(bug => ({
+      ...bug.toObject(),
+      count: bug.messages ? bug.messages.length : 0
+    }));
+
+    const totalPages = Math.ceil(total / limit);
+
+    res.status(200).json({
+      success: true,
+      whatsappId: whatsapp_id,
+      bugs: bugsWithCount,
+      pagination: {
+        page,
+        limit,
+        total,
+        totalPages,
+        hasNext: page < totalPages,
+        hasPrev: page > 1
+      }
+    });
+  } catch (error) {
+    logger.error('Error fetching bug reports:', { error: error.message });
+    res.status(500).json({ success: false, error: error.message });
+  }
+};
+
+module.exports = { reportBugController, getBugByWhatsappIdController };

package/lib/controllers/templateController.js

@@ -113,87 +113,86 @@ const createTemplate = async (req, res) => {
 
 const listTemplates = async (req, res) => {
   try {
-    const { status: queryStatus, type, limit = 50, showFlows: queryShowFlows } = req.query;
-    const provider = requireProvider();
-    const twilioRawTemplates = await provider.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 provider.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) {
-        logger.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: []
-      };
+    const { status: queryStatus, type, limit: queryLimit = 50, showFlows: queryShowFlows } = req.query;
+    const page = Math.max(parseInt(req.query.page) || 1, 1);
+    const limit = Math.min(Math.max(parseInt(queryLimit) || 50, 1), 100);
+    const skip = (page - 1) * limit;
 
-      await TemplateModel.updateOne(
-        { sid: twilioTemplate.sid },
-        {
-          $set: updateFields,
-          $setOnInsert: onInsertFields
-        },
-        { upsert: true }
-      );
-    }
-
-    const findCriteria = { sid: { $in: validTwilioSids } };
+    const findCriteria = {};
+    
     if (queryStatus) {
       findCriteria.status = queryStatus;
     }
+    
+    const showFlows = type === 'flow' || queryShowFlows === 'true';
+    if (showFlows) {
+      findCriteria.type = 'twilio/flex';
+    } else {
+      findCriteria.type = { $ne: 'twilio/flex' };
+    }
 
-    let finalTemplates = await TemplateModel.find(findCriteria)
+    const total = await TemplateModel.countDocuments(findCriteria);
+    const totalPages = Math.ceil(total / limit);
+    
+    const templates = await TemplateModel.find(findCriteria)
       .sort({ dateCreated: -1 })
-      .limit(parseInt(limit, 10))
+      .skip(skip)
+      .limit(limit)
       .lean();
 
-    const formattedTemplates = finalTemplates.map(_formatTemplate);
+    const provider = requireProvider();
+    
+    const approvalPromises = templates
+      .filter(template => template.status !== 'APPROVED' && template.status !== 'REJECTED')
+      .map(async (template) => {
+        try {
+          const approvalInfo = await provider.checkApprovalStatus(template.sid);
+          if (approvalInfo && approvalInfo.approvalRequest) {
+            const reqData = approvalInfo.approvalRequest;
+            const updateFields = {
+              approvalRequest: {
+                sid: reqData.sid,
+                status: reqData.status,
+                dateSubmitted: reqData.dateCreated ? new Date(reqData.dateCreated) : new Date(),
+                dateUpdated: reqData.dateUpdated ? new Date(reqData.dateUpdated) : new Date(),
+                rejectionReason: reqData.rejectionReason || ''
+              },
+              lastUpdated: new Date(),
+              status: reqData.status
+            };
+
+            await TemplateModel.updateOne(
+              { sid: template.sid },
+              { $set: updateFields }
+            );
+
+            Object.assign(template, {
+              approvalRequest: updateFields.approvalRequest,
+              status: updateFields.status,
+              lastUpdated: updateFields.lastUpdated
+            });
+          }
+        } catch (err) {
+          logger.warn(`Could not fetch approval status for template ${template.sid}:`, err.message);
+        }
+      });
+
+    await Promise.all(approvalPromises);
 
     return res.status(200).json({
       success: true,
-      templates: formattedTemplates,
-      count: formattedTemplates.length
+      templates: templates.map(_formatTemplate),
+      count: templates.length,
+      pagination: {
+        page,
+        limit,
+        total,
+        totalPages,
+        hasNext: page < totalPages,
+        hasPrev: page > 1
+      }
     });
-
+    
   } catch (error) {
     logger.error('Error in listTemplates:', { error: error.message });
     return handleApiError(res, error, 'Failed to list templates');

package/lib/models/bugModel.js

@@ -0,0 +1,23 @@
+const mongoose = require('mongoose');
+
+const { getDb, getModelDatabase } = require('../config/mongoConfig');
+const { logger } = require('../utils/logger');
+
+const VALID_SEVERITIES = ['low', 'medium', 'high', 'critical'];
+
+const bugSchema = new mongoose.Schema({
+  reporter: { type: String, required: true, index: true },
+  whatsapp_id: { type: String, required: true, index: true },
+  description: { type: String, required: true },
+  severity: { type: String, required: true, enum: VALID_SEVERITIES },
+  messages: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Message' }]
+}, { timestamps: true });
+
+const getBug = () => {
+  const dbName = getModelDatabase('Bug');
+  const db = dbName ? getDb(dbName) : mongoose;
+  logger.debug('[Bug] Using database', { dbName: dbName || 'default' });
+  return db.models.Bug || db.model('Bug', bugSchema);
+};
+
+module.exports = { getBug, bugSchema, VALID_SEVERITIES };

package/lib/models/templateModel.js

@@ -9,11 +9,12 @@ const TemplateSchema = new mongoose.Schema({
     default: 'UTILITY', 
     enum: ['UTILITY', 'MARKETING', 'AUTHENTICATION'] 
   },
+  type: String,
   language: { type: String, default: 'es' },
   status: {
     type: String,
-    default: 'DRAFT',
-    enum: ['DRAFT', 'PENDING', 'APPROVED', 'REJECTED', 'UNKNOWN']
+    default: 'UNSUBMITTED',
+    enum: ['UNSUBMITTED', 'RECEIVED', 'PENDING', 'APPROVED', 'REJECTED', 'PAUSED', 'DISABLED']
   },
   body: String,
   footer: String,

package/lib/routes/index.js

@@ -22,8 +22,12 @@ const conversationRouteDefinitions = {
   'POST /reply': 'getConversationReplyController',
   'POST /send-template': 'sendTemplateToNewNumberController',
   'POST /:phoneNumber/read': 'markMessagesAsReadController',
+  'POST /case-documentation': 'caseDocumentationController',
   'POST /report-bug': 'reportBugController',
-  'POST /case-documentation': 'caseDocumentationController'
+  'POST /bug': 'reportBugController',
+  'GET /bug/:whatsapp_id': 'getBugByWhatsappIdController',
+  'POST /interaction': 'addInteractionController',
+  'GET /interaction/:whatsapp_id': 'getInteractionsByWhatsappIdController'
 };
 
 const mediaRouteDefinitions = {
@@ -130,6 +134,7 @@ const builtInControllers = {
   markMessagesAsReadController: conversationController.markMessagesAsReadController,
   searchMessagesByNumberController: conversationController.searchMessagesByNumberController,
   reportBugController: bugReportController.reportBugController,
+  getBugByWhatsappIdController: bugReportController.getBugByWhatsappIdController,
   caseDocumentationController: caseDocumentationController.caseDocumentationController,
   
   // Interaction controllers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "3.5.2",
+  "version": "3.5.4",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",