@peopl-health/nexus 1.0.3 → 1.1.0

package/README.md

@@ -219,6 +219,129 @@ await nexus.sendScheduledMessage({
 });
 ```
 
+## Routes for Consumer Servers
+
+The library exports pre-built route definitions that consumer servers can use with minimal code:
+
+### Option 1: Setup All Default Routes (Minimal Code)
+
+```javascript
+const express = require('express');
+const { setupDefaultRoutes } = require('@peopl-health/nexus');
+
+const app = express();
+
+// Define your controllers
+const myControllers = {
+  // Assistant controllers
+  activeAssistantController: (req, res) => { /* your logic */ },
+  createAssistantController: (req, res) => { /* your logic */ },
+  listAssistantController: (req, res) => { /* your logic */ },
+  addInsAssistantController: (req, res) => { /* your logic */ },
+  addMsgAssistantController: (req, res) => { /* your logic */ },
+  getInfoAssistantController: (req, res) => { /* your logic */ },
+  switchAssistantController: (req, res) => { /* your logic */ },
+  stopAssistantController: (req, res) => { /* your logic */ },
+  
+  // Conversation controllers
+  getConversationController: (req, res) => { /* your logic */ },
+  searchConversationsController: (req, res) => { /* your logic */ },
+  getConversationsByNameController: (req, res) => { /* your logic */ },
+  getConversationMessagesController: (req, res) => { /* your logic */ },
+  getNewMessagesController: (req, res) => { /* your logic */ },
+  getConversationReplyController: (req, res) => { /* your logic */ },
+  sendTemplateToNewNumberController: (req, res) => { /* your logic */ },
+  markMessagesAsReadController: (req, res) => { /* your logic */ },
+  
+  // Media controllers
+  getMediaController: (req, res) => { /* your logic */ },
+  handleFileUpload: (req, res) => { /* your logic */ },
+  
+  // Message controllers
+  sendMessageController: (req, res) => { /* your logic */ },
+  sendBulkMessageController: (req, res) => { /* your logic */ },
+  sendBulkMessageAirtableController: (req, res) => { /* your logic */ },
+  
+  // Template controllers
+  createTemplate: (req, res) => { /* your logic */ },
+  listTemplates: (req, res) => { /* your logic */ },
+  getPredefinedTemplates: (req, res) => { /* your logic */ },
+  getTemplate: (req, res) => { /* your logic */ },
+  getCompleteTemplate: (req, res) => { /* your logic */ },
+  createFlow: (req, res) => { /* your logic */ },
+  deleteFlow: (req, res) => { /* your logic */ },
+  submitForApproval: (req, res) => { /* your logic */ },
+  checkApprovalStatus: (req, res) => { /* your logic */ },
+  deleteTemplate: (req, res) => { /* your logic */ }
+};
+
+// Setup all default routes with one line
+setupDefaultRoutes(app, myControllers);
+
+// Add your custom routes
+app.get('/api/custom', myCustomController);
+app.post('/api/special', mySpecialController);
+```
+
+### Option 2: Individual Route Control
+
+```javascript
+const express = require('express');
+const { routes, createRouter } = require('@peopl-health/nexus');
+
+const app = express();
+
+// Setup only specific route groups
+app.use('/api/assistant', createRouter(routes.assistantRoutes, myControllers));
+app.use('/api/message', createRouter(routes.messageRoutes, myControllers));
+app.use('/api/template', createRouter(routes.templateRoutes, myControllers));
+```
+
+### Available Default Route Groups
+
+The `setupDefaultRoutes()` function sets up these 5 route groups:
+
+#### **Assistant Routes** (`/api/assistant`)
+- `POST /active` - Set active assistant
+- `POST /add-instruction` - Add instruction to assistant
+- `POST /add-msg` - Add message to assistant
+- `POST /create` - Create new assistant
+- `POST /get-info` - Get assistant information
+- `GET /list` - List all assistants
+- `POST /switch` - Switch between assistants
+- `POST /stop` - Stop assistant
+
+#### **Conversation Routes** (`/api/conversation`)
+- `GET /` - Get conversations
+- `GET /search` - Search conversations
+- `GET /by-name` - Get conversations by name
+- `GET /:phoneNumber` - Get conversation messages
+- `GET /:phoneNumber/new` - Get new messages
+- `POST /reply` - Send conversation reply
+- `POST /send-template` - Send template to new number
+- `POST /:phoneNumber/read` - Mark messages as read
+
+#### **Media Routes** (`/api/media`)
+- `GET /:key(*)` - Get media file
+- `POST /upload` - Upload media file
+
+#### **Message Routes** (`/api/message`)
+- `POST /send` - Send single message
+- `POST /send-bulk` - Send bulk messages
+- `POST /send-bulk-airtable` - Send bulk messages from Airtable
+
+#### **Template Routes** (`/api/template`)
+- `POST /text` - Create text template
+- `GET /` - List templates
+- `GET /predefined` - Get predefined templates
+- `GET /:id` - Get specific template
+- `GET /complete/:sid` - Get complete template
+- `POST /flow` - Create flow template
+- `DELETE /flow/:sid` - Delete flow template
+- `POST /approval` - Submit template for approval
+- `GET /status/:sid` - Check approval status
+- `DELETE /:id` - Delete template
+
 ## API Reference
 
 ### Nexus Class

package/examples/basic-usage.js

@@ -5,97 +5,42 @@ async function main() {
   const nexus = new Nexus();
 
   try {
-    // Initialize with defaults (twilio provider, mongo storage, openai llm)
+    // 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
-      },
-      // storage: 'mongo' is default
-      storageConfig: {
-        uri: process.env.MONGODB_URI,
-        dbName: 'nexus_basic'
-      },
-      // parser: 'MessageParser' is default
-      parserConfig: {
-        commandPrefixes: ['/', '!'],
-        keywords: ['help', 'support', 'info'],
-        flowTriggers: ['start survey', 'begin onboarding']
-      },
-      // llm: 'openai' is default (optional for basic usage)
-      llmConfig: {
-        apiKey: process.env.OPENAI_API_KEY
       }
     });
 
-    // Set up message handlers
-    nexus.onMessage(async (messageData) => {
-      console.log(`Received message from ${messageData.from}: ${messageData.message}`);
-      
-      // Simple echo response
-      await nexus.sendMessage({
-        to: messageData.from,
-        message: `You said: ${messageData.message}`
-      });
-    });
-
-    nexus.onCommand(async (messageData) => {
-      const { command, args } = messageData.command;
-      
-      switch (command) {
-        case 'help':
-          await nexus.sendMessage({
-            to: messageData.from,
-            message: 'Available commands:\n/help - Show this help\n/status - Check system status\n/echo [text] - Echo your text'
-          });
-          break;
-        case 'status':
-          await nexus.sendMessage({
-            to: messageData.from,
-            message: `System Status: ${nexus.isConnected() ? 'Connected' : 'Disconnected'}`
-          });
-          break;
-        case 'echo':
-          const text = args.join(' ') || 'Nothing to echo!';
-          await nexus.sendMessage({
-            to: messageData.from,
-            message: `Echo: ${text}`
-          });
-          break;
-        default:
-          await nexus.sendMessage({
-            to: messageData.from,
-            message: `Unknown command: ${command}. Type /help for available commands.`
-          });
-      }
-    });
+    // Set up handlers with minimal code
+    nexus.setHandlers({
+      onMessage: async (messageData) => {
+        await nexus.sendMessage({
+          to: messageData.from,
+          message: `Echo: ${messageData.message}`
+        });
+      },
 
-    nexus.onKeyword(async (messageData) => {
-      const keyword = messageData.keyword;
-      
-      switch (keyword) {
-        case 'help':
-        case 'support':
-          await nexus.sendMessage({
-            to: messageData.from,
-            message: 'Hello! I can help you with:\n- Basic messaging\n- Commands (try /help)\n- Keyword responses\n\nWhat would you like to know?'
-          });
-          break;
-        case 'info':
-          await nexus.sendMessage({
-            to: messageData.from,
-            message: 'This is a basic Nexus messaging bot example. It demonstrates simple message handling without AI assistants.'
-          });
-          break;
+      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}`
+        });
       }
     });
 
