Real-time Notifications

Advanced Topics in Real-time Notifications

Push Notifications

Extend your real-time notification system to include push notifications using Web Push API or services like Firebase Cloud Messaging (FCM).

// Using web-push library for Web Push API
const webpush = require('web-push');

// VAPID keys should be generated only once
const vapidKeys = webpush.generateVAPIDKeys();

webpush.setVapidDetails(
  'mailto:example@yourdomain.com',
  vapidKeys.publicKey,
  vapidKeys.privateKey
);

// Store user's subscription object
app.post('/api/push-subscribe', async (req, res) => {
  const { subscription, userId } = req.body;
  
  try {
    await saveSubscription(userId, subscription);
    res.status(201).json({ success: true });
  } catch (error) {
    console.error('Error saving push subscription:', error);
    res.status(500).json({ error: 'Failed to save subscription' });
  }
});

// Send push notification
async function sendPushNotification(userId, title, body, data = {}) {
  try {
    const subscriptions = await getSubscriptionsForUser(userId);
    
    if (!subscriptions || subscriptions.length === 0) {
      return { success: false, reason: 'No subscriptions found' };
    }
    
    const payload = JSON.stringify({
      title,
      body,
      data
    });
    
    const results = await Promise.all(
      subscriptions.map(async (subscription) => {
        try {
          await webpush.sendNotification(subscription, payload);
          return { success: true, subscription };
        } catch (error) {
          if (error.statusCode === 410) {
            // Subscription has expired or is no longer valid
            await removeSubscription(subscription);
          }
          return { success: false, subscription, error };
        }
      })
    );
    
    return {
      success: true,
      results
    };
  } catch (error) {
    console.error('Error sending push notification:', error);
    return { success: false, error };
  }
}

// Enhance notification service to also send push notification
class PushNotificationService extends EnhancedNotificationService {
  async sendToUser(userId, notificationType, payload) {
    // Send socket.io notification
    const socketResult = await super.sendToUser(userId, notificationType, payload);
    
    // If no active connections, try to send push notification
    if (socketResult === 0) {
      // Check user preferences for push
      const shouldPush = await shouldSendPushNotification(userId, notificationType);
      
      if (shouldPush) {
        // Format payload for push notification
        const pushPayload = formatPushPayload(notificationType, payload);
        
        // Send push notification
        await sendPushNotification(
          userId,
          pushPayload.title,
          pushPayload.body,
          {
            type: notificationType,
            url: pushPayload.url,
            ...pushPayload.data
          }
        );
      }
    }
    
    return socketResult;
  }
}

// Helper to format push notification content
function formatPushPayload(type, payload) {
  switch (type) {
    case 'message':
      return {
        title: `New message from ${payload.sender}`,
        body: payload.preview,
        url: `/messages/${payload.conversationId}`,
        data: { messageId: payload.messageId }
      };
    
    case 'friend-request':
      return {
        title: 'New Friend Request',
        body: `${payload.name} wants to connect with you`,
        url: '/friends/requests',
        data: { requestId: payload.requestId }
      };
    
    // Add more notification types as needed
    
    default:
      return {
        title: 'New Notification',
        body: 'You have a new notification',
        url: '/notifications',
        data: {}
      };
  }
}
            

Offline Support and Syncing

Handle cases where users are offline and need to receive missed notifications when they reconnect.

// Enhanced notification service with offline support
class OfflineAwareNotificationService extends PushNotificationService {
  constructor(io, db) {
    super(io);
    this.db = db; // Database connection for storing notifications
  }
  
  async sendToUser(userId, notificationType, payload) {
    // Always store notification in database
    await this.storeNotification(userId, notificationType, payload);
    
    // Attempt to deliver via socket.io and push
    return super.sendToUser(userId, notificationType, payload);
  }
  
  async storeNotification(userId, type, payload) {
    try {
      await this.db.collection('notifications').insertOne({
        userId,
        type,
        payload,
        read: false,
        delivered: false,
        createdAt: new Date()
      });
    } catch (error) {
      console.error('Error storing notification:', error);
    }
  }
  
  async markAsDelivered(notificationIds) {
    try {
      await this.db.collection('notifications').updateMany(
        { _id: { $in: notificationIds } },
        { $set: { delivered: true, deliveredAt: new Date() } }
      );
    } catch (error) {
      console.error('Error marking notifications as delivered:', error);
    }
  }
  
  async markAsRead(notificationIds) {
    try {
      await this.db.collection('notifications').updateMany(
        { _id: { $in: notificationIds } },
        { $set: { read: true, readAt: new Date() } }
      );
    } catch (error) {
      console.error('Error marking notifications as read:', error);
    }
  }
  
  async getUndeliveredNotifications(userId) {
    try {
      return await this.db.collection('notifications')
        .find({ userId, delivered: false })
        .sort({ createdAt: 1 })
        .toArray();
    } catch (error) {
      console.error('Error getting undelivered notifications:', error);
      return [];
    }
  }
}

