Refactor leaderboard responses

src/controllers/leaderboard.controller.ts

@@ -3,6 +3,11 @@ import { ApiBearerAuth, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { AuthGuard } from '../services/guards';
 import { IAuthorizedRequest } from '../interfaces';
 import { LeaderboardService } from '../services';
+import {
+  GlobalLeaderboardResponseDto,
+  MyRankResponseDto,
+  TournamentLeaderboardResponseDto,
+} from '../dtos/leaderboard/responses';
 
 @ApiBearerAuth()
 @Controller('/api/leaderboard')
@@ -24,7 +29,7 @@ export class LeaderboardController {
     description: 'Internal server error, contact with backend team.',
   })
   @Get('/global')
-  public async getGlobalLeaderboard(): Promise<any> {
+  public async getGlobalLeaderboard(): Promise<GlobalLeaderboardResponseDto[]> {
     return await this.leaderboardService.getGlobalLeaderboard();
   }
 
@@ -64,7 +69,7 @@ export class LeaderboardController {
   @Get('/tournament')
   public async getTournamentLeaderboard(
     @Req() req: IAuthorizedRequest,
-  ): Promise<any> {
+  ): Promise<TournamentLeaderboardResponseDto[]> {
     const user = req.user;
     return await this.leaderboardService.getTournamentLeaderboard(
       user.username,
@@ -87,8 +92,12 @@ export class LeaderboardController {
   @Get('/tournament/my-rank')
   public async getMyTournamentRank(
     @Req() req: IAuthorizedRequest,
-  ): Promise<number> {
+  ): Promise<MyRankResponseDto> {
     const user = req.user;
-    return await this.leaderboardService.getRankOfUserByUsername(user.username);
+    return {
+      rank: await this.leaderboardService.getRankOfUserByUsername(
+        user.username,
+      ),
+    };
   }
 }

src/dtos/leaderboard/responses/country-leaderboard-response.dto.ts

@@ -0,0 +1,11 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Expose } from 'class-transformer';
+
+export class CountryLeaderboardResponseDto {
+  @ApiProperty()
+  @Expose()
+  username: string;
+  @ApiProperty()
+  @Expose()
+  levelNum: string;
+}

src/dtos/leaderboard/responses/global-leaderboard-response.dto.ts

@@ -0,0 +1,11 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Expose } from 'class-transformer';
+
+export class GlobalLeaderboardResponseDto {
+  @ApiProperty()
+  @Expose()
+  username: string;
+  @ApiProperty()
+  @Expose()
+  levelNum: string;
+}

src/dtos/leaderboard/responses/index.ts

@@ -0,0 +1,4 @@
+export * from './global-leaderboard-response.dto';
+export * from './country-leaderboard-response.dto';
+export * from './tournament-leaderboard-response.dto';
+export * from './my-rank-response.dto';

src/dtos/leaderboard/responses/my-rank-response.dto.ts

@@ -0,0 +1,8 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Expose } from 'class-transformer';
+
+export class MyRankResponseDto {
+  @ApiProperty()
+  @Expose()
+  rank: number;
+}

src/dtos/leaderboard/responses/tournament-leaderboard-response.dto.ts

@@ -0,0 +1,11 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Expose } from 'class-transformer';
+
+export class TournamentLeaderboardResponseDto {
+  @ApiProperty()
+  @Expose()
+  username: string;
+  @ApiProperty()
+  @Expose()
+  tournamentScore: number;
+}

src/entities/tournamentGroup.entity.ts

@@ -14,11 +14,10 @@ export class TournamentGroup {
     return result;
   }
 
