@peopl-health/nexus 1.0.2

package/lib/adapters/BaileysProvider.js

@@ -0,0 +1,180 @@
+const { MessageProvider } = require('../core/MessageProvider');
+
+/**
+ * Baileys WhatsApp messaging provider
+ */
+class BaileysProvider extends MessageProvider {
+  constructor(config) {
+    super(config);
+    this.waSocket = null;
+    this.authState = config.authState || 'auth_info_baileys';
+    this.mongoUri = config.mongoUri;
+    this.userDbMongo = config.userDbMongo;
+  }
+
+  async initialize() {
+    try {
+      const { default: makeWASocket, useMultiFileAuthState } = require('baileys');
+      const { useMongoDBAuthState } = require('../utils/mongoAuthConfig');
+      const pino = require('pino');
+      
+      const logger = pino({ level: 'warn' });
+      let state, saveCreds;
+
+      if (this.mongoUri && this.userDbMongo) {
+        ({ state, saveCreds } = await useMongoDBAuthState(
+          this.mongoUri,
+          this.userDbMongo,
+          'baileys'
+        ));
+      } else {
+        ({ state, saveCreds } = await useMultiFileAuthState(this.authState));
+      }
+
+      this.waSocket = makeWASocket({
+        auth: state,
+        keepAliveIntervalMs: 30000,
+        logger,
+        printQRInTerminal: true,
+      });
+
+      this.waSocket.ev.on('connection.update', async (update) => {
+        await this.handleConnectionUpdate(update);
+      });
+
+      this.waSocket.ev.on('creds.update', saveCreds);
+      
+    } catch (error) {
+      throw new Error(`Failed to initialize Baileys: ${error.message}`);
+    }
+  }
+
+  async handleConnectionUpdate(update) {
+    const { connection, lastDisconnect, qr } = update || {};
+
+    if (qr) {
+      // Emit QR code event for consumer to handle
+      this.emit?.('qr', qr);
+    }
+
+    if (connection === 'close' && lastDisconnect) {
+      const { DisconnectReason } = require('baileys');
+      const shouldReconnect = lastDisconnect?.error?.output?.statusCode !== DisconnectReason.loggedOut;
+      if (shouldReconnect) {
+        await this.initialize();
+      }
+    } else if (connection === 'open') {
+      this.isConnected = true;
+    }
+  }
+
+  formatCode(code) {
+    return code.includes('@s.whatsapp.net') ? code : `${code}@s.whatsapp.net`;
+  }
+
+  formatMessage(message) {
+    return message.replace(/\\n/g, '\n');
+  }
+
+  async sendMessage(messageData) {
+    if (!this.isConnected || !this.waSocket) {
+      throw new Error('Baileys provider not connected');
+    }
+
+    const { to, message, fileUrl, fileType, hidePreview = false } = messageData;
+    
+    if (!to) {
+      throw new Error('Recipient is required');
+    }
+
+    if (!message && !fileUrl) {
+      throw new Error('Message or file URL is required');
+    }
+
+    const code = this.formatCode(to);
+    let sendOptions = {};
+    let formattedMessage = this.formatMessage(message || '');
+
+    // Handle mentions
+    const regex = /@\d+/g;
+    const matches = formattedMessage.match(regex);
+    if (matches) {
+      const processedNumbers = matches.map(match => {
+        return match.replace('@', '') + '@s.whatsapp.net';
+      });
+      sendOptions.mentions = processedNumbers;
+    }
+
+    // Handle link preview
+    const keywords = ['meet.google.com', 'airtable', 'zoom'];
+    if (keywords.some(keyword => formattedMessage.includes(keyword)) || hidePreview) {
+      sendOptions.linkPreview = false;
+    }
+
+    // Set message content based on type
+    if (!fileUrl || fileType === 'text') {
+      sendOptions.text = formattedMessage;
+    } else {
+      if (fileType === 'image') {
+        sendOptions.image = { url: fileUrl };
+        sendOptions.mimetype = 'image/png';
+        sendOptions.caption = formattedMessage;
+      } else if (fileType === 'document') {
+        sendOptions.document = { url: fileUrl };
+        sendOptions.mimetype = 'application/pdf';
+        sendOptions.caption = formattedMessage;
+      } else if (fileType === 'audio') {
+        sendOptions.audio = { url: fileUrl };
+        sendOptions.mimetype = 'audio/mpeg';
+      } else {
+        throw new Error(`Unsupported file type: ${fileType}`);
+      }
+    }
+
+    try {
+      const result = await this.waSocket.sendMessage(code, sendOptions);
+      return {
+        success: true,
+        messageId: result?.key?.id,
+        provider: 'baileys',
+        result
+      };
+    } catch (error) {
+      throw new Error(`Baileys send failed: ${error.message}`);
+    }
+  }
+
+  async sendScheduledMessage(scheduledMessage) {
+    const { sendTime, timeZone } = scheduledMessage;
+    const delay = this.calculateDelay(sendTime, timeZone);
+    
+    setTimeout(async () => {
+      try {
+        await this.sendMessage(scheduledMessage);
+        console.log('Scheduled message sent successfully');
+      } catch (error) {
+        console.error(`Scheduled message failed: ${error.message}`);
+      }
+    }, delay);
+  }
+
+  calculateDelay(sendTime) {
+    const now = new Date();
+    const targetTime = new Date(sendTime);
+    return Math.max(0, targetTime.getTime() - now.getTime());
+  }
+
+  getConnectionStatus() {
+    return this.waSocket?.user ? true : false;
+  }
+
+  async disconnect() {
+    if (this.waSocket) {
+      await this.waSocket.logout();
+      this.waSocket = null;
+    }
+    this.isConnected = false;
+  }
+}
+
+module.exports = { BaileysProvider };

