@peopl-health/nexus 1.1.3 → 1.1.5

package/examples/basic-usage.js

@@ -1,70 +1,70 @@
-const { Nexus, setupDefaultRoutes } = require('@peopl/nexus');
 const express = require('express');
-require('dotenv').config();
+const { NexusMessaging, setupDefaultRoutes } = require('@peopl-health/nexus');
 
 const app = express();
 app.use(express.json());
 
-async function main() {
-  const nexus = new Nexus();
-
-  try {
-    // Initialize with minimal configuration
-    await nexus.initialize({
-      providerConfig: {
-        accountSid: process.env.TWILIO_ACCOUNT_SID,
-        authToken: process.env.TWILIO_AUTH_TOKEN,
-        phoneNumber: process.env.TWILIO_PHONE_NUMBER
-      }
-    });
+async function startServer() {
+  // Initialize Nexus with all services
+  const nexus = new NexusMessaging();
+  
+  await nexus.initialize({
+    // MongoDB connection
+    mongoUri: process.env.MONGODB_URI,
+    
+    // Messaging provider
+    provider: 'twilio',
+    providerConfig: {
+      accountSid: process.env.TWILIO_ACCOUNT_SID,
+      authToken: process.env.TWILIO_AUTH_TOKEN,
+      phoneNumber: process.env.TWILIO_PHONE_NUMBER
+    }
+  });
 
-    // Setup all default routes (no controllers needed!)
-    setupDefaultRoutes(app);
+  // Set up all default API routes with built-in controllers
+  setupDefaultRoutes(app);
 
-    // Set up handlers with minimal code
-    nexus.setHandlers({
-      onMessage: async (messageData) => {
-        await nexus.sendMessage({
-          to: messageData.from,
-          message: `Echo: ${messageData.message}`
-        });
-      },
+  // Add webhook endpoint for incoming messages
+  app.post('/webhook', async (req, res) => {
+    try {
+      await nexus.processIncomingMessage(req.body);
+      res.status(200).send('OK');
+    } catch (error) {
+      console.error('Webhook error:', error);
+      res.status(500).send('Error');
+    }
+  });
 
-      onCommand: async (messageData) => {
-        const { command } = messageData.command;
-        const responses = {
-          help: 'Commands: /help, /status',
-          status: `Status: ${nexus.isConnected() ? 'Online' : 'Offline'}`
-        };
-        
-        await nexus.sendMessage({
-          to: messageData.from,
-          message: responses[command] || `Unknown command: ${command}`
-        });
-      }
+  // Custom endpoint example
+  app.get('/status', (req, res) => {
+    res.json({
+      connected: nexus.isConnected(),
+      provider: 'twilio',
+      mongodb: nexus.mongodb?.readyState === 1,
+      airtable: !!nexus.airtable
     });
+  });
 
-    // Webhook endpoint
-    app.post('/webhook', async (req, res) => {
-      await nexus.processMessage(req.body);
-      res.sendStatus(200);
-    });
+  // Example using Airtable
+  app.get('/airtable-test', async (req, res) => {
+    try {
+      const calendarBase = nexus.getAirtableBase('calendar');
+      // Use calendarBase to interact with Airtable
+      res.json({ success: true, message: 'Airtable connection ready' });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
 
-    const PORT = process.env.PORT || 3000;
-    app.listen(PORT, () => {
-      console.log(`Nexus server running on port ${PORT}`);
-    });
-    
-  } catch (error) {
-    console.error('Error:', error);
-    process.exit(1);
-  }
+  const PORT = process.env.PORT || 3000;
+  app.listen(PORT, () => {
+    console.log(`Server running on port ${PORT}`);
+    console.log('Available endpoints:');
+    console.log('- POST /webhook - Webhook for incoming messages');
+    console.log('- GET /status - Connection status');
+    console.log('- GET /airtable-test - Test Airtable connection');
+    console.log('- All Nexus API routes under /api/*');
+  });
 }
 
-// Handle graceful shutdown
-process.on('SIGINT', async () => {
-  console.log('\nShutting down gracefully...');
-  process.exit(0);
-});
-
-main().catch(console.error);
+startServer().catch(console.error);

package/examples/consumer-server.js

@@ -13,16 +13,19 @@ let assistants = {};
 
 async function initializeNexus() {
   await nexus.initialize({
-    provider: 'twilio', 
+    // MongoDB connection
+    mongoUri: process.env.MONGODB_URI,
+    
+    // Messaging provider
+    provider: process.env.MESSAGING_PROVIDER || 'twilio',
     providerConfig: {
       accountSid: process.env.TWILIO_ACCOUNT_SID,
       authToken: process.env.TWILIO_AUTH_TOKEN,
       phoneNumber: process.env.TWILIO_PHONE_NUMBER
     },
-    storageConfig: {
-      uri: process.env.MONGODB_URI,
-      dbName: 'nexus_messaging'
-    },
+    
+    // LLM provider
+    llm: 'openai',
     llmConfig: {
       apiKey: process.env.OPENAI_API_KEY
     }
@@ -31,14 +34,12 @@ async function initializeNexus() {
   assistants = {
     sales: new ExampleAssistant({
       assistantId: process.env.SALES_ASSISTANT_ID,
-      llmClient: nexus.getLLMProvider().getClient(),
-      storage: nexus.getStorage(),
+      llmClient: nexus.getLLMProvider(),
       nexus: nexus
     }),
     support: new ExampleAssistant({
       assistantId: process.env.SUPPORT_ASSISTANT_ID,
-      llmClient: nexus.getLLMProvider().getClient(),
-      storage: nexus.getStorage(),
+      llmClient: nexus.getLLMProvider(),
       nexus: nexus
     })
   };

package/lib/core/NexusMessaging.js

@@ -1,5 +1,8 @@
 const { TwilioProvider } = require('../adapters/TwilioProvider');
 const { BaileysProvider } = require('../adapters/BaileysProvider');
+const mongoose = require('mongoose');
+const { airtable, getBase } = require('../config/airtableConfig');
+const OpenAI = require('openai');
 
 /**
  * Core messaging class that manages providers and message handling
@@ -9,6 +12,9 @@ class NexusMessaging {
     this.config = config;
     this.provider = null;
     this.messageStorage = null;
+    this.mongodb = null;
+    this.airtable = airtable;
+    this.llmProvider = null;
     this.handlers = {
       onMessage: null,
       onInteractive: null,
@@ -19,6 +25,97 @@ class NexusMessaging {
     };
   }
 
+  /**
+   * Initialize MongoDB connection
+   * @param {string} mongoUri - MongoDB connection string
+   */
+  async initializeMongoDB(mongoUri = process.env.MONGODB_URI) {
+    if (!mongoUri) {
+      throw new Error('MongoDB URI not provided. Please set MONGODB_URI environment variable or pass mongoUri parameter.');
+    }
+
+    try {
+      await mongoose.connect(mongoUri);
+      this.mongodb = mongoose.connection;
+      console.log('MongoDB connected successfully');
+    } catch (error) {
+      console.error('MongoDB connection failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get Airtable base instance
+   * @param {string} baseId - Airtable base ID
+   */
+  getAirtableBase(baseId) {
+    return getBase(baseId);
+  }
+
+  /**
+   * Initialize LLM provider
+   * @param {string} llmType - LLM provider type ('openai')
+   * @param {Object} llmConfig - LLM configuration
+   */
+  initializeLLM(llmType, llmConfig) {
+    switch (llmType.toLowerCase()) {
+    case 'openai':
+      if (!llmConfig.apiKey) {
+        throw new Error('OpenAI API key is required');
+      }
+      this.llmProvider = new OpenAI({
+        apiKey: llmConfig.apiKey
+      });
+      break;
+    default:
+      throw new Error(`Unsupported LLM provider: ${llmType}`);
+    }
+  }
+
+  /**
+   * Get LLM provider instance
+   */
+  getLLMProvider() {
+    return this.llmProvider;
+  }
+
+  /**
+   * Initialize Nexus with all services
+   * @param {Object} options - Configuration options
+   */
+  async initialize(options = {}) {
+    const {
+      provider,
+      providerConfig,
+      mongoUri,
+      messageStorage,
+      llm,
+      llmConfig
+    } = options;
+
+    // Initialize MongoDB if URI provided
+    if (mongoUri || process.env.MONGODB_URI) {
+      await this.initializeMongoDB(mongoUri);
+    }
+
+    // Initialize messaging provider
+    if (provider && providerConfig) {
+      await this.initializeProvider(provider, providerConfig);
+    }
+
+    // Initialize LLM provider
+    if (llm && llmConfig) {
+      this.initializeLLM(llm, llmConfig);
+    }
+
+    // Set message storage
+    if (messageStorage) {
+      this.setMessageStorage(messageStorage);
+    }
+
+    return this;
+  }
+
   /**
    * Initialize messaging with specified provider
    * @param {string} providerType - 'twilio' or 'baileys'

package/lib/storage/MongoStorage.js

@@ -54,9 +54,9 @@ class MongoStorage {
     });
 
     return {
-      Message: mongoose.model('Message', messageSchema),
-      Interaction: mongoose.model('Interaction', interactionSchema),
-      Thread: mongoose.model('Thread', threadSchema)
+      Message: mongoose.models.Message || mongoose.model('Message', messageSchema),
+      Interaction: mongoose.models.Interaction || mongoose.model('Interaction', interactionSchema),
+      Thread: mongoose.models.Thread || mongoose.model('Thread', threadSchema)
     };
   }
 

package/package.json

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