@peopl-health/nexus 1.2.0 → 1.3.1

package/lib/adapters/BaileysProvider.js

@@ -14,7 +14,10 @@ class BaileysProvider extends MessageProvider {
 
   async initialize() {
     try {
-      const { default: makeWASocket, useMultiFileAuthState } = require('baileys');
+      const baileys = require('baileys');
+      // Support both CJS and ESM shapes
+      const makeWASocket = baileys.default || baileys.makeWASocket || baileys;
+      const useMultiFileAuthState = baileys.useMultiFileAuthState || baileys.useMultiFileAuthState;
       const { useMongoDBAuthState } = require('../config/mongoAuthConfig');
       const pino = require('pino');
       
@@ -175,6 +178,27 @@ class BaileysProvider extends MessageProvider {
     }
     this.isConnected = false;
   }
+
+  // Content/Template operations are not supported for Baileys
+  async listTemplates() {
+    throw new Error('Template operations are only supported with Twilio provider');
+  }
+  async getTemplate() {
+    throw new Error('Template operations are only supported with Twilio provider');
+  }
+  async checkApprovalStatus() {
+    throw new Error('Template operations are only supported with Twilio provider');
+  }
+  async submitForApproval() {
+    throw new Error('Template operations are only supported with Twilio provider');
+  }
+  async deleteTemplate() {
+    throw new Error('Template operations are only supported with Twilio provider');
+  }
+  async createTemplate() {
+    throw new Error('Template operations are only supported with Twilio provider');
+  }
+
 }
 
 module.exports = { BaileysProvider };

package/lib/adapters/TwilioProvider.js

@@ -1,4 +1,5 @@
 const { MessageProvider } = require('../core/MessageProvider');
+const axios = require('axios');
 
 /**
  * Twilio WhatsApp messaging provider
@@ -132,6 +133,112 @@ class TwilioProvider extends MessageProvider {
       throw new Error(`Failed to list templates: ${error.message}`);
     }
   }
+
+  /**
+   * Fetch a specific template/content by SID
+   */
+  async getTemplate(sid) {
+    if (!this.isConnected || !this.twilioClient) {
+      throw new Error('Twilio provider not initialized');
+    }
+    if (!sid) throw new Error('Content SID is required');
+    try {
+      const content = await this.twilioClient.content.v1.contents(sid).fetch();
+      return content;
+    } catch (error) {
+      throw new Error(`Failed to get template: ${error.message}`);
+    }
+  }
+
+  /**
+   * Attempt to check approval status.
+   * Twilio SDK may not expose approval requests directly; return content and null approval by default.
+   */
+  async checkApprovalStatus(sid) {
+    if (!sid) throw new Error('Content SID is required');
+    const content = await this.getTemplate(sid);
+    try {
+      const links = (content && content.links) || {};
+      let approvalsUrl = links.approvals || links.approvalRequests || links.approval_requests;
+      if (!approvalsUrl) {
+        approvalsUrl = 'https://content.twilio.com/v1/Content/' + sid + '/ApprovalRequests';
+      }
+      const resp = await axios.get(approvalsUrl, { auth: { username: this.accountSid, password: this.authToken } });
+      const data = resp && resp.data ? resp.data : null;
+      let approvals = [];
+      if (data) {
+        approvals = data.approval_requests || data.approvalRequests || data.results || data.data || (Array.isArray(data) ? data : []);
+        if (!Array.isArray(approvals) && data.approvalRequest) approvals = [data.approvalRequest];
+      }
+      const approvalRequest = Array.isArray(approvals) && approvals.length > 0 ? approvals[0] : null;
+      return { content, approvalRequest };
+    } catch (error) {
+      // If approval endpoint unavailable, return content only
+      return { content, approvalRequest: null, warning: error.message };
+    }
+  }
+
+  /**
+   * Submit template for approval (best-effort placeholder)
+   */
+  async submitForApproval(contentSid, name, category) {
+    if (!contentSid) throw new Error('Content SID is required');
+    const content = await this.getTemplate(contentSid);
+    try {
+      const links = (content && content.links) || {};
+      let approvalsUrl = links.approvals || links.approvalRequests || links.approval_requests;
+      if (!approvalsUrl) {
+        approvalsUrl = 'https://content.twilio.com/v1/Content/' + contentSid + '/ApprovalRequests';
+      }
+      const payload = {
+        name,
+        category,
+        friendly_name: name,
+        categories: category ? [category] : undefined,
+        channel: 'whatsapp'
+      };
+      const resp = await axios.post(approvalsUrl, payload, { auth: { username: this.accountSid, password: this.authToken } });
+      return { success: true, contentSid, approvalRequest: resp.data || null };
+    } catch (error) {
+      throw new Error(`Failed to submit for approval: ${error.message}`);
+    }
+  }
+
+  /**
+   * Delete a template/content by SID
+   */
+  async deleteTemplate(sid) {
+    if (!this.isConnected || !this.twilioClient) {
+      throw new Error('Twilio provider not initialized');
+    }
+    if (!sid) throw new Error('Content SID is required');
+    try {
+      await this.twilioClient.content.v1.contents(sid).remove();
+      return { success: true };
+    } catch (error) {
+      throw new Error(`Failed to delete template: ${error.message}`);
+    }
+  }
+
+  /**
+   * Create a template/content using Twilio Content API
+   * @param {Object} templateData - Must follow Twilio Content API schema
+   */
+  async createTemplate(templateData) {
+    if (!this.isConnected || !this.twilioClient) {
+      throw new Error('Twilio provider not initialized');
+    }
+    if (!templateData || typeof templateData !== 'object') {
+      throw new Error('templateData must be an object');
+    }
+    try {
+      const created = await this.twilioClient.content.v1.contents.create(templateData);
+      return created;
+    } catch (error) {
+      throw new Error(`Failed to create template: ${error.message}`);
+    }
+  }
+
 }
 
 module.exports = { TwilioProvider };

