dubs-server 1.0.0

package/services/notificationCacheService.js

@@ -0,0 +1,407 @@
+/**
+ * Notification Cache Service - Redis-backed high-performance notification layer
+ * 
+ * Architecture:
+ * - Redis Sorted Set: notifications:{userId} → notification IDs sorted by timestamp
+ * - Redis Hash: notification:{id} → notification data
+ * - Redis Counter: unread:{userId} → instant unread count
+ * - TTL: 48 hours for cached notifications
+ * 
+ * Gracefully falls back to PostgreSQL when Redis is unavailable.
+ */
+
+const redisService = require('./redisService');
+
+// Key prefixes
+const KEYS = {
+  NOTIFICATIONS: (userId) => `notifications:${userId}`,
+  NOTIFICATION: (id) => `notification:${id}`,
+  UNREAD_COUNT: (userId) => `unread:${userId}`,
+};
+
+// Cache TTL (48 hours in seconds)
+const CACHE_TTL = 48 * 60 * 60;
+
+// Maximum notifications to cache per user
+const MAX_CACHED_NOTIFICATIONS = 500;
+
+class NotificationCacheService {
+  constructor() {
+    this.enabled = false;
+  }
+
+  /**
+   * Initialize the cache service
+   * Called during server startup
+   */
+  async initialize() {
+    this.enabled = await redisService.connect();
+    if (this.enabled) {
+      console.log('✅ [NotificationCache] Redis caching enabled');
+    } else {
+      console.log('⚠️  [NotificationCache] Running without Redis cache (PostgreSQL fallback)');
+    }
+    return this.enabled;
+  }
+
+  /**
+   * Check if caching is available
+   */
+  isEnabled() {
+    return this.enabled && redisService.isAvailable();
+  }
+
+  // ============================================
+  // WRITE OPERATIONS
+  // ============================================
+
+  /**
+   * Cache a new notification
+   * Called after writing to PostgreSQL
+   * 
+   * @param {number} userId - User ID
+   * @param {Object} notification - Notification object with id, type, createdAt, etc.
+   */
+  async cacheNotification(userId, notification) {
+    if (!this.isEnabled()) return false;
+
+    try {
+      const notificationId = notification.id;
+      const timestamp = new Date(notification.createdAt).getTime();
+
+      // Use pipeline for atomic operations
+      const pipeline = redisService.pipeline();
+      if (!pipeline) return false;
+
+      // 1. Add to user's sorted set
+      pipeline.zadd(KEYS.NOTIFICATIONS(userId), timestamp, notificationId.toString());
+
+      // 2. Store notification data as hash
+      pipeline.hset(KEYS.NOTIFICATION(notificationId), {
+        id: notificationId.toString(),
+        type: notification.type || '',
+        read: notification.read ? '1' : '0',
+        messageId: notification.messageId?.toString() || '',
+        message: notification.message || '',
+        senderUsername: notification.senderUsername || '',
+        senderWallet: notification.senderWallet || '',
+        senderAvatar: notification.senderAvatar || '',
+        createdAt: notification.createdAt?.toISOString?.() || notification.createdAt || '',
+        // Store complex objects as JSON strings
+        gameInvite: notification.gameInvite ? JSON.stringify(notification.gameInvite) : '',
+        finalScore: notification.finalScore ? JSON.stringify(notification.finalScore) : '',
+        notificationData: notification.notificationData ? JSON.stringify(notification.notificationData) : '',
+      });
+
+      // 3. Set TTL on notification hash
+      pipeline.expire(KEYS.NOTIFICATION(notificationId), CACHE_TTL);
+
+      // 4. Increment unread counter if notification is unread
+      if (!notification.read) {
+        pipeline.incr(KEYS.UNREAD_COUNT(userId));
+      }
+
+      // 5. Trim sorted set to max size (keep most recent)
+      pipeline.zremrangebyrank(KEYS.NOTIFICATIONS(userId), 0, -(MAX_CACHED_NOTIFICATIONS + 1));
+
+      // 6. Set TTL on sorted set
+      pipeline.expire(KEYS.NOTIFICATIONS(userId), CACHE_TTL);
+
+      await pipeline.exec();
+
+      console.log(`[NotificationCache] ✅ Cached notification ${notificationId} for user ${userId}`);
+      return true;
+
+    } catch (error) {
+      console.error('[NotificationCache] Error caching notification:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Bulk cache notifications (for warming cache from PostgreSQL)
+   * 
+   * @param {number} userId - User ID
+   * @param {Object[]} notifications - Array of notification objects
+   */
+  async bulkCacheNotifications(userId, notifications) {
+    if (!this.isEnabled() || notifications.length === 0) return false;
+
+    try {
+      const pipeline = redisService.pipeline();
+      if (!pipeline) return false;
+
+      let unreadCount = 0;
+
+      for (const notification of notifications) {
+        const notificationId = notification.id;
+        const timestamp = new Date(notification.createdAt).getTime();
+
+        // Add to sorted set
+        pipeline.zadd(KEYS.NOTIFICATIONS(userId), timestamp, notificationId.toString());
+
+        // Store notification data
+        pipeline.hset(KEYS.NOTIFICATION(notificationId), {
+          id: notificationId.toString(),
+          type: notification.type || '',
+          read: notification.read ? '1' : '0',
+          messageId: notification.messageId?.toString() || '',
+          message: notification.message || '',
+          senderUsername: notification.senderUsername || '',
+          senderWallet: notification.senderWallet || '',
+          senderAvatar: notification.senderAvatar || '',
+          createdAt: notification.createdAt?.toISOString?.() || notification.createdAt || '',
+          gameInvite: notification.gameInvite ? JSON.stringify(notification.gameInvite) : '',
+          finalScore: notification.finalScore ? JSON.stringify(notification.finalScore) : '',
+          notificationData: notification.notificationData ? JSON.stringify(notification.notificationData) : '',
+        });
+
+        pipeline.expire(KEYS.NOTIFICATION(notificationId), CACHE_TTL);
+
+        if (!notification.read) {
+          unreadCount++;
+        }
+      }
+
+      // Set unread count
+      pipeline.set(KEYS.UNREAD_COUNT(userId), unreadCount.toString());
+
+      // Trim and set TTL
+      pipeline.zremrangebyrank(KEYS.NOTIFICATIONS(userId), 0, -(MAX_CACHED_NOTIFICATIONS + 1));
+      pipeline.expire(KEYS.NOTIFICATIONS(userId), CACHE_TTL);
+
+      await pipeline.exec();
+
+      console.log(`[NotificationCache] ✅ Bulk cached ${notifications.length} notifications for user ${userId}`);
+      return true;
+
+    } catch (error) {
+      console.error('[NotificationCache] Error bulk caching:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Mark notification(s) as read
+   * 
+   * @param {number} userId - User ID
+   * @param {number[]} notificationIds - Array of notification IDs
+   */
+  async markAsRead(userId, notificationIds) {
+    if (!this.isEnabled()) return false;
+
+    try {
+      const pipeline = redisService.pipeline();
+      if (!pipeline) return false;
+
+      let markedCount = 0;
+
+      for (const notificationId of notificationIds) {
+        // Check current read status
+        const notification = await redisService.hgetall(KEYS.NOTIFICATION(notificationId));
+        if (notification && notification.read === '0') {
+          pipeline.hset(KEYS.NOTIFICATION(notificationId), { read: '1' });
+          markedCount++;
+        }
+      }
+
+      // Decrement unread count
+      if (markedCount > 0) {
+        // Use script to safely decrement by N without going below 0
+        const currentCount = await redisService.get(KEYS.UNREAD_COUNT(userId));
+        const newCount = Math.max(0, (parseInt(currentCount) || 0) - markedCount);
+        pipeline.set(KEYS.UNREAD_COUNT(userId), newCount.toString());
+      }
+
+      await pipeline.exec();
+      return true;
+
+    } catch (error) {
+      console.error('[NotificationCache] Error marking as read:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Invalidate user's notification cache
+   * Call when data might be stale (e.g., bulk operations)
+   */
+  async invalidateUserCache(userId) {
+    if (!this.isEnabled()) return false;
+
+    try {
+      // Get all notification IDs for user
+      const notificationIds = await redisService.zrevrange(KEYS.NOTIFICATIONS(userId), 0, -1);
+      
+      if (notificationIds && notificationIds.length > 0) {
+        const keysToDelete = notificationIds.map(id => KEYS.NOTIFICATION(id));
+        keysToDelete.push(KEYS.NOTIFICATIONS(userId));
+        keysToDelete.push(KEYS.UNREAD_COUNT(userId));
+        await redisService.del(...keysToDelete);
+      }
+
+      console.log(`[NotificationCache] Invalidated cache for user ${userId}`);
+      return true;
+
+    } catch (error) {
+      console.error('[NotificationCache] Error invalidating cache:', error.message);
+      return false;
+    }
+  }
+
+  // ============================================
+  // READ OPERATIONS
+  // ============================================
+
+  /**
+   * Get paginated notifications from cache
+   * Uses cursor-based pagination with timestamps
+   * 
+   * @param {number} userId - User ID
+   * @param {Object} options - Pagination options
+   * @param {number} options.limit - Number of notifications to fetch (default: 10)
+   * @param {number} options.cursor - Timestamp cursor (fetch items before this timestamp)
+   * @returns {Object|null} - { notifications, nextCursor, hasMore } or null if cache miss
+   */
+  async getNotifications(userId, { limit = 10, cursor = null } = {}) {
+    if (!this.isEnabled()) return null;
+
+    try {
+      // Check if user has cached notifications
+      const exists = await redisService.exists(KEYS.NOTIFICATIONS(userId));
+      if (!exists) {
+        console.log(`[NotificationCache] Cache miss for user ${userId}`);
+        return null; // Cache miss - caller should fetch from PostgreSQL and warm cache
+      }
+
+      // Get notification IDs from sorted set
+      let notificationIds;
+      if (cursor) {
+        // Cursor-based: get notifications before the cursor timestamp
+        // Use '(' prefix for exclusive max
+        notificationIds = await redisService.zrevrangebyscore(
+          KEYS.NOTIFICATIONS(userId),
+          `(${cursor}`, // Exclusive - don't include the cursor item
+          '-inf',
+          0,
+          limit + 1 // Fetch one extra to check hasMore
+        );
+      } else {
+        // No cursor: get most recent notifications
+        // ZREVRANGE with indices 0 to limit returns limit+1 items (indices are inclusive)
+        notificationIds = await redisService.zrevrange(
+          KEYS.NOTIFICATIONS(userId),
+          0,
+          limit // Returns limit+1 items (indices 0 through limit, inclusive)
+        );
+      }
+
+      if (!notificationIds || notificationIds.length === 0) {
+        return { notifications: [], nextCursor: null, hasMore: false };
+      }
+
+      // Check if there are more results
+      const hasMore = notificationIds.length > limit;
+      if (hasMore) {
+        notificationIds = notificationIds.slice(0, limit);
+      }
+
+      // Batch fetch notification data
+      const notificationKeys = notificationIds.map(id => KEYS.NOTIFICATION(id));
+      const notificationsData = await redisService.hmgetall(notificationKeys);
+
+      if (!notificationsData) {
+        return null; // Cache miss on individual notifications
+      }
+
+      // Parse and format notifications
+      const notifications = notificationsData
+        .filter(data => data !== null)
+        .map(data => this._parseNotificationFromCache(data));
+
+      // Get next cursor (timestamp of last item)
+      let nextCursor = null;
+      if (hasMore && notifications.length > 0) {
+        const lastNotification = notifications[notifications.length - 1];
+        nextCursor = new Date(lastNotification.createdAt).getTime();
+      }
+
+      return {
+        notifications,
+        nextCursor,
+        hasMore,
+      };
+
+    } catch (error) {
+      console.error('[NotificationCache] Error getting notifications:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Get unread count from cache
+   * 
+   * @param {number} userId - User ID
+   * @returns {number|null} - Unread count or null if cache miss
+   */
+  async getUnreadCount(userId) {
+    if (!this.isEnabled()) return null;
+
+    try {
+      const count = await redisService.get(KEYS.UNREAD_COUNT(userId));
+      if (count === null) return null; // Cache miss
+      return parseInt(count) || 0;
+    } catch (error) {
+      console.error('[NotificationCache] Error getting unread count:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Set unread count (used when warming cache)
+   */
+  async setUnreadCount(userId, count) {
+    if (!this.isEnabled()) return false;
+    return redisService.set(KEYS.UNREAD_COUNT(userId), count.toString(), CACHE_TTL);
+  }
+
+  // ============================================
+  // HELPERS
+  // ============================================
+
+  /**
+   * Parse notification data from Redis hash format
+   */
+  _parseNotificationFromCache(data) {
+    return {
+      id: parseInt(data.id),
+      type: data.type,
+      read: data.read === '1',
+      messageId: data.messageId ? parseInt(data.messageId) : null,
+      message: data.message || '',
+      senderUsername: data.senderUsername || 'Unknown',
+      senderWallet: data.senderWallet || '',
+      senderAvatar: data.senderAvatar || null,
+      createdAt: data.createdAt || null,
+      gameInvite: data.gameInvite ? this._safeJsonParse(data.gameInvite) : undefined,
+      finalScore: data.finalScore ? this._safeJsonParse(data.finalScore) : undefined,
+    };
+  }
+
+  /**
+   * Safely parse JSON (returns null on error)
+   */
+  _safeJsonParse(str) {
+    try {
+      return JSON.parse(str);
+    } catch {
+      return null;
+    }
+  }
+}
+
+// Singleton instance
+const notificationCacheService = new NotificationCacheService();
+
+module.exports = notificationCacheService;
+