mmintel/gridpilot.gg
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

wip league admin tools

Browse Source
This commit is contained in:
Marc Mintel
2025-12-28 12:04:12 +01:00
parent 5dc8c2399c
commit 6edf12fda8
401 changed files with 15365 additions and 6047 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
apps/api/src/domain/analytics/AnalyticsController.test.ts
View File

@@ -181,7 +181,7 @@ describe('AnalyticsController', () => {
vi.clearAllMocks();
});
it('allows @Public() endpoint without a session', async () => {
it('allows @Public() endpoint without a session', { retry: 2 }, async () => {
await request(app.getHttpServer()).post('/analytics/page-view').send({}).expect(201);
});

67
apps/api/src/domain/auth/ActorFromSession.test.ts Normal file
View File

@@ -0,0 +1,67 @@
import { describe, expect, it, vi } from 'vitest';
import { requestContextMiddleware } from '@adapters/http/RequestContext';
import { Result } from '@core/shared/application/Result';
import { getActorFromRequestContext } from './getActorFromRequestContext';
import { requireLeagueAdminOrOwner } from '../league/LeagueAuthorization';
async function withRequestContext<T>(req: Record<string, unknown>, fn: () => Promise<T>): Promise<T> {
const res = {};
return await new Promise<T>((resolve, reject) => {
requestContextMiddleware(req as any, res as any, () => {
fn().then(resolve, reject);
});
});
}
describe('ActorFromSession', () => {
it('derives actor from authenticated session (request.user), not request payload', async () => {
const req: any = {
user: { userId: 'driver-from-session' },
body: { driverId: 'driver-from-body' },
};
await withRequestContext(req, async () => {
const actor = getActorFromRequestContext();
expect(actor).toEqual({ userId: 'driver-from-session', driverId: 'driver-from-session' });
});
});
it('permission helper invokes league admin check using session-derived actor (ignores payload)', async () => {
const getLeagueAdminPermissionsUseCase = {
execute: vi.fn(async () => Result.ok(undefined)),
};
const req: any = {
user: { userId: 'driver-from-session' },
body: { performerDriverId: 'driver-from-body' },
};
await withRequestContext(req, async () => {
await expect(
requireLeagueAdminOrOwner('league-1', getLeagueAdminPermissionsUseCase as any),
).resolves.toBeUndefined();
});
expect(getLeagueAdminPermissionsUseCase.execute).toHaveBeenCalledWith({
leagueId: 'league-1',
performerDriverId: 'driver-from-session',
});
});
it('permission helper rejects when league admin check fails', async () => {
const getLeagueAdminPermissionsUseCase = {
execute: vi.fn(async () =>
Result.err({ code: 'USER_NOT_MEMBER', details: { message: 'nope' } } as any),
),
};
const req: any = { user: { userId: 'driver-from-session' } };
await withRequestContext(req, async () => {
await expect(
requireLeagueAdminOrOwner('league-1', getLeagueAdminPermissionsUseCase as any),
).rejects.toThrow('Forbidden');
});
});
});

25
apps/api/src/domain/auth/getActorFromRequestContext.ts Normal file
View File

@@ -0,0 +1,25 @@
import { getHttpRequestContext } from '@adapters/http/RequestContext';
export type Actor = {
userId: string;
driverId: string;
};
type AuthenticatedRequest = {
user?: { userId: string };
};
export function getActorFromRequestContext(): Actor {
const ctx = getHttpRequestContext();
const req = ctx.req as unknown as AuthenticatedRequest;
const userId = req.user?.userId;
if (!userId) {
throw new Error('Unauthorized');
}
// Current canonical mapping:
// - The authenticated session identity is `userId`.
// - In the current system, that `userId` is also treated as the performer `driverId`.
return { userId, driverId: userId };
}

2
apps/api/src/domain/dashboard/presenters/DashboardOverviewPresenter.ts
View File

@@ -39,7 +39,7 @@ export class DashboardOverviewPresenter implements UseCaseOutputPort<DashboardOv
track: String(raceSummary.race.track),
car: String(raceSummary.race.car),
scheduledAt: raceSummary.race.scheduledAt.toISOString(),
status: raceSummary.race.status as 'scheduled' | 'running' | 'completed' | 'cancelled',
status: raceSummary.race.status.toString(),
isMyLeague: raceSummary.isMyLeague,
});

21
apps/api/src/domain/league/LeagueAuthorization.ts Normal file
View File

@@ -0,0 +1,21 @@
import { ForbiddenException } from '@nestjs/common';
import { getActorFromRequestContext } from '../auth/getActorFromRequestContext';
import type { GetLeagueAdminPermissionsUseCase } from '@core/racing/application/use-cases/GetLeagueAdminPermissionsUseCase';
type GetLeagueAdminPermissionsUseCaseLike = Pick<GetLeagueAdminPermissionsUseCase, 'execute'>;
export async function requireLeagueAdminOrOwner(
leagueId: string,
getLeagueAdminPermissionsUseCase: GetLeagueAdminPermissionsUseCaseLike,
): Promise<void> {
const actor = getActorFromRequestContext();
const permissionResult = await getLeagueAdminPermissionsUseCase.execute({
leagueId,
performerDriverId: actor.driverId,
});
if (permissionResult.isErr()) {
throw new ForbiddenException('Forbidden');
}
}

23
apps/api/src/domain/league/LeagueController.test.ts
View File

@@ -11,6 +11,7 @@ import { AuthorizationGuard } from '../auth/AuthorizationGuard';
import type { AuthorizationService } from '../auth/AuthorizationService';
import { FeatureAvailabilityGuard } from '../policy/FeatureAvailabilityGuard';
import type { PolicyService, PolicySnapshot } from '../policy/PolicyService';
import { createHttpContractHarness } from '../../shared/testing/httpContractHarness';
describe('LeagueController', () => {
let controller: LeagueController;
@@ -135,4 +136,26 @@ describe('LeagueController', () => {
await request(app.getHttpServer()).get('/leagues/l1/admin').expect(200);
});
});
describe('transfer ownership contract (HTTP)', () => {
it('rejects client-supplied currentOwnerId (400) once DTO whitelisting is enforced', async () => {
const leagueService = {
transferLeagueOwnership: vi.fn(async () => ({ success: true })),
};
const harness = await createHttpContractHarness({
controllers: [LeagueController],
providers: [{ provide: LeagueService, useValue: leagueService }],
});
try {
await harness.http
.post('/leagues/l1/transfer-ownership')
.send({ currentOwnerId: 'spoof', newOwnerId: 'o2' })
.expect(400);
} finally {
await harness.close();
}
});
});
});

231
apps/api/src/domain/league/LeagueController.ts
View File

