Optimize panel queries and runtime stability

Author: ddddeadispose

Caddyfile

@@ -1,4 +1,6 @@
 {$PANEL_DOMAIN} {
+    encode gzip zstd
+
     reverse_proxy backend:3000 {
         # Force HTTP/1.1 to backend (Express doesn't support h2c)
         transport http {

index.js

@@ -82,7 +82,9 @@ app.use((req, res, next) => {
 
 app.use(i18nMiddleware);
 app.use(countRequest);
-app.use(express.static(path.join(__dirname, 'public')));
+app.use(express.static(path.join(__dirname, 'public'), {
+    maxAge: process.env.NODE_ENV === 'production' ? '1d' : 0,
+}));
 
 // Sanitize error details from 500 responses in production
 app.use((req, res, next) => {
@@ -575,50 +577,78 @@ function setupWebSocketServer(server) {
 function setupCronJobs() {
     // Collect stats every 5 minutes
     cron.schedule('*/5 * * * *', async () => {
-        logger.debug('[Cron] Collecting stats');
-        await syncService.collectAllStats();
-        
-        // Save stats snapshot for charts
-        await statsService.saveHourlySnapshot();
+        try {
+            logger.debug('[Cron] Collecting stats');
+            await syncService.collectAllStats();
+            
+            // Save stats snapshot for charts
+            await statsService.saveHourlySnapshot();
+        } catch (error) {
+            logger.error(`[Cron] Stats collection failed: ${error.message}`);
+        }
     });
 
     // Health check every minute
     cron.schedule('* * * * *', async () => {
-        await syncService.healthCheck();
+        try {
+            await syncService.healthCheck();
+        } catch (error) {
+            logger.error(`[Cron] Health check failed: ${error.message}`);
+        }
     });
 
     // Save daily snapshot every hour
     cron.schedule('0 * * * *', async () => {
-        logger.debug('[Cron] Saving daily stats snapshot');
-        await statsService.saveDailySnapshot();
+        try {
+            logger.debug('[Cron] Saving daily stats snapshot');
+            await statsService.saveDailySnapshot();
+        } catch (error) {
+            logger.error(`[Cron] Daily snapshot failed: ${error.message}`);
+        }
     });
 
     // Save monthly snapshot and cleanup at 00:05
     cron.schedule('5 0 * * *', async () => {
-        logger.info('[Cron] Saving monthly stats snapshot');
-        await statsService.saveMonthlySnapshot();
-        await statsService.cleanup();
+        try {
+            logger.info('[Cron] Saving monthly stats snapshot');
+            await statsService.saveMonthlySnapshot();
+            await statsService.cleanup();
+        } catch (error) {
+            logger.error(`[Cron] Monthly maintenance failed: ${error.message}`);
+        }
     });
 
     // Clean old logs daily at 3:00
     cron.schedule('0 3 * * *', () => {
-        logger.info('[Cron] Cleaning old logs');
-        cleanOldLogs(30);
+        try {
+            logger.info('[Cron] Cleaning old logs');
+            cleanOldLogs(30);
+        } catch (error) {
+            logger.error(`[Cron] Log cleanup failed: ${error.message}`);
+        }
     });
 
     // Check for scheduled backup every hour
     cron.schedule('0 * * * *', async () => {
-        await backupService.scheduledBackup();
+        try {
+            await backupService.scheduledBackup();
+        } catch (error) {
+            logger.error(`[Cron] Scheduled backup failed: ${error.message}`);
+        }
     });
 
     // Initial health check and stats snapshot after 5 seconds
     setTimeout(async () => {
-        logger.info('[Startup] Checking nodes status');
-        await syncService.healthCheck();
-        
-        // Initial stats snapshot
-        await statsService.saveHourlySnapshot();
-        logger.info('[Startup] Initial stats snapshot saved');
+        try {
+            logger.info('[Startup] Checking nodes status');
+            await syncService.healthCheck();
+            
+            // Initial stats snapshot
+            await statsService.saveHourlySnapshot();
+            logger.info('[Startup] Initial stats snapshot saved');
+        } catch (error) {
+            logger.error(`[Startup] Initial checks failed: ${error.message}`);
+        }
     }, 5000);
 }
 

src/models/hyUserModel.js

@@ -69,6 +69,7 @@ const hyUserSchema = new mongoose.Schema({
 
 hyUserSchema.index({ enabled: 1 });
 hyUserSchema.index({ groups: 1 });
+hyUserSchema.index({ expireAt: 1 });
 
 hyUserSchema.virtual('trafficUsedGB').get(function() {
     return ((this.traffic.tx + this.traffic.rx) / (1024 * 1024 * 1024)).toFixed(2);

src/models/serverGroupModel.js

@@ -13,5 +13,7 @@ const serverGroupSchema = new mongoose.Schema({
     subscriptionTitle: { type: String, default: '', trim: true },
 }, { timestamps: true });
 
+serverGroupSchema.index({ active: 1 });
+
 module.exports = mongoose.model('ServerGroup', serverGroupSchema);
 

src/routes/panel.js

@@ -929,18 +929,35 @@ router.get('/users/:userId', requireAuth, async (req, res) => {
 router.get('/groups', requireAuth, async (req, res) => {
     try {
         const groups = await ServerGroup.find().sort({ name: 1 });
-        
-        // Считаем количество нод и пользователей в каждой группе
-        const groupsWithCounts = await Promise.all(groups.map(async (group) => {
-            const [nodesCount, usersCount] = await Promise.all([
-                HyNode.countDocuments({ groups: group._id }),
-                HyUser.countDocuments({ groups: group._id }),
+
+        const groupIds = groups.map((group) => group._id);
+        let nodeCountMap = new Map();
+        let userCountMap = new Map();
+
+        if (groupIds.length > 0) {
+            const [nodeCounts, userCounts] = await Promise.all([
+                HyNode.aggregate([
+                    { $match: { groups: { $in: groupIds } } },
+                    { $unwind: '$groups' },
+                    { $match: { groups: { $in: groupIds } } },
+                    { $group: { _id: '$groups', count: { $sum: 1 } } },
+                ]),
+                HyUser.aggregate([
+                    { $match: { groups: { $in: groupIds } } },
+                    { $unwind: '$groups' },
+                    { $match: { groups: { $in: groupIds } } },
+                    { $group: { _id: '$groups', count: { $sum: 1 } } },
+                ]),
             ]);
-            return {
-                ...group.toObject(),
-                nodesCount,
-                usersCount,
-            };
+
+            nodeCountMap = new Map(nodeCounts.map((item) => [String(item._id), item.count]));
+            userCountMap = new Map(userCounts.map((item) => [String(item._id), item.count]));
+        }
+
+        const groupsWithCounts = groups.map((group) => ({
+            ...group.toObject(),
+            nodesCount: nodeCountMap.get(String(group._id)) || 0,
+            usersCount: userCountMap.get(String(group._id)) || 0,
         }));
 
         render(res, 'groups', {
@@ -1198,11 +1215,17 @@ router.post('/settings/reset-traffic', requireAuth, async (req, res) => {
 
         // Инвалидируем кэш всех пользователей
         const users = await HyUser.find({}).select('userId subscriptionToken').lean();
-        for (const user of users) {
-            await cache.invalidateUser(user.userId);
+        const invalidateTasks = users.flatMap((user) => {
+            const tasks = [() => cache.invalidateUser(user.userId)];
             if (user.subscriptionToken) {
-                await cache.invalidateSubscription(user.subscriptionToken);
+                tasks.push(() => cache.invalidateSubscription(user.subscriptionToken));
             }
+            return tasks;
+        });
+
+        const BATCH_SIZE = 100;
+        for (let i = 0; i < invalidateTasks.length; i += BATCH_SIZE) {
+            await Promise.all(invalidateTasks.slice(i, i + BATCH_SIZE).map((task) => task()));
         }
 
         // Инвалидируем статистику