@peopl-health/nexus 1.1.0 → 1.1.3

package/README.md

@@ -231,52 +231,8 @@ 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);
+// Setup all default routes with built-in controllers (one line!)
+setupDefaultRoutes(app);
 
 // Add your custom routes
 app.get('/api/custom', myCustomController);

package/examples/basic-usage.js

@@ -1,6 +1,10 @@
-const { Nexus } = require('@peopl/nexus');
+const { Nexus, setupDefaultRoutes } = require('@peopl/nexus');
+const express = require('express');
 require('dotenv').config();
 
+const app = express();
+app.use(express.json());
+
 async function main() {
   const nexus = new Nexus();
 
@@ -14,6 +18,9 @@ async function main() {
       }
     });
 
+    // Setup all default routes (no controllers needed!)
+    setupDefaultRoutes(app);
+
     // Set up handlers with minimal code
     nexus.setHandlers({
       onMessage: async (messageData) => {
@@ -37,7 +44,16 @@ async function main() {
       }
     });
 
-    console.log('Nexus started - send messages to test');
+    // Webhook endpoint
+    app.post('/webhook', async (req, res) => {
+      await nexus.processMessage(req.body);
+      res.sendStatus(200);
+    });
+
+    const PORT = process.env.PORT || 3000;
+    app.listen(PORT, () => {
+      console.log(`Nexus server running on port ${PORT}`);
+    });
     
   } catch (error) {
     console.error('Error:', error);

package/lib/config/airtableConfig.js

@@ -0,0 +1,45 @@
+const Airtable = require('airtable');
+
+const airtableConfig = {
+  apiKey: process.env.AIRTABLE_API_KEY,
+};
+
+// Configurable base IDs - users can override via environment variables
+const Calendar_ID = process.env.AIRTABLE_CALENDAR_ID || 'appIjEstWR6972tbF';
+const Config_ID = process.env.AIRTABLE_CONFIG_ID || 'app9K4EvGI8McC8jF';
+const Historial_Clinico_ID = process.env.AIRTABLE_HISTORIAL_CLINICO_ID || 'appdUpGUS06XIzVnY';
+const Logging_ID = process.env.AIRTABLE_LOGGING_ID || 'appQ7YhzfebRDbSPJ';
+const Monitoreo_ID = process.env.AIRTABLE_MONITOREO_ID || 'appdvraKSdp0XVn5n';
+const Programa_Juntas_ID = process.env.AIRTABLE_PROGRAMA_JUNTAS_ID || 'appKFWzkcDEWlrXBE';
+const Symptoms_ID = process.env.AIRTABLE_SYMPTOMS_ID || 'appQRhZlQ9tMfYZWJ';
+const Webinars_Leads_ID = process.env.AIRTABLE_WEBINARS_LEADS_ID || 'appzjpVXTI0TgqGPq';
+
+// Initialize Airtable only if API key is provided
+let airtable = null;
+if (airtableConfig.apiKey) {
+  airtable = new Airtable({ apiKey: airtableConfig.apiKey });
+}
+
+module.exports = {
+  airtable,
+  config: airtableConfig,
+  Calendar_ID,
+  Config_ID,
+  Historial_Clinico_ID,
+  Logging_ID,
+  Monitoreo_ID,
+  Programa_Juntas_ID,
+  Symptoms_ID,
+  Webinars_Leads_ID,
+  
+  // Helper function to get base by ID
+  getBase: (baseId = process.env.AIRTABLE_BASE_ID) => {
+    if (!airtable) {
+      throw new Error('Airtable not configured. Please set AIRTABLE_API_KEY environment variable.');
+    }
+    if (!baseId) {
+      throw new Error('Airtable base ID not provided. Please set AIRTABLE_BASE_ID environment variable or pass baseId parameter.');
+    }
+    return airtable.base(baseId);
+  }
+};

package/lib/{utils → config}/mongoAuthConfig.js

@@ -1,11 +1,6 @@
 const { MongoClient } = require('mongodb');
 
-let baileys;
-try {
-  baileys = require('baileys');
-} catch (error) {
-  baileys = null;
-}
+const { proto, Curve, signedKeyPair, generateRegistrationId } = require('baileys');
 const { randomBytes } = require('crypto');
 
 async function connectToMongo(mongoClient) {
@@ -19,11 +14,6 @@ async function connectToMongo(mongoClient) {
 }
 
 async function initAuthCreds() {
-  if (!baileys) {
-    throw new Error('Baileys is required for auth credentials but not installed');
-  }
-  
-  const { proto, Curve, signedKeyPair, generateRegistrationId } = baileys;
   const identityKey = Curve.generateKeyPair();
   return {
     noiseKey: Curve.generateKeyPair(),
@@ -120,8 +110,8 @@ async function useMongoDBAuthState(uri, dbName, sessionId) {
           const data = {};
           await Promise.all(ids.map(async (id) => {
             let value = await readData(`${type}-${id}`);
-            if (type === 'app-state-sync-key' && baileys) {
-              value = baileys.proto.Message.AppStateSyncKeyData.fromObject(value);
+            if (type === 'app-state-sync-key') {
+              value = proto.Message.AppStateSyncKeyData.fromObject(data);
             }
             data[id] = value;
           }));

package/lib/controllers/assistantController.js

@@ -17,28 +17,14 @@ try {
   // 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
-}
+// Optional service imports - stub functions for missing services
+const getRecordByFilter = () => Promise.resolve(null);
+const createAssistant = () => Promise.resolve({ success: false, error: 'Service not available' });
+const addMsgAssistant = () => Promise.resolve({ success: false, error: 'Service not available' });
+const addInsAssistant = () => Promise.resolve({ success: false, error: 'Service not available' });
+const getThreadInfo = () => Promise.resolve(null);
+const switchAssistant = () => Promise.resolve({ success: false, error: 'Service not available' });
+const sendMessage = () => Promise.resolve({ success: false, error: 'Service not available' });
 
 
 const activeAssistantController = async (req, res) => {
@@ -110,7 +96,7 @@ const createAssistantController = async (req, res) => {
 };
 
 const getInfoAssistantController = async (req, res) => {
-  const { code } = req.body;
+  const { code } = req.query;
 
   try {
     let threadInfo = await getThreadInfo(code);

package/lib/controllers/conversationController.js

@@ -1,6 +1,6 @@
 const { Message } = require('../models/messageModel');
-const { sendMessage } = require('../services/whatsappService');
 const { fetchConversationData, processConversations } = require('../services/conversationService');
+const { sendMessage } = require('../core/NexusMessaging');  
 
 const getConversationController = async (req, res) => {
   const startTime = Date.now();

package/lib/controllers/messageController.js

@@ -1,7 +1,17 @@
-const { ScheduledMessage } = require('../models/agendaMessageModel.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' })
+};
 
-const { getRecordByFilter } = require('../services/airtableService.js');
-const { sendScheduledMessage } = require('../services/whatsappService.js');
+// Stub functions for missing services
+const getRecordByFilter = () => Promise.resolve(null);
+const sendScheduledMessage = () => Promise.resolve({ success: false, error: 'Service not available' });
 
 const moment = require('moment-timezone');
 
@@ -21,7 +31,7 @@ const sendMessageController = async (req, res) => {
   const sendMoment = sendTime ? moment.tz(sendTime, timeZone) + 2500 : new Date();
 
   try {
-    const scheduledMessage = new ScheduledMessage({
+    const messageData = {
       fileUrl,
       message,
       fileType,
@@ -33,14 +43,16 @@ const sendMessageController = async (req, res) => {
       author,
       extraDelay: 0,
       variables
-    });
-    await scheduledMessage.save();
-    console.log(scheduledMessage);
-    const sentMessage = await sendScheduledMessage(scheduledMessage);
-    res.status(200).json({ 
-      status: 200, 
-      response: 'Message scheduled to be sent once!',
-      messageId: sentMessage ? sentMessage.sid : null
+    };
+    await ScheduledMessage.create(messageData);
+    console.log('Sending message with data:', messageData);
+    
+    const result = await sendMessage(messageData);
+    
+    res.status(200).json({
+      success: true,
+      message: 'Message sent successfully',
+      messageId: result?.sid || result?.id
     });
   } catch (err) {
     console.error('Error scheduling individual message:', err.message);

package/lib/controllers/templateController.js

@@ -1,11 +1,23 @@
-const TwilioService = require('../services/twilioService');
-const { handleApiError } = require('../utils/errorHandler');
+// Stub functions for missing services
+const TwilioService = {
+  createTemplate: () => Promise.resolve({ success: false, error: 'Service not available' }),
+  deleteTemplate: () => Promise.resolve({ success: false, error: 'Service not available' }),
+  listTemplates: () => Promise.resolve([]),
+  getTemplate: () => Promise.resolve(null)
+};
+const handleApiError = (res, error, message) => {
+  console.error(message, error);
+  return res.status(500).json({ success: false, error: message });
+};
 
-// Import flow functions from templateFlowController
-const { createFlow, deleteFlow } = require('./templateFlowController');
-const { Template } = require('../templates/templateStructure');
-const TemplateModel = require('../models/templateModel');
-const predefinedTemplates = require('../templates/predefinedTemplates');
+// Stub imports for missing dependencies
+const Template = class { constructor() {} };
+const TemplateModel = {
+  create: () => Promise.resolve({ success: false, error: 'Model not available' }),
+  find: () => Promise.resolve([]),
+  findById: () => Promise.resolve(null)
+};
+const predefinedTemplates = [];
 
 /**
  * Create a new template and store it in both Twilio and our database
@@ -616,6 +628,15 @@ const getCompleteTemplate = async (req, res) => {
   }
 };
 
+// Flow functions (inline since templateFlowController was removed)
+const createFlow = async (req, res) => {
+  return res.status(501).json({ success: false, error: 'Flow creation not available' });
+};
+
+const deleteFlow = async (req, res) => {
+  return res.status(501).json({ success: false, error: 'Flow deletion not available' });
+};
+
 module.exports = {
   createTemplate,
   listTemplates,
@@ -625,7 +646,6 @@ module.exports = {
   checkApprovalStatus,
   deleteTemplate,
   getCompleteTemplate,
-  // Flow functions from templateFlowController
   createFlow,
   deleteFlow
 };

package/lib/routes/index.js

@@ -6,7 +6,7 @@ const assistantRouteDefinitions = {
   'POST /add-instruction': 'addInsAssistantController', 
   'POST /add-msg': 'addMsgAssistantController',
   'POST /create': 'createAssistantController',
-  'POST /get-info': 'getInfoAssistantController',
+  'GET /info': 'getInfoAssistantController',
   'GET /list': 'listAssistantController',
   'POST /switch': 'switchAssistantController',
   'POST /stop': 'stopAssistantController'
@@ -64,13 +64,64 @@ const createRouter = (routeDefinitions, controllers) => {
   return router;
 };
 
-// Helper function to setup all default routes with provided controllers
-const setupDefaultRoutes = (app, controllers) => {
-  app.use('/api/assistant', createRouter(assistantRouteDefinitions, controllers));
-  app.use('/api/conversation', createRouter(conversationRouteDefinitions, controllers));
-  app.use('/api/media', createRouter(mediaRouteDefinitions, controllers));
-  app.use('/api/message', createRouter(messageRouteDefinitions, controllers));
-  app.use('/api/template', createRouter(templateRouteDefinitions, controllers));
+// Import built-in controllers
+const assistantController = require('../controllers/assistantController');
+const conversationController = require('../controllers/conversationController');
+const mediaController = require('../controllers/mediaController');
+const messageController = require('../controllers/messageController');
+const templateController = require('../controllers/templateController');
+
+// Built-in controllers mapping
+const builtInControllers = {
+  // Assistant controllers
+  activeAssistantController: assistantController.activeAssistantController,
+  addInsAssistantController: assistantController.addInsAssistantController,
+  addMsgAssistantController: assistantController.addMsgAssistantController,
+  createAssistantController: assistantController.createAssistantController,
+  getInfoAssistantController: assistantController.getInfoAssistantController,
+  listAssistantController: assistantController.listAssistantController,
+  switchAssistantController: assistantController.switchAssistantController,
+  stopAssistantController: assistantController.stopAssistantController,
+  
+  // Conversation controllers
+  getConversationController: conversationController.getConversationController,
+  searchConversationsController: conversationController.searchConversationsController,
+  getConversationsByNameController: conversationController.getConversationsByNameController,
+  getConversationMessagesController: conversationController.getConversationMessagesController,
+  getNewMessagesController: conversationController.getNewMessagesController,
+  getConversationReplyController: conversationController.getConversationReplyController,
+  sendTemplateToNewNumberController: conversationController.sendTemplateToNewNumberController,
+  markMessagesAsReadController: conversationController.markMessagesAsReadController,
+  
+  // Media controllers
+  getMediaController: mediaController.getMediaController,
+  handleFileUpload: mediaController.handleFileUpload,
+  
+  // Message controllers
+  sendMessageController: messageController.sendMessageController,
+  sendBulkMessageController: messageController.sendBulkMessageController,
+  sendBulkMessageAirtableController: messageController.sendBulkMessageAirtableController,
+  
+  // Template controllers
+  createTemplate: templateController.createTemplate,
+  listTemplates: templateController.listTemplates,
+  getPredefinedTemplates: templateController.getPredefinedTemplates,
+  getTemplate: templateController.getTemplate,
+  getCompleteTemplate: templateController.getCompleteTemplate,
+  createFlow: templateController.createFlow,
+  deleteFlow: templateController.deleteFlow,
+  submitForApproval: templateController.submitForApproval,
+  checkApprovalStatus: templateController.checkApprovalStatus,
+  deleteTemplate: templateController.deleteTemplate
+};
+
+// Helper function to setup all default routes using built-in controllers
+const setupDefaultRoutes = (app) => {
+  app.use('/api/assistant', createRouter(assistantRouteDefinitions, builtInControllers));
+  app.use('/api/conversation', createRouter(conversationRouteDefinitions, builtInControllers));
+  app.use('/api/media', createRouter(mediaRouteDefinitions, builtInControllers));
+  app.use('/api/message', createRouter(messageRouteDefinitions, builtInControllers));
+  app.use('/api/template', createRouter(templateRouteDefinitions, builtInControllers));
 };
 
 module.exports = {

package/lib/services/airtableService.js

@@ -0,0 +1,82 @@
+const { airtable } = require('../config/airtableConfig');
+
+
+async function addRecord(baseID, tableName, fields) {
+  try {
+    const base = airtable.base(baseID);
+    const record = await base(tableName).create(fields);
+    console.log('Record added at', tableName);
+    return record;
+  } catch (error) {
+    console.error('Error adding record:', error);
+    throw error; 
+  }
+}
+
+
+async function getRecords(baseID, tableName) {
+  try {
+    const records = [];
+    const base = airtable.base(baseID);
+    await base(tableName).select({
+      maxRecords: 3
+    }).eachPage((pageRecords, fetchNextPage) => {
+      pageRecords.forEach(record => {
+        records.push(record.fields);
+      });
+      fetchNextPage();
+    });
+    return records;
+  } catch (error) {
+    console.error('Error fetching records:', error);
+  }
+}
+
+
+async function getRecordByFilter(baseID, tableName, filter, view = 'Grid view') {
+  try {
+    const records = [];
+    const base = airtable.base(baseID);
+    await base(tableName).select({
+      filterByFormula: `${filter}`,
+      view: view
+    }).eachPage((pageRecords, fetchNextPage) => {
+      pageRecords.forEach(record => {
+        records.push(record.fields);
+      });
+      fetchNextPage();
+    });
+    return records;
+  } catch (error) {
+    console.error(`Error fetching records by ${filter}:`, error);
+  }
+}
+
+
+async function updateRecordByFilter(baseID, tableName, filter, updateFields) {
+  try {
+    const base = airtable.base(baseID);
+    const updatedRecords = [];
+        
+    await base(tableName).select({
+      filterByFormula: `${filter}`
+    }).eachPage(async (pageRecords, fetchNextPage) => {
+      for (const record of pageRecords) {
+        const updatedRecord = await base(tableName).update(record.id, updateFields);
+        updatedRecords.push(updatedRecord);
+      }
+      fetchNextPage();
+    });
+        
+    return updatedRecords;
+  } catch (error) {
+    console.error(`Error updating records by ${filter}:`, error);
+  }
+}
+
+module.exports = {
+  addRecord,
+  getRecords,
+  getRecordByFilter,
+  updateRecordByFilter
+};

package/lib/services/appointmentService.js

@@ -0,0 +1,55 @@
+const { Calendar_ID } = require('../config/airtableConfig.js');
+
+const { ISO_DATE, parseStartTime, addDays } = require('../utils/dateUtils.js');
+const { dateAndTimeFromStart } = require('../utils/dateUtils.js');
+
+const { getRecordByFilter, updateRecordByFilter } = require('../services/airtableService.js');
+
+
+const getNextAppointmentForPatient = async (name, after = new Date()) => {
+  const filter = `AND(patient_name = "${name}", start_time >= '${ISO_DATE(after)}')`;
+  const rows   = await getRecordByFilter(Calendar_ID, 'calendar_quimio', filter);
+  if (!rows?.length) return null;
+  return rows.sort((a, b) => new Date(a.start_time) - new Date(b.start_time))[0];
+};
+
+const getAppointmentsBetween = async (start, end) => {
+  const filter = `AND(start_time >= '${ISO_DATE(start)}', start_time < '${ISO_DATE(end)}')`;
+  return getRecordByFilter(Calendar_ID, 'calendar_quimio', filter);
+};
+
+const updateAppointmentById = async (recordId, data) => {
+  return updateRecordByFilter(
+    Calendar_ID,
+    'calendar_quimio',
+    `REGEX_MATCH({record_id}, '${recordId}')`,
+    data
+  );
+};
+
+const buildAvailabilityWindow = async originalDate => {
+  const start = addDays(originalDate, 1);
+  const end = addDays(originalDate, 7);
+  
+  const allSlots = await getAppointmentsBetween(start, addDays(end, 1));
+  const availableSlots = allSlots.filter(row => !row.patient);
+  
+  const result = {};
+  availableSlots.forEach(row => {
+    const { date, time } = dateAndTimeFromStart(row.start_time);
+    if (!result[date]) result[date] = [];
+    result[date].push({ time, availableSpots: 1 });
+  });
+  
+  return result;
+};
+
+const parseStart = parseStartTime;
+
+module.exports = {
+  getNextAppointmentForPatient,
+  getAppointmentsBetween,
+  updateAppointmentById,
+  parseStart,
+  buildAvailabilityWindow
+};