@@ -1,4 +1,4 @@
import { Body, Controller, Get, Param, Patch, Post, Inject } from '@nestjs/common';
import { Body, Controller, Delete, Get, HttpCode, Param, Patch, Post, Inject, ValidationPipe, Query } from '@nestjs/common';
import { ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
import { Public } from '../auth/Public';
import { LeagueService } from './LeagueService';
@@ -16,14 +16,25 @@ import { LeagueAdminProtestsDTO } from './dtos/LeagueAdminProtestsDTO';
import { LeagueConfigFormModelDTO } from './dtos/LeagueConfigFormModelDTO';
import { LeagueJoinRequestDTO } from './dtos/LeagueJoinRequestDTO';
import { LeagueMembershipsDTO } from './dtos/LeagueMembershipsDTO';
import { LeagueRosterJoinRequestDTO } from './dtos/LeagueRosterJoinRequestDTO';
import { LeagueRosterMemberDTO } from './dtos/LeagueRosterMemberDTO';
import { LeagueOwnerSummaryDTO } from './dtos/LeagueOwnerSummaryDTO';
import { LeagueScheduleDTO } from './dtos/LeagueScheduleDTO';
import {
LeagueSeasonSchedulePublishInputDTO,
LeagueSeasonSchedulePublishOutputDTO,
} from './dtos/LeagueSeasonSchedulePublishDTO';
import {
CreateLeagueScheduleRaceInputDTO,
CreateLeagueScheduleRaceOutputDTO,
LeagueScheduleRaceMutationSuccessDTO,
UpdateLeagueScheduleRaceInputDTO,
} from './dtos/LeagueScheduleRaceAdminDTO';
import { LeagueSeasonSummaryDTO } from './dtos/LeagueSeasonSummaryDTO';
import { LeagueStandingsDTO } from './dtos/LeagueStandingsDTO';
import { LeagueStatsDTO } from './dtos/LeagueStatsDTO';
import { RejectJoinRequestInputDTO } from './dtos/RejectJoinRequestInputDTO';
import { RejectJoinRequestOutputDTO } from './dtos/RejectJoinRequestOutputDTO';
import { RemoveLeagueMemberInputDTO } from './dtos/RemoveLeagueMemberInputDTO';
import { RemoveLeagueMemberOutputDTO } from './dtos/RemoveLeagueMemberOutputDTO';
import { UpdateLeagueMemberRoleInputDTO } from './dtos/UpdateLeagueMemberRoleInputDTO';
import { UpdateLeagueMemberRoleOutputDTO } from './dtos/UpdateLeagueMemberRoleOutputDTO';
@@ -33,9 +44,11 @@ import { GetLeagueProtestsQueryDTO } from './dtos/GetLeagueProtestsQueryDTO';
import { GetLeagueSeasonsQueryDTO } from './dtos/GetLeagueSeasonsQueryDTO';
import { GetLeagueWalletOutputDTO } from './dtos/GetLeagueWalletOutputDTO';
import { TotalLeaguesDTO } from './dtos/TotalLeaguesDTO';
import { GetLeagueScheduleQueryDTO } from './dtos/GetLeagueScheduleQueryDTO';
import { WithdrawFromLeagueWalletInputDTO } from './dtos/WithdrawFromLeagueWalletInputDTO';
import { WithdrawFromLeagueWalletOutputDTO } from './dtos/WithdrawFromLeagueWalletOutputDTO';
import { LeagueScoringPresetsDTO } from './dtos/LeagueScoringPresetsDTO';
import { TransferLeagueOwnershipInputDTO } from './dtos/TransferLeagueOwnershipInputDTO';
@ApiTags('leagues')
@Controller('leagues')
@@ -103,24 +116,22 @@ export class LeagueController {
@ApiResponse({ status: 200, description: 'League admin permissions', type: LeagueAdminPermissionsDTO })
async getLeagueAdminPermissions(
@Param('leagueId') leagueId: string,
@Param('performerDriverId') performerDriverId: string,
@Param('performerDriverId') _performerDriverId: string,
): Promise<LeagueAdminPermissionsDTO> {
// No specific input DTO needed for Get, parameters from path
return this.leagueService.getLeagueAdminPermissions({ leagueId, performerDriverId });
void _performerDriverId;
return this.leagueService.getLeagueAdminPermissions({ leagueId });
}
@Patch(':leagueId/members/:targetDriverId/remove')
@ApiOperation({ summary: 'Remove a member from the league' })
@ApiBody({ type: RemoveLeagueMemberInputDTO }) // Explicitly define body type for Swagger
@ApiResponse({ status: 200, description: 'Member removed successfully', type: RemoveLeagueMemberOutputDTO })
@ApiResponse({ status: 400, description: 'Cannot remove member' })
@ApiResponse({ status: 404, description: 'Member not found' })
async removeLeagueMember(
@Param('leagueId') leagueId: string,
@Param('performerDriverId') performerDriverId: string,
@Param('targetDriverId') targetDriverId: string, // Body content for a patch often includes IDs
@Param('targetDriverId') targetDriverId: string,
): Promise<RemoveLeagueMemberOutputDTO> {
return this.leagueService.removeLeagueMember({ leagueId, performerDriverId, targetDriverId });
return this.leagueService.removeLeagueMember({ leagueId, targetDriverId });
}
@Patch(':leagueId/members/:targetDriverId/role')
@@ -131,11 +142,10 @@ export class LeagueController {
@ApiResponse({ status: 404, description: 'Member not found' })
async updateLeagueMemberRole(
@Param('leagueId') leagueId: string,
@Param('performerDriverId') performerDriverId: string,
@Param('targetDriverId') targetDriverId: string,
@Body() input: UpdateLeagueMemberRoleInputDTO, // Body includes newRole, other for swagger
): Promise<UpdateLeagueMemberRoleOutputDTO> {
return this.leagueService.updateLeagueMemberRole({ leagueId, performerDriverId, targetDriverId, newRole: input.newRole });
return this.leagueService.updateLeagueMemberRole(leagueId, targetDriverId, input);
}
@Public()
@@ -229,8 +239,105 @@ export class LeagueController {
@Get(':leagueId/schedule')
@ApiOperation({ summary: 'Get league schedule' })
@ApiResponse({ status: 200, description: 'League schedule', type: LeagueScheduleDTO })
async getLeagueSchedule(@Param('leagueId') leagueId: string): Promise<LeagueScheduleDTO> {
return this.leagueService.getLeagueSchedule(leagueId);
async getLeagueSchedule(
@Param('leagueId') leagueId: string,
@Query() query: GetLeagueScheduleQueryDTO,
): Promise<LeagueScheduleDTO> {
return this.leagueService.getLeagueSchedule(leagueId, query);
}
@Post(':leagueId/seasons/:seasonId/schedule/publish')
@HttpCode(200)
@ApiOperation({ summary: 'Publish a league season schedule (admin/owner only; actor derived from session)' })
@ApiBody({ type: LeagueSeasonSchedulePublishInputDTO })
@ApiResponse({ status: 200, description: 'Schedule published', type: LeagueSeasonSchedulePublishOutputDTO })
async publishLeagueSeasonSchedule(
@Param('leagueId') leagueId: string,
@Param('seasonId') seasonId: string,
@Body(
new ValidationPipe({
whitelist: true,
forbidNonWhitelisted: true,
transform: true,
expectedType: LeagueSeasonSchedulePublishInputDTO,
}),
)
input: LeagueSeasonSchedulePublishInputDTO,
): Promise<LeagueSeasonSchedulePublishOutputDTO> {
return this.leagueService.publishLeagueSeasonSchedule(leagueId, seasonId, input);
}
@Post(':leagueId/seasons/:seasonId/schedule/unpublish')
@HttpCode(200)
@ApiOperation({ summary: 'Unpublish a league season schedule (admin/owner only; actor derived from session)' })
@ApiBody({ type: LeagueSeasonSchedulePublishInputDTO })
@ApiResponse({ status: 200, description: 'Schedule unpublished', type: LeagueSeasonSchedulePublishOutputDTO })
async unpublishLeagueSeasonSchedule(
@Param('leagueId') leagueId: string,
@Param('seasonId') seasonId: string,
@Body(
new ValidationPipe({
whitelist: true,
forbidNonWhitelisted: true,
transform: true,
expectedType: LeagueSeasonSchedulePublishInputDTO,
}),
)
input: LeagueSeasonSchedulePublishInputDTO,
): Promise<LeagueSeasonSchedulePublishOutputDTO> {
return this.leagueService.unpublishLeagueSeasonSchedule(leagueId, seasonId, input);
}
@Post(':leagueId/seasons/:seasonId/schedule/races')
@ApiOperation({ summary: 'Create a schedule race for a league season (admin/owner only; actor derived from session)' })
@ApiBody({ type: CreateLeagueScheduleRaceInputDTO })
@ApiResponse({ status: 201, description: 'Race created', type: CreateLeagueScheduleRaceOutputDTO })
async createLeagueSeasonScheduleRace(
@Param('leagueId') leagueId: string,
@Param('seasonId') seasonId: string,
@Body(
new ValidationPipe({
whitelist: true,
forbidNonWhitelisted: true,
transform: true,
expectedType: CreateLeagueScheduleRaceInputDTO,
}),
)
input: CreateLeagueScheduleRaceInputDTO,
): Promise<CreateLeagueScheduleRaceOutputDTO> {
return this.leagueService.createLeagueSeasonScheduleRace(leagueId, seasonId, input);
}
@Patch(':leagueId/seasons/:seasonId/schedule/races/:raceId')
@ApiOperation({ summary: 'Update a schedule race for a league season (admin/owner only; actor derived from session)' })
@ApiBody({ type: UpdateLeagueScheduleRaceInputDTO })
@ApiResponse({ status: 200, description: 'Race updated', type: LeagueScheduleRaceMutationSuccessDTO })
async updateLeagueSeasonScheduleRace(
@Param('leagueId') leagueId: string,
@Param('seasonId') seasonId: string,
@Param('raceId') raceId: string,
@Body(
new ValidationPipe({
whitelist: true,
forbidNonWhitelisted: true,
transform: true,
expectedType: UpdateLeagueScheduleRaceInputDTO,
}),
)
input: UpdateLeagueScheduleRaceInputDTO,
): Promise<LeagueScheduleRaceMutationSuccessDTO> {
return this.leagueService.updateLeagueSeasonScheduleRace(leagueId, seasonId, raceId, input);
}
@Delete(':leagueId/seasons/:seasonId/schedule/races/:raceId')
@ApiOperation({ summary: 'Delete a schedule race for a league season (admin/owner only; actor derived from session)' })
@ApiResponse({ status: 200, description: 'Race deleted', type: LeagueScheduleRaceMutationSuccessDTO })
async deleteLeagueSeasonScheduleRace(
@Param('leagueId') leagueId: string,
@Param('seasonId') seasonId: string,
@Param('raceId') raceId: string,
): Promise<LeagueScheduleRaceMutationSuccessDTO> {
return this.leagueService.deleteLeagueSeasonScheduleRace(leagueId, seasonId, raceId);
}
@Public()
@@ -241,6 +348,82 @@ export class LeagueController {
return this.leagueService.getLeagueStats(leagueId);
}
@Get(':leagueId/admin/roster/members')
@ApiOperation({ summary: 'Get league roster members (admin/owner only; actor derived from session)' })
@ApiResponse({ status: 200, description: 'List of league roster members', type: [LeagueRosterMemberDTO] })
async getLeagueRosterMembers(@Param('leagueId') leagueId: string): Promise<LeagueRosterMemberDTO[]> {
return this.leagueService.getLeagueRosterMembers(leagueId);
}
@Patch(':leagueId/admin/roster/members/:targetDriverId/role')
@HttpCode(200)
@ApiOperation({ summary: "Change a roster member's role (admin/owner only; actor derived from session)" })
@ApiBody({ type: UpdateLeagueMemberRoleInputDTO })
@ApiResponse({ status: 200, description: 'Member role updated successfully', type: UpdateLeagueMemberRoleOutputDTO })
@ApiResponse({ status: 400, description: 'Cannot update role' })
@ApiResponse({ status: 403, description: 'Forbidden' })
@ApiResponse({ status: 404, description: 'Member not found' })
async updateLeagueRosterMemberRole(
@Param('leagueId') leagueId: string,
@Param('targetDriverId') targetDriverId: string,
@Body(
new ValidationPipe({
whitelist: true,
forbidNonWhitelisted: true,
transform: true,
expectedType: UpdateLeagueMemberRoleInputDTO,
}),
)
input: UpdateLeagueMemberRoleInputDTO,
): Promise<UpdateLeagueMemberRoleOutputDTO> {
return this.leagueService.updateLeagueMemberRole(leagueId, targetDriverId, input);
}
@Patch(':leagueId/admin/roster/members/:targetDriverId/remove')
@HttpCode(200)
@ApiOperation({ summary: 'Remove a roster member (admin/owner only; actor derived from session)' })
@ApiResponse({ status: 200, description: 'Member removed successfully', type: RemoveLeagueMemberOutputDTO })
@ApiResponse({ status: 400, description: 'Cannot remove member' })
@ApiResponse({ status: 403, description: 'Forbidden' })
@ApiResponse({ status: 404, description: 'Member not found' })
async removeLeagueRosterMember(
@Param('leagueId') leagueId: string,
@Param('targetDriverId') targetDriverId: string,
): Promise<RemoveLeagueMemberOutputDTO> {
return this.leagueService.removeLeagueMember({ leagueId, targetDriverId });
}
@Get(':leagueId/admin/roster/join-requests')
@ApiOperation({ summary: 'Get league roster join requests (admin/owner only; actor derived from session)' })
@ApiResponse({ status: 200, description: 'List of league join requests', type: [LeagueRosterJoinRequestDTO] })
async getLeagueRosterJoinRequests(@Param('leagueId') leagueId: string): Promise<LeagueRosterJoinRequestDTO[]> {
return this.leagueService.getLeagueRosterJoinRequests(leagueId);
}
@Post(':leagueId/admin/roster/join-requests/:joinRequestId/approve')
@HttpCode(200)
@ApiOperation({ summary: 'Approve a league roster join request (admin/owner only; actor derived from session)' })
@ApiResponse({ status: 200, description: 'Join request approved', type: ApproveJoinRequestOutputDTO })
@ApiResponse({ status: 404, description: 'Join request not found' })
async approveLeagueRosterJoinRequest(
@Param('leagueId') leagueId: string,
@Param('joinRequestId') joinRequestId: string,
): Promise<ApproveJoinRequestOutputDTO> {
return this.leagueService.approveLeagueRosterJoinRequest(leagueId, joinRequestId);
}
@Post(':leagueId/admin/roster/join-requests/:joinRequestId/reject')
@HttpCode(200)
@ApiOperation({ summary: 'Reject a league roster join request (admin/owner only; actor derived from session)' })
@ApiResponse({ status: 200, description: 'Join request rejected', type: RejectJoinRequestOutputDTO })
@ApiResponse({ status: 404, description: 'Join request not found' })
async rejectLeagueRosterJoinRequest(
@Param('leagueId') leagueId: string,
@Param('joinRequestId') joinRequestId: string,
): Promise<RejectJoinRequestOutputDTO> {
return this.leagueService.rejectLeagueRosterJoinRequest(leagueId, joinRequestId);
}
@Get(':leagueId/admin')
@ApiOperation({ summary: 'Get league admin data' })
@ApiResponse({ status: 200, description: 'League admin data', type: LeagueAdminDTO })
@@ -273,17 +456,29 @@ export class LeagueController {
}
@Post(':leagueId/join')
@ApiOperation({ summary: 'Join a league' })
@ApiOperation({ summary: 'Join a league (actor derived from session)' })
@ApiResponse({ status: 200, description: 'Joined league successfully' })
async joinLeague(@Param('leagueId') leagueId: string, @Body() body: { driverId: string }) {
return this.leagueService.joinLeague(leagueId, body.driverId);
async joinLeague(@Param('leagueId') leagueId: string) {
return this.leagueService.joinLeague(leagueId);
}
@Post(':leagueId/transfer-ownership')
@ApiOperation({ summary: 'Transfer league ownership' })
@ApiBody({ type: TransferLeagueOwnershipInputDTO })
@ApiResponse({ status: 200, description: 'Ownership transferred successfully' })
async transferLeagueOwnership(@Param('leagueId') leagueId: string, @Body() body: { currentOwnerId: string, newOwnerId: string }) {
return this.leagueService.transferLeagueOwnership(leagueId, body.currentOwnerId, body.newOwnerId);
async transferLeagueOwnership(
@Param('leagueId') leagueId: string,
@Body(
new ValidationPipe({
whitelist: true,
forbidNonWhitelisted: true,
transform: true,
expectedType: TransferLeagueOwnershipInputDTO,
}),
)
input: TransferLeagueOwnershipInputDTO,
) {
return this.leagueService.transferLeagueOwnership(leagueId, input);
}
@Public()

246
apps/api/src/domain/league/LeagueProviders.ts
View File

@@ -1,5 +1,7 @@
import { Provider } from '@nestjs/common';
import { randomUUID } from 'crypto';
import { LeagueService } from './LeagueService';
import * as LeagueTokens from './LeagueTokens';
// Import core interfaces
import type { IDriverRepository } from '@core/racing/domain/repositories/IDriverRepository';
@@ -28,6 +30,8 @@ import { GetLeagueAdminPermissionsUseCase } from '@core/racing/application/use-c
import { GetLeagueFullConfigUseCase } from '@core/racing/application/use-cases/GetLeagueFullConfigUseCase';
import { GetLeagueJoinRequestsUseCase } from '@core/racing/application/use-cases/GetLeagueJoinRequestsUseCase';
import { GetLeagueMembershipsUseCase } from '@core/racing/application/use-cases/GetLeagueMembershipsUseCase';
import { GetLeagueRosterMembersUseCase } from '@core/racing/application/use-cases/GetLeagueRosterMembersUseCase';
import { GetLeagueRosterJoinRequestsUseCase } from '@core/racing/application/use-cases/GetLeagueRosterJoinRequestsUseCase';
import { GetLeagueOwnerSummaryUseCase } from '@core/racing/application/use-cases/GetLeagueOwnerSummaryUseCase';
import { GetLeagueProtestsUseCase } from '@core/racing/application/use-cases/GetLeagueProtestsUseCase';
import { GetLeagueScheduleUseCase } from '@core/racing/application/use-cases/GetLeagueScheduleUseCase';
@@ -47,6 +51,13 @@ import { TransferLeagueOwnershipUseCase } from '@core/racing/application/use-cas
import { UpdateLeagueMemberRoleUseCase } from '@core/racing/application/use-cases/UpdateLeagueMemberRoleUseCase';
import { WithdrawFromLeagueWalletUseCase } from '@core/racing/application/use-cases/WithdrawFromLeagueWalletUseCase';
// Schedule mutation use cases
import { CreateLeagueSeasonScheduleRaceUseCase } from '@core/racing/application/use-cases/CreateLeagueSeasonScheduleRaceUseCase';
import { UpdateLeagueSeasonScheduleRaceUseCase } from '@core/racing/application/use-cases/UpdateLeagueSeasonScheduleRaceUseCase';
import { DeleteLeagueSeasonScheduleRaceUseCase } from '@core/racing/application/use-cases/DeleteLeagueSeasonScheduleRaceUseCase';
import { PublishLeagueSeasonScheduleUseCase } from '@core/racing/application/use-cases/PublishLeagueSeasonScheduleUseCase';
import { UnpublishLeagueSeasonScheduleUseCase } from '@core/racing/application/use-cases/UnpublishLeagueSeasonScheduleUseCase';
// Import presenters
import { AllLeaguesWithCapacityPresenter } from './presenters/AllLeaguesWithCapacityPresenter';
import { AllLeaguesWithCapacityAndScoringPresenter } from './presenters/AllLeaguesWithCapacityAndScoringPresenter';
@@ -54,6 +65,10 @@ import { ApproveLeagueJoinRequestPresenter } from './presenters/ApproveLeagueJoi
import { CreateLeaguePresenter } from './presenters/CreateLeaguePresenter';
import { GetLeagueAdminPermissionsPresenter } from './presenters/GetLeagueAdminPermissionsPresenter';
import { GetLeagueMembershipsPresenter } from './presenters/GetLeagueMembershipsPresenter';
import {
GetLeagueRosterJoinRequestsPresenter,
GetLeagueRosterMembersPresenter,
} from './presenters/LeagueRosterAdminReadPresenters';
import { GetLeagueOwnerSummaryPresenter } from './presenters/GetLeagueOwnerSummaryPresenter';
import { GetLeagueProtestsPresenter } from './presenters/GetLeagueProtestsPresenter';
import { GetLeagueSeasonsPresenter } from './presenters/GetLeagueSeasonsPresenter';
@@ -74,6 +89,14 @@ import { TransferLeagueOwnershipPresenter } from './presenters/TransferLeagueOwn
import { UpdateLeagueMemberRolePresenter } from './presenters/UpdateLeagueMemberRolePresenter';
import { WithdrawFromLeagueWalletPresenter } from './presenters/WithdrawFromLeagueWalletPresenter';
import {
CreateLeagueSeasonScheduleRacePresenter,
DeleteLeagueSeasonScheduleRacePresenter,
PublishLeagueSeasonSchedulePresenter,
UnpublishLeagueSeasonSchedulePresenter,
UpdateLeagueSeasonScheduleRacePresenter,
} from './presenters/LeagueSeasonScheduleMutationPresenters';
export const LEAGUE_REPOSITORY_TOKEN = 'ILeagueRepository';
export const LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN = 'ILeagueMembershipRepository';
export const LEAGUE_STANDINGS_REPOSITORY_TOKEN = 'ILeagueStandingsRepository';
@@ -108,6 +131,8 @@ export const GET_LEAGUE_OWNER_SUMMARY_USE_CASE = 'GetLeagueOwnerSummaryUseCase';
export const GET_LEAGUE_PROTESTS_USE_CASE = 'GetLeagueProtestsUseCase';
export const GET_LEAGUE_SEASONS_USE_CASE = 'GetLeagueSeasonsUseCase';
export const GET_LEAGUE_MEMBERSHIPS_USE_CASE = 'GetLeagueMembershipsUseCase';
export const GET_LEAGUE_ROSTER_MEMBERS_USE_CASE = 'GetLeagueRosterMembersUseCase';
export const GET_LEAGUE_ROSTER_JOIN_REQUESTS_USE_CASE = 'GetLeagueRosterJoinRequestsUseCase';
export const GET_LEAGUE_SCHEDULE_USE_CASE = 'GetLeagueScheduleUseCase';
export const GET_LEAGUE_ADMIN_PERMISSIONS_USE_CASE = 'GetLeagueAdminPermissionsUseCase';
export const GET_LEAGUE_WALLET_USE_CASE = 'GetLeagueWalletUseCase';
@@ -124,6 +149,8 @@ export const APPROVE_LEAGUE_JOIN_REQUEST_OUTPUT_PORT_TOKEN = 'ApproveLeagueJoinR
export const CREATE_LEAGUE_OUTPUT_PORT_TOKEN = 'CreateLeagueOutputPort_TOKEN';
export const GET_LEAGUE_ADMIN_PERMISSIONS_OUTPUT_PORT_TOKEN = 'GetLeagueAdminPermissionsOutputPort_TOKEN';
export const GET_LEAGUE_MEMBERSHIPS_OUTPUT_PORT_TOKEN = 'GetLeagueMembershipsOutputPort_TOKEN';
export const GET_LEAGUE_ROSTER_MEMBERS_OUTPUT_PORT_TOKEN = 'GetLeagueRosterMembersOutputPort_TOKEN';
export const GET_LEAGUE_ROSTER_JOIN_REQUESTS_OUTPUT_PORT_TOKEN = 'GetLeagueRosterJoinRequestsOutputPort_TOKEN';
export const GET_LEAGUE_OWNER_SUMMARY_OUTPUT_PORT_TOKEN = 'GetLeagueOwnerSummaryOutputPort_TOKEN';
export const GET_LEAGUE_SEASONS_OUTPUT_PORT_TOKEN = 'GetLeagueSeasonsOutputPort_TOKEN';
export const JOIN_LEAGUE_OUTPUT_PORT_TOKEN = 'JoinLeagueOutputPort_TOKEN';
@@ -157,6 +184,8 @@ export const LeagueProviders: Provider[] = [
CreateLeaguePresenter,
GetLeagueAdminPermissionsPresenter,
GetLeagueMembershipsPresenter,
GetLeagueRosterMembersPresenter,
GetLeagueRosterJoinRequestsPresenter,
GetLeagueOwnerSummaryPresenter,
GetLeagueProtestsPresenter,
GetLeagueSeasonsPresenter,
@@ -177,6 +206,11 @@ export const LeagueProviders: Provider[] = [
TransferLeagueOwnershipPresenter,
UpdateLeagueMemberRolePresenter,
WithdrawFromLeagueWalletPresenter,
CreateLeagueSeasonScheduleRacePresenter,
UpdateLeagueSeasonScheduleRacePresenter,
DeleteLeagueSeasonScheduleRacePresenter,
PublishLeagueSeasonSchedulePresenter,
UnpublishLeagueSeasonSchedulePresenter,
// Output ports
{
provide: GET_ALL_LEAGUES_WITH_CAPACITY_OUTPUT_PORT_TOKEN,
@@ -218,6 +252,14 @@ export const LeagueProviders: Provider[] = [
provide: GET_LEAGUE_MEMBERSHIPS_OUTPUT_PORT_TOKEN,
useExisting: GetLeagueMembershipsPresenter,
},
{
provide: GET_LEAGUE_ROSTER_MEMBERS_OUTPUT_PORT_TOKEN,
useExisting: GetLeagueRosterMembersPresenter,
},
{
provide: GET_LEAGUE_ROSTER_JOIN_REQUESTS_OUTPUT_PORT_TOKEN,
useExisting: GetLeagueRosterJoinRequestsPresenter,
},
{
provide: GET_LEAGUE_OWNER_SUMMARY_OUTPUT_PORT_TOKEN,
useExisting: GetLeagueOwnerSummaryPresenter,
@@ -274,6 +316,29 @@ export const LeagueProviders: Provider[] = [
provide: WITHDRAW_FROM_LEAGUE_WALLET_OUTPUT_PORT_TOKEN,
useExisting: WithdrawFromLeagueWalletPresenter,
},
// Schedule mutation output ports
{
provide: LeagueTokens.CREATE_LEAGUE_SEASON_SCHEDULE_RACE_OUTPUT_PORT_TOKEN,
useExisting: CreateLeagueSeasonScheduleRacePresenter,
},
{
provide: LeagueTokens.UPDATE_LEAGUE_SEASON_SCHEDULE_RACE_OUTPUT_PORT_TOKEN,
useExisting: UpdateLeagueSeasonScheduleRacePresenter,
},
{
provide: LeagueTokens.DELETE_LEAGUE_SEASON_SCHEDULE_RACE_OUTPUT_PORT_TOKEN,
useExisting: DeleteLeagueSeasonScheduleRacePresenter,
},
{
provide: LeagueTokens.PUBLISH_LEAGUE_SEASON_SCHEDULE_OUTPUT_PORT_TOKEN,
useExisting: PublishLeagueSeasonSchedulePresenter,
},
{
provide: LeagueTokens.UNPUBLISH_LEAGUE_SEASON_SCHEDULE_OUTPUT_PORT_TOKEN,
useExisting: UnpublishLeagueSeasonSchedulePresenter,
},
// Use cases
{
provide: GET_ALL_LEAGUES_WITH_CAPACITY_USE_CASE,
@@ -346,23 +411,43 @@ export const LeagueProviders: Provider[] = [
},
{
provide: GET_LEAGUE_JOIN_REQUESTS_USE_CASE,
useClass: GetLeagueJoinRequestsUseCase,
useFactory: (
membershipRepo: ILeagueMembershipRepository,
driverRepo: IDriverRepository,
leagueRepo: ILeagueRepository,
output: LeagueJoinRequestsPresenter,
) => new GetLeagueJoinRequestsUseCase(membershipRepo, driverRepo, leagueRepo, output),
inject: [LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN, DRIVER_REPOSITORY_TOKEN, LEAGUE_REPOSITORY_TOKEN, LeagueJoinRequestsPresenter],
},
{
provide: APPROVE_LEAGUE_JOIN_REQUEST_USE_CASE,
useClass: ApproveLeagueJoinRequestUseCase,
useFactory: (
membershipRepo: ILeagueMembershipRepository,
leagueRepo: ILeagueRepository,
) => new ApproveLeagueJoinRequestUseCase(membershipRepo, leagueRepo),
inject: [LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN, LEAGUE_REPOSITORY_TOKEN],
},
{
provide: REJECT_LEAGUE_JOIN_REQUEST_USE_CASE,
useClass: RejectLeagueJoinRequestUseCase,
useFactory: (membershipRepo: ILeagueMembershipRepository) =>
new RejectLeagueJoinRequestUseCase(membershipRepo),
inject: [LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN],
},
{
provide: REMOVE_LEAGUE_MEMBER_USE_CASE,
useClass: RemoveLeagueMemberUseCase,
useFactory: (
membershipRepo: ILeagueMembershipRepository,
output: RemoveLeagueMemberPresenter,
) => new RemoveLeagueMemberUseCase(membershipRepo, output),
inject: [LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN, REMOVE_LEAGUE_MEMBER_OUTPUT_PORT_TOKEN],
},
{
provide: UPDATE_LEAGUE_MEMBER_ROLE_USE_CASE,
useClass: UpdateLeagueMemberRoleUseCase,
useFactory: (
membershipRepo: ILeagueMembershipRepository,
output: UpdateLeagueMemberRolePresenter,
) => new UpdateLeagueMemberRoleUseCase(membershipRepo, output),
inject: [LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN, UPDATE_LEAGUE_MEMBER_ROLE_OUTPUT_PORT_TOKEN],
},
{
provide: GET_LEAGUE_OWNER_SUMMARY_USE_CASE,
@@ -391,15 +476,75 @@ export const LeagueProviders: Provider[] = [
},
{
provide: GET_LEAGUE_MEMBERSHIPS_USE_CASE,
useClass: GetLeagueMembershipsUseCase,
useFactory: (
membershipRepo: ILeagueMembershipRepository,
driverRepo: IDriverRepository,
leagueRepo: ILeagueRepository,
output: GetLeagueMembershipsPresenter,
) => new GetLeagueMembershipsUseCase(membershipRepo, driverRepo, leagueRepo, output),
inject: [LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN, DRIVER_REPOSITORY_TOKEN, LEAGUE_REPOSITORY_TOKEN, GetLeagueMembershipsPresenter],
},
{
provide: GET_LEAGUE_ROSTER_MEMBERS_USE_CASE,
useFactory: (
membershipRepo: ILeagueMembershipRepository,
driverRepo: IDriverRepository,
leagueRepo: ILeagueRepository,
output: GetLeagueRosterMembersPresenter,
) => new GetLeagueRosterMembersUseCase(membershipRepo, driverRepo, leagueRepo, output),
inject: [
LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN,
DRIVER_REPOSITORY_TOKEN,
LEAGUE_REPOSITORY_TOKEN,
GET_LEAGUE_ROSTER_MEMBERS_OUTPUT_PORT_TOKEN,
],
},
{
provide: GET_LEAGUE_ROSTER_JOIN_REQUESTS_USE_CASE,
useFactory: (
membershipRepo: ILeagueMembershipRepository,
driverRepo: IDriverRepository,
leagueRepo: ILeagueRepository,
output: GetLeagueRosterJoinRequestsPresenter,
) => new GetLeagueRosterJoinRequestsUseCase(membershipRepo, driverRepo, leagueRepo, output),
inject: [
LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN,
DRIVER_REPOSITORY_TOKEN,
LEAGUE_REPOSITORY_TOKEN,
GET_LEAGUE_ROSTER_JOIN_REQUESTS_OUTPUT_PORT_TOKEN,
],
},
{
provide: GET_LEAGUE_SCHEDULE_USE_CASE,
useClass: GetLeagueScheduleUseCase,
useFactory: (
leagueRepo: ILeagueRepository,
seasonRepo: ISeasonRepository,
raceRepo: IRaceRepository,
logger: Logger,
output: LeagueSchedulePresenter,
) => new GetLeagueScheduleUseCase(leagueRepo, seasonRepo, raceRepo, logger, output),
inject: [
LEAGUE_REPOSITORY_TOKEN,
SEASON_REPOSITORY_TOKEN,
RACE_REPOSITORY_TOKEN,
LOGGER_TOKEN,
GET_LEAGUE_SCHEDULE_OUTPUT_PORT_TOKEN,
],
},
{
provide: GET_LEAGUE_ADMIN_PERMISSIONS_USE_CASE,
useClass: GetLeagueAdminPermissionsUseCase,
useFactory: (
leagueRepo: ILeagueRepository,
leagueMembershipRepo: ILeagueMembershipRepository,
logger: Logger,
output: GetLeagueAdminPermissionsPresenter,
) => new GetLeagueAdminPermissionsUseCase(leagueRepo, leagueMembershipRepo, logger, output),
inject: [
LEAGUE_REPOSITORY_TOKEN,
LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN,
LOGGER_TOKEN,
GET_LEAGUE_ADMIN_PERMISSIONS_OUTPUT_PORT_TOKEN,
],
},
{
provide: GET_LEAGUE_WALLET_USE_CASE,
@@ -468,7 +613,12 @@ export const LeagueProviders: Provider[] = [
},
{
provide: JOIN_LEAGUE_USE_CASE,
useClass: JoinLeagueUseCase,
useFactory: (
membershipRepo: ILeagueMembershipRepository,
logger: Logger,
output: JoinLeaguePresenter,
) => new JoinLeagueUseCase(membershipRepo, logger, output),
inject: [LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN, LOGGER_TOKEN, JoinLeaguePresenter],
},
{
provide: TRANSFER_LEAGUE_OWNERSHIP_USE_CASE,
@@ -477,5 +627,81 @@ export const LeagueProviders: Provider[] = [
{
provide: GET_LEAGUE_SCORING_CONFIG_USE_CASE,
useClass: GetLeagueScoringConfigUseCase,
}
},
// Schedule mutation use cases
{
provide: LeagueTokens.CREATE_LEAGUE_SEASON_SCHEDULE_RACE_USE_CASE,
useFactory: (
seasonRepo: ISeasonRepository,
raceRepo: IRaceRepository,
logger: Logger,
output: CreateLeagueSeasonScheduleRacePresenter,
) =>
new CreateLeagueSeasonScheduleRaceUseCase(seasonRepo, raceRepo, logger, output, {
generateRaceId: () => `race-${randomUUID()}`,
}),
inject: [
SEASON_REPOSITORY_TOKEN,
RACE_REPOSITORY_TOKEN,
LOGGER_TOKEN,
LeagueTokens.CREATE_LEAGUE_SEASON_SCHEDULE_RACE_OUTPUT_PORT_TOKEN,
],
},
{
provide: LeagueTokens.UPDATE_LEAGUE_SEASON_SCHEDULE_RACE_USE_CASE,
useFactory: (
seasonRepo: ISeasonRepository,
raceRepo: IRaceRepository,
logger: Logger,
output: UpdateLeagueSeasonScheduleRacePresenter,
) => new UpdateLeagueSeasonScheduleRaceUseCase(seasonRepo, raceRepo, logger, output),
inject: [
SEASON_REPOSITORY_TOKEN,
RACE_REPOSITORY_TOKEN,
LOGGER_TOKEN,
LeagueTokens.UPDATE_LEAGUE_SEASON_SCHEDULE_RACE_OUTPUT_PORT_TOKEN,
],
},
{
provide: LeagueTokens.DELETE_LEAGUE_SEASON_SCHEDULE_RACE_USE_CASE,
useFactory: (
seasonRepo: ISeasonRepository,
raceRepo: IRaceRepository,
logger: Logger,
output: DeleteLeagueSeasonScheduleRacePresenter,
) => new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepo, raceRepo, logger, output),
inject: [
SEASON_REPOSITORY_TOKEN,
RACE_REPOSITORY_TOKEN,
LOGGER_TOKEN,
LeagueTokens.DELETE_LEAGUE_SEASON_SCHEDULE_RACE_OUTPUT_PORT_TOKEN,
],
},
{
provide: LeagueTokens.PUBLISH_LEAGUE_SEASON_SCHEDULE_USE_CASE,
useFactory: (
seasonRepo: ISeasonRepository,
logger: Logger,
output: PublishLeagueSeasonSchedulePresenter,
) => new PublishLeagueSeasonScheduleUseCase(seasonRepo, logger, output),
inject: [
SEASON_REPOSITORY_TOKEN,
LOGGER_TOKEN,
LeagueTokens.PUBLISH_LEAGUE_SEASON_SCHEDULE_OUTPUT_PORT_TOKEN,
],
},
{
provide: LeagueTokens.UNPUBLISH_LEAGUE_SEASON_SCHEDULE_USE_CASE,
useFactory: (
seasonRepo: ISeasonRepository,
logger: Logger,
output: UnpublishLeagueSeasonSchedulePresenter,
) => new UnpublishLeagueSeasonScheduleUseCase(seasonRepo, logger, output),
inject: [
SEASON_REPOSITORY_TOKEN,
LOGGER_TOKEN,
LeagueTokens.UNPUBLISH_LEAGUE_SEASON_SCHEDULE_OUTPUT_PORT_TOKEN,
],
},
];

154
apps/api/src/domain/league/LeagueRosterAdminRead.http.test.ts Normal file
View File

@@ -0,0 +1,154 @@
import 'reflect-metadata';
import { ValidationPipe } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { Test } from '@nestjs/testing';
import request from 'supertest';
import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
import { requestContextMiddleware } from '@adapters/http/RequestContext';
import { AuthenticationGuard } from '../auth/AuthenticationGuard';
import { AuthorizationGuard } from '../auth/AuthorizationGuard';
import { IDENTITY_SESSION_PORT_TOKEN } from '../auth/AuthProviders';
import { FeatureAvailabilityGuard } from '../policy/FeatureAvailabilityGuard';
describe('League roster admin read (HTTP, league-scoped)', () => {
const originalEnv = { ...process.env };
let app: any;
beforeAll(async () => {
vi.resetModules();
process.env.GRIDPILOT_API_PERSISTENCE = 'inmemory';
process.env.GRIDPILOT_API_BOOTSTRAP = 'true';
delete process.env.DATABASE_URL;
const { AppModule } = await import('../../app.module');
const module = await Test.createTestingModule({
imports: [AppModule],
}).compile();
app = module.createNestApplication();
// Ensure AsyncLocalStorage request context is present for getActorFromRequestContext()
app.use(requestContextMiddleware);
app.useGlobalPipes(
new ValidationPipe({
whitelist: true,
forbidNonWhitelisted: true,
transform: true,
}),
);
const reflector = new Reflector();
const sessionPort = module.get(IDENTITY_SESSION_PORT_TOKEN);
const authorizationService = {
getRolesForUser: () => [],
};
const policyService = {
getSnapshot: async () => ({
policyVersion: 1,
operationalMode: 'normal',
maintenanceAllowlist: { view: [], mutate: [] },
capabilities: {},
loadedFrom: 'defaults',
loadedAtIso: new Date(0).toISOString(),
}),
};
app.useGlobalGuards(
new AuthenticationGuard(sessionPort as any),
new AuthorizationGuard(reflector, authorizationService as any),
new FeatureAvailabilityGuard(reflector, policyService as any),
);
await app.init();
}, 20_000);
afterAll(async () => {
await app?.close();
process.env = originalEnv;
vi.restoreAllMocks();
});
it('rejects unauthenticated actor (401)', async () => {
await request(app.getHttpServer()).get('/leagues/league-5/admin/roster/members').expect(401);
await request(app.getHttpServer()).get('/leagues/league-5/admin/roster/join-requests').expect(401);
});
it('rejects authenticated non-admin actor (403)', async () => {
const agent = request.agent(app.getHttpServer());
await agent
.post('/auth/signup')
.send({ email: 'roster-read-user@gridpilot.local', password: 'pw1', displayName: 'Roster Read User' })
.expect(201);
await agent.get('/leagues/league-5/admin/roster/members').expect(403);
await agent.get('/leagues/league-5/admin/roster/join-requests').expect(403);
});
it('returns roster members with stable fields (happy path)', async () => {
const agent = request.agent(app.getHttpServer());
await agent.post('/auth/login').send({ email: 'admin@gridpilot.local', password: 'admin123' }).expect(201);
const res = await agent.get('/leagues/league-5/admin/roster/members').expect(200);
expect(res.body).toEqual(expect.any(Array));
expect(res.body.length).toBeGreaterThan(0);
const first = res.body[0] as any;
expect(first).toMatchObject({
driverId: expect.any(String),
role: expect.any(String),
joinedAt: expect.any(String),
driver: expect.any(Object),
});
expect(first.driver).toMatchObject({
id: expect.any(String),
name: expect.any(String),
country: expect.any(String),
});
expect(['owner', 'admin', 'steward', 'member']).toContain(first.role);
});
it('returns join requests with stable fields (happy path)', async () => {
const adminAgent = request.agent(app.getHttpServer());
await adminAgent.post('/auth/login').send({ email: 'admin@gridpilot.local', password: 'admin123' }).expect(201);
const res = await adminAgent.get('/leagues/league-5/admin/roster/join-requests').expect(200);
expect(res.body).toEqual(expect.any(Array));
// Seed data may or may not include join requests for a given league.
// Validate shape on first item if present.
if ((res.body as any[]).length > 0) {
const first = (res.body as any[])[0];
expect(first).toMatchObject({
id: expect.any(String),
leagueId: expect.any(String),
driverId: expect.any(String),
requestedAt: expect.any(String),
driver: {
id: expect.any(String),
name: expect.any(String),
},
});
if (first.message !== undefined) {
expect(first.message).toEqual(expect.any(String));
}
}
});
});

269
apps/api/src/domain/league/LeagueRosterJoinRequests.mutations.http.test.ts Normal file
View File

@@ -0,0 +1,269 @@
import 'reflect-metadata';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { Test } from '@nestjs/testing';
import { Reflector } from '@nestjs/core';
import request from 'supertest';
import { ValidationPipe } from '@nestjs/common';
import { LeagueModule } from './LeagueModule';
import { AuthenticationGuard } from '../auth/AuthenticationGuard';
import { AuthorizationGuard } from '../auth/AuthorizationGuard';
import type { AuthorizationService } from '../auth/AuthorizationService';
import { requestContextMiddleware } from '@adapters/http/RequestContext';
import {
DRIVER_REPOSITORY_TOKEN,
LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN,
LEAGUE_REPOSITORY_TOKEN,
} from '../../persistence/inmemory/InMemoryRacingPersistenceModule';
import { League } from '@core/racing/domain/entities/League';
import { Driver } from '@core/racing/domain/entities/Driver';
import { JoinRequest } from '@core/racing/domain/entities/JoinRequest';
import { LeagueMembership } from '@core/racing/domain/entities/LeagueMembership';
describe('League roster join request mutations (HTTP)', () => {
let app: any;
const sessionPort: { getCurrentSession: () => Promise<null | { token: string; user: { id: string } }> } = {
getCurrentSession: vi.fn(async () => null),
};
const authorizationService: Pick<AuthorizationService, 'getRolesForUser'> = {
getRolesForUser: vi.fn(() => []),
};
async function seedLeagueWithJoinRequest(params: {
leagueId: string;
adminId: string;
requesterId: string;
joinRequestId: string;
maxDrivers?: number;
extraActiveMemberId?: string;
}): Promise<void> {
const leagueRepo = app.get(LEAGUE_REPOSITORY_TOKEN);
const driverRepo = app.get(DRIVER_REPOSITORY_TOKEN);
const membershipRepo = app.get(LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN);
await leagueRepo.create(
League.create({
id: params.leagueId,
name: 'Test League',
description: 'Test league',
ownerId: params.adminId,
settings: { visibility: 'unranked', ...(params.maxDrivers !== undefined ? { maxDrivers: params.maxDrivers } : {}) },
}),
);
await driverRepo.create(
Driver.create({
id: params.adminId,
iracingId: '1001',
name: 'Admin Driver',
country: 'DE',
}),
);
await driverRepo.create(
Driver.create({
id: params.requesterId,
iracingId: '1002',
name: 'Requester Driver',
country: 'DE',
}),
);
await membershipRepo.saveMembership(
LeagueMembership.create({
leagueId: params.leagueId,
driverId: params.adminId,
role: 'admin',
status: 'active',
}),
);
if (params.extraActiveMemberId) {
await driverRepo.create(
Driver.create({
id: params.extraActiveMemberId,
iracingId: '1003',
name: 'Extra Member',
country: 'DE',
}),
);
await membershipRepo.saveMembership(
LeagueMembership.create({
leagueId: params.leagueId,
driverId: params.extraActiveMemberId,
role: 'member',
status: 'active',
}),
);
}
await membershipRepo.saveJoinRequest(
JoinRequest.create({
id: params.joinRequestId,
leagueId: params.leagueId,
driverId: params.requesterId,
requestedAt: new Date('2025-01-01T12:00:00Z'),
message: 'please',
}),
);
}
beforeEach(async () => {
const module = await Test.createTestingModule({
imports: [LeagueModule],
}).compile();
app = module.createNestApplication();
// Required for getActorFromRequestContext() used by requireLeagueAdminOrOwner().
app.use(requestContextMiddleware as any);
// Test-only auth injection: emulate an authenticated session by setting request.user.
app.use((req: any, _res: any, next: any) => {
const userId = req.headers['x-test-user-id'];
if (typeof userId === 'string' && userId.length > 0) {
req.user = { userId };
}
next();
});
app.useGlobalPipes(
new ValidationPipe({
whitelist: true,
forbidNonWhitelisted: true,
transform: true,
}),
);
const reflector = new Reflector();
app.useGlobalGuards(
new AuthenticationGuard(sessionPort as any),
new AuthorizationGuard(reflector, authorizationService as any),
);
await app.init();
});
afterEach(async () => {
await app?.close();
vi.clearAllMocks();
});
it('returns 401 when unauthenticated', async () => {
await seedLeagueWithJoinRequest({
leagueId: 'league-1',
adminId: 'admin-1',
requesterId: 'driver-2',
joinRequestId: 'jr-1',
});
await request(app.getHttpServer())
.post('/leagues/league-1/admin/roster/join-requests/jr-1/approve')
.expect(401);
});
it('returns 403 when authenticated but not admin/owner', async () => {
await seedLeagueWithJoinRequest({
leagueId: 'league-1',
adminId: 'admin-1',
requesterId: 'driver-2',
joinRequestId: 'jr-1',
});
await request(app.getHttpServer())
.post('/leagues/league-1/admin/roster/join-requests/jr-1/approve')
.set('x-test-user-id', 'user-2')
.expect(403);
});
it('approve removes request and adds member; roster reads reflect changes', async () => {
await seedLeagueWithJoinRequest({
leagueId: 'league-1',
adminId: 'admin-1',
requesterId: 'driver-2',
joinRequestId: 'jr-1',
});
await request(app.getHttpServer())
.post('/leagues/league-1/admin/roster/join-requests/jr-1/approve')
.set('x-test-user-id', 'admin-1')
.expect(200);
const joinRequests = await request(app.getHttpServer())
.get('/leagues/league-1/admin/roster/join-requests')
.set('x-test-user-id', 'admin-1')
.expect(200);
expect(Array.isArray(joinRequests.body)).toBe(true);
expect(joinRequests.body.find((r: any) => r.id === 'jr-1')).toBeUndefined();
const members = await request(app.getHttpServer())
.get('/leagues/league-1/admin/roster/members')
.set('x-test-user-id', 'admin-1')
.expect(200);
expect(Array.isArray(members.body)).toBe(true);
expect(members.body.some((m: any) => m.driverId === 'driver-2')).toBe(true);
});
it('reject removes request only; roster reads reflect changes', async () => {
await seedLeagueWithJoinRequest({
leagueId: 'league-1',
adminId: 'admin-1',
requesterId: 'driver-2',
joinRequestId: 'jr-1',
});
await request(app.getHttpServer())
.post('/leagues/league-1/admin/roster/join-requests/jr-1/reject')
.set('x-test-user-id', 'admin-1')
.expect(200);
const joinRequests = await request(app.getHttpServer())
.get('/leagues/league-1/admin/roster/join-requests')
.set('x-test-user-id', 'admin-1')
.expect(200);
expect(Array.isArray(joinRequests.body)).toBe(true);
expect(joinRequests.body.find((r: any) => r.id === 'jr-1')).toBeUndefined();
const members = await request(app.getHttpServer())
.get('/leagues/league-1/admin/roster/members')
.set('x-test-user-id', 'admin-1')
.expect(200);
expect(Array.isArray(members.body)).toBe(true);
expect(members.body.some((m: any) => m.driverId === 'driver-2')).toBe(false);
});
it('approve returns error when league is full and keeps request pending', async () => {
await seedLeagueWithJoinRequest({
leagueId: 'league-1',
adminId: 'admin-1',
requesterId: 'driver-2',
joinRequestId: 'jr-1',
maxDrivers: 2,
extraActiveMemberId: 'driver-3',
});
await request(app.getHttpServer())
.post('/leagues/league-1/admin/roster/join-requests/jr-1/approve')
.set('x-test-user-id', 'admin-1')
.expect(409);
const joinRequests = await request(app.getHttpServer())
.get('/leagues/league-1/admin/roster/join-requests')
.set('x-test-user-id', 'admin-1')
.expect(200);
expect(Array.isArray(joinRequests.body)).toBe(true);
expect(joinRequests.body.find((r: any) => r.id === 'jr-1')).toBeDefined();
});
});

197
apps/api/src/domain/league/LeagueRosterMembers.mutations.http.test.ts Normal file
View File

@@ -0,0 +1,197 @@
import 'reflect-metadata';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { Test } from '@nestjs/testing';
import { Reflector } from '@nestjs/core';
import request from 'supertest';
import { ValidationPipe } from '@nestjs/common';
import { LeagueModule } from './LeagueModule';
import { AuthenticationGuard } from '../auth/AuthenticationGuard';
import { AuthorizationGuard } from '../auth/AuthorizationGuard';
import type { AuthorizationService } from '../auth/AuthorizationService';
import { requestContextMiddleware } from '@adapters/http/RequestContext';
import {
DRIVER_REPOSITORY_TOKEN,
LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN,
LEAGUE_REPOSITORY_TOKEN,
} from '../../persistence/inmemory/InMemoryRacingPersistenceModule';
import { League } from '@core/racing/domain/entities/League';
import { Driver } from '@core/racing/domain/entities/Driver';
import { LeagueMembership } from '@core/racing/domain/entities/LeagueMembership';
describe('League roster member mutations (HTTP)', () => {
let app: any;
const sessionPort: { getCurrentSession: () => Promise<null | { token: string; user: { id: string } }> } = {
getCurrentSession: vi.fn(async () => null),
};
const authorizationService: Pick<AuthorizationService, 'getRolesForUser'> = {
getRolesForUser: vi.fn(() => []),
};
async function seedLeagueWithMembers(params: {
leagueId: string;
adminId: string;
memberId: string;
}): Promise<void> {
const leagueRepo = app.get(LEAGUE_REPOSITORY_TOKEN);
const driverRepo = app.get(DRIVER_REPOSITORY_TOKEN);
const membershipRepo = app.get(LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN);
await leagueRepo.create(
League.create({
id: params.leagueId,
name: 'Test League',
description: 'Test league',
ownerId: params.adminId,
settings: { visibility: 'unranked' },
}),
);
await driverRepo.create(
Driver.create({
id: params.adminId,
iracingId: '2001',
name: 'Admin Driver',
country: 'DE',
}),
);
await driverRepo.create(
Driver.create({
id: params.memberId,
iracingId: '2002',
name: 'Member Driver',
country: 'DE',
}),
);
await membershipRepo.saveMembership(
LeagueMembership.create({
leagueId: params.leagueId,
driverId: params.adminId,
role: 'admin',
status: 'active',
}),
);
await membershipRepo.saveMembership(
LeagueMembership.create({
leagueId: params.leagueId,
driverId: params.memberId,
role: 'member',
status: 'active',
}),
);
}
beforeEach(async () => {
const module = await Test.createTestingModule({
imports: [LeagueModule],
}).compile();
app = module.createNestApplication();
// Required for getActorFromRequestContext() used by requireLeagueAdminOrOwner().
app.use(requestContextMiddleware as any);
// Test-only auth injection: emulate an authenticated session by setting request.user.
app.use((req: any, _res: any, next: any) => {
const userId = req.headers['x-test-user-id'];
if (typeof userId === 'string' && userId.length > 0) {
req.user = { userId };
}
next();
});
app.useGlobalPipes(
new ValidationPipe({
whitelist: true,
forbidNonWhitelisted: true,
transform: true,
}),
);
const reflector = new Reflector();
app.useGlobalGuards(
new AuthenticationGuard(sessionPort as any),
new AuthorizationGuard(reflector, authorizationService as any),
);
await app.init();
});
afterEach(async () => {
await app?.close();
vi.clearAllMocks();
});
it('returns 401 when unauthenticated (role change + removal)', async () => {
await seedLeagueWithMembers({ leagueId: 'league-1', adminId: 'admin-1', memberId: 'driver-2' });
await request(app.getHttpServer())
.patch('/leagues/league-1/admin/roster/members/driver-2/role')
.send({ newRole: 'steward' })
.expect(401);
await request(app.getHttpServer()).patch('/leagues/league-1/admin/roster/members/driver-2/remove').expect(401);
});
it('returns 403 when authenticated but not admin/owner (role change + removal)', async () => {
await seedLeagueWithMembers({ leagueId: 'league-1', adminId: 'admin-1', memberId: 'driver-2' });
await request(app.getHttpServer())
.patch('/leagues/league-1/admin/roster/members/driver-2/role')
.set('x-test-user-id', 'user-2')
.send({ newRole: 'steward' })
.expect(403);
await request(app.getHttpServer())
.patch('/leagues/league-1/admin/roster/members/driver-2/remove')
.set('x-test-user-id', 'user-2')
.expect(403);
});
it('role change is reflected in roster members read', async () => {
await seedLeagueWithMembers({ leagueId: 'league-1', adminId: 'admin-1', memberId: 'driver-2' });
await request(app.getHttpServer())
.patch('/leagues/league-1/admin/roster/members/driver-2/role')
.set('x-test-user-id', 'admin-1')
.send({ newRole: 'steward' })
.expect(200);
const members = await request(app.getHttpServer())
.get('/leagues/league-1/admin/roster/members')
.set('x-test-user-id', 'admin-1')
.expect(200);
expect(Array.isArray(members.body)).toBe(true);
const updated = (members.body as any[]).find(m => m.driverId === 'driver-2');
expect(updated).toBeDefined();
expect(updated.role).toBe('steward');
});
it('member removal is reflected in roster members read', async () => {
await seedLeagueWithMembers({ leagueId: 'league-1', adminId: 'admin-1', memberId: 'driver-2' });
await request(app.getHttpServer())
.patch('/leagues/league-1/admin/roster/members/driver-2/remove')
.set('x-test-user-id', 'admin-1')
.expect(200);
const members = await request(app.getHttpServer())
.get('/leagues/league-1/admin/roster/members')
.set('x-test-user-id', 'admin-1')
.expect(200);
expect(Array.isArray(members.body)).toBe(true);
expect((members.body as any[]).some(m => m.driverId === 'driver-2')).toBe(false);
});
});

191
apps/api/src/domain/league/LeagueScheduleAdmin.http.test.ts Normal file
View File

@@ -0,0 +1,191 @@
import 'reflect-metadata';
import { ValidationPipe } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { Test } from '@nestjs/testing';
import request from 'supertest';
import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
import { requestContextMiddleware } from '@adapters/http/RequestContext';
import { AuthenticationGuard } from '../auth/AuthenticationGuard';
import { AuthorizationGuard } from '../auth/AuthorizationGuard';
import { IDENTITY_SESSION_PORT_TOKEN } from '../auth/AuthProviders';
import { FeatureAvailabilityGuard } from '../policy/FeatureAvailabilityGuard';
describe('League schedule admin CRUD (HTTP, season-scoped)', () => {
const originalEnv = { ...process.env };
let app: any;
beforeAll(async () => {
vi.resetModules();
process.env.GRIDPILOT_API_PERSISTENCE = 'inmemory';
process.env.GRIDPILOT_API_BOOTSTRAP = 'true';
delete process.env.DATABASE_URL;
const { AppModule } = await import('../../app.module');
const module = await Test.createTestingModule({
imports: [AppModule],
}).compile();
app = module.createNestApplication();
// Ensure AsyncLocalStorage request context is present for getActorFromRequestContext()
app.use(requestContextMiddleware);
app.useGlobalPipes(
new ValidationPipe({
whitelist: true,
forbidNonWhitelisted: true,
transform: true,
}),
);
const reflector = new Reflector();
const sessionPort = module.get(IDENTITY_SESSION_PORT_TOKEN);
const authorizationService = {
getRolesForUser: () => [],
};
const policyService = {
getSnapshot: async () => ({
policyVersion: 1,
operationalMode: 'normal',
maintenanceAllowlist: { view: [], mutate: [] },
capabilities: {},
loadedFrom: 'defaults',
loadedAtIso: new Date(0).toISOString(),
}),
};
app.useGlobalGuards(
new AuthenticationGuard(sessionPort as any),
new AuthorizationGuard(reflector, authorizationService as any),
new FeatureAvailabilityGuard(reflector, policyService as any),
);
await app.init();
}, 20_000);
afterAll(async () => {
await app?.close();
process.env = originalEnv;
vi.restoreAllMocks();
});
it('rejects unauthenticated actor (401)', async () => {
await request(app.getHttpServer())
.post('/leagues/league-5/seasons/season-1/schedule/races')
.send({
track: 'Test Track',
car: 'Test Car',
scheduledAtIso: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
})
.expect(401);
});
it('rejects authenticated non-admin actor (403)', async () => {
const agent = request.agent(app.getHttpServer());
await agent
.post('/auth/signup')
.send({ email: 'user1@gridpilot.local', password: 'pw1', displayName: 'User 1' })
.expect(201);
await agent
.post('/leagues/league-5/seasons/season-1/schedule/races')
.send({
track: 'Test Track',
car: 'Test Car',
scheduledAtIso: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
})
.expect(403);
});
it('rejects payload identity spoofing (400)', async () => {
const agent = request.agent(app.getHttpServer());
await agent
.post('/auth/login')
.send({ email: 'admin@gridpilot.local', password: 'admin123' })
.expect(201);
await agent
.post('/leagues/league-5/seasons/season-1/schedule/races')
.send({
track: 'Test Track',
car: 'Test Car',
scheduledAtIso: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
performerDriverId: 'driver-1',
})
.expect(400);
});
it('create/update/delete changes schedule read for the same season (happy path)', async () => {
const agent = request.agent(app.getHttpServer());
await agent
.post('/auth/login')
.send({ email: 'admin@gridpilot.local', password: 'admin123' })
.expect(201);
const initialScheduleRes = await agent.get('/leagues/league-5/schedule?seasonId=season-1').expect(200);
expect(initialScheduleRes.body).toMatchObject({ seasonId: 'season-1', races: expect.any(Array) });
const scheduledAtIso = new Date(Date.now() + 2 * 24 * 60 * 60 * 1000).toISOString();
const createRes = await agent
.post('/leagues/league-5/seasons/season-1/schedule/races')
.send({
track: 'Test Track',
car: 'Test Car',
scheduledAtIso,
})
.expect(201);
expect(createRes.body).toMatchObject({ raceId: expect.any(String) });
const raceId: string = createRes.body.raceId;
const afterCreateRes = await agent.get('/leagues/league-5/schedule?seasonId=season-1').expect(200);
const createdRace = (afterCreateRes.body.races as any[]).find((r) => r.id === raceId);
expect(createdRace).toMatchObject({
id: raceId,
name: 'Test Track - Test Car',
date: scheduledAtIso,
});
const updatedAtIso = new Date(Date.now() + 3 * 24 * 60 * 60 * 1000).toISOString();
await agent
.patch(`/leagues/league-5/seasons/season-1/schedule/races/${raceId}`)
.send({
track: 'Updated Track',
car: 'Updated Car',
scheduledAtIso: updatedAtIso,
})
.expect(200)
.expect((res) => {
expect(res.body).toEqual({ success: true });
});
const afterUpdateRes = await agent.get('/leagues/league-5/schedule?seasonId=season-1').expect(200);
const updatedRace = (afterUpdateRes.body.races as any[]).find((r) => r.id === raceId);
expect(updatedRace).toMatchObject({
id: raceId,
name: 'Updated Track - Updated Car',
date: updatedAtIso,
});
await agent.delete(`/leagues/league-5/seasons/season-1/schedule/races/${raceId}`).expect(200).expect({
success: true,
});
const afterDeleteRes = await agent.get('/leagues/league-5/schedule?seasonId=season-1').expect(200);
const deletedRace = (afterDeleteRes.body.races as any[]).find((r) => r.id === raceId);
expect(deletedRace).toBeUndefined();
});
});

149
apps/api/src/domain/league/LeagueSchedulePublish.http.test.ts Normal file
View File

@@ -0,0 +1,149 @@
import 'reflect-metadata';
import { ValidationPipe } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { Test } from '@nestjs/testing';
import request from 'supertest';
import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
import { requestContextMiddleware } from '@adapters/http/RequestContext';
import { AuthenticationGuard } from '../auth/AuthenticationGuard';
import { AuthorizationGuard } from '../auth/AuthorizationGuard';
import { IDENTITY_SESSION_PORT_TOKEN } from '../auth/AuthProviders';
import { FeatureAvailabilityGuard } from '../policy/FeatureAvailabilityGuard';
describe('League season schedule publish/unpublish (HTTP, season-scoped)', () => {
const originalEnv = { ...process.env };
let app: any;
beforeAll(async () => {
vi.resetModules();
process.env.GRIDPILOT_API_PERSISTENCE = 'inmemory';
process.env.GRIDPILOT_API_BOOTSTRAP = 'true';
delete process.env.DATABASE_URL;
const { AppModule } = await import('../../app.module');
const module = await Test.createTestingModule({
imports: [AppModule],
}).compile();
app = module.createNestApplication();
// Ensure AsyncLocalStorage request context is present for getActorFromRequestContext()
app.use(requestContextMiddleware);
app.useGlobalPipes(
new ValidationPipe({
whitelist: true,
forbidNonWhitelisted: true,
transform: true,
}),
);
const reflector = new Reflector();
const sessionPort = module.get(IDENTITY_SESSION_PORT_TOKEN);
const authorizationService = {
getRolesForUser: () => [],
};
const policyService = {
getSnapshot: async () => ({
policyVersion: 1,
operationalMode: 'normal',
maintenanceAllowlist: { view: [], mutate: [] },
capabilities: {},
loadedFrom: 'defaults',
loadedAtIso: new Date(0).toISOString(),
}),
};
app.useGlobalGuards(
new AuthenticationGuard(sessionPort as any),
new AuthorizationGuard(reflector, authorizationService as any),
new FeatureAvailabilityGuard(reflector, policyService as any),
);
await app.init();
}, 20_000);
afterAll(async () => {
await app?.close();
process.env = originalEnv;
vi.restoreAllMocks();
});
it('rejects unauthenticated actor (401)', async () => {
await request(app.getHttpServer())
.post('/leagues/league-5/seasons/season-1/schedule/publish')
.send({})
.expect(401);
await request(app.getHttpServer())
.post('/leagues/league-5/seasons/season-1/schedule/unpublish')
.send({})
.expect(401);
});
it('rejects authenticated non-admin actor (403)', async () => {
const agent = request.agent(app.getHttpServer());
await agent
.post('/auth/signup')
.send({ email: 'user2@gridpilot.local', password: 'pw2', displayName: 'User 2' })
.expect(201);
await agent.post('/leagues/league-5/seasons/season-1/schedule/publish').send({}).expect(403);
await agent.post('/leagues/league-5/seasons/season-1/schedule/unpublish').send({}).expect(403);
});
it('publish/unpublish toggles state and is reflected via schedule read (happy path)', async () => {
const agent = request.agent(app.getHttpServer());
await agent
.post('/auth/login')
.send({ email: 'admin@gridpilot.local', password: 'admin123' })
.expect(201);
const initialScheduleRes = await agent.get('/leagues/league-5/schedule?seasonId=season-1').expect(200);
expect(initialScheduleRes.body).toMatchObject({
seasonId: 'season-1',
published: false,
races: expect.any(Array),
});
await agent
.post('/leagues/league-5/seasons/season-1/schedule/publish')
.send({})
.expect(200)
.expect((res) => {
expect(res.body).toEqual({ success: true, published: true });
});
const afterPublishRes = await agent.get('/leagues/league-5/schedule?seasonId=season-1').expect(200);
expect(afterPublishRes.body).toMatchObject({
seasonId: 'season-1',
published: true,
races: expect.any(Array),
});
await agent
.post('/leagues/league-5/seasons/season-1/schedule/unpublish')
.send({})
.expect(200)
.expect((res) => {
expect(res.body).toEqual({ success: true, published: false });
});
const afterUnpublishRes = await agent.get('/leagues/league-5/schedule?seasonId=season-1').expect(200);
expect(afterUnpublishRes.body).toMatchObject({
seasonId: 'season-1',
published: false,
races: expect.any(Array),
});
});
});

298
apps/api/src/domain/league/LeagueService.test.ts
View File

@@ -1,7 +1,19 @@
import { describe, expect, it, vi } from 'vitest';
import { Result } from '@core/shared/application/Result';
import { requestContextMiddleware } from '@adapters/http/RequestContext';
import { LeagueService } from './LeagueService';
async function withUserId<T>(userId: string, fn: () => Promise<T>): Promise<T> {
const req = { user: { userId } };
const res = {};
return await new Promise<T>((resolve, reject) => {
requestContextMiddleware(req as any, res as any, () => {
fn().then(resolve, reject);
});
});
}
describe('LeagueService', () => {
it('covers LeagueService happy paths and error branches', async () => {
const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
@@ -35,6 +47,16 @@ describe('LeagueService', () => {
const withdrawFromLeagueWalletUseCase = { execute: vi.fn(ok) };
const getSeasonSponsorshipsUseCase = { execute: vi.fn(ok) };
const getLeagueRosterMembersUseCase = { execute: vi.fn(ok) };
const getLeagueRosterJoinRequestsUseCase = { execute: vi.fn(ok) };
// Schedule mutation use cases (must be called by LeagueService, not repositories)
const createLeagueSeasonScheduleRaceUseCase = { execute: vi.fn(ok) };
const updateLeagueSeasonScheduleRaceUseCase = { execute: vi.fn(ok) };
const deleteLeagueSeasonScheduleRaceUseCase = { execute: vi.fn(ok) };
const publishLeagueSeasonScheduleUseCase = { execute: vi.fn(ok) };
const unpublishLeagueSeasonScheduleUseCase = { execute: vi.fn(ok) };
const allLeaguesWithCapacityPresenter = { present: vi.fn(), getViewModel: vi.fn(() => ({ leagues: [] })) };
const allLeaguesWithCapacityAndScoringPresenter = {
present: vi.fn(),
@@ -47,11 +69,26 @@ describe('LeagueService', () => {
const approveLeagueJoinRequestPresenter = { getViewModel: vi.fn(() => ({ success: true })) };
const createLeaguePresenter = { getViewModel: vi.fn(() => ({ id: 'l1' })) };
const getLeagueAdminPermissionsPresenter = { getResponseModel: vi.fn(() => ({ canManage: true })) };
const getLeagueMembershipsPresenter = { getViewModel: vi.fn(() => ({ memberships: { memberships: [] } })) };
const getLeagueMembershipsPresenter = {
reset: vi.fn(),
getViewModel: vi.fn(() => ({ memberships: { memberships: [] } })),
};
const getLeagueRosterMembersPresenter = {
reset: vi.fn(),
present: vi.fn(),
getViewModel: vi.fn(() => ([])),
};
const getLeagueRosterJoinRequestsPresenter = {
reset: vi.fn(),
present: vi.fn(),
getViewModel: vi.fn(() => ([])),
};
const getLeagueOwnerSummaryPresenter = { getViewModel: vi.fn(() => ({ ownerId: 'o1' })) };
const getLeagueSeasonsPresenter = { getResponseModel: vi.fn(() => ([])) };
const joinLeaguePresenter = { getViewModel: vi.fn(() => ({ success: true })) };
const leagueSchedulePresenter = { getViewModel: vi.fn(() => ({ schedule: [] })) };
const leagueSchedulePresenter = { getViewModel: vi.fn(() => ({ seasonId: 'season-1', published: false, races: [] })) };
const leagueStatsPresenter = { getResponseModel: vi.fn(() => ({ stats: {} })) };
const rejectLeagueJoinRequestPresenter = { getViewModel: vi.fn(() => ({ success: true })) };
const removeLeagueMemberPresenter = { getViewModel: vi.fn(() => ({ success: true })) };
@@ -65,7 +102,13 @@ describe('LeagueService', () => {
const leagueJoinRequestsPresenter = { getViewModel: vi.fn(() => ({ joinRequests: [] })) };
const leagueRacesPresenter = { getViewModel: vi.fn(() => ([])) };
const service = new LeagueService(
const createLeagueSeasonScheduleRacePresenter = { getResponseModel: vi.fn(() => ({ raceId: 'race-1' })) };
const updateLeagueSeasonScheduleRacePresenter = { getResponseModel: vi.fn(() => ({ success: true })) };
const deleteLeagueSeasonScheduleRacePresenter = { getResponseModel: vi.fn(() => ({ success: true })) };
const publishLeagueSeasonSchedulePresenter = { getResponseModel: vi.fn(() => ({ success: true, published: true })) };
const unpublishLeagueSeasonSchedulePresenter = { getResponseModel: vi.fn(() => ({ success: true, published: false })) };
const service = new (LeagueService as any)(
getAllLeaguesWithCapacityUseCase as any,
getAllLeaguesWithCapacityAndScoringUseCase as any,
getLeagueStandingsUseCase as any,
@@ -91,6 +134,11 @@ describe('LeagueService', () => {
getLeagueWalletUseCase as any,
withdrawFromLeagueWalletUseCase as any,
getSeasonSponsorshipsUseCase as any,
createLeagueSeasonScheduleRaceUseCase as any,
updateLeagueSeasonScheduleRaceUseCase as any,
deleteLeagueSeasonScheduleRaceUseCase as any,
publishLeagueSeasonScheduleUseCase as any,
unpublishLeagueSeasonScheduleUseCase as any,
logger as any,
allLeaguesWithCapacityPresenter as any,
allLeaguesWithCapacityAndScoringPresenter as any,
@@ -118,17 +166,77 @@ describe('LeagueService', () => {
withdrawFromLeagueWalletPresenter as any,
leagueJoinRequestsPresenter as any,
leagueRacesPresenter as any,
createLeagueSeasonScheduleRacePresenter as any,
updateLeagueSeasonScheduleRacePresenter as any,
deleteLeagueSeasonScheduleRacePresenter as any,
publishLeagueSeasonSchedulePresenter as any,
unpublishLeagueSeasonSchedulePresenter as any,
// Roster admin read delegation (added for strict TDD)
getLeagueRosterMembersUseCase as any,
getLeagueRosterJoinRequestsUseCase as any,
getLeagueRosterMembersPresenter as any,
getLeagueRosterJoinRequestsPresenter as any,
);
await expect(service.getTotalLeagues()).resolves.toEqual({ total: 1 });
await expect(service.getLeagueJoinRequests('l1')).resolves.toEqual([]);
await withUserId('user-1', async () => {
await expect(service.getLeagueJoinRequests('l1')).resolves.toEqual([]);
});
await expect(service.approveLeagueJoinRequest({ leagueId: 'l1', requestId: 'r1' } as any)).resolves.toEqual({ success: true });
await expect(service.rejectLeagueJoinRequest({ leagueId: 'l1', requestId: 'r1' } as any)).resolves.toEqual({ success: true });
await withUserId('user-1', async () => {
await expect(service.approveLeagueJoinRequest({ leagueId: 'l1', requestId: 'r1' } as any)).resolves.toEqual({
success: true,
});
});
await expect(service.getLeagueAdminPermissions({ leagueId: 'l1' } as any)).resolves.toEqual({ canManage: true });
await expect(service.removeLeagueMember({ leagueId: 'l1', targetDriverId: 'd1' } as any)).resolves.toEqual({ success: true });
await expect(service.updateLeagueMemberRole({ leagueId: 'l1', targetDriverId: 'd1', newRole: 'member' } as any)).resolves.toEqual({ success: true });
await withUserId('user-1', async () => {
await expect(service.rejectLeagueJoinRequest({ leagueId: 'l1', requestId: 'r1' } as any)).resolves.toEqual({
success: true,
});
});
expect(rejectLeagueJoinRequestUseCase.execute).toHaveBeenCalledWith(
{ leagueId: 'l1', joinRequestId: 'r1' },
rejectLeagueJoinRequestPresenter,
);
await withUserId('user-1', async () => {
await expect(service.getLeagueAdminPermissions({ leagueId: 'l1' } as any)).resolves.toEqual({ canManage: true });
});
await withUserId('user-1', async () => {
await expect(service.removeLeagueMember({ leagueId: 'l1', targetDriverId: 'd1' } as any)).resolves.toEqual({
success: true,
});
});
expect(getLeagueAdminPermissionsUseCase.execute).toHaveBeenCalledWith({
leagueId: 'l1',
performerDriverId: 'user-1',
});
expect(removeLeagueMemberUseCase.execute).toHaveBeenCalledWith({
leagueId: 'l1',
targetDriverId: 'd1',
});
await withUserId('user-1', async () => {
await expect(service.updateLeagueMemberRole('l1', 'd1', { newRole: 'member' } as any)).resolves.toEqual({
success: true,
});
});
expect(getLeagueAdminPermissionsUseCase.execute).toHaveBeenCalledWith({
leagueId: 'l1',
performerDriverId: 'user-1',
});
expect(updateLeagueMemberRoleUseCase.execute).toHaveBeenCalledWith({
leagueId: 'l1',
targetDriverId: 'd1',
newRole: 'member',
});
await expect(service.getLeagueOwnerSummary({ leagueId: 'l1' } as any)).resolves.toEqual({ ownerId: 'o1' });
await expect(service.getLeagueProtests({ leagueId: 'l1' } as any)).resolves.toEqual({ protests: [] });
@@ -138,21 +246,165 @@ describe('LeagueService', () => {
await expect(service.getLeagueScoringConfig('l1')).resolves.toEqual({ config: {} });
await expect(service.getLeagueMemberships('l1')).resolves.toEqual({ memberships: [] });
// Roster admin read endpoints must delegate to core use cases (tests fail until refactor)
await withUserId('user-1', async () => {
await service.getLeagueRosterMembers('l1');
});
expect(getLeagueRosterMembersUseCase.execute).toHaveBeenCalledWith({ leagueId: 'l1' });
expect(getLeagueRosterMembersPresenter.reset).toHaveBeenCalled();
await withUserId('user-1', async () => {
await service.getLeagueRosterJoinRequests('l1');
});
expect(getLeagueRosterJoinRequestsUseCase.execute).toHaveBeenCalledWith({ leagueId: 'l1' });
expect(getLeagueRosterJoinRequestsPresenter.reset).toHaveBeenCalled();
// Roster admin read endpoints must be admin-gated (auth boundary) and must not execute core use cases on 403.
getLeagueAdminPermissionsUseCase.execute.mockResolvedValueOnce(
Result.err({ code: 'FORBIDDEN', details: { message: 'nope' } }) as any,
);
getLeagueRosterMembersUseCase.execute.mockClear();
await withUserId('user-2', async () => {
await expect(service.getLeagueRosterMembers('l1')).rejects.toThrow('Forbidden');
});
expect(getLeagueRosterMembersUseCase.execute).not.toHaveBeenCalled();
await expect(service.getLeagueStandings('l1')).resolves.toEqual({ standings: [] });
await expect(service.getLeagueSchedule('l1')).resolves.toEqual({ schedule: [] });
await expect(service.getLeagueSchedule('l1')).resolves.toEqual({ seasonId: 'season-1', published: false, races: [] });
expect(getLeagueScheduleUseCase.execute).toHaveBeenCalledWith({ leagueId: 'l1' });
getLeagueScheduleUseCase.execute.mockClear();
await expect(service.getLeagueSchedule('l1', { seasonId: 'season-x' } as any)).resolves.toEqual({
seasonId: 'season-1',
published: false,
races: [],
});
expect(getLeagueScheduleUseCase.execute).toHaveBeenCalledWith({ leagueId: 'l1', seasonId: 'season-x' });
await expect(service.getLeagueStats('l1')).resolves.toEqual({ stats: {} });
await expect(service.createLeague({ name: 'n', description: 'd', ownerId: 'o' } as any)).resolves.toEqual({ id: 'l1' });
await expect(service.listLeagueScoringPresets()).resolves.toEqual({ presets: [] });
await expect(service.joinLeague('l1', 'd1')).resolves.toEqual({ success: true });
await expect(service.transferLeagueOwnership('l1', 'o1', 'o2')).resolves.toEqual({ success: true });
await withUserId('user-1', async () => {
await expect(service.joinLeague('l1')).resolves.toEqual({ success: true });
});
await withUserId('user-1', async () => {
await expect(service.transferLeagueOwnership('l1', { newOwnerId: 'o2' } as any)).resolves.toEqual({ success: true });
});
// Transfer ownership must be admin-gated and actor-derived (no payload owner/admin IDs)
getLeagueAdminPermissionsUseCase.execute.mockClear();
transferLeagueOwnershipUseCase.execute.mockClear();
await withUserId('user-1', async () => {
await expect(
service.transferLeagueOwnership('l1', { newOwnerId: 'o2', currentOwnerId: 'spoof' } as any),
).resolves.toEqual({ success: true });
});
expect(getLeagueAdminPermissionsUseCase.execute).toHaveBeenCalledWith({
leagueId: 'l1',
performerDriverId: 'user-1',
});
expect(transferLeagueOwnershipUseCase.execute).toHaveBeenCalledWith({
leagueId: 'l1',
currentOwnerId: 'user-1',
newOwnerId: 'o2',
});
// Unauthorized (non-admin/owner) actors are rejected
getLeagueAdminPermissionsUseCase.execute.mockResolvedValueOnce(
Result.err({ code: 'FORBIDDEN', details: { message: 'nope' } }) as any,
);
transferLeagueOwnershipUseCase.execute.mockClear();
await withUserId('user-2', async () => {
await expect(service.transferLeagueOwnership('l1', { newOwnerId: 'o2' } as any)).rejects.toThrow('Forbidden');
});
expect(transferLeagueOwnershipUseCase.execute).not.toHaveBeenCalled();
// Actor must be derived from session (request context), not payload arguments.
joinLeagueUseCase.execute.mockClear();
await withUserId('user-1', async () => {
await expect(service.joinLeague('l1')).resolves.toEqual({ success: true });
});
expect(joinLeagueUseCase.execute).toHaveBeenCalledWith({ leagueId: 'l1', driverId: 'user-1' });
await expect(service.getSeasonSponsorships('s1')).resolves.toEqual({ sponsorships: [] });
await expect(service.getRaces('l1')).resolves.toEqual({ races: [] });
await expect(service.getLeagueWallet('l1')).resolves.toEqual({ balance: 0 });
await expect(service.withdrawFromLeagueWallet('l1', { amount: 1, currency: 'USD', destinationAccount: 'x' } as any)).resolves.toEqual({
success: true,
await withUserId('user-1', async () => {
await expect(
service.publishLeagueSeasonSchedule('l1', 'season-1', {} as any),
).resolves.toEqual({ success: true, published: true });
await expect(
service.unpublishLeagueSeasonSchedule('l1', 'season-1', {} as any),
).resolves.toEqual({ success: true, published: false });
await expect(
service.createLeagueSeasonScheduleRace('l1', 'season-1', {
track: 'Spa',
car: 'GT3',
scheduledAtIso: new Date('2025-01-10T20:00:00Z').toISOString(),
} as any),
).resolves.toEqual({ raceId: 'race-1' });
await expect(
service.updateLeagueSeasonScheduleRace('l1', 'season-1', 'race-1', {
track: 'Monza',
car: 'LMP2',
} as any),
).resolves.toEqual({ success: true });
await expect(
service.deleteLeagueSeasonScheduleRace('l1', 'season-1', 'race-1'),
).resolves.toEqual({ success: true });
});
expect(publishLeagueSeasonScheduleUseCase.execute).toHaveBeenCalledWith({ leagueId: 'l1', seasonId: 'season-1' });
expect(unpublishLeagueSeasonScheduleUseCase.execute).toHaveBeenCalledWith({ leagueId: 'l1', seasonId: 'season-1' });
expect(createLeagueSeasonScheduleRaceUseCase.execute).toHaveBeenCalledWith({
leagueId: 'l1',
seasonId: 'season-1',
track: 'Spa',
car: 'GT3',
scheduledAt: expect.any(Date),
});
expect(updateLeagueSeasonScheduleRaceUseCase.execute).toHaveBeenCalledWith({
leagueId: 'l1',
seasonId: 'season-1',
raceId: 'race-1',
track: 'Monza',
car: 'LMP2',
});
expect(deleteLeagueSeasonScheduleRaceUseCase.execute).toHaveBeenCalledWith({
leagueId: 'l1',
seasonId: 'season-1',
raceId: 'race-1',
});
await withUserId('user-1', async () => {
await expect(
service.withdrawFromLeagueWallet('l1', { amount: 1, currency: 'USD', destinationAccount: 'x' } as any),
).resolves.toEqual({
success: true,
});
});
expect(withdrawFromLeagueWalletUseCase.execute).toHaveBeenCalledWith({
leagueId: 'l1',
requestedById: 'user-1',
amount: 1,
currency: 'USD',
reason: 'x',
});
await expect(service.getAllLeaguesWithCapacity()).resolves.toEqual({ leagues: [] });
@@ -186,16 +438,20 @@ describe('LeagueService', () => {
// getLeagueAdmin error branch: fullConfigResult is Err
getLeagueFullConfigUseCase.execute.mockResolvedValueOnce(Result.err({ code: 'REPOSITORY_ERROR', details: { message: 'boom' } }));
await expect(service.getLeagueAdmin('l1')).rejects.toThrow('REPOSITORY_ERROR');
await withUserId('user-1', async () => {
await expect(service.getLeagueAdmin('l1')).rejects.toThrow('REPOSITORY_ERROR');
});
// getLeagueAdmin happy path
getLeagueFullConfigUseCase.execute.mockResolvedValueOnce(Result.ok(undefined));
await expect(service.getLeagueAdmin('l1')).resolves.toEqual({
joinRequests: [],
ownerSummary: { ownerId: 'o1' },
config: { form: { form: {} } },
protests: { protests: [] },
seasons: [],
await withUserId('user-1', async () => {
await expect(service.getLeagueAdmin('l1')).resolves.toEqual({
joinRequests: [],
ownerSummary: { ownerId: 'o1' },
config: { form: { form: {} } },
protests: { protests: [] },
seasons: [],
});
});
// keep lint happy (ensures err() used)

543
apps/api/src/domain/league/LeagueService.ts
View File

@@ -1,4 +1,4 @@
import { Inject, Injectable } from '@nestjs/common';
import { BadRequestException, ConflictException, Inject, Injectable, NotFoundException } from '@nestjs/common';
import { ApproveJoinRequestInputDTO } from './dtos/ApproveJoinRequestInputDTO';
import { ApproveLeagueJoinRequestDTO } from './dtos/ApproveLeagueJoinRequestDTO';
import { CreateLeagueInputDTO } from './dtos/CreateLeagueInputDTO';
@@ -9,6 +9,13 @@ import { GetLeagueProtestsQueryDTO } from './dtos/GetLeagueProtestsQueryDTO';
import { GetLeagueRacesOutputDTO } from './dtos/GetLeagueRacesOutputDTO';
import { GetLeagueSeasonsQueryDTO } from './dtos/GetLeagueSeasonsQueryDTO';
import { GetLeagueWalletOutputDTO } from './dtos/GetLeagueWalletOutputDTO';
import { GetLeagueScheduleQueryDTO } from './dtos/GetLeagueScheduleQueryDTO';
import {
CreateLeagueScheduleRaceInputDTO,
CreateLeagueScheduleRaceOutputDTO,
LeagueScheduleRaceMutationSuccessDTO,
UpdateLeagueScheduleRaceInputDTO,
} from './dtos/LeagueScheduleRaceAdminDTO';
import { GetSeasonSponsorshipsOutputDTO } from './dtos/GetSeasonSponsorshipsOutputDTO';
import { LeagueAdminDTO } from './dtos/LeagueAdminDTO';
import { LeagueAdminPermissionsDTO } from './dtos/LeagueAdminPermissionsDTO';
@@ -16,8 +23,14 @@ import { LeagueAdminProtestsDTO } from './dtos/LeagueAdminProtestsDTO';
import { LeagueConfigFormModelDTO } from './dtos/LeagueConfigFormModelDTO';
import { LeagueJoinRequestWithDriverDTO } from './dtos/LeagueJoinRequestWithDriverDTO';
import { LeagueMembershipsDTO } from './dtos/LeagueMembershipsDTO';
import { LeagueRosterJoinRequestDTO } from './dtos/LeagueRosterJoinRequestDTO';
import { LeagueRosterMemberDTO } from './dtos/LeagueRosterMemberDTO';
import { LeagueOwnerSummaryDTO } from './dtos/LeagueOwnerSummaryDTO';
import { LeagueScheduleDTO } from './dtos/LeagueScheduleDTO';
import {
LeagueSeasonSchedulePublishInputDTO,
LeagueSeasonSchedulePublishOutputDTO,
} from './dtos/LeagueSeasonSchedulePublishDTO';
import { LeagueSeasonSummaryDTO } from './dtos/LeagueSeasonSummaryDTO';
import { LeagueStandingsDTO } from './dtos/LeagueStandingsDTO';
import { LeagueStatsDTO } from './dtos/LeagueStatsDTO';
@@ -26,11 +39,15 @@ import { RejectJoinRequestOutputDTO } from './dtos/RejectJoinRequestOutputDTO';
import { RemoveLeagueMemberInputDTO } from './dtos/RemoveLeagueMemberInputDTO';
import { RemoveLeagueMemberOutputDTO } from './dtos/RemoveLeagueMemberOutputDTO';
import { TransferLeagueOwnershipOutputDTO } from './dtos/TransferLeagueOwnershipOutputDTO';
import { TransferLeagueOwnershipInputDTO } from './dtos/TransferLeagueOwnershipInputDTO';
import { UpdateLeagueMemberRoleInputDTO } from './dtos/UpdateLeagueMemberRoleInputDTO';
import { UpdateLeagueMemberRoleOutputDTO } from './dtos/UpdateLeagueMemberRoleOutputDTO';
import { WithdrawFromLeagueWalletInputDTO } from './dtos/WithdrawFromLeagueWalletInputDTO';
import { WithdrawFromLeagueWalletOutputDTO } from './dtos/WithdrawFromLeagueWalletOutputDTO';
import { getActorFromRequestContext } from '../auth/getActorFromRequestContext';
import { requireLeagueAdminOrOwner } from './LeagueAuthorization';
// Core imports for view models
import type { AllLeaguesWithCapacityDTO as AllLeaguesWithCapacityViewModel } from './dtos/AllLeaguesWithCapacityDTO';
import type { AllLeaguesWithCapacityAndScoringDTO as AllLeaguesWithCapacityAndScoringViewModel } from './dtos/AllLeaguesWithCapacityAndScoringDTO';
@@ -52,9 +69,12 @@ import { GetLeagueAdminPermissionsUseCase } from '@core/racing/application/use-c
import { GetLeagueFullConfigUseCase } from '@core/racing/application/use-cases/GetLeagueFullConfigUseCase';
import { GetLeagueJoinRequestsUseCase } from '@core/racing/application/use-cases/GetLeagueJoinRequestsUseCase';
import { GetLeagueMembershipsUseCase } from '@core/racing/application/use-cases/GetLeagueMembershipsUseCase';
import { GetLeagueRosterMembersUseCase } from '@core/racing/application/use-cases/GetLeagueRosterMembersUseCase';
import { GetLeagueRosterJoinRequestsUseCase } from '@core/racing/application/use-cases/GetLeagueRosterJoinRequestsUseCase';
import { GetLeagueOwnerSummaryUseCase } from '@core/racing/application/use-cases/GetLeagueOwnerSummaryUseCase';
import { GetLeagueProtestsUseCase } from '@core/racing/application/use-cases/GetLeagueProtestsUseCase';
import { GetLeagueScheduleUseCase } from '@core/racing/application/use-cases/GetLeagueScheduleUseCase';
import type { GetLeagueScheduleInput } from '@core/racing/application/use-cases/GetLeagueScheduleUseCase';
import { GetLeagueScoringConfigUseCase } from '@core/racing/application/use-cases/GetLeagueScoringConfigUseCase';
import { GetLeagueSeasonsUseCase } from '@core/racing/application/use-cases/GetLeagueSeasonsUseCase';
import { GetLeagueStandingsUseCase } from '@core/racing/application/use-cases/GetLeagueStandingsUseCase';
@@ -70,6 +90,12 @@ import { TransferLeagueOwnershipUseCase } from '@core/racing/application/use-cas
import { UpdateLeagueMemberRoleUseCase } from '@core/racing/application/use-cases/UpdateLeagueMemberRoleUseCase';
import { WithdrawFromLeagueWalletUseCase } from '@core/racing/application/use-cases/WithdrawFromLeagueWalletUseCase';
import { CreateLeagueSeasonScheduleRaceUseCase } from '@core/racing/application/use-cases/CreateLeagueSeasonScheduleRaceUseCase';
import { DeleteLeagueSeasonScheduleRaceUseCase } from '@core/racing/application/use-cases/DeleteLeagueSeasonScheduleRaceUseCase';
import { PublishLeagueSeasonScheduleUseCase } from '@core/racing/application/use-cases/PublishLeagueSeasonScheduleUseCase';
import { UnpublishLeagueSeasonScheduleUseCase } from '@core/racing/application/use-cases/UnpublishLeagueSeasonScheduleUseCase';
import { UpdateLeagueSeasonScheduleRaceUseCase } from '@core/racing/application/use-cases/UpdateLeagueSeasonScheduleRaceUseCase';
// API Presenters
import { AllLeaguesWithCapacityPresenter } from './presenters/AllLeaguesWithCapacityPresenter';
import { AllLeaguesWithCapacityAndScoringPresenter } from './presenters/AllLeaguesWithCapacityAndScoringPresenter';
@@ -77,6 +103,10 @@ import { ApproveLeagueJoinRequestPresenter } from './presenters/ApproveLeagueJoi
import { CreateLeaguePresenter } from './presenters/CreateLeaguePresenter';
import { GetLeagueAdminPermissionsPresenter } from './presenters/GetLeagueAdminPermissionsPresenter';
import { GetLeagueMembershipsPresenter } from './presenters/GetLeagueMembershipsPresenter';
import {
GetLeagueRosterJoinRequestsPresenter,
GetLeagueRosterMembersPresenter,
} from './presenters/LeagueRosterAdminReadPresenters';
import { GetLeagueOwnerSummaryPresenter } from './presenters/GetLeagueOwnerSummaryPresenter';
import { GetLeagueProtestsPresenter } from './presenters/GetLeagueProtestsPresenter';
import { GetLeagueSeasonsPresenter } from './presenters/GetLeagueSeasonsPresenter';
@@ -96,58 +126,74 @@ import { TransferLeagueOwnershipPresenter } from './presenters/TransferLeagueOwn
import { UpdateLeagueMemberRolePresenter } from './presenters/UpdateLeagueMemberRolePresenter';
import { GetLeagueWalletPresenter } from './presenters/GetLeagueWalletPresenter';
import { WithdrawFromLeagueWalletPresenter } from './presenters/WithdrawFromLeagueWalletPresenter';
import {
CreateLeagueSeasonScheduleRacePresenter,
DeleteLeagueSeasonScheduleRacePresenter,
PublishLeagueSeasonSchedulePresenter,
UnpublishLeagueSeasonSchedulePresenter,
UpdateLeagueSeasonScheduleRacePresenter,
} from './presenters/LeagueSeasonScheduleMutationPresenters';
// Tokens
import {
LOGGER_TOKEN,
GET_ALL_LEAGUES_WITH_CAPACITY_USE_CASE,
GET_LEAGUE_STANDINGS_USE_CASE,
GET_ALL_LEAGUES_WITH_CAPACITY_AND_SCORING_USE_CASE,
GET_LEAGUE_STATS_USE_CASE,
GET_LEAGUE_FULL_CONFIG_USE_CASE,
GET_LEAGUE_SCORING_CONFIG_USE_CASE,
LIST_LEAGUE_SCORING_PRESETS_USE_CASE,
JOIN_LEAGUE_USE_CASE,
TRANSFER_LEAGUE_OWNERSHIP_USE_CASE,
CREATE_LEAGUE_WITH_SEASON_AND_SCORING_USE_CASE,
GET_TOTAL_LEAGUES_USE_CASE,
GET_LEAGUE_JOIN_REQUESTS_USE_CASE,
APPROVE_LEAGUE_JOIN_REQUEST_USE_CASE,
REJECT_LEAGUE_JOIN_REQUEST_USE_CASE,
REMOVE_LEAGUE_MEMBER_USE_CASE,
UPDATE_LEAGUE_MEMBER_ROLE_USE_CASE,
GET_LEAGUE_OWNER_SUMMARY_USE_CASE,
GET_LEAGUE_PROTESTS_USE_CASE,
GET_LEAGUE_SEASONS_USE_CASE,
GET_LEAGUE_MEMBERSHIPS_USE_CASE,
GET_LEAGUE_SCHEDULE_USE_CASE,
GET_LEAGUE_ADMIN_PERMISSIONS_USE_CASE,
GET_LEAGUE_WALLET_USE_CASE,
WITHDRAW_FROM_LEAGUE_WALLET_USE_CASE,
GET_SEASON_SPONSORSHIPS_USE_CASE,
GET_ALL_LEAGUES_WITH_CAPACITY_OUTPUT_PORT_TOKEN,
GET_ALL_LEAGUES_WITH_CAPACITY_AND_SCORING_OUTPUT_PORT_TOKEN,
GET_LEAGUE_STANDINGS_OUTPUT_PORT_TOKEN,
GET_LEAGUE_PROTESTS_OUTPUT_PORT_TOKEN,
GET_SEASON_SPONSORSHIPS_OUTPUT_PORT_TOKEN,
LIST_LEAGUE_SCORING_PRESETS_OUTPUT_PORT_TOKEN,
APPROVE_LEAGUE_JOIN_REQUEST_OUTPUT_PORT_TOKEN,
APPROVE_LEAGUE_JOIN_REQUEST_USE_CASE,
CREATE_LEAGUE_OUTPUT_PORT_TOKEN,
CREATE_LEAGUE_SEASON_SCHEDULE_RACE_USE_CASE,
CREATE_LEAGUE_WITH_SEASON_AND_SCORING_USE_CASE,
GET_ALL_LEAGUES_WITH_CAPACITY_AND_SCORING_OUTPUT_PORT_TOKEN,
GET_ALL_LEAGUES_WITH_CAPACITY_AND_SCORING_USE_CASE,
GET_ALL_LEAGUES_WITH_CAPACITY_OUTPUT_PORT_TOKEN,
GET_ALL_LEAGUES_WITH_CAPACITY_USE_CASE,
GET_LEAGUE_ADMIN_PERMISSIONS_OUTPUT_PORT_TOKEN,
GET_LEAGUE_ADMIN_PERMISSIONS_USE_CASE,
GET_LEAGUE_FULL_CONFIG_OUTPUT_PORT_TOKEN,
GET_LEAGUE_FULL_CONFIG_USE_CASE,
GET_LEAGUE_JOIN_REQUESTS_USE_CASE,
GET_LEAGUE_MEMBERSHIPS_OUTPUT_PORT_TOKEN,
GET_LEAGUE_MEMBERSHIPS_USE_CASE,
GET_LEAGUE_ROSTER_JOIN_REQUESTS_OUTPUT_PORT_TOKEN,
GET_LEAGUE_ROSTER_JOIN_REQUESTS_USE_CASE,
GET_LEAGUE_ROSTER_MEMBERS_OUTPUT_PORT_TOKEN,
GET_LEAGUE_ROSTER_MEMBERS_USE_CASE,
GET_LEAGUE_OWNER_SUMMARY_OUTPUT_PORT_TOKEN,
GET_LEAGUE_SEASONS_OUTPUT_PORT_TOKEN,
JOIN_LEAGUE_OUTPUT_PORT_TOKEN,
GET_LEAGUE_OWNER_SUMMARY_USE_CASE,
GET_LEAGUE_PROTESTS_OUTPUT_PORT_TOKEN,
GET_LEAGUE_PROTESTS_USE_CASE,
GET_LEAGUE_SCHEDULE_OUTPUT_PORT_TOKEN,
GET_LEAGUE_SCHEDULE_USE_CASE,
GET_LEAGUE_SCORING_CONFIG_OUTPUT_PORT_TOKEN,
GET_LEAGUE_SCORING_CONFIG_USE_CASE,
GET_LEAGUE_SEASONS_OUTPUT_PORT_TOKEN,
GET_LEAGUE_SEASONS_USE_CASE,
GET_LEAGUE_STATS_OUTPUT_PORT_TOKEN,
GET_LEAGUE_STATS_USE_CASE,
GET_LEAGUE_STANDINGS_OUTPUT_PORT_TOKEN,
GET_LEAGUE_STANDINGS_USE_CASE,
GET_LEAGUE_WALLET_OUTPUT_PORT_TOKEN,
GET_LEAGUE_WALLET_USE_CASE,
GET_SEASON_SPONSORSHIPS_OUTPUT_PORT_TOKEN,
GET_SEASON_SPONSORSHIPS_USE_CASE,
GET_TOTAL_LEAGUES_USE_CASE,
JOIN_LEAGUE_OUTPUT_PORT_TOKEN,
JOIN_LEAGUE_USE_CASE,
LIST_LEAGUE_SCORING_PRESETS_OUTPUT_PORT_TOKEN,
LIST_LEAGUE_SCORING_PRESETS_USE_CASE,
LOGGER_TOKEN,
PUBLISH_LEAGUE_SEASON_SCHEDULE_USE_CASE,
REJECT_LEAGUE_JOIN_REQUEST_OUTPUT_PORT_TOKEN,
REJECT_LEAGUE_JOIN_REQUEST_USE_CASE,
REMOVE_LEAGUE_MEMBER_OUTPUT_PORT_TOKEN,
REMOVE_LEAGUE_MEMBER_USE_CASE,
TOTAL_LEAGUES_OUTPUT_PORT_TOKEN,
TRANSFER_LEAGUE_OWNERSHIP_OUTPUT_PORT_TOKEN,
TRANSFER_LEAGUE_OWNERSHIP_USE_CASE,
UNPUBLISH_LEAGUE_SEASON_SCHEDULE_USE_CASE,
UPDATE_LEAGUE_MEMBER_ROLE_OUTPUT_PORT_TOKEN,
GET_LEAGUE_FULL_CONFIG_OUTPUT_PORT_TOKEN,
GET_LEAGUE_SCORING_CONFIG_OUTPUT_PORT_TOKEN,
GET_LEAGUE_WALLET_OUTPUT_PORT_TOKEN,
UPDATE_LEAGUE_MEMBER_ROLE_USE_CASE,
UPDATE_LEAGUE_SEASON_SCHEDULE_RACE_USE_CASE,
DELETE_LEAGUE_SEASON_SCHEDULE_RACE_USE_CASE,
WITHDRAW_FROM_LEAGUE_WALLET_OUTPUT_PORT_TOKEN,
WITHDRAW_FROM_LEAGUE_WALLET_USE_CASE,
} from './LeagueTokens';
@Injectable()
@@ -178,7 +224,21 @@ export class LeagueService {
@Inject(GET_LEAGUE_WALLET_USE_CASE) private readonly getLeagueWalletUseCase: GetLeagueWalletUseCase,
@Inject(WITHDRAW_FROM_LEAGUE_WALLET_USE_CASE) private readonly withdrawFromLeagueWalletUseCase: WithdrawFromLeagueWalletUseCase,
@Inject(GET_SEASON_SPONSORSHIPS_USE_CASE) private readonly getSeasonSponsorshipsUseCase: GetSeasonSponsorshipsUseCase,
// Schedule mutations
@Inject(CREATE_LEAGUE_SEASON_SCHEDULE_RACE_USE_CASE)
private readonly createLeagueSeasonScheduleRaceUseCase: CreateLeagueSeasonScheduleRaceUseCase,
@Inject(UPDATE_LEAGUE_SEASON_SCHEDULE_RACE_USE_CASE)
private readonly updateLeagueSeasonScheduleRaceUseCase: UpdateLeagueSeasonScheduleRaceUseCase,
@Inject(DELETE_LEAGUE_SEASON_SCHEDULE_RACE_USE_CASE)
private readonly deleteLeagueSeasonScheduleRaceUseCase: DeleteLeagueSeasonScheduleRaceUseCase,
@Inject(PUBLISH_LEAGUE_SEASON_SCHEDULE_USE_CASE)
private readonly publishLeagueSeasonScheduleUseCase: PublishLeagueSeasonScheduleUseCase,
@Inject(UNPUBLISH_LEAGUE_SEASON_SCHEDULE_USE_CASE)
private readonly unpublishLeagueSeasonScheduleUseCase: UnpublishLeagueSeasonScheduleUseCase,
@Inject(LOGGER_TOKEN) private readonly logger: Logger,
// Injected presenters
@Inject(GET_ALL_LEAGUES_WITH_CAPACITY_OUTPUT_PORT_TOKEN) private readonly allLeaguesWithCapacityPresenter: AllLeaguesWithCapacityPresenter,
@Inject(GET_ALL_LEAGUES_WITH_CAPACITY_AND_SCORING_OUTPUT_PORT_TOKEN) private readonly allLeaguesWithCapacityAndScoringPresenter: AllLeaguesWithCapacityAndScoringPresenter,
@@ -204,8 +264,30 @@ export class LeagueService {
@Inject(GET_LEAGUE_SCORING_CONFIG_OUTPUT_PORT_TOKEN) private readonly leagueScoringConfigPresenter: LeagueScoringConfigPresenter,
@Inject(GET_LEAGUE_WALLET_OUTPUT_PORT_TOKEN) private readonly getLeagueWalletPresenter: GetLeagueWalletPresenter,
@Inject(WITHDRAW_FROM_LEAGUE_WALLET_OUTPUT_PORT_TOKEN) private readonly withdrawFromLeagueWalletPresenter: WithdrawFromLeagueWalletPresenter,
private readonly leagueJoinRequestsPresenter: LeagueJoinRequestsPresenter,
private readonly leagueRacesPresenter: LeagueRacesPresenter,
@Inject(LeagueJoinRequestsPresenter) private readonly leagueJoinRequestsPresenter: LeagueJoinRequestsPresenter,
@Inject(LeagueRacesPresenter) private readonly leagueRacesPresenter: LeagueRacesPresenter,
// Schedule mutation presenters
@Inject(CreateLeagueSeasonScheduleRacePresenter)
private readonly createLeagueSeasonScheduleRacePresenter: CreateLeagueSeasonScheduleRacePresenter,
@Inject(UpdateLeagueSeasonScheduleRacePresenter)
private readonly updateLeagueSeasonScheduleRacePresenter: UpdateLeagueSeasonScheduleRacePresenter,
@Inject(DeleteLeagueSeasonScheduleRacePresenter)
private readonly deleteLeagueSeasonScheduleRacePresenter: DeleteLeagueSeasonScheduleRacePresenter,
@Inject(PublishLeagueSeasonSchedulePresenter)
private readonly publishLeagueSeasonSchedulePresenter: PublishLeagueSeasonSchedulePresenter,
@Inject(UnpublishLeagueSeasonSchedulePresenter)
private readonly unpublishLeagueSeasonSchedulePresenter: UnpublishLeagueSeasonSchedulePresenter,
// Roster admin read delegation
@Inject(GET_LEAGUE_ROSTER_MEMBERS_USE_CASE)
private readonly getLeagueRosterMembersUseCase: GetLeagueRosterMembersUseCase,
@Inject(GET_LEAGUE_ROSTER_JOIN_REQUESTS_USE_CASE)
private readonly getLeagueRosterJoinRequestsUseCase: GetLeagueRosterJoinRequestsUseCase,
@Inject(GET_LEAGUE_ROSTER_MEMBERS_OUTPUT_PORT_TOKEN)
private readonly getLeagueRosterMembersPresenter: GetLeagueRosterMembersPresenter,
@Inject(GET_LEAGUE_ROSTER_JOIN_REQUESTS_OUTPUT_PORT_TOKEN)
private readonly getLeagueRosterJoinRequestsPresenter: GetLeagueRosterJoinRequestsPresenter,
) {}
async getAllLeaguesWithCapacity(): Promise<AllLeaguesWithCapacityViewModel> {
@@ -247,43 +329,214 @@ export class LeagueService {
return this.totalLeaguesPresenter.getResponseModel()!;
}
private getActor(): ReturnType<typeof getActorFromRequestContext> {
return getActorFromRequestContext();
}
private async requireLeagueAdminPermissions(leagueId: string): Promise<void> {
await requireLeagueAdminOrOwner(leagueId, this.getLeagueAdminPermissionsUseCase);
}
async getLeagueJoinRequests(leagueId: string): Promise<LeagueJoinRequestWithDriverDTO[]> {
this.logger.debug(`[LeagueService] Fetching join requests for league: ${leagueId}.`);
await this.requireLeagueAdminPermissions(leagueId);
this.leagueJoinRequestsPresenter.reset?.();
await this.getLeagueJoinRequestsUseCase.execute({ leagueId });
return this.leagueJoinRequestsPresenter.getViewModel()!.joinRequests;
}
async approveLeagueJoinRequest(input: ApproveJoinRequestInputDTO): Promise<ApproveLeagueJoinRequestDTO> {
this.logger.debug('Approving join request:', input);
await this.approveLeagueJoinRequestUseCase.execute(input, this.approveLeagueJoinRequestPresenter);
await this.requireLeagueAdminPermissions(input.leagueId);
this.approveLeagueJoinRequestPresenter.reset?.();
const result = await this.approveLeagueJoinRequestUseCase.execute(
{ leagueId: input.leagueId, joinRequestId: input.requestId },
this.approveLeagueJoinRequestPresenter,
);
if (result.isErr()) {
const err = result.unwrapErr();
if (err.code === 'JOIN_REQUEST_NOT_FOUND') {
throw new NotFoundException('Join request not found');
}
if (err.code === 'LEAGUE_NOT_FOUND') {
throw new NotFoundException('League not found');
}
if (err.code === 'LEAGUE_AT_CAPACITY') {
throw new ConflictException('League is at capacity');
}
throw new Error(err.code);
}
return this.approveLeagueJoinRequestPresenter.getViewModel()!;
}
async rejectLeagueJoinRequest(input: RejectJoinRequestInputDTO): Promise<RejectJoinRequestOutputDTO> {
this.logger.debug('Rejecting join request:', input);
await this.rejectLeagueJoinRequestUseCase.execute({
leagueId: input.leagueId,
adminId: 'admin', // This should come from auth context
requestId: input.requestId
});
await this.requireLeagueAdminPermissions(input.leagueId);
this.rejectLeagueJoinRequestPresenter.reset?.();
const result = await this.rejectLeagueJoinRequestUseCase.execute(
{ leagueId: input.leagueId, joinRequestId: input.requestId },
this.rejectLeagueJoinRequestPresenter,
);
if (result.isErr()) {
const err = result.unwrapErr();
if (err.code === 'JOIN_REQUEST_NOT_FOUND') {
throw new NotFoundException('Join request not found');
}
if (err.code === 'LEAGUE_NOT_FOUND') {
throw new NotFoundException('League not found');
}
if (err.code === 'LEAGUE_AT_CAPACITY') {
throw new ConflictException('League is at capacity');
}
throw new Error(err.code);
}
return this.rejectLeagueJoinRequestPresenter.getViewModel()!;
}
async approveLeagueRosterJoinRequest(leagueId: string, joinRequestId: string): Promise<ApproveLeagueJoinRequestDTO> {
this.logger.debug('Approving roster join request:', { leagueId, joinRequestId });
await this.requireLeagueAdminPermissions(leagueId);
this.approveLeagueJoinRequestPresenter.reset?.();
const result = await this.approveLeagueJoinRequestUseCase.execute(
{ leagueId, joinRequestId },
this.approveLeagueJoinRequestPresenter,
);
if (result.isErr()) {
const err = result.unwrapErr();
if (err.code === 'JOIN_REQUEST_NOT_FOUND') {
throw new NotFoundException('Join request not found');
}
if (err.code === 'LEAGUE_NOT_FOUND') {
throw new NotFoundException('League not found');
}
if (err.code === 'LEAGUE_AT_CAPACITY') {
throw new ConflictException('League is at capacity');
}
throw new Error(err.code);
}
return this.approveLeagueJoinRequestPresenter.getViewModel()!;
}
async rejectLeagueRosterJoinRequest(leagueId: string, joinRequestId: string): Promise<RejectJoinRequestOutputDTO> {
this.logger.debug('Rejecting roster join request:', { leagueId, joinRequestId });
await this.requireLeagueAdminPermissions(leagueId);
this.rejectLeagueJoinRequestPresenter.reset?.();
const result = await this.rejectLeagueJoinRequestUseCase.execute(
{ leagueId, joinRequestId },
this.rejectLeagueJoinRequestPresenter,
);
if (result.isErr()) {
throw new NotFoundException('Join request not found');
}
return this.rejectLeagueJoinRequestPresenter.getViewModel()!;
}
async getLeagueAdminPermissions(query: GetLeagueAdminPermissionsInputDTO): Promise<LeagueAdminPermissionsDTO> {
this.logger.debug('Getting league admin permissions', { query });
await this.getLeagueAdminPermissionsUseCase.execute(query);
const actor = this.getActor();
this.logger.debug('Getting league admin permissions', { leagueId: query.leagueId, performerDriverId: actor.driverId });
await this.getLeagueAdminPermissionsUseCase.execute({
leagueId: query.leagueId,
performerDriverId: actor.driverId,
});
return this.getLeagueAdminPermissionsPresenter.getResponseModel()!;
}
async removeLeagueMember(input: RemoveLeagueMemberInputDTO): Promise<RemoveLeagueMemberOutputDTO> {
this.logger.debug('Removing league member', { leagueId: input.leagueId, targetDriverId: input.targetDriverId });
await this.removeLeagueMemberUseCase.execute(input);
await this.requireLeagueAdminPermissions(input.leagueId);
this.removeLeagueMemberPresenter.reset?.();
const result = await this.removeLeagueMemberUseCase.execute({
leagueId: input.leagueId,
targetDriverId: input.targetDriverId,
});
if (result.isErr()) {
const err = result.unwrapErr();
if (err.code === 'MEMBERSHIP_NOT_FOUND') {
throw new NotFoundException('Member not found');
}
if (err.code === 'CANNOT_REMOVE_LAST_OWNER') {
throw new BadRequestException(err.details.message);
}
throw new Error(err.code);
}
return this.removeLeagueMemberPresenter.getViewModel()!;
}
async updateLeagueMemberRole(input: UpdateLeagueMemberRoleInputDTO): Promise<UpdateLeagueMemberRoleOutputDTO> {
this.logger.debug('Updating league member role', { leagueId: input.leagueId, targetDriverId: input.targetDriverId, newRole: input.newRole });
await this.updateLeagueMemberRoleUseCase.execute(input);
async updateLeagueMemberRole(
leagueId: string,
targetDriverId: string,
input: UpdateLeagueMemberRoleInputDTO,
): Promise<UpdateLeagueMemberRoleOutputDTO> {
this.logger.debug('Updating league member role', {
leagueId,
targetDriverId,
newRole: input.newRole,
});
await this.requireLeagueAdminPermissions(leagueId);
this.updateLeagueMemberRolePresenter.reset?.();
const result = await this.updateLeagueMemberRoleUseCase.execute({
leagueId,
targetDriverId,
newRole: input.newRole,
});
if (result.isErr()) {
const err = result.unwrapErr();
if (err.code === 'MEMBERSHIP_NOT_FOUND') {
throw new NotFoundException('Member not found');
}
if (err.code === 'INVALID_ROLE' || err.code === 'CANNOT_DOWNGRADE_LAST_OWNER') {
throw new BadRequestException(err.details.message);
}
throw new Error(err.code);
}
return this.updateLeagueMemberRolePresenter.getViewModel()!;
}
@@ -323,19 +576,166 @@ export class LeagueService {
return this.getLeagueMembershipsPresenter.getViewModel()!.memberships;
}
async getLeagueRosterMembers(leagueId: string): Promise<LeagueRosterMemberDTO[]> {
this.logger.debug('Getting league roster members (admin)', { leagueId });
await this.requireLeagueAdminPermissions(leagueId);
this.getLeagueRosterMembersPresenter.reset?.();
const result = await this.getLeagueRosterMembersUseCase.execute({ leagueId });
if (result.isErr()) {
throw new Error(result.unwrapErr().code);
}
return this.getLeagueRosterMembersPresenter.getViewModel()!;
}
async getLeagueRosterJoinRequests(leagueId: string): Promise<LeagueRosterJoinRequestDTO[]> {
this.logger.debug('Getting league roster join requests (admin)', { leagueId });
await this.requireLeagueAdminPermissions(leagueId);
this.getLeagueRosterJoinRequestsPresenter.reset?.();
const result = await this.getLeagueRosterJoinRequestsUseCase.execute({ leagueId });
if (result.isErr()) {
throw new Error(result.unwrapErr().code);
}
return this.getLeagueRosterJoinRequestsPresenter.getViewModel()!;
}
async getLeagueStandings(leagueId: string): Promise<LeagueStandingsDTO> {
this.logger.debug('Getting league standings', { leagueId });
await this.getLeagueStandingsUseCase.execute({ leagueId });
return this.leagueStandingsPresenter.getResponseModel()!;
}
async getLeagueSchedule(leagueId: string): Promise<LeagueScheduleDTO> {
this.logger.debug('Getting league schedule', { leagueId });
async getLeagueSchedule(leagueId: string, query?: GetLeagueScheduleQueryDTO): Promise<LeagueScheduleDTO> {
this.logger.debug('Getting league schedule', { leagueId, query });
const input: GetLeagueScheduleInput = query?.seasonId ? { leagueId, seasonId: query.seasonId } : { leagueId };
await this.getLeagueScheduleUseCase.execute(input);
await this.getLeagueScheduleUseCase.execute({ leagueId });
return this.leagueSchedulePresenter.getViewModel()!;
}
async publishLeagueSeasonSchedule(
leagueId: string,
seasonId: string,
_input: LeagueSeasonSchedulePublishInputDTO,
): Promise<LeagueSeasonSchedulePublishOutputDTO> {
void _input;
await this.requireLeagueAdminPermissions(leagueId);
this.publishLeagueSeasonSchedulePresenter.reset?.();
const result = await this.publishLeagueSeasonScheduleUseCase.execute({ leagueId, seasonId });
if (result.isErr()) {
throw new Error(result.unwrapErr().code);
}
return this.publishLeagueSeasonSchedulePresenter.getResponseModel()!;
}
async unpublishLeagueSeasonSchedule(
leagueId: string,
seasonId: string,
_input: LeagueSeasonSchedulePublishInputDTO,
): Promise<LeagueSeasonSchedulePublishOutputDTO> {
void _input;
await this.requireLeagueAdminPermissions(leagueId);
this.unpublishLeagueSeasonSchedulePresenter.reset?.();
const result = await this.unpublishLeagueSeasonScheduleUseCase.execute({ leagueId, seasonId });
if (result.isErr()) {
throw new Error(result.unwrapErr().code);
}
return this.unpublishLeagueSeasonSchedulePresenter.getResponseModel()!;
}
async createLeagueSeasonScheduleRace(
leagueId: string,
seasonId: string,
input: CreateLeagueScheduleRaceInputDTO,
): Promise<CreateLeagueScheduleRaceOutputDTO> {
await this.requireLeagueAdminPermissions(leagueId);
const scheduledAt = new Date(input.scheduledAtIso);
if (Number.isNaN(scheduledAt.getTime())) {
throw new Error('INVALID_SCHEDULED_AT');
}
this.createLeagueSeasonScheduleRacePresenter.reset?.();
const result = await this.createLeagueSeasonScheduleRaceUseCase.execute({
leagueId,
seasonId,
track: input.track,
car: input.car,
scheduledAt,
});
if (result.isErr()) {
throw new Error(result.unwrapErr().code);
}
return this.createLeagueSeasonScheduleRacePresenter.getResponseModel()!;
}
async updateLeagueSeasonScheduleRace(
leagueId: string,
seasonId: string,
raceId: string,
input: UpdateLeagueScheduleRaceInputDTO,
): Promise<LeagueScheduleRaceMutationSuccessDTO> {
await this.requireLeagueAdminPermissions(leagueId);
const scheduledAt =
input.scheduledAtIso !== undefined ? new Date(input.scheduledAtIso) : undefined;
if (scheduledAt && Number.isNaN(scheduledAt.getTime())) {
throw new Error('INVALID_SCHEDULED_AT');
}
this.updateLeagueSeasonScheduleRacePresenter.reset?.();
const result = await this.updateLeagueSeasonScheduleRaceUseCase.execute({
leagueId,
seasonId,
raceId,
...(input.track !== undefined ? { track: input.track } : {}),
...(input.car !== undefined ? { car: input.car } : {}),
...(scheduledAt !== undefined ? { scheduledAt } : {}),
});
if (result.isErr()) {
throw new Error(result.unwrapErr().code);
}
return this.updateLeagueSeasonScheduleRacePresenter.getResponseModel()!;
}
async deleteLeagueSeasonScheduleRace(
leagueId: string,
seasonId: string,
raceId: string,
): Promise<LeagueScheduleRaceMutationSuccessDTO> {
await this.requireLeagueAdminPermissions(leagueId);
this.deleteLeagueSeasonScheduleRacePresenter.reset?.();
const result = await this.deleteLeagueSeasonScheduleRaceUseCase.execute({ leagueId, seasonId, raceId });
if (result.isErr()) {
throw new Error(result.unwrapErr().code);
}
return this.deleteLeagueSeasonScheduleRacePresenter.getResponseModel()!;
}
async getLeagueStats(leagueId: string): Promise<LeagueStatsDTO> {
this.logger.debug('Getting league stats', { leagueId });
await this.getLeagueStatsUseCase.execute({ leagueId });
@@ -408,17 +808,27 @@ export class LeagueService {
return this.leagueScoringPresetsPresenter.getViewModel()!;
}
async joinLeague(leagueId: string, driverId: string): Promise<JoinLeagueOutputDTO> {
this.logger.debug('Joining league', { leagueId, driverId });
async joinLeague(leagueId: string): Promise<JoinLeagueOutputDTO> {
const actor = this.getActor();
this.logger.debug('Joining league', { leagueId, actorDriverId: actor.driverId });
await this.joinLeagueUseCase.execute({ leagueId, driverId });
await this.joinLeagueUseCase.execute({ leagueId, driverId: actor.driverId });
return this.joinLeaguePresenter.getViewModel()!;
}
async transferLeagueOwnership(leagueId: string, currentOwnerId: string, newOwnerId: string): Promise<TransferLeagueOwnershipOutputDTO> {
this.logger.debug('Transferring league ownership', { leagueId, currentOwnerId, newOwnerId });
async transferLeagueOwnership(leagueId: string, input: TransferLeagueOwnershipInputDTO): Promise<TransferLeagueOwnershipOutputDTO> {
this.logger.debug('Transferring league ownership', { leagueId, newOwnerId: input.newOwnerId });
await this.requireLeagueAdminPermissions(leagueId);
const actor = this.getActor();
await this.transferLeagueOwnershipUseCase.execute({
leagueId,
currentOwnerId: actor.driverId,
newOwnerId: input.newOwnerId,
});
await this.transferLeagueOwnershipUseCase.execute({ leagueId, currentOwnerId, newOwnerId });
return this.transferLeagueOwnershipPresenter.getViewModel()!;
}
@@ -444,15 +854,22 @@ export class LeagueService {
return this.getLeagueWalletPresenter.getResponseModel();
}
async withdrawFromLeagueWallet(leagueId: string, input: WithdrawFromLeagueWalletInputDTO): Promise<WithdrawFromLeagueWalletOutputDTO> {
async withdrawFromLeagueWallet(
leagueId: string,
input: WithdrawFromLeagueWalletInputDTO,
): Promise<WithdrawFromLeagueWalletOutputDTO> {
this.logger.debug('Withdrawing from league wallet', { leagueId, amount: input.amount });
const actor = this.getActor();
await this.withdrawFromLeagueWalletUseCase.execute({
leagueId,
requestedById: "admin",
requestedById: actor.driverId,
amount: input.amount,
currency: input.currency as 'USD' | 'EUR' | 'GBP',
reason: input.destinationAccount,
});
return this.withdrawFromLeagueWalletPresenter.getResponseModel();
}
}

20
apps/api/src/domain/league/LeagueTokens.ts
View File

@@ -33,12 +33,21 @@ export const GET_LEAGUE_OWNER_SUMMARY_USE_CASE = 'GetLeagueOwnerSummaryUseCase';
export const GET_LEAGUE_PROTESTS_USE_CASE = 'GetLeagueProtestsUseCase';
export const GET_LEAGUE_SEASONS_USE_CASE = 'GetLeagueSeasonsUseCase';
export const GET_LEAGUE_MEMBERSHIPS_USE_CASE = 'GetLeagueMembershipsUseCase';
export const GET_LEAGUE_ROSTER_MEMBERS_USE_CASE = 'GetLeagueRosterMembersUseCase';
export const GET_LEAGUE_ROSTER_JOIN_REQUESTS_USE_CASE = 'GetLeagueRosterJoinRequestsUseCase';
export const GET_LEAGUE_SCHEDULE_USE_CASE = 'GetLeagueScheduleUseCase';
export const GET_LEAGUE_ADMIN_PERMISSIONS_USE_CASE = 'GetLeagueAdminPermissionsUseCase';
export const GET_LEAGUE_WALLET_USE_CASE = 'GetLeagueWalletUseCase';
export const WITHDRAW_FROM_LEAGUE_WALLET_USE_CASE = 'WithdrawFromLeagueWalletUseCase';
export const GET_SEASON_SPONSORSHIPS_USE_CASE = 'GetSeasonSponsorshipsUseCase';
// Schedule mutation use cases
export const CREATE_LEAGUE_SEASON_SCHEDULE_RACE_USE_CASE = 'CreateLeagueSeasonScheduleRaceUseCase';
export const UPDATE_LEAGUE_SEASON_SCHEDULE_RACE_USE_CASE = 'UpdateLeagueSeasonScheduleRaceUseCase';
export const DELETE_LEAGUE_SEASON_SCHEDULE_RACE_USE_CASE = 'DeleteLeagueSeasonScheduleRaceUseCase';
export const PUBLISH_LEAGUE_SEASON_SCHEDULE_USE_CASE = 'PublishLeagueSeasonScheduleUseCase';
export const UNPUBLISH_LEAGUE_SEASON_SCHEDULE_USE_CASE = 'UnpublishLeagueSeasonScheduleUseCase';
export const GET_ALL_LEAGUES_WITH_CAPACITY_OUTPUT_PORT_TOKEN = 'GetAllLeaguesWithCapacityOutputPort_TOKEN';
export const GET_ALL_LEAGUES_WITH_CAPACITY_AND_SCORING_OUTPUT_PORT_TOKEN = 'GetAllLeaguesWithCapacityAndScoringOutputPort_TOKEN';
export const GET_LEAGUE_STANDINGS_OUTPUT_PORT_TOKEN = 'GetLeagueStandingsOutputPort_TOKEN';
@@ -49,6 +58,8 @@ export const APPROVE_LEAGUE_JOIN_REQUEST_OUTPUT_PORT_TOKEN = 'ApproveLeagueJoinR
export const CREATE_LEAGUE_OUTPUT_PORT_TOKEN = 'CreateLeagueOutputPort_TOKEN';
export const GET_LEAGUE_ADMIN_PERMISSIONS_OUTPUT_PORT_TOKEN = 'GetLeagueAdminPermissionsOutputPort_TOKEN';
export const GET_LEAGUE_MEMBERSHIPS_OUTPUT_PORT_TOKEN = 'GetLeagueMembershipsOutputPort_TOKEN';
export const GET_LEAGUE_ROSTER_MEMBERS_OUTPUT_PORT_TOKEN = 'GetLeagueRosterMembersOutputPort_TOKEN';
export const GET_LEAGUE_ROSTER_JOIN_REQUESTS_OUTPUT_PORT_TOKEN = 'GetLeagueRosterJoinRequestsOutputPort_TOKEN';
export const GET_LEAGUE_OWNER_SUMMARY_OUTPUT_PORT_TOKEN = 'GetLeagueOwnerSummaryOutputPort_TOKEN';
export const GET_LEAGUE_SEASONS_OUTPUT_PORT_TOKEN = 'GetLeagueSeasonsOutputPort_TOKEN';
export const JOIN_LEAGUE_OUTPUT_PORT_TOKEN = 'JoinLeagueOutputPort_TOKEN';
@@ -62,4 +73,11 @@ export const UPDATE_LEAGUE_MEMBER_ROLE_OUTPUT_PORT_TOKEN = 'UpdateLeagueMemberRo
export const GET_LEAGUE_FULL_CONFIG_OUTPUT_PORT_TOKEN = 'GetLeagueFullConfigOutputPort_TOKEN';
export const GET_LEAGUE_SCORING_CONFIG_OUTPUT_PORT_TOKEN = 'GetLeagueScoringConfigOutputPort_TOKEN';
export const GET_LEAGUE_WALLET_OUTPUT_PORT_TOKEN = 'GetLeagueWalletOutputPort_TOKEN';
export const WITHDRAW_FROM_LEAGUE_WALLET_OUTPUT_PORT_TOKEN = 'WithdrawFromLeagueWalletOutputPort_TOKEN';
export const WITHDRAW_FROM_LEAGUE_WALLET_OUTPUT_PORT_TOKEN = 'WithdrawFromLeagueWalletOutputPort_TOKEN';
// Schedule mutation output ports
export const CREATE_LEAGUE_SEASON_SCHEDULE_RACE_OUTPUT_PORT_TOKEN = 'CreateLeagueSeasonScheduleRaceOutputPort_TOKEN';
export const UPDATE_LEAGUE_SEASON_SCHEDULE_RACE_OUTPUT_PORT_TOKEN = 'UpdateLeagueSeasonScheduleRaceOutputPort_TOKEN';
export const DELETE_LEAGUE_SEASON_SCHEDULE_RACE_OUTPUT_PORT_TOKEN = 'DeleteLeagueSeasonScheduleRaceOutputPort_TOKEN';
export const PUBLISH_LEAGUE_SEASON_SCHEDULE_OUTPUT_PORT_TOKEN = 'PublishLeagueSeasonScheduleOutputPort_TOKEN';
export const UNPUBLISH_LEAGUE_SEASON_SCHEDULE_OUTPUT_PORT_TOKEN = 'UnpublishLeagueSeasonScheduleOutputPort_TOKEN';

4
apps/api/src/domain/league/dtos/GetLeagueAdminPermissionsInputDTO.ts
View File

@@ -5,8 +5,4 @@ export class GetLeagueAdminPermissionsInputDTO {
@ApiProperty()
@IsString()
leagueId!: string;
@ApiProperty()
@IsString()
performerDriverId!: string;
}

9
apps/api/src/domain/league/dtos/GetLeagueScheduleQueryDTO.ts Normal file
View File

@@ -0,0 +1,9 @@
import { ApiPropertyOptional } from '@nestjs/swagger';
import { IsOptional, IsString } from 'class-validator';
export class GetLeagueScheduleQueryDTO {
@ApiPropertyOptional({ description: 'Season to scope schedule to' })
@IsOptional()
@IsString()
seasonId?: string;
}

15
apps/api/src/domain/league/dtos/LeagueMemberDTO.ts
View File

@@ -1,5 +1,5 @@
import { ApiProperty } from '@nestjs/swagger';
import { IsString, IsDate, IsEnum, ValidateNested } from 'class-validator';
import { IsEnum, IsString, ValidateNested } from 'class-validator';
import { Type } from 'class-transformer';
import { DriverDTO } from '../../driver/dtos/DriverDTO';
@@ -13,12 +13,11 @@ export class LeagueMemberDTO {
@Type(() => DriverDTO)
driver!: DriverDTO;
@ApiProperty({ enum: ['owner', 'manager', 'member'] })
@IsEnum(['owner', 'manager', 'member'])
role!: 'owner' | 'manager' | 'member';
@ApiProperty({ enum: ['owner', 'admin', 'steward', 'member'] })
@IsEnum(['owner', 'admin', 'steward', 'member'])
role!: 'owner' | 'admin' | 'steward' | 'member';
@ApiProperty()
@IsDate()
@Type(() => Date)
joinedAt!: Date;
@ApiProperty({ description: 'ISO-8601 timestamp' })
@IsString()
joinedAt!: string;
}

41
apps/api/src/domain/league/dtos/LeagueRosterJoinRequestDTO.ts Normal file
View File

@@ -0,0 +1,41 @@
import { ApiProperty } from '@nestjs/swagger';
import { Type } from 'class-transformer';
import { IsOptional, IsString, ValidateNested } from 'class-validator';
class LeagueRosterJoinRequestDriverDTO {
@ApiProperty()
@IsString()
id!: string;
@ApiProperty()
@IsString()
name!: string;
}
export class LeagueRosterJoinRequestDTO {
@ApiProperty()
@IsString()
id!: string;
@ApiProperty()
@IsString()
leagueId!: string;
@ApiProperty()
@IsString()
driverId!: string;
@ApiProperty({ format: 'date-time' })
@IsString()
requestedAt!: string;
@ApiProperty({ required: false })
@IsOptional()
@IsString()
message?: string;
@ApiProperty({ type: () => LeagueRosterJoinRequestDriverDTO })
@ValidateNested()
@Type(() => LeagueRosterJoinRequestDriverDTO)
driver!: LeagueRosterJoinRequestDriverDTO;
}

23
apps/api/src/domain/league/dtos/LeagueRosterMemberDTO.ts Normal file
View File

@@ -0,0 +1,23 @@
import { ApiProperty } from '@nestjs/swagger';
import { Type } from 'class-transformer';
import { IsEnum, IsString, ValidateNested } from 'class-validator';
import { DriverDTO } from '../../driver/dtos/DriverDTO';
export class LeagueRosterMemberDTO {
@ApiProperty()
@IsString()
driverId!: string;
@ApiProperty({ type: () => DriverDTO })
@ValidateNested()
@Type(() => DriverDTO)
driver!: DriverDTO;
@ApiProperty({ enum: ['owner', 'admin', 'steward', 'member'] })
@IsEnum(['owner', 'admin', 'steward', 'member'])
role!: 'owner' | 'admin' | 'steward' | 'member';
@ApiProperty({ format: 'date-time' })
@IsString()
joinedAt!: string;
}

10
apps/api/src/domain/league/dtos/LeagueScheduleDTO.ts
View File

@@ -1,9 +1,17 @@
import { ApiProperty } from '@nestjs/swagger';
import { IsArray, ValidateNested } from 'class-validator';
import { IsArray, IsBoolean, IsString, ValidateNested } from 'class-validator';
import { Type } from 'class-transformer';
import { RaceDTO } from '../../race/dtos/RaceDTO';
export class LeagueScheduleDTO {
@ApiProperty()
@IsString()
seasonId!: string;
@ApiProperty({ description: 'Whether the season schedule is published' })
@IsBoolean()
published!: boolean;
@ApiProperty({ type: [RaceDTO] })
@IsArray()
@ValidateNested({ each: true })

51
apps/api/src/domain/league/dtos/LeagueScheduleRaceAdminDTO.ts Normal file
View File

@@ -0,0 +1,51 @@
import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
import { IsBoolean, IsISO8601, IsOptional, IsString } from 'class-validator';
export class CreateLeagueScheduleRaceInputDTO {
@ApiProperty()
@IsString()
track!: string;
@ApiProperty()
@IsString()
car!: string;
@ApiProperty({
description: 'ISO-8601 timestamp string (UTC recommended).',
example: '2025-01-01T12:00:00.000Z',
})
@IsISO8601()
scheduledAtIso!: string;
}
export class UpdateLeagueScheduleRaceInputDTO {
@ApiPropertyOptional()
@IsOptional()
@IsString()
track?: string;
@ApiPropertyOptional()
@IsOptional()
@IsString()
car?: string;
@ApiPropertyOptional({
description: 'ISO-8601 timestamp string (UTC recommended).',
example: '2025-01-01T12:00:00.000Z',
})
@IsOptional()
@IsISO8601()
scheduledAtIso?: string;
}
export class CreateLeagueScheduleRaceOutputDTO {
@ApiProperty()
@IsString()
raceId!: string;
}
export class LeagueScheduleRaceMutationSuccessDTO {
@ApiProperty()
@IsBoolean()
success!: boolean;
}

20
apps/api/src/domain/league/dtos/LeagueSeasonSchedulePublishDTO.ts Normal file
View File

@@ -0,0 +1,20 @@
import { ApiProperty } from '@nestjs/swagger';
import { IsBoolean } from 'class-validator';
/**
* Intentionally empty.
*
* With global ValidationPipe({ whitelist: true, forbidNonWhitelisted: true }),
* any unexpected body keys will be rejected (prevents identity spoofing / junk payloads).
*/
export class LeagueSeasonSchedulePublishInputDTO {}
export class LeagueSeasonSchedulePublishOutputDTO {
@ApiProperty()
@IsBoolean()
success!: boolean;
@ApiProperty({ description: 'Whether the season schedule is published after this operation' })
@IsBoolean()
published!: boolean;
}

4
apps/api/src/domain/league/dtos/RemoveLeagueMemberInputDTO.ts
View File

@@ -6,10 +6,6 @@ export class RemoveLeagueMemberInputDTO {
@IsString()
leagueId!: string;
@ApiProperty()
@IsString()
performerDriverId!: string;
@ApiProperty()
@IsString()
targetDriverId!: string;

8
apps/api/src/domain/league/dtos/TransferLeagueOwnershipInputDTO.ts Normal file
View File

@@ -0,0 +1,8 @@
import { ApiProperty } from '@nestjs/swagger';
import { IsString } from 'class-validator';
export class TransferLeagueOwnershipInputDTO {
@ApiProperty()
@IsString()
newOwnerId!: string;
}

20
apps/api/src/domain/league/dtos/UpdateLeagueMemberRoleInputDTO.ts
View File

@@ -1,20 +1,8 @@
import { ApiProperty } from '@nestjs/swagger';
import { IsString, IsEnum } from 'class-validator';
import { IsEnum } from 'class-validator';
export class UpdateLeagueMemberRoleInputDTO {
@ApiProperty()
@IsString()
leagueId!: string;
@ApiProperty()
@IsString()
performerDriverId!: string;
@ApiProperty()
@IsString()
targetDriverId!: string;
@ApiProperty({ enum: ['owner', 'manager', 'member'] })
@IsEnum(['owner', 'manager', 'member'])
newRole!: 'owner' | 'manager' | 'member';
@ApiProperty({ enum: ['owner', 'admin', 'steward', 'member'] })
@IsEnum(['owner', 'admin', 'steward', 'member'])
newRole!: 'owner' | 'admin' | 'steward' | 'member';
}

4
apps/api/src/domain/league/presenters/GetLeagueMembershipsPresenter.ts
View File

@@ -27,8 +27,8 @@ export class GetLeagueMembershipsPresenter implements UseCaseOutputPort<GetLeagu
joinedAt: driver!.joinedAt.toDate().toISOString(),
...(driver!.bio ? { bio: driver!.bio.toString() } : {}),
},
role: membership.role.toString() as 'owner' | 'manager' | 'member',
joinedAt: membership.joinedAt.toDate(),
role: membership.role.toString() as 'owner' | 'admin' | 'steward' | 'member',
joinedAt: membership.joinedAt.toDate().toISOString(),
}));
this.result = {
memberships: {

64
apps/api/src/domain/league/presenters/LeagueRosterAdminReadPresenters.ts Normal file
View File

@@ -0,0 +1,64 @@
import type { UseCaseOutputPort } from '@core/shared/application';
import type { GetLeagueRosterMembersResult } from '@core/racing/application/use-cases/GetLeagueRosterMembersUseCase';
import type { GetLeagueRosterJoinRequestsResult } from '@core/racing/application/use-cases/GetLeagueRosterJoinRequestsUseCase';
import type { LeagueRosterMemberDTO } from '../dtos/LeagueRosterMemberDTO';
import type { LeagueRosterJoinRequestDTO } from '../dtos/LeagueRosterJoinRequestDTO';
import type { DriverDTO } from '../../driver/dtos/DriverDTO';
export class GetLeagueRosterMembersPresenter implements UseCaseOutputPort<GetLeagueRosterMembersResult> {
private viewModel: LeagueRosterMemberDTO[] | null = null;
reset(): void {
this.viewModel = null;
}
present(result: GetLeagueRosterMembersResult): void {
this.viewModel = result.members.map(({ membership, driver }) => ({
driverId: membership.driverId.toString(),
driver: this.mapDriver(driver),
role: membership.role.toString() as 'owner' | 'admin' | 'steward' | 'member',
joinedAt: membership.joinedAt.toDate().toISOString(),
}));
}
getViewModel(): LeagueRosterMemberDTO[] | null {
return this.viewModel;
}
private mapDriver(driver: GetLeagueRosterMembersResult['members'][number]['driver']): DriverDTO {
return {
id: driver.id,
iracingId: driver.iracingId.toString(),
name: driver.name.toString(),
country: driver.country.toString(),
joinedAt: driver.joinedAt.toDate().toISOString(),
...(driver.bio ? { bio: driver.bio.toString() } : {}),
};
}
}
export class GetLeagueRosterJoinRequestsPresenter implements UseCaseOutputPort<GetLeagueRosterJoinRequestsResult> {
private viewModel: LeagueRosterJoinRequestDTO[] | null = null;
reset(): void {
this.viewModel = null;
}
present(result: GetLeagueRosterJoinRequestsResult): void {
this.viewModel = result.joinRequests.map(req => ({
id: req.id,
leagueId: req.leagueId,
driverId: req.driverId,
requestedAt: req.requestedAt.toISOString(),
...(req.message ? { message: req.message } : {}),
driver: {
id: req.driver.id,
name: req.driver.name.toString(),
},
}));
}
getViewModel(): LeagueRosterJoinRequestDTO[] | null {
return this.viewModel;
}
}

41
apps/api/src/domain/league/presenters/LeagueSchedulePresenter.test.ts Normal file
View File

@@ -0,0 +1,41 @@
import { describe, expect, it } from 'vitest';
import { LeagueSchedulePresenter } from './LeagueSchedulePresenter';
import { Race } from '@core/racing/domain/entities/Race';
describe('LeagueSchedulePresenter', () => {
it('includes seasonId on the schedule DTO and serializes dates to ISO strings', () => {
const presenter = new LeagueSchedulePresenter();
const race = Race.create({
id: 'race-1',
leagueId: 'league-1',
scheduledAt: new Date('2025-01-02T20:00:00Z'),
track: 'Spa',
car: 'GT3',
});
presenter.present({
league: { id: 'league-1' },
seasonId: 'season-1',
published: false,
races: [{ race }],
} as any);
const vm = presenter.getViewModel() as any;
expect(vm).not.toBeNull();
expect(vm.seasonId).toBe('season-1');
expect(vm.published).toBe(false);
expect(Array.isArray(vm.races)).toBe(true);
expect(vm.races[0]).toMatchObject({
id: 'race-1',
name: 'Spa - GT3',
date: '2025-01-02T20:00:00.000Z',
});
// Guard: dates must be ISO strings (no Date objects)
expect(typeof vm.races[0].date).toBe('string');
expect(vm.races[0].date).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
});
});

2
apps/api/src/domain/league/presenters/LeagueSchedulePresenter.ts
View File

@@ -12,6 +12,8 @@ export class LeagueSchedulePresenter implements UseCaseOutputPort<GetLeagueSched
present(result: GetLeagueScheduleResult, leagueName?: string) {
this.result = {
seasonId: result.seasonId,
published: result.published,
races: result.races.map(race => ({
id: race.race.id,
name: `${race.race.track} - ${race.race.car}`,

105
apps/api/src/domain/league/presenters/LeagueSeasonScheduleMutationPresenters.ts Normal file
View File

@@ -0,0 +1,105 @@
import type { UseCaseOutputPort } from '@core/shared/application';
import type {
CreateLeagueScheduleRaceOutputDTO,
LeagueScheduleRaceMutationSuccessDTO,
} from '../dtos/LeagueScheduleRaceAdminDTO';
import type { LeagueSeasonSchedulePublishOutputDTO } from '../dtos/LeagueSeasonSchedulePublishDTO';
import type { CreateLeagueSeasonScheduleRaceResult } from '@core/racing/application/use-cases/CreateLeagueSeasonScheduleRaceUseCase';
import type { UpdateLeagueSeasonScheduleRaceResult } from '@core/racing/application/use-cases/UpdateLeagueSeasonScheduleRaceUseCase';
import type { DeleteLeagueSeasonScheduleRaceResult } from '@core/racing/application/use-cases/DeleteLeagueSeasonScheduleRaceUseCase';
import type { PublishLeagueSeasonScheduleResult } from '@core/racing/application/use-cases/PublishLeagueSeasonScheduleUseCase';
import type { UnpublishLeagueSeasonScheduleResult } from '@core/racing/application/use-cases/UnpublishLeagueSeasonScheduleUseCase';
export class CreateLeagueSeasonScheduleRacePresenter
implements UseCaseOutputPort<CreateLeagueSeasonScheduleRaceResult>
{
private responseModel: CreateLeagueScheduleRaceOutputDTO | null = null;
present(result: CreateLeagueSeasonScheduleRaceResult): void {
this.responseModel = { raceId: result.raceId };
}
getResponseModel(): CreateLeagueScheduleRaceOutputDTO | null {
return this.responseModel;
}
reset(): void {
this.responseModel = null;
}
}
export class UpdateLeagueSeasonScheduleRacePresenter
implements UseCaseOutputPort<UpdateLeagueSeasonScheduleRaceResult>
{
private responseModel: LeagueScheduleRaceMutationSuccessDTO | null = null;
present(result: UpdateLeagueSeasonScheduleRaceResult): void {
void result;
this.responseModel = { success: true };
}
getResponseModel(): LeagueScheduleRaceMutationSuccessDTO | null {
return this.responseModel;
}
reset(): void {
this.responseModel = null;
}
}
export class DeleteLeagueSeasonScheduleRacePresenter
implements UseCaseOutputPort<DeleteLeagueSeasonScheduleRaceResult>
{
private responseModel: LeagueScheduleRaceMutationSuccessDTO | null = null;
present(result: DeleteLeagueSeasonScheduleRaceResult): void {
void result;
this.responseModel = { success: true };
}
getResponseModel(): LeagueScheduleRaceMutationSuccessDTO | null {
return this.responseModel;
}
reset(): void {
this.responseModel = null;
}
}
export class PublishLeagueSeasonSchedulePresenter
implements UseCaseOutputPort<PublishLeagueSeasonScheduleResult>
{
private responseModel: LeagueSeasonSchedulePublishOutputDTO | null = null;
present(result: PublishLeagueSeasonScheduleResult): void {
this.responseModel = { success: true, published: result.published };
}
getResponseModel(): LeagueSeasonSchedulePublishOutputDTO | null {
return this.responseModel;
}
reset(): void {
this.responseModel = null;
}
}
export class UnpublishLeagueSeasonSchedulePresenter
implements UseCaseOutputPort<UnpublishLeagueSeasonScheduleResult>
{
private responseModel: LeagueSeasonSchedulePublishOutputDTO | null = null;
present(result: UnpublishLeagueSeasonScheduleResult): void {
this.responseModel = { success: true, published: result.published };
}
getResponseModel(): LeagueSeasonSchedulePublishOutputDTO | null {
return this.responseModel;
}
reset(): void {
this.responseModel = null;
}
}

6
apps/api/src/domain/league/presenters/RejectLeagueJoinRequestPresenter.ts
View File

@@ -10,11 +10,9 @@ export class RejectLeagueJoinRequestPresenter implements UseCaseOutputPort<Rejec
}
present(result: RejectLeagueJoinRequestResult): void {
void result;
this.result = {
success: true,
message: 'Join request rejected successfully',
success: result.success,
message: result.message,
};
}

7
apps/api/src/domain/race/presenters/GetAllRacesPresenter.ts
View File

@@ -24,10 +24,13 @@ export class GetAllRacesPresenter implements UseCaseOutputPort<GetAllRacesResult
track: race.track,
car: race.car,
scheduledAt: race.scheduledAt.toISOString(),
status: race.status,
status: race.status.toString(),
leagueId: race.leagueId,
leagueName: leagueMap.get(race.leagueId) ?? 'Unknown League',
strengthOfField: race.strengthOfField ?? null,
strengthOfField:
typeof race.strengthOfField === 'number'
? race.strengthOfField
: race.strengthOfField?.toNumber() ?? null,
})),
filters: {
statuses: [

10
apps/api/src/domain/race/presenters/RaceDetailPresenter.ts
View File

@@ -42,9 +42,13 @@ export class RaceDetailPresenter implements UseCaseOutputPort<GetRaceDetailResul
scheduledAt: output.race.scheduledAt.toISOString(),
sessionType: output.race.sessionType.toString(),
status: output.race.status.toString(),
strengthOfField: output.race.strengthOfField ?? null,
...(output.race.registeredCount !== undefined && { registeredCount: output.race.registeredCount }),
...(output.race.maxParticipants !== undefined && { maxParticipants: output.race.maxParticipants }),
strengthOfField: output.race.strengthOfField?.toNumber() ?? null,
...(output.race.registeredCount !== undefined && {
registeredCount: output.race.registeredCount.toNumber(),
}),
...(output.race.maxParticipants !== undefined && {
maxParticipants: output.race.maxParticipants.toNumber(),
}),
}
: null;

8
apps/api/src/domain/race/presenters/RacesPageDataPresenter.ts
View File

@@ -36,13 +36,13 @@ export class RacesPageDataPresenter {
track: race.track,
car: race.car,
scheduledAt: race.scheduledAt.toISOString(),
status: race.status,
status: race.status.toString(),
leagueId: race.leagueId,
leagueName,
strengthOfField: race.strengthOfField ?? null,
strengthOfField: race.strengthOfField?.toNumber() ?? null,
isUpcoming: race.scheduledAt > new Date(),
isLive: race.status === 'running',
isPast: race.scheduledAt < new Date() && race.status === 'completed',
isLive: race.status.isRunning(),
isPast: race.scheduledAt < new Date() && race.status.isCompleted(),
}));
this.model = { races } as RacesPageDataDTO;

160
apps/api/src/shared/testing/contractValidation.test.ts
View File

@@ -8,6 +8,9 @@
import { describe, it, expect } from 'vitest';
import * as fs from 'fs/promises';
import * as path from 'path';
import * as os from 'os';
import { execFile } from 'node:child_process';
import { promisify } from 'node:util';
interface OpenAPISchema {
type?: string;
@@ -38,6 +41,7 @@ describe('API Contract Validation', () => {
const apiRoot = path.join(__dirname, '../../..');
const openapiPath = path.join(apiRoot, 'openapi.json');
const generatedTypesDir = path.join(apiRoot, '../website/lib/types/generated');
const execFileAsync = promisify(execFile);
describe('OpenAPI Spec Integrity', () => {
it('should have a valid OpenAPI spec file', async () => {
@@ -53,7 +57,7 @@ describe('API Contract Validation', () => {
it('should have required OpenAPI fields', async () => {
const content = await fs.readFile(openapiPath, 'utf-8');
const spec: OpenAPISpec = JSON.parse(content);
expect(spec.openapi).toMatch(/^3\.\d+\.\d+$/);
expect(spec.info).toBeDefined();
expect(spec.info.title).toBeDefined();
@@ -62,6 +66,105 @@ describe('API Contract Validation', () => {
expect(spec.components.schemas).toBeDefined();
});
it('committed openapi.json should match generator output', async () => {
const repoRoot = path.join(apiRoot, '../..');
const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gridpilot-openapi-'));
const generatedOpenapiPath = path.join(tmpDir, 'openapi.json');
await execFileAsync(
'npx',
['--no-install', 'tsx', 'scripts/generate-openapi-spec.ts', '--output', generatedOpenapiPath],
{ cwd: repoRoot, maxBuffer: 20 * 1024 * 1024 },
);
const committed: OpenAPISpec = JSON.parse(await fs.readFile(openapiPath, 'utf-8'));
const generated: OpenAPISpec = JSON.parse(await fs.readFile(generatedOpenapiPath, 'utf-8'));
expect(generated).toEqual(committed);
});
it('should include real HTTP paths for known routes', async () => {
const content = await fs.readFile(openapiPath, 'utf-8');
const spec: OpenAPISpec = JSON.parse(content);
const pathKeys = Object.keys(spec.paths ?? {});
expect(pathKeys.length).toBeGreaterThan(0);
// A couple of stable routes to detect "empty/stale" specs.
expect(spec.paths['/drivers/leaderboard']).toBeDefined();
expect(spec.paths['/dashboard/overview']).toBeDefined();
// Sanity-check the operation objects exist (method keys are lowercase in OpenAPI).
expect(spec.paths['/drivers/leaderboard'].get).toBeDefined();
expect(spec.paths['/dashboard/overview'].get).toBeDefined();
});
it('should include league schedule publish/unpublish endpoints and published state', async () => {
const content = await fs.readFile(openapiPath, 'utf-8');
const spec: OpenAPISpec = JSON.parse(content);
expect(spec.paths['/leagues/{leagueId}/seasons/{seasonId}/schedule/publish']).toBeDefined();
expect(spec.paths['/leagues/{leagueId}/seasons/{seasonId}/schedule/publish'].post).toBeDefined();
expect(spec.paths['/leagues/{leagueId}/seasons/{seasonId}/schedule/unpublish']).toBeDefined();
expect(spec.paths['/leagues/{leagueId}/seasons/{seasonId}/schedule/unpublish'].post).toBeDefined();
const scheduleSchema = spec.components.schemas['LeagueScheduleDTO'];
if (!scheduleSchema) {
throw new Error('Expected LeagueScheduleDTO schema to be present in OpenAPI spec');
}
expect(scheduleSchema.properties?.published).toBeDefined();
expect(scheduleSchema.properties?.published?.type).toBe('boolean');
expect(scheduleSchema.required ?? []).toContain('published');
});
it('should include league roster admin read endpoints and schemas', async () => {
const content = await fs.readFile(openapiPath, 'utf-8');
const spec: OpenAPISpec = JSON.parse(content);
expect(spec.paths['/leagues/{leagueId}/admin/roster/members']).toBeDefined();
expect(spec.paths['/leagues/{leagueId}/admin/roster/members'].get).toBeDefined();
expect(spec.paths['/leagues/{leagueId}/admin/roster/join-requests']).toBeDefined();
expect(spec.paths['/leagues/{leagueId}/admin/roster/join-requests'].get).toBeDefined();
expect(spec.paths['/leagues/{leagueId}/admin/roster/join-requests/{joinRequestId}/approve']).toBeDefined();
expect(spec.paths['/leagues/{leagueId}/admin/roster/join-requests/{joinRequestId}/approve'].post).toBeDefined();
expect(spec.paths['/leagues/{leagueId}/admin/roster/join-requests/{joinRequestId}/reject']).toBeDefined();
expect(spec.paths['/leagues/{leagueId}/admin/roster/join-requests/{joinRequestId}/reject'].post).toBeDefined();
const memberSchema = spec.components.schemas['LeagueRosterMemberDTO'];
if (!memberSchema) {
throw new Error('Expected LeagueRosterMemberDTO schema to be present in OpenAPI spec');
}
expect(memberSchema.properties?.driverId).toBeDefined();
expect(memberSchema.properties?.role).toBeDefined();
expect(memberSchema.properties?.joinedAt).toBeDefined();
expect(memberSchema.required ?? []).toContain('driverId');
expect(memberSchema.required ?? []).toContain('role');
expect(memberSchema.required ?? []).toContain('joinedAt');
expect(memberSchema.required ?? []).toContain('driver');
const joinRequestSchema = spec.components.schemas['LeagueRosterJoinRequestDTO'];
if (!joinRequestSchema) {
throw new Error('Expected LeagueRosterJoinRequestDTO schema to be present in OpenAPI spec');
}
expect(joinRequestSchema.properties?.id).toBeDefined();
expect(joinRequestSchema.properties?.leagueId).toBeDefined();
expect(joinRequestSchema.properties?.driverId).toBeDefined();
expect(joinRequestSchema.properties?.requestedAt).toBeDefined();
expect(joinRequestSchema.required ?? []).toContain('id');
expect(joinRequestSchema.required ?? []).toContain('leagueId');
expect(joinRequestSchema.required ?? []).toContain('driverId');
expect(joinRequestSchema.required ?? []).toContain('requestedAt');
expect(joinRequestSchema.required ?? []).toContain('driver');
});
it('should have no circular references in schemas', async () => {
const content = await fs.readFile(openapiPath, 'utf-8');
const spec: OpenAPISpec = JSON.parse(content);
@@ -113,19 +216,30 @@ describe('API Contract Validation', () => {
});
describe('DTO Consistency', () => {
it('should have DTO files for all schemas', async () => {
it('should have generated DTO files for critical schemas', async () => {
const content = await fs.readFile(openapiPath, 'utf-8');
const spec: OpenAPISpec = JSON.parse(content);
const schemas = Object.keys(spec.components.schemas);
const generatedFiles = await fs.readdir(generatedTypesDir);
const generatedDTOs = generatedFiles
.filter(f => f.endsWith('.ts'))
.map(f => f.replace('.ts', ''));
// All schemas should have corresponding generated DTOs
for (const schema of schemas) {
expect(generatedDTOs).toContain(schema);
// We intentionally do NOT require a 1:1 mapping for *all* schemas here.
// OpenAPI generation and type generation can be run as separate steps,
// and new schemas should not break API contract validation by themselves.
const criticalDTOs = [
'RequestAvatarGenerationInputDTO',
'RequestAvatarGenerationOutputDTO',
'UploadMediaInputDTO',
'UploadMediaOutputDTO',
'RaceDTO',
'DriverDTO',
];
for (const dtoName of criticalDTOs) {
expect(spec.components.schemas[dtoName]).toBeDefined();
expect(generatedDTOs).toContain(dtoName);
}
});
@@ -166,12 +280,19 @@ describe('API Contract Validation', () => {
for (const file of dtos) {
const content = await fs.readFile(path.join(generatedTypesDir, file), 'utf-8');
// Basic TypeScript syntax checks
// `index.ts` is a generated barrel file (no interfaces).
if (file === 'index.ts') {
expect(content).toContain('export type {');
expect(content).toContain("from './");
continue;
}
// Basic TypeScript syntax checks (DTO interfaces)
expect(content).toContain('export interface');
expect(content).toContain('{');
expect(content).toContain('}');
// Should not have syntax errors (basic check)
expect(content).not.toContain('undefined;');
expect(content).not.toContain('any;');
@@ -233,25 +354,16 @@ describe('API Contract Validation', () => {
const spec: OpenAPISpec = JSON.parse(content);
const schemas = spec.components.schemas;
for (const [schemaName, schema] of Object.entries(schemas)) {
for (const [, schema] of Object.entries(schemas)) {
const required = new Set(schema.required ?? []);
if (!schema.properties) continue;
for (const [propName, propSchema] of Object.entries(schema.properties)) {
const dtoPath = path.join(generatedTypesDir, `${schemaName}.ts`);
const dtoContent = await fs.readFile(dtoPath, 'utf-8');
if (!propSchema.nullable) continue;
if (propSchema.nullable) {
// Nullable properties should be optional OR include `| null` in the type.
const propRegex = new RegExp(`${propName}(\\?)?:\\s*([^;]+);`);
const match = dtoContent.match(propRegex);
if (match) {
const optionalMark = match[1];
const typeText = match[2] ?? '';
expect(optionalMark === '?' || typeText.includes('| null')).toBe(true);
}
}
// In OpenAPI 3.0, a `nullable: true` property should not be listed as required,
// otherwise downstream generators can't represent it safely.
expect(required.has(propName)).toBe(false);
}
}
});