@peopl-health/nexus 1.5.2 → 1.5.3

package/lib/core/NexusMessaging.js

@@ -1,5 +1,4 @@
 const { airtable, getBase } = require('../config/airtableConfig');
-const { convertTwilioToInternalFormat } = require('../helpers/twilioHelper');
 const { replyAssistant } = require('../services/assistantService');
 const { createProvider } = require('../adapters/registry');
 
@@ -27,7 +26,15 @@ class NexusMessaging {
       onFlow: null
     };
     this.events = new EventEmitter();
-    this.middleware = { any: [], message: [], interactive: [], media: [], command: [], keyword: [], flow: [] };
+    this.middleware = {
+      any: [],
+      message: [],
+      interactive: [],
+      media: [],
+      command: [],
+      keyword: [],
+      flow: []
+    };
   }
 
   /**
@@ -118,7 +125,11 @@ class NexusMessaging {
    * Internal helper to run middleware pipeline and the final handler
    */
   async _runPipeline(type, messageData, finalHandler) {
-    const chain = [...(this.middleware.any || []), ...(this.middleware[type] || []), async (ctx) => { return finalHandler(ctx); }];
+    const chain = [
+      ...(this.middleware.any || []),
+      ...(this.middleware[type] || []),
+      async (ctx) => await finalHandler(ctx)
+    ];
     let idx = -1;
     const runner = async (i) => {
       if (i <= idx) throw new Error('next() called multiple times');
@@ -316,32 +327,69 @@ class NexusMessaging {
     }
   }
 
-  async handleMessage(messageData) {
-    this.events.emit && this.events.emit('message:received', messageData);
-    const final = async (ctx) => {
-      if (this.handlers.onMessage) {
-        return await this.handlers.onMessage(ctx, this);
-      } else {
-        return await this.handleMessageWithAssistant(ctx);
+  async _handleWithPipeline(type, handlerKey, messageData, fallback) {
+    this.events.emit(`${type}:received`, messageData);
+    const result = await this._runPipeline(type, messageData, async (ctx) => {
+      const handler = this.handlers[handlerKey];
+      if (handler) {
+        return await handler(ctx, this);
       }
-    };
-    const result = await this._runPipeline('message', messageData, final);
-    this.events.emit && this.events.emit('message:handled', messageData);
+      if (fallback) {
+        return await fallback(ctx);
+      }
+    });
+    this.events.emit(`${type}:handled`, messageData);
     return result;
   }
 
+  _extractAssistantInputs(messageData) {
+    if (!messageData || typeof messageData !== 'object') {
+      return { from: null, message: null };
+    }
+
+    const from = [
+      messageData.from,
+      messageData.sender,
+      messageData.numero,
+      messageData.code,
+      messageData.From,
+      messageData.key?.remoteJid,
+      messageData.raw?.from,
+      messageData.raw?.From,
+      messageData.raw?.key?.remoteJid
+    ].find((value) => typeof value === 'string' && value.trim().length > 0) || null;
+
+    const message = [
+      typeof messageData.message === 'string' ? messageData.message : null,
+      typeof messageData.message?.conversation === 'string' ? messageData.message.conversation : null,
+      typeof messageData.Body === 'string' ? messageData.Body : null,
+      typeof messageData.raw?.message?.conversation === 'string' ? messageData.raw.message.conversation : null,
+      typeof messageData.raw?.Body === 'string' ? messageData.raw.Body : null
+    ].find((value) => typeof value === 'string' && value.trim().length > 0) || null;
+
+    return { from, message };
+  }
+
+  async handleMessage(messageData) {
+    return await this._handleWithPipeline('message', 'onMessage', messageData, async (ctx) => {
+      return await this.handleMessageWithAssistant(ctx);
+    });
+  }
+
   async handleMessageWithAssistant(messageData) {
     try {
-      console.log('MESSAGE DATA', messageData);
+      const { from, message } = this._extractAssistantInputs(messageData);
 
-      const response = await replyAssistant(
-        messageData.from, 
-        messageData.message
-      );
+      if (!from || !message) {
+        console.warn('Unable to resolve assistant inputs from message, skipping automatic reply.');
+        return;
+      }
+
+      const response = await replyAssistant(from, message);
 
       if (response) {
         await this.sendMessage({
-          to: messageData.from,
+          to: from,
           message: response
         });
       }
@@ -354,63 +402,23 @@ class NexusMessaging {
     if (this.messageStorage) {
       await this.messageStorage.saveInteractive(messageData);
     }
-    this.events.emit && this.events.emit('interactive:received', messageData);
-    const final = async (ctx) => {
-      if (this.handlers.onInteractive) {
-        return await this.handlers.onInteractive(ctx, this);
-      }
-    };
-    const result = await this._runPipeline('interactive', messageData, final);
-    this.events.emit && this.events.emit('interactive:handled', messageData);
-    return result;
+    return await this._handleWithPipeline('interactive', 'onInteractive', messageData);
   }
 
   async handleMedia(messageData) {
-    this.events.emit && this.events.emit('media:received', messageData);
-    const final = async (ctx) => {
-      if (this.handlers.onMedia) {
-        return await this.handlers.onMedia(ctx, this);
-      }
-    };
-    const result = await this._runPipeline('media', messageData, final);
-    this.events.emit && this.events.emit('media:handled', messageData);
-    return result;
+    return await this._handleWithPipeline('media', 'onMedia', messageData);
   }
 
   async handleCommand(messageData) {
-    this.events.emit && this.events.emit('command:received', messageData);
-    const final = async (ctx) => {
-      if (this.handlers.onCommand) {
-        return await this.handlers.onCommand(ctx, this);
-      }
-    };
-    const result = await this._runPipeline('command', messageData, final);
-    this.events.emit && this.events.emit('command:handled', messageData);
-    return result;
+    return await this._handleWithPipeline('command', 'onCommand', messageData);
   }
 
   async handleKeyword(messageData) {
-    this.events.emit && this.events.emit('keyword:received', messageData);
-    const final = async (ctx) => {
-      if (this.handlers.onKeyword) {
-        return await this.handlers.onKeyword(ctx, this);
-      }
-    };
-    const result = await this._runPipeline('keyword', messageData, final);
-    this.events.emit && this.events.emit('keyword:handled', messageData);
-    return result;
+    return await this._handleWithPipeline('keyword', 'onKeyword', messageData);
   }
 
   async handleFlow(messageData) {
-    this.events.emit && this.events.emit('flow:received', messageData);
-    const final = async (ctx) => {
-      if (this.handlers.onFlow) {
-        return await this.handlers.onFlow(ctx, this);
-      }
-    };
-    const result = await this._runPipeline('flow', messageData, final);
-    this.events.emit && this.events.emit('flow:handled', messageData);
-    return result;
+    return await this._handleWithPipeline('flow', 'onFlow', messageData);
   }
 
   /**

package/lib/index.js

@@ -67,10 +67,11 @@ class Nexus {
 
     // Auto-configure template controllers with active provider when Twilio is used
     try {
-      const activeProvider = typeof this.messaging.getProvider === 'function' 
-        ? this.messaging.getProvider() 
+      const activeProvider = typeof this.messaging.getProvider === 'function'
+        ? this.messaging.getProvider()
         : null;
-      if (activeProvider && activeProvider.constructor && activeProvider.constructor.name === 'TwilioProvider') {
+
+      if (activeProvider instanceof TwilioProvider) {
         if (typeof templateController.configureNexusProvider === 'function') {
           templateController.configureNexusProvider(activeProvider);
         }
@@ -129,28 +130,24 @@ class Nexus {
     if (llm === 'openai') {
       this.llmProvider = new DefaultLLMProvider(llmConfig);
       try {
-        if (this.llmProvider && typeof this.llmProvider.getClient === 'function') {
+        if (typeof this.llmProvider.getClient === 'function') {
           llmConfigModule.openaiClient = this.llmProvider.getClient();
         }
       } catch (err) {
         console.warn('[Nexus] Failed to expose OpenAI client:', err?.message || err);
       }
+    }
 
     // Convenience: handle common top-level config for mongo, media bucket, airtable
     try {
-      // Mongo URI passthrough for storage=mongo
-      if (options.mongoUri && storage === 'mongo') {
-        if (typeof storageConfig === 'object') {
-          storageConfig.mongoUri = storageConfig.mongoUri || options.mongoUri;
-        }
+      if (options.mongoUri && storage === 'mongo' && typeof storageConfig === 'object') {
+        storageConfig.mongoUri = storageConfig.mongoUri || options.mongoUri;
       }
 
-      // Media bucket (overrides storage setting)
       if (options.media && options.media.bucketName) {
         runtimeConfig.set('AWS_S3_BUCKET_NAME', options.media.bucketName);
       }
 
-      // Airtable base default (accepts alias like 'calendar' or an ID)
       if (options.airtable && options.airtable.base) {
         runtimeConfig.set('AIRTABLE_BASE_ID', options.airtable.base);
       }
@@ -161,13 +158,11 @@ class Nexus {
       console.warn('[Nexus] convenience config warning:', cfgErr?.message || cfgErr);
     }
 
-    }
-
 
     // Configure Assistants (registry + overrides)
     const assistantsConfig = assistantsOpt || assistantOpt;
     try {
-      if (this.llmProvider && typeof configureAssistantsLLM === 'function') {
+      if (this.llmProvider && typeof configureAssistantsLLM === 'function' && typeof this.llmProvider.getClient === 'function') {
         // Provide the raw OpenAI client to the assistant service
         configureAssistantsLLM(this.llmProvider.getClient());
       }

package/lib/services/conversationService.js

@@ -56,6 +56,7 @@ const fetchConversationData = async (filter, skip, limit) => {
       nombre_whatsapp: 1,
       from_me: 1
     }},
+    { $sort: { createdAt: 1, timestamp: 1 } },
     { $group: {
       _id: '$numero',
       latestMessage: { $last: '$$ROOT' },
@@ -169,8 +170,10 @@ const fetchConversationData = async (filter, skip, limit) => {
       { $project: {
         numero: 1,
         from_me: 1,
-        createdAt: 1
+        createdAt: 1,
+        timestamp: 1
       }},
+      { $sort: { createdAt: -1, timestamp: -1 } },
       { $group: {
         _id: '$numero',
         latestMessage: { $first: '$$ROOT' }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "publishConfig": {
     "access": "public"