diff --git a/apps/api/src/modules/auction/auction-durability.scheduler.spec.ts b/apps/api/src/modules/auction/auction-durability.scheduler.spec.ts index f211e0a8..4cceabd4 100644 --- a/apps/api/src/modules/auction/auction-durability.scheduler.spec.ts +++ b/apps/api/src/modules/auction/auction-durability.scheduler.spec.ts @@ -960,7 +960,10 @@ describe('auction durability projection helpers', () => { const sideEffectUpdateOne = jest.fn().mockReturnValue({ exec: jest.fn().mockResolvedValue({ matchedCount: 1, modifiedCount: 1 }), }); - const reserveForMatch = jest.fn().mockResolvedValue(match); + const reserveForMatch = jest.fn().mockImplementation(() => { + expect(match.teamBuiltAt).toBeUndefined(); + return Promise.resolve(match); + }); const scheduleInitialPoll = jest.fn().mockResolvedValue(null); const mirrorMatchSideEffectStatus = jest.fn().mockResolvedValue(true); const broadcastMatchSideEffect = jest.fn(); @@ -1010,7 +1013,7 @@ describe('auction durability projection helpers', () => { teamIndex: 1, }, ]); - expect(match.save).toHaveBeenCalledTimes(1); + expect(match.save).toHaveBeenCalledTimes(2); expect(reserveForMatch).toHaveBeenCalledWith(match); expect(scheduleInitialPoll).toHaveBeenCalledWith(match); expect(sideEffectUpdateOne).toHaveBeenCalledWith( diff --git a/apps/api/src/modules/auction/auction-durability.scheduler.ts b/apps/api/src/modules/auction/auction-durability.scheduler.ts index f1df8715..7163e204 100644 --- a/apps/api/src/modules/auction/auction-durability.scheduler.ts +++ b/apps/api/src/modules/auction/auction-durability.scheduler.ts @@ -80,6 +80,7 @@ type ParsedMatchSideEffectMutation = | { type: typeof UNDO_COMPLETED_MATCH_SIDE_EFFECT_TYPE }; interface CleanupSideEffectMatchDocument { + competitionId?: unknown; gameSchedule?: unknown[]; participants: Array<{ excluded?: boolean }>; result?: unknown; @@ -420,13 +421,14 @@ export class AuctionDurabilityScheduler }, ); if (!processingDelta) return; - let expectedMatchSideEffectRevision = + const expectedMatchSideEffectRevision = processingDelta.matchSideEffectRevision; try { const match = (await execMaybe( MatchModel.findById(payload.matchId) as never, )) as { + competitionId?: unknown; participants: Array<{ preferredPositions?: Array<{ position?: Position }>; userId: { toString(): string }; @@ -438,39 +440,50 @@ export class AuctionDurabilityScheduler } | null; if (!match) throw new Error(`Match not found: ${String(payload.matchId)}`); - const matchTeams = buildMatchTeamsFromProjection( - payload.afterAuctionMongoProjection, - match, - ); - // [AUCTION-DEBUG] 제거 대상. 최종 팀에 같은 유저가 2번 들어갔는지 무조건 검사 - // (출처가 markSold든 undo 복원이든 projection이든 여기서 결정적으로 잡힌다). - const allMemberUserIds = matchTeams.flatMap((team) => - team.members.map((member) => member.userId.toString()), - ); - const distinctMemberCount = new Set(allMemberUserIds).size; - recordNewRelicCustomEvent('AuctionServerTeamBuild', { - matchId: typeof payload.matchId === 'string' ? payload.matchId : '', - auctionStateTransitionId: payload.auctionStateTransitionId, - teamCount: matchTeams.length, - totalMemberCount: allMemberUserIds.length, - distinctMemberCount, - hasDuplicateMember: allMemberUserIds.length !== distinctMemberCount, - duplicateUserId: - allMemberUserIds.find( - (id, idx) => allMemberUserIds.indexOf(id) !== idx, - ) ?? null, - }); - if (matchTeams.length === 0) { - throw new Error( - `Auction complete side effect produced no match teams for match ${String(payload.matchId)}.`, + if (match.competitionId) { + await this.tournamentResultService.scheduleInitialPoll(match as never); + } else { + const matchTeams = buildMatchTeamsFromProjection( + payload.afterAuctionMongoProjection, + match, + ); + // [AUCTION-DEBUG] 제거 대상. 최종 팀에 같은 유저가 2번 들어갔는지 무조건 검사 + // (출처가 markSold든 undo 복원이든 projection이든 여기서 결정적으로 잡힌다). + const allMemberUserIds = matchTeams.flatMap((team) => + team.members.map((member) => member.userId.toString()), + ); + const distinctMemberCount = new Set(allMemberUserIds).size; + recordNewRelicCustomEvent('AuctionServerTeamBuild', { + matchId: typeof payload.matchId === 'string' ? payload.matchId : '', + auctionStateTransitionId: payload.auctionStateTransitionId, + teamCount: matchTeams.length, + totalMemberCount: allMemberUserIds.length, + distinctMemberCount, + hasDuplicateMember: allMemberUserIds.length !== distinctMemberCount, + duplicateUserId: + allMemberUserIds.find( + (id, idx) => allMemberUserIds.indexOf(id) !== idx, + ) ?? null, + }); + if (matchTeams.length === 0) { + throw new Error( + `Auction complete side effect produced no match teams for match ${String(payload.matchId)}.`, + ); + } + const finalizedAt = match.teamBuiltAt ?? new Date(); + match.teams = matchTeams; + match.status = 'team-built'; + match.teamBuiltAt = undefined; + await match.save(); + const preparedMatch = + (await this.tournamentCodeService.reserveForMatch(match as never)) ?? + match; + preparedMatch.teamBuiltAt = finalizedAt; + await preparedMatch.save(); + await this.tournamentResultService.scheduleInitialPoll( + preparedMatch as never, ); } - match.teams = matchTeams; - match.status = 'team-built'; - match.teamBuiltAt = match.teamBuiltAt ?? new Date(); - await match.save(); - await this.tournamentCodeService.reserveForMatch(match as never); - await this.tournamentResultService.scheduleInitialPoll(match as never); const completedAtTimestampMS = await this.auctionRedisService.getCurrentRedisTimestampMS(); @@ -543,7 +556,9 @@ export class AuctionDurabilityScheduler await this.isAppendHistoryInvalidatedByLaterDestructiveMutation(params); if (invalidated) return; - const historyOperation = buildAuctionHistoryUpsert(params.payload).updateOne; + const historyOperation = buildAuctionHistoryUpsert( + params.payload, + ).updateOne; await execMaybe( params.AuctionHistoryModel.updateOne( historyOperation.filter as never, @@ -700,7 +715,7 @@ export class AuctionDurabilityScheduler }, ); if (!processingDelta) return; - let expectedMatchSideEffectRevision = + const expectedMatchSideEffectRevision = processingDelta.matchSideEffectRevision; try { @@ -710,6 +725,11 @@ export class AuctionDurabilityScheduler if (!match) { throw new Error(`Match not found: ${String(params.payload.matchId)}`); } + if (match.competitionId) { + throw new Error( + 'Cannot reset or undo Match teams after the immutable Competition has been created.', + ); + } await params.updateMatch(match); const completedAtTimestampMS = diff --git a/apps/api/src/modules/auction/auction.service.spec.ts b/apps/api/src/modules/auction/auction.service.spec.ts index 9e53a110..695e8b49 100644 --- a/apps/api/src/modules/auction/auction.service.spec.ts +++ b/apps/api/src/modules/auction/auction.service.spec.ts @@ -2072,13 +2072,17 @@ describe('AuctionService', () => { findById: jest.fn().mockResolvedValue(match), }, }); + tournamentCodeService.reserveForMatch.mockImplementation((candidate) => { + expect(candidate.teamBuiltAt).toBeUndefined(); + return Promise.resolve(candidate); + }); await service.next(matchId); expect(auction.phase).toBe('complete'); expect(auction.completedAt).toBeInstanceOf(Date); expect(auction.save).toHaveBeenCalledTimes(1); - expect(match.save).toHaveBeenCalledTimes(1); + expect(match.save).toHaveBeenCalledTimes(2); expect(match.teams).toEqual([ { teamIndex: 1, @@ -2174,6 +2178,55 @@ describe('AuctionService', () => { expect(session.commitTransaction).toHaveBeenCalledTimes(1); }); + it('rejects auction reset after Competition bootstrap', async () => { + const matchId = new mongoose.Types.ObjectId(); + const communityId = new mongoose.Types.ObjectId(); + const session = { + startTransaction: jest.fn(), + commitTransaction: jest.fn().mockResolvedValue(undefined), + abortTransaction: jest.fn().mockResolvedValue(undefined), + endSession: jest.fn().mockResolvedValue(undefined), + }; + const auction = { + deleteOne: jest.fn(), + }; + const match = { + communityId, + competitionId: new mongoose.Types.ObjectId(), + status: 'team-built', + teams: [{ teamIndex: 1 }], + tournamentCodeIds: [], + gameSchedule: [], + participants: [], + save: jest.fn(), + }; + const { service, connectionService, tournamentCodeService } = createService( + { + auction: { + findOne: jest.fn().mockReturnValue({ + session: jest.fn().mockResolvedValue(auction), + }), + }, + match: { + findById: jest.fn().mockReturnValue({ + session: jest.fn().mockResolvedValue(match), + }), + }, + }, + ); + connectionService.createSession.mockResolvedValue(session); + + await expect(service.reset({ matchId, communityId })).rejects.toThrow( + 'immutable Competition', + ); + + expect(session.abortTransaction).toHaveBeenCalledTimes(1); + expect(session.commitTransaction).not.toHaveBeenCalled(); + expect(auction.deleteOne).not.toHaveBeenCalled(); + expect(tournamentCodeService.releaseFromMatch).not.toHaveBeenCalled(); + expect(match.save).not.toHaveBeenCalled(); + }); + it('fully deletes redis-v1 auction data when cancelling an auction', async () => { const matchId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId(); diff --git a/apps/api/src/modules/auction/auction.service.ts b/apps/api/src/modules/auction/auction.service.ts index 6c92e9a6..3737ea2f 100644 --- a/apps/api/src/modules/auction/auction.service.ts +++ b/apps/api/src/modules/auction/auction.service.ts @@ -1,5 +1,6 @@ import { BadRequestException, + ConflictException, Injectable, InternalServerErrorException, Logger, @@ -471,7 +472,7 @@ export class AuctionService { ? auction.toObject({ depopulate: true }) : auction; return { - ...JSON.parse(JSON.stringify(mongoState)), + ...this.cloneJson(mongoState), ...redisState, chatMessages: auction.chatMessages ?? [], }; @@ -1061,8 +1062,8 @@ export class AuctionService { return this.resolveReplayedRedisActionRequest(matchId, actionRequest); } - const passedPlayer = { - ...JSON.parse(JSON.stringify(currentPlayer)), + const passedPlayer: AuctionPlayerSnapshot = { + ...this.cloneAuctionPlayerSnapshot(currentPlayer), passCount: this.numberFromState(currentPlayer.passCount) + 1, }; structureInput.auctionPlayerOrder[ @@ -1157,8 +1158,8 @@ export class AuctionService { ]; if (!currentPlayer) throw new BadRequestException('No current player.'); - const passedPlayer = { - ...JSON.parse(JSON.stringify(currentPlayer)), + const passedPlayer: AuctionPlayerSnapshot = { + ...this.cloneAuctionPlayerSnapshot(currentPlayer), passCount: this.numberFromState(currentPlayer.passCount) + 1, }; structureInput.auctionPlayerOrder[ @@ -1210,7 +1211,7 @@ export class AuctionService { structureInput.auctionPlayerOrder = [ ...structureInput.auctionPlayerOrder, ...structureInput.passedAuctionPlayerQueue.map((player) => - JSON.parse(JSON.stringify(player)), + this.cloneAuctionPlayerSnapshot(player), ), ]; structureInput.passedAuctionPlayerQueue = []; @@ -1434,6 +1435,7 @@ export class AuctionService { if (!match.communityId.equals(params.communityId)) { throw new BadRequestException('Community mismatch.'); } + this.assertCompetitionLifecycleMutable(match, 'reset the auction'); if (this.isRedisV1Auction(auction)) { redisRuntimeToClear = { @@ -1543,11 +1545,17 @@ export class AuctionService { const undoingCompletedAuction = Boolean(auction.completedAt) && !('completedAt' in snapshot); + if (undoingCompletedAuction) { + this.assertCompetitionLifecycleMutable( + match, + 'undo a completed auction', + ); + } if (this.isRedisV1Auction(auction)) { redisUndoContext = { auction, actionRequestParams: params, - snapshot: snapshot as Record, + snapshot: snapshot, targetHistorySequence: params.sequence, undoingCompletedAuction, }; @@ -2111,7 +2119,7 @@ export class AuctionService { ? (auction.toObject({ depopulate: true }) as Record) : (auction as unknown as Record); return { - ...JSON.parse(JSON.stringify(base)), + ...this.cloneJson(base), ...this.buildAuctionMongoProjectionFromState(auction, state), _id: auction._id, matchId: auction.matchId, @@ -2220,11 +2228,11 @@ export class AuctionService { >[0]['auctionTeams'], ): AuctionTeam[] { return auctionTeams.map((team) => ({ - captainUserId: team.captainUserId as mongoose.Types.ObjectId, + captainUserId: team.captainUserId, members: (team.members ?? []).map((member) => ({ assignedPosition: member.assignedPosition, cost: member.memberAcquisitionBidPointAmount, - userId: member.userId as mongoose.Types.ObjectId, + userId: member.userId, })), points: team.remainingBidPointAmount, teamIndex: team.teamIndex, @@ -2247,7 +2255,11 @@ export class AuctionService { // 구조 전환 핸들러가 이 작업본을 변이하므로 snapshotBefore 원본과 참조를 공유하면 안 된다. // structuredClone은 ObjectId를 [object Object]로 망가뜨리므로, 코드베이스 관행대로 // JSON 클론으로 깊은 복사 + ObjectId/Date 정규화를 함께 수행한다. - return JSON.parse(JSON.stringify(this.arrayFromState(value))) as T[]; + return this.cloneJson(this.arrayFromState(value)); + } + + private cloneJson(value: T): T { + return JSON.parse(JSON.stringify(value)) as T; } private numberFromState(value: unknown, fallback = 0): number { @@ -2455,7 +2467,7 @@ export class AuctionService { sequence: (latest?.sequence ?? 0) + 1, action, actorUserId, - snapshotBefore: JSON.parse(JSON.stringify(snapshotBefore)), + snapshotBefore: this.cloneJson(snapshotBefore), takenAt: new Date(), }); } @@ -2612,6 +2624,17 @@ export class AuctionService { return auction.auctionEngineVersion === 'redis-v1'; } + private assertCompetitionLifecycleMutable( + match: Pick, + action: string, + ): void { + if (match.competitionId) { + throw new ConflictException( + `Cannot ${action} after the immutable Competition has been created. Create a new Match instead.`, + ); + } + } + private isRestartableResetRedisAuction(auction: AuctionDocument): boolean { return ( this.isRedisV1Auction(auction) && @@ -2661,6 +2684,10 @@ export class AuctionService { const MatchModel = await this.connectionService.getModel('match'); const match = await MatchModel.findById(auction.matchId); if (!match) throw new NotFoundException('Match not found.'); + if (match.competitionId) { + await this.tournamentResultService.scheduleInitialPoll(match); + return; + } const participantByUserId = new Map( match.participants.map((participant) => [ @@ -2698,12 +2725,16 @@ export class AuctionService { `Auction completed without teams for match ${match._id.toString()}.`, ); } + const finalizedAt = match.teamBuiltAt ?? new Date(); match.teams = matchTeams; match.status = 'team-built'; - match.teamBuiltAt = match.teamBuiltAt ?? new Date(); + match.teamBuiltAt = undefined; await match.save(); - await this.tournamentCodeService.reserveForMatch(match); - await this.tournamentResultService.scheduleInitialPoll(match); + const preparedMatch = + (await this.tournamentCodeService.reserveForMatch(match)) ?? match; + preparedMatch.teamBuiltAt = finalizedAt; + await preparedMatch.save(); + await this.tournamentResultService.scheduleInitialPoll(preparedMatch); } private async syncMatchTeamsFromRedisAuctionState( @@ -2713,6 +2744,10 @@ export class AuctionService { const MatchModel = await this.connectionService.getModel('match'); const match = await MatchModel.findById(auction.matchId); if (!match) throw new NotFoundException('Match not found.'); + if (match.competitionId) { + await this.tournamentResultService.scheduleInitialPoll(match); + return; + } const participantByUserId = new Map( match.participants.map((participant) => [ @@ -2757,12 +2792,16 @@ export class AuctionService { `Redis auction completed without teams for match ${match._id.toString()}.`, ); } + const finalizedAt = match.teamBuiltAt ?? new Date(); match.teams = matchTeams; match.status = 'team-built'; - match.teamBuiltAt = match.teamBuiltAt ?? new Date(); + match.teamBuiltAt = undefined; await match.save(); - await this.tournamentCodeService.reserveForMatch(match); - await this.tournamentResultService.scheduleInitialPoll(match); + const preparedMatch = + (await this.tournamentCodeService.reserveForMatch(match)) ?? match; + preparedMatch.teamBuiltAt = finalizedAt; + await preparedMatch.save(); + await this.tournamentResultService.scheduleInitialPoll(preparedMatch); } private async hydrateRedisStateFromAuctionDocument( @@ -2948,7 +2987,7 @@ export class AuctionService { void this.refreshOrderSnapshotsFromRiot(params).catch((error: unknown) => { this.logger.warn( `Auction background Riot refresh failed for ${params.auctionId.toString()}: ${ - error instanceof Error ? error.message : error + error instanceof Error ? error.message : String(error) }`, ); }); @@ -3004,7 +3043,7 @@ export class AuctionService { } catch (error: unknown) { this.logger.warn( `Failed to refresh auction Riot snapshot for ${target.puuid}: ${ - error instanceof Error ? error.message : error + error instanceof Error ? error.message : String(error) }`, ); } diff --git a/apps/api/src/modules/community-stats/community-stats.service.spec.ts b/apps/api/src/modules/community-stats/community-stats.service.spec.ts index 5de46644..954a7b12 100644 --- a/apps/api/src/modules/community-stats/community-stats.service.spec.ts +++ b/apps/api/src/modules/community-stats/community-stats.service.spec.ts @@ -8,7 +8,11 @@ import type { } from './community-stats.types'; import { MatchStatsRepository } from './match-stats.repository'; import { MatchStatsService } from './match-stats.service'; -import type { InternalGameDetail, InternalRecord } from './match-stats.types'; +import { + MATCH_STATS_BUILDER_VERSION, + type InternalGameDetail, + type InternalRecord, +} from './match-stats.types'; function objectives() { return { @@ -219,8 +223,9 @@ describe('CommunityStatsService', () => { matchStatsRepository, {} as MatchStatsService, ); - (service as unknown as { resolveContext: jest.Mock }).resolveContext = - jest.fn().mockResolvedValue({ + (service as unknown as { resolveContext: jest.Mock }).resolveContext = jest + .fn() + .mockResolvedValue({ community: {}, season: { id: 'all', @@ -275,7 +280,12 @@ describe('CommunityStatsService', () => { participant.userId = userId.toString(); let resolveFragments: - | ((fragments: Array<{ matchId: mongoose.Types.ObjectId; records: InternalRecord[] }>) => void) + | (( + fragments: Array<{ + matchId: mongoose.Types.ObjectId; + records: InternalRecord[]; + }>, + ) => void) | undefined; const fragmentsPromise = new Promise< Array<{ matchId: mongoose.Types.ObjectId; records: InternalRecord[] }> @@ -296,8 +306,9 @@ describe('CommunityStatsService', () => { matchStatsRepository, {} as MatchStatsService, ); - (service as unknown as { resolveContext: jest.Mock }).resolveContext = - jest.fn().mockResolvedValue({ + (service as unknown as { resolveContext: jest.Mock }).resolveContext = jest + .fn() + .mockResolvedValue({ community: {}, season: { id: 'all', @@ -329,4 +340,83 @@ describe('CommunityStatsService', () => { ); expect(cacheService.set).toHaveBeenCalledTimes(1); }); + + it('self-heals Competition fragments when their source revision is stale', async () => { + const communityId = new mongoose.Types.ObjectId(); + const matchId = new mongoose.Types.ObjectId(); + const competitionId = new mongoose.Types.ObjectId(); + const matches = [{ _id: matchId, competitionId }]; + const MatchModel = { + find: jest.fn().mockReturnValue({ + sort: jest.fn().mockReturnValue({ + limit: jest.fn().mockReturnValue({ + select: jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue(matches), + }), + }), + }), + }), + }; + const CompetitionModel = { + find: jest.fn().mockReturnValue({ + select: jest.fn().mockReturnValue({ + lean: jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue([ + { + _id: competitionId, + revision: 7, + projectorVersion: 3, + }, + ]), + }), + }), + }), + }; + const connectionService = { + getModel: jest.fn().mockImplementation((name: string) => { + if (name === 'match') return Promise.resolve(MatchModel); + if (name === 'competition') return Promise.resolve(CompetitionModel); + throw new Error(`Unexpected model ${name}`); + }), + } as unknown as ConnectionService; + const matchStatsRepository = { + findByCommunity: jest.fn().mockResolvedValue([ + { + matchId, + builderVersion: MATCH_STATS_BUILDER_VERSION, + sourceCompetitionId: competitionId, + sourceRevision: 6, + projectorVersion: 3, + }, + ]), + } as unknown as jest.Mocked; + const matchStatsService = { + buildAndUpsert: jest.fn().mockResolvedValue(undefined), + } as unknown as jest.Mocked; + const service = new CommunityStatsService( + connectionService, + {} as CommunityStatsCacheService, + matchStatsRepository, + matchStatsService, + ); + + const rebuilt = await ( + service as unknown as { + rebuildMissingOrStaleFragments( + communityId: mongoose.Types.ObjectId, + ): Promise; + } + ).rebuildMissingOrStaleFragments(communityId); + + expect(MatchModel.find).toHaveBeenCalledWith({ + communityId, + status: { $in: ['finished', 'in-progress'] }, + $or: [ + { competitionId: { $exists: true } }, + { 'result.games.0': { $exists: true } }, + ], + }); + expect(matchStatsService.buildAndUpsert).toHaveBeenCalledWith(matchId); + expect(rebuilt).toBe(1); + }); }); diff --git a/apps/api/src/modules/community-stats/community-stats.service.ts b/apps/api/src/modules/community-stats/community-stats.service.ts index aa843f7e..59cc774d 100644 --- a/apps/api/src/modules/community-stats/community-stats.service.ts +++ b/apps/api/src/modules/community-stats/community-stats.service.ts @@ -238,58 +238,56 @@ export class CommunityStatsService { } const response: InternalMatchDetailResponse = { match, - games: gameDetails.map( - (game) => ({ - gameNumber: game.gameNumber, - riotMatchId: game.riotMatchId, - gameCreation: game.gameCreation, - gameDuration: game.gameDuration, - gameVersion: game.gameVersion, - timeline: game.timeline ?? [], - objectiveEvents: game.objectiveEvents ?? [], - teams: game.teams.map((team) => ({ - teamIndex: team.teamIndex, - side: team.side, - win: team.win, - objectives: team.objectives, - bans: team.bans ?? [], - participants: team.participants.map((record) => ({ - userId: record.userId, - summonerName: record.summonerName, - tagLine: record.tagLine, - teamIndex: record.teamIndex, - side: record.side, - teamPosition: record.teamPosition, - championId: record.championId, - championLevel: record.championLevel, - kills: record.kills, - deaths: record.deaths, - assists: record.assists, - cs: record.cs, - csPerMin: record.csPerMin, - gold: record.gold, - gpm: record.gpm, - damageDealtToChampions: record.damageDealtToChampions, - damageTaken: record.damageTaken, - damageShare: record.damageShare, - killParticipation: record.killParticipation, - visionScore: record.visionScore, - wardsPlaced: record.wardsPlaced, - wardsKilled: record.wardsKilled, - controlWardsBought: record.controlWardsBought, - firstBloodKill: record.firstBloodKill ?? false, - firstBloodAssist: record.firstBloodAssist ?? false, - items: record.items, - trinket: record.trinket, - summonerSpells: record.summonerSpells, - perks: record.perks, - itemBuild: record.itemBuild ?? [], - skillBuild: record.skillBuild ?? [], - win: record.win, - })), + games: gameDetails.map((game) => ({ + gameNumber: game.gameNumber, + riotMatchId: game.riotMatchId, + gameCreation: game.gameCreation, + gameDuration: game.gameDuration, + gameVersion: game.gameVersion, + timeline: game.timeline ?? [], + objectiveEvents: game.objectiveEvents ?? [], + teams: game.teams.map((team) => ({ + teamIndex: team.teamIndex, + side: team.side, + win: team.win, + objectives: team.objectives, + bans: team.bans ?? [], + participants: team.participants.map((record) => ({ + userId: record.userId, + summonerName: record.summonerName, + tagLine: record.tagLine, + teamIndex: record.teamIndex, + side: record.side, + teamPosition: record.teamPosition, + championId: record.championId, + championLevel: record.championLevel, + kills: record.kills, + deaths: record.deaths, + assists: record.assists, + cs: record.cs, + csPerMin: record.csPerMin, + gold: record.gold, + gpm: record.gpm, + damageDealtToChampions: record.damageDealtToChampions, + damageTaken: record.damageTaken, + damageShare: record.damageShare, + killParticipation: record.killParticipation, + visionScore: record.visionScore, + wardsPlaced: record.wardsPlaced, + wardsKilled: record.wardsKilled, + controlWardsBought: record.controlWardsBought, + firstBloodKill: record.firstBloodKill ?? false, + firstBloodAssist: record.firstBloodAssist ?? false, + items: record.items, + trinket: record.trinket, + summonerSpells: record.summonerSpells, + perks: record.perks, + itemBuild: record.itemBuild ?? [], + skillBuild: record.skillBuild ?? [], + win: record.win, })), - }), - ), + })), + })), }; await this.cacheService.setDetail(key, response); return response; @@ -357,7 +355,7 @@ export class CommunityStatsService { const detailsByMatchId = new Map(); for (const fragment of fragments) { - const filteredGames = (fragment.gameDetails as InternalGameDetail[]) + const filteredGames = fragment.gameDetails .filter((game) => this.isGameInRange(game.gameCreation, context)) .sort((left, right) => left.gameNumber - right.gameNumber); if (filteredGames.length === 0) continue; @@ -373,7 +371,7 @@ export class CommunityStatsService { filteredGames.map((game) => game.gameNumber), ); records.push( - ...(fragment.records as InternalRecord[]).filter((record) => + ...fragment.records.filter((record) => allowedGameNumbers.has(record.gameNumber), ), ); @@ -407,11 +405,7 @@ export class CommunityStatsService { toGameCreation: context.to?.getTime(), limit: MAX_MATCH_SCAN, }); - const allUserRecords = this.extractUserRecords( - fragments, - userId, - context, - ); + const allUserRecords = this.extractUserRecords(fragments, userId, context); const records = this.applyChampionFilter(allUserRecords, params.filters); const limit = this.clampLimit(params.filters.limit, 30, 50); const cursor = params.filters.cursor; @@ -457,7 +451,7 @@ export class CommunityStatsService { ): InternalRecord[] { return fragments .flatMap((fragment) => - (fragment.records as InternalRecord[]).filter( + fragment.records.filter( (record) => record.userId === userId && this.isGameInRange(record.gameCreation, context), @@ -493,7 +487,7 @@ export class CommunityStatsService { for (const fragment of fragments) { detailsByMatchId.set( fragment.matchId.toString(), - (fragment.gameDetails as InternalGameDetail[]).filter((game) => + fragment.gameDetails.filter((game) => this.isGameInRange(game.gameCreation, context), ), ); @@ -509,11 +503,14 @@ export class CommunityStatsService { MatchModel.find({ communityId, status: { $in: ['finished', 'in-progress'] }, - 'result.games.0': { $exists: true }, + $or: [ + { competitionId: { $exists: true } }, + { 'result.games.0': { $exists: true } }, + ], }) .sort({ scheduledAt: -1 }) .limit(MAX_MATCH_SCAN) - .select({ _id: 1 }) + .select({ _id: 1, competitionId: 1 }) .exec(), this.matchStatsRepository.findByCommunity({ communityId, @@ -523,11 +520,45 @@ export class CommunityStatsService { const fragmentByMatchId = new Map( fragments.map((fragment) => [fragment.matchId.toString(), fragment]), ); + const competitionIds = matches.flatMap((match) => + match.competitionId ? [match.competitionId] : [], + ); + const CompetitionModel = + await this.connectionService.getModel('competition'); + const competitions = + competitionIds.length > 0 + ? await CompetitionModel.find({ _id: { $in: competitionIds } }) + .select({ _id: 1, revision: 1, projectorVersion: 1 }) + .lean() + .exec() + : []; + const competitionById = new Map( + competitions.map((competition) => [ + competition._id.toString(), + competition, + ]), + ); let rebuilt = 0; for (const match of matches) { const fragment = fragmentByMatchId.get(match._id.toString()); - if (fragment && fragment.builderVersion >= MATCH_STATS_BUILDER_VERSION) { + const competition = match.competitionId + ? competitionById.get(match.competitionId.toString()) + : undefined; + const sourceIsCurrent = match.competitionId + ? Boolean( + competition && + fragment?.sourceCompetitionId?.toString() === + competition._id.toString() && + (fragment.sourceRevision ?? -1) >= competition.revision && + (fragment.projectorVersion ?? -1) >= competition.projectorVersion, + ) + : true; + if ( + fragment && + fragment.builderVersion >= MATCH_STATS_BUILDER_VERSION && + sourceIsCurrent + ) { continue; } diff --git a/apps/api/src/modules/community-stats/match-stats.repository.spec.ts b/apps/api/src/modules/community-stats/match-stats.repository.spec.ts index cb044bf3..b9a8c6ef 100644 --- a/apps/api/src/modules/community-stats/match-stats.repository.spec.ts +++ b/apps/api/src/modules/community-stats/match-stats.repository.spec.ts @@ -4,6 +4,47 @@ import type { MatchStats } from '../global/database/schema'; import { MatchStatsRepository } from './match-stats.repository'; describe('MatchStatsRepository', () => { + it('does not let a legacy upsert overwrite a Competition-backed fragment', async () => { + const fragment = { + ...statsFragment(12), + sourceCompetitionId: undefined, + sourceRevision: undefined, + projectorVersion: undefined, + }; + const updateOne = jest + .fn() + .mockReturnValueOnce({ + exec: jest.fn().mockResolvedValue({ matchedCount: 0 }), + }) + .mockReturnValueOnce({ + exec: jest + .fn() + .mockResolvedValue({ matchedCount: 1, upsertedCount: 0 }), + }); + const connection = { + getModel: jest.fn().mockResolvedValue({ updateOne }), + } as unknown as ConnectionService; + const repository = new MatchStatsRepository(connection); + + await repository.upsert(fragment); + + expect(updateOne).toHaveBeenNthCalledWith( + 1, + { + matchId: fragment.matchId, + sourceCompetitionId: { $exists: false }, + }, + { $set: fragment }, + { upsert: false }, + ); + expect(updateOne).toHaveBeenNthCalledWith( + 2, + { matchId: fragment.matchId }, + { $setOnInsert: fragment }, + { upsert: true }, + ); + }); + it('only updates a Competition projection when its revision is not stale', async () => { const updateOne = jest.fn().mockReturnValue({ exec: jest.fn().mockResolvedValue({ matchedCount: 1, upsertedCount: 0 }), @@ -36,6 +77,122 @@ describe('MatchStatsRepository', () => { { upsert: false }, ); }); + + it('converges concurrent initial upserts to the highest Competition revision', async () => { + const older = statsFragment(12); + const newer = { + ...statsFragment(13), + matchId: older.matchId, + sourceCompetitionId: older.sourceCompetitionId, + }; + let stored: ReturnType | undefined; + let initialGuardCount = 0; + let releaseInitialGuards!: () => void; + const initialGuardsReady = new Promise((resolve) => { + releaseInitialGuards = resolve; + }); + let releaseOlderInsert!: () => void; + const olderInserted = new Promise((resolve) => { + releaseOlderInsert = resolve; + }); + const updateOne = jest.fn( + ( + _filter: Record, + update: { + $set?: ReturnType; + $setOnInsert?: ReturnType; + }, + ) => ({ + exec: async () => { + const fragment = update.$set ?? update.$setOnInsert!; + if (update.$set && !stored && initialGuardCount < 2) { + initialGuardCount += 1; + if (initialGuardCount === 2) releaseInitialGuards(); + await initialGuardsReady; + return { matchedCount: 0, upsertedCount: 0 }; + } + + if (update.$setOnInsert) { + if (fragment.sourceRevision === 13) await olderInserted; + const existed = stored !== undefined; + if (!stored) stored = fragment; + if (fragment.sourceRevision === 12) releaseOlderInsert(); + return { + matchedCount: existed ? 1 : 0, + upsertedCount: existed ? 0 : 1, + }; + } + + if ( + stored && + stored.sourceCompetitionId?.equals(fragment.sourceCompetitionId!) && + stored.sourceRevision! <= fragment.sourceRevision! + ) { + stored = fragment; + return { matchedCount: 1, upsertedCount: 0 }; + } + return { matchedCount: 0, upsertedCount: 0 }; + }, + }), + ); + const connection = { + getModel: jest.fn().mockResolvedValue({ updateOne }), + } as unknown as ConnectionService; + const repository = new MatchStatsRepository(connection); + + await Promise.all([repository.upsert(older), repository.upsert(newer)]); + + expect(stored?.sourceRevision).toBe(13); + }); + + it('guards a zero-game delete so an observed revision cannot remove newer stats', async () => { + const matchId = new Types.ObjectId(); + const sourceCompetitionId = new Types.ObjectId(); + const deleteOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ deletedCount: 0 }), + }); + const connection = { + getModel: jest.fn().mockResolvedValue({ deleteOne }), + } as unknown as ConnectionService; + const repository = new MatchStatsRepository(connection); + + await repository.deleteByMatch(matchId, { + sourceCompetitionId, + sourceRevision: 12, + }); + + expect(deleteOne).toHaveBeenCalledWith({ + matchId, + $or: [ + { sourceCompetitionId: { $exists: false } }, + { + sourceCompetitionId, + $or: [ + { sourceRevision: { $exists: false } }, + { sourceRevision: { $lte: 12 } }, + ], + }, + ], + }); + }); + + it('deletes only non-Competition stats during legacy source cleanup', async () => { + const matchId = new Types.ObjectId(); + const deleteOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ deletedCount: 0 }), + }); + const connection = { + getModel: jest.fn().mockResolvedValue({ deleteOne }), + } as unknown as ConnectionService; + const repository = new MatchStatsRepository(connection); + + await repository.deleteLegacyByMatch(matchId); + + expect(deleteOne).toHaveBeenCalledWith({ + matchId, + sourceCompetitionId: { $exists: false }, + }); + }); }); function statsFragment(sourceRevision: number) { diff --git a/apps/api/src/modules/community-stats/match-stats.repository.ts b/apps/api/src/modules/community-stats/match-stats.repository.ts index 50a0d3fd..f56a3baa 100644 --- a/apps/api/src/modules/community-stats/match-stats.repository.ts +++ b/apps/api/src/modules/community-stats/match-stats.repository.ts @@ -13,6 +13,11 @@ export type MatchStatsDetailFragment = Pick< 'matchId' | 'gameDetails' >; +export interface MatchStatsDeleteGuard { + sourceCompetitionId: mongoose.Types.ObjectId; + sourceRevision: number; +} + @Injectable() export class MatchStatsRepository { constructor(private readonly connectionService: ConnectionService) {} @@ -25,30 +30,33 @@ export class MatchStatsRepository { !fragment.sourceCompetitionId || fragment.sourceRevision === undefined ) { - await MatchStatsModel.updateOne( - { matchId: fragment.matchId }, + const updated = await MatchStatsModel.updateOne( + { + matchId: fragment.matchId, + sourceCompetitionId: { $exists: false }, + }, { $set: fragment }, - { upsert: true }, + { upsert: false }, ).exec(); + if (updated.matchedCount > 0) return; + + // A legacy builder must never overwrite a Competition-backed fragment + // that appeared while the legacy source was being read. + try { + await MatchStatsModel.updateOne( + { matchId: fragment.matchId }, + { $setOnInsert: fragment }, + { upsert: true }, + ).exec(); + } catch (error) { + if (!isDuplicateKeyError(error)) throw error; + } return; } + const revisionGuard = competitionRevisionGuard(fragment); const updated = await MatchStatsModel.updateOne( - { - matchId: fragment.matchId, - $or: [ - { sourceCompetitionId: { $exists: false } }, - { sourceCompetitionId: fragment.sourceCompetitionId }, - ], - $and: [ - { - $or: [ - { sourceRevision: { $exists: false } }, - { sourceRevision: { $lte: fragment.sourceRevision } }, - ], - }, - ], - }, + revisionGuard, { $set: fragment }, { upsert: false }, ).exec(); @@ -56,16 +64,48 @@ export class MatchStatsRepository { // If no read model exists, insert it. If a newer revision won the race, // this filter matches it and $setOnInsert intentionally changes nothing. + try { + await MatchStatsModel.updateOne( + { matchId: fragment.matchId }, + { $setOnInsert: fragment }, + { upsert: true }, + ).exec(); + } catch (error) { + if (!isDuplicateKeyError(error)) throw error; + } + + // A lower revision can win the initial insert between the guarded miss and + // the upsert. Re-run the monotonic CAS so every concurrent builder converges + // to the highest source revision; a newer winner simply does not match. await MatchStatsModel.updateOne( - { matchId: fragment.matchId }, - { $setOnInsert: fragment }, - { upsert: true }, + revisionGuard, + { $set: fragment }, + { upsert: false }, ).exec(); } - public async deleteByMatch(matchId: mongoose.Types.ObjectId): Promise { + public async deleteByMatch( + matchId: mongoose.Types.ObjectId, + guard?: MatchStatsDeleteGuard, + ): Promise { const MatchStatsModel = await this.connectionService.getModel('matchStats'); - await MatchStatsModel.deleteOne({ matchId }).exec(); + await MatchStatsModel.deleteOne( + guard + ? { + matchId, + $or: [ + { sourceCompetitionId: { $exists: false } }, + { + sourceCompetitionId: guard.sourceCompetitionId, + $or: [ + { sourceRevision: { $exists: false } }, + { sourceRevision: { $lte: guard.sourceRevision } }, + ], + }, + ], + } + : { matchId }, + ).exec(); } public async deleteByMatches( @@ -76,6 +116,16 @@ export class MatchStatsRepository { await MatchStatsModel.deleteMany({ matchId: { $in: matchIds } }).exec(); } + public async deleteLegacyByMatch( + matchId: mongoose.Types.ObjectId, + ): Promise { + const MatchStatsModel = await this.connectionService.getModel('matchStats'); + await MatchStatsModel.deleteOne({ + matchId, + sourceCompetitionId: { $exists: false }, + }).exec(); + } + public async findByMatch( matchId: mongoose.Types.ObjectId, ): Promise { @@ -173,3 +223,32 @@ export class MatchStatsRepository { return filter; } } + +function competitionRevisionGuard( + fragment: Omit, +) { + return { + matchId: fragment.matchId, + $or: [ + { sourceCompetitionId: { $exists: false } }, + { sourceCompetitionId: fragment.sourceCompetitionId }, + ], + $and: [ + { + $or: [ + { sourceRevision: { $exists: false } }, + { sourceRevision: { $lte: fragment.sourceRevision } }, + ], + }, + ], + }; +} + +function isDuplicateKeyError(error: unknown): boolean { + return ( + typeof error === 'object' && + error !== null && + 'code' in error && + error.code === 11_000 + ); +} diff --git a/apps/api/src/modules/community-stats/match-stats.service.spec.ts b/apps/api/src/modules/community-stats/match-stats.service.spec.ts index 4af50388..4c76b51a 100644 --- a/apps/api/src/modules/community-stats/match-stats.service.spec.ts +++ b/apps/api/src/modules/community-stats/match-stats.service.spec.ts @@ -39,6 +39,57 @@ describe('MatchStatsService', () => { expect(repository.upsert).not.toHaveBeenCalled(); }); + it('revision-guards deletion when a Competition reversal leaves zero games', async () => { + const matchId = new mongoose.Types.ObjectId(); + const communityId = new mongoose.Types.ObjectId(); + const competitionId = new mongoose.Types.ObjectId(); + const match = { + _id: matchId, + communityId, + scheduledAt: new Date('2026-07-12T10:00:00.000Z'), + status: 'in-progress', + teams: [], + result: undefined, + }; + const competition = { + _id: competitionId, + revision: 12, + projectorVersion: 3, + teams: [], + projection: { phase: 'ready', games: [] }, + }; + const connectionService = { + getModel: jest.fn().mockImplementation(async (name: string) => { + if (name === 'match') { + return { findById: () => queryResult(match, false) }; + } + if (name === 'competition') { + return { findOne: () => queryResult(competition) }; + } + if (name === 'riotMatch') return {}; + throw new Error(`Unexpected model: ${name}`); + }), + } as unknown as ConnectionService; + const repository = { + deleteByMatch: jest.fn().mockResolvedValue(undefined), + upsert: jest.fn(), + } as unknown as jest.Mocked; + const service = new MatchStatsService( + connectionService, + repository, + {} as MatchStatsFragmentBuilder, + { getMatchTimeline: jest.fn() } as never, + ); + + await service.buildAndUpsert(matchId, { sourceRevision: 12 }); + + expect(repository.deleteByMatch).toHaveBeenCalledWith(matchId, { + sourceCompetitionId: competitionId, + sourceRevision: 12, + }); + expect(repository.upsert).not.toHaveBeenCalled(); + }); + it('upserts a fragment for eligible matches', async () => { const matchId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId(); @@ -237,6 +288,92 @@ describe('MatchStatsService', () => { ); }); + it('removes a fragment written after its Competition Match was deleted', async () => { + const matchId = new mongoose.Types.ObjectId(); + const communityId = new mongoose.Types.ObjectId(); + const competitionId = new mongoose.Types.ObjectId(); + const teamAId = new mongoose.Types.ObjectId(); + const teamBId = new mongoose.Types.ObjectId(); + const match = { + _id: matchId, + communityId, + scheduledAt: new Date('2026-07-12T10:00:00.000Z'), + status: 'in-progress', + teams: [], + result: undefined, + }; + const competition = { + _id: competitionId, + revision: 12, + projectorVersion: 3, + teams: [ + { teamId: teamAId, legacyTeamIndex: 1, displayOrder: 1 }, + { teamId: teamBId, legacyTeamIndex: 2, displayOrder: 2 }, + ], + projection: { + phase: 'running', + games: [ + { + id: new mongoose.Types.ObjectId(), + displayNumber: 1, + evidence: { type: 'legacy', legacyReference: 'legacy:1' }, + teams: { + blue: { teamId: teamAId.toString() }, + red: { teamId: teamBId.toString() }, + }, + winnerTeamId: teamAId.toString(), + }, + ], + }, + }; + const findById = jest + .fn() + .mockReturnValueOnce(queryResult(match, false)) + .mockReturnValueOnce(queryResult(null, false)); + const findCompetition = jest.fn().mockReturnValue(queryResult(competition)); + const connectionService = { + getModel: jest.fn().mockImplementation(async (name: string) => { + if (name === 'match') return { findById }; + if (name === 'competition') return { findOne: findCompetition }; + if (name === 'riotMatch') return {}; + throw new Error(`Unexpected model: ${name}`); + }), + } as unknown as ConnectionService; + const repository = { + upsert: jest.fn().mockResolvedValue(undefined), + deleteByMatch: jest.fn().mockResolvedValue(undefined), + deleteLegacyByMatch: jest.fn(), + } as unknown as jest.Mocked; + const builder = { + buildFragment: jest.fn().mockReturnValue({ + matchCard: {}, + records: [], + gameDetails: [], + userIds: [], + championIds: [], + gameCreationMin: 1, + gameCreationMax: 2, + }), + } as unknown as jest.Mocked; + const service = new MatchStatsService( + connectionService, + repository, + builder, + { getMatchTimeline: jest.fn() } as never, + ); + + await service.buildAndUpsert(matchId, { sourceRevision: 12 }); + + expect(repository.upsert).toHaveBeenCalled(); + expect(repository.deleteByMatch).toHaveBeenCalledWith(matchId, { + sourceCompetitionId: competitionId, + sourceRevision: 12, + }); + expect(repository.upsert.mock.invocationCallOrder[0]).toBeLessThan( + repository.deleteByMatch.mock.invocationCallOrder[0], + ); + }); + it('does not rebuild before the requested Competition revision is visible', async () => { const matchId = new mongoose.Types.ObjectId(); const riotFind = jest.fn(); diff --git a/apps/api/src/modules/community-stats/match-stats.service.ts b/apps/api/src/modules/community-stats/match-stats.service.ts index 3bb3eee7..1b54c86b 100644 --- a/apps/api/src/modules/community-stats/match-stats.service.ts +++ b/apps/api/src/modules/community-stats/match-stats.service.ts @@ -48,7 +48,14 @@ export class MatchStatsService { : undefined; const sourceMatch = competitionSource?.match ?? match; if (!this.isEligible(sourceMatch)) { - await this.repository.deleteByMatch(matchId); + if (competitionSource) { + await this.repository.deleteByMatch(matchId, { + sourceCompetitionId: competitionSource.sourceCompetitionId, + sourceRevision: competitionSource.sourceRevision, + }); + } else { + await this.repository.deleteByMatch(matchId); + } return; } @@ -135,6 +142,11 @@ export class MatchStatsService { } : {}), }); + + // Source reads and the read-model write are intentionally separated by + // Riot/timeline work. Revalidate after the write so a concurrent aggregate + // deletion cannot resurrect MatchStats after the delete transaction. + await this.removeFragmentIfSourceChanged(matchId, competitionSource); } public async removeByMatch(matchId: mongoose.Types.ObjectId): Promise { @@ -196,6 +208,49 @@ export class MatchStatsService { ? (region as RiotRegionalRoute) : 'asia'; } + + private async removeFragmentIfSourceChanged( + matchId: mongoose.Types.ObjectId, + source: + | { + sourceCompetitionId: mongoose.Types.ObjectId; + sourceRevision: number; + } + | undefined, + ): Promise { + const [MatchModel, CompetitionModel] = await Promise.all([ + this.connectionService.getModel('match'), + this.connectionService.getModel('competition'), + ]); + const [currentMatch, currentCompetition] = await Promise.all([ + MatchModel.findById(matchId).exec(), + CompetitionModel.findOne({ + matchId, + ...(source + ? { + _id: source.sourceCompetitionId, + revision: source.sourceRevision, + } + : {}), + }) + .lean() + .exec(), + ]); + + if (source) { + if (!currentMatch || !currentCompetition) { + await this.repository.deleteByMatch(matchId, { + sourceCompetitionId: source.sourceCompetitionId, + sourceRevision: source.sourceRevision, + }); + } + return; + } + + if (!currentMatch || currentCompetition) { + await this.repository.deleteLegacyByMatch(matchId); + } + } } function isRiotMatchTimelineDto(value: unknown): value is RiotMatchTimelineDto { diff --git a/apps/api/src/modules/competition/competition-bootstrap.service.spec.ts b/apps/api/src/modules/competition/competition-bootstrap.service.spec.ts index a35531aa..5a26cdf3 100644 --- a/apps/api/src/modules/competition/competition-bootstrap.service.spec.ts +++ b/apps/api/src/modules/competition/competition-bootstrap.service.spec.ts @@ -193,8 +193,37 @@ describe('CompetitionBootstrapService', () => { }); }); + it('rejects double elimination until authoritative seeds are persisted', async () => { + const harness = createHarness(); + const service = new CompetitionBootstrapService( + harness.connectionService as ConnectionService, + ); + + await expect( + service.bootstrap( + matchSnapshot({ + gameMode: 'double-elimination', + teamCount: 4, + gameCount: 3, + }), + ), + ).rejects.toMatchObject({ + code: 'INVALID_MATCH_TEAM_SNAPSHOT', + httpStatus: 422, + }); + + expect(harness.connectionService.createSession).not.toHaveBeenCalled(); + expect(harness.competitionModel.findOneAndUpdate).not.toHaveBeenCalled(); + }); + it('rejects incomplete and duplicate team assignments before opening a transaction', async () => { const cases: Array<[string, (match: CompetitionBootstrapMatch) => void]> = [ + [ + 'the Match lifecycle is still recruiting', + (match) => { + match.status = 'recruiting'; + }, + ], [ 'an active participant is not assigned', (match) => { @@ -288,6 +317,8 @@ describe('CompetitionBootstrapService', () => { expect(harness.matchModel.updateOne).toHaveBeenCalledWith( { _id: MATCH_ID, + status: 'team-built', + teamBuiltAt: new Date('2026-07-12T00:05:00.000Z'), $or: [ { competitionId: { $exists: false } }, { competitionId: null }, @@ -404,6 +435,8 @@ function matchSnapshot(params: { return { _id: MATCH_ID, communityId: COMMUNITY_ID, + status: 'team-built', + teamBuiltAt: new Date('2026-07-12T00:05:00.000Z'), gameCount: params.gameCount ?? 3, gameMode: params.gameMode, ...(params.roundRobinMaxRounds === undefined diff --git a/apps/api/src/modules/competition/competition-bootstrap.service.ts b/apps/api/src/modules/competition/competition-bootstrap.service.ts index b06a6a9e..3304b8b3 100644 --- a/apps/api/src/modules/competition/competition-bootstrap.service.ts +++ b/apps/api/src/modules/competition/competition-bootstrap.service.ts @@ -5,6 +5,7 @@ import { ConnectionService } from '../global/database/connection.service'; import type { MatchGameMode, MatchParticipant, + MatchStatus, MatchTeam, } from '../global/database/schema'; import type { @@ -30,6 +31,8 @@ export interface CompetitionBootstrapMatch { _id: Types.ObjectId; communityId: Types.ObjectId; competitionId?: Types.ObjectId; + status: MatchStatus; + teamBuiltAt: Date; gameCount: number; gameMode: MatchGameMode; roundRobinMaxRounds?: number; @@ -142,6 +145,8 @@ export class CompetitionBootstrapService { const linkResult = await MatchModel.updateOne( { _id: match._id, + status: match.status, + teamBuiltAt: match.teamBuiltAt, $or: [ { competitionId: { $exists: false } }, { competitionId: null }, @@ -206,6 +211,13 @@ function buildCompetitionInsertPayload( ): CompetitionInsertPayload { assertObjectId(match._id, 'Match ID'); assertObjectId(match.communityId, 'Community ID'); + if (match.status === 'recruiting' || !(match.teamBuiltAt instanceof Date)) { + throw new CompetitionBootstrapError( + 'INVALID_MATCH_TEAM_SNAPSHOT', + 'Competition bootstrap requires a finalized team-built Match lifecycle.', + 422, + ); + } assertPositiveInteger(match.gameCount, 'Match game count'); const competitionId = stableObjectId(match._id, 'competition'); @@ -405,7 +417,11 @@ function applySeeds( ): void { if (match.gameMode !== 'double-elimination') return; const configuredSeeds = match.doubleElimination?.seeds ?? []; - if (configuredSeeds.length === 0) return; + if (configuredSeeds.length === 0) { + throw invalidTeamSnapshot( + 'Double-elimination seeds must be finalized before Competition bootstrap.', + ); + } if (configuredSeeds.length !== teams.length) { throw invalidTeamSnapshot( 'Double-elimination seeds must include every built team exactly once.', diff --git a/apps/api/src/modules/competition/competition-command.service.spec.ts b/apps/api/src/modules/competition/competition-command.service.spec.ts index bf15347d..d4a9a75c 100644 --- a/apps/api/src/modules/competition/competition-command.service.spec.ts +++ b/apps/api/src/modules/competition/competition-command.service.spec.ts @@ -106,6 +106,49 @@ describe('CompetitionCommandService', () => { expect(harness.session.abortTransaction).not.toHaveBeenCalled(); }); + it('replays a concurrently committed identical command after a duplicate-key race', async () => { + const harness = createHarness(); + let committedReceipt: Record | null = null; + harness.outboxModel.findOne.mockImplementation(() => + queryResult(committedReceipt), + ); + harness.factModel.insertMany.mockImplementationOnce( + async ([fact]: Array>) => { + committedReceipt = { + competitionId: COMPETITION_ID, + idempotencyKey: fact.idempotencyKey, + requestHash: fact.requestHash, + commandId: fact.commandId, + revision: fact.revision, + payload: { + projection: PROJECTION, + phase: PROJECTION.phase, + }, + }; + throw Object.assign(new Error('duplicate command fact'), { + code: 11_000, + }); + }, + ); + const service = new CompetitionCommandService( + harness.connectionService as ConnectionService, + ); + + await expect( + service.acceptGame(acceptGameCommand()), + ).resolves.toMatchObject({ + revision: 8, + replayed: true, + }); + + expect(harness.connectionService.createSession).toHaveBeenCalledTimes(2); + expect(harness.factModel.insertMany).toHaveBeenCalledTimes(1); + expect(harness.competitionModel.findOneAndUpdate).not.toHaveBeenCalled(); + expect(harness.outboxModel.insertMany).not.toHaveBeenCalled(); + expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1); + expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1); + }); + it('rejects the same Idempotency-Key when its payload hash differs', async () => { const harness = createHarness(); harness.outboxModel.findOne.mockReturnValue( @@ -382,6 +425,39 @@ describe('CompetitionCommandService', () => { { session: harness.session }, ); expect(harness.tournamentCodeModel.updateMany).toHaveBeenCalled(); + expect(harness.matchModel.updateOne).toHaveBeenCalledWith( + { _id: reversal.competition.matchId }, + { + $pull: { + tournamentCodeIds: { + $in: [reversal.parentCodeId, reversal.childCodeId], + }, + }, + }, + { session: harness.session }, + ); + const [, codeReversalPipeline] = harness.tournamentCodeModel.updateMany.mock + .calls[0] as unknown as [ + Record, + Array>, + ]; + expect(codeReversalPipeline[0].$set).toMatchObject({ + state: { + $cond: [{ $eq: ['$state', 'reserved'] }, 'released', 'voided'], + }, + matchId: { + $cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$matchId'], + }, + gameNumber: { + $cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$gameNumber'], + }, + bracketMatchId: { + $cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$bracketMatchId'], + }, + reservedAt: { + $cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$reservedAt'], + }, + }); expect(harness.competitionModel.findOneAndUpdate).toHaveBeenCalledWith( { _id: COMPETITION_ID, revision: 7 }, expect.objectContaining({ $inc: { revision: 1 } }), @@ -390,6 +466,50 @@ describe('CompetitionCommandService', () => { expect(harness.outboxModel.insertMany).toHaveBeenCalledTimes(1); expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1); }); + + it('retries a cascade reversal after a transient transaction conflict', async () => { + const reversal = reversalFixture(); + const harness = createHarness({ + competition: reversal.competition, + facts: reversal.facts, + assignments: reversal.assignments, + }); + harness.factModel.insertMany + .mockRejectedValueOnce( + Object.assign(new Error('write conflict'), { + code: 112, + codeName: 'WriteConflict', + }), + ) + .mockResolvedValueOnce([]); + const service = new CompetitionCommandService( + harness.connectionService as ConnectionService, + ); + const preview = await service.previewSeriesReversal({ + competitionId: COMPETITION_ID, + expectedRevision: 7, + seriesId: reversal.parentSeriesId, + mode: 'cascade', + }); + + await expect( + service.reverseSeries({ + competitionId: COMPETITION_ID, + expectedRevision: 7, + idempotencyKey: 'admin:reverse:transient-retry', + actor: { type: 'user', userId: USER_ID }, + seriesId: reversal.parentSeriesId, + mode: 'cascade', + reason: 'Wrong result ingestion', + impactHash: preview.impactHash, + }), + ).resolves.toMatchObject({ revision: 8, replayed: false }); + + expect(harness.connectionService.createSession).toHaveBeenCalledTimes(2); + expect(harness.factModel.insertMany).toHaveBeenCalledTimes(2); + expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1); + expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1); + }); }); const COMPETITION_ID = new Types.ObjectId('64b000000000000000000001'); @@ -496,12 +616,18 @@ function createHarness( updateOne: jest.fn().mockResolvedValue({ modifiedCount: 1 }), updateMany: jest.fn().mockResolvedValue({ modifiedCount: 2 }), }; + const matchModel = { + updateOne: jest + .fn() + .mockResolvedValue({ matchedCount: 1, modifiedCount: 1 }), + }; const models: Record = { competition: competitionModel, competitionFact: factModel, competitionOutbox: outboxModel, tournamentCodeAssignment: assignmentModel, tournamentCode: tournamentCodeModel, + match: matchModel, }; const connectionService = { createSession: jest.fn().mockResolvedValue(session), @@ -515,6 +641,7 @@ function createHarness( outboxModel, assignmentModel, tournamentCodeModel, + matchModel, connectionService, }; } @@ -612,6 +739,8 @@ function reversalFixture() { childFactId, parentGameSlotId, childGameSlotId, + parentCodeId, + childCodeId, competition: { ...competitionDocument(7), seriesGraph: [ diff --git a/apps/api/src/modules/competition/competition-command.service.ts b/apps/api/src/modules/competition/competition-command.service.ts index 362024a8..7567f2af 100644 --- a/apps/api/src/modules/competition/competition-command.service.ts +++ b/apps/api/src/modules/competition/competition-command.service.ts @@ -14,6 +14,7 @@ import { } from './domain/competition-reversal'; type PersistenceId = string | mongoose.Types.ObjectId; +const COMMAND_TRANSACTION_ATTEMPTS = 3; export type CompetitionCommandActor = | { type: 'system' } @@ -211,283 +212,316 @@ export class CompetitionCommandService { throw invalidCommandError(); } - const session = await this.connectionService.createSession(); - if (!session) { - throw new CompetitionCommandError( - 'COMPETITION_TRANSACTION_UNAVAILABLE', - 'A MongoDB transaction is required for Competition commands.', - 500, - ); - } - - try { - session.startTransaction(); - const [CompetitionModel, FactModel, OutboxModel, AssignmentModel] = - await Promise.all([ - this.connectionService.getModel('competition'), - this.connectionService.getModel('competitionFact'), - this.connectionService.getModel('competitionOutbox'), - this.connectionService.getModel('tournamentCodeAssignment'), - ]); - const requestHash = requestHashFor(envelope); - const commandId = commandIdFor(envelope); - const receipt = await OutboxModel.findOne({ - competitionId: command.competitionId, - idempotencyKey: command.idempotencyKey, - }) - .session(session) - .lean() - .exec(); - if (receipt) { - const replay = await this.replay( - CompetitionModel, - command.competitionId, - requestHash, - receipt, - session, + let lastRetryableError: unknown; + for ( + let attempt = 1; + attempt <= COMMAND_TRANSACTION_ATTEMPTS; + attempt += 1 + ) { + const session = await this.connectionService.createSession(); + if (!session) { + throw new CompetitionCommandError( + 'COMPETITION_TRANSACTION_UNAVAILABLE', + 'A MongoDB transaction is required for Competition commands.', + 500, ); - await session.commitTransaction(); - return replay; } - const competition = await CompetitionModel.findById(command.competitionId) - .session(session) - .lean() - .exec(); - if (!competition) throw competitionNotFound(command.competitionId); - assertExpectedRevision(competition.revision, command.expectedRevision); - - const [existingFacts, assignments] = await Promise.all([ - FactModel.find({ competitionId: command.competitionId }) - .sort({ revision: 1, ordinalWithinRevision: 1 }) + try { + session.startTransaction(); + const [CompetitionModel, FactModel, OutboxModel, AssignmentModel] = + await Promise.all([ + this.connectionService.getModel('competition'), + this.connectionService.getModel('competitionFact'), + this.connectionService.getModel('competitionOutbox'), + this.connectionService.getModel('tournamentCodeAssignment'), + ]); + const requestHash = requestHashFor(envelope); + const commandId = commandIdFor(envelope); + const receipt = await OutboxModel.findOne({ + competitionId: command.competitionId, + idempotencyKey: command.idempotencyKey, + }) .session(session) .lean() - .exec(), - AssignmentModel.find({ competitionId: command.competitionId }) - .session(session) - .lean() - .exec() as Promise, - ]); - const input = reversalInput( - competition, - command, - existingFacts, - assignments, - ); - const preview = assertReversalPreview(input, command.impactHash); - const nextRevision = command.expectedRevision + 1; - const recordedAt = new Date(); - const occurredAt = command.occurredAt ?? recordedAt; - const rawFacts = buildReversalFacts({ - preview, - facts: input.facts, - competitionId: idString(command.competitionId), - commandId, - nextRevision, - actor: toPlain(command.actor) as Readonly>, - reason: command.reason.trim(), - occurredAt, - }); - const reversalFacts = rawFacts.map((rawFact) => - persistenceReversalFact(rawFact, command, commandId, requestHash), - ); - const projection = projectCompetition({ - competitionId: idString(command.competitionId), - revision: nextRevision, - projectorVersion: competition.projectorVersion, - teams: toPlain(competition.teams) as never, - format: toPlain(competition.format) as never, - seriesGraph: toPlain(competition.seriesGraph) as never, - facts: [...existingFacts, ...reversalFacts].map(factForProjection), - }); - - await FactModel.insertMany(reversalFacts, { session }); - const updated = await CompetitionModel.findOneAndUpdate( - { _id: command.competitionId, revision: command.expectedRevision }, - { - $inc: { revision: 1 }, - $set: { - projection, - projectorVersion: competition.projectorVersion, - phase: projection.phase, - }, - }, - { new: true, runValidators: true, session }, - ) - .lean() - .exec(); - if (!updated) throw staleRevisionError(command.expectedRevision); - - await this.applyReversalAssignments( - command.competitionId, - preview, - assignments, - commandId, - recordedAt, - session, - ); - await OutboxModel.insertMany( - [ - buildOutbox( + .exec(); + if (receipt) { + const replay = await this.replay( + CompetitionModel, command.competitionId, - envelope, - commandId, requestHash, - nextRevision, - reversalFacts, - projection, - updated, - recordedAt, - ), - ], - { session }, - ); - await session.commitTransaction(); - return { - competition: updated, - commandId, - revision: nextRevision, - replayed: false, - }; - } catch (error) { - await session.abortTransaction().catch(() => undefined); - throw error; - } finally { - await session.endSession(); + receipt, + session, + ); + await session.commitTransaction(); + return replay; + } + + const competition = await CompetitionModel.findById( + command.competitionId, + ) + .session(session) + .lean() + .exec(); + if (!competition) throw competitionNotFound(command.competitionId); + assertExpectedRevision(competition.revision, command.expectedRevision); + + const [existingFacts, assignments] = await Promise.all([ + FactModel.find({ competitionId: command.competitionId }) + .sort({ revision: 1, ordinalWithinRevision: 1 }) + .session(session) + .lean() + .exec(), + AssignmentModel.find({ competitionId: command.competitionId }) + .session(session) + .lean() + .exec() as Promise, + ]); + const input = reversalInput( + competition, + command, + existingFacts, + assignments, + ); + const preview = assertReversalPreview(input, command.impactHash); + const nextRevision = command.expectedRevision + 1; + const recordedAt = new Date(); + const occurredAt = command.occurredAt ?? recordedAt; + const rawFacts = buildReversalFacts({ + preview, + facts: input.facts, + competitionId: idString(command.competitionId), + commandId, + nextRevision, + actor: toPlain(command.actor) as Readonly>, + reason: command.reason.trim(), + occurredAt, + }); + const reversalFacts = rawFacts.map((rawFact) => + persistenceReversalFact(rawFact, command, commandId, requestHash), + ); + const projection = projectCompetition({ + competitionId: idString(command.competitionId), + revision: nextRevision, + projectorVersion: competition.projectorVersion, + teams: toPlain(competition.teams) as never, + format: toPlain(competition.format) as never, + seriesGraph: toPlain(competition.seriesGraph) as never, + facts: [...existingFacts, ...reversalFacts].map(factForProjection), + }); + + await FactModel.insertMany(reversalFacts, { session }); + const updated = await CompetitionModel.findOneAndUpdate( + { _id: command.competitionId, revision: command.expectedRevision }, + { + $inc: { revision: 1 }, + $set: { + projection, + projectorVersion: competition.projectorVersion, + phase: projection.phase, + }, + }, + { new: true, runValidators: true, session }, + ) + .lean() + .exec(); + if (!updated) throw staleRevisionError(command.expectedRevision); + + await this.applyReversalAssignments( + command.competitionId, + competition.matchId, + preview, + assignments, + commandId, + recordedAt, + session, + ); + await OutboxModel.insertMany( + [ + buildOutbox( + command.competitionId, + envelope, + commandId, + requestHash, + nextRevision, + reversalFacts, + projection, + updated, + recordedAt, + ), + ], + { session }, + ); + await session.commitTransaction(); + return { + competition: updated, + commandId, + revision: nextRevision, + replayed: false, + }; + } catch (error) { + await session.abortTransaction().catch(() => undefined); + if ( + attempt < COMMAND_TRANSACTION_ATTEMPTS && + isRetryableCommandTransactionError(error) + ) { + lastRetryableError = error; + continue; + } + throw error; + } finally { + await session.endSession(); + } } + throw lastRetryableError; } private async runCommand( command: CommandEnvelope, ): Promise { validateEnvelope(command); - const session = await this.connectionService.createSession(); - if (!session) { - throw new CompetitionCommandError( - 'COMPETITION_TRANSACTION_UNAVAILABLE', - 'A MongoDB transaction is required for Competition commands.', - 500, - ); - } + let lastRetryableError: unknown; + for ( + let attempt = 1; + attempt <= COMMAND_TRANSACTION_ATTEMPTS; + attempt += 1 + ) { + const session = await this.connectionService.createSession(); + if (!session) { + throw new CompetitionCommandError( + 'COMPETITION_TRANSACTION_UNAVAILABLE', + 'A MongoDB transaction is required for Competition commands.', + 500, + ); + } - try { - session.startTransaction(); - const CompetitionModel = - await this.connectionService.getModel('competition'); - const FactModel = - await this.connectionService.getModel('competitionFact'); - const OutboxModel = - await this.connectionService.getModel('competitionOutbox'); - const requestHash = requestHashFor(command); - const commandId = commandIdFor(command); - const competitionId = command.competitionId; + try { + session.startTransaction(); + const CompetitionModel = + await this.connectionService.getModel('competition'); + const FactModel = + await this.connectionService.getModel('competitionFact'); + const OutboxModel = + await this.connectionService.getModel('competitionOutbox'); + const requestHash = requestHashFor(command); + const commandId = commandIdFor(command); + const competitionId = command.competitionId; - const receipt = await OutboxModel.findOne({ - competitionId, - idempotencyKey: command.idempotencyKey, - }) - .session(session) - .lean() - .exec(); - if (receipt) { - const replay = await this.replay( - CompetitionModel, + const receipt = await OutboxModel.findOne({ competitionId, + idempotencyKey: command.idempotencyKey, + }) + .session(session) + .lean() + .exec(); + if (receipt) { + const replay = await this.replay( + CompetitionModel, + competitionId, + requestHash, + receipt, + session, + ); + await session.commitTransaction(); + return replay; + } + + const competition = await CompetitionModel.findById(competitionId) + .session(session) + .lean() + .exec(); + if (!competition) { + throw new CompetitionCommandError( + 'COMPETITION_NOT_FOUND', + 'Competition not found.', + 404, + { competitionId: idString(competitionId) }, + ); + } + assertExpectedRevision(competition.revision, command.expectedRevision); + + const existingFacts = await FactModel.find({ competitionId }) + .sort({ revision: 1, ordinalWithinRevision: 1 }) + .session(session) + .lean() + .exec(); + const nextRevision = command.expectedRevision + 1; + const recordedAt = new Date(); + const fact = buildFact( + command, + commandId, requestHash, - receipt, - session, + nextRevision, + recordedAt, + ); + const projection = projectCompetition({ + competitionId: idString(competitionId), + revision: nextRevision, + projectorVersion: competition.projectorVersion, + teams: toPlain(competition.teams) as never, + format: toPlain(competition.format) as never, + seriesGraph: toPlain(competition.seriesGraph) as never, + facts: [...existingFacts, fact].map(factForProjection), + }); + + await FactModel.insertMany([fact], { session }); + const updated = await CompetitionModel.findOneAndUpdate( + { _id: competitionId, revision: command.expectedRevision }, + { + $inc: { revision: 1 }, + $set: { + projection, + projectorVersion: competition.projectorVersion, + phase: projection.phase, + }, + }, + { new: true, runValidators: true, session }, + ) + .lean() + .exec(); + if (!updated) { + throw staleRevisionError(command.expectedRevision); + } + + await this.applyTournamentCode(command, commandId, recordedAt, session); + await OutboxModel.insertMany( + [ + buildOutbox( + competitionId, + command, + commandId, + requestHash, + nextRevision, + fact, + projection, + updated, + recordedAt, + ), + ], + { session }, ); await session.commitTransaction(); - return replay; + return { + competition: updated, + commandId, + revision: nextRevision, + replayed: false, + }; + } catch (error) { + await session.abortTransaction().catch(() => undefined); + if ( + attempt < COMMAND_TRANSACTION_ATTEMPTS && + isRetryableCommandTransactionError(error) + ) { + lastRetryableError = error; + continue; + } + throw error; + } finally { + await session.endSession(); } - - const competition = await CompetitionModel.findById(competitionId) - .session(session) - .lean() - .exec(); - if (!competition) { - throw new CompetitionCommandError( - 'COMPETITION_NOT_FOUND', - 'Competition not found.', - 404, - { competitionId: idString(competitionId) }, - ); - } - assertExpectedRevision(competition.revision, command.expectedRevision); - - const existingFacts = await FactModel.find({ competitionId }) - .sort({ revision: 1, ordinalWithinRevision: 1 }) - .session(session) - .lean() - .exec(); - const nextRevision = command.expectedRevision + 1; - const recordedAt = new Date(); - const fact = buildFact( - command, - commandId, - requestHash, - nextRevision, - recordedAt, - ); - const projection = projectCompetition({ - competitionId: idString(competitionId), - revision: nextRevision, - projectorVersion: competition.projectorVersion, - teams: toPlain(competition.teams) as never, - format: toPlain(competition.format) as never, - seriesGraph: toPlain(competition.seriesGraph) as never, - facts: [...existingFacts, fact].map(factForProjection), - }); - - await FactModel.insertMany([fact], { session }); - const updated = await CompetitionModel.findOneAndUpdate( - { _id: competitionId, revision: command.expectedRevision }, - { - $inc: { revision: 1 }, - $set: { - projection, - projectorVersion: competition.projectorVersion, - phase: projection.phase, - }, - }, - { new: true, runValidators: true, session }, - ) - .lean() - .exec(); - if (!updated) { - throw staleRevisionError(command.expectedRevision); - } - - await this.applyTournamentCode(command, commandId, recordedAt, session); - await OutboxModel.insertMany( - [ - buildOutbox( - competitionId, - command, - commandId, - requestHash, - nextRevision, - fact, - projection, - updated, - recordedAt, - ), - ], - { session }, - ); - await session.commitTransaction(); - return { - competition: updated, - commandId, - revision: nextRevision, - replayed: false, - }; - } catch (error) { - await session.abortTransaction().catch(() => undefined); - throw error; - } finally { - await session.endSession(); } + throw lastRetryableError; } private async replay( @@ -595,6 +629,7 @@ export class CompetitionCommandService { private async applyReversalAssignments( competitionId: PersistenceId, + matchId: PersistenceId, preview: SeriesReversalPreview, assignments: AssignmentRecord[], commandId: string, @@ -638,6 +673,14 @@ export class CompetitionCommandService { tournamentCodeReversalStatePipeline(recordedAt), { session }, ); + const MatchModel = (await this.connectionService.getModel( + 'match', + )) as mongoose.Model; + await MatchModel.updateOne( + { _id: matchId }, + { $pull: { tournamentCodeIds: { $in: codeIds } } }, + { session }, + ); } } @@ -956,6 +999,22 @@ function tournamentCodeReversalStatePipeline( releasedAt: { $cond: [{ $eq: ['$state', 'reserved'] }, recordedAt, '$releasedAt'], }, + matchId: { + $cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$matchId'], + }, + gameNumber: { + $cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$gameNumber'], + }, + bracketMatchId: { + $cond: [ + { $eq: ['$state', 'reserved'] }, + '$$REMOVE', + '$bracketMatchId', + ], + }, + reservedAt: { + $cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$reservedAt'], + }, }, }, ]; @@ -968,6 +1027,21 @@ function persistenceObjectId(value: PersistenceId): PersistenceId { : value; } +function isRetryableCommandTransactionError(error: unknown): boolean { + const candidate = error as { + code?: number; + codeName?: string; + hasErrorLabel?: (label: string) => boolean; + }; + return Boolean( + candidate?.code === 11_000 || + candidate?.code === 112 || + candidate?.codeName === 'WriteConflict' || + candidate?.hasErrorLabel?.('TransientTransactionError') || + candidate?.hasErrorLabel?.('UnknownTransactionCommitResult'), + ); +} + function competitionNotFound( competitionId: PersistenceId, ): CompetitionCommandError { diff --git a/apps/api/src/modules/competition/competition-query.service.spec.ts b/apps/api/src/modules/competition/competition-query.service.spec.ts index be77a820..13211b94 100644 --- a/apps/api/src/modules/competition/competition-query.service.spec.ts +++ b/apps/api/src/modules/competition/competition-query.service.spec.ts @@ -1,29 +1,24 @@ -import { ForbiddenException } from '@nestjs/common'; +import { ConflictException, ForbiddenException } from '@nestjs/common'; import { Types } from 'mongoose'; import { ConnectionService } from '../global/database/connection.service'; -import { CompetitionBootstrapService } from './competition-bootstrap.service'; import { CompetitionQueryService } from './competition-query.service'; describe('CompetitionQueryService', () => { - it('bootstraps a built Match once when its Competition is first read', async () => { + it('does not let a public read race the team-build bootstrap workflow', async () => { const harness = createHarness({ competition: null }); - const bootstrapped = competitionDocument(); - harness.bootstrapService.bootstrap.mockResolvedValue(bootstrapped); const service = createService(harness); - const result = await service.getCompetition({ - communityId: COMMUNITY_ID, - matchId: MATCH_ID, - }); + await expect( + service.getCompetition({ + communityId: COMMUNITY_ID, + matchId: MATCH_ID, + }), + ).rejects.toBeInstanceOf(ConflictException); expect(harness.matchModel.findOne).toHaveBeenCalledWith({ _id: MATCH_ID, communityId: COMMUNITY_ID, }); - expect(harness.bootstrapService.bootstrap).toHaveBeenCalledWith( - expect.objectContaining({ _id: MATCH_ID, status: 'team-built' }), - ); - expect(result).toBe(bootstrapped); }); it('returns an explicit team view with codes only for the callers team', async () => { @@ -56,6 +51,7 @@ describe('CompetitionQueryService', () => { expect(JSON.stringify(result)).not.toContain('OPPONENT-SECRET-CODE'); expect(harness.tournamentCodeModel.find).toHaveBeenCalledWith({ _id: { $in: [TEAM_A_CODE_ID] }, + state: { $in: ['reserved', 'used'] }, }); }); @@ -71,6 +67,20 @@ describe('CompetitionQueryService', () => { ).rejects.toBeInstanceOf(ForbiddenException); }); + it('does not expose a stale code whose active assignment no longer matches', async () => { + const harness = createHarness(); + harness.tournamentCodeModel.find.mockReturnValueOnce(queryResult([])); + const service = createService(harness); + + await expect( + service.getTeamView({ + communityId: COMMUNITY_ID, + matchId: MATCH_ID, + userId: TEAM_A_USER_ID, + }), + ).rejects.toBeInstanceOf(ConflictException); + }); + it('pages facts in immutable revision order using an opaque cursor', async () => { const harness = createHarness(); harness.factModel.find.mockReturnValueOnce( @@ -116,7 +126,6 @@ const GAME_SLOT_ID = 'slot-1'; function createService(harness: ReturnType) { return new CompetitionQueryService( harness.connectionService as ConnectionService, - harness.bootstrapService as unknown as CompetitionBootstrapService, ); } @@ -167,11 +176,15 @@ function createHarness(options: { competition?: unknown } = {}) { { _id: TEAM_A_CODE_ID, code: 'TEAM-A-SECRET-CODE', + state: 'reserved', + matchId: MATCH_ID, expiresAt: new Date('2026-07-13T00:00:00.000Z'), }, { _id: TEAM_B_CODE_ID, code: 'OPPONENT-SECRET-CODE', + state: 'reserved', + matchId: MATCH_ID, expiresAt: new Date('2026-07-13T00:00:00.000Z'), }, ]), @@ -196,7 +209,6 @@ function createHarness(options: { competition?: unknown } = {}) { connectionService: { getModel: jest.fn((name: string) => Promise.resolve(models[name])), }, - bootstrapService: { bootstrap: jest.fn() }, }; } diff --git a/apps/api/src/modules/competition/competition-query.service.ts b/apps/api/src/modules/competition/competition-query.service.ts index 0913861a..b20c4815 100644 --- a/apps/api/src/modules/competition/competition-query.service.ts +++ b/apps/api/src/modules/competition/competition-query.service.ts @@ -13,7 +13,6 @@ import { import mongoose from 'mongoose'; import { ConnectionService } from '../global/database/connection.service'; import type { Competition, CompetitionFact } from './competition.schema'; -import { CompetitionBootstrapService } from './competition-bootstrap.service'; type PersistenceId = string | mongoose.Types.ObjectId; type CompetitionRecord = Competition & { _id: mongoose.Types.ObjectId }; @@ -30,25 +29,12 @@ interface CompetitionProjectionSource { @Injectable() export class CompetitionQueryService { - constructor( - private readonly connectionService: ConnectionService, - private readonly bootstrapService: CompetitionBootstrapService, - ) {} + constructor(private readonly connectionService: ConnectionService) {} - /** Resolve the one-to-one aggregate, lazily freezing a completed team build. */ + /** Resolve the aggregate created by the finalized team-build workflow. */ public async getCompetition( scope: CompetitionScope, ): Promise { - const CompetitionModel = - await this.connectionService.getModel('competition'); - const existing = await CompetitionModel.findOne({ - matchId: scope.matchId, - communityId: scope.communityId, - }) - .lean() - .exec(); - if (existing) return existing as CompetitionRecord; - const MatchModel = await this.connectionService.getModel('match'); const match = await MatchModel.findOne({ _id: scope.matchId, @@ -66,7 +52,19 @@ export class CompetitionQueryService { 'Competition is unavailable until team building is complete.', ); } - return this.bootstrapService.bootstrap(match as never); + + const CompetitionModel = + await this.connectionService.getModel('competition'); + const existing = await CompetitionModel.findOne({ + matchId: scope.matchId, + communityId: scope.communityId, + }) + .lean() + .exec(); + if (existing) return existing as CompetitionRecord; + throw new ConflictException( + 'Competition is still being initialized by the team-build workflow.', + ); } public async getTeamView( @@ -126,7 +124,10 @@ export class CompetitionQueryService { const TournamentCodeModel = await this.connectionService.getModel('tournamentCode'); const codes = codeIds.length - ? await TournamentCodeModel.find({ _id: { $in: codeIds } }) + ? await TournamentCodeModel.find({ + _id: { $in: codeIds }, + state: { $in: ['reserved', 'used'] }, + }) .lean() .exec() : []; @@ -150,6 +151,17 @@ export class CompetitionQueryService { const code = assignment ? codeById.get(idString(assignment.tournamentCodeId)) : undefined; + if ( + assignment && + (!code || + code.state !== assignment.state || + !code.matchId || + !sameId(code.matchId, competition.matchId)) + ) { + throw new ConflictException( + 'Tournament Code assignment is inconsistent and cannot be exposed.', + ); + } return { gameSlotId: gameSlotId as never, seriesId: idString(slot.seriesId as PersistenceId) as never, diff --git a/apps/api/src/modules/competition/competition.schema.spec.ts b/apps/api/src/modules/competition/competition.schema.spec.ts index 3e96e0a3..c65a0cc5 100644 --- a/apps/api/src/modules/competition/competition.schema.spec.ts +++ b/apps/api/src/modules/competition/competition.schema.spec.ts @@ -1,4 +1,5 @@ import { + COMPETITION_OUTBOX_STATES, CompetitionFactSchema, CompetitionOutboxSchema, CompetitionSchema, @@ -93,6 +94,13 @@ describe('Competition persistence schemas', () => { ]); }); + it('defines a terminal dead-letter state for poison outbox events', () => { + expect(COMPETITION_OUTBOX_STATES).toContain('dead-letter'); + expect(CompetitionOutboxSchema.path('state').options.enum).toContain( + 'dead-letter', + ); + }); + it('allows only one active assignment for a code or GameSlot', () => { expectIndexes(TournamentCodeAssignmentSchema, [ { diff --git a/apps/api/src/modules/competition/competition.schema.ts b/apps/api/src/modules/competition/competition.schema.ts index d76f043a..849ebae5 100644 --- a/apps/api/src/modules/competition/competition.schema.ts +++ b/apps/api/src/modules/competition/competition.schema.ts @@ -20,6 +20,7 @@ export const COMPETITION_OUTBOX_STATES = [ 'pending', 'published', 'failed', + 'dead-letter', ] as const; export type CompetitionOutboxState = (typeof COMPETITION_OUTBOX_STATES)[number]; @@ -32,6 +33,110 @@ export const TOURNAMENT_CODE_ASSIGNMENT_STATES = [ export type TournamentCodeAssignmentState = (typeof TOURNAMENT_CODE_ASSIGNMENT_STATES)[number]; +export interface CompetitionDomainInvariantIndex { + collection: + | 'match' + | 'competition' + | 'competition_fact' + | 'competition_outbox' + | 'tournament_code_assignment'; + key: mongoose.IndexDefinition; + options: mongoose.IndexOptions & { name: string; unique: true }; +} + +/** + * Database-enforced Competition identities. Runtime schemas and the one-off + * migration consume this same list so production cannot silently run with a + * weaker set of uniqueness guarantees than command handling expects. + */ +export const COMPETITION_DOMAIN_INVARIANT_INDEXES: CompetitionDomainInvariantIndex[] = + [ + { + collection: 'match', + key: { competitionId: 1 }, + options: { + name: 'competitionId_1', + unique: true, + partialFilterExpression: { + competitionId: { $type: 'objectId' }, + }, + }, + }, + { + collection: 'competition', + key: { matchId: 1 }, + options: { name: 'matchId_1', unique: true }, + }, + { + collection: 'competition_fact', + key: { competitionId: 1, revision: 1, ordinalWithinRevision: 1 }, + options: { + name: 'competitionId_1_revision_1_ordinalWithinRevision_1', + unique: true, + }, + }, + { + collection: 'competition_fact', + key: { competitionId: 1, commandId: 1, ordinalWithinRevision: 1 }, + options: { + name: 'competitionId_1_commandId_1_ordinalWithinRevision_1', + unique: true, + }, + }, + { + collection: 'competition_fact', + key: { 'evidence.riotMatchId': 1 }, + options: { + name: 'evidence.riotMatchId_1', + unique: true, + partialFilterExpression: { + type: 'game-accepted', + 'evidence.riotMatchId': { $type: 'string' }, + }, + }, + }, + { + collection: 'competition_outbox', + key: { eventId: 1 }, + options: { name: 'eventId_1', unique: true }, + }, + { + collection: 'competition_outbox', + key: { competitionId: 1, idempotencyKey: 1 }, + options: { + name: 'competitionId_1_idempotencyKey_1', + unique: true, + }, + }, + { + collection: 'tournament_code_assignment', + key: { gameSlotId: 1 }, + options: { + name: 'gameSlotId_1', + unique: true, + partialFilterExpression: { state: { $in: ['reserved', 'used'] } }, + }, + }, + { + collection: 'tournament_code_assignment', + key: { tournamentCodeId: 1 }, + options: { + name: 'tournamentCodeId_1', + unique: true, + partialFilterExpression: { state: { $in: ['reserved', 'used'] } }, + }, + }, + { + collection: 'tournament_code_assignment', + key: { riotMatchId: 1 }, + options: { + name: 'riotMatchId_1', + unique: true, + partialFilterExpression: { riotMatchId: { $type: 'string' } }, + }, + }, + ]; + export interface CompetitionTeamMemberSnapshot { userId: mongoose.Types.ObjectId; displayName: string; @@ -200,7 +305,7 @@ export const CompetitionSchema: mongoose.Schema = { timestamps: true, collection: 'competition' }, ); -CompetitionSchema.index({ matchId: 1 }, { unique: true }); +applyCompetitionDomainInvariantIndexes(CompetitionSchema, 'competition'); CompetitionSchema.index({ communityId: 1, phase: 1, updatedAt: -1 }); export const CompetitionFactSchema = new Schema( @@ -238,23 +343,9 @@ export const CompetitionFactSchema = new Schema( { timestamps: true, collection: 'competition_fact' }, ); -CompetitionFactSchema.index( - { competitionId: 1, revision: 1, ordinalWithinRevision: 1 }, - { unique: true }, -); -CompetitionFactSchema.index( - { competitionId: 1, commandId: 1, ordinalWithinRevision: 1 }, - { unique: true }, -); -CompetitionFactSchema.index( - { 'evidence.riotMatchId': 1 }, - { - unique: true, - partialFilterExpression: { - type: 'game-accepted', - 'evidence.riotMatchId': { $type: 'string' }, - }, - }, +applyCompetitionDomainInvariantIndexes( + CompetitionFactSchema, + 'competition_fact', ); CompetitionFactSchema.index({ competitionId: 1, seriesId: 1, recordedAt: 1 }); @@ -286,12 +377,11 @@ export const CompetitionOutboxSchema = new Schema( { timestamps: true, collection: 'competition_outbox' }, ); -CompetitionOutboxSchema.index({ eventId: 1 }, { unique: true }); -CompetitionOutboxSchema.index({ state: 1, availableAt: 1 }); -CompetitionOutboxSchema.index( - { competitionId: 1, idempotencyKey: 1 }, - { unique: true }, +applyCompetitionDomainInvariantIndexes( + CompetitionOutboxSchema, + 'competition_outbox', ); +CompetitionOutboxSchema.index({ state: 1, availableAt: 1 }); export const TournamentCodeAssignmentSchema = new Schema( @@ -323,30 +413,22 @@ export const TournamentCodeAssignmentSchema = { timestamps: true, collection: 'tournament_code_assignment' }, ); -const activeAssignmentFilter = { state: { $in: ['reserved', 'used'] } }; -TournamentCodeAssignmentSchema.index( - { gameSlotId: 1 }, - { - unique: true, - partialFilterExpression: activeAssignmentFilter, - }, -); -TournamentCodeAssignmentSchema.index( - { tournamentCodeId: 1 }, - { - unique: true, - partialFilterExpression: activeAssignmentFilter, - }, -); -TournamentCodeAssignmentSchema.index( - { riotMatchId: 1 }, - { - unique: true, - partialFilterExpression: { riotMatchId: { $type: 'string' } }, - }, +applyCompetitionDomainInvariantIndexes( + TournamentCodeAssignmentSchema, + 'tournament_code_assignment', ); TournamentCodeAssignmentSchema.index({ competitionId: 1, state: 1 }); +export function applyCompetitionDomainInvariantIndexes( + schema: mongoose.Schema, + collection: CompetitionDomainInvariantIndex['collection'], +): void { + for (const index of COMPETITION_DOMAIN_INVARIANT_INDEXES) { + if (index.collection !== collection) continue; + schema.index(index.key, index.options); + } +} + export const competitionModelDefinitions: Array<{ name: string; schema: mongoose.Schema; diff --git a/apps/api/src/modules/competition/domain/competition-projector.spec.ts b/apps/api/src/modules/competition/domain/competition-projector.spec.ts index c648c17f..c83a66ea 100644 --- a/apps/api/src/modules/competition/domain/competition-projector.spec.ts +++ b/apps/api/src/modules/competition/domain/competition-projector.spec.ts @@ -307,6 +307,114 @@ describe('projectCompetition', () => { expect(projection.games).toEqual([]); }); + it('rejects an accepted game that targets a Series outside the graph', () => { + const competitionId = 'competition-unknown-game-series'; + const teams = [seededTeam('team-1', 1), seededTeam('team-2', 2)]; + const format = { + type: 'paired-series' as const, + rule: fixedGames(1), + }; + const seriesGraph = generateSeriesGraph({ competitionId, teams, format }); + const accepted = acceptedGameFactory(competitionId)( + seriesGraph[0], + 1, + 'team-1', + 'team-2', + 'team-1', + ); + + expect(() => + projectCompetition({ + competitionId, + revision: 1, + projectorVersion: 1, + teams, + format, + seriesGraph, + facts: [{ ...accepted, seriesId: 'series-does-not-exist' }], + }), + ).toThrow( + expect.objectContaining({ + code: 'GAME_SERIES_MISMATCH', + }), + ); + }); + + it('rejects an accepted game that targets an unknown GameSlot', () => { + const competitionId = 'competition-unknown-game-slot'; + const teams = [seededTeam('team-1', 1), seededTeam('team-2', 2)]; + const format = { + type: 'paired-series' as const, + rule: fixedGames(1), + }; + const seriesGraph = generateSeriesGraph({ competitionId, teams, format }); + const accepted = acceptedGameFactory(competitionId)( + seriesGraph[0], + 1, + 'team-1', + 'team-2', + 'team-1', + ); + + expect(() => + projectCompetition({ + competitionId, + revision: 1, + projectorVersion: 1, + teams, + format, + seriesGraph, + facts: [{ ...accepted, gameSlotId: 'slot-does-not-exist' }], + }), + ).toThrow( + expect.objectContaining({ + code: 'GAME_SLOT_INVALID', + }), + ); + }); + + it('rejects an adjudication that targets a Series outside the graph', () => { + const competitionId = 'competition-unknown-adjudication-series'; + const teams = [seededTeam('team-1', 1), seededTeam('team-2', 2)]; + const format = { + type: 'paired-series' as const, + rule: fixedGames(1), + }; + const seriesGraph = generateSeriesGraph({ competitionId, teams, format }); + + expect(() => + projectCompetition({ + competitionId, + revision: 1, + projectorVersion: 1, + teams, + format, + seriesGraph, + facts: [ + { + id: 'fact-unknown-adjudication-series', + type: 'series-adjudicated', + competitionId, + revision: 1, + ordinalWithinRevision: 1, + commandId: 'command-unknown-adjudication-series', + schemaVersion: 1, + actor: { type: 'user' }, + occurredAt: new Date('2026-07-12T00:00:01.000Z'), + recordedAt: new Date('2026-07-12T00:00:02.000Z'), + seriesId: 'series-does-not-exist', + decision: { type: 'administrative', winnerTeamId: 'team-1' }, + reason: 'Manual correction', + }, + ], + }), + ).toThrow( + expect.objectContaining({ + code: 'ADJUDICATION_INVALID', + }), + ); + }); + it('completes an eight-team double elimination with shared elimination-round placements', () => { const competitionId = 'competition-eight-team-completion'; const teams = Array.from({ length: 8 }, (_, index) => diff --git a/apps/api/src/modules/competition/domain/competition-projector.ts b/apps/api/src/modules/competition/domain/competition-projector.ts index 976a86da..4e431d3a 100644 --- a/apps/api/src/modules/competition/domain/competition-projector.ts +++ b/apps/api/src/modules/competition/domain/competition-projector.ts @@ -1,3 +1,4 @@ +import { assertCompetitionInvariant } from './domain-error'; import type { CompetitionGraphFormat, CompetitionGraphTeam, @@ -130,6 +131,7 @@ export interface CompetitionProjection { export function projectCompetition( input: ProjectCompetitionInput, ): CompetitionProjection { + assertPrimaryFactTargetsGraph(input.seriesGraph, input.facts); const teamBySeed = new Map(); const knownTeams = new Set(); for (const team of input.teams) { @@ -279,6 +281,68 @@ export function projectCompetition( } } +function assertPrimaryFactTargetsGraph( + graph: readonly SeriesDefinition[], + facts: readonly unknown[], +): void { + const definitionsById = new Map( + graph.map((definition) => [definition.id, definition]), + ); + + for (const fact of facts) { + if (!isRecord(fact)) continue; + + if (fact.type === 'game-accepted') { + const seriesId = + typeof fact.seriesId === 'string' ? fact.seriesId : undefined; + const definition = seriesId ? definitionsById.get(seriesId) : undefined; + assertCompetitionInvariant( + definition !== undefined, + 'GAME_SERIES_MISMATCH', + `Accepted game targets an unknown Series ${String(fact.seriesId)}`, + { factId: fact.id, seriesId: fact.seriesId }, + ); + + const gameSlot = definition.gameSlots.find( + ({ id }) => id === fact.gameSlotId, + ); + assertCompetitionInvariant( + gameSlot !== undefined, + 'GAME_SLOT_INVALID', + `Accepted game targets an unknown GameSlot ${String(fact.gameSlotId)}`, + { + factId: fact.id, + seriesId: definition.id, + gameSlotId: fact.gameSlotId, + }, + ); + assertCompetitionInvariant( + gameSlot.ordinal === fact.ordinal, + 'GAME_ORDINAL_INVALID', + `Accepted game ordinal does not match GameSlot ${gameSlot.id}`, + { + factId: fact.id, + gameSlotId: gameSlot.id, + expectedOrdinal: gameSlot.ordinal, + actualOrdinal: fact.ordinal, + }, + ); + continue; + } + + if (fact.type === 'series-adjudicated') { + const seriesId = + typeof fact.seriesId === 'string' ? fact.seriesId : undefined; + assertCompetitionInvariant( + seriesId !== undefined && definitionsById.has(seriesId), + 'ADJUDICATION_INVALID', + `Adjudication targets an unknown Series ${String(fact.seriesId)}`, + { factId: fact.id, seriesId: fact.seriesId }, + ); + } + } +} + function asProjectorDefinition( definition: SeriesDefinition, ): SeriesDefinitionLike { diff --git a/apps/api/src/modules/global/database/migrations/competition-domain-runner.spec.ts b/apps/api/src/modules/global/database/migrations/competition-domain-runner.spec.ts index 580eddf8..c0d65a78 100644 --- a/apps/api/src/modules/global/database/migrations/competition-domain-runner.spec.ts +++ b/apps/api/src/modules/global/database/migrations/competition-domain-runner.spec.ts @@ -36,6 +36,7 @@ describe('migrateCompetitionDomain', () => { expect(startSession).not.toHaveBeenCalled(); expect(db.writeCount).toBe(0); expect(db.docs('competition')).toHaveLength(0); + expect(db.createdIndexes).toHaveLength(0); }); it('applies one Match atomically and converges on an already-applied replay', async () => { @@ -181,6 +182,309 @@ describe('migrateCompetitionDomain', () => { }); expect(db.writeCount).toBe(0); }); + + it('ensures every Competition unique or partial index before the first apply write', async () => { + const match = readyMatch(); + const db = new MemoryMigrationDb({ + match: [match], + riotMatch: [riotArchive()], + tournamentCode: [usedTournamentCode(match)], + }); + + const result = await migrateCompetitionDomain(db, { + dryRun: false, + startSession: () => Promise.resolve(new FakeSession()), + }); + + expect(result.indexPreflight).toMatchObject({ + status: 'ensured', + requiredIndexes: 10, + conflicts: [], + }); + expect(result.indexPreflight.ensuredIndexes).toHaveLength(10); + expect(db.createdIndexes).toHaveLength(10); + expect(db.createdIndexes).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + collection: 'match', + key: { competitionId: 1 }, + options: expect.objectContaining({ + unique: true, + partialFilterExpression: { + competitionId: { $type: 'objectId' }, + }, + }), + }), + expect.objectContaining({ + collection: 'competition', + key: { matchId: 1 }, + options: expect.objectContaining({ unique: true }), + }), + expect.objectContaining({ + collection: 'competition_fact', + key: { 'evidence.riotMatchId': 1 }, + options: expect.objectContaining({ + unique: true, + partialFilterExpression: expect.any(Object), + }), + }), + expect.objectContaining({ + collection: 'tournament_code_assignment', + key: { gameSlotId: 1 }, + options: expect.objectContaining({ + unique: true, + partialFilterExpression: expect.any(Object), + }), + }), + ]), + ); + expect(db.operations.indexOf('create-index')).toBeLessThan( + db.operations.indexOf('write'), + ); + }); + + it('blocks apply with a machine-readable report when a required index cannot be created', async () => { + const match = readyMatch(); + const db = new MemoryMigrationDb({ match: [match] }); + db.indexCreationError = Object.assign( + new Error('E11000 duplicate key while building competitionId_1'), + { + code: 11000, + keyPattern: { competitionId: 1 }, + keyValue: { competitionId: match._id }, + }, + ); + const startSession = jest.fn(() => Promise.resolve(new FakeSession())); + + const result = await migrateCompetitionDomain(db, { + dryRun: false, + startSession, + }); + + expect(result.indexPreflight).toMatchObject({ + status: 'blocked', + conflicts: [ + expect.objectContaining({ + collection: 'match', + code: 11000, + keyValue: { + competitionId: (match._id as mongoose.Types.ObjectId).toHexString(), + }, + }), + ], + }); + expect(result.matches).toEqual([]); + expect(result.summary.scanned).toBe(0); + expect(startSession).not.toHaveBeenCalled(); + expect(db.writeCount).toBe(0); + }); + + it('quarantines a later Match that reuses an already accepted global Riot identity', async () => { + const firstMatch = readyMatch('KR_SHARED_MIGRATION'); + const secondMatch = readyMatch('KR_SHARED_MIGRATION'); + const db = new MemoryMigrationDb({ + match: [firstMatch, secondMatch], + riotMatch: [riotArchive('KR_SHARED_MIGRATION')], + tournamentCode: [ + usedTournamentCode(firstMatch, 'KR_SHARED_MIGRATION'), + usedTournamentCode(secondMatch, 'KR_SHARED_MIGRATION'), + ], + }); + + const result = await migrateCompetitionDomain(db, { + dryRun: false, + startSession: () => Promise.resolve(new FakeSession()), + }); + + expect(result.summary).toMatchObject({ applied: 1, quarantined: 1 }); + expect(result.matches).toContainEqual( + expect.objectContaining({ + status: 'quarantined', + reasons: expect.arrayContaining([ + expect.objectContaining({ code: 'GLOBAL_UNIQUE_INDEX_CONFLICT' }), + ]), + }), + ); + expect(db.docs('competition_fact')).toHaveLength(1); + expect(db.docs('competition_migration_quarantine')).toHaveLength(1); + }); + + it('resumes repeated limited apply runs after the durable Match checkpoint', async () => { + const firstMatch = readyMatch('KR_BATCH_1'); + const secondMatch = readyMatch('KR_BATCH_2'); + const db = new MemoryMigrationDb({ + match: [firstMatch, secondMatch], + riotMatch: [riotArchive('KR_BATCH_1'), riotArchive('KR_BATCH_2')], + tournamentCode: [ + usedTournamentCode(firstMatch, 'KR_BATCH_1'), + usedTournamentCode(secondMatch, 'KR_BATCH_2'), + ], + }); + + const first = await migrateCompetitionDomain(db, { + dryRun: false, + limit: 1, + startSession: () => Promise.resolve(new FakeSession()), + }); + const second = await migrateCompetitionDomain(db, { + dryRun: false, + limit: 1, + startSession: () => Promise.resolve(new FakeSession()), + }); + + expect(first.summary).toMatchObject({ scanned: 1, applied: 1 }); + expect(first.resume).toMatchObject({ + strategy: 'checkpoint', + hasMore: true, + completed: false, + }); + expect(second.summary).toMatchObject({ scanned: 1, applied: 1 }); + expect(second.matches[0].matchId).not.toBe(first.matches[0].matchId); + expect(second.resume).toMatchObject({ + strategy: 'checkpoint', + startedAfterMatchId: first.matches[0].matchId, + hasMore: false, + completed: true, + }); + expect(db.docs('competition')).toHaveLength(2); + expect(db.docs('competition_migration_checkpoint')).toHaveLength(1); + }); + + it('does not let an apply checkpoint silently narrow a later dry-run', async () => { + const firstMatch = readyMatch('KR_DRY_RUN_1'); + const secondMatch = readyMatch('KR_DRY_RUN_2'); + const db = new MemoryMigrationDb({ + match: [firstMatch, secondMatch], + riotMatch: [riotArchive('KR_DRY_RUN_1'), riotArchive('KR_DRY_RUN_2')], + tournamentCode: [ + usedTournamentCode(firstMatch, 'KR_DRY_RUN_1'), + usedTournamentCode(secondMatch, 'KR_DRY_RUN_2'), + ], + }); + const applied = await migrateCompetitionDomain(db, { + dryRun: false, + limit: 1, + startSession: () => Promise.resolve(new FakeSession()), + }); + + const dryRun = await migrateCompetitionDomain(db, { + dryRun: true, + limit: 1, + }); + + expect(dryRun.resume.strategy).toBe('none'); + expect(dryRun.matches[0].matchId).toBe(applied.matches[0].matchId); + }); + + it('does not advance a limited-run checkpoint past a failed Match', async () => { + const match = readyMatch('KR_RETRY_AFTER_FAILURE'); + const db = new MemoryMigrationDb({ + match: [match], + riotMatch: [riotArchive('KR_RETRY_AFTER_FAILURE')], + tournamentCode: [usedTournamentCode(match, 'KR_RETRY_AFTER_FAILURE')], + }); + + const failed = await migrateCompetitionDomain(db, { + dryRun: false, + limit: 1, + startSession: () => Promise.resolve(undefined), + }); + + expect(failed.summary).toMatchObject({ scanned: 1, failed: 1 }); + expect(failed.resume).toMatchObject({ + strategy: 'checkpoint', + hasMore: true, + completed: false, + }); + expect(db.docs('competition_migration_checkpoint')).toHaveLength(0); + + const retried = await migrateCompetitionDomain(db, { + dryRun: false, + limit: 1, + startSession: () => Promise.resolve(new FakeSession()), + }); + + expect(db.docs('competition_migration_checkpoint')).toHaveLength(1); + expect(retried.matches[0].matchId).toBe(failed.matches[0].matchId); + expect(retried.summary).toMatchObject({ scanned: 1, applied: 1 }); + }); + + it('durably overrides a later checkpoint before an explicit earlier retry can fail', async () => { + const retryMatch = readyMatch('KR_EXPLICIT_RETRY'); + const laterMatch = readyMatch('KR_LATER_CHECKPOINT'); + const explicitAfter = '000000000000000000000000'; + const migrationRunId = '20260712-competition-domain'; + const db = new MemoryMigrationDb({ + match: [retryMatch, laterMatch], + riotMatch: [ + riotArchive('KR_EXPLICIT_RETRY'), + riotArchive('KR_LATER_CHECKPOINT'), + ], + tournamentCode: [ + usedTournamentCode(retryMatch, 'KR_EXPLICIT_RETRY'), + usedTournamentCode(laterMatch, 'KR_LATER_CHECKPOINT'), + ], + competition_migration_checkpoint: [ + { + _id: migrationRunId, + migrationRunId, + lastMatchId: laterMatch._id, + status: 'running', + }, + ], + }); + + const failed = await migrateCompetitionDomain(db, { + dryRun: false, + limit: 1, + afterMatchId: explicitAfter, + startSession: () => Promise.resolve(undefined), + }); + + expect(failed.summary).toMatchObject({ scanned: 1, failed: 1 }); + expect( + String(db.docs('competition_migration_checkpoint')[0].lastMatchId), + ).toBe(explicitAfter); + + const retried = await migrateCompetitionDomain(db, { + dryRun: false, + limit: 1, + startSession: () => Promise.resolve(new FakeSession()), + }); + + expect(retried.matches[0].matchId).toBe(failed.matches[0].matchId); + expect(retried.summary).toMatchObject({ scanned: 1, applied: 1 }); + }); + + it('does not persist an explicit checkpoint override during dry-run', async () => { + const match = readyMatch('KR_DRY_EXPLICIT_CURSOR'); + const migrationRunId = '20260712-competition-domain'; + const persistedCheckpoint = objectId(); + const db = new MemoryMigrationDb({ + match: [match], + riotMatch: [riotArchive('KR_DRY_EXPLICIT_CURSOR')], + tournamentCode: [usedTournamentCode(match, 'KR_DRY_EXPLICIT_CURSOR')], + competition_migration_checkpoint: [ + { + _id: migrationRunId, + migrationRunId, + lastMatchId: persistedCheckpoint, + status: 'running', + }, + ], + }); + + await migrateCompetitionDomain(db, { + dryRun: true, + limit: 1, + afterMatchId: '000000000000000000000000', + }); + + expect( + String(db.docs('competition_migration_checkpoint')[0].lastMatchId), + ).toBe(persistedCheckpoint.toHexString()); + expect(db.writeCount).toBe(0); + }); }); class FakeSession implements CompetitionDomainMigrationSession { @@ -211,6 +515,13 @@ type AnyDoc = Record & { _id: unknown }; class MemoryMigrationDb implements CompetitionDomainMigrationDb { private readonly collections = new Map(); public writeCount = 0; + public readonly createdIndexes: Array<{ + collection: string; + key: Record; + options: Record; + }> = []; + public readonly operations: string[] = []; + public indexCreationError?: Error; constructor(seed: Record = {}) { for (const [name, docs] of Object.entries(seed)) { @@ -227,6 +538,23 @@ class MemoryMigrationDb implements CompetitionDomainMigrationDb { collection(name: string) { const owner = this; return { + createIndex( + key: Record, + options: Record, + ) { + owner.operations.push('create-index'); + if (owner.indexCreationError) { + const error = owner.indexCreationError; + owner.indexCreationError = undefined; + return Promise.reject(error); + } + owner.createdIndexes.push({ collection: name, key, options }); + return Promise.resolve( + typeof options.name === 'string' + ? options.name + : Object.keys(key).join('_'), + ); + }, find(filter: Record) { return new MemoryCursor(() => owner.docs(name).filter((doc) => matches(doc, filter)), @@ -240,6 +568,7 @@ class MemoryMigrationDb implements CompetitionDomainMigrationDb { update: Record>, options: { upsert?: boolean } = {}, ) { + owner.operations.push('write'); owner.writeCount += 1; const docs = owner.docs(name); let doc = docs.find((candidate) => matches(candidate, filter)); @@ -251,6 +580,7 @@ class MemoryMigrationDb implements CompetitionDomainMigrationDb { if (!doc) return { matchedCount: 0, modifiedCount: 0 }; if (inserted) Object.assign(doc, update.$setOnInsert ?? {}); Object.assign(doc, update.$set ?? {}); + for (const field of Object.keys(update.$unset ?? {})) delete doc[field]; return { matchedCount: inserted ? 0 : 1, modifiedCount: 1, @@ -258,6 +588,7 @@ class MemoryMigrationDb implements CompetitionDomainMigrationDb { }; }, async deleteOne(filter: Record) { + owner.operations.push('write'); owner.writeCount += 1; const docs = owner.docs(name); const index = docs.findIndex((doc) => matches(doc, filter)); @@ -318,6 +649,9 @@ function matches(doc: AnyDoc, filter: Record): boolean { sameValue(actual, candidate), ); } + if ('$gt' in expected) { + return String(actual) > String(expected.$gt); + } } return sameValue(actual, expected); }); @@ -348,7 +682,7 @@ function isRecord(value: unknown): value is Record { return value !== null && typeof value === 'object' && !Array.isArray(value); } -function readyMatch(): AnyDoc { +function readyMatch(riotMatchId = 'KR_MIGRATION_1'): AnyDoc { const matchId = objectId(); const codeId = objectId(); return { @@ -362,11 +696,11 @@ function readyMatch(): AnyDoc { gameSchedule: [{ gameNumber: 1, teamAIndex: 1, teamBIndex: 2 }], tournamentCodeIds: [codeId], result: { - riotMatchIds: ['KR_MIGRATION_1'], + riotMatchIds: [riotMatchId], games: [ { gameNumber: 1, - riotMatchId: 'KR_MIGRATION_1', + riotMatchId, blueTeamIndex: 1, redTeamIndex: 2, winnerTeamIndex: 1, @@ -383,23 +717,26 @@ function readyMatch(): AnyDoc { }; } -function usedTournamentCode(match = readyMatch()): AnyDoc { +function usedTournamentCode( + match = readyMatch(), + riotMatchId = 'KR_MIGRATION_1', +): AnyDoc { return { _id: match.tournamentCodeIds[0], matchId: match._id, state: 'used', gameNumber: 1, - riotMatchId: 'KR_MIGRATION_1', + riotMatchId, reservedAt: new Date('2026-07-01T00:30:00.000Z'), usedAt: new Date('2026-07-01T01:00:00.000Z'), }; } -function riotArchive(): AnyDoc { +function riotArchive(matchId = 'KR_MIGRATION_1'): AnyDoc { return { _id: objectId(), - matchId: 'KR_MIGRATION_1', - raw: { metadata: { matchId: 'KR_MIGRATION_1' } }, + matchId, + raw: { metadata: { matchId } }, }; } diff --git a/apps/api/src/modules/global/database/migrations/competition-domain-runner.ts b/apps/api/src/modules/global/database/migrations/competition-domain-runner.ts index 3b4c246c..542bc458 100644 --- a/apps/api/src/modules/global/database/migrations/competition-domain-runner.ts +++ b/apps/api/src/modules/global/database/migrations/competition-domain-runner.ts @@ -1,6 +1,10 @@ import { createHash } from 'node:crypto'; import mongoose from 'mongoose'; import { projectCompetition } from '../../../competition/domain/competition-projector'; +import { + COMPETITION_DOMAIN_INVARIANT_INDEXES, + type CompetitionDomainInvariantIndex, +} from '../../../competition/competition.schema'; import { planCompetitionMigration, type CompetitionMigrationAssignment, @@ -21,6 +25,10 @@ export interface CompetitionDomainMigrationCursor extends AsyncIterable; find( filter: Record, options?: { session?: CompetitionDomainMigrationSession }, @@ -34,6 +42,7 @@ export interface CompetitionDomainMigrationCollection { update: { $set?: Record; $setOnInsert?: Record; + $unset?: Record; }, options?: { session?: CompetitionDomainMigrationSession; @@ -64,6 +73,7 @@ export interface CompetitionDomainMigrationSession { export interface CompetitionDomainMigrationOptions { dryRun?: boolean; limit?: number; + afterMatchId?: string; migrationRunId?: string; now?: Date; startSession?: () => Promise; @@ -118,10 +128,37 @@ export interface CompetitionDomainMigrationSummary { export interface CompetitionDomainMigrationResult { migrationRunId: string; mode: 'dry-run' | 'apply'; + indexPreflight: CompetitionDomainIndexPreflight; + resume: CompetitionDomainMigrationResume; summary: CompetitionDomainMigrationSummary; matches: CompetitionDomainMigrationMatchResult[]; } +export interface CompetitionDomainMigrationResume { + strategy: 'none' | 'cursor' | 'checkpoint'; + startedAfterMatchId?: string; + checkpointAfterMatchId?: string; + hasMore: boolean; + completed: boolean; +} + +export interface CompetitionDomainIndexConflict { + collection: CompetitionDomainInvariantIndex['collection']; + indexName: string; + key: Record; + code?: number; + keyPattern?: Record; + keyValue?: unknown; + message: string; +} + +export interface CompetitionDomainIndexPreflight { + status: 'dry-run' | 'ensured' | 'blocked'; + requiredIndexes: number; + ensuredIndexes: string[]; + conflicts: CompetitionDomainIndexConflict[]; +} + /** * Plans or applies the clean-break Competition migration. Apply mode owns one * Mongo transaction per Match so a process can be stopped and safely resumed. @@ -135,9 +172,43 @@ export async function migrateCompetitionDomain( options.migrationRunId?.trim() || DEFAULT_MIGRATION_RUN_ID; assertOptions(options); - const matchSnapshots = await scanMatches(db, options.limit); + const resumeStart = await resolveResumeStart( + db, + migrationRunId, + options, + dryRun, + ); + + const indexPreflight = await ensureCompetitionDomainIndexes(db, dryRun); + if (indexPreflight.status === 'blocked') { + return { + migrationRunId, + mode: 'apply', + indexPreflight, + resume: resumeReport(resumeStart, undefined, true, false), + summary: summarize([]), + matches: [], + }; + } + if (!dryRun && options.limit !== undefined && options.afterMatchId) { + await persistMigrationCheckpoint(db, { + migrationRunId, + matchId: options.afterMatchId, + completed: false, + resetMatchStatus: true, + observedAt: options.now ?? new Date(), + }); + } + + const scan = await scanMatches( + db, + options.limit, + resumeStart.startedAfterMatchId, + ); const matches: CompetitionDomainMigrationMatchResult[] = []; - for (const [index, scannedMatch] of matchSnapshots.entries()) { + let checkpointAfterMatchId = resumeStart.startedAfterMatchId; + let haltedOnFailure = false; + for (const [index, scannedMatch] of scan.matches.entries()) { const result = dryRun ? await inspectMatch(db, scannedMatch, migrationRunId) : await applyMatch(db, scannedMatch, migrationRunId, options); @@ -146,29 +217,216 @@ export async function migrateCompetitionDomain( index: index + 1, matchId: result.matchId, status: result.status, - total: matchSnapshots.length, + total: scan.matches.length, + }); + if (!dryRun && options.limit !== undefined) { + if (result.status === 'failed') { + haltedOnFailure = true; + break; + } + await persistMigrationCheckpoint(db, { + migrationRunId, + matchId: result.matchId, + matchStatus: result.status, + completed: false, + observedAt: options.now ?? new Date(), + }); + checkpointAfterMatchId = result.matchId; + } + } + + const hasMore = + scan.hasMore || haltedOnFailure || matches.length < scan.matches.length; + const completed = + !hasMore && !matches.some(({ status }) => status === 'failed'); + if (!dryRun && options.limit !== undefined && completed) { + await persistMigrationCheckpoint(db, { + migrationRunId, + matchId: checkpointAfterMatchId, + completed: true, + observedAt: options.now ?? new Date(), }); } return { migrationRunId, mode: dryRun ? 'dry-run' : 'apply', + indexPreflight, + resume: resumeReport( + resumeStart, + checkpointAfterMatchId, + hasMore, + completed, + ), summary: summarize(matches), matches, }; } +interface ResumeStart { + strategy: CompetitionDomainMigrationResume['strategy']; + startedAfterMatchId?: string; +} + +async function resolveResumeStart( + db: CompetitionDomainMigrationDb, + migrationRunId: string, + options: CompetitionDomainMigrationOptions, + dryRun: boolean, +): Promise { + if (dryRun || options.limit === undefined) { + return { + strategy: options.afterMatchId ? 'cursor' : 'none', + ...(options.afterMatchId + ? { startedAfterMatchId: options.afterMatchId } + : {}), + }; + } + if (options.afterMatchId) { + return { + strategy: 'cursor', + startedAfterMatchId: options.afterMatchId, + }; + } + const checkpoint = await db + .collection('competition_migration_checkpoint') + .findOne({ _id: migrationRunId }); + const checkpointMatchId = optionalIdString(checkpoint?.lastMatchId); + if (checkpointMatchId) assertMatchCursor(checkpointMatchId); + return { + strategy: 'checkpoint', + ...(checkpointMatchId ? { startedAfterMatchId: checkpointMatchId } : {}), + }; +} + +function resumeReport( + start: ResumeStart, + checkpointAfterMatchId: string | undefined, + hasMore: boolean, + completed: boolean, +): CompetitionDomainMigrationResume { + return { + strategy: start.strategy, + ...(start.startedAfterMatchId + ? { startedAfterMatchId: start.startedAfterMatchId } + : {}), + ...(checkpointAfterMatchId ? { checkpointAfterMatchId } : {}), + hasMore, + completed, + }; +} + +async function persistMigrationCheckpoint( + db: CompetitionDomainMigrationDb, + params: { + migrationRunId: string; + matchId?: string; + matchStatus?: CompetitionDomainMigrationMatchResult['status']; + completed: boolean; + resetMatchStatus?: boolean; + observedAt: Date; + }, +): Promise { + await db.collection('competition_migration_checkpoint').updateOne( + { _id: params.migrationRunId }, + { + $set: { + migrationRunId: params.migrationRunId, + status: params.completed ? 'completed' : 'running', + ...(params.matchId + ? { lastMatchId: persistenceId(params.matchId) } + : {}), + ...(params.matchStatus ? { lastMatchStatus: params.matchStatus } : {}), + updatedAt: params.observedAt, + }, + $setOnInsert: { + _id: params.migrationRunId, + createdAt: params.observedAt, + }, + ...(params.resetMatchStatus ? { $unset: { lastMatchStatus: 1 } } : {}), + }, + { upsert: true }, + ); +} + +async function ensureCompetitionDomainIndexes( + db: CompetitionDomainMigrationDb, + dryRun: boolean, +): Promise { + if (dryRun) { + return { + status: 'dry-run', + requiredIndexes: COMPETITION_DOMAIN_INVARIANT_INDEXES.length, + ensuredIndexes: [], + conflicts: [], + }; + } + + const ensuredIndexes: string[] = []; + const conflicts: CompetitionDomainIndexConflict[] = []; + for (const index of COMPETITION_DOMAIN_INVARIANT_INDEXES) { + try { + const createdName = await db + .collection(index.collection) + .createIndex(index.key, index.options); + ensuredIndexes.push(createdName); + } catch (error) { + conflicts.push(indexConflict(index, error)); + } + } + return { + status: conflicts.length > 0 ? 'blocked' : 'ensured', + requiredIndexes: COMPETITION_DOMAIN_INVARIANT_INDEXES.length, + ensuredIndexes, + conflicts, + }; +} + +function indexConflict( + index: CompetitionDomainInvariantIndex, + error: unknown, +): CompetitionDomainIndexConflict { + const record = isRecord(error) ? error : {}; + const code = + typeof record.code === 'number' && Number.isInteger(record.code) + ? record.code + : undefined; + const keyPattern = isRecord(record.keyPattern) + ? (canonicalValue(record.keyPattern) as Record) + : undefined; + const keyValue = + record.keyValue === undefined ? undefined : canonicalValue(record.keyValue); + return { + collection: index.collection, + indexName: index.options.name, + key: canonicalValue(index.key) as Record, + ...(code === undefined ? {} : { code }), + ...(keyPattern ? { keyPattern } : {}), + ...(keyValue === undefined ? {} : { keyValue }), + message: error instanceof Error ? error.message : String(error), + }; +} + async function scanMatches( db: CompetitionDomainMigrationDb, limit: number | undefined, -): Promise { - return readCursor( + afterMatchId: string | undefined, +): Promise<{ matches: AnyDocument[]; hasMore: boolean }> { + const scanned = await readCursor( db .collection('match') - .find(MATCH_SCAN_FILTER) + .find({ + ...MATCH_SCAN_FILTER, + ...(afterMatchId ? { _id: { $gt: persistenceId(afterMatchId) } } : {}), + }) .sort({ _id: 1 }) - .limit(limit ?? 0), + .limit(limit === undefined ? 0 : limit + 1), ); + if (limit === undefined) return { matches: scanned, hasMore: false }; + return { + matches: scanned.slice(0, limit), + hasMore: scanned.length > limit, + }; } async function inspectMatch( @@ -260,6 +518,30 @@ async function applyMatch( }; } + const uniquenessConflicts = await findReadyPlanUniquenessConflicts( + db, + plan, + session, + ); + if (uniquenessConflicts.length > 0) { + await persistQuarantine( + db, + currentMatch, + uniquenessConflicts, + plan.warnings, + migrationRunId, + options.now ?? new Date(), + session, + ); + await session.commitTransaction(); + return { + status: 'quarantined', + matchId, + warnings: plan.warnings, + reasons: uniquenessConflicts, + }; + } + await upsertReadyPlan(db, plan, session); await verifyReadyPlan(db, plan, session); @@ -305,6 +587,123 @@ async function applyMatch( } } +interface UniqueIdentityCheck { + collection: 'competition' | 'competition_fact' | 'tournament_code_assignment'; + indexName: string; + filter: Record; + expectedDocumentId: string; +} + +async function findReadyPlanUniquenessConflicts( + db: CompetitionDomainMigrationDb, + plan: ReadyCompetitionMigrationPlan, + session: CompetitionDomainMigrationSession, +): Promise { + const checks: UniqueIdentityCheck[] = [ + { + collection: 'competition', + indexName: 'matchId_1', + filter: { matchId: persistenceId(plan.competition.matchId) }, + expectedDocumentId: plan.competition.id, + }, + ]; + + for (const fact of plan.facts) { + checks.push( + { + collection: 'competition_fact', + indexName: 'competitionId_1_revision_1_ordinalWithinRevision_1', + filter: { + competitionId: persistenceId(fact.competitionId), + revision: fact.revision, + ordinalWithinRevision: fact.ordinalWithinRevision, + }, + expectedDocumentId: fact.id, + }, + { + collection: 'competition_fact', + indexName: 'competitionId_1_commandId_1_ordinalWithinRevision_1', + filter: { + competitionId: persistenceId(fact.competitionId), + commandId: fact.commandId, + ordinalWithinRevision: fact.ordinalWithinRevision, + }, + expectedDocumentId: fact.id, + }, + ); + if (fact.type === 'game-accepted' && fact.evidence.type === 'riot') { + checks.push({ + collection: 'competition_fact', + indexName: 'evidence.riotMatchId_1', + filter: { + type: 'game-accepted', + 'evidence.riotMatchId': fact.evidence.riotMatchId, + }, + expectedDocumentId: fact.id, + }); + } + } + + for (const assignment of plan.assignments) { + if (assignment.state === 'reserved' || assignment.state === 'used') { + checks.push( + { + collection: 'tournament_code_assignment', + indexName: 'gameSlotId_1', + filter: { + gameSlotId: persistenceId(assignment.gameSlotId), + state: { $in: ['reserved', 'used'] }, + }, + expectedDocumentId: assignment.id, + }, + { + collection: 'tournament_code_assignment', + indexName: 'tournamentCodeId_1', + filter: { + tournamentCodeId: persistenceId(assignment.tournamentCodeId), + state: { $in: ['reserved', 'used'] }, + }, + expectedDocumentId: assignment.id, + }, + ); + } + if (assignment.riotMatchId) { + checks.push({ + collection: 'tournament_code_assignment', + indexName: 'riotMatchId_1', + filter: { riotMatchId: assignment.riotMatchId }, + expectedDocumentId: assignment.id, + }); + } + } + + const conflicts: CompetitionMigrationIssue[] = []; + // Mongo sessions do not support parallel operations inside one transaction. + for (const check of checks) { + const existing = await db + .collection(check.collection) + .findOne(check.filter, { session }); + if (!existing || idString(existing._id) === check.expectedDocumentId) { + continue; + } + conflicts.push({ + code: 'GLOBAL_UNIQUE_INDEX_CONFLICT', + message: `Migration input conflicts with ${check.collection}.${check.indexName}.`, + details: { + collection: check.collection, + indexName: check.indexName, + key: canonicalValue(check.filter) as Record, + expectedDocumentId: check.expectedDocumentId, + conflictingDocumentId: idString(existing._id), + ...(existing.competitionId + ? { conflictingCompetitionId: idString(existing.competitionId) } + : {}), + }, + }); + } + return conflicts; +} + async function hydrateLegacyMatch( db: CompetitionDomainMigrationDb, match: AnyDocument, @@ -819,6 +1218,17 @@ function assertOptions(options: CompetitionDomainMigrationOptions): void { if (options.dryRun === false && !options.startSession) { throw new Error('Apply mode requires a transaction session factory.'); } + if (options.afterMatchId !== undefined) { + assertMatchCursor(options.afterMatchId); + } +} + +function assertMatchCursor(value: string): void { + if (!/^[a-f\d]{24}$/i.test(value)) { + throw new Error( + 'Competition migration afterMatchId must be a 24-character hexadecimal Match ObjectId.', + ); + } } async function readCursor( diff --git a/apps/api/src/modules/global/database/migrations/run-competition-domain.spec.ts b/apps/api/src/modules/global/database/migrations/run-competition-domain.spec.ts index f1c3b0b7..ed69f1aa 100644 --- a/apps/api/src/modules/global/database/migrations/run-competition-domain.spec.ts +++ b/apps/api/src/modules/global/database/migrations/run-competition-domain.spec.ts @@ -31,4 +31,22 @@ describe('competition domain migration CLI', () => { nodeEnv: 'dev', }); }); + + it('accepts an explicit Match cursor for limited-run recovery', () => { + expect( + parseCliOptions([ + '--apply', + '--limit=25', + '--after', + '66a000000000000000000123', + ]), + ).toMatchObject({ + dryRun: false, + limit: 25, + afterMatchId: '66a000000000000000000123', + }); + expect(() => parseCliOptions(['--after', 'not-an-object-id'])).toThrow( + '--after requires a 24-character hexadecimal Match ObjectId.', + ); + }); }); diff --git a/apps/api/src/modules/global/database/migrations/run-competition-domain.ts b/apps/api/src/modules/global/database/migrations/run-competition-domain.ts index 6c3133b6..9c9d954f 100644 --- a/apps/api/src/modules/global/database/migrations/run-competition-domain.ts +++ b/apps/api/src/modules/global/database/migrations/run-competition-domain.ts @@ -15,6 +15,7 @@ export interface CompetitionDomainCliOptions { dryRun: boolean; help: boolean; limit?: number; + afterMatchId?: string; nodeEnv: string; } @@ -60,6 +61,7 @@ export function parseCliOptions(argv: string[]): CompetitionDomainCliOptions { let dryRun = true; let help = false; let limit: number | undefined; + let afterMatchId: string | undefined; let nodeEnv = process.env.NODE_ENV ?? 'dev'; for (let index = 0; index < argv.length; index += 1) { @@ -95,6 +97,15 @@ export function parseCliOptions(argv: string[]): CompetitionDomainCliOptions { limit = positiveInteger(argument.slice('--limit='.length), '--limit'); continue; } + if (argument === '--after') { + afterMatchId = matchObjectId(argv[index + 1]); + index += 1; + continue; + } + if (argument.startsWith('--after=')) { + afterMatchId = matchObjectId(argument.slice('--after='.length)); + continue; + } if (argument === '--help' || argument === '-h') { help = true; continue; @@ -105,7 +116,7 @@ export function parseCliOptions(argv: string[]): CompetitionDomainCliOptions { if (!['dev', 'staging', 'prod'].includes(nodeEnv)) { throw new Error('--env must be dev, staging, or prod.'); } - return { dryRun, help, limit, nodeEnv }; + return { dryRun, help, limit, afterMatchId, nodeEnv }; } function positiveInteger(value: string | undefined, label: string): number { @@ -116,6 +127,15 @@ function positiveInteger(value: string | undefined, label: string): number { return parsed; } +function matchObjectId(value: string | undefined): string { + if (!value || !/^[a-f\d]{24}$/i.test(value)) { + throw new Error( + '--after requires a 24-character hexadecimal Match ObjectId.', + ); + } + return value.toLowerCase(); +} + function printHelp(): void { process.stdout.write(`Usage: pnpm --silent --filter api competition:migrate @@ -125,7 +145,8 @@ Options: --dry-run Plan and report without writes. Default. --apply Apply one transaction per Match. --env dev | staging | prod. Default: NODE_ENV or dev. - --limit Scan at most n Matches in deterministic _id order. + --limit Scan at most n Matches. Apply resumes from a durable checkpoint. + --after Override the checkpoint with a Match ObjectId cursor. The JSON report is written to stdout; the concise human summary is written to stderr. `); @@ -153,6 +174,7 @@ async function main(): Promise { { dryRun: options.dryRun, limit: options.limit, + afterMatchId: options.afterMatchId, startSession: options.dryRun ? undefined : async () => connection.startSession(), @@ -164,11 +186,15 @@ async function main(): Promise { `db=${resolveMongoDbName(options.nodeEnv)} scanned=${summary.scanned} ` + `ready=${summary.ready} applied=${summary.applied} ` + `alreadyApplied=${summary.alreadyApplied} quarantined=${summary.quarantined} ` + - `failed=${summary.failed} unclassified=${summary.unclassified}\n`, + `failed=${summary.failed} unclassified=${summary.unclassified} ` + + `indexPreflight=${result.indexPreflight.status} ` + + `resume=${result.resume.checkpointAfterMatchId ?? 'none'} ` + + `completed=${result.resume.completed}\n`, ); process.stdout.write(`${JSON.stringify(result, null, 2)}\n`); - if (summary.failed > 0) process.exitCode = 1; + if (result.indexPreflight.status === 'blocked') process.exitCode = 1; + else if (summary.failed > 0) process.exitCode = 1; else if (summary.quarantined > 0) process.exitCode = 2; } finally { await app.close().catch((error: unknown) => { diff --git a/apps/api/src/modules/global/database/schema.ts b/apps/api/src/modules/global/database/schema.ts index 34783ab9..a162f2b6 100644 --- a/apps/api/src/modules/global/database/schema.ts +++ b/apps/api/src/modules/global/database/schema.ts @@ -8,6 +8,7 @@ import { CompetitionFact, CompetitionOutbox, TournamentCodeAssignment, + applyCompetitionDomainInvariantIndexes, competitionModelDefinitions, } from '../../competition/competition.schema'; import { ModelDefinition } from './types'; @@ -465,6 +466,7 @@ export interface TournamentCode extends MongooseTimestamps { reservedAt?: Date; usedAt?: Date; releasedAt?: Date; + voidedAt?: Date; riotMatchId?: string; uploadedBy: mongoose.Types.ObjectId; uploadedAt: Date; @@ -1501,6 +1503,7 @@ export const TournamentCodeSchema = new Schema( reservedAt: { type: Date }, usedAt: { type: Date }, releasedAt: { type: Date }, + voidedAt: { type: Date }, riotMatchId: { type: String }, uploadedBy: { type: Schema.Types.ObjectId, ref: 'user', required: true }, uploadedAt: { type: Date, required: true, default: Date.now }, @@ -1952,13 +1955,7 @@ export const MatchSchema = new Schema( ); MatchSchema.index({ communityId: 1, scheduledAt: -1 }); -MatchSchema.index( - { competitionId: 1 }, - { - unique: true, - partialFilterExpression: { competitionId: { $type: 'objectId' } }, - }, -); +applyCompetitionDomainInvariantIndexes(MatchSchema, 'match'); MatchSchema.index({ communityId: 1, status: 1, scheduledAt: -1 }); MatchSchema.index( { communityId: 1, shortCode: 1 }, diff --git a/apps/api/src/modules/legacy-import/legacy-import-result-cutover.spec.ts b/apps/api/src/modules/legacy-import/legacy-import-result-cutover.spec.ts index e7aa8d8d..4619fa50 100644 --- a/apps/api/src/modules/legacy-import/legacy-import-result-cutover.spec.ts +++ b/apps/api/src/modules/legacy-import/legacy-import-result-cutover.spec.ts @@ -294,16 +294,40 @@ describe('Legacy import Competition result cutover', () => { it('cascades admin deletion through Competition facts and read models', async () => { const fixture = createImportFixture(); + const session = { + startTransaction: jest.fn(), + commitTransaction: jest.fn().mockResolvedValue(undefined), + abortTransaction: jest.fn().mockResolvedValue(undefined), + endSession: jest.fn().mockResolvedValue(undefined), + }; const competitionFactModel = deleteManyModel(); const competitionOutboxModel = deleteManyModel(); - const assignmentModel = deleteManyModel(); + const reservedCodeId = new mongoose.Types.ObjectId(); + const usedCodeId = new mongoose.Types.ObjectId(); + const assignmentModel = { + ...deleteManyModel(), + find: jest.fn().mockReturnValue({ + select: jest.fn().mockReturnValue({ + session: jest.fn().mockReturnValue({ + lean: jest.fn().mockReturnValue( + execResult([ + { tournamentCodeId: reservedCodeId, state: 'reserved' }, + { tournamentCodeId: usedCodeId, state: 'used' }, + ]), + ), + }), + }), + }), + }; const competitionModel = { ...deleteManyModel(), find: jest.fn().mockReturnValue({ select: jest.fn().mockReturnValue({ - lean: jest - .fn() - .mockReturnValue(execResult([{ _id: fixture.competition._id }])), + session: jest.fn().mockReturnValue({ + lean: jest + .fn() + .mockReturnValue(execResult([{ _id: fixture.competition._id }])), + }), }), }), }; @@ -311,11 +335,44 @@ describe('Legacy import Competition result cutover', () => { find: jest.fn().mockReturnValue({ select: jest .fn() - .mockReturnValue(execResult([{ _id: fixture.match._id }])), + .mockReturnValue(sessionResult([{ _id: fixture.match._id }])), }), - deleteMany: jest.fn().mockReturnValue(execResult({ deletedCount: 1 })), + deleteMany: jest.fn().mockReturnValue(sessionResult({ deletedCount: 1 })), + }; + const tournamentCodeModel = { + find: jest.fn().mockReturnValue({ + select: jest.fn().mockReturnValue({ + session: jest.fn().mockReturnValue({ + lean: jest.fn().mockReturnValue( + execResult([ + { + _id: reservedCodeId, + state: 'reserved', + matchId: fixture.match._id, + }, + { + _id: usedCodeId, + state: 'used', + matchId: fixture.match._id, + }, + ]), + ), + }), + }), + }), + updateMany: jest + .fn() + .mockReturnValue(sessionResult({ matchedCount: 1, modifiedCount: 1 })), + }; + const matchStatsModel = deleteManyModel(); + const quarantineCollection = { + deleteMany: jest.fn().mockResolvedValue({ deletedCount: 1 }), }; const connectionService = { + createSession: jest.fn().mockResolvedValue(session), + getConnection: jest.fn().mockResolvedValue({ + collection: jest.fn().mockReturnValue(quarantineCollection), + }), getModel: jest.fn((name: string) => { const models: Record = { match: matchModel, @@ -323,6 +380,8 @@ describe('Legacy import Competition result cutover', () => { competitionFact: competitionFactModel, competitionOutbox: competitionOutboxModel, tournamentCodeAssignment: assignmentModel, + tournamentCode: tournamentCodeModel, + matchStats: matchStatsModel, }; const model = models[name]; return model @@ -330,15 +389,11 @@ describe('Legacy import Competition result cutover', () => { : Promise.reject(new Error(`Unexpected model ${name}`)); }), } as unknown as ConnectionService; - const matchStatsService = { - removeByMatches: jest.fn().mockResolvedValue(undefined), - } as unknown as jest.Mocked; const communityStatsService = { invalidateCommunity: jest.fn().mockResolvedValue(undefined), } as unknown as jest.Mocked; const service = createService({ connectionService, - matchStatsService, communityStatsService, }); @@ -360,9 +415,98 @@ describe('Legacy import Competition result cutover', () => { expect(competitionModel.deleteMany).toHaveBeenCalledWith({ _id: { $in: [fixture.competition._id] }, }); - expect(matchStatsService.removeByMatches).toHaveBeenCalledWith([ - fixture.match._id, - ]); + expect(tournamentCodeModel.updateMany).toHaveBeenCalledTimes(2); + expect(matchStatsModel.deleteMany).toHaveBeenCalledWith({ + matchId: { $in: [fixture.match._id] }, + }); + expect(session.commitTransaction).toHaveBeenCalledTimes(1); + expect(session.abortTransaction).not.toHaveBeenCalled(); + expect(communityStatsService.invalidateCommunity).toHaveBeenCalledWith( + fixture.match.communityId, + ); + }); + + it('aborts legacy deletion when an active assignment points to another Match code', async () => { + const harness = createBulkDeleteFailureHarness({ + codeMatchId: new mongoose.Types.ObjectId(), + }); + + await expect( + harness.service.bulkDeleteLegacyMatches({ + communityId: harness.fixture.match.communityId, + body: { matchIds: [harness.fixture.match._id.toString()] }, + }), + ).rejects.toThrow(/Tournament Code assignment/); + + expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1); + expect(harness.session.commitTransaction).not.toHaveBeenCalled(); + expect(harness.matchModel.deleteMany).not.toHaveBeenCalled(); + expect(harness.competitionFactModel.deleteMany).not.toHaveBeenCalled(); + }); + + it('aborts legacy deletion when a validated Tournament Code transition does not update exactly once', async () => { + const harness = createBulkDeleteFailureHarness({ + updateResult: { matchedCount: 0, modifiedCount: 0 }, + }); + + await expect( + harness.service.bulkDeleteLegacyMatches({ + communityId: harness.fixture.match.communityId, + body: { matchIds: [harness.fixture.match._id.toString()] }, + }), + ).rejects.toThrow(/Tournament Code transition/); + + expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1); + expect(harness.session.commitTransaction).not.toHaveBeenCalled(); + expect(harness.matchModel.deleteMany).not.toHaveBeenCalled(); + }); + + it('invalidates community caches again when a committed deletion is retried', async () => { + const harness = createBulkDeleteFailureHarness({}); + harness.matchModel.find + .mockReset() + .mockReturnValueOnce({ + select: jest + .fn() + .mockReturnValue(sessionResult([{ _id: harness.fixture.match._id }])), + }) + .mockReturnValueOnce({ + select: jest.fn().mockReturnValue(sessionResult([])), + }); + harness.communityStatsService.invalidateCommunity + .mockRejectedValueOnce(new Error('Redis unavailable')) + .mockResolvedValueOnce(0); + + await expect( + harness.service.bulkDeleteLegacyMatches({ + communityId: harness.fixture.match.communityId, + body: { matchIds: [harness.fixture.match._id.toString()] }, + }), + ).rejects.toThrow('Redis unavailable'); + + await expect( + harness.service.bulkDeleteLegacyMatches({ + communityId: harness.fixture.match.communityId, + body: { matchIds: [harness.fixture.match._id.toString()] }, + }), + ).resolves.toEqual({ deleted: 0 }); + expect( + harness.communityStatsService.invalidateCommunity, + ).toHaveBeenCalledTimes(2); + }); + + it('removes migration quarantine records in the same legacy deletion transaction', async () => { + const harness = createBulkDeleteFailureHarness({}); + + await harness.service.bulkDeleteLegacyMatches({ + communityId: harness.fixture.match.communityId, + body: { matchIds: [harness.fixture.match._id.toString()] }, + }); + + expect(harness.quarantineCollection.deleteMany).toHaveBeenCalledWith( + { _id: { $in: [harness.fixture.match._id] } }, + { session: harness.session }, + ); }); it('rebuilds a historical legacy Match into Competition facts without rewriting Match.result', async () => { @@ -707,10 +851,135 @@ function execResult(value: T) { return { exec: jest.fn().mockResolvedValue(value) }; } +function sessionResult(value: T) { + const query = { + exec: jest.fn().mockResolvedValue(value), + session: jest.fn(), + }; + query.session.mockReturnValue(query); + return query; +} + function deleteManyModel() { return { deleteMany: jest .fn() - .mockReturnValue(execResult({ acknowledged: true, deletedCount: 1 })), + .mockReturnValue(sessionResult({ acknowledged: true, deletedCount: 1 })), + }; +} + +function createBulkDeleteFailureHarness(options: { + codeMatchId?: mongoose.Types.ObjectId; + codeState?: 'reserved' | 'used'; + assignmentState?: 'reserved' | 'used'; + updateResult?: { matchedCount: number; modifiedCount: number }; +}) { + const fixture = createImportFixture(); + const session = { + startTransaction: jest.fn(), + commitTransaction: jest.fn().mockResolvedValue(undefined), + abortTransaction: jest.fn().mockResolvedValue(undefined), + endSession: jest.fn().mockResolvedValue(undefined), + }; + const tournamentCodeId = new mongoose.Types.ObjectId(); + const assignmentState = options.assignmentState ?? 'reserved'; + const codeState = options.codeState ?? assignmentState; + const assignmentModel = { + ...deleteManyModel(), + find: jest.fn().mockReturnValue({ + select: jest.fn().mockReturnValue({ + session: jest.fn().mockReturnValue({ + lean: jest + .fn() + .mockReturnValue( + execResult([{ tournamentCodeId, state: assignmentState }]), + ), + }), + }), + }), + }; + const competitionModel = { + ...deleteManyModel(), + find: jest.fn().mockReturnValue({ + select: jest.fn().mockReturnValue({ + session: jest.fn().mockReturnValue({ + lean: jest + .fn() + .mockReturnValue(execResult([{ _id: fixture.competition._id }])), + }), + }), + }), + }; + const matchModel = { + find: jest.fn().mockReturnValue({ + select: jest + .fn() + .mockReturnValue(sessionResult([{ _id: fixture.match._id }])), + }), + deleteMany: jest.fn().mockReturnValue(sessionResult({ deletedCount: 1 })), + }; + const tournamentCodeModel = { + find: jest.fn().mockReturnValue({ + select: jest.fn().mockReturnValue({ + session: jest.fn().mockReturnValue({ + lean: jest.fn().mockReturnValue( + execResult([ + { + _id: tournamentCodeId, + state: codeState, + matchId: options.codeMatchId ?? fixture.match._id, + }, + ]), + ), + }), + }), + }), + updateMany: jest + .fn() + .mockReturnValue( + sessionResult( + options.updateResult ?? { matchedCount: 1, modifiedCount: 1 }, + ), + ), + }; + const competitionFactModel = deleteManyModel(); + const competitionOutboxModel = deleteManyModel(); + const matchStatsModel = deleteManyModel(); + const quarantineCollection = { + deleteMany: jest.fn().mockResolvedValue({ deletedCount: 1 }), + }; + const connectionService = { + createSession: jest.fn().mockResolvedValue(session), + getConnection: jest.fn().mockResolvedValue({ + collection: jest.fn().mockReturnValue(quarantineCollection), + }), + getModel: jest.fn((name: string) => { + const models: Record = { + match: matchModel, + competition: competitionModel, + competitionFact: competitionFactModel, + competitionOutbox: competitionOutboxModel, + tournamentCodeAssignment: assignmentModel, + tournamentCode: tournamentCodeModel, + matchStats: matchStatsModel, + }; + const model = models[name]; + return model + ? Promise.resolve(model) + : Promise.reject(new Error(`Unexpected model ${name}`)); + }), + } as unknown as ConnectionService; + const communityStatsService = { + invalidateCommunity: jest.fn().mockResolvedValue(0), + } as unknown as jest.Mocked; + const service = createService({ connectionService, communityStatsService }); + return { + fixture, + session, + service, + matchModel, + competitionFactModel, + communityStatsService, + quarantineCollection, }; } diff --git a/apps/api/src/modules/legacy-import/legacy-import.service.ts b/apps/api/src/modules/legacy-import/legacy-import.service.ts index 7b1a3cf5..5b320bed 100644 --- a/apps/api/src/modules/legacy-import/legacy-import.service.ts +++ b/apps/api/src/modules/legacy-import/legacy-import.service.ts @@ -2,6 +2,7 @@ import { BadRequestException, ConflictException, Injectable, + InternalServerErrorException, Logger, NotFoundException, } from '@nestjs/common'; @@ -381,60 +382,194 @@ export class LegacyImportService { .filter((id) => mongoose.isValidObjectId(id)) .map((id) => new mongoose.Types.ObjectId(id)); if (ids.length === 0) return { deleted: 0 }; - const MatchModel = await this.connectionService.getModel('match'); - const targets = await MatchModel.find({ - _id: { $in: ids }, - communityId: params.communityId, - legacyImported: true, - }) - .select({ _id: 1 }) - .exec(); - const targetIds = targets.map((match) => match._id); - if (targetIds.length === 0) return { deleted: 0 }; - const [ + MatchModel, CompetitionModel, CompetitionFactModel, CompetitionOutboxModel, AssignmentModel, + TournamentCodeModel, + MatchStatsModel, + connection, ] = await Promise.all([ + this.connectionService.getModel('match'), this.connectionService.getModel('competition'), this.connectionService.getModel('competitionFact'), this.connectionService.getModel('competitionOutbox'), this.connectionService.getModel('tournamentCodeAssignment'), + this.connectionService.getModel('tournamentCode'), + this.connectionService.getModel('matchStats'), + this.connectionService.getConnection(), ]); - const competitions = await CompetitionModel.find({ - matchId: { $in: targetIds }, - }) - .select({ _id: 1 }) - .lean() - .exec(); - const competitionIds = competitions.map(({ _id }) => _id); - if (competitionIds.length > 0) { - await Promise.all([ - CompetitionFactModel.deleteMany({ - competitionId: { $in: competitionIds }, - }).exec(), - CompetitionOutboxModel.deleteMany({ - competitionId: { $in: competitionIds }, - }).exec(), - AssignmentModel.deleteMany({ - competitionId: { $in: competitionIds }, - }).exec(), - ]); - await CompetitionModel.deleteMany({ - _id: { $in: competitionIds }, - }).exec(); + const session = await this.connectionService.createSession(); + if (!session) { + throw new InternalServerErrorException( + 'A MongoDB transaction is required to delete legacy Matches.', + ); + } + + let deleted = 0; + try { + session.startTransaction(); + const targets = await MatchModel.find({ + _id: { $in: ids }, + communityId: params.communityId, + legacyImported: true, + }) + .select({ _id: 1 }) + .session(session) + .exec(); + const targetIds = targets.map((match) => match._id); + if (targetIds.length === 0) { + await session.commitTransaction(); + } else { + const competitions = await CompetitionModel.find({ + matchId: { $in: targetIds }, + }) + .select({ _id: 1 }) + .session(session) + .lean() + .exec(); + const competitionIds = competitions.map(({ _id }) => _id); + if (competitionIds.length > 0) { + const assignments = await AssignmentModel.find({ + competitionId: { $in: competitionIds }, + state: { $in: ['reserved', 'used'] }, + }) + .select({ tournamentCodeId: 1, state: 1 }) + .session(session) + .lean() + .exec(); + const assignmentCodeIds = assignments.map( + ({ tournamentCodeId }) => tournamentCodeId, + ); + const uniqueAssignmentCodeIds = new Set( + assignmentCodeIds.map((id) => id.toString()), + ); + if (uniqueAssignmentCodeIds.size !== assignmentCodeIds.length) { + throw new ConflictException( + 'Tournament Code assignments contain a duplicate active code identity.', + ); + } + const tournamentCodes = + assignmentCodeIds.length === 0 + ? [] + : await TournamentCodeModel.find({ + _id: { $in: assignmentCodeIds }, + }) + .select({ _id: 1, state: 1, matchId: 1 }) + .session(session) + .lean() + .exec(); + const tournamentCodeById = new Map( + tournamentCodes.map((code) => [code._id.toString(), code]), + ); + const targetIdSet = new Set(targetIds.map((id) => id.toString())); + for (const assignment of assignments) { + const code = tournamentCodeById.get( + assignment.tournamentCodeId.toString(), + ); + if ( + !code || + code.state !== assignment.state || + !code.matchId || + !targetIdSet.has(code.matchId.toString()) + ) { + throw new ConflictException( + 'Tournament Code assignment ownership or state does not match the target legacy Match.', + ); + } + } + const releasedCodeIds = assignments + .filter(({ state }) => state === 'reserved') + .map(({ tournamentCodeId }) => tournamentCodeId); + const voidedCodeIds = assignments + .filter(({ state }) => state === 'used') + .map(({ tournamentCodeId }) => tournamentCodeId); + const terminalAt = new Date(); + if (releasedCodeIds.length > 0) { + const released = await TournamentCodeModel.updateMany( + { + _id: { $in: releasedCodeIds }, + matchId: { $in: targetIds }, + state: 'reserved', + }, + { + $set: { state: 'released', releasedAt: terminalAt }, + $unset: legacyTournamentCodeBindingUnset(), + }, + ) + .session(session) + .exec(); + assertExactTournamentCodeTransition( + released, + releasedCodeIds.length, + ); + } + if (voidedCodeIds.length > 0) { + const voided = await TournamentCodeModel.updateMany( + { + _id: { $in: voidedCodeIds }, + matchId: { $in: targetIds }, + state: 'used', + }, + { + $set: { state: 'voided', voidedAt: terminalAt }, + $unset: legacyTournamentCodeBindingUnset(), + }, + ) + .session(session) + .exec(); + assertExactTournamentCodeTransition(voided, voidedCodeIds.length); + } + + await CompetitionFactModel.deleteMany({ + competitionId: { $in: competitionIds }, + }) + .session(session) + .exec(); + await CompetitionOutboxModel.deleteMany({ + competitionId: { $in: competitionIds }, + }) + .session(session) + .exec(); + await AssignmentModel.deleteMany({ + competitionId: { $in: competitionIds }, + }) + .session(session) + .exec(); + await CompetitionModel.deleteMany({ + _id: { $in: competitionIds }, + }) + .session(session) + .exec(); + } + + await connection + .collection('competition_migration_quarantine') + .deleteMany({ _id: { $in: targetIds } }, { session }); + const result = await MatchModel.deleteMany({ + _id: { $in: targetIds }, + communityId: params.communityId, + legacyImported: true, + }) + .session(session) + .exec(); + await MatchStatsModel.deleteMany({ matchId: { $in: targetIds } }) + .session(session) + .exec(); + deleted = result.deletedCount ?? 0; + await session.commitTransaction(); + } + } catch (error) { + await session.abortTransaction().catch(() => undefined); + throw error; + } finally { + await session.endSession().catch(() => undefined); } - const result = await MatchModel.deleteMany({ - _id: { $in: targetIds }, - communityId: params.communityId, - legacyImported: true, - }).exec(); - await this.matchStatsService.removeByMatches(targetIds); await this.communityStatsService.invalidateCommunity(params.communityId); - return { deleted: result.deletedCount ?? 0 }; + return { deleted }; } public async rebuildLegacyMatches(params: { @@ -1322,6 +1457,29 @@ function optionalNumber(value: unknown): number | undefined { : undefined; } +function legacyTournamentCodeBindingUnset(): Record { + return { + matchId: 1, + gameNumber: 1, + bracketMatchId: 1, + reservedAt: 1, + }; +} + +function assertExactTournamentCodeTransition( + result: { matchedCount?: number; modifiedCount?: number }, + expectedCount: number, +): void { + if ( + result.matchedCount !== expectedCount || + result.modifiedCount !== expectedCount + ) { + throw new ConflictException( + 'Tournament Code transition did not update every validated assignment.', + ); + } +} + function deterministicObjectId(key: string): mongoose.Types.ObjectId { return new mongoose.Types.ObjectId( createHash('sha256').update(key).digest('hex').slice(0, 24), diff --git a/apps/api/src/modules/match/dto/create-match.dto.spec.ts b/apps/api/src/modules/match/dto/create-match.dto.spec.ts index 99e8e941..2b77dc13 100644 --- a/apps/api/src/modules/match/dto/create-match.dto.spec.ts +++ b/apps/api/src/modules/match/dto/create-match.dto.spec.ts @@ -1,7 +1,9 @@ import 'reflect-metadata'; +import { BadRequestException, ValidationPipe } from '@nestjs/common'; import { plainToInstance } from 'class-transformer'; import { validateSync } from 'class-validator'; -import { CreateMatchDto } from './create-match.dto'; +import mongoose from 'mongoose'; +import { CreateMatchDto, JoinMatchDto } from './create-match.dto'; describe('CreateMatchDto game mode cutover', () => { it('rejects the removed live bracket mode', () => { @@ -31,3 +33,31 @@ describe('CreateMatchDto game mode cutover', () => { }, ); }); + +describe('JoinMatchDto self-join boundary', () => { + it('rejects a caller-supplied userId', async () => { + const pipe = new ValidationPipe({ + whitelist: true, + forbidNonWhitelisted: true, + transform: true, + }); + + try { + await pipe.transform( + { + preferredPositions: [{ position: 'MID', priority: 1 }], + userId: new mongoose.Types.ObjectId().toString(), + }, + { type: 'body', metatype: JoinMatchDto }, + ); + throw new Error('Expected validation to reject userId.'); + } catch (error) { + expect(error).toBeInstanceOf(BadRequestException); + expect((error as BadRequestException).getResponse()).toEqual({ + error: 'Bad Request', + message: ['property userId should not exist'], + statusCode: 400, + }); + } + }); +}); diff --git a/apps/api/src/modules/match/dto/create-match.dto.ts b/apps/api/src/modules/match/dto/create-match.dto.ts index 5c5b418d..5f60725d 100644 --- a/apps/api/src/modules/match/dto/create-match.dto.ts +++ b/apps/api/src/modules/match/dto/create-match.dto.ts @@ -215,10 +215,6 @@ export class JoinMatchDto { @ValidateNested({ each: true }) @Type(() => PositionPreferenceDto) preferredPositions!: PositionPreferenceDto[]; - - @IsOptional() - @IsString() - userId?: string; } export class AddParticipantDto { @@ -234,13 +230,3 @@ export class AddParticipantDto { @IsString() riotPuuid?: string; } - -export class SwapDoubleEliminationSeedsDto { - @IsInt() - @Min(1) - leftSeedNumber!: number; - - @IsInt() - @Min(1) - rightSeedNumber!: number; -} diff --git a/apps/api/src/modules/match/match-public.presenter.spec.ts b/apps/api/src/modules/match/match-public.presenter.spec.ts index c86fdfca..de26841c 100644 --- a/apps/api/src/modules/match/match-public.presenter.spec.ts +++ b/apps/api/src/modules/match/match-public.presenter.spec.ts @@ -9,6 +9,7 @@ describe('presentPublicMatch', () => { competitionId: oid('3'), shortCode: '33NW', title: '내전', + joined: false, description: '설명', mapId: 11, status: 'in-progress', @@ -25,6 +26,16 @@ describe('presentPublicMatch', () => { gameName: '선수', tagLine: 'KR1', profileIconId: 1, + tier: { + queueType: 'RANKED_SOLO_5x5', + tier: 'GOLD', + rank: 'I', + leaguePoints: 42, + wins: 10, + losses: 5, + fetchedAt: new Date('2026-07-10T00:00:00.000Z'), + puuid: 'secret-tier-puuid', + }, preferredPositions: [ { position: 'MID', priority: 1 }, { position: 'SUP', priority: 2 }, @@ -65,6 +76,15 @@ describe('presentPublicMatch', () => { expect.objectContaining({ userId: oid('5').toString(), joinedAt: '2026-07-01T00:00:00.000Z', + tier: { + queueType: 'RANKED_SOLO_5x5', + tier: 'GOLD', + rank: 'I', + leaguePoints: 42, + wins: 10, + losses: 5, + fetchedAt: '2026-07-10T00:00:00.000Z', + }, }), ], teams: [ @@ -89,6 +109,7 @@ describe('presentPublicMatch', () => { expect(response).not.toHaveProperty('resultPollState'); expect(response).not.toHaveProperty('legacyImportSource'); expect(response.participants[0]).not.toHaveProperty('puuid'); + expect(response.participants[0]?.tier).not.toHaveProperty('puuid'); }); }); diff --git a/apps/api/src/modules/match/match-public.presenter.ts b/apps/api/src/modules/match/match-public.presenter.ts index ccadcca3..42572f7e 100644 --- a/apps/api/src/modules/match/match-public.presenter.ts +++ b/apps/api/src/modules/match/match-public.presenter.ts @@ -1,3 +1,4 @@ +import type { MatchDetailResponse, MatchTierView } from '@lolympus/contracts'; import type { MatchGameMode, MatchStatus, @@ -57,12 +58,12 @@ interface PublicMatchSource { export function presentPublicMatch( source: PublicMatchSource, options: { joined?: boolean } = {}, -) { +): MatchDetailResponse { return { - _id: source._id.toString(), - communityId: source.communityId.toString(), + _id: source._id.toString() as never, + communityId: source.communityId.toString() as never, ...(source.competitionId - ? { competitionId: source.competitionId.toString() } + ? { competitionId: source.competitionId.toString() as never } : {}), ...(source.shortCode ? { shortCode: source.shortCode } : {}), title: source.title, @@ -82,32 +83,37 @@ export function presentPublicMatch( source.doubleElimination?.resetFinalEnabled ?? false, } : {}), - ...(source.hostUserId ? { hostUserId: source.hostUserId.toString() } : {}), - participants: source.participants.map((participant) => ({ - userId: participant.userId.toString(), - ...(participant.gameName ? { gameName: participant.gameName } : {}), - ...(participant.tagLine ? { tagLine: participant.tagLine } : {}), - ...(participant.profileIconId === undefined - ? {} - : { profileIconId: participant.profileIconId }), - ...(participant.tier === undefined - ? {} - : { tier: toWireValue(participant.tier) }), - preferredPositions: participant.preferredPositions.map((preference) => ({ - position: preference.position, - priority: preference.priority, - })), - joinedAt: asIso(participant.joinedAt), - excluded: participant.excluded ?? false, - })), + ...(source.hostUserId + ? { hostUserId: source.hostUserId.toString() as never } + : {}), + participants: source.participants.map((participant) => { + const tier = toPublicTier(participant.tier); + return { + userId: participant.userId.toString() as never, + ...(participant.gameName ? { gameName: participant.gameName } : {}), + ...(participant.tagLine ? { tagLine: participant.tagLine } : {}), + ...(participant.profileIconId === undefined + ? {} + : { profileIconId: participant.profileIconId }), + ...(tier ? { tier } : {}), + preferredPositions: participant.preferredPositions.map( + (preference) => ({ + position: preference.position, + priority: preference.priority, + }), + ), + joinedAt: asIso(participant.joinedAt), + excluded: participant.excluded ?? false, + }; + }), teams: source.teams.map((team) => ({ teamIndex: team.teamIndex, name: team.name, ...(team.captainUserId - ? { captainUserId: team.captainUserId.toString() } + ? { captainUserId: team.captainUserId.toString() as never } : {}), members: team.members.map((member) => ({ - userId: member.userId.toString(), + userId: member.userId.toString() as never, assignedPosition: member.assignedPosition, ...(member.cost === undefined ? {} : { cost: member.cost }), })), @@ -115,7 +121,7 @@ export function presentPublicMatch( prizes: [...source.prizes], notices: [...source.notices], schedule: source.schedule.map(({ time, label }) => ({ time, label })), - ...(options.joined === undefined ? {} : { joined: options.joined }), + joined: options.joined ?? false, createdAt: asIso(source.createdAt), updatedAt: asIso(source.updatedAt), }; @@ -125,13 +131,29 @@ function asIso(value: Date | string): string { return value instanceof Date ? value.toISOString() : value; } -function toWireValue(value: unknown): unknown { - if (value instanceof Date) return value.toISOString(); - if (Array.isArray(value)) return value.map(toWireValue); - if (typeof value === 'object' && value !== null) { - return Object.fromEntries( - Object.entries(value).map(([key, child]) => [key, toWireValue(child)]), - ); +function toPublicTier(value: unknown): MatchTierView | undefined { + if (typeof value !== 'object' || value === null || Array.isArray(value)) { + return undefined; } - return value; + const tier = value as Record; + if ( + typeof tier.queueType !== 'string' || + typeof tier.tier !== 'string' || + typeof tier.rank !== 'string' || + typeof tier.leaguePoints !== 'number' || + typeof tier.wins !== 'number' || + typeof tier.losses !== 'number' || + !(typeof tier.fetchedAt === 'string' || tier.fetchedAt instanceof Date) + ) { + return undefined; + } + return { + queueType: tier.queueType, + tier: tier.tier, + rank: tier.rank, + leaguePoints: tier.leaguePoints, + wins: tier.wins, + losses: tier.losses, + fetchedAt: asIso(tier.fetchedAt), + }; } diff --git a/apps/api/src/modules/match/match.controller.spec.ts b/apps/api/src/modules/match/match.controller.spec.ts new file mode 100644 index 00000000..36d85ea7 --- /dev/null +++ b/apps/api/src/modules/match/match.controller.spec.ts @@ -0,0 +1,93 @@ +import 'reflect-metadata'; +import { GUARDS_METADATA } from '@nestjs/common/constants'; +import mongoose from 'mongoose'; +import { METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED } from '../auth/allow-public-access.decorator'; +import { ROLES_KEY } from '../auth/roles.decorator'; +import { RolesGuard } from '../auth/roles.guard'; +import type { UserDocument } from '../global/database/schema'; +import { MatchController } from './match.controller'; + +describe('MatchController participant access', () => { + function createController() { + const joinedMatch = { _id: new mongoose.Types.ObjectId() }; + const response = { _id: joinedMatch._id.toString(), joined: true }; + const matchService = { + join: jest.fn().mockResolvedValue(joinedMatch), + serialize: jest.fn().mockReturnValue(response), + }; + + return { + controller: new MatchController(matchService as never), + joinedMatch, + matchService, + response, + }; + } + + function createUser(communityId: mongoose.Types.ObjectId): UserDocument { + return { + _id: new mongoose.Types.ObjectId(), + communityId, + role: 'member', + } as UserDocument; + } + + it('requires an authenticated community member for the self-join route', () => { + // Metadata must be read from the unbound prototype method itself. + // eslint-disable-next-line @typescript-eslint/unbound-method + const handler = MatchController.prototype.joinMatch; + const roles = Reflect.getMetadata(ROLES_KEY, handler) as + | string[] + | undefined; + const guards = Reflect.getMetadata(GUARDS_METADATA, handler) as + | unknown[] + | undefined; + + expect( + Reflect.getMetadata(METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED, handler), + ).not.toBe(true); + expect(roles).toHaveLength(3); + expect(roles).toEqual(expect.arrayContaining(['owner', 'admin', 'member'])); + expect(guards).toEqual(expect.arrayContaining([RolesGuard])); + }); + + it('joins only the authenticated user', async () => { + const communityId = new mongoose.Types.ObjectId(); + const matchId = new mongoose.Types.ObjectId(); + const currentUser = createUser(communityId); + const preferredPositions = [{ position: 'MID' as const, priority: 1 }]; + const { controller, joinedMatch, matchService, response } = + createController(); + + await expect( + controller.joinMatch(currentUser, communityId, matchId, { + preferredPositions, + }), + ).resolves.toBe(response); + expect(matchService.join).toHaveBeenCalledWith({ + matchId, + communityId, + userId: currentUser._id, + preferredPositions, + }); + expect(matchService.serialize).toHaveBeenCalledWith(joinedMatch, { + joined: true, + }); + }); + + it('rejects a dev-auth user from a different URL community', async () => { + const currentUser = createUser(new mongoose.Types.ObjectId()); + const requestedCommunityId = new mongoose.Types.ObjectId(); + const { controller, matchService } = createController(); + + await expect( + controller.joinMatch( + currentUser, + requestedCommunityId, + new mongoose.Types.ObjectId(), + { preferredPositions: [{ position: 'TOP', priority: 1 }] }, + ), + ).rejects.toThrow('Different community.'); + expect(matchService.join).not.toHaveBeenCalled(); + }); +}); diff --git a/apps/api/src/modules/match/match.controller.ts b/apps/api/src/modules/match/match.controller.ts index 64ffc95b..aa13b292 100644 --- a/apps/api/src/modules/match/match.controller.ts +++ b/apps/api/src/modules/match/match.controller.ts @@ -1,3 +1,7 @@ +import type { + MatchDetailResponse, + MatchListResponse, +} from '@lolympus/contracts'; import { BadRequestException, Body, @@ -23,7 +27,6 @@ import { AddParticipantDto, CreateMatchDto, JoinMatchDto, - SwapDoubleEliminationSeedsDto, UpdateMatchDto, UpdateParticipantDto, } from './dto/create-match.dto'; @@ -41,9 +44,9 @@ export class MatchController { @Param('communityId', ParseObjectIdPipe) communityId: mongoose.Types.ObjectId, @Body() body: CreateMatchDto, - ) { + ): Promise { this.assertSameCommunity(currentUser, communityId); - return this.matchService.create({ + const match = await this.matchService.create({ communityId, hostUserId: currentUser._id, data: { @@ -62,6 +65,7 @@ export class MatchController { schedule: body.schedule ?? [], }, }); + return this.matchService.serialize(match, { joined: false }); } // 공개 — 커뮤니티 내 매치 리스트. 로그인 시 본인 참여 여부를 함께 반환. @@ -78,7 +82,7 @@ export class MatchController { @Query('scheduledFrom') scheduledFrom?: string, @Query('scheduledTo') scheduledTo?: string, @Query('sort') sort?: 'asc' | 'desc', - ) { + ): Promise { const result = await this.matchService.listPage({ communityId, status, @@ -108,10 +112,20 @@ export class MatchController { @Get(':matchId') @AllowPublicAccess() public async getMatch( + @CurrentUser() currentUser: UserDocument | undefined, + @Param('communityId', ParseObjectIdPipe) + communityId: mongoose.Types.ObjectId, @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, - ) { - const match = await this.matchService.getById(matchId); - return this.matchService.serialize(match); + ): Promise { + const match = await this.matchService.getById(matchId, communityId); + return this.matchService.serialize(match, { + joined: Boolean( + currentUser && + match.participants.some((participant) => + participant.userId.equals(currentUser._id), + ), + ), + }); } @Patch(':matchId') @@ -123,48 +137,18 @@ export class MatchController { communityId: mongoose.Types.ObjectId, @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, @Body() body: UpdateMatchDto, - ) { + ): Promise { this.assertSameCommunity(currentUser, communityId); - return this.matchService.update({ matchId, communityId, patch: body }); - } - - @Post(':matchId/double-elimination/seeds/reshuffle') - @Roles('admin', 'owner') - @UseGuards(RolesGuard) - public async reshuffleDoubleEliminationSeeds( - @CurrentUser() currentUser: UserDocument, - @Param('communityId', ParseObjectIdPipe) - communityId: mongoose.Types.ObjectId, - @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, - ) { - this.assertSameCommunity(currentUser, communityId); - const match = await this.matchService.reshuffleDoubleEliminationSeeds({ + const match = await this.matchService.update({ matchId, communityId, - actorUserId: currentUser._id, + patch: body, }); - return this.matchService.serialize(match); - } - - @Post(':matchId/double-elimination/seeds/swap') - @Roles('admin', 'owner') - @UseGuards(RolesGuard) - public async swapDoubleEliminationSeeds( - @CurrentUser() currentUser: UserDocument, - @Param('communityId', ParseObjectIdPipe) - communityId: mongoose.Types.ObjectId, - @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, - @Body() body: SwapDoubleEliminationSeedsDto, - ) { - this.assertSameCommunity(currentUser, communityId); - const match = await this.matchService.swapDoubleEliminationSeeds({ - matchId, - communityId, - actorUserId: currentUser._id, - leftSeedNumber: body.leftSeedNumber, - rightSeedNumber: body.rightSeedNumber, + return this.matchService.serialize(match, { + joined: match.participants.some((participant) => + participant.userId.equals(currentUser._id), + ), }); - return this.matchService.serialize(match); } @Delete(':matchId') @@ -181,20 +165,25 @@ export class MatchController { await this.matchService.remove({ matchId, communityId }); } - // 공개 — 참여 (로그인된 유저는 자기 자신, 비로그인은 body.userId 사용). + // 커뮤니티 멤버 본인 참여. 다른 유저 추가는 관리자 전용 경로를 사용한다. @Post(':matchId/participants') - @AllowPublicAccess() + @Roles('owner', 'admin', 'member') + @UseGuards(RolesGuard) public async joinMatch( - @CurrentUser() currentUser: UserDocument | undefined, + @CurrentUser() currentUser: UserDocument, + @Param('communityId', ParseObjectIdPipe) + communityId: mongoose.Types.ObjectId, @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, @Body() body: JoinMatchDto, - ) { - const userId = this.resolveJoinerUserId(currentUser, body.userId); - return this.matchService.join({ + ): Promise { + this.assertSameCommunity(currentUser, communityId); + const match = await this.matchService.join({ matchId, - userId, + communityId, + userId: currentUser._id, preferredPositions: body.preferredPositions, }); + return this.matchService.serialize(match, { joined: true }); } // 관리자 전용 — 커뮤니티 유저를 모집중 매치에 직접 추가한다. @@ -208,15 +197,20 @@ export class MatchController { @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, @Param('userId', ParseObjectIdPipe) userId: mongoose.Types.ObjectId, @Body() body: AddParticipantDto | undefined, - ) { + ): Promise { this.assertSameCommunity(currentUser, communityId); const match = await this.matchService.join({ matchId, + communityId, userId, preferredPositions: body?.preferredPositions, riotPuuid: body?.riotPuuid, }); - return this.matchService.serialize(match); + return this.matchService.serialize(match, { + joined: match.participants.some((participant) => + participant.userId.equals(currentUser._id), + ), + }); } // 관리자 전용 — 참가자 주/부 포지션 변경. @@ -230,7 +224,7 @@ export class MatchController { @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, @Param('userId', ParseObjectIdPipe) userId: mongoose.Types.ObjectId, @Body() body: UpdateParticipantDto, - ) { + ): Promise { this.assertSameCommunity(currentUser, communityId); const match = await this.matchService.updateParticipantPositions({ matchId, @@ -239,7 +233,11 @@ export class MatchController { mainPosition: body.mainPosition, subPosition: body.subPosition, }); - return this.matchService.serialize(match); + return this.matchService.serialize(match, { + joined: match.participants.some((participant) => + participant.userId.equals(currentUser._id), + ), + }); } // 관리자 전용 — 참가자 강제 제외. @@ -262,19 +260,6 @@ export class MatchController { }); } - private resolveJoinerUserId( - currentUser: UserDocument | undefined, - bodyUserId?: string, - ): mongoose.Types.ObjectId { - if (currentUser) return currentUser._id; - if (!bodyUserId || !mongoose.isValidObjectId(bodyUserId)) { - throw new BadRequestException( - 'userId is required when not authenticated.', - ); - } - return new mongoose.Types.ObjectId(bodyUserId); - } - private assertSameCommunity( user: UserDocument, communityId: mongoose.Types.ObjectId, diff --git a/apps/api/src/modules/match/match.service.spec.ts b/apps/api/src/modules/match/match.service.spec.ts index 41110da0..e06d039c 100644 --- a/apps/api/src/modules/match/match.service.spec.ts +++ b/apps/api/src/modules/match/match.service.spec.ts @@ -57,6 +57,7 @@ describe('MatchService', () => { ) { const MatchModel = { findById: jest.fn().mockResolvedValue(match), + findOne: jest.fn().mockResolvedValue(match), findOneAndUpdate: jest.fn().mockResolvedValue(updatedMatch), }; const connectionService = { @@ -203,6 +204,19 @@ describe('MatchService', () => { }); }); + it('scopes Match detail lookup to the URL community', async () => { + const matchId = new mongoose.Types.ObjectId(); + const communityId = new mongoose.Types.ObjectId(); + const match = { _id: matchId, communityId }; + const { service, MatchModel } = createService(match); + + await expect(service.getById(matchId, communityId)).resolves.toBe(match); + expect(MatchModel.findOne).toHaveBeenCalledWith({ + _id: matchId, + communityId, + }); + }); + it('applies offset before page-based pagination', async () => { const communityId = new mongoose.Types.ObjectId(); const { service, skip } = createServiceWithListModel(); @@ -344,6 +358,36 @@ describe('MatchService', () => { expect(match.save).not.toHaveBeenCalled(); }); + it('does not join a user from a different community', async () => { + const requestedCommunityId = new mongoose.Types.ObjectId(); + const userId = new mongoose.Types.ObjectId(); + const user = { + _id: userId, + communityId: new mongoose.Types.ObjectId(), + preferredPositions: [], + riotAccounts: [], + }; + const match = { + _id: new mongoose.Types.ObjectId(), + communityId: requestedCommunityId, + status: 'recruiting', + participants: [], + }; + const { service, MatchModel } = createServiceWithJoinModels({ + user, + match, + }); + + await expect( + service.join({ + matchId: match._id, + communityId: requestedCommunityId, + userId, + }), + ).rejects.toThrow('Match not found.'); + expect(MatchModel.findOneAndUpdate).not.toHaveBeenCalled(); + }); + it('cancels a join with an atomic participant pull', async () => { const communityId = new mongoose.Types.ObjectId(); const userId = new mongoose.Types.ObjectId(); @@ -525,7 +569,7 @@ describe('MatchService', () => { expect(MatchModel.create).not.toHaveBeenCalled(); }); - it('clears game schedule when a built match returns to recruiting', async () => { + it('rejects returning a finalized team build to recruiting', async () => { const communityId = new mongoose.Types.ObjectId(); const match = { communityId, @@ -547,20 +591,23 @@ describe('MatchService', () => { const { service, tournamentCodeService, matchStatsService } = createService(match); - await service.update({ - matchId: new mongoose.Types.ObjectId(), - communityId, - patch: { status: 'recruiting' }, - }); - + await expect( + service.update({ + matchId: new mongoose.Types.ObjectId(), + communityId, + patch: { status: 'recruiting' }, + }), + ).rejects.toThrow('cannot return to recruiting'); expect(tournamentCodeService.releaseFromMatch).not.toHaveBeenCalled(); expect(match.tournamentCodeIds).toEqual([]); - expect(match.gameSchedule).toEqual([]); - expect(match.teamBuiltAt).toBeUndefined(); - expect(match.result).toBeUndefined(); - expect(match.resultPollState).toBeUndefined(); - expect(match.save).toHaveBeenCalledTimes(1); - expect(matchStatsService.removeByMatch).toHaveBeenCalledWith(match._id); + expect(match.gameSchedule).toEqual([ + { gameNumber: 1, teamAIndex: 2, teamBIndex: 4 }, + ]); + expect(match.teamBuiltAt).toBeInstanceOf(Date); + expect(match.result).toEqual({ games: [] }); + expect(match.resultPollState).toEqual({ state: 'polling' }); + expect(match.save).not.toHaveBeenCalled(); + expect(matchStatsService.removeByMatch).not.toHaveBeenCalled(); }); it('rejects round-robin max round changes after recruiting', async () => { @@ -581,12 +628,77 @@ describe('MatchService', () => { patch: { roundRobinMaxRounds: 3 }, }), ).rejects.toThrow( - 'maxParticipants, gameMode, roundRobinMaxRounds, and doubleEliminationResetFinalEnabled can only be changed while recruiting.', + 'maxParticipants, gameCount, gameMode, roundRobinMaxRounds, and doubleEliminationResetFinalEnabled can only be changed while recruiting.', ); expect(match.set).not.toHaveBeenCalled(); }); - it('releases reserved codes when returning a built match to recruiting', async () => { + it('rejects game count changes after recruiting', async () => { + const communityId = new mongoose.Types.ObjectId(); + const match = { + communityId, + status: 'team-built', + tournamentCodeIds: [], + set: jest.fn(), + save: jest.fn(), + }; + const { service } = createService(match); + + await expect( + service.update({ + matchId: new mongoose.Types.ObjectId(), + communityId, + patch: { gameCount: 5 }, + }), + ).rejects.toThrow('gameCount'); + expect(match.set).not.toHaveBeenCalled(); + }); + + it('rejects returning to recruiting after Competition bootstrap', async () => { + const communityId = new mongoose.Types.ObjectId(); + const match = { + communityId, + competitionId: new mongoose.Types.ObjectId(), + status: 'team-built', + tournamentCodeIds: [], + set: jest.fn(), + save: jest.fn(), + }; + const { service, tournamentCodeService } = createService(match); + + await expect( + service.update({ + matchId: new mongoose.Types.ObjectId(), + communityId, + patch: { status: 'recruiting' }, + }), + ).rejects.toThrow('cannot return to recruiting'); + expect(match.set).not.toHaveBeenCalled(); + expect(tournamentCodeService.releaseFromMatch).not.toHaveBeenCalled(); + }); + + it('rejects hard deletion after Competition bootstrap', async () => { + const communityId = new mongoose.Types.ObjectId(); + const match = { + _id: new mongoose.Types.ObjectId(), + communityId, + competitionId: new mongoose.Types.ObjectId(), + status: 'recruiting', + tournamentCodeIds: [], + deleteOne: jest.fn(), + }; + const { service, tournamentCodeService, matchStatsService } = + createService(match); + + await expect( + service.remove({ matchId: match._id, communityId }), + ).rejects.toThrow('cannot be hard-deleted'); + expect(tournamentCodeService.releaseFromMatch).not.toHaveBeenCalled(); + expect(matchStatsService.removeByMatch).not.toHaveBeenCalled(); + expect(match.deleteOne).not.toHaveBeenCalled(); + }); + + it('preserves reserved codes when a recruiting rollback is rejected', async () => { const communityId = new mongoose.Types.ObjectId(); const codeId = new mongoose.Types.ObjectId(); const match = { @@ -604,14 +716,18 @@ describe('MatchService', () => { }; const { service, tournamentCodeService } = createService(match); - await service.update({ - matchId: new mongoose.Types.ObjectId(), - communityId, - patch: { status: 'recruiting' }, - }); - - expect(tournamentCodeService.releaseFromMatch).toHaveBeenCalledWith(match); - expect(match.tournamentCodeIds).toEqual([]); - expect(match.gameSchedule).toEqual([]); + await expect( + service.update({ + matchId: new mongoose.Types.ObjectId(), + communityId, + patch: { status: 'recruiting' }, + }), + ).rejects.toThrow('cannot return to recruiting'); + expect(tournamentCodeService.releaseFromMatch).not.toHaveBeenCalled(); + expect(match.tournamentCodeIds).toEqual([codeId]); + expect(match.gameSchedule).toEqual([ + { gameNumber: 1, teamAIndex: 1, teamBIndex: 3 }, + ]); + expect(match.save).not.toHaveBeenCalled(); }); }); diff --git a/apps/api/src/modules/match/match.service.ts b/apps/api/src/modules/match/match.service.ts index 9061cba8..37037459 100644 --- a/apps/api/src/modules/match/match.service.ts +++ b/apps/api/src/modules/match/match.service.ts @@ -1,14 +1,11 @@ import { BadRequestException, + ConflictException, Injectable, InternalServerErrorException, NotFoundException, } from '@nestjs/common'; import mongoose from 'mongoose'; -import { - reshuffleDoubleEliminationSeeds, - swapDoubleEliminationSeeds, -} from '../double-elimination/double-elimination.util'; import { MatchStatsService } from '../community-stats/match-stats.service'; import { CommunityStatsService } from '../community-stats/community-stats.service'; import { ConnectionService } from '../global/database/connection.service'; @@ -76,6 +73,7 @@ interface MatchListFilter { interface JoinMatchParams { matchId: mongoose.Types.ObjectId; + communityId?: mongoose.Types.ObjectId; userId: mongoose.Types.ObjectId; preferredPositions?: PositionPreference[]; // 특정 RiotAccount(puuid)로 참가하고 싶을 때 지정. 없으면 primary 사용. @@ -101,17 +99,6 @@ interface UpdateParticipantPositionsParams { subPosition: Position; } -interface DoubleEliminationAdminParams { - matchId: mongoose.Types.ObjectId; - communityId: mongoose.Types.ObjectId; - actorUserId: mongoose.Types.ObjectId; -} - -interface SwapDoubleEliminationSeedsParams extends DoubleEliminationAdminParams { - leftSeedNumber: number; - rightSeedNumber: number; -} - @Injectable() export class MatchService { constructor( @@ -197,9 +184,10 @@ export class MatchService { public async getById( matchId: mongoose.Types.ObjectId, + communityId: mongoose.Types.ObjectId, ): Promise { const MatchModel = await this.connectionService.getModel('match'); - const match = await MatchModel.findById(matchId); + const match = await MatchModel.findOne({ _id: matchId, communityId }); if (!match) throw new NotFoundException('Match not found.'); return match; } @@ -224,15 +212,24 @@ export class MatchService { throw new BadRequestException('Match does not belong to this community.'); } const previousStatus = match.status; + if ( + previousStatus !== 'recruiting' && + params.patch.status === 'recruiting' + ) { + throw new ConflictException( + 'A finalized team build cannot return to recruiting. Preserve its immutable lifecycle and create a new Match instead.', + ); + } if ( previousStatus !== 'recruiting' && ('maxParticipants' in params.patch || + 'gameCount' in params.patch || 'gameMode' in params.patch || 'roundRobinMaxRounds' in params.patch || 'doubleEliminationResetFinalEnabled' in params.patch) ) { throw new BadRequestException( - 'maxParticipants, gameMode, roundRobinMaxRounds, and doubleEliminationResetFinalEnabled can only be changed while recruiting.', + 'maxParticipants, gameCount, gameMode, roundRobinMaxRounds, and doubleEliminationResetFinalEnabled can only be changed while recruiting.', ); } const patchToSet = @@ -252,21 +249,8 @@ export class MatchService { }) : this.stripMatchConfigInput(params.patch); match.set(patchToSet); - if (previousStatus !== 'recruiting' && match.status === 'recruiting') { - if (match.tournamentCodeIds.length > 0) { - await this.tournamentCodeService.releaseFromMatch(match); - } - match.tournamentCodeIds = []; - match.gameSchedule = []; - match.teamBuiltAt = undefined; - match.result = undefined; - match.resultPollState = undefined; - } await match.save(); - if (previousStatus !== 'recruiting' && match.status === 'recruiting') { - await this.matchStatsService.removeByMatch(match._id); - await this.communityStatsService.invalidateCommunity(params.communityId); - } else if (match.result?.games?.length) { + if (match.result?.games?.length) { await this.matchStatsService.buildAndUpsert(match._id); await this.communityStatsService.invalidateCommunity(params.communityId); } @@ -283,62 +267,31 @@ export class MatchService { if (!match.communityId.equals(params.communityId)) { throw new BadRequestException('Match does not belong to this community.'); } + if (match.status !== 'recruiting') { + throw new ConflictException( + 'Only a recruiting Match can be hard-deleted. Finalized Match history must be preserved.', + ); + } + if (match.competitionId) { + throw new ConflictException( + 'A Match with a Competition cannot be hard-deleted. Preserve the immutable ledger and archive the Match instead.', + ); + } await this.tournamentCodeService.releaseFromMatch(match); await this.matchStatsService.removeByMatch(match._id); await match.deleteOne(); await this.communityStatsService.invalidateCommunity(params.communityId); } - public async reshuffleDoubleEliminationSeeds( - params: DoubleEliminationAdminParams, - ): Promise { - const match = await this.loadDoubleEliminationMatch(params); - await this.assertDoubleEliminationSeedsCanChange(match); - await this.releaseReservedDoubleEliminationCodes(match); - match.doubleElimination = reshuffleDoubleEliminationSeeds( - match.doubleElimination as NonNullable, - ); - match.doubleElimination.events.push({ - type: 'seeds-reshuffled', - actorUserId: params.actorUserId, - createdAt: new Date(), - }); - match.markModified('doubleElimination'); - await match.save(); - await this.tournamentCodeService.reserveForMatch(match); - return match; - } - - public async swapDoubleEliminationSeeds( - params: SwapDoubleEliminationSeedsParams, - ): Promise { - const match = await this.loadDoubleEliminationMatch(params); - await this.assertDoubleEliminationSeedsCanChange(match); - await this.releaseReservedDoubleEliminationCodes(match); - match.doubleElimination = swapDoubleEliminationSeeds( - match.doubleElimination as NonNullable, - { - leftSeedNumber: params.leftSeedNumber, - rightSeedNumber: params.rightSeedNumber, - }, - ); - match.doubleElimination.events.push({ - type: 'seeds-swapped', - actorUserId: params.actorUserId, - createdAt: new Date(), - }); - match.markModified('doubleElimination'); - await match.save(); - await this.tournamentCodeService.reserveForMatch(match); - return match; - } - public async join(params: JoinMatchParams): Promise { const MatchModel = await this.connectionService.getModel('match'); const UserModel = await this.connectionService.getModel('user'); const user = await UserModel.findById(params.userId); if (!user) throw new NotFoundException('User not found.'); + if (params.communityId && !user.communityId.equals(params.communityId)) { + throw new NotFoundException('Match not found.'); + } const selectedRiot = params.riotPuuid ? user.riotAccounts.find((a) => a.puuid === params.riotPuuid) @@ -362,7 +315,7 @@ export class MatchService { const updatedMatch = await MatchModel.findOneAndUpdate( { _id: params.matchId, - communityId: user.communityId, + communityId: params.communityId ?? user.communityId, status: 'recruiting', 'participants.userId': { $ne: user._id }, $expr: { $lt: [{ $size: '$participants' }, '$maxParticipants'] }, @@ -438,85 +391,6 @@ export class MatchService { return gameCount % 2 === 0 ? gameCount + 1 : gameCount; } - private async loadDoubleEliminationMatch(params: { - matchId: mongoose.Types.ObjectId; - communityId: mongoose.Types.ObjectId; - }): Promise { - const MatchModel = await this.connectionService.getModel('match'); - let match = await MatchModel.findById(params.matchId); - if (!match) throw new NotFoundException('Match not found.'); - if (!match.communityId.equals(params.communityId)) { - throw new BadRequestException('Match does not belong to this community.'); - } - if ((match.gameMode ?? 'pair') !== 'double-elimination') { - throw new BadRequestException('Match is not double elimination.'); - } - if (!match.doubleElimination?.bracketMatches?.length) { - match = await this.tournamentCodeService.reserveForMatch(match); - } - if (!match.doubleElimination?.bracketMatches?.length) { - throw new BadRequestException('Double elimination bracket is not ready.'); - } - return match; - } - - private async assertDoubleEliminationSeedsCanChange( - match: MatchDocument, - ): Promise { - if ( - match.doubleElimination?.bracketMatches.some( - (bracketMatch) => bracketMatch.state === 'completed', - ) - ) { - throw new BadRequestException( - 'Seeds cannot be changed after a bracket match is completed.', - ); - } - const TournamentCodeModel = - await this.connectionService.getModel('tournamentCode'); - const usedCode = await TournamentCodeModel.exists({ - _id: { $in: match.tournamentCodeIds ?? [] }, - $or: [{ state: 'used' }, { riotMatchId: { $exists: true } }], - }); - if (usedCode) { - throw new BadRequestException( - 'Seeds cannot be changed after a tournament code is used.', - ); - } - } - - private async releaseReservedDoubleEliminationCodes( - match: MatchDocument, - ): Promise { - const ids = match.tournamentCodeIds ?? []; - if (ids.length === 0) return; - const TournamentCodeModel = - await this.connectionService.getModel('tournamentCode'); - const codes = await TournamentCodeModel.find({ - _id: { $in: ids }, - matchId: match._id, - state: 'reserved', - bracketMatchId: { $exists: true }, - }).exec(); - if (codes.length === 0) return; - const releasedIds = codes.map((code) => code._id.toString()); - await TournamentCodeModel.updateMany( - { _id: { $in: codes.map((code) => code._id) } }, - { - $set: { state: 'released', releasedAt: new Date() }, - $unset: { - matchId: 1, - gameNumber: 1, - bracketMatchId: 1, - reservedAt: 1, - }, - }, - ).exec(); - match.tournamentCodeIds = ids.filter( - (id) => !releasedIds.includes(id.toString()), - ); - } - public async cancelJoin( params: CancelMatchJoinParams, ): Promise { diff --git a/apps/api/src/modules/tournament-code/tournament-code-replacement.controller.spec.ts b/apps/api/src/modules/tournament-code/tournament-code-replacement.controller.spec.ts deleted file mode 100644 index 8c39a85b..00000000 --- a/apps/api/src/modules/tournament-code/tournament-code-replacement.controller.spec.ts +++ /dev/null @@ -1,47 +0,0 @@ -import mongoose from 'mongoose'; -import { METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED } from '../auth/allow-public-access.decorator'; -import { TournamentCodeReplacementController } from './tournament-code-replacement.controller'; -import type { TournamentCodeService } from './tournament-code.service'; - -describe('TournamentCodeReplacementController', () => { - function createFixture() { - const service = { - replaceForMatchGame: jest.fn().mockResolvedValue({ - gameNumber: 1, - code: 'NEW-CODE', - }), - } as unknown as jest.Mocked< - Pick - >; - const controller = new TournamentCodeReplacementController( - service as unknown as TournamentCodeService, - ); - const communityId = new mongoose.Types.ObjectId(); - const matchId = new mongoose.Types.ObjectId(); - - return { controller, service, communityId, matchId }; - } - - it('allows public replacement requests', async () => { - const { controller, service, communityId, matchId } = createFixture(); - - await expect( - controller.replaceForMatchGame(communityId, matchId, 1), - ).resolves.toEqual(expect.objectContaining({ code: 'NEW-CODE' })); - - expect(service.replaceForMatchGame).toHaveBeenCalledWith({ - communityId, - matchId, - gameNumber: 1, - }); - }); - - it('marks the replacement endpoint as public access', () => { - expect( - Reflect.getMetadata( - METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED, - TournamentCodeReplacementController.prototype.replaceForMatchGame, - ), - ).toBe(true); - }); -}); diff --git a/apps/api/src/modules/tournament-code/tournament-code-replacement.controller.ts b/apps/api/src/modules/tournament-code/tournament-code-replacement.controller.ts deleted file mode 100644 index 61f0ead5..00000000 --- a/apps/api/src/modules/tournament-code/tournament-code-replacement.controller.ts +++ /dev/null @@ -1,30 +0,0 @@ -import { - Controller, - Param, - ParseIntPipe, - Post, -} from '@nestjs/common'; -import mongoose from 'mongoose'; -import { AllowPublicAccess } from '../auth/allow-public-access.decorator'; -import { ParseObjectIdPipe } from '../common/parse-object-id.pipe'; -import { TournamentCodeService } from './tournament-code.service'; - -@Controller('communities/:communityId/tournament-codes') -export class TournamentCodeReplacementController { - constructor(private readonly tournamentCodeService: TournamentCodeService) {} - - @Post('matches/:matchId/games/:gameNumber/replace') - @AllowPublicAccess() - public async replaceForMatchGame( - @Param('communityId', ParseObjectIdPipe) - communityId: mongoose.Types.ObjectId, - @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, - @Param('gameNumber', ParseIntPipe) gameNumber: number, - ) { - return this.tournamentCodeService.replaceForMatchGame({ - communityId, - matchId, - gameNumber, - }); - } -} diff --git a/apps/api/src/modules/tournament-code/tournament-code.module.ts b/apps/api/src/modules/tournament-code/tournament-code.module.ts index a908133d..1cad459a 100644 --- a/apps/api/src/modules/tournament-code/tournament-code.module.ts +++ b/apps/api/src/modules/tournament-code/tournament-code.module.ts @@ -3,14 +3,13 @@ import { AuctionRedisModule } from '../auction/redis/auction-redis.module'; import { TournamentResultModule } from '../tournament-result/tournament-result.module'; import { TournamentCodeController } from './tournament-code.controller'; import { TournamentCodeAutoProvisionService } from './tournament-code-auto-provision.service'; -import { TournamentCodeReplacementController } from './tournament-code-replacement.controller'; import { TournamentCodeScheduler } from './tournament-code.scheduler'; import { TournamentCodeService } from './tournament-code.service'; import { TournamentCodeVendorService } from './tournament-code-vendor.service'; @Module({ imports: [TournamentResultModule, AuctionRedisModule], - controllers: [TournamentCodeController, TournamentCodeReplacementController], + controllers: [TournamentCodeController], providers: [ TournamentCodeService, TournamentCodeVendorService, diff --git a/apps/api/src/modules/tournament-code/tournament-code.scheduler.spec.ts b/apps/api/src/modules/tournament-code/tournament-code.scheduler.spec.ts index c570fd1e..e12d11d4 100644 --- a/apps/api/src/modules/tournament-code/tournament-code.scheduler.spec.ts +++ b/apps/api/src/modules/tournament-code/tournament-code.scheduler.spec.ts @@ -1,16 +1,28 @@ +import mongoose from 'mongoose'; import { DistributedLockService } from '../global/redis/distributed-lock.service'; import { TournamentCodeScheduler } from './tournament-code.scheduler'; describe('TournamentCodeScheduler', () => { function createScheduler(params?: { attachedMatches?: unknown[]; + expirationResult?: { + affectedMatchIds: unknown[]; + expiredCount: number; + failedCount: number; + }; scheduleInitialPoll?: jest.Mock; }) { const tournamentCodeService = { attachPendingMatchDocuments: jest .fn() .mockResolvedValue(params?.attachedMatches ?? []), - markExpired: jest.fn().mockResolvedValue(0), + markExpired: jest.fn().mockResolvedValue( + params?.expirationResult ?? { + affectedMatchIds: [], + expiredCount: 0, + failedCount: 0, + }, + ), }; const autoProvisionService = { ensurePool: jest.fn().mockResolvedValue(undefined), @@ -20,21 +32,26 @@ describe('TournamentCodeScheduler', () => { params?.scheduleInitialPoll ?? jest.fn().mockResolvedValue(null), }; const distributedLockService = { - runWithRenewedLock: jest.fn().mockImplementation(async (options, operation) => - operation({ - lockKey: options.lockKey, - lockOwnershipToken: 'lock-owner', - lockExpirationDurationMilliseconds: - options.lockExpirationDurationMilliseconds, - }), - ), + runWithRenewedLock: jest + .fn() + .mockImplementation(async (options, operation) => + operation({ + lockKey: options.lockKey, + lockOwnershipToken: 'lock-owner', + lockExpirationDurationMilliseconds: + options.lockExpirationDurationMilliseconds, + }), + ), } as unknown as jest.Mocked; const scheduler = new TournamentCodeScheduler( tournamentCodeService as never, autoProvisionService as never, tournamentResultService as never, distributedLockService as never, - ) as unknown as { attachPending(): Promise }; + ) as unknown as { + attachPending(): Promise; + markExpired(): Promise; + }; return { scheduler, @@ -84,4 +101,21 @@ describe('TournamentCodeScheduler', () => { tournamentCodeService.attachPendingMatchDocuments, ).not.toHaveBeenCalled(); }); + + it('reconciles Competition assignments after expiring Match-bound codes', async () => { + const matchId = new mongoose.Types.ObjectId(); + const { scheduler, tournamentResultService } = createScheduler({ + expirationResult: { + affectedMatchIds: [matchId], + expiredCount: 1, + failedCount: 0, + }, + }); + + await scheduler.markExpired(); + + expect(tournamentResultService.scheduleInitialPoll).toHaveBeenCalledWith( + matchId, + ); + }); }); diff --git a/apps/api/src/modules/tournament-code/tournament-code.scheduler.ts b/apps/api/src/modules/tournament-code/tournament-code.scheduler.ts index 3429c19d..16740842 100644 --- a/apps/api/src/modules/tournament-code/tournament-code.scheduler.ts +++ b/apps/api/src/modules/tournament-code/tournament-code.scheduler.ts @@ -1,4 +1,9 @@ -import { Injectable, Logger, OnModuleDestroy, OnModuleInit } from '@nestjs/common'; +import { + Injectable, + Logger, + OnModuleDestroy, + OnModuleInit, +} from '@nestjs/common'; import { DistributedLockService } from '../global/redis/distributed-lock.service'; import { TournamentResultService } from '../tournament-result/tournament-result.service'; import { TournamentCodeAutoProvisionService } from './tournament-code-auto-provision.service'; @@ -31,13 +36,19 @@ export class TournamentCodeScheduler implements OnModuleInit, OnModuleDestroy { this.attachTimer = setInterval(() => { void this.attachPending(); }, 30_000); - this.expireTimer = setInterval(() => { - void this.markExpired(); - }, 60 * 60 * 1000); + this.expireTimer = setInterval( + () => { + void this.markExpired(); + }, + 60 * 60 * 1000, + ); if (isAutoProvisionEnabled()) { - this.refillTimer = setInterval(() => { - void this.ensureVendorPool(); - }, 5 * 60 * 1000); + this.refillTimer = setInterval( + () => { + void this.ensureVendorPool(); + }, + 5 * 60 * 1000, + ); } this.attachTimer.unref?.(); this.expireTimer.unref?.(); @@ -99,7 +110,18 @@ export class TournamentCodeScheduler implements OnModuleInit, OnModuleDestroy { SCHEDULER_LOCK_RENEWAL_INTERVAL_MILLISECONDS, }, async () => { - await this.tournamentCodeService.markExpired(); + const result = await this.tournamentCodeService.markExpired(); + for (const matchId of result.affectedMatchIds) { + try { + await this.tournamentResultService.scheduleInitialPoll(matchId); + } catch (error) { + this.logger.warn( + `Failed to reconcile Competition codes after expiring a code for Match ${matchId.toString()}: ${ + error instanceof Error ? error.message : error + }`, + ); + } + } }, ); } catch (error) { @@ -136,8 +158,7 @@ export class TournamentCodeScheduler implements OnModuleInit, OnModuleDestroy { } function isAutoProvisionEnabled(): boolean { - const raw = process.env.TOURNAMENT_CODE_AUTO_PROVISION_ENABLED - ?.trim() - .toLowerCase(); + const raw = + process.env.TOURNAMENT_CODE_AUTO_PROVISION_ENABLED?.trim().toLowerCase(); return raw !== 'false' && raw !== '0' && raw !== 'off'; } diff --git a/apps/api/src/modules/tournament-code/tournament-code.service.spec.ts b/apps/api/src/modules/tournament-code/tournament-code.service.spec.ts index c0ed7fd0..49eed573 100644 --- a/apps/api/src/modules/tournament-code/tournament-code.service.spec.ts +++ b/apps/api/src/modules/tournament-code/tournament-code.service.spec.ts @@ -2,6 +2,7 @@ import { TournamentCodeSchema, type MatchDocument, } from '../global/database/schema'; +import { Logger } from '@nestjs/common'; import mongoose from 'mongoose'; import { TournamentCodeService } from './tournament-code.service'; import { buildDoubleEliminationBracket } from '../double-elimination/double-elimination.util'; @@ -13,11 +14,6 @@ type TournamentCodeServiceInternals = TournamentCodeService & { gameNumber: number, ): { teamAIndex: number; teamBIndex: number }; ensureGameSchedule(match: MatchDocument): void; - replaceForMatchGame(params: { - communityId: mongoose.Types.ObjectId; - matchId: mongoose.Types.ObjectId; - gameNumber: number; - }): Promise; attachPendingMatches(communityId?: mongoose.Types.ObjectId): Promise; }; @@ -37,6 +33,21 @@ function createSession() { }; } +function mongoQuery(value: T) { + const query = { + exec: jest.fn().mockResolvedValue(value), + lean: jest.fn(), + limit: jest.fn(), + select: jest.fn(), + session: jest.fn(), + }; + query.lean.mockReturnValue(query); + query.limit.mockReturnValue(query); + query.select.mockReturnValue(query); + query.session.mockReturnValue(query); + return query; +} + function createService() { return new TournamentCodeService( {} as never, @@ -51,6 +62,7 @@ interface MatchOverrides { participants?: Array<{ excluded?: boolean }>; teams?: Array<{ teamIndex: number }>; doubleElimination?: MatchDocument['doubleElimination']; + tournamentCodeIds?: mongoose.Types.ObjectId[]; gameSchedule?: Array<{ gameNumber: number; roundNumber?: number; @@ -261,6 +273,43 @@ describe('TournamentCodeService round-robin scheduling', () => { ).toMatchObject({ gameCount: 3, requiredWins: 2 }); }); + it('builds a missing bracket from already-persisted authoritative seeds', () => { + const service = createService(); + const match = createMatch({ + gameMode: 'double-elimination', + gameCount: 3, + teams: Array.from({ length: 4 }, (_, index) => ({ + teamIndex: index + 1, + })), + doubleElimination: { + teamCount: 4, + resetFinalEnabled: true, + resetFinalCreated: false, + seeds: [ + { seedNumber: 1, teamIndex: 3 }, + { seedNumber: 2, teamIndex: 1 }, + { seedNumber: 3, teamIndex: 4 }, + { seedNumber: 4, teamIndex: 2 }, + ], + bracketMatches: [], + placements: {}, + events: [], + }, + }); + const random = jest.spyOn(Math, 'random').mockReturnValue(0); + + service.ensureGameSchedule(match); + + expect(match.doubleElimination?.seeds).toEqual([ + { seedNumber: 1, teamIndex: 3 }, + { seedNumber: 2, teamIndex: 1 }, + { seedNumber: 3, teamIndex: 4 }, + { seedNumber: 4, teamIndex: 2 }, + ]); + expect(random).not.toHaveBeenCalled(); + random.mockRestore(); + }); + it('expands double-elimination winner bracket series into code slots', async () => { const TournamentCodeModel = { find: jest.fn().mockReturnValue({ @@ -437,6 +486,50 @@ describe('TournamentCodeService round-robin scheduling', () => { expect(slots).toEqual([]); }); + + it('shows the active replacement when a reversed terminal code shares its game number', async () => { + const oldCodeId = new mongoose.Types.ObjectId(); + const replacementCodeId = new mongoose.Types.ObjectId(); + const TournamentCodeModel = { + find: jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue([ + { + _id: replacementCodeId, + code: 'NEW-CODE', + gameNumber: 1, + state: 'reserved', + expiresAt: new Date('2026-07-13T00:00:00.000Z'), + }, + { + _id: oldCodeId, + code: 'OLD-CODE', + gameNumber: 1, + state: 'released', + expiresAt: new Date('2026-07-13T00:00:00.000Z'), + }, + ]), + }), + }; + const service = new TournamentCodeService( + { getModel: jest.fn().mockResolvedValue(TournamentCodeModel) } as never, + createAuctionRedisService() as never, + ) as unknown as TournamentCodeServiceInternals; + const match = createMatch({ + gameCount: 1, + teams: [{ teamIndex: 1 }, { teamIndex: 2 }], + tournamentCodeIds: [oldCodeId, replacementCodeId], + }); + + const slots = await service.buildSlots(match); + + expect(slots[0]).toEqual( + expect.objectContaining({ + gameNumber: 1, + code: 'NEW-CODE', + state: 'reserved', + }), + ); + }); }); describe('TournamentCodeService bulk upload', () => { @@ -639,228 +732,278 @@ describe('TournamentCodeService pending match attachment', () => { }); }); -describe('TournamentCodeService code replacement', () => { - function queryResult(value: T) { - return { exec: jest.fn().mockResolvedValue(value) }; - } - - function createCode(overrides: Record) { - return { +describe('TournamentCodeService Competition assignment safety', () => { + it('does not restore an actively reserved code outside Competition commands', async () => { + const code = { _id: new mongoose.Types.ObjectId(), - code: 'CODE', state: 'reserved', - expiresAt: new Date(Date.now() + 60 * 60 * 1000), - matchId: new mongoose.Types.ObjectId(), - gameNumber: 1, - reservedAt: new Date(), - releasedAt: undefined, - riotMatchId: undefined, - save: jest.fn().mockResolvedValue(undefined), - ...overrides, + save: jest.fn(), }; - } - - function createReplacementFixture(params?: { - currentCode?: Record | null; - replacementCode?: Record | null; - match?: MatchDocument; - }) { - const communityId = new mongoose.Types.ObjectId(); - const matchId = new mongoose.Types.ObjectId(); - const oldCodeId = new mongoose.Types.ObjectId(); - const newCodeId = new mongoose.Types.ObjectId(); - const match = - params?.match ?? - createMatch({ - _id: matchId, - communityId, - status: 'in-progress', - gameCount: 1, - participants: Array.from({ length: 10 }, () => ({})), - teams: [{ teamIndex: 1 }, { teamIndex: 2 }], - tournamentCodeIds: [oldCodeId], - } as unknown as MatchOverrides); - const currentCode = - params?.currentCode === null - ? null - : createCode({ - _id: oldCodeId, - code: 'OLD-CODE', - matchId, - gameNumber: 1, - ...(params?.currentCode ?? {}), - }); - const replacementCode = - params?.replacementCode === null - ? null - : createCode({ - _id: newCodeId, - code: 'NEW-CODE', - matchId, - gameNumber: 1, - ...(params?.replacementCode ?? {}), - }); - - const MatchModel = { - findOne: jest.fn().mockReturnValue(queryResult(match)), - }; - const TournamentCodeModel = { - findOne: jest.fn().mockReturnValue(queryResult(currentCode)), - findOneAndUpdate: jest.fn().mockReturnValue(queryResult(replacementCode)), - updateOne: jest.fn().mockReturnValue(queryResult({ modifiedCount: 1 })), - }; - const session = createSession(); const connectionService = { - createSession: jest.fn().mockResolvedValue(session), - getModel: jest.fn().mockImplementation((modelName: string) => { - if (modelName === 'match') return Promise.resolve(MatchModel); - if (modelName === 'tournamentCode') { - return Promise.resolve(TournamentCodeModel); + getModel: jest.fn().mockImplementation((name: string) => { + if (name === 'tournamentCode') { + return Promise.resolve({ + findById: jest.fn().mockResolvedValue(code), + }); } - throw new Error(`Unexpected model: ${modelName}`); + if (name === 'match') return Promise.resolve({}); + throw new Error(`Unexpected model ${name}`); }), }; - const auctionRedisService = createAuctionRedisService(); const service = new TournamentCodeService( connectionService as never, - auctionRedisService as never, - ) as unknown as TournamentCodeServiceInternals; + createAuctionRedisService() as never, + ); - return { - match, - communityId, - matchId, - currentCode, - replacementCode, - MatchModel, - TournamentCodeModel, - auctionRedisService, - session, - service, - }; - } - - it('replaces a reserved code on the same game slot', async () => { - const { - match, - communityId, - matchId, - currentCode, - replacementCode, - MatchModel, - TournamentCodeModel, - auctionRedisService, - session, - service, - } = createReplacementFixture(); - - const slot = await service.replaceForMatchGame({ - communityId, - matchId, - gameNumber: 1, - }); - - expect(slot).toEqual( - expect.objectContaining({ - gameNumber: 1, - teamAIndex: 1, - teamBIndex: 2, - code: 'NEW-CODE', - state: 'reserved', - }), + await expect(service.restoreToAvailable(code._id)).rejects.toThrow( + 'Active Competition assignments', ); - expect(MatchModel.findOne).toHaveBeenCalledWith({ - _id: matchId, - communityId, - }); - expect(TournamentCodeModel.findOneAndUpdate).toHaveBeenCalledWith( - expect.objectContaining({ - state: 'available', - region: 'kr', - mapType: 'SUMMONERS_RIFT', - teamSize: 5, - }), - expect.objectContaining({ - $set: expect.objectContaining({ - state: 'reserved', - matchId, - gameNumber: 1, - }), - }), - expect.objectContaining({ returnDocument: 'after' }), - ); - expect(auctionRedisService.acquireTokenLock).toHaveBeenCalledWith( - `tournament-code:match:${matchId.toString()}:lock`, - expect.any(String), - expect.any(Number), - ); - expect(session.startTransaction).toHaveBeenCalledTimes(1); - expect(session.commitTransaction).toHaveBeenCalledTimes(1); - expect(auctionRedisService.releaseTokenLock).toHaveBeenCalledWith( - `tournament-code:match:${matchId.toString()}:lock`, - expect.any(String), - ); - expect(TournamentCodeModel.updateOne).toHaveBeenCalledWith( - { _id: currentCode?._id }, - expect.objectContaining({ - $set: expect.objectContaining({ state: 'released' }), - $unset: expect.objectContaining({ - matchId: 1, - gameNumber: 1, - bracketMatchId: 1, - reservedAt: 1, - }), - }), - ); - expect(currentCode?.save).not.toHaveBeenCalled(); - expect(match.tournamentCodeIds.map((id) => id.toString())).toEqual([ - replacementCode?._id.toString(), - ]); - expect(match.save).toHaveBeenCalled(); + expect(code.save).not.toHaveBeenCalled(); }); - it('rejects replacement after the game result is collected', async () => { + it('expires a reserved code and releases its assignment and Match binding atomically', async () => { + const codeId = new mongoose.Types.ObjectId(); const matchId = new mongoose.Types.ObjectId(); - const communityId = new mongoose.Types.ObjectId(); - const fixture = createReplacementFixture({ - match: createMatch({ - _id: matchId, - communityId, - status: 'in-progress', - gameCount: 1, - participants: Array.from({ length: 10 }, () => ({})), - teams: [{ teamIndex: 1 }, { teamIndex: 2 }], - tournamentCodeIds: [new mongoose.Types.ObjectId()], - result: { - riotMatchIds: ['KR_1'], - games: [{ gameNumber: 1 }], - seriesResults: [], - }, - } as unknown as MatchOverrides), + const competitionId = new mongoose.Types.ObjectId(); + const assignmentId = new mongoose.Types.ObjectId(); + const session = createSession(); + const code = { _id: codeId, state: 'reserved', matchId }; + const codeUpdate = jest.fn().mockReturnValue(mongoQuery(code)); + const assignmentUpdate = jest + .fn() + .mockReturnValue(mongoQuery({ matchedCount: 1, modifiedCount: 1 })); + const matchUpdate = jest + .fn() + .mockReturnValue(mongoQuery({ matchedCount: 1, modifiedCount: 1 })); + const models = { + tournamentCode: { + find: jest.fn().mockReturnValue(mongoQuery([{ _id: codeId }])), + findOne: jest.fn().mockReturnValue(mongoQuery(code)), + findOneAndUpdate: codeUpdate, + }, + tournamentCodeAssignment: { + find: jest.fn().mockReturnValue( + mongoQuery([ + { + _id: assignmentId, + competitionId, + state: 'reserved', + }, + ]), + ), + updateOne: assignmentUpdate, + }, + competition: { + findById: jest.fn().mockReturnValue(mongoQuery({ matchId })), + }, + match: { updateOne: matchUpdate }, + }; + const service = new TournamentCodeService( + { + createSession: jest.fn().mockResolvedValue(session), + getModel: jest.fn((name: keyof typeof models) => + Promise.resolve(models[name]), + ), + } as never, + createAuctionRedisService() as never, + ); + + await expect(service.markExpired()).resolves.toEqual({ + affectedMatchIds: [matchId], + expiredCount: 1, + failedCount: 0, }); - await expect( - fixture.service.replaceForMatchGame({ - communityId, - matchId, - gameNumber: 1, - }), - ).rejects.toThrow('already has a collected result'); - expect(fixture.TournamentCodeModel.findOne).not.toHaveBeenCalled(); - expect(fixture.TournamentCodeModel.findOneAndUpdate).not.toHaveBeenCalled(); + expect(codeUpdate).toHaveBeenCalledWith( + { + _id: codeId, + expiresAt: { $lte: expect.any(Date) as Date }, + state: 'reserved', + }, + { + $set: { state: 'expired' }, + $unset: { + bracketMatchId: 1, + gameNumber: 1, + matchId: 1, + reservedAt: 1, + }, + }, + { returnDocument: 'before', session }, + ); + expect(assignmentUpdate).toHaveBeenCalledWith( + { _id: assignmentId, state: 'reserved' }, + { + $set: { releasedAt: expect.any(Date) as Date, state: 'released' }, + }, + { session }, + ); + expect(matchUpdate).toHaveBeenCalledWith( + { _id: matchId }, + { $pull: { tournamentCodeIds: codeId } }, + { session }, + ); + expect(session.commitTransaction).toHaveBeenCalledTimes(1); }); - it('aborts the transaction when no replacement code is available', async () => { - const { match, communityId, matchId, currentCode, session, service } = - createReplacementFixture({ - replacementCode: null, - }); + it('isolates a used-assignment corruption and still expires the next valid candidate', async () => { + const corruptCodeId = new mongoose.Types.ObjectId(); + const validCodeId = new mongoose.Types.ObjectId(); + const corruptMatchId = new mongoose.Types.ObjectId(); + const validMatchId = new mongoose.Types.ObjectId(); + const competitionId = new mongoose.Types.ObjectId(); + const validAssignmentId = new mongoose.Types.ObjectId(); + const sessions = [createSession(), createSession()]; + const codeById = new Map([ + [ + corruptCodeId.toString(), + { _id: corruptCodeId, state: 'reserved', matchId: corruptMatchId }, + ], + [ + validCodeId.toString(), + { _id: validCodeId, state: 'reserved', matchId: validMatchId }, + ], + ]); + const codeUpdate = jest.fn((filter: { _id: mongoose.Types.ObjectId }) => + mongoQuery(codeById.get(filter._id.toString())), + ); + const assignmentUpdate = jest + .fn() + .mockReturnValue(mongoQuery({ matchedCount: 1, modifiedCount: 1 })); + const matchUpdate = jest + .fn() + .mockReturnValue(mongoQuery({ matchedCount: 1, modifiedCount: 1 })); + const models = { + tournamentCode: { + find: jest + .fn() + .mockReturnValue( + mongoQuery([{ _id: corruptCodeId }, { _id: validCodeId }]), + ), + findOne: jest.fn((filter: { _id: mongoose.Types.ObjectId }) => + mongoQuery(codeById.get(filter._id.toString())), + ), + findOneAndUpdate: codeUpdate, + }, + tournamentCodeAssignment: { + find: jest.fn((filter: { tournamentCodeId: mongoose.Types.ObjectId }) => + mongoQuery( + filter.tournamentCodeId.equals(corruptCodeId) + ? [ + { + _id: new mongoose.Types.ObjectId(), + competitionId, + state: 'used', + }, + ] + : [ + { + _id: validAssignmentId, + competitionId, + state: 'reserved', + }, + ], + ), + ), + updateOne: assignmentUpdate, + }, + competition: { + findById: jest + .fn() + .mockReturnValue(mongoQuery({ matchId: validMatchId })), + }, + match: { updateOne: matchUpdate }, + }; + const errorLog = jest + .spyOn(Logger.prototype, 'error') + .mockImplementation(() => undefined); + const service = new TournamentCodeService( + { + createSession: jest + .fn() + .mockImplementation(() => Promise.resolve(sessions.shift())), + getModel: jest.fn((name: keyof typeof models) => + Promise.resolve(models[name]), + ), + } as never, + createAuctionRedisService() as never, + ); - await expect( - service.replaceForMatchGame({ communityId, matchId, gameNumber: 1 }), - ).rejects.toThrow('No available tournament code'); - expect(currentCode?.save).not.toHaveBeenCalled(); - expect(match.save).not.toHaveBeenCalled(); + await expect(service.markExpired()).resolves.toEqual({ + affectedMatchIds: [validMatchId], + expiredCount: 1, + failedCount: 1, + }); + + expect(codeUpdate).toHaveBeenCalledTimes(1); + expect(codeUpdate.mock.calls[0][0]).toMatchObject({ _id: validCodeId }); + expect(assignmentUpdate).toHaveBeenCalledWith( + { _id: validAssignmentId, state: 'reserved' }, + expect.any(Object), + expect.any(Object), + ); + expect(errorLog).toHaveBeenCalledWith( + expect.stringContaining('used Competition assignment'), + ); + errorLog.mockRestore(); + }); + + it('leaves a foreign Competition assignment unchanged and reports the candidate failure', async () => { + const codeId = new mongoose.Types.ObjectId(); + const matchId = new mongoose.Types.ObjectId(); + const foreignMatchId = new mongoose.Types.ObjectId(); + const competitionId = new mongoose.Types.ObjectId(); + const code = { _id: codeId, state: 'reserved', matchId }; + const codeUpdate = jest.fn(); + const session = createSession(); + const models = { + tournamentCode: { + find: jest.fn().mockReturnValue(mongoQuery([{ _id: codeId }])), + findOne: jest.fn().mockReturnValue(mongoQuery(code)), + findOneAndUpdate: codeUpdate, + }, + tournamentCodeAssignment: { + find: jest.fn().mockReturnValue( + mongoQuery([ + { + _id: new mongoose.Types.ObjectId(), + competitionId, + state: 'reserved', + }, + ]), + ), + updateOne: jest.fn(), + }, + competition: { + findById: jest + .fn() + .mockReturnValue(mongoQuery({ matchId: foreignMatchId })), + }, + match: { updateOne: jest.fn() }, + }; + const errorLog = jest + .spyOn(Logger.prototype, 'error') + .mockImplementation(() => undefined); + const service = new TournamentCodeService( + { + createSession: jest.fn().mockResolvedValue(session), + getModel: jest.fn((name: keyof typeof models) => + Promise.resolve(models[name]), + ), + } as never, + createAuctionRedisService() as never, + ); + + await expect(service.markExpired()).resolves.toEqual({ + affectedMatchIds: [], + expiredCount: 0, + failedCount: 1, + }); + expect(codeUpdate).not.toHaveBeenCalled(); expect(session.abortTransaction).toHaveBeenCalledTimes(1); + expect(errorLog).toHaveBeenCalledWith( + expect.stringContaining('ownership does not match'), + ); + errorLog.mockRestore(); }); }); diff --git a/apps/api/src/modules/tournament-code/tournament-code.service.ts b/apps/api/src/modules/tournament-code/tournament-code.service.ts index 06611779..45c677b8 100644 --- a/apps/api/src/modules/tournament-code/tournament-code.service.ts +++ b/apps/api/src/modules/tournament-code/tournament-code.service.ts @@ -3,6 +3,7 @@ import { ConflictException, Injectable, InternalServerErrorException, + Logger, NotFoundException, } from '@nestjs/common'; import { randomUUID } from 'crypto'; @@ -43,8 +44,16 @@ const DEFAULT_SPECTATOR_TYPE: TournamentSpectatorType = 'ALL'; const TOURNAMENT_CODE_MATCH_LOCK_TTL_MS = 30_000; const TOURNAMENT_CODE_TRANSACTION_ATTEMPTS = 3; +export interface TournamentCodeExpirationResult { + expiredCount: number; + failedCount: number; + affectedMatchIds: mongoose.Types.ObjectId[]; +} + @Injectable() export class TournamentCodeService { + private readonly logger = new Logger(TournamentCodeService.name); + constructor( private readonly connectionService: ConnectionService, private readonly auctionRedisService: AuctionRedisService, @@ -216,9 +225,9 @@ export class TournamentCodeService { const MatchModel = await this.connectionService.getModel('match'); const code = await TournamentCodeModel.findById(id); if (!code) throw new NotFoundException('Tournament code not found.'); - if (code.state !== 'released' && code.state !== 'reserved') { + if (code.state !== 'released') { throw new BadRequestException( - 'Only released or reserved tournament codes can be restored.', + 'Only released tournament codes can be restored. Active Competition assignments must be reversed through Competition commands.', ); } const previousMatchId = code.matchId; @@ -318,174 +327,6 @@ export class TournamentCodeService { return match; } - public async replaceForMatchGame(params: { - communityId: mongoose.Types.ObjectId; - matchId: mongoose.Types.ObjectId; - gameNumber: number; - }): Promise { - return this.withLockedMatchTransaction(params.matchId, (session) => - this.replaceForMatchGameInTransaction(params, session), - ); - } - - private async replaceForMatchGameInTransaction( - params: { - communityId: mongoose.Types.ObjectId; - matchId: mongoose.Types.ObjectId; - gameNumber: number; - }, - session: mongoose.ClientSession, - ): Promise { - const MatchModel = await this.connectionService.getModel('match'); - const TournamentCodeModel = - await this.connectionService.getModel('tournamentCode'); - const match = await this.execQuery( - this.withQuerySession( - MatchModel.findOne({ - _id: params.matchId, - communityId: params.communityId, - }), - session, - ), - ); - if (!match) throw new NotFoundException('Match not found.'); - if (match.status !== 'team-built' && match.status !== 'in-progress') { - throw new BadRequestException( - 'Tournament codes can only be replaced while the match is ready or in progress.', - ); - } - - match.gameCount = match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT; - match.tournamentCodeIds = match.tournamentCodeIds ?? []; - this.ensureGameSchedule(match); - const doubleEliminationSlot = - (match.gameMode ?? 'pair') === 'double-elimination' - ? this.resolveDoubleEliminationGameSlotByGameNumber( - match, - params.gameNumber, - ) - : undefined; - - const requiredSlots = this.resolveRequiredSlots(match); - if ( - !Number.isInteger(params.gameNumber) || - params.gameNumber < 1 || - params.gameNumber > requiredSlots - ) { - throw new BadRequestException('Invalid tournament code game number.'); - } - if ( - (match.result?.games ?? []).some( - (game) => game.gameNumber === params.gameNumber, - ) - ) { - throw new BadRequestException( - 'This game already has a collected result and cannot be replaced.', - ); - } - - const currentCode = await this.execQuery( - this.withQuerySession( - TournamentCodeModel.findOne({ - _id: { $in: match.tournamentCodeIds }, - matchId: match._id, - ...(doubleEliminationSlot - ? { - gameNumber: params.gameNumber, - bracketMatchId: - doubleEliminationSlot.bracketMatch.bracketMatchId, - } - : { gameNumber: params.gameNumber }), - }), - session, - ), - ); - if (!currentCode) { - throw new NotFoundException('Assigned tournament code not found.'); - } - if (currentCode.state === 'used' || currentCode.riotMatchId) { - throw new BadRequestException( - 'Used tournament codes cannot be replaced.', - ); - } - - const expiresAfter = new Date( - Date.now() + TOURNAMENT_CODE_EXPIRY_MARGIN_MS, - ); - await this.execQuery( - this.withQuerySession( - TournamentCodeModel.updateOne( - { _id: currentCode._id }, - { - $set: { state: 'released', releasedAt: new Date() }, - $unset: { - matchId: 1, - gameNumber: 1, - bracketMatchId: 1, - reservedAt: 1, - riotMatchId: 1, - }, - }, - ), - session, - ), - ); - - const replacement = await TournamentCodeModel.findOneAndUpdate( - { - state: 'available', - region: DEFAULT_REGION, - mapType: 'SUMMONERS_RIFT', - teamSize: 5, - expiresAt: { $gt: expiresAfter }, - }, - { - $set: { - state: 'reserved', - matchId: match._id, - gameNumber: params.gameNumber, - ...(doubleEliminationSlot - ? { - bracketMatchId: - doubleEliminationSlot.bracketMatch.bracketMatchId, - } - : {}), - reservedAt: new Date(), - }, - $unset: { releasedAt: 1 }, - }, - { sort: { expiresAt: 1 }, returnDocument: 'after', session }, - ).exec(); - if (!replacement) { - throw new BadRequestException( - 'No available tournament code to replace with.', - ); - } - - match.tournamentCodeIds = this.replaceTournamentCodeId( - match.tournamentCodeIds, - currentCode._id, - replacement._id, - ); - await match.save({ session }); - - return { - gameNumber: params.gameNumber, - ...(doubleEliminationSlot - ? this.toDoubleEliminationSlotBase(doubleEliminationSlot) - : {}), - roundNumber: this.resolveRoundNumberForGameNumber( - match, - params.gameNumber, - ), - ...this.resolveSeriesRefForGameNumber(match, params.gameNumber), - code: replacement.code, - expiresAt: replacement.expiresAt.toISOString(), - state: replacement.state, - riotMatchId: replacement.riotMatchId ?? null, - }; - } - public async releaseFromMatch( matchOrId: MatchDocument | mongoose.Types.ObjectId, ): Promise { @@ -530,17 +371,153 @@ export class TournamentCodeService { await match.save({ session }); } - public async markExpired(): Promise { - const TournamentCodeModel = - await this.connectionService.getModel('tournamentCode'); - const result = await TournamentCodeModel.updateMany( - { - state: { $in: ['available', 'reserved', 'released'] }, - expiresAt: { $lte: new Date() }, - }, - { $set: { state: 'expired' } }, - ).exec(); - return result.modifiedCount; + public async markExpired(): Promise { + const [TournamentCodeModel, AssignmentModel, CompetitionModel, MatchModel] = + await Promise.all([ + this.connectionService.getModel('tournamentCode'), + this.connectionService.getModel('tournamentCodeAssignment'), + this.connectionService.getModel('competition'), + this.connectionService.getModel('match'), + ]); + const expiredAt = new Date(); + const candidates = await TournamentCodeModel.find({ + state: { $in: ['available', 'reserved', 'released'] }, + expiresAt: { $lte: expiredAt }, + }) + .select({ _id: 1 }) + .lean() + .exec(); + const affectedMatchIds = new Map(); + let expiredCount = 0; + let failedCount = 0; + + for (const candidate of candidates) { + try { + const expired = await this.runTransactionWithRetry(async (session) => { + const code = await TournamentCodeModel.findOne( + { + _id: candidate._id, + expiresAt: { $lte: expiredAt }, + state: { $in: ['available', 'reserved', 'released'] }, + }, + null, + { session }, + ) + .lean() + .exec(); + if (!code) return null; + + const activeAssignments = await AssignmentModel.find({ + tournamentCodeId: code._id, + state: { $in: ['reserved', 'used'] }, + }) + .session(session) + .limit(2) + .lean() + .exec(); + if (activeAssignments.length > 1) { + throw new Error( + `Tournament Code ${code._id.toString()} has multiple active Competition assignments.`, + ); + } + const assignment = activeAssignments[0]; + if (assignment?.state === 'used') { + throw new Error( + `Tournament Code ${code._id.toString()} has a used Competition assignment and cannot expire as reserved.`, + ); + } + if (assignment) { + if (!code.matchId) { + throw new Error( + `Tournament Code ${code._id.toString()} has an active Competition assignment without a Match binding.`, + ); + } + const competition = await CompetitionModel.findById( + assignment.competitionId, + ) + .session(session) + .select({ matchId: 1 }) + .lean() + .exec(); + if ( + !competition || + competition.matchId.toString() !== code.matchId.toString() + ) { + throw new Error( + `Tournament Code ${code._id.toString()} Competition ownership does not match its Match binding.`, + ); + } + } + + const expiredCode = await TournamentCodeModel.findOneAndUpdate( + { + _id: code._id, + expiresAt: { $lte: expiredAt }, + state: code.state, + }, + { + $set: { state: 'expired' }, + $unset: { + bracketMatchId: 1, + gameNumber: 1, + matchId: 1, + reservedAt: 1, + }, + }, + { returnDocument: 'before', session }, + ).exec(); + if (!expiredCode) return null; + + if (assignment) { + const assignmentResult = await AssignmentModel.updateOne( + { _id: assignment._id, state: 'reserved' }, + { $set: { releasedAt: expiredAt, state: 'released' } }, + { session }, + ).exec(); + if (assignmentResult.modifiedCount !== 1) { + throw new Error( + `Tournament Code ${code._id.toString()} assignment did not transition to released.`, + ); + } + } + if (code.matchId) { + const matchResult = await MatchModel.updateOne( + { _id: code.matchId }, + { $pull: { tournamentCodeIds: code._id } }, + { session }, + ).exec(); + if ( + assignment && + (matchResult.matchedCount !== 1 || + matchResult.modifiedCount !== 1) + ) { + throw new Error( + `Tournament Code ${code._id.toString()} Match binding did not transition atomically.`, + ); + } + } + return code; + }); + if (!expired) continue; + expiredCount += 1; + if (expired.matchId) { + affectedMatchIds.set(expired.matchId.toString(), expired.matchId); + } + } catch (error) { + failedCount += 1; + this.logger.error( + `Failed to expire Tournament Code ${candidate._id.toString()}; candidate was left unchanged: ${ + error instanceof Error ? error.message : String(error) + }`, + ); + } + } + + return { + expiredCount, + failedCount, + affectedMatchIds: [...affectedMatchIds.values()], + }; } public async attachPendingMatches( @@ -610,7 +587,11 @@ export class TournamentCodeService { : []; const byGameNumber = new Map( codes - .filter((code) => typeof code.gameNumber === 'number') + .filter( + (code) => + typeof code.gameNumber === 'number' && + (code.state === 'reserved' || code.state === 'used'), + ) .map((code) => [code.gameNumber as number, code]), ); @@ -645,21 +626,6 @@ export class TournamentCodeService { return (code ?? '').trim(); } - private replaceTournamentCodeId( - currentIds: mongoose.Types.ObjectId[], - oldId: mongoose.Types.ObjectId, - newId: mongoose.Types.ObjectId, - ): mongoose.Types.ObjectId[] { - let replaced = false; - const next = currentIds.map((id) => { - if (id.toString() !== oldId.toString()) return id; - replaced = true; - return newId; - }); - if (!replaced) next.push(newId); - return next; - } - private resolveMatchId( matchOrId: MatchDocument | mongoose.Types.ObjectId, ): mongoose.Types.ObjectId { @@ -991,7 +957,12 @@ export class TournamentCodeService { .map((team) => team.teamIndex) .sort((left, right) => left - right); if (teamIndexes.length !== 4 && teamIndexes.length !== 8) return; - const shuffledTeamIndexes = this.shuffleTeamIndexes(teamIndexes); + const seededTeamIndexes = this.configuredDoubleEliminationSeedOrder( + match, + teamIndexes, + ); + const shuffledTeamIndexes = + seededTeamIndexes ?? this.shuffleTeamIndexes(teamIndexes); match.doubleElimination = buildDoubleEliminationBracket( shuffledTeamIndexes, { @@ -1003,6 +974,34 @@ export class TournamentCodeService { match.markModified?.('doubleElimination'); } + private configuredDoubleEliminationSeedOrder( + match: MatchDocument, + teamIndexes: number[], + ): number[] | undefined { + const seeds = match.doubleElimination?.seeds ?? []; + if (seeds.length !== teamIndexes.length) return undefined; + const validTeamIndexes = new Set(teamIndexes); + const seedNumbers = new Set(); + const seededTeamIndexes = new Set(); + for (const seed of seeds) { + if ( + !Number.isInteger(seed.seedNumber) || + seed.seedNumber < 1 || + seed.seedNumber > teamIndexes.length || + seedNumbers.has(seed.seedNumber) || + !validTeamIndexes.has(seed.teamIndex) || + seededTeamIndexes.has(seed.teamIndex) + ) { + return undefined; + } + seedNumbers.add(seed.seedNumber); + seededTeamIndexes.add(seed.teamIndex); + } + return [...seeds] + .sort((left, right) => left.seedNumber - right.seedNumber) + .map(({ teamIndex }) => teamIndex); + } + private resolveDoubleEliminationGameSlotByGameNumber( match: MatchDocument, gameNumber: number, diff --git a/apps/api/src/modules/tournament-result/competition-outbox.processor.spec.ts b/apps/api/src/modules/tournament-result/competition-outbox.processor.spec.ts index b0e1b8b8..c4c4d816 100644 --- a/apps/api/src/modules/tournament-result/competition-outbox.processor.spec.ts +++ b/apps/api/src/modules/tournament-result/competition-outbox.processor.spec.ts @@ -1,5 +1,6 @@ /* eslint-disable @typescript-eslint/no-unsafe-assignment */ import mongoose from 'mongoose'; +import { Logger } from '@nestjs/common'; import { CommunityStatsService } from '../community-stats/community-stats.service'; import { MatchStatsService } from '../community-stats/match-stats.service'; import { ConnectionService } from '../global/database/connection.service'; @@ -7,6 +8,10 @@ import { CompetitionAssignmentProvisioner } from './competition-assignment.provi import { CompetitionOutboxProcessor } from './competition-outbox.processor'; describe('CompetitionOutboxProcessor', () => { + afterEach(() => { + jest.restoreAllMocks(); + }); + it('leases a projection event and applies idempotent downstream effects', async () => { const competitionId = new mongoose.Types.ObjectId(); const matchId = new mongoose.Types.ObjectId(); @@ -158,6 +163,59 @@ describe('CompetitionOutboxProcessor', () => { }, ); }); + + it('dead-letters a poison event after the delivery attempt limit', async () => { + const event = { + _id: new mongoose.Types.ObjectId(), + competitionId: new mongoose.Types.ObjectId(), + revision: 2, + type: 'competition.projection-updated', + state: 'pending', + attemptCount: 10, + }; + const updateOne = jest.fn(() => executable({ matchedCount: 1 })); + const models = { + competitionOutbox: { + findOneAndUpdate: jest + .fn() + .mockReturnValueOnce(leanExecutable(event)) + .mockReturnValueOnce(leanExecutable(null)), + updateOne, + }, + competition: { + findById: jest.fn(() => leanExecutable(null)), + }, + match: {}, + }; + const errorLog = jest + .spyOn(Logger.prototype, 'error') + .mockImplementation(() => undefined); + const processor = new CompetitionOutboxProcessor( + { + getModel: jest.fn((name: keyof typeof models) => + Promise.resolve(models[name]), + ), + } as unknown as ConnectionService, + { provisionReadyAssignments: jest.fn() } as never, + { buildAndUpsert: jest.fn() } as never, + { invalidateCommunity: jest.fn() } as never, + ); + + await expect(processor.drainOnce()).resolves.toBe(1); + + expect(updateOne).toHaveBeenCalledWith( + { _id: event._id, state: 'pending', attemptCount: 10 }, + { + $set: { + state: 'dead-letter', + lastError: 'Competition no longer exists.', + }, + }, + ); + expect(errorLog).toHaveBeenCalledWith( + expect.stringContaining('moved to dead-letter after 10 attempts'), + ); + }); }); function leanExecutable(value: T) { diff --git a/apps/api/src/modules/tournament-result/competition-outbox.processor.ts b/apps/api/src/modules/tournament-result/competition-outbox.processor.ts index dbd71012..768597ac 100644 --- a/apps/api/src/modules/tournament-result/competition-outbox.processor.ts +++ b/apps/api/src/modules/tournament-result/competition-outbox.processor.ts @@ -15,6 +15,7 @@ const DRAIN_INTERVAL_MS = 5_000; const PROCESSING_LEASE_MS = 60_000; const MAX_EVENTS_PER_DRAIN = 20; const MAX_RETRY_DELAY_MS = 5 * 60_000; +const MAX_DELIVERY_ATTEMPTS = 10; interface ClaimedOutboxEvent { _id: mongoose.Types.ObjectId; @@ -130,18 +131,33 @@ export class CompetitionOutboxProcessor $unset: { lastError: 1 }, }).exec(); } catch (error) { + const lastError = errorMessage(error).slice(0, 2_000); + if (event.attemptCount >= MAX_DELIVERY_ATTEMPTS) { + const terminal = await OutboxModel.updateOne(leaseFilter(event), { + $set: { + state: 'dead-letter', + lastError, + }, + }).exec(); + if (terminal.matchedCount > 0) { + this.logger.error( + `Competition outbox event ${event._id.toString()} moved to dead-letter after ${event.attemptCount} attempts: ${lastError}`, + ); + } + return; + } const availableAt = new Date( Date.now() + retryDelayMilliseconds(event.attemptCount), ); await OutboxModel.updateOne(leaseFilter(event), { $set: { state: 'failed', - lastError: errorMessage(error).slice(0, 2_000), + lastError, availableAt, }, }).exec(); this.logger.warn( - `Competition outbox event ${event._id.toString()} failed: ${errorMessage(error)}`, + `Competition outbox event ${event._id.toString()} failed: ${lastError}`, ); } } diff --git a/apps/web/package.json b/apps/web/package.json index b3e5c10d..881c1aec 100644 --- a/apps/web/package.json +++ b/apps/web/package.json @@ -7,6 +7,7 @@ "dev": "vite", "start:dev": "vite --mode development", "start:staging": "vite --mode staging", + "test": "node --test --experimental-strip-types test/*.test.ts", "build": "tsc -b && vite build", "build:staging": "tsc -b && vite build --mode staging", "build:prod": "tsc -b && vite build --mode production", diff --git a/apps/web/src/api/auth-query-scope.ts b/apps/web/src/api/auth-query-scope.ts new file mode 100644 index 00000000..916986f0 --- /dev/null +++ b/apps/web/src/api/auth-query-scope.ts @@ -0,0 +1,35 @@ +export interface AuthQueryScopeInput { + authUserId: string | null; + accountKey: string | null; + msalConfigured: boolean; + msalReady: boolean; +} + +interface ExecuteAuthScopedQueryInput { + accountKey: string | null; + acquireAccessToken: () => Promise; + request: (authorizationHeader: string | null) => Promise; +} + +export function resolveAuthQueryScope({ + authUserId, + accountKey, + msalConfigured, + msalReady, +}: AuthQueryScopeInput) { + return { + cacheKey: [authUserId, accountKey] as const, + ready: Boolean(authUserId || !msalConfigured || msalReady), + }; +} + +export async function executeAuthScopedQuery({ + accountKey, + acquireAccessToken, + request, +}: ExecuteAuthScopedQueryInput): Promise { + if (!accountKey) return request(null); + + const accessToken = await acquireAccessToken(); + return request(`Bearer ${accessToken}`); +} diff --git a/apps/web/src/api/hooks.ts b/apps/web/src/api/hooks.ts index 1c7d515a..9cb15d64 100644 --- a/apps/web/src/api/hooks.ts +++ b/apps/web/src/api/hooks.ts @@ -5,6 +5,9 @@ import type { CompetitionCommandResponse, CompetitionDetailResponse, CreateSeriesAdjudicationRequest, + MatchDetailResponse, + MatchLifecycleStatus, + MatchListResponse, ReverseSeriesResultRequest, SeriesId, SeriesReversalPreviewRequest, @@ -18,6 +21,10 @@ import { MSAL_API_SCOPE, MSAL_SILENT_REDIRECT_URI, } from '../lib/auth/msal.config'; +import { + executeAuthScopedQuery, + resolveAuthQueryScope, +} from './auth-query-scope'; import type { ApiAuction, ApiAuctionHistoryEntry, @@ -31,7 +38,6 @@ import type { LegacyImportJobsResponse, LegacyImportMembersResponse, LegacyMatchListResponse, - ApiMatch, ApiRecentMatchesResponse, ApiRecentSummaryResponse, ApiTeamInsightsResponse, @@ -41,9 +47,7 @@ import type { DdragonManifest, StartLegacyImportRequest, StartLegacyImportResponse, - MatchStatus, MatchMutationRequest, - MatchesResponse, ManualTournamentResultCollectResponse, MeResponse, RiotQueueGroup, @@ -59,7 +63,7 @@ import type { const DDRAGON_MANIFEST_STALE_MS = 24 * 60 * 60 * 1000; interface MatchesQueryOptions { - status?: MatchStatus; + status?: MatchLifecycleStatus; limit?: number; page?: number; offset?: number; @@ -101,6 +105,45 @@ function createMatchesPath( return `/communities/${communityId}/matches${queryString ? `?${queryString}` : ''}`; } +function useOptionalAuthQueryScope() { + const authUserId = useAuthUserId(); + const { accounts, inProgress, instance } = useMsal(); + const account = isMsalConfigured + ? (instance.getActiveAccount() ?? accounts[0] ?? null) + : null; + const scope = resolveAuthQueryScope({ + authUserId, + accountKey: account?.homeAccountId ?? null, + msalConfigured: isMsalConfigured, + msalReady: inProgress === InteractionStatus.None, + }); + + const fetch = (path: string) => + executeAuthScopedQuery({ + accountKey: account?.homeAccountId ?? null, + acquireAccessToken: async () => { + if (!account) { + throw new Error('MSAL account is unavailable.'); + } + const response = await instance.acquireTokenSilent({ + account, + scopes: [MSAL_API_SCOPE], + redirectUri: MSAL_SILENT_REDIRECT_URI, + }); + return response.accessToken; + }, + request: (authorizationHeader) => + apiFetch( + path, + authorizationHeader + ? { headers: { Authorization: authorizationHeader } } + : undefined, + ), + }); + + return { ...scope, fetch }; +} + export function useCommunity(communityId = DEFAULT_COMMUNITY_ID) { return useQuery({ queryKey: ['community', communityId], @@ -114,10 +157,13 @@ export function useMatches( options: MatchesQueryOptions, communityId = DEFAULT_COMMUNITY_ID, ) { + const authScope = useOptionalAuthQueryScope(); + return useQuery({ queryKey: [ 'matches', communityId, + ...authScope.cacheKey, options.status ?? null, options.limit ?? null, options.page ?? null, @@ -127,13 +173,12 @@ export function useMatches( options.sort ?? null, ], queryFn: async () => { - const response = await apiFetch( + const response = await authScope.fetch( createMatchesPath(communityId, options), - { auth: 'none' }, ); return response.matches; }, - enabled: Boolean(communityId), + enabled: Boolean(communityId && authScope.ready), }); } @@ -141,10 +186,13 @@ export function useMatchesPage( options: MatchesQueryOptions, communityId = DEFAULT_COMMUNITY_ID, ) { + const authScope = useOptionalAuthQueryScope(); + return useQuery({ queryKey: [ 'matches-page', communityId, + ...authScope.cacheKey, options.status ?? null, options.limit ?? null, options.page ?? null, @@ -154,10 +202,10 @@ export function useMatchesPage( options.sort ?? null, ], queryFn: () => - apiFetch(createMatchesPath(communityId, options), { - auth: 'none', - }), - enabled: Boolean(communityId), + authScope.fetch( + createMatchesPath(communityId, options), + ), + enabled: Boolean(communityId && authScope.ready), placeholderData: (previousData) => previousData, }); } @@ -166,15 +214,25 @@ export function useMatch( matchId: string | undefined, communityId = DEFAULT_COMMUNITY_ID, ) { - return useQuery({ - queryKey: ['match', communityId, matchId ?? null], + const authScope = useOptionalAuthQueryScope(); + const queryKey = [ + 'match', + communityId, + matchId ?? null, + ...authScope.cacheKey, + ] as const; + + const query = useQuery({ + queryKey, queryFn: () => - apiFetch(`/communities/${communityId}/matches/${matchId}`, { - auth: 'none', - }), - enabled: Boolean(communityId && matchId), + authScope.fetch( + `/communities/${communityId}/matches/${matchId}`, + ), + enabled: Boolean(communityId && matchId && authScope.ready), retry: false, }); + + return { ...query, queryKey }; } export function useCompetition( @@ -426,7 +484,7 @@ export function useResetAuction(communityId = DEFAULT_COMMUNITY_ID) { export function useCreateMatch(communityId = DEFAULT_COMMUNITY_ID) { return useMutation({ mutationFn: (body: MatchMutationRequest) => - apiFetch(`/communities/${communityId}/matches`, { + apiFetch(`/communities/${communityId}/matches`, { method: 'POST', body: JSON.stringify(body), }), @@ -442,10 +500,13 @@ export function useUpdateMatch(communityId = DEFAULT_COMMUNITY_ID) { matchId: string; body: Partial; }) => - apiFetch(`/communities/${communityId}/matches/${matchId}`, { - method: 'PATCH', - body: JSON.stringify(body), - }), + apiFetch( + `/communities/${communityId}/matches/${matchId}`, + { + method: 'PATCH', + body: JSON.stringify(body), + }, + ), }); } @@ -1028,34 +1089,12 @@ export function useRebuildLegacyMatches(communityId = DEFAULT_COMMUNITY_ID) { } export function useMe() { - const authUserId = useAuthUserId(); - const { accounts, inProgress, instance } = useMsal(); - const account = isMsalConfigured - ? (instance.getActiveAccount() ?? accounts[0] ?? null) - : null; - const accountKey = account?.homeAccountId ?? null; - const isMsalReady = - !isMsalConfigured || inProgress === InteractionStatus.None; + const authScope = useOptionalAuthQueryScope(); return useQuery({ - queryKey: ['me', authUserId, accountKey], - queryFn: async () => { - if (!account) { - return apiFetch('/me'); - } - - const response = await instance.acquireTokenSilent({ - account, - scopes: [MSAL_API_SCOPE], - redirectUri: MSAL_SILENT_REDIRECT_URI, - }); - return apiFetch('/me', { - headers: { - Authorization: `Bearer ${response.accessToken}`, - }, - }); - }, - enabled: Boolean(authUserId || isMsalReady), + queryKey: ['me', ...authScope.cacheKey], + queryFn: () => authScope.fetch('/me'), + enabled: authScope.ready, retry: false, }); } diff --git a/apps/web/src/api/mappers.ts b/apps/web/src/api/mappers.ts index 91e9acc3..0e768888 100644 --- a/apps/web/src/api/mappers.ts +++ b/apps/web/src/api/mappers.ts @@ -1,15 +1,17 @@ +import type { + MatchDetailResponse, + MatchLifecycleStatus, + MatchParticipantView, +} from "@lolympus/contracts"; import type { ApiAuction, ApiAuctionPlayerSnapshot, ApiAuctionTeam, - ApiMatch, - ApiMatchParticipant, ApiPositionPreference, ApiRiotLaneStats, ApiRiotRecentStatsSummary, ApiTierHistoryEntry, ApiTierInfo, - MatchStatus, Position, RiotLane, } from "./types"; @@ -46,7 +48,7 @@ export interface MatchDetailView { title: string; date: string; time: string; - status: MatchStatus; + status: MatchLifecycleStatus; description: string; map: string; maxParticipants: number; @@ -180,7 +182,7 @@ function resolveMainAndSubPosition( } function mapMatchParticipantToView( - participant: ApiMatchParticipant, + participant: MatchParticipantView, ): ParticipantView { const { mainPosition, subPosition } = resolveMainAndSubPosition( participant.preferredPositions, @@ -383,7 +385,9 @@ export function buildDefaultPreferredPositions() { })); } -export function mapApiMatchToMatchDetail(match: ApiMatch): MatchDetailView { +export function mapApiMatchToMatchDetail( + match: MatchDetailResponse, +): MatchDetailView { const formattedDate = formatKoreanDate(match.scheduledAt); const participants = match.participants.map(mapMatchParticipantToView); const participantLookup = new Map( @@ -439,7 +443,7 @@ export function mapApiMatchToMatchDetail(match: ApiMatch): MatchDetailView { export function mapApiAuctionToAuctionState( auction: ApiAuction, - match: ApiMatch, + match: MatchDetailResponse, now = new Date(), ): AuctionStateView { const participantLookup = new Map( diff --git a/apps/web/src/api/types.ts b/apps/web/src/api/types.ts index f453045f..09523bf6 100644 --- a/apps/web/src/api/types.ts +++ b/apps/web/src/api/types.ts @@ -1,15 +1,14 @@ -export type Position = 'TOP' | 'JGL' | 'MID' | 'ADC' | 'SUP'; +import type { + MatchGameMode, + MatchPosition, + MatchPositionPreferenceView, + MatchScheduleItemView, + MatchTierView, +} from '@lolympus/contracts'; + +export type Position = MatchPosition; export type RiotLane = 'TOP' | 'JUNGLE' | 'MIDDLE' | 'BOTTOM' | 'UTILITY'; export type TeamSide = 'blue' | 'red'; -export type MatchGameMode = - | 'pair' - | 'round-robin' - | 'double-elimination'; -export type MatchStatus = - | 'recruiting' - | 'team-built' - | 'in-progress' - | 'finished'; export type AuctionPhase = | 'waiting' | 'presenting' @@ -25,20 +24,8 @@ export type AuctionTopTierThreshold = | 'MANUAL'; export type CommunityRole = 'owner' | 'admin' | 'member'; -export interface ApiPositionPreference { - position: Position; - priority: number; -} - -export interface ApiTierInfo { - queueType: string; - tier: string; - rank: string; - leaguePoints: number; - wins: number; - losses: number; - fetchedAt: string; -} +export type ApiPositionPreference = MatchPositionPreferenceView; +export type ApiTierInfo = MatchTierView; export interface ApiChampionMasteryEntry { puuid?: string; @@ -142,36 +129,6 @@ export type TournamentCodeState = | 'released' | 'voided'; -export interface ApiMatchParticipant { - userId: string; - puuid?: string; - gameName?: string; - tagLine?: string; - profileIconId?: number; - tier?: ApiTierInfo; - preferredPositions: ApiPositionPreference[]; - joinedAt: string; - excluded?: boolean; -} - -export interface ApiMatchTeamMember { - userId: string; - assignedPosition: Position; - cost?: number; -} - -export interface ApiMatchTeam { - teamIndex: number; - name: string; - captainUserId?: string; - members: ApiMatchTeamMember[]; -} - -export interface ApiMatchScheduleItem { - time: string; - label: string; -} - export interface ManualTournamentResultCollectResponse { scanned: number; matched: number; @@ -180,31 +137,6 @@ export interface ManualTournamentResultCollectResponse { gameNumbers: number[]; } -export interface ApiMatch { - _id: string; - communityId: string; - shortCode?: string; - title: string; - description: string; - mapId: number; - status: MatchStatus; - scheduledAt: string; - maxParticipants: number; - gameCount: number; - gameMode: MatchGameMode; - roundRobinMaxRounds?: number; - doubleEliminationResetFinalEnabled?: boolean; - hostUserId?: string; - participants: ApiMatchParticipant[]; - teams: ApiMatchTeam[]; - prizes: string[]; - notices: string[]; - schedule: ApiMatchScheduleItem[]; - joined?: boolean; - createdAt: string; - updatedAt: string; -} - export interface ApiAuctionPlayerSnapshot { userId: string; puuid: string; @@ -336,13 +268,6 @@ export interface MeResponse { memberships: ApiMembership[]; } -export interface MatchesResponse { - matches: ApiMatch[]; - total: number; - page: number; - limit: number; -} - export interface MatchMutationRequest { title: string; description?: string; @@ -355,7 +280,7 @@ export interface MatchMutationRequest { doubleEliminationResetFinalEnabled?: boolean; prizes?: string[]; notices?: string[]; - schedule?: ApiMatchScheduleItem[]; + schedule?: MatchScheduleItemView[]; } export interface DdragonChampionEntry { diff --git a/apps/web/src/pages/MatchDetailPage.tsx b/apps/web/src/pages/MatchDetailPage.tsx index 24c1061e..c80ca4cc 100644 --- a/apps/web/src/pages/MatchDetailPage.tsx +++ b/apps/web/src/pages/MatchDetailPage.tsx @@ -1,5 +1,9 @@ import { useEffect, useState } from "react"; import { useMutation, useQueryClient } from "@tanstack/react-query"; +import type { + MatchDetailResponse, + MatchParticipantView, +} from "@lolympus/contracts"; import { ChevronLeft, Search, X } from "lucide-react"; import { Link, useLocation, useNavigate, useParams } from "react-router"; import { @@ -37,8 +41,6 @@ import type { AuctionTopTierThreshold, ApiCommunityUserSearchCandidate, ApiCommunityUserSearchRiotAccount, - ApiMatch, - ApiMatchParticipant, ApiPositionPreference, ApiTierInfo, ManualTournamentResultCollectResponse, @@ -138,7 +140,7 @@ function parseAuctionSecondsInput(value: string, min: number) { return seconds; } -function buildAuctionParticipantPool(participants: ApiMatchParticipant[]) { +function buildAuctionParticipantPool(participants: MatchParticipantView[]) { const ordered = [...participants].sort( (left, right) => new Date(left.joinedAt).getTime() - new Date(right.joinedAt).getTime(), @@ -148,7 +150,7 @@ function buildAuctionParticipantPool(participants: ApiMatchParticipant[]) { } function buildCaptainSlots( - participants: ApiMatchParticipant[], + participants: MatchParticipantView[], ): CaptainSelectionSlot[] { const teamCount = Math.floor( buildAuctionParticipantPool(participants).length / 5, @@ -1451,7 +1453,7 @@ export default function MatchDetailPage() { }, }); - const matchQueryKey = ["match", DEFAULT_COMMUNITY_ID, id ?? null]; + const matchQueryKey = matchQuery.queryKey; const addParticipantMutation = useMutation({ mutationFn: ({ @@ -1463,7 +1465,7 @@ export default function MatchDetailPage() { preferredPositions: ApiPositionPreference[]; riotPuuid?: string; }) => - apiFetch( + apiFetch( `/communities/${DEFAULT_COMMUNITY_ID}/matches/${id}/participants/${userId}`, { method: "POST", @@ -1488,9 +1490,10 @@ export default function MatchDetailPage() { ), onMutate: async (userId: string) => { await queryClient.cancelQueries({ queryKey: matchQueryKey }); - const previous = queryClient.getQueryData(matchQueryKey); + const previous = + queryClient.getQueryData(matchQueryKey); if (previous) { - queryClient.setQueryData(matchQueryKey, { + queryClient.setQueryData(matchQueryKey, { ...previous, participants: previous.participants.filter( (participant) => participant.userId !== userId, @@ -1531,9 +1534,10 @@ export default function MatchDetailPage() { ), onMutate: async ({ userId, mainPosition, subPosition }) => { await queryClient.cancelQueries({ queryKey: matchQueryKey }); - const previous = queryClient.getQueryData(matchQueryKey); + const previous = + queryClient.getQueryData(matchQueryKey); if (previous) { - queryClient.setQueryData(matchQueryKey, { + queryClient.setQueryData(matchQueryKey, { ...previous, participants: previous.participants.map((participant) => participant.userId === userId @@ -1759,7 +1763,7 @@ export default function MatchDetailPage() { const manualPriorityCandidates = auctionParticipantPool.filter( (participant) => !selectedCaptainIds.includes(participant.userId), ); - const manualPriorityCandidateIds = new Set( + const manualPriorityCandidateIds = new Set( manualPriorityCandidates.map((participant) => participant.userId), ); const selectedManualTopTierUserIds = diff --git a/apps/web/src/pages/MatchTeamProgressPage.tsx b/apps/web/src/pages/MatchTeamProgressPage.tsx index 2db4bdcc..53ac68ff 100644 --- a/apps/web/src/pages/MatchTeamProgressPage.tsx +++ b/apps/web/src/pages/MatchTeamProgressPage.tsx @@ -1,41 +1,112 @@ -import { useState } from "react"; +import { useEffect, useRef, useState } from "react"; import { Link, useParams } from "react-router"; import { useCompetition, useTeamCompetition } from "../api/hooks"; import { SeriesScoreCard } from "../components/competition/SeriesScoreCard"; import { DEFAULT_COMMUNITY_ID } from "../config"; +import { + getTeamProgressErrorContent, + isConsistentTeamProgressSnapshot, + type TeamProgressErrorContent, +} from "./match-team-progress-state"; export default function MatchTeamProgressPage() { const { id } = useParams(); const competitionQuery = useCompetition(id, DEFAULT_COMMUNITY_ID); const teamQuery = useTeamCompetition(id, DEFAULT_COMMUNITY_ID); + const refetchCompetition = competitionQuery.refetch; + const refetchTeam = teamQuery.refetch; const [copiedSlotId, setCopiedSlotId] = useState(null); + const lastAutoRefetchedMismatchRef = useRef(null); + const competition = competitionQuery.data; + const teamView = teamQuery.data; + const hasQueryError = Boolean( + competitionQuery.error || teamQuery.error, + ); + const isRefetching = competitionQuery.isFetching || teamQuery.isFetching; + const revisionsMatch = isConsistentTeamProgressSnapshot( + competition, + teamView, + ); + const revisionMismatchKey = + competition && teamView && !revisionsMatch + ? `${competition.revision}:${teamView.revision}` + : null; + useEffect(() => { + if (!revisionMismatchKey) { + lastAutoRefetchedMismatchRef.current = null; + return; + } + if ( + hasQueryError || + isRefetching || + lastAutoRefetchedMismatchRef.current === revisionMismatchKey + ) { + return; + } + + lastAutoRefetchedMismatchRef.current = revisionMismatchKey; + void Promise.all([refetchCompetition(), refetchTeam()]).catch( + () => undefined, + ); + }, [ + hasQueryError, + isRefetching, + refetchCompetition, + refetchTeam, + revisionMismatchKey, + ]); + + function retryBoth() { + void Promise.all([refetchCompetition(), refetchTeam()]).catch( + () => undefined, + ); + } + if (competitionQuery.isLoading || teamQuery.isLoading) { + return ; + } + + if (hasQueryError) { return ( -
-
-
-
+ ); } - const competition = competitionQuery.data; - const teamView = teamQuery.data; if (!competition || !teamView) { return ( -
-

팀 진행 정보를 볼 수 없습니다

-

- 이 내전에 참여한 계정으로 로그인했는지 확인해주세요. -

- - 내전 상세로 - -
+ + ); + } + + if (!revisionsMatch) { + return ( + ); } @@ -208,6 +279,59 @@ export default function MatchTeamProgressPage() { ); } +function TeamProgressLoadingState() { + return ( +
+
+
+
+ ); +} + +function TeamProgressProblemState({ + content, + isRetrying, + matchId, + onRetry, +}: { + content: TeamProgressErrorContent; + isRetrying: boolean; + matchId: string | undefined; + onRetry: () => void; +}) { + return ( +
+
+

{content.title}

+

+ {content.description} +

+
+ + + 내전 상세로 + +
+
+
+ ); +} + function EmptyState({ message }: { message: string }) { return (

{ const [time, ...labelParts] = line.split('|').map((part) => part.trim()); return { @@ -102,11 +102,11 @@ function parseSchedule(value: string): ApiMatchScheduleItem[] { }); } -function scheduleToText(schedule: ApiMatchScheduleItem[] = []) { +function scheduleToText(schedule: MatchScheduleItemView[] = []) { return schedule.map((item) => `${item.time}|${item.label}`).join('\n'); } -function makeForm(match?: ApiMatch): MatchMutationRequest & { +function makeForm(match?: MatchDetailResponse): MatchMutationRequest & { prizesText: string; noticesText: string; scheduleText: string; @@ -149,7 +149,7 @@ export default function MatchAdminPage() { const createMutation = useCreateMatch(communityId); const updateMutation = useUpdateMatch(communityId); const deleteMutation = useDeleteMatch(communityId); - const [editing, setEditing] = useState(null); + const [editing, setEditing] = useState(null); const [showForm, setShowForm] = useState(false); const [form, setForm] = useState(makeForm()); const [message, setMessage] = useState(null); @@ -181,7 +181,7 @@ export default function MatchAdminPage() { setMessage(null); } - function openEdit(match: ApiMatch) { + function openEdit(match: MatchDetailResponse) { setEditing(match); setForm(makeForm(match)); setShowForm(true); @@ -550,7 +550,15 @@ export default function MatchAdminPage() {