package/lib/adapters/TwilioProvider.js

@@ -0,0 +1,118 @@
+const { MessageProvider } = require('../core/MessageProvider');
+
+/**
+ * Twilio WhatsApp messaging provider
+ */
+class TwilioProvider extends MessageProvider {
+  constructor(config) {
+    super(config);
+    this.twilioClient = null;
+    this.accountSid = config.accountSid;
+    this.authToken = config.authToken;
+    this.whatsappNumber = config.whatsappNumber;
+  }
+
+  async initialize() {
+    if (!this.accountSid || !this.authToken) {
+      throw new Error('Twilio credentials (accountSid, authToken) are required');
+    }
+
+    try {
+      const twilio = require('twilio');
+      this.twilioClient = twilio(this.accountSid, this.authToken);
+      this.isConnected = true;
+    } catch (error) {
+      throw new Error(`Failed to initialize Twilio: ${error.message}`);
+    }
+  }
+
+  ensureWhatsAppFormat(number) {
+    if (!number) return null;
+    if (number.startsWith('whatsapp:')) return number;
+    if (number.startsWith('+')) return `whatsapp:${number}`;
+    return `whatsapp:+${number}`;
+  }
+
+  async sendMessage(messageData) {
+    if (!this.isConnected || !this.twilioClient) {
+      throw new Error('Twilio provider not initialized');
+    }
+
+    const { to, message, fileUrl, fileType, variables, contentSid } = messageData;
+    
+    const formattedFrom = this.ensureWhatsAppFormat(this.whatsappNumber);
+    const formattedTo = this.ensureWhatsAppFormat(to);
+
+    if (!formattedFrom || !formattedTo) {
+      throw new Error('Invalid sender or recipient number');
+    }
+
+    const messageParams = {
+      from: formattedFrom,
+      to: formattedTo
+    };
+
+    // Handle template messages
+    if (contentSid) {
+      messageParams.contentSid = contentSid;
+      if (variables && Object.keys(variables).length > 0) {
+        const formattedVariables = {};
+        Object.keys(variables).forEach(key => {
+          const numericString = key.replace(/[^0-9]/g, '');
+          const numericKey = parseInt(numericString, 10).toString();
+          formattedVariables[numericKey] = variables[key];
+        });
+        messageParams.contentVariables = JSON.stringify(formattedVariables);
+      }
+    } else if (message) {
+      messageParams.body = message;
+    }
+
+    // Handle media messages
+    if (fileUrl && fileType !== 'text') {
+      messageParams.mediaUrl = [fileUrl];
+      if (!messageParams.body || messageParams.body.trim() === '') {
+        delete messageParams.body;
+      }
+    }
+
+    // Validate message has content
+    if (!messageParams.body && !messageParams.mediaUrl && !messageParams.contentSid) {
+      throw new Error('Message must have body, media URL, or content SID');
+    }
+
+    try {
+      const result = await this.twilioClient.messages.create(messageParams);
+      return {
+        success: true,
+        messageId: result.sid,
+        provider: 'twilio',
+        result
+      };
+    } catch (error) {
+      throw new Error(`Twilio send failed: ${error.message}`);
+    }
+  }
+
+  async sendScheduledMessage(scheduledMessage) {
+    const { sendTime, timeZone } = scheduledMessage;
+    const delay = this.calculateDelay(sendTime, timeZone);
+    
+    setTimeout(async () => {
+      try {
+        await this.sendMessage(scheduledMessage);
+        console.log('Scheduled message sent successfully');
+      } catch (error) {
+        console.error(`Scheduled message failed: ${error.message}`);
+      }
+    }, delay);
+  }
+
+  calculateDelay(sendTime) {
+    const now = new Date();
+    const targetTime = new Date(sendTime);
+    return Math.max(0, targetTime.getTime() - now.getTime());
+  }
+}
+
+module.exports = { TwilioProvider };

