Comprehensive comparison for technology in applications

const Ably = require('ably');
const express = require('express');
const app = express();

// Initialize Ably client with API key
const ably = new Ably.Realtime({
  key: process.env.ABLY_API_KEY,
  echoMessages: false
});

// Middleware
app.use(express.json());

// Real-time order tracking system
class OrderTrackingService {
  constructor(ablyClient) {
    this.ably = ablyClient;
    this.ordersChannel = this.ably.channels.get('orders');
    
    // Handle connection state changes
    this.ably.connection.on('connected', () => {
      console.log('Connected to Ably');
    });
    
    this.ably.connection.on('failed', (err) => {
      console.error('Ably connection failed:', err);
    });
  }

  async publishOrderUpdate(orderId, status, metadata = {}) {
    try {
      const message = {
        orderId,
        status,
        timestamp: Date.now(),
        ...metadata
      };

      await this.ordersChannel.publish('order-update', message);
      console.log(`Published order update for ${orderId}`);
      return { success: true, message };
    } catch (error) {
      console.error('Failed to publish order update:', error);
      throw new Error('Unable to publish order update');
    }
  }

  async getOrderHistory(orderId) {
    try {
      const history = await this.ordersChannel.history({
        limit: 100,
        direction: 'backwards'
      });

      const orderMessages = history.items
        .filter(msg => msg.data.orderId === orderId)
        .map(msg => msg.data);

      return orderMessages;
    } catch (error) {
      console.error('Failed to retrieve order history:', error);
      return [];
    }
  }

  generateTokenRequest(clientId) {
    return this.ably.auth.createTokenRequest({
      clientId,
      capability: {
        'orders': ['subscribe'],
        [`orders:${clientId}`]: ['subscribe', 'publish']
      },
      ttl: 3600000
    });
  }
}

const orderService = new OrderTrackingService(ably);

// API endpoint to update order status
app.post('/api/orders/:orderId/status', async (req, res) => {
  try {
    const { orderId } = req.params;
    const { status, location, estimatedDelivery } = req.body;

    if (!orderId || !status) {
      return res.status(400).json({ error: 'Missing required fields' });
    }

    const result = await orderService.publishOrderUpdate(orderId, status, {
      location,
      estimatedDelivery
    });

    res.json(result);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// API endpoint to get order history
app.get('/api/orders/:orderId/history', async (req, res) => {
  try {
    const { orderId } = req.params;
    const history = await orderService.getOrderHistory(orderId);
    res.json({ orderId, history });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Token authentication endpoint for clients
app.post('/api/auth/token', async (req, res) => {
  try {
    const { clientId } = req.body;
    
    if (!clientId) {
      return res.status(400).json({ error: 'clientId required' });
    }

    const tokenRequest = await orderService.generateTokenRequest(clientId);
    res.json(tokenRequest);
  } catch (error) {
    res.status(500).json({ error: 'Token generation failed' });
  }
});

// Graceful shutdown
process.on('SIGTERM', () => {
  console.log('Shutting down gracefully...');
  ably.close();
  process.exit(0);
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});