@akson/chatsuite-sdk/examples/session-management.ts

Production-ready TypeScript SDK for ChatSuite - WhatsApp automation with built-in session management, message queuing, webhook server, and database sync

/**
 * Session Management Example
 * 
 * Demonstrates advanced session management features:
 * - MongoDB session persistence
 * - Auto-reconnection logic
 * - Health monitoring
 * - Multiple session handling
 * 
 * Run: npx ts-node examples/session-management.ts
 */

import { 
  SessionManager, 
  MongoSessionStore, 
  InMemorySessionStore 
} from '../src/index';

async function sessionManagementExample() {
  console.log('🗄️ Session Management Example');

  // Choose storage backend
  const useMongoStorage = process.env.MONGODB_URI ? true : false;
  
  const sessionManager = new SessionManager({
    store: useMongoStorage 
      ? new MongoSessionStore({
          uri: process.env.MONGODB_URI!,
          database: 'whatsapp_sessions',
          collection: 'sessions'
        })
      : new InMemorySessionStore(),
    
    autoReconnect: true,
    qrCodeExpiry: 60000, // 1 minute
    maxReconnectAttempts: 5,
    reconnectDelay: 5000, // 5 seconds
    healthCheckInterval: 30000 // 30 seconds
  });

  // Initialize session manager
  console.log('Initializing session manager...');
  await sessionManager.initialize();
  console.log(`✅ Session manager initialized with ${useMongoStorage ? 'MongoDB' : 'in-memory'} storage`);

  // Event handlers
  sessionManager.on('session:created', (session) => {
    console.log(`✨ Session created: ${session.phoneNumber} (${session.sessionId})`);
  });

  sessionManager.on('session:qr', (session) => {
    console.log(`📱 QR Code available for ${session.phoneNumber}`);
    console.log(`QR expires at: ${session.qrCodeExpiry}`);
    // In a real app, you would display the QR code to the user
    // console.log('QR Code:', session.qrCode);
  });

  sessionManager.on('session:connected', (session) => {
    console.log(`🔗 Session connected: ${session.phoneNumber}`);
    console.log(`Connected at: ${session.lastConnected}`);
  });

  sessionManager.on('session:disconnected', (session) => {
    console.log(`❌ Session disconnected: ${session.phoneNumber}`);
  });

  sessionManager.on('session:expired', (phoneNumber) => {
    console.log(`⏰ Session expired and removed: ${phoneNumber}`);
  });

  sessionManager.on('health:check', (phoneNumber, health) => {
    console.log(`🏥 Health check for ${phoneNumber}: ${health.status}`);
    if (health.latency) {
      console.log(`  Latency: ${health.latency}ms`);
    }
    if (health.errors && health.errors.length > 0) {
      console.log(`  Errors: ${health.errors.join(', ')}`);
    }
  });

  // Create multiple sessions
  const phoneNumbers = [
    '+1234567890',
    '+0987654321',
    '+1122334455'
  ];

  console.log('\n📱 Creating sessions...');
  for (const phoneNumber of phoneNumbers) {
    try {
      const session = await sessionManager.createOrRestore(
        phoneNumber, 
        `Session for ${phoneNumber}`
      );
      
      console.log(`✅ Created session: ${session.phoneNumber}`);
      
      // Simulate QR code generation
      await sessionManager.updateQRCode(phoneNumber, `qr-code-${Date.now()}`);
      
      // Simulate connection after some delay
      setTimeout(async () => {
        try {
          await sessionManager.markConnected(phoneNumber, {
            // Baileys session data would go here
            creds: { noiseKey: 'example' },
            keys: { preKeys: {} }
          });
        } catch (error) {
          console.log(`Failed to connect ${phoneNumber}:`, error.message);
        }
      }, Math.random() * 5000); // Random delay 0-5 seconds

    } catch (error) {
      console.error(`❌ Failed to create session for ${phoneNumber}:`, error.message);
    }
  }

  // Monitor sessions
  setInterval(async () => {
    try {
      const allSessions = await sessionManager.getAllSessions();
      
      console.log('\n📊 Session Status Summary:');
      console.log(`Total sessions: ${allSessions.length}`);
      
      const statusCounts = allSessions.reduce((acc, session) => {
        acc[session.status] = (acc[session.status] || 0) + 1;
        return acc;
      }, {} as Record<string, number>);
      
      for (const [status, count] of Object.entries(statusCounts)) {
        console.log(`  ${status}: ${count}`);
      }

      // Health check for connected sessions
      for (const session of allSessions) {
        if (session.status === 'connected') {
          const health = await sessionManager.getSessionHealth(session.phoneNumber);
          if (health) {
            console.log(`  ${session.phoneNumber}: ${health.status}`);
          }
        }
      }

    } catch (error) {
      console.error('Error monitoring sessions:', error);
    }
  }, 15000); // Every 15 seconds

  // Simulate random disconnections
  setInterval(async () => {
    try {
      const allSessions = await sessionManager.getAllSessions();
      const connectedSessions = allSessions.filter(s => s.status === 'connected');
      
      if (connectedSessions.length > 0 && Math.random() < 0.3) {
        const randomSession = connectedSessions[Math.floor(Math.random() * connectedSessions.length)];
        console.log(`\n🔌 Simulating disconnection for ${randomSession.phoneNumber}`);
        await sessionManager.markDisconnected(randomSession.phoneNumber);
      }
    } catch (error) {
      console.error('Error in disconnect simulation:', error);
    }
  }, 20000); // Every 20 seconds

  // Cleanup old sessions periodically
  setInterval(async () => {
    try {
      const allSessions = await sessionManager.getAllSessions();
      const oldSessions = allSessions.filter(session => {
        const age = Date.now() - session.lastConnected?.getTime() || 0;
        return age > 5 * 60 * 1000; // 5 minutes old
      });

      for (const oldSession of oldSessions) {
        if (oldSession.status === 'disconnected') {
          console.log(`🧹 Cleaning up old session: ${oldSession.phoneNumber}`);
          await sessionManager.deleteSession(oldSession.phoneNumber);
        }
      }
    } catch (error) {
      console.error('Error in cleanup:', error);
    }
  }, 60000); // Every minute

  console.log('\n🎮 Session management demo running!');
  console.log('Features demonstrated:');
  console.log('  ✅ Multi-session management');
  console.log('  ✅ Automatic persistence');
  console.log('  ✅ Health monitoring');
  console.log('  ✅ Auto-reconnection');
  console.log('  ✅ Event-driven updates');
  console.log('\nPress Ctrl+C to stop...');

  // Graceful shutdown
  process.on('SIGINT', async () => {
    console.log('\n🛑 Shutting down session manager...');
    await sessionManager.stop();
    console.log('✅ Session manager stopped');
    process.exit(0);
  });
}

// Handle errors
process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
});

// Run the example
if (require.main === module) {
  sessionManagementExample().catch(console.error);
}

export { sessionManagementExample };