feat: add prediction note, admin role update, trending markets & competition participants endpoints

backend/src/admin/admin.controller.ts

@@ -19,6 +19,7 @@ import { BanUserDto } from './dto/ban-user.dto';
 import { ActivityLogQueryDto } from './dto/activity-log-query.dto';
 import { StatsResponseDto } from './dto/stats-response.dto';
 import { ResolveMarketDto } from './dto/resolve-market.dto';
+import { UpdateUserRoleDto } from './dto/update-user-role.dto';
 import { ModerateCommentDto } from './dto/moderate-comment.dto';
 import { ReportQueryDto } from './dto/report-query.dto';
 
@@ -59,6 +60,19 @@ export class AdminController {
     );
   }
 
+  @Patch('users/:id/role')
+  async updateUserRole(
+    @Param('id') id: string,
+    @Body() dto: UpdateUserRoleDto,
+    @Request() req: any,
+  ) {
+    return this.adminService.updateUserRole(
+      id,
+      dto,
+      (req as { user: { id: string } }).user.id,
+    );
+  }
+
   @Get('users/:id/activity')
   async getUserActivity(
     @Param('id') id: string,

backend/src/admin/admin.service.spec.ts

@@ -17,6 +17,7 @@ import { SorobanService } from '../soroban/soroban.service';
 import { User } from '../users/entities/user.entity';
 import { AdminService } from './admin.service';
 import { ResolveMarketDto } from './dto/resolve-market.dto';
+import { Role } from '../common/enums/role.enum';
 
 const mockRepo = () => ({
   findOne: jest.fn(),
@@ -206,3 +207,80 @@ describe('AdminService.adminResolveMarket', () => {
     );
   });
 });
+
+describe('AdminService.updateUserRole', () => {
+  let service: AdminService;
+  let usersRepo: ReturnType<typeof mockRepo>;
+  let analyticsService: jest.Mocked<Pick<AnalyticsService, 'logActivity'>>;
+
+  const adminId = 'admin-1';
+
+  beforeEach(async () => {
+    usersRepo = mockRepo();
+    analyticsService = { logActivity: jest.fn().mockResolvedValue({}) };
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        AdminService,
+        { provide: getRepositoryToken(User), useValue: usersRepo },
+        { provide: getRepositoryToken(Market), useValue: mockRepo() },
+        { provide: getRepositoryToken(Comment), useValue: mockRepo() },
+        { provide: getRepositoryToken(Prediction), useValue: mockRepo() },
+        { provide: getRepositoryToken(Competition), useValue: mockRepo() },
+        { provide: getRepositoryToken(ActivityLog), useValue: mockRepo() },
+        { provide: AnalyticsService, useValue: analyticsService },
+        {
+          provide: NotificationsService,
+          useValue: { create: jest.fn() },
+        },
+        {
+          provide: SorobanService,
+          useValue: { resolveMarket: jest.fn() },
+        },
+      ],
+    }).compile();
+
+    service = module.get<AdminService>(AdminService);
+  });
+
+  it('should update user role from user to admin', async () => {
+    const user = {
+      id: 'user-1',
+      role: 'user',
+    } as User;
+
+    usersRepo.findOne.mockResolvedValue(user);
+    usersRepo.save.mockResolvedValue({ ...user, role: Role.Admin });
+
+    const result = await service.updateUserRole(
+      'user-1',
+      { role: Role.Admin },
+      adminId,
+    );
+
+    expect(result.role).toBe(Role.Admin);
+    expect(analyticsService.logActivity).toHaveBeenCalledWith(
+      adminId,
+      'USER_ROLE_CHANGED',
+      expect.objectContaining({
+        target_user_id: 'user-1',
+        previous_role: 'user',
+        new_role: Role.Admin,
+      }),
+    );
+  });
+
+  it('should throw BadRequestException when admin tries to change own role', async () => {
+    await expect(
+      service.updateUserRole(adminId, { role: Role.User }, adminId),
+    ).rejects.toThrow(BadRequestException);
+  });
+
+  it('should throw NotFoundException when user does not exist', async () => {
+    usersRepo.findOne.mockResolvedValue(null);
+
+    await expect(
+      service.updateUserRole('non-existent', { role: Role.Admin }, adminId),
+    ).rejects.toThrow(NotFoundException);
+  });
+});

backend/src/admin/admin.service.ts

@@ -22,6 +22,7 @@ import { ListUsersQueryDto } from './dto/list-users-query.dto';
 import { ActivityLogQueryDto } from './dto/activity-log-query.dto';
 import { StatsResponseDto } from './dto/stats-response.dto';
 import { ResolveMarketDto } from './dto/resolve-market.dto';
