dubs-server 1.0.0

package/routes/socialRoutes.js

@@ -0,0 +1,459 @@
+/**
+ * 👥 Social/Friends API Routes
+ * 
+ * User search, friend requests, friends management
+ */
+
+const express = require('express');
+const router = express.Router();
+const { authenticate } = require('../middleware/authenticate');
+const { pool } = require('../services/db'); // Shared database pool
+
+module.exports = (socialService) => {
+
+  /**
+   * GET /social/leaderboard
+   * Public leaderboard for modal (no auth required)
+   * Query: ?gameType=connect4|sports|esports&tab=wins|winrate|earnings|grinder|efficiency&limit=25
+   */
+  router.get('/leaderboard', async (req, res) => {
+    try {
+      const { gameType = 'connect4', tab = 'wins', limit = 25 } = req.query;
+      const result = await socialService.getLeaderboard(gameType, tab, limit);
+
+      res.json({
+        success: true,
+        ...result
+      });
+    } catch (error) {
+      console.error('Error getting leaderboard:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * GET /social/top-players
+   * Get top players by wins for each category (sports, connect4)
+   */
+  router.get('/top-players', authenticate, async (req, res) => {
+    try {
+      const { userId } = req.user;
+      const limit = Math.min(parseInt(req.query.limit) || 10, 20);
+
+      const topPlayers = await socialService.getTopPlayers(userId, limit);
+
+      res.json({
+        success: true,
+        ...topPlayers
+      });
+    } catch (error) {
+      console.error('Error getting top players:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * GET /social/discover/summary
+   * Get category summary with user counts for discover page
+   */
+  router.get('/discover/summary', authenticate, async (req, res) => {
+    try {
+      const { userId } = req.user;
+      const categories = await socialService.getCategorySummary(userId);
+
+      res.json({
+        success: true,
+        categories
+      });
+    } catch (error) {
+      console.error('Error getting category summary:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * GET /social/discover?category=NBA&page=1&limit=20&sortBy=activity
+   * Discover users by game category with pagination
+   *
+   * Categories: NBA, NHL, NFL, EPL, UFC, connect4
+   * SortBy: activity (default), games_played, recent
+   */
+  router.get('/discover', authenticate, async (req, res) => {
+    try {
+      const { category, page = 1, limit = 20, sortBy = 'activity' } = req.query;
+      const { userId } = req.user;
+
+      if (!category) {
+        return res.status(400).json({
+          success: false,
+          error: 'Category is required. Valid categories: NBA, NHL, NFL, EPL, UFC, connect4'
+        });
+      }
+
+      const validCategories = ['NBA', 'NHL', 'NFL', 'EPL', 'UFC', 'connect4', 'all'];
+      if (!validCategories.includes(category)) {
+        return res.status(400).json({
+          success: false,
+          error: `Invalid category. Valid categories: ${validCategories.join(', ')}`
+        });
+      }
+
+      const result = await socialService.discoverByCategory(category, userId, {
+        page: parseInt(page),
+        limit: parseInt(limit),
+        sortBy
+      });
+
+      res.json({
+        success: true,
+        category,
+        ...result
+      });
+    } catch (error) {
+      console.error('Error discovering users:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * GET /social/search?q=username
+   * Search users by username (empty query returns all users)
+   */
+  router.get('/search', authenticate, async (req, res) => {
+    try {
+      const { q } = req.query;
+      const { userId } = req.user;
+
+      // Empty query returns all users
+      const query = q || '';
+
+      const results = await socialService.searchUsers(query, userId);
+
+      res.json({
+        success: true,
+        results
+      });
+    } catch (error) {
+      console.error('Error searching users:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * POST /social/friend-request/:targetUserId
+   * Send friend request
+   */
+  router.post('/friend-request/:targetUserId', authenticate, async (req, res) => {
+    try {
+      const { userId } = req.user;
+      const targetUserId = parseInt(req.params.targetUserId);
+
+      if (userId === targetUserId) {
+        return res.status(400).json({
+          success: false,
+          error: 'Cannot send friend request to yourself'
+        });
+      }
+
+      const result = await socialService.sendFriendRequest(userId, targetUserId);
+
+      if (!result || !result.requestId) {
+        return res.status(500).json({
+          success: false,
+          error: 'Failed to send friend request'
+        });
+      }
+
+      const { requestId, notificationId } = result;
+
+      console.log(`[Social] Friend request sent from ${userId} to ${targetUserId}, requestId: ${requestId}, notificationId: ${notificationId}`);
+
+      // Send real-time notification via user's room (works whether online or not)
+      const chatNamespace = global.chatNamespace;
+
+      if (chatNamespace) {
+        // Get sender info (using shared pool)
+        const userResult = await pool.query(
+          'SELECT username, wallet_address, avatar FROM users WHERE id = $1',
+          [userId]
+        );
+
+        if (userResult.rows.length > 0) {
+          const notificationPayload = {
+            id: notificationId, // Real database ID
+            friendRequestId: requestId,
+            type: 'friend_request',
+            read: false,
+            message: '',
+            senderUsername: userResult.rows[0].username,
+            senderWallet: userResult.rows[0].wallet_address,
+            senderAvatar: userResult.rows[0].avatar || null,
+            createdAt: new Date(),
+          };
+
+          console.log('[Social] Sending friend request notification to room user-' + targetUserId);
+          chatNamespace.to(`user-${targetUserId}`).emit('notification', notificationPayload);
+          console.log('[Social] Notification sent successfully');
+        }
+      } else {
+        console.log('[Social] WebSocket not available');
+      }
+
+      res.json({
+        success: true,
+        requestId
+      });
+    } catch (error) {
+      console.error('Error sending friend request:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * GET /social/friend-requests
+   * Get pending friend requests (received)
+   */
+  router.get('/friend-requests', authenticate, async (req, res) => {
+    try {
+      const { userId } = req.user;
+      const requests = await socialService.getPendingRequests(userId);
+
+      res.json({
+        success: true,
+        requests
+      });
+    } catch (error) {
+      console.error('Error getting friend requests:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * POST /social/request/:requestId/accept
+   * Accept friend request
+   */
+  router.post('/request/:requestId/accept', authenticate, async (req, res) => {
+    try {
+      const { userId } = req.user;
+      const requestId = parseInt(req.params.requestId);
+
+      const result = await socialService.acceptFriendRequest(requestId, userId);
+
+      if (!result || !result.success) {
+        return res.status(404).json({
+          success: false,
+          error: 'Friend request not found or already processed'
+        });
+      }
+
+      // Notify the sender that their request was accepted
+      const chatNamespace = global.chatNamespace;
+
+      if (chatNamespace && result.fromUserId) {
+        // Using shared pool
+        const userResult = await pool.query(
+          'SELECT username, wallet_address, avatar FROM users WHERE id = $1',
+          [userId]
+        );
+
+        // Send WebSocket event for UI update via user's room
+        chatNamespace.to(`user-${result.fromUserId}`).emit('friend_request_accepted', {
+          requestId,
+          acceptedBy: userId,
+          acceptedByUsername: userResult.rows[0]?.username,
+        });
+
+        // Send notification that shows in bell badge (with real DB ID)
+        chatNamespace.to(`user-${result.fromUserId}`).emit('notification', {
+          id: result.notificationId, // Real database ID
+          type: 'friend_request_accepted',
+          read: false,
+          message: '',
+          senderUsername: userResult.rows[0]?.username || 'Someone',
+          senderWallet: userResult.rows[0]?.wallet_address || '',
+          senderAvatar: userResult.rows[0]?.avatar || null,
+          createdAt: new Date(),
+        });
+      }
+
+      res.json({
+        success: true
+      });
+    } catch (error) {
+      console.error('Error accepting friend request:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * POST /social/request/:requestId/reject
+   * Reject friend request
+   */
+  router.post('/request/:requestId/reject', authenticate, async (req, res) => {
+    try {
+      console.log('[Social] Reject request endpoint hit, requestId:', req.params.requestId);
+      const { userId } = req.user;
+      const requestId = parseInt(req.params.requestId);
+      console.log('[Social] Parsed requestId:', requestId, 'userId:', userId);
+
+      const result = await socialService.rejectFriendRequest(requestId, userId);
+      console.log('[Social] Reject result:', result);
+
+      if (!result || !result.success) {
+        return res.status(404).json({
+          success: false,
+          error: 'Friend request not found'
+        });
+      }
+
+      // Notify the sender that their request was declined
+      const chatNamespace = global.chatNamespace;
+
+      if (chatNamespace && result.fromUserId) {
+        // Using shared pool
+        const userResult = await pool.query(
+          'SELECT username, wallet_address, avatar FROM users WHERE id = $1',
+          [userId]
+        );
+
+        // Send WebSocket event for UI update via user's room
+        chatNamespace.to(`user-${result.fromUserId}`).emit('friend_request_declined', {
+          requestId,
+          declinedBy: userId,
+        });
+
+        // Send notification that shows in bell badge (with real DB ID)
+        chatNamespace.to(`user-${result.fromUserId}`).emit('notification', {
+          id: result.notificationId, // Real database ID
+          type: 'friend_request_declined',
+          read: false,
+          message: '',
+          senderUsername: userResult.rows[0]?.username || 'Someone',
+          senderWallet: userResult.rows[0]?.wallet_address || '',
+          senderAvatar: userResult.rows[0]?.avatar || null,
+          createdAt: new Date(),
+        });
+      }
+
+      res.json({
+        success: true
+      });
+    } catch (error) {
+      console.error('Error rejecting friend request:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * GET /social/friends
+   * Get friends list
+   */
+  router.get('/friends', authenticate, async (req, res) => {
+    try {
+      const { userId } = req.user;
+      const friends = await socialService.getFriends(userId);
+
+      res.json({
+        success: true,
+        friends
+      });
+    } catch (error) {
+      console.error('Error getting friends:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * DELETE /social/friend/:targetUserId
+   * Remove friend
+   */
+  router.delete('/friend/:targetUserId', authenticate, async (req, res) => {
+    try {
+      const { userId } = req.user;
+      const targetUserId = parseInt(req.params.targetUserId);
+
+      const result = await socialService.removeFriend(userId, targetUserId);
+
+      if (!result.success) {
+        return res.status(500).json({
+          success: false,
+          error: 'Failed to remove friend'
+        });
+      }
+
+      // Notify the other user (silent - no notification, just UI update)
+      const chatNamespace = global.chatNamespace;
+
+      if (chatNamespace) {
+        chatNamespace.to(`user-${targetUserId}`).emit('friend_removed', {
+          removedBy: userId,
+        });
+      }
+
+      res.json({
+        success: true
+      });
+    } catch (error) {
+      console.error('Error removing friend:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * GET /social/blocked
+   * Get blocked users list
+   */
+  router.get('/blocked', authenticate, async (req, res) => {
+    try {
+      const { userId } = req.user;
+      const blocked = await socialService.getBlockedUsers(userId);
+
+      res.json({
+        success: true,
+        blocked
+      });
+    } catch (error) {
+      console.error('Error getting blocked users:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  return router;
+};
+