package/lib/adapters/index.js

@@ -0,0 +1,7 @@
+const { TwilioProvider } = require('./TwilioProvider');
+const { BaileysProvider } = require('./BaileysProvider');
+
+module.exports = {
+  TwilioProvider,
+  BaileysProvider
+};

package/lib/core/MessageProvider.js

@@ -0,0 +1,71 @@
+/**
+ * Abstract base class for messaging providers
+ */
+class MessageProvider {
+  constructor(config = {}) {
+    this.config = config;
+    this.isConnected = false;
+  }
+
+  /**
+   * Initialize the provider connection
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    throw new Error('initialize() must be implemented by provider');
+  }
+
+  /**
+   * Connect the provider
+   * @returns {Promise<void>}
+   */
+  async connect() {
+    throw new Error('connect() must be implemented by provider');
+  }
+
+  /**
+   * Send a message
+   * @param {Object} messageData - Message data
+   * @param {string} messageData.to - Recipient
+   * @param {string} messageData.message - Message text
+   * @param {string} messageData.fileUrl - Optional file URL
+   * @param {string} messageData.fileType - File type (text, image, document, audio)
+   * @param {Object} messageData.variables - Template variables
+   * @param {string} messageData.contentSid - Template content SID
+   * @returns {Promise<Object>} Message result
+   */
+  async sendMessage(messageData) {
+    // eslint-disable-next-line no-unused-vars
+    messageData;
+    throw new Error('sendMessage() must be implemented by provider');
+  }
+
+  /**
+   * Send a scheduled message
+   * @param {Object} scheduledMessage - Scheduled message data
+   * @returns {Promise<void>}
+   */
+  async sendScheduledMessage(scheduledMessage) {
+    // eslint-disable-next-line no-unused-vars
+    scheduledMessage;
+    throw new Error('sendScheduledMessage() must be implemented by provider');
+  }
+
+  /**
+   * Check if provider is connected
+   * @returns {boolean}
+   */
+  getConnectionStatus() {
+    return this.isConnected;
+  }
+
+  /**
+   * Disconnect the provider
+   * @returns {Promise<void>}
+   */
+  async disconnect() {
+    throw new Error('disconnect() must be implemented by provider');
+  }
+}
+
+module.exports = { MessageProvider };

package/lib/core/NexusMessaging.js