-    console.log('Nexus basic example started successfully');
-    console.log('Send messages to your configured phone number to test');
+    console.log('Nexus started - send messages to test');
     
   } catch (error) {
-    console.error('Error starting Nexus:', error);
+    console.error('Error:', error);
     process.exit(1);
   }
 }

package/lib/controllers/assistantController.js

@@ -0,0 +1,168 @@
+// Optional config - will be undefined if not available
+let Config_ID;
+try {
+  Config_ID = require('../config/airtableConfig')?.Config_ID;
+} catch (e) {
+  Config_ID = null;
+}
+
+// Optional model imports
+let updateThreadActive, updateThreadStop, Thread;
+try {
+  const threadModel = require('../models/threadModel');
+  updateThreadActive = threadModel.updateThreadActive;
+  updateThreadStop = threadModel.updateThreadStop;
+  Thread = threadModel.Thread;
+} catch (e) {
+  // Models not available
+}
+
+// Optional service imports
+let getRecordByFilter, createAssistant, addMsgAssistant, addInsAssistant, getThreadInfo, switchAssistant, sendMessage;
+try {
+  getRecordByFilter = require('../services/airtableService')?.getRecordByFilter;
+} catch (e) {
+  // Service not available
+}
+try {
+  const assistantService = require('../services/assistantService');
+  createAssistant = assistantService.createAssistant;
+  addMsgAssistant = assistantService.addMsgAssistant;
+  addInsAssistant = assistantService.addInsAssistant;
+  getThreadInfo = assistantService.getThreadInfo;
+  switchAssistant = assistantService.switchAssistant;
+} catch (e) {
+  // Service not available
+}
+try {
+  sendMessage = require('../services/whatsappService')?.sendMessage;
+} catch (e) {
+  // Service not available
+}
+
+
+const activeAssistantController = async (req, res) => {
+  const { code, active } = req.body;
+
+  try {
+    await updateThreadActive(code, active);
+    return res.status(200).send({ message: 'Active assistant' });
+  } catch (error) {
+    console.log(error);
+    return res.status(500).send({ message: 'Failed to active assistant', error });
+  }
+};
+
+const addInsAssistantController = async (req, res) => {
+  const { code, instruction } = req.body;
+
+  try {
+    const ans = await addInsAssistant(code, instruction);
+    if (ans) await sendMessage({code, message: ans, fileType: 'text'});
+    return res.status(200).send({ message: 'Add instruction to the assistant' });
+  } catch (error) {
+    console.log(error);
+    res.status(500).send({ message: 'Failed to add instruction to assistant', error });
+  }
+};
+
+const addMsgAssistantController = async (req, res) => {
+  const { code, messages, reply } = req.body;
+
+  try {
+    const ans = await addMsgAssistant(code, messages, reply);
+    if (ans) await sendMessage({code, message: ans, fileType: 'text'});
+    return res.status(200).send({ message: 'Add message to the assistant' });
+  } catch (error) {
+    console.log(error);
+    res.status(500).send({ message: 'Failed to add message assistant', error });
+  }
+};
+
+const createAssistantController = async (req, res) => {
+  const { assistant_id, codes, 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' });
+  }
+
+  try {
+    console.log('codes', codes);
+    for (const code of codes) {
+      const thread = await Thread.findOne({ code: code });
+      if (thread !== null) {
+        await switchAssistant(code, assistant_id);
+        console.log('FORCE', force);
+        if (!force) continue;
+      }
+
+      await createAssistant(code, assistant_id, messages, thread);
+      console.log('messages', messages);
+      for (const message of messages) {
+        console.log('message', message);
+        await sendMessage({code, message, fileType: 'text'});
+      }
+    }
+    res.status(200).send({ message: 'Create the assistant' });
+  } catch (error) {
+    console.log(error);
+    res.status(500).send({ message: 'Failed to create assistant', error });
+  }
+};
+
+const getInfoAssistantController = async (req, res) => {
+  const { code } = req.body;
+
+  try {
+    let threadInfo = await getThreadInfo(code);
+    return res.status(200).send({ message: 'Send assistant info' , threadInfo});
+  } catch (error) {
+    console.log(error);
+    res.status(500).send({ message: 'Failed to receive assistant info', error });
+  }
+};
+
+const listAssistantController = async (req, res) => {
+  try {
+    const assistants = await getRecordByFilter(Config_ID, 'assistants', `status="${process.env.NODE_ENV}"`);
+    return res.status(200).send({ message: 'List assistants' , assistants});
+  } catch (error) {
+    console.log(error);
+    res.status(500).send({ message: 'Failed to list assistants', error });
+  }
+};
+
+const switchAssistantController = async (req, res) => {
+  const { code, assistant_id } = req.body;
+
+  try {
+    await switchAssistant(code, assistant_id);
+    return res.status(200).send({ message: 'Switch assistant' });
+  } catch (error) {
+    console.log(error);
+    res.status(500).send({ message: 'Failed to switch assistant', error });
+  }
+};
+
+const stopAssistantController = async (req, res) => {
+  const { code, stop } = req.body;
+
+  try {
+    await updateThreadStop(code, stop);
+    return res.status(200).send({ message: 'Stop assistant' });
+  } catch (error) {
+    console.log(error);
+    return res.status(500).send({ message: 'Failed to stop assistant', error });
+  }
+};
+
+
+module.exports = {
+  activeAssistantController,
+  addInsAssistantController,
+  addMsgAssistantController,
+  createAssistantController,
+  getInfoAssistantController,
+  listAssistantController,
+  switchAssistantController,
+  stopAssistantController
+};