refactor: Clean up middleware and error handling, improve leaderboard data fetching and caching logic

Author: codevoid048

server/app.js

@@ -4,7 +4,6 @@ import authRoutes from "./routes/authRoutes.js";
 import profileRoutes from "./routes/profileRoutes.js";
 import challengeRoutes from "./routes/challengeRoutes.js";
 import leaderboardRoutes from "./routes/leaderboardRoutes.js";
-import { warmupLeaderboardCache } from "./utils/leaderBoardCache.js";
 import passport from "passport";
 import cookieParser from "cookie-parser";
 import dotenv from "dotenv";
@@ -17,47 +16,19 @@ import typeSenseRoutes from "./routes/typeSenseRoutes.js";
 import { startStreakCronJob } from './utils/streakResetJob.js';
 import { appLifecycle } from './utils/appLifecycle.js';
 import { globalErrorHandler } from './middleware/errorHandler.js';
-import auditService from './services/auditService.js';
-import { httpLogger, auditContextMiddleware, auditErrorMiddleware, performanceMonitor } from './middleware/auditMiddleware.js';
 dotenv.config();
 
 const app = express();
 
 app.use(cors({ origin: process.env.CLIENT_URL, credentials: true }));
 
-// Memory-safe payload size limits with proper error handling
-// Audit context middleware (must be early in middleware chain)
-app.use(auditContextMiddleware);
+app.use(express.json({ limit: '2mb' }));
 
-app.use(express.json({ 
-    limit: '2mb', // Reduced from 5mb to prevent memory issues
-    verify: (req, res, buf) => {
-        // Monitor large requests with audit service
-        if (buf.length > 1024 * 1024) { // 1MB threshold
-            auditService.security('large_request_detected', {
-                requestId: req.auditContext?.requestId,
-                size: buf.length,
-                ip: req.ip,
-                url: req.originalUrl,
-                userAgent: req.get('User-Agent')
-            });
-        }
-    }
-}));
-
-app.use(express.urlencoded({ 
-    limit: '2mb', 
-    extended: false,
-    parameterLimit: 1000 // Limit number of parameters
-}));
+app.use(express.urlencoded({ limit: '2mb', extended: false }));
 
 app.use(cookieParser());
 app.use(passport.initialize());
 
-// Replace Morgan with our audit-integrated HTTP logger
-app.use(httpLogger);
-app.use(performanceMonitor);
-
 
 app.use('/api/auth', authRoutes);
 app.use('/api/profile', profileRoutes);
@@ -70,24 +41,11 @@ app.use('/api', statsRoutes);
 app.use('/api/user', userRoutes);
 app.use('/api', typeSenseRoutes);
 
-// Error handling middleware
-app.use(auditErrorMiddleware);
-app.use(globalErrorHandler);
-
-// Initialize application services with audit logging
-auditService.systemEvent('app_initializing', { 
-    environment: process.env.NODE_ENV,
-    version: process.env.npm_package_version
-});
-
-warmupLeaderboardCache();
 startStreakCronJob();
 appLifecycle.initialize();
 
 // Export cleanup function for server.js
 export const cleanup = async () => {
-    auditService.systemEvent('app_shutting_down');
-    await auditService.shutdown();
     return appLifecycle.cleanup();
 };
 

server/controllers/leaderboardController.js