package/lib/adapters/registry.js

@@ -0,0 +1,29 @@
+const { TwilioProvider } = require('./TwilioProvider');
+const { BaileysProvider } = require('./BaileysProvider');
+
+const _providers = new Map();
+
+function registerProvider(name, ProviderClass) {
+  if (!name || !ProviderClass) throw new Error('registerProvider requires name and ProviderClass');
+  _providers.set(String(name).toLowerCase(), ProviderClass);
+}
+
+function getProvider(name) {
+  return _providers.get(String(name || '').toLowerCase());
+}
+
+function createProvider(name, config) {
+  const ProviderClass = getProvider(name);
+  if (!ProviderClass) throw new Error(`Unsupported provider: ${name}`);
+  return new ProviderClass(config || {});
+}
+
+// Register built-ins
+registerProvider('twilio', TwilioProvider);
+registerProvider('baileys', BaileysProvider);
+
+module.exports = {
+  registerProvider,
+  getProvider,
+  createProvider
+};

package/lib/config/configLoader.js

@@ -0,0 +1,38 @@
+const path = require('path');
+
+const defaults = {
+  provider: { name: 'twilio', config: {} },
+  storage: null,
+  features: { airtable: true, s3: true },
+  assistants: { registry: {}, select: {}, getAssistantById: null },
+  handlers: {},
+  interactive: {}
+};
+
+function merge(a, b) {
+  if (!b) return { ...a };
+  const out = { ...a };
+  for (const k of Object.keys(b)) {
+    if (b[k] && typeof b[k] === 'object' && !Array.isArray(b[k])) {
+      out[k] = merge(a[k] || {}, b[k]);
+    } else {
+      out[k] = b[k];
+    }
+  }
+  return out;
+}
+
+function loadNexusConfig(userConfig) {
+  if (userConfig && typeof userConfig === 'object') {
+    return merge(defaults, userConfig);
+  }
+  try {
+    const localPath = path.resolve(process.cwd(), 'nexus.config.js');
+    const fileConfig = require(localPath);
+    return merge(defaults, fileConfig || {});
+  } catch {
+    return { ...defaults };
+  }
+}
+
+module.exports = { loadNexusConfig, defaults };

package/lib/controllers/assistantController.js

@@ -1,6 +1,6 @@
 const { Config_ID } = require('../config/airtableConfig');
 
-const { updateThreadActive, updateThreadStop, Thread } = require('../models/threadModel');
+const { Thread } = require('../models/threadModel');
 
 const { getRecordByFilter } = require('../services/airtableService');
 const { createAssistant, addMsgAssistant, addInsAssistant } = require('../services/assistantService');
