@peopl-health/nexus 1.0.2

package/lib/utils/logger.js

@@ -0,0 +1,22 @@
+const pino = require('pino');
+
+const createLogger = (config = {}) => {
+  const {
+    level = process.env.NODE_ENV === 'production' ? 'info' : 'debug'
+  } = config;
+
+  return pino({
+    level,
+    transport: process.env.NODE_ENV !== 'production' ? {
+      target: 'pino-pretty',
+      options: {
+        colorize: true
+      }
+    } : undefined
+  });
+};
+
+// Default logger instance
+const logger = createLogger();
+
+module.exports = { logger, createLogger };

package/lib/utils/mongoAuthConfig.js

@@ -0,0 +1,139 @@
+const { MongoClient } = require('mongodb');
+
+const { proto, Curve, signedKeyPair, generateRegistrationId } = require('baileys');
+const { randomBytes } = require('crypto');
+
+async function connectToMongo(mongoClient) {
+  try {
+    await mongoClient.connect();
+    console.log('Connected to Mongo database successfully.');
+  } catch (err) {
+    console.error('Error connecting to Mongo database:', err.message);
+    throw err;
+  }
+}
+
+async function initAuthCreds() {
+  const identityKey = Curve.generateKeyPair();
+  return {
+    noiseKey: Curve.generateKeyPair(),
+    signedIdentityKey: identityKey,
+    signedPreKey: signedKeyPair(identityKey, 1),
+    registrationId: generateRegistrationId(),
+    advSecretKey: randomBytes(32).toString('base64'),
+    processedHistoryMessages: [],
+    nextPreKeyId: 1,
+    firstUnuploadedPreKeyId: 1,
+    accountSettings: {
+      unarchiveChats: false,
+    },
+  };
+}
+
+const BufferJSON = {
+  replacer: (k, value) => {
+    if (
+      Buffer.isBuffer(value) ||
+        value instanceof Uint8Array ||
+        value?.type === 'Buffer'
+    ) {
+      return {
+        type: 'Buffer',
+        data: Buffer.from(value?.data || value).toString('base64'),
+      };
+    }
+  
+    return value;
+  },
+  
+  reviver: (_, value) => {
+    if (
+      typeof value === 'object' &&
+        !!value &&
+        (value.buffer === true || value.type === 'Buffer')
+    ) {
+      const val = value.data || value.value;
+      return typeof val === 'string'
+        ? Buffer.from(val, 'base64')
+        : Buffer.from(val || []);
+    }
+  
+    return value;
+  },
+};
+
+async function useMongoDBAuthState(uri, dbName, sessionId) {
+  const client = new MongoClient(uri);
+  await connectToMongo(client);
+    
+  const db = client.db(dbName);
+  const collection = db.collection('auth_sessions');
+    
+  const writeData = async (data, key) => {
+    const informationToStore = JSON.parse(
+      JSON.stringify(data, BufferJSON.replacer)
+    );
+
+    const update = {
+      $set: {
+        ...informationToStore,
+      },
+    };
+    return collection.updateOne({ _id: `${sessionId}-${key}` }, update, { upsert: true });
+  };
+
+  const readData = async (key) => {
+    try {
+      const data = JSON.stringify(await collection.findOne({ _id: `${sessionId}-${key}` }));
+      return JSON.parse(data, BufferJSON.reviver);
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  };
+    
+  const removeData = async (key) => {
+    try {
+      await collection.deleteOne({ _id: `${sessionId}-${key}` });
+    } catch (err) {
+      console.log(err);
+    }
+  };
+
+  const creds = (await readData('creds')) || (0, initAuthCreds)();
+
+  return {
+    state: {
+      creds,
+      keys: {
+        get: async (type, ids) => {
+          const data = {};
+          await Promise.all(ids.map(async (id) => {
+            let value = await readData(`${type}-${id}`);
+            if (type === 'app-state-sync-key') {
+              value = proto.Message.AppStateSyncKeyData.fromObject(data);
+            }
+            data[id] = value;
+          }));
+          return data;
+        },
+        set: async (data) => {
+          const tasks = [];
+          for (const category in data) {
+            for (const id in data[category]) {
+              const value = data[category][id];
+              const key = `${category}-${id}`;
+              tasks.push(value ? writeData(value, key) : removeData(key));
+            }
+          }
+          await Promise.all(tasks);
+        }
+      }
+    },
+    saveCreds: async () => {
+      await writeData(creds, 'creds');
+    }
+  };
+}
+
+module.exports = { useMongoDBAuthState };

package/lib/utils/twilioHelper.js

@@ -0,0 +1,77 @@
+const axios = require('axios');
+const { v4: uuidv4 } = require('uuid');
+
+function convertTwilioToInternalFormat(twilioMessage) {
+  const from = twilioMessage.From || '';
+  const to = twilioMessage.To || '';
+  const fromMe = to === from;
+    
+  return {
+    key: {
+      id: twilioMessage.MessageSid || uuidv4(),
+      fromMe: fromMe,
+      remoteJid: fromMe ? to : from
+    },
+    pushName: twilioMessage.ProfileName || '',
+    message: {
+      conversation: twilioMessage.Body || ''
+    },
+    messageTimestamp: Math.floor(Date.now() / 1000)
+  };
+}
+
+async function downloadMediaFromTwilio(mediaUrl, credentials) {
+  try {
+    console.log(`Downloading media from: ${mediaUrl}`);
+        
+    const response = await axios({
+      method: 'GET',
+      url: mediaUrl,
+      responseType: 'arraybuffer',
+      headers: {
+        'Authorization': `Basic ${Buffer.from(
+          `${credentials.accountSid}:${credentials.authToken}`
+        ).toString('base64')}`
+      }
+    });
+        
+    return Buffer.from(response.data);
+  } catch (error) {
+    console.error(`Failed to download media: ${error.message}`);
+    throw error;
+  }
+}
+
+function getMediaTypeFromContentType(contentType) {
+  if (contentType.startsWith('image/')) return 'imageMessage';
+  if (contentType.startsWith('audio/')) return 'audioMessage';
+  if (contentType.startsWith('video/')) return 'videoMessage';
+  if (contentType.startsWith('application/')) return 'documentMessage';
+  return 'unknownMessage';
+}
+
+function extractTitle(message, mediaType) {
+  if (mediaType === 'documentMessage' && message.MediaUrl0) {
+    const urlParts = message.MediaUrl0.split('/');
+    return urlParts[urlParts.length - 1] || null;
+  }
+  return null;
+}
+
+const ensureWhatsAppFormat = (phoneNumber) => {
+  if (!phoneNumber) return null;
+    
+  if (phoneNumber.startsWith('whatsapp:')) {
+    return phoneNumber;
+  }
+    
+  return `whatsapp:${phoneNumber}`;
+};
+
+module.exports = {
+  convertTwilioToInternalFormat,
+  downloadMediaFromTwilio,
+  getMediaTypeFromContentType,
+  extractTitle,
+  ensureWhatsAppFormat
+};

package/lib/utils/whatsappHelper.js

@@ -0,0 +1,68 @@
+const moment = require('moment-timezone');
+
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function formatCode(codeBase) {
+
+  const [number, domain] = codeBase.split('@');
+    
+  if (!number || !domain) {
+    throw new Error('Invalid code format: missing number or domain');
+  }
+
+  if (domain !== 's.whatsapp.net') {
+    throw new Error('Invalid domain: must be s.whatsapp.net');
+  }
+
+  let formattedNumber = number;
+
+  if (formattedNumber.endsWith('-2')) {
+    formattedNumber = formattedNumber.slice(0, -2);
+  }
+
+  if (formattedNumber.length === 10) {
+    formattedNumber = '52' + formattedNumber;
+  }
+
+  if (formattedNumber.startsWith('52') && formattedNumber.length === 12) {
+    formattedNumber = formattedNumber.substring(0, 2) + '1' + formattedNumber.substring(2);
+  }
+  return `${formattedNumber}@s.whatsapp.net`;
+}
+
+function calculateDelay(sendTime, timeZone) {
+  if (sendTime !== undefined && timeZone !== undefined) {
+    const sendMoment = moment.tz(sendTime, timeZone);
+
+    if (!sendMoment.isValid()) {
+      return { error: 'Invalid time format' };
+    }
+
+    const now = moment().tz(timeZone);
+    const randomDelay = Math.floor(Math.random() * 15001) + 15000;
+    const delay = sendMoment.diff(now) + randomDelay;
+
+    console.log(
+      'Scheduled Time:', sendMoment.format(), 
+      'Current Time:', now.format(), 
+      'Delay (minutes):', delay / 60000, 
+      'Remaining Seconds:', delay % 60000
+    );
+
+    if (delay <= 0) {
+      return 2500;
+    }
+
+    return delay;
+  } else {
+    return 2500;
+  }
+}
+
+module.exports = {
+  delay,
+  formatCode,
+  calculateDelay
+};

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@peopl-health/nexus",
+  "version": "1.0.2",
+  "description": "Core messaging and assistant library for WhatsApp communication platforms",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./lib/index.js",
+      "require": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    },
+    "./adapters": {
+      "import": "./lib/adapters/index.js",
+      "require": "./lib/adapters/index.js"
+    },
+    "./core": {
+      "import": "./lib/core/index.js",
+      "require": "./lib/core/index.js"
+    },
+    "./utils": {
+      "import": "./lib/utils/index.js",
+      "require": "./lib/utils/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "jest",
+    "lint": "eslint lib/**/*.js",
+    "prepublishOnly": "npm test && npm run lint",
+    "version": "npm run prepublishOnly && git add -A lib",
+    "postversion": "git push && git push --tags"
+  },
+  "keywords": [
+    "whatsapp",
+    "messaging",
+    "ai-assistant",
+    "twilio",
+    "baileys",
+    "communication"
+  ],
+  "author": "PEOPL Health Tech",
+  "license": "MIT",
+  "dependencies": {
+    "mongoose": "^7.5.0",
+    "moment-timezone": "^0.5.43",
+    "pino": "^8.15.0",
+    "pino-pretty": "^10.2.0",
+    "uuid": "^9.0.0",
+    "axios": "^1.5.0"
+  },
+  "peerDependencies": {
+    "baileys": "^6.4.0",
+    "twilio": "^4.15.0",
+    "openai": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.5.0",
+    "typescript": "^5.1.6",
+    "jest": "^29.6.2",
+    "eslint": "^8.47.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/peopl-health/nexus.git"
+  },
+  "files": [
+    "lib/",
+    "examples/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "MIGRATION_GUIDE.md"
+  ]
+}