// Socket.io handling for reconnection and notification syncing
io.on('connection', (socket) => {
  // ... other connection handling
  
  // Handle authentication and user registration
  socket.on('auth', async (userData) => {
    const userId = userData.userId;
    
    // Register this socket with the user ID
    notificationService.registerUser(userId, socket.id);
    
    // Fetch undelivered notifications
    const undeliveredNotifications = await notificationService.getUndeliveredNotifications(userId);
    
    if (undeliveredNotifications.length > 0) {
      // Send undelivered notifications to the client
      socket.emit('notification-sync', undeliveredNotifications);
      
      // Mark notifications as delivered
      await notificationService.markAsDelivered(
        undeliveredNotifications.map(notification => notification._id)
      );
    }
    
    // Acknowledge successful authentication
    socket.emit('auth_success', { userId });
  });
  
  // Handle notification read status updates
  socket.on('mark-notifications-read', async (data) => {
    const { notificationIds } = data;
    
    await notificationService.markAsRead(notificationIds);
    socket.emit('notifications-marked-read', { success: true, count: notificationIds.length });
  });
});
            

Analytics and Insights

Track notification engagement to improve your notification strategy.

// Add analytics capabilities to notification service
class AnalyticsEnabledNotificationService extends OfflineAwareNotificationService {
  constructor(io, db, analyticsService) {
    super(io, db);
    this.analyticsService = analyticsService;
  }
  
  async sendToUser(userId, notificationType, payload) {
    // Track notification send event
    this.analyticsService.trackEvent('notification_sent', {
      userId,
      notificationType,
      timestamp: new Date()
    });
    
    return super.sendToUser(userId, notificationType, payload);
  }
  
  async markAsDelivered(notificationIds) {
    // Get notifications before marking them as delivered
    const notifications = await this.db.collection('notifications')
      .find({ _id: { $in: notificationIds } })
      .toArray();
    
    // Track delivery events
    for (const notification of notifications) {
      this.analyticsService.trackEvent('notification_delivered', {
        userId: notification.userId,
        notificationId: notification._id.toString(),
        notificationType: notification.type,
        deliveryLatency: new Date() - notification.createdAt,
        timestamp: new Date()
      });
    }
    
    return super.markAsDelivered(notificationIds);
  }
  
  async markAsRead(notificationIds) {
    // Get notifications before marking them as read
    const notifications = await this.db.collection('notifications')
      .find({ _id: { $in: notificationIds } })
      .toArray();
    
    // Track read events
    for (const notification of notifications) {
      const deliveredAt = notification.deliveredAt || notification.createdAt;
      
      this.analyticsService.trackEvent('notification_read', {
        userId: notification.userId,
        notificationId: notification._id.toString(),
        notificationType: notification.type,
        readLatency: new Date() - deliveredAt,
        totalLatency: new Date() - notification.createdAt,
        timestamp: new Date()
      });
    }
    
    return super.markAsRead(notificationIds);
  }
  
  // Get engagement metrics for notifications
  async getEngagementMetrics(options = {}) {
    const { startDate, endDate, notificationType } = options;
    
    const query = {};
    
    if (startDate || endDate) {
      query.createdAt = {};
      if (startDate) query.createdAt.$gte = new Date(startDate);
      if (endDate) query.createdAt.$lte = new Date(endDate);
    }
    
    if (notificationType) {
      query.type = notificationType;
    }
    
    try {
      const totalCount = await this.db.collection('notifications')
        .countDocuments(query);
        
      const deliveredCount = await this.db.collection('notifications')
        .countDocuments({ ...query, delivered: true });
        
      const readCount = await this.db.collection('notifications')
        .countDocuments({ ...query, read: true });
        
      // Calculate average delivery and read times
      const deliveryTimes = await this.db.collection('notifications')
        .find({ ...query, delivered: true, deliveredAt: { $exists: true } })
        .project({ deliveryTime: { $subtract: ['$deliveredAt', '$createdAt'] } })
        .toArray();
        
      const readTimes = await this.db.collection('notifications')
        .find({ ...query, read: true, readAt: { $exists: true } })
        .project({ readTime: { $subtract: ['$readAt', '$deliveredAt'] } })
        .toArray();
        
      const avgDeliveryTime = deliveryTimes.length > 0 
        ? deliveryTimes.reduce((sum, item) => sum + item.deliveryTime, 0) / deliveryTimes.length 
        : null;
        
      const avgReadTime = readTimes.length > 0 
        ? readTimes.reduce((sum, item) => sum + item.readTime, 0) / readTimes.length 
        : null;
      
      return {
        totalCount,
        deliveredCount,
        readCount,
        deliveryRate: totalCount > 0 ? deliveredCount / totalCount : 0,
        readRate: deliveredCount > 0 ? readCount / deliveredCount : 0,
        overallReadRate: totalCount > 0 ? readCount / totalCount : 0,
        avgDeliveryTime,
        avgReadTime
      };
    } catch (error) {
      console.error('Error calculating engagement metrics:', error);
      return null;
    }
  }
}