@@ -12,7 +12,7 @@ const activeAssistantController = async (req, res) => {
   const { code, active } = req.body;
 
   try {
-    await updateThreadActive(code, active);
+    await Thread.updateOne({ code }, { $set: { active: !!active } });
     return res.status(200).send({ message: 'Active assistant' });
   } catch (error) {
     console.log(error);
@@ -34,7 +34,7 @@ const addInsAssistantController = async (req, res) => {
 };
 
 const addMsgAssistantController = async (req, res) => {
-  const { code, messages, reply } = req.body;
+  const { code, messages, reply = false } = req.body;
 
   try {
     const ans = await addMsgAssistant(code, messages, reply);
@@ -47,7 +47,7 @@ const addMsgAssistantController = async (req, res) => {
 };
 
 const createAssistantController = async (req, res) => {
-  const { assistant_id, codes, messages=[], force=false } = req.body;
+  const { assistant_id, codes, instrucciones=[], messages=[], force=false } = req.body;
   if (!Array.isArray(codes) || codes.length === 0) {
     return res.status(400).send({ error: 'codes must be a non-empty array' });
   }
@@ -62,7 +62,7 @@ const createAssistantController = async (req, res) => {
         if (!force) continue;
       }
 
-      await createAssistant(code, assistant_id, messages, thread);
+      await createAssistant(code, assistant_id, [...instrucciones, ...messages], thread);
       console.log('messages', messages);
       for (const message of messages) {
         console.log('message', message);
@@ -114,7 +114,7 @@ const stopAssistantController = async (req, res) => {
   const { code, stop } = req.body;
 
   try {
-    await updateThreadStop(code, stop);
+    await Thread.updateOne({ code }, { $set: { stopped: !!stop } });
     return res.status(200).send({ message: 'Stop assistant' });
   } catch (error) {
     console.log(error);

package/lib/controllers/messageController.js

@@ -1,17 +1,21 @@
+const { Message } = require('../models/messageModel.js');
+
 // Import from Nexus core
 const { sendMessage } = require('../core/NexusMessaging');
 
-// Stub for missing model
-const ScheduledMessage = {
-  create: () => Promise.resolve({ success: false, error: 'Model not available' }),
-  find: () => Promise.resolve([]),
-  findById: () => Promise.resolve(null),
-  deleteOne: () => Promise.resolve({ success: false, error: 'Model not available' })
+// Injectable dependencies with safe defaults
+let injected = {
+  ScheduledMessage: null,
+  getRecordByFilter: null,
+  sendScheduledMessage: null
 };
 
-// Stub functions for missing services
-const getRecordByFilter = () => Promise.resolve(null);
-const sendScheduledMessage = () => Promise.resolve({ success: false, error: 'Service not available' });
+// Allow consumers to inject their model and services
+const configureMessageController = ({ ScheduledMessage, getRecordByFilter, sendScheduledMessage } = {}) => {
+  if (ScheduledMessage) injected.ScheduledMessage = ScheduledMessage;
+  if (getRecordByFilter) injected.getRecordByFilter = getRecordByFilter;
+  if (sendScheduledMessage) injected.sendScheduledMessage = sendScheduledMessage;
+};
 
 const moment = require('moment-timezone');
 
@@ -31,6 +35,9 @@ const sendMessageController = async (req, res) => {
   const sendMoment = sendTime ? moment.tz(sendTime, timeZone) + 2500 : new Date();
 
   try {
+    if (!injected.ScheduledMessage || typeof injected.ScheduledMessage.create !== 'function') {
+      return res.status(500).json({ success: false, error: 'ScheduledMessage model not configured. Call configureMessageController() to inject it.' });
+    }
     const messageData = {
       fileUrl,
       message,
@@ -44,7 +51,7 @@ const sendMessageController = async (req, res) => {
       extraDelay: 0,
       variables
     };
-    await ScheduledMessage.create(messageData);
+    await injected.ScheduledMessage.create(messageData);
     console.log('Sending message with data:', messageData);
     
     const result = await sendMessage(messageData);
@@ -76,12 +83,18 @@ const sendBulkMessageController = async (req, res) => {
   const sendMoment = sendTime ? moment.tz(sendTime, timeZone) + 20*1000 : new Date();
 
   try {
+    if (!injected.ScheduledMessage || typeof injected.ScheduledMessage.create !== 'function') {
+      return res.status(500).json({ success: false, error: 'ScheduledMessage model not configured. Call configureMessageController() to inject it.' });
+    }
+    if (!injected.sendScheduledMessage || typeof injected.sendScheduledMessage !== 'function') {
+      return res.status(500).json({ success: false, error: 'sendScheduledMessage not configured. Call configureMessageController() to inject it.' });
+    }
     let numSend = 0;
     let extraDelay = 0;
     let curMessage = message;
     const scheduledMessages = [];
     for (const code of codes) {
-      const scheduledMessage = new ScheduledMessage({
+      const scheduledMessage = new injected.ScheduledMessage({
         fileUrl,
         message: curMessage,
         fileType,
@@ -106,8 +119,8 @@ const sendBulkMessageController = async (req, res) => {
     // Schedule all messages with Agenda in parallel
     const sentMessages = await Promise.all(
       scheduledMessages.map(async (message) => {
-        const savedMessage = await ScheduledMessage.create(message);
-        return sendScheduledMessage(savedMessage);
+        const savedMessage = await injected.ScheduledMessage.create(message);
+        return injected.sendScheduledMessage(savedMessage);
       })
     );
 
@@ -153,7 +166,16 @@ const sendBulkMessageAirtableController = async (req, res) => {
   }
 
   try {
-    const rows = await getRecordByFilter(baseId, tableName, condition);
+    if (!injected.getRecordByFilter || typeof injected.getRecordByFilter !== 'function') {
+      return res.status(500).json({ success: false, error: 'Airtable getRecordByFilter not configured. Call configureMessageController() to inject it.' });
+    }
+    if (!injected.ScheduledMessage || typeof injected.ScheduledMessage.create !== 'function') {
+      return res.status(500).json({ success: false, error: 'ScheduledMessage model not configured. Call configureMessageController() to inject it.' });
+    }
+    if (!injected.sendScheduledMessage || typeof injected.sendScheduledMessage !== 'function') {
+      return res.status(500).json({ success: false, error: 'sendScheduledMessage not configured. Call configureMessageController() to inject it.' });
+    }
+    const rows = await injected.getRecordByFilter(baseId, tableName, condition);
     let extraDelay = 0;
     let curMessage = message;
     const sentPhones = new Set();
@@ -192,18 +214,14 @@ const sendBulkMessageAirtableController = async (req, res) => {
         variables
       };
             
-      // Add to scheduledMessages for both saving and scheduling
       scheduledMessages.push(scheduledMessage);
-
-      // Increment delay and message counter
       extraDelay += Math.floor(Math.random() * 5001) + 5000;
     }
 
-    // Schedule all messages with Agenda in parallel
     const sentMessages = await Promise.all(
       scheduledMessages.map(async (message) => {
-        const savedMessage = await ScheduledMessage.create(message);
-        return sendScheduledMessage(savedMessage);
+        const savedMessage = await injected.ScheduledMessage.create(message);
+        return injected.sendScheduledMessage(savedMessage);
       })
     );
 
@@ -223,8 +241,37 @@ const sendBulkMessageAirtableController = async (req, res) => {
   }
 };
 
+const getLastInteractionController = async (req, res) => {
+  const { code } = req.body;
+
+  try {
+    const lastMessage = await Message.findOne({
+      $or: [
+        { numero: code },
+        { group_id: code }
+      ]
+    }).sort({ createdAt: -1 }).exec();
+
+    if (!lastMessage) {
+      return res.status(404).send({ message: 'No messages found for the provided code.' });
+    }
+      
+    const createdAt = new Date(lastMessage.createdAt);
+    const now = new Date();
+    const timeDiffMs = now - createdAt;
+    const minutes = Math.floor(timeDiffMs / (1000 * 60));
+
+    return res.status(200).send({ message: 'Last interaction retrieved successfully.', lastMessage, minutes });
+  } catch (error) {
+    console.error(error);
+    return res.status(500).send({ message: 'Failed to retrieve the last interaction.', error });
+  }
+};
+
 module.exports = {
   sendMessageController,
   sendBulkMessageController,
-  sendBulkMessageAirtableController
+  sendBulkMessageAirtableController,
+  getLastInteractionController,
+  configureMessageController
 };

package/lib/controllers/templateController.js

@@ -17,33 +17,21 @@ const checkTemplateSupport = () => {
     throw new Error('Template operations are only supported with Twilio provider');
   }
 };
-const mongoose = require('mongoose');
+
 const { handleApiError } = require('../utils/errorHandler');
 
 const { Template } = require('../templates/templateStructure');
 const predefinedTemplates = require('../templates/predefinedTemplates');
 
-// Use mongoose models to avoid conflicts
+
 const getTemplateModel = () => {
-  if (mongoose.models.Template) {
-    return mongoose.models.Template;
-  }
-  
-  // If not in mongoose.models, require and return the model
+  // Require the concrete model; enforce presence instead of stubbing
   try {
+    // If already registered in mongoose.models, require still returns the same model
     const TemplateModel = require('../models/templateModel');
     return TemplateModel;
   } catch (error) {
-    console.error('Failed to load Template model:', error);
-    // Return a stub model with required methods
-    return {
-      deleteMany: () => Promise.resolve({ deletedCount: 0 }),
-      find: () => ({ sort: () => ({ limit: () => ({ lean: () => Promise.resolve([]) }) }) }),
-      findOne: () => Promise.resolve(null),
-      create: () => Promise.resolve({}),
-      updateOne: () => Promise.resolve({}),
-      deleteOne: () => Promise.resolve({})
-    };
+    throw new Error('Template model not available. Ensure models are loaded before using template controllers.');
   }
 };