@peopl-health/nexus 3.5.16 → 3.6.1

package/lib/config/airtableConfig.js

@@ -16,6 +16,7 @@ const Symptoms_ID = runtimeConfig.get('AIRTABLE_SYMPTOMS_ID') || 'appQRhZlQ9tMfY
 const Follow_Up_ID = runtimeConfig.get('AIRTABLE_FOLLOW_UP_ID') || 'appBjKw1Ub0KkbZf0';
 const Webinars_Leads_ID = runtimeConfig.get('AIRTABLE_WEBINARS_LEADS_ID') || 'appzjpVXTI0TgqGPq';
 const Product_ID = runtimeConfig.get('AIRTABLE_PRODUCT_ID') || 'appu2YDW2pKDYLL5H';
+const Dashboard_ID = runtimeConfig.get('AIRTABLE_DASHBOARD_ID') || 'appg9YUNlfIC82MzR';
 
 let airtable = null;
 if (airtableConfig.apiKey) {
@@ -32,7 +33,8 @@ const BASE_MAP = {
   symptoms: Symptoms_ID,
   followup: Follow_Up_ID,
   webinars: Webinars_Leads_ID,
-  product: Product_ID
+  product: Product_ID,
+  dashboard: Dashboard_ID
 };
 
 module.exports = {
@@ -48,6 +50,7 @@ module.exports = {
   Follow_Up_ID,
   Webinars_Leads_ID,
   Product_ID,
+  Dashboard_ID,
   getBase: (baseKeyOrId = runtimeConfig.get('AIRTABLE_BASE_ID')) => {
     if (!airtable) {
       throw new Error('Airtable not configured. Please set AIRTABLE_API_KEY environment variable.');

package/lib/controllers/conversationController.js

@@ -275,11 +275,25 @@ const searchConversationsController = async (req, res) => {
       }
     }
 
+    let threadNameMap = {};
+    let messageNameMap = {};
+    if (phoneNumbers.length > 0) {
+      const threads = await Thread.find({ code: { $in: phoneNumbers } }).select('code nombre').lean();
+      threads.forEach(t => { if (t.code && t.nombre) threadNameMap[t.code] = t.nombre; });
+
+      const lastPatientMessages = await Message.aggregate([
+        { $match: { numero: { $in: phoneNumbers }, from_me: false, nombre_whatsapp: { $exists: true, $nin: [null, ''] } } },
+        { $sort: { createdAt: -1 } },
+        { $group: { _id: '$numero', nombre_whatsapp: { $first: '$nombre_whatsapp' } } }
+      ]);
+      lastPatientMessages.forEach(m => { messageNameMap[m._id] = m.nombre_whatsapp; });
+    }
+
     const processedConversations = conversations.map(conv => {
       if (!conv || !conv.latestMessage) {
         return {
           phoneNumber: conv?._id || 'unknown',
-          name: 'Unknown',
+          name: 'Desconocido',
           patientId: airtablePatientIdMap[conv?._id] || null,
           lastMessage: '',
           lastMessageTime: new Date(),
@@ -312,7 +326,7 @@ const searchConversationsController = async (req, res) => {
 
       return {
         phoneNumber: conv._id,
-        name: airtableNameMap[conv._id] || conv?.latestMessage?.nombre_whatsapp || 'Unknown',
+        name: airtableNameMap[conv._id] || threadNameMap[conv._id] || messageNameMap[conv._id] || 'Desconocido',
         patientId: airtablePatientIdMap[conv._id] || null,
         lastMessage: conv?.latestMessage?.body || '',
         lastMessageTime: conv?.latestMessage?.createdAt || conv?.latestMessage?.timestamp || new Date(),

package/lib/controllers/dashboardController.js

@@ -0,0 +1,55 @@
+const { logger } = require('../utils/logger');
+
+const { validateAndAdaptBox } = require('../helpers/dashboardHelper');
+
+const { getAllBoxes, getStatsById, updateBox } = require('../services/dashboardService');
+
+const getDashboardController = async (req, res) => {
+  try {
+    const force = req.query.force === 'true';
+    const boxes = await getAllBoxes(force);
+    res.json({ success: true, boxes });
+  } catch (error) {
+    logger.error('[DashboardController] Error fetching dashboards:', { error: error.message });
+    res.status(500).json({ success: false, error: error.message || 'Failed to fetch dashboards' });
+  }
+};
+
+const getDashboardStatsControllerById = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { type } = req.query;
+    const cacheId = type ? `${type}_${id}` : id;
+
+    const stats = await getStatsById(cacheId);
+    if (!stats) {
+      return res.status(404).json({ success: false, error: 'Indicator stats not found' });
+    }
+
+    res.json({ success: true, stats });
+  } catch (error) {
+    logger.error('[DashboardController] Error fetching dashboard stats by id:', { error: error.message, id: req.params?.id });
+    res.status(500).json({ success: false, error: error.message || 'Failed to fetch dashboard stats' });
+  }
+};
+
+const updateDashboardControllerById = async (req, res) => {
+  try {
+    const { error, box } = validateAndAdaptBox(req.body);
+    if (error) {
+      return res.status(400).json({ success: false, error });
+    }
+
+    res.json({ success: true, message: 'Box updated', id: box.id });
+
+    await updateBox(box.id, box);
+  } catch (error) {
+    logger.error('[DashboardController] Error updating dashboard:', { error: error.message, id: req.params?.id });
+  }
+};
+
+module.exports = {
+  getDashboardController,
+  getDashboardStatsControllerById,
+  updateDashboardControllerById
+};

package/lib/helpers/dashboardHelper.js

@@ -0,0 +1,65 @@
+const { Dashboard_ID } = require('../config/airtableConfig');
+
+const { logger } = require('../utils/logger');
+const { safeParse } = require('../utils/jsonUtils');
+
+const { getRecordByFilter } = require('../services/airtableService');
+
+const BOX_COLUMNS = ['id', 'type', 'title', 'metadata', 'config', 'total', 'sample', 'indicator'];
+const REQUIRED_BOX_FIELDS = ['id', 'type', 'metadata'];
+
+function adaptBox(raw) {
+  return {
+    ...raw,
+    id: `${raw['type']}_${raw['id']}`,
+    metadata: safeParse(raw['metadata']),
+    config: safeParse(raw['config'])
+  };
+}
+
+function validateAndAdaptBox(body, existingBox) {
+  if (!body || typeof body !== 'object') return { error: 'Request body is required' };
+  const missing = REQUIRED_BOX_FIELDS.filter(field => !(field in body));
+  if (missing.length > 0) return { error: `Missing required fields: ${missing.join(', ')}` };
+
+  const adapted = adaptBox(body);
+  if (!adapted.config && existingBox?.config) {
+    adapted.config = existingBox.config;
+  }
+
+  return { box: adapted };
+}
+
+async function fetchBoxesFromAirtable(boxId) {
+  let filter = '{is_active} = true';
+  if (boxId) {
+    filter = `AND({is_active} = true, {id} = '${boxId}')`;
+  }
+
+  const rawBoxes = await getRecordByFilter(Dashboard_ID, 'master', filter, undefined, BOX_COLUMNS) || [];
+  return rawBoxes.map(adaptBox);
+}
+
+async function fetchDetailsFromAirtable(boxes) {
+  if (!boxes || boxes.length === 0) return [];
+
+  const results = await Promise.all(
+    boxes.map(async box => {
+      if (!box.config || !box.config.table) {
+        logger.warn(`[DashboardHelper] Box ${box.id} has no config or table, skipping`);
+        return { id: box.id, records: [] };
+      }
+      const records = await getRecordByFilter(Dashboard_ID, box.config.table, 'TRUE()', box.config.view, box.config.columns) || [];
+      return { id: box.id, records };
+    })
+  );
+  return results;
+}
+
+function attachPreview(box, records) {
+  if (records.length > 0) {
+    box.metadata = { ...box.metadata, preview: records[0] };
+  }
+}
+
+module.exports = { fetchBoxesFromAirtable, fetchDetailsFromAirtable, attachPreview, validateAndAdaptBox };

package/lib/routes/index.js

@@ -80,6 +80,12 @@ const templateRouteDefinitions = {
   'DELETE /:id': 'deleteTemplate'
 };
 
+const dashboardRouteDefinitions = {
+  'GET /': 'getDashboardController',
+  'GET /stats/:id': 'getDashboardStatsControllerById',
+  'POST /:id': 'updateDashboardControllerById'
+};
+
 const createRouter = (routeDefinitions, controllers) => {
   const router = express.Router();
   
@@ -109,6 +115,7 @@ const templateController = require('../controllers/templateController');
 const templateFlowController = require('../controllers/templateFlowController');
 const flowDataExchangeController = require('../controllers/flowDataExchangeController');
 const uploadController = require('../controllers/uploadController');
+const dashboardController = require('../controllers/dashboardController');
 
 const builtInControllers = {
   // Assistant controllers
@@ -181,7 +188,12 @@ const builtInControllers = {
   // Thread review controllers
   updateReviewStatusController: conversationController.updateReviewStatusController,
   updateAllReviewStatusController: conversationController.updateAllReviewStatusController,
-  getReviewStatusController: conversationController.getReviewStatusController
+  getReviewStatusController: conversationController.getReviewStatusController,
+
+  // Dashboard controllers
+  getDashboardController: dashboardController.getDashboardController,
+  getDashboardStatsControllerById: dashboardController.getDashboardStatsControllerById,
+  updateDashboardControllerById: dashboardController.updateDashboardControllerById
 };
 
 const setupDefaultRoutes = (app) => {
@@ -192,6 +204,7 @@ const setupDefaultRoutes = (app) => {
   app.use('/api/message', createRouter(messageRouteDefinitions, builtInControllers));
   app.use('/api/patient', createRouter(patientRouteDefinitions, builtInControllers));
   app.use('/api/template', createRouter(templateRouteDefinitions, builtInControllers));
+  app.use('/api/dashboard', createRouter(dashboardRouteDefinitions, builtInControllers));
 };
 
 module.exports = {
@@ -202,6 +215,7 @@ module.exports = {
   messageRoutes: messageRouteDefinitions,
   patientRoutes: patientRouteDefinitions,
   templateRoutes: templateRouteDefinitions,
+  dashboardRoutes: dashboardRouteDefinitions,
 
   createRouter,
   setupDefaultRoutes

package/lib/services/conversationService.js

@@ -104,15 +104,20 @@ const fetchConversationData = async (filter, skip, limit) => {
 
   const phoneNumbers = conversations.map(c => c._id).filter(Boolean);
   let airtableNameMap = {};
+  let threadNameMap = {};
   if (phoneNumbers.length) {
     const formula = `OR(${phoneNumbers.map(p => `{whatsapp_id} = "${p}"`).join(', ')})`;
     const records = await getRecordByFilter(Historial_Clinico_ID, 'estado_general', formula);
-    airtableNameMap = toMap(records || [], r => r.whatsapp_id, r => r.name);
+    airtableNameMap = toMap((records || []).filter(r => r.name), r => r.whatsapp_id, r => r.name);
+
+    const threads = await Thread.find({ code: { $in: phoneNumbers } }).select('code nombre').lean();
+    threadNameMap = toMap((threads || []).filter(t => t.nombre), t => t.code, t => t.nombre);
   }
 
   const nameMap = {
-    ...airtableNameMap,
-    ...toMap(contactNames, c => c?._id && !airtableNameMap[c._id] ? c._id : null, c => c.name || 'Unknown')
+    ...toMap(contactNames, c => c?._id ? c._id : null, c => c.name || 'Desconocido'),
+    ...threadNameMap,
+    ...airtableNameMap
   };
   const unreadMap = toMap(unreadCounts, i => i?._id, i => i.unreadCount || 0);
 
@@ -128,13 +133,13 @@ const getMediaType = (media) => {
 };
 
 const processConversations = async (conversations, nameMap, unreadMap) => {
-  const createConversation = (conv, index, fallback = {}) => {
+  const createConversation = (conv, index) => {
     const msg = conv?.latestMessage;
-    const phoneNumber = conv?._id || fallback.phoneNumber || `error_${index}`;
+    const phoneNumber = conv?._id || `error_${index}`;
     return {
       phoneNumber,
-      name: nameMap[phoneNumber] || msg?.nombre_whatsapp || fallback.name || 'Unknown',
-      lastMessage: msg?.body || fallback.lastMessage || '',
+      name: nameMap[phoneNumber],
+      lastMessage: msg?.body || '',
       lastMessageTime: msg?.createdAt || msg?.timestamp || new Date(),
       messageCount: conv?.messageCount || 0,
       unreadCount: unreadMap[phoneNumber] || 0,
@@ -148,16 +153,13 @@ const processConversations = async (conversations, nameMap, unreadMap) => {
   try {
     const result = (conversations || []).map((conv, index) => {
       try {
-        if (!conv?.latestMessage) {
-          logger.warn('[processConversations] Missing latestMessage', { index, id: conv?._id });
-          return createConversation(conv, index, { name: 'Unknown' });
-        }
+        if (!conv?.latestMessage) logger.warn('[processConversations] Missing latestMessage', { index, id: conv?._id });
         return createConversation(conv, index);
       } catch (error) {
         logger.error('[processConversations] Error processing', { index, error: error.message });
-        return createConversation(conv, index, { name: 'Error Processing', lastMessage: 'Error processing conversation' });
+        return null;
       }
-    });
+    }).filter(Boolean);
 
     logger.info('[processConversations] Completed', { count: result.length });
     return result;

package/lib/services/dashboardService.js

@@ -0,0 +1,68 @@
+const { logger } = require('../utils/logger');
+const MapCache = require('../utils/MapCache');
+
+const { fetchBoxesFromAirtable, fetchDetailsFromAirtable, attachPreview } = require('../helpers/dashboardHelper');
+
+const boxCache = new MapCache({ maxSize: 100 });
+const detailCache = new MapCache({ maxSize: 100 });
+
+async function seedCaches() {
+  try {
+    logger.info('[DashboardService] Cold-start: seeding caches from Airtable');
+
+    const boxes = await fetchBoxesFromAirtable();
+    boxes.forEach(box => boxCache.set(box.id, box));
+
+    const details = await fetchDetailsFromAirtable(boxes);
+    details.forEach(({ id, records }) => {
+      detailCache.set(id, records);
+      const box = boxCache.get(id);
+      if (box) attachPreview(box, records);
+    });
+  } catch (error) {
+    logger.error('[DashboardService] Error seeding caches:', { error: error.message });
+    throw error;
+  }
+}
+
+async function ensureSeeded(force) {
+  if (force) {
+    boxCache.clear();
+    detailCache.clear();
+  }
+  if (boxCache.size === 0) {
+    await seedCaches();
+  }
+}
+
+async function getAllBoxes(force) {
+  await ensureSeeded(force);
+  return Array.from(boxCache.entries()).map(([id, { config: _config, ...data }]) => ({ id, ...data }));
+}
+
+async function getStatsById(cacheId) {
+  const detail = detailCache.get(cacheId);
+  if (!detail) return null;
+  return { id: cacheId, records: detail };
+}
+
+async function updateBox(id, data) {
+  boxCache.set(id, data);
+  logger.info('[DashboardService] Box cache updated', { id });
+
+  const box = boxCache.get(id);
+  if (box?.config?.table) {
+    const [detail] = await fetchDetailsFromAirtable([box]);
+    if (detail) {
+      detailCache.set(detail.id, detail.records);
+      attachPreview(box, detail.records);
+      logger.info('[DashboardService] Detail cache refreshed after box update', { id });
+    }
+  }
+}
+
+module.exports = {
+  getAllBoxes,
+  getStatsById,
+  updateBox
+};

package/lib/utils/jsonUtils.js

@@ -9,4 +9,12 @@ function jsonStringifyWithUnicodeEscapes(obj) {
   });
 }
 
-module.exports = { jsonStringifyWithUnicodeEscapes };
+function safeParse(value, fallback = {}) {
+  try {
+    return JSON.parse(value || JSON.stringify(fallback));
+  } catch {
+    return fallback;
+  }
+}
+
+module.exports = { jsonStringifyWithUnicodeEscapes, safeParse };

package/package.json

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