added a test for resolution of api calls

Author: GigaElk

backend/src/index.ts

@@ -121,10 +121,6 @@ app.get("/health", async (req, res) => {
 });
 
 app.get("/api/health", async (req, res) => {
-  // Temporarily bypassed for debugging startup issues
-  console.log('HEALTH CHECK ENDPOINT WAS HIT');
-  res.status(200).json({ status: "ok" });
-  /*
   try {
     await initializeServices();
     const healthStatus = await healthCheckService.performEnhancedHealthCheck();
@@ -138,7 +134,6 @@ app.get("/api/health", async (req, res) => {
       timestamp: new Date().toISOString(),
     });
   }
-  */
 });
 
 // Database wake-up endpoint

backend/src/routes/likes.ts

@@ -12,6 +12,6 @@ router.get('/:postId/check', authenticateToken, likeController.isLiked);
 
 // Public routes (no authentication required)
 router.get('/:postId', getLikesValidation, likeController.getLikes);
-router.get('/:postId/count', likeController.getLikeCount);
+router.get('/:postId/stats', likeController.getLikeCount);
 
 export default router;

backend/src/routes/worryResolution.ts

@@ -13,6 +13,8 @@ import { authenticateToken } from '../middleware/auth';
 const router = Router();
 const worryResolutionController = new WorryResolutionController();
 
+router.get('/test', (req, res) => res.send('Worry resolution route is working!'));
+
 // Public routes (no authentication required)
 router.get('/stories', getPublicResolutionStoriesValidation, worryResolutionController.getPublicResolutionStories);
 

backend/src/services/databaseRecovery.ts

@@ -304,9 +304,6 @@ export class DatabaseRecoveryService {
     logger.info('Creating database connection');
 
     try {
-      console.log('--- DATABASE_URL FROM ENV ---');
-      console.log(process.env.DATABASE_URL);
-      console.log('-----------------------------');
       this.prismaClient = new PrismaClient({
         log: process.env.NODE_ENV === 'development' ? ['query', 'info', 'warn', 'error'] : ['error'],
         datasources: {

backend/src/services/healthCheck.ts

@@ -163,7 +163,7 @@ export class HealthCheckService {
       });
 
       // Log warnings for concerning metrics
-      if (metrics.memoryUsage.usagePercent > 80) {
+      if (metrics.memoryUsage.usagePercent > 95) {
         logger.warn('High memory usage detected', {
           correlationId,
           memoryUsage: metrics.memoryUsage,
@@ -300,12 +300,91 @@ export class HealthCheckService {
   }
 
   private async checkEnhancedMemory(): Promise<HealthCheckResult> {
-    // Temporarily bypassed for debugging startup issues
-    return {
-      status: 'pass',
-      message: 'Memory check bypassed for debugging',
-      lastChecked: new Date().toISOString(),
-    };
+    try {
+      const memoryHealthMetrics = this.memoryManager.getHealthMetrics();
+      const memoryMetrics = this.getMemoryMetrics();
+
+      // Use memory manager's status determination
+      const status = memoryHealthMetrics.status;
+      
+      if (status === 'emergency') {
+        // Memory manager will handle emergency cleanup
+        await this.memoryManager.checkMemoryPressure();
+        
+        return {
+          status: 'fail',
+          message: 'Memory usage critical - emergency cleanup triggered',
+          lastChecked: new Date().toISOString(),
+          details: {
+            ...memoryMetrics,
+            memoryManagerStatus: status,
+            trend: memoryHealthMetrics.trend,
+            leakDetection: memoryHealthMetrics.leakDetection,
+            recentAlerts: memoryHealthMetrics.recentAlerts?.length || 0,
+          },
+        };
+      }
+
+      if (status === 'critical') {
+        return {
+          status: 'fail',
+          message: 'Memory usage critical',
+          lastChecked: new Date().toISOString(),
+          details: {
+            ...memoryMetrics,
+            memoryManagerStatus: status,
+            trend: memoryHealthMetrics.trend,
+            recommendations: memoryHealthMetrics.recommendations,
+          },
+        };
+      }
+
+      if (status === 'warning') {
+        return {
+          status: 'warn',
+          message: 'Memory usage high',
+          lastChecked: new Date().toISOString(),
+          details: {
+            ...memoryMetrics,
+            memoryManagerStatus: status,
+            trend: memoryHealthMetrics.trend,
+          },
+        };
+      }
+
+      if (memoryHealthMetrics.leakDetection.detected) {
+        return {
+          status: 'warn',
+          message: `Potential memory leak detected (${memoryHealthMetrics.leakDetection.confidence}% confidence)`,
+          lastChecked: new Date().toISOString(),
+          details: {
+            ...memoryMetrics,
+            memoryManagerStatus: status,
+            leakDetection: memoryHealthMetrics.leakDetection,
+          },
+        };
+      }
+
+      return {
+        status: 'pass',
+        message: 'Memory usage normal',
+        lastChecked: new Date().toISOString(),
+        details: {
+          ...memoryMetrics,
+          memoryManagerStatus: status,
+          trend: memoryHealthMetrics.trend,
+          gcStats: memoryHealthMetrics.gcStats,
+        },
+      };
+    } catch (error) {
+      logger.error('Enhanced memory health check failed', error);
+      return {
+        status: 'fail',
+        message: 'Memory check failed',
+        lastChecked: new Date().toISOString(),
+        details: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
   }
 
   private async checkSchedulers(): Promise<HealthCheckResult> {