@peopl-health/nexus 3.9.9 → 3.10.0

package/lib/controllers/conversationController.js

@@ -35,9 +35,9 @@ const getConversationController = async (req, res) => {
       });
     }
 
-    const { conversations, total, nameMap } = await fetchConversationData(filter, skip, limit);
+    const { threads, total, airtableNameMap } = await fetchConversationData(filter, skip, limit);
 
-    if (!conversations?.length) {
+    if (!threads?.length) {
       return res.status(200).json({
         success: true,
         conversations: [],
@@ -45,7 +45,7 @@ const getConversationController = async (req, res) => {
       });
     }
 
-    const processedConversations = await processConversations(conversations, nameMap);
+    const processedConversations = await processConversations(threads, airtableNameMap);
     const totalPages = Math.ceil(total / limit);
 
     res.status(200).json({

package/lib/models/messageModel.js

@@ -9,6 +9,10 @@ const { getClinicalContext } = require('../helpers/patientInformationHelper');
 
 const { updateRecordByFilter } = require('../services/airtableService');
 
+const { Thread } = require('./threadModel');
+
+const INTERNAL_ORIGINS = new Set(['system', 'instruction']);
+
 const messageSchema = new mongoose.Schema({
   raw: { type: Object, default: null },
   body: { type: String, required: true },
@@ -139,6 +143,25 @@ async function insertMessage(values) {
     );
     const isNew = !result?.lastErrorObject?.updatedExisting;
 
+    if (isNew && values.numero && !INTERNAL_ORIGINS.has(values.origin)) {
+      Thread.findOneAndUpdate(
+        { code: values.numero },
+        {
+          $set: {
+            lastMessageAt: new Date(),
+            lastMessageBody: values.body || '',
+            lastMessageFromMe: !!values.from_me,
+            lastMessageMedia: values.media || null
+          },
+          $inc: {
+            messageCount: 1,
+            ...(!values.from_me ? { unreadCount: 1 } : {})
+          }
+        },
+        { upsert: true, setDefaultsOnInsert: true }
+      ).catch(err => logger.error('[MongoStorage] Failed to denormalize thread', { numero: values.numero, error: err.message }));
+    }
+
     updateRecordByFilter(Monitoreo_ID, 'message_monitor', `{whatsapp_id} = "${values.numero}"`, {
       ...(values.from_me ? { last_message_bot: values.body } : { last_message_patient: values.body, read: false }),
       ...(values.from_me ? { last_message_bot_time: values.timestamp } : { last_message_patient_time: values.timestamp })

package/lib/models/threadModel.js

@@ -15,12 +15,18 @@ const threadSchema = new mongoose.Schema({
   version: { type: Number, default: null },
   preset_id: { type: String, default: null },
   nextSid: { type: [String], default: [] },
-  unreadCount: { type: Number, default: 0 }
+  unreadCount: { type: Number, default: 0 },
+  messageCount: { type: Number, default: 0 },
+  lastMessageAt: { type: Date, default: null },
+  lastMessageBody: { type: String, default: null },
+  lastMessageFromMe: { type: Boolean, default: false },
+  lastMessageMedia: { type: Object, default: null }
 }, { timestamps: true });
 
 threadSchema.index({ code: 1, active: 1 });
 threadSchema.index({ thread_id: 1 });
 threadSchema.index({ conversation_id: 1 });
+threadSchema.index({ lastMessageAt: -1 }, { name: 'last_message_at_idx', sparse: true });
 
 threadSchema.methods.getConversationId = function() {
   return this.conversation_id;

package/lib/services/conversationService.js

@@ -3,7 +3,6 @@ const { Historial_Clinico_ID, Symptoms_ID } = require('../config/airtableConfig'
 const { logger } = require('../utils/logger');
 const { parseDate } = require('../utils/dateUtils');
 
-const { Message } = require('../models/messageModel');
 const { Thread } = require('../models/threadModel');
 const TemplateModel = require('../models/templateModel');
 
@@ -15,20 +14,30 @@ const { sendMessage, requireProvider } = require('../core/NexusMessaging');
 
 const { Template } = require('../templates/templateStructure');
 
-const BASE_MATCH = { group_id: null };
-const UNREAD_MATCH = { from_me: false, $or: [{ read: false }, { read: { $exists: false } }] };
-const PENDING_REVIEW_MATCH = { $or: [{ review: false }, { review: null }] };
-const THREAD_LOOKUP = { $lookup: { from: 'threads', localField: '_id', foreignField: 'code', as: 'threadInfo' } };
-const THREAD_FIELDS = { $addFields: {
-  review: { $arrayElemAt: ['$threadInfo.review', 0] },
-  unreadCount: { $ifNull: [{ $arrayElemAt: ['$threadInfo.unreadCount', 0] }, 0] }
-} };
-
 const toMap = (arr, keyFn, valFn) => arr.reduce((m, item) => {
   const key = keyFn(item);
   return key ? { ...m, [key]: valFn(item) } : m;
 }, {});
 
+const buildThreadFilter = (filter, { triageIds }) => {
+  const base = { lastMessageAt: { $ne: null } };
+  switch (filter) {
+  case 'unread':
+    return { ...base, unreadCount: { $gt: 0 } };
+  case 'pending-review':
+    return { ...base, $or: [{ review: false }, { review: null }] };
+  case 'recent':
+    return { ...base, lastMessageAt: { $gt: new Date(Date.now() - 86400000) } };
+  case 'no-response':
+    return { ...base, lastMessageFromMe: false };
+  case 'triage-last-month':
+    return { ...base, code: { $in: triageIds } };
+  case 'all':
+  default:
+    return base;
+  }
+};
+
 const fetchConversationData = async (filter, skip, limit) => {
   let triageIds = [];
   if (filter === 'triage-last-month') {
@@ -36,99 +45,34 @@ const fetchConversationData = async (filter, skip, limit) => {
     triageIds = (triageRecords || []).map(r => r.whatsapp_id).filter(Boolean);
   }
 
-  let unreadCodes = [];
-  if (filter === 'unread') {
-    const unreadThreads = await Thread.find({ unreadCount: { $gt: 0 } }, { code: 1, _id: 0 }).lean();
-    unreadCodes = unreadThreads.map(t => t.code);
-  }
-
-  const filterMap = {
-    unread: { ...BASE_MATCH, numero: { $in: unreadCodes } },
-    recent: { ...BASE_MATCH, createdAt: { $gt: new Date(Date.now() - 86400000) } },
-    'no-response': BASE_MATCH,
-    'pending-review': BASE_MATCH,
-    'triage-last-month': { ...BASE_MATCH, numero: { $in: triageIds } },
-    all: BASE_MATCH
-  };
-  const filterConditions = filterMap[filter] || BASE_MATCH;
+  const threadFilter = buildThreadFilter(filter, { triageIds });
 
   logger.info('[fetchConversationData] Applying filter', { filter });
-
-  const pipeline = [
-    { $match: filterConditions },
-    { $project: { numero: 1, body: 1, createdAt: 1, timestamp: 1, media: 1, nombre_whatsapp: 1, from_me: 1 } },
-    { $sort: { createdAt: 1, timestamp: 1 } },
-    { $group: { _id: '$numero', latestMessage: { $last: '$$ROOT' }, messageCount: { $sum: 1 } } },
-    { $match: { _id: { $nin: [null, ''] } } },
-    ...(filter === 'no-response' ? [{ $match: { 'latestMessage.from_me': false } }] : []),
-    THREAD_LOOKUP,
-    THREAD_FIELDS,
-    { $project: { threadInfo: 0 } },
-    ...(filter === 'pending-review' ? [{ $match: PENDING_REVIEW_MATCH }] : []),
-    { $sort: { 'latestMessage.createdAt': -1 } },
-    { $skip: skip },
-    { $limit: limit }
-  ];
-
-  const getTotalPipeline = () => {
-    if (filter === 'no-response') {
-      return [
-        { $match: BASE_MATCH },
-        { $project: { numero: 1, from_me: 1, createdAt: 1 } },
-        { $sort: { createdAt: -1 } },
-        { $group: { _id: '$numero', latestMessage: { $first: '$$ROOT' } } },
-        { $match: { 'latestMessage.from_me': false } },
-        { $count: 'total' }
-      ];
-    }
-    if (filter === 'pending-review') {
-      return [
-        { $match: BASE_MATCH },
-        { $group: { _id: '$numero' } },
-        THREAD_LOOKUP,
-        THREAD_FIELDS,
-        { $match: PENDING_REVIEW_MATCH },
-        { $count: 'total' }
-      ];
-    }
-    return [{ $match: filterConditions }, { $group: { _id: '$numero' } }, { $count: 'total' }];
-  };
-
-  const totalPromise = filter === 'unread'
-    ? Promise.resolve(unreadCodes.length)
-    : Message.aggregate(getTotalPipeline(), { allowDiskUse: true }).then(r => r[0]?.total || 0);
-
   const startTime = Date.now();
-  const [conversations, contactNames, total] = await Promise.all([
-    Message.aggregate(pipeline, { allowDiskUse: true }),
-    Message.aggregate([
-      { $match: { ...BASE_MATCH, from_me: false } },
-      { $sort: { createdAt: -1 } },
-      { $group: { _id: '$numero', name: { $first: '$nombre_whatsapp' } } }
-    ], { allowDiskUse: true }),
-    totalPromise
+
+  const [threads, total] = await Promise.all([
+    Thread.find(threadFilter)
+      .sort({ lastMessageAt: -1 })
+      .skip(skip)
+      .limit(limit)
+      .lean(),
+    Thread.countDocuments(threadFilter)
   ]);
 
-  logger.info('[fetchConversationData] Completed', { duration: Date.now() - startTime, count: conversations.length });
+  logger.info('[fetchConversationData] Completed', { duration: Date.now() - startTime, count: threads.length });
 
-  const phoneNumbers = conversations.map(c => c._id).filter(Boolean);
+  const phoneNumbers = threads.map(t => t.code).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 || []).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 missingNombre = threads.filter(t => !t.nombre).map(t => t.code);
+    if (missingNombre.length) {
+      const formula = `OR(${missingNombre.map(p => `{whatsapp_id} = "${p}"`).join(', ')})`;
+      const records = await getRecordByFilter(Historial_Clinico_ID, 'estado_general', formula);
+      airtableNameMap = toMap((records || []).filter(r => r.name), r => r.whatsapp_id, r => r.name);
+    }
   }
 
-  const nameMap = {
-    ...toMap(contactNames, c => c?._id ? c._id : null, c => c.name || 'Desconocido'),
-    ...threadNameMap,
-    ...airtableNameMap
-  };
-  return { conversations, total, nameMap };
+  return { threads, total, airtableNameMap };
 };
 
 const getMediaType = (media) => {
@@ -139,29 +83,39 @@ const getMediaType = (media) => {
   return type === 'application' ? 'document' : subtype === 'webp' ? 'sticker' : type;
 };
 
-const processConversations = async (conversations, nameMap) => {
-  const createConversation = (conv, index) => {
-    const msg = conv?.latestMessage;
-    const phoneNumber = conv?._id || `error_${index}`;
+const processConversations = async (threads, airtableNameMap) => {
+  const createConversation = (thread, index) => {
+    const phoneNumber = thread?.code || `error_${index}`;
     return {
       phoneNumber,
-      name: nameMap[phoneNumber],
-      lastMessage: msg?.body || '',
-      lastMessageTime: msg?.createdAt || msg?.timestamp || new Date(),
-      messageCount: conv?.messageCount || 0,
-      unreadCount: conv?.unreadCount || 0,
-      isLastMessageMedia: !!msg?.media,
-      lastMessageType: getMediaType(msg?.media),
-      lastMessageFromMe: msg?.from_me || false,
-      review: conv?.review || false
+      name: thread?.nombre || airtableNameMap[phoneNumber] || 'Desconocido',
+      patientId: thread?.patient_id || null,
+      assistantId: thread?.assistant_id || null,
+      presetId: thread?.preset_id || null,
+      promptId: thread?.prompt_id || null,
+      version: thread?.version || null,
+      active: thread?.active ?? true,
+      stopped: thread?.stopped ?? false,
+      review: thread?.review ?? false,
+      unreadCount: thread?.unreadCount || 0,
+      messageCount: thread?.messageCount || 0,
+      nextSid: thread?.nextSid || [],
+      conversationId: thread?.conversation_id || null,
+      threadId: thread?.thread_id || null,
+      threadCreatedAt: thread?.createdAt || null,
+      threadUpdatedAt: thread?.updatedAt || null,
+      lastMessage: thread?.lastMessageBody || '',
+      lastMessageTime: thread?.lastMessageAt || null,
+      lastMessageFromMe: thread?.lastMessageFromMe || false,
+      isLastMessageMedia: !!thread?.lastMessageMedia,
+      lastMessageType: getMediaType(thread?.lastMessageMedia)
     };
   };
 
   try {
-    const result = (conversations || []).map((conv, index) => {
+    const result = (threads || []).map((thread, index) => {
       try {
-        if (!conv?.latestMessage) logger.warn('[processConversations] Missing latestMessage', { index, id: conv?._id });
-        return createConversation(conv, index);
+        return createConversation(thread, index);
       } catch (error) {
         logger.error('[processConversations] Error processing', { index, error: error.message });
         return null;

package/lib/storage/MongoStorage.js

@@ -37,14 +37,9 @@ class MongoStorage {
   async saveMessage(messageData) {
     try {
       const values = this.buildMessageValues(messageData);
-      const { isNew } = await insertMessage(values);
+      await insertMessage(values);
       logger.info('[MongoStorage] Message stored');
 
-      if (isNew && !values.from_me) {
-        Thread.findOneAndUpdate({ code: values.numero }, { $inc: { unreadCount: 1 } }, { upsert: true })
-          .catch(err => logger.warn('[MongoStorage] Failed to increment thread unread_count', { error: err.message }));
-      }
-
       const chatId = messageData.from;
       const messageId = messageData.messageId;
 

package/package.json

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