@@ -57,29 +57,54 @@ export const updateUserPoints = async (req, res) => {
 
 export const getLeaderboardData = async (req, res) => {
   try {
-    const { search = "", page, limit } = req.query;
+    const { search = "", page = 1, limit = 10 } = req.query;
 
-    let leaderboard = getCachedLeaderboard();
+    let leaderboard = await getCachedLeaderboard();
     if (!leaderboard) {
       leaderboard = await updateRanks();
     }
 
+    // Ensure leaderboard is an array
+    if (!Array.isArray(leaderboard)) {
+      console.error("Leaderboard is not an array:", typeof leaderboard, leaderboard);
+      leaderboard = [];
+    }
+
+    // Handle case where leaderboard is empty
+    if (leaderboard.length === 0) {
+      return res.json({
+        users: [],
+        totalUsers: 0,
+        currentPage: 1,
+        totalPages: 1,
+      });
+    }
+
     // Filter based on search query, if any
     let filteredLeaderboard = leaderboard;
     if (search.trim() !== "") {
       const searchLower = search.toLowerCase();
       filteredLeaderboard = leaderboard.filter(user =>
-        user.username.toLowerCase().includes(searchLower)
+        user.username && user.username.toLowerCase().includes(searchLower)
       );
     }
 
-    // Pagination logic
+    // Ensure filtered result is also an array
+    if (!Array.isArray(filteredLeaderboard)) {
+      console.error("Filtered leaderboard is not an array:", typeof filteredLeaderboard);
+      filteredLeaderboard = [];
+    }
+
+    // Pagination logic with proper defaults
+    const pageNum = Math.max(parseInt(page) || 1, 1);
+    const limitNum = Math.min(Math.max(parseInt(limit) || 10, 1), 100); // Max 100 per page
+    
     const totalUsers = filteredLeaderboard.length;
-    const totalPages = Math.ceil(totalUsers / limit);
-    const currentPage = Math.min(Math.max(parseInt(page), 1), totalPages);
+    const totalPages = Math.max(Math.ceil(totalUsers / limitNum), 1);
+    const currentPage = Math.min(pageNum, totalPages);
 
-    const startIndex = (currentPage - 1) * limit;
-    const pagedUsers = filteredLeaderboard.slice(startIndex, startIndex + parseInt(limit));
+    const startIndex = (currentPage - 1) * limitNum;
+    const pagedUsers = filteredLeaderboard.slice(startIndex, startIndex + limitNum);
 
     res.json({
       users: pagedUsers,
@@ -88,7 +113,7 @@ export const getLeaderboardData = async (req, res) => {
       totalPages,
     });
   } catch (error) {
-    // console.error("Error fetching leaderboard:", error);
+    console.error("Error fetching leaderboard:", error);
     res.status(500).json({ error: "Internal server error" });
   }
 };

server/lib/db.js

@@ -1,64 +1,34 @@
 import mongoose from "mongoose"
-import { setupDatabase } from "./dbIndexes.js"
-import auditService from "../services/auditService.js"
-// import { setupMongoChangeStream } from "../typesense/liveSync.js"
 
 const connectDB = async () => {
     try {
-        // Connection options with resource limits
         const connectionOptions = {
-            maxPoolSize: 10, // Limit connection pool size
-            serverSelectionTimeoutMS: 5000, // How long to try selecting a server
-            socketTimeoutMS: 45000, // How long to wait for a response
-            bufferMaxEntries: 0, // Disable mongoose buffering
-            bufferCommands: false, // Disable mongoose buffering
+            maxPoolSize: 10,
+            serverSelectionTimeoutMS: 30000,
+            socketTimeoutMS: 45000,
+            bufferCommands: false,
         };
 
         const conn = await mongoose.connect(process.env.MONGO_URI, connectionOptions);
+        console.log(`MongoDB Connected: ${conn.connection.host}`);
 
-        auditService.systemEvent('database_connected', {
-            host: conn.connection.host,
-            database: conn.connection.name,
-            connectionPoolSize: connectionOptions.maxPoolSize
-        });
-        
-        // Monitor connection events for memory management
-        mongoose.connection.on('connected', () => {
-            auditService.systemEvent('database_connection_established', {
-                readyState: mongoose.connection.readyState
-            });
-        });
-        
-        mongoose.connection.on('disconnected', () => {
-            auditService.systemEvent('database_disconnected', {
-                reason: 'connection_lost'
-            });
-        });
-        
+        // Simple error handling
         mongoose.connection.on('error', (error) => {
-            auditService.error('Database connection error', error, {
-                host: conn.connection.host,
-                readyState: mongoose.connection.readyState
-            });
+            console.error('Database connection error:', error.message);
         });
 
-        // Setup indexes for performance and race condition prevention
-        const audit = auditService.startTrace('database_setup');
-        await setupDatabase();
-        audit.complete({ indexesSetup: true });
-        
-        //setupMongoChangeStream();
-        
-        auditService.systemEvent('database_initialization_complete', {
-            environment: process.env.NODE_ENV
-        });
+        // Warmup leaderboard cache after DB is ready (with delay for Redis connection)
+        setTimeout(async () => {
+            try {
+                const { warmupLeaderboardCache } = await import("../utils/leaderBoardCache.js");
+                warmupLeaderboardCache();
+            } catch (error) {
+                console.error('Failed to warmup leaderboard cache:', error.message);
+            }
+        }, 2000); // 2 second delay
 
     } catch (error) {
-        auditService.critical('Database connection failed', {
-            error: error.message,
-            mongoUri: process.env.MONGO_URI ? 'configured' : 'missing',
-            environment: process.env.NODE_ENV
-        });
+        console.error('Database connection failed:', error.message);
         process.exit(1);
     }
 }

server/lib/dbIndexes.js

@@ -1,46 +1,67 @@
 import mongoose from "mongoose";
 
-// Database indexes to prevent race conditions and improve performance
+// Drop and recreate all performance indexes
 export const createOptimalIndexes = async () => {
     try {
-        console.log('Creating database indexes for race condition prevention...');
-        
-        // User model indexes
-        await mongoose.connection.db.collection('users').createIndexes([
-            // Unique constraints to prevent duplicate registrations
-            { key: { email: 1 }, unique: true, partialFilterExpression: { isVerified: true } },
-            { key: { username: 1 }, unique: true, partialFilterExpression: { isVerified: true } },
-            { key: { RegistrationNumber: 1 }, unique: true, partialFilterExpression: { isVerified: true } },
-            
-            // Performance indexes
-            { key: { points: -1, rank: 1 }, name: 'leaderboard_sort' },
-            { key: { isVerified: 1, points: -1 }, name: 'leaderboard_filter' },
-            { key: { 'solveChallenges.easy.timestamp': -1 }, name: 'streak_easy' },
-            { key: { 'solveChallenges.medium.timestamp': -1 }, name: 'streak_medium' },
-            { key: { 'solveChallenges.hard.timestamp': -1 }, name: 'streak_hard' },
-            
-            // Platform data indexes
-            { key: { 'leetCode.username': 1 }, sparse: true },
-            { key: { 'gfg.username': 1 }, sparse: true },
-            { key: { 'codeforces.username': 1 }, sparse: true },
-            { key: { 'codechef.username': 1 }, sparse: true }
-        ]);
-
-        // Challenge model indexes
-        await mongoose.connection.db.collection('challenges').createIndexes([
-            // Query performance indexes
-            { key: { category: 1, difficulty: 1, createdAt: -1 }, name: 'challenge_filter' },
-            { key: { createdAt: -1 }, name: 'daily_challenge' },
-            { key: { title: 'text', category: 'text' }, name: 'challenge_search' },
+        console.log('Setting up database indexes...');
+        
+        const usersCollection = mongoose.connection.db.collection('users');
+        const challengesCollection = mongoose.connection.db.collection('challenges');
+        
+        // Drop problematic indexes individually
+        try {
+            // Drop known problematic indexes
+            const problematicIndexes = [
+                'username_1', 'email_1', 'UserTextIndex', 'ChallengeTextIndex',
+                'email_unique_idx', 'username_unique_idx', 'regno_unique_idx',
+                'challenge_search_idx', 'leaderboard_sort_idx'
+            ];
 
-            // Solved users index
-            { key: { solvedUsers: 1 }, sparse: true }
-        ]);
-
+            for (const indexName of problematicIndexes) {
+                try {
+                    await usersCollection.dropIndex(indexName);
+                } catch (e) { /* Index doesn't exist */ }
+                try {
+                    await challengesCollection.dropIndex(indexName);
+                } catch (e) { /* Index doesn't exist */ }
+            }
+        } catch (error) {
+            // Continue anyway
+        }
+        
+        // Wait for drops to complete
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        
+        // Create essential user indexes with explicit names
+        await usersCollection.createIndex({ email: 1 }, { unique: true, sparse: true, name: 'email_unique_idx' });
+        await usersCollection.createIndex({ username: 1 }, { unique: true, sparse: true, name: 'username_unique_idx' });
+        // Skip RegistrationNumber for now - has duplicates
+        
+        // Performance indexes for leaderboard
+        await usersCollection.createIndex({ points: -1, rank: 1 }, { name: 'leaderboard_sort_idx' });
+        await usersCollection.createIndex({ isVerified: 1, points: -1 }, { name: 'verified_points_idx' });
+        
+        // Streak tracking indexes
+        await usersCollection.createIndex({ 'solveChallenges.easy.timestamp': -1 }, { name: 'easy_streak_idx' });
+        await usersCollection.createIndex({ 'solveChallenges.medium.timestamp': -1 }, { name: 'medium_streak_idx' });
+        await usersCollection.createIndex({ 'solveChallenges.hard.timestamp': -1 }, { name: 'hard_streak_idx' });
+        
+        // Platform data indexes
+        await usersCollection.createIndex({ 'leetCode.username': 1 }, { sparse: true, name: 'leetcode_username_idx' });
+        await usersCollection.createIndex({ 'gfg.username': 1 }, { sparse: true, name: 'gfg_username_idx' });
+        await usersCollection.createIndex({ 'codeforces.username': 1 }, { sparse: true, name: 'cf_username_idx' });
+        await usersCollection.createIndex({ 'codechef.username': 1 }, { sparse: true, name: 'cc_username_idx' });
+        
+        // Challenge indexes
+        await challengesCollection.createIndex({ category: 1, difficulty: 1, createdAt: -1 }, { name: 'challenge_filter_idx' });
+        await challengesCollection.createIndex({ createdAt: -1 }, { name: 'challenge_date_idx' });
+        await challengesCollection.createIndex({ title: 'text', category: 'text' }, { name: 'challenge_search_idx' });
+        await challengesCollection.createIndex({ solvedUsers: 1 }, { sparse: true, name: 'solved_users_idx' });
+        
         console.log('Database indexes created successfully');
 
     } catch (error) {
-        console.error('Error creating database indexes:', error);
+        console.error('Error setting up database indexes:', error);
     }
 };