@peopl-health/nexus 2.4.7 → 2.4.9-fix-pdf-processing

package/lib/helpers/messageHelper.js

@@ -1,5 +1,6 @@
 const moment = require('moment-timezone');
 const { Message } = require('../models/messageModel.js');
+const { logger } = require('../utils/logger');
 
 const addMessageToThread = async (reply, messagesChat, provider, thread) => {
   const threadId = thread.getConversationId();
@@ -18,7 +19,7 @@ const addMessageToThread = async (reply, messagesChat, provider, thread) => {
     });
   }
   
-  console.log(`[addMessageToThread] Message added - ID: ${reply.message_id}, Thread: ${threadId}, Origin: ${reply.origin}`);
+  logger.info(`[addMessageToThread] Message added - ID: ${reply.message_id}, Thread: ${threadId}, Origin: ${reply.origin}`);
 };
 
 const updateMessageRecord = async (reply, thread) => {
@@ -33,7 +34,7 @@ const updateMessageRecord = async (reply, thread) => {
     } }
   );
   
-  console.log(`[updateMessageRecord] Record updated - ID: ${reply.message_id}, Thread: ${threadId}, Processed: true`);
+  logger.info(`[updateMessageRecord] Record updated - ID: ${reply.message_id}, Thread: ${threadId}, Processed: true`);
 };
 
 
@@ -44,21 +45,21 @@ async function getLastMessages(code) {
       .sort({ createdAt: 1 });
 
     if (!lastMessages || lastMessages.length === 0) {
-      console.log(`[getLastMessages] No messages found for code: ${code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown'}`);
+      logger.info(`[getLastMessages] No messages found for code: ${code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown'}`);
       return null;
     }
 
     const unprocessedMessages = lastMessages.filter(msg => !msg.processed);
     if (unprocessedMessages.length === 0) {
-      console.log(`[getLastMessages] No unprocessed messages for code: ${code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown'}`);
+      logger.info(`[getLastMessages] No unprocessed messages for code: ${code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown'}`);
       return null;
     }
 
-    console.log(`[getLastMessages] Found ${unprocessedMessages.length} unprocessed messages for code: ${code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown'}`);
+    logger.info(`[getLastMessages] Found ${unprocessedMessages.length} unprocessed messages for code: ${code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown'}`);
     return unprocessedMessages;
 
   } catch (error) {
-    console.error(`[getLastMessages] Error for code: ${code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown'}:`, error?.message || String(error));
+    logger.error(`[getLastMessages] Error for code: ${code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown'}:`, error?.message || String(error));
     return null;
   }
 }
@@ -70,15 +71,15 @@ async function getLastNMessages(code, n) {
       .limit(n);
 
     if (!lastMessages || lastMessages.length === 0) {
-      console.log(`[getLastNMessages] No messages found for code: ${code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown'}, limit: ${n}`);
+      logger.info(`[getLastNMessages] No messages found for code: ${code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown'}, limit: ${n}`);
       return [];
     }
 
-    console.log(`[getLastNMessages] Found ${lastMessages.length} messages for code: ${code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown'}, limit: ${n}`);
+    logger.info(`[getLastNMessages] Found ${lastMessages.length} messages for code: ${code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown'}, limit: ${n}`);
     return lastMessages;
 
   } catch (error) {
-    console.error(`[getLastNMessages] Error for code: ${code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown'}, limit: ${n}:`, error?.message || String(error));
+    logger.error(`[getLastNMessages] Error for code: ${code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown'}, limit: ${n}:`, error?.message || String(error));
     return [];
   }
 }
@@ -91,7 +92,7 @@ function formatMessage(reply) {
     
     const msgDate = new Date(reply.createdAt);    
     if (isNaN(msgDate.getTime())) {
-      console.warn(`[formatMessage] Invalid timestamp for message ID: ${reply.message_id}`);
+      logger.warn(`[formatMessage] Invalid timestamp for message ID: ${reply.message_id}`);
       return reply.body;
     }
     
@@ -102,7 +103,7 @@ function formatMessage(reply) {
     
     return `[${mexicoCityTime}] ${reply.body}`;
   } catch (error) {
-    console.error(`[formatMessage] Error for message ID: ${reply.message_id}:`, error?.message || String(error));
+    logger.error(`[formatMessage] Error for message ID: ${reply.message_id}:`, error?.message || String(error));
     return null;
   } 
 }