+import { UpdateUserRoleDto } from './dto/update-user-role.dto';
 import {
   ReportFormat,
   ReportQueryDto,
@@ -180,6 +181,36 @@ export class AdminService {
     return user;
   }
 
+  async updateUserRole(
+    id: string,
+    dto: UpdateUserRoleDto,
+    adminId: string,
+  ): Promise<User> {
+    if (id === adminId) {
+      throw new BadRequestException('You cannot change your own role');
+    }
+
+    const user = await this.usersRepository.findOne({ where: { id } });
+    if (!user) throw new NotFoundException('User not found');
+
+    const previousRole = user.role;
+    user.role = dto.role;
+
+    await this.usersRepository.save(user);
+
+    await this.analyticsService.logActivity(adminId, 'USER_ROLE_CHANGED', {
+      target_user_id: id,
+      previous_role: previousRole,
+      new_role: dto.role,
+    });
+
+    this.logger.log(
+      `Admin ${adminId} changed role of user ${id} from "${previousRole}" to "${dto.role}"`,
+    );
+
+    return user;
+  }
+
   async getUserActivity(userId: string, query: ActivityLogQueryDto) {
     const { page = 1, limit = 10, actionType, startDate, endDate } = query;
     const skip = (page - 1) * limit;

backend/src/admin/dto/update-user-role.dto.ts

@@ -0,0 +1,13 @@
+import { IsEnum } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+import { Role } from '../../common/enums/role.enum';
+
+export class UpdateUserRoleDto {
+  @ApiProperty({
+    description: 'The role to assign to the user',
+    enum: Role,
+    example: Role.Admin,
+  })
+  @IsEnum(Role)
+  role: Role;
+}

backend/src/competitions/competitions.controller.ts

@@ -23,6 +23,10 @@ import {
   ListCompetitionsDto,
   PaginatedCompetitionsResponse,
 } from './dto/list-competitions.dto';
+import {
+  ListParticipantsQueryDto,
+  PaginatedParticipantsResponse,
+} from './dto/list-participants.dto';
 import { Competition } from './entities/competition.entity';
 import { CurrentUser } from '../common/decorators/current-user.decorator';
 import { Public } from '../common/decorators/public.decorator';
@@ -76,4 +80,19 @@ export class CompetitionsController {
     }
     return competition;
   }
+
+  @Get(':id/participants')
+  @Public()
+  @ApiOperation({ summary: 'Get participants of a competition' })
+  @ApiResponse({
+    status: 200,
+    description: 'Paginated participants with scores and rankings',
+  })
+  @ApiResponse({ status: 404, description: 'Competition not found' })
+  async getParticipants(
+    @Param('id') id: string,
+    @Query() query: ListParticipantsQueryDto,
+  ): Promise<PaginatedParticipantsResponse> {
+    return this.competitionsService.getParticipants(id, query);
+  }
 }

backend/src/competitions/competitions.module.ts

@@ -1,12 +1,16 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { Competition } from './entities/competition.entity';
+import { CompetitionParticipant } from './entities/competition-participant.entity';
 import { CompetitionsService } from './competitions.service';
 import { CompetitionsController } from './competitions.controller';
 import { UsersModule } from '../users/users.module';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Competition]), UsersModule],
+  imports: [
+    TypeOrmModule.forFeature([Competition, CompetitionParticipant]),
+    UsersModule,
+  ],
   controllers: [CompetitionsController],
   providers: [CompetitionsService],
   exports: [CompetitionsService],

backend/src/competitions/competitions.service.spec.ts

@@ -1,10 +1,12 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { getRepositoryToken } from '@nestjs/typeorm';
+import { NotFoundException } from '@nestjs/common';
 import { CompetitionsService } from './competitions.service';
 import {
   Competition,
   CompetitionVisibility,
 } from './entities/competition.entity';
+import { CompetitionParticipant } from './entities/competition-participant.entity';
 import { CreateCompetitionDto } from './dto/create-competition.dto';
 import { User } from '../users/entities/user.entity';
 
@@ -34,6 +36,11 @@ describe('CompetitionsService', () => {
     save: jest.fn(),
     find: jest.fn(),
     findOne: jest.fn(),
+    createQueryBuilder: jest.fn(),
+  };
+
+  const mockParticipantsRepository = {
+    createQueryBuilder: jest.fn(),
   };
 
   beforeEach(async () => {
@@ -44,6 +51,10 @@ describe('CompetitionsService', () => {
           provide: getRepositoryToken(Competition),
           useValue: mockRepository,
         },
+        {
+          provide: getRepositoryToken(CompetitionParticipant),
+          useValue: mockParticipantsRepository,
+        },
       ],
     }).compile();
 
@@ -151,4 +162,69 @@ describe('CompetitionsService', () => {
       expect(result).toBeNull();
     });
   });
+
+  describe('getParticipants', () => {
+    it('should return paginated participants for a competition', async () => {
+      mockRepository.findOne.mockResolvedValue(mockCompetition);
+
+      const participants = [
+        {
+          id: 'part-1',
+          user_id: 'user-1',
+          competition_id: 'comp-uuid-1',
+          score: 100,
+          rank: 1,
+          joined_at: new Date(),
+          user: {
+            id: 'user-1',
+            username: 'alice',
+            stellar_address: 'GABCDEF',
+          },
+        },
+        {
+          id: 'part-2',
+          user_id: 'user-2',
+          competition_id: 'comp-uuid-1',
+          score: 50,
+          rank: 2,
+          joined_at: new Date(),
+          user: {
+            id: 'user-2',
+            username: null,
+            stellar_address: 'GXYZ123',
+          },
+        },
+      ];
+
+      const qbMock = {
+        leftJoinAndSelect: jest.fn().mockReturnThis(),
+        where: jest.fn().mockReturnThis(),
+        orderBy: jest.fn().mockReturnThis(),
+        addOrderBy: jest.fn().mockReturnThis(),
+        skip: jest.fn().mockReturnThis(),
+        take: jest.fn().mockReturnThis(),
+        getManyAndCount: jest.fn().mockResolvedValue([participants, 2]),
+      };
+      mockParticipantsRepository.createQueryBuilder.mockReturnValue(qbMock);
+
+      const result = await service.getParticipants('comp-uuid-1', {
+        page: 1,
+        limit: 20,
+      });
+
+      expect(result.data).toHaveLength(2);
+      expect(result.total).toBe(2);
+      expect(result.data[0].username).toBe('alice');
+      expect(result.data[0].score).toBe(100);
+      expect(result.data[1].username).toBeNull();
+    });
+
+    it('should throw NotFoundException if competition does not exist', async () => {
+      mockRepository.findOne.mockResolvedValue(null);
+
+      await expect(
+        service.getParticipants('non-existent', { page: 1, limit: 20 }),
+      ).rejects.toThrow(NotFoundException);
+    });
+  });
 });