@@ -0,0 +1,231 @@
+const { TwilioProvider } = require('../adapters/TwilioProvider');
+const { BaileysProvider } = require('../adapters/BaileysProvider');
+
+/**
+ * Core messaging class that manages providers and message handling
+ */
+class NexusMessaging {
+  constructor(config = {}) {
+    this.config = config;
+    this.provider = null;
+    this.messageStorage = null;
+    this.handlers = {
+      onMessage: null,
+      onInteractive: null,
+      onMedia: null,
+      onCommand: null,
+      onKeyword: null,
+      onFlow: null
+    };
+  }
+
+  /**
+   * Initialize messaging with specified provider
+   * @param {string} providerType - 'twilio' or 'baileys'
+   * @param {Object} providerConfig - Provider-specific configuration
+   */
+  async initializeProvider(providerType, providerConfig) {
+    switch (providerType.toLowerCase()) {
+    case 'twilio':
+      this.provider = new TwilioProvider(providerConfig);
+      break;
+    case 'baileys':
+      this.provider = new BaileysProvider(providerConfig);
+      break;
+    default:
+      throw new Error(`Unsupported provider: ${providerType}`);
+    }
+
+    await this.provider.initialize();
+  }
+
+  /**
+   * Set message storage interface
+   * @param {Object} storage - Storage interface with save methods
+   */
+  setMessageStorage(storage) {
+    this.messageStorage = storage;
+  }
+
+  /**
+   * Register event handlers for different message types
+   * @param {Object} handlers - Handler functions
+   */
+  setHandlers(handlers) {
+    this.handlers = { ...this.handlers, ...handlers };
+  }
+
+  /**
+   * Register a single message handler
+   * @param {Function} handler - Message handler function
+   */
+  onMessage(handler) {
+    this.handlers.onMessage = handler;
+  }
+
+  /**
+   * Register an interactive message handler
+   * @param {Function} handler - Interactive handler function
+   */
+  onInteractive(handler) {
+    this.handlers.onInteractive = handler;
+  }
+
+  /**
+   * Register a media handler
+   * @param {Function} handler - Media handler function
+   */
+  onMedia(handler) {
+    this.handlers.onMedia = handler;
+  }
+
+  /**
+   * Register a command handler
+   * @param {Function} handler - Command handler function
+   */
+  onCommand(handler) {
+    this.handlers.onCommand = handler;
+  }
+
+  /**
+   * Register a keyword handler
+   * @param {Function} handler - Keyword handler function
+   */
+  onKeyword(handler) {
+    this.handlers.onKeyword = handler;
+  }
+
+  /**
+   * Register a flow handler
+   * @param {Function} handler - Flow handler function
+   */
+  onFlow(handler) {
+    this.handlers.onFlow = handler;
+  }
+
+  /**
+   * Send a message through the active provider
+   * @param {Object} messageData - Message data
+   */
+  async sendMessage(messageData) {
+    if (!this.provider) {
+      throw new Error('No provider initialized');
+    }
+
+    const result = await this.provider.sendMessage(messageData);
+    
+    // Store message if storage is configured
+    if (this.messageStorage) {
+      await this.messageStorage.saveMessage({
+        ...messageData,
+        messageId: result.messageId,
+        provider: result.provider,
+        timestamp: new Date(),
+        fromMe: true
+      });
+    }
+
+    return result;
+  }
+
+  /**
+   * Send a scheduled message
+   * @param {Object} scheduledMessage - Scheduled message data
+   */
+  async sendScheduledMessage(scheduledMessage) {
+    if (!this.provider) {
+      throw new Error('No provider initialized');
+    }
+
+    return await this.provider.sendScheduledMessage(scheduledMessage);
+  }
+
+  /**
+   * Process incoming message with configured handlers
+   * @param {Object} messageData - Incoming message data
+   */
+  async processIncomingMessage(messageData) {
+    // Store incoming message
+    if (this.messageStorage) {
+      await this.messageStorage.saveMessage({
+        ...messageData,
+        timestamp: new Date(),
+        fromMe: false
+      });
+    }
+
+    // Determine message type and call appropriate handler
+    if (messageData.interactive) {
+      return await this.handleInteractive(messageData);
+    } else if (messageData.media) {
+      return await this.handleMedia(messageData);
+    } else if (messageData.command) {
+      return await this.handleCommand(messageData);
+    } else if (messageData.keyword) {
+      return await this.handleKeyword(messageData);
+    } else if (messageData.flow) {
+      return await this.handleFlow(messageData);
+    } else {
+      return await this.handleMessage(messageData);
+    }
+  }
+
+  async handleMessage(messageData) {
+    if (this.handlers.onMessage) {
+      return await this.handlers.onMessage(messageData, this);
+    }
+  }
+
+  async handleInteractive(messageData) {
+    // Store interactive message
+    if (this.messageStorage) {
+      await this.messageStorage.saveInteractive(messageData);
+    }
+
+    if (this.handlers.onInteractive) {
+      return await this.handlers.onInteractive(messageData, this);
+    }
+  }
+
+  async handleMedia(messageData) {
+    if (this.handlers.onMedia) {
+      return await this.handlers.onMedia(messageData, this);
+    }
+  }
+
+  async handleCommand(messageData) {
+    if (this.handlers.onCommand) {
+      return await this.handlers.onCommand(messageData, this);
+    }
+  }
+
+  async handleKeyword(messageData) {
+    if (this.handlers.onKeyword) {
+      return await this.handlers.onKeyword(messageData, this);
+    }
+  }
+
+  async handleFlow(messageData) {
+    if (this.handlers.onFlow) {
+      return await this.handlers.onFlow(messageData, this);
+    }
+  }
+
+  /**
+   * Get provider connection status
+   */
+  isConnected() {
+    return this.provider ? this.provider.getConnectionStatus() : false;
+  }
+
+  /**
+   * Disconnect the provider
+   */
+  async disconnect() {
+    if (this.provider) {
+      await this.provider.disconnect();
+    }
+  }
+}
+
+module.exports = { NexusMessaging };

package/lib/core/index.js

@@ -0,0 +1,7 @@
+const { NexusMessaging } = require('./NexusMessaging');
+const { MessageProvider } = require('./MessageProvider');
+
+module.exports = {
+  NexusMessaging,
+  MessageProvider
+};