-  public static newInstanceFromDynamoDBObjectWithoutTournamentId(
+  public static newInstanceFromDynamoDBObjectWithoutTournamentAndGroupId(
     data: any,
   ): TournamentGroup {
     const result = new TournamentGroup();
-    result.groupId = data.groupId.S;
     result.username = data.username.S;
     result.tournamentScore = data.tournamentScore.N;
 

src/repositories/tournamentGroup.repository.ts

@@ -13,6 +13,7 @@ import { TournamentRepository } from './tournament.repository';
 import { IsOngoing, SortOption } from '../enums';
 import { UserRepository } from './user.repository';
 import { v4 as uuidv4 } from 'uuid';
+import { TournamentLeaderboardResponseDto } from '../dtos/leaderboard/responses';
 
 @Injectable()
 export class TournamentGroupRepository {
@@ -60,22 +61,22 @@ export class TournamentGroupRepository {
   public async getGroupMembersByGroupId(
     groupId: string,
     sortOption: SortOption,
-  ): Promise<any> {
+  ): Promise<TournamentLeaderboardResponseDto[]> {
     const queryCommand = new QueryCommand({
       TableName: this.tableName,
       KeyConditionExpression: 'groupId = :groupId',
       ExpressionAttributeValues: {
         ':groupId': { S: groupId },
       },
-      ProjectionExpression: 'groupId, username, tournamentScore',
+      ProjectionExpression: 'username, tournamentScore',
     });
 
     try {
       const queryResult = await this.client.send(queryCommand);
 
       if (queryResult.Items && queryResult.Items.length > 0) {
         const result = queryResult.Items.map((item) =>
-          TournamentGroup.newInstanceFromDynamoDBObjectWithoutTournamentId(
+          TournamentGroup.newInstanceFromDynamoDBObjectWithoutTournamentAndGroupId(
             item,
           ),
         );

src/repositories/user.repository.ts

@@ -17,6 +17,7 @@ import {
 import { ConfigService } from '@nestjs/config';
 import { User } from '../entities';
 import { TournamentGroupRepository } from '.';
+import { GlobalLeaderboardResponseDto, CountryLeaderboardResponseDto } from '../dtos/leaderboard/responses';
 
 @Injectable()
 export class UserRepository {
@@ -141,21 +142,25 @@ export class UserRepository {
     }
   }
 
-  public async getGlobalLeaderboard(): Promise<any> {
+  public async getGlobalLeaderboard(): Promise<GlobalLeaderboardResponseDto[]> {
     const queryCommand = new QueryCommand({
       TableName: 'Users',
       IndexName: 'LevelGSI',
       KeyConditionExpression: 'dummyPartitionKey = :dpk',
       ExpressionAttributeValues: {
         ':dpk': { S: '_' },
       },
+      ProjectionExpression: 'username, levelNum',
       Limit: 1000,
       ScanIndexForward: false,
     });
 
     try {
       const response = await this.client.send(queryCommand);
-      return response.Items;
+      return response.Items.map((item) => ({
+        levelNum: item.levelNum.N,
+        username: item.username.S,
+      }));
     } catch (error) {
       console.error('Error in get global leaderboard request:', error);
       throw new InternalServerErrorException(
@@ -164,21 +169,25 @@ export class UserRepository {
     }
   }
 
-  public async getCountryLeaderboard(countryCode: string): Promise<any> {
+  public async getCountryLeaderboard(countryCode: string): Promise<CountryLeaderboardResponseDto[]> {
     const queryCommand = new QueryCommand({
       TableName: 'Users',
       IndexName: 'CountryCodeGSI',
       KeyConditionExpression: 'countryCode = :val',
       ExpressionAttributeValues: {
         ':val': { S: countryCode },
       },
+      ProjectionExpression: 'username, levelNum',
       Limit: 1000,
       ScanIndexForward: false,
     });
 
     try {
       const response = await this.client.send(queryCommand);
-      return response.Items;
+      return response.Items.map((item) => ({
+        levelNum: item.levelNum.N,
+        username: item.username.S,
+      }));
     } catch (error) {
       console.error('Error in get global leaderboard request:', error);
       throw new InternalServerErrorException(

src/services/leaderboard.service.ts

@@ -2,6 +2,7 @@ import { BadRequestException, Injectable } from '@nestjs/common';
 import { TournamentGroupRepository, UserRepository } from '../repositories';
 import { SortOption } from '../enums';
 import { IUser } from '../interfaces';
+import { GlobalLeaderboardResponseDto, TournamentLeaderboardResponseDto } from '../dtos/leaderboard/responses';
 
 @Injectable()
 export class LeaderboardService {
@@ -10,7 +11,7 @@ export class LeaderboardService {
     public readonly userRepository: UserRepository,
   ) {}
 
-  public async getGlobalLeaderboard() {
+  public async getGlobalLeaderboard(): Promise<GlobalLeaderboardResponseDto[]>{
     const users = await this.userRepository.getGlobalLeaderboard();
 
     return users;
@@ -22,7 +23,7 @@ export class LeaderboardService {
     return users;
   }
 
-  public async getTournamentLeaderboard(username: string) {
+  public async getTournamentLeaderboard(username: string): Promise<TournamentLeaderboardResponseDto[]> {
     const user = await this.userRepository.findUserByUsername(username);
 
     if (user.currGroupId === '') {
@@ -58,9 +59,9 @@ export class LeaderboardService {
         user.currGroupId,
         SortOption.NO_SORT,
       );
-    const userScore = members.findIndex(
+    const userScore = members[members.findIndex(
       (item) => item.username === user.username,
-    ).tournamentScore;
+    )].tournamentScore;
 
     let rank = 1; // calculate the rank of user in the group
     for (let member of members) {