Files
lolympus-tournament-support/apps/api/src/modules/tournament-result/tournament-result.service.ts
T
dahyeon 0d7617e2d2 feat: connect tournament views to APIs and recover archived stats
Remove development previews and complete hall of fame, match history, official results, and multi-kill API integration.

Fix active match pagination and team-ready controls, preserve basic scoreboards, and recover statistics when Riot archives arrive.

Use bounded in-process cache invalidation retries and add the Riot match lookup index migration with regression coverage.
2026-11-11 02:00:35 +09:00

1081 lines
36 KiB
TypeScript

import {
BadRequestException,
Injectable,
Logger,
NotFoundException,
} from '@nestjs/common';
import { createHash } from 'node:crypto';
import mongoose from 'mongoose';
import { CommunityStatsService } from '../community-stats/community-stats.service';
import {
CompetitionBootstrapService,
type CompetitionBootstrapMatch,
} from '../competition/competition-bootstrap.service';
import { CompetitionCommandService } from '../competition/competition-command.service';
import { ConnectionService } from '../global/database/connection.service';
import type {
MatchDocument,
RiotMatch as StoredRiotMatch,
TournamentCodeDocument,
} from '../global/database/schema';
import { DistributedLockService } from '../global/redis/distributed-lock.service';
import { RiotJobQueueService } from '../riot-job-queue/riot-job-queue.service';
import type { RiotJobPriority } from '../riot-job-queue/riot-job-queue.types';
import { RiotMatchService } from '../riot/riot-match.service';
import type { RiotMatchDto, RiotRegionalRoute } from '../riot/riot.types';
import { CompetitionAssignmentProvisioner } from './competition-assignment.provisioner';
import {
compareRiotGameChronology,
hasAcceptedRiotMatch,
mapRiotGameToCompetitionSlot,
resolveReadyCompetitionSlot,
type CompetitionResultGameSlotProjection,
type CompetitionResultSnapshot,
type MappedCompetitionRiotGame,
} from './competition-result.adapter';
import {
collectCaptainAndLimitedTeamMemberUserIds,
collectCaptainUserIds,
collectMatchUserIds,
type MatchPuuidLookup,
} from './team-mapping.util';
import type {
EnqueueTournamentResultPollResult,
ManualTournamentResultCollectResponse,
PollTournamentResultJob,
} from './tournament-result.types';
const FIRST_HOUR_POLL_DELAY_MS = 2 * 60_000;
const LATER_POLL_DELAY_MS = 60 * 60_000;
const POLL_EXPIRY_MS = 24 * 60 * 60_000;
const EXPAND_AFTER_MS = 60 * 60_000;
const EXPANDED_MEMBER_LIMIT_PER_TEAM = 2;
const TOURNAMENT_LOOKUP_START_MARGIN_SECONDS = 60;
const RESULT_ACCEPT_ATTEMPTS = 2;
const TOURNAMENT_RESULT_POLL_PROCESSING_LOCK_EXPIRATION_DURATION_MILLISECONDS =
30 * 60_000;
const TOURNAMENT_RESULT_POLL_PROCESSING_LOCK_RENEWAL_INTERVAL_MILLISECONDS =
5 * 60_000;
const TOURNAMENT_RESULT_POLL_SCHEDULING_LOCK_EXPIRATION_DURATION_MILLISECONDS =
5 * 60_000;
type CompetitionPersistenceDocument = {
_id: mongoose.Types.ObjectId;
revision: number;
phase: string;
teams: unknown[];
projection: Record<string, unknown>;
toObject?: () => unknown;
};
type CodeAssignmentRecord = {
competitionId: mongoose.Types.ObjectId;
seriesId: mongoose.Types.ObjectId;
gameSlotId: mongoose.Types.ObjectId;
tournamentCodeId: mongoose.Types.ObjectId;
state: 'reserved' | 'used' | 'released' | 'voided';
};
type AcceptanceOutcome =
| {
kind: 'accepted';
displayNumber: number;
competition: CompetitionResultSnapshot;
}
| { kind: 'duplicate'; competition: CompetitionResultSnapshot }
| { kind: 'unmatched'; competition: CompetitionResultSnapshot };
@Injectable()
export class TournamentResultService {
private readonly logger = new Logger(TournamentResultService.name);
constructor(
private readonly connectionService: ConnectionService,
private readonly riotMatchService: RiotMatchService,
private readonly riotJobQueueService: RiotJobQueueService,
private readonly communityStatsService: CommunityStatsService,
private readonly distributedLockService: DistributedLockService,
private readonly competitionBootstrapService: CompetitionBootstrapService,
private readonly competitionCommandService: CompetitionCommandService,
private readonly competitionAssignmentProvisioner: CompetitionAssignmentProvisioner,
) {}
public async scheduleInitialPoll(
matchOrId: MatchDocument | mongoose.Types.ObjectId,
priority: RiotJobPriority = 'high',
): Promise<EnqueueTournamentResultPollResult | null> {
const matchIdentifier = this.resolveMatchIdentifier(matchOrId);
const preparedMatchId = await this.distributedLockService.runWithLock(
{
lockKey: this.tournamentResultPollProcessingLockKey(matchIdentifier),
lockExpirationDurationMilliseconds:
TOURNAMENT_RESULT_POLL_SCHEDULING_LOCK_EXPIRATION_DURATION_MILLISECONDS,
lockAcquireTimeoutMilliseconds: 1_000,
lockRetryDelayMilliseconds: 100,
},
async () => this.prepareInitialPollWhileLockOwned(matchOrId),
);
if (!preparedMatchId) return null;
// A fast worker must not see the job while its preparation owns the same lock.
return this.riotJobQueueService.enqueueTournamentResultPoll({
matchId: preparedMatchId,
attempt: 1,
expandedToAllPuuids: false,
priority,
});
}
private async prepareInitialPollWhileLockOwned(
matchOrId: MatchDocument | mongoose.Types.ObjectId,
): Promise<string | null> {
const match = await this.loadMatch(matchOrId);
if (!this.isReadyToPoll(match)) return null;
let competition = await this.ensureCompetition(match);
competition = await this.provisionCompetitionAssignments(
match,
competition,
);
if (competition.projection.phase === 'completed') return null;
if (match.status === 'finished') match.status = 'in-progress';
match.resultPollState = {
startedAt: match.resultPollState?.startedAt ?? new Date(),
lastPolledAt: match.resultPollState?.lastPolledAt,
lastPollOutcome: match.resultPollState?.lastPollOutcome,
matchedCount: competition.projection.games.length,
expandedToAllPuuids: false,
state: 'polling',
};
await match.save();
return match._id.toString();
}
public async scheduleManualPoll(params: {
matchId: mongoose.Types.ObjectId;
communityId: mongoose.Types.ObjectId;
}): Promise<EnqueueTournamentResultPollResult> {
const match = await this.loadMatch(params.matchId);
if (!match.communityId.equals(params.communityId)) {
throw new BadRequestException('Match does not belong to this community.');
}
if (!this.isReadyToPoll(match)) {
throw new BadRequestException(
'Match needs built teams and teamBuiltAt before polling.',
);
}
const result = await this.scheduleInitialPoll(match, 'high');
if (!result) {
throw new BadRequestException(
'Tournament result polling is not available.',
);
}
return result;
}
public async collectManualByWindow(params: {
matchId: mongoose.Types.ObjectId;
communityId: mongoose.Types.ObjectId;
startTime: Date;
endTime: Date;
}): Promise<ManualTournamentResultCollectResponse> {
const match = await this.loadMatch(params.matchId);
this.assertManualCollectionAllowed(match, params.communityId);
if (params.startTime.getTime() > params.endTime.getTime()) {
throw new BadRequestException(
'startTime must be less than or equal to endTime.',
);
}
const region = await this.resolveRiotRegion(match);
const lookup = await this.buildPuuidLookup(match);
const puuids = this.collectPollingPuuids(
collectMatchUserIds(match),
lookup,
);
const startTime = Math.floor(params.startTime.getTime() / 1_000);
const endTime = Math.floor(params.endTime.getTime() / 1_000);
const riotMatchIds = new Set<string>();
for (const puuid of puuids) {
try {
const ids = await this.riotMatchService.getMatchIdsByPuuid(puuid, {
region,
startTime,
endTime,
count: 100,
});
ids.forEach((id) => riotMatchIds.add(id));
} catch (error) {
this.logger.warn(
`Manual result match id lookup failed for ${puuid}: ${errorMessage(error)}`,
);
}
}
const details = await this.loadRiotMatchDetails(
[...riotMatchIds],
region,
'Manual result detail fetch failed',
);
return this.applyManualRiotMatches(match, details, lookup);
}
public async collectManualByRiotMatch(params: {
matchId: mongoose.Types.ObjectId;
communityId: mongoose.Types.ObjectId;
riotMatchId: string;
}): Promise<ManualTournamentResultCollectResponse> {
const match = await this.loadMatch(params.matchId);
this.assertManualCollectionAllowed(match, params.communityId);
const riotMatchId = params.riotMatchId.trim();
if (!riotMatchId) throw new BadRequestException('riotMatchId is required.');
const region = await this.resolveRiotRegion(match);
const lookup = await this.buildPuuidLookup(match);
const detail = await this.ensureRiotMatchPersisted(riotMatchId, region);
return this.applyManualRiotMatches(match, [detail], lookup);
}
public async cancelPolling(
matchOrId: MatchDocument | mongoose.Types.ObjectId,
session?: mongoose.ClientSession,
): Promise<void> {
const match =
matchOrId instanceof mongoose.Types.ObjectId
? await this.loadMatch(matchOrId, session)
: matchOrId;
match.resultPollState = undefined;
if (session) await match.save({ session });
else await match.save();
}
public async processPollJob(job: PollTournamentResultJob): Promise<void> {
const didProcess = await this.distributedLockService.runWithRenewedLock(
{
lockKey: this.tournamentResultPollProcessingLockKey(job.matchId),
lockExpirationDurationMilliseconds:
TOURNAMENT_RESULT_POLL_PROCESSING_LOCK_EXPIRATION_DURATION_MILLISECONDS,
lockRenewalIntervalMilliseconds:
TOURNAMENT_RESULT_POLL_PROCESSING_LOCK_RENEWAL_INTERVAL_MILLISECONDS,
},
async () => {
await this.processPollJobWhileLockOwned(job);
return true;
},
);
if (didProcess) return;
throw new Error(
`Tournament result poll job ${job.jobId} could not acquire the processing lock for match ${job.matchId}.`,
);
}
private async processPollJobWhileLockOwned(
job: PollTournamentResultJob,
): Promise<void> {
const MatchModel = await this.connectionService.getModel('match');
const TournamentCodeModel =
await this.connectionService.getModel('tournamentCode');
const match = await MatchModel.findById(job.matchId);
if (!match) return;
if (!this.isReadyToPoll(match)) {
await this.updatePollState(match, 'failed', job.expandedToAllPuuids);
return;
}
let competition = await this.ensureCompetition(match);
competition = await this.provisionCompetitionAssignments(
match,
competition,
);
const codes = await TournamentCodeModel.find({ matchId: match._id })
.sort({ gameNumber: 1 })
.exec();
const unmatchedCodes = codes.filter(
(code) => code.state === 'reserved' && !code.riotMatchId,
);
if (unmatchedCodes.length === 0) {
await this.syncMatchLifecycle(match, competition);
if (competition.projection.phase !== 'completed') {
await this.scheduleNextPoll(match, competition, job);
}
return;
}
const region = await this.resolveRiotRegion(match);
const lookup = await this.buildPuuidLookup(match);
const puuids = job.expandedToAllPuuids
? this.collectPollingPuuids(
collectCaptainAndLimitedTeamMemberUserIds(
match,
EXPANDED_MEMBER_LIMIT_PER_TEAM,
),
lookup,
)
: this.collectPollingPuuids(collectCaptainUserIds(match), lookup);
const checkedRiotMatchIds = new Set<string>();
const unmatchedByCode = new Map(
unmatchedCodes.map((code) => [code.code, code]),
);
const collected: Array<{
detail: RiotMatchDto;
code: TournamentCodeDocument;
tournamentCode: string;
}> = [];
let matched = 0;
for (const puuid of puuids) {
let riotMatchIds: string[];
try {
riotMatchIds = await this.riotMatchService.getMatchIdsByPuuid(puuid, {
region,
type: 'tourney',
startTime: this.resolveStartTime(match),
endTime: Math.floor(Date.now() / 1_000),
count: 100,
});
} catch (error) {
this.logger.warn(
`Tournament result match id lookup failed for ${puuid}: ${errorMessage(error)}`,
);
continue;
}
for (const riotMatchId of riotMatchIds) {
if (checkedRiotMatchIds.has(riotMatchId)) continue;
checkedRiotMatchIds.add(riotMatchId);
let detail: RiotMatchDto;
try {
detail = await this.ensureRiotMatchPersisted(riotMatchId, region);
} catch (error) {
this.logger.warn(
`Tournament result detail fetch failed for ${riotMatchId}: ${errorMessage(error)}`,
);
continue;
}
const tournamentCode = detail.info.tournamentCode?.trim();
if (!tournamentCode) continue;
const code = unmatchedByCode.get(tournamentCode);
if (!code) continue;
collected.push({ detail, code, tournamentCode });
}
}
collected.sort((left, right) =>
compareRiotGameChronology(left.detail, right.detail),
);
for (const candidate of collected) {
if (unmatchedByCode.get(candidate.tournamentCode) !== candidate.code) {
continue;
}
const outcome = await this.acceptRiotGame({
match,
initialCompetition: competition,
detail: candidate.detail,
lookup,
code: candidate.code,
});
competition = outcome.competition;
if (outcome.kind === 'accepted') matched += 1;
if (outcome.kind !== 'unmatched') {
unmatchedByCode.delete(candidate.tournamentCode);
}
}
await this.updatePollState(
match,
matched > 0 ? 'matched' : 'not-found',
job.expandedToAllPuuids,
competition,
);
await this.syncMatchLifecycle(match, competition);
if (competition.projection.phase !== 'completed') {
await this.scheduleNextPoll(match, competition, job);
}
}
private async applyManualRiotMatches(
match: MatchDocument,
details: RiotMatchDto[],
lookup: MatchPuuidLookup,
): Promise<ManualTournamentResultCollectResponse> {
const sortedDetails = [...details].sort(compareRiotGameChronology);
let competition = await this.ensureCompetition(match);
const riotMatchIds: string[] = [];
const gameNumbers: number[] = [];
let skipped = 0;
for (const detail of sortedDetails) {
const outcome = await this.acceptRiotGame({
match,
initialCompetition: competition,
detail,
lookup,
});
competition = outcome.competition;
if (outcome.kind !== 'accepted') {
skipped += 1;
continue;
}
riotMatchIds.push(detail.metadata.matchId);
gameNumbers.push(outcome.displayNumber);
}
match.resultPollState = {
startedAt: match.resultPollState?.startedAt ?? new Date(),
lastPolledAt: new Date(),
lastPollOutcome: riotMatchIds.length > 0 ? 'matched' : 'not-found',
matchedCount: competition.projection.games.length,
expandedToAllPuuids: true,
state:
competition.projection.phase === 'completed' ? 'complete' : 'polling',
};
await this.syncMatchLifecycle(match, competition);
return {
scanned: sortedDetails.length,
matched: riotMatchIds.length,
skipped,
riotMatchIds,
gameNumbers,
};
}
private async acceptRiotGame(params: {
match: MatchDocument;
initialCompetition: CompetitionResultSnapshot;
detail: RiotMatchDto;
lookup: MatchPuuidLookup;
code?: TournamentCodeDocument;
}): Promise<AcceptanceOutcome> {
let competition = params.initialCompetition;
for (let attempt = 1; attempt <= RESULT_ACCEPT_ATTEMPTS; attempt += 1) {
if (hasAcceptedRiotMatch(competition, params.detail.metadata.matchId)) {
return { kind: 'duplicate', competition };
}
const declaredCode =
params.code ??
(await this.findDeclaredTournamentCode(params.match, params.detail));
const target = declaredCode
? await this.resolveCodeTarget(competition, declaredCode)
: undefined;
const mapped = target
? mapRiotGameToCompetitionSlot({
competition,
target,
detail: params.detail,
lookup: params.lookup,
})
: declaredCode
? null
: resolveReadyCompetitionSlot({
competition,
detail: params.detail,
lookup: params.lookup,
});
if (!mapped) return { kind: 'unmatched', competition };
const manualCode =
declaredCode ??
(await this.findCodeForMappedSlot(params.match, mapped));
if (manualCode && !params.code) {
await this.ensureCodeAssignment(competition, manualCode, {
id: mapped.gameSlotId,
seriesId: mapped.seriesId,
ordinal: mapped.ordinal,
displayNumber: mapped.displayNumber,
});
}
try {
const result = await this.competitionCommandService.acceptGame({
competitionId: objectId(competition.competitionId, 'Competition'),
expectedRevision: competition.revision,
idempotencyKey: `riot-result:${params.detail.metadata.matchId}`,
actor: { type: 'system' },
occurredAt: mapped.occurredAt,
gameId: objectId(mapped.gameId, 'Game'),
seriesId: objectId(mapped.seriesId, 'Series'),
gameSlotId: objectId(mapped.gameSlotId, 'GameSlot'),
ordinal: mapped.ordinal,
evidence: mapped.evidence,
mapping: mapped.mapping,
startedAt: mapped.startedAt,
durationSeconds: mapped.durationSeconds,
participants: mapped.normalizedParticipants,
...(manualCode
? {
tournamentCode: {
tournamentCodeId: manualCode._id,
riotMatchId: params.detail.metadata.matchId,
},
}
: {}),
});
competition = competitionSnapshot(result.competition);
competition = await this.provisionCompetitionAssignments(
params.match,
competition,
);
// acceptGame commits the stats rebuild to the durable Competition outbox.
return {
kind: 'accepted',
displayNumber: mapped.displayNumber,
competition,
};
} catch (error) {
if (attempt < RESULT_ACCEPT_ATTEMPTS && isStaleRevision(error)) {
competition = await this.loadCompetition(competition.competitionId);
continue;
}
throw error;
}
}
return { kind: 'unmatched', competition };
}
private async resolveCodeTarget(
competition: CompetitionResultSnapshot,
code: TournamentCodeDocument,
): Promise<CompetitionResultGameSlotProjection | undefined> {
const AssignmentModel = await this.connectionService.getModel(
'tournamentCodeAssignment',
);
const existing = (await AssignmentModel.findOne({
competitionId: objectId(competition.competitionId, 'Competition'),
tournamentCodeId: code._id,
})
.lean()
.exec()) as CodeAssignmentRecord | null;
if (existing) {
if (existing.state !== 'reserved') return undefined;
return competition.projection.gameSlots.find(
(slot) =>
slot.id === existing.gameSlotId.toString() && slot.status === 'ready',
);
}
if (!code.gameNumber) return undefined;
const target = competition.projection.gameSlots.find(
(slot) =>
slot.displayNumber === code.gameNumber && slot.status === 'ready',
);
if (!target) return undefined;
await this.ensureCodeAssignment(competition, code, target);
return target;
}
private async ensureCodeAssignment(
competition: CompetitionResultSnapshot,
code: TournamentCodeDocument,
target: Pick<
CompetitionResultGameSlotProjection,
'id' | 'seriesId' | 'ordinal' | 'displayNumber'
>,
): Promise<void> {
const AssignmentModel = await this.connectionService.getModel(
'tournamentCodeAssignment',
);
const competitionId = objectId(competition.competitionId, 'Competition');
const seriesId = objectId(target.seriesId, 'Series');
const gameSlotId = objectId(target.id, 'GameSlot');
const commandId = `cutover-assignment:${code._id.toString()}:${target.id}:${competition.revision}`;
await AssignmentModel.updateOne(
{
competitionId,
tournamentCodeId: code._id,
state: { $in: ['reserved', 'used'] },
},
{
$setOnInsert: {
_id: deterministicObjectId(commandId),
competitionId,
seriesId,
gameSlotId,
tournamentCodeId: code._id,
state: 'reserved',
reservedAt: code.reservedAt ?? new Date(),
commandId,
},
},
{ upsert: true },
).exec();
}
private async findDeclaredTournamentCode(
match: MatchDocument,
detail: RiotMatchDto,
): Promise<TournamentCodeDocument | undefined> {
const tournamentCode = detail.info.tournamentCode?.trim();
if (!tournamentCode) return undefined;
const TournamentCodeModel =
await this.connectionService.getModel('tournamentCode');
const code = await TournamentCodeModel.findOne({
matchId: match._id,
state: 'reserved',
code: tournamentCode,
}).exec();
return code ?? undefined;
}
private async findCodeForMappedSlot(
match: MatchDocument,
mapped: MappedCompetitionRiotGame,
): Promise<TournamentCodeDocument | undefined> {
if (match.tournamentCodeIds.length === 0) return undefined;
const TournamentCodeModel =
await this.connectionService.getModel('tournamentCode');
const code = await TournamentCodeModel.findOne({
_id: { $in: match.tournamentCodeIds },
matchId: match._id,
state: 'reserved',
gameNumber: mapped.displayNumber,
}).exec();
return code ?? undefined;
}
private async ensureCompetition(
match: MatchDocument,
): Promise<CompetitionResultSnapshot> {
const document = await this.competitionBootstrapService.bootstrap(
match as unknown as CompetitionBootstrapMatch,
);
const snapshot = competitionSnapshot(document);
match.competitionId = objectId(snapshot.competitionId, 'Competition');
return snapshot;
}
private async provisionCompetitionAssignments(
match: MatchDocument,
competition: CompetitionResultSnapshot,
): Promise<CompetitionResultSnapshot> {
try {
await this.competitionAssignmentProvisioner.provisionReadyAssignments({
matchId: match._id,
competition,
});
return competition;
} catch (error) {
if (!isAssignmentStaleRevision(error)) throw error;
const current = await this.loadCompetition(competition.competitionId);
await this.competitionAssignmentProvisioner.provisionReadyAssignments({
matchId: match._id,
competition: current,
});
return current;
}
}
private async loadCompetition(
competitionId: string,
): Promise<CompetitionResultSnapshot> {
const CompetitionModel =
await this.connectionService.getModel('competition');
const competition = await CompetitionModel.findById(competitionId)
.lean()
.exec();
if (!competition) throw new NotFoundException('Competition not found.');
return competitionSnapshot(competition);
}
private async syncMatchLifecycle(
match: MatchDocument,
competition: CompetitionResultSnapshot,
): Promise<void> {
if (competition.projection.phase === 'completed') {
match.status = 'finished';
if (match.resultPollState) match.resultPollState.state = 'complete';
} else if (
(competition.projection.phase === 'running' &&
match.status === 'team-built') ||
match.status === 'finished'
) {
match.status = 'in-progress';
}
if (match.resultPollState) {
match.resultPollState.matchedCount = competition.projection.games.length;
}
await match.save();
if (competition.projection.phase === 'completed') {
void this.communityStatsService
.invalidateCommunity(match.communityId)
.catch((error) => {
this.logger.warn(
`Failed to invalidate community stats cache for ${match.communityId.toString()}: ${errorMessage(error)}`,
);
});
}
}
private async ensureRiotMatchPersisted(
riotMatchId: string,
region: RiotRegionalRoute,
): Promise<RiotMatchDto> {
const RiotMatchModel = await this.connectionService.getModel('riotMatch');
const stored = await RiotMatchModel.findOne({
matchId: riotMatchId,
}).exec();
if (isRiotMatchDto(stored?.raw)) {
return stored.raw;
}
const dto = await this.riotMatchService.getMatch(riotMatchId, { region });
const payload: Partial<StoredRiotMatch> = {
matchId: dto.metadata.matchId,
gameCreation: dto.info.gameCreation,
gameDuration: dto.info.gameDuration,
gameVersion: dto.info.gameVersion,
queueId: dto.info.queueId,
participantPuuids: dto.metadata.participants,
raw: dto as unknown as Record<string, unknown>,
fetchedAt: new Date(),
};
await RiotMatchModel.updateOne(
{ matchId: dto.metadata.matchId },
{ $set: payload },
{ upsert: true },
).exec();
await this.communityStatsService
.refreshForRiotMatches([dto.metadata.matchId])
.catch((error: unknown) => {
this.logger.warn(
`Stats recovery failed after saving ${dto.metadata.matchId}: ${errorMessage(error)}`,
);
});
return dto;
}
private async loadRiotMatchDetails(
riotMatchIds: string[],
region: RiotRegionalRoute,
logPrefix: string,
): Promise<RiotMatchDto[]> {
const details: RiotMatchDto[] = [];
const checked = new Set<string>();
for (const riotMatchId of riotMatchIds) {
if (checked.has(riotMatchId)) continue;
checked.add(riotMatchId);
try {
details.push(await this.ensureRiotMatchPersisted(riotMatchId, region));
} catch (error) {
this.logger.warn(`${logPrefix} ${riotMatchId}: ${errorMessage(error)}`);
}
}
return details;
}
private async buildPuuidLookup(
match: MatchDocument,
): Promise<MatchPuuidLookup> {
const puuidByUserId = new Map<string, string>();
const userIdByPuuid = new Map<string, mongoose.Types.ObjectId>();
for (const participant of match.participants) {
if (!participant.puuid) continue;
puuidByUserId.set(participant.userId.toString(), participant.puuid);
userIdByPuuid.set(participant.puuid, participant.userId);
}
const missingUserIds = collectMatchUserIds(match).filter(
(userId) => !puuidByUserId.has(userId.toString()),
);
if (missingUserIds.length > 0) {
const UserModel = await this.connectionService.getModel('user');
const users = await UserModel.find({ _id: { $in: missingUserIds } })
.select({ riotAccounts: 1 })
.exec();
for (const user of users) {
const primary =
user.riotAccounts.find((account) => account.isPrimary) ??
user.riotAccounts[0];
if (!primary) continue;
puuidByUserId.set(user._id.toString(), primary.puuid);
userIdByPuuid.set(primary.puuid, user._id);
}
}
return { puuidByUserId, userIdByPuuid };
}
private collectPollingPuuids(
userIds: mongoose.Types.ObjectId[],
lookup: MatchPuuidLookup,
): string[] {
return [
...new Set(
userIds.flatMap((userId) => {
const puuid = lookup.puuidByUserId.get(userId.toString());
return puuid ? [puuid] : [];
}),
),
];
}
private async updatePollState(
match: MatchDocument,
outcome: 'matched' | 'not-found' | 'failed',
expandedToAllPuuids: boolean,
competition?: CompetitionResultSnapshot,
): Promise<void> {
match.resultPollState = {
startedAt: match.resultPollState?.startedAt ?? new Date(),
lastPolledAt: new Date(),
lastPollOutcome: outcome,
matchedCount:
competition?.projection.games.length ??
match.resultPollState?.matchedCount ??
0,
expandedToAllPuuids,
state: outcome === 'failed' ? 'failed' : 'polling',
};
await match.save();
}
private async scheduleNextPoll(
match: MatchDocument,
competition: CompetitionResultSnapshot,
job: PollTournamentResultJob,
): Promise<void> {
const pollState = match.resultPollState;
const startedAt = pollState?.startedAt ?? new Date();
const elapsedMs = Date.now() - startedAt.getTime();
const delayMs = this.nextPollDelayMs(elapsedMs);
if (delayMs === null) {
match.resultPollState = {
startedAt,
lastPolledAt: pollState?.lastPolledAt,
lastPollOutcome: pollState?.lastPollOutcome,
matchedCount: competition.projection.games.length,
expandedToAllPuuids:
pollState?.expandedToAllPuuids ?? job.expandedToAllPuuids,
state: 'expired',
};
await match.save();
this.logger.warn(
`Tournament result polling expired for match ${match._id.toString()}.`,
);
return;
}
const expandedToAllPuuids =
job.expandedToAllPuuids ||
(elapsedMs >= EXPAND_AFTER_MS &&
competition.projection.games.length === 0);
await this.riotJobQueueService.enqueueTournamentResultPoll({
matchId: match._id.toString(),
attempt: job.attempt + 1,
expandedToAllPuuids,
priority: 'low',
deferUntilMs: Date.now() + delayMs,
});
}
private nextPollDelayMs(elapsedMs: number): number | null {
if (elapsedMs >= POLL_EXPIRY_MS) return null;
if (elapsedMs <= EXPAND_AFTER_MS) return FIRST_HOUR_POLL_DELAY_MS;
return LATER_POLL_DELAY_MS;
}
private resolveStartTime(match: MatchDocument): number {
return Math.max(
0,
Math.floor(match.teamBuiltAt!.getTime() / 1_000) -
TOURNAMENT_LOOKUP_START_MARGIN_SECONDS,
);
}
private isReadyToPoll(match: MatchDocument): boolean {
return this.hasBuiltTeams(match);
}
private assertManualCollectionAllowed(
match: MatchDocument,
communityId: mongoose.Types.ObjectId,
): void {
if (!match.communityId.equals(communityId)) {
throw new BadRequestException('Match does not belong to this community.');
}
if (!this.hasBuiltTeams(match)) {
throw new BadRequestException(
'Match needs built teams before manual result collection.',
);
}
}
private hasBuiltTeams(match: MatchDocument): boolean {
return Boolean(
match.teamBuiltAt &&
match.teams.length >= 2 &&
match.teams.every((team) => team.members.length > 0),
);
}
private async resolveRiotRegion(
match: MatchDocument,
): Promise<RiotRegionalRoute> {
const CommunityModel = await this.connectionService.getModel('community');
const community = await CommunityModel.findById(match.communityId)
.select({ riotRegion: 1 })
.lean()
.exec();
return community?.riotRegion ?? 'asia';
}
private async loadMatch(
matchOrId: MatchDocument | mongoose.Types.ObjectId,
session?: mongoose.ClientSession,
): Promise<MatchDocument> {
const MatchModel = await this.connectionService.getModel('match');
const query =
matchOrId instanceof mongoose.Types.ObjectId
? MatchModel.findById(matchOrId)
: MatchModel.findById(matchOrId._id);
const match = await (session ? query.session(session) : query);
if (!match) throw new NotFoundException('Match not found.');
return match;
}
private resolveMatchIdentifier(
matchOrId: MatchDocument | mongoose.Types.ObjectId,
): string {
return matchOrId instanceof mongoose.Types.ObjectId
? matchOrId.toString()
: matchOrId._id.toString();
}
private tournamentResultPollProcessingLockKey(
matchIdentifier: string,
): string {
return `distributed-lock:tournament-result:process-poll-job:match:${matchIdentifier}`;
}
}
function competitionSnapshot(value: unknown): CompetitionResultSnapshot {
const raw =
value && typeof value === 'object' && 'toObject' in value
? ((value as CompetitionPersistenceDocument).toObject?.() ?? value)
: value;
if (!isRecord(raw)) throw new Error('Competition snapshot is missing.');
const projection = raw.projection;
if (!isRecord(projection))
throw new Error('Competition projection is missing.');
const competitionId = idString(raw._id);
const revision = raw.revision;
if (!competitionId || typeof revision !== 'number') {
throw new Error('Competition identity or revision is invalid.');
}
return {
competitionId,
revision,
phase: String(raw.phase) as CompetitionResultSnapshot['phase'],
teams: asArray(raw.teams).map((team) => ({
teamId: idString(asRecord(team).teamId),
members: asArray(asRecord(team).members).map((member) => ({
userId: idString(asRecord(member).userId),
})),
})),
projection: {
phase: String(
projection.phase,
) as CompetitionResultSnapshot['projection']['phase'],
series: asArray(projection.series).map((series) => {
const record = asRecord(series);
return {
seriesId: idString(record.seriesId),
status: String(
record.status,
) as CompetitionResultSnapshot['projection']['series'][number]['status'],
entries: asArray(record.entries).map((entry) => {
const row = asRecord(entry);
return {
slot: String(row.slot) as 'A' | 'B',
teamId: row.teamId == null ? null : idString(row.teamId),
gameWins: typeof row.gameWins === 'number' ? row.gameWins : 0,
};
}),
};
}),
gameSlots: asArray(projection.gameSlots).map((slot) => {
const record = asRecord(slot);
return {
id: idString(record.id),
seriesId: idString(record.seriesId),
ordinal: Number(record.ordinal),
displayNumber: Number(record.displayNumber),
status: String(
record.status,
) as CompetitionResultGameSlotProjection['status'],
};
}),
games: asArray(projection.games).map((game) => {
const evidence = asRecord(asRecord(game).evidence);
return {
evidence: {
type: typeof evidence.type === 'string' ? evidence.type : undefined,
riotMatchId:
typeof evidence.riotMatchId === 'string'
? evidence.riotMatchId
: undefined,
},
};
}),
},
};
}
function objectId(value: string, label: string): mongoose.Types.ObjectId {
if (!mongoose.Types.ObjectId.isValid(value)) {
throw new Error(`${label} id is not a valid ObjectId.`);
}
return new mongoose.Types.ObjectId(value);
}
function deterministicObjectId(key: string): mongoose.Types.ObjectId {
return new mongoose.Types.ObjectId(
createHash('sha256').update(key).digest('hex').slice(0, 24),
);
}
function isStaleRevision(error: unknown): boolean {
return isRecord(error) && error.code === 'STALE_COMPETITION_REVISION';
}
function isAssignmentStaleRevision(error: unknown): boolean {
return (
isRecord(error) && error.code === 'COMPETITION_ASSIGNMENT_STALE_REVISION'
);
}
function isRiotMatchDto(value: unknown): value is RiotMatchDto {
return Boolean(
value &&
typeof value === 'object' &&
'metadata' in value &&
'info' in value,
);
}
function isRecord(value: unknown): value is Record<string, unknown> {
return value !== null && typeof value === 'object' && !Array.isArray(value);
}
function asRecord(value: unknown): Record<string, unknown> {
return isRecord(value) ? value : {};
}
function asArray(value: unknown): unknown[] {
return Array.isArray(value) ? value : [];
}
function idString(value: unknown): string {
if (value instanceof mongoose.Types.ObjectId) return value.toString();
if (typeof value === 'string') return value;
if (typeof value === 'number' || typeof value === 'bigint') {
return String(value);
}
return '';
}
function errorMessage(error: unknown): string {
return error instanceof Error ? error.message : String(error);
}