Merge pull request #162 from Mirabel64/perf/stellar-wave-perf-fixes

perf: address Stellar Wave issues #100, #101, #102, #103

Author: dzekojohn4

backend/src/analytics/analytics.controller.ts

@@ -31,48 +31,51 @@ export class AnalyticsController implements OnModuleInit {
 
   @Post('record-solve')
   @HttpCode(HttpStatus.NO_CONTENT)
-  recordSolve(@Body() body: RecordSolveDto): void {
+  async recordSolve(@Body() body: RecordSolveDto): Promise<void> {
     this.logger.log(`Received record-solve request: ${JSON.stringify(body)}`);
     const { userId, puzzleId, solveTime } = body;
-    this.analyticsService.recordPuzzleSolve(userId, puzzleId, solveTime);
+    // Await so write errors surface as 5xx rather than being silently
+    // dropped; the service internally falls back to in-memory on Redis
+    // failure so this won't crash the request.
+    await this.analyticsService.recordPuzzleSolveAsync(
+      userId,
+      puzzleId,
+      solveTime,
+    );
   }
 
   @Get('puzzles/most-solved')
   async getMostSolvedPuzzles(): Promise<
     Array<{ puzzleId: string; solveCount: number }>
   > {
     this.logger.log('Handling request for most solved puzzles.');
-    return this.analyticsService.getMostSolvedPuzzles();
+    return this.analyticsService.getMostSolvedPuzzlesAsync();
   }
 
   @Get('puzzles/:puzzleId/average-solve-time')
-  getAverageSolveTime(@Param('puzzleId') puzzleId: string): {
-    puzzleId: string;
-    averageSolveTime: number;
-  } {
+  async getAverageSolveTime(
+    @Param('puzzleId') puzzleId: string,
+  ): Promise<{ puzzleId: string; averageSolveTime: number }> {
     this.logger.log(
       `Handling request for average solve time for puzzle ${puzzleId}.`,
     );
     const averageSolveTime =
-      this.analyticsService.getAverageSolveTime(puzzleId);
+      await this.analyticsService.getAverageSolveTimeAsync(puzzleId);
     return { puzzleId, averageSolveTime };
   }
 
   @Get('users/:userId/history')
-  getUserPuzzleHistory(
+  async getUserPuzzleHistory(
     @Param('userId') userId: string,
-    @Query('page') page?: string,
-    @Query('limit') limit?: string,
-  ): PaginatedUserPuzzleHistory {
-    const parsedPage = page ? parseInt(page, 10) : 1;
-    const parsedLimit = limit ? parseInt(limit, 10) : 20;
-    this.logger.log(
-      `Handling paginated request for user ${userId} puzzle history (page=${parsedPage}, limit=${parsedLimit}).`,
-    );
-    return this.analyticsService.getUserPuzzleStatsPage(
-      userId,
-      parsedPage > 0 ? parsedPage : 1,
-      parsedLimit > 0 ? parsedLimit : 20,
-    );
+  ): Promise<Record<string, any>> {
+    this.logger.log(`Handling request for user ${userId} puzzle history.`);
+    const userHistoryMap =
+      await this.analyticsService.getUserPuzzleStatsAsync(userId);
+
+    const userHistoryObject: Record<string, any> = {};
+    userHistoryMap.forEach((value, key) => {
+      userHistoryObject[key] = value;
+    });
+    return userHistoryObject;
   }
 }

backend/src/analytics/analytics.service.spec.ts

@@ -27,4 +27,39 @@ describe('AnalyticsService', () => {
   it('should be defined', () => {
     expect(service).toBeDefined();
   });
+
+  describe('in-memory fallback (no REDIS_URL)', () => {
+    it('records solves to the in-memory mirror and aggregates correctly', async () => {
+      await service.recordPuzzleSolveAsync('u1', 'pA', 100);
+      await service.recordPuzzleSolveAsync('u1', 'pA', 200);
+      await service.recordPuzzleSolveAsync('u2', 'pB', 50);
+
+      const sorted = await service.getMostSolvedPuzzlesAsync();
+      expect(sorted).toEqual([
+        { puzzleId: 'pA', solveCount: 2 },
+        { puzzleId: 'pB', solveCount: 1 },
+      ]);
+
+      await expect(service.getAverageSolveTimeAsync('pA')).resolves.toBe(150);
+      await expect(service.getAverageSolveTimeAsync('pB')).resolves.toBe(50);
+      await expect(service.getAverageSolveTimeAsync('unknown')).resolves.toBe(
+        0,
+      );
+
+      const u1History = await service.getUserPuzzleStatsAsync('u1');
+      expect(u1History.get('pA')).toMatchObject({
+        solveCount: 2,
+        totalSolveTime: 300,
+        attempts: 2,
+      });
+      expect(u1History.get('pA')?.lastSolved).toBeInstanceOf(Date);
+    });
+
+    it('records every solve exactly once (no double-increment in mirror)', async () => {
+      await service.recordPuzzleSolveAsync('u1', 'pA', 100);
+      await service.recordPuzzleSolve('u1', 'pA', 100);
+      const sorted = await service.getMostSolvedPuzzlesAsync();
+      expect(sorted).toEqual([{ puzzleId: 'pA', solveCount: 2 }]);
+    });
+  });
 });