package/lib/helpers/processHelper.js

@@ -2,7 +2,7 @@ const fs = require('fs');
 const { generatePresignedUrl } = require('../config/awsConfig.js');
 const { analyzeImage } = require('./llmsHelper.js');
 const { cleanupFiles, downloadMediaAndCreateFile } = require('./filesHelper.js');
-const { formatMessage, addMessageToThread, updateMessageRecord } = require('./messageHelper.js');
+const { formatMessage } = require('./messageHelper.js');
 const { sanitizeLogMetadata } = require('../utils/sanitizer.js');
 
 /**
@@ -66,7 +66,7 @@ const processImageFile = async (fileName, reply) => {
                     fileName.toLowerCase().includes('/sticker/');
 
   try {
-    imageAnalysis = await analyzeImage(fileName, isSticker);
+    imageAnalysis = await analyzeImage(fileName, isSticker, reply.media?.contentType);
     
     logger.info('processImageFile', {
       message_id: reply.message_id,

package/lib/helpers/qrHelper.js

@@ -1,4 +1,5 @@
 const qrcode = require('qrcode');
+const { logger } = require('../utils/logger');
 
 
 async function generateQRBuffer(text) {
@@ -6,7 +7,7 @@ async function generateQRBuffer(text) {
     const qrBuffer = await qrcode.toBuffer(text, { type: 'image/png' });
     return qrBuffer;
   } catch (err) {
-    console.error('Error generating QR code:', err.stack);
+    logger.error('Error generating QR code', { error: err.message, stack: err.stack });
     throw err;
   }
 }

package/lib/helpers/twilioMediaProcessor.js

@@ -5,28 +5,20 @@ const {
   getMediaTypeFromContentType,
   extractTitle
 } = require('./twilioHelper');
-const { validateMedia } = require('../utils/mediaValidator');
 const { generatePresignedUrl } = require('../config/awsConfig');
 const { addLinkedRecord } = require('../services/airtableService');
 const { Monitoreo_ID } = require('../config/airtableConfig');
-
-const ensureLogger = (logger) => {
-  if (!logger) return console;
-  const fallback = {};
-  for (const level of ['info', 'warn', 'error', 'debug']) {
-    fallback[level] = typeof logger[level] === 'function' ? logger[level].bind(logger) : console[level].bind(console);
-  }
-  return fallback;
-};
+const { validateMedia } = require('../utils/mediaValidator');
+const { logger } = require('../utils/logger');
 
 const normalizeMediaType = (type) => {
   if (!type || typeof type !== 'string') return 'document';
   return type.replace(/Message$/i, '').replace(/WithCaption$/i, '').toLowerCase();
 };
 
-async function uploadMediaToAirtable(whatsappId, mediaUrl, log, baseID, tableName) {
+async function uploadMediaToAirtable(whatsappId, mediaUrl, baseID, tableName) {
   if (!baseID) {
-    log.debug && log.debug('[uploadMediaToAirtable] Base ID not configured; skipping Airtable upload');
+    logger.debug('[uploadMediaToAirtable] Base ID not configured; skipping Airtable upload');
     return;
   }
 
@@ -45,25 +37,23 @@ async function uploadMediaToAirtable(whatsappId, mediaUrl, log, baseID, tableNam
       }
     );
     
-    log.debug && log.debug('[uploadMediaToAirtable] Successfully uploaded media to estudios table', { whatsappId });
+    logger.debug('[uploadMediaToAirtable] Successfully uploaded media to estudios table', { whatsappId });
   } catch (error) {
-    log.warn && log.warn('[uploadMediaToAirtable] Failed to upload media to estudios table', { whatsappId, error: error?.message || error });
+    logger.warn('[uploadMediaToAirtable] Failed to upload media to estudios table', { whatsappId, error: error?.message || error });
     throw error;
   }
 }
 
-async function processTwilioMediaMessage(twilioMessage, logger, bucketName) {
+async function processTwilioMediaMessage(twilioMessage, bucketName) {
   if (!twilioMessage) return [];
-
-  const log = ensureLogger(logger);
   const numMedia = parseInt(twilioMessage.NumMedia || '0', 10);
   if (!numMedia || numMedia <= 0) {
-    log.debug && log.debug('[TwilioMedia] No media detected in message');
+    logger.debug('[TwilioMedia] No media detected in message');
     return [];
   }
 
   if (!bucketName) {
-    log.warn && log.warn('[TwilioMedia] AWS bucket not configured; skipping media processing');
+    logger.warn('[TwilioMedia] AWS bucket not configured; skipping media processing');
     return [];
   }
 
@@ -78,25 +68,25 @@ async function processTwilioMediaMessage(twilioMessage, logger, bucketName) {
     const contentType = twilioMessage[`MediaContentType${i}`];
 
     if (!mediaUrl || !contentType) {
-      log.warn && log.warn('[TwilioMedia] Missing media URL or content type', { index: i });
+      logger.warn('[TwilioMedia] Missing media URL or content type', { index: i });
       continue;
     }
 
-    log.info && log.info('[TwilioMedia] Processing media item', { index: i, contentType, mediaUrl });
+    logger.info('[TwilioMedia] Processing media item', { index: i, contentType, mediaUrl });
 
     let mediaBuffer;
     try {
-      mediaBuffer = await downloadMediaFromTwilio(mediaUrl, log);
+      mediaBuffer = await downloadMediaFromTwilio(mediaUrl, logger);
     } catch (error) {
-      log.error && log.error('[TwilioMedia] Failed to download media', { index: i, error: error?.message || error });
+      logger.error('[TwilioMedia] Failed to download media', { index: i, error: error?.message || error });
       continue;
     }
 
     const validationResult = validateMedia(mediaBuffer, contentType);
     if (!validationResult.valid) {
-      log.warn && log.warn('[TwilioMedia] Media validation warning', { index: i, message: validationResult.message });
+      logger.warn('[TwilioMedia] Media validation warning', { index: i, message: validationResult.message });
     } else {
-      log.debug && log.debug('[TwilioMedia] Media validation passed', { index: i, message: validationResult.message });
+      logger.debug('[TwilioMedia] Media validation passed', { index: i, message: validationResult.message });
     }
 
     const helperMediaType = getMediaTypeFromContentType(contentType);
@@ -119,7 +109,7 @@ async function processTwilioMediaMessage(twilioMessage, logger, bucketName) {
         derivedMediaType
       );
     } catch (error) {
-      log.error && log.error('[TwilioMedia] Failed to upload media to S3', { index: i, error: error?.message || error });
+      logger.error('[TwilioMedia] Failed to upload media to S3', { index: i, error: error?.message || error });
       continue;
     }
 
@@ -146,16 +136,16 @@ async function processTwilioMediaMessage(twilioMessage, logger, bucketName) {
       item.metadata.presignedUrl = url;
 
       if (derivedMediaType !== 'sticker') {
-        await uploadMediaToAirtable(code, url, log, Monitoreo_ID, 'estudios');
+        await uploadMediaToAirtable(code, url, Monitoreo_ID, 'estudios');
       }
     } catch (error) {
-      log.warn && log.warn('[TwilioMedia] Failed to update Airtable with media reference', { index: i, error: error?.message || error });
+      logger.warn('[TwilioMedia] Failed to update Airtable with media reference', { index: i, error: error?.message || error });
     }
 
     mediaItems.push(item);
   }
 
-  console.log('[TwilioMedia] Completed processing', {
+  logger.info('[TwilioMedia] Completed processing', {
     from: code,
     itemsStored: mediaItems.length,
     bucket: bucketName

package/lib/helpers/whatsappHelper.js

@@ -1,4 +1,5 @@
 const moment = require('moment-timezone');
+const { logger } = require('../utils/logger');
 
 
 function delay(ms) {
@@ -7,7 +8,7 @@ function delay(ms) {
 
 
 function formatCode(codeBase) {
-  console.log(`formatCode ${codeBase}`);
+  logger.info(`formatCode ${codeBase}`);
 
   const [number, domain] = codeBase.split('@');
     
@@ -50,7 +51,7 @@ function calculateDelay(sendTime, timeZone) {
     const delay = sendMoment.diff(now) + randomDelay;
 
     // Log the calculated details for debugging
-    console.log(
+    logger.info(
       'Scheduled Time:', sendMoment.format(), 
       'Current Time:', now.format(), 
       'Delay (minutes):', delay / 60000, 

package/lib/index.js

@@ -25,9 +25,9 @@ const {
 } = require('./services/preprocessingHooks');
 const { 
   requestIdMiddleware, 
-  getRequestId, 
-  logger 
+  getRequestId
 } = require('./middleware/requestId');
+const { logger } = require('./utils/logger');
 
 /**
  * Main Nexus class that orchestrates all components
@@ -39,7 +39,7 @@ class Nexus {
     try {
       setDefaultInstance(this.messaging);
     } catch (err) {
-      console.warn('[Nexus] Failed to set default messaging instance:', err?.message || err);
+      logger.warn('[Nexus] Failed to set default messaging instance:', err?.message || err);
     }
     this.storage = null;
     this.messageParser = null;
@@ -92,11 +92,10 @@ class Nexus {
         }
       }
     } catch (e) {
-      console.warn('Warning: failed to auto-configure template providers:', e?.message || e);
+      logger.warn('Warning: failed to auto-configure template providers:', e?.message || e);
     }
 
-
-    // Convenience: handle mongoUri early (before storage connect)
+    // Handle mongoUri early (before storage connect)
     try {
       if (options.mongoUri) {
         if (storage === 'mongo') {
@@ -104,12 +103,11 @@ class Nexus {
             storageConfig.mongoUri = options.mongoUri;
           }
         } else {
-          // If not using MongoStorage but a URI is provided, initialize default mongoose connection
           await this.messaging.initializeMongoDB(options.mongoUri);
         }
       }
     } catch (dbErr) {
-      console.warn('[Nexus] mongo convenience warning:', dbErr?.message || dbErr);
+      logger.warn('[Nexus] mongo convenience warning:', dbErr?.message || dbErr);
     }
 
     // Initialize storage if provided
@@ -119,9 +117,8 @@ class Nexus {
         if (typeof storage === 'string') {
           this.storage = createStorage(storage, storageConfig || {});
         } else if (typeof storage === 'object' && (storage.saveMessage || storage.saveInteractive)) {
-          this.storage = storage; // external adapter instance
+          this.storage = storage;
         } else {
-          // default to mongo if truthy but not recognized
           this.storage = createStorage('mongo', storageConfig || {});
         }
         if (this.storage && typeof this.storage.connect === 'function') {
@@ -129,7 +126,7 @@ class Nexus {
         }
         this.messaging.setMessageStorage(this.storage);
       } catch (e) {
-        console.warn('Warning: storage initialization failed:', e?.message || e);
+        logger.warn('Warning: storage initialization failed:', e?.message || e);
       }
     }
 
@@ -150,7 +147,7 @@ class Nexus {
           llmConfigModule.setOpenAIClient(providerInstance.getClient());
         }
       } catch (err) {
-        console.warn('[Nexus] Failed to expose OpenAI provider:', err?.message || err);
+        logger.warn('[Nexus] Failed to expose OpenAI provider:', err?.message || err);
       }
     }
 
@@ -171,7 +168,7 @@ class Nexus {
         runtimeConfig.set('AIRTABLE_API_KEY', options.airtable.apiKey);
       }
     } catch (cfgErr) {
-      console.warn('[Nexus] convenience config warning:', cfgErr?.message || cfgErr);
+      logger.warn('[Nexus] convenience config warning:', cfgErr?.message || cfgErr);
     }
 
 
@@ -195,7 +192,7 @@ class Nexus {
         }
       }
     } catch (e) {
-      console.warn('Warning: failed to configure assistants:', e?.message || e);
+      logger.warn('Warning: failed to configure assistants:', e?.message || e);
     }
 
     this.isInitialized = true;

package/lib/interactive/index.js

@@ -1,6 +1,7 @@
 
 const { toTwilioContent } = require('./twilioMapper');
 const { registerFlow, getFlow, listFlows, registerInteractiveHandler, listInteractiveHandlers } = require('./registry');
+const { logger } = require('../utils/logger');
 
 async function sendInteractive(nexusOrMessaging, params) {
   const { code, spec, id, variables } = params || {};
@@ -28,16 +29,6 @@ async function sendInteractive(nexusOrMessaging, params) {
   throw new Error('Interactive/flows not supported for this provider');
 }
 
-module.exports = {
-  registerFlow,
-  getFlow,
-  listFlows,
-  sendInteractive,
-  registerInteractiveHandler,
-  attachInteractiveRouter
-};
-
-
 function _matchInteractive(match, interactive) {
   if (!match) return true;
   if (!interactive) return false;
@@ -76,7 +67,7 @@ function attachInteractiveRouter(nexusOrMessaging) {
           await handler(messageData, messaging);
         }
       } catch (e) {
-        console.warn('Interactive handler error:', e && e.message || e);
+        logger.warn('Interactive handler error:', e && e.message || e);
       }
     }
   };
@@ -84,3 +75,12 @@ function attachInteractiveRouter(nexusOrMessaging) {
   bus.on('interactive:received', handler);
   return () => bus.off && bus.off('interactive:received', handler);
 }
+
+module.exports = {
+  registerFlow,
+  getFlow,
+  listFlows,
+  sendInteractive,
+  registerInteractiveHandler,
+  attachInteractiveRouter
+};

package/lib/middleware/requestId.js

@@ -1,41 +1,36 @@
 const { AsyncLocalStorage } = require('async_hooks');
 const { v4: uuidv4 } = require('uuid');
+const { setRequestIdGetter } = require('../utils/logger');
 
 const requestContext = new AsyncLocalStorage();
 
 function getRequestId() {
   const store = requestContext.getStore();
-  return store?.requestId || 'no-context';
+  return store?.requestId || null;
 }
 
+setRequestIdGetter(getRequestId);
+
 function requestIdMiddleware(req, res, next) {
   const requestId = uuidv4().substring(0, 8);
   req.requestId = requestId;
   res.setHeader('X-Request-Id', requestId);
   
   requestContext.run({ requestId }, () => {
-    console.log(`[${requestId}] → ${req.method} ${req.path}`);
-    
     const startTime = Date.now();
+    
     res.on('finish', () => {
       const duration = Date.now() - startTime;
-      console.log(`[${requestId}] ← ${res.statusCode} ${req.method} ${req.path} (${duration}ms)`);
+      if (process.env.LOG_HTTP_REQUESTS === 'true') {
+        console.log(`[${requestId}] ${req.method} ${req.path} - ${res.statusCode} (${duration}ms)`);
+      }
     });
     
     next();
   });
 }
 
-const logger = {
-  log: (...args) => console.log(`[${getRequestId()}]`, ...args),
-  error: (...args) => console.error(`[${getRequestId()}]`, ...args),
-  warn: (...args) => console.warn(`[${getRequestId()}]`, ...args),
-  info: (...args) => console.info(`[${getRequestId()}]`, ...args),
-  debug: (...args) => console.debug(`[${getRequestId()}]`, ...args)
-};
-
 module.exports = { 
   requestIdMiddleware, 
-  getRequestId,
-  logger 
+  getRequestId
 };

package/lib/models/messageModel.js

@@ -2,6 +2,7 @@ const mongoose = require('mongoose');
 const moment = require('moment-timezone');
 const { getRecordByFilter } = require('../services/airtableService');
 const { Monitoreo_ID } = require('../config/airtableConfig');
+const { logger } = require('../utils/logger');
 
 
 const messageSchema = new mongoose.Schema({
@@ -79,7 +80,7 @@ async function getClinicalContext(whatsappId) {
     }
     return null;
   } catch (error) {
-    console.error('Error fetching clinical context from Airtable:', error);
+    logger.error('Error fetching clinical context from Airtable:', error);
     return null;
   }
 }
@@ -116,9 +117,9 @@ async function insertMessage(values) {
       { upsert: true, new: true }
     );
 
-    console.log('[MongoStorage] Message inserted or updated successfully');
+    logger.info('[MongoStorage] Message inserted or updated successfully');
   } catch (err) {
-    console.error('[MongoStorage] Error inserting message:', err);
+    logger.error('[MongoStorage] Error inserting message:', err);
     throw err;
   }
 }
@@ -173,7 +174,7 @@ async function getContactDisplayName(contactNumber) {
       return contactNumber;
     }
   } catch (error) {
-    console.error('[MongoStorage] Error fetching display name for ${contactNumber}:', error);
+    logger.error('[MongoStorage] Error fetching display name for ${contactNumber}:', error);
     return contactNumber;
   }
 }

package/lib/providers/OpenAIAssistantsProvider.js

@@ -1,5 +1,6 @@
 const { OpenAI } = require('openai');
 const { retryWithBackoff } = require('../utils/retryHelper');
+const { logger } = require('../utils/logger');
 
 const DEFAULT_MAX_RETRIES = parseInt(process.env.MAX_RETRIES || '10', 10);
 const PROVIDER_NAME = 'OpenAIAssistantsProvider';
@@ -274,7 +275,7 @@ class OpenAIAssistantsProvider {
         const result = await assistant.executeTool(name, args);
         outputs.push({ tool_call_id: call.id, output: typeof result === 'string' ? result : JSON.stringify(result) });
       } catch (error) {
-        console.error('[OpenAIAssistantsProvider] Tool execution failed', error);
+        logger.error('[OpenAIAssistantsProvider] Tool execution failed', error);
         outputs.push({
           tool_call_id: call.id,
           output: JSON.stringify({ success: false, error: error?.message || 'Tool execution failed' })
@@ -294,19 +295,19 @@ class OpenAIAssistantsProvider {
   async checkRunStatus(assistant, thread_id, run_id, retryCount = 0, maxRetries = DEFAULT_MAX_RETRIES, actionHandled = false) {
     try {
       const run = await this.getRun({ threadId: thread_id, runId: run_id });
-      console.log(`Status: ${run.status} ${thread_id} ${run_id} (attempt ${retryCount + 1})`);
+      logger.info(`Status: ${run.status} ${thread_id} ${run_id} (attempt ${retryCount + 1})`);
 
       const failedStatuses = ['failed', 'expired', 'incomplete', 'errored'];
       if (failedStatuses.includes(run.status)) {
-        console.log(`Run failed. ${run.status} `);
-        console.log('Error:');
-        console.log(run);
+        logger.info(`Run failed. ${run.status} `);
+        logger.info('Error:');
+        logger.info(run);
         return {run, completed: false};
       } else if (run.status === 'cancelled') {
-        console.log('cancelled');
+        logger.info('cancelled');
         return {run, completed: true};
       } else if (run.status === 'requires_action') {
-        console.log('requires_action');
+        logger.info('requires_action');
         if (retryCount >= maxRetries) {
           return {run, completed: false};
         }
@@ -325,11 +326,11 @@ class OpenAIAssistantsProvider {
         await new Promise(resolve => setTimeout(resolve, 1000));
         return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, actionHandled);
       } else {
-        console.log('Run completed.');
+        logger.info('Run completed.');
         return {run, completed: true};
       }
     } catch (error) {
-      console.error('Error checking run status:', error);
+      logger.error('Error checking run status:', error);
       return {run: null, completed: false};
     }
   }