Compare commits
30
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
640e593676 | ||
|
|
ee96f8d48b | ||
|
|
683d602d63 | ||
|
|
7ea2002975 | ||
|
|
ec92494211 | ||
|
|
6bddb666fc | ||
|
|
7db97c540b | ||
|
|
6aa2cb9009 | ||
|
|
575cd911cb | ||
|
|
78a2c7cf0d | ||
|
|
0c2c7b59fc | ||
|
|
5049220e03 | ||
|
|
ab9c48b1e6 | ||
|
|
2958106e42 | ||
|
|
ce07bfa0c8 | ||
|
|
4d6fa2625e | ||
|
|
ee4c3eeb27 | ||
|
|
55e5b8df70 | ||
|
|
f3286e7fd1 | ||
|
|
e6e434d13f | ||
|
|
28e9ac1529 | ||
|
|
874d785381 | ||
|
|
0c31a78df0 | ||
|
|
3b274b4ec2 | ||
|
|
59b9ef79e5 | ||
|
|
5d4fe443d0 | ||
|
|
39112ff7ff | ||
|
|
2135af7107 | ||
|
|
05a83db886 | ||
|
|
f4ba3d524f |
No files matched your search
@@ -8,6 +8,7 @@
|
||||
"scripts": {
|
||||
"build": "nest build",
|
||||
"format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
|
||||
"competition:migrate": "ts-node src/modules/global/database/migrations/run-competition-domain.ts",
|
||||
"seed:dev": "ts-node src/seed.ts",
|
||||
"seed:dakao-participant": "ts-node src/seed-dakao-participant.ts",
|
||||
"start:dev": "NODE_ENV=dev NEW_RELIC_HOME=. node --import newrelic/esm-loader.mjs -r newrelic dist/main.js",
|
||||
@@ -27,6 +28,7 @@
|
||||
"test:e2e": "jest --config ./test/jest-e2e.json"
|
||||
},
|
||||
"dependencies": {
|
||||
"@lolympus/contracts": "workspace:*",
|
||||
"@nestjs/common": "^11.0.1",
|
||||
"@nestjs/config": "^4.0.4",
|
||||
"@nestjs/core": "^11.0.1",
|
||||
|
||||
@@ -8,6 +8,7 @@ import { AuctionModule } from './modules/auction/auction.module';
|
||||
import { AuthModule } from './modules/auth/auth.module';
|
||||
import { CommunityModule } from './modules/community/community.module';
|
||||
import { CommunityStatsModule } from './modules/community-stats/community-stats.module';
|
||||
import { CompetitionModule } from './modules/competition/competition.module';
|
||||
import { DakaoModule } from './modules/dakao/dakao.module';
|
||||
import { GlobalModule } from './modules/global/global.module';
|
||||
import { LegacyImportModule } from './modules/legacy-import/legacy-import.module';
|
||||
@@ -31,6 +32,7 @@ import { UserModule } from './modules/user/user.module';
|
||||
BackgroundRefreshModule,
|
||||
CommunityModule,
|
||||
CommunityStatsModule,
|
||||
CompetitionModule,
|
||||
MatchModule,
|
||||
MatchHistoryModule,
|
||||
LegacyImportModule,
|
||||
|
||||
@@ -18,7 +18,14 @@ async function bootstrap() {
|
||||
app.enableCors({
|
||||
origin: createCorsOrigin(nodeEnv),
|
||||
credentials: true,
|
||||
allowedHeaders: ['Authorization', 'Content-Type', 'X-Auth-User-Id'],
|
||||
allowedHeaders: [
|
||||
'Authorization',
|
||||
'Content-Type',
|
||||
'X-Auth-User-Id',
|
||||
'If-Match',
|
||||
'Idempotency-Key',
|
||||
],
|
||||
exposedHeaders: ['ETag'],
|
||||
});
|
||||
app.useGlobalPipes(
|
||||
new ValidationPipe({
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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 =
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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<string, unknown>,
|
||||
snapshot: snapshot,
|
||||
targetHistorySequence: params.sequence,
|
||||
undoingCompletedAuction,
|
||||
};
|
||||
@@ -2111,7 +2119,7 @@ export class AuctionService {
|
||||
? (auction.toObject({ depopulate: true }) as Record<string, unknown>)
|
||||
: (auction as unknown as Record<string, unknown>);
|
||||
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<T>(value))) as T[];
|
||||
return this.cloneJson(this.arrayFromState<T>(value));
|
||||
}
|
||||
|
||||
private cloneJson<T>(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<MatchDocument, 'competitionId'>,
|
||||
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)
|
||||
}`,
|
||||
);
|
||||
}
|
||||
|
||||
@@ -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<MatchStatsRepository>;
|
||||
const matchStatsService = {
|
||||
buildAndUpsert: jest.fn().mockResolvedValue(undefined),
|
||||
} as unknown as jest.Mocked<MatchStatsService>;
|
||||
const service = new CommunityStatsService(
|
||||
connectionService,
|
||||
{} as CommunityStatsCacheService,
|
||||
matchStatsRepository,
|
||||
matchStatsService,
|
||||
);
|
||||
|
||||
const rebuilt = await (
|
||||
service as unknown as {
|
||||
rebuildMissingOrStaleFragments(
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
): Promise<number>;
|
||||
}
|
||||
).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);
|
||||
});
|
||||
});
|
||||
@@ -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<string, InternalGameDetail[]>();
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,216 @@
|
||||
import { Types } from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
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 }),
|
||||
});
|
||||
const connection = {
|
||||
getModel: jest.fn().mockResolvedValue({ updateOne }),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = new MatchStatsRepository(connection);
|
||||
const fragment = statsFragment(12);
|
||||
|
||||
await repository.upsert(fragment);
|
||||
|
||||
expect(updateOne).toHaveBeenCalledWith(
|
||||
{
|
||||
matchId: fragment.matchId,
|
||||
$or: [
|
||||
{ sourceCompetitionId: { $exists: false } },
|
||||
{ sourceCompetitionId: fragment.sourceCompetitionId },
|
||||
],
|
||||
$and: [
|
||||
{
|
||||
$or: [
|
||||
{ sourceRevision: { $exists: false } },
|
||||
{ sourceRevision: { $lte: 12 } },
|
||||
],
|
||||
},
|
||||
],
|
||||
},
|
||||
{ $set: fragment },
|
||||
{ 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<typeof statsFragment> | undefined;
|
||||
let initialGuardCount = 0;
|
||||
let releaseInitialGuards!: () => void;
|
||||
const initialGuardsReady = new Promise<void>((resolve) => {
|
||||
releaseInitialGuards = resolve;
|
||||
});
|
||||
let releaseOlderInsert!: () => void;
|
||||
const olderInserted = new Promise<void>((resolve) => {
|
||||
releaseOlderInsert = resolve;
|
||||
});
|
||||
const updateOne = jest.fn(
|
||||
(
|
||||
_filter: Record<string, unknown>,
|
||||
update: {
|
||||
$set?: ReturnType<typeof statsFragment>;
|
||||
$setOnInsert?: ReturnType<typeof statsFragment>;
|
||||
},
|
||||
) => ({
|
||||
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) {
|
||||
return {
|
||||
matchId: new Types.ObjectId(),
|
||||
communityId: new Types.ObjectId(),
|
||||
sourceCompetitionId: new Types.ObjectId(),
|
||||
sourceRevision,
|
||||
projectorVersion: 3,
|
||||
scheduledAt: new Date(),
|
||||
gameCreationMin: 1,
|
||||
gameCreationMax: 2,
|
||||
userIds: [],
|
||||
championIds: [],
|
||||
matchCard: {},
|
||||
records: [],
|
||||
gameDetails: [],
|
||||
builtAt: new Date(),
|
||||
builderVersion: 9,
|
||||
} satisfies Omit<MatchStats, 'createdAt' | 'updatedAt'>;
|
||||
}
|
||||
@@ -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) {}
|
||||
@@ -21,16 +26,86 @@ export class MatchStatsRepository {
|
||||
fragment: Omit<MatchStats, 'createdAt' | 'updatedAt'>,
|
||||
): Promise<void> {
|
||||
const MatchStatsModel = await this.connectionService.getModel('matchStats');
|
||||
await MatchStatsModel.updateOne(
|
||||
{ matchId: fragment.matchId },
|
||||
if (
|
||||
!fragment.sourceCompetitionId ||
|
||||
fragment.sourceRevision === undefined
|
||||
) {
|
||||
const updated = await MatchStatsModel.updateOne(
|
||||
{
|
||||
matchId: fragment.matchId,
|
||||
sourceCompetitionId: { $exists: false },
|
||||
},
|
||||
{ $set: fragment },
|
||||
{ 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(
|
||||
revisionGuard,
|
||||
{ $set: fragment },
|
||||
{ upsert: true },
|
||||
{ upsert: false },
|
||||
).exec();
|
||||
if (updated.matchedCount > 0) return;
|
||||
|
||||
// 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(
|
||||
revisionGuard,
|
||||
{ $set: fragment },
|
||||
{ upsert: false },
|
||||
).exec();
|
||||
}
|
||||
|
||||
public async deleteByMatch(matchId: mongoose.Types.ObjectId): Promise<void> {
|
||||
public async deleteByMatch(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
guard?: MatchStatsDeleteGuard,
|
||||
): Promise<void> {
|
||||
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(
|
||||
@@ -41,6 +116,16 @@ export class MatchStatsRepository {
|
||||
await MatchStatsModel.deleteMany({ matchId: { $in: matchIds } }).exec();
|
||||
}
|
||||
|
||||
public async deleteLegacyByMatch(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
): Promise<void> {
|
||||
const MatchStatsModel = await this.connectionService.getModel('matchStats');
|
||||
await MatchStatsModel.deleteOne({
|
||||
matchId,
|
||||
sourceCompetitionId: { $exists: false },
|
||||
}).exec();
|
||||
}
|
||||
|
||||
public async findByMatch(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
): Promise<MatchStatsDocument | null> {
|
||||
@@ -138,3 +223,32 @@ export class MatchStatsRepository {
|
||||
return filter;
|
||||
}
|
||||
}
|
||||
|
||||
function competitionRevisionGuard(
|
||||
fragment: Omit<MatchStats, 'createdAt' | 'updatedAt'>,
|
||||
) {
|
||||
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
|
||||
);
|
||||
}
|
||||
@@ -17,6 +17,7 @@ describe('MatchStatsService', () => {
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockImplementation(async (name: string) => {
|
||||
if (name === 'match') return { findById };
|
||||
if (name === 'competition') return { findOne: () => queryResult(null) };
|
||||
if (name === 'riotMatch') return {};
|
||||
throw new Error(`Unexpected model: ${name}`);
|
||||
}),
|
||||
@@ -38,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<MatchStatsRepository>;
|
||||
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();
|
||||
@@ -73,6 +125,7 @@ describe('MatchStatsService', () => {
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockImplementation(async (name: string) => {
|
||||
if (name === 'match') return { findById };
|
||||
if (name === 'competition') return { findOne: () => queryResult(null) };
|
||||
if (name === 'riotMatch') return { find: riotFind };
|
||||
throw new Error(`Unexpected model: ${name}`);
|
||||
}),
|
||||
@@ -118,4 +171,283 @@ describe('MatchStatsService', () => {
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('builds from the Competition projection and records its source revision', 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 userAId = new mongoose.Types.ObjectId();
|
||||
const userBId = new mongoose.Types.ObjectId();
|
||||
const match = {
|
||||
_id: matchId,
|
||||
communityId,
|
||||
scheduledAt: new Date('2026-07-12T10:00:00.000Z'),
|
||||
status: 'in-progress',
|
||||
teams: [],
|
||||
result: { games: [{ riotMatchId: 'KR_LEGACY_MUST_NOT_BE_USED' }] },
|
||||
};
|
||||
const competition = {
|
||||
_id: competitionId,
|
||||
revision: 12,
|
||||
projectorVersion: 3,
|
||||
teams: [
|
||||
{ teamId: teamAId, legacyTeamIndex: 8, displayOrder: 1 },
|
||||
{ teamId: teamBId, legacyTeamIndex: 3, displayOrder: 2 },
|
||||
],
|
||||
projection: {
|
||||
phase: 'running',
|
||||
games: [
|
||||
{
|
||||
displayNumber: 4,
|
||||
evidence: { type: 'riot', riotMatchId: 'KR_COMPETITION' },
|
||||
teams: {
|
||||
blue: { teamId: teamAId.toString() },
|
||||
red: { teamId: teamBId.toString() },
|
||||
},
|
||||
winnerTeamId: teamAId.toString(),
|
||||
startedAt: '2026-07-12T10:00:00.000Z',
|
||||
durationSeconds: 1800,
|
||||
participants: [
|
||||
participant(userAId, teamAId, 'blue', true),
|
||||
participant(userBId, teamBId, 'red', false),
|
||||
],
|
||||
},
|
||||
],
|
||||
},
|
||||
};
|
||||
const riotFind = jest.fn().mockReturnValue({
|
||||
lean: () => ({
|
||||
exec: jest
|
||||
.fn()
|
||||
.mockResolvedValue([{ matchId: 'KR_COMPETITION', raw: {} }]),
|
||||
}),
|
||||
});
|
||||
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 { find: riotFind };
|
||||
throw new Error(`Unexpected model: ${name}`);
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
upsert: jest.fn().mockResolvedValue(undefined),
|
||||
deleteByMatch: jest.fn(),
|
||||
} as unknown as jest.Mocked<MatchStatsRepository>;
|
||||
const builder = {
|
||||
buildFragment: jest.fn().mockReturnValue({
|
||||
matchCard: {},
|
||||
records: [],
|
||||
gameDetails: [],
|
||||
userIds: [],
|
||||
championIds: [],
|
||||
gameCreationMin: 1,
|
||||
gameCreationMax: 2,
|
||||
}),
|
||||
} as unknown as jest.Mocked<MatchStatsFragmentBuilder>;
|
||||
const service = new MatchStatsService(
|
||||
connectionService,
|
||||
repository,
|
||||
builder,
|
||||
{ getMatchTimeline: jest.fn() } as never,
|
||||
);
|
||||
|
||||
await service.buildAndUpsert(matchId, { sourceRevision: 12 });
|
||||
|
||||
expect(riotFind).toHaveBeenCalledWith({
|
||||
matchId: { $in: ['KR_COMPETITION'] },
|
||||
});
|
||||
expect(builder.buildFragment).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
match: expect.objectContaining({
|
||||
result: expect.objectContaining({
|
||||
riotMatchIds: ['KR_COMPETITION'],
|
||||
games: [
|
||||
expect.objectContaining({
|
||||
gameNumber: 4,
|
||||
blueTeamIndex: 8,
|
||||
redTeamIndex: 3,
|
||||
winnerTeamIndex: 8,
|
||||
}),
|
||||
],
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
);
|
||||
expect(repository.upsert).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
sourceCompetitionId: competitionId,
|
||||
sourceRevision: 12,
|
||||
projectorVersion: 3,
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
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<MatchStatsRepository>;
|
||||
const builder = {
|
||||
buildFragment: jest.fn().mockReturnValue({
|
||||
matchCard: {},
|
||||
records: [],
|
||||
gameDetails: [],
|
||||
userIds: [],
|
||||
championIds: [],
|
||||
gameCreationMin: 1,
|
||||
gameCreationMax: 2,
|
||||
}),
|
||||
} as unknown as jest.Mocked<MatchStatsFragmentBuilder>;
|
||||
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();
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockImplementation(async (name: string) => {
|
||||
if (name === 'match') {
|
||||
return {
|
||||
findById: () =>
|
||||
queryResult(
|
||||
{
|
||||
_id: matchId,
|
||||
status: 'in-progress',
|
||||
},
|
||||
false,
|
||||
),
|
||||
};
|
||||
}
|
||||
if (name === 'competition') {
|
||||
return {
|
||||
findOne: () => queryResult({ revision: 11 }),
|
||||
};
|
||||
}
|
||||
if (name === 'riotMatch') return { find: riotFind };
|
||||
throw new Error(`Unexpected model: ${name}`);
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
upsert: jest.fn(),
|
||||
deleteByMatch: jest.fn(),
|
||||
} as unknown as jest.Mocked<MatchStatsRepository>;
|
||||
const builder = {
|
||||
buildFragment: jest.fn(),
|
||||
} as unknown as jest.Mocked<MatchStatsFragmentBuilder>;
|
||||
const service = new MatchStatsService(
|
||||
connectionService,
|
||||
repository,
|
||||
builder,
|
||||
{ getMatchTimeline: jest.fn() } as never,
|
||||
);
|
||||
|
||||
await service.buildAndUpsert(matchId, { sourceRevision: 12 });
|
||||
|
||||
expect(riotFind).not.toHaveBeenCalled();
|
||||
expect(builder.buildFragment).not.toHaveBeenCalled();
|
||||
expect(repository.upsert).not.toHaveBeenCalled();
|
||||
expect(repository.deleteByMatch).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
function participant(
|
||||
userId: mongoose.Types.ObjectId,
|
||||
teamId: mongoose.Types.ObjectId,
|
||||
side: 'blue' | 'red',
|
||||
win: boolean,
|
||||
) {
|
||||
return {
|
||||
userId: userId.toString(),
|
||||
teamId: teamId.toString(),
|
||||
side,
|
||||
summonerName: 'player',
|
||||
tagLine: 'KR1',
|
||||
championId: 1,
|
||||
kills: 1,
|
||||
deaths: 1,
|
||||
assists: 1,
|
||||
win,
|
||||
};
|
||||
}
|
||||
|
||||
function queryResult<T>(value: T, lean = true) {
|
||||
const query = {
|
||||
lean: jest.fn(),
|
||||
exec: jest.fn().mockResolvedValue(value),
|
||||
};
|
||||
query.lean.mockReturnValue(query);
|
||||
return lean ? query : { exec: query.exec };
|
||||
}
|
||||
@@ -26,18 +26,40 @@ export class MatchStatsService {
|
||||
|
||||
public async buildAndUpsert(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
options: { includeTimeline?: boolean } = {},
|
||||
options: { includeTimeline?: boolean; sourceRevision?: number } = {},
|
||||
): Promise<void> {
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const CompetitionModel =
|
||||
await this.connectionService.getModel('competition');
|
||||
const RiotMatchModel = await this.connectionService.getModel('riotMatch');
|
||||
const match = await MatchModel.findById(matchId).exec();
|
||||
if (!match) return;
|
||||
if (!this.isEligible(match)) {
|
||||
await this.repository.deleteByMatch(matchId);
|
||||
const competition = await CompetitionModel.findOne({ matchId })
|
||||
.lean()
|
||||
.exec();
|
||||
if (
|
||||
options.sourceRevision !== undefined &&
|
||||
(!competition || competition.revision < options.sourceRevision)
|
||||
) {
|
||||
return;
|
||||
}
|
||||
const competitionSource = competition
|
||||
? competitionStatsSource(match, competition)
|
||||
: undefined;
|
||||
const sourceMatch = competitionSource?.match ?? match;
|
||||
if (!this.isEligible(sourceMatch)) {
|
||||
if (competitionSource) {
|
||||
await this.repository.deleteByMatch(matchId, {
|
||||
sourceCompetitionId: competitionSource.sourceCompetitionId,
|
||||
sourceRevision: competitionSource.sourceRevision,
|
||||
});
|
||||
} else {
|
||||
await this.repository.deleteByMatch(matchId);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
const riotIds = [
|
||||
const riotIds = competitionSource?.riotMatchIds ?? [
|
||||
...new Set(
|
||||
(match.result?.games ?? [])
|
||||
.map((game) => game.riotMatchId)
|
||||
@@ -93,7 +115,7 @@ export class MatchStatsService {
|
||||
}
|
||||
|
||||
const fragment = this.builder.buildFragment({
|
||||
match,
|
||||
match: sourceMatch,
|
||||
rawByRiotMatchId,
|
||||
timelineByRiotMatchId,
|
||||
timelineLoadAttempted: options.includeTimeline === true,
|
||||
@@ -112,7 +134,19 @@ export class MatchStatsService {
|
||||
gameDetails: fragment.gameDetails,
|
||||
builtAt: new Date(),
|
||||
builderVersion: MATCH_STATS_BUILDER_VERSION,
|
||||
...(competitionSource
|
||||
? {
|
||||
sourceCompetitionId: competitionSource.sourceCompetitionId,
|
||||
sourceRevision: competitionSource.sourceRevision,
|
||||
projectorVersion: competitionSource.projectorVersion,
|
||||
}
|
||||
: {}),
|
||||
});
|
||||
|
||||
// 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<void> {
|
||||
@@ -132,7 +166,10 @@ export class MatchStatsService {
|
||||
const matches = await 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 })
|
||||
.select({ _id: 1 })
|
||||
@@ -171,11 +208,52 @@ export class MatchStatsService {
|
||||
? (region as RiotRegionalRoute)
|
||||
: 'asia';
|
||||
}
|
||||
|
||||
private async removeFragmentIfSourceChanged(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
source:
|
||||
| {
|
||||
sourceCompetitionId: mongoose.Types.ObjectId;
|
||||
sourceRevision: number;
|
||||
}
|
||||
| undefined,
|
||||
): Promise<void> {
|
||||
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 {
|
||||
function isRiotMatchTimelineDto(value: unknown): value is RiotMatchTimelineDto {
|
||||
if (!isRecord(value) || !isRecord(value.info)) return false;
|
||||
return Array.isArray(value.info.frames);
|
||||
}
|
||||
@@ -183,3 +261,153 @@ function isRiotMatchTimelineDto(
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return typeof value === 'object' && value !== null;
|
||||
}
|
||||
|
||||
function competitionStatsSource(
|
||||
match: MatchDocument,
|
||||
competition: {
|
||||
_id: mongoose.Types.ObjectId;
|
||||
revision: number;
|
||||
projectorVersion: number;
|
||||
teams: unknown[];
|
||||
projection: Record<string, unknown>;
|
||||
},
|
||||
): {
|
||||
match: MatchDocument;
|
||||
riotMatchIds: string[];
|
||||
sourceCompetitionId: mongoose.Types.ObjectId;
|
||||
sourceRevision: number;
|
||||
projectorVersion: number;
|
||||
} {
|
||||
const teamIndexById = new Map<string, number>();
|
||||
for (const rawTeam of competition.teams) {
|
||||
if (!isRecord(rawTeam)) continue;
|
||||
const teamId = identifier(rawTeam.teamId);
|
||||
const legacyTeamIndex = finiteNumber(rawTeam.legacyTeamIndex);
|
||||
const displayOrder = finiteNumber(rawTeam.displayOrder);
|
||||
if (teamId && (legacyTeamIndex ?? displayOrder)) {
|
||||
teamIndexById.set(teamId, legacyTeamIndex ?? displayOrder!);
|
||||
}
|
||||
}
|
||||
|
||||
const rawGames = Array.isArray(competition.projection.games)
|
||||
? competition.projection.games
|
||||
: [];
|
||||
const riotMatchIds = new Set<string>();
|
||||
const games = rawGames.flatMap((rawGame, gameIndex) => {
|
||||
if (!isRecord(rawGame)) return [];
|
||||
const teams = isRecord(rawGame.teams) ? rawGame.teams : undefined;
|
||||
const blue = teams && isRecord(teams.blue) ? teams.blue : undefined;
|
||||
const red = teams && isRecord(teams.red) ? teams.red : undefined;
|
||||
const blueTeamId = identifier(blue?.teamId);
|
||||
const redTeamId = identifier(red?.teamId);
|
||||
const winnerTeamId = identifier(rawGame.winnerTeamId);
|
||||
const blueTeamIndex = blueTeamId
|
||||
? teamIndexById.get(blueTeamId)
|
||||
: undefined;
|
||||
const redTeamIndex = redTeamId ? teamIndexById.get(redTeamId) : undefined;
|
||||
const winnerTeamIndex = winnerTeamId
|
||||
? teamIndexById.get(winnerTeamId)
|
||||
: undefined;
|
||||
if (!blueTeamIndex || !redTeamIndex || !winnerTeamIndex) return [];
|
||||
|
||||
const evidence = isRecord(rawGame.evidence) ? rawGame.evidence : undefined;
|
||||
const riotMatchId =
|
||||
evidence?.type === 'riot' && typeof evidence.riotMatchId === 'string'
|
||||
? evidence.riotMatchId
|
||||
: typeof evidence?.legacyReference === 'string'
|
||||
? evidence.legacyReference
|
||||
: `competition:${identifier(rawGame.id) ?? 'game'}`;
|
||||
if (evidence?.type === 'riot') riotMatchIds.add(riotMatchId);
|
||||
const participantValues = Array.isArray(rawGame.participants)
|
||||
? rawGame.participants
|
||||
: [];
|
||||
const participants = participantValues.flatMap((rawParticipant) => {
|
||||
if (!isRecord(rawParticipant)) return [];
|
||||
const userId = identifier(rawParticipant.userId);
|
||||
const teamId = identifier(rawParticipant.teamId);
|
||||
const teamIndex = teamId ? teamIndexById.get(teamId) : undefined;
|
||||
const side = rawParticipant.side;
|
||||
if (
|
||||
!userId ||
|
||||
!mongoose.isValidObjectId(userId) ||
|
||||
!teamIndex ||
|
||||
(side !== 'blue' && side !== 'red')
|
||||
) {
|
||||
return [];
|
||||
}
|
||||
return [
|
||||
{
|
||||
userId: new mongoose.Types.ObjectId(userId),
|
||||
teamIndex,
|
||||
side,
|
||||
championId: finiteNumber(rawParticipant.championId) ?? 0,
|
||||
kills: finiteNumber(rawParticipant.kills) ?? 0,
|
||||
deaths: finiteNumber(rawParticipant.deaths) ?? 0,
|
||||
assists: finiteNumber(rawParticipant.assists) ?? 0,
|
||||
win: teamId === winnerTeamId,
|
||||
},
|
||||
];
|
||||
});
|
||||
const startedAt = dateFromUnknown(rawGame.startedAt);
|
||||
return [
|
||||
{
|
||||
gameNumber: finiteNumber(rawGame.displayNumber) ?? gameIndex + 1,
|
||||
riotMatchId,
|
||||
blueTeamIndex,
|
||||
redTeamIndex,
|
||||
winnerTeamIndex,
|
||||
winnerSide:
|
||||
winnerTeamIndex === blueTeamIndex
|
||||
? ('blue' as const)
|
||||
: ('red' as const),
|
||||
gameCreation: Number.isNaN(startedAt.getTime())
|
||||
? 0
|
||||
: startedAt.getTime(),
|
||||
gameDuration: finiteNumber(rawGame.durationSeconds) ?? 0,
|
||||
participants,
|
||||
},
|
||||
];
|
||||
});
|
||||
const base =
|
||||
typeof match.toObject === 'function' ? match.toObject() : { ...match };
|
||||
return {
|
||||
match: {
|
||||
...base,
|
||||
status:
|
||||
competition.projection.phase === 'completed'
|
||||
? 'finished'
|
||||
: games.length > 0
|
||||
? 'in-progress'
|
||||
: match.status,
|
||||
result: {
|
||||
riotMatchIds: games.map(({ riotMatchId }) => riotMatchId),
|
||||
games,
|
||||
seriesResults: [],
|
||||
},
|
||||
} as unknown as MatchDocument,
|
||||
riotMatchIds: [...riotMatchIds],
|
||||
sourceCompetitionId: competition._id,
|
||||
sourceRevision: competition.revision,
|
||||
projectorVersion: competition.projectorVersion,
|
||||
};
|
||||
}
|
||||
|
||||
function identifier(value: unknown): string | undefined {
|
||||
if (typeof value === 'string' && value.length > 0) return value;
|
||||
if (value instanceof mongoose.Types.ObjectId) return value.toHexString();
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function dateFromUnknown(value: unknown): Date {
|
||||
if (value instanceof Date) return new Date(value.getTime());
|
||||
if (typeof value === 'string' || typeof value === 'number') {
|
||||
return new Date(value);
|
||||
}
|
||||
return new Date(Number.NaN);
|
||||
}
|
||||
|
||||
function finiteNumber(value: unknown): number | undefined {
|
||||
return typeof value === 'number' && Number.isFinite(value)
|
||||
? value
|
||||
: undefined;
|
||||
}
|
||||
@@ -0,0 +1,541 @@
|
||||
import { Types } from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import {
|
||||
CompetitionBootstrapError,
|
||||
CompetitionBootstrapService,
|
||||
type CompetitionBootstrapMatch,
|
||||
} from './competition-bootstrap.service';
|
||||
|
||||
describe('CompetitionBootstrapService', () => {
|
||||
it('creates a deterministic paired-Series Competition and immutable snapshots', async () => {
|
||||
const firstHarness = createHarness();
|
||||
const firstService = new CompetitionBootstrapService(
|
||||
firstHarness.connectionService as ConnectionService,
|
||||
);
|
||||
const match = matchSnapshot({ gameMode: 'pair', teamCount: 2 });
|
||||
|
||||
const first = await firstService.bootstrap(match);
|
||||
|
||||
const inserted = firstHarness.insertedPayloads[0];
|
||||
expect(inserted).toMatchObject({
|
||||
_id: expect.any(Types.ObjectId),
|
||||
matchId: MATCH_ID,
|
||||
communityId: COMMUNITY_ID,
|
||||
schemaVersion: 1,
|
||||
projectorVersion: 1,
|
||||
revision: 0,
|
||||
phase: 'ready',
|
||||
format: {
|
||||
type: 'paired-series',
|
||||
rule: { type: 'fixed-games', gameCount: 3, drawPolicy: 'allow' },
|
||||
},
|
||||
});
|
||||
expect(inserted.teams).toEqual([
|
||||
expect.objectContaining({
|
||||
teamId: expect.any(Types.ObjectId),
|
||||
legacyTeamIndex: 1,
|
||||
displayOrder: 1,
|
||||
seedNumber: 1,
|
||||
name: 'Team 1',
|
||||
members: [
|
||||
expect.objectContaining({
|
||||
userId: USER_IDS[0],
|
||||
displayName: 'Player 1#KR1',
|
||||
gameName: 'Player 1',
|
||||
tagLine: 'KR1',
|
||||
profileIconId: 101,
|
||||
assignedPosition: 'TOP',
|
||||
cost: 10,
|
||||
}),
|
||||
],
|
||||
}),
|
||||
expect.objectContaining({
|
||||
teamId: expect.any(Types.ObjectId),
|
||||
legacyTeamIndex: 2,
|
||||
displayOrder: 2,
|
||||
seedNumber: 2,
|
||||
name: 'Team 2',
|
||||
}),
|
||||
]);
|
||||
expect(inserted.seriesGraph).toHaveLength(1);
|
||||
expect(inserted.seriesGraph[0]).toMatchObject({
|
||||
code: 'PAIR_M1',
|
||||
slots: [
|
||||
{
|
||||
position: 'A',
|
||||
source: {
|
||||
type: 'team',
|
||||
teamId: inserted.teams[0].teamId.toString(),
|
||||
},
|
||||
},
|
||||
{
|
||||
position: 'B',
|
||||
source: {
|
||||
type: 'team',
|
||||
teamId: inserted.teams[1].teamId.toString(),
|
||||
},
|
||||
},
|
||||
],
|
||||
});
|
||||
expect(inserted.projection).toMatchObject({
|
||||
competitionId: inserted._id.toString(),
|
||||
sourceRevision: 0,
|
||||
projectorVersion: 1,
|
||||
formatType: 'paired-series',
|
||||
phase: 'ready',
|
||||
});
|
||||
expect(first._id).toEqual(inserted._id);
|
||||
|
||||
const secondHarness = createHarness();
|
||||
const secondService = new CompetitionBootstrapService(
|
||||
secondHarness.connectionService as ConnectionService,
|
||||
);
|
||||
await secondService.bootstrap({
|
||||
...match,
|
||||
teams: [...match.teams].reverse(),
|
||||
participants: [...match.participants].reverse(),
|
||||
});
|
||||
|
||||
const secondInserted = secondHarness.insertedPayloads[0];
|
||||
expect(secondInserted._id).toEqual(inserted._id);
|
||||
expect(secondInserted.teams.map(({ teamId }) => teamId)).toEqual(
|
||||
inserted.teams.map(({ teamId }) => teamId),
|
||||
);
|
||||
expect(secondInserted.seriesGraph).toEqual(inserted.seriesGraph);
|
||||
});
|
||||
|
||||
it('maps round-robin configuration and preserves a limited round count', async () => {
|
||||
const harness = createHarness();
|
||||
const service = new CompetitionBootstrapService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
await service.bootstrap(
|
||||
matchSnapshot({
|
||||
gameMode: 'round-robin',
|
||||
teamCount: 4,
|
||||
gameCount: 2,
|
||||
roundRobinMaxRounds: 2,
|
||||
}),
|
||||
);
|
||||
|
||||
expect(harness.insertedPayloads[0]).toMatchObject({
|
||||
format: {
|
||||
type: 'round-robin',
|
||||
rule: { type: 'fixed-games', gameCount: 2, drawPolicy: 'allow' },
|
||||
maxRounds: 2,
|
||||
tieBreakers: ['series-wins', 'game-diff', 'head-to-head'],
|
||||
},
|
||||
});
|
||||
expect(harness.insertedPayloads[0].seriesGraph).toHaveLength(4);
|
||||
});
|
||||
|
||||
it('maps double elimination seeds and stage-specific Series rules', async () => {
|
||||
const harness = createHarness();
|
||||
const service = new CompetitionBootstrapService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
const match = matchSnapshot({
|
||||
gameMode: 'double-elimination',
|
||||
teamCount: 4,
|
||||
gameCount: 5,
|
||||
});
|
||||
match.doubleElimination = {
|
||||
teamCount: 4,
|
||||
resetFinalEnabled: true,
|
||||
seeds: [
|
||||
{ seedNumber: 1, teamIndex: 3 },
|
||||
{ seedNumber: 2, teamIndex: 1 },
|
||||
{ seedNumber: 3, teamIndex: 4 },
|
||||
{ seedNumber: 4, teamIndex: 2 },
|
||||
],
|
||||
};
|
||||
|
||||
await service.bootstrap(match);
|
||||
|
||||
const inserted = harness.insertedPayloads[0];
|
||||
expect(inserted.format).toEqual({
|
||||
type: 'double-elimination',
|
||||
teamCount: 4,
|
||||
resetFinalEnabled: true,
|
||||
rules: {
|
||||
upper: { type: 'first-to', winsRequired: 3, maxGames: 5 },
|
||||
lower: { type: 'first-to', winsRequired: 1, maxGames: 1 },
|
||||
grandFinal: { type: 'first-to', winsRequired: 1, maxGames: 1 },
|
||||
resetFinal: { type: 'first-to', winsRequired: 1, maxGames: 1 },
|
||||
},
|
||||
});
|
||||
expect(
|
||||
inserted.teams.map(({ legacyTeamIndex, seedNumber }) => ({
|
||||
legacyTeamIndex,
|
||||
seedNumber,
|
||||
})),
|
||||
).toEqual([
|
||||
{ legacyTeamIndex: 1, seedNumber: 2 },
|
||||
{ legacyTeamIndex: 2, seedNumber: 4 },
|
||||
{ legacyTeamIndex: 3, seedNumber: 1 },
|
||||
{ legacyTeamIndex: 4, seedNumber: 3 },
|
||||
]);
|
||||
expect(
|
||||
inserted.seriesGraph.find(({ code }) => code === 'WB_R1_M1').rule,
|
||||
).toEqual({ type: 'first-to', winsRequired: 3, maxGames: 5 });
|
||||
expect(
|
||||
inserted.seriesGraph.find(({ code }) => code?.startsWith('LB_')).rule,
|
||||
).toEqual({ type: 'first-to', winsRequired: 1, maxGames: 1 });
|
||||
expect(inserted.seriesGraph.find(({ code }) => code === 'GF').rule).toEqual(
|
||||
{ type: 'first-to', winsRequired: 1, maxGames: 1 },
|
||||
);
|
||||
expect(
|
||||
inserted.seriesGraph.find(({ code }) => code === 'GF_RESET'),
|
||||
).toMatchObject({
|
||||
rule: { type: 'first-to', winsRequired: 1, maxGames: 1 },
|
||||
activation: { type: 'grand-final-reset-required' },
|
||||
});
|
||||
});
|
||||
|
||||
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) => {
|
||||
match.teams[1].members = [];
|
||||
},
|
||||
],
|
||||
[
|
||||
'the same team index is repeated',
|
||||
(match) => {
|
||||
match.teams[1].teamIndex = match.teams[0].teamIndex;
|
||||
},
|
||||
],
|
||||
[
|
||||
'one member is assigned to multiple teams',
|
||||
(match) => {
|
||||
match.teams[1].members[0].userId = match.teams[0].members[0].userId;
|
||||
},
|
||||
],
|
||||
[
|
||||
'a team member has no participant snapshot',
|
||||
(match) => {
|
||||
match.teams[1].members[0].userId = new Types.ObjectId();
|
||||
},
|
||||
],
|
||||
];
|
||||
|
||||
for (const [label, mutate] of cases) {
|
||||
const harness = createHarness();
|
||||
const service = new CompetitionBootstrapService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
const match = matchSnapshot({ gameMode: 'pair', teamCount: 2 });
|
||||
mutate(match);
|
||||
|
||||
await expect(service.bootstrap(match)).rejects.toMatchObject({
|
||||
name: 'CompetitionBootstrapError',
|
||||
code: 'INVALID_MATCH_TEAM_SNAPSHOT',
|
||||
httpStatus: 422,
|
||||
});
|
||||
expect(harness.connectionService.createSession).not.toHaveBeenCalled();
|
||||
expect(harness.competitionModel.findOneAndUpdate).not.toHaveBeenCalled();
|
||||
expect(label).toBeTruthy();
|
||||
}
|
||||
});
|
||||
|
||||
it('rejects bracket mode live but explicitly maps it for legacy migration', async () => {
|
||||
const liveHarness = createHarness();
|
||||
const liveService = new CompetitionBootstrapService(
|
||||
liveHarness.connectionService as ConnectionService,
|
||||
);
|
||||
const match = matchSnapshot({ gameMode: 'bracket', teamCount: 2 });
|
||||
|
||||
await expect(liveService.bootstrap(match)).rejects.toEqual(
|
||||
expect.objectContaining<Partial<CompetitionBootstrapError>>({
|
||||
code: 'UNSUPPORTED_LIVE_MATCH_MODE',
|
||||
httpStatus: 422,
|
||||
}),
|
||||
);
|
||||
|
||||
const migrationHarness = createHarness();
|
||||
const migrationService = new CompetitionBootstrapService(
|
||||
migrationHarness.connectionService as ConnectionService,
|
||||
);
|
||||
await migrationService.bootstrap(match, { source: 'legacy-migration' });
|
||||
|
||||
expect(migrationHarness.insertedPayloads[0].format.type).toBe(
|
||||
'paired-series',
|
||||
);
|
||||
});
|
||||
|
||||
it('upserts once and links only an unlinked or already-linked Match in one transaction', async () => {
|
||||
const harness = createHarness();
|
||||
const service = new CompetitionBootstrapService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
const competition = await service.bootstrap(
|
||||
matchSnapshot({ gameMode: 'pair', teamCount: 2 }),
|
||||
);
|
||||
|
||||
expect(harness.competitionModel.findOneAndUpdate).toHaveBeenCalledWith(
|
||||
{ matchId: MATCH_ID },
|
||||
{ $setOnInsert: harness.insertedPayloads[0] },
|
||||
expect.objectContaining({
|
||||
upsert: true,
|
||||
returnDocument: 'after',
|
||||
setDefaultsOnInsert: true,
|
||||
session: harness.sessions[0],
|
||||
}),
|
||||
);
|
||||
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 },
|
||||
{ competitionId: competition._id },
|
||||
],
|
||||
},
|
||||
{ $set: { competitionId: competition._id } },
|
||||
{ session: harness.sessions[0] },
|
||||
);
|
||||
expect(harness.sessions[0].commitTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.sessions[0].abortTransaction).not.toHaveBeenCalled();
|
||||
expect(harness.sessions[0].endSession).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('reuses an existing Competition without replacing its immutable snapshot', async () => {
|
||||
const existingId = new Types.ObjectId('64b000000000000000000099');
|
||||
const existing = {
|
||||
_id: existingId,
|
||||
matchId: MATCH_ID,
|
||||
teams: [{ name: 'Original immutable team snapshot' }],
|
||||
revision: 4,
|
||||
};
|
||||
const harness = createHarness({ existingCompetition: existing });
|
||||
const service = new CompetitionBootstrapService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
const result = await service.bootstrap(
|
||||
matchSnapshot({ gameMode: 'pair', teamCount: 2 }),
|
||||
);
|
||||
|
||||
expect(result).toBe(existing);
|
||||
expect(harness.competitionModel.findOneAndUpdate.mock.calls[0][1]).toEqual({
|
||||
$setOnInsert: harness.insertedPayloads[0],
|
||||
});
|
||||
expect(harness.matchModel.updateOne.mock.calls[0][1]).toEqual({
|
||||
$set: { competitionId: existingId },
|
||||
});
|
||||
});
|
||||
|
||||
it('retries a duplicate-key bootstrap race and safely converges on the winner', async () => {
|
||||
const duplicateKey = Object.assign(new Error('duplicate key'), {
|
||||
code: 11000,
|
||||
});
|
||||
const winner = {
|
||||
_id: new Types.ObjectId('64b000000000000000000098'),
|
||||
matchId: MATCH_ID,
|
||||
revision: 0,
|
||||
};
|
||||
const harness = createHarness({
|
||||
competitionResults: [duplicateKey, winner],
|
||||
sessionCount: 2,
|
||||
});
|
||||
const service = new CompetitionBootstrapService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
const result = await service.bootstrap(
|
||||
matchSnapshot({ gameMode: 'pair', teamCount: 2 }),
|
||||
);
|
||||
|
||||
expect(result).toBe(winner);
|
||||
expect(harness.connectionService.createSession).toHaveBeenCalledTimes(2);
|
||||
expect(harness.sessions[0].abortTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.sessions[0].commitTransaction).not.toHaveBeenCalled();
|
||||
expect(harness.sessions[0].endSession).toHaveBeenCalledTimes(1);
|
||||
expect(harness.sessions[1].commitTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.matchModel.updateOne).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('aborts when the Match is already linked to a different Competition', async () => {
|
||||
const harness = createHarness({ matchUpdateResult: { matchedCount: 0 } });
|
||||
const service = new CompetitionBootstrapService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
await expect(
|
||||
service.bootstrap(matchSnapshot({ gameMode: 'pair', teamCount: 2 })),
|
||||
).rejects.toMatchObject({
|
||||
code: 'MATCH_COMPETITION_LINK_CONFLICT',
|
||||
httpStatus: 409,
|
||||
});
|
||||
expect(harness.sessions[0].abortTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.sessions[0].commitTransaction).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
const MATCH_ID = new Types.ObjectId('64b000000000000000000001');
|
||||
const COMMUNITY_ID = new Types.ObjectId('64b000000000000000000002');
|
||||
const USER_IDS = Array.from(
|
||||
{ length: 8 },
|
||||
(_, index) =>
|
||||
new Types.ObjectId(
|
||||
`64b0000000000000000001${String(index + 1).padStart(2, '0')}`,
|
||||
),
|
||||
);
|
||||
|
||||
function matchSnapshot(params: {
|
||||
gameMode: CompetitionBootstrapMatch['gameMode'];
|
||||
teamCount: number;
|
||||
gameCount?: number;
|
||||
roundRobinMaxRounds?: number;
|
||||
}): CompetitionBootstrapMatch {
|
||||
const participants = USER_IDS.slice(0, params.teamCount).map(
|
||||
(userId, index) => ({
|
||||
userId,
|
||||
gameName: `Player ${index + 1}`,
|
||||
tagLine: 'KR1',
|
||||
profileIconId: 101 + index,
|
||||
preferredPositions: [],
|
||||
joinedAt: new Date('2026-07-12T00:00:00.000Z'),
|
||||
}),
|
||||
);
|
||||
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
|
||||
? {}
|
||||
: { roundRobinMaxRounds: params.roundRobinMaxRounds }),
|
||||
participants,
|
||||
teams: participants.map((participant, index) => ({
|
||||
teamIndex: index + 1,
|
||||
name: `Team ${index + 1}`,
|
||||
captainUserId: participant.userId,
|
||||
members: [
|
||||
{
|
||||
userId: participant.userId,
|
||||
assignedPosition: 'TOP',
|
||||
cost: 10 + index,
|
||||
},
|
||||
],
|
||||
})),
|
||||
};
|
||||
}
|
||||
|
||||
interface InsertPayload {
|
||||
_id: Types.ObjectId;
|
||||
teams: Array<{
|
||||
teamId: Types.ObjectId;
|
||||
legacyTeamIndex: number;
|
||||
seedNumber: number;
|
||||
}>;
|
||||
seriesGraph: Array<{ code?: string; rule: unknown }>;
|
||||
[key: string]: any;
|
||||
}
|
||||
|
||||
function createHarness(
|
||||
options: {
|
||||
existingCompetition?: Record<string, unknown>;
|
||||
competitionResults?: Array<Record<string, unknown> | Error>;
|
||||
matchUpdateResult?: { matchedCount: number };
|
||||
sessionCount?: number;
|
||||
} = {},
|
||||
) {
|
||||
const sessions = Array.from(
|
||||
{ length: options.sessionCount ?? 1 },
|
||||
createSession,
|
||||
);
|
||||
const insertedPayloads: InsertPayload[] = [];
|
||||
let competitionCall = 0;
|
||||
const competitionModel = {
|
||||
findOneAndUpdate: jest.fn(
|
||||
(
|
||||
_filter: unknown,
|
||||
update: { $setOnInsert: InsertPayload },
|
||||
_queryOptions: unknown,
|
||||
) => {
|
||||
insertedPayloads.push(update.$setOnInsert);
|
||||
const selected = options.competitionResults?.[competitionCall++];
|
||||
if (selected instanceof Error) return rejectedQuery(selected);
|
||||
return queryResult(
|
||||
selected ?? options.existingCompetition ?? update.$setOnInsert,
|
||||
);
|
||||
},
|
||||
),
|
||||
};
|
||||
const matchModel = {
|
||||
updateOne: jest
|
||||
.fn()
|
||||
.mockResolvedValue(options.matchUpdateResult ?? { matchedCount: 1 }),
|
||||
};
|
||||
const models: Record<string, unknown> = {
|
||||
competition: competitionModel,
|
||||
match: matchModel,
|
||||
};
|
||||
let sessionIndex = 0;
|
||||
const connectionService = {
|
||||
createSession: jest.fn(() => Promise.resolve(sessions[sessionIndex++])),
|
||||
getModel: jest.fn((name: string) => Promise.resolve(models[name])),
|
||||
};
|
||||
|
||||
return {
|
||||
sessions,
|
||||
insertedPayloads,
|
||||
competitionModel,
|
||||
matchModel,
|
||||
connectionService,
|
||||
};
|
||||
}
|
||||
|
||||
function createSession() {
|
||||
return {
|
||||
startTransaction: jest.fn(),
|
||||
commitTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
abortTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
endSession: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
}
|
||||
|
||||
function queryResult<T>(value: T) {
|
||||
return { exec: jest.fn().mockResolvedValue(value) };
|
||||
}
|
||||
|
||||
function rejectedQuery(error: Error) {
|
||||
return { exec: jest.fn().mockRejectedValue(error) };
|
||||
}
|
||||
@@ -0,0 +1,639 @@
|
||||
import { createHash } from 'node:crypto';
|
||||
import { Injectable } from '@nestjs/common';
|
||||
import mongoose, { Types } from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import type {
|
||||
MatchGameMode,
|
||||
MatchParticipant,
|
||||
MatchStatus,
|
||||
MatchTeam,
|
||||
} from '../global/database/schema';
|
||||
import type {
|
||||
CompetitionDocument,
|
||||
CompetitionTeamSnapshot,
|
||||
} from './competition.schema';
|
||||
import {
|
||||
generateSeriesGraph,
|
||||
type CompetitionGraphFormat,
|
||||
type CompetitionGraphTeam,
|
||||
type SeriesDefinition,
|
||||
} from './domain/series-graph';
|
||||
import {
|
||||
projectCompetition,
|
||||
type CompetitionProjection,
|
||||
} from './domain/competition-projector';
|
||||
|
||||
const COMPETITION_SCHEMA_VERSION = 1;
|
||||
const COMPETITION_PROJECTOR_VERSION = 1;
|
||||
const BOOTSTRAP_TRANSACTION_ATTEMPTS = 3;
|
||||
|
||||
export interface CompetitionBootstrapMatch {
|
||||
_id: Types.ObjectId;
|
||||
communityId: Types.ObjectId;
|
||||
competitionId?: Types.ObjectId;
|
||||
status: MatchStatus;
|
||||
teamBuiltAt: Date;
|
||||
gameCount: number;
|
||||
gameMode: MatchGameMode;
|
||||
roundRobinMaxRounds?: number;
|
||||
participants: MatchParticipant[];
|
||||
teams: MatchTeam[];
|
||||
doubleElimination?: {
|
||||
teamCount: 4 | 8;
|
||||
resetFinalEnabled: boolean;
|
||||
seeds: Array<{ seedNumber: number; teamIndex: number }>;
|
||||
};
|
||||
}
|
||||
|
||||
export interface CompetitionBootstrapOptions {
|
||||
/** `bracket` is accepted only by the explicit legacy migration path. */
|
||||
source?: 'live' | 'legacy-migration';
|
||||
}
|
||||
|
||||
export type CompetitionBootstrapErrorCode =
|
||||
| 'INVALID_MATCH_TEAM_SNAPSHOT'
|
||||
| 'INVALID_MATCH_FORMAT'
|
||||
| 'UNSUPPORTED_LIVE_MATCH_MODE'
|
||||
| 'COMPETITION_TRANSACTION_UNAVAILABLE'
|
||||
| 'COMPETITION_BOOTSTRAP_FAILED'
|
||||
| 'COMPETITION_BOOTSTRAP_RACE'
|
||||
| 'MATCH_COMPETITION_LINK_CONFLICT';
|
||||
|
||||
export class CompetitionBootstrapError extends Error {
|
||||
constructor(
|
||||
public readonly code: CompetitionBootstrapErrorCode,
|
||||
message: string,
|
||||
public readonly httpStatus: 409 | 422 | 500,
|
||||
public readonly details?: Readonly<Record<string, unknown>>,
|
||||
) {
|
||||
super(message);
|
||||
this.name = 'CompetitionBootstrapError';
|
||||
}
|
||||
}
|
||||
|
||||
interface CompetitionInsertPayload {
|
||||
_id: Types.ObjectId;
|
||||
matchId: Types.ObjectId;
|
||||
communityId: Types.ObjectId;
|
||||
schemaVersion: number;
|
||||
projectorVersion: number;
|
||||
revision: number;
|
||||
phase: CompetitionProjection['phase'];
|
||||
teams: CompetitionTeamSnapshot[];
|
||||
format: CompetitionGraphFormat;
|
||||
seriesGraph: SeriesDefinition[];
|
||||
projection: CompetitionProjection;
|
||||
}
|
||||
|
||||
/**
|
||||
* Freezes the recruiting Match into the one-to-one Competition aggregate.
|
||||
* Retries only repeat deterministic upserts, so duplicate creators and unknown
|
||||
* commit outcomes converge without replacing an existing immutable snapshot.
|
||||
*/
|
||||
@Injectable()
|
||||
export class CompetitionBootstrapService {
|
||||
constructor(private readonly connectionService: ConnectionService) {}
|
||||
|
||||
public async bootstrap(
|
||||
match: CompetitionBootstrapMatch,
|
||||
options: CompetitionBootstrapOptions = {},
|
||||
): Promise<CompetitionDocument> {
|
||||
const payload = buildCompetitionInsertPayload(
|
||||
match,
|
||||
options.source ?? 'live',
|
||||
);
|
||||
const [CompetitionModel, MatchModel] = await Promise.all([
|
||||
this.connectionService.getModel('competition'),
|
||||
this.connectionService.getModel('match'),
|
||||
]);
|
||||
|
||||
let lastRetryableError: unknown;
|
||||
for (
|
||||
let attempt = 1;
|
||||
attempt <= BOOTSTRAP_TRANSACTION_ATTEMPTS;
|
||||
attempt += 1
|
||||
) {
|
||||
const session = await this.connectionService.createSession();
|
||||
if (!session) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'COMPETITION_TRANSACTION_UNAVAILABLE',
|
||||
'A MongoDB transaction is required to bootstrap a Competition.',
|
||||
500,
|
||||
);
|
||||
}
|
||||
|
||||
try {
|
||||
session.startTransaction();
|
||||
const competition = await CompetitionModel.findOneAndUpdate(
|
||||
{ matchId: match._id },
|
||||
{ $setOnInsert: payload },
|
||||
{
|
||||
upsert: true,
|
||||
returnDocument: 'after',
|
||||
setDefaultsOnInsert: true,
|
||||
session,
|
||||
},
|
||||
).exec();
|
||||
if (!competition) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'COMPETITION_BOOTSTRAP_FAILED',
|
||||
'Competition upsert returned no document.',
|
||||
500,
|
||||
);
|
||||
}
|
||||
|
||||
const linkResult = await MatchModel.updateOne(
|
||||
{
|
||||
_id: match._id,
|
||||
status: match.status,
|
||||
teamBuiltAt: match.teamBuiltAt,
|
||||
$or: [
|
||||
{ competitionId: { $exists: false } },
|
||||
{ competitionId: null },
|
||||
{ competitionId: competition._id },
|
||||
],
|
||||
},
|
||||
{ $set: { competitionId: competition._id } },
|
||||
{ session },
|
||||
);
|
||||
if (linkResult.matchedCount !== 1) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'MATCH_COMPETITION_LINK_CONFLICT',
|
||||
'Match is missing or linked to a different Competition.',
|
||||
409,
|
||||
{ matchId: match._id.toString() },
|
||||
);
|
||||
}
|
||||
|
||||
await session.commitTransaction();
|
||||
return competition;
|
||||
} catch (error) {
|
||||
await session.abortTransaction().catch(() => undefined);
|
||||
if (
|
||||
attempt < BOOTSTRAP_TRANSACTION_ATTEMPTS &&
|
||||
isRetryableBootstrapError(error)
|
||||
) {
|
||||
lastRetryableError = error;
|
||||
continue;
|
||||
}
|
||||
if (isRetryableBootstrapError(error)) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'COMPETITION_BOOTSTRAP_RACE',
|
||||
'Competition bootstrap did not converge after concurrent writes.',
|
||||
409,
|
||||
{ matchId: match._id.toString() },
|
||||
);
|
||||
}
|
||||
throw error;
|
||||
} finally {
|
||||
await session.endSession().catch(() => undefined);
|
||||
}
|
||||
}
|
||||
|
||||
throw new CompetitionBootstrapError(
|
||||
'COMPETITION_BOOTSTRAP_RACE',
|
||||
'Competition bootstrap retry budget was exhausted.',
|
||||
409,
|
||||
{
|
||||
matchId: match._id.toString(),
|
||||
cause:
|
||||
lastRetryableError instanceof Error
|
||||
? lastRetryableError.message
|
||||
: String(lastRetryableError),
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function buildCompetitionInsertPayload(
|
||||
match: CompetitionBootstrapMatch,
|
||||
source: NonNullable<CompetitionBootstrapOptions['source']>,
|
||||
): 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');
|
||||
const teams = snapshotTeams(match, competitionId);
|
||||
const graphTeams = teams.map(
|
||||
({ teamId, displayOrder, seedNumber }): CompetitionGraphTeam => ({
|
||||
teamId: teamId.toString(),
|
||||
displayOrder,
|
||||
seedNumber,
|
||||
}),
|
||||
);
|
||||
const format = mapMatchFormat(match, teams, source);
|
||||
|
||||
let seriesGraph: SeriesDefinition[];
|
||||
let projection: CompetitionProjection;
|
||||
try {
|
||||
seriesGraph = generateSeriesGraph({
|
||||
competitionId: competitionId.toString(),
|
||||
teams: graphTeams,
|
||||
format,
|
||||
});
|
||||
projection = projectCompetition({
|
||||
competitionId: competitionId.toString(),
|
||||
revision: 0,
|
||||
projectorVersion: COMPETITION_PROJECTOR_VERSION,
|
||||
teams: graphTeams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts: [],
|
||||
});
|
||||
} catch (error) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'INVALID_MATCH_FORMAT',
|
||||
error instanceof Error
|
||||
? error.message
|
||||
: 'The Match cannot produce a valid Competition graph.',
|
||||
422,
|
||||
{
|
||||
matchId: match._id.toString(),
|
||||
domainCode: readErrorCode(error),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
return {
|
||||
_id: competitionId,
|
||||
matchId: match._id,
|
||||
communityId: match.communityId,
|
||||
schemaVersion: COMPETITION_SCHEMA_VERSION,
|
||||
projectorVersion: COMPETITION_PROJECTOR_VERSION,
|
||||
revision: 0,
|
||||
phase: projection.phase,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
projection,
|
||||
};
|
||||
}
|
||||
|
||||
function snapshotTeams(
|
||||
match: CompetitionBootstrapMatch,
|
||||
competitionId: Types.ObjectId,
|
||||
): CompetitionTeamSnapshot[] {
|
||||
if (!Array.isArray(match.teams) || match.teams.length < 2) {
|
||||
throw invalidTeamSnapshot(
|
||||
'A Competition requires at least two built teams.',
|
||||
);
|
||||
}
|
||||
if (!Array.isArray(match.participants)) {
|
||||
throw invalidTeamSnapshot('Match participants are missing.');
|
||||
}
|
||||
|
||||
const participantById = new Map<string, MatchParticipant>();
|
||||
for (const participant of match.participants) {
|
||||
const userId = objectIdString(participant?.userId);
|
||||
if (!userId || participantById.has(userId)) {
|
||||
throw invalidTeamSnapshot(
|
||||
'Match participants must have unique ObjectId user identities.',
|
||||
);
|
||||
}
|
||||
participantById.set(userId, participant);
|
||||
}
|
||||
|
||||
const orderedTeams = [...match.teams].sort(
|
||||
(left, right) => left.teamIndex - right.teamIndex,
|
||||
);
|
||||
const teamIndexes = new Set<number>();
|
||||
const assignedUserIds = new Set<string>();
|
||||
const memberCounts = new Set<number>();
|
||||
const snapshots: CompetitionTeamSnapshot[] = [];
|
||||
|
||||
for (const [displayIndex, team] of orderedTeams.entries()) {
|
||||
if (
|
||||
!Number.isInteger(team.teamIndex) ||
|
||||
team.teamIndex < 1 ||
|
||||
teamIndexes.has(team.teamIndex)
|
||||
) {
|
||||
throw invalidTeamSnapshot(
|
||||
'Built teams must have unique positive integer team indexes.',
|
||||
);
|
||||
}
|
||||
teamIndexes.add(team.teamIndex);
|
||||
if (typeof team.name !== 'string' || team.name.trim().length === 0) {
|
||||
throw invalidTeamSnapshot('Every built team needs a non-empty name.');
|
||||
}
|
||||
if (!Array.isArray(team.members) || team.members.length === 0) {
|
||||
throw invalidTeamSnapshot('Every built team needs at least one member.');
|
||||
}
|
||||
memberCounts.add(team.members.length);
|
||||
|
||||
const memberSnapshots = [...team.members]
|
||||
.sort(compareTeamMembers)
|
||||
.map((member) => {
|
||||
const userId = objectIdString(member.userId);
|
||||
const participant = userId ? participantById.get(userId) : undefined;
|
||||
if (
|
||||
!userId ||
|
||||
!participant ||
|
||||
participant.excluded === true ||
|
||||
assignedUserIds.has(userId)
|
||||
) {
|
||||
throw invalidTeamSnapshot(
|
||||
'Every non-excluded participant must be assigned to exactly one team.',
|
||||
);
|
||||
}
|
||||
assignedUserIds.add(userId);
|
||||
|
||||
const gameName = nonEmptyString(participant.gameName);
|
||||
const tagLine = nonEmptyString(participant.tagLine);
|
||||
return {
|
||||
userId: member.userId,
|
||||
displayName: gameName
|
||||
? tagLine
|
||||
? `${gameName}#${tagLine}`
|
||||
: gameName
|
||||
: userId,
|
||||
...(gameName ? { gameName } : {}),
|
||||
...(tagLine ? { tagLine } : {}),
|
||||
...(participant.profileIconId === undefined
|
||||
? {}
|
||||
: { profileIconId: participant.profileIconId }),
|
||||
assignedPosition: member.assignedPosition,
|
||||
...(member.cost === undefined ? {} : { cost: member.cost }),
|
||||
};
|
||||
});
|
||||
|
||||
if (team.captainUserId) {
|
||||
const captainUserId = team.captainUserId.toString();
|
||||
if (
|
||||
!memberSnapshots.some(
|
||||
({ userId }) => userId.toString() === captainUserId,
|
||||
)
|
||||
) {
|
||||
throw invalidTeamSnapshot('A team captain must belong to that team.');
|
||||
}
|
||||
}
|
||||
|
||||
snapshots.push({
|
||||
teamId: stableObjectId(
|
||||
competitionId,
|
||||
'team',
|
||||
`legacy-team-index:${team.teamIndex}`,
|
||||
),
|
||||
legacyTeamIndex: team.teamIndex,
|
||||
displayOrder: displayIndex + 1,
|
||||
seedNumber: displayIndex + 1,
|
||||
name: team.name.trim(),
|
||||
...(team.captainUserId ? { captainUserId: team.captainUserId } : {}),
|
||||
members: memberSnapshots,
|
||||
});
|
||||
}
|
||||
|
||||
if (memberCounts.size !== 1) {
|
||||
throw invalidTeamSnapshot(
|
||||
'All built teams must have the same member count.',
|
||||
);
|
||||
}
|
||||
const activeParticipantIds = [...participantById]
|
||||
.filter(([, participant]) => participant.excluded !== true)
|
||||
.map(([userId]) => userId);
|
||||
if (
|
||||
activeParticipantIds.length !== assignedUserIds.size ||
|
||||
activeParticipantIds.some((userId) => !assignedUserIds.has(userId))
|
||||
) {
|
||||
throw invalidTeamSnapshot(
|
||||
'Every non-excluded participant must be assigned to exactly one team.',
|
||||
);
|
||||
}
|
||||
|
||||
applySeeds(match, snapshots);
|
||||
return snapshots;
|
||||
}
|
||||
|
||||
function applySeeds(
|
||||
match: CompetitionBootstrapMatch,
|
||||
teams: CompetitionTeamSnapshot[],
|
||||
): void {
|
||||
if (match.gameMode !== 'double-elimination') return;
|
||||
const configuredSeeds = match.doubleElimination?.seeds ?? [];
|
||||
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.',
|
||||
);
|
||||
}
|
||||
|
||||
const validTeamIndexes = new Set(
|
||||
teams.map(({ legacyTeamIndex }) => legacyTeamIndex as number),
|
||||
);
|
||||
const seedByTeamIndex = new Map<number, number>();
|
||||
const seedNumbers = new Set<number>();
|
||||
for (const seed of configuredSeeds) {
|
||||
if (
|
||||
!Number.isInteger(seed.seedNumber) ||
|
||||
seed.seedNumber < 1 ||
|
||||
seed.seedNumber > teams.length ||
|
||||
seedNumbers.has(seed.seedNumber) ||
|
||||
!validTeamIndexes.has(seed.teamIndex) ||
|
||||
seedByTeamIndex.has(seed.teamIndex)
|
||||
) {
|
||||
throw invalidTeamSnapshot(
|
||||
'Double-elimination seeds must be unique and contiguous.',
|
||||
);
|
||||
}
|
||||
seedNumbers.add(seed.seedNumber);
|
||||
seedByTeamIndex.set(seed.teamIndex, seed.seedNumber);
|
||||
}
|
||||
for (const team of teams) {
|
||||
team.seedNumber = seedByTeamIndex.get(team.legacyTeamIndex as number)!;
|
||||
}
|
||||
}
|
||||
|
||||
function mapMatchFormat(
|
||||
match: CompetitionBootstrapMatch,
|
||||
teams: CompetitionTeamSnapshot[],
|
||||
source: NonNullable<CompetitionBootstrapOptions['source']>,
|
||||
): CompetitionGraphFormat {
|
||||
switch (match.gameMode) {
|
||||
case 'pair':
|
||||
return fixedGameFormat('paired-series', match.gameCount);
|
||||
case 'bracket':
|
||||
if (source !== 'legacy-migration') {
|
||||
throw new CompetitionBootstrapError(
|
||||
'UNSUPPORTED_LIVE_MATCH_MODE',
|
||||
'Legacy bracket mode can only be bootstrapped by migration.',
|
||||
422,
|
||||
);
|
||||
}
|
||||
return fixedGameFormat('paired-series', match.gameCount);
|
||||
case 'round-robin':
|
||||
if (
|
||||
match.roundRobinMaxRounds !== undefined &&
|
||||
(!Number.isInteger(match.roundRobinMaxRounds) ||
|
||||
match.roundRobinMaxRounds < 1)
|
||||
) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'INVALID_MATCH_FORMAT',
|
||||
'Round-robin max rounds must be a positive integer.',
|
||||
422,
|
||||
);
|
||||
}
|
||||
return {
|
||||
type: 'round-robin',
|
||||
rule: fixedGamesRule(match.gameCount),
|
||||
...(match.roundRobinMaxRounds === undefined
|
||||
? {}
|
||||
: { maxRounds: match.roundRobinMaxRounds }),
|
||||
tieBreakers: ['series-wins', 'game-diff', 'head-to-head'],
|
||||
};
|
||||
case 'double-elimination': {
|
||||
if (teams.length !== 4 && teams.length !== 8) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'INVALID_MATCH_FORMAT',
|
||||
'Double elimination supports only four or eight teams.',
|
||||
422,
|
||||
);
|
||||
}
|
||||
if (
|
||||
match.doubleElimination?.teamCount !== undefined &&
|
||||
match.doubleElimination.teamCount !== teams.length
|
||||
) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'INVALID_MATCH_FORMAT',
|
||||
'Double-elimination team count does not match the built teams.',
|
||||
422,
|
||||
);
|
||||
}
|
||||
const bestOfOne = {
|
||||
type: 'first-to' as const,
|
||||
winsRequired: 1,
|
||||
maxGames: 1,
|
||||
};
|
||||
return {
|
||||
type: 'double-elimination',
|
||||
teamCount: teams.length,
|
||||
resetFinalEnabled: match.doubleElimination?.resetFinalEnabled ?? false,
|
||||
rules: {
|
||||
upper: {
|
||||
type: 'first-to',
|
||||
winsRequired: Math.floor(match.gameCount / 2) + 1,
|
||||
maxGames: match.gameCount,
|
||||
},
|
||||
lower: { ...bestOfOne },
|
||||
grandFinal: { ...bestOfOne },
|
||||
resetFinal: { ...bestOfOne },
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function fixedGameFormat(
|
||||
type: 'paired-series',
|
||||
gameCount: number,
|
||||
): Extract<CompetitionGraphFormat, { type: 'paired-series' }> {
|
||||
return { type, rule: fixedGamesRule(gameCount) };
|
||||
}
|
||||
|
||||
function fixedGamesRule(gameCount: number) {
|
||||
return {
|
||||
type: 'fixed-games' as const,
|
||||
gameCount,
|
||||
drawPolicy: 'allow' as const,
|
||||
};
|
||||
}
|
||||
|
||||
function stableObjectId(
|
||||
namespaceId: Types.ObjectId,
|
||||
entityKind: string,
|
||||
...logicalKey: string[]
|
||||
): Types.ObjectId {
|
||||
const hex = createHash('sha256')
|
||||
.update(JSON.stringify([namespaceId.toString(), entityKind, ...logicalKey]))
|
||||
.digest('hex')
|
||||
.slice(0, 24);
|
||||
return new Types.ObjectId(hex);
|
||||
}
|
||||
|
||||
function compareTeamMembers(
|
||||
left: MatchTeam['members'][number],
|
||||
right: MatchTeam['members'][number],
|
||||
): number {
|
||||
const positionOrder = ['TOP', 'JGL', 'MID', 'ADC', 'SUP'];
|
||||
return (
|
||||
positionOrder.indexOf(left.assignedPosition) -
|
||||
positionOrder.indexOf(right.assignedPosition) ||
|
||||
left.userId.toString().localeCompare(right.userId.toString())
|
||||
);
|
||||
}
|
||||
|
||||
function invalidTeamSnapshot(message: string): CompetitionBootstrapError {
|
||||
return new CompetitionBootstrapError(
|
||||
'INVALID_MATCH_TEAM_SNAPSHOT',
|
||||
message,
|
||||
422,
|
||||
);
|
||||
}
|
||||
|
||||
function assertPositiveInteger(value: number, label: string): void {
|
||||
if (!Number.isInteger(value) || value < 1) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'INVALID_MATCH_FORMAT',
|
||||
`${label} must be a positive integer.`,
|
||||
422,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function assertObjectId(
|
||||
value: unknown,
|
||||
label: string,
|
||||
): asserts value is Types.ObjectId {
|
||||
if (!(value instanceof mongoose.Types.ObjectId)) {
|
||||
throw invalidTeamSnapshot(`${label} must be a MongoDB ObjectId.`);
|
||||
}
|
||||
}
|
||||
|
||||
function objectIdString(value: unknown): string | undefined {
|
||||
return value instanceof mongoose.Types.ObjectId
|
||||
? value.toString()
|
||||
: undefined;
|
||||
}
|
||||
|
||||
function nonEmptyString(value: unknown): string | undefined {
|
||||
if (typeof value !== 'string') return undefined;
|
||||
const trimmed = value.trim();
|
||||
return trimmed.length > 0 ? trimmed : undefined;
|
||||
}
|
||||
|
||||
function readErrorCode(error: unknown): string | undefined {
|
||||
if (
|
||||
typeof error === 'object' &&
|
||||
error !== null &&
|
||||
'code' in error &&
|
||||
typeof error.code === 'string'
|
||||
) {
|
||||
return error.code;
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function isRetryableBootstrapError(error: unknown): boolean {
|
||||
const candidate = error as {
|
||||
code?: number;
|
||||
codeName?: string;
|
||||
hasErrorLabel?: (label: string) => boolean;
|
||||
};
|
||||
return Boolean(
|
||||
candidate?.code === 11000 ||
|
||||
candidate?.code === 112 ||
|
||||
candidate?.codeName === 'WriteConflict' ||
|
||||
candidate?.hasErrorLabel?.('TransientTransactionError') ||
|
||||
candidate?.hasErrorLabel?.('UnknownTransactionCommitResult'),
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,784 @@
|
||||
import { Types } from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import { CompetitionCommandService } from './competition-command.service';
|
||||
import { projectCompetition } from './domain/competition-projector';
|
||||
|
||||
jest.mock('./domain/competition-projector', () => ({
|
||||
projectCompetition: jest.fn(),
|
||||
}));
|
||||
|
||||
const mockedProjectCompetition = jest.mocked(projectCompetition);
|
||||
|
||||
describe('CompetitionCommandService', () => {
|
||||
beforeEach(() => {
|
||||
jest.useFakeTimers().setSystemTime(new Date('2026-07-12T10:00:00.000Z'));
|
||||
mockedProjectCompetition.mockReset();
|
||||
mockedProjectCompetition.mockReturnValue(PROJECTION as never);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
jest.useRealTimers();
|
||||
});
|
||||
|
||||
it('rejects a stale expected revision and aborts without writing', async () => {
|
||||
const harness = createHarness({ competitionRevision: 8 });
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
await expect(service.acceptGame(acceptGameCommand())).rejects.toMatchObject(
|
||||
{
|
||||
code: 'STALE_COMPETITION_REVISION',
|
||||
httpStatus: 412,
|
||||
details: { expectedRevision: 7, actualRevision: 8 },
|
||||
},
|
||||
);
|
||||
|
||||
expect(harness.factModel.insertMany).not.toHaveBeenCalled();
|
||||
expect(harness.competitionModel.findOneAndUpdate).not.toHaveBeenCalled();
|
||||
expect(harness.outboxModel.insertMany).not.toHaveBeenCalled();
|
||||
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.session.commitTransaction).not.toHaveBeenCalled();
|
||||
expect(harness.session.endSession).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('uses the expected revision in the persistence CAS and aborts a lost race', async () => {
|
||||
const harness = createHarness({ casResult: null });
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
await expect(service.acceptGame(acceptGameCommand())).rejects.toMatchObject(
|
||||
{
|
||||
code: 'STALE_COMPETITION_REVISION',
|
||||
httpStatus: 412,
|
||||
},
|
||||
);
|
||||
|
||||
const [casFilter, casUpdate, casOptions] = harness.competitionModel
|
||||
.findOneAndUpdate.mock.calls[0] as unknown as [
|
||||
Record<string, unknown>,
|
||||
{ $inc: Record<string, unknown>; $set: Record<string, unknown> },
|
||||
Record<string, unknown>,
|
||||
];
|
||||
expect(casFilter).toEqual({ _id: COMPETITION_ID, revision: 7 });
|
||||
expect(casUpdate).toMatchObject({
|
||||
$inc: { revision: 1 },
|
||||
$set: { projection: PROJECTION },
|
||||
});
|
||||
expect(casOptions).toMatchObject({ new: true, session: harness.session });
|
||||
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.session.commitTransaction).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('replays an exact Idempotency-Key request without appending a second fact', async () => {
|
||||
const harness = createHarness();
|
||||
let storedReceipt: Record<string, unknown> | null = null;
|
||||
harness.outboxModel.findOne.mockImplementation(() =>
|
||||
queryResult(storedReceipt),
|
||||
);
|
||||
harness.outboxModel.insertMany.mockImplementation(
|
||||
([receipt]: Array<Record<string, unknown>>) => {
|
||||
storedReceipt = receipt;
|
||||
return Promise.resolve([receipt]);
|
||||
},
|
||||
);
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
const command = acceptGameCommand();
|
||||
|
||||
const first = await service.acceptGame(command);
|
||||
const replay = await service.acceptGame(command);
|
||||
|
||||
expect(first).toMatchObject({ revision: 8, replayed: false });
|
||||
expect(replay).toMatchObject({
|
||||
commandId: first.commandId,
|
||||
revision: 8,
|
||||
replayed: true,
|
||||
});
|
||||
expect(replay.competition).toEqual(first.competition);
|
||||
expect(harness.factModel.insertMany).toHaveBeenCalledTimes(1);
|
||||
expect(harness.competitionModel.findOneAndUpdate).toHaveBeenCalledTimes(1);
|
||||
expect(harness.outboxModel.insertMany).toHaveBeenCalledTimes(1);
|
||||
expect(mockedProjectCompetition).toHaveBeenCalledTimes(1);
|
||||
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(2);
|
||||
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<string, unknown> | null = null;
|
||||
harness.outboxModel.findOne.mockImplementation(() =>
|
||||
queryResult(committedReceipt),
|
||||
);
|
||||
harness.factModel.insertMany.mockImplementationOnce(
|
||||
async ([fact]: Array<Record<string, unknown>>) => {
|
||||
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(
|
||||
queryResult({
|
||||
idempotencyKey: 'riot:KR_7000000001',
|
||||
requestHash: 'a-different-payload-hash',
|
||||
commandId: 'cmpcmd_original',
|
||||
revision: 8,
|
||||
}),
|
||||
);
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
await expect(service.acceptGame(acceptGameCommand())).rejects.toMatchObject(
|
||||
{
|
||||
code: 'IDEMPOTENCY_KEY_CONFLICT',
|
||||
httpStatus: 409,
|
||||
},
|
||||
);
|
||||
|
||||
expect(harness.competitionModel.findById).not.toHaveBeenCalled();
|
||||
expect(harness.factModel.insertMany).not.toHaveBeenCalled();
|
||||
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('atomically accepts a code-backed game, projects it, and enqueues an event', async () => {
|
||||
const harness = createHarness();
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
const command = {
|
||||
...acceptGameCommand(),
|
||||
tournamentCode: {
|
||||
tournamentCodeId: TOURNAMENT_CODE_ID,
|
||||
riotMatchId: 'KR_7000000001',
|
||||
},
|
||||
};
|
||||
|
||||
const result = await service.acceptGame(command);
|
||||
|
||||
expect(result).toMatchObject({ revision: 8, replayed: false });
|
||||
expect(harness.session.startTransaction).toHaveBeenCalledTimes(1);
|
||||
const [insertedFacts, factOptions] = harness.factModel.insertMany.mock
|
||||
.calls[0] as unknown as [
|
||||
Array<Record<string, unknown>>,
|
||||
Record<string, unknown>,
|
||||
];
|
||||
expect(insertedFacts).toHaveLength(1);
|
||||
expect(insertedFacts[0]).toMatchObject({
|
||||
type: 'game-accepted',
|
||||
revision: 8,
|
||||
ordinalWithinRevision: 1,
|
||||
gameId: GAME_ID,
|
||||
seriesId: SERIES_ID,
|
||||
gameSlotId: GAME_SLOT_ID,
|
||||
startedAt: new Date('2026-07-12T09:30:00.000Z'),
|
||||
durationSeconds: 1_800,
|
||||
participants: [
|
||||
{
|
||||
userId: USER_ID.toHexString(),
|
||||
teamId: TEAM_A_ID.toHexString(),
|
||||
side: 'blue',
|
||||
},
|
||||
],
|
||||
});
|
||||
expect(factOptions).toEqual({ session: harness.session });
|
||||
|
||||
const projectionInput = mockedProjectCompetition.mock.calls[0][0];
|
||||
const projectedFact = projectionInput.facts[0] as Record<string, unknown>;
|
||||
const projectedMapping = projectedFact.mapping as Record<string, unknown>;
|
||||
expect(projectionInput.competitionId).toBe(COMPETITION_ID.toHexString());
|
||||
expect(projectionInput.revision).toBe(8);
|
||||
expect(typeof projectedFact.id).toBe('string');
|
||||
expect(projectedFact).toMatchObject({
|
||||
type: 'game-accepted',
|
||||
seriesId: SERIES_ID.toHexString(),
|
||||
});
|
||||
expect(projectedMapping.winnerTeamId).toBe(TEAM_A_ID.toHexString());
|
||||
|
||||
const [assignmentFilter, assignmentUpdate, assignmentOptions] = harness
|
||||
.assignmentModel.updateOne.mock.calls[0] as unknown as [
|
||||
Record<string, unknown>,
|
||||
{ $set: Record<string, unknown> },
|
||||
Record<string, unknown>,
|
||||
];
|
||||
expect(assignmentFilter).toMatchObject({
|
||||
competitionId: COMPETITION_ID,
|
||||
gameSlotId: GAME_SLOT_ID,
|
||||
tournamentCodeId: TOURNAMENT_CODE_ID,
|
||||
state: 'reserved',
|
||||
});
|
||||
expect(assignmentUpdate.$set.state).toBe('used');
|
||||
expect(assignmentOptions).toEqual({ session: harness.session });
|
||||
|
||||
const [codeFilter, codeUpdate, codeOptions] = harness.tournamentCodeModel
|
||||
.updateOne.mock.calls[0] as unknown as [
|
||||
Record<string, unknown>,
|
||||
{ $set: Record<string, unknown> },
|
||||
Record<string, unknown>,
|
||||
];
|
||||
expect(codeFilter).toEqual({
|
||||
_id: TOURNAMENT_CODE_ID,
|
||||
state: 'reserved',
|
||||
});
|
||||
expect(codeUpdate.$set.state).toBe('used');
|
||||
expect(codeOptions).toEqual({ session: harness.session });
|
||||
|
||||
const [outboxRecords, outboxOptions] = harness.outboxModel.insertMany.mock
|
||||
.calls[0] as unknown as [
|
||||
Array<Record<string, unknown>>,
|
||||
Record<string, unknown>,
|
||||
];
|
||||
expect(outboxRecords).toHaveLength(1);
|
||||
expect(outboxRecords[0]).toMatchObject({
|
||||
revision: 8,
|
||||
type: 'competition.projection-updated',
|
||||
state: 'pending',
|
||||
payload: { projection: PROJECTION },
|
||||
});
|
||||
expect(outboxOptions).toEqual({ session: harness.session });
|
||||
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.session.abortTransaction).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('appends an administrative adjudication through the same command runner', async () => {
|
||||
const harness = createHarness();
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
const result = await service.adjudicateSeries({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
idempotencyKey: 'admin:series:walkover:1',
|
||||
actor: { type: 'user', userId: USER_ID },
|
||||
seriesId: SERIES_ID,
|
||||
decision: { type: 'walkover', winnerTeamId: TEAM_B_ID },
|
||||
reason: 'Opponent did not appear before the deadline.',
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({ revision: 8, replayed: false });
|
||||
expect(harness.factModel.insertMany).toHaveBeenCalledWith(
|
||||
[
|
||||
expect.objectContaining({
|
||||
type: 'series-adjudicated',
|
||||
seriesId: SERIES_ID,
|
||||
decision: { type: 'walkover', winnerTeamId: TEAM_B_ID },
|
||||
reason: 'Opponent did not appear before the deadline.',
|
||||
}),
|
||||
],
|
||||
{ session: harness.session },
|
||||
);
|
||||
expect(harness.assignmentModel.updateOne).not.toHaveBeenCalled();
|
||||
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('previews a strict or cascade reversal against the requested revision', async () => {
|
||||
const reversal = reversalFixture();
|
||||
const harness = createHarness({
|
||||
competition: reversal.competition,
|
||||
facts: reversal.facts,
|
||||
assignments: reversal.assignments,
|
||||
});
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
const preview = await service.previewSeriesReversal({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
seriesId: reversal.parentSeriesId,
|
||||
mode: 'cascade',
|
||||
});
|
||||
|
||||
expect(preview).toMatchObject({
|
||||
sourceRevision: 7,
|
||||
impactHash: expect.stringMatching(/^[a-f0-9]{64}$/),
|
||||
impact: {
|
||||
seriesIds: [
|
||||
reversal.parentSeriesId.toHexString(),
|
||||
reversal.childSeriesId.toHexString(),
|
||||
],
|
||||
factIds: [
|
||||
reversal.parentFactId.toHexString(),
|
||||
reversal.childFactId.toHexString(),
|
||||
],
|
||||
releasesReservedCodes: 1,
|
||||
voidsUsedCodes: 1,
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it('rejects a reversal preview at a stale revision', async () => {
|
||||
const reversal = reversalFixture();
|
||||
const harness = createHarness({ competition: reversal.competition });
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
await expect(
|
||||
service.previewSeriesReversal({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 6,
|
||||
seriesId: reversal.parentSeriesId,
|
||||
mode: 'strict',
|
||||
}),
|
||||
).rejects.toMatchObject({
|
||||
code: 'STALE_COMPETITION_REVISION',
|
||||
httpStatus: 412,
|
||||
});
|
||||
});
|
||||
|
||||
it('hash-confirms and atomically appends cascade reversal facts', async () => {
|
||||
const reversal = reversalFixture();
|
||||
const harness = createHarness({
|
||||
competition: reversal.competition,
|
||||
facts: reversal.facts,
|
||||
assignments: reversal.assignments,
|
||||
});
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
const preview = await service.previewSeriesReversal({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
seriesId: reversal.parentSeriesId,
|
||||
mode: 'cascade',
|
||||
});
|
||||
|
||||
const result = await service.reverseSeries({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
idempotencyKey: 'admin:reverse:1',
|
||||
actor: { type: 'user', userId: USER_ID },
|
||||
seriesId: reversal.parentSeriesId,
|
||||
mode: 'cascade',
|
||||
reason: 'Wrong result ingestion',
|
||||
impactHash: preview.impactHash,
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({ revision: 8, replayed: false });
|
||||
expect(harness.factModel.insertMany).toHaveBeenCalledWith(
|
||||
[
|
||||
expect.objectContaining({
|
||||
_id: expect.any(Types.ObjectId),
|
||||
type: 'game-voided',
|
||||
gameAcceptedFactId: reversal.parentFactId,
|
||||
revision: 8,
|
||||
ordinalWithinRevision: 1,
|
||||
reason: 'Wrong result ingestion',
|
||||
}),
|
||||
expect.objectContaining({
|
||||
_id: expect.any(Types.ObjectId),
|
||||
type: 'game-voided',
|
||||
gameAcceptedFactId: reversal.childFactId,
|
||||
revision: 8,
|
||||
ordinalWithinRevision: 2,
|
||||
}),
|
||||
],
|
||||
{ session: harness.session },
|
||||
);
|
||||
expect(harness.assignmentModel.updateMany).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
competitionId: COMPETITION_ID,
|
||||
gameSlotId: {
|
||||
$in: expect.arrayContaining([
|
||||
reversal.parentGameSlotId,
|
||||
reversal.childGameSlotId,
|
||||
]),
|
||||
},
|
||||
}),
|
||||
expect.any(Array),
|
||||
{ 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<string, unknown>,
|
||||
Array<Record<string, any>>,
|
||||
];
|
||||
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 } }),
|
||||
expect.objectContaining({ session: harness.session }),
|
||||
);
|
||||
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');
|
||||
const SERIES_ID = new Types.ObjectId('64b000000000000000000002');
|
||||
const GAME_SLOT_ID = new Types.ObjectId('64b000000000000000000003');
|
||||
const GAME_ID = new Types.ObjectId('64b000000000000000000004');
|
||||
const TEAM_A_ID = new Types.ObjectId('64b000000000000000000005');
|
||||
const TEAM_B_ID = new Types.ObjectId('64b000000000000000000006');
|
||||
const USER_ID = new Types.ObjectId('64b000000000000000000007');
|
||||
const TOURNAMENT_CODE_ID = new Types.ObjectId('64b000000000000000000008');
|
||||
|
||||
const PROJECTION = {
|
||||
sourceRevision: 8,
|
||||
projectorVersion: 1,
|
||||
phase: 'running',
|
||||
formatType: 'paired-series',
|
||||
series: [],
|
||||
games: [],
|
||||
gameSlots: [],
|
||||
rounds: [],
|
||||
connectors: [],
|
||||
};
|
||||
|
||||
function acceptGameCommand() {
|
||||
return {
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
idempotencyKey: 'riot:KR_7000000001',
|
||||
actor: { type: 'system' as const },
|
||||
occurredAt: new Date('2026-07-12T09:59:00.000Z'),
|
||||
gameId: GAME_ID,
|
||||
seriesId: SERIES_ID,
|
||||
gameSlotId: GAME_SLOT_ID,
|
||||
ordinal: 1,
|
||||
evidence: {
|
||||
type: 'riot' as const,
|
||||
riotMatchId: 'KR_7000000001',
|
||||
payloadHash: 'sha256:riot-payload',
|
||||
},
|
||||
mapping: {
|
||||
mappingVersion: 1,
|
||||
confidence: 1,
|
||||
blueTeamId: TEAM_A_ID,
|
||||
redTeamId: TEAM_B_ID,
|
||||
winnerTeamId: TEAM_A_ID,
|
||||
participantAssignments: [],
|
||||
},
|
||||
startedAt: new Date('2026-07-12T09:30:00.000Z'),
|
||||
durationSeconds: 1_800,
|
||||
participants: [
|
||||
{
|
||||
userId: USER_ID.toHexString(),
|
||||
teamId: TEAM_A_ID.toHexString(),
|
||||
side: 'blue',
|
||||
},
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
function createHarness(
|
||||
options: {
|
||||
competitionRevision?: number;
|
||||
casResult?: Record<string, unknown> | null;
|
||||
competition?: Record<string, unknown>;
|
||||
facts?: Array<Record<string, unknown>>;
|
||||
assignments?: Array<Record<string, unknown>>;
|
||||
} = {},
|
||||
) {
|
||||
const session = {
|
||||
startTransaction: jest.fn(),
|
||||
commitTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
abortTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
endSession: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const competition =
|
||||
options.competition ??
|
||||
competitionDocument(options.competitionRevision ?? 7);
|
||||
const competitionModel = {
|
||||
findById: jest.fn().mockReturnValue(queryResult(competition)),
|
||||
findOneAndUpdate: jest
|
||||
.fn()
|
||||
.mockReturnValue(
|
||||
queryResult(
|
||||
options.casResult === undefined
|
||||
? competitionDocument(8, PROJECTION)
|
||||
: options.casResult,
|
||||
),
|
||||
),
|
||||
};
|
||||
const factModel = {
|
||||
find: jest.fn().mockReturnValue(queryResult(options.facts ?? [])),
|
||||
insertMany: jest.fn().mockResolvedValue([]),
|
||||
};
|
||||
const outboxModel = {
|
||||
findOne: jest.fn().mockReturnValue(queryResult(null)),
|
||||
insertMany: jest.fn().mockResolvedValue([]),
|
||||
};
|
||||
const assignmentModel = {
|
||||
find: jest.fn().mockReturnValue(queryResult(options.assignments ?? [])),
|
||||
updateOne: jest.fn().mockResolvedValue({ modifiedCount: 1 }),
|
||||
updateMany: jest.fn().mockResolvedValue({ modifiedCount: 2 }),
|
||||
};
|
||||
const tournamentCodeModel = {
|
||||
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<string, unknown> = {
|
||||
competition: competitionModel,
|
||||
competitionFact: factModel,
|
||||
competitionOutbox: outboxModel,
|
||||
tournamentCodeAssignment: assignmentModel,
|
||||
tournamentCode: tournamentCodeModel,
|
||||
match: matchModel,
|
||||
};
|
||||
const connectionService = {
|
||||
createSession: jest.fn().mockResolvedValue(session),
|
||||
getModel: jest.fn((name: string) => Promise.resolve(models[name])),
|
||||
};
|
||||
|
||||
return {
|
||||
session,
|
||||
competitionModel,
|
||||
factModel,
|
||||
outboxModel,
|
||||
assignmentModel,
|
||||
tournamentCodeModel,
|
||||
matchModel,
|
||||
connectionService,
|
||||
};
|
||||
}
|
||||
|
||||
function competitionDocument(revision: number, projection = PROJECTION) {
|
||||
return {
|
||||
_id: COMPETITION_ID,
|
||||
matchId: new Types.ObjectId('64b000000000000000000010'),
|
||||
communityId: new Types.ObjectId('64b000000000000000000011'),
|
||||
schemaVersion: 1,
|
||||
projectorVersion: 1,
|
||||
revision,
|
||||
phase: 'running',
|
||||
teams: [
|
||||
{ teamId: TEAM_A_ID, displayOrder: 1, seedNumber: 1 },
|
||||
{ teamId: TEAM_B_ID, displayOrder: 2, seedNumber: 2 },
|
||||
],
|
||||
format: {
|
||||
type: 'paired-series',
|
||||
rule: { type: 'first-to', winsRequired: 2, maxGames: 3 },
|
||||
},
|
||||
seriesGraph: [],
|
||||
projection,
|
||||
};
|
||||
}
|
||||
|
||||
function queryResult<T>(value: T) {
|
||||
const query = {
|
||||
session: jest.fn(),
|
||||
sort: jest.fn(),
|
||||
lean: jest.fn(),
|
||||
exec: jest.fn().mockResolvedValue(value),
|
||||
};
|
||||
query.session.mockReturnValue(query);
|
||||
query.sort.mockReturnValue(query);
|
||||
query.lean.mockReturnValue(query);
|
||||
return query;
|
||||
}
|
||||
|
||||
function reversalFixture() {
|
||||
const parentSeriesId = new Types.ObjectId('64b000000000000000000021');
|
||||
const childSeriesId = new Types.ObjectId('64b000000000000000000022');
|
||||
const parentFactId = new Types.ObjectId('64b000000000000000000023');
|
||||
const childFactId = new Types.ObjectId('64b000000000000000000024');
|
||||
const parentGameSlotId = new Types.ObjectId('64b000000000000000000025');
|
||||
const childGameSlotId = new Types.ObjectId('64b000000000000000000026');
|
||||
const parentCodeId = new Types.ObjectId('64b000000000000000000027');
|
||||
const childCodeId = new Types.ObjectId('64b000000000000000000028');
|
||||
const series = (
|
||||
id: Types.ObjectId,
|
||||
sourceA: Record<string, unknown>,
|
||||
sourceB: Record<string, unknown>,
|
||||
) => ({
|
||||
id: id.toHexString(),
|
||||
stage: { type: 'upper', displayOrder: 1 },
|
||||
slots: [
|
||||
{ position: 'A', source: sourceA },
|
||||
{ position: 'B', source: sourceB },
|
||||
],
|
||||
rule: { type: 'first-to', winsRequired: 1, maxGames: 1 },
|
||||
gameSlots: [],
|
||||
});
|
||||
const accepted = (
|
||||
_id: Types.ObjectId,
|
||||
seriesId: Types.ObjectId,
|
||||
gameSlotId: Types.ObjectId,
|
||||
) => ({
|
||||
_id,
|
||||
competitionId: COMPETITION_ID,
|
||||
type: 'game-accepted',
|
||||
revision: 1,
|
||||
ordinalWithinRevision: 1,
|
||||
commandId: `command-${_id.toHexString()}`,
|
||||
idempotencyKey: `key-${_id.toHexString()}`,
|
||||
requestHash: `hash-${_id.toHexString()}`,
|
||||
schemaVersion: 1,
|
||||
actor: { type: 'system' },
|
||||
occurredAt: new Date('2026-07-12T00:00:00.000Z'),
|
||||
recordedAt: new Date('2026-07-12T00:00:00.000Z'),
|
||||
gameId: new Types.ObjectId(),
|
||||
seriesId,
|
||||
gameSlotId,
|
||||
ordinal: 1,
|
||||
evidence: { type: 'legacy', legacyReference: 'legacy' },
|
||||
mapping: {
|
||||
blueTeamId: TEAM_A_ID,
|
||||
redTeamId: TEAM_B_ID,
|
||||
winnerTeamId: TEAM_A_ID,
|
||||
},
|
||||
});
|
||||
return {
|
||||
parentSeriesId,
|
||||
childSeriesId,
|
||||
parentFactId,
|
||||
childFactId,
|
||||
parentGameSlotId,
|
||||
childGameSlotId,
|
||||
parentCodeId,
|
||||
childCodeId,
|
||||
competition: {
|
||||
...competitionDocument(7),
|
||||
seriesGraph: [
|
||||
series(
|
||||
parentSeriesId,
|
||||
{ type: 'team', teamId: TEAM_A_ID.toHexString() },
|
||||
{ type: 'team', teamId: TEAM_B_ID.toHexString() },
|
||||
),
|
||||
series(
|
||||
childSeriesId,
|
||||
{
|
||||
type: 'series-outcome',
|
||||
seriesId: parentSeriesId.toHexString(),
|
||||
select: 'winner',
|
||||
},
|
||||
{ type: 'team', teamId: TEAM_B_ID.toHexString() },
|
||||
),
|
||||
],
|
||||
},
|
||||
facts: [
|
||||
accepted(parentFactId, parentSeriesId, parentGameSlotId),
|
||||
accepted(childFactId, childSeriesId, childGameSlotId),
|
||||
],
|
||||
assignments: [
|
||||
{
|
||||
competitionId: COMPETITION_ID,
|
||||
seriesId: parentSeriesId,
|
||||
gameSlotId: parentGameSlotId,
|
||||
tournamentCodeId: parentCodeId,
|
||||
state: 'used',
|
||||
},
|
||||
{
|
||||
competitionId: COMPETITION_ID,
|
||||
seriesId: childSeriesId,
|
||||
gameSlotId: childGameSlotId,
|
||||
tournamentCodeId: childCodeId,
|
||||
state: 'reserved',
|
||||
},
|
||||
],
|
||||
};
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,331 @@
|
||||
import { ConflictException, ForbiddenException } from '@nestjs/common';
|
||||
import { Types } from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import { CompetitionQueryService } from './competition-query.service';
|
||||
|
||||
describe('CompetitionQueryService', () => {
|
||||
it('does not let a public read race the team-build bootstrap workflow', async () => {
|
||||
const harness = createHarness({ competition: null });
|
||||
const service = createService(harness);
|
||||
|
||||
await expect(
|
||||
service.getCompetition({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
}),
|
||||
).rejects.toBeInstanceOf(ConflictException);
|
||||
|
||||
expect(harness.matchModel.findOne).toHaveBeenCalledWith({
|
||||
_id: MATCH_ID,
|
||||
communityId: COMMUNITY_ID,
|
||||
});
|
||||
});
|
||||
|
||||
it('returns an explicit team view with codes only for the callers team', async () => {
|
||||
const harness = createHarness();
|
||||
const service = createService(harness);
|
||||
|
||||
const result = await service.getTeamView({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
userId: TEAM_A_USER_ID,
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({
|
||||
competitionId: COMPETITION_ID.toHexString(),
|
||||
revision: 4,
|
||||
teamId: TEAM_A_ID.toHexString(),
|
||||
activeSeries: [expect.objectContaining({ seriesId: SERIES_ID })],
|
||||
tournamentCodes: [
|
||||
{
|
||||
gameSlotId: GAME_SLOT_ID,
|
||||
seriesId: SERIES_ID,
|
||||
ordinal: 1,
|
||||
displayNumber: 1,
|
||||
state: 'reserved',
|
||||
code: 'TEAM-A-SECRET-CODE',
|
||||
expiresAt: '2026-07-13T00:00:00.000Z',
|
||||
},
|
||||
],
|
||||
});
|
||||
expect(JSON.stringify(result)).not.toContain('OPPONENT-SECRET-CODE');
|
||||
expect(harness.tournamentCodeModel.find).toHaveBeenCalledWith({
|
||||
_id: { $in: [TEAM_A_CODE_ID] },
|
||||
state: { $in: ['reserved', 'used'] },
|
||||
});
|
||||
});
|
||||
|
||||
it('does not reveal a team view to an authenticated non-participant', async () => {
|
||||
const service = createService(createHarness());
|
||||
|
||||
await expect(
|
||||
service.getTeamView({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
userId: new Types.ObjectId('64c000000000000000000099'),
|
||||
}),
|
||||
).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(
|
||||
queryResult([
|
||||
factDocument('64c000000000000000000031', 1, 1),
|
||||
factDocument('64c000000000000000000032', 2, 1),
|
||||
factDocument('64c000000000000000000033', 3, 1),
|
||||
]),
|
||||
);
|
||||
const service = createService(harness);
|
||||
|
||||
const first = await service.listFacts({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
limit: 2,
|
||||
});
|
||||
|
||||
expect(first.facts).toHaveLength(2);
|
||||
expect(first.nextCursor).toEqual(expect.any(String));
|
||||
expect(first.facts[0]).toMatchObject({
|
||||
id: '64c000000000000000000031',
|
||||
competitionId: COMPETITION_ID.toHexString(),
|
||||
type: 'game-accepted',
|
||||
revision: 1,
|
||||
});
|
||||
expect(first.facts[0]).not.toHaveProperty('requestHash');
|
||||
expect(first.facts[0]).not.toHaveProperty('idempotencyKey');
|
||||
});
|
||||
});
|
||||
|
||||
const COMMUNITY_ID = new Types.ObjectId('64c000000000000000000001');
|
||||
const MATCH_ID = new Types.ObjectId('64c000000000000000000002');
|
||||
const COMPETITION_ID = new Types.ObjectId('64c000000000000000000003');
|
||||
const TEAM_A_ID = new Types.ObjectId('64c000000000000000000004');
|
||||
const TEAM_B_ID = new Types.ObjectId('64c000000000000000000005');
|
||||
const TEAM_A_USER_ID = new Types.ObjectId('64c000000000000000000006');
|
||||
const TEAM_B_USER_ID = new Types.ObjectId('64c000000000000000000007');
|
||||
const TEAM_A_CODE_ID = new Types.ObjectId('64c000000000000000000008');
|
||||
const TEAM_B_CODE_ID = new Types.ObjectId('64c000000000000000000009');
|
||||
const SERIES_ID = 'series-1';
|
||||
const GAME_SLOT_ID = 'slot-1';
|
||||
|
||||
function createService(harness: ReturnType<typeof createHarness>) {
|
||||
return new CompetitionQueryService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
}
|
||||
|
||||
function createHarness(options: { competition?: unknown } = {}) {
|
||||
const competition =
|
||||
options.competition === undefined
|
||||
? competitionDocument()
|
||||
: options.competition;
|
||||
const competitionModel = {
|
||||
findOne: jest.fn().mockReturnValue(queryResult(competition)),
|
||||
};
|
||||
const matchModel = {
|
||||
findOne: jest.fn().mockReturnValue(
|
||||
queryResult({
|
||||
_id: MATCH_ID,
|
||||
communityId: COMMUNITY_ID,
|
||||
status: 'team-built',
|
||||
teams: [{ teamIndex: 1 }, { teamIndex: 2 }],
|
||||
participants: [],
|
||||
gameMode: 'pair',
|
||||
gameCount: 3,
|
||||
}),
|
||||
),
|
||||
};
|
||||
const assignmentModel = {
|
||||
find: jest.fn().mockReturnValue(
|
||||
queryResult([
|
||||
{
|
||||
competitionId: COMPETITION_ID,
|
||||
seriesId: SERIES_ID,
|
||||
gameSlotId: GAME_SLOT_ID,
|
||||
tournamentCodeId: TEAM_A_CODE_ID,
|
||||
state: 'reserved',
|
||||
},
|
||||
{
|
||||
competitionId: COMPETITION_ID,
|
||||
seriesId: 'series-opponent-only',
|
||||
gameSlotId: 'slot-opponent-only',
|
||||
tournamentCodeId: TEAM_B_CODE_ID,
|
||||
state: 'reserved',
|
||||
},
|
||||
]),
|
||||
),
|
||||
};
|
||||
const tournamentCodeModel = {
|
||||
find: jest.fn().mockReturnValue(
|
||||
queryResult([
|
||||
{
|
||||
_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'),
|
||||
},
|
||||
]),
|
||||
),
|
||||
};
|
||||
const factModel = {
|
||||
find: jest.fn().mockReturnValue(queryResult([])),
|
||||
};
|
||||
const models: Record<string, unknown> = {
|
||||
competition: competitionModel,
|
||||
match: matchModel,
|
||||
tournamentCodeAssignment: assignmentModel,
|
||||
tournamentCode: tournamentCodeModel,
|
||||
competitionFact: factModel,
|
||||
};
|
||||
return {
|
||||
competitionModel,
|
||||
matchModel,
|
||||
assignmentModel,
|
||||
tournamentCodeModel,
|
||||
factModel,
|
||||
connectionService: {
|
||||
getModel: jest.fn((name: string) => Promise.resolve(models[name])),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function competitionDocument() {
|
||||
return {
|
||||
_id: COMPETITION_ID,
|
||||
matchId: MATCH_ID,
|
||||
communityId: COMMUNITY_ID,
|
||||
schemaVersion: 1,
|
||||
projectorVersion: 1,
|
||||
revision: 4,
|
||||
phase: 'running',
|
||||
teams: [
|
||||
{
|
||||
teamId: TEAM_A_ID,
|
||||
displayOrder: 1,
|
||||
seedNumber: 1,
|
||||
name: 'Team A',
|
||||
members: [{ userId: TEAM_A_USER_ID, displayName: 'A' }],
|
||||
},
|
||||
{
|
||||
teamId: TEAM_B_ID,
|
||||
displayOrder: 2,
|
||||
seedNumber: 2,
|
||||
name: 'Team B',
|
||||
members: [{ userId: TEAM_B_USER_ID, displayName: 'B' }],
|
||||
},
|
||||
],
|
||||
format: {
|
||||
type: 'paired-series',
|
||||
rule: { type: 'fixed-games', gameCount: 3, drawPolicy: 'allow' },
|
||||
},
|
||||
seriesGraph: [],
|
||||
projection: {
|
||||
sourceRevision: 4,
|
||||
projectorVersion: 1,
|
||||
phase: 'running',
|
||||
formatType: 'paired-series',
|
||||
series: [
|
||||
{
|
||||
seriesId: SERIES_ID,
|
||||
status: 'in-progress',
|
||||
stage: { type: 'pair', displayOrder: 1 },
|
||||
rule: { type: 'fixed-games', gameCount: 3, drawPolicy: 'allow' },
|
||||
entries: [
|
||||
{ slot: 'A', teamId: TEAM_A_ID.toHexString(), gameWins: 1 },
|
||||
{ slot: 'B', teamId: TEAM_B_ID.toHexString(), gameWins: 0 },
|
||||
],
|
||||
},
|
||||
{
|
||||
seriesId: 'series-opponent-only',
|
||||
status: 'in-progress',
|
||||
stage: { type: 'pair', displayOrder: 2 },
|
||||
rule: { type: 'fixed-games', gameCount: 3, drawPolicy: 'allow' },
|
||||
entries: [
|
||||
{ slot: 'A', teamId: TEAM_B_ID.toHexString(), gameWins: 0 },
|
||||
{ slot: 'B', teamId: 'other-team', gameWins: 1 },
|
||||
],
|
||||
},
|
||||
],
|
||||
games: [],
|
||||
gameSlots: [
|
||||
{
|
||||
id: GAME_SLOT_ID,
|
||||
seriesId: SERIES_ID,
|
||||
ordinal: 1,
|
||||
displayNumber: 1,
|
||||
status: 'reserved',
|
||||
entries: [],
|
||||
},
|
||||
],
|
||||
rounds: [],
|
||||
connectors: [],
|
||||
},
|
||||
createdAt: new Date('2026-07-11T00:00:00.000Z'),
|
||||
updatedAt: new Date('2026-07-12T00:00:00.000Z'),
|
||||
};
|
||||
}
|
||||
|
||||
function factDocument(id: string, revision: number, ordinal: number) {
|
||||
return {
|
||||
_id: new Types.ObjectId(id),
|
||||
competitionId: COMPETITION_ID,
|
||||
type: 'game-accepted',
|
||||
revision,
|
||||
ordinalWithinRevision: ordinal,
|
||||
commandId: `command-${revision}`,
|
||||
idempotencyKey: `secret-${revision}`,
|
||||
requestHash: `hash-${revision}`,
|
||||
schemaVersion: 1,
|
||||
actor: { type: 'system' },
|
||||
occurredAt: new Date('2026-07-12T00:00:00.000Z'),
|
||||
recordedAt: new Date('2026-07-12T00:00:01.000Z'),
|
||||
gameId: new Types.ObjectId('64c000000000000000000041'),
|
||||
seriesId: new Types.ObjectId('64c000000000000000000042'),
|
||||
gameSlotId: new Types.ObjectId('64c000000000000000000043'),
|
||||
ordinal: 1,
|
||||
evidence: { type: 'legacy', legacyReference: 'legacy-1' },
|
||||
mapping: {
|
||||
mappingVersion: 1,
|
||||
confidence: 1,
|
||||
blueTeamId: TEAM_A_ID,
|
||||
redTeamId: TEAM_B_ID,
|
||||
winnerTeamId: TEAM_A_ID,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function queryResult<T>(value: T) {
|
||||
const query = {
|
||||
sort: jest.fn(),
|
||||
limit: jest.fn(),
|
||||
lean: jest.fn(),
|
||||
exec: jest.fn().mockResolvedValue(value),
|
||||
};
|
||||
query.sort.mockReturnValue(query);
|
||||
query.limit.mockReturnValue(query);
|
||||
query.lean.mockReturnValue(query);
|
||||
return query;
|
||||
}
|
||||
@@ -0,0 +1,390 @@
|
||||
import type {
|
||||
CompetitionFactView,
|
||||
CompetitionFactsResponse,
|
||||
TeamCompetitionViewResponse,
|
||||
} from '@lolympus/contracts';
|
||||
import {
|
||||
ConflictException,
|
||||
ForbiddenException,
|
||||
Injectable,
|
||||
NotFoundException,
|
||||
UnprocessableEntityException,
|
||||
} from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import type { Competition, CompetitionFact } from './competition.schema';
|
||||
|
||||
type PersistenceId = string | mongoose.Types.ObjectId;
|
||||
type CompetitionRecord = Competition & { _id: mongoose.Types.ObjectId };
|
||||
|
||||
export interface CompetitionScope {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
}
|
||||
|
||||
interface CompetitionProjectionSource {
|
||||
series?: Array<Record<string, unknown>>;
|
||||
gameSlots?: Array<Record<string, unknown>>;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class CompetitionQueryService {
|
||||
constructor(private readonly connectionService: ConnectionService) {}
|
||||
|
||||
/** Resolve the aggregate created by the finalized team-build workflow. */
|
||||
public async getCompetition(
|
||||
scope: CompetitionScope,
|
||||
): Promise<CompetitionRecord> {
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const match = await MatchModel.findOne({
|
||||
_id: scope.matchId,
|
||||
communityId: scope.communityId,
|
||||
})
|
||||
.lean()
|
||||
.exec();
|
||||
if (!match) throw new NotFoundException('Match not found.');
|
||||
if (
|
||||
match.status === 'recruiting' ||
|
||||
!Array.isArray(match.teams) ||
|
||||
match.teams.length < 2
|
||||
) {
|
||||
throw new ConflictException(
|
||||
'Competition is unavailable until team building is complete.',
|
||||
);
|
||||
}
|
||||
|
||||
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(
|
||||
scope: CompetitionScope & { userId: mongoose.Types.ObjectId },
|
||||
): Promise<TeamCompetitionViewResponse> {
|
||||
const competition = (await this.getCompetition(scope)) as Competition & {
|
||||
_id: PersistenceId;
|
||||
};
|
||||
const team = competition.teams.find(({ members }) =>
|
||||
members.some(({ userId }) => sameId(userId, scope.userId)),
|
||||
);
|
||||
if (!team) {
|
||||
throw new ForbiddenException(
|
||||
'Only a Competition team member may access the team view.',
|
||||
);
|
||||
}
|
||||
|
||||
const projection = competition.projection as CompetitionProjectionSource;
|
||||
const allSeries = Array.isArray(projection.series) ? projection.series : [];
|
||||
const teamId = idString(team.teamId);
|
||||
const activeSeries = allSeries.filter(
|
||||
(series) =>
|
||||
series.status !== 'completed' &&
|
||||
series.status !== 'inactive' &&
|
||||
Array.isArray(series.entries) &&
|
||||
series.entries.some(
|
||||
(entry) =>
|
||||
isRecord(entry) &&
|
||||
idString(entry.teamId as PersistenceId) === teamId,
|
||||
),
|
||||
);
|
||||
const activeSeriesIds = new Set(
|
||||
activeSeries.map((series) => idString(series.seriesId as PersistenceId)),
|
||||
);
|
||||
const gameSlots = (
|
||||
Array.isArray(projection.gameSlots) ? projection.gameSlots : []
|
||||
).filter((slot) =>
|
||||
activeSeriesIds.has(idString(slot.seriesId as PersistenceId)),
|
||||
);
|
||||
|
||||
const AssignmentModel = await this.connectionService.getModel(
|
||||
'tournamentCodeAssignment',
|
||||
);
|
||||
const queriedAssignments = await AssignmentModel.find({
|
||||
competitionId: competition._id,
|
||||
seriesId: { $in: [...activeSeriesIds] },
|
||||
state: { $in: ['reserved', 'used'] },
|
||||
})
|
||||
.lean()
|
||||
.exec();
|
||||
// Keep this defensive filter even when the persistence query is mocked or
|
||||
// changed: an opponent-only assignment must never cross this boundary.
|
||||
const assignments = queriedAssignments.filter((assignment) =>
|
||||
activeSeriesIds.has(idString(assignment.seriesId)),
|
||||
);
|
||||
const codeIds = assignments.map(({ tournamentCodeId }) => tournamentCodeId);
|
||||
const TournamentCodeModel =
|
||||
await this.connectionService.getModel('tournamentCode');
|
||||
const codes = codeIds.length
|
||||
? await TournamentCodeModel.find({
|
||||
_id: { $in: codeIds },
|
||||
state: { $in: ['reserved', 'used'] },
|
||||
})
|
||||
.lean()
|
||||
.exec()
|
||||
: [];
|
||||
const codeById = new Map(codes.map((code) => [idString(code._id), code]));
|
||||
const assignmentBySlot = new Map(
|
||||
assignments.map((assignment) => [
|
||||
idString(assignment.gameSlotId),
|
||||
assignment,
|
||||
]),
|
||||
);
|
||||
|
||||
return {
|
||||
competitionId: idString(competition._id) as never,
|
||||
revision: competition.revision,
|
||||
phase: competition.phase,
|
||||
teamId: teamId as never,
|
||||
activeSeries: toWire(activeSeries) as never,
|
||||
tournamentCodes: gameSlots.map((slot) => {
|
||||
const gameSlotId = idString(slot.id as PersistenceId);
|
||||
const assignment = assignmentBySlot.get(gameSlotId);
|
||||
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,
|
||||
ordinal: numberValue(slot.ordinal),
|
||||
displayNumber: numberValue(slot.displayNumber),
|
||||
state:
|
||||
assignment?.state === 'reserved' || assignment?.state === 'used'
|
||||
? assignment.state
|
||||
: 'pending',
|
||||
code: typeof code?.code === 'string' ? code.code : null,
|
||||
expiresAt: code?.expiresAt ? isoDate(code.expiresAt) : null,
|
||||
};
|
||||
}),
|
||||
};
|
||||
}
|
||||
|
||||
public async listFacts(
|
||||
scope: CompetitionScope & { cursor?: string; limit?: number },
|
||||
): Promise<CompetitionFactsResponse> {
|
||||
const competition = (await this.getCompetition(scope)) as Competition & {
|
||||
_id: PersistenceId;
|
||||
};
|
||||
const limit = normalizeLimit(scope.limit);
|
||||
const cursor = scope.cursor ? decodeCursor(scope.cursor) : undefined;
|
||||
const cursorFilter = cursor
|
||||
? {
|
||||
$or: [
|
||||
{ revision: { $gt: cursor.revision } },
|
||||
{
|
||||
revision: cursor.revision,
|
||||
ordinalWithinRevision: { $gt: cursor.ordinalWithinRevision },
|
||||
},
|
||||
{
|
||||
revision: cursor.revision,
|
||||
ordinalWithinRevision: cursor.ordinalWithinRevision,
|
||||
_id: { $gt: new mongoose.Types.ObjectId(cursor.id) },
|
||||
},
|
||||
],
|
||||
}
|
||||
: {};
|
||||
const FactModel = await this.connectionService.getModel('competitionFact');
|
||||
const rows = await FactModel.find({
|
||||
competitionId: competition._id,
|
||||
...cursorFilter,
|
||||
})
|
||||
.sort({ revision: 1, ordinalWithinRevision: 1, _id: 1 })
|
||||
.limit(limit + 1)
|
||||
.lean()
|
||||
.exec();
|
||||
const page = rows.slice(0, limit);
|
||||
const last = page.at(-1);
|
||||
return {
|
||||
facts: page.map(presentFact),
|
||||
nextCursor:
|
||||
rows.length > limit && last
|
||||
? encodeCursor({
|
||||
revision: requiredNumber(last.revision, 'revision'),
|
||||
ordinalWithinRevision: requiredNumber(
|
||||
last.ordinalWithinRevision,
|
||||
'ordinalWithinRevision',
|
||||
),
|
||||
id: requiredId(last._id, '_id'),
|
||||
})
|
||||
: null,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
function presentFact(
|
||||
source: CompetitionFact & { _id: mongoose.Types.ObjectId },
|
||||
): CompetitionFactView {
|
||||
const common = {
|
||||
id: requiredId(source._id, '_id') as never,
|
||||
competitionId: requiredId(source.competitionId, 'competitionId') as never,
|
||||
revision: requiredNumber(source.revision, 'revision'),
|
||||
ordinalWithinRevision: requiredNumber(
|
||||
source.ordinalWithinRevision,
|
||||
'ordinalWithinRevision',
|
||||
),
|
||||
commandId: requiredString(source.commandId, 'commandId') as never,
|
||||
schemaVersion: requiredNumber(source.schemaVersion, 'schemaVersion'),
|
||||
actor: toWire(source.actor) as never,
|
||||
occurredAt: isoDate(source.occurredAt),
|
||||
recordedAt: isoDate(source.recordedAt),
|
||||
...(typeof source.causationId === 'string' && source.causationId.length > 0
|
||||
? { causationId: source.causationId }
|
||||
: {}),
|
||||
};
|
||||
switch (source.type) {
|
||||
case 'game-accepted':
|
||||
return {
|
||||
...common,
|
||||
type: 'game-accepted',
|
||||
gameId: requiredId(source.gameId, 'gameId') as never,
|
||||
seriesId: requiredId(source.seriesId, 'seriesId') as never,
|
||||
gameSlotId: requiredId(source.gameSlotId, 'gameSlotId') as never,
|
||||
ordinal: requiredNumber(source.ordinal, 'ordinal'),
|
||||
startedAt: isoDate(source.startedAt ?? source.occurredAt),
|
||||
durationSeconds: numberValue(source.durationSeconds ?? 0),
|
||||
participants: toWire(source.participants ?? []) as never,
|
||||
evidence: toWire(source.evidence) as never,
|
||||
mapping: toWire(source.mapping) as never,
|
||||
};
|
||||
case 'game-voided':
|
||||
return {
|
||||
...common,
|
||||
type: 'game-voided',
|
||||
gameAcceptedFactId: requiredId(
|
||||
source.gameAcceptedFactId,
|
||||
'gameAcceptedFactId',
|
||||
) as never,
|
||||
reason: requiredString(source.reason, 'reason'),
|
||||
};
|
||||
case 'series-adjudicated':
|
||||
return {
|
||||
...common,
|
||||
type: 'series-adjudicated',
|
||||
seriesId: requiredId(source.seriesId, 'seriesId') as never,
|
||||
decision: toWire(source.decision) as never,
|
||||
reason: requiredString(source.reason, 'reason'),
|
||||
};
|
||||
case 'adjudication-reversed':
|
||||
return {
|
||||
...common,
|
||||
type: 'adjudication-reversed',
|
||||
adjudicationFactId: requiredId(
|
||||
source.adjudicationFactId,
|
||||
'adjudicationFactId',
|
||||
) as never,
|
||||
reason: requiredString(source.reason, 'reason'),
|
||||
};
|
||||
default:
|
||||
throw new Error('Unsupported Competition fact type.');
|
||||
}
|
||||
}
|
||||
|
||||
interface FactCursor {
|
||||
revision: number;
|
||||
ordinalWithinRevision: number;
|
||||
id: string;
|
||||
}
|
||||
|
||||
function encodeCursor(cursor: FactCursor): string {
|
||||
return Buffer.from(JSON.stringify(cursor)).toString('base64url');
|
||||
}
|
||||
|
||||
function decodeCursor(value: string): FactCursor {
|
||||
try {
|
||||
const parsed: unknown = JSON.parse(
|
||||
Buffer.from(value, 'base64url').toString('utf8'),
|
||||
);
|
||||
if (
|
||||
!isRecord(parsed) ||
|
||||
!Number.isInteger(parsed.revision) ||
|
||||
!Number.isInteger(parsed.ordinalWithinRevision) ||
|
||||
typeof parsed.id !== 'string' ||
|
||||
!mongoose.isValidObjectId(parsed.id)
|
||||
) {
|
||||
throw new Error('malformed cursor');
|
||||
}
|
||||
return parsed as unknown as FactCursor;
|
||||
} catch {
|
||||
throw new UnprocessableEntityException('Invalid facts cursor.');
|
||||
}
|
||||
}
|
||||
|
||||
function normalizeLimit(value: number | undefined): number {
|
||||
if (value === undefined) return 50;
|
||||
if (!Number.isInteger(value) || value < 1 || value > 100) {
|
||||
throw new UnprocessableEntityException(
|
||||
'Facts page limit must be an integer from 1 through 100.',
|
||||
);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
function sameId(left: PersistenceId, right: PersistenceId): boolean {
|
||||
return idString(left) === idString(right);
|
||||
}
|
||||
|
||||
function idString(value: PersistenceId): string {
|
||||
return value instanceof mongoose.Types.ObjectId
|
||||
? value.toHexString()
|
||||
: String(value);
|
||||
}
|
||||
|
||||
function isoDate(value: unknown): string {
|
||||
if (value instanceof Date) return value.toISOString();
|
||||
if (typeof value === 'string') return value;
|
||||
throw new Error('Competition fact contains an invalid date.');
|
||||
}
|
||||
|
||||
function numberValue(value: unknown): number {
|
||||
return typeof value === 'number' ? value : Number(value);
|
||||
}
|
||||
|
||||
function toWire(value: unknown): unknown {
|
||||
if (value instanceof mongoose.Types.ObjectId) return value.toHexString();
|
||||
if (value instanceof Date) return value.toISOString();
|
||||
if (Array.isArray(value)) return value.map(toWire);
|
||||
if (isRecord(value)) {
|
||||
return Object.fromEntries(
|
||||
Object.entries(value).map(([key, child]) => [key, toWire(child)]),
|
||||
);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return value !== null && typeof value === 'object' && !Array.isArray(value);
|
||||
}
|
||||
|
||||
function requiredId(value: unknown, field: string): string {
|
||||
if (value instanceof mongoose.Types.ObjectId) return value.toHexString();
|
||||
return requiredString(value, field);
|
||||
}
|
||||
|
||||
function requiredString(value: unknown, field: string): string {
|
||||
if (typeof value === 'string' && value.length > 0) return value;
|
||||
throw new Error(`Competition fact contains an invalid ${field}.`);
|
||||
}
|
||||
|
||||
function requiredNumber(value: unknown, field: string): number {
|
||||
if (typeof value === 'number' && Number.isFinite(value)) return value;
|
||||
throw new Error(`Competition fact contains an invalid ${field}.`);
|
||||
}
|
||||
@@ -0,0 +1,356 @@
|
||||
import { HttpException } from '@nestjs/common';
|
||||
import { Types } from 'mongoose';
|
||||
import { METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED } from '../auth/allow-public-access.decorator';
|
||||
import { ROLES_KEY } from '../auth/roles.decorator';
|
||||
import { CompetitionCommandService } from './competition-command.service';
|
||||
import { CompetitionController } from './competition.controller';
|
||||
import { CompetitionQueryService } from './competition-query.service';
|
||||
|
||||
describe('CompetitionController', () => {
|
||||
it('marks only the detail endpoint public and writes a revision ETag', async () => {
|
||||
const { controller, queryService } = createHarness();
|
||||
const response = { setHeader: jest.fn() };
|
||||
|
||||
const result = await controller.getDetail(
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
response as never,
|
||||
);
|
||||
|
||||
expect(
|
||||
Reflect.getMetadata(
|
||||
METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED,
|
||||
CompetitionController.prototype.getDetail,
|
||||
),
|
||||
).toBe(true);
|
||||
expect(
|
||||
Reflect.getMetadata(
|
||||
METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED,
|
||||
CompetitionController.prototype.getTeamView,
|
||||
),
|
||||
).not.toBe(true);
|
||||
expect(response.setHeader).toHaveBeenCalledWith('ETag', '"7"');
|
||||
expect(result).toMatchObject({ revision: 7 });
|
||||
expect(queryService.getCompetition).toHaveBeenCalledWith({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
});
|
||||
});
|
||||
|
||||
it('protects audit and mutation endpoints with admin roles', () => {
|
||||
for (const method of [
|
||||
'listFacts',
|
||||
'acceptGame',
|
||||
'adjudicateSeries',
|
||||
'previewReversal',
|
||||
'reverseSeries',
|
||||
] as const) {
|
||||
expect(
|
||||
Reflect.getMetadata(ROLES_KEY, CompetitionController.prototype[method]),
|
||||
).toEqual(['owner', 'admin']);
|
||||
}
|
||||
});
|
||||
|
||||
it('requires If-Match and Idempotency-Key for a mutation', async () => {
|
||||
const { controller } = createHarness();
|
||||
|
||||
await expect(
|
||||
controller.acceptGame(
|
||||
adminUser(),
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
undefined,
|
||||
undefined,
|
||||
acceptGameBody(),
|
||||
),
|
||||
).rejects.toMatchObject({
|
||||
status: 422,
|
||||
response: {
|
||||
error: { code: 'INVALID_COMPETITION_COMMAND_HEADERS' },
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it('passes revision, idempotency and the authenticated actor to accept-game', async () => {
|
||||
const { controller, commandService } = createHarness();
|
||||
|
||||
await controller.acceptGame(
|
||||
adminUser(),
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
'W/"7"',
|
||||
'operator:accept:1',
|
||||
acceptGameBody(),
|
||||
);
|
||||
|
||||
expect(commandService.acceptGame).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
expectedRevision: 7,
|
||||
idempotencyKey: 'operator:accept:1',
|
||||
}),
|
||||
);
|
||||
const accepted = commandService.acceptGame.mock.calls[0][0];
|
||||
expect(accepted.competitionId.toHexString()).toBe(
|
||||
COMPETITION_ID.toHexString(),
|
||||
);
|
||||
expect(accepted.actor.userId.toHexString()).toBe(ADMIN_ID.toHexString());
|
||||
expect(accepted.gameId.toHexString()).toBe(GAME_ID.toHexString());
|
||||
expect(accepted.seriesId.toHexString()).toBe(SERIES_ID);
|
||||
expect(accepted.gameSlotId.toHexString()).toBe(GAME_SLOT_ID.toHexString());
|
||||
});
|
||||
|
||||
it('maps command conflicts to the explicit error envelope', async () => {
|
||||
const { controller, commandService } = createHarness();
|
||||
commandService.adjudicateSeries.mockRejectedValue({
|
||||
code: 'IDEMPOTENCY_KEY_CONFLICT',
|
||||
message: 'duplicate key with another payload',
|
||||
httpStatus: 409,
|
||||
details: { idempotencyKey: 'same-key' },
|
||||
});
|
||||
|
||||
let thrown: unknown;
|
||||
try {
|
||||
await controller.adjudicateSeries(
|
||||
adminUser(),
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
new Types.ObjectId(SERIES_ID),
|
||||
'"7"',
|
||||
'same-key',
|
||||
{
|
||||
decision: { type: 'administrative-draw' },
|
||||
reason: '운영 판단',
|
||||
},
|
||||
);
|
||||
} catch (error) {
|
||||
thrown = error;
|
||||
}
|
||||
|
||||
expect(thrown).toBeInstanceOf(HttpException);
|
||||
expect(thrown).toMatchObject({
|
||||
status: 409,
|
||||
response: {
|
||||
error: {
|
||||
code: 'IDEMPOTENCY_KEY_CONFLICT',
|
||||
details: { idempotencyKey: 'same-key' },
|
||||
},
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it.each([
|
||||
{
|
||||
source: {
|
||||
code: 'STALE_COMPETITION_REVISION',
|
||||
message: 'stale',
|
||||
httpStatus: 412,
|
||||
},
|
||||
status: 412,
|
||||
},
|
||||
{
|
||||
source: {
|
||||
code: 'GAME_TEAM_MISMATCH',
|
||||
message: 'invalid evidence mapping',
|
||||
},
|
||||
status: 422,
|
||||
},
|
||||
])('maps $source.code to HTTP $status', async ({ source, status }) => {
|
||||
const { controller, commandService } = createHarness();
|
||||
commandService.acceptGame.mockRejectedValue(source);
|
||||
|
||||
await expect(
|
||||
controller.acceptGame(
|
||||
adminUser(),
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
'"7"',
|
||||
`operator:error:${status}`,
|
||||
acceptGameBody(),
|
||||
),
|
||||
).rejects.toMatchObject({
|
||||
status,
|
||||
response: { error: { code: source.code } },
|
||||
});
|
||||
});
|
||||
|
||||
it('returns an explicit 422 envelope for an invalid command body', async () => {
|
||||
const { controller, commandService } = createHarness();
|
||||
|
||||
await expect(
|
||||
controller.adjudicateSeries(
|
||||
adminUser(),
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
new Types.ObjectId(SERIES_ID),
|
||||
'"7"',
|
||||
'operator:invalid-body:1',
|
||||
{
|
||||
decision: { type: 'walkover' },
|
||||
reason: '',
|
||||
},
|
||||
),
|
||||
).rejects.toMatchObject({
|
||||
status: 422,
|
||||
response: {
|
||||
error: { code: 'INVALID_COMPETITION_REQUEST' },
|
||||
},
|
||||
});
|
||||
expect(commandService.adjudicateSeries).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('rejects malformed game evidence before it reaches the ledger', async () => {
|
||||
const { controller, commandService } = createHarness();
|
||||
|
||||
await expect(
|
||||
controller.acceptGame(
|
||||
adminUser(),
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
'"7"',
|
||||
'operator:bad-evidence:1',
|
||||
{
|
||||
...acceptGameBody(),
|
||||
evidence: { type: 'invented-evidence' },
|
||||
},
|
||||
),
|
||||
).rejects.toMatchObject({
|
||||
status: 422,
|
||||
response: {
|
||||
error: { code: 'INVALID_COMPETITION_REQUEST' },
|
||||
},
|
||||
});
|
||||
expect(commandService.acceptGame).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('requires the same revision for preview and hash-confirmed reversal', async () => {
|
||||
const { controller, commandService } = createHarness();
|
||||
|
||||
await controller.previewReversal(
|
||||
adminUser(),
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
new Types.ObjectId(SERIES_ID),
|
||||
'"7"',
|
||||
{ mode: 'cascade', reason: '잘못 수집됨' },
|
||||
);
|
||||
await controller.reverseSeries(
|
||||
adminUser(),
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
new Types.ObjectId(SERIES_ID),
|
||||
'"7"',
|
||||
'operator:reverse:1',
|
||||
{
|
||||
mode: 'cascade',
|
||||
reason: '잘못 수집됨',
|
||||
impactHash: 'a'.repeat(64),
|
||||
},
|
||||
);
|
||||
|
||||
expect(commandService.previewSeriesReversal).toHaveBeenCalledWith({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
seriesId: new Types.ObjectId(SERIES_ID),
|
||||
mode: 'cascade',
|
||||
});
|
||||
expect(commandService.reverseSeries).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
idempotencyKey: 'operator:reverse:1',
|
||||
impactHash: 'a'.repeat(64),
|
||||
}),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
const COMMUNITY_ID = new Types.ObjectId('64d000000000000000000001');
|
||||
const MATCH_ID = new Types.ObjectId('64d000000000000000000002');
|
||||
const COMPETITION_ID = new Types.ObjectId('64d000000000000000000003');
|
||||
const ADMIN_ID = new Types.ObjectId('64d000000000000000000004');
|
||||
const GAME_ID = new Types.ObjectId('64d000000000000000000005');
|
||||
const SERIES_ID = '64d000000000000000000006';
|
||||
const GAME_SLOT_ID = new Types.ObjectId('64d000000000000000000007');
|
||||
const TEAM_A_ID = new Types.ObjectId('64d000000000000000000008');
|
||||
const TEAM_B_ID = new Types.ObjectId('64d000000000000000000009');
|
||||
|
||||
function createHarness() {
|
||||
const competition = {
|
||||
_id: COMPETITION_ID,
|
||||
matchId: MATCH_ID,
|
||||
communityId: COMMUNITY_ID,
|
||||
schemaVersion: 1,
|
||||
revision: 7,
|
||||
phase: 'running',
|
||||
teams: [],
|
||||
format: {
|
||||
type: 'paired-series',
|
||||
rule: { type: 'fixed-games', gameCount: 3, drawPolicy: 'allow' },
|
||||
},
|
||||
projection: {
|
||||
sourceRevision: 7,
|
||||
projectorVersion: 1,
|
||||
phase: 'running',
|
||||
formatType: 'paired-series',
|
||||
series: [],
|
||||
games: [],
|
||||
gameSlots: [],
|
||||
rounds: [],
|
||||
connectors: [],
|
||||
},
|
||||
createdAt: new Date('2026-07-11T00:00:00.000Z'),
|
||||
updatedAt: new Date('2026-07-12T00:00:00.000Z'),
|
||||
};
|
||||
const queryService = {
|
||||
getCompetition: jest.fn().mockResolvedValue(competition),
|
||||
getTeamView: jest.fn(),
|
||||
listFacts: jest.fn(),
|
||||
};
|
||||
const commandService = {
|
||||
acceptGame: jest.fn().mockResolvedValue({ competition, revision: 8 }),
|
||||
adjudicateSeries: jest.fn().mockResolvedValue({ competition, revision: 8 }),
|
||||
previewSeriesReversal: jest.fn().mockResolvedValue({
|
||||
sourceRevision: 7,
|
||||
impactHash: 'a'.repeat(64),
|
||||
impact: {},
|
||||
}),
|
||||
reverseSeries: jest.fn().mockResolvedValue({ competition, revision: 8 }),
|
||||
};
|
||||
return {
|
||||
queryService,
|
||||
commandService,
|
||||
controller: new CompetitionController(
|
||||
queryService as unknown as CompetitionQueryService,
|
||||
commandService as unknown as CompetitionCommandService,
|
||||
),
|
||||
};
|
||||
}
|
||||
|
||||
function adminUser() {
|
||||
return {
|
||||
_id: ADMIN_ID,
|
||||
communityId: COMMUNITY_ID,
|
||||
role: 'admin',
|
||||
} as never;
|
||||
}
|
||||
|
||||
function acceptGameBody() {
|
||||
return {
|
||||
gameId: GAME_ID.toHexString(),
|
||||
seriesId: SERIES_ID,
|
||||
gameSlotId: GAME_SLOT_ID.toHexString(),
|
||||
ordinal: 1,
|
||||
evidence: {
|
||||
type: 'riot',
|
||||
riotMatchId: 'KR_1',
|
||||
payloadHash: 'sha256:value',
|
||||
},
|
||||
mapping: {
|
||||
mappingVersion: 1,
|
||||
confidence: 1,
|
||||
blueTeamId: TEAM_A_ID.toHexString(),
|
||||
redTeamId: TEAM_B_ID.toHexString(),
|
||||
winnerTeamId: TEAM_A_ID.toHexString(),
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,499 @@
|
||||
import type {
|
||||
CompetitionCommandResponse,
|
||||
CompetitionDetailResponse,
|
||||
CompetitionFactsResponse,
|
||||
SeriesReversalPreviewResponse,
|
||||
TeamCompetitionViewResponse,
|
||||
} from '@lolympus/contracts';
|
||||
import {
|
||||
Body,
|
||||
Controller,
|
||||
Get,
|
||||
Headers,
|
||||
HttpException,
|
||||
Param,
|
||||
Post,
|
||||
Query,
|
||||
Res,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import type { Response } from 'express';
|
||||
import mongoose from 'mongoose';
|
||||
import { plainToInstance } from 'class-transformer';
|
||||
import { validateSync, type ValidationError } from 'class-validator';
|
||||
import { AllowPublicAccess } from '../auth/allow-public-access.decorator';
|
||||
import { CurrentUser } from '../auth/current-user.decorator';
|
||||
import { Roles } from '../auth/roles.decorator';
|
||||
import { RolesGuard } from '../auth/roles.guard';
|
||||
import { ParseObjectIdPipe } from '../common/parse-object-id.pipe';
|
||||
import type { UserDocument } from '../global/database/schema';
|
||||
import { CompetitionCommandService } from './competition-command.service';
|
||||
import { presentCompetitionDetail } from './competition.presenter';
|
||||
import { CompetitionQueryService } from './competition-query.service';
|
||||
import {
|
||||
AcceptCompetitionGameDto,
|
||||
AdjudicateCompetitionSeriesDto,
|
||||
CompetitionFactsQueryDto,
|
||||
PreviewCompetitionSeriesReversalDto,
|
||||
ReverseCompetitionSeriesDto,
|
||||
} from './dto/competition-command.dto';
|
||||
|
||||
@Controller('communities/:communityId/matches/:matchId/competition')
|
||||
export class CompetitionController {
|
||||
constructor(
|
||||
private readonly queryService: CompetitionQueryService,
|
||||
private readonly commandService: CompetitionCommandService,
|
||||
) {}
|
||||
|
||||
@Get()
|
||||
@AllowPublicAccess()
|
||||
public async getDetail(
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Res({ passthrough: true }) response: Response,
|
||||
): Promise<CompetitionDetailResponse> {
|
||||
return this.translate(async () => {
|
||||
const competition = await this.queryService.getCompetition({
|
||||
communityId,
|
||||
matchId,
|
||||
});
|
||||
response.setHeader('ETag', revisionEtag(competition.revision));
|
||||
return presentCompetitionDetail(competition as never);
|
||||
});
|
||||
}
|
||||
|
||||
@Get('team')
|
||||
public async getTeamView(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Res({ passthrough: true }) response?: Response,
|
||||
): Promise<TeamCompetitionViewResponse> {
|
||||
return this.translate(async () => {
|
||||
assertSameCommunity(currentUser, communityId);
|
||||
const result = await this.queryService.getTeamView({
|
||||
communityId,
|
||||
matchId,
|
||||
userId: currentUser._id,
|
||||
});
|
||||
response?.setHeader('ETag', revisionEtag(result.revision));
|
||||
return result;
|
||||
});
|
||||
}
|
||||
|
||||
@Get('facts')
|
||||
@Roles('owner', 'admin')
|
||||
@UseGuards(RolesGuard)
|
||||
public async listFacts(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Query() rawQuery: unknown,
|
||||
): Promise<CompetitionFactsResponse> {
|
||||
return this.translate(async () => {
|
||||
assertSameCommunity(currentUser, communityId);
|
||||
const query = validateDto(CompetitionFactsQueryDto, rawQuery);
|
||||
return this.queryService.listFacts({
|
||||
communityId,
|
||||
matchId,
|
||||
cursor: query.cursor,
|
||||
limit: query.limit,
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
@Post('games/accept')
|
||||
@Roles('owner', 'admin')
|
||||
@UseGuards(RolesGuard)
|
||||
public async acceptGame(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Headers('if-match') ifMatch: string | undefined,
|
||||
@Headers('idempotency-key') idempotencyKey: string | undefined,
|
||||
@Body() rawBody: unknown,
|
||||
): Promise<CompetitionCommandResponse> {
|
||||
return this.translate(async () => {
|
||||
assertSameCommunity(currentUser, communityId);
|
||||
const body = validateDto(AcceptCompetitionGameDto, rawBody);
|
||||
const expectedRevision = requireCommandHeaders(ifMatch, idempotencyKey);
|
||||
const competition = await this.queryService.getCompetition({
|
||||
communityId,
|
||||
matchId,
|
||||
});
|
||||
const result = await this.commandService.acceptGame({
|
||||
competitionId: competition._id,
|
||||
expectedRevision,
|
||||
idempotencyKey: idempotencyKey!,
|
||||
actor: { type: 'user', userId: currentUser._id },
|
||||
gameId: new mongoose.Types.ObjectId(body.gameId),
|
||||
seriesId: new mongoose.Types.ObjectId(body.seriesId),
|
||||
gameSlotId: new mongoose.Types.ObjectId(body.gameSlotId),
|
||||
ordinal: body.ordinal,
|
||||
evidence: { ...body.evidence },
|
||||
mapping: { ...body.mapping },
|
||||
...(body.startedAt ? { startedAt: body.startedAt } : {}),
|
||||
...(body.durationSeconds === undefined
|
||||
? {}
|
||||
: { durationSeconds: body.durationSeconds }),
|
||||
...(body.participants ? { participants: body.participants } : {}),
|
||||
...(body.tournamentCode
|
||||
? {
|
||||
tournamentCode: {
|
||||
tournamentCodeId: new mongoose.Types.ObjectId(
|
||||
body.tournamentCode.tournamentCodeId,
|
||||
),
|
||||
riotMatchId: body.tournamentCode.riotMatchId,
|
||||
},
|
||||
}
|
||||
: {}),
|
||||
});
|
||||
return {
|
||||
competition: presentCompetitionDetail(result.competition as never),
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
@Post('series/:seriesId/adjudications')
|
||||
@Roles('owner', 'admin')
|
||||
@UseGuards(RolesGuard)
|
||||
public async adjudicateSeries(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Param('seriesId', ParseObjectIdPipe) seriesId: mongoose.Types.ObjectId,
|
||||
@Headers('if-match') ifMatch: string | undefined,
|
||||
@Headers('idempotency-key') idempotencyKey: string | undefined,
|
||||
@Body() rawBody: unknown,
|
||||
): Promise<CompetitionCommandResponse> {
|
||||
return this.translate(async () => {
|
||||
assertSameCommunity(currentUser, communityId);
|
||||
const body = validateDto(AdjudicateCompetitionSeriesDto, rawBody);
|
||||
const expectedRevision = requireCommandHeaders(ifMatch, idempotencyKey);
|
||||
const competition = await this.queryService.getCompetition({
|
||||
communityId,
|
||||
matchId,
|
||||
});
|
||||
const decision =
|
||||
body.decision.type === 'administrative-draw'
|
||||
? ({ type: 'administrative-draw' } as const)
|
||||
: {
|
||||
type: body.decision.type,
|
||||
winnerTeamId: new mongoose.Types.ObjectId(
|
||||
body.decision.winnerTeamId!,
|
||||
),
|
||||
};
|
||||
const result = await this.commandService.adjudicateSeries({
|
||||
competitionId: competition._id,
|
||||
expectedRevision,
|
||||
idempotencyKey: idempotencyKey!,
|
||||
actor: { type: 'user', userId: currentUser._id },
|
||||
seriesId,
|
||||
decision,
|
||||
reason: body.reason,
|
||||
});
|
||||
return {
|
||||
competition: presentCompetitionDetail(result.competition as never),
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
@Post('series/:seriesId/reversal-preview')
|
||||
@Roles('owner', 'admin')
|
||||
@UseGuards(RolesGuard)
|
||||
public async previewReversal(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Param('seriesId', ParseObjectIdPipe) seriesId: mongoose.Types.ObjectId,
|
||||
@Headers('if-match') ifMatch: string | undefined,
|
||||
@Body() rawBody: unknown,
|
||||
): Promise<SeriesReversalPreviewResponse> {
|
||||
return this.translate(async () => {
|
||||
assertSameCommunity(currentUser, communityId);
|
||||
const body = validateDto(PreviewCompetitionSeriesReversalDto, rawBody);
|
||||
const expectedRevision = requireRevisionHeader(ifMatch);
|
||||
const competition = await this.queryService.getCompetition({
|
||||
communityId,
|
||||
matchId,
|
||||
});
|
||||
return (await this.commandService.previewSeriesReversal({
|
||||
competitionId: competition._id,
|
||||
expectedRevision,
|
||||
seriesId,
|
||||
mode: body.mode,
|
||||
})) as SeriesReversalPreviewResponse;
|
||||
});
|
||||
}
|
||||
|
||||
@Post('series/:seriesId/reverse')
|
||||
@Roles('owner', 'admin')
|
||||
@UseGuards(RolesGuard)
|
||||
public async reverseSeries(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Param('seriesId', ParseObjectIdPipe) seriesId: mongoose.Types.ObjectId,
|
||||
@Headers('if-match') ifMatch: string | undefined,
|
||||
@Headers('idempotency-key') idempotencyKey: string | undefined,
|
||||
@Body() rawBody: unknown,
|
||||
): Promise<CompetitionCommandResponse> {
|
||||
return this.translate(async () => {
|
||||
assertSameCommunity(currentUser, communityId);
|
||||
const body = validateDto(ReverseCompetitionSeriesDto, rawBody);
|
||||
const expectedRevision = requireCommandHeaders(ifMatch, idempotencyKey);
|
||||
const competition = await this.queryService.getCompetition({
|
||||
communityId,
|
||||
matchId,
|
||||
});
|
||||
const result = await this.commandService.reverseSeries({
|
||||
competitionId: competition._id,
|
||||
expectedRevision,
|
||||
idempotencyKey: idempotencyKey!,
|
||||
actor: { type: 'user', userId: currentUser._id },
|
||||
seriesId,
|
||||
mode: body.mode,
|
||||
reason: body.reason,
|
||||
impactHash: body.impactHash,
|
||||
});
|
||||
return {
|
||||
competition: presentCompetitionDetail(result.competition as never),
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
private async translate<T>(operation: () => Promise<T>): Promise<T> {
|
||||
try {
|
||||
return await operation();
|
||||
} catch (error) {
|
||||
throw explicitHttpError(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function requireCommandHeaders(
|
||||
ifMatch: string | undefined,
|
||||
idempotencyKey: string | undefined,
|
||||
): number {
|
||||
const revision = parseRevision(ifMatch);
|
||||
if (
|
||||
revision === undefined ||
|
||||
typeof idempotencyKey !== 'string' ||
|
||||
idempotencyKey.trim().length === 0 ||
|
||||
idempotencyKey.length > 200
|
||||
) {
|
||||
throw apiHttpError(
|
||||
422,
|
||||
'INVALID_COMPETITION_COMMAND_HEADERS',
|
||||
'A numeric If-Match revision and non-empty Idempotency-Key are required.',
|
||||
);
|
||||
}
|
||||
return revision;
|
||||
}
|
||||
|
||||
function requireRevisionHeader(ifMatch: string | undefined): number {
|
||||
const revision = parseRevision(ifMatch);
|
||||
if (revision === undefined) {
|
||||
throw apiHttpError(
|
||||
422,
|
||||
'INVALID_COMPETITION_COMMAND_HEADERS',
|
||||
'A numeric If-Match revision is required.',
|
||||
);
|
||||
}
|
||||
return revision;
|
||||
}
|
||||
|
||||
function parseRevision(value: string | undefined): number | undefined {
|
||||
if (!value) return undefined;
|
||||
const match = /^(?:W\/)?"?(\d+)"?$/.exec(value.trim());
|
||||
if (!match) return undefined;
|
||||
const revision = Number(match[1]);
|
||||
return Number.isSafeInteger(revision) ? revision : undefined;
|
||||
}
|
||||
|
||||
function revisionEtag(revision: number): string {
|
||||
return `"${revision}"`;
|
||||
}
|
||||
|
||||
function assertSameCommunity(
|
||||
user: UserDocument,
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
): void {
|
||||
if (!user?.communityId?.equals(communityId)) {
|
||||
throw apiHttpError(
|
||||
403,
|
||||
'COMPETITION_COMMUNITY_FORBIDDEN',
|
||||
'The authenticated user does not belong to this community.',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function explicitHttpError(error: unknown): HttpException {
|
||||
if (error instanceof HttpException) {
|
||||
const response = error.getResponse();
|
||||
if (
|
||||
typeof response === 'object' &&
|
||||
response !== null &&
|
||||
'error' in response
|
||||
) {
|
||||
return error;
|
||||
}
|
||||
return apiHttpError(
|
||||
error.getStatus(),
|
||||
statusCodeName(error.getStatus()),
|
||||
typeof response === 'string'
|
||||
? response
|
||||
: error.message || 'Competition request failed.',
|
||||
);
|
||||
}
|
||||
if (isCodedError(error)) {
|
||||
return apiHttpError(
|
||||
error.httpStatus ?? codedErrorStatus(error.code),
|
||||
error.code,
|
||||
error.message,
|
||||
error.details,
|
||||
);
|
||||
}
|
||||
return apiHttpError(
|
||||
500,
|
||||
'COMPETITION_INTERNAL_ERROR',
|
||||
'Competition request failed.',
|
||||
);
|
||||
}
|
||||
|
||||
function codedErrorStatus(code: string): number {
|
||||
switch (code) {
|
||||
case 'REVERSAL_SERIES_NOT_FOUND':
|
||||
case 'REVERSAL_REASON_REQUIRED':
|
||||
return 422;
|
||||
case 'REVERSAL_DESCENDANT_ACTIVITY':
|
||||
case 'REVERSAL_NO_ACTIVE_RESULT':
|
||||
case 'REVERSAL_PREVIEW_STALE':
|
||||
case 'DUPLICATE_FACT_ID':
|
||||
case 'DUPLICATE_GAME_ID':
|
||||
case 'DUPLICATE_RIOT_MATCH_ID':
|
||||
case 'DUPLICATE_GAME_SLOT':
|
||||
case 'DUPLICATE_GAME_ORDINAL':
|
||||
case 'DUPLICATE_ADJUDICATION':
|
||||
case 'FACT_ALREADY_REVERSED':
|
||||
case 'SERIES_ALREADY_COMPLETED':
|
||||
case 'WALKOVER_HAS_ACTIVE_GAMES':
|
||||
return 409;
|
||||
case 'FACT_REFERENCE_NOT_FOUND':
|
||||
case 'FACT_TYPE_INVALID':
|
||||
case 'GAME_SLOT_INVALID':
|
||||
case 'GAME_ORDINAL_INVALID':
|
||||
case 'GAME_SERIES_MISMATCH':
|
||||
case 'GAME_TEAM_MISMATCH':
|
||||
case 'GAME_WINNER_INVALID':
|
||||
case 'SERIES_DEFINITION_INVALID':
|
||||
case 'SERIES_PARTICIPANTS_INVALID':
|
||||
case 'ADJUDICATION_INVALID':
|
||||
case 'ADJUDICATION_DRAW_NOT_ALLOWED':
|
||||
return 422;
|
||||
default:
|
||||
return 500;
|
||||
}
|
||||
}
|
||||
|
||||
function statusCodeName(status: number): string {
|
||||
switch (status) {
|
||||
case 403:
|
||||
return 'COMPETITION_FORBIDDEN';
|
||||
case 404:
|
||||
return 'COMPETITION_NOT_FOUND';
|
||||
case 409:
|
||||
return 'COMPETITION_CONFLICT';
|
||||
case 412:
|
||||
return 'STALE_COMPETITION_REVISION';
|
||||
case 422:
|
||||
return 'INVALID_COMPETITION_REQUEST';
|
||||
default:
|
||||
return 'COMPETITION_REQUEST_FAILED';
|
||||
}
|
||||
}
|
||||
|
||||
function apiHttpError(
|
||||
status: number,
|
||||
code: string,
|
||||
message: string,
|
||||
details?: unknown,
|
||||
): HttpException {
|
||||
return new HttpException(
|
||||
{
|
||||
error: {
|
||||
code,
|
||||
message,
|
||||
...(details === undefined ? {} : { details }),
|
||||
},
|
||||
},
|
||||
status,
|
||||
);
|
||||
}
|
||||
|
||||
function isCodedError(error: unknown): error is {
|
||||
code: string;
|
||||
message: string;
|
||||
httpStatus?: number;
|
||||
details?: unknown;
|
||||
} {
|
||||
return (
|
||||
typeof error === 'object' &&
|
||||
error !== null &&
|
||||
typeof (error as { code?: unknown }).code === 'string' &&
|
||||
typeof (error as { message?: unknown }).message === 'string'
|
||||
);
|
||||
}
|
||||
|
||||
type DtoConstructor<T extends object> = new () => T;
|
||||
|
||||
function validateDto<T extends object>(
|
||||
constructor: DtoConstructor<T>,
|
||||
value: unknown,
|
||||
): T {
|
||||
if (typeof value !== 'object' || value === null || Array.isArray(value)) {
|
||||
throw apiHttpError(
|
||||
422,
|
||||
'INVALID_COMPETITION_REQUEST',
|
||||
'The Competition request body must be an object.',
|
||||
);
|
||||
}
|
||||
const instance = plainToInstance(constructor, value);
|
||||
const errors = validateSync(instance, {
|
||||
whitelist: true,
|
||||
forbidNonWhitelisted: true,
|
||||
forbidUnknownValues: true,
|
||||
});
|
||||
if (errors.length > 0) {
|
||||
throw apiHttpError(
|
||||
422,
|
||||
'INVALID_COMPETITION_REQUEST',
|
||||
'The Competition request payload is invalid.',
|
||||
{ fields: flattenValidationErrors(errors) },
|
||||
);
|
||||
}
|
||||
return instance;
|
||||
}
|
||||
|
||||
function flattenValidationErrors(
|
||||
errors: readonly ValidationError[],
|
||||
prefix = '',
|
||||
): Array<{ field: string; constraints: string[] }> {
|
||||
return errors.flatMap((error) => {
|
||||
const field = prefix ? `${prefix}.${error.property}` : error.property;
|
||||
const current = error.constraints
|
||||
? [{ field, constraints: Object.values(error.constraints) }]
|
||||
: [];
|
||||
return [
|
||||
...current,
|
||||
...flattenValidationErrors(error.children ?? [], field),
|
||||
];
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
export type CompetitionCommandErrorCode =
|
||||
| 'COMPETITION_NOT_FOUND'
|
||||
| 'COMPETITION_TRANSACTION_UNAVAILABLE'
|
||||
| 'IDEMPOTENCY_KEY_CONFLICT'
|
||||
| 'INVALID_COMPETITION_COMMAND'
|
||||
| 'STALE_COMPETITION_REVISION'
|
||||
| 'TOURNAMENT_CODE_ASSIGNMENT_CONFLICT';
|
||||
|
||||
/**
|
||||
* Transport-neutral command failure. Controllers may translate `httpStatus`
|
||||
* directly while command handlers remain usable by jobs and migrations.
|
||||
*/
|
||||
export class CompetitionCommandError extends Error {
|
||||
constructor(
|
||||
public readonly code: CompetitionCommandErrorCode,
|
||||
message: string,
|
||||
public readonly httpStatus: 404 | 409 | 412 | 422 | 500,
|
||||
public readonly details?: Readonly<Record<string, unknown>>,
|
||||
) {
|
||||
super(message);
|
||||
this.name = 'CompetitionCommandError';
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
import { MODULE_METADATA } from '@nestjs/common/constants';
|
||||
import { CompetitionBootstrapService } from './competition-bootstrap.service';
|
||||
import { CompetitionCommandService } from './competition-command.service';
|
||||
import { CompetitionController } from './competition.controller';
|
||||
import { CompetitionModule } from './competition.module';
|
||||
import { CompetitionQueryService } from './competition-query.service';
|
||||
|
||||
describe('CompetitionModule', () => {
|
||||
it('owns and exports the Competition transport and application services', () => {
|
||||
expect(
|
||||
Reflect.getMetadata(MODULE_METADATA.CONTROLLERS, CompetitionModule),
|
||||
).toEqual([CompetitionController]);
|
||||
expect(
|
||||
Reflect.getMetadata(MODULE_METADATA.PROVIDERS, CompetitionModule),
|
||||
).toEqual(
|
||||
expect.arrayContaining([
|
||||
CompetitionBootstrapService,
|
||||
CompetitionCommandService,
|
||||
CompetitionQueryService,
|
||||
]),
|
||||
);
|
||||
expect(
|
||||
Reflect.getMetadata(MODULE_METADATA.EXPORTS, CompetitionModule),
|
||||
).toEqual(
|
||||
expect.arrayContaining([
|
||||
CompetitionBootstrapService,
|
||||
CompetitionCommandService,
|
||||
CompetitionQueryService,
|
||||
]),
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,20 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { CompetitionBootstrapService } from './competition-bootstrap.service';
|
||||
import { CompetitionCommandService } from './competition-command.service';
|
||||
import { CompetitionController } from './competition.controller';
|
||||
import { CompetitionQueryService } from './competition-query.service';
|
||||
|
||||
@Module({
|
||||
controllers: [CompetitionController],
|
||||
providers: [
|
||||
CompetitionBootstrapService,
|
||||
CompetitionCommandService,
|
||||
CompetitionQueryService,
|
||||
],
|
||||
exports: [
|
||||
CompetitionBootstrapService,
|
||||
CompetitionCommandService,
|
||||
CompetitionQueryService,
|
||||
],
|
||||
})
|
||||
export class CompetitionModule {}
|
||||
@@ -0,0 +1,97 @@
|
||||
import { presentCompetitionDetail } from './competition.presenter';
|
||||
|
||||
describe('presentCompetitionDetail', () => {
|
||||
it('returns the explicit public contract without persistence-only fields', () => {
|
||||
const response = presentCompetitionDetail({
|
||||
_id: objectId('competition-1'),
|
||||
matchId: objectId('match-1'),
|
||||
communityId: objectId('community-1'),
|
||||
schemaVersion: 1,
|
||||
projectorVersion: 3,
|
||||
revision: 7,
|
||||
phase: 'running',
|
||||
teams: [
|
||||
{
|
||||
teamId: objectId('team-8'),
|
||||
legacyTeamIndex: 8,
|
||||
displayOrder: 2,
|
||||
seedNumber: 2,
|
||||
name: '똥칼라파워',
|
||||
captainUserId: objectId('captain-8'),
|
||||
members: [
|
||||
{
|
||||
userId: objectId('user-8'),
|
||||
displayName: 'player 8',
|
||||
gameName: '칼라',
|
||||
tagLine: 'KR1',
|
||||
assignedPosition: 'MID',
|
||||
cost: 42,
|
||||
secretPuuid: 'must-not-leak',
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
format: {
|
||||
type: 'paired-series',
|
||||
rule: { type: 'fixed-games', gameCount: 3, drawPolicy: 'allow' },
|
||||
},
|
||||
seriesGraph: [{ internal: true }],
|
||||
projection: {
|
||||
sourceRevision: 7,
|
||||
projectorVersion: 3,
|
||||
phase: 'running',
|
||||
formatType: 'paired-series',
|
||||
series: [],
|
||||
games: [],
|
||||
gameSlots: [],
|
||||
rounds: [],
|
||||
connectors: [],
|
||||
},
|
||||
internalCommandReceipts: [{ idempotencyKey: 'secret' }],
|
||||
createdAt: new Date('2026-07-11T00:00:00.000Z'),
|
||||
updatedAt: new Date('2026-07-12T00:00:00.000Z'),
|
||||
});
|
||||
|
||||
expect(response).toMatchObject({
|
||||
id: 'competition-1',
|
||||
matchId: 'match-1',
|
||||
communityId: 'community-1',
|
||||
schemaVersion: 1,
|
||||
revision: 7,
|
||||
phase: 'running',
|
||||
createdAt: '2026-07-11T00:00:00.000Z',
|
||||
updatedAt: '2026-07-12T00:00:00.000Z',
|
||||
teams: [
|
||||
{
|
||||
teamId: 'team-8',
|
||||
displayOrder: 2,
|
||||
name: '똥칼라파워',
|
||||
captainUserId: 'captain-8',
|
||||
members: [
|
||||
{
|
||||
userId: 'user-8',
|
||||
displayName: 'player 8',
|
||||
gameName: '칼라',
|
||||
tagLine: 'KR1',
|
||||
assignedPosition: 'MID',
|
||||
cost: 42,
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
projection: {
|
||||
sourceRevision: 7,
|
||||
projectorVersion: 3,
|
||||
},
|
||||
});
|
||||
expect(response).not.toHaveProperty('seriesGraph');
|
||||
expect(response).not.toHaveProperty('internalCommandReceipts');
|
||||
expect(response.teams[0]).not.toHaveProperty('legacyTeamIndex');
|
||||
expect(response.teams[0]).not.toHaveProperty('seedNumber');
|
||||
expect(response.teams[0].members[0]).not.toHaveProperty('secretPuuid');
|
||||
});
|
||||
});
|
||||
|
||||
function objectId(value: string) {
|
||||
return { toString: () => value };
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
import type {
|
||||
CommunityId,
|
||||
CompetitionDetailResponse,
|
||||
CompetitionFormat,
|
||||
CompetitionId,
|
||||
CompetitionPhase,
|
||||
CompetitionProjection,
|
||||
MatchId,
|
||||
PlayerPosition,
|
||||
TeamId,
|
||||
UserId,
|
||||
} from '@lolympus/contracts';
|
||||
|
||||
type IdLike = string | { toString(): string };
|
||||
|
||||
interface CompetitionMemberSource {
|
||||
userId: IdLike;
|
||||
displayName: string;
|
||||
gameName?: string;
|
||||
tagLine?: string;
|
||||
profileIconId?: number;
|
||||
assignedPosition?: string;
|
||||
cost?: number;
|
||||
[key: string]: unknown;
|
||||
}
|
||||
|
||||
interface CompetitionTeamSource {
|
||||
teamId: IdLike;
|
||||
displayOrder: number;
|
||||
name: string;
|
||||
captainUserId?: IdLike;
|
||||
members: CompetitionMemberSource[];
|
||||
[key: string]: unknown;
|
||||
}
|
||||
|
||||
export interface CompetitionDetailSource {
|
||||
_id: IdLike;
|
||||
matchId: IdLike;
|
||||
communityId: IdLike;
|
||||
schemaVersion: number;
|
||||
revision: number;
|
||||
phase: CompetitionPhase;
|
||||
teams: CompetitionTeamSource[];
|
||||
format: Record<string, unknown>;
|
||||
projection: Record<string, unknown>;
|
||||
createdAt: Date | string;
|
||||
updatedAt: Date | string;
|
||||
[key: string]: unknown;
|
||||
}
|
||||
|
||||
/** Build the public wire DTO without ever spreading a persistence document. */
|
||||
export function presentCompetitionDetail(
|
||||
source: CompetitionDetailSource,
|
||||
): CompetitionDetailResponse {
|
||||
return {
|
||||
id: asId<CompetitionId>(source._id),
|
||||
matchId: asId<MatchId>(source.matchId),
|
||||
communityId: asId<CommunityId>(source.communityId),
|
||||
schemaVersion: source.schemaVersion,
|
||||
revision: source.revision,
|
||||
phase: source.phase,
|
||||
teams: source.teams.map((team) => ({
|
||||
teamId: asId<TeamId>(team.teamId),
|
||||
displayOrder: team.displayOrder,
|
||||
name: team.name,
|
||||
...(team.captainUserId
|
||||
? { captainUserId: asId<UserId>(team.captainUserId) }
|
||||
: {}),
|
||||
members: team.members.map((member) => ({
|
||||
userId: asId<UserId>(member.userId),
|
||||
displayName: member.displayName,
|
||||
...(member.gameName ? { gameName: member.gameName } : {}),
|
||||
...(member.tagLine ? { tagLine: member.tagLine } : {}),
|
||||
...(member.profileIconId !== undefined
|
||||
? { profileIconId: member.profileIconId }
|
||||
: {}),
|
||||
...(member.assignedPosition
|
||||
? { assignedPosition: member.assignedPosition as PlayerPosition }
|
||||
: {}),
|
||||
...(member.cost !== undefined ? { cost: member.cost } : {}),
|
||||
})),
|
||||
})),
|
||||
format: toWireValue(source.format) as CompetitionFormat,
|
||||
projection: toWireValue(source.projection) as CompetitionProjection,
|
||||
createdAt: asIsoDateTime(source.createdAt),
|
||||
updatedAt: asIsoDateTime(source.updatedAt),
|
||||
};
|
||||
}
|
||||
|
||||
function asId<T extends string>(value: IdLike): T {
|
||||
return value.toString() as T;
|
||||
}
|
||||
|
||||
function asIsoDateTime(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 (isPlainRecord(value)) {
|
||||
return Object.fromEntries(
|
||||
Object.entries(value).map(([key, entry]) => [key, toWireValue(entry)]),
|
||||
);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
function isPlainRecord(value: unknown): value is Record<string, unknown> {
|
||||
return (
|
||||
typeof value === 'object' &&
|
||||
value !== null &&
|
||||
Object.getPrototypeOf(value) === Object.prototype
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
import {
|
||||
COMPETITION_OUTBOX_STATES,
|
||||
CompetitionFactSchema,
|
||||
CompetitionOutboxSchema,
|
||||
CompetitionSchema,
|
||||
TournamentCodeAssignmentSchema,
|
||||
competitionModelDefinitions,
|
||||
} from './competition.schema';
|
||||
import {
|
||||
MatchSchema,
|
||||
MatchStatsSchema,
|
||||
tournamentModelDefinitions,
|
||||
} from '../global/database/schema';
|
||||
|
||||
describe('Competition persistence schemas', () => {
|
||||
it('registers every Competition-owned collection', () => {
|
||||
expect(
|
||||
competitionModelDefinitions.map(({ name, schemaName }) => ({
|
||||
name,
|
||||
schemaName,
|
||||
})),
|
||||
).toEqual([
|
||||
{ name: 'competition', schemaName: 'competition' },
|
||||
{ name: 'competitionFact', schemaName: 'competition_fact' },
|
||||
{ name: 'competitionOutbox', schemaName: 'competition_outbox' },
|
||||
{
|
||||
name: 'tournamentCodeAssignment',
|
||||
schemaName: 'tournament_code_assignment',
|
||||
},
|
||||
]);
|
||||
expect(tournamentModelDefinitions).toEqual(
|
||||
expect.arrayContaining(
|
||||
competitionModelDefinitions.map(({ name, schemaName }) =>
|
||||
expect.objectContaining({ name, schemaName }),
|
||||
),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it('links Match and stats projections to the Competition revision', () => {
|
||||
expect(MatchSchema.path('competitionId')).toBeDefined();
|
||||
expect(MatchStatsSchema.path('sourceCompetitionId')).toBeDefined();
|
||||
expect(MatchStatsSchema.path('sourceRevision')).toBeDefined();
|
||||
expect(MatchStatsSchema.path('projectorVersion')).toBeDefined();
|
||||
expectIndexes(MatchSchema, [
|
||||
{
|
||||
keys: { competitionId: 1 },
|
||||
options: { unique: true },
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
it('enforces one Competition per Match and monotonic revisions', () => {
|
||||
expectIndexes(CompetitionSchema, [
|
||||
{
|
||||
keys: { matchId: 1 },
|
||||
options: { unique: true },
|
||||
},
|
||||
{
|
||||
keys: { communityId: 1, phase: 1, updatedAt: -1 },
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
it('makes fact ordering and command replay identities unique', () => {
|
||||
expect(CompetitionFactSchema.path('startedAt')).toBeDefined();
|
||||
expect(CompetitionFactSchema.path('durationSeconds')).toBeDefined();
|
||||
expect(CompetitionFactSchema.path('participants')).toBeDefined();
|
||||
expectIndexes(CompetitionFactSchema, [
|
||||
{
|
||||
keys: { competitionId: 1, revision: 1, ordinalWithinRevision: 1 },
|
||||
options: { unique: true },
|
||||
},
|
||||
{
|
||||
keys: { competitionId: 1, commandId: 1, ordinalWithinRevision: 1 },
|
||||
options: { unique: true },
|
||||
},
|
||||
{
|
||||
keys: { 'evidence.riotMatchId': 1 },
|
||||
options: { unique: true },
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
it('prevents duplicate outbox events', () => {
|
||||
expectIndexes(CompetitionOutboxSchema, [
|
||||
{
|
||||
keys: { eventId: 1 },
|
||||
options: { unique: true },
|
||||
},
|
||||
{
|
||||
keys: { state: 1, availableAt: 1 },
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
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, [
|
||||
{
|
||||
keys: { gameSlotId: 1 },
|
||||
options: {
|
||||
unique: true,
|
||||
partialFilterExpression: { state: { $in: ['reserved', 'used'] } },
|
||||
},
|
||||
},
|
||||
{
|
||||
keys: { tournamentCodeId: 1 },
|
||||
options: {
|
||||
unique: true,
|
||||
partialFilterExpression: { state: { $in: ['reserved', 'used'] } },
|
||||
},
|
||||
},
|
||||
{
|
||||
keys: { riotMatchId: 1 },
|
||||
options: { unique: true },
|
||||
},
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
function expectIndexes(
|
||||
schema: {
|
||||
indexes(): Array<[Record<string, number>, Record<string, unknown>]>;
|
||||
},
|
||||
expected: Array<{
|
||||
keys: Record<string, number>;
|
||||
options?: Record<string, unknown>;
|
||||
}>,
|
||||
) {
|
||||
const indexes = schema.indexes();
|
||||
for (const candidate of expected) {
|
||||
expect(indexes).toEqual(
|
||||
expect.arrayContaining([
|
||||
[candidate.keys, expect.objectContaining(candidate.options ?? {})],
|
||||
]),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,457 @@
|
||||
import mongoose, { HydratedDocument, Schema } from 'mongoose';
|
||||
|
||||
export const COMPETITION_PHASES = [
|
||||
'ready',
|
||||
'running',
|
||||
'completed',
|
||||
'cancelled',
|
||||
] as const;
|
||||
export type CompetitionPhase = (typeof COMPETITION_PHASES)[number];
|
||||
|
||||
export const COMPETITION_FACT_TYPES = [
|
||||
'game-accepted',
|
||||
'game-voided',
|
||||
'series-adjudicated',
|
||||
'adjudication-reversed',
|
||||
] as const;
|
||||
export type CompetitionFactType = (typeof COMPETITION_FACT_TYPES)[number];
|
||||
|
||||
export const COMPETITION_OUTBOX_STATES = [
|
||||
'pending',
|
||||
'published',
|
||||
'failed',
|
||||
'dead-letter',
|
||||
] as const;
|
||||
export type CompetitionOutboxState = (typeof COMPETITION_OUTBOX_STATES)[number];
|
||||
|
||||
export const TOURNAMENT_CODE_ASSIGNMENT_STATES = [
|
||||
'reserved',
|
||||
'used',
|
||||
'released',
|
||||
'voided',
|
||||
] as const;
|
||||
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;
|
||||
gameName?: string;
|
||||
tagLine?: string;
|
||||
profileIconId?: number;
|
||||
assignedPosition?: string;
|
||||
cost?: number;
|
||||
}
|
||||
|
||||
export interface CompetitionTeamSnapshot {
|
||||
teamId: mongoose.Types.ObjectId;
|
||||
legacyTeamIndex?: number;
|
||||
displayOrder: number;
|
||||
seedNumber: number;
|
||||
name: string;
|
||||
captainUserId?: mongoose.Types.ObjectId;
|
||||
members: CompetitionTeamMemberSnapshot[];
|
||||
}
|
||||
|
||||
export interface Competition {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
schemaVersion: number;
|
||||
projectorVersion: number;
|
||||
revision: number;
|
||||
phase: CompetitionPhase;
|
||||
teams: CompetitionTeamSnapshot[];
|
||||
format: Record<string, unknown>;
|
||||
seriesGraph: Array<Record<string, unknown>>;
|
||||
projection: Record<string, unknown>;
|
||||
createdAt: Date;
|
||||
updatedAt: Date;
|
||||
}
|
||||
|
||||
export type CompetitionDocument = HydratedDocument<Competition>;
|
||||
|
||||
export interface CompetitionFact {
|
||||
competitionId: mongoose.Types.ObjectId;
|
||||
type: CompetitionFactType;
|
||||
revision: number;
|
||||
ordinalWithinRevision: number;
|
||||
commandId: string;
|
||||
idempotencyKey: string;
|
||||
requestHash: string;
|
||||
schemaVersion: number;
|
||||
actor: Record<string, unknown>;
|
||||
occurredAt: Date;
|
||||
recordedAt: Date;
|
||||
causationId?: string;
|
||||
gameId?: mongoose.Types.ObjectId;
|
||||
seriesId?: mongoose.Types.ObjectId;
|
||||
gameSlotId?: mongoose.Types.ObjectId;
|
||||
ordinal?: number;
|
||||
startedAt?: Date;
|
||||
durationSeconds?: number;
|
||||
participants?: Array<Record<string, unknown>>;
|
||||
evidence?: Record<string, unknown>;
|
||||
mapping?: Record<string, unknown>;
|
||||
gameAcceptedFactId?: mongoose.Types.ObjectId;
|
||||
adjudicationFactId?: mongoose.Types.ObjectId;
|
||||
decision?: Record<string, unknown>;
|
||||
reason?: string;
|
||||
createdAt: Date;
|
||||
updatedAt: Date;
|
||||
}
|
||||
|
||||
export type CompetitionFactDocument = HydratedDocument<CompetitionFact>;
|
||||
|
||||
export interface CompetitionOutbox {
|
||||
eventId: string;
|
||||
competitionId: mongoose.Types.ObjectId;
|
||||
revision: number;
|
||||
commandId: string;
|
||||
idempotencyKey: string;
|
||||
requestHash: string;
|
||||
type: string;
|
||||
payload: Record<string, unknown>;
|
||||
state: CompetitionOutboxState;
|
||||
attemptCount: number;
|
||||
availableAt: Date;
|
||||
publishedAt?: Date;
|
||||
lastError?: string;
|
||||
createdAt: Date;
|
||||
updatedAt: Date;
|
||||
}
|
||||
|
||||
export type CompetitionOutboxDocument = HydratedDocument<CompetitionOutbox>;
|
||||
|
||||
export interface TournamentCodeAssignment {
|
||||
competitionId: mongoose.Types.ObjectId;
|
||||
seriesId: mongoose.Types.ObjectId;
|
||||
gameSlotId: mongoose.Types.ObjectId;
|
||||
tournamentCodeId: mongoose.Types.ObjectId;
|
||||
state: TournamentCodeAssignmentState;
|
||||
reservedAt: Date;
|
||||
usedAt?: Date;
|
||||
releasedAt?: Date;
|
||||
voidedAt?: Date;
|
||||
riotMatchId?: string;
|
||||
commandId: string;
|
||||
createdAt: Date;
|
||||
updatedAt: Date;
|
||||
}
|
||||
|
||||
export type TournamentCodeAssignmentDocument =
|
||||
HydratedDocument<TournamentCodeAssignment>;
|
||||
|
||||
const CompetitionTeamMemberSchema = new Schema<CompetitionTeamMemberSnapshot>(
|
||||
{
|
||||
userId: { type: Schema.Types.ObjectId, ref: 'user', required: true },
|
||||
displayName: { type: String, required: true },
|
||||
gameName: { type: String },
|
||||
tagLine: { type: String },
|
||||
profileIconId: { type: Number },
|
||||
assignedPosition: { type: String },
|
||||
cost: { type: Number },
|
||||
},
|
||||
{ _id: false },
|
||||
);
|
||||
|
||||
const CompetitionTeamSchema = new Schema<CompetitionTeamSnapshot>(
|
||||
{
|
||||
teamId: { type: Schema.Types.ObjectId, required: true },
|
||||
legacyTeamIndex: { type: Number, min: 1 },
|
||||
displayOrder: { type: Number, required: true, min: 1 },
|
||||
seedNumber: { type: Number, required: true, min: 1 },
|
||||
name: { type: String, required: true },
|
||||
captainUserId: { type: Schema.Types.ObjectId, ref: 'user' },
|
||||
members: {
|
||||
type: [CompetitionTeamMemberSchema],
|
||||
required: true,
|
||||
default: [],
|
||||
},
|
||||
},
|
||||
{ _id: false },
|
||||
);
|
||||
|
||||
export const CompetitionSchema: mongoose.Schema<Competition> =
|
||||
new Schema<Competition>(
|
||||
{
|
||||
matchId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
ref: 'match',
|
||||
required: true,
|
||||
},
|
||||
communityId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
ref: 'community',
|
||||
required: true,
|
||||
},
|
||||
schemaVersion: { type: Number, required: true, min: 1 },
|
||||
projectorVersion: { type: Number, required: true, min: 1 },
|
||||
revision: { type: Number, required: true, min: 0, default: 0 },
|
||||
phase: {
|
||||
type: String,
|
||||
enum: COMPETITION_PHASES,
|
||||
required: true,
|
||||
default: 'ready',
|
||||
},
|
||||
teams: { type: [CompetitionTeamSchema], required: true },
|
||||
format: { type: Schema.Types.Mixed, required: true },
|
||||
seriesGraph: { type: Schema.Types.Mixed, required: true },
|
||||
projection: { type: Schema.Types.Mixed, required: true },
|
||||
},
|
||||
{ timestamps: true, collection: 'competition' },
|
||||
);
|
||||
|
||||
applyCompetitionDomainInvariantIndexes(CompetitionSchema, 'competition');
|
||||
CompetitionSchema.index({ communityId: 1, phase: 1, updatedAt: -1 });
|
||||
|
||||
export const CompetitionFactSchema = new Schema<CompetitionFact>(
|
||||
{
|
||||
competitionId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
ref: 'competition',
|
||||
required: true,
|
||||
},
|
||||
type: { type: String, enum: COMPETITION_FACT_TYPES, required: true },
|
||||
revision: { type: Number, required: true, min: 1 },
|
||||
ordinalWithinRevision: { type: Number, required: true, min: 1 },
|
||||
commandId: { type: String, required: true },
|
||||
idempotencyKey: { type: String, required: true },
|
||||
requestHash: { type: String, required: true },
|
||||
schemaVersion: { type: Number, required: true, min: 1 },
|
||||
actor: { type: Schema.Types.Mixed, required: true },
|
||||
occurredAt: { type: Date, required: true },
|
||||
recordedAt: { type: Date, required: true },
|
||||
causationId: { type: String },
|
||||
gameId: { type: Schema.Types.ObjectId },
|
||||
seriesId: { type: Schema.Types.ObjectId },
|
||||
gameSlotId: { type: Schema.Types.ObjectId },
|
||||
ordinal: { type: Number, min: 1 },
|
||||
startedAt: { type: Date },
|
||||
durationSeconds: { type: Number, min: 0 },
|
||||
participants: { type: Schema.Types.Mixed },
|
||||
evidence: { type: Schema.Types.Mixed },
|
||||
mapping: { type: Schema.Types.Mixed },
|
||||
gameAcceptedFactId: { type: Schema.Types.ObjectId },
|
||||
adjudicationFactId: { type: Schema.Types.ObjectId },
|
||||
decision: { type: Schema.Types.Mixed },
|
||||
reason: { type: String },
|
||||
},
|
||||
{ timestamps: true, collection: 'competition_fact' },
|
||||
);
|
||||
|
||||
applyCompetitionDomainInvariantIndexes(
|
||||
CompetitionFactSchema,
|
||||
'competition_fact',
|
||||
);
|
||||
CompetitionFactSchema.index({ competitionId: 1, seriesId: 1, recordedAt: 1 });
|
||||
|
||||
export const CompetitionOutboxSchema = new Schema<CompetitionOutbox>(
|
||||
{
|
||||
eventId: { type: String, required: true },
|
||||
competitionId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
ref: 'competition',
|
||||
required: true,
|
||||
},
|
||||
revision: { type: Number, required: true, min: 1 },
|
||||
commandId: { type: String, required: true },
|
||||
idempotencyKey: { type: String, required: true },
|
||||
requestHash: { type: String, required: true },
|
||||
type: { type: String, required: true },
|
||||
payload: { type: Schema.Types.Mixed, required: true },
|
||||
state: {
|
||||
type: String,
|
||||
enum: COMPETITION_OUTBOX_STATES,
|
||||
required: true,
|
||||
default: 'pending',
|
||||
},
|
||||
attemptCount: { type: Number, required: true, min: 0, default: 0 },
|
||||
availableAt: { type: Date, required: true },
|
||||
publishedAt: { type: Date },
|
||||
lastError: { type: String },
|
||||
},
|
||||
{ timestamps: true, collection: 'competition_outbox' },
|
||||
);
|
||||
|
||||
applyCompetitionDomainInvariantIndexes(
|
||||
CompetitionOutboxSchema,
|
||||
'competition_outbox',
|
||||
);
|
||||
CompetitionOutboxSchema.index({ state: 1, availableAt: 1 });
|
||||
|
||||
export const TournamentCodeAssignmentSchema =
|
||||
new Schema<TournamentCodeAssignment>(
|
||||
{
|
||||
competitionId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
ref: 'competition',
|
||||
required: true,
|
||||
},
|
||||
seriesId: { type: Schema.Types.ObjectId, required: true },
|
||||
gameSlotId: { type: Schema.Types.ObjectId, required: true },
|
||||
tournamentCodeId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
ref: 'tournamentCode',
|
||||
required: true,
|
||||
},
|
||||
state: {
|
||||
type: String,
|
||||
enum: TOURNAMENT_CODE_ASSIGNMENT_STATES,
|
||||
required: true,
|
||||
},
|
||||
reservedAt: { type: Date, required: true },
|
||||
usedAt: { type: Date },
|
||||
releasedAt: { type: Date },
|
||||
voidedAt: { type: Date },
|
||||
riotMatchId: { type: String },
|
||||
commandId: { type: String, required: true },
|
||||
},
|
||||
{ timestamps: true, collection: 'tournament_code_assignment' },
|
||||
);
|
||||
|
||||
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;
|
||||
schemaName: string;
|
||||
}> = [
|
||||
{
|
||||
name: 'competition',
|
||||
schema: CompetitionSchema,
|
||||
schemaName: 'competition',
|
||||
},
|
||||
{
|
||||
name: 'competitionFact',
|
||||
schema: CompetitionFactSchema,
|
||||
schemaName: 'competition_fact',
|
||||
},
|
||||
{
|
||||
name: 'competitionOutbox',
|
||||
schema: CompetitionOutboxSchema,
|
||||
schemaName: 'competition_outbox',
|
||||
},
|
||||
{
|
||||
name: 'tournamentCodeAssignment',
|
||||
schema: TournamentCodeAssignmentSchema,
|
||||
schemaName: 'tournament_code_assignment',
|
||||
},
|
||||
];
|
||||
@@ -0,0 +1,619 @@
|
||||
import { projectCompetition } from './competition-projector';
|
||||
import { generateSeriesGraph } from './series-graph';
|
||||
|
||||
describe('projectCompetition', () => {
|
||||
it('keeps a three-way round-robin cycle on a shared rank', () => {
|
||||
const competitionId = 'competition-round-robin-tie';
|
||||
const teams = ['team-1', 'team-2', 'team-3'].map((teamId, index) => ({
|
||||
teamId,
|
||||
displayOrder: index + 1,
|
||||
seedNumber: index + 1,
|
||||
}));
|
||||
const format = {
|
||||
type: 'round-robin' as const,
|
||||
rule: fixedGames(1),
|
||||
tieBreakers: ['series-wins', 'game-diff', 'head-to-head'] as const,
|
||||
};
|
||||
const seriesGraph = generateSeriesGraph({
|
||||
competitionId,
|
||||
teams,
|
||||
format,
|
||||
});
|
||||
const accept = acceptedGameFactory(competitionId);
|
||||
const oneVersusTwo = requireRoundRobinSeries(
|
||||
seriesGraph,
|
||||
'team-1',
|
||||
'team-2',
|
||||
);
|
||||
const oneVersusThree = requireRoundRobinSeries(
|
||||
seriesGraph,
|
||||
'team-1',
|
||||
'team-3',
|
||||
);
|
||||
const twoVersusThree = requireRoundRobinSeries(
|
||||
seriesGraph,
|
||||
'team-2',
|
||||
'team-3',
|
||||
);
|
||||
const facts = [
|
||||
accept(oneVersusTwo, 1, 'team-1', 'team-2', 'team-1'),
|
||||
accept(twoVersusThree, 1, 'team-2', 'team-3', 'team-2'),
|
||||
accept(oneVersusThree, 1, 'team-3', 'team-1', 'team-3'),
|
||||
];
|
||||
|
||||
const projection = projectCompetition({
|
||||
competitionId,
|
||||
revision: facts.length,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts,
|
||||
});
|
||||
|
||||
expect(projection.outcome).toEqual({
|
||||
type: 'round-robin',
|
||||
leaderTeamIds: ['team-1', 'team-2', 'team-3'],
|
||||
standings: [
|
||||
standing('team-1', 1),
|
||||
standing('team-2', 1),
|
||||
standing('team-3', 1),
|
||||
],
|
||||
completedAt: '2026-07-12T00:00:03.000Z',
|
||||
});
|
||||
expect(projection.games).toHaveLength(3);
|
||||
expect(projection.gameSlots).toHaveLength(3);
|
||||
expect(projection.rounds).toEqual(
|
||||
expect.arrayContaining([
|
||||
expect.objectContaining({ stage: 'round-robin', roundNumber: 1 }),
|
||||
]),
|
||||
);
|
||||
});
|
||||
|
||||
it('attributes WB_R2_M2 wins to team ids when series and bracket slot orders differ', () => {
|
||||
const competitionId = 'competition-wb-r2-m2-regression';
|
||||
const teams = [
|
||||
seededTeam('team-1', 1),
|
||||
seededTeam('team-8', 2),
|
||||
seededTeam('team-3', 3),
|
||||
seededTeam('team-4', 4),
|
||||
seededTeam('team-5', 5),
|
||||
seededTeam('team-6', 6),
|
||||
seededTeam('team-7', 7),
|
||||
seededTeam('team-2', 8),
|
||||
];
|
||||
const format = doubleEliminationFormat({ upperWinsRequired: 2 });
|
||||
const seriesGraph = generateSeriesGraph({
|
||||
competitionId,
|
||||
teams,
|
||||
format,
|
||||
});
|
||||
const wbRoundOneMatchThree = requireSeries(seriesGraph, 'WB_R1_M3');
|
||||
const wbRoundOneMatchFour = requireSeries(seriesGraph, 'WB_R1_M4');
|
||||
const wbRoundTwoMatchTwo = requireSeries(seriesGraph, 'WB_R2_M2');
|
||||
const accept = acceptedGameFactory(competitionId);
|
||||
const facts = [
|
||||
accept(wbRoundOneMatchThree, 1, 'team-8', 'team-7', 'team-8'),
|
||||
accept(wbRoundOneMatchThree, 2, 'team-7', 'team-8', 'team-8'),
|
||||
accept(wbRoundOneMatchFour, 1, 'team-3', 'team-6', 'team-3'),
|
||||
accept(wbRoundOneMatchFour, 2, 'team-6', 'team-3', 'team-3'),
|
||||
accept(wbRoundTwoMatchTwo, 1, 'team-3', 'team-8', 'team-8'),
|
||||
accept(wbRoundTwoMatchTwo, 2, 'team-8', 'team-3', 'team-3'),
|
||||
accept(wbRoundTwoMatchTwo, 3, 'team-3', 'team-8', 'team-8'),
|
||||
];
|
||||
|
||||
const projection = projectCompetition({
|
||||
competitionId,
|
||||
revision: facts.length,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts,
|
||||
});
|
||||
|
||||
expect(projectedSeries(projection, 'WB_R2_M2')).toMatchObject({
|
||||
status: 'completed',
|
||||
entries: [
|
||||
{ slot: 'A', teamId: 'team-8', gameWins: 2 },
|
||||
{ slot: 'B', teamId: 'team-3', gameWins: 1 },
|
||||
],
|
||||
outcome: {
|
||||
type: 'played',
|
||||
winnerTeamId: 'team-8',
|
||||
loserTeamId: 'team-3',
|
||||
},
|
||||
});
|
||||
expect(projectedSeries(projection, 'WB_FINAL').entries).toContainEqual({
|
||||
slot: 'B',
|
||||
teamId: 'team-8',
|
||||
gameWins: 0,
|
||||
});
|
||||
expect(projectedSeries(projection, 'LB_R2_M1').entries).toContainEqual({
|
||||
slot: 'B',
|
||||
teamId: 'team-3',
|
||||
gameWins: 0,
|
||||
});
|
||||
expect(projection.games).toHaveLength(7);
|
||||
expect(
|
||||
projection.games.filter(
|
||||
(game) => game.seriesId === wbRoundTwoMatchTwo.id,
|
||||
),
|
||||
).toEqual([
|
||||
expect.objectContaining({ winnerTeamId: 'team-8', ordinal: 1 }),
|
||||
expect.objectContaining({ winnerTeamId: 'team-3', ordinal: 2 }),
|
||||
expect.objectContaining({ winnerTeamId: 'team-8', ordinal: 3 }),
|
||||
]);
|
||||
expect(
|
||||
projection.connectors.some(
|
||||
(connector) =>
|
||||
connector.from.seriesId === wbRoundTwoMatchTwo.id &&
|
||||
connector.from.select === 'winner' &&
|
||||
connector.to.slot === 'B',
|
||||
),
|
||||
).toBe(true);
|
||||
});
|
||||
|
||||
it('activates the predefined reset final only when the lower-bracket finalist wins GF', () => {
|
||||
const competitionId = 'competition-grand-final-reset';
|
||||
const teams = Array.from({ length: 4 }, (_, index) =>
|
||||
seededTeam(`team-${index + 1}`, index + 1),
|
||||
);
|
||||
const format = doubleEliminationFormat({ upperWinsRequired: 1 });
|
||||
const seriesGraph = generateSeriesGraph({
|
||||
competitionId,
|
||||
teams,
|
||||
format,
|
||||
});
|
||||
const resetDefinition = requireSeries(seriesGraph, 'GF_RESET');
|
||||
|
||||
const initial = projectCompetition({
|
||||
competitionId,
|
||||
revision: 0,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts: [],
|
||||
});
|
||||
expect(projectedSeries(initial, 'GF_RESET')).toMatchObject({
|
||||
seriesId: resetDefinition.id,
|
||||
status: 'inactive',
|
||||
});
|
||||
|
||||
const accept = acceptedGameFactory(competitionId);
|
||||
const facts = [
|
||||
accept(
|
||||
requireSeries(seriesGraph, 'WB_R1_M1'),
|
||||
1,
|
||||
'team-1',
|
||||
'team-4',
|
||||
'team-1',
|
||||
),
|
||||
accept(
|
||||
requireSeries(seriesGraph, 'WB_R1_M2'),
|
||||
1,
|
||||
'team-2',
|
||||
'team-3',
|
||||
'team-2',
|
||||
),
|
||||
accept(
|
||||
requireSeries(seriesGraph, 'WB_FINAL'),
|
||||
1,
|
||||
'team-1',
|
||||
'team-2',
|
||||
'team-1',
|
||||
),
|
||||
accept(
|
||||
requireSeries(seriesGraph, 'LB_R1_M1'),
|
||||
1,
|
||||
'team-3',
|
||||
'team-4',
|
||||
'team-3',
|
||||
),
|
||||
accept(
|
||||
requireSeries(seriesGraph, 'LB_FINAL'),
|
||||
1,
|
||||
'team-3',
|
||||
'team-2',
|
||||
'team-2',
|
||||
),
|
||||
accept(requireSeries(seriesGraph, 'GF'), 1, 'team-2', 'team-1', 'team-2'),
|
||||
];
|
||||
|
||||
const afterGrandFinal = projectCompetition({
|
||||
competitionId,
|
||||
revision: facts.length,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts,
|
||||
});
|
||||
|
||||
expect(projectedSeries(afterGrandFinal, 'GF_RESET')).toMatchObject({
|
||||
seriesId: resetDefinition.id,
|
||||
status: 'ready',
|
||||
entries: [
|
||||
{ slot: 'A', teamId: 'team-1', gameWins: 0 },
|
||||
{ slot: 'B', teamId: 'team-2', gameWins: 0 },
|
||||
],
|
||||
});
|
||||
expect(afterGrandFinal).not.toHaveProperty('outcome');
|
||||
expect(afterGrandFinal.gameSlots).toEqual(
|
||||
expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
seriesId: resetDefinition.id,
|
||||
status: 'ready',
|
||||
entries: [
|
||||
{ slot: 'A', teamId: 'team-1' },
|
||||
{ slot: 'B', teamId: 'team-2' },
|
||||
],
|
||||
}),
|
||||
]),
|
||||
);
|
||||
});
|
||||
|
||||
it('makes a voided GameSlot ready again when its Series can be replayed', () => {
|
||||
const competitionId = 'competition-replay-voided-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 definition = seriesGraph[0];
|
||||
const accepted = acceptedGameFactory(competitionId)(
|
||||
definition,
|
||||
1,
|
||||
'team-1',
|
||||
'team-2',
|
||||
'team-1',
|
||||
);
|
||||
|
||||
const projection = projectCompetition({
|
||||
competitionId,
|
||||
revision: 2,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts: [
|
||||
accepted,
|
||||
{
|
||||
id: 'fact-void-game-1',
|
||||
type: 'game-voided',
|
||||
competitionId,
|
||||
revision: 2,
|
||||
ordinalWithinRevision: 1,
|
||||
commandId: 'command-void-game-1',
|
||||
schemaVersion: 1,
|
||||
actor: { type: 'user' as const },
|
||||
occurredAt: new Date('2026-07-12T00:00:02.000Z'),
|
||||
recordedAt: new Date('2026-07-12T00:01:02.000Z'),
|
||||
gameAcceptedFactId: accepted.id,
|
||||
reason: 'Incorrect Riot evidence',
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
expect(projection.phase).toBe('ready');
|
||||
expect(projection.series[0]).toMatchObject({ status: 'ready' });
|
||||
expect(projection.gameSlots[0]).toMatchObject({ status: 'ready' });
|
||||
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) =>
|
||||
seededTeam(`team-${index + 1}`, index + 1),
|
||||
);
|
||||
const format = doubleEliminationFormat({ upperWinsRequired: 1 });
|
||||
const seriesGraph = generateSeriesGraph({ competitionId, teams, format });
|
||||
const accept = acceptedGameFactory(competitionId);
|
||||
const facts: ReturnType<typeof accept>[] = [];
|
||||
let projection = projectCompetition({
|
||||
competitionId,
|
||||
revision: 0,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts,
|
||||
});
|
||||
|
||||
for (let guard = 0; projection.phase !== 'completed'; guard += 1) {
|
||||
if (guard > seriesGraph.length) {
|
||||
throw new Error('Double-elimination projection did not converge.');
|
||||
}
|
||||
const playable = projection.series.find(
|
||||
(series) => series.status === 'ready',
|
||||
);
|
||||
if (!playable) throw new Error('Missing playable Series.');
|
||||
const definition = seriesGraph.find(
|
||||
(series) => series.id === playable.seriesId,
|
||||
);
|
||||
const [entryA, entryB] = playable.entries;
|
||||
if (!definition || !entryA.teamId || !entryB.teamId) {
|
||||
throw new Error('Playable Series has unresolved participants.');
|
||||
}
|
||||
facts.push(
|
||||
accept(definition, 1, entryA.teamId, entryB.teamId, entryA.teamId),
|
||||
);
|
||||
projection = projectCompetition({
|
||||
competitionId,
|
||||
revision: facts.length,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts,
|
||||
});
|
||||
}
|
||||
|
||||
expect(projection.outcome?.type).toBe('double-elimination');
|
||||
if (projection.outcome?.type !== 'double-elimination') {
|
||||
throw new Error('Expected a double-elimination outcome.');
|
||||
}
|
||||
expect(typeof projection.outcome.championTeamId).toBe('string');
|
||||
expect(projection.outcome.placements).toHaveLength(8);
|
||||
expect(projection.placements?.map(({ rank }) => rank)).toEqual([
|
||||
1, 2, 3, 4, 5, 5, 7, 7,
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
function fixedGames(gameCount: number) {
|
||||
return {
|
||||
type: 'fixed-games' as const,
|
||||
gameCount,
|
||||
drawPolicy: 'allow' as const,
|
||||
};
|
||||
}
|
||||
|
||||
function seededTeam(teamId: string, seedNumber: number) {
|
||||
return { teamId, displayOrder: seedNumber, seedNumber };
|
||||
}
|
||||
|
||||
function doubleEliminationFormat(params: { upperWinsRequired: 1 | 2 }) {
|
||||
const upper =
|
||||
params.upperWinsRequired === 1
|
||||
? { type: 'first-to' as const, winsRequired: 1, maxGames: 1 }
|
||||
: { type: 'first-to' as const, winsRequired: 2, maxGames: 3 };
|
||||
const singleGame = {
|
||||
type: 'first-to' as const,
|
||||
winsRequired: 1,
|
||||
maxGames: 1,
|
||||
};
|
||||
return {
|
||||
type: 'double-elimination' as const,
|
||||
resetFinalEnabled: true,
|
||||
rules: {
|
||||
upper,
|
||||
lower: singleGame,
|
||||
grandFinal: singleGame,
|
||||
resetFinal: singleGame,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function requireSeries<
|
||||
T extends { code?: string; id: string; gameSlots: Array<GameSlotLike> },
|
||||
>(graph: T[], code: string): T {
|
||||
const definition = graph.find((series) => series.code === code);
|
||||
if (!definition) throw new Error(`Missing series ${code}`);
|
||||
return definition;
|
||||
}
|
||||
|
||||
function requireRoundRobinSeries<
|
||||
T extends {
|
||||
id: string;
|
||||
gameSlots: Array<GameSlotLike>;
|
||||
slots: Array<{ source: { type: string; teamId?: string } }>;
|
||||
},
|
||||
>(graph: T[], leftTeamId: string, rightTeamId: string): T {
|
||||
const expected = new Set([leftTeamId, rightTeamId]);
|
||||
const definition = graph.find((series) => {
|
||||
const actual = series.slots
|
||||
.filter((slot) => slot.source.type === 'team')
|
||||
.map((slot) => slot.source.teamId);
|
||||
return (
|
||||
actual.length === 2 && actual.every((teamId) => expected.has(teamId!))
|
||||
);
|
||||
});
|
||||
if (!definition) {
|
||||
throw new Error(`Missing round-robin series ${leftTeamId}/${rightTeamId}`);
|
||||
}
|
||||
return definition;
|
||||
}
|
||||
|
||||
function acceptedGameFactory(competitionId: string) {
|
||||
let revision = 0;
|
||||
return <T extends { id: string; gameSlots: Array<GameSlotLike> }>(
|
||||
definition: T,
|
||||
ordinal: number,
|
||||
blueTeamId: string,
|
||||
redTeamId: string,
|
||||
winnerTeamId: string,
|
||||
) => {
|
||||
revision += 1;
|
||||
const gameSlot = definition.gameSlots.find(
|
||||
(candidate) => candidate.ordinal === ordinal,
|
||||
);
|
||||
if (!gameSlot) {
|
||||
throw new Error(`Missing game slot ${definition.id}/${ordinal}`);
|
||||
}
|
||||
return {
|
||||
id: `fact-${revision}`,
|
||||
type: 'game-accepted' as const,
|
||||
competitionId,
|
||||
revision,
|
||||
ordinalWithinRevision: 1,
|
||||
commandId: `command-${revision}`,
|
||||
schemaVersion: 1,
|
||||
actor: { type: 'system' as const },
|
||||
occurredAt: new Date(
|
||||
`2026-07-12T00:00:${String(revision).padStart(2, '0')}.000Z`,
|
||||
),
|
||||
recordedAt: new Date(
|
||||
`2026-07-12T00:01:${String(revision).padStart(2, '0')}.000Z`,
|
||||
),
|
||||
gameId: `game-${revision}`,
|
||||
seriesId: definition.id,
|
||||
gameSlotId: gameSlot.id,
|
||||
ordinal,
|
||||
evidence: {
|
||||
type: 'riot' as const,
|
||||
riotMatchId: `KR_${competitionId}_${revision}`,
|
||||
payloadHash: `sha256:${competitionId}:${revision}`,
|
||||
},
|
||||
mapping: {
|
||||
mappingVersion: 1,
|
||||
confidence: 1,
|
||||
blueTeamId,
|
||||
redTeamId,
|
||||
winnerTeamId,
|
||||
participantAssignments: [],
|
||||
},
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
function projectedSeries<
|
||||
T extends { series: Array<{ code?: string; seriesId: string }> },
|
||||
>(projection: T, code: string) {
|
||||
const series = projection.series.find((candidate) => candidate.code === code);
|
||||
if (!series) throw new Error(`Missing projected series ${code}`);
|
||||
return series;
|
||||
}
|
||||
|
||||
function standing(teamId: string, rank: number) {
|
||||
return {
|
||||
teamId,
|
||||
rank,
|
||||
seriesPlayed: 2,
|
||||
seriesWins: 1,
|
||||
seriesLosses: 1,
|
||||
seriesDraws: 0,
|
||||
gameWins: 1,
|
||||
gameLosses: 1,
|
||||
gameDiff: 0,
|
||||
};
|
||||
}
|
||||
|
||||
interface GameSlotLike {
|
||||
id: string;
|
||||
ordinal: number;
|
||||
}
|
||||
@@ -0,0 +1,995 @@
|
||||
import { assertCompetitionInvariant } from './domain-error';
|
||||
import type {
|
||||
CompetitionGraphFormat,
|
||||
CompetitionGraphTeam,
|
||||
ParticipantSource,
|
||||
SeriesDefinition,
|
||||
} from './series-graph';
|
||||
import {
|
||||
projectSeries,
|
||||
type SeriesDefinitionLike,
|
||||
type SeriesProjection,
|
||||
type SeriesProjectionOutcome,
|
||||
} from './series-projector';
|
||||
|
||||
export interface ProjectCompetitionInput {
|
||||
competitionId: string;
|
||||
revision: number;
|
||||
projectorVersion: number;
|
||||
teams: readonly CompetitionGraphTeam[];
|
||||
format: CompetitionGraphFormat;
|
||||
seriesGraph: readonly SeriesDefinition[];
|
||||
facts: readonly unknown[];
|
||||
}
|
||||
|
||||
export interface RoundRobinStanding {
|
||||
teamId: string;
|
||||
rank: number;
|
||||
seriesPlayed: number;
|
||||
seriesWins: number;
|
||||
seriesLosses: number;
|
||||
seriesDraws: number;
|
||||
gameWins: number;
|
||||
gameLosses: number;
|
||||
gameDiff: number;
|
||||
}
|
||||
|
||||
export interface CompetitionPlacement {
|
||||
teamId: string;
|
||||
rank: number;
|
||||
}
|
||||
|
||||
export interface CompetitionGameProjection {
|
||||
id: string;
|
||||
seriesId: string;
|
||||
gameSlotId: string;
|
||||
ordinal: number;
|
||||
displayNumber: number;
|
||||
evidence:
|
||||
| { type: 'riot'; riotMatchId: string }
|
||||
| { type: 'legacy'; legacyReference: string };
|
||||
teams: {
|
||||
blue: { side: 'blue'; teamId: string };
|
||||
red: { side: 'red'; teamId: string };
|
||||
};
|
||||
winnerTeamId: string;
|
||||
startedAt: string;
|
||||
durationSeconds: number;
|
||||
participants: unknown[];
|
||||
}
|
||||
|
||||
export interface GameSlotProjection {
|
||||
id: string;
|
||||
seriesId: string;
|
||||
ordinal: number;
|
||||
displayNumber: number;
|
||||
status: 'inactive' | 'waiting' | 'ready' | 'completed' | 'voided';
|
||||
entries: [
|
||||
{ slot: 'A'; teamId: string | null },
|
||||
{ slot: 'B'; teamId: string | null },
|
||||
];
|
||||
gameId?: string;
|
||||
}
|
||||
|
||||
export interface BracketRoundProjection {
|
||||
stage: SeriesDefinition['stage']['type'];
|
||||
roundNumber?: number;
|
||||
displayOrder: number;
|
||||
label: string;
|
||||
seriesIds: string[];
|
||||
}
|
||||
|
||||
export interface SeriesConnectorProjection {
|
||||
from: {
|
||||
seriesId: string;
|
||||
select: 'winner' | 'loser' | 'slot-a' | 'slot-b';
|
||||
};
|
||||
to: { seriesId: string; slot: 'A' | 'B' };
|
||||
}
|
||||
|
||||
export type CompetitionProjectionOutcome =
|
||||
| {
|
||||
type: 'paired-series';
|
||||
completedSeriesIds: string[];
|
||||
drawnSeriesIds: string[];
|
||||
completedAt: string;
|
||||
}
|
||||
| {
|
||||
type: 'round-robin';
|
||||
leaderTeamIds: string[];
|
||||
standings: RoundRobinStanding[];
|
||||
completedAt: string;
|
||||
}
|
||||
| {
|
||||
type: 'double-elimination';
|
||||
championTeamId: string;
|
||||
placements: CompetitionPlacement[];
|
||||
completedAt: string;
|
||||
};
|
||||
|
||||
export interface CompetitionProjection {
|
||||
competitionId: string;
|
||||
sourceRevision: number;
|
||||
projectorVersion: number;
|
||||
formatType: CompetitionGraphFormat['type'];
|
||||
phase: 'ready' | 'running' | 'completed';
|
||||
series: SeriesProjection[];
|
||||
games: CompetitionGameProjection[];
|
||||
gameSlots: GameSlotProjection[];
|
||||
rounds: BracketRoundProjection[];
|
||||
connectors: SeriesConnectorProjection[];
|
||||
standings?: RoundRobinStanding[];
|
||||
placements?: CompetitionPlacement[];
|
||||
outcome?: CompetitionProjectionOutcome;
|
||||
}
|
||||
|
||||
/**
|
||||
* Rebuilds all official Competition state from the immutable graph and fact
|
||||
* ledger. Participant identity is always resolved through explicit sources;
|
||||
* display codes and slot/array order are never used as team identity.
|
||||
*/
|
||||
export function projectCompetition(
|
||||
input: ProjectCompetitionInput,
|
||||
): CompetitionProjection {
|
||||
assertPrimaryFactTargetsGraph(input.seriesGraph, input.facts);
|
||||
const teamBySeed = new Map<number, string>();
|
||||
const knownTeams = new Set<string>();
|
||||
for (const team of input.teams) {
|
||||
knownTeams.add(team.teamId);
|
||||
if (team.seedNumber !== undefined) {
|
||||
teamBySeed.set(team.seedNumber, team.teamId);
|
||||
}
|
||||
}
|
||||
|
||||
const definitionsById = new Map(
|
||||
input.seriesGraph.map((definition) => [definition.id, definition]),
|
||||
);
|
||||
const projectedById = new Map<string, SeriesProjection>();
|
||||
const remaining = new Set(input.seriesGraph.map(({ id }) => id));
|
||||
|
||||
// A graph can be stored in any display order. Resolve it as a DAG rather
|
||||
// than relying on that order or parsing diagnostic codes such as WB_R2_M2.
|
||||
let madeProgress = true;
|
||||
while (remaining.size > 0 && madeProgress) {
|
||||
madeProgress = false;
|
||||
|
||||
for (const seriesId of [...remaining]) {
|
||||
const definition = definitionsById.get(seriesId)!;
|
||||
const activation = resolveActivation(definition, projectedById);
|
||||
if (activation === 'pending') continue;
|
||||
|
||||
if (activation === 'inactive') {
|
||||
projectedById.set(
|
||||
definition.id,
|
||||
projectSeries({
|
||||
definition: asProjectorDefinition(definition),
|
||||
participants: resolveAvailableParticipants(
|
||||
definition,
|
||||
knownTeams,
|
||||
teamBySeed,
|
||||
projectedById,
|
||||
),
|
||||
facts: input.facts,
|
||||
active: false,
|
||||
}),
|
||||
);
|
||||
remaining.delete(seriesId);
|
||||
madeProgress = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
const participants = definition.slots.map(({ source }) =>
|
||||
resolveParticipant(source, knownTeams, teamBySeed, projectedById),
|
||||
);
|
||||
if (participants.some((teamId) => teamId === undefined)) continue;
|
||||
|
||||
projectedById.set(
|
||||
definition.id,
|
||||
projectSeries({
|
||||
definition: asProjectorDefinition(definition),
|
||||
participants,
|
||||
facts: input.facts,
|
||||
}),
|
||||
);
|
||||
remaining.delete(seriesId);
|
||||
madeProgress = true;
|
||||
}
|
||||
}
|
||||
|
||||
// An unresolved outcome source is a normal waiting bracket node. Conditional
|
||||
// reset nodes remain inactive until their grand-final condition is known.
|
||||
for (const seriesId of remaining) {
|
||||
const definition = definitionsById.get(seriesId)!;
|
||||
const participants = resolveAvailableParticipants(
|
||||
definition,
|
||||
knownTeams,
|
||||
teamBySeed,
|
||||
projectedById,
|
||||
);
|
||||
projectedById.set(
|
||||
definition.id,
|
||||
projectSeries({
|
||||
definition: asProjectorDefinition(definition),
|
||||
participants,
|
||||
facts: input.facts,
|
||||
...(definition.activation ? { active: false } : {}),
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
const series = input.seriesGraph.map(({ id }) => projectedById.get(id)!);
|
||||
const gameProjection = projectGamesAndSlots(
|
||||
input.seriesGraph,
|
||||
series,
|
||||
input.facts,
|
||||
);
|
||||
const common = {
|
||||
competitionId: input.competitionId,
|
||||
sourceRevision: input.revision,
|
||||
projectorVersion: input.projectorVersion,
|
||||
formatType: input.format.type,
|
||||
series,
|
||||
games: gameProjection.games,
|
||||
gameSlots: gameProjection.gameSlots,
|
||||
rounds: projectRounds(input.seriesGraph),
|
||||
connectors: projectConnectors(input.seriesGraph),
|
||||
};
|
||||
|
||||
switch (input.format.type) {
|
||||
case 'paired-series': {
|
||||
const outcome = pairedSeriesOutcome(series);
|
||||
return {
|
||||
...common,
|
||||
phase: phaseFor(series, outcome),
|
||||
...(outcome ? { outcome } : {}),
|
||||
};
|
||||
}
|
||||
case 'round-robin': {
|
||||
const standings = roundRobinStandings(input.teams, series);
|
||||
const outcome =
|
||||
series.length > 0 &&
|
||||
series.every(({ status }) => status === 'completed')
|
||||
? {
|
||||
type: 'round-robin' as const,
|
||||
leaderTeamIds: standings
|
||||
.filter(({ rank }) => rank === 1)
|
||||
.map(({ teamId }) => teamId),
|
||||
standings,
|
||||
completedAt: competitionCompletedAt(series),
|
||||
}
|
||||
: undefined;
|
||||
return {
|
||||
...common,
|
||||
phase: phaseFor(series, outcome),
|
||||
standings,
|
||||
...(outcome ? { outcome } : {}),
|
||||
};
|
||||
}
|
||||
case 'double-elimination': {
|
||||
const outcome = doubleEliminationOutcome(
|
||||
input.teams,
|
||||
input.format.resetFinalEnabled,
|
||||
series,
|
||||
);
|
||||
return {
|
||||
...common,
|
||||
phase: phaseFor(series, outcome),
|
||||
placements: outcome?.placements ?? [],
|
||||
...(outcome ? { outcome } : {}),
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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 {
|
||||
return definition as unknown as SeriesDefinitionLike;
|
||||
}
|
||||
|
||||
function resolveActivation(
|
||||
definition: SeriesDefinition,
|
||||
projections: ReadonlyMap<string, SeriesProjection>,
|
||||
): 'active' | 'inactive' | 'pending' {
|
||||
if (!definition.activation) return 'active';
|
||||
|
||||
const grandFinal = projections.get(definition.activation.grandFinalSeriesId);
|
||||
if (!grandFinal || grandFinal.status !== 'completed') return 'pending';
|
||||
if (grandFinal.outcome.type === 'draw') return 'inactive';
|
||||
|
||||
const lowerBracketFinalist = grandFinal.entries.find(
|
||||
({ slot }) => slot === 'B',
|
||||
)?.teamId;
|
||||
return grandFinal.outcome.winnerTeamId === lowerBracketFinalist
|
||||
? 'active'
|
||||
: 'inactive';
|
||||
}
|
||||
|
||||
function resolveAvailableParticipants(
|
||||
definition: SeriesDefinition,
|
||||
knownTeams: ReadonlySet<string>,
|
||||
teamBySeed: ReadonlyMap<number, string>,
|
||||
projections: ReadonlyMap<string, SeriesProjection>,
|
||||
): Array<string | null> {
|
||||
return definition.slots.map(
|
||||
({ source }) =>
|
||||
resolveParticipant(source, knownTeams, teamBySeed, projections) ?? null,
|
||||
);
|
||||
}
|
||||
|
||||
function resolveParticipant(
|
||||
source: ParticipantSource,
|
||||
knownTeams: ReadonlySet<string>,
|
||||
teamBySeed: ReadonlyMap<number, string>,
|
||||
projections: ReadonlyMap<string, SeriesProjection>,
|
||||
): string | undefined {
|
||||
switch (source.type) {
|
||||
case 'team':
|
||||
return knownTeams.has(source.teamId) ? source.teamId : undefined;
|
||||
case 'seed':
|
||||
return teamBySeed.get(source.seedNumber);
|
||||
case 'series-outcome': {
|
||||
const sourceSeries = projections.get(source.seriesId);
|
||||
if (!sourceSeries || sourceSeries.status !== 'completed') {
|
||||
return undefined;
|
||||
}
|
||||
if (sourceSeries.outcome.type === 'draw') return undefined;
|
||||
return source.select === 'winner'
|
||||
? sourceSeries.outcome.winnerTeamId
|
||||
: sourceSeries.outcome.loserTeamId;
|
||||
}
|
||||
case 'series-slot': {
|
||||
const sourceSeries = projections.get(source.seriesId);
|
||||
return (
|
||||
sourceSeries?.entries.find(({ slot }) => slot === source.slot)
|
||||
?.teamId ?? undefined
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function pairedSeriesOutcome(
|
||||
series: readonly SeriesProjection[],
|
||||
):
|
||||
| Extract<CompetitionProjectionOutcome, { type: 'paired-series' }>
|
||||
| undefined {
|
||||
if (
|
||||
series.length === 0 ||
|
||||
!series.every(({ status }) => status === 'completed')
|
||||
) {
|
||||
return undefined;
|
||||
}
|
||||
return {
|
||||
type: 'paired-series',
|
||||
completedSeriesIds: series
|
||||
.filter(
|
||||
(candidate) =>
|
||||
candidate.status === 'completed' && candidate.outcome.type !== 'draw',
|
||||
)
|
||||
.map(({ seriesId }) => seriesId),
|
||||
completedAt: competitionCompletedAt(series),
|
||||
drawnSeriesIds: series
|
||||
.filter(
|
||||
(candidate) =>
|
||||
candidate.status === 'completed' && candidate.outcome.type === 'draw',
|
||||
)
|
||||
.map(({ seriesId }) => seriesId),
|
||||
};
|
||||
}
|
||||
|
||||
function roundRobinStandings(
|
||||
teams: readonly CompetitionGraphTeam[],
|
||||
series: readonly SeriesProjection[],
|
||||
): RoundRobinStanding[] {
|
||||
const standingByTeam = new Map(
|
||||
teams.map((team) => [team.teamId, emptyStanding(team.teamId)]),
|
||||
);
|
||||
const completed = series.filter(
|
||||
(candidate): candidate is SeriesProjection & { status: 'completed' } =>
|
||||
candidate.status === 'completed',
|
||||
);
|
||||
|
||||
for (const projected of completed) {
|
||||
addSeriesToStandings(standingByTeam, projected);
|
||||
}
|
||||
|
||||
const displayOrderByTeam = new Map(
|
||||
teams.map(({ teamId, displayOrder }) => [teamId, displayOrder]),
|
||||
);
|
||||
const base = [...standingByTeam.values()].sort(
|
||||
(left, right) =>
|
||||
right.seriesWins - left.seriesWins ||
|
||||
right.gameDiff - left.gameDiff ||
|
||||
stableTeamOrder(left.teamId, right.teamId, displayOrderByTeam),
|
||||
);
|
||||
|
||||
const ranked: RoundRobinStanding[] = [];
|
||||
let start = 0;
|
||||
while (start < base.length) {
|
||||
let end = start + 1;
|
||||
while (
|
||||
end < base.length &&
|
||||
base[end].seriesWins === base[start].seriesWins &&
|
||||
base[end].gameDiff === base[start].gameDiff
|
||||
) {
|
||||
end += 1;
|
||||
}
|
||||
|
||||
const tiedGroup = base.slice(start, end);
|
||||
const teamIds = new Set(tiedGroup.map(({ teamId }) => teamId));
|
||||
const miniTable = new Map(
|
||||
tiedGroup.map(({ teamId }) => [teamId, emptyMiniTableRow()]),
|
||||
);
|
||||
for (const projected of completed) {
|
||||
const participants = projected.entries.map(({ teamId }) => teamId);
|
||||
if (
|
||||
participants.length === 2 &&
|
||||
participants.every(
|
||||
(teamId): teamId is string => teamId !== null && teamIds.has(teamId),
|
||||
)
|
||||
) {
|
||||
addSeriesToMiniTable(miniTable, projected);
|
||||
}
|
||||
}
|
||||
|
||||
tiedGroup.sort((left, right) => {
|
||||
const leftMini = miniTable.get(left.teamId)!;
|
||||
const rightMini = miniTable.get(right.teamId)!;
|
||||
return (
|
||||
rightMini.seriesWins - leftMini.seriesWins ||
|
||||
rightMini.gameDiff - leftMini.gameDiff ||
|
||||
stableTeamOrder(left.teamId, right.teamId, displayOrderByTeam)
|
||||
);
|
||||
});
|
||||
|
||||
let tiedStart = 0;
|
||||
while (tiedStart < tiedGroup.length) {
|
||||
const reference = miniTable.get(tiedGroup[tiedStart].teamId)!;
|
||||
let tiedEnd = tiedStart + 1;
|
||||
while (tiedEnd < tiedGroup.length) {
|
||||
const candidate = miniTable.get(tiedGroup[tiedEnd].teamId)!;
|
||||
if (
|
||||
candidate.seriesWins !== reference.seriesWins ||
|
||||
candidate.gameDiff !== reference.gameDiff
|
||||
) {
|
||||
break;
|
||||
}
|
||||
tiedEnd += 1;
|
||||
}
|
||||
|
||||
const rank = start + tiedStart + 1;
|
||||
for (const standing of tiedGroup.slice(tiedStart, tiedEnd)) {
|
||||
ranked.push({ ...standing, rank });
|
||||
}
|
||||
tiedStart = tiedEnd;
|
||||
}
|
||||
start = end;
|
||||
}
|
||||
|
||||
return ranked;
|
||||
}
|
||||
|
||||
function emptyStanding(teamId: string): RoundRobinStanding {
|
||||
return {
|
||||
teamId,
|
||||
rank: 0,
|
||||
seriesWins: 0,
|
||||
seriesLosses: 0,
|
||||
seriesDraws: 0,
|
||||
seriesPlayed: 0,
|
||||
gameWins: 0,
|
||||
gameLosses: 0,
|
||||
gameDiff: 0,
|
||||
};
|
||||
}
|
||||
|
||||
function addSeriesToStandings(
|
||||
rows: Map<string, RoundRobinStanding>,
|
||||
projected: SeriesProjection & { status: 'completed' },
|
||||
): void {
|
||||
const [entryA, entryB] = projected.entries;
|
||||
if (entryA.teamId === null || entryB.teamId === null) return;
|
||||
const rowA = rows.get(entryA.teamId);
|
||||
const rowB = rows.get(entryB.teamId);
|
||||
if (!rowA || !rowB) return;
|
||||
|
||||
rowA.gameWins += entryA.gameWins;
|
||||
rowA.gameLosses += entryB.gameWins;
|
||||
rowB.gameWins += entryB.gameWins;
|
||||
rowB.gameLosses += entryA.gameWins;
|
||||
rowA.gameDiff = rowA.gameWins - rowA.gameLosses;
|
||||
rowB.gameDiff = rowB.gameWins - rowB.gameLosses;
|
||||
rowA.seriesPlayed += 1;
|
||||
rowB.seriesPlayed += 1;
|
||||
|
||||
if (projected.outcome.type === 'draw') {
|
||||
rowA.seriesDraws += 1;
|
||||
rowB.seriesDraws += 1;
|
||||
return;
|
||||
}
|
||||
rows.get(projected.outcome.winnerTeamId)!.seriesWins += 1;
|
||||
rows.get(projected.outcome.loserTeamId)!.seriesLosses += 1;
|
||||
}
|
||||
|
||||
interface MiniTableRow {
|
||||
seriesWins: number;
|
||||
gameWins: number;
|
||||
gameLosses: number;
|
||||
gameDiff: number;
|
||||
}
|
||||
|
||||
function emptyMiniTableRow(): MiniTableRow {
|
||||
return { seriesWins: 0, gameWins: 0, gameLosses: 0, gameDiff: 0 };
|
||||
}
|
||||
|
||||
function addSeriesToMiniTable(
|
||||
rows: Map<string, MiniTableRow>,
|
||||
projected: SeriesProjection & { status: 'completed' },
|
||||
): void {
|
||||
const [entryA, entryB] = projected.entries;
|
||||
if (entryA.teamId === null || entryB.teamId === null) return;
|
||||
const rowA = rows.get(entryA.teamId)!;
|
||||
const rowB = rows.get(entryB.teamId)!;
|
||||
rowA.gameWins += entryA.gameWins;
|
||||
rowA.gameLosses += entryB.gameWins;
|
||||
rowB.gameWins += entryB.gameWins;
|
||||
rowB.gameLosses += entryA.gameWins;
|
||||
rowA.gameDiff = rowA.gameWins - rowA.gameLosses;
|
||||
rowB.gameDiff = rowB.gameWins - rowB.gameLosses;
|
||||
if (projected.outcome.type !== 'draw') {
|
||||
rows.get(projected.outcome.winnerTeamId)!.seriesWins += 1;
|
||||
}
|
||||
}
|
||||
|
||||
function doubleEliminationOutcome(
|
||||
teams: readonly CompetitionGraphTeam[],
|
||||
resetFinalEnabled: boolean,
|
||||
series: readonly SeriesProjection[],
|
||||
):
|
||||
| Extract<CompetitionProjectionOutcome, { type: 'double-elimination' }>
|
||||
| undefined {
|
||||
const grandFinal = series.find(({ stage }) => stage.type === 'grand-final');
|
||||
if (!grandFinal || grandFinal.status !== 'completed') return undefined;
|
||||
if (grandFinal.outcome.type === 'draw') return undefined;
|
||||
|
||||
let decisiveOutcome: Exclude<SeriesProjectionOutcome, { type: 'draw' }> =
|
||||
grandFinal.outcome;
|
||||
const lowerFinalist = grandFinal.entries.find(
|
||||
({ slot }) => slot === 'B',
|
||||
)?.teamId;
|
||||
if (resetFinalEnabled && grandFinal.outcome.winnerTeamId === lowerFinalist) {
|
||||
const resetFinal = series.find(({ stage }) => stage.type === 'reset-final');
|
||||
if (!resetFinal || resetFinal.status !== 'completed') return undefined;
|
||||
if (resetFinal.outcome.type === 'draw') return undefined;
|
||||
decisiveOutcome = resetFinal.outcome;
|
||||
}
|
||||
|
||||
const championTeamId = decisiveOutcome.winnerTeamId;
|
||||
const runnerUpTeamId = decisiveOutcome.loserTeamId;
|
||||
const placements: CompetitionPlacement[] = [
|
||||
{ teamId: championTeamId, rank: 1 },
|
||||
{ teamId: runnerUpTeamId, rank: 2 },
|
||||
];
|
||||
const alreadyPlaced = new Set([championTeamId, runnerUpTeamId]);
|
||||
const eliminatedByRound = new Map<number, string[]>();
|
||||
|
||||
for (const projected of series) {
|
||||
if (
|
||||
projected.stage.type !== 'lower' ||
|
||||
projected.status !== 'completed' ||
|
||||
projected.outcome.type === 'draw'
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
const key = projected.stage.roundNumber ?? projected.stage.displayOrder;
|
||||
const eliminated = eliminatedByRound.get(key) ?? [];
|
||||
if (!alreadyPlaced.has(projected.outcome.loserTeamId)) {
|
||||
eliminated.push(projected.outcome.loserTeamId);
|
||||
}
|
||||
eliminatedByRound.set(key, eliminated);
|
||||
}
|
||||
|
||||
let nextRank = 3;
|
||||
for (const [, eliminated] of [...eliminatedByRound].sort(
|
||||
([left], [right]) => right - left,
|
||||
)) {
|
||||
const unique = [...new Set(eliminated)].filter(
|
||||
(teamId) => !alreadyPlaced.has(teamId),
|
||||
);
|
||||
unique.sort(
|
||||
(left, right) =>
|
||||
teamDisplayOrder(left, teams) - teamDisplayOrder(right, teams),
|
||||
);
|
||||
for (const teamId of unique) {
|
||||
placements.push({ teamId, rank: nextRank });
|
||||
alreadyPlaced.add(teamId);
|
||||
}
|
||||
nextRank += unique.length;
|
||||
}
|
||||
|
||||
// With a valid 4/8-team graph every team is accounted for by the decisive
|
||||
// final or a lower-bracket elimination. Keep replay deterministic if an old
|
||||
// migrated graph omitted placement metadata.
|
||||
const unplaced = teams
|
||||
.filter(({ teamId }) => !alreadyPlaced.has(teamId))
|
||||
.sort((left, right) => left.displayOrder - right.displayOrder);
|
||||
for (const { teamId } of unplaced) {
|
||||
placements.push({ teamId, rank: nextRank });
|
||||
nextRank += 1;
|
||||
}
|
||||
|
||||
return {
|
||||
type: 'double-elimination',
|
||||
championTeamId,
|
||||
placements,
|
||||
completedAt: decisiveOutcome.completedAt,
|
||||
};
|
||||
}
|
||||
|
||||
interface AcceptedGameProjectionFact {
|
||||
id: string;
|
||||
type: 'game-accepted';
|
||||
revision: number;
|
||||
ordinalWithinRevision: number;
|
||||
gameId: string;
|
||||
seriesId: string;
|
||||
gameSlotId: string;
|
||||
ordinal: number;
|
||||
occurredAt: Date | string;
|
||||
startedAt?: Date | string;
|
||||
durationSeconds?: number;
|
||||
participants?: unknown[];
|
||||
evidence?: {
|
||||
type?: string;
|
||||
riotMatchId?: string;
|
||||
legacyReference?: string;
|
||||
};
|
||||
mapping: {
|
||||
blueTeamId: string;
|
||||
redTeamId: string;
|
||||
winnerTeamId: string;
|
||||
};
|
||||
}
|
||||
|
||||
interface VoidedGameProjectionFact {
|
||||
type: 'game-voided';
|
||||
revision: number;
|
||||
ordinalWithinRevision: number;
|
||||
gameAcceptedFactId: string;
|
||||
}
|
||||
|
||||
function projectGamesAndSlots(
|
||||
graph: readonly SeriesDefinition[],
|
||||
series: readonly SeriesProjection[],
|
||||
facts: readonly unknown[],
|
||||
): {
|
||||
games: CompetitionGameProjection[];
|
||||
gameSlots: GameSlotProjection[];
|
||||
} {
|
||||
const acceptedByFactId = new Map<string, AcceptedGameProjectionFact>();
|
||||
const activeBySlotId = new Map<string, AcceptedGameProjectionFact>();
|
||||
|
||||
for (const fact of projectionGameFacts(facts)) {
|
||||
if (fact.type === 'game-accepted') {
|
||||
acceptedByFactId.set(fact.id, fact);
|
||||
activeBySlotId.set(fact.gameSlotId, fact);
|
||||
continue;
|
||||
}
|
||||
const accepted = acceptedByFactId.get(fact.gameAcceptedFactId);
|
||||
if (!accepted) continue;
|
||||
if (activeBySlotId.get(accepted.gameSlotId)?.id === accepted.id) {
|
||||
activeBySlotId.delete(accepted.gameSlotId);
|
||||
}
|
||||
}
|
||||
|
||||
const displayNumberBySlotId = new Map<string, number>();
|
||||
let displayNumber = 0;
|
||||
for (const definition of graph) {
|
||||
for (const slot of [...definition.gameSlots].sort(
|
||||
(left, right) => left.ordinal - right.ordinal,
|
||||
)) {
|
||||
displayNumber += 1;
|
||||
displayNumberBySlotId.set(slot.id, displayNumber);
|
||||
}
|
||||
}
|
||||
|
||||
const games = [...activeBySlotId.values()]
|
||||
.sort(
|
||||
(left, right) =>
|
||||
(displayNumberBySlotId.get(left.gameSlotId) ?? 0) -
|
||||
(displayNumberBySlotId.get(right.gameSlotId) ?? 0),
|
||||
)
|
||||
.map((fact) => ({
|
||||
id: fact.gameId,
|
||||
seriesId: fact.seriesId,
|
||||
gameSlotId: fact.gameSlotId,
|
||||
ordinal: fact.ordinal,
|
||||
displayNumber: displayNumberBySlotId.get(fact.gameSlotId) ?? 0,
|
||||
evidence:
|
||||
fact.evidence?.type === 'riot' && fact.evidence.riotMatchId
|
||||
? {
|
||||
type: 'riot' as const,
|
||||
riotMatchId: fact.evidence.riotMatchId,
|
||||
}
|
||||
: {
|
||||
type: 'legacy' as const,
|
||||
legacyReference:
|
||||
fact.evidence?.legacyReference ?? `fact:${fact.id}`,
|
||||
},
|
||||
teams: {
|
||||
blue: {
|
||||
side: 'blue' as const,
|
||||
teamId: fact.mapping.blueTeamId,
|
||||
},
|
||||
red: { side: 'red' as const, teamId: fact.mapping.redTeamId },
|
||||
},
|
||||
winnerTeamId: fact.mapping.winnerTeamId,
|
||||
startedAt: toIsoString(fact.startedAt ?? fact.occurredAt),
|
||||
durationSeconds:
|
||||
typeof fact.durationSeconds === 'number' ? fact.durationSeconds : 0,
|
||||
participants: Array.isArray(fact.participants)
|
||||
? [...fact.participants]
|
||||
: [],
|
||||
}));
|
||||
|
||||
const projectedBySeriesId = new Map(
|
||||
series.map((projection) => [projection.seriesId, projection]),
|
||||
);
|
||||
const gameSlots = graph.flatMap((definition) => {
|
||||
const projected = projectedBySeriesId.get(definition.id)!;
|
||||
const entries: GameSlotProjection['entries'] = [
|
||||
{
|
||||
slot: 'A',
|
||||
teamId:
|
||||
projected.entries.find(({ slot }) => slot === 'A')?.teamId ?? null,
|
||||
},
|
||||
{
|
||||
slot: 'B',
|
||||
teamId:
|
||||
projected.entries.find(({ slot }) => slot === 'B')?.teamId ?? null,
|
||||
},
|
||||
];
|
||||
return [...definition.gameSlots]
|
||||
.sort((left, right) => left.ordinal - right.ordinal)
|
||||
.map((slot) => {
|
||||
const game = activeBySlotId.get(slot.id);
|
||||
const status = game
|
||||
? ('completed' as const)
|
||||
: gameSlotStatus(projected.status);
|
||||
return {
|
||||
id: slot.id,
|
||||
seriesId: definition.id,
|
||||
ordinal: slot.ordinal,
|
||||
displayNumber: displayNumberBySlotId.get(slot.id) ?? 0,
|
||||
status,
|
||||
entries,
|
||||
...(game ? { gameId: game.gameId } : {}),
|
||||
};
|
||||
});
|
||||
});
|
||||
|
||||
return { games, gameSlots };
|
||||
}
|
||||
|
||||
function projectionGameFacts(
|
||||
facts: readonly unknown[],
|
||||
): Array<AcceptedGameProjectionFact | VoidedGameProjectionFact> {
|
||||
return facts
|
||||
.filter(
|
||||
(fact): fact is AcceptedGameProjectionFact | VoidedGameProjectionFact =>
|
||||
isRecord(fact) &&
|
||||
(fact.type === 'game-accepted' || fact.type === 'game-voided'),
|
||||
)
|
||||
.sort(
|
||||
(left, right) =>
|
||||
left.revision - right.revision ||
|
||||
left.ordinalWithinRevision - right.ordinalWithinRevision,
|
||||
);
|
||||
}
|
||||
|
||||
function gameSlotStatus(
|
||||
status: SeriesProjection['status'],
|
||||
): GameSlotProjection['status'] {
|
||||
switch (status) {
|
||||
case 'inactive':
|
||||
return 'inactive';
|
||||
case 'waiting':
|
||||
return 'waiting';
|
||||
case 'ready':
|
||||
case 'in-progress':
|
||||
return 'ready';
|
||||
case 'completed':
|
||||
return 'inactive';
|
||||
}
|
||||
}
|
||||
|
||||
function projectRounds(
|
||||
graph: readonly SeriesDefinition[],
|
||||
): BracketRoundProjection[] {
|
||||
const rounds = new Map<string, BracketRoundProjection>();
|
||||
for (const definition of graph) {
|
||||
const { type: stage, roundNumber, displayOrder } = definition.stage;
|
||||
const key = `${stage}:${roundNumber ?? 'none'}`;
|
||||
const existing = rounds.get(key);
|
||||
if (existing) {
|
||||
existing.seriesIds.push(definition.id);
|
||||
existing.displayOrder = Math.min(existing.displayOrder, displayOrder);
|
||||
continue;
|
||||
}
|
||||
rounds.set(key, {
|
||||
stage,
|
||||
...(roundNumber !== undefined ? { roundNumber } : {}),
|
||||
displayOrder,
|
||||
label: roundLabel(stage, roundNumber),
|
||||
seriesIds: [definition.id],
|
||||
});
|
||||
}
|
||||
return [...rounds.values()].sort(
|
||||
(left, right) => left.displayOrder - right.displayOrder,
|
||||
);
|
||||
}
|
||||
|
||||
function roundLabel(
|
||||
stage: SeriesDefinition['stage']['type'],
|
||||
roundNumber?: number,
|
||||
): string {
|
||||
switch (stage) {
|
||||
case 'pair':
|
||||
return 'Pair';
|
||||
case 'round-robin':
|
||||
return `Round ${roundNumber ?? 1}`;
|
||||
case 'upper':
|
||||
return `Upper ${roundNumber ?? 1}`;
|
||||
case 'lower':
|
||||
return `Lower ${roundNumber ?? 1}`;
|
||||
case 'grand-final':
|
||||
return 'Grand Final';
|
||||
case 'reset-final':
|
||||
return 'Reset Final';
|
||||
}
|
||||
}
|
||||
|
||||
function projectConnectors(
|
||||
graph: readonly SeriesDefinition[],
|
||||
): SeriesConnectorProjection[] {
|
||||
const connectors: SeriesConnectorProjection[] = [];
|
||||
for (const definition of graph) {
|
||||
for (const { position, source } of definition.slots) {
|
||||
if (source.type === 'series-outcome') {
|
||||
connectors.push({
|
||||
from: {
|
||||
seriesId: source.seriesId,
|
||||
select: source.select,
|
||||
},
|
||||
to: { seriesId: definition.id, slot: position },
|
||||
});
|
||||
continue;
|
||||
}
|
||||
if (source.type === 'series-slot') {
|
||||
connectors.push({
|
||||
from: {
|
||||
seriesId: source.seriesId,
|
||||
select: source.slot === 'A' ? 'slot-a' : 'slot-b',
|
||||
},
|
||||
to: { seriesId: definition.id, slot: position },
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
return connectors;
|
||||
}
|
||||
|
||||
function competitionCompletedAt(series: readonly SeriesProjection[]): string {
|
||||
return series
|
||||
.filter(
|
||||
(projection): projection is SeriesProjection & { status: 'completed' } =>
|
||||
projection.status === 'completed',
|
||||
)
|
||||
.map(({ outcome }) => outcome.completedAt)
|
||||
.sort()
|
||||
.at(-1)!;
|
||||
}
|
||||
|
||||
function toIsoString(value: Date | string): string {
|
||||
return value instanceof Date ? value.toISOString() : value;
|
||||
}
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return typeof value === 'object' && value !== null;
|
||||
}
|
||||
|
||||
function phaseFor(
|
||||
series: readonly SeriesProjection[],
|
||||
outcome: CompetitionProjectionOutcome | undefined,
|
||||
): CompetitionProjection['phase'] {
|
||||
if (outcome) return 'completed';
|
||||
return series.some(
|
||||
({ status }) => status === 'in-progress' || status === 'completed',
|
||||
)
|
||||
? 'running'
|
||||
: 'ready';
|
||||
}
|
||||
|
||||
function stableTeamOrder(
|
||||
left: string,
|
||||
right: string,
|
||||
displayOrderByTeam: ReadonlyMap<string, number>,
|
||||
): number {
|
||||
return (
|
||||
(displayOrderByTeam.get(left) ?? Number.MAX_SAFE_INTEGER) -
|
||||
(displayOrderByTeam.get(right) ?? Number.MAX_SAFE_INTEGER) ||
|
||||
left.localeCompare(right)
|
||||
);
|
||||
}
|
||||
|
||||
function teamDisplayOrder(
|
||||
teamId: string,
|
||||
teams: readonly CompetitionGraphTeam[],
|
||||
): number {
|
||||
return (
|
||||
teams.find((candidate) => candidate.teamId === teamId)?.displayOrder ??
|
||||
Number.MAX_SAFE_INTEGER
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,215 @@
|
||||
import {
|
||||
assertReversalPreview,
|
||||
buildReversalFacts,
|
||||
previewSeriesReversal,
|
||||
} from './competition-reversal';
|
||||
|
||||
describe('Competition reversal planning', () => {
|
||||
const graph = [
|
||||
series('series-parent', [team('team-8'), team('team-3')]),
|
||||
series('series-child', [winner('series-parent'), loser('series-parent')]),
|
||||
];
|
||||
const facts = [
|
||||
accepted('fact-parent', 'series-parent', 'slot-parent', 'team-8', 'team-3'),
|
||||
accepted('fact-child', 'series-child', 'slot-child', 'team-8', 'team-3'),
|
||||
];
|
||||
const assignments = [
|
||||
assignment('assignment-parent', 'series-parent', 'slot-parent', 'used'),
|
||||
assignment('assignment-child', 'series-child', 'slot-child', 'reserved'),
|
||||
];
|
||||
|
||||
it('rejects strict reversal when a descendant has result activity', () => {
|
||||
expect(() =>
|
||||
previewSeriesReversal({
|
||||
competitionId: 'competition-1',
|
||||
revision: 2,
|
||||
seriesId: 'series-parent',
|
||||
mode: 'strict',
|
||||
graph,
|
||||
facts,
|
||||
assignments,
|
||||
}),
|
||||
).toThrow(
|
||||
expect.objectContaining({ code: 'REVERSAL_DESCENDANT_ACTIVITY' }),
|
||||
);
|
||||
});
|
||||
|
||||
it('builds a deterministic cascade impact from graph descendants', () => {
|
||||
const first = previewSeriesReversal({
|
||||
competitionId: 'competition-1',
|
||||
revision: 2,
|
||||
seriesId: 'series-parent',
|
||||
mode: 'cascade',
|
||||
graph,
|
||||
facts,
|
||||
assignments,
|
||||
});
|
||||
const second = previewSeriesReversal({
|
||||
competitionId: 'competition-1',
|
||||
revision: 2,
|
||||
seriesId: 'series-parent',
|
||||
mode: 'cascade',
|
||||
graph,
|
||||
facts,
|
||||
assignments,
|
||||
});
|
||||
const extraAssignments = [
|
||||
...assignments,
|
||||
assignment('assignment-extra-z', 'series-child', 'slot-z', 'reserved'),
|
||||
assignment('assignment-extra-a', 'series-child', 'slot-a', 'reserved'),
|
||||
];
|
||||
const unorderedFirst = previewSeriesReversal({
|
||||
competitionId: 'competition-1',
|
||||
revision: 2,
|
||||
seriesId: 'series-parent',
|
||||
mode: 'cascade',
|
||||
graph,
|
||||
facts,
|
||||
assignments: extraAssignments,
|
||||
});
|
||||
const unorderedSecond = previewSeriesReversal({
|
||||
competitionId: 'competition-1',
|
||||
revision: 2,
|
||||
seriesId: 'series-parent',
|
||||
mode: 'cascade',
|
||||
graph,
|
||||
facts,
|
||||
assignments: [...extraAssignments].reverse(),
|
||||
});
|
||||
|
||||
expect(second).toEqual(first);
|
||||
expect(unorderedSecond).toEqual(unorderedFirst);
|
||||
expect(first).toEqual({
|
||||
sourceRevision: 2,
|
||||
impactHash: expect.stringMatching(/^[a-f0-9]{64}$/),
|
||||
impact: {
|
||||
seriesIds: ['series-parent', 'series-child'],
|
||||
factIds: ['fact-parent', 'fact-child'],
|
||||
gameSlotIds: ['slot-child', 'slot-parent'],
|
||||
teamIds: ['team-3', 'team-8'],
|
||||
releasesReservedCodes: 1,
|
||||
voidsUsedCodes: 1,
|
||||
requiresStatsRebuild: true,
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it('rejects a stale or changed preview before emitting reversal facts', () => {
|
||||
const preview = previewSeriesReversal({
|
||||
competitionId: 'competition-1',
|
||||
revision: 2,
|
||||
seriesId: 'series-parent',
|
||||
mode: 'cascade',
|
||||
graph,
|
||||
facts,
|
||||
assignments,
|
||||
});
|
||||
|
||||
expect(() =>
|
||||
assertReversalPreview(
|
||||
{
|
||||
competitionId: 'competition-1',
|
||||
revision: 3,
|
||||
seriesId: 'series-parent',
|
||||
mode: 'cascade',
|
||||
graph,
|
||||
facts,
|
||||
assignments,
|
||||
},
|
||||
preview.impactHash,
|
||||
),
|
||||
).toThrow(expect.objectContaining({ code: 'REVERSAL_PREVIEW_STALE' }));
|
||||
});
|
||||
|
||||
it('emits one append-only reversal fact for every active result fact', () => {
|
||||
const preview = previewSeriesReversal({
|
||||
competitionId: 'competition-1',
|
||||
revision: 2,
|
||||
seriesId: 'series-parent',
|
||||
mode: 'cascade',
|
||||
graph,
|
||||
facts,
|
||||
assignments,
|
||||
});
|
||||
|
||||
expect(
|
||||
buildReversalFacts({
|
||||
preview,
|
||||
facts,
|
||||
competitionId: 'competition-1',
|
||||
commandId: 'command-reverse',
|
||||
nextRevision: 3,
|
||||
actor: { type: 'user', userId: 'admin-1' },
|
||||
reason: '잘못 수집된 게임',
|
||||
occurredAt: new Date('2026-07-12T01:00:00.000Z'),
|
||||
}),
|
||||
).toEqual([
|
||||
expect.objectContaining({
|
||||
type: 'game-voided',
|
||||
gameAcceptedFactId: 'fact-parent',
|
||||
revision: 3,
|
||||
ordinalWithinRevision: 1,
|
||||
}),
|
||||
expect.objectContaining({
|
||||
type: 'game-voided',
|
||||
gameAcceptedFactId: 'fact-child',
|
||||
revision: 3,
|
||||
ordinalWithinRevision: 2,
|
||||
}),
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
function series(id: string, sources: Array<Record<string, unknown>>) {
|
||||
return {
|
||||
id,
|
||||
stage: { type: 'upper' as const, displayOrder: 1 },
|
||||
slots: [
|
||||
{ position: 'A' as const, source: sources[0] },
|
||||
{ position: 'B' as const, source: sources[1] },
|
||||
],
|
||||
rule: { type: 'first-to' as const, winsRequired: 1, maxGames: 1 },
|
||||
gameSlots: [{ id: id.replace('series', 'slot'), seriesId: id, ordinal: 1 }],
|
||||
};
|
||||
}
|
||||
|
||||
function team(teamId: string) {
|
||||
return { type: 'team', teamId };
|
||||
}
|
||||
|
||||
function winner(seriesId: string) {
|
||||
return { type: 'series-outcome', seriesId, select: 'winner' };
|
||||
}
|
||||
|
||||
function loser(seriesId: string) {
|
||||
return { type: 'series-outcome', seriesId, select: 'loser' };
|
||||
}
|
||||
|
||||
function accepted(
|
||||
id: string,
|
||||
seriesId: string,
|
||||
gameSlotId: string,
|
||||
winnerTeamId: string,
|
||||
loserTeamId: string,
|
||||
) {
|
||||
return {
|
||||
id,
|
||||
type: 'game-accepted',
|
||||
seriesId,
|
||||
gameSlotId,
|
||||
mapping: {
|
||||
blueTeamId: winnerTeamId,
|
||||
redTeamId: loserTeamId,
|
||||
winnerTeamId,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function assignment(
|
||||
id: string,
|
||||
seriesId: string,
|
||||
gameSlotId: string,
|
||||
state: 'reserved' | 'used',
|
||||
) {
|
||||
return { id, seriesId, gameSlotId, state };
|
||||
}
|
||||
@@ -0,0 +1,362 @@
|
||||
import { createHash } from 'node:crypto';
|
||||
|
||||
export type SeriesReversalMode = 'strict' | 'cascade';
|
||||
|
||||
interface ReversalGraphSeries {
|
||||
id: string;
|
||||
slots: ReadonlyArray<{
|
||||
source: Readonly<{
|
||||
type?: unknown;
|
||||
seriesId?: unknown;
|
||||
}>;
|
||||
}>;
|
||||
}
|
||||
|
||||
interface ReversalFactBase {
|
||||
id: string;
|
||||
type: string;
|
||||
seriesId?: string;
|
||||
}
|
||||
|
||||
interface AcceptedGameFact extends ReversalFactBase {
|
||||
type: 'game-accepted';
|
||||
seriesId: string;
|
||||
gameSlotId: string;
|
||||
mapping: {
|
||||
blueTeamId: string;
|
||||
redTeamId: string;
|
||||
winnerTeamId: string;
|
||||
};
|
||||
}
|
||||
|
||||
interface AdjudicatedFact extends ReversalFactBase {
|
||||
type: 'series-adjudicated';
|
||||
seriesId: string;
|
||||
decision:
|
||||
| { type: string; winnerTeamId?: string }
|
||||
| { type: 'administrative-draw' };
|
||||
}
|
||||
|
||||
interface VoidedGameFact extends ReversalFactBase {
|
||||
type: 'game-voided';
|
||||
gameAcceptedFactId: string;
|
||||
}
|
||||
|
||||
interface ReversedAdjudicationFact extends ReversalFactBase {
|
||||
type: 'adjudication-reversed';
|
||||
adjudicationFactId: string;
|
||||
}
|
||||
|
||||
type ReversalFact =
|
||||
| AcceptedGameFact
|
||||
| AdjudicatedFact
|
||||
| VoidedGameFact
|
||||
| ReversedAdjudicationFact;
|
||||
|
||||
interface ReversalAssignment {
|
||||
seriesId: string;
|
||||
gameSlotId: string;
|
||||
state: string;
|
||||
}
|
||||
|
||||
export interface ReversalPreviewInput {
|
||||
competitionId: string;
|
||||
revision: number;
|
||||
seriesId: string;
|
||||
mode: SeriesReversalMode;
|
||||
graph: readonly ReversalGraphSeries[];
|
||||
facts: readonly unknown[];
|
||||
assignments: readonly ReversalAssignment[];
|
||||
}
|
||||
|
||||
export interface SeriesReversalImpact {
|
||||
seriesIds: string[];
|
||||
factIds: string[];
|
||||
gameSlotIds: string[];
|
||||
teamIds: string[];
|
||||
releasesReservedCodes: number;
|
||||
voidsUsedCodes: number;
|
||||
requiresStatsRebuild: boolean;
|
||||
}
|
||||
|
||||
export interface SeriesReversalPreview {
|
||||
sourceRevision: number;
|
||||
impactHash: string;
|
||||
impact: SeriesReversalImpact;
|
||||
}
|
||||
|
||||
export class CompetitionReversalError extends Error {
|
||||
constructor(
|
||||
public readonly code:
|
||||
| 'REVERSAL_SERIES_NOT_FOUND'
|
||||
| 'REVERSAL_NO_ACTIVE_RESULT'
|
||||
| 'REVERSAL_DESCENDANT_ACTIVITY'
|
||||
| 'REVERSAL_PREVIEW_STALE'
|
||||
| 'REVERSAL_REASON_REQUIRED',
|
||||
message: string,
|
||||
public readonly details?: Readonly<Record<string, unknown>>,
|
||||
) {
|
||||
super(message);
|
||||
this.name = 'CompetitionReversalError';
|
||||
}
|
||||
}
|
||||
|
||||
/** Calculate the exact immutable facts and code assignments affected by a reversal. */
|
||||
export function previewSeriesReversal(
|
||||
input: ReversalPreviewInput,
|
||||
): SeriesReversalPreview {
|
||||
const seriesOrder = affectedSeries(input.graph, input.seriesId);
|
||||
const facts = normalizeReversalFacts(input.facts);
|
||||
const active = activeResultFacts(facts);
|
||||
const affectedSet = new Set(seriesOrder);
|
||||
const descendantSet = new Set(seriesOrder.slice(1));
|
||||
const descendantActivity = active.filter((fact) =>
|
||||
descendantSet.has(fact.seriesId),
|
||||
);
|
||||
const descendantUsedAssignments = input.assignments.filter(
|
||||
(assignment) =>
|
||||
descendantSet.has(assignment.seriesId) && assignment.state === 'used',
|
||||
);
|
||||
|
||||
if (
|
||||
input.mode === 'strict' &&
|
||||
(descendantActivity.length > 0 || descendantUsedAssignments.length > 0)
|
||||
) {
|
||||
throw new CompetitionReversalError(
|
||||
'REVERSAL_DESCENDANT_ACTIVITY',
|
||||
'A descendant Series has result or used-code activity. Preview a cascade reversal.',
|
||||
{
|
||||
seriesIds: [
|
||||
...new Set([
|
||||
...descendantActivity.map(({ seriesId }) => seriesId),
|
||||
...descendantUsedAssignments.map(({ seriesId }) => seriesId),
|
||||
]),
|
||||
],
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
const selectedFacts = active.filter(
|
||||
(fact) =>
|
||||
fact.seriesId === input.seriesId ||
|
||||
(input.mode === 'cascade' && descendantSet.has(fact.seriesId)),
|
||||
);
|
||||
if (!selectedFacts.some(({ seriesId }) => seriesId === input.seriesId)) {
|
||||
throw new CompetitionReversalError(
|
||||
'REVERSAL_NO_ACTIVE_RESULT',
|
||||
`Series ${input.seriesId} has no active result to reverse.`,
|
||||
{ seriesId: input.seriesId },
|
||||
);
|
||||
}
|
||||
|
||||
const factOrder = new Map(
|
||||
seriesOrder.map((seriesId, index) => [seriesId, index]),
|
||||
);
|
||||
selectedFacts.sort(
|
||||
(left, right) =>
|
||||
factOrder.get(left.seriesId)! - factOrder.get(right.seriesId)!,
|
||||
);
|
||||
const assignments = input.assignments.filter((assignment) =>
|
||||
affectedSet.has(assignment.seriesId),
|
||||
);
|
||||
const teamIds = new Set<string>();
|
||||
const gameSlotIds = new Set<string>();
|
||||
for (const fact of selectedFacts) {
|
||||
if (fact.type === 'game-accepted') {
|
||||
gameSlotIds.add(fact.gameSlotId);
|
||||
teamIds.add(fact.mapping.blueTeamId);
|
||||
teamIds.add(fact.mapping.redTeamId);
|
||||
} else if ('winnerTeamId' in fact.decision && fact.decision.winnerTeamId) {
|
||||
teamIds.add(fact.decision.winnerTeamId);
|
||||
}
|
||||
}
|
||||
for (const assignment of assignments) gameSlotIds.add(assignment.gameSlotId);
|
||||
|
||||
const impact: SeriesReversalImpact = {
|
||||
seriesIds: seriesOrder,
|
||||
factIds: selectedFacts.map(({ id }) => id),
|
||||
gameSlotIds: [...gameSlotIds].sort(),
|
||||
teamIds: [...teamIds].sort(),
|
||||
releasesReservedCodes: assignments.filter(
|
||||
({ state }) => state === 'reserved',
|
||||
).length,
|
||||
voidsUsedCodes: assignments.filter(({ state }) => state === 'used').length,
|
||||
requiresStatsRebuild: selectedFacts.some(
|
||||
({ type }) => type === 'game-accepted',
|
||||
),
|
||||
};
|
||||
return {
|
||||
sourceRevision: input.revision,
|
||||
impactHash: hashImpact(input, impact),
|
||||
impact,
|
||||
};
|
||||
}
|
||||
|
||||
export function assertReversalPreview(
|
||||
input: ReversalPreviewInput,
|
||||
expectedImpactHash: string,
|
||||
): SeriesReversalPreview {
|
||||
const current = previewSeriesReversal(input);
|
||||
if (current.impactHash !== expectedImpactHash) {
|
||||
throw new CompetitionReversalError(
|
||||
'REVERSAL_PREVIEW_STALE',
|
||||
'The Competition changed after the reversal preview.',
|
||||
{ sourceRevision: input.revision },
|
||||
);
|
||||
}
|
||||
return current;
|
||||
}
|
||||
|
||||
export function buildReversalFacts(input: {
|
||||
preview: SeriesReversalPreview;
|
||||
facts: readonly unknown[];
|
||||
competitionId: string;
|
||||
commandId: string;
|
||||
nextRevision: number;
|
||||
actor: Readonly<Record<string, unknown>>;
|
||||
reason: string;
|
||||
occurredAt: Date;
|
||||
}): Array<Record<string, unknown>> {
|
||||
if (!input.reason.trim()) {
|
||||
throw new CompetitionReversalError(
|
||||
'REVERSAL_REASON_REQUIRED',
|
||||
'A reversal reason is required.',
|
||||
);
|
||||
}
|
||||
const byId = new Map(
|
||||
normalizeReversalFacts(input.facts).map((fact) => [fact.id, fact]),
|
||||
);
|
||||
const causationId = deterministicId(
|
||||
input.competitionId,
|
||||
input.commandId,
|
||||
'reversal',
|
||||
);
|
||||
|
||||
return input.preview.impact.factIds.map((factId, index) => {
|
||||
const target = byId.get(factId);
|
||||
if (!target) {
|
||||
throw new CompetitionReversalError(
|
||||
'REVERSAL_PREVIEW_STALE',
|
||||
`Fact ${factId} no longer matches the preview.`,
|
||||
);
|
||||
}
|
||||
const common = {
|
||||
id: deterministicId(input.competitionId, input.commandId, factId),
|
||||
competitionId: input.competitionId,
|
||||
revision: input.nextRevision,
|
||||
ordinalWithinRevision: index + 1,
|
||||
commandId: input.commandId,
|
||||
schemaVersion: 1,
|
||||
actor: input.actor,
|
||||
occurredAt: input.occurredAt,
|
||||
recordedAt: input.occurredAt,
|
||||
causationId,
|
||||
reason: input.reason,
|
||||
};
|
||||
return target.type === 'game-accepted'
|
||||
? {
|
||||
...common,
|
||||
type: 'game-voided',
|
||||
gameAcceptedFactId: target.id,
|
||||
}
|
||||
: {
|
||||
...common,
|
||||
type: 'adjudication-reversed',
|
||||
adjudicationFactId: target.id,
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
function affectedSeries(
|
||||
graph: readonly ReversalGraphSeries[],
|
||||
sourceSeriesId: string,
|
||||
): string[] {
|
||||
if (!graph.some(({ id }) => id === sourceSeriesId)) {
|
||||
throw new CompetitionReversalError(
|
||||
'REVERSAL_SERIES_NOT_FOUND',
|
||||
`Series ${sourceSeriesId} does not exist.`,
|
||||
);
|
||||
}
|
||||
const affected = new Set([sourceSeriesId]);
|
||||
let changed = true;
|
||||
while (changed) {
|
||||
changed = false;
|
||||
for (const definition of graph) {
|
||||
if (affected.has(definition.id)) continue;
|
||||
if (
|
||||
definition.slots.some(({ source }) =>
|
||||
typeof source.seriesId === 'string'
|
||||
? affected.has(source.seriesId)
|
||||
: false,
|
||||
)
|
||||
) {
|
||||
affected.add(definition.id);
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return graph.filter(({ id }) => affected.has(id)).map(({ id }) => id);
|
||||
}
|
||||
|
||||
function normalizeReversalFacts(facts: readonly unknown[]): ReversalFact[] {
|
||||
return facts.filter((fact): fact is ReversalFact => {
|
||||
if (!isRecord(fact) || typeof fact.id !== 'string') return false;
|
||||
return (
|
||||
fact.type === 'game-accepted' ||
|
||||
fact.type === 'series-adjudicated' ||
|
||||
fact.type === 'game-voided' ||
|
||||
fact.type === 'adjudication-reversed'
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
function activeResultFacts(
|
||||
facts: readonly ReversalFact[],
|
||||
): Array<AcceptedGameFact | AdjudicatedFact> {
|
||||
const voided = new Set(
|
||||
facts
|
||||
.filter((fact): fact is VoidedGameFact => fact.type === 'game-voided')
|
||||
.map(({ gameAcceptedFactId }) => gameAcceptedFactId),
|
||||
);
|
||||
const reversed = new Set(
|
||||
facts
|
||||
.filter(
|
||||
(fact): fact is ReversedAdjudicationFact =>
|
||||
fact.type === 'adjudication-reversed',
|
||||
)
|
||||
.map(({ adjudicationFactId }) => adjudicationFactId),
|
||||
);
|
||||
return facts.filter(
|
||||
(fact): fact is AcceptedGameFact | AdjudicatedFact =>
|
||||
(fact.type === 'game-accepted' && !voided.has(fact.id)) ||
|
||||
(fact.type === 'series-adjudicated' && !reversed.has(fact.id)),
|
||||
);
|
||||
}
|
||||
|
||||
function hashImpact(
|
||||
input: ReversalPreviewInput,
|
||||
impact: SeriesReversalImpact,
|
||||
): string {
|
||||
return createHash('sha256')
|
||||
.update(
|
||||
JSON.stringify({
|
||||
competitionId: input.competitionId,
|
||||
sourceRevision: input.revision,
|
||||
seriesId: input.seriesId,
|
||||
mode: input.mode,
|
||||
impact,
|
||||
}),
|
||||
)
|
||||
.digest('hex');
|
||||
}
|
||||
|
||||
function deterministicId(...parts: string[]): string {
|
||||
return createHash('sha256')
|
||||
.update(JSON.stringify(parts))
|
||||
.digest('hex')
|
||||
.slice(0, 24);
|
||||
}
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return typeof value === 'object' && value !== null;
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
export type CompetitionDomainErrorCode =
|
||||
| 'DUPLICATE_FACT_ID'
|
||||
| 'DUPLICATE_GAME_ID'
|
||||
| 'DUPLICATE_RIOT_MATCH_ID'
|
||||
| 'DUPLICATE_GAME_SLOT'
|
||||
| 'DUPLICATE_GAME_ORDINAL'
|
||||
| 'DUPLICATE_ADJUDICATION'
|
||||
| 'FACT_REFERENCE_NOT_FOUND'
|
||||
| 'FACT_ALREADY_REVERSED'
|
||||
| 'FACT_TYPE_INVALID'
|
||||
| 'GAME_SLOT_INVALID'
|
||||
| 'GAME_ORDINAL_INVALID'
|
||||
| 'GAME_SERIES_MISMATCH'
|
||||
| 'GAME_TEAM_MISMATCH'
|
||||
| 'GAME_WINNER_INVALID'
|
||||
| 'SERIES_ALREADY_COMPLETED'
|
||||
| 'SERIES_DEFINITION_INVALID'
|
||||
| 'SERIES_PARTICIPANTS_INVALID'
|
||||
| 'ADJUDICATION_INVALID'
|
||||
| 'ADJUDICATION_DRAW_NOT_ALLOWED'
|
||||
| 'WALKOVER_HAS_ACTIVE_GAMES';
|
||||
|
||||
/**
|
||||
* A deterministic domain-invariant failure. Command handlers translate these
|
||||
* errors to the appropriate HTTP conflict/validation response; projectors do
|
||||
* not depend on NestJS or transport concerns.
|
||||
*/
|
||||
export class CompetitionDomainError extends Error {
|
||||
constructor(
|
||||
public readonly code: CompetitionDomainErrorCode,
|
||||
message: string,
|
||||
public readonly details?: Readonly<Record<string, unknown>>,
|
||||
) {
|
||||
super(message);
|
||||
this.name = 'CompetitionDomainError';
|
||||
}
|
||||
}
|
||||
|
||||
export function assertCompetitionInvariant(
|
||||
condition: unknown,
|
||||
code: CompetitionDomainErrorCode,
|
||||
message: string,
|
||||
details?: Readonly<Record<string, unknown>>,
|
||||
): asserts condition {
|
||||
if (!condition) {
|
||||
throw new CompetitionDomainError(code, message, details);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
import { generateSeriesGraph } from './series-graph';
|
||||
|
||||
describe('generateSeriesGraph', () => {
|
||||
it('generates a deterministic graph with stable opaque ids', () => {
|
||||
const input = {
|
||||
competitionId: 'competition-deterministic',
|
||||
teams: Array.from({ length: 8 }, (_, index) => ({
|
||||
teamId: `team-${index + 1}`,
|
||||
displayOrder: index + 1,
|
||||
seedNumber: index + 1,
|
||||
})),
|
||||
format: {
|
||||
type: 'double-elimination' as const,
|
||||
resetFinalEnabled: true,
|
||||
rules: {
|
||||
upper: firstTo(2, 3),
|
||||
lower: firstTo(1, 1),
|
||||
grandFinal: firstTo(1, 1),
|
||||
resetFinal: firstTo(1, 1),
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
const first = generateSeriesGraph(input);
|
||||
const second = generateSeriesGraph(input);
|
||||
|
||||
expect(second).toEqual(first);
|
||||
expect(first.map((series) => series.id)).toHaveLength(15);
|
||||
expect(new Set(first.map((series) => series.id))).toHaveProperty(
|
||||
'size',
|
||||
15,
|
||||
);
|
||||
expect(first.every((series) => series.id.length > 0)).toBe(true);
|
||||
});
|
||||
|
||||
it('predefines a conditional grand-final reset node using only slot sources', () => {
|
||||
const graph = generateSeriesGraph({
|
||||
competitionId: 'competition-reset-node',
|
||||
teams: Array.from({ length: 4 }, (_, index) => ({
|
||||
teamId: `team-${index + 1}`,
|
||||
displayOrder: index + 1,
|
||||
seedNumber: index + 1,
|
||||
})),
|
||||
format: {
|
||||
type: 'double-elimination' as const,
|
||||
resetFinalEnabled: true,
|
||||
rules: {
|
||||
upper: firstTo(2, 3),
|
||||
lower: firstTo(1, 1),
|
||||
grandFinal: firstTo(1, 1),
|
||||
resetFinal: firstTo(1, 1),
|
||||
},
|
||||
},
|
||||
});
|
||||
const grandFinal = graph.find((series) => series.code === 'GF');
|
||||
const resetFinal = graph.find((series) => series.code === 'GF_RESET');
|
||||
|
||||
expect(grandFinal).toBeDefined();
|
||||
expect(resetFinal).toMatchObject({
|
||||
stage: { type: 'reset-final' },
|
||||
activation: {
|
||||
type: 'grand-final-reset-required',
|
||||
grandFinalSeriesId: grandFinal!.id,
|
||||
},
|
||||
slots: [
|
||||
{
|
||||
position: 'A',
|
||||
source: {
|
||||
type: 'series-slot',
|
||||
seriesId: grandFinal!.id,
|
||||
slot: 'A',
|
||||
},
|
||||
},
|
||||
{
|
||||
position: 'B',
|
||||
source: {
|
||||
type: 'series-slot',
|
||||
seriesId: grandFinal!.id,
|
||||
slot: 'B',
|
||||
},
|
||||
},
|
||||
],
|
||||
});
|
||||
for (const series of graph) {
|
||||
expect(series).not.toHaveProperty('winnerAdvancesTo');
|
||||
expect(series).not.toHaveProperty('loserAdvancesTo');
|
||||
}
|
||||
});
|
||||
|
||||
it('rejects a first-to rule that can exhaust every GameSlot without a winner', () => {
|
||||
try {
|
||||
generateSeriesGraph({
|
||||
competitionId: 'competition-unfinishable-first-to',
|
||||
teams: Array.from({ length: 4 }, (_, index) => ({
|
||||
teamId: `team-${index + 1}`,
|
||||
displayOrder: index + 1,
|
||||
seedNumber: index + 1,
|
||||
})),
|
||||
format: {
|
||||
type: 'double-elimination',
|
||||
resetFinalEnabled: false,
|
||||
rules: {
|
||||
upper: firstTo(2, 2),
|
||||
lower: firstTo(1, 1),
|
||||
grandFinal: firstTo(1, 1),
|
||||
resetFinal: firstTo(1, 1),
|
||||
},
|
||||
},
|
||||
});
|
||||
throw new Error('Expected INVALID_FIRST_TO_RULE');
|
||||
} catch (error) {
|
||||
expect(error).toMatchObject({ code: 'INVALID_FIRST_TO_RULE' });
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
function firstTo(winsRequired: number, maxGames: number) {
|
||||
return { type: 'first-to' as const, winsRequired, maxGames };
|
||||
}
|
||||
@@ -0,0 +1,647 @@
|
||||
import { createHash } from 'node:crypto';
|
||||
|
||||
export type SeriesSlot = 'A' | 'B';
|
||||
|
||||
export type FirstToSeriesRule = {
|
||||
type: 'first-to';
|
||||
winsRequired: number;
|
||||
maxGames: number;
|
||||
};
|
||||
|
||||
export type FixedGamesSeriesRule = {
|
||||
type: 'fixed-games';
|
||||
gameCount: number;
|
||||
drawPolicy: 'allow' | 'tiebreak-required';
|
||||
};
|
||||
|
||||
export type SeriesRule = FirstToSeriesRule | FixedGamesSeriesRule;
|
||||
|
||||
export type ParticipantSource =
|
||||
| { type: 'team'; teamId: string }
|
||||
| { type: 'seed'; seedNumber: number }
|
||||
| {
|
||||
type: 'series-outcome';
|
||||
seriesId: string;
|
||||
select: 'winner' | 'loser';
|
||||
}
|
||||
| {
|
||||
type: 'series-slot';
|
||||
seriesId: string;
|
||||
slot: SeriesSlot;
|
||||
};
|
||||
|
||||
export type SeriesStageType =
|
||||
| 'pair'
|
||||
| 'round-robin'
|
||||
| 'upper'
|
||||
| 'lower'
|
||||
| 'grand-final'
|
||||
| 'reset-final';
|
||||
|
||||
export interface SeriesDefinition {
|
||||
id: string;
|
||||
code?: string;
|
||||
stage: {
|
||||
type: SeriesStageType;
|
||||
roundNumber?: number;
|
||||
displayOrder: number;
|
||||
};
|
||||
slots: [
|
||||
{ position: 'A'; source: ParticipantSource },
|
||||
{ position: 'B'; source: ParticipantSource },
|
||||
];
|
||||
rule: SeriesRule;
|
||||
activation?: {
|
||||
type: 'grand-final-reset-required';
|
||||
grandFinalSeriesId: string;
|
||||
};
|
||||
gameSlots: Array<{
|
||||
id: string;
|
||||
seriesId: string;
|
||||
ordinal: number;
|
||||
}>;
|
||||
}
|
||||
|
||||
export interface CompetitionGraphTeam {
|
||||
teamId: string;
|
||||
displayOrder: number;
|
||||
seedNumber?: number;
|
||||
}
|
||||
|
||||
export type CompetitionGraphFormat =
|
||||
| {
|
||||
type: 'paired-series';
|
||||
rule: FixedGamesSeriesRule;
|
||||
}
|
||||
| {
|
||||
type: 'round-robin';
|
||||
rule: FixedGamesSeriesRule;
|
||||
maxRounds?: number;
|
||||
tieBreakers: readonly ['series-wins', 'game-diff', 'head-to-head'];
|
||||
}
|
||||
| {
|
||||
type: 'double-elimination';
|
||||
teamCount?: 4 | 8;
|
||||
resetFinalEnabled: boolean;
|
||||
rules: {
|
||||
upper: FirstToSeriesRule;
|
||||
lower: FirstToSeriesRule;
|
||||
grandFinal: FirstToSeriesRule;
|
||||
resetFinal: FirstToSeriesRule;
|
||||
};
|
||||
};
|
||||
|
||||
export interface GenerateSeriesGraphInput {
|
||||
competitionId: string;
|
||||
teams: readonly CompetitionGraphTeam[];
|
||||
format: CompetitionGraphFormat;
|
||||
}
|
||||
|
||||
interface DoubleEliminationTemplate {
|
||||
code: string;
|
||||
stage: Extract<
|
||||
SeriesStageType,
|
||||
'upper' | 'lower' | 'grand-final' | 'reset-final'
|
||||
>;
|
||||
roundNumber: number;
|
||||
sources: [TemplateParticipantSource, TemplateParticipantSource];
|
||||
}
|
||||
|
||||
type TemplateParticipantSource =
|
||||
| { type: 'seed'; seedNumber: number }
|
||||
| {
|
||||
type: 'series-outcome';
|
||||
seriesCode: string;
|
||||
select: 'winner' | 'loser';
|
||||
}
|
||||
| { type: 'series-slot'; seriesCode: string; slot: SeriesSlot };
|
||||
|
||||
interface RoundRobinPairing {
|
||||
roundNumber: number;
|
||||
teamAIndex: number;
|
||||
teamBIndex: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds the immutable Series graph. Identifiers depend only on the Competition
|
||||
* identity and the logical node/slot key, never on array position or a display
|
||||
* number supplied by a client.
|
||||
*/
|
||||
export function generateSeriesGraph(
|
||||
input: GenerateSeriesGraphInput,
|
||||
): SeriesDefinition[] {
|
||||
assertCompetitionId(input.competitionId);
|
||||
const teams = normalizeTeams(input.teams);
|
||||
|
||||
let graph: SeriesDefinition[];
|
||||
switch (input.format.type) {
|
||||
case 'paired-series':
|
||||
graph = generatePairedSeriesGraph(
|
||||
input.competitionId,
|
||||
teams,
|
||||
input.format.rule,
|
||||
);
|
||||
break;
|
||||
case 'round-robin':
|
||||
graph = generateRoundRobinGraph(
|
||||
input.competitionId,
|
||||
teams,
|
||||
input.format.rule,
|
||||
input.format.maxRounds,
|
||||
);
|
||||
break;
|
||||
case 'double-elimination':
|
||||
graph = generateDoubleEliminationGraph(
|
||||
input.competitionId,
|
||||
teams,
|
||||
input.format,
|
||||
);
|
||||
break;
|
||||
}
|
||||
|
||||
assertValidGraph(graph);
|
||||
return graph;
|
||||
}
|
||||
|
||||
function generatePairedSeriesGraph(
|
||||
competitionId: string,
|
||||
teams: CompetitionGraphTeam[],
|
||||
rule: FixedGamesSeriesRule,
|
||||
): SeriesDefinition[] {
|
||||
assertFixedGamesRule(rule);
|
||||
if (teams.length < 2 || teams.length % 2 !== 0) {
|
||||
throw graphError(
|
||||
'INVALID_PAIRED_TEAM_COUNT',
|
||||
'Paired Series requires a positive, even number of teams.',
|
||||
);
|
||||
}
|
||||
|
||||
const definitions: SeriesDefinition[] = [];
|
||||
for (let teamIndex = 0; teamIndex < teams.length; teamIndex += 2) {
|
||||
const code = `PAIR_M${teamIndex / 2 + 1}`;
|
||||
definitions.push(
|
||||
createSeriesDefinition({
|
||||
competitionId,
|
||||
code,
|
||||
stage: 'pair',
|
||||
roundNumber: 1,
|
||||
displayOrder: definitions.length + 1,
|
||||
sources: [
|
||||
{ type: 'team', teamId: teams[teamIndex].teamId },
|
||||
{ type: 'team', teamId: teams[teamIndex + 1].teamId },
|
||||
],
|
||||
rule,
|
||||
}),
|
||||
);
|
||||
}
|
||||
return definitions;
|
||||
}
|
||||
|
||||
function generateRoundRobinGraph(
|
||||
competitionId: string,
|
||||
teams: CompetitionGraphTeam[],
|
||||
rule: FixedGamesSeriesRule,
|
||||
maxRounds?: number,
|
||||
): SeriesDefinition[] {
|
||||
assertFixedGamesRule(rule);
|
||||
if (teams.length < 2) {
|
||||
throw graphError(
|
||||
'INVALID_ROUND_ROBIN_TEAM_COUNT',
|
||||
'Round robin requires at least two teams.',
|
||||
);
|
||||
}
|
||||
|
||||
const pairings = roundRobinPairings(teams.length, maxRounds);
|
||||
const matchNumberByRound = new Map<number, number>();
|
||||
|
||||
return pairings.map((pairing, index) => {
|
||||
const matchNumber = (matchNumberByRound.get(pairing.roundNumber) ?? 0) + 1;
|
||||
matchNumberByRound.set(pairing.roundNumber, matchNumber);
|
||||
const code = `RR_R${pairing.roundNumber}_M${matchNumber}`;
|
||||
return createSeriesDefinition({
|
||||
competitionId,
|
||||
code,
|
||||
stage: 'round-robin',
|
||||
roundNumber: pairing.roundNumber,
|
||||
displayOrder: index + 1,
|
||||
sources: [
|
||||
{ type: 'team', teamId: teams[pairing.teamAIndex].teamId },
|
||||
{ type: 'team', teamId: teams[pairing.teamBIndex].teamId },
|
||||
],
|
||||
rule,
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
function generateDoubleEliminationGraph(
|
||||
competitionId: string,
|
||||
teams: CompetitionGraphTeam[],
|
||||
format: Extract<CompetitionGraphFormat, { type: 'double-elimination' }>,
|
||||
): SeriesDefinition[] {
|
||||
if (teams.length !== 4 && teams.length !== 8) {
|
||||
throw graphError(
|
||||
'INVALID_DOUBLE_ELIMINATION_TEAM_COUNT',
|
||||
'Double elimination supports only four or eight teams.',
|
||||
);
|
||||
}
|
||||
if (format.teamCount !== undefined && format.teamCount !== teams.length) {
|
||||
throw graphError(
|
||||
'DOUBLE_ELIMINATION_TEAM_COUNT_MISMATCH',
|
||||
'The configured team count does not match the team snapshots.',
|
||||
);
|
||||
}
|
||||
assertContiguousSeeds(teams);
|
||||
assertFirstToRule(format.rules.upper);
|
||||
assertFirstToRule(format.rules.lower);
|
||||
assertFirstToRule(format.rules.grandFinal);
|
||||
assertFirstToRule(format.rules.resetFinal);
|
||||
|
||||
const templates =
|
||||
teams.length === 4
|
||||
? fourTeamDoubleEliminationTemplate()
|
||||
: eightTeamDoubleEliminationTemplate();
|
||||
if (format.resetFinalEnabled) templates.push(resetFinalTemplate());
|
||||
|
||||
return templates.map((template, index) => {
|
||||
const rule = ruleForStage(template.stage, format.rules);
|
||||
const grandFinalSeriesId = stableSeriesId(competitionId, 'GF');
|
||||
return createSeriesDefinition({
|
||||
competitionId,
|
||||
code: template.code,
|
||||
stage: template.stage,
|
||||
roundNumber: template.roundNumber,
|
||||
displayOrder: index + 1,
|
||||
sources: template.sources.map((source) =>
|
||||
resolveTemplateSource(competitionId, source),
|
||||
) as [ParticipantSource, ParticipantSource],
|
||||
rule,
|
||||
activation:
|
||||
template.stage === 'reset-final'
|
||||
? {
|
||||
type: 'grand-final-reset-required',
|
||||
grandFinalSeriesId,
|
||||
}
|
||||
: undefined,
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
function createSeriesDefinition(params: {
|
||||
competitionId: string;
|
||||
code: string;
|
||||
stage: SeriesStageType;
|
||||
roundNumber: number;
|
||||
displayOrder: number;
|
||||
sources: [ParticipantSource, ParticipantSource];
|
||||
rule: SeriesRule;
|
||||
activation?: SeriesDefinition['activation'];
|
||||
}): SeriesDefinition {
|
||||
const id = stableSeriesId(params.competitionId, params.code);
|
||||
const rule = cloneRule(params.rule);
|
||||
const gameCount =
|
||||
rule.type === 'fixed-games' ? rule.gameCount : rule.maxGames;
|
||||
|
||||
return {
|
||||
id,
|
||||
code: params.code,
|
||||
stage: {
|
||||
type: params.stage,
|
||||
roundNumber: params.roundNumber,
|
||||
displayOrder: params.displayOrder,
|
||||
},
|
||||
slots: [
|
||||
{ position: 'A', source: { ...params.sources[0] } },
|
||||
{ position: 'B', source: { ...params.sources[1] } },
|
||||
],
|
||||
rule,
|
||||
...(params.activation ? { activation: { ...params.activation } } : {}),
|
||||
gameSlots: Array.from({ length: gameCount }, (_, index) => ({
|
||||
id: stableGameSlotId(params.competitionId, params.code, index + 1),
|
||||
seriesId: id,
|
||||
ordinal: index + 1,
|
||||
})),
|
||||
};
|
||||
}
|
||||
|
||||
function fourTeamDoubleEliminationTemplate(): DoubleEliminationTemplate[] {
|
||||
return [
|
||||
deSeries('WB_R1_M1', 'upper', 1, seed(1), seed(4)),
|
||||
deSeries('WB_R1_M2', 'upper', 1, seed(2), seed(3)),
|
||||
deSeries('WB_FINAL', 'upper', 2, winner('WB_R1_M1'), winner('WB_R1_M2')),
|
||||
deSeries('LB_R1_M1', 'lower', 1, loser('WB_R1_M1'), loser('WB_R1_M2')),
|
||||
deSeries('LB_FINAL', 'lower', 2, winner('LB_R1_M1'), loser('WB_FINAL')),
|
||||
deSeries('GF', 'grand-final', 1, winner('WB_FINAL'), winner('LB_FINAL')),
|
||||
];
|
||||
}
|
||||
|
||||
function eightTeamDoubleEliminationTemplate(): DoubleEliminationTemplate[] {
|
||||
return [
|
||||
deSeries('WB_R1_M1', 'upper', 1, seed(1), seed(8)),
|
||||
deSeries('WB_R1_M2', 'upper', 1, seed(4), seed(5)),
|
||||
deSeries('WB_R1_M3', 'upper', 1, seed(2), seed(7)),
|
||||
deSeries('WB_R1_M4', 'upper', 1, seed(3), seed(6)),
|
||||
deSeries('WB_R2_M1', 'upper', 2, winner('WB_R1_M1'), winner('WB_R1_M2')),
|
||||
deSeries('WB_R2_M2', 'upper', 2, winner('WB_R1_M3'), winner('WB_R1_M4')),
|
||||
deSeries('WB_FINAL', 'upper', 3, winner('WB_R2_M1'), winner('WB_R2_M2')),
|
||||
deSeries('LB_R1_M1', 'lower', 1, loser('WB_R1_M1'), loser('WB_R1_M2')),
|
||||
deSeries('LB_R1_M2', 'lower', 1, loser('WB_R1_M3'), loser('WB_R1_M4')),
|
||||
deSeries('LB_R2_M1', 'lower', 2, winner('LB_R1_M1'), loser('WB_R2_M2')),
|
||||
deSeries('LB_R2_M2', 'lower', 2, winner('LB_R1_M2'), loser('WB_R2_M1')),
|
||||
deSeries('LB_R3_M1', 'lower', 3, winner('LB_R2_M1'), winner('LB_R2_M2')),
|
||||
deSeries('LB_FINAL', 'lower', 4, winner('LB_R3_M1'), loser('WB_FINAL')),
|
||||
deSeries('GF', 'grand-final', 1, winner('WB_FINAL'), winner('LB_FINAL')),
|
||||
];
|
||||
}
|
||||
|
||||
function resetFinalTemplate(): DoubleEliminationTemplate {
|
||||
return deSeries(
|
||||
'GF_RESET',
|
||||
'reset-final',
|
||||
1,
|
||||
seriesSlot('GF', 'A'),
|
||||
seriesSlot('GF', 'B'),
|
||||
);
|
||||
}
|
||||
|
||||
function deSeries(
|
||||
code: string,
|
||||
stage: DoubleEliminationTemplate['stage'],
|
||||
roundNumber: number,
|
||||
sourceA: TemplateParticipantSource,
|
||||
sourceB: TemplateParticipantSource,
|
||||
): DoubleEliminationTemplate {
|
||||
return { code, stage, roundNumber, sources: [sourceA, sourceB] };
|
||||
}
|
||||
|
||||
function seed(seedNumber: number): TemplateParticipantSource {
|
||||
return { type: 'seed', seedNumber };
|
||||
}
|
||||
|
||||
function winner(seriesCode: string): TemplateParticipantSource {
|
||||
return { type: 'series-outcome', seriesCode, select: 'winner' };
|
||||
}
|
||||
|
||||
function loser(seriesCode: string): TemplateParticipantSource {
|
||||
return { type: 'series-outcome', seriesCode, select: 'loser' };
|
||||
}
|
||||
|
||||
function seriesSlot(
|
||||
seriesCode: string,
|
||||
slot: SeriesSlot,
|
||||
): TemplateParticipantSource {
|
||||
return { type: 'series-slot', seriesCode, slot };
|
||||
}
|
||||
|
||||
function resolveTemplateSource(
|
||||
competitionId: string,
|
||||
source: TemplateParticipantSource,
|
||||
): ParticipantSource {
|
||||
switch (source.type) {
|
||||
case 'seed':
|
||||
return { ...source };
|
||||
case 'series-outcome':
|
||||
return {
|
||||
type: 'series-outcome',
|
||||
seriesId: stableSeriesId(competitionId, source.seriesCode),
|
||||
select: source.select,
|
||||
};
|
||||
case 'series-slot':
|
||||
return {
|
||||
type: 'series-slot',
|
||||
seriesId: stableSeriesId(competitionId, source.seriesCode),
|
||||
slot: source.slot,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
function ruleForStage(
|
||||
stage: DoubleEliminationTemplate['stage'],
|
||||
rules: Extract<
|
||||
CompetitionGraphFormat,
|
||||
{ type: 'double-elimination' }
|
||||
>['rules'],
|
||||
): FirstToSeriesRule {
|
||||
switch (stage) {
|
||||
case 'upper':
|
||||
return rules.upper;
|
||||
case 'lower':
|
||||
return rules.lower;
|
||||
case 'grand-final':
|
||||
return rules.grandFinal;
|
||||
case 'reset-final':
|
||||
return rules.resetFinal;
|
||||
}
|
||||
}
|
||||
|
||||
function roundRobinPairings(
|
||||
teamCount: number,
|
||||
maxRounds?: number,
|
||||
): RoundRobinPairing[] {
|
||||
const bye = -1;
|
||||
const rotating = Array.from({ length: teamCount }, (_, index) => index);
|
||||
if (rotating.length % 2 === 1) rotating.push(bye);
|
||||
|
||||
const fullRoundCount = rotating.length - 1;
|
||||
const requestedRounds =
|
||||
maxRounds === undefined
|
||||
? fullRoundCount
|
||||
: Number.isFinite(maxRounds)
|
||||
? Math.floor(maxRounds)
|
||||
: fullRoundCount;
|
||||
const roundCount = Math.max(0, Math.min(fullRoundCount, requestedRounds));
|
||||
const pairings: RoundRobinPairing[] = [];
|
||||
|
||||
for (let roundIndex = 0; roundIndex < roundCount; roundIndex += 1) {
|
||||
for (let index = 0; index < rotating.length / 2; index += 1) {
|
||||
const left = rotating[index];
|
||||
const right = rotating[rotating.length - 1 - index];
|
||||
if (left === bye || right === bye) continue;
|
||||
pairings.push({
|
||||
roundNumber: roundIndex + 1,
|
||||
teamAIndex: Math.min(left, right),
|
||||
teamBIndex: Math.max(left, right),
|
||||
});
|
||||
}
|
||||
|
||||
const fixed = rotating[0];
|
||||
const tail = rotating.slice(1);
|
||||
tail.unshift(tail.pop() as number);
|
||||
rotating.splice(0, rotating.length, fixed, ...tail);
|
||||
}
|
||||
|
||||
return pairings;
|
||||
}
|
||||
|
||||
function normalizeTeams(
|
||||
teams: readonly CompetitionGraphTeam[],
|
||||
): CompetitionGraphTeam[] {
|
||||
const normalized = teams.map((team) => ({ ...team }));
|
||||
const teamIds = new Set<string>();
|
||||
const displayOrders = new Set<number>();
|
||||
|
||||
for (const team of normalized) {
|
||||
if (typeof team.teamId !== 'string' || team.teamId.trim().length === 0) {
|
||||
throw graphError('INVALID_TEAM_ID', 'Every team needs an opaque ID.');
|
||||
}
|
||||
if (teamIds.has(team.teamId)) {
|
||||
throw graphError(
|
||||
'DUPLICATE_TEAM_ID',
|
||||
`Duplicate team ID: ${team.teamId}`,
|
||||
);
|
||||
}
|
||||
if (!Number.isInteger(team.displayOrder) || team.displayOrder < 1) {
|
||||
throw graphError(
|
||||
'INVALID_TEAM_DISPLAY_ORDER',
|
||||
'Team display order must be a positive integer.',
|
||||
);
|
||||
}
|
||||
if (displayOrders.has(team.displayOrder)) {
|
||||
throw graphError(
|
||||
'DUPLICATE_TEAM_DISPLAY_ORDER',
|
||||
`Duplicate team display order: ${team.displayOrder}`,
|
||||
);
|
||||
}
|
||||
teamIds.add(team.teamId);
|
||||
displayOrders.add(team.displayOrder);
|
||||
}
|
||||
|
||||
return normalized.sort(
|
||||
(left, right) =>
|
||||
left.displayOrder - right.displayOrder ||
|
||||
left.teamId.localeCompare(right.teamId),
|
||||
);
|
||||
}
|
||||
|
||||
function assertContiguousSeeds(teams: CompetitionGraphTeam[]): void {
|
||||
const seeds = teams.map((team) => team.seedNumber);
|
||||
if (
|
||||
seeds.some((seedNumber) => !Number.isInteger(seedNumber)) ||
|
||||
new Set(seeds).size !== teams.length
|
||||
) {
|
||||
throw graphError(
|
||||
'INVALID_DOUBLE_ELIMINATION_SEEDS',
|
||||
'Double-elimination seeds must be unique integers.',
|
||||
);
|
||||
}
|
||||
const sorted = [...(seeds as number[])].sort((left, right) => left - right);
|
||||
if (sorted.some((seedNumber, index) => seedNumber !== index + 1)) {
|
||||
throw graphError(
|
||||
'INVALID_DOUBLE_ELIMINATION_SEEDS',
|
||||
'Double-elimination seeds must be contiguous from one to the team count.',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function assertCompetitionId(competitionId: string): void {
|
||||
if (typeof competitionId !== 'string' || competitionId.trim().length === 0) {
|
||||
throw graphError(
|
||||
'INVALID_COMPETITION_ID',
|
||||
'Competition ID must be a non-empty string.',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function assertFixedGamesRule(rule: FixedGamesSeriesRule): void {
|
||||
if (!Number.isInteger(rule.gameCount) || rule.gameCount < 1) {
|
||||
throw graphError(
|
||||
'INVALID_FIXED_GAMES_RULE',
|
||||
'Fixed-game Series need a positive game count.',
|
||||
);
|
||||
}
|
||||
if (rule.drawPolicy !== 'allow' && rule.drawPolicy !== 'tiebreak-required') {
|
||||
throw graphError(
|
||||
'INVALID_FIXED_GAMES_RULE',
|
||||
'Fixed-game Series need a supported draw policy.',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function assertFirstToRule(rule: FirstToSeriesRule): void {
|
||||
if (
|
||||
!Number.isInteger(rule.winsRequired) ||
|
||||
rule.winsRequired < 1 ||
|
||||
!Number.isInteger(rule.maxGames) ||
|
||||
rule.maxGames < rule.winsRequired * 2 - 1
|
||||
) {
|
||||
throw graphError(
|
||||
'INVALID_FIRST_TO_RULE',
|
||||
'First-to Series need positive, achievable win and game limits.',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function cloneRule(rule: SeriesRule): SeriesRule {
|
||||
return rule.type === 'fixed-games' ? { ...rule } : { ...rule };
|
||||
}
|
||||
|
||||
function assertValidGraph(graph: SeriesDefinition[]): void {
|
||||
const seriesIndexById = new Map<string, number>();
|
||||
const gameSlotIds = new Set<string>();
|
||||
|
||||
graph.forEach((series, index) => {
|
||||
if (seriesIndexById.has(series.id)) {
|
||||
throw graphError('DUPLICATE_SERIES_ID', 'Series IDs must be unique.');
|
||||
}
|
||||
seriesIndexById.set(series.id, index);
|
||||
for (const gameSlot of series.gameSlots) {
|
||||
if (gameSlotIds.has(gameSlot.id)) {
|
||||
throw graphError(
|
||||
'DUPLICATE_GAME_SLOT_ID',
|
||||
'GameSlot IDs must be unique.',
|
||||
);
|
||||
}
|
||||
gameSlotIds.add(gameSlot.id);
|
||||
}
|
||||
});
|
||||
|
||||
graph.forEach((series, index) => {
|
||||
for (const slot of series.slots) {
|
||||
if (
|
||||
slot.source.type !== 'series-outcome' &&
|
||||
slot.source.type !== 'series-slot'
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
const sourceIndex = seriesIndexById.get(slot.source.seriesId);
|
||||
if (sourceIndex === undefined) {
|
||||
throw graphError(
|
||||
'UNKNOWN_SERIES_SOURCE',
|
||||
`Series ${series.id} references an unknown source.`,
|
||||
);
|
||||
}
|
||||
if (sourceIndex >= index) {
|
||||
throw graphError(
|
||||
'CYCLIC_SERIES_GRAPH',
|
||||
`Series ${series.id} does not follow its source in topological order.`,
|
||||
);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function stableSeriesId(competitionId: string, code: string): string {
|
||||
return stableOpaqueId(competitionId, 'series', code);
|
||||
}
|
||||
|
||||
function stableGameSlotId(
|
||||
competitionId: string,
|
||||
seriesCode: string,
|
||||
ordinal: number,
|
||||
): string {
|
||||
return stableOpaqueId(competitionId, 'game-slot', seriesCode, ordinal);
|
||||
}
|
||||
|
||||
function stableOpaqueId(
|
||||
competitionId: string,
|
||||
entityKind: string,
|
||||
...logicalKey: Array<string | number>
|
||||
): string {
|
||||
return createHash('sha256')
|
||||
.update(JSON.stringify([competitionId, entityKind, ...logicalKey]))
|
||||
.digest('hex')
|
||||
.slice(0, 24);
|
||||
}
|
||||
|
||||
function graphError(code: string, message: string): Error & { code: string } {
|
||||
return Object.assign(new Error(message), { code });
|
||||
}
|
||||
@@ -0,0 +1,354 @@
|
||||
import { projectSeries } from './series-projector';
|
||||
|
||||
describe('projectSeries', () => {
|
||||
it('keeps a fixed-games pair in progress until every game slot is filled', () => {
|
||||
const definition = seriesDefinition({
|
||||
id: 'series-pair',
|
||||
stage: 'pair',
|
||||
rule: {
|
||||
type: 'fixed-games',
|
||||
gameCount: 3,
|
||||
drawPolicy: 'allow',
|
||||
},
|
||||
});
|
||||
const firstTwoGames = [
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 1,
|
||||
blueTeamId: 'team-8',
|
||||
redTeamId: 'team-3',
|
||||
winnerTeamId: 'team-8',
|
||||
}),
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 2,
|
||||
blueTeamId: 'team-3',
|
||||
redTeamId: 'team-8',
|
||||
winnerTeamId: 'team-8',
|
||||
}),
|
||||
];
|
||||
|
||||
const inProgress = projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: firstTwoGames,
|
||||
});
|
||||
|
||||
expect(inProgress).toMatchObject({
|
||||
status: 'in-progress',
|
||||
leaderTeamId: 'team-8',
|
||||
entries: [
|
||||
{ slot: 'A', teamId: 'team-8', gameWins: 2 },
|
||||
{ slot: 'B', teamId: 'team-3', gameWins: 0 },
|
||||
],
|
||||
});
|
||||
expect(inProgress).not.toHaveProperty('outcome');
|
||||
|
||||
const completed = projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: [
|
||||
...firstTwoGames,
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 3,
|
||||
blueTeamId: 'team-8',
|
||||
redTeamId: 'team-3',
|
||||
winnerTeamId: 'team-3',
|
||||
}),
|
||||
],
|
||||
});
|
||||
|
||||
expect(completed).toMatchObject({
|
||||
status: 'completed',
|
||||
entries: [
|
||||
{ slot: 'A', teamId: 'team-8', gameWins: 2 },
|
||||
{ slot: 'B', teamId: 'team-3', gameWins: 1 },
|
||||
],
|
||||
outcome: {
|
||||
type: 'played',
|
||||
winnerTeamId: 'team-8',
|
||||
loserTeamId: 'team-3',
|
||||
},
|
||||
});
|
||||
expect(completed).not.toHaveProperty('leaderTeamId');
|
||||
});
|
||||
|
||||
it('reports a leader during first-to play and a winner only after the threshold', () => {
|
||||
const definition = seriesDefinition({
|
||||
id: 'series-first-to',
|
||||
stage: 'upper',
|
||||
rule: { type: 'first-to', winsRequired: 2, maxGames: 3 },
|
||||
});
|
||||
const firstGame = acceptedGame({
|
||||
definition,
|
||||
ordinal: 1,
|
||||
blueTeamId: 'team-8',
|
||||
redTeamId: 'team-3',
|
||||
winnerTeamId: 'team-8',
|
||||
});
|
||||
|
||||
const oneToZero = projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: [firstGame],
|
||||
});
|
||||
|
||||
expect(oneToZero).toMatchObject({
|
||||
status: 'in-progress',
|
||||
leaderTeamId: 'team-8',
|
||||
});
|
||||
expect(oneToZero).not.toHaveProperty('outcome');
|
||||
|
||||
const twoToOne = projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: [
|
||||
firstGame,
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 2,
|
||||
blueTeamId: 'team-8',
|
||||
redTeamId: 'team-3',
|
||||
winnerTeamId: 'team-3',
|
||||
}),
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 3,
|
||||
blueTeamId: 'team-3',
|
||||
redTeamId: 'team-8',
|
||||
winnerTeamId: 'team-8',
|
||||
}),
|
||||
],
|
||||
});
|
||||
|
||||
expect(twoToOne).toMatchObject({
|
||||
status: 'completed',
|
||||
outcome: {
|
||||
type: 'played',
|
||||
winnerTeamId: 'team-8',
|
||||
loserTeamId: 'team-3',
|
||||
decidedByGameIds: [
|
||||
'game-series-first-to-1',
|
||||
'game-series-first-to-2',
|
||||
'game-series-first-to-3',
|
||||
],
|
||||
},
|
||||
});
|
||||
expect(twoToOne).not.toHaveProperty('leaderTeamId');
|
||||
});
|
||||
|
||||
it('rejects accepted evidence whose teams do not match the series participants', () => {
|
||||
const definition = seriesDefinition({
|
||||
id: 'series-invalid-team',
|
||||
stage: 'upper',
|
||||
rule: { type: 'first-to', winsRequired: 2, maxGames: 3 },
|
||||
});
|
||||
|
||||
expectInvariant(
|
||||
() =>
|
||||
projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: [
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 1,
|
||||
blueTeamId: 'team-8',
|
||||
redTeamId: 'team-9',
|
||||
winnerTeamId: 'team-8',
|
||||
}),
|
||||
],
|
||||
}),
|
||||
'GAME_TEAM_MISMATCH',
|
||||
);
|
||||
});
|
||||
|
||||
it('rejects a game accepted after a first-to series was already complete', () => {
|
||||
const definition = seriesDefinition({
|
||||
id: 'series-extra-game',
|
||||
stage: 'upper',
|
||||
rule: { type: 'first-to', winsRequired: 2, maxGames: 3 },
|
||||
});
|
||||
|
||||
expectInvariant(
|
||||
() =>
|
||||
projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: [
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 1,
|
||||
blueTeamId: 'team-8',
|
||||
redTeamId: 'team-3',
|
||||
winnerTeamId: 'team-8',
|
||||
}),
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 2,
|
||||
blueTeamId: 'team-3',
|
||||
redTeamId: 'team-8',
|
||||
winnerTeamId: 'team-8',
|
||||
}),
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 3,
|
||||
blueTeamId: 'team-8',
|
||||
redTeamId: 'team-3',
|
||||
winnerTeamId: 'team-3',
|
||||
}),
|
||||
],
|
||||
}),
|
||||
'SERIES_ALREADY_COMPLETED',
|
||||
);
|
||||
});
|
||||
|
||||
it('allows an inactive descendant after all of its historical activity was reversed', () => {
|
||||
const definition = seriesDefinition({
|
||||
id: 'series-reversed-descendant',
|
||||
stage: 'upper',
|
||||
rule: { type: 'first-to', winsRequired: 1, maxGames: 1 },
|
||||
});
|
||||
const accepted = acceptedGame({
|
||||
definition,
|
||||
ordinal: 1,
|
||||
blueTeamId: 'team-8',
|
||||
redTeamId: 'team-3',
|
||||
winnerTeamId: 'team-8',
|
||||
});
|
||||
|
||||
expect(
|
||||
projectSeries({
|
||||
definition,
|
||||
participants: [null, null],
|
||||
active: false,
|
||||
facts: [
|
||||
accepted,
|
||||
{
|
||||
id: 'fact-series-reversed-descendant-void',
|
||||
type: 'game-voided',
|
||||
competitionId: 'competition-series-projector',
|
||||
revision: 2,
|
||||
ordinalWithinRevision: 1,
|
||||
commandId: 'command-series-reversed-descendant-void',
|
||||
schemaVersion: 1,
|
||||
actor: { type: 'user' },
|
||||
occurredAt: new Date('2026-07-12T00:02:00.000Z'),
|
||||
recordedAt: new Date('2026-07-12T00:02:01.000Z'),
|
||||
gameAcceptedFactId: accepted.id,
|
||||
reason: 'Cascade reversal',
|
||||
},
|
||||
],
|
||||
}),
|
||||
).toMatchObject({ status: 'inactive' });
|
||||
});
|
||||
|
||||
it('rejects an unfinishable persisted first-to definition', () => {
|
||||
const definition = seriesDefinition({
|
||||
id: 'series-unfinishable',
|
||||
stage: 'upper',
|
||||
rule: { type: 'first-to', winsRequired: 2, maxGames: 2 },
|
||||
});
|
||||
|
||||
expectInvariant(
|
||||
() =>
|
||||
projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: [],
|
||||
}),
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
function seriesDefinition(params: {
|
||||
id: string;
|
||||
stage: 'pair' | 'upper';
|
||||
rule:
|
||||
| {
|
||||
type: 'fixed-games';
|
||||
gameCount: number;
|
||||
drawPolicy: 'allow';
|
||||
}
|
||||
| { type: 'first-to'; winsRequired: number; maxGames: number };
|
||||
}) {
|
||||
const gameCount =
|
||||
params.rule.type === 'fixed-games'
|
||||
? params.rule.gameCount
|
||||
: params.rule.maxGames;
|
||||
return {
|
||||
id: params.id,
|
||||
code: params.id,
|
||||
stage: { type: params.stage, displayOrder: 1 },
|
||||
slots: [
|
||||
{
|
||||
position: 'A' as const,
|
||||
source: { type: 'team' as const, teamId: 'team-8' },
|
||||
},
|
||||
{
|
||||
position: 'B' as const,
|
||||
source: { type: 'team' as const, teamId: 'team-3' },
|
||||
},
|
||||
],
|
||||
rule: params.rule,
|
||||
gameSlots: Array.from({ length: gameCount }, (_, index) => ({
|
||||
id: `${params.id}-slot-${index + 1}`,
|
||||
seriesId: params.id,
|
||||
ordinal: index + 1,
|
||||
})),
|
||||
};
|
||||
}
|
||||
|
||||
function acceptedGame(params: {
|
||||
definition: ReturnType<typeof seriesDefinition>;
|
||||
ordinal: number;
|
||||
blueTeamId: string;
|
||||
redTeamId: string;
|
||||
winnerTeamId: string;
|
||||
}) {
|
||||
const gameSlot = params.definition.gameSlots.find(
|
||||
(slot) => slot.ordinal === params.ordinal,
|
||||
);
|
||||
if (!gameSlot) throw new Error(`Missing game slot ${params.ordinal}`);
|
||||
|
||||
return {
|
||||
id: `fact-${params.definition.id}-${params.ordinal}`,
|
||||
type: 'game-accepted' as const,
|
||||
competitionId: 'competition-series-projector',
|
||||
revision: params.ordinal,
|
||||
ordinalWithinRevision: 1,
|
||||
commandId: `command-${params.definition.id}-${params.ordinal}`,
|
||||
schemaVersion: 1,
|
||||
actor: { type: 'system' as const },
|
||||
occurredAt: new Date(`2026-07-12T00:0${params.ordinal}:00.000Z`),
|
||||
recordedAt: new Date(`2026-07-12T00:0${params.ordinal}:01.000Z`),
|
||||
gameId: `game-${params.definition.id}-${params.ordinal}`,
|
||||
seriesId: params.definition.id,
|
||||
gameSlotId: gameSlot.id,
|
||||
ordinal: params.ordinal,
|
||||
evidence: {
|
||||
type: 'riot' as const,
|
||||
riotMatchId: `KR_${params.definition.id}_${params.ordinal}`,
|
||||
payloadHash: `sha256:${params.definition.id}:${params.ordinal}`,
|
||||
},
|
||||
mapping: {
|
||||
mappingVersion: 1,
|
||||
confidence: 1,
|
||||
blueTeamId: params.blueTeamId,
|
||||
redTeamId: params.redTeamId,
|
||||
winnerTeamId: params.winnerTeamId,
|
||||
participantAssignments: [],
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function expectInvariant(action: () => unknown, code: string) {
|
||||
try {
|
||||
action();
|
||||
throw new Error(`Expected invariant ${code}`);
|
||||
} catch (error) {
|
||||
expect(error).toMatchObject({ code });
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,819 @@
|
||||
import {
|
||||
assertCompetitionInvariant,
|
||||
CompetitionDomainError,
|
||||
} from './domain-error';
|
||||
|
||||
export type SeriesSlot = 'A' | 'B';
|
||||
|
||||
export type SeriesRule =
|
||||
| { type: 'first-to'; winsRequired: number; maxGames: number }
|
||||
| {
|
||||
type: 'fixed-games';
|
||||
gameCount: number;
|
||||
drawPolicy: 'allow' | 'tiebreak-required';
|
||||
};
|
||||
|
||||
export interface SeriesDefinitionLike {
|
||||
id: string;
|
||||
code?: string;
|
||||
stage: {
|
||||
type: string;
|
||||
roundNumber?: number;
|
||||
displayOrder: number;
|
||||
};
|
||||
slots: ReadonlyArray<{
|
||||
position: SeriesSlot;
|
||||
source: Readonly<Record<string, unknown>>;
|
||||
}>;
|
||||
rule: SeriesRule;
|
||||
gameSlots: ReadonlyArray<{
|
||||
id: string;
|
||||
seriesId: string;
|
||||
ordinal: number;
|
||||
}>;
|
||||
}
|
||||
|
||||
export interface ProjectSeriesInput {
|
||||
definition: SeriesDefinitionLike;
|
||||
participants: readonly (string | null | undefined)[];
|
||||
facts: readonly unknown[];
|
||||
/** A stable conditional node can exist before it is eligible for play. */
|
||||
active?: boolean;
|
||||
}
|
||||
|
||||
export interface SeriesProjectionEntry {
|
||||
slot: SeriesSlot;
|
||||
teamId: string | null;
|
||||
gameWins: number;
|
||||
}
|
||||
|
||||
export type SeriesProjectionOutcome =
|
||||
| {
|
||||
type: 'played';
|
||||
winnerTeamId: string;
|
||||
loserTeamId: string;
|
||||
decidedByGameIds: string[];
|
||||
completedAt: string;
|
||||
}
|
||||
| {
|
||||
type: 'draw';
|
||||
basis:
|
||||
| { type: 'played'; decidedByGameIds: string[] }
|
||||
| { type: 'administrative'; decisionFactId: string };
|
||||
completedAt: string;
|
||||
}
|
||||
| {
|
||||
type: 'walkover' | 'forfeit' | 'administrative';
|
||||
winnerTeamId: string;
|
||||
loserTeamId: string;
|
||||
decisionFactId: string;
|
||||
completedAt: string;
|
||||
};
|
||||
|
||||
interface SeriesProjectionBase {
|
||||
seriesId: string;
|
||||
code?: string;
|
||||
stage: SeriesDefinitionLike['stage'];
|
||||
rule: SeriesRule;
|
||||
entries: [SeriesProjectionEntry, SeriesProjectionEntry];
|
||||
}
|
||||
|
||||
export type SeriesProjection = SeriesProjectionBase &
|
||||
(
|
||||
| { status: 'inactive' | 'waiting' | 'ready' }
|
||||
| { status: 'in-progress'; leaderTeamId?: string }
|
||||
| { status: 'completed'; outcome: SeriesProjectionOutcome }
|
||||
);
|
||||
|
||||
interface FactBase {
|
||||
id: string;
|
||||
type: string;
|
||||
revision: number;
|
||||
ordinalWithinRevision: number;
|
||||
occurredAt: Date | string;
|
||||
recordedAt?: Date | string;
|
||||
}
|
||||
|
||||
interface GameAcceptedFact extends FactBase {
|
||||
type: 'game-accepted';
|
||||
gameId: string;
|
||||
seriesId: string;
|
||||
gameSlotId: string;
|
||||
ordinal: number;
|
||||
evidence?: {
|
||||
type?: string;
|
||||
riotMatchId?: string;
|
||||
};
|
||||
mapping: {
|
||||
blueTeamId: string;
|
||||
redTeamId: string;
|
||||
winnerTeamId: string;
|
||||
};
|
||||
}
|
||||
|
||||
interface GameVoidedFact extends FactBase {
|
||||
type: 'game-voided';
|
||||
gameAcceptedFactId: string;
|
||||
reason?: string;
|
||||
}
|
||||
|
||||
interface SeriesAdjudicatedFact extends FactBase {
|
||||
type: 'series-adjudicated';
|
||||
seriesId: string;
|
||||
decision:
|
||||
| { type: 'walkover' | 'forfeit' | 'administrative'; winnerTeamId: string }
|
||||
| { type: 'administrative-draw' };
|
||||
reason: string;
|
||||
}
|
||||
|
||||
interface AdjudicationReversedFact extends FactBase {
|
||||
type: 'adjudication-reversed';
|
||||
adjudicationFactId: string;
|
||||
reason?: string;
|
||||
}
|
||||
|
||||
type CompetitionFact =
|
||||
| GameAcceptedFact
|
||||
| GameVoidedFact
|
||||
| SeriesAdjudicatedFact
|
||||
| AdjudicationReversedFact;
|
||||
|
||||
interface PlayedState {
|
||||
activeGames: GameAcceptedFact[];
|
||||
winsByTeam: Map<string, number>;
|
||||
completed: boolean;
|
||||
}
|
||||
|
||||
/** Project one Series exclusively from its definition, resolved participants and fact ledger. */
|
||||
export function projectSeries(input: ProjectSeriesInput): SeriesProjection {
|
||||
validateDefinition(input.definition);
|
||||
const participants = normalizeParticipants(input.participants);
|
||||
const facts = normalizeFacts(input.facts);
|
||||
const base = projectionBase(input.definition, participants);
|
||||
|
||||
if (input.active === false) {
|
||||
assertNoSeriesActivity(input.definition.id, facts);
|
||||
return { ...base, status: 'inactive' };
|
||||
}
|
||||
|
||||
if (participants.some((teamId) => teamId === null)) {
|
||||
assertNoSeriesActivity(input.definition.id, facts);
|
||||
return { ...base, status: 'waiting' };
|
||||
}
|
||||
|
||||
const resolvedParticipants = participants as [string, string];
|
||||
const relevantFacts = selectRelevantFacts(input.definition.id, facts);
|
||||
const activeGames = new Map<string, GameAcceptedFact>();
|
||||
const voidedGameFacts = new Set<string>();
|
||||
const adjudications = new Map<string, SeriesAdjudicatedFact>();
|
||||
const reversedAdjudications = new Set<string>();
|
||||
let activeAdjudication: SeriesAdjudicatedFact | undefined;
|
||||
|
||||
for (const fact of relevantFacts) {
|
||||
switch (fact.type) {
|
||||
case 'game-accepted': {
|
||||
assertCompetitionInvariant(
|
||||
activeAdjudication === undefined &&
|
||||
!derivePlayedState(
|
||||
input.definition.rule,
|
||||
[...activeGames.values()],
|
||||
resolvedParticipants,
|
||||
).completed,
|
||||
'SERIES_ALREADY_COMPLETED',
|
||||
`Series ${input.definition.id} was already completed before game ${fact.gameId}`,
|
||||
{ seriesId: input.definition.id, factId: fact.id },
|
||||
);
|
||||
validateAcceptedGame(input.definition, resolvedParticipants, fact);
|
||||
validateActiveGameUniqueness(activeGames.values(), fact);
|
||||
activeGames.set(fact.id, fact);
|
||||
break;
|
||||
}
|
||||
case 'game-voided': {
|
||||
const accepted = facts.find(
|
||||
(candidate): candidate is GameAcceptedFact =>
|
||||
candidate.type === 'game-accepted' &&
|
||||
candidate.id === fact.gameAcceptedFactId,
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
accepted !== undefined,
|
||||
'FACT_REFERENCE_NOT_FOUND',
|
||||
`Voided game fact ${fact.gameAcceptedFactId} does not exist`,
|
||||
{ factId: fact.id, referencedFactId: fact.gameAcceptedFactId },
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
activeGames.has(accepted.id) && !voidedGameFacts.has(accepted.id),
|
||||
'FACT_ALREADY_REVERSED',
|
||||
`Game fact ${accepted.id} is already voided`,
|
||||
{ factId: fact.id, referencedFactId: accepted.id },
|
||||
);
|
||||
activeGames.delete(accepted.id);
|
||||
voidedGameFacts.add(accepted.id);
|
||||
break;
|
||||
}
|
||||
case 'series-adjudicated': {
|
||||
const played = derivePlayedState(
|
||||
input.definition.rule,
|
||||
[...activeGames.values()],
|
||||
resolvedParticipants,
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
!played.completed && activeAdjudication === undefined,
|
||||
activeAdjudication
|
||||
? 'DUPLICATE_ADJUDICATION'
|
||||
: 'SERIES_ALREADY_COMPLETED',
|
||||
`Series ${input.definition.id} already has an official outcome`,
|
||||
{ seriesId: input.definition.id, factId: fact.id },
|
||||
);
|
||||
validateAdjudication(
|
||||
input.definition,
|
||||
resolvedParticipants,
|
||||
played.activeGames,
|
||||
fact,
|
||||
);
|
||||
adjudications.set(fact.id, fact);
|
||||
activeAdjudication = fact;
|
||||
break;
|
||||
}
|
||||
case 'adjudication-reversed': {
|
||||
const adjudication = adjudications.get(fact.adjudicationFactId);
|
||||
assertCompetitionInvariant(
|
||||
adjudication !== undefined,
|
||||
'FACT_REFERENCE_NOT_FOUND',
|
||||
`Adjudication fact ${fact.adjudicationFactId} does not exist or is not active in this Series`,
|
||||
{ factId: fact.id, referencedFactId: fact.adjudicationFactId },
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
!reversedAdjudications.has(adjudication.id) &&
|
||||
activeAdjudication?.id === adjudication.id,
|
||||
'FACT_ALREADY_REVERSED',
|
||||
`Adjudication fact ${adjudication.id} is already reversed`,
|
||||
{ factId: fact.id, referencedFactId: adjudication.id },
|
||||
);
|
||||
reversedAdjudications.add(adjudication.id);
|
||||
activeAdjudication = undefined;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const played = derivePlayedState(
|
||||
input.definition.rule,
|
||||
[...activeGames.values()],
|
||||
resolvedParticipants,
|
||||
);
|
||||
const entries = entriesFor(resolvedParticipants, played.winsByTeam);
|
||||
const projectedBase = { ...base, entries };
|
||||
|
||||
if (activeAdjudication) {
|
||||
return {
|
||||
...projectedBase,
|
||||
status: 'completed',
|
||||
outcome: adjudicatedOutcome(activeAdjudication, resolvedParticipants),
|
||||
};
|
||||
}
|
||||
|
||||
if (played.completed) {
|
||||
return {
|
||||
...projectedBase,
|
||||
status: 'completed',
|
||||
outcome: playedOutcome(
|
||||
input.definition.rule,
|
||||
played.activeGames,
|
||||
resolvedParticipants,
|
||||
played.winsByTeam,
|
||||
),
|
||||
};
|
||||
}
|
||||
|
||||
if (played.activeGames.length === 0) {
|
||||
return { ...projectedBase, status: 'ready' };
|
||||
}
|
||||
|
||||
const leaderTeamId = deriveLeader(resolvedParticipants, played.winsByTeam);
|
||||
return {
|
||||
...projectedBase,
|
||||
status: 'in-progress',
|
||||
...(leaderTeamId ? { leaderTeamId } : {}),
|
||||
};
|
||||
}
|
||||
|
||||
function validateDefinition(definition: SeriesDefinitionLike): void {
|
||||
assertCompetitionInvariant(
|
||||
typeof definition.id === 'string' && definition.id.length > 0,
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
'A Series must have an opaque id',
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
definition.slots.length === 2 &&
|
||||
definition.slots[0]?.position === 'A' &&
|
||||
definition.slots[1]?.position === 'B',
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
`Series ${definition.id} must define exactly the local A and B slots`,
|
||||
);
|
||||
|
||||
const requiredSlots =
|
||||
definition.rule.type === 'fixed-games'
|
||||
? definition.rule.gameCount
|
||||
: definition.rule.maxGames;
|
||||
assertCompetitionInvariant(
|
||||
Number.isInteger(requiredSlots) && requiredSlots > 0,
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
`Series ${definition.id} has an invalid game count`,
|
||||
);
|
||||
if (definition.rule.type === 'first-to') {
|
||||
assertCompetitionInvariant(
|
||||
Number.isInteger(definition.rule.winsRequired) &&
|
||||
definition.rule.winsRequired > 0 &&
|
||||
definition.rule.maxGames >= definition.rule.winsRequired * 2 - 1,
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
`Series ${definition.id} has an invalid first-to threshold`,
|
||||
);
|
||||
}
|
||||
assertCompetitionInvariant(
|
||||
definition.gameSlots.length === requiredSlots,
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
`Series ${definition.id} must predefine every GameSlot`,
|
||||
);
|
||||
|
||||
const ids = new Set<string>();
|
||||
const ordinals = new Set<number>();
|
||||
for (const slot of definition.gameSlots) {
|
||||
assertCompetitionInvariant(
|
||||
slot.seriesId === definition.id &&
|
||||
typeof slot.id === 'string' &&
|
||||
slot.id.length > 0,
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
`GameSlot ${slot.id} does not belong to Series ${definition.id}`,
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
Number.isInteger(slot.ordinal) &&
|
||||
slot.ordinal >= 1 &&
|
||||
slot.ordinal <= requiredSlots,
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
`GameSlot ${slot.id} has an invalid ordinal`,
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
!ids.has(slot.id) && !ordinals.has(slot.ordinal),
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
`Series ${definition.id} has duplicate GameSlot identity or ordinal`,
|
||||
);
|
||||
ids.add(slot.id);
|
||||
ordinals.add(slot.ordinal);
|
||||
}
|
||||
}
|
||||
|
||||
function normalizeParticipants(
|
||||
participants: readonly (string | null | undefined)[],
|
||||
): [string | null, string | null] {
|
||||
assertCompetitionInvariant(
|
||||
participants.length === 2,
|
||||
'SERIES_PARTICIPANTS_INVALID',
|
||||
'A Series projection requires exactly two participant slots',
|
||||
);
|
||||
const normalized = participants.map((teamId) => teamId ?? null) as [
|
||||
string | null,
|
||||
string | null,
|
||||
];
|
||||
for (const teamId of normalized) {
|
||||
assertCompetitionInvariant(
|
||||
teamId === null || (typeof teamId === 'string' && teamId.length > 0),
|
||||
'SERIES_PARTICIPANTS_INVALID',
|
||||
'Resolved participant ids must be opaque non-empty strings',
|
||||
);
|
||||
}
|
||||
assertCompetitionInvariant(
|
||||
normalized[0] === null ||
|
||||
normalized[1] === null ||
|
||||
normalized[0] !== normalized[1],
|
||||
'SERIES_PARTICIPANTS_INVALID',
|
||||
'A team cannot occupy both Series slots',
|
||||
);
|
||||
return normalized;
|
||||
}
|
||||
|
||||
function normalizeFacts(facts: readonly unknown[]): CompetitionFact[] {
|
||||
const normalized = facts.map(normalizeFact).sort(compareFacts);
|
||||
const factIds = new Set<string>();
|
||||
const gameIds = new Set<string>();
|
||||
const riotMatchIds = new Set<string>();
|
||||
|
||||
for (const fact of normalized) {
|
||||
assertCompetitionInvariant(
|
||||
!factIds.has(fact.id),
|
||||
'DUPLICATE_FACT_ID',
|
||||
`Duplicate fact id ${fact.id}`,
|
||||
{ factId: fact.id },
|
||||
);
|
||||
factIds.add(fact.id);
|
||||
|
||||
if (fact.type === 'game-accepted') {
|
||||
assertCompetitionInvariant(
|
||||
!gameIds.has(fact.gameId),
|
||||
'DUPLICATE_GAME_ID',
|
||||
`Duplicate game id ${fact.gameId}`,
|
||||
{ gameId: fact.gameId },
|
||||
);
|
||||
gameIds.add(fact.gameId);
|
||||
const riotMatchId = fact.evidence?.riotMatchId;
|
||||
if (fact.evidence?.type === 'riot' && riotMatchId) {
|
||||
assertCompetitionInvariant(
|
||||
!riotMatchIds.has(riotMatchId),
|
||||
'DUPLICATE_RIOT_MATCH_ID',
|
||||
`Riot match ${riotMatchId} was accepted more than once`,
|
||||
{ riotMatchId },
|
||||
);
|
||||
riotMatchIds.add(riotMatchId);
|
||||
}
|
||||
}
|
||||
}
|
||||
return normalized;
|
||||
}
|
||||
|
||||
function normalizeFact(value: unknown): CompetitionFact {
|
||||
assertCompetitionInvariant(
|
||||
isRecord(value) &&
|
||||
typeof value.id === 'string' &&
|
||||
typeof value.type === 'string' &&
|
||||
Number.isFinite(value.revision) &&
|
||||
Number.isFinite(value.ordinalWithinRevision),
|
||||
'FACT_TYPE_INVALID',
|
||||
'Competition facts require identity and ledger ordering fields',
|
||||
);
|
||||
|
||||
switch (value.type) {
|
||||
case 'game-accepted':
|
||||
case 'game-voided':
|
||||
case 'series-adjudicated':
|
||||
case 'adjudication-reversed':
|
||||
return value as unknown as CompetitionFact;
|
||||
default:
|
||||
throw new CompetitionDomainError(
|
||||
'FACT_TYPE_INVALID',
|
||||
`Unsupported Competition fact type ${value.type}`,
|
||||
{ factType: value.type },
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function selectRelevantFacts(
|
||||
seriesId: string,
|
||||
facts: CompetitionFact[],
|
||||
): CompetitionFact[] {
|
||||
const acceptedSeriesById = new Map(
|
||||
facts
|
||||
.filter((fact): fact is GameAcceptedFact => fact.type === 'game-accepted')
|
||||
.map((fact) => [fact.id, fact.seriesId]),
|
||||
);
|
||||
const adjudicationSeriesById = new Map(
|
||||
facts
|
||||
.filter(
|
||||
(fact): fact is SeriesAdjudicatedFact =>
|
||||
fact.type === 'series-adjudicated',
|
||||
)
|
||||
.map((fact) => [fact.id, fact.seriesId]),
|
||||
);
|
||||
|
||||
return facts.filter((fact) => {
|
||||
switch (fact.type) {
|
||||
case 'game-accepted':
|
||||
case 'series-adjudicated':
|
||||
return fact.seriesId === seriesId;
|
||||
case 'game-voided': {
|
||||
const targetSeriesId = acceptedSeriesById.get(fact.gameAcceptedFactId);
|
||||
assertCompetitionInvariant(
|
||||
targetSeriesId !== undefined,
|
||||
'FACT_REFERENCE_NOT_FOUND',
|
||||
`Voided game fact ${fact.gameAcceptedFactId} does not exist`,
|
||||
{ factId: fact.id, referencedFactId: fact.gameAcceptedFactId },
|
||||
);
|
||||
return targetSeriesId === seriesId;
|
||||
}
|
||||
case 'adjudication-reversed': {
|
||||
const targetSeriesId = adjudicationSeriesById.get(
|
||||
fact.adjudicationFactId,
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
targetSeriesId !== undefined,
|
||||
'FACT_REFERENCE_NOT_FOUND',
|
||||
`Adjudication fact ${fact.adjudicationFactId} does not exist`,
|
||||
{ factId: fact.id, referencedFactId: fact.adjudicationFactId },
|
||||
);
|
||||
return targetSeriesId === seriesId;
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function assertNoSeriesActivity(
|
||||
seriesId: string,
|
||||
facts: CompetitionFact[],
|
||||
): void {
|
||||
const acceptedSeriesById = new Map(
|
||||
facts
|
||||
.filter((fact): fact is GameAcceptedFact => fact.type === 'game-accepted')
|
||||
.map((fact) => [fact.id, fact.seriesId]),
|
||||
);
|
||||
const adjudicationSeriesById = new Map(
|
||||
facts
|
||||
.filter(
|
||||
(fact): fact is SeriesAdjudicatedFact =>
|
||||
fact.type === 'series-adjudicated',
|
||||
)
|
||||
.map((fact) => [fact.id, fact.seriesId]),
|
||||
);
|
||||
const activeGames = new Set<string>();
|
||||
const activeAdjudications = new Set<string>();
|
||||
|
||||
for (const fact of facts) {
|
||||
switch (fact.type) {
|
||||
case 'game-accepted':
|
||||
if (fact.seriesId === seriesId) activeGames.add(fact.id);
|
||||
break;
|
||||
case 'game-voided':
|
||||
if (acceptedSeriesById.get(fact.gameAcceptedFactId) === seriesId) {
|
||||
assertCompetitionInvariant(
|
||||
activeGames.delete(fact.gameAcceptedFactId),
|
||||
'FACT_ALREADY_REVERSED',
|
||||
`Game fact ${fact.gameAcceptedFactId} is already voided`,
|
||||
{ factId: fact.id, referencedFactId: fact.gameAcceptedFactId },
|
||||
);
|
||||
}
|
||||
break;
|
||||
case 'series-adjudicated':
|
||||
if (fact.seriesId === seriesId) activeAdjudications.add(fact.id);
|
||||
break;
|
||||
case 'adjudication-reversed':
|
||||
if (adjudicationSeriesById.get(fact.adjudicationFactId) === seriesId) {
|
||||
assertCompetitionInvariant(
|
||||
activeAdjudications.delete(fact.adjudicationFactId),
|
||||
'FACT_ALREADY_REVERSED',
|
||||
`Adjudication fact ${fact.adjudicationFactId} is already reversed`,
|
||||
{ factId: fact.id, referencedFactId: fact.adjudicationFactId },
|
||||
);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
assertCompetitionInvariant(
|
||||
activeGames.size === 0 && activeAdjudications.size === 0,
|
||||
'SERIES_PARTICIPANTS_INVALID',
|
||||
`Series ${seriesId} cannot contain facts before both participants are active`,
|
||||
{ seriesId },
|
||||
);
|
||||
}
|
||||
|
||||
function validateAcceptedGame(
|
||||
definition: SeriesDefinitionLike,
|
||||
participants: [string, string],
|
||||
fact: GameAcceptedFact,
|
||||
): void {
|
||||
assertCompetitionInvariant(
|
||||
fact.seriesId === definition.id,
|
||||
'GAME_SERIES_MISMATCH',
|
||||
`Game ${fact.gameId} targets a different Series`,
|
||||
);
|
||||
const slot = definition.gameSlots.find(
|
||||
(candidate) => candidate.id === fact.gameSlotId,
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
slot !== undefined,
|
||||
'GAME_SLOT_INVALID',
|
||||
`Game ${fact.gameId} targets an unknown GameSlot`,
|
||||
{ gameId: fact.gameId, gameSlotId: fact.gameSlotId },
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
slot.ordinal === fact.ordinal,
|
||||
'GAME_ORDINAL_INVALID',
|
||||
`Game ${fact.gameId} ordinal does not match its GameSlot`,
|
||||
{ gameId: fact.gameId, ordinal: fact.ordinal },
|
||||
);
|
||||
|
||||
const { blueTeamId, redTeamId, winnerTeamId } = fact.mapping;
|
||||
const expectedTeams = new Set(participants);
|
||||
const actualTeams = new Set([blueTeamId, redTeamId]);
|
||||
assertCompetitionInvariant(
|
||||
actualTeams.size === 2 &&
|
||||
expectedTeams.size === actualTeams.size &&
|
||||
[...expectedTeams].every((teamId) => actualTeams.has(teamId)),
|
||||
'GAME_TEAM_MISMATCH',
|
||||
`Game ${fact.gameId} teams do not match Series ${definition.id}`,
|
||||
{
|
||||
gameId: fact.gameId,
|
||||
expectedTeamIds: participants,
|
||||
actualTeamIds: [blueTeamId, redTeamId],
|
||||
},
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
winnerTeamId === blueTeamId || winnerTeamId === redTeamId,
|
||||
'GAME_WINNER_INVALID',
|
||||
`Game ${fact.gameId} winner is not a participant`,
|
||||
{ gameId: fact.gameId, winnerTeamId },
|
||||
);
|
||||
}
|
||||
|
||||
function validateActiveGameUniqueness(
|
||||
activeGames: Iterable<GameAcceptedFact>,
|
||||
fact: GameAcceptedFact,
|
||||
): void {
|
||||
for (const active of activeGames) {
|
||||
assertCompetitionInvariant(
|
||||
active.gameSlotId !== fact.gameSlotId,
|
||||
'DUPLICATE_GAME_SLOT',
|
||||
`GameSlot ${fact.gameSlotId} already has an accepted game`,
|
||||
{ gameSlotId: fact.gameSlotId },
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
active.ordinal !== fact.ordinal,
|
||||
'DUPLICATE_GAME_ORDINAL',
|
||||
`Series ordinal ${fact.ordinal} already has an accepted game`,
|
||||
{ ordinal: fact.ordinal },
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function validateAdjudication(
|
||||
definition: SeriesDefinitionLike,
|
||||
participants: [string, string],
|
||||
activeGames: GameAcceptedFact[],
|
||||
fact: SeriesAdjudicatedFact,
|
||||
): void {
|
||||
assertCompetitionInvariant(
|
||||
typeof fact.reason === 'string' && fact.reason.trim().length > 0,
|
||||
'ADJUDICATION_INVALID',
|
||||
`Adjudication ${fact.id} requires a reason`,
|
||||
);
|
||||
if (fact.decision.type === 'administrative-draw') {
|
||||
assertCompetitionInvariant(
|
||||
definition.rule.type === 'fixed-games' &&
|
||||
definition.rule.drawPolicy === 'allow',
|
||||
'ADJUDICATION_DRAW_NOT_ALLOWED',
|
||||
`Series ${definition.id} cannot be adjudicated as a draw`,
|
||||
);
|
||||
return;
|
||||
}
|
||||
assertCompetitionInvariant(
|
||||
participants.includes(fact.decision.winnerTeamId),
|
||||
'ADJUDICATION_INVALID',
|
||||
`Adjudication winner is not a Series participant`,
|
||||
);
|
||||
if (fact.decision.type === 'walkover') {
|
||||
assertCompetitionInvariant(
|
||||
activeGames.length === 0,
|
||||
'WALKOVER_HAS_ACTIVE_GAMES',
|
||||
`Walkover Series ${definition.id} cannot retain played games`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function derivePlayedState(
|
||||
rule: SeriesRule,
|
||||
games: GameAcceptedFact[],
|
||||
participants: [string, string],
|
||||
): PlayedState {
|
||||
const activeGames = [...games].sort(compareGames);
|
||||
const winsByTeam = new Map(participants.map((teamId) => [teamId, 0]));
|
||||
for (const game of activeGames) {
|
||||
const winnerTeamId = game.mapping.winnerTeamId;
|
||||
winsByTeam.set(winnerTeamId, (winsByTeam.get(winnerTeamId) ?? 0) + 1);
|
||||
}
|
||||
const completed =
|
||||
rule.type === 'fixed-games'
|
||||
? activeGames.length === rule.gameCount
|
||||
: participants.some(
|
||||
(teamId) => (winsByTeam.get(teamId) ?? 0) >= rule.winsRequired,
|
||||
);
|
||||
return { activeGames, winsByTeam, completed };
|
||||
}
|
||||
|
||||
function playedOutcome(
|
||||
rule: SeriesRule,
|
||||
activeGames: GameAcceptedFact[],
|
||||
participants: [string, string],
|
||||
winsByTeam: Map<string, number>,
|
||||
): SeriesProjectionOutcome {
|
||||
const decidedByGameIds = activeGames.map((game) => game.gameId);
|
||||
const completedAt = toIsoString(activeGames.at(-1)!.occurredAt);
|
||||
const [teamAId, teamBId] = participants;
|
||||
const teamAWins = winsByTeam.get(teamAId) ?? 0;
|
||||
const teamBWins = winsByTeam.get(teamBId) ?? 0;
|
||||
|
||||
if (teamAWins === teamBWins) {
|
||||
assertCompetitionInvariant(
|
||||
rule.type === 'fixed-games' && rule.drawPolicy === 'allow',
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
'This Series completed tied but its rule requires a winner',
|
||||
);
|
||||
return {
|
||||
type: 'draw',
|
||||
basis: { type: 'played', decidedByGameIds },
|
||||
completedAt,
|
||||
};
|
||||
}
|
||||
|
||||
const winnerTeamId = teamAWins > teamBWins ? teamAId : teamBId;
|
||||
return {
|
||||
type: 'played',
|
||||
winnerTeamId,
|
||||
loserTeamId: winnerTeamId === teamAId ? teamBId : teamAId,
|
||||
decidedByGameIds,
|
||||
completedAt,
|
||||
};
|
||||
}
|
||||
|
||||
function adjudicatedOutcome(
|
||||
fact: SeriesAdjudicatedFact,
|
||||
participants: [string, string],
|
||||
): SeriesProjectionOutcome {
|
||||
const completedAt = toIsoString(fact.occurredAt);
|
||||
if (fact.decision.type === 'administrative-draw') {
|
||||
return {
|
||||
type: 'draw',
|
||||
basis: { type: 'administrative', decisionFactId: fact.id },
|
||||
completedAt,
|
||||
};
|
||||
}
|
||||
const winnerTeamId = fact.decision.winnerTeamId;
|
||||
return {
|
||||
type: fact.decision.type,
|
||||
winnerTeamId,
|
||||
loserTeamId:
|
||||
participants[0] === winnerTeamId ? participants[1] : participants[0],
|
||||
decisionFactId: fact.id,
|
||||
completedAt,
|
||||
};
|
||||
}
|
||||
|
||||
function projectionBase(
|
||||
definition: SeriesDefinitionLike,
|
||||
participants: [string | null, string | null],
|
||||
): SeriesProjectionBase {
|
||||
return {
|
||||
seriesId: definition.id,
|
||||
...(definition.code ? { code: definition.code } : {}),
|
||||
stage: definition.stage,
|
||||
rule: definition.rule,
|
||||
entries: [
|
||||
{ slot: 'A', teamId: participants[0], gameWins: 0 },
|
||||
{ slot: 'B', teamId: participants[1], gameWins: 0 },
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
function entriesFor(
|
||||
participants: [string, string],
|
||||
winsByTeam: Map<string, number>,
|
||||
): [SeriesProjectionEntry, SeriesProjectionEntry] {
|
||||
return [
|
||||
{
|
||||
slot: 'A',
|
||||
teamId: participants[0],
|
||||
gameWins: winsByTeam.get(participants[0]) ?? 0,
|
||||
},
|
||||
{
|
||||
slot: 'B',
|
||||
teamId: participants[1],
|
||||
gameWins: winsByTeam.get(participants[1]) ?? 0,
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
function deriveLeader(
|
||||
participants: [string, string],
|
||||
winsByTeam: Map<string, number>,
|
||||
): string | undefined {
|
||||
const firstWins = winsByTeam.get(participants[0]) ?? 0;
|
||||
const secondWins = winsByTeam.get(participants[1]) ?? 0;
|
||||
if (firstWins === secondWins) return undefined;
|
||||
return firstWins > secondWins ? participants[0] : participants[1];
|
||||
}
|
||||
|
||||
function compareFacts(left: CompetitionFact, right: CompetitionFact): number {
|
||||
return (
|
||||
left.revision - right.revision ||
|
||||
left.ordinalWithinRevision - right.ordinalWithinRevision ||
|
||||
left.id.localeCompare(right.id)
|
||||
);
|
||||
}
|
||||
|
||||
function compareGames(left: GameAcceptedFact, right: GameAcceptedFact): number {
|
||||
return (
|
||||
left.ordinal - right.ordinal ||
|
||||
left.revision - right.revision ||
|
||||
left.id.localeCompare(right.id)
|
||||
);
|
||||
}
|
||||
|
||||
function toIsoString(value: Date | string): string {
|
||||
const date = value instanceof Date ? value : new Date(value);
|
||||
assertCompetitionInvariant(
|
||||
!Number.isNaN(date.getTime()),
|
||||
'FACT_TYPE_INVALID',
|
||||
'Fact timestamps must be valid dates',
|
||||
);
|
||||
return date.toISOString();
|
||||
}
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return typeof value === 'object' && value !== null;
|
||||
}
|
||||
@@ -0,0 +1,178 @@
|
||||
import { Type } from 'class-transformer';
|
||||
import {
|
||||
IsEnum,
|
||||
IsArray,
|
||||
IsDate,
|
||||
IsInt,
|
||||
IsMongoId,
|
||||
IsNumber,
|
||||
IsObject,
|
||||
IsOptional,
|
||||
IsString,
|
||||
Matches,
|
||||
Max,
|
||||
MaxLength,
|
||||
Min,
|
||||
MinLength,
|
||||
ValidateIf,
|
||||
ValidateNested,
|
||||
} from 'class-validator';
|
||||
|
||||
const ADJUDICATION_TYPES = [
|
||||
'walkover',
|
||||
'forfeit',
|
||||
'administrative',
|
||||
'administrative-draw',
|
||||
] as const;
|
||||
const REVERSAL_MODES = ['strict', 'cascade'] as const;
|
||||
const EVIDENCE_TYPES = ['riot', 'legacy'] as const;
|
||||
|
||||
export class CompetitionGameEvidenceDto {
|
||||
@IsEnum(EVIDENCE_TYPES)
|
||||
type!: (typeof EVIDENCE_TYPES)[number];
|
||||
|
||||
@ValidateIf(({ type }) => type === 'riot')
|
||||
@IsString()
|
||||
@MinLength(1)
|
||||
@MaxLength(128)
|
||||
riotMatchId?: string;
|
||||
|
||||
@ValidateIf(({ type }) => type === 'riot')
|
||||
@IsString()
|
||||
@MinLength(1)
|
||||
@MaxLength(256)
|
||||
payloadHash?: string;
|
||||
|
||||
@ValidateIf(({ type }) => type === 'legacy')
|
||||
@IsString()
|
||||
@MinLength(1)
|
||||
@MaxLength(512)
|
||||
legacyReference?: string;
|
||||
}
|
||||
|
||||
export class CompetitionGameMappingDto {
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
mappingVersion!: number;
|
||||
|
||||
@IsNumber()
|
||||
@Min(0)
|
||||
@Max(1)
|
||||
confidence!: number;
|
||||
|
||||
@IsMongoId()
|
||||
blueTeamId!: string;
|
||||
|
||||
@IsMongoId()
|
||||
redTeamId!: string;
|
||||
|
||||
@IsMongoId()
|
||||
winnerTeamId!: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@IsObject({ each: true })
|
||||
participantAssignments?: Array<Record<string, unknown>>;
|
||||
}
|
||||
|
||||
export class TournamentCodeReferenceDto {
|
||||
@IsMongoId()
|
||||
tournamentCodeId!: string;
|
||||
|
||||
@IsString()
|
||||
@MinLength(1)
|
||||
@MaxLength(128)
|
||||
riotMatchId!: string;
|
||||
}
|
||||
|
||||
export class AcceptCompetitionGameDto {
|
||||
@IsMongoId()
|
||||
gameId!: string;
|
||||
|
||||
@IsMongoId()
|
||||
seriesId!: string;
|
||||
|
||||
@IsMongoId()
|
||||
gameSlotId!: string;
|
||||
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
ordinal!: number;
|
||||
|
||||
@ValidateNested()
|
||||
@Type(() => CompetitionGameEvidenceDto)
|
||||
evidence!: CompetitionGameEvidenceDto;
|
||||
|
||||
@ValidateNested()
|
||||
@Type(() => CompetitionGameMappingDto)
|
||||
mapping!: CompetitionGameMappingDto;
|
||||
|
||||
@IsOptional()
|
||||
@IsDate()
|
||||
@Type(() => Date)
|
||||
startedAt?: Date;
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
@Min(0)
|
||||
durationSeconds?: number;
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@IsObject({ each: true })
|
||||
participants?: Array<Record<string, unknown>>;
|
||||
|
||||
@IsOptional()
|
||||
@ValidateNested()
|
||||
@Type(() => TournamentCodeReferenceDto)
|
||||
tournamentCode?: TournamentCodeReferenceDto;
|
||||
}
|
||||
|
||||
export class CompetitionAdjudicationDecisionDto {
|
||||
@IsEnum(ADJUDICATION_TYPES)
|
||||
type!: (typeof ADJUDICATION_TYPES)[number];
|
||||
|
||||
@ValidateIf(({ type }) => type !== 'administrative-draw')
|
||||
@IsMongoId()
|
||||
winnerTeamId?: string;
|
||||
}
|
||||
|
||||
export class AdjudicateCompetitionSeriesDto {
|
||||
@ValidateNested()
|
||||
@Type(() => CompetitionAdjudicationDecisionDto)
|
||||
decision!: CompetitionAdjudicationDecisionDto;
|
||||
|
||||
@IsString()
|
||||
@MinLength(1)
|
||||
@MaxLength(2000)
|
||||
reason!: string;
|
||||
}
|
||||
|
||||
export class PreviewCompetitionSeriesReversalDto {
|
||||
@IsEnum(REVERSAL_MODES)
|
||||
mode!: (typeof REVERSAL_MODES)[number];
|
||||
|
||||
@IsString()
|
||||
@MinLength(1)
|
||||
@MaxLength(2000)
|
||||
reason!: string;
|
||||
}
|
||||
|
||||
export class ReverseCompetitionSeriesDto extends PreviewCompetitionSeriesReversalDto {
|
||||
@Matches(/^[a-f0-9]{64}$/)
|
||||
impactHash!: string;
|
||||
}
|
||||
|
||||
export class CompetitionFactsQueryDto {
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(512)
|
||||
cursor?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
@Max(100)
|
||||
@Type(() => Number)
|
||||
limit?: number;
|
||||
}
|
||||
@@ -0,0 +1,303 @@
|
||||
import { projectCompetition } from '../../../competition/domain/competition-projector';
|
||||
import {
|
||||
planCompetitionMigration,
|
||||
type LegacyMatchInput,
|
||||
type ReadyCompetitionMigrationPlan,
|
||||
} from './20260712-competition-domain';
|
||||
|
||||
describe('planCompetitionMigration', () => {
|
||||
it('produces deterministic, idempotent identities and maps legacy bracket mode explicitly', () => {
|
||||
const legacy = pairedMatch({ gameMode: 'bracket' });
|
||||
|
||||
const first = planCompetitionMigration(legacy);
|
||||
const second = planCompetitionMigration(structuredClone(legacy));
|
||||
|
||||
expect(first).toEqual(second);
|
||||
const plan = requireReady(first);
|
||||
expect(plan.competition.id).toMatch(/^[a-f0-9]{24}$/);
|
||||
expect(plan.competition.teams.map((team) => team.teamId)).toEqual(
|
||||
expect.arrayContaining([
|
||||
expect.stringMatching(/^[a-f0-9]{24}$/),
|
||||
expect.stringMatching(/^[a-f0-9]{24}$/),
|
||||
]),
|
||||
);
|
||||
expect(plan.competition.format).toMatchObject({ type: 'paired-series' });
|
||||
expect(plan.warnings).toContainEqual(
|
||||
expect.objectContaining({
|
||||
code: 'LEGACY_BRACKET_MAPPED_TO_PAIRED_SERIES',
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('preserves Riot-backed and normalized-only games as different evidence kinds', () => {
|
||||
const legacy = pairedMatch({ gameCount: 2 });
|
||||
legacy.result = {
|
||||
games: [
|
||||
legacyGame({
|
||||
gameNumber: 1,
|
||||
riotMatchId: 'KR_WITH_ARCHIVE',
|
||||
blueTeamIndex: 1,
|
||||
redTeamIndex: 2,
|
||||
winnerTeamIndex: 1,
|
||||
riotArchivePresent: true,
|
||||
}),
|
||||
legacyGame({
|
||||
gameNumber: 2,
|
||||
riotMatchId: 'KR_NORMALIZED_ONLY',
|
||||
blueTeamIndex: 2,
|
||||
redTeamIndex: 1,
|
||||
winnerTeamIndex: 2,
|
||||
riotArchivePresent: false,
|
||||
}),
|
||||
],
|
||||
seriesResults: [],
|
||||
};
|
||||
|
||||
const plan = requireReady(planCompetitionMigration(legacy));
|
||||
const games = plan.facts.filter((fact) => fact.type === 'game-accepted');
|
||||
|
||||
expect(games).toHaveLength(2);
|
||||
expect(games[0]).toMatchObject({
|
||||
evidence: {
|
||||
type: 'riot',
|
||||
riotMatchId: 'KR_WITH_ARCHIVE',
|
||||
},
|
||||
});
|
||||
expect(games[1]).toMatchObject({
|
||||
evidence: {
|
||||
type: 'legacy',
|
||||
legacyReference: expect.stringContaining('KR_NORMALIZED_ONLY'),
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it('turns a winner-only Series into an adjudication without fabricating games', () => {
|
||||
const legacy = pairedMatch({ gameCount: 3 });
|
||||
legacy.result = {
|
||||
games: [],
|
||||
seriesResults: [
|
||||
{
|
||||
teamAIndex: 1,
|
||||
teamBIndex: 2,
|
||||
teamAWins: 0,
|
||||
teamBWins: 0,
|
||||
winnerTeamIndex: 2,
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
const plan = requireReady(planCompetitionMigration(legacy));
|
||||
|
||||
expect(plan.facts).toHaveLength(1);
|
||||
expect(plan.facts[0]).toMatchObject({
|
||||
type: 'series-adjudicated',
|
||||
decision: {
|
||||
type: 'administrative',
|
||||
winnerTeamId: plan.competition.teams[1].teamId,
|
||||
},
|
||||
reason: 'legacy-winner-only-result',
|
||||
});
|
||||
expect(plan.facts).not.toContainEqual(
|
||||
expect.objectContaining({ type: 'game-accepted' }),
|
||||
);
|
||||
});
|
||||
|
||||
it('quarantines an ambiguous legacy game assignment instead of guessing', () => {
|
||||
const legacy = pairedMatch({
|
||||
teams: [
|
||||
legacyTeam(1, 'One'),
|
||||
legacyTeam(2, 'Two'),
|
||||
legacyTeam(3, 'Three'),
|
||||
legacyTeam(4, 'Four'),
|
||||
],
|
||||
});
|
||||
legacy.gameSchedule = [
|
||||
{ gameNumber: 7, teamAIndex: 1, teamBIndex: 2 },
|
||||
{ gameNumber: 7, teamAIndex: 3, teamBIndex: 4 },
|
||||
];
|
||||
legacy.result = {
|
||||
games: [
|
||||
legacyGame({
|
||||
gameNumber: 7,
|
||||
riotMatchId: 'KR_AMBIGUOUS',
|
||||
blueTeamIndex: 1,
|
||||
redTeamIndex: 2,
|
||||
winnerTeamIndex: 1,
|
||||
riotArchivePresent: true,
|
||||
}),
|
||||
],
|
||||
seriesResults: [],
|
||||
};
|
||||
|
||||
const plan = planCompetitionMigration(legacy);
|
||||
|
||||
expect(plan).toMatchObject({
|
||||
status: 'quarantined',
|
||||
reasons: expect.arrayContaining([
|
||||
expect.objectContaining({ code: 'AMBIGUOUS_GAME_ASSIGNMENT' }),
|
||||
]),
|
||||
});
|
||||
});
|
||||
|
||||
it('repairs the data.txt WB_R2_M2 positional bug from accepted game evidence', () => {
|
||||
const legacy = loadDataTxtFixture();
|
||||
|
||||
const plan = requireReady(planCompetitionMigration(legacy));
|
||||
const projection = projectCompetition({
|
||||
competitionId: plan.competition.id,
|
||||
revision: plan.competition.revision,
|
||||
projectorVersion: plan.competition.projectorVersion,
|
||||
teams: plan.competition.teams,
|
||||
format: plan.competition.format,
|
||||
seriesGraph: plan.competition.seriesGraph,
|
||||
facts: plan.facts,
|
||||
});
|
||||
const team3 = plan.competition.teams.find(
|
||||
(team) => team.legacyTeamIndex === 3,
|
||||
);
|
||||
const team8 = plan.competition.teams.find(
|
||||
(team) => team.legacyTeamIndex === 8,
|
||||
);
|
||||
const series = (code: string) =>
|
||||
projection.series.find((candidate) => candidate.code === code);
|
||||
|
||||
expect(team3).toBeDefined();
|
||||
expect(team8).toBeDefined();
|
||||
expect(series('WB_R2_M2')).toMatchObject({
|
||||
status: 'completed',
|
||||
entries: [
|
||||
{ slot: 'A', teamId: team8!.teamId, gameWins: 2 },
|
||||
{ slot: 'B', teamId: team3!.teamId, gameWins: 1 },
|
||||
],
|
||||
outcome: {
|
||||
type: 'played',
|
||||
winnerTeamId: team8!.teamId,
|
||||
loserTeamId: team3!.teamId,
|
||||
},
|
||||
});
|
||||
expect(series('WB_FINAL')).toMatchObject({
|
||||
entries: expect.arrayContaining([
|
||||
{ slot: 'B', teamId: team8!.teamId, gameWins: 0 },
|
||||
]),
|
||||
});
|
||||
expect(series('LB_R2_M1')).toMatchObject({
|
||||
entries: expect.arrayContaining([
|
||||
{ slot: 'B', teamId: team3!.teamId, gameWins: 0 },
|
||||
]),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
function pairedMatch(
|
||||
overrides: Partial<LegacyMatchInput> = {},
|
||||
): LegacyMatchInput {
|
||||
return {
|
||||
_id: 'match-legacy-paired',
|
||||
communityId: 'community-1',
|
||||
gameMode: 'pair',
|
||||
gameCount: 1,
|
||||
status: 'in-progress',
|
||||
teams: [legacyTeam(1, 'One'), legacyTeam(2, 'Two')],
|
||||
gameSchedule: [{ gameNumber: 1, teamAIndex: 1, teamBIndex: 2 }],
|
||||
createdAt: '2026-07-01T00:00:00.000Z',
|
||||
updatedAt: '2026-07-02T00:00:00.000Z',
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
function legacyTeam(teamIndex: number, name: string) {
|
||||
return {
|
||||
teamIndex,
|
||||
name,
|
||||
captainUserId: `captain-${teamIndex}`,
|
||||
members: [],
|
||||
};
|
||||
}
|
||||
|
||||
function legacyGame(
|
||||
overrides: Partial<NonNullable<LegacyMatchInput['result']>['games'][number]>,
|
||||
): NonNullable<LegacyMatchInput['result']>['games'][number] {
|
||||
return {
|
||||
gameNumber: 1,
|
||||
riotMatchId: 'KR_DEFAULT',
|
||||
blueTeamIndex: 1,
|
||||
redTeamIndex: 2,
|
||||
winnerTeamIndex: 1,
|
||||
gameCreation: 1782864000000,
|
||||
gameDuration: 1800,
|
||||
participants: [],
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
function requireReady(
|
||||
plan: ReturnType<typeof planCompetitionMigration>,
|
||||
): ReadyCompetitionMigrationPlan {
|
||||
if (plan.status !== 'ready') {
|
||||
throw new Error(
|
||||
`Expected ready migration plan: ${JSON.stringify(plan.reasons)}`,
|
||||
);
|
||||
}
|
||||
return plan;
|
||||
}
|
||||
|
||||
function loadDataTxtFixture(): LegacyMatchInput {
|
||||
const seededTeamIndexes = [1, 8, 3, 4, 5, 6, 7, 2];
|
||||
const games = [
|
||||
['WB_R1_M3', 8, 7, 8],
|
||||
['WB_R1_M3', 7, 8, 8],
|
||||
['WB_R1_M4', 3, 6, 3],
|
||||
['WB_R1_M4', 6, 3, 3],
|
||||
['WB_R2_M2', 3, 8, 8],
|
||||
['WB_R2_M2', 8, 3, 3],
|
||||
['WB_R2_M2', 3, 8, 8],
|
||||
] as const;
|
||||
|
||||
return {
|
||||
_id: '6a3e0c2c8ade90b14b72f335',
|
||||
communityId: '69ebe0adf627c11be2f020a1',
|
||||
gameMode: 'double-elimination',
|
||||
gameCount: 3,
|
||||
status: 'in-progress',
|
||||
teams: Array.from({ length: 8 }, (_, index) =>
|
||||
legacyTeam(
|
||||
index + 1,
|
||||
index + 1 === 3
|
||||
? '해온해줘'
|
||||
: index + 1 === 8
|
||||
? '똥칼라파워'
|
||||
: `${index + 1}팀`,
|
||||
),
|
||||
),
|
||||
doubleElimination: {
|
||||
teamCount: 8,
|
||||
resetFinalEnabled: true,
|
||||
seeds: seededTeamIndexes.map((teamIndex, index) => ({
|
||||
seedNumber: index + 1,
|
||||
teamIndex,
|
||||
})),
|
||||
bracketMatches: [],
|
||||
},
|
||||
result: {
|
||||
games: games.map(
|
||||
(
|
||||
[bracketMatchId, blueTeamIndex, redTeamIndex, winnerTeamIndex],
|
||||
index,
|
||||
) =>
|
||||
legacyGame({
|
||||
gameNumber: index + 1,
|
||||
bracketMatchId,
|
||||
riotMatchId: `KR_DATA_TXT_${index + 1}`,
|
||||
riotArchivePresent: true,
|
||||
blueTeamIndex,
|
||||
redTeamIndex,
|
||||
winnerTeamIndex,
|
||||
gameCreation: 1782864000000 + index * 60_000,
|
||||
}),
|
||||
),
|
||||
seriesResults: [],
|
||||
},
|
||||
createdAt: '2026-06-27T05:18:00.000Z',
|
||||
updatedAt: '2026-07-12T17:17:00.000Z',
|
||||
};
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,842 @@
|
||||
import mongoose from 'mongoose';
|
||||
import {
|
||||
migrateCompetitionDomain,
|
||||
type CompetitionDomainMigrationDb,
|
||||
type CompetitionDomainMigrationSession,
|
||||
} from './competition-domain-runner';
|
||||
|
||||
describe('migrateCompetitionDomain', () => {
|
||||
it('defaults to a side-effect-free dry run and reports the deterministic plan', async () => {
|
||||
const match = readyMatch();
|
||||
const db = new MemoryMigrationDb({
|
||||
match: [match],
|
||||
riotMatch: [riotArchive()],
|
||||
tournamentCode: [usedTournamentCode(match)],
|
||||
});
|
||||
const startSession = jest.fn(async () => new FakeSession());
|
||||
|
||||
const result = await migrateCompetitionDomain(db, { startSession });
|
||||
|
||||
expect(result.mode).toBe('dry-run');
|
||||
expect(result.summary).toMatchObject({
|
||||
scanned: 1,
|
||||
ready: 1,
|
||||
applied: 0,
|
||||
quarantined: 0,
|
||||
failed: 0,
|
||||
unclassified: 0,
|
||||
factsPlanned: 1,
|
||||
assignmentsPlanned: 1,
|
||||
});
|
||||
expect(result.matches[0]).toMatchObject({
|
||||
status: 'ready',
|
||||
factCount: 1,
|
||||
assignmentCount: 1,
|
||||
});
|
||||
expect(startSession).not.toHaveBeenCalled();
|
||||
expect(db.writeCount).toBe(0);
|
||||
expect(db.docs('competition')).toHaveLength(0);
|
||||
expect(db.createdIndexes).toHaveLength(0);
|
||||
});
|
||||
|
||||
it.each([
|
||||
['absent', (match: AnyDoc) => delete match.gameMode],
|
||||
['null', (match: AnyDoc) => (match.gameMode = null)],
|
||||
])(
|
||||
'restores the historical pair default when raw Mongo Match gameMode is %s',
|
||||
async (_label, omitGameMode) => {
|
||||
const match = readyMatch();
|
||||
omitGameMode(match);
|
||||
const before = canonical(match);
|
||||
const db = new MemoryMigrationDb({
|
||||
match: [match],
|
||||
riotMatch: [riotArchive()],
|
||||
tournamentCode: [usedTournamentCode(match)],
|
||||
});
|
||||
|
||||
const result = await migrateCompetitionDomain(db);
|
||||
|
||||
expect(result.summary).toMatchObject({
|
||||
scanned: 1,
|
||||
ready: 1,
|
||||
quarantined: 0,
|
||||
failed: 0,
|
||||
});
|
||||
expect(result.matches[0]).toMatchObject({
|
||||
status: 'ready',
|
||||
factCount: 1,
|
||||
assignmentCount: 1,
|
||||
});
|
||||
expect(canonical(db.docs('match')[0])).toBe(before);
|
||||
expect(db.writeCount).toBe(0);
|
||||
},
|
||||
);
|
||||
|
||||
it('keeps an explicitly unknown raw Mongo Match gameMode quarantined', async () => {
|
||||
const match = readyMatch();
|
||||
match.gameMode = 'future-mode';
|
||||
const db = new MemoryMigrationDb({ match: [match] });
|
||||
|
||||
const result = await migrateCompetitionDomain(db);
|
||||
|
||||
expect(result.summary).toMatchObject({
|
||||
scanned: 1,
|
||||
ready: 0,
|
||||
quarantined: 1,
|
||||
failed: 0,
|
||||
});
|
||||
expect(result.matches[0]).toMatchObject({
|
||||
status: 'quarantined',
|
||||
reasons: [
|
||||
expect.objectContaining({ code: 'UNSUPPORTED_LEGACY_GAME_MODE' }),
|
||||
],
|
||||
});
|
||||
expect(db.writeCount).toBe(0);
|
||||
});
|
||||
|
||||
it('applies one Match atomically and converges on an already-applied replay', async () => {
|
||||
const match = readyMatch();
|
||||
const originalResult = canonical(match.result);
|
||||
const db = new MemoryMigrationDb({
|
||||
match: [match],
|
||||
riotMatch: [riotArchive()],
|
||||
tournamentCode: [usedTournamentCode(match)],
|
||||
});
|
||||
const sessions: FakeSession[] = [];
|
||||
const startSession = jest.fn(async () => {
|
||||
const session = new FakeSession();
|
||||
sessions.push(session);
|
||||
return session;
|
||||
});
|
||||
|
||||
const first = await migrateCompetitionDomain(db, {
|
||||
dryRun: false,
|
||||
startSession,
|
||||
});
|
||||
|
||||
expect(first.summary).toMatchObject({
|
||||
scanned: 1,
|
||||
applied: 1,
|
||||
alreadyApplied: 0,
|
||||
failed: 0,
|
||||
});
|
||||
expect(db.docs('competition')).toHaveLength(1);
|
||||
expect(db.docs('competition_fact')).toHaveLength(1);
|
||||
expect(db.docs('competition_fact')[0].evidence).toMatchObject({
|
||||
type: 'riot',
|
||||
riotMatchId: 'KR_MIGRATION_1',
|
||||
payloadHash: expect.stringMatching(/^sha256:[a-f0-9]{64}$/),
|
||||
});
|
||||
expect(db.docs('tournament_code_assignment')).toHaveLength(1);
|
||||
expect(db.docs('competition_migration_quarantine')).toHaveLength(0);
|
||||
expect(String(db.docs('match')[0].competitionId)).toBe(
|
||||
first.matches[0].competitionId,
|
||||
);
|
||||
expect(canonical(db.docs('match')[0].result)).toBe(originalResult);
|
||||
expect(sessions[0]).toMatchObject({
|
||||
started: 1,
|
||||
committed: 1,
|
||||
aborted: 0,
|
||||
ended: 1,
|
||||
});
|
||||
|
||||
const second = await migrateCompetitionDomain(db, {
|
||||
dryRun: false,
|
||||
startSession,
|
||||
});
|
||||
|
||||
expect(second.summary).toMatchObject({
|
||||
scanned: 1,
|
||||
applied: 0,
|
||||
alreadyApplied: 1,
|
||||
failed: 0,
|
||||
});
|
||||
expect(db.docs('competition')).toHaveLength(1);
|
||||
expect(db.docs('competition_fact')).toHaveLength(1);
|
||||
expect(db.docs('tournament_code_assignment')).toHaveLength(1);
|
||||
expect(sessions[1]).toMatchObject({ committed: 1, aborted: 0, ended: 1 });
|
||||
});
|
||||
|
||||
it('quarantines an ambiguous Match without changing any legacy Match field', async () => {
|
||||
const match = ambiguousMatch();
|
||||
const before = canonical(match);
|
||||
const db = new MemoryMigrationDb({ match: [match] });
|
||||
const session = new FakeSession();
|
||||
|
||||
const result = await migrateCompetitionDomain(db, {
|
||||
dryRun: false,
|
||||
startSession: async () => session,
|
||||
});
|
||||
|
||||
expect(result.summary).toMatchObject({
|
||||
scanned: 1,
|
||||
quarantined: 1,
|
||||
applied: 0,
|
||||
failed: 0,
|
||||
});
|
||||
expect(result.matches[0]).toMatchObject({
|
||||
status: 'quarantined',
|
||||
reasons: expect.arrayContaining([
|
||||
expect.objectContaining({ code: 'AMBIGUOUS_GAME_ASSIGNMENT' }),
|
||||
]),
|
||||
});
|
||||
expect(canonical(db.docs('match')[0])).toBe(before);
|
||||
expect(db.docs('competition')).toHaveLength(0);
|
||||
expect(db.docs('competition_fact')).toHaveLength(0);
|
||||
expect(db.docs('competition_migration_quarantine')).toHaveLength(1);
|
||||
expect(session).toMatchObject({ committed: 1, aborted: 0, ended: 1 });
|
||||
});
|
||||
|
||||
it('aborts and reports a failed Match when persisted projection replay diverges', async () => {
|
||||
const match = readyMatch();
|
||||
const db = new MemoryMigrationDb({
|
||||
match: [match],
|
||||
riotMatch: [riotArchive()],
|
||||
tournamentCode: [usedTournamentCode(match)],
|
||||
});
|
||||
await migrateCompetitionDomain(db, {
|
||||
dryRun: false,
|
||||
startSession: async () => new FakeSession(),
|
||||
});
|
||||
db.docs('competition')[0].projection = {
|
||||
phase: 'completed',
|
||||
corrupt: true,
|
||||
};
|
||||
const session = new FakeSession();
|
||||
|
||||
const result = await migrateCompetitionDomain(db, {
|
||||
dryRun: false,
|
||||
startSession: async () => session,
|
||||
});
|
||||
|
||||
expect(result.summary).toMatchObject({
|
||||
scanned: 1,
|
||||
applied: 0,
|
||||
alreadyApplied: 0,
|
||||
failed: 1,
|
||||
});
|
||||
expect(result.matches[0]).toMatchObject({
|
||||
status: 'failed',
|
||||
error: expect.stringContaining('replay'),
|
||||
});
|
||||
expect(session).toMatchObject({ committed: 0, aborted: 1, ended: 1 });
|
||||
});
|
||||
|
||||
it('reports apply failures without attempting writes when no session can be created', async () => {
|
||||
const db = new MemoryMigrationDb({ match: [readyMatch()] });
|
||||
|
||||
const result = await migrateCompetitionDomain(db, {
|
||||
dryRun: false,
|
||||
startSession: async () => undefined,
|
||||
});
|
||||
|
||||
expect(result.summary.failed).toBe(1);
|
||||
expect(result.matches[0]).toMatchObject({
|
||||
status: 'failed',
|
||||
error: expect.stringContaining('transaction session'),
|
||||
});
|
||||
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 {
|
||||
public started = 0;
|
||||
public committed = 0;
|
||||
public aborted = 0;
|
||||
public ended = 0;
|
||||
|
||||
startTransaction(): void {
|
||||
this.started += 1;
|
||||
}
|
||||
|
||||
async commitTransaction(): Promise<void> {
|
||||
this.committed += 1;
|
||||
}
|
||||
|
||||
async abortTransaction(): Promise<void> {
|
||||
this.aborted += 1;
|
||||
}
|
||||
|
||||
async endSession(): Promise<void> {
|
||||
this.ended += 1;
|
||||
}
|
||||
}
|
||||
|
||||
type AnyDoc = Record<string, any> & { _id: unknown };
|
||||
|
||||
class MemoryMigrationDb implements CompetitionDomainMigrationDb {
|
||||
private readonly collections = new Map<string, AnyDoc[]>();
|
||||
public writeCount = 0;
|
||||
public readonly createdIndexes: Array<{
|
||||
collection: string;
|
||||
key: Record<string, unknown>;
|
||||
options: Record<string, unknown>;
|
||||
}> = [];
|
||||
public readonly operations: string[] = [];
|
||||
public indexCreationError?: Error;
|
||||
|
||||
constructor(seed: Record<string, AnyDoc[]> = {}) {
|
||||
for (const [name, docs] of Object.entries(seed)) {
|
||||
this.collections.set(name, docs);
|
||||
}
|
||||
}
|
||||
|
||||
docs(name: string): AnyDoc[] {
|
||||
const docs = this.collections.get(name) ?? [];
|
||||
this.collections.set(name, docs);
|
||||
return docs;
|
||||
}
|
||||
|
||||
collection(name: string) {
|
||||
const owner = this;
|
||||
return {
|
||||
createIndex(
|
||||
key: Record<string, unknown>,
|
||||
options: Record<string, unknown>,
|
||||
) {
|
||||
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<string, unknown>) {
|
||||
return new MemoryCursor(() =>
|
||||
owner.docs(name).filter((doc) => matches(doc, filter)),
|
||||
);
|
||||
},
|
||||
async findOne(filter: Record<string, unknown>) {
|
||||
return owner.docs(name).find((doc) => matches(doc, filter)) ?? null;
|
||||
},
|
||||
async updateOne(
|
||||
filter: Record<string, unknown>,
|
||||
update: Record<string, Record<string, unknown>>,
|
||||
options: { upsert?: boolean } = {},
|
||||
) {
|
||||
owner.operations.push('write');
|
||||
owner.writeCount += 1;
|
||||
const docs = owner.docs(name);
|
||||
let doc = docs.find((candidate) => matches(candidate, filter));
|
||||
const inserted = !doc && options.upsert === true;
|
||||
if (inserted) {
|
||||
doc = materializeEqualityFilter(filter);
|
||||
docs.push(doc);
|
||||
}
|
||||
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,
|
||||
upsertedCount: inserted ? 1 : 0,
|
||||
};
|
||||
},
|
||||
async deleteOne(filter: Record<string, unknown>) {
|
||||
owner.operations.push('write');
|
||||
owner.writeCount += 1;
|
||||
const docs = owner.docs(name);
|
||||
const index = docs.findIndex((doc) => matches(doc, filter));
|
||||
if (index === -1) return { deletedCount: 0 };
|
||||
docs.splice(index, 1);
|
||||
return { deletedCount: 1 };
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
class MemoryCursor {
|
||||
private sortSpec: Record<string, 1 | -1> = {};
|
||||
private max = 0;
|
||||
|
||||
constructor(private readonly read: () => AnyDoc[]) {}
|
||||
|
||||
sort(spec: Record<string, 1 | -1>): this {
|
||||
this.sortSpec = spec;
|
||||
return this;
|
||||
}
|
||||
|
||||
limit(limit: number): this {
|
||||
this.max = limit;
|
||||
return this;
|
||||
}
|
||||
|
||||
async *[Symbol.asyncIterator](): AsyncIterator<AnyDoc> {
|
||||
const entries = [...this.read()].sort((left, right) => {
|
||||
for (const [key, direction] of Object.entries(this.sortSpec)) {
|
||||
const compared = String(readPath(left, key)).localeCompare(
|
||||
String(readPath(right, key)),
|
||||
);
|
||||
if (compared !== 0) return compared * direction;
|
||||
}
|
||||
return 0;
|
||||
});
|
||||
for (const doc of this.max > 0 ? entries.slice(0, this.max) : entries) {
|
||||
yield doc;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function matches(doc: AnyDoc, filter: Record<string, unknown>): boolean {
|
||||
return Object.entries(filter).every(([key, expected]) => {
|
||||
if (key === '$or') {
|
||||
return (expected as Record<string, unknown>[]).some((candidate) =>
|
||||
matches(doc, candidate),
|
||||
);
|
||||
}
|
||||
const actual = readPath(doc, key);
|
||||
if (isRecord(expected)) {
|
||||
if ('$exists' in expected) {
|
||||
return (actual !== undefined) === Boolean(expected.$exists);
|
||||
}
|
||||
if ('$in' in expected) {
|
||||
return (expected.$in as unknown[]).some((candidate) =>
|
||||
sameValue(actual, candidate),
|
||||
);
|
||||
}
|
||||
if ('$gt' in expected) {
|
||||
return String(actual) > String(expected.$gt);
|
||||
}
|
||||
}
|
||||
return sameValue(actual, expected);
|
||||
});
|
||||
}
|
||||
|
||||
function readPath(value: unknown, path: string): unknown {
|
||||
return path.split('.').reduce<unknown>((current, segment) => {
|
||||
if (Array.isArray(current) && /^\d+$/.test(segment)) {
|
||||
return current[Number(segment)];
|
||||
}
|
||||
return isRecord(current) ? current[segment] : undefined;
|
||||
}, value);
|
||||
}
|
||||
|
||||
function materializeEqualityFilter(filter: Record<string, unknown>): AnyDoc {
|
||||
return Object.fromEntries(
|
||||
Object.entries(filter).filter(
|
||||
([key, value]) => !key.startsWith('$') && !isRecord(value),
|
||||
),
|
||||
) as AnyDoc;
|
||||
}
|
||||
|
||||
function sameValue(left: unknown, right: unknown): boolean {
|
||||
return String(left) === String(right);
|
||||
}
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, any> {
|
||||
return value !== null && typeof value === 'object' && !Array.isArray(value);
|
||||
}
|
||||
|
||||
function readyMatch(riotMatchId = 'KR_MIGRATION_1'): AnyDoc {
|
||||
const matchId = objectId();
|
||||
const codeId = objectId();
|
||||
return {
|
||||
_id: matchId,
|
||||
communityId: objectId(),
|
||||
gameMode: 'pair',
|
||||
gameCount: 1,
|
||||
status: 'in-progress',
|
||||
participants: [],
|
||||
teams: [legacyTeam(1), legacyTeam(2)],
|
||||
gameSchedule: [{ gameNumber: 1, teamAIndex: 1, teamBIndex: 2 }],
|
||||
tournamentCodeIds: [codeId],
|
||||
result: {
|
||||
riotMatchIds: [riotMatchId],
|
||||
games: [
|
||||
{
|
||||
gameNumber: 1,
|
||||
riotMatchId,
|
||||
blueTeamIndex: 1,
|
||||
redTeamIndex: 2,
|
||||
winnerTeamIndex: 1,
|
||||
winnerSide: 'blue',
|
||||
gameCreation: 1_782_864_000_000,
|
||||
gameDuration: 1800,
|
||||
participants: [],
|
||||
},
|
||||
],
|
||||
seriesResults: [],
|
||||
},
|
||||
createdAt: new Date('2026-07-01T00:00:00.000Z'),
|
||||
updatedAt: new Date('2026-07-02T00:00:00.000Z'),
|
||||
};
|
||||
}
|
||||
|
||||
function usedTournamentCode(
|
||||
match = readyMatch(),
|
||||
riotMatchId = 'KR_MIGRATION_1',
|
||||
): AnyDoc {
|
||||
return {
|
||||
_id: match.tournamentCodeIds[0],
|
||||
matchId: match._id,
|
||||
state: 'used',
|
||||
gameNumber: 1,
|
||||
riotMatchId,
|
||||
reservedAt: new Date('2026-07-01T00:30:00.000Z'),
|
||||
usedAt: new Date('2026-07-01T01:00:00.000Z'),
|
||||
};
|
||||
}
|
||||
|
||||
function riotArchive(matchId = 'KR_MIGRATION_1'): AnyDoc {
|
||||
return {
|
||||
_id: objectId(),
|
||||
matchId,
|
||||
raw: { metadata: { matchId } },
|
||||
};
|
||||
}
|
||||
|
||||
function ambiguousMatch(): AnyDoc {
|
||||
const match = readyMatch();
|
||||
match.teams = [legacyTeam(1), legacyTeam(2), legacyTeam(3), legacyTeam(4)];
|
||||
match.gameSchedule = [
|
||||
{ gameNumber: 7, teamAIndex: 1, teamBIndex: 2 },
|
||||
{ gameNumber: 7, teamAIndex: 3, teamBIndex: 4 },
|
||||
];
|
||||
match.tournamentCodeIds = [];
|
||||
match.result = {
|
||||
games: [
|
||||
{
|
||||
gameNumber: 7,
|
||||
riotMatchId: 'KR_AMBIGUOUS',
|
||||
blueTeamIndex: 1,
|
||||
redTeamIndex: 2,
|
||||
winnerTeamIndex: 1,
|
||||
winnerSide: 'blue',
|
||||
participants: [],
|
||||
},
|
||||
],
|
||||
seriesResults: [],
|
||||
};
|
||||
return match;
|
||||
}
|
||||
|
||||
function legacyTeam(teamIndex: number) {
|
||||
return {
|
||||
teamIndex,
|
||||
name: `${teamIndex}팀`,
|
||||
captainUserId: objectId(),
|
||||
members: [],
|
||||
};
|
||||
}
|
||||
|
||||
function objectId(): mongoose.Types.ObjectId {
|
||||
return new mongoose.Types.ObjectId();
|
||||
}
|
||||
|
||||
function canonical(value: unknown): string {
|
||||
return JSON.stringify(value, (_key, child) => {
|
||||
if (child instanceof mongoose.Types.ObjectId) return child.toHexString();
|
||||
if (child instanceof Date) return child.toISOString();
|
||||
return child;
|
||||
});
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,52 @@
|
||||
import { parseCliOptions } from './run-competition-domain';
|
||||
|
||||
describe('competition domain migration CLI', () => {
|
||||
const originalNodeEnv = process.env.NODE_ENV;
|
||||
|
||||
beforeEach(() => {
|
||||
process.env.NODE_ENV = 'dev';
|
||||
});
|
||||
|
||||
afterAll(() => {
|
||||
process.env.NODE_ENV = originalNodeEnv;
|
||||
});
|
||||
|
||||
it('ignores pnpm standalone separators before dry-run and apply options', () => {
|
||||
expect(parseCliOptions(['--', '--dry-run'])).toMatchObject({
|
||||
dryRun: true,
|
||||
help: false,
|
||||
nodeEnv: 'dev',
|
||||
});
|
||||
expect(parseCliOptions(['--', '--apply'])).toMatchObject({
|
||||
dryRun: false,
|
||||
help: false,
|
||||
nodeEnv: 'dev',
|
||||
});
|
||||
});
|
||||
|
||||
it('recognizes help after a pnpm standalone separator without exiting', () => {
|
||||
expect(parseCliOptions(['--', '--help'])).toMatchObject({
|
||||
dryRun: true,
|
||||
help: true,
|
||||
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.',
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,222 @@
|
||||
import 'reflect-metadata';
|
||||
import { Module } from '@nestjs/common';
|
||||
import { ConfigModule } from '@nestjs/config';
|
||||
import { NestFactory } from '@nestjs/core';
|
||||
import { readFile } from 'node:fs/promises';
|
||||
import { resolve } from 'node:path';
|
||||
import { ConnectionService, resolveMongoDbName } from '../connection.service';
|
||||
import { SecretModule } from '../../secret/secret.module';
|
||||
import {
|
||||
migrateCompetitionDomain,
|
||||
type CompetitionDomainMigrationDb,
|
||||
} from './competition-domain-runner';
|
||||
|
||||
export interface CompetitionDomainCliOptions {
|
||||
dryRun: boolean;
|
||||
help: boolean;
|
||||
limit?: number;
|
||||
afterMatchId?: string;
|
||||
nodeEnv: string;
|
||||
}
|
||||
|
||||
@Module({
|
||||
imports: [
|
||||
ConfigModule.forRoot({
|
||||
isGlobal: true,
|
||||
envFilePath: [
|
||||
resolve(__dirname, '../../../../../../project.env'),
|
||||
resolve(process.cwd(), '../project.env'),
|
||||
resolve(process.cwd(), 'apps/project.env'),
|
||||
resolve(process.cwd(), 'project.env'),
|
||||
],
|
||||
}),
|
||||
SecretModule,
|
||||
],
|
||||
providers: [ConnectionService],
|
||||
})
|
||||
class MigrationModule {}
|
||||
|
||||
async function loadMachineEnvFile(): Promise<void> {
|
||||
const homeDir = process.env.HOME ?? process.env.USERPROFILE;
|
||||
if (!homeDir) return;
|
||||
try {
|
||||
const file = await readFile(
|
||||
resolve(homeDir, 'source/global-env-vars.txt'),
|
||||
'utf8',
|
||||
);
|
||||
for (const rawLine of file.split(/\r?\n/)) {
|
||||
const line = rawLine.trim();
|
||||
if (!line || line.startsWith('#')) continue;
|
||||
const matched = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
|
||||
if (!matched) continue;
|
||||
const [, key, rawValue] = matched;
|
||||
process.env[key] = rawValue.replace(/^["']|["']$/g, '');
|
||||
}
|
||||
} catch {
|
||||
// A local machine env file is optional for one-off migrations.
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
const argument = argv[index];
|
||||
// pnpm preserves the conventional option separator when it forwards
|
||||
// script arguments (`pnpm ... -- --apply`). It is not a CLI option.
|
||||
if (argument === '--') continue;
|
||||
if (argument === '--apply') {
|
||||
dryRun = false;
|
||||
continue;
|
||||
}
|
||||
if (argument === '--dry-run') {
|
||||
dryRun = true;
|
||||
continue;
|
||||
}
|
||||
if (argument === '--env') {
|
||||
const value = argv[index + 1];
|
||||
if (!value) throw new Error('--env requires dev, staging, or prod.');
|
||||
nodeEnv = value;
|
||||
index += 1;
|
||||
continue;
|
||||
}
|
||||
if (argument.startsWith('--env=')) {
|
||||
nodeEnv = argument.slice('--env='.length);
|
||||
continue;
|
||||
}
|
||||
if (argument === '--limit') {
|
||||
limit = positiveInteger(argv[index + 1], '--limit');
|
||||
index += 1;
|
||||
continue;
|
||||
}
|
||||
if (argument.startsWith('--limit=')) {
|
||||
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;
|
||||
}
|
||||
throw new Error(`Unknown argument: ${argument}`);
|
||||
}
|
||||
|
||||
if (!['dev', 'staging', 'prod'].includes(nodeEnv)) {
|
||||
throw new Error('--env must be dev, staging, or prod.');
|
||||
}
|
||||
return { dryRun, help, limit, afterMatchId, nodeEnv };
|
||||
}
|
||||
|
||||
function positiveInteger(value: string | undefined, label: string): number {
|
||||
const parsed = Number(value);
|
||||
if (!Number.isInteger(parsed) || parsed < 1) {
|
||||
throw new Error(`${label} requires a positive integer.`);
|
||||
}
|
||||
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
|
||||
pnpm --silent --filter api competition:migrate -- --env staging --apply
|
||||
|
||||
Options:
|
||||
--dry-run Plan and report without writes. Default.
|
||||
--apply Apply one transaction per Match.
|
||||
--env <env> dev | staging | prod. Default: NODE_ENV or dev.
|
||||
--limit <n> Scan at most n Matches. Apply resumes from a durable checkpoint.
|
||||
--after <id> Override the checkpoint with a Match ObjectId cursor.
|
||||
|
||||
The JSON report is written to stdout; the concise human summary is written to stderr.
|
||||
`);
|
||||
}
|
||||
|
||||
async function main(): Promise<void> {
|
||||
const options = parseCliOptions(process.argv.slice(2));
|
||||
if (options.help) {
|
||||
printHelp();
|
||||
return;
|
||||
}
|
||||
await loadMachineEnvFile();
|
||||
process.env.NODE_ENV = options.nodeEnv;
|
||||
|
||||
const app = await NestFactory.createApplicationContext(MigrationModule, {
|
||||
logger: false,
|
||||
});
|
||||
try {
|
||||
const connectionService = app.get(ConnectionService);
|
||||
const connection = await connectionService.getConnection();
|
||||
if (!connection.db) throw new Error('MongoDB connection has no db handle.');
|
||||
|
||||
const result = await migrateCompetitionDomain(
|
||||
connection.db as unknown as CompetitionDomainMigrationDb,
|
||||
{
|
||||
dryRun: options.dryRun,
|
||||
limit: options.limit,
|
||||
afterMatchId: options.afterMatchId,
|
||||
startSession: options.dryRun
|
||||
? undefined
|
||||
: async () => connection.startSession(),
|
||||
},
|
||||
);
|
||||
const { summary } = result;
|
||||
process.stderr.write(
|
||||
`[competition-domain migration] mode=${result.mode} env=${options.nodeEnv} ` +
|
||||
`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} ` +
|
||||
`indexPreflight=${result.indexPreflight.status} ` +
|
||||
`resume=${result.resume.checkpointAfterMatchId ?? 'none'} ` +
|
||||
`completed=${result.resume.completed}\n`,
|
||||
);
|
||||
process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
|
||||
|
||||
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) => {
|
||||
const message = error instanceof Error ? error.message : String(error);
|
||||
process.stderr.write(
|
||||
`[competition-domain migration] context close warning: ${message}\n`,
|
||||
);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if (require.main === module) {
|
||||
void main().catch((error: unknown) => {
|
||||
const message = error instanceof Error ? error.message : String(error);
|
||||
process.stderr.write(`[competition-domain migration] failed: ${message}\n`);
|
||||
process.stdout.write(
|
||||
`${JSON.stringify({
|
||||
migrationRunId: '20260712-competition-domain',
|
||||
mode: process.argv.includes('--apply') ? 'apply' : 'dry-run',
|
||||
error: message,
|
||||
})}\n`,
|
||||
);
|
||||
process.exitCode = 1;
|
||||
});
|
||||
}
|
||||
@@ -3,6 +3,14 @@ import type {
|
||||
RiotPlatformRoute,
|
||||
RiotRegionalRoute,
|
||||
} from '../../riot/riot.types';
|
||||
import {
|
||||
Competition,
|
||||
CompetitionFact,
|
||||
CompetitionOutbox,
|
||||
TournamentCodeAssignment,
|
||||
applyCompetitionDomainInvariantIndexes,
|
||||
competitionModelDefinitions,
|
||||
} from '../../competition/competition.schema';
|
||||
import { ModelDefinition } from './types';
|
||||
|
||||
export type Position = 'TOP' | 'JGL' | 'MID' | 'ADC' | 'SUP';
|
||||
@@ -458,6 +466,7 @@ export interface TournamentCode extends MongooseTimestamps {
|
||||
reservedAt?: Date;
|
||||
usedAt?: Date;
|
||||
releasedAt?: Date;
|
||||
voidedAt?: Date;
|
||||
riotMatchId?: string;
|
||||
uploadedBy: mongoose.Types.ObjectId;
|
||||
uploadedAt: Date;
|
||||
@@ -672,6 +681,7 @@ export interface MatchScheduleItem {
|
||||
|
||||
export interface Match extends MongooseTimestamps {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
competitionId?: mongoose.Types.ObjectId;
|
||||
shortCode?: string;
|
||||
title: string;
|
||||
description: string;
|
||||
@@ -1021,6 +1031,9 @@ export interface MatchStatsTimelinePoint {
|
||||
|
||||
export interface MatchStats extends MongooseTimestamps {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
sourceCompetitionId?: mongoose.Types.ObjectId;
|
||||
sourceRevision?: number;
|
||||
projectorVersion?: number;
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
scheduledAt: Date;
|
||||
gameCreationMin: number;
|
||||
@@ -1490,6 +1503,7 @@ export const TournamentCodeSchema = new Schema<TournamentCode>(
|
||||
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 },
|
||||
@@ -1845,6 +1859,11 @@ export const MatchSchema = new Schema<Match>(
|
||||
ref: 'community',
|
||||
required: true,
|
||||
},
|
||||
competitionId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
ref: 'competition',
|
||||
required: false,
|
||||
},
|
||||
shortCode: {
|
||||
type: String,
|
||||
required: false,
|
||||
@@ -1936,6 +1955,7 @@ export const MatchSchema = new Schema<Match>(
|
||||
);
|
||||
|
||||
MatchSchema.index({ communityId: 1, scheduledAt: -1 });
|
||||
applyCompetitionDomainInvariantIndexes(MatchSchema, 'match');
|
||||
MatchSchema.index({ communityId: 1, status: 1, scheduledAt: -1 });
|
||||
MatchSchema.index(
|
||||
{ communityId: 1, shortCode: 1 },
|
||||
@@ -2389,6 +2409,13 @@ export const MatchStatsSchema: mongoose.Schema<MatchStats> = new Schema(
|
||||
required: true,
|
||||
unique: true,
|
||||
},
|
||||
sourceCompetitionId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
ref: 'competition',
|
||||
required: false,
|
||||
},
|
||||
sourceRevision: { type: Number, required: false, min: 0 },
|
||||
projectorVersion: { type: Number, required: false, min: 1 },
|
||||
communityId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
ref: 'community',
|
||||
@@ -2419,6 +2446,7 @@ MatchStatsSchema.index({ communityId: 1, userIds: 1, scheduledAt: -1 });
|
||||
MatchStatsSchema.index({ communityId: 1, championIds: 1 });
|
||||
|
||||
export const tournamentModelDefinitions: ModelDefinition[] = [
|
||||
...competitionModelDefinitions,
|
||||
{ name: 'identity', schema: IdentitySchema, schemaName: 'identity' },
|
||||
{ name: 'community', schema: CommunitySchema, schemaName: 'community' },
|
||||
{
|
||||
@@ -2468,6 +2496,10 @@ export const tournamentModelDefinitions: ModelDefinition[] = [
|
||||
];
|
||||
|
||||
export interface TournamentModelTypes {
|
||||
competition: Competition;
|
||||
competitionFact: CompetitionFact;
|
||||
competitionOutbox: CompetitionOutbox;
|
||||
tournamentCodeAssignment: TournamentCodeAssignment;
|
||||
identity: Identity;
|
||||
community: Community;
|
||||
dakaoInboundMessage: DakaoInboundMessage;
|
||||
|
||||
@@ -0,0 +1,985 @@
|
||||
/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/require-await, @typescript-eslint/unbound-method */
|
||||
import { readFileSync } from 'node:fs';
|
||||
import mongoose from 'mongoose';
|
||||
import type { CompetitionBootstrapService } from '../competition/competition-bootstrap.service';
|
||||
import type { CompetitionCommandService } from '../competition/competition-command.service';
|
||||
import type { MatchStatsService } from '../community-stats/match-stats.service';
|
||||
import type { CommunityStatsService } from '../community-stats/community-stats.service';
|
||||
import type { ConnectionService } from '../global/database/connection.service';
|
||||
import type { DistributedLockService } from '../global/redis/distributed-lock.service';
|
||||
import type { RedisService } from '../global/redis/redis.service';
|
||||
import type { RiotMatchService } from '../riot/riot-match.service';
|
||||
import type { RiotMatchDto } from '../riot/riot.types';
|
||||
import { LegacyImportService } from './legacy-import.service';
|
||||
import type { LegacyUserSnapshot, UserByPuuidMap } from './match-builder.util';
|
||||
import type { LegacyImportMemberJob } from './legacy-import.types';
|
||||
|
||||
const ServiceConstructor = LegacyImportService as unknown as new (
|
||||
...dependencies: unknown[]
|
||||
) => LegacyImportService;
|
||||
|
||||
describe('Legacy import Competition result cutover', () => {
|
||||
it('has no production Match.result writer', () => {
|
||||
const source = readFileSync(
|
||||
require.resolve('./legacy-import.service'),
|
||||
'utf8',
|
||||
);
|
||||
|
||||
expect(source).not.toMatch(/\b(?:match|update)\.result\s*=/u);
|
||||
expect(source).not.toMatch(/\bresult\s*:\s*\{\s*winnerTeamIndex/u);
|
||||
});
|
||||
|
||||
it('creates a paired Competition and accepts Riot evidence without writing Match.result', async () => {
|
||||
const fixture = createImportFixture();
|
||||
const competitionFactModel = {
|
||||
exists: jest.fn().mockResolvedValue(null),
|
||||
};
|
||||
const matchModel = {
|
||||
findOneAndUpdate: jest.fn().mockReturnValue(execResult(fixture.match)),
|
||||
updateOne: jest.fn().mockReturnValue(execResult({ modifiedCount: 1 })),
|
||||
};
|
||||
const connectionService = {
|
||||
getModel: jest.fn(async (name: string) => {
|
||||
if (name === 'competitionFact') return competitionFactModel;
|
||||
if (name === 'match') return matchModel;
|
||||
throw new Error(`Unexpected model ${name}`);
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const bootstrapService = {
|
||||
bootstrap: jest.fn().mockResolvedValue(fixture.competition),
|
||||
} as unknown as jest.Mocked<CompetitionBootstrapService>;
|
||||
const commandService = {
|
||||
acceptGame: jest.fn().mockResolvedValue({
|
||||
competition: {
|
||||
...fixture.competition,
|
||||
revision: 1,
|
||||
phase: 'completed',
|
||||
},
|
||||
commandId: 'command-1',
|
||||
revision: 1,
|
||||
replayed: false,
|
||||
}),
|
||||
} as unknown as jest.Mocked<CompetitionCommandService>;
|
||||
const matchStatsService = {
|
||||
buildAndUpsert: jest.fn().mockResolvedValue(undefined),
|
||||
} as unknown as jest.Mocked<MatchStatsService>;
|
||||
const service = createService({
|
||||
connectionService,
|
||||
matchStatsService,
|
||||
bootstrapService,
|
||||
commandService,
|
||||
runWithLock: async (_options, operation) => operation(),
|
||||
});
|
||||
jest
|
||||
.spyOn(
|
||||
service as unknown as {
|
||||
ensureRiotMatchPersisted: (
|
||||
riotMatchId: string,
|
||||
region: string,
|
||||
) => Promise<RiotMatchDto>;
|
||||
},
|
||||
'ensureRiotMatchPersisted',
|
||||
)
|
||||
.mockResolvedValue(fixture.detail);
|
||||
|
||||
const outcome = await importSingleMatch(
|
||||
service,
|
||||
fixture.detail.metadata.matchId,
|
||||
fixture.job,
|
||||
fixture.userByPuuid,
|
||||
);
|
||||
|
||||
expect(outcome).toBe('imported');
|
||||
expect(matchModel.findOneAndUpdate).toHaveBeenCalledWith(
|
||||
{ _id: expect.any(mongoose.Types.ObjectId) },
|
||||
{
|
||||
$setOnInsert: expect.not.objectContaining({
|
||||
result: expect.anything(),
|
||||
doubleElimination: expect.anything(),
|
||||
}),
|
||||
},
|
||||
expect.objectContaining({ upsert: true, returnDocument: 'after' }),
|
||||
);
|
||||
expect(bootstrapService.bootstrap).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
gameMode: 'pair',
|
||||
gameCount: 1,
|
||||
teams: expect.arrayContaining([
|
||||
expect.objectContaining({ teamIndex: 1 }),
|
||||
expect.objectContaining({ teamIndex: 2 }),
|
||||
]),
|
||||
}),
|
||||
);
|
||||
expect(commandService.acceptGame).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
competitionId: fixture.competition._id.toString(),
|
||||
expectedRevision: 0,
|
||||
evidence: expect.objectContaining({
|
||||
type: 'riot',
|
||||
riotMatchId: fixture.detail.metadata.matchId,
|
||||
payloadHash: expect.stringMatching(/^[a-f0-9]{64}$/u),
|
||||
}),
|
||||
mapping: expect.objectContaining({
|
||||
blueTeamId: fixture.blueTeamId.toString(),
|
||||
redTeamId: fixture.redTeamId.toString(),
|
||||
winnerTeamId: fixture.blueTeamId.toString(),
|
||||
algorithmVersion: 'roster-overlap-v1',
|
||||
mappingVersion: 1,
|
||||
confidence: 1,
|
||||
diagnostics: {
|
||||
trustedOverlap: 10,
|
||||
normalOverlap: 10,
|
||||
reversedOverlap: 0,
|
||||
},
|
||||
participantAssignments: expect.any(Array),
|
||||
snapshot: expect.any(Object),
|
||||
}),
|
||||
}),
|
||||
);
|
||||
expect(matchModel.updateOne).toHaveBeenCalledWith(
|
||||
{ _id: fixture.match._id },
|
||||
{ $set: { status: 'finished' } },
|
||||
);
|
||||
expect(matchStatsService.buildAndUpsert).toHaveBeenCalledWith(
|
||||
fixture.match._id,
|
||||
{ sourceRevision: 1 },
|
||||
);
|
||||
});
|
||||
|
||||
it('detects duplicates from accepted Competition fact evidence before fetching Riot data', async () => {
|
||||
const fixture = createImportFixture();
|
||||
const competitionFactModel = {
|
||||
exists: jest
|
||||
.fn()
|
||||
.mockResolvedValue({ _id: new mongoose.Types.ObjectId() }),
|
||||
};
|
||||
const connectionService = {
|
||||
getModel: jest.fn(async (name: string) => {
|
||||
if (name === 'competitionFact') return competitionFactModel;
|
||||
throw new Error(`Unexpected model ${name}`);
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const service = createService({
|
||||
connectionService,
|
||||
runWithLock: async (_options, operation) => operation(),
|
||||
});
|
||||
const ensureRiotMatchPersisted = jest
|
||||
.spyOn(
|
||||
service as unknown as {
|
||||
ensureRiotMatchPersisted: () => Promise<RiotMatchDto>;
|
||||
},
|
||||
'ensureRiotMatchPersisted',
|
||||
)
|
||||
.mockResolvedValue(fixture.detail);
|
||||
|
||||
const outcome = await importSingleMatch(
|
||||
service,
|
||||
fixture.detail.metadata.matchId,
|
||||
fixture.job,
|
||||
fixture.userByPuuid,
|
||||
);
|
||||
|
||||
expect(outcome).toBe('duplicate');
|
||||
expect(competitionFactModel.exists).toHaveBeenCalledWith({
|
||||
type: 'game-accepted',
|
||||
'evidence.type': 'riot',
|
||||
'evidence.riotMatchId': fixture.detail.metadata.matchId,
|
||||
});
|
||||
expect(ensureRiotMatchPersisted).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('lists new legacy imports from Competition projection when Match.result is absent', async () => {
|
||||
const fixture = createImportFixture();
|
||||
const canonicalCompetition = {
|
||||
...fixture.competition,
|
||||
revision: 1,
|
||||
phase: 'completed',
|
||||
projection: {
|
||||
phase: 'completed',
|
||||
series: [
|
||||
{
|
||||
...fixture.competition.projection.series[0],
|
||||
status: 'completed',
|
||||
entries: [
|
||||
{
|
||||
slot: 'A',
|
||||
teamId: fixture.blueTeamId,
|
||||
gameWins: 1,
|
||||
},
|
||||
{ slot: 'B', teamId: fixture.redTeamId, gameWins: 0 },
|
||||
],
|
||||
outcome: {
|
||||
type: 'played',
|
||||
winnerTeamId: fixture.blueTeamId,
|
||||
loserTeamId: fixture.redTeamId,
|
||||
},
|
||||
},
|
||||
],
|
||||
gameSlots: [],
|
||||
games: [
|
||||
{
|
||||
seriesId: fixture.competition.projection.series[0].seriesId,
|
||||
winnerTeamId: fixture.blueTeamId,
|
||||
evidence: {
|
||||
type: 'riot',
|
||||
riotMatchId: fixture.detail.metadata.matchId,
|
||||
},
|
||||
participants: fixture.match.participants.map(({ userId }) => ({
|
||||
userId,
|
||||
})),
|
||||
},
|
||||
],
|
||||
},
|
||||
};
|
||||
const matchModel = {
|
||||
find: jest.fn().mockReturnValue({
|
||||
sort: jest.fn().mockReturnValue({
|
||||
limit: jest.fn().mockReturnValue(execResult([fixture.match])),
|
||||
}),
|
||||
}),
|
||||
};
|
||||
const competitionModel = {
|
||||
find: jest.fn().mockReturnValue({
|
||||
lean: jest.fn().mockReturnValue(execResult([canonicalCompetition])),
|
||||
}),
|
||||
};
|
||||
const riotMatchModel = {
|
||||
find: jest.fn().mockReturnValue({
|
||||
lean: jest.fn().mockReturnValue(
|
||||
execResult([
|
||||
{
|
||||
matchId: fixture.detail.metadata.matchId,
|
||||
raw: fixture.detail,
|
||||
},
|
||||
]),
|
||||
),
|
||||
}),
|
||||
};
|
||||
const connectionService = {
|
||||
getModel: jest.fn((name: string) => {
|
||||
if (name === 'match') return Promise.resolve(matchModel);
|
||||
if (name === 'competition') return Promise.resolve(competitionModel);
|
||||
if (name === 'riotMatch') return Promise.resolve(riotMatchModel);
|
||||
return Promise.reject(new Error(`Unexpected model ${name}`));
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const service = createService({ connectionService });
|
||||
jest
|
||||
.spyOn(
|
||||
service as unknown as {
|
||||
buildUserByPuuidMap: () => Promise<UserByPuuidMap>;
|
||||
},
|
||||
'buildUserByPuuidMap',
|
||||
)
|
||||
.mockResolvedValue(fixture.userByPuuid);
|
||||
|
||||
const page = await service.listLegacyMatches({
|
||||
communityId: fixture.match.communityId,
|
||||
});
|
||||
|
||||
expect(page.matches).toEqual([
|
||||
expect.objectContaining({
|
||||
matchId: fixture.match._id.toString(),
|
||||
riotMatchId: fixture.detail.metadata.matchId,
|
||||
memberCount: 10,
|
||||
externalCount: 0,
|
||||
teamAIndex: 1,
|
||||
teamBIndex: 2,
|
||||
teamAWins: 1,
|
||||
teamBWins: 0,
|
||||
winnerTeamIndex: 1,
|
||||
}),
|
||||
]);
|
||||
});
|
||||
|
||||
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 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({
|
||||
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: 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<string, unknown> = {
|
||||
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(undefined),
|
||||
} as unknown as jest.Mocked<CommunityStatsService>;
|
||||
const service = createService({
|
||||
connectionService,
|
||||
communityStatsService,
|
||||
});
|
||||
|
||||
const result = await service.bulkDeleteLegacyMatches({
|
||||
communityId: fixture.match.communityId,
|
||||
body: { matchIds: [fixture.match._id.toString()] },
|
||||
});
|
||||
|
||||
expect(result).toEqual({ deleted: 1 });
|
||||
for (const model of [
|
||||
competitionFactModel,
|
||||
competitionOutboxModel,
|
||||
assignmentModel,
|
||||
]) {
|
||||
expect(model.deleteMany).toHaveBeenCalledWith({
|
||||
competitionId: { $in: [fixture.competition._id] },
|
||||
});
|
||||
}
|
||||
expect(competitionModel.deleteMany).toHaveBeenCalledWith({
|
||||
_id: { $in: [fixture.competition._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 () => {
|
||||
const fixture = createImportFixture();
|
||||
const historicalMatch = {
|
||||
...fixture.match,
|
||||
legacyImported: true,
|
||||
result: {
|
||||
riotMatchIds: [fixture.detail.metadata.matchId],
|
||||
games: [
|
||||
{
|
||||
riotMatchId: fixture.detail.metadata.matchId,
|
||||
participants: [],
|
||||
},
|
||||
],
|
||||
seriesResults: [],
|
||||
},
|
||||
};
|
||||
const matchModel = {
|
||||
find: jest.fn().mockReturnValue(execResult([historicalMatch])),
|
||||
updateOne: jest.fn().mockReturnValue(execResult({ modifiedCount: 1 })),
|
||||
};
|
||||
const competitionModel = {
|
||||
find: jest.fn().mockReturnValue({
|
||||
lean: jest.fn().mockReturnValue(execResult([])),
|
||||
}),
|
||||
};
|
||||
const riotMatchModel = {
|
||||
find: jest.fn().mockReturnValue({
|
||||
lean: jest.fn().mockReturnValue(
|
||||
execResult([
|
||||
{
|
||||
matchId: fixture.detail.metadata.matchId,
|
||||
raw: fixture.detail,
|
||||
},
|
||||
]),
|
||||
),
|
||||
}),
|
||||
};
|
||||
const connectionService = {
|
||||
getModel: jest.fn(async (name: string) => {
|
||||
if (name === 'match') return matchModel;
|
||||
if (name === 'competition') return competitionModel;
|
||||
if (name === 'riotMatch') return riotMatchModel;
|
||||
throw new Error(`Unexpected model ${name}`);
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const bootstrapService = {
|
||||
bootstrap: jest.fn().mockResolvedValue(fixture.competition),
|
||||
} as unknown as jest.Mocked<CompetitionBootstrapService>;
|
||||
const commandService = {
|
||||
acceptGame: jest.fn().mockResolvedValue({
|
||||
competition: {
|
||||
...fixture.competition,
|
||||
revision: 1,
|
||||
phase: 'completed',
|
||||
},
|
||||
commandId: 'command-1',
|
||||
revision: 1,
|
||||
replayed: false,
|
||||
}),
|
||||
} as unknown as jest.Mocked<CompetitionCommandService>;
|
||||
const matchStatsService = {
|
||||
buildAndUpsert: jest.fn().mockResolvedValue(undefined),
|
||||
} as unknown as jest.Mocked<MatchStatsService>;
|
||||
const service = createService({
|
||||
connectionService,
|
||||
matchStatsService,
|
||||
bootstrapService,
|
||||
commandService,
|
||||
});
|
||||
jest
|
||||
.spyOn(
|
||||
service as unknown as {
|
||||
buildUserByPuuidMap: () => Promise<UserByPuuidMap>;
|
||||
},
|
||||
'buildUserByPuuidMap',
|
||||
)
|
||||
.mockResolvedValue(fixture.userByPuuid);
|
||||
|
||||
const result = await service.rebuildLegacyMatches({
|
||||
communityId: fixture.match.communityId,
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({ scanned: 1, rebuilt: 1 });
|
||||
for (const [, update] of matchModel.updateOne.mock.calls) {
|
||||
expect(update).toEqual(
|
||||
expect.objectContaining({
|
||||
$set: expect.not.objectContaining({ result: expect.anything() }),
|
||||
}),
|
||||
);
|
||||
}
|
||||
expect(bootstrapService.bootstrap).toHaveBeenCalledTimes(1);
|
||||
expect(commandService.acceptGame).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
actor: { type: 'system' },
|
||||
evidence: expect.objectContaining({
|
||||
type: 'riot',
|
||||
riotMatchId: fixture.detail.metadata.matchId,
|
||||
}),
|
||||
}),
|
||||
);
|
||||
expect(matchStatsService.buildAndUpsert).toHaveBeenCalledWith(
|
||||
fixture.match._id,
|
||||
{ sourceRevision: 1 },
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
function createService(
|
||||
options: {
|
||||
connectionService?: ConnectionService;
|
||||
communityStatsService?: CommunityStatsService;
|
||||
matchStatsService?: MatchStatsService;
|
||||
bootstrapService?: CompetitionBootstrapService;
|
||||
commandService?: CompetitionCommandService;
|
||||
runWithLock?: (
|
||||
options: Record<string, unknown>,
|
||||
operation: () => Promise<unknown>,
|
||||
) => Promise<unknown>;
|
||||
} = {},
|
||||
): LegacyImportService {
|
||||
const distributedLockService = {
|
||||
runWithLock:
|
||||
options.runWithLock ??
|
||||
(async (
|
||||
_options: Record<string, unknown>,
|
||||
operation: () => Promise<unknown>,
|
||||
) => operation()),
|
||||
} as unknown as DistributedLockService;
|
||||
return new ServiceConstructor(
|
||||
options.connectionService ?? ({} as ConnectionService),
|
||||
{} as RedisService,
|
||||
{} as RiotMatchService,
|
||||
options.communityStatsService ??
|
||||
({
|
||||
invalidateCommunity: jest.fn().mockResolvedValue(undefined),
|
||||
} as unknown as CommunityStatsService),
|
||||
options.matchStatsService ?? ({} as MatchStatsService),
|
||||
distributedLockService,
|
||||
options.bootstrapService ?? ({} as CompetitionBootstrapService),
|
||||
options.commandService ?? ({} as CompetitionCommandService),
|
||||
);
|
||||
}
|
||||
|
||||
async function importSingleMatch(
|
||||
service: LegacyImportService,
|
||||
riotMatchId: string,
|
||||
job: LegacyImportMemberJob,
|
||||
userByPuuid: UserByPuuidMap,
|
||||
): Promise<string> {
|
||||
return (
|
||||
service as unknown as {
|
||||
importSingleMatch: (
|
||||
riotMatchId: string,
|
||||
job: LegacyImportMemberJob,
|
||||
userByPuuid: UserByPuuidMap,
|
||||
) => Promise<string>;
|
||||
}
|
||||
).importSingleMatch(riotMatchId, job, userByPuuid);
|
||||
}
|
||||
|
||||
function createImportFixture() {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const triggeredBy = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const competitionId = new mongoose.Types.ObjectId();
|
||||
const seriesId = new mongoose.Types.ObjectId();
|
||||
const gameSlotId = new mongoose.Types.ObjectId();
|
||||
const blueTeamId = new mongoose.Types.ObjectId();
|
||||
const redTeamId = new mongoose.Types.ObjectId();
|
||||
const users = Array.from({ length: 10 }, (_, index) => ({
|
||||
userId: new mongoose.Types.ObjectId(),
|
||||
puuid: `puuid-${index + 1}`,
|
||||
}));
|
||||
const userByPuuid: UserByPuuidMap = new Map(
|
||||
users.map(({ userId, puuid }, index) => [
|
||||
puuid,
|
||||
{
|
||||
userId,
|
||||
account: {
|
||||
puuid,
|
||||
gameName: `player-${index + 1}`,
|
||||
tagLine: 'KR1',
|
||||
profileIconId: index + 1,
|
||||
tiers: [],
|
||||
isPrimary: true,
|
||||
},
|
||||
displayName: `player-${index + 1}`,
|
||||
preferredPositions: [],
|
||||
} as LegacyUserSnapshot,
|
||||
]),
|
||||
);
|
||||
const participants = users.map(({ puuid }, index) => ({
|
||||
puuid,
|
||||
participantId: index + 1,
|
||||
teamId: index < 5 ? 100 : 200,
|
||||
championId: index + 1,
|
||||
teamPosition: ['TOP', 'JUNGLE', 'MIDDLE', 'BOTTOM', 'UTILITY'][index % 5],
|
||||
kills: index < 5 ? 10 : 2,
|
||||
deaths: index < 5 ? 2 : 10,
|
||||
assists: index < 5 ? 8 : 3,
|
||||
win: index < 5,
|
||||
}));
|
||||
const detail = {
|
||||
metadata: {
|
||||
dataVersion: '2',
|
||||
matchId: 'KR_legacy_1',
|
||||
participants: users.map(({ puuid }) => puuid),
|
||||
},
|
||||
info: {
|
||||
gameCreation: Date.parse('2026-07-12T10:00:00.000Z'),
|
||||
gameEndTimestamp: Date.parse('2026-07-12T10:30:00.000Z'),
|
||||
gameDuration: 1_800,
|
||||
mapId: 11,
|
||||
tournamentCode: 'LEGACY-CODE',
|
||||
participants,
|
||||
teams: [
|
||||
{ teamId: 100, win: true },
|
||||
{ teamId: 200, win: false },
|
||||
],
|
||||
},
|
||||
} as unknown as RiotMatchDto;
|
||||
const match = {
|
||||
_id: matchId,
|
||||
communityId,
|
||||
title: 'legacy',
|
||||
description: 'Legacy import (자동 생성)',
|
||||
mapId: 11,
|
||||
status: 'team-built',
|
||||
scheduledAt: new Date(detail.info.gameCreation),
|
||||
maxParticipants: 10,
|
||||
gameCount: 1,
|
||||
gameMode: 'pair',
|
||||
tournamentCodeIds: [],
|
||||
gameSchedule: [],
|
||||
teamBuiltAt: new Date(detail.info.gameCreation),
|
||||
hostUserId: triggeredBy,
|
||||
participants: users.map(({ userId, puuid }, index) => ({
|
||||
userId,
|
||||
puuid,
|
||||
gameName: `player-${index + 1}`,
|
||||
tagLine: 'KR1',
|
||||
profileIconId: index + 1,
|
||||
preferredPositions: [],
|
||||
joinedAt: new Date(detail.info.gameCreation),
|
||||
})),
|
||||
teams: [
|
||||
{
|
||||
teamIndex: 1,
|
||||
name: '1팀',
|
||||
members: users.slice(0, 5).map(({ userId }, index) => ({
|
||||
userId,
|
||||
assignedPosition: ['TOP', 'JGL', 'MID', 'ADC', 'SUP'][index],
|
||||
})),
|
||||
},
|
||||
{
|
||||
teamIndex: 2,
|
||||
name: '2팀',
|
||||
members: users.slice(5).map(({ userId }, index) => ({
|
||||
userId,
|
||||
assignedPosition: ['TOP', 'JGL', 'MID', 'ADC', 'SUP'][index],
|
||||
})),
|
||||
},
|
||||
],
|
||||
prizes: [],
|
||||
notices: [],
|
||||
schedule: [],
|
||||
};
|
||||
const competition = {
|
||||
_id: competitionId,
|
||||
matchId,
|
||||
communityId,
|
||||
revision: 0,
|
||||
phase: 'ready',
|
||||
teams: [
|
||||
{
|
||||
teamId: blueTeamId,
|
||||
legacyTeamIndex: 1,
|
||||
displayOrder: 1,
|
||||
seedNumber: 1,
|
||||
name: '1팀',
|
||||
members: users.slice(0, 5).map(({ userId }) => ({ userId })),
|
||||
},
|
||||
{
|
||||
teamId: redTeamId,
|
||||
legacyTeamIndex: 2,
|
||||
displayOrder: 2,
|
||||
seedNumber: 2,
|
||||
name: '2팀',
|
||||
members: users.slice(5).map(({ userId }) => ({ userId })),
|
||||
},
|
||||
],
|
||||
projection: {
|
||||
phase: 'ready',
|
||||
series: [
|
||||
{
|
||||
seriesId,
|
||||
status: 'ready',
|
||||
entries: [
|
||||
{ slot: 'A', teamId: blueTeamId, gameWins: 0 },
|
||||
{ slot: 'B', teamId: redTeamId, gameWins: 0 },
|
||||
],
|
||||
},
|
||||
],
|
||||
gameSlots: [
|
||||
{
|
||||
id: gameSlotId,
|
||||
seriesId,
|
||||
ordinal: 1,
|
||||
displayNumber: 1,
|
||||
status: 'ready',
|
||||
},
|
||||
],
|
||||
games: [],
|
||||
},
|
||||
};
|
||||
const job: LegacyImportMemberJob = {
|
||||
kind: 'legacy-import-member',
|
||||
jobId: 'member-job-1',
|
||||
parentJobId: 'legacy-job-1',
|
||||
communityId: communityId.toString(),
|
||||
userId: users[0].userId.toString(),
|
||||
puuid: users[0].puuid,
|
||||
startTime: 1,
|
||||
endTime: 2,
|
||||
triggeredBy: triggeredBy.toString(),
|
||||
region: 'asia',
|
||||
};
|
||||
return {
|
||||
detail,
|
||||
match,
|
||||
competition,
|
||||
blueTeamId,
|
||||
redTeamId,
|
||||
job,
|
||||
userByPuuid,
|
||||
};
|
||||
}
|
||||
|
||||
function execResult<T>(value: T) {
|
||||
return { exec: jest.fn().mockResolvedValue(value) };
|
||||
}
|
||||
|
||||
function sessionResult<T>(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(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<string, unknown> = {
|
||||
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<CommunityStatsService>;
|
||||
const service = createService({ connectionService, communityStatsService });
|
||||
return {
|
||||
fixture,
|
||||
session,
|
||||
service,
|
||||
matchModel,
|
||||
competitionFactModel,
|
||||
communityStatsService,
|
||||
quarantineCollection,
|
||||
};
|
||||
}
|
||||
@@ -1,11 +1,12 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { CompetitionModule } from '../competition/competition.module';
|
||||
import { CommunityStatsModule } from '../community-stats/community-stats.module';
|
||||
import { RiotModule } from '../riot/riot.module';
|
||||
import { LegacyImportController } from './legacy-import.controller';
|
||||
import { LegacyImportService } from './legacy-import.service';
|
||||
|
||||
@Module({
|
||||
imports: [RiotModule, CommunityStatsModule],
|
||||
imports: [RiotModule, CommunityStatsModule, CompetitionModule],
|
||||
controllers: [LegacyImportController],
|
||||
providers: [LegacyImportService],
|
||||
exports: [LegacyImportService],
|
||||
|
||||
@@ -1,4 +1,6 @@
|
||||
import mongoose from 'mongoose';
|
||||
import { CompetitionBootstrapService } from '../competition/competition-bootstrap.service';
|
||||
import { CompetitionCommandService } from '../competition/competition-command.service';
|
||||
import { MatchStatsService } from '../community-stats/match-stats.service';
|
||||
import { CommunityStatsService } from '../community-stats/community-stats.service';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
@@ -66,6 +68,8 @@ describe('LegacyImportService member job completion', () => {
|
||||
communityStatsService,
|
||||
{} as MatchStatsService,
|
||||
distributedLockService,
|
||||
{} as CompetitionBootstrapService,
|
||||
{} as CompetitionCommandService,
|
||||
);
|
||||
const job: LegacyImportMemberJob = {
|
||||
kind: 'legacy-import-member',
|
||||
|
||||
@@ -2,11 +2,20 @@ import {
|
||||
BadRequestException,
|
||||
ConflictException,
|
||||
Injectable,
|
||||
InternalServerErrorException,
|
||||
Logger,
|
||||
NotFoundException,
|
||||
} from '@nestjs/common';
|
||||
import { randomUUID } from 'crypto';
|
||||
import { createHash, randomUUID } from 'node:crypto';
|
||||
import mongoose from 'mongoose';
|
||||
import {
|
||||
CompetitionBootstrapService,
|
||||
type CompetitionBootstrapMatch,
|
||||
} from '../competition/competition-bootstrap.service';
|
||||
import {
|
||||
CompetitionCommandService,
|
||||
type CompetitionCommandActor,
|
||||
} from '../competition/competition-command.service';
|
||||
import { MatchStatsService } from '../community-stats/match-stats.service';
|
||||
import { CommunityStatsService } from '../community-stats/community-stats.service';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
@@ -17,6 +26,7 @@ import {
|
||||
import type {
|
||||
LegacyImportJobDocument,
|
||||
Match,
|
||||
MatchDocument,
|
||||
RiotMatch as StoredRiotMatch,
|
||||
UserDocument,
|
||||
} from '../global/database/schema';
|
||||
@@ -25,7 +35,11 @@ import { RIOT_JOB_LOW_STREAM } from '../riot-job-queue/riot-job-queue.types';
|
||||
import { RiotMatchService } from '../riot/riot-match.service';
|
||||
import type { RiotMatchDto, RiotRegionalRoute } from '../riot/riot.types';
|
||||
import {
|
||||
buildGameResult,
|
||||
resolveReadyCompetitionSlot,
|
||||
type CompetitionResultSnapshot,
|
||||
} from '../tournament-result/competition-result.adapter';
|
||||
import type { MatchPuuidLookup } from '../tournament-result/team-mapping.util';
|
||||
import {
|
||||
buildParticipantsSnapshot,
|
||||
buildTeams,
|
||||
buildUserByPuuidMap,
|
||||
@@ -50,6 +64,10 @@ const MATCH_IMPORT_LOCK_TTL_SECONDS = 60;
|
||||
const MATCH_ID_PAGE_SIZE = 100;
|
||||
|
||||
type ImportOutcome = 'imported' | 'duplicate' | 'skipped' | 'error';
|
||||
type ResultlessMatchPatch = Omit<
|
||||
Partial<Match>,
|
||||
'result' | 'doubleElimination'
|
||||
>;
|
||||
|
||||
@Injectable()
|
||||
export class LegacyImportService {
|
||||
@@ -62,6 +80,8 @@ export class LegacyImportService {
|
||||
private readonly communityStatsService: CommunityStatsService,
|
||||
private readonly matchStatsService: MatchStatsService,
|
||||
private readonly distributedLockService: DistributedLockService,
|
||||
private readonly competitionBootstrapService: CompetitionBootstrapService,
|
||||
private readonly competitionCommandService: CompetitionCommandService,
|
||||
) {}
|
||||
|
||||
public async previewMembers(params: {
|
||||
@@ -154,7 +174,7 @@ export class LegacyImportService {
|
||||
startTime: Math.floor(window.startTime.getTime() / 1000),
|
||||
endTime: Math.floor(window.endTime.getTime() / 1000),
|
||||
triggeredBy: params.triggeredBy.toString(),
|
||||
region: (community.riotRegion ?? 'asia') as RiotRegionalRoute,
|
||||
region: community.riotRegion ?? 'asia',
|
||||
};
|
||||
await this.redisService.appendStream(
|
||||
RIOT_JOB_LOW_STREAM,
|
||||
@@ -302,8 +322,19 @@ export class LegacyImportService {
|
||||
.limit(limit + 1)
|
||||
.exec();
|
||||
const visible = matches.slice(0, limit);
|
||||
const riotMatchIds = visible
|
||||
.map((match) => match.result?.games[0]?.riotMatchId)
|
||||
const competitionByMatchId = await this.loadCompetitionByMatchId(
|
||||
visible.map(({ _id }) => _id),
|
||||
);
|
||||
const summaryByMatchId = new Map(
|
||||
visible.map((match) => [
|
||||
match._id.toString(),
|
||||
summarizeCompetitionResult(
|
||||
competitionByMatchId.get(match._id.toString()),
|
||||
) ?? summarizeLegacyMatchResult(match),
|
||||
]),
|
||||
);
|
||||
const riotMatchIds = [...summaryByMatchId.values()]
|
||||
.map(({ riotMatchId }) => riotMatchId)
|
||||
.filter((matchId): matchId is string => Boolean(matchId));
|
||||
const RiotMatchModel = await this.connectionService.getModel('riotMatch');
|
||||
const rawDocs = await RiotMatchModel.find({
|
||||
@@ -317,23 +348,23 @@ export class LegacyImportService {
|
||||
const userByPuuid = await this.buildUserByPuuidMap(params.communityId);
|
||||
return {
|
||||
matches: visible.map((match) => {
|
||||
const riotMatchId = match.result?.games[0]?.riotMatchId ?? null;
|
||||
const summary = summaryByMatchId.get(match._id.toString())!;
|
||||
const riotMatchId = summary.riotMatchId;
|
||||
const raw = riotMatchId ? rawById.get(riotMatchId) : undefined;
|
||||
const memberCount = match.result?.games[0]?.participants.length ?? 0;
|
||||
return {
|
||||
matchId: match._id.toString(),
|
||||
title: match.title,
|
||||
scheduledAt: match.scheduledAt.toISOString(),
|
||||
riotMatchId,
|
||||
memberCount,
|
||||
memberCount: summary.memberCount,
|
||||
externalCount: raw
|
||||
? resolveExternalCount(raw, userByPuuid)
|
||||
: Math.max(0, 10 - memberCount),
|
||||
teamAIndex: match.result?.seriesResults?.[0]?.teamAIndex ?? 1,
|
||||
teamBIndex: match.result?.seriesResults?.[0]?.teamBIndex ?? 2,
|
||||
teamAWins: match.result?.seriesResults?.[0]?.teamAWins ?? 0,
|
||||
teamBWins: match.result?.seriesResults?.[0]?.teamBWins ?? 0,
|
||||
winnerTeamIndex: match.result?.winnerTeamIndex,
|
||||
: Math.max(0, 10 - summary.memberCount),
|
||||
teamAIndex: summary.teamAIndex,
|
||||
teamBIndex: summary.teamBIndex,
|
||||
teamAWins: summary.teamAWins,
|
||||
teamBWins: summary.teamBWins,
|
||||
winnerTeamIndex: summary.winnerTeamIndex,
|
||||
};
|
||||
}),
|
||||
nextCursor:
|
||||
@@ -351,25 +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 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: {
|
||||
@@ -380,12 +580,19 @@ export class LegacyImportService {
|
||||
communityId: params.communityId,
|
||||
legacyImported: true,
|
||||
}).exec();
|
||||
const riotMatchIds = matches
|
||||
.map(
|
||||
(match) =>
|
||||
match.result?.games[0]?.riotMatchId ??
|
||||
match.result?.riotMatchIds?.[0],
|
||||
)
|
||||
const competitionByMatchId = await this.loadCompetitionByMatchId(
|
||||
matches.map(({ _id }) => _id),
|
||||
);
|
||||
const summaryByMatchId = new Map(
|
||||
matches.map((match) => [
|
||||
match._id.toString(),
|
||||
summarizeCompetitionResult(
|
||||
competitionByMatchId.get(match._id.toString()),
|
||||
) ?? summarizeLegacyMatchResult(match),
|
||||
]),
|
||||
);
|
||||
const riotMatchIds = [...summaryByMatchId.values()]
|
||||
.map(({ riotMatchId }) => riotMatchId)
|
||||
.filter((matchId): matchId is string => Boolean(matchId));
|
||||
|
||||
const RiotMatchModel = await this.connectionService.getModel('riotMatch');
|
||||
@@ -409,14 +616,17 @@ export class LegacyImportService {
|
||||
};
|
||||
|
||||
for (const match of matches) {
|
||||
const riotMatchId =
|
||||
match.result?.games[0]?.riotMatchId ?? match.result?.riotMatchIds?.[0];
|
||||
const existingCompetition = competitionByMatchId.get(
|
||||
match._id.toString(),
|
||||
);
|
||||
const summary = summaryByMatchId.get(match._id.toString())!;
|
||||
const riotMatchId = summary.riotMatchId;
|
||||
const raw = riotMatchId ? rawById.get(riotMatchId) : undefined;
|
||||
const title = this.normalizeLegacyTitle(
|
||||
match.title,
|
||||
raw?.info.gameCreation ?? match.scheduledAt.getTime(),
|
||||
);
|
||||
const update: Partial<Match> = {};
|
||||
const update: ResultlessMatchPatch = {};
|
||||
if (title !== match.title) {
|
||||
update.title = title;
|
||||
result.normalizedTitles += 1;
|
||||
@@ -429,43 +639,41 @@ export class LegacyImportService {
|
||||
{ _id: match._id },
|
||||
{ $set: update },
|
||||
).exec();
|
||||
await this.matchStatsService.buildAndUpsert(match._id);
|
||||
await this.rebuildMatchStats(
|
||||
match._id,
|
||||
competitionRevision(existingCompetition),
|
||||
);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
const participants = buildParticipantsSnapshot(raw, userByPuuid);
|
||||
const gameResult = buildGameResult(raw, userByPuuid, 1);
|
||||
if (!gameResult || participants.length === 0) {
|
||||
const teams = buildTeams(raw, userByPuuid);
|
||||
const counts = countKnownParticipants(raw, userByPuuid);
|
||||
if (
|
||||
!hasDecisiveRiotWinner(raw) ||
|
||||
!hasTrustedCompetitionRoster(counts, participants, teams)
|
||||
) {
|
||||
result.skippedNoKnownParticipants += 1;
|
||||
if (Object.keys(update).length > 0) {
|
||||
await MatchModel.updateOne(
|
||||
{ _id: match._id },
|
||||
{ $set: update },
|
||||
).exec();
|
||||
await this.matchStatsService.buildAndUpsert(match._id);
|
||||
await this.rebuildMatchStats(
|
||||
match._id,
|
||||
competitionRevision(existingCompetition),
|
||||
);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
const winnerTeamIndex = gameResult.winnerTeamIndex;
|
||||
update.mapId = raw.info.mapId ?? match.mapId;
|
||||
update.participants = participants;
|
||||
update.teams = buildTeams(raw, userByPuuid);
|
||||
update.result = {
|
||||
winnerTeamIndex,
|
||||
riotMatchIds: [riotMatchId],
|
||||
games: [gameResult],
|
||||
seriesResults: [
|
||||
{
|
||||
teamAIndex: 1,
|
||||
teamBIndex: 2,
|
||||
teamAWins: winnerTeamIndex === 1 ? 1 : 0,
|
||||
teamBWins: winnerTeamIndex === 2 ? 1 : 0,
|
||||
winnerTeamIndex,
|
||||
},
|
||||
],
|
||||
};
|
||||
update.teams = teams;
|
||||
update.gameMode = 'pair';
|
||||
update.gameCount = 1;
|
||||
update.teamBuiltAt = match.teamBuiltAt ?? new Date(raw.info.gameCreation);
|
||||
|
||||
await MatchModel.updateOne(
|
||||
{
|
||||
@@ -475,7 +683,30 @@ export class LegacyImportService {
|
||||
},
|
||||
{ $set: update },
|
||||
).exec();
|
||||
await this.matchStatsService.buildAndUpsert(match._id);
|
||||
let sourceRevision = competitionRevision(existingCompetition);
|
||||
if (!summarizeCompetitionResult(existingCompetition)) {
|
||||
const updatedMatch = {
|
||||
...toPlainRecord(match),
|
||||
...update,
|
||||
_id: match._id,
|
||||
communityId: match.communityId,
|
||||
} as unknown as MatchDocument;
|
||||
sourceRevision =
|
||||
(await this.acceptRiotCompetitionFact({
|
||||
match: updatedMatch,
|
||||
detail: raw,
|
||||
actor: { type: 'system' },
|
||||
})) ?? undefined;
|
||||
}
|
||||
if (sourceRevision === undefined) {
|
||||
result.skippedNoKnownParticipants += 1;
|
||||
continue;
|
||||
}
|
||||
await MatchModel.updateOne(
|
||||
{ _id: match._id },
|
||||
{ $set: { status: 'finished' } },
|
||||
).exec();
|
||||
await this.rebuildMatchStats(match._id, sourceRevision);
|
||||
result.rebuilt += 1;
|
||||
}
|
||||
|
||||
@@ -486,6 +717,44 @@ export class LegacyImportService {
|
||||
return result;
|
||||
}
|
||||
|
||||
private async loadCompetitionByMatchId(
|
||||
matchIds: mongoose.Types.ObjectId[],
|
||||
): Promise<Map<string, unknown>> {
|
||||
if (matchIds.length === 0) return new Map();
|
||||
const CompetitionModel =
|
||||
await this.connectionService.getModel('competition');
|
||||
const competitions = await CompetitionModel.find({
|
||||
matchId: { $in: matchIds },
|
||||
})
|
||||
.lean()
|
||||
.exec();
|
||||
return new Map(
|
||||
competitions.map((competition) => [
|
||||
competition.matchId.toString(),
|
||||
competition,
|
||||
]),
|
||||
);
|
||||
}
|
||||
|
||||
private rebuildMatchStats(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
sourceRevision?: number,
|
||||
): Promise<void> {
|
||||
return this.matchStatsService
|
||||
.buildAndUpsert(matchId, {
|
||||
...(sourceRevision === undefined ? {} : { sourceRevision }),
|
||||
})
|
||||
.catch((error: unknown) => {
|
||||
this.logger.warn(
|
||||
`Failed to rebuild legacy Match stats ${matchId.toString()}${
|
||||
sourceRevision === undefined
|
||||
? ''
|
||||
: ` at Competition revision ${sourceRevision}`
|
||||
}: ${error instanceof Error ? error.message : String(error)}`,
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
private async collectMatchIds(
|
||||
job: LegacyImportMemberJob,
|
||||
): Promise<Set<string>> {
|
||||
@@ -521,9 +790,12 @@ export class LegacyImportService {
|
||||
MATCH_IMPORT_LOCK_TTL_SECONDS * 1000,
|
||||
},
|
||||
async () => {
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const existing = await MatchModel.exists({
|
||||
'result.games.riotMatchId': riotMatchId,
|
||||
const CompetitionFactModel =
|
||||
await this.connectionService.getModel('competitionFact');
|
||||
const existing = await CompetitionFactModel.exists({
|
||||
type: 'game-accepted',
|
||||
'evidence.type': 'riot',
|
||||
'evidence.riotMatchId': riotMatchId,
|
||||
});
|
||||
if (existing) return 'duplicate';
|
||||
|
||||
@@ -533,43 +805,31 @@ export class LegacyImportService {
|
||||
);
|
||||
if (!detail.info.tournamentCode) return 'skipped';
|
||||
const counts = countKnownParticipants(detail, userByPuuid);
|
||||
if (counts.total === 0) return 'skipped';
|
||||
|
||||
const gameResult = buildGameResult(detail, userByPuuid, 1);
|
||||
if (!gameResult || gameResult.participants.length === 0) {
|
||||
const participants = buildParticipantsSnapshot(detail, userByPuuid);
|
||||
const teams = buildTeams(detail, userByPuuid);
|
||||
if (
|
||||
!hasDecisiveRiotWinner(detail) ||
|
||||
!hasTrustedCompetitionRoster(counts, participants, teams)
|
||||
) {
|
||||
return 'skipped';
|
||||
}
|
||||
|
||||
const winnerTeamIndex = gameResult.winnerTeamIndex;
|
||||
const matchPayload: Partial<Match> = {
|
||||
const matchPayload: ResultlessMatchPatch = {
|
||||
communityId: new mongoose.Types.ObjectId(job.communityId),
|
||||
title: this.formatLegacyDate(detail.info.gameCreation),
|
||||
description: 'Legacy import (자동 생성)',
|
||||
mapId: detail.info.mapId ?? 11,
|
||||
status: 'finished',
|
||||
status: 'team-built',
|
||||
scheduledAt: new Date(detail.info.gameCreation),
|
||||
maxParticipants: 10,
|
||||
gameCount: 1,
|
||||
gameMode: 'pair',
|
||||
tournamentCodeIds: [],
|
||||
gameSchedule: [],
|
||||
teamBuiltAt: new Date(detail.info.gameCreation),
|
||||
hostUserId: new mongoose.Types.ObjectId(job.triggeredBy),
|
||||
participants: buildParticipantsSnapshot(detail, userByPuuid),
|
||||
teams: buildTeams(detail, userByPuuid),
|
||||
result: {
|
||||
winnerTeamIndex,
|
||||
riotMatchIds: [riotMatchId],
|
||||
games: [gameResult],
|
||||
seriesResults: [
|
||||
{
|
||||
teamAIndex: 1,
|
||||
teamBIndex: 2,
|
||||
teamAWins: winnerTeamIndex === 1 ? 1 : 0,
|
||||
teamBWins: winnerTeamIndex === 2 ? 1 : 0,
|
||||
winnerTeamIndex,
|
||||
},
|
||||
],
|
||||
},
|
||||
participants,
|
||||
teams,
|
||||
legacyImported: true,
|
||||
legacyImportSource: {
|
||||
importedAt: new Date(),
|
||||
@@ -581,8 +841,36 @@ export class LegacyImportService {
|
||||
notices: [],
|
||||
schedule: [],
|
||||
};
|
||||
const match = await MatchModel.create(matchPayload);
|
||||
await this.matchStatsService.buildAndUpsert(match._id);
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const match = await MatchModel.findOneAndUpdate(
|
||||
{
|
||||
_id: deterministicObjectId(`legacy-import:match:${riotMatchId}`),
|
||||
},
|
||||
{ $setOnInsert: matchPayload },
|
||||
{
|
||||
upsert: true,
|
||||
returnDocument: 'after',
|
||||
setDefaultsOnInsert: true,
|
||||
runValidators: true,
|
||||
},
|
||||
).exec();
|
||||
if (!match)
|
||||
throw new Error('Legacy Match upsert returned no document.');
|
||||
|
||||
const sourceRevision = await this.acceptRiotCompetitionFact({
|
||||
match,
|
||||
detail,
|
||||
actor: {
|
||||
type: 'migration',
|
||||
migrationRunId: job.parentJobId,
|
||||
},
|
||||
});
|
||||
if (sourceRevision === null) return 'skipped';
|
||||
await MatchModel.updateOne(
|
||||
{ _id: match._id },
|
||||
{ $set: { status: 'finished' } },
|
||||
).exec();
|
||||
await this.rebuildMatchStats(match._id, sourceRevision);
|
||||
return 'imported';
|
||||
},
|
||||
);
|
||||
@@ -598,6 +886,42 @@ export class LegacyImportService {
|
||||
}
|
||||
}
|
||||
|
||||
private async acceptRiotCompetitionFact(params: {
|
||||
match: MatchDocument;
|
||||
detail: RiotMatchDto;
|
||||
actor: CompetitionCommandActor;
|
||||
}): Promise<number | null> {
|
||||
const competitionDocument =
|
||||
await this.competitionBootstrapService.bootstrap(
|
||||
params.match as unknown as CompetitionBootstrapMatch,
|
||||
);
|
||||
const competition = toCompetitionResultSnapshot(competitionDocument);
|
||||
const mapped = resolveReadyCompetitionSlot({
|
||||
competition,
|
||||
detail: params.detail,
|
||||
lookup: buildMatchPuuidLookup(params.match),
|
||||
});
|
||||
if (!mapped) return null;
|
||||
|
||||
const accepted = await this.competitionCommandService.acceptGame({
|
||||
competitionId: competition.competitionId,
|
||||
expectedRevision: competition.revision,
|
||||
idempotencyKey: `legacy-import:riot:${params.detail.metadata.matchId}`,
|
||||
actor: params.actor,
|
||||
occurredAt: mapped.occurredAt,
|
||||
gameId: mapped.gameId,
|
||||
seriesId: mapped.seriesId,
|
||||
gameSlotId: mapped.gameSlotId,
|
||||
ordinal: mapped.ordinal,
|
||||
evidence: mapped.evidence,
|
||||
mapping: mapped.mapping,
|
||||
startedAt: mapped.startedAt,
|
||||
durationSeconds: mapped.durationSeconds,
|
||||
participants: mapped.normalizedParticipants,
|
||||
});
|
||||
return accepted.revision;
|
||||
}
|
||||
|
||||
private async ensureRiotMatchPersisted(
|
||||
riotMatchId: string,
|
||||
region: RiotRegionalRoute,
|
||||
@@ -679,13 +1003,18 @@ export class LegacyImportService {
|
||||
const updated = await LegacyImportJobModel.findOne({
|
||||
jobId: job.parentJobId,
|
||||
})
|
||||
.select({ processedMembers: 1, totalMembers: 1, state: 1, completedAt: 1 })
|
||||
.select({
|
||||
processedMembers: 1,
|
||||
totalMembers: 1,
|
||||
state: 1,
|
||||
completedAt: 1,
|
||||
})
|
||||
.lean()
|
||||
.exec();
|
||||
const completed = Boolean(
|
||||
updated &&
|
||||
updated.state !== 'cancelled' &&
|
||||
updated.processedMembers >= updated.totalMembers,
|
||||
updated.state !== 'cancelled' &&
|
||||
updated.processedMembers >= updated.totalMembers,
|
||||
);
|
||||
if (completed) {
|
||||
await LegacyImportJobModel.updateOne(
|
||||
@@ -741,7 +1070,7 @@ export class LegacyImportService {
|
||||
.catch((error: unknown) => {
|
||||
this.logger.warn(
|
||||
`Failed to release legacy import lock ${lockOwnership.lockKey}: ${
|
||||
error instanceof Error ? error.message : error
|
||||
error instanceof Error ? error.message : String(error)
|
||||
}`,
|
||||
);
|
||||
});
|
||||
@@ -903,3 +1232,256 @@ function isRiotMatchDto(value: unknown): value is RiotMatchDto {
|
||||
'info' in value,
|
||||
);
|
||||
}
|
||||
|
||||
interface LegacyResultSummary {
|
||||
riotMatchId: string | null;
|
||||
memberCount: number;
|
||||
teamAIndex: number;
|
||||
teamBIndex: number;
|
||||
teamAWins: number;
|
||||
teamBWins: number;
|
||||
winnerTeamIndex?: number;
|
||||
}
|
||||
|
||||
function summarizeCompetitionResult(
|
||||
value: unknown,
|
||||
): LegacyResultSummary | null {
|
||||
if (!value) return null;
|
||||
const competition = toPlainRecord(value);
|
||||
const projection = toRecord(competition.projection);
|
||||
const games = toArray(projection.games).map(toRecord);
|
||||
const game = games.find((candidate) => {
|
||||
const evidence = toRecord(candidate.evidence);
|
||||
return evidence.type === 'riot' && typeof evidence.riotMatchId === 'string';
|
||||
});
|
||||
if (!game) return null;
|
||||
const evidence = toRecord(game.evidence);
|
||||
const series = toArray(projection.series)
|
||||
.map(toRecord)
|
||||
.find(
|
||||
(candidate) => idString(candidate.seriesId) === idString(game.seriesId),
|
||||
);
|
||||
const entries = toArray(series?.entries).map(toRecord);
|
||||
const teamIndexById = new Map(
|
||||
toArray(competition.teams).map((teamValue) => {
|
||||
const team = toRecord(teamValue);
|
||||
return [
|
||||
idString(team.teamId),
|
||||
optionalNumber(team.legacyTeamIndex) ?? numberValue(team.displayOrder),
|
||||
];
|
||||
}),
|
||||
);
|
||||
const teamA = entries.find((entry) => entry.slot === 'A');
|
||||
const teamB = entries.find((entry) => entry.slot === 'B');
|
||||
const teamAId = idString(teamA?.teamId);
|
||||
const teamBId = idString(teamB?.teamId);
|
||||
const winnerTeamId =
|
||||
idString(toRecord(series?.outcome).winnerTeamId) ||
|
||||
idString(game.winnerTeamId);
|
||||
return {
|
||||
riotMatchId: String(evidence.riotMatchId),
|
||||
memberCount: toArray(game.participants).filter(
|
||||
(participant) => idString(toRecord(participant).userId).length > 0,
|
||||
).length,
|
||||
teamAIndex: teamIndexById.get(teamAId) ?? 1,
|
||||
teamBIndex: teamIndexById.get(teamBId) ?? 2,
|
||||
teamAWins: numberValue(teamA?.gameWins),
|
||||
teamBWins: numberValue(teamB?.gameWins),
|
||||
...(teamIndexById.has(winnerTeamId)
|
||||
? { winnerTeamIndex: teamIndexById.get(winnerTeamId) }
|
||||
: {}),
|
||||
};
|
||||
}
|
||||
|
||||
function summarizeLegacyMatchResult(match: MatchDocument): LegacyResultSummary {
|
||||
const series = match.result?.seriesResults?.[0];
|
||||
const game = match.result?.games?.[0];
|
||||
return {
|
||||
riotMatchId: game?.riotMatchId ?? match.result?.riotMatchIds?.[0] ?? null,
|
||||
memberCount: game?.participants.length ?? 0,
|
||||
teamAIndex: series?.teamAIndex ?? 1,
|
||||
teamBIndex: series?.teamBIndex ?? 2,
|
||||
teamAWins: series?.teamAWins ?? 0,
|
||||
teamBWins: series?.teamBWins ?? 0,
|
||||
...(match.result?.winnerTeamIndex === undefined
|
||||
? {}
|
||||
: { winnerTeamIndex: match.result.winnerTeamIndex }),
|
||||
};
|
||||
}
|
||||
|
||||
function competitionRevision(value: unknown): number | undefined {
|
||||
return value ? optionalNumber(toPlainRecord(value).revision) : undefined;
|
||||
}
|
||||
|
||||
function hasDecisiveRiotWinner(detail: RiotMatchDto): boolean {
|
||||
return (
|
||||
detail.info.teams.filter(
|
||||
({ teamId, win }) => win && (teamId === 100 || teamId === 200),
|
||||
).length === 1
|
||||
);
|
||||
}
|
||||
|
||||
function hasTrustedCompetitionRoster(
|
||||
counts: { team100: number; team200: number; total: number },
|
||||
participants: Match['participants'],
|
||||
teams: Match['teams'],
|
||||
): boolean {
|
||||
if (
|
||||
counts.total < 6 ||
|
||||
counts.team100 !== counts.team200 ||
|
||||
counts.team100 === 0 ||
|
||||
teams.length !== 2 ||
|
||||
teams.some((team) => team.members.length !== counts.team100)
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
const userIds = participants.map(({ userId }) => userId.toString());
|
||||
return (
|
||||
userIds.length === counts.total && new Set(userIds).size === userIds.length
|
||||
);
|
||||
}
|
||||
|
||||
function buildMatchPuuidLookup(match: MatchDocument): 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);
|
||||
}
|
||||
return { puuidByUserId, userIdByPuuid };
|
||||
}
|
||||
|
||||
function toCompetitionResultSnapshot(
|
||||
value: unknown,
|
||||
): CompetitionResultSnapshot {
|
||||
const raw = toPlainRecord(value);
|
||||
const projection = toRecord(raw.projection);
|
||||
return {
|
||||
competitionId: idString(raw._id),
|
||||
revision: numberValue(raw.revision),
|
||||
phase: String(raw.phase) as CompetitionResultSnapshot['phase'],
|
||||
teams: toArray(raw.teams).map((teamValue) => {
|
||||
const team = toRecord(teamValue);
|
||||
return {
|
||||
teamId: idString(team.teamId),
|
||||
members: toArray(team.members).map((memberValue) => ({
|
||||
userId: idString(toRecord(memberValue).userId),
|
||||
})),
|
||||
};
|
||||
}),
|
||||
projection: {
|
||||
phase: String(
|
||||
projection.phase,
|
||||
) as CompetitionResultSnapshot['projection']['phase'],
|
||||
series: toArray(projection.series).map((seriesValue) => {
|
||||
const series = toRecord(seriesValue);
|
||||
return {
|
||||
seriesId: idString(series.seriesId),
|
||||
status: String(
|
||||
series.status,
|
||||
) as CompetitionResultSnapshot['projection']['series'][number]['status'],
|
||||
entries: toArray(series.entries).map((entryValue) => {
|
||||
const entry = toRecord(entryValue);
|
||||
return {
|
||||
slot: String(entry.slot) as 'A' | 'B',
|
||||
teamId: entry.teamId == null ? null : idString(entry.teamId),
|
||||
gameWins: numberValue(entry.gameWins),
|
||||
};
|
||||
}),
|
||||
};
|
||||
}),
|
||||
gameSlots: toArray(projection.gameSlots).map((slotValue) => {
|
||||
const slot = toRecord(slotValue);
|
||||
return {
|
||||
id: idString(slot.id),
|
||||
seriesId: idString(slot.seriesId),
|
||||
ordinal: numberValue(slot.ordinal),
|
||||
displayNumber: numberValue(slot.displayNumber),
|
||||
status: String(
|
||||
slot.status,
|
||||
) as CompetitionResultSnapshot['projection']['gameSlots'][number]['status'],
|
||||
};
|
||||
}),
|
||||
games: toArray(projection.games).map((gameValue) => {
|
||||
const evidence = toRecord(toRecord(gameValue).evidence);
|
||||
return {
|
||||
evidence: {
|
||||
type: typeof evidence.type === 'string' ? evidence.type : undefined,
|
||||
riotMatchId:
|
||||
typeof evidence.riotMatchId === 'string'
|
||||
? evidence.riotMatchId
|
||||
: undefined,
|
||||
},
|
||||
};
|
||||
}),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function toPlainRecord(value: unknown): Record<string, unknown> {
|
||||
if (
|
||||
value &&
|
||||
typeof value === 'object' &&
|
||||
'toObject' in value &&
|
||||
typeof value.toObject === 'function'
|
||||
) {
|
||||
const document = value as { toObject: () => unknown };
|
||||
return toRecord(document.toObject());
|
||||
}
|
||||
return toRecord(value);
|
||||
}
|
||||
|
||||
function toRecord(value: unknown): Record<string, unknown> {
|
||||
return value !== null && typeof value === 'object' && !Array.isArray(value)
|
||||
? (value as Record<string, unknown>)
|
||||
: {};
|
||||
}
|
||||
|
||||
function toArray(value: unknown): unknown[] {
|
||||
return Array.isArray(value) ? value : [];
|
||||
}
|
||||
|
||||
function idString(value: unknown): string {
|
||||
if (value instanceof mongoose.Types.ObjectId) return value.toString();
|
||||
return typeof value === 'string' ? value : '';
|
||||
}
|
||||
|
||||
function numberValue(value: unknown): number {
|
||||
return typeof value === 'number' && Number.isFinite(value) ? value : 0;
|
||||
}
|
||||
|
||||
function optionalNumber(value: unknown): number | undefined {
|
||||
return typeof value === 'number' && Number.isFinite(value)
|
||||
? value
|
||||
: undefined;
|
||||
}
|
||||
|
||||
function legacyTournamentCodeBindingUnset(): Record<string, 1> {
|
||||
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),
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
import 'reflect-metadata';
|
||||
import { BadRequestException, ValidationPipe } from '@nestjs/common';
|
||||
import { plainToInstance } from 'class-transformer';
|
||||
import { validateSync } from 'class-validator';
|
||||
import mongoose from 'mongoose';
|
||||
import { CreateMatchDto, JoinMatchDto } from './create-match.dto';
|
||||
|
||||
describe('CreateMatchDto game mode cutover', () => {
|
||||
it('rejects the removed live bracket mode', () => {
|
||||
const dto = plainToInstance(CreateMatchDto, {
|
||||
title: 'legacy bracket',
|
||||
scheduledAt: '2026-07-13T10:00:00.000Z',
|
||||
gameMode: 'bracket',
|
||||
});
|
||||
|
||||
expect(validateSync(dto)).toEqual(
|
||||
expect.arrayContaining([
|
||||
expect.objectContaining({ property: 'gameMode' }),
|
||||
]),
|
||||
);
|
||||
});
|
||||
|
||||
it.each(['pair', 'round-robin', 'double-elimination'] as const)(
|
||||
'accepts the live %s mode',
|
||||
(gameMode) => {
|
||||
const dto = plainToInstance(CreateMatchDto, {
|
||||
title: 'Competition',
|
||||
scheduledAt: '2026-07-13T10:00:00.000Z',
|
||||
gameMode,
|
||||
});
|
||||
|
||||
expect(validateSync(dto)).toEqual([]);
|
||||
},
|
||||
);
|
||||
});
|
||||
|
||||
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,
|
||||
});
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -8,6 +8,7 @@ import {
|
||||
IsDate,
|
||||
IsEnum,
|
||||
IsInt,
|
||||
IsIn,
|
||||
IsOptional,
|
||||
IsString,
|
||||
MaxLength,
|
||||
@@ -17,9 +18,16 @@ import {
|
||||
ValidationArguments,
|
||||
ValidationOptions,
|
||||
} from 'class-validator';
|
||||
import { MATCH_GAME_MODES, POSITIONS } from '../../global/database/schema';
|
||||
import { POSITIONS } from '../../global/database/schema';
|
||||
import type { MatchGameMode, Position } from '../../global/database/schema';
|
||||
|
||||
const LIVE_MATCH_GAME_MODES = [
|
||||
'pair',
|
||||
'round-robin',
|
||||
'double-elimination',
|
||||
] as const;
|
||||
type LiveMatchGameMode = Exclude<MatchGameMode, 'bracket'>;
|
||||
|
||||
function IsMultipleOf(
|
||||
multiple: number,
|
||||
validationOptions?: ValidationOptions,
|
||||
@@ -99,8 +107,8 @@ export class CreateMatchDto {
|
||||
gameCount?: number;
|
||||
|
||||
@IsOptional()
|
||||
@IsEnum(MATCH_GAME_MODES)
|
||||
gameMode?: MatchGameMode;
|
||||
@IsIn(LIVE_MATCH_GAME_MODES)
|
||||
gameMode?: LiveMatchGameMode;
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
@@ -163,8 +171,8 @@ export class UpdateMatchDto {
|
||||
gameCount?: number;
|
||||
|
||||
@IsOptional()
|
||||
@IsEnum(MATCH_GAME_MODES)
|
||||
gameMode?: MatchGameMode;
|
||||
@IsIn(LIVE_MATCH_GAME_MODES)
|
||||
gameMode?: LiveMatchGameMode;
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
@@ -207,10 +215,6 @@ export class JoinMatchDto {
|
||||
@ValidateNested({ each: true })
|
||||
@Type(() => PositionPreferenceDto)
|
||||
preferredPositions!: PositionPreferenceDto[];
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
userId?: string;
|
||||
}
|
||||
|
||||
export class AddParticipantDto {
|
||||
@@ -226,31 +230,3 @@ export class AddParticipantDto {
|
||||
@IsString()
|
||||
riotPuuid?: string;
|
||||
}
|
||||
|
||||
export class SwapDoubleEliminationSeedsDto {
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
leftSeedNumber!: number;
|
||||
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
rightSeedNumber!: number;
|
||||
}
|
||||
|
||||
export class ApplyDoubleEliminationWalkoverDto {
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
winnerTeamIndex!: number;
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(512)
|
||||
reason?: string;
|
||||
}
|
||||
|
||||
export class CancelDoubleEliminationActionDto {
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(512)
|
||||
reason?: string;
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
import { Types } from 'mongoose';
|
||||
import { presentPublicMatch } from './match-public.presenter';
|
||||
|
||||
describe('presentPublicMatch', () => {
|
||||
it('whitelists recruiting fields and excludes result/code internals', () => {
|
||||
const response = presentPublicMatch({
|
||||
_id: oid('1'),
|
||||
communityId: oid('2'),
|
||||
competitionId: oid('3'),
|
||||
shortCode: '33NW',
|
||||
title: '내전',
|
||||
joined: false,
|
||||
description: '설명',
|
||||
mapId: 11,
|
||||
status: 'in-progress',
|
||||
scheduledAt: new Date('2026-07-12T10:00:00.000Z'),
|
||||
maxParticipants: 20,
|
||||
gameCount: 3,
|
||||
gameMode: 'double-elimination',
|
||||
roundRobinMaxRounds: undefined,
|
||||
hostUserId: oid('4'),
|
||||
participants: [
|
||||
{
|
||||
userId: oid('5'),
|
||||
puuid: 'public-roster-snapshot',
|
||||
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 },
|
||||
],
|
||||
joinedAt: new Date('2026-07-01T00:00:00.000Z'),
|
||||
excluded: false,
|
||||
},
|
||||
],
|
||||
teams: [
|
||||
{
|
||||
teamIndex: 8,
|
||||
name: '똥칼라파워',
|
||||
captainUserId: oid('5'),
|
||||
members: [{ userId: oid('5'), assignedPosition: 'MID', cost: 42 }],
|
||||
},
|
||||
],
|
||||
prizes: ['상품'],
|
||||
notices: ['안내'],
|
||||
schedule: [{ time: '20:00', label: '시작' }],
|
||||
createdAt: new Date('2026-07-01T00:00:00.000Z'),
|
||||
updatedAt: new Date('2026-07-12T00:00:00.000Z'),
|
||||
tournamentCodeIds: [oid('6')],
|
||||
tournamentCodes: [{ code: 'SECRET' }],
|
||||
result: { winnerTeamIndex: 3, games: [], seriesResults: [] },
|
||||
doubleElimination: { bracketMatches: [{ winnerTeamIndex: 3 }] },
|
||||
resultPollState: { state: 'polling' },
|
||||
legacyImportSource: { triggeringPuuid: 'secret' },
|
||||
});
|
||||
|
||||
expect(response).toMatchObject({
|
||||
_id: oid('1').toString(),
|
||||
communityId: oid('2').toString(),
|
||||
competitionId: oid('3').toString(),
|
||||
title: '내전',
|
||||
doubleEliminationResetFinalEnabled: false,
|
||||
scheduledAt: '2026-07-12T10:00:00.000Z',
|
||||
participants: [
|
||||
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: [
|
||||
{
|
||||
teamIndex: 8,
|
||||
name: '똥칼라파워',
|
||||
captainUserId: oid('5').toString(),
|
||||
members: [
|
||||
{
|
||||
userId: oid('5').toString(),
|
||||
assignedPosition: 'MID',
|
||||
cost: 42,
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
});
|
||||
expect(response).not.toHaveProperty('tournamentCodeIds');
|
||||
expect(response).not.toHaveProperty('tournamentCodes');
|
||||
expect(response).not.toHaveProperty('result');
|
||||
expect(response).not.toHaveProperty('doubleElimination');
|
||||
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');
|
||||
});
|
||||
});
|
||||
|
||||
function oid(suffix: string) {
|
||||
return new Types.ObjectId(suffix.padStart(24, '0'));
|
||||
}
|
||||
@@ -0,0 +1,159 @@
|
||||
import type { MatchDetailResponse, MatchTierView } from '@lolympus/contracts';
|
||||
import type {
|
||||
MatchGameMode,
|
||||
MatchStatus,
|
||||
Position,
|
||||
} from '../global/database/schema';
|
||||
|
||||
type IdLike = string | { toString(): string };
|
||||
|
||||
interface PublicMatchSource {
|
||||
_id: IdLike;
|
||||
communityId: IdLike;
|
||||
competitionId?: IdLike;
|
||||
shortCode?: string;
|
||||
title: string;
|
||||
description: string;
|
||||
mapId: number;
|
||||
status: MatchStatus;
|
||||
scheduledAt: Date | string;
|
||||
maxParticipants: number;
|
||||
gameCount: number;
|
||||
gameMode: MatchGameMode;
|
||||
roundRobinMaxRounds?: number;
|
||||
doubleElimination?: { resetFinalEnabled?: boolean };
|
||||
hostUserId?: IdLike;
|
||||
participants: Array<{
|
||||
userId: IdLike;
|
||||
gameName?: string;
|
||||
tagLine?: string;
|
||||
profileIconId?: number;
|
||||
tier?: unknown;
|
||||
preferredPositions: Array<{ position: Position; priority: number }>;
|
||||
joinedAt: Date | string;
|
||||
excluded?: boolean;
|
||||
[key: string]: unknown;
|
||||
}>;
|
||||
teams: Array<{
|
||||
teamIndex: number;
|
||||
name: string;
|
||||
captainUserId?: IdLike;
|
||||
members: Array<{
|
||||
userId: IdLike;
|
||||
assignedPosition: Position;
|
||||
cost?: number;
|
||||
[key: string]: unknown;
|
||||
}>;
|
||||
[key: string]: unknown;
|
||||
}>;
|
||||
prizes: string[];
|
||||
notices: string[];
|
||||
schedule: Array<{ time: string; label: string }>;
|
||||
createdAt: Date | string;
|
||||
updatedAt: Date | string;
|
||||
[key: string]: unknown;
|
||||
}
|
||||
|
||||
/** Public Match DTO. Competitive results and Tournament Codes live elsewhere. */
|
||||
export function presentPublicMatch(
|
||||
source: PublicMatchSource,
|
||||
options: { joined?: boolean } = {},
|
||||
): MatchDetailResponse {
|
||||
return {
|
||||
_id: source._id.toString() as never,
|
||||
communityId: source.communityId.toString() as never,
|
||||
...(source.competitionId
|
||||
? { competitionId: source.competitionId.toString() as never }
|
||||
: {}),
|
||||
...(source.shortCode ? { shortCode: source.shortCode } : {}),
|
||||
title: source.title,
|
||||
description: source.description,
|
||||
mapId: source.mapId,
|
||||
status: source.status,
|
||||
scheduledAt: asIso(source.scheduledAt),
|
||||
maxParticipants: source.maxParticipants,
|
||||
gameCount: source.gameCount,
|
||||
gameMode: source.gameMode === 'bracket' ? 'pair' : source.gameMode,
|
||||
...(source.roundRobinMaxRounds === undefined
|
||||
? {}
|
||||
: { roundRobinMaxRounds: source.roundRobinMaxRounds }),
|
||||
...(source.gameMode === 'double-elimination'
|
||||
? {
|
||||
doubleEliminationResetFinalEnabled:
|
||||
source.doubleElimination?.resetFinalEnabled ?? 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() as never }
|
||||
: {}),
|
||||
members: team.members.map((member) => ({
|
||||
userId: member.userId.toString() as never,
|
||||
assignedPosition: member.assignedPosition,
|
||||
...(member.cost === undefined ? {} : { cost: member.cost }),
|
||||
})),
|
||||
})),
|
||||
prizes: [...source.prizes],
|
||||
notices: [...source.notices],
|
||||
schedule: source.schedule.map(({ time, label }) => ({ time, label })),
|
||||
joined: options.joined ?? false,
|
||||
createdAt: asIso(source.createdAt),
|
||||
updatedAt: asIso(source.updatedAt),
|
||||
};
|
||||
}
|
||||
|
||||
function asIso(value: Date | string): string {
|
||||
return value instanceof Date ? value.toISOString() : value;
|
||||
}
|
||||
|
||||
function toPublicTier(value: unknown): MatchTierView | undefined {
|
||||
if (typeof value !== 'object' || value === null || Array.isArray(value)) {
|
||||
return undefined;
|
||||
}
|
||||
const tier = value as Record<string, unknown>;
|
||||
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),
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
import { PATH_METADATA } from '@nestjs/common/constants';
|
||||
import { MatchController } from './match.controller';
|
||||
import { MatchService } from './match.service';
|
||||
|
||||
const LEGACY_RESULT_METHODS = [
|
||||
'applyDoubleEliminationWalkover',
|
||||
'cancelDoubleEliminationWalkover',
|
||||
'cancelDoubleEliminationRiotResult',
|
||||
] as const;
|
||||
|
||||
describe('Match result ownership cutover', () => {
|
||||
it('does not expose legacy Match result mutation routes', () => {
|
||||
const routes = Object.getOwnPropertyNames(MatchController.prototype)
|
||||
.map((name) => {
|
||||
const handler = Object.getOwnPropertyDescriptor(
|
||||
MatchController.prototype,
|
||||
name,
|
||||
)?.value as unknown;
|
||||
return typeof handler === 'function'
|
||||
? (Reflect.getMetadata(PATH_METADATA, handler) as unknown)
|
||||
: undefined;
|
||||
})
|
||||
.filter((path): path is string => typeof path === 'string');
|
||||
|
||||
expect(routes).not.toEqual(
|
||||
expect.arrayContaining([
|
||||
':matchId/double-elimination/bracket-matches/:bracketMatchId/walkover',
|
||||
':matchId/double-elimination/bracket-matches/:bracketMatchId/walkover/cancel',
|
||||
':matchId/double-elimination/bracket-matches/:bracketMatchId/result/cancel',
|
||||
]),
|
||||
);
|
||||
});
|
||||
|
||||
it.each(LEGACY_RESULT_METHODS)(
|
||||
'removes the legacy MatchService.%s result writer',
|
||||
(methodName) => {
|
||||
expect(Object.getOwnPropertyNames(MatchService.prototype)).not.toContain(
|
||||
methodName,
|
||||
);
|
||||
},
|
||||
);
|
||||
});
|
||||
@@ -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();
|
||||
});
|
||||
});
|
||||
@@ -1,3 +1,7 @@
|
||||
import type {
|
||||
MatchDetailResponse,
|
||||
MatchListResponse,
|
||||
} from '@lolympus/contracts';
|
||||
import {
|
||||
BadRequestException,
|
||||
Body,
|
||||
@@ -18,18 +22,11 @@ import { CurrentUser } from '../auth/current-user.decorator';
|
||||
import { Roles } from '../auth/roles.decorator';
|
||||
import { RolesGuard } from '../auth/roles.guard';
|
||||
import { ParseObjectIdPipe } from '../common/parse-object-id.pipe';
|
||||
import type {
|
||||
MatchDocument,
|
||||
MatchStatus,
|
||||
UserDocument,
|
||||
} from '../global/database/schema';
|
||||
import type { MatchStatus, UserDocument } from '../global/database/schema';
|
||||
import {
|
||||
AddParticipantDto,
|
||||
ApplyDoubleEliminationWalkoverDto,
|
||||
CancelDoubleEliminationActionDto,
|
||||
CreateMatchDto,
|
||||
JoinMatchDto,
|
||||
SwapDoubleEliminationSeedsDto,
|
||||
UpdateMatchDto,
|
||||
UpdateParticipantDto,
|
||||
} from './dto/create-match.dto';
|
||||
@@ -47,9 +44,9 @@ export class MatchController {
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Body() body: CreateMatchDto,
|
||||
) {
|
||||
): Promise<MatchDetailResponse> {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
return this.matchService.create({
|
||||
const match = await this.matchService.create({
|
||||
communityId,
|
||||
hostUserId: currentUser._id,
|
||||
data: {
|
||||
@@ -68,6 +65,7 @@ export class MatchController {
|
||||
schedule: body.schedule ?? [],
|
||||
},
|
||||
});
|
||||
return this.matchService.serialize(match, { joined: false });
|
||||
}
|
||||
|
||||
// 공개 — 커뮤니티 내 매치 리스트. 로그인 시 본인 참여 여부를 함께 반환.
|
||||
@@ -84,7 +82,7 @@ export class MatchController {
|
||||
@Query('scheduledFrom') scheduledFrom?: string,
|
||||
@Query('scheduledTo') scheduledTo?: string,
|
||||
@Query('sort') sort?: 'asc' | 'desc',
|
||||
) {
|
||||
): Promise<MatchListResponse> {
|
||||
const result = await this.matchService.listPage({
|
||||
communityId,
|
||||
status,
|
||||
@@ -95,21 +93,39 @@ export class MatchController {
|
||||
scheduledTo: this.toOptionalDate(scheduledTo),
|
||||
sort,
|
||||
});
|
||||
if (!currentUser) return result;
|
||||
const myId = currentUser._id;
|
||||
return {
|
||||
...result,
|
||||
matches: result.matches.map((m) => this.annotateJoined(m, myId)),
|
||||
matches: result.matches.map((match) =>
|
||||
this.matchService.serialize(match, {
|
||||
...(currentUser
|
||||
? {
|
||||
joined: match.participants.some((participant) =>
|
||||
participant.userId.equals(currentUser._id),
|
||||
),
|
||||
}
|
||||
: {}),
|
||||
}),
|
||||
),
|
||||
};
|
||||
}
|
||||
|
||||
@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<MatchDetailResponse> {
|
||||
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')
|
||||
@@ -121,119 +137,18 @@ export class MatchController {
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Body() body: UpdateMatchDto,
|
||||
) {
|
||||
): Promise<MatchDetailResponse> {
|
||||
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);
|
||||
}
|
||||
|
||||
@Post(':matchId/double-elimination/bracket-matches/:bracketMatchId/walkover')
|
||||
@Roles('admin', 'owner')
|
||||
@UseGuards(RolesGuard)
|
||||
public async applyDoubleEliminationWalkover(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Param('bracketMatchId') bracketMatchId: string,
|
||||
@Body() body: ApplyDoubleEliminationWalkoverDto,
|
||||
) {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
const match = await this.matchService.applyDoubleEliminationWalkover({
|
||||
matchId,
|
||||
communityId,
|
||||
actorUserId: currentUser._id,
|
||||
bracketMatchId,
|
||||
winnerTeamIndex: body.winnerTeamIndex,
|
||||
reason: body.reason,
|
||||
});
|
||||
return this.matchService.serialize(match);
|
||||
}
|
||||
|
||||
@Post(
|
||||
':matchId/double-elimination/bracket-matches/:bracketMatchId/walkover/cancel',
|
||||
)
|
||||
@Roles('admin', 'owner')
|
||||
@UseGuards(RolesGuard)
|
||||
public async cancelDoubleEliminationWalkover(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Param('bracketMatchId') bracketMatchId: string,
|
||||
@Body() body: CancelDoubleEliminationActionDto,
|
||||
) {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
const match = await this.matchService.cancelDoubleEliminationWalkover({
|
||||
matchId,
|
||||
communityId,
|
||||
actorUserId: currentUser._id,
|
||||
bracketMatchId,
|
||||
reason: body.reason,
|
||||
});
|
||||
return this.matchService.serialize(match);
|
||||
}
|
||||
|
||||
@Post(
|
||||
':matchId/double-elimination/bracket-matches/:bracketMatchId/result/cancel',
|
||||
)
|
||||
@Roles('admin', 'owner')
|
||||
@UseGuards(RolesGuard)
|
||||
public async cancelDoubleEliminationRiotResult(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Param('bracketMatchId') bracketMatchId: string,
|
||||
@Body() body: CancelDoubleEliminationActionDto,
|
||||
) {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
const match = await this.matchService.cancelDoubleEliminationRiotResult({
|
||||
matchId,
|
||||
communityId,
|
||||
actorUserId: currentUser._id,
|
||||
bracketMatchId,
|
||||
reason: body.reason,
|
||||
});
|
||||
return this.matchService.serialize(match);
|
||||
}
|
||||
|
||||
@Delete(':matchId')
|
||||
@@ -250,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<MatchDetailResponse> {
|
||||
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 });
|
||||
}
|
||||
|
||||
// 관리자 전용 — 커뮤니티 유저를 모집중 매치에 직접 추가한다.
|
||||
@@ -277,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<MatchDetailResponse> {
|
||||
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),
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
// 관리자 전용 — 참가자 주/부 포지션 변경.
|
||||
@@ -299,7 +224,7 @@ export class MatchController {
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Param('userId', ParseObjectIdPipe) userId: mongoose.Types.ObjectId,
|
||||
@Body() body: UpdateParticipantDto,
|
||||
) {
|
||||
): Promise<MatchDetailResponse> {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
const match = await this.matchService.updateParticipantPositions({
|
||||
matchId,
|
||||
@@ -308,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),
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
// 관리자 전용 — 참가자 강제 제외.
|
||||
@@ -331,28 +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 annotateJoined(
|
||||
match: MatchDocument,
|
||||
userId: mongoose.Types.ObjectId,
|
||||
) {
|
||||
const obj = match.toObject();
|
||||
const joined = match.participants.some((p) => p.userId.equals(userId));
|
||||
return { ...obj, joined };
|
||||
}
|
||||
|
||||
private assertSameCommunity(
|
||||
user: UserDocument,
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
|
||||
@@ -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();
|
||||
});
|
||||
});
|
||||
@@ -1,24 +1,17 @@
|
||||
import {
|
||||
BadRequestException,
|
||||
ConflictException,
|
||||
Injectable,
|
||||
InternalServerErrorException,
|
||||
NotFoundException,
|
||||
} from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import {
|
||||
cancelDoubleEliminationBracketMatch,
|
||||
completeDoubleEliminationBracketMatch,
|
||||
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';
|
||||
import {
|
||||
Match,
|
||||
MatchDocument,
|
||||
MatchGameMode,
|
||||
MatchSeriesResult,
|
||||
MatchStatus,
|
||||
POSITIONS,
|
||||
Position,
|
||||
@@ -27,6 +20,7 @@ import {
|
||||
} from '../global/database/schema';
|
||||
import { DEFAULT_TOURNAMENT_GAME_COUNT } from '../tournament-code/tournament-code.constants';
|
||||
import { TournamentCodeService } from '../tournament-code/tournament-code.service';
|
||||
import { presentPublicMatch } from './match-public.presenter';
|
||||
|
||||
const MATCH_SHORT_CODE_ALPHABET = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
|
||||
const MATCH_SHORT_CODE_LENGTH = 4;
|
||||
@@ -79,6 +73,7 @@ interface MatchListFilter {
|
||||
|
||||
interface JoinMatchParams {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
communityId?: mongoose.Types.ObjectId;
|
||||
userId: mongoose.Types.ObjectId;
|
||||
preferredPositions?: PositionPreference[];
|
||||
// 특정 RiotAccount(puuid)로 참가하고 싶을 때 지정. 없으면 primary 사용.
|
||||
@@ -104,28 +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;
|
||||
}
|
||||
|
||||
interface ApplyDoubleEliminationWalkoverParams extends DoubleEliminationAdminParams {
|
||||
bracketMatchId: string;
|
||||
winnerTeamIndex: number;
|
||||
reason?: string;
|
||||
}
|
||||
|
||||
interface CancelDoubleEliminationActionParams extends DoubleEliminationAdminParams {
|
||||
bracketMatchId: string;
|
||||
reason?: string;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class MatchService {
|
||||
constructor(
|
||||
@@ -211,37 +184,24 @@ export class MatchService {
|
||||
|
||||
public async getById(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
): Promise<MatchDocument> {
|
||||
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;
|
||||
}
|
||||
|
||||
public async serialize(match: MatchDocument) {
|
||||
public serialize(match: MatchDocument, options: { joined?: boolean } = {}) {
|
||||
const obj = match.toObject();
|
||||
if (obj.result?.games) {
|
||||
obj.result.games = [...obj.result.games].sort(
|
||||
(left, right) => left.gameNumber - right.gameNumber,
|
||||
);
|
||||
if (!obj.result.seriesResults?.length) {
|
||||
obj.result.seriesResults = this.buildSeriesResults(obj.result.games);
|
||||
}
|
||||
}
|
||||
return {
|
||||
...obj,
|
||||
gameCount: match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT,
|
||||
gameMode: match.gameMode ?? 'pair',
|
||||
participants: (obj.participants ?? []).map((participant) => ({
|
||||
...participant,
|
||||
excluded: participant.excluded ?? false,
|
||||
})),
|
||||
teams: (obj.teams ?? []).map((team) => ({
|
||||
...team,
|
||||
})),
|
||||
gameSchedule: obj.gameSchedule ?? [],
|
||||
tournamentCodes: await this.tournamentCodeService.buildSlots(match),
|
||||
};
|
||||
return presentPublicMatch(
|
||||
{
|
||||
...obj,
|
||||
gameCount: match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT,
|
||||
gameMode: match.gameMode ?? 'pair',
|
||||
} as never,
|
||||
options,
|
||||
);
|
||||
}
|
||||
|
||||
public async update(params: UpdateMatchParams): Promise<MatchDocument> {
|
||||
@@ -252,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 =
|
||||
@@ -280,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);
|
||||
}
|
||||
@@ -311,186 +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<MatchDocument> {
|
||||
const match = await this.loadDoubleEliminationMatch(params);
|
||||
await this.assertDoubleEliminationSeedsCanChange(match);
|
||||
await this.releaseReservedDoubleEliminationCodes(match);
|
||||
match.doubleElimination = reshuffleDoubleEliminationSeeds(
|
||||
match.doubleElimination as NonNullable<Match['doubleElimination']>,
|
||||
);
|
||||
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<MatchDocument> {
|
||||
const match = await this.loadDoubleEliminationMatch(params);
|
||||
await this.assertDoubleEliminationSeedsCanChange(match);
|
||||
await this.releaseReservedDoubleEliminationCodes(match);
|
||||
match.doubleElimination = swapDoubleEliminationSeeds(
|
||||
match.doubleElimination as NonNullable<Match['doubleElimination']>,
|
||||
{
|
||||
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 applyDoubleEliminationWalkover(
|
||||
params: ApplyDoubleEliminationWalkoverParams,
|
||||
): Promise<MatchDocument> {
|
||||
const match = await this.loadDoubleEliminationMatch(params);
|
||||
const bracketMatch = this.requireDoubleEliminationBracketMatch(
|
||||
match,
|
||||
params.bracketMatchId,
|
||||
);
|
||||
if (bracketMatch.state !== 'ready') {
|
||||
throw new BadRequestException('Bracket match is not ready.');
|
||||
}
|
||||
if (
|
||||
bracketMatch.teamAIndex !== params.winnerTeamIndex &&
|
||||
bracketMatch.teamBIndex !== params.winnerTeamIndex
|
||||
) {
|
||||
throw new BadRequestException(
|
||||
'Winner team is not assigned to this bracket match.',
|
||||
);
|
||||
}
|
||||
|
||||
await this.releaseReservedDoubleEliminationCodes(match, [
|
||||
params.bracketMatchId,
|
||||
]);
|
||||
match.doubleElimination = completeDoubleEliminationBracketMatch(
|
||||
match.doubleElimination as NonNullable<Match['doubleElimination']>,
|
||||
{
|
||||
bracketMatchId: params.bracketMatchId,
|
||||
winnerTeamIndex: params.winnerTeamIndex,
|
||||
completedBy: 'walkover',
|
||||
completedAt: new Date(),
|
||||
walkover: {
|
||||
winnerTeamIndex: params.winnerTeamIndex,
|
||||
reason: params.reason,
|
||||
awardedBy: params.actorUserId,
|
||||
awardedAt: new Date(),
|
||||
active: true,
|
||||
},
|
||||
},
|
||||
);
|
||||
match.markModified('doubleElimination');
|
||||
this.syncDoubleEliminationWinner(match);
|
||||
await match.save();
|
||||
await this.tournamentCodeService.reserveForMatch(match);
|
||||
await this.communityStatsService.invalidateCommunity(params.communityId);
|
||||
return match;
|
||||
}
|
||||
|
||||
public async cancelDoubleEliminationWalkover(
|
||||
params: CancelDoubleEliminationActionParams,
|
||||
): Promise<MatchDocument> {
|
||||
const match = await this.loadDoubleEliminationMatch(params);
|
||||
const bracketMatch = this.requireDoubleEliminationBracketMatch(
|
||||
match,
|
||||
params.bracketMatchId,
|
||||
);
|
||||
if (
|
||||
bracketMatch.completedBy !== 'walkover' ||
|
||||
!bracketMatch.walkover?.active
|
||||
) {
|
||||
throw new BadRequestException('Active walkover was not found.');
|
||||
}
|
||||
await this.releaseReservedDoubleEliminationCodes(match);
|
||||
match.doubleElimination = cancelDoubleEliminationBracketMatch(
|
||||
match.doubleElimination as NonNullable<Match['doubleElimination']>,
|
||||
{
|
||||
bracketMatchId: params.bracketMatchId,
|
||||
cancelledBy: params.actorUserId,
|
||||
cancelReason: params.reason,
|
||||
},
|
||||
);
|
||||
match.markModified('doubleElimination');
|
||||
this.syncDoubleEliminationWinner(match);
|
||||
await match.save();
|
||||
await this.tournamentCodeService.reserveForMatch(match);
|
||||
await this.communityStatsService.invalidateCommunity(params.communityId);
|
||||
return match;
|
||||
}
|
||||
|
||||
public async cancelDoubleEliminationRiotResult(
|
||||
params: CancelDoubleEliminationActionParams,
|
||||
): Promise<MatchDocument> {
|
||||
const match = await this.loadDoubleEliminationMatch(params);
|
||||
const game = match.result?.games?.find(
|
||||
(entry) => entry.bracketMatchId === params.bracketMatchId,
|
||||
);
|
||||
if (!game) throw new NotFoundException('Collected result not found.');
|
||||
await this.releaseReservedDoubleEliminationCodes(match);
|
||||
match.doubleElimination = cancelDoubleEliminationBracketMatch(
|
||||
match.doubleElimination as NonNullable<Match['doubleElimination']>,
|
||||
{
|
||||
bracketMatchId: params.bracketMatchId,
|
||||
cancelledBy: params.actorUserId,
|
||||
cancelReason: params.reason,
|
||||
},
|
||||
);
|
||||
match.doubleElimination!.events.push({
|
||||
type: 'riot-result-cancelled',
|
||||
bracketMatchId: params.bracketMatchId,
|
||||
actorUserId: params.actorUserId,
|
||||
reason: params.reason,
|
||||
createdAt: new Date(),
|
||||
});
|
||||
const games = (match.result?.games ?? []).filter(
|
||||
(entry) => entry.bracketMatchId !== params.bracketMatchId,
|
||||
);
|
||||
match.result = {
|
||||
winnerTeamIndex: undefined,
|
||||
mvpUserId: match.result?.mvpUserId,
|
||||
riotMatchIds: (match.result?.riotMatchIds ?? []).filter(
|
||||
(riotMatchId) => riotMatchId !== game.riotMatchId,
|
||||
),
|
||||
games,
|
||||
seriesResults: this.buildSeriesResults(games),
|
||||
};
|
||||
await this.voidDoubleEliminationCode(match, params.bracketMatchId);
|
||||
if (match.status === 'finished') match.status = 'in-progress';
|
||||
match.markModified('doubleElimination');
|
||||
await match.save();
|
||||
await this.tournamentCodeService.reserveForMatch(match);
|
||||
await this.matchStatsService.buildAndUpsert(match._id);
|
||||
await this.communityStatsService.invalidateCommunity(params.communityId);
|
||||
return match;
|
||||
}
|
||||
|
||||
public async join(params: JoinMatchParams): Promise<MatchDocument> {
|
||||
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)
|
||||
@@ -514,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'] },
|
||||
@@ -531,7 +332,7 @@ export class MatchService {
|
||||
T extends Partial<Match> & DoubleEliminationConfigInput,
|
||||
>(input: T): Partial<Match> {
|
||||
const patch = this.stripMatchConfigInput(input);
|
||||
const gameMode = (patch.gameMode ?? 'pair') as MatchGameMode;
|
||||
const gameMode = patch.gameMode ?? 'pair';
|
||||
const maxParticipants = patch.maxParticipants ?? 10;
|
||||
|
||||
if (gameMode === 'double-elimination') {
|
||||
@@ -578,7 +379,8 @@ export class MatchService {
|
||||
private stripMatchConfigInput<
|
||||
T extends Partial<Match> & DoubleEliminationConfigInput,
|
||||
>(input: T): Partial<Match> {
|
||||
const { doubleEliminationResetFinalEnabled: _ignored, ...patch } = input;
|
||||
const patch = { ...input };
|
||||
delete patch.doubleEliminationResetFinalEnabled;
|
||||
return patch;
|
||||
}
|
||||
|
||||
@@ -589,139 +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<MatchDocument> {
|
||||
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<void> {
|
||||
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 requireDoubleEliminationBracketMatch(
|
||||
match: MatchDocument,
|
||||
bracketMatchId: string,
|
||||
) {
|
||||
const bracketMatch = match.doubleElimination?.bracketMatches.find(
|
||||
(entry) => entry.bracketMatchId === bracketMatchId,
|
||||
);
|
||||
if (!bracketMatch) throw new NotFoundException('Bracket match not found.');
|
||||
return bracketMatch;
|
||||
}
|
||||
|
||||
private async releaseReservedDoubleEliminationCodes(
|
||||
match: MatchDocument,
|
||||
bracketMatchIds?: string[],
|
||||
): Promise<void> {
|
||||
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',
|
||||
...(bracketMatchIds
|
||||
? { bracketMatchId: { $in: bracketMatchIds } }
|
||||
: { 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()),
|
||||
);
|
||||
}
|
||||
|
||||
private async voidDoubleEliminationCode(
|
||||
match: MatchDocument,
|
||||
bracketMatchId: string,
|
||||
): Promise<void> {
|
||||
const TournamentCodeModel =
|
||||
await this.connectionService.getModel('tournamentCode');
|
||||
await TournamentCodeModel.updateOne(
|
||||
{
|
||||
_id: { $in: match.tournamentCodeIds ?? [] },
|
||||
matchId: match._id,
|
||||
bracketMatchId,
|
||||
state: 'used',
|
||||
},
|
||||
{
|
||||
$set: { state: 'voided' },
|
||||
},
|
||||
).exec();
|
||||
}
|
||||
|
||||
private syncDoubleEliminationWinner(match: MatchDocument): void {
|
||||
if ((match.gameMode ?? 'pair') !== 'double-elimination') return;
|
||||
const firstTeamIndex = match.doubleElimination?.placements.firstTeamIndex;
|
||||
if (firstTeamIndex) {
|
||||
match.status = 'finished';
|
||||
match.result = match.result ?? {
|
||||
riotMatchIds: [],
|
||||
games: [],
|
||||
seriesResults: [],
|
||||
};
|
||||
match.result.winnerTeamIndex = firstTeamIndex;
|
||||
return;
|
||||
}
|
||||
if (match.status === 'finished') {
|
||||
match.status = 'in-progress';
|
||||
}
|
||||
if (match.result) {
|
||||
match.result.winnerTeamIndex = undefined;
|
||||
}
|
||||
}
|
||||
|
||||
public async cancelJoin(
|
||||
params: CancelMatchJoinParams,
|
||||
): Promise<MatchDocument> {
|
||||
@@ -1042,34 +711,4 @@ export class MatchService {
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
||||
private buildSeriesResults(
|
||||
games: NonNullable<Match['result']>['games'],
|
||||
): MatchSeriesResult[] {
|
||||
const bySeries = new Map<string, MatchSeriesResult>();
|
||||
for (const game of games) {
|
||||
const teamAIndex = Math.min(game.blueTeamIndex, game.redTeamIndex);
|
||||
const teamBIndex = Math.max(game.blueTeamIndex, game.redTeamIndex);
|
||||
const key = game.bracketMatchId ?? `${teamAIndex}:${teamBIndex}`;
|
||||
const current =
|
||||
bySeries.get(key) ??
|
||||
({
|
||||
bracketMatchId: game.bracketMatchId,
|
||||
teamAIndex,
|
||||
teamBIndex,
|
||||
teamAWins: 0,
|
||||
teamBWins: 0,
|
||||
} satisfies MatchSeriesResult);
|
||||
if (game.winnerTeamIndex === teamAIndex) current.teamAWins += 1;
|
||||
if (game.winnerTeamIndex === teamBIndex) current.teamBWins += 1;
|
||||
current.winnerTeamIndex =
|
||||
current.teamAWins > current.teamBWins
|
||||
? teamAIndex
|
||||
: current.teamBWins > current.teamAWins
|
||||
? teamBIndex
|
||||
: undefined;
|
||||
bySeries.set(key, current);
|
||||
}
|
||||
return [...bySeries.values()];
|
||||
}
|
||||
}
|
||||
@@ -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<TournamentCodeService, 'replaceForMatchGame'>
|
||||
>;
|
||||
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);
|
||||
});
|
||||
});
|
||||
@@ -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,
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
|
||||
@@ -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<DistributedLockService>;
|
||||
const scheduler = new TournamentCodeScheduler(
|
||||
tournamentCodeService as never,
|
||||
autoProvisionService as never,
|
||||
tournamentResultService as never,
|
||||
distributedLockService as never,
|
||||
) as unknown as { attachPending(): Promise<void> };
|
||||
) as unknown as {
|
||||
attachPending(): Promise<void>;
|
||||
markExpired(): Promise<void>;
|
||||
};
|
||||
|
||||
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,
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -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';
|
||||
}
|
||||
@@ -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<unknown>;
|
||||
attachPendingMatches(communityId?: mongoose.Types.ObjectId): Promise<number>;
|
||||
};
|
||||
|
||||
@@ -37,6 +33,21 @@ function createSession() {
|
||||
};
|
||||
}
|
||||
|
||||
function mongoQuery<T>(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<T>(value: T) {
|
||||
return { exec: jest.fn().mockResolvedValue(value) };
|
||||
}
|
||||
|
||||
function createCode(overrides: Record<string, unknown>) {
|
||||
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<string, unknown> | null;
|
||||
replacementCode?: Record<string, unknown> | 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();
|
||||
});
|
||||
});
|
||||
@@ -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<TournamentCodeSlotView> {
|
||||
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<TournamentCodeSlotView> {
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const TournamentCodeModel =
|
||||
await this.connectionService.getModel('tournamentCode');
|
||||
const match = await this.execQuery<MatchDocument | null>(
|
||||
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<TournamentCodeDocument | null>(
|
||||
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<void> {
|
||||
@@ -530,17 +371,153 @@ export class TournamentCodeService {
|
||||
await match.save({ session });
|
||||
}
|
||||
|
||||
public async markExpired(): Promise<number> {
|
||||
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<TournamentCodeExpirationResult> {
|
||||
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<string, mongoose.Types.ObjectId>();
|
||||
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<number>();
|
||||
const seededTeamIndexes = new Set<number>();
|
||||
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,
|
||||
|
||||
@@ -0,0 +1,281 @@
|
||||
/* eslint-disable @typescript-eslint/no-unsafe-assignment */
|
||||
import mongoose from 'mongoose';
|
||||
import type { CompetitionResultSnapshot } from './competition-result.adapter';
|
||||
import { CompetitionAssignmentProvisioner } from './competition-assignment.provisioner';
|
||||
|
||||
describe('CompetitionAssignmentProvisioner', () => {
|
||||
it('reserves an available code and creates the stable GameSlot assignment in one transaction', async () => {
|
||||
const harness = createHarness();
|
||||
const provisioner = new CompetitionAssignmentProvisioner(
|
||||
harness.connectionService as never,
|
||||
);
|
||||
|
||||
const result = await provisioner.provisionReadyAssignments({
|
||||
matchId: harness.matchId,
|
||||
competition: harness.competition,
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({
|
||||
requested: 1,
|
||||
reserved: 1,
|
||||
existing: 0,
|
||||
unavailable: 0,
|
||||
});
|
||||
expect(harness.competitionModel.updateOne).toHaveBeenCalledWith(
|
||||
{ _id: harness.competitionId, revision: 2 },
|
||||
{ $set: { revision: 2 } },
|
||||
{ session: harness.session, timestamps: false },
|
||||
);
|
||||
expect(harness.codeModel.findOneAndUpdate).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ state: 'available' }),
|
||||
{
|
||||
$set: expect.objectContaining({
|
||||
state: 'reserved',
|
||||
matchId: harness.matchId,
|
||||
gameNumber: 1,
|
||||
}),
|
||||
},
|
||||
expect.objectContaining({
|
||||
new: true,
|
||||
session: harness.session,
|
||||
sort: { expiresAt: 1 },
|
||||
}),
|
||||
);
|
||||
expect(harness.assignmentModel.insertMany).toHaveBeenCalledWith(
|
||||
[
|
||||
expect.objectContaining({
|
||||
competitionId: harness.competitionId,
|
||||
seriesId: harness.seriesId,
|
||||
gameSlotId: harness.gameSlotId,
|
||||
tournamentCodeId: harness.codeId,
|
||||
state: 'reserved',
|
||||
commandId: `provision-code:${harness.competitionId.toString()}:${harness.gameSlotId.toString()}:2:${harness.codeId.toString()}`,
|
||||
}),
|
||||
],
|
||||
{ session: harness.session },
|
||||
);
|
||||
expect(harness.matchModel.updateOne).toHaveBeenCalledWith(
|
||||
{ _id: harness.matchId },
|
||||
{ $addToSet: { tournamentCodeIds: harness.codeId } },
|
||||
{ session: harness.session },
|
||||
);
|
||||
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('converges after a unique-index race by rereading the active GameSlot assignment', async () => {
|
||||
const harness = createHarness({
|
||||
assignmentInsertError: duplicateKeyError(),
|
||||
});
|
||||
const activeAssignment = {
|
||||
competitionId: harness.competitionId,
|
||||
seriesId: harness.seriesId,
|
||||
gameSlotId: harness.gameSlotId,
|
||||
tournamentCodeId: harness.codeId,
|
||||
state: 'reserved',
|
||||
};
|
||||
harness.assignmentModel.findOne
|
||||
.mockReturnValueOnce(queryResult(null))
|
||||
.mockReturnValueOnce(queryResult(activeAssignment));
|
||||
const provisioner = new CompetitionAssignmentProvisioner(
|
||||
harness.connectionService as never,
|
||||
);
|
||||
|
||||
const result = await provisioner.provisionReadyAssignments({
|
||||
matchId: harness.matchId,
|
||||
competition: harness.competition,
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({ reserved: 0, existing: 1, unavailable: 0 });
|
||||
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.session.endSession).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('releases a reserved code when an early Series outcome makes its GameSlot inactive', async () => {
|
||||
const harness = createHarness();
|
||||
harness.competition.projection.gameSlots[0].status = 'inactive';
|
||||
const assignmentId = new mongoose.Types.ObjectId();
|
||||
harness.assignmentModel.find.mockReturnValue(
|
||||
queryResult([
|
||||
{
|
||||
_id: assignmentId,
|
||||
competitionId: harness.competitionId,
|
||||
seriesId: harness.seriesId,
|
||||
gameSlotId: harness.gameSlotId,
|
||||
tournamentCodeId: harness.codeId,
|
||||
state: 'reserved',
|
||||
},
|
||||
]),
|
||||
);
|
||||
harness.assignmentModel.findOneAndUpdate.mockReturnValue(
|
||||
queryResult({ _id: assignmentId, state: 'released' }),
|
||||
);
|
||||
const provisioner = new CompetitionAssignmentProvisioner(
|
||||
harness.connectionService as never,
|
||||
);
|
||||
|
||||
const result = await provisioner.provisionReadyAssignments({
|
||||
matchId: harness.matchId,
|
||||
competition: harness.competition,
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({ requested: 0, released: 1 });
|
||||
expect(harness.assignmentModel.findOneAndUpdate).toHaveBeenCalledWith(
|
||||
{ _id: assignmentId, state: 'reserved' },
|
||||
{ $set: expect.objectContaining({ state: 'released' }) },
|
||||
{ new: true, session: harness.session },
|
||||
);
|
||||
expect(harness.codeModel.findOneAndUpdate).toHaveBeenCalledWith(
|
||||
{ _id: harness.codeId, state: 'reserved' },
|
||||
expect.objectContaining({
|
||||
$set: expect.objectContaining({ state: 'released' }),
|
||||
}),
|
||||
{ new: true, session: harness.session },
|
||||
);
|
||||
expect(harness.matchModel.updateOne).toHaveBeenCalledWith(
|
||||
{ _id: harness.matchId },
|
||||
{ $pull: { tournamentCodeIds: harness.codeId } },
|
||||
{ session: harness.session },
|
||||
);
|
||||
});
|
||||
|
||||
it('refuses to reserve without a MongoDB transaction', async () => {
|
||||
const harness = createHarness();
|
||||
harness.connectionService.createSession.mockResolvedValue(undefined);
|
||||
const provisioner = new CompetitionAssignmentProvisioner(
|
||||
harness.connectionService as never,
|
||||
);
|
||||
|
||||
await expect(
|
||||
provisioner.provisionReadyAssignments({
|
||||
matchId: harness.matchId,
|
||||
competition: harness.competition,
|
||||
}),
|
||||
).rejects.toMatchObject({
|
||||
code: 'COMPETITION_ASSIGNMENT_TRANSACTION_UNAVAILABLE',
|
||||
});
|
||||
expect(harness.codeModel.findOneAndUpdate).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('rejects a stale projection revision before reserving a code', async () => {
|
||||
const harness = createHarness();
|
||||
harness.competitionModel.updateOne.mockResolvedValue({ matchedCount: 0 });
|
||||
const provisioner = new CompetitionAssignmentProvisioner(
|
||||
harness.connectionService as never,
|
||||
);
|
||||
|
||||
await expect(
|
||||
provisioner.provisionReadyAssignments({
|
||||
matchId: harness.matchId,
|
||||
competition: harness.competition,
|
||||
}),
|
||||
).rejects.toMatchObject({
|
||||
code: 'COMPETITION_ASSIGNMENT_STALE_REVISION',
|
||||
});
|
||||
expect(harness.codeModel.findOneAndUpdate).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
function createHarness(options: { assignmentInsertError?: Error } = {}) {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const competitionId = new mongoose.Types.ObjectId();
|
||||
const seriesId = new mongoose.Types.ObjectId();
|
||||
const gameSlotId = new mongoose.Types.ObjectId();
|
||||
const codeId = new mongoose.Types.ObjectId();
|
||||
const competition: CompetitionResultSnapshot = {
|
||||
competitionId: competitionId.toString(),
|
||||
revision: 2,
|
||||
phase: 'running',
|
||||
teams: [],
|
||||
projection: {
|
||||
phase: 'running',
|
||||
series: [],
|
||||
games: [],
|
||||
gameSlots: [
|
||||
{
|
||||
id: gameSlotId.toString(),
|
||||
seriesId: seriesId.toString(),
|
||||
ordinal: 1,
|
||||
displayNumber: 1,
|
||||
status: 'ready',
|
||||
},
|
||||
],
|
||||
},
|
||||
};
|
||||
const session = {
|
||||
startTransaction: jest.fn(),
|
||||
commitTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
abortTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
endSession: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const assignmentModel = {
|
||||
find: jest.fn().mockReturnValue(queryResult([])),
|
||||
findOne: jest.fn().mockReturnValue(queryResult(null)),
|
||||
findOneAndUpdate: jest.fn().mockReturnValue(queryResult(null)),
|
||||
insertMany: options.assignmentInsertError
|
||||
? jest.fn().mockRejectedValue(options.assignmentInsertError)
|
||||
: jest.fn().mockResolvedValue([]),
|
||||
};
|
||||
const code = {
|
||||
_id: codeId,
|
||||
state: 'reserved',
|
||||
reservedAt: new Date('2026-07-12T10:00:00.000Z'),
|
||||
};
|
||||
const codeModel = {
|
||||
find: jest.fn().mockReturnValue(queryResult([])),
|
||||
findOneAndUpdate: jest.fn().mockReturnValue(queryResult(code)),
|
||||
};
|
||||
const matchModel = {
|
||||
updateOne: jest.fn().mockReturnValue(execResult(undefined)),
|
||||
};
|
||||
const competitionModel = {
|
||||
findOne: jest.fn().mockReturnValue(queryResult({ _id: competitionId })),
|
||||
updateOne: jest.fn().mockResolvedValue({ matchedCount: 1 }),
|
||||
};
|
||||
const models: Record<string, unknown> = {
|
||||
tournamentCodeAssignment: assignmentModel,
|
||||
tournamentCode: codeModel,
|
||||
match: matchModel,
|
||||
competition: competitionModel,
|
||||
};
|
||||
const connectionService = {
|
||||
createSession: jest.fn().mockResolvedValue(session),
|
||||
getModel: jest
|
||||
.fn()
|
||||
.mockImplementation((name: string) => Promise.resolve(models[name])),
|
||||
};
|
||||
return {
|
||||
connectionService,
|
||||
session,
|
||||
assignmentModel,
|
||||
codeModel,
|
||||
matchModel,
|
||||
competitionModel,
|
||||
matchId,
|
||||
competitionId,
|
||||
seriesId,
|
||||
gameSlotId,
|
||||
codeId,
|
||||
competition,
|
||||
};
|
||||
}
|
||||
|
||||
function queryResult<T>(value: T) {
|
||||
const query = {
|
||||
sort: jest.fn(),
|
||||
session: jest.fn(),
|
||||
lean: jest.fn(),
|
||||
exec: jest.fn().mockResolvedValue(value),
|
||||
};
|
||||
query.sort.mockReturnValue(query);
|
||||
query.session.mockReturnValue(query);
|
||||
query.lean.mockReturnValue(query);
|
||||
return query;
|
||||
}
|
||||
|
||||
function execResult<T>(value: T) {
|
||||
return { exec: jest.fn().mockResolvedValue(value) };
|
||||
}
|
||||
|
||||
function duplicateKeyError(): Error & { code: number } {
|
||||
return Object.assign(new Error('E11000 duplicate key'), { code: 11000 });
|
||||
}
|
||||
@@ -0,0 +1,471 @@
|
||||
import { Injectable } from '@nestjs/common';
|
||||
import { createHash } from 'node:crypto';
|
||||
import mongoose from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import { TOURNAMENT_CODE_EXPIRY_MARGIN_MS } from '../tournament-code/tournament-code.constants';
|
||||
import type {
|
||||
CompetitionResultGameSlotProjection,
|
||||
CompetitionResultSnapshot,
|
||||
} from './competition-result.adapter';
|
||||
|
||||
const PROVISION_ATTEMPTS = 3;
|
||||
const ACTIVE_ASSIGNMENT_STATES = ['reserved', 'used'] as const;
|
||||
|
||||
export type CompetitionAssignmentProvisionErrorCode =
|
||||
| 'COMPETITION_ASSIGNMENT_TRANSACTION_UNAVAILABLE'
|
||||
| 'COMPETITION_ASSIGNMENT_STALE_REVISION'
|
||||
| 'COMPETITION_ASSIGNMENT_PROVISION_FAILED';
|
||||
|
||||
export class CompetitionAssignmentProvisionError extends Error {
|
||||
constructor(
|
||||
public readonly code: CompetitionAssignmentProvisionErrorCode,
|
||||
message: string,
|
||||
public readonly cause?: unknown,
|
||||
) {
|
||||
super(message);
|
||||
this.name = 'CompetitionAssignmentProvisionError';
|
||||
}
|
||||
}
|
||||
|
||||
export interface CompetitionAssignmentProvisionResult {
|
||||
requested: number;
|
||||
reserved: number;
|
||||
existing: number;
|
||||
unavailable: number;
|
||||
released: number;
|
||||
}
|
||||
|
||||
type ReservationOutcome = 'reserved' | 'existing' | 'unavailable';
|
||||
|
||||
interface AssignmentRecord {
|
||||
_id: mongoose.Types.ObjectId;
|
||||
competitionId: mongoose.Types.ObjectId;
|
||||
seriesId: mongoose.Types.ObjectId;
|
||||
gameSlotId: mongoose.Types.ObjectId;
|
||||
tournamentCodeId: mongoose.Types.ObjectId;
|
||||
state: 'reserved' | 'used' | 'released' | 'voided';
|
||||
}
|
||||
|
||||
interface CodeRecord {
|
||||
_id: mongoose.Types.ObjectId;
|
||||
state: string;
|
||||
reservedAt?: Date;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class CompetitionAssignmentProvisioner {
|
||||
constructor(private readonly connectionService: ConnectionService) {}
|
||||
|
||||
public async provisionReadyAssignments(params: {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
competition: CompetitionResultSnapshot;
|
||||
}): Promise<CompetitionAssignmentProvisionResult> {
|
||||
const targets = uniqueReadyTargets(params.competition);
|
||||
const released = await this.releaseInactiveAssignments({
|
||||
...params,
|
||||
readyGameSlotIds: new Set(targets.map(({ id }) => id)),
|
||||
});
|
||||
const result: CompetitionAssignmentProvisionResult = {
|
||||
requested: targets.length,
|
||||
reserved: 0,
|
||||
existing: 0,
|
||||
unavailable: 0,
|
||||
released,
|
||||
};
|
||||
|
||||
for (const target of targets) {
|
||||
const outcome = await this.reserveTarget({ ...params, target });
|
||||
result[outcome] += 1;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private async releaseInactiveAssignments(params: {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
competition: CompetitionResultSnapshot;
|
||||
readyGameSlotIds: ReadonlySet<string>;
|
||||
}): Promise<number> {
|
||||
const competitionId = objectId(
|
||||
params.competition.competitionId,
|
||||
'Competition',
|
||||
);
|
||||
const [AssignmentModel, TournamentCodeModel, MatchModel, CompetitionModel] =
|
||||
await Promise.all([
|
||||
this.connectionService.getModel('tournamentCodeAssignment'),
|
||||
this.connectionService.getModel('tournamentCode'),
|
||||
this.connectionService.getModel('match'),
|
||||
this.connectionService.getModel('competition'),
|
||||
]);
|
||||
const reserved = (await AssignmentModel.find({
|
||||
competitionId,
|
||||
state: 'reserved',
|
||||
gameSlotId: {
|
||||
$nin: [...params.readyGameSlotIds].map((id) =>
|
||||
objectId(id, 'GameSlot'),
|
||||
),
|
||||
},
|
||||
})
|
||||
.sort({ reservedAt: 1, _id: 1 })
|
||||
.lean()
|
||||
.exec()) as AssignmentRecord[];
|
||||
|
||||
let released = 0;
|
||||
for (const assignment of reserved) {
|
||||
const didRelease = await this.releaseAssignment({
|
||||
matchId: params.matchId,
|
||||
assignment,
|
||||
AssignmentModel,
|
||||
TournamentCodeModel,
|
||||
MatchModel,
|
||||
CompetitionModel,
|
||||
competitionId,
|
||||
expectedRevision: params.competition.revision,
|
||||
});
|
||||
if (didRelease) released += 1;
|
||||
}
|
||||
return released;
|
||||
}
|
||||
|
||||
private async releaseAssignment(params: {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
assignment: AssignmentRecord;
|
||||
AssignmentModel: mongoose.Model<any>;
|
||||
TournamentCodeModel: mongoose.Model<any>;
|
||||
MatchModel: mongoose.Model<any>;
|
||||
CompetitionModel: mongoose.Model<any>;
|
||||
competitionId: mongoose.Types.ObjectId;
|
||||
expectedRevision: number;
|
||||
}): Promise<boolean> {
|
||||
for (let attempt = 1; attempt <= PROVISION_ATTEMPTS; attempt += 1) {
|
||||
const session = await this.connectionService.createSession();
|
||||
if (!session) {
|
||||
throw new CompetitionAssignmentProvisionError(
|
||||
'COMPETITION_ASSIGNMENT_TRANSACTION_UNAVAILABLE',
|
||||
'A MongoDB transaction is required to release Competition GameSlot codes.',
|
||||
);
|
||||
}
|
||||
try {
|
||||
session.startTransaction();
|
||||
await assertCurrentRevision({
|
||||
CompetitionModel: params.CompetitionModel,
|
||||
competitionId: params.competitionId,
|
||||
expectedRevision: params.expectedRevision,
|
||||
session,
|
||||
});
|
||||
const releasedAt = new Date();
|
||||
const assignment = (await params.AssignmentModel.findOneAndUpdate(
|
||||
{ _id: params.assignment._id, state: 'reserved' },
|
||||
{ $set: { state: 'released', releasedAt } },
|
||||
{ new: true, session },
|
||||
).exec()) as AssignmentRecord | null;
|
||||
if (!assignment) {
|
||||
await session.commitTransaction();
|
||||
return false;
|
||||
}
|
||||
const code = (await params.TournamentCodeModel.findOneAndUpdate(
|
||||
{ _id: params.assignment.tournamentCodeId, state: 'reserved' },
|
||||
{
|
||||
$set: { state: 'released', releasedAt },
|
||||
$unset: {
|
||||
matchId: 1,
|
||||
gameNumber: 1,
|
||||
bracketMatchId: 1,
|
||||
reservedAt: 1,
|
||||
},
|
||||
},
|
||||
{ new: true, session },
|
||||
).exec()) as CodeRecord | null;
|
||||
if (!code) {
|
||||
throw new Error(
|
||||
'Reserved assignment points to a Tournament Code that is not reserved.',
|
||||
);
|
||||
}
|
||||
await params.MatchModel.updateOne(
|
||||
{ _id: params.matchId },
|
||||
{ $pull: { tournamentCodeIds: params.assignment.tournamentCodeId } },
|
||||
{ session },
|
||||
).exec();
|
||||
await session.commitTransaction();
|
||||
return true;
|
||||
} catch (error) {
|
||||
await session.abortTransaction().catch(() => undefined);
|
||||
if (isStaleRevisionError(error)) throw error;
|
||||
const current = (await params.AssignmentModel.findById(
|
||||
params.assignment._id,
|
||||
)
|
||||
.lean()
|
||||
.exec()) as AssignmentRecord | null;
|
||||
if (current && current.state !== 'reserved') return false;
|
||||
if (attempt < PROVISION_ATTEMPTS && isRetryable(error)) continue;
|
||||
throw new CompetitionAssignmentProvisionError(
|
||||
'COMPETITION_ASSIGNMENT_PROVISION_FAILED',
|
||||
`Failed to release Tournament Code assignment ${params.assignment._id.toString()}.`,
|
||||
error,
|
||||
);
|
||||
} finally {
|
||||
await session.endSession().catch(() => undefined);
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private async reserveTarget(params: {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
competition: CompetitionResultSnapshot;
|
||||
target: CompetitionResultGameSlotProjection;
|
||||
}): Promise<ReservationOutcome> {
|
||||
const competitionId = objectId(
|
||||
params.competition.competitionId,
|
||||
'Competition',
|
||||
);
|
||||
const seriesId = objectId(params.target.seriesId, 'Series');
|
||||
const gameSlotId = objectId(params.target.id, 'GameSlot');
|
||||
const [AssignmentModel, TournamentCodeModel, MatchModel, CompetitionModel] =
|
||||
await Promise.all([
|
||||
this.connectionService.getModel('tournamentCodeAssignment'),
|
||||
this.connectionService.getModel('tournamentCode'),
|
||||
this.connectionService.getModel('match'),
|
||||
this.connectionService.getModel('competition'),
|
||||
]);
|
||||
|
||||
for (let attempt = 1; attempt <= PROVISION_ATTEMPTS; attempt += 1) {
|
||||
const session = await this.connectionService.createSession();
|
||||
if (!session) {
|
||||
throw new CompetitionAssignmentProvisionError(
|
||||
'COMPETITION_ASSIGNMENT_TRANSACTION_UNAVAILABLE',
|
||||
'A MongoDB transaction is required to reserve Competition GameSlot codes.',
|
||||
);
|
||||
}
|
||||
|
||||
try {
|
||||
session.startTransaction();
|
||||
await assertCurrentRevision({
|
||||
CompetitionModel,
|
||||
competitionId,
|
||||
expectedRevision: params.competition.revision,
|
||||
session,
|
||||
});
|
||||
const existing = (await AssignmentModel.findOne({
|
||||
competitionId,
|
||||
gameSlotId,
|
||||
state: { $in: ACTIVE_ASSIGNMENT_STATES },
|
||||
})
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec()) as AssignmentRecord | null;
|
||||
if (existing) {
|
||||
await session.commitTransaction();
|
||||
return 'existing';
|
||||
}
|
||||
|
||||
const code = await this.claimCode({
|
||||
matchId: params.matchId,
|
||||
competitionId,
|
||||
displayNumber: params.target.displayNumber,
|
||||
AssignmentModel,
|
||||
TournamentCodeModel,
|
||||
session,
|
||||
});
|
||||
if (!code) {
|
||||
await session.commitTransaction();
|
||||
return 'unavailable';
|
||||
}
|
||||
|
||||
const commandId = `provision-code:${params.competition.competitionId}:${params.target.id}:${params.competition.revision}:${code._id.toString()}`;
|
||||
await AssignmentModel.insertMany(
|
||||
[
|
||||
{
|
||||
_id: deterministicObjectId(commandId),
|
||||
competitionId,
|
||||
seriesId,
|
||||
gameSlotId,
|
||||
tournamentCodeId: code._id,
|
||||
state: 'reserved',
|
||||
reservedAt: code.reservedAt ?? new Date(),
|
||||
commandId,
|
||||
},
|
||||
],
|
||||
{ session },
|
||||
);
|
||||
await MatchModel.updateOne(
|
||||
{ _id: params.matchId },
|
||||
{ $addToSet: { tournamentCodeIds: code._id } },
|
||||
{ session },
|
||||
).exec();
|
||||
await session.commitTransaction();
|
||||
return 'reserved';
|
||||
} catch (error) {
|
||||
await session.abortTransaction().catch(() => undefined);
|
||||
if (isStaleRevisionError(error)) throw error;
|
||||
const converged = await this.findActiveAssignment(
|
||||
AssignmentModel,
|
||||
competitionId,
|
||||
gameSlotId,
|
||||
);
|
||||
if (converged) return 'existing';
|
||||
if (attempt < PROVISION_ATTEMPTS && isRetryable(error)) continue;
|
||||
throw new CompetitionAssignmentProvisionError(
|
||||
'COMPETITION_ASSIGNMENT_PROVISION_FAILED',
|
||||
`Failed to reserve a Tournament Code for GameSlot ${params.target.id}.`,
|
||||
error,
|
||||
);
|
||||
} finally {
|
||||
await session.endSession().catch(() => undefined);
|
||||
}
|
||||
}
|
||||
|
||||
throw new CompetitionAssignmentProvisionError(
|
||||
'COMPETITION_ASSIGNMENT_PROVISION_FAILED',
|
||||
`Reservation retry budget was exhausted for GameSlot ${params.target.id}.`,
|
||||
);
|
||||
}
|
||||
|
||||
private async claimCode(params: {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
competitionId: mongoose.Types.ObjectId;
|
||||
displayNumber: number;
|
||||
AssignmentModel: mongoose.Model<any>;
|
||||
TournamentCodeModel: mongoose.Model<any>;
|
||||
session: mongoose.ClientSession;
|
||||
}): Promise<CodeRecord | null> {
|
||||
const legacyCandidates = (await params.TournamentCodeModel.find({
|
||||
matchId: params.matchId,
|
||||
state: 'reserved',
|
||||
gameNumber: params.displayNumber,
|
||||
})
|
||||
.sort({ reservedAt: 1, _id: 1 })
|
||||
.session(params.session)
|
||||
.exec()) as CodeRecord[];
|
||||
|
||||
for (const candidate of legacyCandidates) {
|
||||
const assigned = (await params.AssignmentModel.findOne({
|
||||
tournamentCodeId: candidate._id,
|
||||
state: { $in: ACTIVE_ASSIGNMENT_STATES },
|
||||
})
|
||||
.session(params.session)
|
||||
.lean()
|
||||
.exec()) as AssignmentRecord | null;
|
||||
if (assigned) continue;
|
||||
const promoted = (await params.TournamentCodeModel.findOneAndUpdate(
|
||||
{
|
||||
_id: candidate._id,
|
||||
matchId: params.matchId,
|
||||
state: 'reserved',
|
||||
gameNumber: params.displayNumber,
|
||||
},
|
||||
{ $set: { gameNumber: params.displayNumber } },
|
||||
{ new: true, session: params.session },
|
||||
).exec()) as CodeRecord | null;
|
||||
if (promoted) return promoted;
|
||||
}
|
||||
|
||||
return (await params.TournamentCodeModel.findOneAndUpdate(
|
||||
{
|
||||
state: 'available',
|
||||
region: 'kr',
|
||||
mapType: 'SUMMONERS_RIFT',
|
||||
teamSize: 5,
|
||||
expiresAt: {
|
||||
$gt: new Date(Date.now() + TOURNAMENT_CODE_EXPIRY_MARGIN_MS),
|
||||
},
|
||||
},
|
||||
{
|
||||
$set: {
|
||||
state: 'reserved',
|
||||
matchId: params.matchId,
|
||||
gameNumber: params.displayNumber,
|
||||
reservedAt: new Date(),
|
||||
},
|
||||
},
|
||||
{ new: true, session: params.session, sort: { expiresAt: 1 } },
|
||||
).exec()) as CodeRecord | null;
|
||||
}
|
||||
|
||||
private async findActiveAssignment(
|
||||
AssignmentModel: mongoose.Model<any>,
|
||||
competitionId: mongoose.Types.ObjectId,
|
||||
gameSlotId: mongoose.Types.ObjectId,
|
||||
): Promise<AssignmentRecord | null> {
|
||||
return (await AssignmentModel.findOne({
|
||||
competitionId,
|
||||
gameSlotId,
|
||||
state: { $in: ACTIVE_ASSIGNMENT_STATES },
|
||||
})
|
||||
.lean()
|
||||
.exec()) as AssignmentRecord | null;
|
||||
}
|
||||
}
|
||||
|
||||
function uniqueReadyTargets(
|
||||
competition: CompetitionResultSnapshot,
|
||||
): CompetitionResultGameSlotProjection[] {
|
||||
const byId = new Map<string, CompetitionResultGameSlotProjection>();
|
||||
for (const slot of competition.projection.gameSlots) {
|
||||
if (slot.status === 'ready') byId.set(slot.id, slot);
|
||||
}
|
||||
return [...byId.values()].sort(
|
||||
(left, right) =>
|
||||
left.displayNumber - right.displayNumber || left.ordinal - right.ordinal,
|
||||
);
|
||||
}
|
||||
|
||||
function objectId(value: string, label: string): mongoose.Types.ObjectId {
|
||||
if (!mongoose.Types.ObjectId.isValid(value)) {
|
||||
throw new CompetitionAssignmentProvisionError(
|
||||
'COMPETITION_ASSIGNMENT_PROVISION_FAILED',
|
||||
`${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),
|
||||
);
|
||||
}
|
||||
|
||||
async function assertCurrentRevision(params: {
|
||||
CompetitionModel: mongoose.Model<any>;
|
||||
competitionId: mongoose.Types.ObjectId;
|
||||
expectedRevision: number;
|
||||
session: mongoose.ClientSession;
|
||||
}): Promise<void> {
|
||||
const current = await params.CompetitionModel.updateOne(
|
||||
{
|
||||
_id: params.competitionId,
|
||||
revision: params.expectedRevision,
|
||||
},
|
||||
{ $set: { revision: params.expectedRevision } },
|
||||
{ session: params.session, timestamps: false },
|
||||
);
|
||||
if (current.matchedCount === 1) return;
|
||||
throw new CompetitionAssignmentProvisionError(
|
||||
'COMPETITION_ASSIGNMENT_STALE_REVISION',
|
||||
'Competition changed before Tournament Code assignments were reconciled.',
|
||||
);
|
||||
}
|
||||
|
||||
function isStaleRevisionError(
|
||||
error: unknown,
|
||||
): error is CompetitionAssignmentProvisionError {
|
||||
return (
|
||||
error instanceof CompetitionAssignmentProvisionError &&
|
||||
error.code === 'COMPETITION_ASSIGNMENT_STALE_REVISION'
|
||||
);
|
||||
}
|
||||
|
||||
function isRetryable(error: unknown): boolean {
|
||||
const candidate = error as {
|
||||
code?: number;
|
||||
codeName?: string;
|
||||
hasErrorLabel?: (label: string) => boolean;
|
||||
};
|
||||
return Boolean(
|
||||
candidate?.code === 11000 ||
|
||||
candidate?.code === 112 ||
|
||||
candidate?.codeName === 'WriteConflict' ||
|
||||
candidate?.hasErrorLabel?.('TransientTransactionError') ||
|
||||
candidate?.hasErrorLabel?.('UnknownTransactionCommitResult'),
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,232 @@
|
||||
/* 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';
|
||||
import { CompetitionAssignmentProvisioner } from './competition-assignment.provisioner';
|
||||
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();
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const eventId = new mongoose.Types.ObjectId();
|
||||
const event = {
|
||||
_id: eventId,
|
||||
competitionId,
|
||||
revision: 7,
|
||||
type: 'competition.projection-updated',
|
||||
state: 'pending',
|
||||
attemptCount: 1,
|
||||
};
|
||||
const publish = jest.fn(() => executable({ matchedCount: 1 }));
|
||||
const claim = jest
|
||||
.fn()
|
||||
.mockReturnValueOnce(leanExecutable(event))
|
||||
.mockReturnValueOnce(leanExecutable(null));
|
||||
const matchUpdate = jest.fn(() => executable({ matchedCount: 1 }));
|
||||
const models = {
|
||||
competitionOutbox: {
|
||||
findOneAndUpdate: claim,
|
||||
updateOne: publish,
|
||||
},
|
||||
competition: {
|
||||
findById: jest.fn(() =>
|
||||
leanExecutable({
|
||||
_id: competitionId,
|
||||
matchId,
|
||||
communityId,
|
||||
revision: 8,
|
||||
phase: 'completed',
|
||||
teams: [],
|
||||
projection: {
|
||||
phase: 'completed',
|
||||
series: [],
|
||||
gameSlots: [],
|
||||
games: [{ evidence: { type: 'riot', riotMatchId: 'KR_1' } }],
|
||||
},
|
||||
}),
|
||||
),
|
||||
},
|
||||
match: {
|
||||
findById: jest.fn(() =>
|
||||
leanExecutable({ status: 'in-progress', resultPollState: {} }),
|
||||
),
|
||||
updateOne: matchUpdate,
|
||||
},
|
||||
};
|
||||
const connection = {
|
||||
getModel: jest.fn((name: keyof typeof models) =>
|
||||
Promise.resolve(models[name]),
|
||||
),
|
||||
} as unknown as ConnectionService;
|
||||
const provisionReadyAssignments = jest.fn().mockResolvedValue({});
|
||||
const provisioner = {
|
||||
provisionReadyAssignments,
|
||||
} as unknown as jest.Mocked<CompetitionAssignmentProvisioner>;
|
||||
const buildAndUpsert = jest.fn().mockResolvedValue(undefined);
|
||||
const stats = {
|
||||
buildAndUpsert,
|
||||
} as unknown as jest.Mocked<MatchStatsService>;
|
||||
const invalidateCommunity = jest.fn().mockResolvedValue(undefined);
|
||||
const communityStats = {
|
||||
invalidateCommunity,
|
||||
} as unknown as jest.Mocked<CommunityStatsService>;
|
||||
const processor = new CompetitionOutboxProcessor(
|
||||
connection,
|
||||
provisioner,
|
||||
stats,
|
||||
communityStats,
|
||||
);
|
||||
|
||||
await expect(processor.drainOnce()).resolves.toBe(1);
|
||||
|
||||
expect(provisionReadyAssignments).toHaveBeenCalledWith({
|
||||
matchId,
|
||||
competition: expect.objectContaining({
|
||||
competitionId: competitionId.toString(),
|
||||
revision: 8,
|
||||
}),
|
||||
});
|
||||
expect(matchUpdate).toHaveBeenCalledWith(
|
||||
{ _id: matchId },
|
||||
{
|
||||
$set: expect.objectContaining({
|
||||
status: 'finished',
|
||||
'resultPollState.matchedCount': 1,
|
||||
'resultPollState.state': 'complete',
|
||||
}),
|
||||
},
|
||||
);
|
||||
expect(buildAndUpsert).toHaveBeenCalledWith(matchId, {
|
||||
sourceRevision: 8,
|
||||
});
|
||||
expect(invalidateCommunity).toHaveBeenCalledWith(communityId);
|
||||
expect(publish).toHaveBeenCalledWith(
|
||||
{ _id: eventId, state: 'pending', attemptCount: 1 },
|
||||
expect.objectContaining({
|
||||
$set: expect.objectContaining({ state: 'published' }),
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('marks a leased event failed and retryable when effects cannot run', async () => {
|
||||
const event = {
|
||||
_id: new mongoose.Types.ObjectId(),
|
||||
competitionId: new mongoose.Types.ObjectId(),
|
||||
revision: 2,
|
||||
type: 'competition.projection-updated',
|
||||
state: 'pending',
|
||||
attemptCount: 3,
|
||||
};
|
||||
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 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: 3 },
|
||||
{
|
||||
$set: expect.objectContaining({
|
||||
state: 'failed',
|
||||
lastError: 'Competition no longer exists.',
|
||||
availableAt: expect.any(Date),
|
||||
}),
|
||||
},
|
||||
);
|
||||
});
|
||||
|
||||
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<T>(value: T) {
|
||||
const query = {
|
||||
lean: jest.fn(),
|
||||
exec: jest.fn().mockResolvedValue(value),
|
||||
};
|
||||
query.lean.mockReturnValue(query);
|
||||
return query;
|
||||
}
|
||||
|
||||
function executable<T>(value: T) {
|
||||
return { exec: jest.fn().mockResolvedValue(value) };
|
||||
}
|
||||
@@ -0,0 +1,333 @@
|
||||
import {
|
||||
Injectable,
|
||||
Logger,
|
||||
OnModuleDestroy,
|
||||
OnModuleInit,
|
||||
} from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import { CommunityStatsService } from '../community-stats/community-stats.service';
|
||||
import { MatchStatsService } from '../community-stats/match-stats.service';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import { CompetitionAssignmentProvisioner } from './competition-assignment.provisioner';
|
||||
import type { CompetitionResultSnapshot } from './competition-result.adapter';
|
||||
|
||||
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;
|
||||
competitionId: mongoose.Types.ObjectId;
|
||||
revision: number;
|
||||
type: string;
|
||||
state: 'pending' | 'failed';
|
||||
attemptCount: number;
|
||||
}
|
||||
|
||||
interface CompetitionEffectDocument {
|
||||
_id: mongoose.Types.ObjectId;
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
revision: number;
|
||||
phase: string;
|
||||
teams: unknown[];
|
||||
projection: Record<string, unknown>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Delivers durable Competition projection effects. The Mongo outbox lease is
|
||||
* the retry boundary; every downstream effect is intentionally idempotent so
|
||||
* an expired lease can be processed safely by another API instance.
|
||||
*/
|
||||
@Injectable()
|
||||
export class CompetitionOutboxProcessor
|
||||
implements OnModuleInit, OnModuleDestroy
|
||||
{
|
||||
private readonly logger = new Logger(CompetitionOutboxProcessor.name);
|
||||
private timer?: NodeJS.Timeout;
|
||||
private draining = false;
|
||||
|
||||
constructor(
|
||||
private readonly connectionService: ConnectionService,
|
||||
private readonly assignmentProvisioner: CompetitionAssignmentProvisioner,
|
||||
private readonly matchStatsService: MatchStatsService,
|
||||
private readonly communityStatsService: CommunityStatsService,
|
||||
) {}
|
||||
|
||||
public onModuleInit(): void {
|
||||
this.timer = setInterval(() => void this.drainSafely(), DRAIN_INTERVAL_MS);
|
||||
this.timer.unref?.();
|
||||
void this.drainSafely();
|
||||
}
|
||||
|
||||
public onModuleDestroy(): void {
|
||||
if (this.timer) clearInterval(this.timer);
|
||||
}
|
||||
|
||||
public async drainOnce(limit = MAX_EVENTS_PER_DRAIN): Promise<number> {
|
||||
if (!Number.isInteger(limit) || limit < 1) return 0;
|
||||
let processed = 0;
|
||||
while (processed < limit) {
|
||||
const event = await this.claimNextEvent();
|
||||
if (!event) break;
|
||||
await this.deliver(event);
|
||||
processed += 1;
|
||||
}
|
||||
return processed;
|
||||
}
|
||||
|
||||
private async drainSafely(): Promise<void> {
|
||||
if (this.draining) return;
|
||||
this.draining = true;
|
||||
try {
|
||||
await this.drainOnce();
|
||||
} catch (error) {
|
||||
this.logger.warn(
|
||||
`Competition outbox drain failed: ${errorMessage(error)}`,
|
||||
);
|
||||
} finally {
|
||||
this.draining = false;
|
||||
}
|
||||
}
|
||||
|
||||
private async claimNextEvent(): Promise<ClaimedOutboxEvent | null> {
|
||||
const OutboxModel =
|
||||
await this.connectionService.getModel('competitionOutbox');
|
||||
const now = new Date();
|
||||
return OutboxModel.findOneAndUpdate(
|
||||
{
|
||||
state: { $in: ['pending', 'failed'] },
|
||||
availableAt: { $lte: now },
|
||||
},
|
||||
{
|
||||
$set: {
|
||||
state: 'pending',
|
||||
availableAt: new Date(now.getTime() + PROCESSING_LEASE_MS),
|
||||
},
|
||||
$inc: { attemptCount: 1 },
|
||||
$unset: { lastError: 1 },
|
||||
},
|
||||
{
|
||||
new: true,
|
||||
sort: { availableAt: 1, revision: 1, _id: 1 },
|
||||
},
|
||||
)
|
||||
.lean()
|
||||
.exec() as Promise<ClaimedOutboxEvent | null>;
|
||||
}
|
||||
|
||||
private async deliver(event: ClaimedOutboxEvent): Promise<void> {
|
||||
const OutboxModel =
|
||||
await this.connectionService.getModel('competitionOutbox');
|
||||
try {
|
||||
if (event.type !== 'competition.projection-updated') {
|
||||
throw new Error(`Unsupported Competition outbox type ${event.type}.`);
|
||||
}
|
||||
await this.applyProjectionEffects(event);
|
||||
await OutboxModel.updateOne(leaseFilter(event), {
|
||||
$set: { state: 'published', publishedAt: new Date() },
|
||||
$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,
|
||||
availableAt,
|
||||
},
|
||||
}).exec();
|
||||
this.logger.warn(
|
||||
`Competition outbox event ${event._id.toString()} failed: ${lastError}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
private async applyProjectionEffects(
|
||||
event: ClaimedOutboxEvent,
|
||||
): Promise<void> {
|
||||
const [CompetitionModel, MatchModel] = await Promise.all([
|
||||
this.connectionService.getModel('competition'),
|
||||
this.connectionService.getModel('match'),
|
||||
]);
|
||||
const competition = (await CompetitionModel.findById(event.competitionId)
|
||||
.lean()
|
||||
.exec()) as CompetitionEffectDocument | null;
|
||||
if (!competition) throw new Error('Competition no longer exists.');
|
||||
if (competition.revision < event.revision) {
|
||||
throw new Error(
|
||||
`Competition revision ${competition.revision} is behind outbox revision ${event.revision}.`,
|
||||
);
|
||||
}
|
||||
|
||||
const snapshot = toResultSnapshot(competition);
|
||||
await this.assignmentProvisioner.provisionReadyAssignments({
|
||||
matchId: competition.matchId,
|
||||
competition: snapshot,
|
||||
});
|
||||
|
||||
const match = await MatchModel.findById(competition.matchId).lean().exec();
|
||||
if (!match) throw new Error('Competition Match no longer exists.');
|
||||
const phase = projectionPhase(competition.projection);
|
||||
const gameCount = projectionGames(competition.projection).length;
|
||||
const status =
|
||||
phase === 'completed'
|
||||
? 'finished'
|
||||
: gameCount > 0 || match.status === 'finished'
|
||||
? 'in-progress'
|
||||
: match.status;
|
||||
const set: Record<string, unknown> = { status };
|
||||
if (match.resultPollState) {
|
||||
set['resultPollState.matchedCount'] = gameCount;
|
||||
set['resultPollState.state'] =
|
||||
phase === 'completed' ? 'complete' : 'polling';
|
||||
}
|
||||
await MatchModel.updateOne(
|
||||
{ _id: competition.matchId },
|
||||
{ $set: set },
|
||||
).exec();
|
||||
|
||||
await this.matchStatsService.buildAndUpsert(competition.matchId, {
|
||||
sourceRevision: competition.revision,
|
||||
});
|
||||
await this.communityStatsService.invalidateCommunity(
|
||||
competition.communityId,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function leaseFilter(event: ClaimedOutboxEvent) {
|
||||
return {
|
||||
_id: event._id,
|
||||
state: 'pending',
|
||||
attemptCount: event.attemptCount,
|
||||
};
|
||||
}
|
||||
|
||||
function retryDelayMilliseconds(attemptCount: number): number {
|
||||
return Math.min(
|
||||
Math.max(1, 2 ** Math.min(attemptCount, 8)) * 1_000,
|
||||
MAX_RETRY_DELAY_MS,
|
||||
);
|
||||
}
|
||||
|
||||
function toResultSnapshot(
|
||||
competition: CompetitionEffectDocument,
|
||||
): CompetitionResultSnapshot {
|
||||
const projection = competition.projection;
|
||||
return {
|
||||
competitionId: competition._id.toString(),
|
||||
revision: competition.revision,
|
||||
phase: String(competition.phase) as CompetitionResultSnapshot['phase'],
|
||||
teams: arrayValue(competition.teams).map((team) => ({
|
||||
teamId: idValue(recordValue(team).teamId),
|
||||
members: arrayValue(recordValue(team).members).map((member) => ({
|
||||
userId: idValue(recordValue(member).userId),
|
||||
})),
|
||||
})),
|
||||
projection: {
|
||||
phase: projectionPhase(projection),
|
||||
series: arrayValue(projection.series).map((series) => {
|
||||
const source = recordValue(series);
|
||||
return {
|
||||
seriesId: idValue(source.seriesId),
|
||||
status: String(
|
||||
source.status,
|
||||
) as CompetitionResultSnapshot['projection']['series'][number]['status'],
|
||||
entries: arrayValue(source.entries).map((entry) => {
|
||||
const row = recordValue(entry);
|
||||
return {
|
||||
slot: String(row.slot) as 'A' | 'B',
|
||||
teamId: row.teamId == null ? null : idValue(row.teamId),
|
||||
gameWins: numberValue(row.gameWins),
|
||||
};
|
||||
}),
|
||||
};
|
||||
}),
|
||||
gameSlots: arrayValue(projection.gameSlots).map((slot) => {
|
||||
const source = recordValue(slot);
|
||||
return {
|
||||
id: idValue(source.id),
|
||||
seriesId: idValue(source.seriesId),
|
||||
ordinal: numberValue(source.ordinal),
|
||||
displayNumber: numberValue(source.displayNumber),
|
||||
status: String(
|
||||
source.status,
|
||||
) as CompetitionResultSnapshot['projection']['gameSlots'][number]['status'],
|
||||
};
|
||||
}),
|
||||
games: projectionGames(projection).map((game) => {
|
||||
const evidence = recordValue(recordValue(game).evidence);
|
||||
return {
|
||||
evidence: {
|
||||
type: typeof evidence.type === 'string' ? evidence.type : undefined,
|
||||
riotMatchId:
|
||||
typeof evidence.riotMatchId === 'string'
|
||||
? evidence.riotMatchId
|
||||
: undefined,
|
||||
},
|
||||
};
|
||||
}),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function projectionPhase(
|
||||
projection: Record<string, unknown>,
|
||||
): CompetitionResultSnapshot['projection']['phase'] {
|
||||
const phase = projection.phase;
|
||||
if (phase !== 'ready' && phase !== 'running' && phase !== 'completed') {
|
||||
throw new Error('Competition projection phase is invalid.');
|
||||
}
|
||||
return phase;
|
||||
}
|
||||
|
||||
function projectionGames(projection: Record<string, unknown>): unknown[] {
|
||||
return arrayValue(projection.games);
|
||||
}
|
||||
|
||||
function recordValue(value: unknown): Record<string, unknown> {
|
||||
return value !== null && typeof value === 'object' && !Array.isArray(value)
|
||||
? (value as Record<string, unknown>)
|
||||
: {};
|
||||
}
|
||||
|
||||
function arrayValue(value: unknown): unknown[] {
|
||||
return Array.isArray(value) ? value : [];
|
||||
}
|
||||
|
||||
function idValue(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 numberValue(value: unknown): number {
|
||||
return typeof value === 'number' ? value : Number(value);
|
||||
}
|
||||
|
||||
function errorMessage(error: unknown): string {
|
||||
return error instanceof Error ? error.message : String(error);
|
||||
}
|
||||
@@ -0,0 +1,244 @@
|
||||
import mongoose from 'mongoose';
|
||||
import type { RiotMatchDto } from '../riot/riot.types';
|
||||
import type { MatchPuuidLookup } from './team-mapping.util';
|
||||
import {
|
||||
compareRiotGameChronology,
|
||||
mapRiotGameToCompetitionSlot,
|
||||
resolveReadyCompetitionSlot,
|
||||
type CompetitionResultSnapshot,
|
||||
} from './competition-result.adapter';
|
||||
|
||||
const competitionId = new mongoose.Types.ObjectId().toString();
|
||||
const seriesId = new mongoose.Types.ObjectId().toString();
|
||||
const gameSlotId = new mongoose.Types.ObjectId().toString();
|
||||
const teamAId = new mongoose.Types.ObjectId().toString();
|
||||
const teamBId = new mongoose.Types.ObjectId().toString();
|
||||
|
||||
function fixture(): {
|
||||
competition: CompetitionResultSnapshot;
|
||||
detail: RiotMatchDto;
|
||||
lookup: MatchPuuidLookup;
|
||||
} {
|
||||
const users = Array.from({ length: 10 }, (_, index) => ({
|
||||
userId: new mongoose.Types.ObjectId(),
|
||||
puuid: `puuid-${index + 1}`,
|
||||
}));
|
||||
const lookup: MatchPuuidLookup = {
|
||||
puuidByUserId: new Map(
|
||||
users.map(({ userId, puuid }) => [userId.toString(), puuid]),
|
||||
),
|
||||
userIdByPuuid: new Map(users.map(({ userId, puuid }) => [puuid, userId])),
|
||||
};
|
||||
const competition: CompetitionResultSnapshot = {
|
||||
competitionId,
|
||||
revision: 4,
|
||||
phase: 'running',
|
||||
teams: [
|
||||
{
|
||||
teamId: teamAId,
|
||||
members: users.slice(0, 5).map(({ userId }) => ({
|
||||
userId: userId.toString(),
|
||||
})),
|
||||
},
|
||||
{
|
||||
teamId: teamBId,
|
||||
members: users.slice(5).map(({ userId }) => ({
|
||||
userId: userId.toString(),
|
||||
})),
|
||||
},
|
||||
],
|
||||
projection: {
|
||||
phase: 'running',
|
||||
series: [
|
||||
{
|
||||
seriesId,
|
||||
status: 'ready',
|
||||
entries: [
|
||||
{ slot: 'A', teamId: teamAId, gameWins: 0 },
|
||||
{ slot: 'B', teamId: teamBId, gameWins: 0 },
|
||||
],
|
||||
},
|
||||
],
|
||||
gameSlots: [
|
||||
{
|
||||
id: gameSlotId,
|
||||
seriesId,
|
||||
ordinal: 1,
|
||||
displayNumber: 17,
|
||||
status: 'ready',
|
||||
},
|
||||
],
|
||||
games: [],
|
||||
},
|
||||
};
|
||||
const participants = [
|
||||
...users.slice(5).map(({ puuid }, index) => ({
|
||||
puuid,
|
||||
participantId: index + 1,
|
||||
teamId: 100,
|
||||
championId: index + 1,
|
||||
kills: 10,
|
||||
deaths: 2,
|
||||
assists: 8,
|
||||
win: true,
|
||||
})),
|
||||
...users.slice(0, 5).map(({ puuid }, index) => ({
|
||||
puuid,
|
||||
participantId: index + 6,
|
||||
teamId: 200,
|
||||
championId: index + 6,
|
||||
kills: 2,
|
||||
deaths: 10,
|
||||
assists: 3,
|
||||
win: false,
|
||||
})),
|
||||
];
|
||||
const detail = {
|
||||
metadata: {
|
||||
dataVersion: '2',
|
||||
matchId: 'KR_123456789',
|
||||
participants: participants.map(({ puuid }) => puuid),
|
||||
},
|
||||
info: {
|
||||
gameCreation: Date.parse('2026-07-12T10:00:00.000Z'),
|
||||
gameEndTimestamp: Date.parse('2026-07-12T10:30:00.000Z'),
|
||||
gameDuration: 1800,
|
||||
participants,
|
||||
teams: [
|
||||
{ teamId: 100, win: true },
|
||||
{ teamId: 200, win: false },
|
||||
],
|
||||
},
|
||||
} as unknown as RiotMatchDto;
|
||||
return { competition, detail, lookup };
|
||||
}
|
||||
|
||||
describe('Competition result Riot mapping', () => {
|
||||
it('maps Riot sides to stable team ids using the frozen roster snapshot', () => {
|
||||
const { competition, detail, lookup } = fixture();
|
||||
|
||||
const accepted = mapRiotGameToCompetitionSlot({
|
||||
competition,
|
||||
target: competition.projection.gameSlots[0],
|
||||
detail,
|
||||
lookup,
|
||||
});
|
||||
|
||||
expect(accepted).toMatchObject({
|
||||
seriesId,
|
||||
gameSlotId,
|
||||
ordinal: 1,
|
||||
displayNumber: 17,
|
||||
mapping: {
|
||||
mappingVersion: 1,
|
||||
blueTeamId: teamBId,
|
||||
redTeamId: teamAId,
|
||||
winnerTeamId: teamBId,
|
||||
algorithmVersion: 'roster-overlap-v1',
|
||||
confidence: 1,
|
||||
diagnostics: {
|
||||
trustedOverlap: 10,
|
||||
normalOverlap: 0,
|
||||
reversedOverlap: 10,
|
||||
},
|
||||
},
|
||||
evidence: {
|
||||
type: 'riot',
|
||||
riotMatchId: 'KR_123456789',
|
||||
normalizedSnapshot: {
|
||||
startedAt: '2026-07-12T10:00:00.000Z',
|
||||
durationSeconds: 1800,
|
||||
},
|
||||
},
|
||||
});
|
||||
expect(accepted?.evidence.payloadHash).toMatch(/^[a-f0-9]{64}$/);
|
||||
expect(accepted?.normalizedParticipants).toHaveLength(10);
|
||||
expect(typeof accepted?.normalizedParticipants[0]?.userId).toBe('string');
|
||||
expect(accepted?.normalizedParticipants[0]).toMatchObject({
|
||||
teamId: teamBId,
|
||||
side: 'blue',
|
||||
summonerName: '',
|
||||
tagLine: '',
|
||||
});
|
||||
});
|
||||
|
||||
it('retains unknown Riot participants as normalized evidence with a null user id', () => {
|
||||
const { competition, detail, lookup } = fixture();
|
||||
detail.info.participants[0].puuid = 'unknown-substitute';
|
||||
|
||||
const accepted = mapRiotGameToCompetitionSlot({
|
||||
competition,
|
||||
target: competition.projection.gameSlots[0],
|
||||
detail,
|
||||
lookup,
|
||||
});
|
||||
|
||||
expect(accepted?.mapping.confidence).toBe(0.9);
|
||||
expect(accepted?.normalizedParticipants).toHaveLength(10);
|
||||
expect(accepted?.normalizedParticipants[0]).toMatchObject({
|
||||
userId: null,
|
||||
teamId: teamBId,
|
||||
side: 'blue',
|
||||
});
|
||||
expect(accepted?.mapping.participantAssignments).toHaveLength(9);
|
||||
});
|
||||
|
||||
it('resolves a manual result from ready stable GameSlots, not display codes', () => {
|
||||
const { competition, detail, lookup } = fixture();
|
||||
|
||||
const accepted = resolveReadyCompetitionSlot({
|
||||
competition,
|
||||
detail,
|
||||
lookup,
|
||||
});
|
||||
|
||||
expect(accepted).toMatchObject({ seriesId, gameSlotId, displayNumber: 17 });
|
||||
});
|
||||
|
||||
it('rejects an untrusted roster overlap instead of guessing a team', () => {
|
||||
const { competition, detail, lookup } = fixture();
|
||||
detail.info.participants.forEach((participant, index) => {
|
||||
participant.puuid = `unknown-${index}`;
|
||||
});
|
||||
|
||||
expect(
|
||||
mapRiotGameToCompetitionSlot({
|
||||
competition,
|
||||
target: competition.projection.gameSlots[0],
|
||||
detail,
|
||||
lookup,
|
||||
}),
|
||||
).toBeNull();
|
||||
});
|
||||
|
||||
it('rejects inconsistent Riot evidence with more than one winning team', () => {
|
||||
const { competition, detail, lookup } = fixture();
|
||||
detail.info.teams.forEach((team) => {
|
||||
team.win = true;
|
||||
});
|
||||
|
||||
expect(
|
||||
mapRiotGameToCompetitionSlot({
|
||||
competition,
|
||||
target: competition.projection.gameSlots[0],
|
||||
detail,
|
||||
lookup,
|
||||
}),
|
||||
).toBeNull();
|
||||
});
|
||||
|
||||
it('orders collected Riot games by occurrence before first-to projection', () => {
|
||||
const { detail } = fixture();
|
||||
const later = {
|
||||
...detail,
|
||||
metadata: { ...detail.metadata, matchId: 'KR_LATER' },
|
||||
info: { ...detail.info, gameCreation: detail.info.gameCreation + 60_000 },
|
||||
};
|
||||
|
||||
expect(
|
||||
[later, detail]
|
||||
.sort(compareRiotGameChronology)
|
||||
.map((game) => game.metadata.matchId),
|
||||
).toEqual(['KR_123456789', 'KR_LATER']);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,365 @@
|
||||
import { createHash } from 'node:crypto';
|
||||
import type { RiotMatchDto } from '../riot/riot.types';
|
||||
import type { MatchPuuidLookup } from './team-mapping.util';
|
||||
|
||||
const RIOT_BLUE_TEAM_ID = 100;
|
||||
const RIOT_RED_TEAM_ID = 200;
|
||||
const MINIMUM_TRUSTED_OVERLAP = 6;
|
||||
const MAPPING_ALGORITHM_VERSION = 'roster-overlap-v1';
|
||||
|
||||
type CompetitionPhase = 'ready' | 'running' | 'completed' | 'cancelled';
|
||||
|
||||
export interface CompetitionResultTeamSnapshot {
|
||||
teamId: string;
|
||||
members: Array<{ userId: string }>;
|
||||
}
|
||||
|
||||
export interface CompetitionResultSeriesProjection {
|
||||
seriesId: string;
|
||||
status: 'inactive' | 'waiting' | 'ready' | 'in-progress' | 'completed';
|
||||
entries: Array<{
|
||||
slot: 'A' | 'B';
|
||||
teamId: string | null;
|
||||
gameWins: number;
|
||||
}>;
|
||||
}
|
||||
|
||||
export interface CompetitionResultGameSlotProjection {
|
||||
id: string;
|
||||
seriesId: string;
|
||||
ordinal: number;
|
||||
displayNumber: number;
|
||||
status: 'inactive' | 'waiting' | 'ready' | 'completed' | 'voided';
|
||||
}
|
||||
|
||||
export interface CompetitionResultSnapshot {
|
||||
competitionId: string;
|
||||
revision: number;
|
||||
phase: CompetitionPhase;
|
||||
teams: CompetitionResultTeamSnapshot[];
|
||||
projection: {
|
||||
phase: Exclude<CompetitionPhase, 'cancelled'>;
|
||||
series: CompetitionResultSeriesProjection[];
|
||||
gameSlots: CompetitionResultGameSlotProjection[];
|
||||
games: Array<{
|
||||
evidence?: { type?: string; riotMatchId?: string };
|
||||
}>;
|
||||
};
|
||||
}
|
||||
|
||||
export interface MappedCompetitionRiotGame {
|
||||
gameId: string;
|
||||
seriesId: string;
|
||||
gameSlotId: string;
|
||||
ordinal: number;
|
||||
displayNumber: number;
|
||||
occurredAt: Date;
|
||||
startedAt: Date;
|
||||
durationSeconds: number;
|
||||
normalizedParticipants: Array<Record<string, unknown>>;
|
||||
evidence: {
|
||||
type: 'riot';
|
||||
riotMatchId: string;
|
||||
payloadHash: string;
|
||||
normalizedSnapshot: {
|
||||
startedAt: string;
|
||||
durationSeconds: number;
|
||||
participantCount: number;
|
||||
};
|
||||
};
|
||||
mapping: {
|
||||
mappingVersion: 1;
|
||||
blueTeamId: string;
|
||||
redTeamId: string;
|
||||
winnerTeamId: string;
|
||||
algorithmVersion: typeof MAPPING_ALGORITHM_VERSION;
|
||||
confidence: number;
|
||||
diagnostics: {
|
||||
trustedOverlap: number;
|
||||
normalOverlap: number;
|
||||
reversedOverlap: number;
|
||||
};
|
||||
participantAssignments: Array<{
|
||||
userId: string;
|
||||
teamId: string;
|
||||
side: 'blue' | 'red';
|
||||
}>;
|
||||
snapshot: {
|
||||
slotATeamId: string;
|
||||
slotBTeamId: string;
|
||||
slotAPuuids: string[];
|
||||
slotBPuuids: string[];
|
||||
bluePuuids: string[];
|
||||
redPuuids: string[];
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
export function compareRiotGameChronology(
|
||||
left: RiotMatchDto,
|
||||
right: RiotMatchDto,
|
||||
): number {
|
||||
return (
|
||||
left.info.gameCreation - right.info.gameCreation ||
|
||||
left.metadata.matchId.localeCompare(right.metadata.matchId)
|
||||
);
|
||||
}
|
||||
|
||||
export function mapRiotGameToCompetitionSlot(params: {
|
||||
competition: CompetitionResultSnapshot;
|
||||
target: CompetitionResultGameSlotProjection;
|
||||
detail: RiotMatchDto;
|
||||
lookup: MatchPuuidLookup;
|
||||
}): MappedCompetitionRiotGame | null {
|
||||
const { competition, target, detail, lookup } = params;
|
||||
if (target.status !== 'ready') return null;
|
||||
const series = competition.projection.series.find(
|
||||
(candidate) => candidate.seriesId === target.seriesId,
|
||||
);
|
||||
if (
|
||||
!series ||
|
||||
(series.status !== 'ready' && series.status !== 'in-progress')
|
||||
) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const slotATeamId = series.entries.find(({ slot }) => slot === 'A')?.teamId;
|
||||
const slotBTeamId = series.entries.find(({ slot }) => slot === 'B')?.teamId;
|
||||
if (!slotATeamId || !slotBTeamId || slotATeamId === slotBTeamId) return null;
|
||||
const slotATeam = competition.teams.find(
|
||||
({ teamId }) => teamId === slotATeamId,
|
||||
);
|
||||
const slotBTeam = competition.teams.find(
|
||||
({ teamId }) => teamId === slotBTeamId,
|
||||
);
|
||||
if (!slotATeam || !slotBTeam) return null;
|
||||
|
||||
const slotAPuuids = rosterPuuids(slotATeam, lookup);
|
||||
const slotBPuuids = rosterPuuids(slotBTeam, lookup);
|
||||
const bluePuuids = participantPuuids(detail, RIOT_BLUE_TEAM_ID);
|
||||
const redPuuids = participantPuuids(detail, RIOT_RED_TEAM_ID);
|
||||
const normalOverlap =
|
||||
countOverlap(bluePuuids, slotAPuuids) +
|
||||
countOverlap(redPuuids, slotBPuuids);
|
||||
const reversedOverlap =
|
||||
countOverlap(bluePuuids, slotBPuuids) +
|
||||
countOverlap(redPuuids, slotAPuuids);
|
||||
const trustedOverlap = Math.max(normalOverlap, reversedOverlap);
|
||||
if (
|
||||
trustedOverlap < MINIMUM_TRUSTED_OVERLAP ||
|
||||
normalOverlap === reversedOverlap
|
||||
) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const blueTeamId =
|
||||
normalOverlap > reversedOverlap ? slotATeamId : slotBTeamId;
|
||||
const redTeamId = normalOverlap > reversedOverlap ? slotBTeamId : slotATeamId;
|
||||
const winningRiotTeams = detail.info.teams.filter(
|
||||
({ teamId, win }) =>
|
||||
win && (teamId === RIOT_BLUE_TEAM_ID || teamId === RIOT_RED_TEAM_ID),
|
||||
);
|
||||
if (winningRiotTeams.length !== 1) return null;
|
||||
const winningRiotTeam = winningRiotTeams[0];
|
||||
const winnerTeamId =
|
||||
winningRiotTeam?.teamId === RIOT_BLUE_TEAM_ID
|
||||
? blueTeamId
|
||||
: winningRiotTeam?.teamId === RIOT_RED_TEAM_ID
|
||||
? redTeamId
|
||||
: undefined;
|
||||
if (!winnerTeamId) return null;
|
||||
|
||||
const startedAt = new Date(detail.info.gameCreation);
|
||||
const durationSeconds = detail.info.gameDuration;
|
||||
const occurredAt = new Date(
|
||||
detail.info.gameEndTimestamp ??
|
||||
detail.info.gameCreation + durationSeconds * 1_000,
|
||||
);
|
||||
const normalizedParticipants = detail.info.participants.flatMap(
|
||||
(participant) => {
|
||||
const userId = lookup.userIdByPuuid.get(participant.puuid);
|
||||
const teamId =
|
||||
participant.teamId === RIOT_BLUE_TEAM_ID
|
||||
? blueTeamId
|
||||
: participant.teamId === RIOT_RED_TEAM_ID
|
||||
? redTeamId
|
||||
: undefined;
|
||||
const side =
|
||||
participant.teamId === RIOT_BLUE_TEAM_ID
|
||||
? 'blue'
|
||||
: participant.teamId === RIOT_RED_TEAM_ID
|
||||
? 'red'
|
||||
: undefined;
|
||||
if (!teamId || !side) return [];
|
||||
return [
|
||||
{
|
||||
userId: userId?.toString() ?? null,
|
||||
teamId,
|
||||
side,
|
||||
summonerName:
|
||||
participant.riotIdGameName ?? participant.summonerName ?? '',
|
||||
tagLine: participant.riotIdTagLine ?? '',
|
||||
championId: participant.championId,
|
||||
kills: participant.kills,
|
||||
deaths: participant.deaths,
|
||||
assists: participant.assists,
|
||||
},
|
||||
];
|
||||
},
|
||||
);
|
||||
|
||||
return {
|
||||
gameId: deterministicGameId(
|
||||
competition.competitionId,
|
||||
detail.metadata.matchId,
|
||||
),
|
||||
seriesId: target.seriesId,
|
||||
gameSlotId: target.id,
|
||||
ordinal: target.ordinal,
|
||||
displayNumber: target.displayNumber,
|
||||
occurredAt,
|
||||
startedAt,
|
||||
durationSeconds,
|
||||
normalizedParticipants,
|
||||
evidence: {
|
||||
type: 'riot',
|
||||
riotMatchId: detail.metadata.matchId,
|
||||
payloadHash: sha256(detail),
|
||||
normalizedSnapshot: {
|
||||
startedAt: startedAt.toISOString(),
|
||||
durationSeconds,
|
||||
participantCount: normalizedParticipants.length,
|
||||
},
|
||||
},
|
||||
mapping: {
|
||||
mappingVersion: 1,
|
||||
blueTeamId,
|
||||
redTeamId,
|
||||
winnerTeamId,
|
||||
algorithmVersion: MAPPING_ALGORITHM_VERSION,
|
||||
confidence:
|
||||
trustedOverlap / Math.max(slotAPuuids.length + slotBPuuids.length, 1),
|
||||
diagnostics: { trustedOverlap, normalOverlap, reversedOverlap },
|
||||
participantAssignments: normalizedParticipants.flatMap((participant) =>
|
||||
typeof participant.userId === 'string'
|
||||
? [
|
||||
{
|
||||
userId: participant.userId,
|
||||
teamId: String(participant.teamId),
|
||||
side: participant.side as 'blue' | 'red',
|
||||
},
|
||||
]
|
||||
: [],
|
||||
),
|
||||
snapshot: {
|
||||
slotATeamId,
|
||||
slotBTeamId,
|
||||
slotAPuuids,
|
||||
slotBPuuids,
|
||||
bluePuuids,
|
||||
redPuuids,
|
||||
},
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
export function resolveReadyCompetitionSlot(params: {
|
||||
competition: CompetitionResultSnapshot;
|
||||
detail: RiotMatchDto;
|
||||
lookup: MatchPuuidLookup;
|
||||
}): MappedCompetitionRiotGame | null {
|
||||
const firstReadySlotBySeries = new Map<
|
||||
string,
|
||||
CompetitionResultGameSlotProjection
|
||||
>();
|
||||
for (const slot of [...params.competition.projection.gameSlots].sort(
|
||||
(left, right) =>
|
||||
left.displayNumber - right.displayNumber || left.ordinal - right.ordinal,
|
||||
)) {
|
||||
if (slot.status !== 'ready' || firstReadySlotBySeries.has(slot.seriesId)) {
|
||||
continue;
|
||||
}
|
||||
firstReadySlotBySeries.set(slot.seriesId, slot);
|
||||
}
|
||||
|
||||
const candidates = [...firstReadySlotBySeries.values()]
|
||||
.map((target) => mapRiotGameToCompetitionSlot({ ...params, target }))
|
||||
.filter((candidate): candidate is MappedCompetitionRiotGame =>
|
||||
Boolean(candidate),
|
||||
)
|
||||
.sort(
|
||||
(left, right) =>
|
||||
right.mapping.diagnostics.trustedOverlap -
|
||||
left.mapping.diagnostics.trustedOverlap ||
|
||||
left.displayNumber - right.displayNumber,
|
||||
);
|
||||
if (candidates.length === 0) return null;
|
||||
if (
|
||||
candidates.length > 1 &&
|
||||
candidates[0].mapping.diagnostics.trustedOverlap ===
|
||||
candidates[1].mapping.diagnostics.trustedOverlap
|
||||
) {
|
||||
return null;
|
||||
}
|
||||
return candidates[0];
|
||||
}
|
||||
|
||||
export function hasAcceptedRiotMatch(
|
||||
competition: CompetitionResultSnapshot,
|
||||
riotMatchId: string,
|
||||
): boolean {
|
||||
return competition.projection.games.some(
|
||||
({ evidence }) =>
|
||||
evidence?.type === 'riot' && evidence.riotMatchId === riotMatchId,
|
||||
);
|
||||
}
|
||||
|
||||
function rosterPuuids(
|
||||
team: CompetitionResultTeamSnapshot,
|
||||
lookup: MatchPuuidLookup,
|
||||
): string[] {
|
||||
return team.members.flatMap(({ userId }) => {
|
||||
const puuid = lookup.puuidByUserId.get(userId);
|
||||
return puuid ? [puuid] : [];
|
||||
});
|
||||
}
|
||||
|
||||
function participantPuuids(detail: RiotMatchDto, riotTeamId: number): string[] {
|
||||
return detail.info.participants
|
||||
.filter(({ teamId }) => teamId === riotTeamId)
|
||||
.map(({ puuid }) => puuid);
|
||||
}
|
||||
|
||||
function countOverlap(left: string[], right: string[]): number {
|
||||
const rightSet = new Set(right);
|
||||
return left.filter((item) => rightSet.has(item)).length;
|
||||
}
|
||||
|
||||
function deterministicGameId(
|
||||
competitionId: string,
|
||||
riotMatchId: string,
|
||||
): string {
|
||||
return sha256([competitionId, 'riot-game', riotMatchId]).slice(0, 24);
|
||||
}
|
||||
|
||||
function sha256(value: unknown): string {
|
||||
return createHash('sha256').update(canonicalJson(value)).digest('hex');
|
||||
}
|
||||
|
||||
function canonicalJson(value: unknown): string {
|
||||
return JSON.stringify(canonicalize(value));
|
||||
}
|
||||
|
||||
function canonicalize(value: unknown): unknown {
|
||||
if (value instanceof Date) return value.toISOString();
|
||||
if (Array.isArray(value)) return value.map(canonicalize);
|
||||
if (value && typeof value === 'object') {
|
||||
return Object.fromEntries(
|
||||
Object.entries(value as Record<string, unknown>)
|
||||
.filter(([, child]) => child !== undefined)
|
||||
.sort(([left], [right]) => left.localeCompare(right))
|
||||
.map(([key, child]) => [key, canonicalize(child)]),
|
||||
);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
@@ -1,180 +1,32 @@
|
||||
import mongoose from 'mongoose';
|
||||
import type { MatchDocument } from '../global/database/schema';
|
||||
import type { RiotMatchDto } from '../riot/riot.types';
|
||||
import {
|
||||
collectCaptainAndLimitedTeamMemberUserIds,
|
||||
computeGameResult,
|
||||
type MatchPuuidLookup,
|
||||
} from './team-mapping.util';
|
||||
|
||||
function makeMatch(): {
|
||||
match: MatchDocument;
|
||||
lookup: MatchPuuidLookup;
|
||||
blueUserIds: mongoose.Types.ObjectId[];
|
||||
redUserIds: mongoose.Types.ObjectId[];
|
||||
} {
|
||||
const blueUserIds = Array.from(
|
||||
{ length: 5 },
|
||||
() => new mongoose.Types.ObjectId(),
|
||||
);
|
||||
const redUserIds = Array.from(
|
||||
{ length: 5 },
|
||||
() => new mongoose.Types.ObjectId(),
|
||||
);
|
||||
const puuidByUserId = new Map<string, string>();
|
||||
const userIdByPuuid = new Map<string, mongoose.Types.ObjectId>();
|
||||
|
||||
for (const [index, userId] of [...blueUserIds, ...redUserIds].entries()) {
|
||||
const puuid = `puuid-${index}`;
|
||||
puuidByUserId.set(userId.toString(), puuid);
|
||||
userIdByPuuid.set(puuid, userId);
|
||||
}
|
||||
|
||||
const match = {
|
||||
teams: [
|
||||
{
|
||||
teamIndex: 1,
|
||||
name: '1팀',
|
||||
members: blueUserIds.map((userId) => ({
|
||||
userId,
|
||||
assignedPosition: 'MID',
|
||||
})),
|
||||
},
|
||||
{
|
||||
teamIndex: 2,
|
||||
name: '2팀',
|
||||
members: redUserIds.map((userId) => ({
|
||||
userId,
|
||||
assignedPosition: 'MID',
|
||||
})),
|
||||
},
|
||||
],
|
||||
participants: [...blueUserIds, ...redUserIds].map((userId, index) => ({
|
||||
userId,
|
||||
puuid: `puuid-${index}`,
|
||||
preferredPositions: [],
|
||||
joinedAt: new Date(),
|
||||
})),
|
||||
} as unknown as MatchDocument;
|
||||
|
||||
return {
|
||||
match,
|
||||
lookup: { puuidByUserId, userIdByPuuid },
|
||||
blueUserIds,
|
||||
redUserIds,
|
||||
};
|
||||
}
|
||||
|
||||
function makeRiotMatch(params: {
|
||||
team100Puuids: string[];
|
||||
team200Puuids: string[];
|
||||
winningTeamId: 100 | 200;
|
||||
}): RiotMatchDto {
|
||||
const participants = [
|
||||
...params.team100Puuids.map((puuid, index) => ({
|
||||
puuid,
|
||||
participantId: index + 1,
|
||||
teamId: 100,
|
||||
championId: 10 + index,
|
||||
kills: index,
|
||||
deaths: 1,
|
||||
assists: 2,
|
||||
win: params.winningTeamId === 100,
|
||||
})),
|
||||
...params.team200Puuids.map((puuid, index) => ({
|
||||
puuid,
|
||||
participantId: index + 6,
|
||||
teamId: 200,
|
||||
championId: 20 + index,
|
||||
kills: index,
|
||||
deaths: 2,
|
||||
assists: 3,
|
||||
win: params.winningTeamId === 200,
|
||||
})),
|
||||
];
|
||||
|
||||
return {
|
||||
metadata: {
|
||||
dataVersion: '2',
|
||||
matchId: 'KR_1',
|
||||
participants: participants.map((participant) => participant.puuid),
|
||||
},
|
||||
info: {
|
||||
gameCreation: 1,
|
||||
gameDuration: 1800,
|
||||
participants,
|
||||
teams: [
|
||||
{ teamId: 100, win: params.winningTeamId === 100 },
|
||||
{ teamId: 200, win: params.winningTeamId === 200 },
|
||||
],
|
||||
},
|
||||
} as unknown as RiotMatchDto;
|
||||
}
|
||||
|
||||
describe('computeGameResult', () => {
|
||||
it('maps Riot teams to local blue/red by overlap', () => {
|
||||
const { match, lookup } = makeMatch();
|
||||
const detail = makeRiotMatch({
|
||||
team100Puuids: ['puuid-0', 'puuid-1', 'puuid-2', 'puuid-3', 'puuid-4'],
|
||||
team200Puuids: ['puuid-5', 'puuid-6', 'puuid-7', 'puuid-8', 'puuid-9'],
|
||||
winningTeamId: 100,
|
||||
});
|
||||
|
||||
const result = computeGameResult({ match, lookup, detail, gameNumber: 1 });
|
||||
|
||||
expect(result).toMatchObject({
|
||||
gameNumber: 1,
|
||||
riotMatchId: 'KR_1',
|
||||
winnerSide: 'blue',
|
||||
blueTeamIndex: 1,
|
||||
redTeamIndex: 2,
|
||||
winnerTeamIndex: 1,
|
||||
gameDuration: 1800,
|
||||
});
|
||||
expect(result?.participants).toHaveLength(10);
|
||||
expect(result?.participants[0]).toMatchObject({
|
||||
teamIndex: 1,
|
||||
side: 'blue',
|
||||
});
|
||||
});
|
||||
|
||||
it('handles reversed Riot side assignment', () => {
|
||||
const { match, lookup } = makeMatch();
|
||||
const detail = makeRiotMatch({
|
||||
team100Puuids: ['puuid-5', 'puuid-6', 'puuid-7', 'puuid-8', 'puuid-9'],
|
||||
team200Puuids: ['puuid-0', 'puuid-1', 'puuid-2', 'puuid-3', 'puuid-4'],
|
||||
winningTeamId: 100,
|
||||
});
|
||||
|
||||
const result = computeGameResult({ match, lookup, detail, gameNumber: 2 });
|
||||
|
||||
expect(result).toMatchObject({
|
||||
blueTeamIndex: 2,
|
||||
redTeamIndex: 1,
|
||||
winnerSide: 'blue',
|
||||
winnerTeamIndex: 2,
|
||||
});
|
||||
});
|
||||
|
||||
it('rejects matches with too little overlap', () => {
|
||||
const { match, lookup } = makeMatch();
|
||||
const detail = makeRiotMatch({
|
||||
team100Puuids: ['other-1', 'other-2', 'other-3', 'other-4', 'other-5'],
|
||||
team200Puuids: ['other-6', 'other-7', 'other-8', 'other-9', 'other-10'],
|
||||
winningTeamId: 100,
|
||||
});
|
||||
|
||||
const result = computeGameResult({ match, lookup, detail, gameNumber: 3 });
|
||||
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
});
|
||||
import { collectCaptainAndLimitedTeamMemberUserIds } from './team-mapping.util';
|
||||
|
||||
describe('collectCaptainAndLimitedTeamMemberUserIds', () => {
|
||||
it('keeps captains and caps extra members per team', () => {
|
||||
const { blueUserIds, match, redUserIds } = makeMatch();
|
||||
match.teams[0].captainUserId = blueUserIds[0];
|
||||
match.teams[1].captainUserId = redUserIds[0];
|
||||
const blueUserIds = Array.from(
|
||||
{ length: 5 },
|
||||
() => new mongoose.Types.ObjectId(),
|
||||
);
|
||||
const redUserIds = Array.from(
|
||||
{ length: 5 },
|
||||
() => new mongoose.Types.ObjectId(),
|
||||
);
|
||||
const match = {
|
||||
teams: [
|
||||
{
|
||||
teamIndex: 1,
|
||||
captainUserId: blueUserIds[0],
|
||||
members: blueUserIds.map((userId) => ({ userId })),
|
||||
},
|
||||
{
|
||||
teamIndex: 2,
|
||||
captainUserId: redUserIds[0],
|
||||
members: redUserIds.map((userId) => ({ userId })),
|
||||
},
|
||||
],
|
||||
participants: [],
|
||||
} as unknown as MatchDocument;
|
||||
|
||||
const userIds = collectCaptainAndLimitedTeamMemberUserIds(match, 2).map(
|
||||
(userId) => userId.toString(),
|
||||
|
||||
@@ -1,14 +1,5 @@
|
||||
import mongoose from 'mongoose';
|
||||
import type {
|
||||
MatchDocument,
|
||||
MatchGameResult,
|
||||
TeamSide,
|
||||
} from '../global/database/schema';
|
||||
import type { RiotMatchDto } from '../riot/riot.types';
|
||||
|
||||
const RIOT_BLUE_TEAM_ID = 100;
|
||||
const RIOT_RED_TEAM_ID = 200;
|
||||
const MINIMUM_TRUSTED_OVERLAP = 6;
|
||||
import type { MatchDocument } from '../global/database/schema';
|
||||
|
||||
export interface MatchPuuidLookup {
|
||||
puuidByUserId: Map<string, string>;
|
||||
@@ -61,113 +52,3 @@ export function collectMatchUserIds(
|
||||
}
|
||||
return [...ids.values()];
|
||||
}
|
||||
|
||||
export function collectTeamPuuids(
|
||||
match: MatchDocument,
|
||||
teamIndex: number,
|
||||
lookup: MatchPuuidLookup,
|
||||
): string[] {
|
||||
const team = match.teams.find((item) => item.teamIndex === teamIndex);
|
||||
if (!team) return [];
|
||||
const userIds = [
|
||||
...(team.captainUserId ? [team.captainUserId] : []),
|
||||
...team.members.map((member) => member.userId),
|
||||
];
|
||||
return userIds
|
||||
.map((userId) => lookup.puuidByUserId.get(userId.toString()))
|
||||
.filter((puuid): puuid is string => Boolean(puuid));
|
||||
}
|
||||
|
||||
export function computeGameResult(params: {
|
||||
match: MatchDocument;
|
||||
detail: RiotMatchDto;
|
||||
gameNumber: number;
|
||||
lookup: MatchPuuidLookup;
|
||||
teamAIndex?: number;
|
||||
teamBIndex?: number;
|
||||
}): MatchGameResult | null {
|
||||
const {
|
||||
match,
|
||||
detail,
|
||||
gameNumber,
|
||||
lookup,
|
||||
teamAIndex = 1,
|
||||
teamBIndex = 2,
|
||||
} = params;
|
||||
const teamAPuuids = collectTeamPuuids(match, teamAIndex, lookup);
|
||||
const teamBPuuids = collectTeamPuuids(match, teamBIndex, lookup);
|
||||
const team100Puuids = detail.info.participants
|
||||
.filter((participant) => participant.teamId === RIOT_BLUE_TEAM_ID)
|
||||
.map((participant) => participant.puuid);
|
||||
const team200Puuids = detail.info.participants
|
||||
.filter((participant) => participant.teamId === RIOT_RED_TEAM_ID)
|
||||
.map((participant) => participant.puuid);
|
||||
|
||||
const normalOverlap =
|
||||
countOverlap(team100Puuids, teamAPuuids) +
|
||||
countOverlap(team200Puuids, teamBPuuids);
|
||||
const reversedOverlap =
|
||||
countOverlap(team100Puuids, teamBPuuids) +
|
||||
countOverlap(team200Puuids, teamAPuuids);
|
||||
const blueTeamIndex =
|
||||
normalOverlap >= reversedOverlap ? teamAIndex : teamBIndex;
|
||||
const redTeamIndex =
|
||||
normalOverlap >= reversedOverlap ? teamBIndex : teamAIndex;
|
||||
const teamIndexByRiotTeamId: Record<number, number> = {
|
||||
[RIOT_BLUE_TEAM_ID]: blueTeamIndex,
|
||||
[RIOT_RED_TEAM_ID]: redTeamIndex,
|
||||
};
|
||||
const sideByRiotTeamId: Record<number, TeamSide> = {
|
||||
[RIOT_BLUE_TEAM_ID]: 'blue',
|
||||
[RIOT_RED_TEAM_ID]: 'red',
|
||||
};
|
||||
|
||||
if (Math.max(normalOverlap, reversedOverlap) < MINIMUM_TRUSTED_OVERLAP) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const winningTeam = detail.info.teams.find((team) => team.win);
|
||||
if (!winningTeam) return null;
|
||||
const winnerSide = sideByRiotTeamId[winningTeam.teamId];
|
||||
if (!winnerSide) return null;
|
||||
const winnerTeamIndex = teamIndexByRiotTeamId[winningTeam.teamId];
|
||||
if (!winnerTeamIndex) return null;
|
||||
|
||||
const participants = detail.info.participants
|
||||
.map((participant) => {
|
||||
const userId = lookup.userIdByPuuid.get(participant.puuid);
|
||||
const side = sideByRiotTeamId[participant.teamId];
|
||||
const teamIndex = teamIndexByRiotTeamId[participant.teamId];
|
||||
if (!userId || !side || !teamIndex) return null;
|
||||
return {
|
||||
userId,
|
||||
teamIndex,
|
||||
side,
|
||||
championId: participant.championId,
|
||||
kills: participant.kills,
|
||||
deaths: participant.deaths,
|
||||
assists: participant.assists,
|
||||
win: participant.win,
|
||||
};
|
||||
})
|
||||
.filter((participant): participant is NonNullable<typeof participant> =>
|
||||
Boolean(participant),
|
||||
);
|
||||
|
||||
return {
|
||||
gameNumber,
|
||||
riotMatchId: detail.metadata.matchId,
|
||||
blueTeamIndex,
|
||||
redTeamIndex,
|
||||
winnerTeamIndex,
|
||||
winnerSide,
|
||||
gameCreation: detail.info.gameCreation,
|
||||
gameDuration: detail.info.gameDuration,
|
||||
participants,
|
||||
};
|
||||
}
|
||||
|
||||
export function countOverlap(left: string[], right: string[]): number {
|
||||
const rightSet = new Set(right);
|
||||
return left.filter((item) => rightSet.has(item)).length;
|
||||
}
|
||||
@@ -0,0 +1,294 @@
|
||||
/* eslint-disable @typescript-eslint/no-unsafe-assignment */
|
||||
import mongoose from 'mongoose';
|
||||
import type { MatchDocument } from '../global/database/schema';
|
||||
import type { RiotMatchDto } from '../riot/riot.types';
|
||||
import { TournamentResultService } from './tournament-result.service';
|
||||
|
||||
describe('TournamentResultService Competition cutover', () => {
|
||||
it('accepts a manually collected Riot game through Competition without mutating legacy result state', async () => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const competitionId = new mongoose.Types.ObjectId();
|
||||
const seriesId = new mongoose.Types.ObjectId();
|
||||
const earlierGameSlotId = new mongoose.Types.ObjectId();
|
||||
const gameSlotId = new mongoose.Types.ObjectId();
|
||||
const tournamentCodeId = new mongoose.Types.ObjectId();
|
||||
const teamAId = new mongoose.Types.ObjectId();
|
||||
const teamBId = new mongoose.Types.ObjectId();
|
||||
const users = Array.from({ length: 10 }, (_, index) => ({
|
||||
userId: new mongoose.Types.ObjectId(),
|
||||
puuid: `cutover-puuid-${index + 1}`,
|
||||
}));
|
||||
const legacyResult = {
|
||||
winnerTeamIndex: 2,
|
||||
riotMatchIds: ['legacy'],
|
||||
games: [],
|
||||
seriesResults: [],
|
||||
};
|
||||
const legacyBracket = { marker: 'must-not-change' };
|
||||
const match = {
|
||||
_id: matchId,
|
||||
communityId,
|
||||
status: 'team-built',
|
||||
gameCount: 1,
|
||||
gameMode: 'pair',
|
||||
teamBuiltAt: new Date('2026-07-12T09:00:00.000Z'),
|
||||
tournamentCodeIds: [tournamentCodeId],
|
||||
participants: users.map(({ userId, puuid }) => ({
|
||||
userId,
|
||||
puuid,
|
||||
excluded: false,
|
||||
})),
|
||||
teams: [
|
||||
{
|
||||
teamIndex: 1,
|
||||
name: 'Team A',
|
||||
members: users.slice(0, 5).map(({ userId }) => ({ userId })),
|
||||
},
|
||||
{
|
||||
teamIndex: 2,
|
||||
name: 'Team B',
|
||||
members: users.slice(5).map(({ userId }) => ({ userId })),
|
||||
},
|
||||
],
|
||||
result: legacyResult,
|
||||
doubleElimination: legacyBracket,
|
||||
save: jest.fn().mockResolvedValue(undefined),
|
||||
} as unknown as MatchDocument & { save: jest.Mock };
|
||||
const readyCompetition = {
|
||||
_id: competitionId,
|
||||
revision: 0,
|
||||
phase: 'ready',
|
||||
teams: [
|
||||
{
|
||||
teamId: teamAId,
|
||||
members: users.slice(0, 5).map(({ userId }) => ({ userId })),
|
||||
},
|
||||
{
|
||||
teamId: teamBId,
|
||||
members: users.slice(5).map(({ userId }) => ({ userId })),
|
||||
},
|
||||
],
|
||||
projection: {
|
||||
phase: 'ready',
|
||||
series: [
|
||||
{
|
||||
seriesId: seriesId.toString(),
|
||||
status: 'ready',
|
||||
entries: [
|
||||
{ slot: 'A', teamId: teamAId.toString(), gameWins: 0 },
|
||||
{ slot: 'B', teamId: teamBId.toString(), gameWins: 0 },
|
||||
],
|
||||
},
|
||||
],
|
||||
gameSlots: [
|
||||
{
|
||||
id: earlierGameSlotId.toString(),
|
||||
seriesId: seriesId.toString(),
|
||||
ordinal: 1,
|
||||
displayNumber: 16,
|
||||
status: 'ready',
|
||||
},
|
||||
{
|
||||
id: gameSlotId.toString(),
|
||||
seriesId: seriesId.toString(),
|
||||
ordinal: 2,
|
||||
displayNumber: 17,
|
||||
status: 'ready',
|
||||
},
|
||||
],
|
||||
games: [],
|
||||
},
|
||||
};
|
||||
const completedCompetition = {
|
||||
...readyCompetition,
|
||||
revision: 1,
|
||||
phase: 'completed',
|
||||
projection: {
|
||||
...readyCompetition.projection,
|
||||
phase: 'completed',
|
||||
games: [
|
||||
{
|
||||
evidence: { type: 'riot', riotMatchId: 'KR_CUTOVER_1' },
|
||||
},
|
||||
],
|
||||
},
|
||||
};
|
||||
const detail = riotDetail(users.map(({ puuid }) => puuid));
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockImplementation((name: string) => {
|
||||
if (name === 'match') {
|
||||
return Promise.resolve({
|
||||
findById: jest.fn().mockResolvedValue(match),
|
||||
});
|
||||
}
|
||||
if (name === 'community') {
|
||||
return Promise.resolve({
|
||||
findById: jest.fn().mockReturnValue({
|
||||
select: jest.fn().mockReturnValue({
|
||||
lean: jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue({ riotRegion: 'asia' }),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
});
|
||||
}
|
||||
if (name === 'riotMatch') {
|
||||
return Promise.resolve({
|
||||
findOne: jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue(null),
|
||||
}),
|
||||
updateOne: jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue(undefined),
|
||||
}),
|
||||
});
|
||||
}
|
||||
if (name === 'competition') {
|
||||
return Promise.resolve({
|
||||
findById: jest.fn().mockReturnValue({
|
||||
lean: jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue(readyCompetition),
|
||||
}),
|
||||
}),
|
||||
});
|
||||
}
|
||||
if (name === 'tournamentCode') {
|
||||
return Promise.resolve({
|
||||
findOne: jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue({
|
||||
_id: tournamentCodeId,
|
||||
code: 'CUTOVER-CODE',
|
||||
state: 'reserved',
|
||||
gameNumber: 17,
|
||||
}),
|
||||
}),
|
||||
});
|
||||
}
|
||||
if (name === 'tournamentCodeAssignment') {
|
||||
return Promise.resolve({
|
||||
findOne: jest.fn().mockReturnValue({
|
||||
lean: jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue({
|
||||
competitionId,
|
||||
seriesId,
|
||||
gameSlotId,
|
||||
tournamentCodeId,
|
||||
state: 'reserved',
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
updateOne: jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue(undefined),
|
||||
}),
|
||||
});
|
||||
}
|
||||
throw new Error(`Unexpected model ${name}`);
|
||||
}),
|
||||
};
|
||||
const commandService = {
|
||||
acceptGame: jest.fn().mockResolvedValue({
|
||||
competition: completedCompetition,
|
||||
commandId: 'cmpcmd-result',
|
||||
revision: 1,
|
||||
replayed: false,
|
||||
}),
|
||||
};
|
||||
const matchStatsService = {
|
||||
buildAndUpsert: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const service = new TournamentResultService(
|
||||
connectionService as never,
|
||||
{ getMatch: jest.fn().mockResolvedValue(detail) } as never,
|
||||
{} as never,
|
||||
{ invalidateCommunity: jest.fn().mockResolvedValue(undefined) } as never,
|
||||
matchStatsService as never,
|
||||
{
|
||||
runWithLock: jest.fn(),
|
||||
runWithRenewedLock: jest.fn(),
|
||||
} as never,
|
||||
{ bootstrap: jest.fn().mockResolvedValue(readyCompetition) } as never,
|
||||
commandService as never,
|
||||
{
|
||||
provisionReadyAssignments: jest.fn().mockResolvedValue({
|
||||
requested: 1,
|
||||
reserved: 0,
|
||||
existing: 1,
|
||||
unavailable: 0,
|
||||
}),
|
||||
} as never,
|
||||
);
|
||||
|
||||
const response = await service.collectManualByRiotMatch({
|
||||
matchId,
|
||||
communityId,
|
||||
riotMatchId: ' KR_CUTOVER_1 ',
|
||||
});
|
||||
|
||||
expect(response).toMatchObject({
|
||||
scanned: 1,
|
||||
matched: 1,
|
||||
skipped: 0,
|
||||
riotMatchIds: ['KR_CUTOVER_1'],
|
||||
gameNumbers: [17],
|
||||
});
|
||||
expect(commandService.acceptGame).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
competitionId,
|
||||
expectedRevision: 0,
|
||||
idempotencyKey: 'riot-result:KR_CUTOVER_1',
|
||||
seriesId,
|
||||
gameSlotId,
|
||||
ordinal: 2,
|
||||
mapping: expect.objectContaining({
|
||||
blueTeamId: teamAId.toString(),
|
||||
redTeamId: teamBId.toString(),
|
||||
winnerTeamId: teamAId.toString(),
|
||||
}),
|
||||
startedAt: new Date('2026-07-12T10:00:00.000Z'),
|
||||
durationSeconds: 1800,
|
||||
participants: expect.any(Array),
|
||||
tournamentCode: {
|
||||
tournamentCodeId,
|
||||
riotMatchId: 'KR_CUTOVER_1',
|
||||
},
|
||||
}),
|
||||
);
|
||||
expect(match.result).toBe(legacyResult);
|
||||
expect(match.doubleElimination).toBe(legacyBracket);
|
||||
expect(match.status).toBe('finished');
|
||||
expect(matchStatsService.buildAndUpsert).toHaveBeenCalledWith(matchId, {
|
||||
sourceRevision: 1,
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
function riotDetail(puuids: string[]): RiotMatchDto {
|
||||
const participants = puuids.map((puuid, index) => ({
|
||||
puuid,
|
||||
participantId: index + 1,
|
||||
teamId: index < 5 ? 100 : 200,
|
||||
championId: index + 1,
|
||||
kills: 1,
|
||||
deaths: 1,
|
||||
assists: 1,
|
||||
win: index < 5,
|
||||
}));
|
||||
return {
|
||||
metadata: {
|
||||
dataVersion: '2',
|
||||
matchId: 'KR_CUTOVER_1',
|
||||
participants: puuids,
|
||||
},
|
||||
info: {
|
||||
tournamentCode: 'CUTOVER-CODE',
|
||||
gameCreation: Date.parse('2026-07-12T10:00:00.000Z'),
|
||||
gameEndTimestamp: Date.parse('2026-07-12T10:30:00.000Z'),
|
||||
gameDuration: 1800,
|
||||
participants,
|
||||
teams: [
|
||||
{ teamId: 100, win: true },
|
||||
{ teamId: 200, win: false },
|
||||
],
|
||||
},
|
||||
} as unknown as RiotMatchDto;
|
||||
}
|
||||
@@ -1,14 +1,26 @@
|
||||
import { forwardRef, Module } from '@nestjs/common';
|
||||
import { CommunityStatsModule } from '../community-stats/community-stats.module';
|
||||
import { CompetitionModule } from '../competition/competition.module';
|
||||
import { RiotJobQueueModule } from '../riot-job-queue/riot-job-queue.module';
|
||||
import { RiotModule } from '../riot/riot.module';
|
||||
import { CompetitionAssignmentProvisioner } from './competition-assignment.provisioner';
|
||||
import { CompetitionOutboxProcessor } from './competition-outbox.processor';
|
||||
import { TournamentResultController } from './tournament-result.controller';
|
||||
import { TournamentResultService } from './tournament-result.service';
|
||||
|
||||
@Module({
|
||||
imports: [RiotModule, CommunityStatsModule, forwardRef(() => RiotJobQueueModule)],
|
||||
imports: [
|
||||
RiotModule,
|
||||
CommunityStatsModule,
|
||||
CompetitionModule,
|
||||
forwardRef(() => RiotJobQueueModule),
|
||||
],
|
||||
controllers: [TournamentResultController],
|
||||
providers: [TournamentResultService],
|
||||
providers: [
|
||||
CompetitionAssignmentProvisioner,
|
||||
CompetitionOutboxProcessor,
|
||||
TournamentResultService,
|
||||
],
|
||||
exports: [TournamentResultService],
|
||||
})
|
||||
export class TournamentResultModule {}
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -1,4 +1,3 @@
|
||||
import type { TeamSide } from '../global/database/schema';
|
||||
import type { RiotJobPriority } from '../riot-job-queue/riot-job-queue.types';
|
||||
|
||||
export interface PollTournamentResultJob {
|
||||
@@ -26,14 +25,3 @@ export interface ManualTournamentResultCollectResponse {
|
||||
riotMatchIds: string[];
|
||||
gameNumbers: number[];
|
||||
}
|
||||
|
||||
export interface ComputedGameParticipant {
|
||||
userId: string;
|
||||
teamIndex: number;
|
||||
side: TeamSide;
|
||||
championId: number;
|
||||
kills: number;
|
||||
deaths: number;
|
||||
assists: number;
|
||||
win: boolean;
|
||||
}
|
||||
@@ -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",
|
||||
@@ -18,6 +19,7 @@
|
||||
"preview": "vite preview"
|
||||
},
|
||||
"dependencies": {
|
||||
"@lolympus/contracts": "workspace:*",
|
||||
"@azure/msal-browser": "^5.8.0",
|
||||
"@azure/msal-react": "^5.3.1",
|
||||
"@newrelic/browser-agent": "^1.316.0",
|
||||
|
||||
+12
-11
@@ -51,7 +51,8 @@ function MsalHeaderActions() {
|
||||
function ThemeToggle() {
|
||||
const theme = useTheme();
|
||||
const nextTheme = theme === "light" ? "dark" : "light";
|
||||
const label = nextTheme === "dark" ? "다크 테마로 전환" : "라이트 테마로 전환";
|
||||
const label =
|
||||
nextTheme === "dark" ? "다크 테마로 전환" : "라이트 테마로 전환";
|
||||
const Icon = nextTheme === "dark" ? Moon : Sun;
|
||||
|
||||
return (
|
||||
@@ -81,11 +82,11 @@ function AppFooter() {
|
||||
</Link>
|
||||
</nav>
|
||||
<p className="leading-relaxed max-w-4xl">
|
||||
© 2026 LOLYMPUS. LOLYMPUS is not endorsed by Riot Games and
|
||||
does not reflect the views or opinions of Riot Games or anyone
|
||||
officially involved in producing or managing League of Legends.
|
||||
League of Legends and Riot Games are trademarks or registered
|
||||
trademarks of Riot Games, Inc. League of Legends © Riot Games, Inc.
|
||||
© 2026 LOLYMPUS. LOLYMPUS is not endorsed by Riot Games and does not
|
||||
reflect the views or opinions of Riot Games or anyone officially
|
||||
involved in producing or managing League of Legends. League of Legends
|
||||
and Riot Games are trademarks or registered trademarks of Riot Games,
|
||||
Inc. League of Legends © Riot Games, Inc.
|
||||
</p>
|
||||
</div>
|
||||
</footer>
|
||||
@@ -156,12 +157,12 @@ function App() {
|
||||
path="/match/:id/game/:gameNumber"
|
||||
element={<MatchGameDetailPage />}
|
||||
/>
|
||||
<Route
|
||||
path="/match/:id/team/:teamIndex"
|
||||
element={<MatchTeamProgressPage />}
|
||||
/>
|
||||
<Route path="/match/:id/team" element={<MatchTeamProgressPage />} />
|
||||
<Route path="/match/:id/auction" element={<AuctionPage />} />
|
||||
<Route path="/users/:userId/history" element={<UserHistoryPage />} />
|
||||
<Route
|
||||
path="/users/:userId/history"
|
||||
element={<UserHistoryPage />}
|
||||
/>
|
||||
<Route
|
||||
path="/communities/:cid/internal-stats"
|
||||
element={<CommunityInternalStatsPage />}
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
export interface AuthQueryScopeInput {
|
||||
authUserId: string | null;
|
||||
accountKey: string | null;
|
||||
msalConfigured: boolean;
|
||||
msalReady: boolean;
|
||||
}
|
||||
|
||||
interface ExecuteAuthScopedQueryInput<T> {
|
||||
accountKey: string | null;
|
||||
acquireAccessToken: () => Promise<string>;
|
||||
request: (authorizationHeader: string | null) => Promise<T>;
|
||||
}
|
||||
|
||||
export function resolveAuthQueryScope({
|
||||
authUserId,
|
||||
accountKey,
|
||||
msalConfigured,
|
||||
msalReady,
|
||||
}: AuthQueryScopeInput) {
|
||||
return {
|
||||
cacheKey: [authUserId, accountKey] as const,
|
||||
ready: Boolean(authUserId || !msalConfigured || msalReady),
|
||||
};
|
||||
}
|
||||
|
||||
export async function executeAuthScopedQuery<T>({
|
||||
accountKey,
|
||||
acquireAccessToken,
|
||||
request,
|
||||
}: ExecuteAuthScopedQueryInput<T>): Promise<T> {
|
||||
if (!accountKey) return request(null);
|
||||
|
||||
const accessToken = await acquireAccessToken();
|
||||
return request(`Bearer ${accessToken}`);
|
||||
}
|
||||
+286
-173
@@ -1,6 +1,19 @@
|
||||
import { InteractionStatus } from '@azure/msal-browser';
|
||||
import { useMsal } from '@azure/msal-react';
|
||||
import { useInfiniteQuery, useMutation, useQuery } from '@tanstack/react-query';
|
||||
import type {
|
||||
CompetitionCommandResponse,
|
||||
CompetitionDetailResponse,
|
||||
CreateSeriesAdjudicationRequest,
|
||||
MatchDetailResponse,
|
||||
MatchLifecycleStatus,
|
||||
MatchListResponse,
|
||||
ReverseSeriesResultRequest,
|
||||
SeriesId,
|
||||
SeriesReversalPreviewRequest,
|
||||
SeriesReversalPreviewResponse,
|
||||
TeamCompetitionViewResponse,
|
||||
} from '@lolympus/contracts';
|
||||
import { DEFAULT_COMMUNITY_ID, useAuthUserId } from '../config';
|
||||
import { apiFetch } from '../lib/api';
|
||||
import {
|
||||
@@ -8,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,
|
||||
@@ -21,7 +38,6 @@ import type {
|
||||
LegacyImportJobsResponse,
|
||||
LegacyImportMembersResponse,
|
||||
LegacyMatchListResponse,
|
||||
ApiMatch,
|
||||
ApiRecentMatchesResponse,
|
||||
ApiRecentSummaryResponse,
|
||||
ApiTeamInsightsResponse,
|
||||
@@ -31,9 +47,7 @@ import type {
|
||||
DdragonManifest,
|
||||
StartLegacyImportRequest,
|
||||
StartLegacyImportResponse,
|
||||
MatchStatus,
|
||||
MatchMutationRequest,
|
||||
MatchesResponse,
|
||||
ManualTournamentResultCollectResponse,
|
||||
MeResponse,
|
||||
RiotQueueGroup,
|
||||
@@ -41,7 +55,6 @@ import type {
|
||||
RebuildLegacyMatchesResponse,
|
||||
TournamentCodeBulkUploadResponse,
|
||||
TournamentCodeListResponse,
|
||||
TournamentCodeSlotView,
|
||||
TournamentCodeState,
|
||||
TournamentCodeStatsResponse,
|
||||
TournamentCodeUploadItem,
|
||||
@@ -50,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;
|
||||
@@ -83,7 +96,8 @@ function createMatchesPath(
|
||||
if (options.limit) searchParams.set('limit', String(options.limit));
|
||||
if (options.page) searchParams.set('page', String(options.page));
|
||||
if (options.offset) searchParams.set('offset', String(options.offset));
|
||||
if (options.scheduledFrom) searchParams.set('scheduledFrom', options.scheduledFrom);
|
||||
if (options.scheduledFrom)
|
||||
searchParams.set('scheduledFrom', options.scheduledFrom);
|
||||
if (options.scheduledTo) searchParams.set('scheduledTo', options.scheduledTo);
|
||||
if (options.sort) searchParams.set('sort', options.sort);
|
||||
|
||||
@@ -91,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 = <T>(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<T>(
|
||||
path,
|
||||
authorizationHeader
|
||||
? { headers: { Authorization: authorizationHeader } }
|
||||
: undefined,
|
||||
),
|
||||
});
|
||||
|
||||
return { ...scope, fetch };
|
||||
}
|
||||
|
||||
export function useCommunity(communityId = DEFAULT_COMMUNITY_ID) {
|
||||
return useQuery({
|
||||
queryKey: ['community', communityId],
|
||||
@@ -104,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,
|
||||
@@ -117,13 +173,12 @@ export function useMatches(
|
||||
options.sort ?? null,
|
||||
],
|
||||
queryFn: async () => {
|
||||
const response = await apiFetch<MatchesResponse>(
|
||||
const response = await authScope.fetch<MatchListResponse>(
|
||||
createMatchesPath(communityId, options),
|
||||
{ auth: 'none' },
|
||||
);
|
||||
return response.matches;
|
||||
},
|
||||
enabled: Boolean(communityId),
|
||||
enabled: Boolean(communityId && authScope.ready),
|
||||
});
|
||||
}
|
||||
|
||||
@@ -131,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,
|
||||
@@ -144,26 +202,159 @@ export function useMatchesPage(
|
||||
options.sort ?? null,
|
||||
],
|
||||
queryFn: () =>
|
||||
apiFetch<MatchesResponse>(createMatchesPath(communityId, options), {
|
||||
auth: 'none',
|
||||
}),
|
||||
enabled: Boolean(communityId),
|
||||
authScope.fetch<MatchListResponse>(
|
||||
createMatchesPath(communityId, options),
|
||||
),
|
||||
enabled: Boolean(communityId && authScope.ready),
|
||||
placeholderData: (previousData) => previousData,
|
||||
});
|
||||
}
|
||||
|
||||
export function useMatch(matchId: string | undefined, communityId = DEFAULT_COMMUNITY_ID) {
|
||||
return useQuery({
|
||||
queryKey: ['match', communityId, matchId ?? null],
|
||||
export function useMatch(
|
||||
matchId: string | undefined,
|
||||
communityId = DEFAULT_COMMUNITY_ID,
|
||||
) {
|
||||
const authScope = useOptionalAuthQueryScope();
|
||||
const queryKey = [
|
||||
'match',
|
||||
communityId,
|
||||
matchId ?? null,
|
||||
...authScope.cacheKey,
|
||||
] as const;
|
||||
|
||||
const query = useQuery({
|
||||
queryKey,
|
||||
queryFn: () =>
|
||||
apiFetch<ApiMatch>(`/communities/${communityId}/matches/${matchId}`, {
|
||||
auth: 'none',
|
||||
}),
|
||||
authScope.fetch<MatchDetailResponse>(
|
||||
`/communities/${communityId}/matches/${matchId}`,
|
||||
),
|
||||
enabled: Boolean(communityId && matchId && authScope.ready),
|
||||
retry: false,
|
||||
});
|
||||
|
||||
return { ...query, queryKey };
|
||||
}
|
||||
|
||||
export function useCompetition(
|
||||
matchId: string | undefined,
|
||||
communityId = DEFAULT_COMMUNITY_ID,
|
||||
enabled = true,
|
||||
) {
|
||||
return useQuery({
|
||||
queryKey: ['competition', communityId, matchId ?? null],
|
||||
queryFn: () =>
|
||||
apiFetch<CompetitionDetailResponse>(
|
||||
`/communities/${communityId}/matches/${matchId}/competition`,
|
||||
{
|
||||
auth: 'none',
|
||||
},
|
||||
),
|
||||
enabled: enabled && Boolean(communityId && matchId),
|
||||
retry: false,
|
||||
});
|
||||
}
|
||||
|
||||
export function useTeamCompetition(
|
||||
matchId: string | undefined,
|
||||
communityId = DEFAULT_COMMUNITY_ID,
|
||||
) {
|
||||
return useQuery({
|
||||
queryKey: ['competition-team', communityId, matchId ?? null],
|
||||
queryFn: () =>
|
||||
apiFetch<TeamCompetitionViewResponse>(
|
||||
`/communities/${communityId}/matches/${matchId}/competition/team`,
|
||||
),
|
||||
enabled: Boolean(communityId && matchId),
|
||||
retry: false,
|
||||
});
|
||||
}
|
||||
|
||||
type CompetitionMutationScope = {
|
||||
matchId: string;
|
||||
seriesId: SeriesId;
|
||||
revision: number;
|
||||
};
|
||||
|
||||
type IdempotentCompetitionMutationScope = CompetitionMutationScope & {
|
||||
idempotencyKey: string;
|
||||
};
|
||||
|
||||
function competitionCommandHeaders(revision: number, idempotencyKey?: string) {
|
||||
return {
|
||||
'If-Match': `"${revision}"`,
|
||||
...(idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : {}),
|
||||
};
|
||||
}
|
||||
|
||||
export function useAdjudicateCompetitionSeries(
|
||||
communityId = DEFAULT_COMMUNITY_ID,
|
||||
) {
|
||||
return useMutation({
|
||||
mutationFn: (
|
||||
params: IdempotentCompetitionMutationScope & {
|
||||
request: CreateSeriesAdjudicationRequest;
|
||||
},
|
||||
) =>
|
||||
apiFetch<CompetitionCommandResponse>(
|
||||
`/communities/${communityId}/matches/${params.matchId}/competition/series/${params.seriesId}/adjudications`,
|
||||
{
|
||||
method: 'POST',
|
||||
headers: competitionCommandHeaders(
|
||||
params.revision,
|
||||
params.idempotencyKey,
|
||||
),
|
||||
body: JSON.stringify(params.request),
|
||||
},
|
||||
),
|
||||
retry: false,
|
||||
});
|
||||
}
|
||||
|
||||
export function usePreviewCompetitionSeriesReversal(
|
||||
communityId = DEFAULT_COMMUNITY_ID,
|
||||
) {
|
||||
return useMutation({
|
||||
mutationFn: (
|
||||
params: CompetitionMutationScope & {
|
||||
request: SeriesReversalPreviewRequest;
|
||||
},
|
||||
) =>
|
||||
apiFetch<SeriesReversalPreviewResponse>(
|
||||
`/communities/${communityId}/matches/${params.matchId}/competition/series/${params.seriesId}/reversal-preview`,
|
||||
{
|
||||
method: 'POST',
|
||||
headers: competitionCommandHeaders(params.revision),
|
||||
body: JSON.stringify(params.request),
|
||||
},
|
||||
),
|
||||
retry: false,
|
||||
});
|
||||
}
|
||||
|
||||
export function useReverseCompetitionSeries(
|
||||
communityId = DEFAULT_COMMUNITY_ID,
|
||||
) {
|
||||
return useMutation({
|
||||
mutationFn: (
|
||||
params: IdempotentCompetitionMutationScope & {
|
||||
request: ReverseSeriesResultRequest;
|
||||
},
|
||||
) =>
|
||||
apiFetch<CompetitionCommandResponse>(
|
||||
`/communities/${communityId}/matches/${params.matchId}/competition/series/${params.seriesId}/reverse`,
|
||||
{
|
||||
method: 'POST',
|
||||
headers: competitionCommandHeaders(
|
||||
params.revision,
|
||||
params.idempotencyKey,
|
||||
),
|
||||
body: JSON.stringify(params.request),
|
||||
},
|
||||
),
|
||||
retry: false,
|
||||
});
|
||||
}
|
||||
|
||||
export function useCommunityUserSearch(
|
||||
query: string,
|
||||
communityId = DEFAULT_COMMUNITY_ID,
|
||||
@@ -293,7 +484,7 @@ export function useResetAuction(communityId = DEFAULT_COMMUNITY_ID) {
|
||||
export function useCreateMatch(communityId = DEFAULT_COMMUNITY_ID) {
|
||||
return useMutation({
|
||||
mutationFn: (body: MatchMutationRequest) =>
|
||||
apiFetch<ApiMatch>(`/communities/${communityId}/matches`, {
|
||||
apiFetch<MatchDetailResponse>(`/communities/${communityId}/matches`, {
|
||||
method: 'POST',
|
||||
body: JSON.stringify(body),
|
||||
}),
|
||||
@@ -302,104 +493,18 @@ export function useCreateMatch(communityId = DEFAULT_COMMUNITY_ID) {
|
||||
|
||||
export function useUpdateMatch(communityId = DEFAULT_COMMUNITY_ID) {
|
||||
return useMutation({
|
||||
mutationFn: ({ matchId, body }: { matchId: string; body: Partial<MatchMutationRequest> }) =>
|
||||
apiFetch<ApiMatch>(`/communities/${communityId}/matches/${matchId}`, {
|
||||
method: 'PATCH',
|
||||
body: JSON.stringify(body),
|
||||
}),
|
||||
});
|
||||
}
|
||||
|
||||
export function useReshuffleDoubleEliminationSeeds(
|
||||
communityId = DEFAULT_COMMUNITY_ID,
|
||||
) {
|
||||
return useMutation({
|
||||
mutationFn: (matchId: string) =>
|
||||
apiFetch<ApiMatch>(
|
||||
`/communities/${communityId}/matches/${matchId}/double-elimination/seeds/reshuffle`,
|
||||
{ method: 'POST' },
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
export function useSwapDoubleEliminationSeeds(
|
||||
communityId = DEFAULT_COMMUNITY_ID,
|
||||
) {
|
||||
return useMutation({
|
||||
mutationFn: (params: {
|
||||
mutationFn: ({
|
||||
matchId,
|
||||
body,
|
||||
}: {
|
||||
matchId: string;
|
||||
leftSeedNumber: number;
|
||||
rightSeedNumber: number;
|
||||
body: Partial<MatchMutationRequest>;
|
||||
}) =>
|
||||
apiFetch<ApiMatch>(
|
||||
`/communities/${communityId}/matches/${params.matchId}/double-elimination/seeds/swap`,
|
||||
apiFetch<MatchDetailResponse>(
|
||||
`/communities/${communityId}/matches/${matchId}`,
|
||||
{
|
||||
method: 'POST',
|
||||
body: JSON.stringify({
|
||||
leftSeedNumber: params.leftSeedNumber,
|
||||
rightSeedNumber: params.rightSeedNumber,
|
||||
}),
|
||||
},
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
export function useApplyDoubleEliminationWalkover(
|
||||
communityId = DEFAULT_COMMUNITY_ID,
|
||||
) {
|
||||
return useMutation({
|
||||
mutationFn: (params: {
|
||||
matchId: string;
|
||||
bracketMatchId: string;
|
||||
winnerTeamIndex: number;
|
||||
reason?: string;
|
||||
}) =>
|
||||
apiFetch<ApiMatch>(
|
||||
`/communities/${communityId}/matches/${params.matchId}/double-elimination/bracket-matches/${params.bracketMatchId}/walkover`,
|
||||
{
|
||||
method: 'POST',
|
||||
body: JSON.stringify({
|
||||
winnerTeamIndex: params.winnerTeamIndex,
|
||||
reason: params.reason,
|
||||
}),
|
||||
},
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
export function useCancelDoubleEliminationWalkover(
|
||||
communityId = DEFAULT_COMMUNITY_ID,
|
||||
) {
|
||||
return useMutation({
|
||||
mutationFn: (params: {
|
||||
matchId: string;
|
||||
bracketMatchId: string;
|
||||
reason?: string;
|
||||
}) =>
|
||||
apiFetch<ApiMatch>(
|
||||
`/communities/${communityId}/matches/${params.matchId}/double-elimination/bracket-matches/${params.bracketMatchId}/walkover/cancel`,
|
||||
{
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ reason: params.reason }),
|
||||
},
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
export function useCancelDoubleEliminationRiotResult(
|
||||
communityId = DEFAULT_COMMUNITY_ID,
|
||||
) {
|
||||
return useMutation({
|
||||
mutationFn: (params: {
|
||||
matchId: string;
|
||||
bracketMatchId: string;
|
||||
reason?: string;
|
||||
}) =>
|
||||
apiFetch<ApiMatch>(
|
||||
`/communities/${communityId}/matches/${params.matchId}/double-elimination/bracket-matches/${params.bracketMatchId}/result/cancel`,
|
||||
{
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ reason: params.reason }),
|
||||
method: 'PATCH',
|
||||
body: JSON.stringify(body),
|
||||
},
|
||||
),
|
||||
});
|
||||
@@ -416,7 +521,8 @@ function createUserHistoryPath(
|
||||
if (filters.queueGroup) searchParams.set('queueGroup', filters.queueGroup);
|
||||
if (filters.rank) searchParams.set('rank', filters.rank);
|
||||
if (filters.seasonId) searchParams.set('seasonId', filters.seasonId);
|
||||
if (filters.championId) searchParams.set('championId', String(filters.championId));
|
||||
if (filters.championId)
|
||||
searchParams.set('championId', String(filters.championId));
|
||||
for (const [key, value] of Object.entries(extra)) {
|
||||
if (value !== null && value !== undefined && value !== '') {
|
||||
searchParams.set(key, String(value));
|
||||
@@ -461,8 +567,15 @@ export function useChampionStats(
|
||||
],
|
||||
queryFn: () =>
|
||||
apiFetch<ApiChampionStatsResponse>(
|
||||
createUserHistoryPath(communityId, userId ?? '', 'champion-stats', filters),
|
||||
{ auth: 'none' },
|
||||
createUserHistoryPath(
|
||||
communityId,
|
||||
userId ?? '',
|
||||
'champion-stats',
|
||||
filters,
|
||||
),
|
||||
{
|
||||
auth: 'none',
|
||||
},
|
||||
),
|
||||
enabled: Boolean(communityId && userId && enabled),
|
||||
});
|
||||
@@ -486,8 +599,15 @@ export function useRecentSummary(
|
||||
],
|
||||
queryFn: () =>
|
||||
apiFetch<ApiRecentSummaryResponse>(
|
||||
createUserHistoryPath(communityId, userId ?? '', 'recent-summary', filters),
|
||||
{ auth: 'none' },
|
||||
createUserHistoryPath(
|
||||
communityId,
|
||||
userId ?? '',
|
||||
'recent-summary',
|
||||
filters,
|
||||
),
|
||||
{
|
||||
auth: 'none',
|
||||
},
|
||||
),
|
||||
enabled: Boolean(communityId && userId && enabled),
|
||||
});
|
||||
@@ -511,10 +631,16 @@ export function useRecentMatches(
|
||||
],
|
||||
queryFn: ({ pageParam }) =>
|
||||
apiFetch<ApiRecentMatchesResponse>(
|
||||
createUserHistoryPath(communityId, userId ?? '', 'recent-matches', filters, {
|
||||
cursor: pageParam,
|
||||
limit: 10,
|
||||
}),
|
||||
createUserHistoryPath(
|
||||
communityId,
|
||||
userId ?? '',
|
||||
'recent-matches',
|
||||
filters,
|
||||
{
|
||||
cursor: pageParam,
|
||||
limit: 10,
|
||||
},
|
||||
),
|
||||
{ auth: 'none' },
|
||||
),
|
||||
initialPageParam: null as number | null,
|
||||
@@ -533,7 +659,8 @@ function createCommunityInternalStatsPath(
|
||||
if (filters.seasonId) searchParams.set('seasonId', filters.seasonId);
|
||||
if (filters.from) searchParams.set('from', filters.from);
|
||||
if (filters.to) searchParams.set('to', filters.to);
|
||||
if (filters.championId) searchParams.set('championId', String(filters.championId));
|
||||
if (filters.championId)
|
||||
searchParams.set('championId', String(filters.championId));
|
||||
if (filters.limit) searchParams.set('limit', String(filters.limit));
|
||||
for (const [key, value] of Object.entries(extra)) {
|
||||
if (value !== null && value !== undefined && value !== '') {
|
||||
@@ -590,7 +717,9 @@ export function useCommunityLeaderboard(
|
||||
queryFn: () =>
|
||||
apiFetch<ApiLeaderboardResponse>(
|
||||
createCommunityInternalStatsPath(communityId, 'leaderboard', filters),
|
||||
{ auth: 'none' },
|
||||
{
|
||||
auth: 'none',
|
||||
},
|
||||
),
|
||||
enabled: Boolean(communityId && enabled),
|
||||
});
|
||||
@@ -613,7 +742,9 @@ export function useTeamInsights(
|
||||
queryFn: () =>
|
||||
apiFetch<ApiTeamInsightsResponse>(
|
||||
createCommunityInternalStatsPath(communityId, 'team-insights', filters),
|
||||
{ auth: 'none' },
|
||||
{
|
||||
auth: 'none',
|
||||
},
|
||||
),
|
||||
enabled: Boolean(communityId && enabled),
|
||||
});
|
||||
@@ -628,7 +759,9 @@ export function useInternalMatchDetail(
|
||||
queryFn: () =>
|
||||
apiFetch<ApiInternalMatchDetailResponse>(
|
||||
`/communities/${communityId}/internal-stats/match/${matchId}`,
|
||||
{ auth: 'none' },
|
||||
{
|
||||
auth: 'none',
|
||||
},
|
||||
),
|
||||
enabled: Boolean(communityId && matchId),
|
||||
retry: false,
|
||||
@@ -651,10 +784,16 @@ export function useUserInternalHistory(
|
||||
],
|
||||
queryFn: ({ pageParam }) =>
|
||||
apiFetch<ApiUserInternalHistoryResponse>(
|
||||
createUserHistoryPath(communityId, userId ?? '', 'internal-history', filters, {
|
||||
cursor: pageParam,
|
||||
limit: 10,
|
||||
}),
|
||||
createUserHistoryPath(
|
||||
communityId,
|
||||
userId ?? '',
|
||||
'internal-history',
|
||||
filters,
|
||||
{
|
||||
cursor: pageParam,
|
||||
limit: 10,
|
||||
},
|
||||
),
|
||||
{ auth: 'none' },
|
||||
),
|
||||
initialPageParam: null as number | null,
|
||||
@@ -740,7 +879,9 @@ export function useTournamentCodes(
|
||||
});
|
||||
}
|
||||
|
||||
export function useBulkUploadTournamentCodes(communityId = DEFAULT_COMMUNITY_ID) {
|
||||
export function useBulkUploadTournamentCodes(
|
||||
communityId = DEFAULT_COMMUNITY_ID,
|
||||
) {
|
||||
return useMutation({
|
||||
mutationFn: (codes: TournamentCodeUploadItem[]) =>
|
||||
apiFetch<TournamentCodeBulkUploadResponse>(
|
||||
@@ -772,16 +913,6 @@ export function useDeleteTournamentCode(communityId = DEFAULT_COMMUNITY_ID) {
|
||||
});
|
||||
}
|
||||
|
||||
export function useReplaceTournamentCode(communityId = DEFAULT_COMMUNITY_ID) {
|
||||
return useMutation({
|
||||
mutationFn: (params: { matchId: string; gameNumber: number }) =>
|
||||
apiFetch<TournamentCodeSlotView>(
|
||||
`/communities/${communityId}/tournament-codes/matches/${params.matchId}/games/${params.gameNumber}/replace`,
|
||||
{ method: 'POST' },
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
export function usePollTournamentResult(communityId = DEFAULT_COMMUNITY_ID) {
|
||||
return useMutation({
|
||||
mutationFn: (matchId: string) =>
|
||||
@@ -791,9 +922,12 @@ export function usePollTournamentResult(communityId = DEFAULT_COMMUNITY_ID) {
|
||||
priority: 'high' | 'low';
|
||||
attempt: number;
|
||||
expandedToAllPuuids: boolean;
|
||||
}>(`/communities/${communityId}/matches/${matchId}/poll-tournament-result`, {
|
||||
method: 'POST',
|
||||
}),
|
||||
}>(
|
||||
`/communities/${communityId}/matches/${matchId}/poll-tournament-result`,
|
||||
{
|
||||
method: 'POST',
|
||||
},
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
@@ -848,7 +982,8 @@ export function useLegacyImportMembers(
|
||||
],
|
||||
queryFn: () => {
|
||||
const searchParams = new URLSearchParams();
|
||||
if (options.windowStart) searchParams.set('windowStart', options.windowStart);
|
||||
if (options.windowStart)
|
||||
searchParams.set('windowStart', options.windowStart);
|
||||
if (options.windowEnd) searchParams.set('windowEnd', options.windowEnd);
|
||||
const queryString = searchParams.toString();
|
||||
return apiFetch<LegacyImportMembersResponse>(
|
||||
@@ -954,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<MeResponse>('/me');
|
||||
}
|
||||
|
||||
const response = await instance.acquireTokenSilent({
|
||||
account,
|
||||
scopes: [MSAL_API_SCOPE],
|
||||
redirectUri: MSAL_SILENT_REDIRECT_URI,
|
||||
});
|
||||
return apiFetch<MeResponse>('/me', {
|
||||
headers: {
|
||||
Authorization: `Bearer ${response.accessToken}`,
|
||||
},
|
||||
});
|
||||
},
|
||||
enabled: Boolean(authUserId || isMsalReady),
|
||||
queryKey: ['me', ...authScope.cacheKey],
|
||||
queryFn: () => authScope.fetch<MeResponse>('/me'),
|
||||
enabled: authScope.ready,
|
||||
retry: false,
|
||||
});
|
||||
}
|
||||
+29
-70
@@ -1,19 +1,19 @@
|
||||
import type {
|
||||
MatchDetailResponse,
|
||||
MatchLifecycleStatus,
|
||||
MatchParticipantView,
|
||||
} from "@lolympus/contracts";
|
||||
import type {
|
||||
ApiAuction,
|
||||
ApiAuctionPlayerSnapshot,
|
||||
ApiAuctionTeam,
|
||||
ApiMatch,
|
||||
ApiMatchParticipant,
|
||||
ApiPositionPreference,
|
||||
ApiRiotLaneStats,
|
||||
ApiRiotRecentStatsSummary,
|
||||
ApiTierHistoryEntry,
|
||||
ApiTierInfo,
|
||||
ApiDoubleEliminationBracket,
|
||||
MatchStatus,
|
||||
Position,
|
||||
RiotLane,
|
||||
TournamentCodeSlotView,
|
||||
} from "./types";
|
||||
import { POSITION_ORDER, teamIndexLabel } from "../lib/league";
|
||||
|
||||
@@ -48,44 +48,13 @@ export interface MatchDetailView {
|
||||
title: string;
|
||||
date: string;
|
||||
time: string;
|
||||
status: MatchStatus;
|
||||
status: MatchLifecycleStatus;
|
||||
description: string;
|
||||
map: string;
|
||||
maxParticipants: number;
|
||||
gameCount: number;
|
||||
gameMode: ApiMatch["gameMode"];
|
||||
doubleElimination?: ApiDoubleEliminationBracket;
|
||||
tournamentCodes: TournamentCodeSlotView[];
|
||||
joined: boolean;
|
||||
participants: ParticipantView[];
|
||||
teams: TeamView[];
|
||||
result?: {
|
||||
winner?: string;
|
||||
winnerTeamIndex?: number;
|
||||
riotMatchIds: string[];
|
||||
games: Array<{
|
||||
gameNumber: number;
|
||||
bracketMatchId?: string;
|
||||
riotMatchId: string;
|
||||
blueTeamIndex: number;
|
||||
redTeamIndex: number;
|
||||
winnerTeamIndex: number;
|
||||
winnerSide: "blue" | "red";
|
||||
gameCreation: number;
|
||||
gameDuration: number;
|
||||
participants: Array<{
|
||||
userId: string;
|
||||
teamIndex: number;
|
||||
side: "blue" | "red";
|
||||
championId: number;
|
||||
kills: number;
|
||||
deaths: number;
|
||||
assists: number;
|
||||
win: boolean;
|
||||
}>;
|
||||
}>;
|
||||
seriesResults: NonNullable<ApiMatch["result"]>["seriesResults"];
|
||||
};
|
||||
prizes: string[];
|
||||
notices: string[];
|
||||
schedule: { time: string; label: string }[];
|
||||
@@ -213,7 +182,7 @@ function resolveMainAndSubPosition(
|
||||
}
|
||||
|
||||
function mapMatchParticipantToView(
|
||||
participant: ApiMatchParticipant,
|
||||
participant: MatchParticipantView,
|
||||
): ParticipantView {
|
||||
const { mainPosition, subPosition } = resolveMainAndSubPosition(
|
||||
participant.preferredPositions,
|
||||
@@ -416,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(
|
||||
@@ -434,7 +405,9 @@ export function mapApiMatchToMatchDetail(match: ApiMatch): MatchDetailView {
|
||||
captainUserId: team.captainUserId,
|
||||
captainName:
|
||||
captain?.summonerName ??
|
||||
(team.captainUserId ? `User ${team.captainUserId.slice(-4)}` : undefined),
|
||||
(team.captainUserId
|
||||
? `User ${team.captainUserId.slice(-4)}`
|
||||
: undefined),
|
||||
captainTag: captain?.tag,
|
||||
participants: team.members.map((member) => {
|
||||
const participant =
|
||||
@@ -450,10 +423,6 @@ export function mapApiMatchToMatchDetail(match: ApiMatch): MatchDetailView {
|
||||
};
|
||||
});
|
||||
|
||||
const winnerTeam = match.result?.winnerTeamIndex
|
||||
? teams.find((team) => team.teamIndex === match.result?.winnerTeamIndex)
|
||||
: undefined;
|
||||
|
||||
return {
|
||||
id: match._id,
|
||||
title: match.title,
|
||||
@@ -463,24 +432,9 @@ export function mapApiMatchToMatchDetail(match: ApiMatch): MatchDetailView {
|
||||
description: match.description,
|
||||
map: mapIdToLabel(match.mapId),
|
||||
maxParticipants: match.maxParticipants,
|
||||
gameCount: match.gameCount ?? 3,
|
||||
gameMode: match.gameMode ?? "pair",
|
||||
doubleElimination: match.doubleElimination,
|
||||
tournamentCodes: match.tournamentCodes ?? [],
|
||||
joined: Boolean(match.joined),
|
||||
participants,
|
||||
teams,
|
||||
result: match.result
|
||||
? {
|
||||
winner: match.result.winnerTeamIndex ? winnerTeam?.name : undefined,
|
||||
winnerTeamIndex: match.result.winnerTeamIndex,
|
||||
riotMatchIds: match.result.riotMatchIds,
|
||||
games: [...(match.result.games ?? [])].sort(
|
||||
(left, right) => left.gameNumber - right.gameNumber,
|
||||
),
|
||||
seriesResults: match.result.seriesResults ?? [],
|
||||
}
|
||||
: undefined,
|
||||
prizes: match.prizes,
|
||||
notices: match.notices,
|
||||
schedule: match.schedule,
|
||||
@@ -489,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(
|
||||
@@ -523,9 +477,9 @@ export function mapApiAuctionToAuctionState(
|
||||
const auctionPlayerLookup = new Map(
|
||||
auctionOrder.map((player) => [player.userId, player]),
|
||||
);
|
||||
const teams = rawAuctionTeams.map(normalizeApiAuctionTeam).sort(
|
||||
(left, right) => left.teamIndex - right.teamIndex,
|
||||
);
|
||||
const teams = rawAuctionTeams
|
||||
.map(normalizeApiAuctionTeam)
|
||||
.sort((left, right) => left.teamIndex - right.teamIndex);
|
||||
|
||||
const totalPlayers = auctionOrder.length;
|
||||
const currentPlayer =
|
||||
@@ -535,7 +489,9 @@ export function mapApiAuctionToAuctionState(
|
||||
rawAuctionOrder[currentAuctionPlayerOrderIndex]?.userId ?? "",
|
||||
) ?? null);
|
||||
const currentPlayerIndex =
|
||||
auction.phase === "complete" ? totalPlayers : currentAuctionPlayerOrderIndex;
|
||||
auction.phase === "complete"
|
||||
? totalPlayers
|
||||
: currentAuctionPlayerOrderIndex;
|
||||
const remainingMs = currentBidRoundDeadlineTimestampMS
|
||||
? Math.max(0, currentBidRoundDeadlineTimestampMS - now.getTime())
|
||||
: 0;
|
||||
@@ -557,11 +513,12 @@ export function mapApiAuctionToAuctionState(
|
||||
auctionRound: auction.currentAuctionRound ?? auction.auctionRound ?? 1,
|
||||
bids: normalizeApiAuctionBids(auction),
|
||||
currentBid,
|
||||
currentBidder: currentBidderTeamIndex !== undefined
|
||||
? {
|
||||
teamIndex: currentBidderTeamIndex,
|
||||
}
|
||||
: null,
|
||||
currentBidder:
|
||||
currentBidderTeamIndex !== undefined
|
||||
? {
|
||||
teamIndex: currentBidderTeamIndex,
|
||||
}
|
||||
: null,
|
||||
remainingMs,
|
||||
timer,
|
||||
maxTimer: maximumBidRoundDurationSeconds,
|
||||
@@ -574,7 +531,9 @@ export function mapApiAuctionToAuctionState(
|
||||
|
||||
type NormalizedApiAuctionTeam = ApiAuctionTeam & { points: number };
|
||||
|
||||
function normalizeApiAuctionTeam(team: ApiAuctionTeam): NormalizedApiAuctionTeam {
|
||||
function normalizeApiAuctionTeam(
|
||||
team: ApiAuctionTeam,
|
||||
): NormalizedApiAuctionTeam {
|
||||
return {
|
||||
...team,
|
||||
points: team.points ?? team.remainingBidPointAmount ?? 0,
|
||||
|
||||
+12
-208
@@ -1,16 +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'
|
||||
| 'bracket'
|
||||
| 'round-robin'
|
||||
| 'double-elimination';
|
||||
export type MatchStatus =
|
||||
| 'recruiting'
|
||||
| 'team-built'
|
||||
| 'in-progress'
|
||||
| 'finished';
|
||||
export type AuctionPhase =
|
||||
| 'waiting'
|
||||
| 'presenting'
|
||||
@@ -26,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;
|
||||
@@ -143,153 +129,6 @@ export type TournamentCodeState =
|
||||
| 'released'
|
||||
| 'voided';
|
||||
|
||||
export type TournamentCodeSlotState = TournamentCodeState | 'pending';
|
||||
|
||||
export interface TournamentCodeSlotView {
|
||||
gameNumber: number;
|
||||
seriesGameNumber?: number;
|
||||
seriesGameCount?: number;
|
||||
seriesRequiredWins?: number;
|
||||
bracketMatchId?: string;
|
||||
bracketSide?: string;
|
||||
roundNumber?: number;
|
||||
matchNumber?: number;
|
||||
teamAIndex?: number;
|
||||
teamBIndex?: number;
|
||||
code: string | null;
|
||||
expiresAt: string | null;
|
||||
state: TournamentCodeSlotState;
|
||||
riotMatchId: string | null;
|
||||
}
|
||||
|
||||
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 ApiMatchGameResultParticipant {
|
||||
userId: string;
|
||||
teamIndex: number;
|
||||
side: TeamSide;
|
||||
championId: number;
|
||||
kills: number;
|
||||
deaths: number;
|
||||
assists: number;
|
||||
win: boolean;
|
||||
}
|
||||
|
||||
export interface ApiMatchGameResult {
|
||||
gameNumber: number;
|
||||
bracketMatchId?: string;
|
||||
riotMatchId: string;
|
||||
blueTeamIndex: number;
|
||||
redTeamIndex: number;
|
||||
winnerTeamIndex: number;
|
||||
winnerSide: TeamSide;
|
||||
gameCreation: number;
|
||||
gameDuration: number;
|
||||
participants: ApiMatchGameResultParticipant[];
|
||||
}
|
||||
|
||||
export interface ApiMatchResult {
|
||||
winnerTeamIndex?: number;
|
||||
mvpUserId?: string;
|
||||
riotMatchIds: string[];
|
||||
games: ApiMatchGameResult[];
|
||||
seriesResults?: Array<{
|
||||
bracketMatchId?: string;
|
||||
teamAIndex: number;
|
||||
teamBIndex: number;
|
||||
teamAWins: number;
|
||||
teamBWins: number;
|
||||
winnerTeamIndex?: number;
|
||||
}>;
|
||||
}
|
||||
|
||||
export interface ApiMatchScheduleItem {
|
||||
time: string;
|
||||
label: string;
|
||||
}
|
||||
|
||||
export interface ApiMatchGameAssignment {
|
||||
gameNumber: number;
|
||||
roundNumber?: number;
|
||||
teamAIndex: number;
|
||||
teamBIndex: number;
|
||||
}
|
||||
|
||||
export interface ApiDoubleEliminationSeed {
|
||||
seedNumber: number;
|
||||
teamIndex: number;
|
||||
}
|
||||
|
||||
export interface ApiDoubleEliminationBracketDestination {
|
||||
bracketMatchId: string;
|
||||
position: 'A' | 'B';
|
||||
}
|
||||
|
||||
export interface ApiDoubleEliminationWalkover {
|
||||
winnerTeamIndex: number;
|
||||
reason?: string;
|
||||
awardedAt: string;
|
||||
cancelledAt?: string;
|
||||
cancelReason?: string;
|
||||
active: boolean;
|
||||
}
|
||||
|
||||
export interface ApiDoubleEliminationBracketMatch {
|
||||
bracketMatchId: string;
|
||||
gameNumber: number;
|
||||
gameCount: number;
|
||||
requiredWins: number;
|
||||
bracketSide: 'winner' | 'loser' | 'grand-final' | 'reset-final';
|
||||
roundNumber: number;
|
||||
matchNumber: number;
|
||||
state: 'pending' | 'ready' | 'completed';
|
||||
teamAIndex?: number;
|
||||
teamBIndex?: number;
|
||||
winnerAdvancesTo?: ApiDoubleEliminationBracketDestination;
|
||||
loserAdvancesTo?: ApiDoubleEliminationBracketDestination;
|
||||
winnerTeamIndex?: number;
|
||||
loserTeamIndex?: number;
|
||||
completedBy?: 'riot-result' | 'walkover';
|
||||
completedAt?: string;
|
||||
walkover?: ApiDoubleEliminationWalkover;
|
||||
}
|
||||
|
||||
export interface ApiDoubleEliminationBracket {
|
||||
teamCount: 4 | 8;
|
||||
resetFinalEnabled: boolean;
|
||||
resetFinalCreated: boolean;
|
||||
seeds: ApiDoubleEliminationSeed[];
|
||||
bracketMatches: ApiDoubleEliminationBracketMatch[];
|
||||
placements: {
|
||||
firstTeamIndex?: number;
|
||||
secondTeamIndex?: number;
|
||||
thirdTeamIndex?: number;
|
||||
};
|
||||
}
|
||||
|
||||
export interface ManualTournamentResultCollectResponse {
|
||||
scanned: number;
|
||||
matched: number;
|
||||
@@ -298,34 +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;
|
||||
gameSchedule?: ApiMatchGameAssignment[];
|
||||
doubleElimination?: ApiDoubleEliminationBracket;
|
||||
tournamentCodes?: TournamentCodeSlotView[];
|
||||
hostUserId?: string;
|
||||
participants: ApiMatchParticipant[];
|
||||
teams: ApiMatchTeam[];
|
||||
result?: ApiMatchResult;
|
||||
prizes: string[];
|
||||
notices: string[];
|
||||
schedule: ApiMatchScheduleItem[];
|
||||
joined?: boolean;
|
||||
createdAt: string;
|
||||
updatedAt: string;
|
||||
}
|
||||
|
||||
export interface ApiAuctionPlayerSnapshot {
|
||||
userId: string;
|
||||
puuid: string;
|
||||
@@ -457,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;
|
||||
@@ -476,7 +280,7 @@ export interface MatchMutationRequest {
|
||||
doubleEliminationResetFinalEnabled?: boolean;
|
||||
prizes?: string[];
|
||||
notices?: string[];
|
||||
schedule?: ApiMatchScheduleItem[];
|
||||
schedule?: MatchScheduleItemView[];
|
||||
}
|
||||
|
||||
export interface DdragonChampionEntry {
|
||||
|
||||
@@ -0,0 +1,763 @@
|
||||
import { useMemo, useRef, useState } from "react";
|
||||
import { useQueryClient } from "@tanstack/react-query";
|
||||
import type {
|
||||
CompetitionCommandResponse,
|
||||
CompetitionDetailResponse,
|
||||
SeriesAdjudicationDecision,
|
||||
SeriesProjection,
|
||||
SeriesReversalMode,
|
||||
SeriesReversalPreviewResponse,
|
||||
TeamId,
|
||||
} from "@lolympus/contracts";
|
||||
import {
|
||||
useAdjudicateCompetitionSeries,
|
||||
usePreviewCompetitionSeriesReversal,
|
||||
useReverseCompetitionSeries,
|
||||
} from "../../api/hooks";
|
||||
import { ApiError } from "../../lib/api";
|
||||
|
||||
type AdjudicationType = SeriesAdjudicationDecision["type"];
|
||||
|
||||
const ADJUDICATION_LABELS: Record<AdjudicationType, string> = {
|
||||
walkover: "부전승",
|
||||
forfeit: "몰수패",
|
||||
administrative: "운영자 판정",
|
||||
"administrative-draw": "운영자 무승부",
|
||||
};
|
||||
|
||||
export function CompetitionAdminControls({
|
||||
competition,
|
||||
communityId,
|
||||
canManage,
|
||||
}: {
|
||||
competition: CompetitionDetailResponse;
|
||||
communityId: string;
|
||||
canManage: boolean;
|
||||
}) {
|
||||
const queryClient = useQueryClient();
|
||||
const series = competition.projection.series;
|
||||
const defaultSeries =
|
||||
series.find(
|
||||
(item) => item.status === "ready" || item.status === "in-progress",
|
||||
) ??
|
||||
series.find((item) => item.status === "completed") ??
|
||||
series[0];
|
||||
const [selectedSeriesId, setSelectedSeriesId] = useState<string>(
|
||||
defaultSeries?.seriesId ?? "",
|
||||
);
|
||||
const [adjudicationType, setAdjudicationType] =
|
||||
useState<AdjudicationType>("walkover");
|
||||
const [winnerTeamId, setWinnerTeamId] = useState<string>("");
|
||||
const [adjudicationReason, setAdjudicationReason] = useState("");
|
||||
const [reversalMode, setReversalMode] =
|
||||
useState<SeriesReversalMode>("strict");
|
||||
const [reversalReason, setReversalReason] = useState("");
|
||||
const [reversalPreview, setReversalPreview] =
|
||||
useState<SeriesReversalPreviewResponse | null>(null);
|
||||
const [impactConfirmed, setImpactConfirmed] = useState(false);
|
||||
const [notice, setNotice] = useState<string | null>(null);
|
||||
const adjudicationIdempotencyKeyRef = useRef<string | null>(null);
|
||||
const reversalIdempotencyKeyRef = useRef<string | null>(null);
|
||||
const adjudicationMutation = useAdjudicateCompetitionSeries(communityId);
|
||||
const previewMutation = usePreviewCompetitionSeriesReversal(communityId);
|
||||
const reversalMutation = useReverseCompetitionSeries(communityId);
|
||||
|
||||
const selectedSeries =
|
||||
series.find((item) => item.seriesId === selectedSeriesId) ?? defaultSeries;
|
||||
const teamById = useMemo(
|
||||
() => new Map(competition.teams.map((team) => [team.teamId, team])),
|
||||
[competition.teams],
|
||||
);
|
||||
const eligibleTeams = selectedSeries
|
||||
? selectedSeries.entries.flatMap((entry) =>
|
||||
entry.teamId ? [teamById.get(entry.teamId)] : [],
|
||||
)
|
||||
: [];
|
||||
const selectedSeriesGames = selectedSeries
|
||||
? competition.projection.games.filter(
|
||||
(game) => game.seriesId === selectedSeries.seriesId,
|
||||
)
|
||||
: [];
|
||||
const drawAllowed = Boolean(
|
||||
selectedSeries?.rule.type === "fixed-games" &&
|
||||
selectedSeries.rule.drawPolicy === "allow",
|
||||
);
|
||||
const canAdjudicate = Boolean(
|
||||
selectedSeries &&
|
||||
(selectedSeries.status === "ready" ||
|
||||
selectedSeries.status === "in-progress"),
|
||||
);
|
||||
const canReverse = selectedSeries?.status === "completed";
|
||||
const previewIsCurrent = Boolean(
|
||||
reversalPreview && reversalPreview.sourceRevision === competition.revision,
|
||||
);
|
||||
const effectiveSelectedSeriesId = selectedSeries?.seriesId ?? "";
|
||||
const effectiveWinnerTeamId = eligibleTeams.some(
|
||||
(team) => team?.teamId === winnerTeamId,
|
||||
)
|
||||
? winnerTeamId
|
||||
: (eligibleTeams.find(Boolean)?.teamId ?? "");
|
||||
const effectiveAdjudicationType =
|
||||
adjudicationType === "administrative-draw" && !drawAllowed
|
||||
? "administrative"
|
||||
: adjudicationType === "walkover" && selectedSeriesGames.length > 0
|
||||
? "forfeit"
|
||||
: adjudicationType;
|
||||
|
||||
if (!canManage || series.length === 0) return null;
|
||||
|
||||
async function invalidateCompetitionCaches(
|
||||
response?: CompetitionCommandResponse,
|
||||
) {
|
||||
const matchId = String(competition.matchId);
|
||||
if (response) {
|
||||
queryClient.setQueryData(
|
||||
["competition", communityId, matchId],
|
||||
response.competition,
|
||||
);
|
||||
}
|
||||
await Promise.all([
|
||||
queryClient.invalidateQueries({
|
||||
queryKey: ["competition", communityId, matchId],
|
||||
}),
|
||||
queryClient.invalidateQueries({
|
||||
queryKey: ["competition-team", communityId, matchId],
|
||||
}),
|
||||
queryClient.invalidateQueries({
|
||||
queryKey: ["match", communityId, matchId],
|
||||
}),
|
||||
queryClient.invalidateQueries({
|
||||
queryKey: ["matches", communityId],
|
||||
}),
|
||||
queryClient.invalidateQueries({
|
||||
queryKey: ["matches-page", communityId],
|
||||
}),
|
||||
]);
|
||||
}
|
||||
|
||||
function resetCommandFeedback() {
|
||||
setNotice(null);
|
||||
adjudicationMutation.reset();
|
||||
previewMutation.reset();
|
||||
reversalMutation.reset();
|
||||
}
|
||||
|
||||
function handleSelectedSeriesChange(nextSeriesId: string) {
|
||||
const nextSeries = series.find((item) => item.seriesId === nextSeriesId);
|
||||
const nextHasGames = competition.projection.games.some(
|
||||
(game) => game.seriesId === nextSeries?.seriesId,
|
||||
);
|
||||
setSelectedSeriesId(nextSeriesId);
|
||||
setWinnerTeamId("");
|
||||
setAdjudicationType(nextHasGames ? "forfeit" : "walkover");
|
||||
setAdjudicationReason("");
|
||||
setReversalMode("strict");
|
||||
setReversalReason("");
|
||||
setReversalPreview(null);
|
||||
setImpactConfirmed(false);
|
||||
adjudicationIdempotencyKeyRef.current = null;
|
||||
reversalIdempotencyKeyRef.current = null;
|
||||
resetCommandFeedback();
|
||||
}
|
||||
|
||||
function handleAdjudicationSubmit(event: React.FormEvent) {
|
||||
event.preventDefault();
|
||||
if (!selectedSeries || !canAdjudicate || !adjudicationReason.trim()) {
|
||||
return;
|
||||
}
|
||||
if (
|
||||
effectiveAdjudicationType !== "administrative-draw" &&
|
||||
!effectiveWinnerTeamId
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
const decision: SeriesAdjudicationDecision =
|
||||
effectiveAdjudicationType === "administrative-draw"
|
||||
? { type: "administrative-draw" }
|
||||
: {
|
||||
type: effectiveAdjudicationType,
|
||||
winnerTeamId: effectiveWinnerTeamId as TeamId,
|
||||
};
|
||||
const idempotencyKey =
|
||||
adjudicationIdempotencyKeyRef.current ??
|
||||
`adjudicate:${selectedSeries.seriesId}:${crypto.randomUUID()}`;
|
||||
adjudicationIdempotencyKeyRef.current = idempotencyKey;
|
||||
resetCommandFeedback();
|
||||
adjudicationMutation.mutate(
|
||||
{
|
||||
matchId: String(competition.matchId),
|
||||
seriesId: selectedSeries.seriesId,
|
||||
revision: competition.revision,
|
||||
idempotencyKey,
|
||||
request: {
|
||||
decision,
|
||||
reason: adjudicationReason.trim(),
|
||||
},
|
||||
},
|
||||
{
|
||||
onSuccess: async (response) => {
|
||||
adjudicationIdempotencyKeyRef.current = null;
|
||||
setNotice("Series 판정을 기록했습니다.");
|
||||
setAdjudicationReason("");
|
||||
await invalidateCompetitionCaches(response);
|
||||
},
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
function handlePreviewSubmit(event: React.FormEvent) {
|
||||
event.preventDefault();
|
||||
if (!selectedSeries || !canReverse || !reversalReason.trim()) return;
|
||||
|
||||
resetCommandFeedback();
|
||||
setReversalPreview(null);
|
||||
setImpactConfirmed(false);
|
||||
previewMutation.mutate(
|
||||
{
|
||||
matchId: String(competition.matchId),
|
||||
seriesId: selectedSeries.seriesId,
|
||||
revision: competition.revision,
|
||||
request: {
|
||||
mode: reversalMode,
|
||||
reason: reversalReason.trim(),
|
||||
},
|
||||
},
|
||||
{
|
||||
onSuccess: (preview) => {
|
||||
reversalIdempotencyKeyRef.current = null;
|
||||
setReversalPreview(preview);
|
||||
setImpactConfirmed(false);
|
||||
},
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
function handleReverse() {
|
||||
if (
|
||||
!selectedSeries ||
|
||||
!reversalPreview ||
|
||||
!previewIsCurrent ||
|
||||
!impactConfirmed ||
|
||||
!reversalReason.trim()
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
const idempotencyKey =
|
||||
reversalIdempotencyKeyRef.current ??
|
||||
`reverse:${selectedSeries.seriesId}:${crypto.randomUUID()}`;
|
||||
reversalIdempotencyKeyRef.current = idempotencyKey;
|
||||
resetCommandFeedback();
|
||||
reversalMutation.mutate(
|
||||
{
|
||||
matchId: String(competition.matchId),
|
||||
seriesId: selectedSeries.seriesId,
|
||||
revision: reversalPreview.sourceRevision,
|
||||
idempotencyKey,
|
||||
request: {
|
||||
mode: reversalMode,
|
||||
reason: reversalReason.trim(),
|
||||
impactHash: reversalPreview.impactHash,
|
||||
},
|
||||
},
|
||||
{
|
||||
onSuccess: async (response) => {
|
||||
reversalIdempotencyKeyRef.current = null;
|
||||
setNotice("Series 결과를 되돌렸습니다.");
|
||||
setReversalPreview(null);
|
||||
setImpactConfirmed(false);
|
||||
setReversalReason("");
|
||||
await invalidateCompetitionCaches(response);
|
||||
},
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
const commandError =
|
||||
adjudicationMutation.error ??
|
||||
previewMutation.error ??
|
||||
reversalMutation.error;
|
||||
const commandErrorCode = competitionCommandErrorCode(commandError);
|
||||
const staleCommand =
|
||||
(commandError instanceof ApiError && commandError.status === 412) ||
|
||||
commandErrorCode === "REVERSAL_PREVIEW_STALE";
|
||||
const commandPending =
|
||||
adjudicationMutation.isPending ||
|
||||
previewMutation.isPending ||
|
||||
reversalMutation.isPending;
|
||||
|
||||
return (
|
||||
<section
|
||||
className="mb-6 border border-warning/25 bg-warning/[0.04] p-4"
|
||||
aria-labelledby="competition-admin-heading"
|
||||
>
|
||||
<div className="flex flex-wrap items-start justify-between gap-3 border-b border-warning/20 pb-3">
|
||||
<div>
|
||||
<p className="text-[11px] font-bold uppercase tracking-wider text-warning">
|
||||
Owner / Admin
|
||||
</p>
|
||||
<h2
|
||||
id="competition-admin-heading"
|
||||
className="mt-1 text-base font-bold"
|
||||
>
|
||||
공식 결과 관리
|
||||
</h2>
|
||||
</div>
|
||||
<span className="border border-base-content/10 px-2 py-1 font-mono text-xs text-base-content/45">
|
||||
revision {competition.revision}
|
||||
</span>
|
||||
</div>
|
||||
|
||||
<label className="mt-4 block text-xs font-bold text-base-content/55">
|
||||
Series
|
||||
<select
|
||||
className="mt-1.5 h-10 w-full border border-base-content/15 bg-base-100 px-3 text-sm focus:border-warning/50 focus:outline-none"
|
||||
value={effectiveSelectedSeriesId}
|
||||
disabled={commandPending}
|
||||
onChange={(event) => handleSelectedSeriesChange(event.target.value)}
|
||||
>
|
||||
{series.map((item) => (
|
||||
<option key={item.seriesId} value={item.seriesId}>
|
||||
{seriesLabel(item)} · {seriesStatusLabel(item.status)}
|
||||
</option>
|
||||
))}
|
||||
</select>
|
||||
</label>
|
||||
|
||||
{notice && (
|
||||
<p
|
||||
className="mt-3 border border-success/20 bg-success/10 px-3 py-2 text-sm text-success"
|
||||
role="status"
|
||||
>
|
||||
{notice}
|
||||
</p>
|
||||
)}
|
||||
|
||||
{commandError && (
|
||||
<div
|
||||
className="mt-3 border border-error/20 bg-error/10 px-3 py-2 text-sm text-error"
|
||||
role="alert"
|
||||
>
|
||||
<p>{competitionCommandErrorMessage(commandError)}</p>
|
||||
{staleCommand && (
|
||||
<button
|
||||
type="button"
|
||||
className="mt-2 border border-error/25 px-2 py-1 text-xs font-bold hover:bg-error/10"
|
||||
onClick={() => {
|
||||
adjudicationIdempotencyKeyRef.current = null;
|
||||
reversalIdempotencyKeyRef.current = null;
|
||||
resetCommandFeedback();
|
||||
void invalidateCompetitionCaches();
|
||||
}}
|
||||
>
|
||||
최신 revision 불러오기
|
||||
</button>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
|
||||
{canAdjudicate ? (
|
||||
<form className="mt-4 space-y-3" onSubmit={handleAdjudicationSubmit}>
|
||||
<h3 className="text-sm font-bold">Series 판정</h3>
|
||||
<div className="grid gap-3 sm:grid-cols-2">
|
||||
<label className="text-xs font-bold text-base-content/50">
|
||||
판정 유형
|
||||
<select
|
||||
className="mt-1.5 h-10 w-full border border-base-content/15 bg-base-100 px-3 text-sm focus:border-warning/50 focus:outline-none"
|
||||
value={effectiveAdjudicationType}
|
||||
disabled={adjudicationMutation.isPending}
|
||||
onChange={(event) => {
|
||||
resetCommandFeedback();
|
||||
adjudicationIdempotencyKeyRef.current = null;
|
||||
setAdjudicationType(event.target.value as AdjudicationType);
|
||||
}}
|
||||
>
|
||||
<option
|
||||
value="walkover"
|
||||
disabled={selectedSeriesGames.length > 0}
|
||||
>
|
||||
{ADJUDICATION_LABELS.walkover}
|
||||
</option>
|
||||
<option value="forfeit">{ADJUDICATION_LABELS.forfeit}</option>
|
||||
<option value="administrative">
|
||||
{ADJUDICATION_LABELS.administrative}
|
||||
</option>
|
||||
{drawAllowed && (
|
||||
<option value="administrative-draw">
|
||||
{ADJUDICATION_LABELS["administrative-draw"]}
|
||||
</option>
|
||||
)}
|
||||
</select>
|
||||
</label>
|
||||
|
||||
{effectiveAdjudicationType !== "administrative-draw" && (
|
||||
<label className="text-xs font-bold text-base-content/50">
|
||||
승리 팀
|
||||
<select
|
||||
className="mt-1.5 h-10 w-full border border-base-content/15 bg-base-100 px-3 text-sm focus:border-warning/50 focus:outline-none"
|
||||
value={effectiveWinnerTeamId}
|
||||
disabled={adjudicationMutation.isPending}
|
||||
onChange={(event) => {
|
||||
resetCommandFeedback();
|
||||
adjudicationIdempotencyKeyRef.current = null;
|
||||
setWinnerTeamId(event.target.value);
|
||||
}}
|
||||
>
|
||||
{eligibleTeams.map((team) =>
|
||||
team ? (
|
||||
<option key={team.teamId} value={team.teamId}>
|
||||
{team.name}
|
||||
</option>
|
||||
) : null,
|
||||
)}
|
||||
</select>
|
||||
</label>
|
||||
)}
|
||||
</div>
|
||||
|
||||
<label className="block text-xs font-bold text-base-content/50">
|
||||
판정 사유
|
||||
<textarea
|
||||
className="mt-1.5 min-h-24 w-full resize-y border border-base-content/15 bg-base-100 px-3 py-2 text-sm focus:border-warning/50 focus:outline-none"
|
||||
maxLength={2000}
|
||||
value={adjudicationReason}
|
||||
disabled={adjudicationMutation.isPending}
|
||||
onChange={(event) => {
|
||||
resetCommandFeedback();
|
||||
adjudicationIdempotencyKeyRef.current = null;
|
||||
setAdjudicationReason(event.target.value);
|
||||
}}
|
||||
placeholder="감사 로그에 남을 구체적인 사유를 입력하세요."
|
||||
required
|
||||
/>
|
||||
</label>
|
||||
<button
|
||||
type="submit"
|
||||
className="btn btn-warning btn-sm px-4 text-xs"
|
||||
disabled={
|
||||
adjudicationMutation.isPending ||
|
||||
!adjudicationReason.trim() ||
|
||||
(effectiveAdjudicationType !== "administrative-draw" &&
|
||||
!effectiveWinnerTeamId)
|
||||
}
|
||||
>
|
||||
{adjudicationMutation.isPending ? "기록 중..." : "판정 기록"}
|
||||
</button>
|
||||
</form>
|
||||
) : canReverse && selectedSeries ? (
|
||||
<form className="mt-4 space-y-3" onSubmit={handlePreviewSubmit}>
|
||||
<h3 className="text-sm font-bold">결과 되돌리기</h3>
|
||||
<p className="text-xs leading-5 text-base-content/50">
|
||||
먼저 현재 revision에서 영향을 계산합니다. 실행 시 동일 revision과
|
||||
impact hash가 검증됩니다.
|
||||
</p>
|
||||
<fieldset className="grid gap-2 sm:grid-cols-2">
|
||||
<legend className="mb-1 text-xs font-bold text-base-content/50">
|
||||
되돌리기 범위
|
||||
</legend>
|
||||
{(["strict", "cascade"] as const).map((mode) => (
|
||||
<label
|
||||
key={mode}
|
||||
className="flex cursor-pointer items-start gap-2 border border-base-content/10 bg-base-100 px-3 py-2 text-xs"
|
||||
>
|
||||
<input
|
||||
type="radio"
|
||||
name="reversal-mode"
|
||||
className="radio radio-warning radio-xs mt-0.5"
|
||||
value={mode}
|
||||
checked={reversalMode === mode}
|
||||
disabled={
|
||||
previewMutation.isPending || reversalMutation.isPending
|
||||
}
|
||||
onChange={() => {
|
||||
resetCommandFeedback();
|
||||
reversalIdempotencyKeyRef.current = null;
|
||||
setReversalMode(mode);
|
||||
setReversalPreview(null);
|
||||
setImpactConfirmed(false);
|
||||
}}
|
||||
/>
|
||||
<span>
|
||||
<strong className="block text-base-content/70">
|
||||
{mode === "strict" ? "Strict" : "Cascade"}
|
||||
</strong>
|
||||
<span className="mt-0.5 block text-base-content/40">
|
||||
{mode === "strict"
|
||||
? "후속 결과가 없을 때 선택 Series만 되돌립니다."
|
||||
: "영향받은 후속 Series 결과도 함께 되돌립니다."}
|
||||
</span>
|
||||
</span>
|
||||
</label>
|
||||
))}
|
||||
</fieldset>
|
||||
|
||||
<label className="block text-xs font-bold text-base-content/50">
|
||||
되돌리기 사유
|
||||
<textarea
|
||||
className="mt-1.5 min-h-24 w-full resize-y border border-base-content/15 bg-base-100 px-3 py-2 text-sm focus:border-warning/50 focus:outline-none"
|
||||
maxLength={2000}
|
||||
value={reversalReason}
|
||||
disabled={previewMutation.isPending || reversalMutation.isPending}
|
||||
onChange={(event) => {
|
||||
resetCommandFeedback();
|
||||
reversalIdempotencyKeyRef.current = null;
|
||||
setReversalReason(event.target.value);
|
||||
setReversalPreview(null);
|
||||
setImpactConfirmed(false);
|
||||
}}
|
||||
placeholder="감사 로그에 남을 구체적인 사유를 입력하세요."
|
||||
required
|
||||
/>
|
||||
</label>
|
||||
|
||||
<button
|
||||
type="submit"
|
||||
className="btn btn-outline btn-sm px-4 text-xs"
|
||||
disabled={
|
||||
previewMutation.isPending ||
|
||||
reversalMutation.isPending ||
|
||||
!reversalReason.trim()
|
||||
}
|
||||
>
|
||||
{previewMutation.isPending ? "계산 중..." : "영향 미리보기"}
|
||||
</button>
|
||||
|
||||
{reversalPreview && (
|
||||
<ReversalImpactPanel
|
||||
preview={reversalPreview}
|
||||
competition={competition}
|
||||
confirmed={impactConfirmed}
|
||||
onConfirmedChange={setImpactConfirmed}
|
||||
previewIsCurrent={previewIsCurrent}
|
||||
executing={reversalMutation.isPending}
|
||||
onExecute={handleReverse}
|
||||
/>
|
||||
)}
|
||||
</form>
|
||||
) : (
|
||||
<p className="mt-4 border border-dashed border-base-content/15 px-3 py-4 text-sm text-base-content/45">
|
||||
이 Series는 현재 판정하거나 되돌릴 수 있는 상태가 아닙니다.
|
||||
</p>
|
||||
)}
|
||||
</section>
|
||||
);
|
||||
}
|
||||
|
||||
function ReversalImpactPanel({
|
||||
preview,
|
||||
competition,
|
||||
confirmed,
|
||||
onConfirmedChange,
|
||||
previewIsCurrent,
|
||||
executing,
|
||||
onExecute,
|
||||
}: {
|
||||
preview: SeriesReversalPreviewResponse;
|
||||
competition: CompetitionDetailResponse;
|
||||
confirmed: boolean;
|
||||
onConfirmedChange: (confirmed: boolean) => void;
|
||||
previewIsCurrent: boolean;
|
||||
executing: boolean;
|
||||
onExecute: () => void;
|
||||
}) {
|
||||
const seriesById = new Map(
|
||||
competition.projection.series.map((series) => [series.seriesId, series]),
|
||||
);
|
||||
const teamById = new Map(
|
||||
competition.teams.map((team) => [team.teamId, team]),
|
||||
);
|
||||
const { impact } = preview;
|
||||
|
||||
return (
|
||||
<div className="border border-error/25 bg-error/[0.04] p-3">
|
||||
<div className="flex flex-wrap items-center justify-between gap-2">
|
||||
<h4 className="text-sm font-bold text-error">영향 범위</h4>
|
||||
<span className="font-mono text-xs text-base-content/45">
|
||||
source revision {preview.sourceRevision}
|
||||
</span>
|
||||
</div>
|
||||
<dl className="mt-3 grid grid-cols-2 gap-2 text-xs sm:grid-cols-4">
|
||||
<ImpactCount label="Series" value={impact.seriesIds.length} />
|
||||
<ImpactCount label="Facts" value={impact.factIds.length} />
|
||||
<ImpactCount label="Game slots" value={impact.gameSlotIds.length} />
|
||||
<ImpactCount label="Teams" value={impact.teamIds.length} />
|
||||
<ImpactCount label="코드 반환" value={impact.releasesReservedCodes} />
|
||||
<ImpactCount label="사용 코드 무효화" value={impact.voidsUsedCodes} />
|
||||
<ImpactCount
|
||||
label="통계 재생성"
|
||||
value={impact.requiresStatsRebuild ? "필요" : "불필요"}
|
||||
/>
|
||||
</dl>
|
||||
|
||||
<div className="mt-3 grid gap-2 sm:grid-cols-2">
|
||||
<ImpactList
|
||||
title="영향받는 Series"
|
||||
items={impact.seriesIds.map((seriesId) => {
|
||||
const series = seriesById.get(seriesId);
|
||||
return series ? seriesLabel(series) : String(seriesId);
|
||||
})}
|
||||
/>
|
||||
<ImpactList
|
||||
title="영향받는 팀"
|
||||
items={impact.teamIds.map(
|
||||
(teamId) => teamById.get(teamId)?.name ?? String(teamId),
|
||||
)}
|
||||
/>
|
||||
<ImpactList title="되돌릴 사실 ID" items={impact.factIds.map(String)} />
|
||||
<ImpactList
|
||||
title="영향받는 Game slot ID"
|
||||
items={impact.gameSlotIds.map(String)}
|
||||
/>
|
||||
</div>
|
||||
|
||||
<div className="mt-3">
|
||||
<span className="text-xs font-bold text-base-content/45">
|
||||
Impact hash
|
||||
</span>
|
||||
<code className="mt-1 block break-all border border-base-content/10 bg-base-100 px-2 py-1.5 font-mono text-[11px] text-base-content/55">
|
||||
{preview.impactHash}
|
||||
</code>
|
||||
</div>
|
||||
|
||||
{!previewIsCurrent && (
|
||||
<p
|
||||
className="mt-3 border border-error/20 bg-error/10 px-2 py-2 text-xs text-error"
|
||||
role="alert"
|
||||
>
|
||||
Competition revision이 변경되었습니다. 새 미리보기가 필요합니다.
|
||||
</p>
|
||||
)}
|
||||
|
||||
<label className="mt-3 flex items-start gap-2 text-xs text-base-content/60">
|
||||
<input
|
||||
type="checkbox"
|
||||
className="checkbox checkbox-error checkbox-xs mt-0.5"
|
||||
checked={confirmed}
|
||||
disabled={!previewIsCurrent || executing}
|
||||
onChange={(event) => onConfirmedChange(event.target.checked)}
|
||||
/>
|
||||
표시된 Series, 사실, 코드 및 통계 영향을 확인했습니다.
|
||||
</label>
|
||||
<button
|
||||
type="button"
|
||||
className="btn btn-error btn-sm mt-3 px-4 text-xs"
|
||||
disabled={!confirmed || !previewIsCurrent || executing}
|
||||
onClick={onExecute}
|
||||
>
|
||||
{executing ? "되돌리는 중..." : "Hash 확인 후 되돌리기"}
|
||||
</button>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
function ImpactCount({
|
||||
label,
|
||||
value,
|
||||
}: {
|
||||
label: string;
|
||||
value: number | string;
|
||||
}) {
|
||||
return (
|
||||
<div className="border border-base-content/10 bg-base-100 px-2 py-2">
|
||||
<dt className="text-base-content/40">{label}</dt>
|
||||
<dd className="mt-0.5 font-mono font-bold text-base-content/70">
|
||||
{value}
|
||||
</dd>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
function ImpactList({ title, items }: { title: string; items: string[] }) {
|
||||
return (
|
||||
<div className="border border-base-content/10 bg-base-100 px-2 py-2 text-xs">
|
||||
<h5 className="font-bold text-base-content/45">{title}</h5>
|
||||
{items.length > 0 ? (
|
||||
<ul className="mt-1 space-y-0.5 text-base-content/60">
|
||||
{items.map((item, index) => (
|
||||
<li key={`${item}:${index}`} className="break-all">
|
||||
{item}
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
) : (
|
||||
<p className="mt-1 text-base-content/35">없음</p>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
function seriesLabel(series: SeriesProjection) {
|
||||
return series.code ?? `${stageLabel(series)} Series`;
|
||||
}
|
||||
|
||||
function stageLabel(series: SeriesProjection) {
|
||||
switch (series.stage.type) {
|
||||
case "pair":
|
||||
return "대진";
|
||||
case "round-robin":
|
||||
return `${series.stage.roundNumber ?? 1}라운드`;
|
||||
case "upper":
|
||||
return `승자조 ${series.stage.roundNumber ?? 1}라운드`;
|
||||
case "lower":
|
||||
return `패자조 ${series.stage.roundNumber ?? 1}라운드`;
|
||||
case "grand-final":
|
||||
return "그랜드 파이널";
|
||||
case "reset-final":
|
||||
return "리셋 파이널";
|
||||
}
|
||||
}
|
||||
|
||||
function seriesStatusLabel(status: SeriesProjection["status"]) {
|
||||
switch (status) {
|
||||
case "inactive":
|
||||
return "비활성";
|
||||
case "waiting":
|
||||
return "대기";
|
||||
case "ready":
|
||||
return "경기 가능";
|
||||
case "in-progress":
|
||||
return "진행 중";
|
||||
case "completed":
|
||||
return "종료";
|
||||
}
|
||||
}
|
||||
|
||||
function competitionCommandErrorMessage(error: unknown) {
|
||||
const code = competitionCommandErrorCode(error);
|
||||
if (code === "REVERSAL_PREVIEW_STALE") {
|
||||
return "미리보기 이후 Competition이 변경되었습니다. 최신 revision에서 영향을 다시 계산하세요.";
|
||||
}
|
||||
if (code === "REVERSAL_DESCENDANT_ACTIVITY") {
|
||||
return "후속 Series에 결과 또는 코드 사용 이력이 있습니다. Cascade 모드로 영향을 다시 계산하세요.";
|
||||
}
|
||||
if (code === "WALKOVER_HAS_ACTIVE_GAMES") {
|
||||
return "이미 반영된 게임이 있어 부전승 처리할 수 없습니다. 몰수패 또는 운영자 판정을 사용하세요.";
|
||||
}
|
||||
if (code === "ADJUDICATION_DRAW_NOT_ALLOWED") {
|
||||
return "이 Series 규칙은 운영자 무승부를 허용하지 않습니다.";
|
||||
}
|
||||
if (error instanceof ApiError) {
|
||||
if (error.status === 412) {
|
||||
return "Competition revision이 변경되었습니다. 최신 revision을 불러온 뒤 다시 시도하세요.";
|
||||
}
|
||||
if (error.status === 409) {
|
||||
return `현재 결과 상태와 충돌했습니다. ${error.message}`;
|
||||
}
|
||||
if (error.status === 422) {
|
||||
return `요청을 적용할 수 없습니다. ${error.message}`;
|
||||
}
|
||||
if (error.status === 403) {
|
||||
return "이 Competition 결과를 관리할 권한이 없습니다.";
|
||||
}
|
||||
}
|
||||
return error instanceof Error
|
||||
? error.message
|
||||
: "Competition 명령을 처리하지 못했습니다.";
|
||||
}
|
||||
|
||||
function competitionCommandErrorCode(error: unknown) {
|
||||
if (!(error instanceof ApiError)) return null;
|
||||
const envelope = error.data as { error?: { code?: unknown } } | null;
|
||||
return typeof envelope?.error?.code === "string" ? envelope.error.code : null;
|
||||
}
|
||||
@@ -0,0 +1,185 @@
|
||||
import type {
|
||||
BracketRoundView,
|
||||
CompetitionDetailResponse,
|
||||
CompetitionOutcome,
|
||||
TeamId,
|
||||
} from "@lolympus/contracts";
|
||||
import { Link } from "react-router";
|
||||
import { RoundRobinTable } from "./RoundRobinTable";
|
||||
import { SeriesScoreCard } from "./SeriesScoreCard";
|
||||
|
||||
export function CompetitionResults({
|
||||
competition,
|
||||
}: {
|
||||
competition: CompetitionDetailResponse;
|
||||
}) {
|
||||
const { projection } = competition;
|
||||
const teamById = new Map(
|
||||
competition.teams.map((team) => [team.teamId, team]),
|
||||
);
|
||||
const seriesById = new Map(
|
||||
projection.series.map((series) => [series.seriesId, series]),
|
||||
);
|
||||
|
||||
return (
|
||||
<section className="mb-6 space-y-4" aria-labelledby="competition-heading">
|
||||
<header className="flex flex-wrap items-end justify-between gap-3 border-b border-base-content/10 pb-3">
|
||||
<div>
|
||||
<p className="text-[11px] font-bold uppercase tracking-wider text-base-content/35">
|
||||
Competition
|
||||
</p>
|
||||
<h2 id="competition-heading" className="mt-1 text-lg font-bold">
|
||||
공식 경기 결과
|
||||
</h2>
|
||||
</div>
|
||||
<div className="flex items-center gap-3">
|
||||
<span className="text-xs text-base-content/40">
|
||||
revision {competition.revision}
|
||||
</span>
|
||||
<Link
|
||||
to={`/match/${competition.matchId}/team`}
|
||||
className="border border-base-content/10 px-2.5 py-1.5 text-xs font-bold text-base-content/55 hover:border-primary/30 hover:text-primary focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary"
|
||||
>
|
||||
내 팀 진행
|
||||
</Link>
|
||||
</div>
|
||||
</header>
|
||||
|
||||
{projection.outcome && (
|
||||
<OutcomeSummary outcome={projection.outcome} teamById={teamById} />
|
||||
)}
|
||||
|
||||
{projection.formatType === "round-robin" && (
|
||||
<RoundRobinTable standings={projection.standings} teamById={teamById} />
|
||||
)}
|
||||
|
||||
{projection.rounds.length > 0 ? (
|
||||
<div className="overflow-x-auto pb-2">
|
||||
<div className="grid min-w-max auto-cols-[17rem] grid-flow-col gap-4">
|
||||
{projection.rounds.map((round) => (
|
||||
<RoundColumn
|
||||
key={`${round.stage}:${round.roundNumber ?? 0}`}
|
||||
round={round}
|
||||
seriesById={seriesById}
|
||||
teamById={teamById}
|
||||
/>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
) : (
|
||||
<p
|
||||
className="border border-dashed border-base-content/15 px-4 py-5 text-sm text-base-content/45"
|
||||
role="status"
|
||||
>
|
||||
편성된 공식 대진이 없습니다.
|
||||
</p>
|
||||
)}
|
||||
|
||||
{projection.games.length > 0 && (
|
||||
<div className="border border-base-content/10 bg-base-content/[0.02] p-4">
|
||||
<h3 className="text-xs font-bold uppercase tracking-wider text-base-content/40">
|
||||
완료된 게임
|
||||
</h3>
|
||||
<ul className="mt-3 grid gap-2 sm:grid-cols-2 lg:grid-cols-3">
|
||||
{projection.games.map((game) => (
|
||||
<li
|
||||
key={game.id}
|
||||
className="flex items-center justify-between gap-3 border border-base-content/8 bg-base-100 px-3 py-2 text-xs"
|
||||
>
|
||||
<span className="text-base-content/45">
|
||||
Game {game.displayNumber}
|
||||
</span>
|
||||
<span className="truncate font-semibold">
|
||||
{teamById.get(game.winnerTeamId)?.name ?? "알 수 없는 팀"} 승
|
||||
</span>
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
</div>
|
||||
)}
|
||||
</section>
|
||||
);
|
||||
}
|
||||
|
||||
function RoundColumn({
|
||||
round,
|
||||
seriesById,
|
||||
teamById,
|
||||
}: {
|
||||
round: BracketRoundView;
|
||||
seriesById: Map<
|
||||
string,
|
||||
CompetitionDetailResponse["projection"]["series"][number]
|
||||
>;
|
||||
teamById: Map<TeamId, CompetitionDetailResponse["teams"][number]>;
|
||||
}) {
|
||||
return (
|
||||
<section aria-label={round.label} className="space-y-2">
|
||||
<h3 className="px-1 text-xs font-bold text-base-content/45">
|
||||
{stageLabel(round.stage, round.roundNumber)}
|
||||
</h3>
|
||||
<div className="space-y-3">
|
||||
{round.seriesIds.map((seriesId) => {
|
||||
const series = seriesById.get(seriesId);
|
||||
return series ? (
|
||||
<SeriesScoreCard
|
||||
key={series.seriesId}
|
||||
series={series}
|
||||
teamById={teamById}
|
||||
/>
|
||||
) : null;
|
||||
})}
|
||||
</div>
|
||||
</section>
|
||||
);
|
||||
}
|
||||
|
||||
function OutcomeSummary({
|
||||
outcome,
|
||||
teamById,
|
||||
}: {
|
||||
outcome: CompetitionOutcome;
|
||||
teamById: Map<TeamId, CompetitionDetailResponse["teams"][number]>;
|
||||
}) {
|
||||
if (outcome.type === "paired-series") {
|
||||
return (
|
||||
<p className="border-l-2 border-success bg-success/5 px-3 py-2 text-sm text-base-content/65">
|
||||
{outcome.completedSeriesIds.length + outcome.drawnSeriesIds.length}개
|
||||
Series가 모두 종료되었습니다.
|
||||
</p>
|
||||
);
|
||||
}
|
||||
const leaders =
|
||||
outcome.type === "round-robin"
|
||||
? outcome.leaderTeamIds
|
||||
: [outcome.championTeamId];
|
||||
return (
|
||||
<p className="border-l-2 border-success bg-success/5 px-3 py-2 text-sm">
|
||||
<span className="mr-2 text-xs font-bold text-success">
|
||||
{outcome.type === "round-robin" ? "1위" : "우승"}
|
||||
</span>
|
||||
<span className="font-bold">
|
||||
{leaders
|
||||
.map((teamId) => teamById.get(teamId)?.name ?? "알 수 없는 팀")
|
||||
.join(", ")}
|
||||
</span>
|
||||
</p>
|
||||
);
|
||||
}
|
||||
|
||||
function stageLabel(stage: BracketRoundView["stage"], round?: number) {
|
||||
switch (stage) {
|
||||
case "pair":
|
||||
return "대진";
|
||||
case "round-robin":
|
||||
return `${round ?? 1}라운드`;
|
||||
case "upper":
|
||||
return `승자조 ${round ?? 1}라운드`;
|
||||
case "lower":
|
||||
return `패자조 ${round ?? 1}라운드`;
|
||||
case "grand-final":
|
||||
return "그랜드 파이널";
|
||||
case "reset-final":
|
||||
return "리셋 파이널";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
import type {
|
||||
CompetitionTeamView,
|
||||
RoundRobinStandingView,
|
||||
TeamId,
|
||||
} from "@lolympus/contracts";
|
||||
|
||||
export function RoundRobinTable({
|
||||
standings,
|
||||
teamById,
|
||||
}: {
|
||||
standings: RoundRobinStandingView[];
|
||||
teamById: ReadonlyMap<TeamId, CompetitionTeamView>;
|
||||
}) {
|
||||
return (
|
||||
<div className="overflow-x-auto border border-base-content/10">
|
||||
<table className="w-full min-w-[36rem] text-left text-xs">
|
||||
<caption className="sr-only">라운드 로빈 공식 순위</caption>
|
||||
<thead className="border-b border-base-content/10 bg-base-200/40 text-base-content/40">
|
||||
<tr>
|
||||
<th scope="col" className="w-14 px-3 py-2 font-semibold">
|
||||
순위
|
||||
</th>
|
||||
<th scope="col" className="px-3 py-2 font-semibold">
|
||||
팀
|
||||
</th>
|
||||
<th scope="col" className="px-3 py-2 text-right font-semibold">
|
||||
전적
|
||||
</th>
|
||||
<th scope="col" className="px-3 py-2 text-right font-semibold">
|
||||
게임
|
||||
</th>
|
||||
<th scope="col" className="px-3 py-2 text-right font-semibold">
|
||||
득실
|
||||
</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody className="divide-y divide-base-content/8">
|
||||
{standings.map((standing) => (
|
||||
<tr key={standing.teamId}>
|
||||
<td className="px-3 py-2.5 font-mono font-bold tabular-nums">
|
||||
{standing.rank}
|
||||
</td>
|
||||
<th scope="row" className="px-3 py-2.5 font-semibold">
|
||||
{teamById.get(standing.teamId)?.name ?? "알 수 없는 팀"}
|
||||
</th>
|
||||
<td className="px-3 py-2.5 text-right tabular-nums text-base-content/60">
|
||||
{standing.seriesWins}승 {standing.seriesLosses}패
|
||||
{standing.seriesDraws > 0 ? ` ${standing.seriesDraws}무` : ""}
|
||||
</td>
|
||||
<td className="px-3 py-2.5 text-right tabular-nums text-base-content/60">
|
||||
{standing.gameWins}-{standing.gameLosses}
|
||||
</td>
|
||||
<td className="px-3 py-2.5 text-right font-mono font-bold tabular-nums">
|
||||
{standing.gameDiff > 0 ? "+" : ""}
|
||||
{standing.gameDiff}
|
||||
</td>
|
||||
</tr>
|
||||
))}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
import type {
|
||||
CompetitionTeamView,
|
||||
SeriesProjection,
|
||||
TeamId,
|
||||
} from "@lolympus/contracts";
|
||||
|
||||
const STATUS_LABEL: Record<SeriesProjection["status"], string> = {
|
||||
inactive: "비활성",
|
||||
waiting: "대진 대기",
|
||||
ready: "경기 가능",
|
||||
"in-progress": "진행 중",
|
||||
completed: "종료",
|
||||
};
|
||||
|
||||
export function SeriesScoreCard({
|
||||
series,
|
||||
teamById,
|
||||
}: {
|
||||
series: SeriesProjection;
|
||||
teamById: ReadonlyMap<TeamId, CompetitionTeamView>;
|
||||
}) {
|
||||
const winnerTeamId =
|
||||
series.status === "completed" && series.outcome.type !== "draw"
|
||||
? series.outcome.winnerTeamId
|
||||
: null;
|
||||
|
||||
return (
|
||||
<article
|
||||
className="border border-base-content/10 bg-base-100"
|
||||
aria-label={`${series.code ?? "경기"} ${STATUS_LABEL[series.status]}`}
|
||||
>
|
||||
<header className="flex items-center justify-between gap-3 border-b border-base-content/8 px-3 py-2">
|
||||
<span className="truncate text-xs font-bold text-base-content/65">
|
||||
{series.code ?? "Series"}
|
||||
</span>
|
||||
<span className="shrink-0 text-[11px] text-base-content/40">
|
||||
{STATUS_LABEL[series.status]}
|
||||
</span>
|
||||
</header>
|
||||
<div className="divide-y divide-base-content/8">
|
||||
{series.entries.map((entry) => {
|
||||
const team = entry.teamId ? teamById.get(entry.teamId) : undefined;
|
||||
const isWinner = entry.teamId === winnerTeamId;
|
||||
return (
|
||||
<div
|
||||
key={entry.slot}
|
||||
className="grid grid-cols-[1.5rem_minmax(0,1fr)_2rem] items-center gap-2 px-3 py-2.5"
|
||||
>
|
||||
<span className="text-[10px] font-bold text-base-content/30">
|
||||
{entry.slot}
|
||||
</span>
|
||||
<span
|
||||
className={`truncate text-sm ${
|
||||
isWinner
|
||||
? "font-bold text-base-content"
|
||||
: "text-base-content/60"
|
||||
}`}
|
||||
>
|
||||
{team?.name ?? (entry.teamId ? "알 수 없는 팀" : "대기 중")}
|
||||
{isWinner && (
|
||||
<span className="ml-2 text-[10px] font-bold text-success">
|
||||
승리
|
||||
</span>
|
||||
)}
|
||||
</span>
|
||||
<span className="text-right font-mono text-base font-bold tabular-nums text-base-content/75">
|
||||
{entry.gameWins}
|
||||
</span>
|
||||
</div>
|
||||
);
|
||||
})}
|
||||
</div>
|
||||
</article>
|
||||
);
|
||||
}
|
||||
@@ -29,6 +29,9 @@ function resolveErrorMessage(status: number, data: unknown) {
|
||||
const message = (data as { message?: unknown }).message;
|
||||
if (typeof message === 'string') return message;
|
||||
if (Array.isArray(message)) return message.join(', ');
|
||||
const nestedMessage = (data as { error?: { message?: unknown } }).error
|
||||
?.message;
|
||||
if (typeof nestedMessage === 'string') return nestedMessage;
|
||||
}
|
||||
return `API request failed (${status})`;
|
||||
}
|
||||
@@ -85,7 +88,11 @@ export async function apiFetch<T>(
|
||||
|
||||
const data = await readResponseBody(response);
|
||||
if (!response.ok) {
|
||||
throw new ApiError(response.status, resolveErrorMessage(response.status, data), data);
|
||||
throw new ApiError(
|
||||
response.status,
|
||||
resolveErrorMessage(response.status, data),
|
||||
data,
|
||||
);
|
||||
}
|
||||
|
||||
return data as T;
|
||||
|
||||
@@ -390,23 +390,15 @@ function formatCompactDateTime(dateLike: string) {
|
||||
function HistoryMetaText({
|
||||
map,
|
||||
participants,
|
||||
result,
|
||||
}: {
|
||||
map: string;
|
||||
participants: number;
|
||||
result?: string;
|
||||
}) {
|
||||
return (
|
||||
<div className={HISTORY_MOBILE_META_CLASS}>
|
||||
<span>{map}</span>
|
||||
<span className="text-base-content/20">·</span>
|
||||
<span>{participants}명</span>
|
||||
{result && (
|
||||
<>
|
||||
<span className="text-base-content/20">·</span>
|
||||
<span>{result}</span>
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -691,11 +683,12 @@ export default function HomePage() {
|
||||
{match.participants.length}명
|
||||
</td>
|
||||
<td className="py-2.5 px-4 text-xs text-base-content/50 whitespace-nowrap">
|
||||
<span className="block truncate">
|
||||
{match.result?.winner
|
||||
? `${match.result.winner} 승리`
|
||||
: '-'}
|
||||
</span>
|
||||
<Link
|
||||
to={`/match/${match.id}`}
|
||||
className="font-semibold text-base-content/45 hover:text-primary"
|
||||
>
|
||||
공식 결과
|
||||
</Link>
|
||||
</td>
|
||||
</tr>
|
||||
))
|
||||
@@ -717,10 +710,6 @@ export default function HomePage() {
|
||||
<div className="md:hidden border border-base-content/10">
|
||||
{historyMatches.length > 0 ? (
|
||||
historyMatches.map((match) => {
|
||||
const resultLabel = match.result?.winner
|
||||
? `${match.result.winner} 승리`
|
||||
: undefined;
|
||||
|
||||
return (
|
||||
<Link
|
||||
key={match.id}
|
||||
@@ -747,7 +736,6 @@ export default function HomePage() {
|
||||
<HistoryMetaText
|
||||
map={match.map}
|
||||
participants={match.participants.length}
|
||||
result={resultLabel}
|
||||
/>
|
||||
</div>
|
||||
</Link>
|
||||
|
||||
+649
-2805
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -1,5 +1,10 @@
|
||||
import { useMemo, useState } from 'react';
|
||||
import { useQueryClient } from '@tanstack/react-query';
|
||||
import type {
|
||||
MatchDetailResponse,
|
||||
MatchGameMode,
|
||||
MatchScheduleItemView,
|
||||
} from '@lolympus/contracts';
|
||||
import { Link, useParams } from 'react-router';
|
||||
import {
|
||||
useCreateMatch,
|
||||
@@ -8,12 +13,7 @@ import {
|
||||
useMe,
|
||||
useUpdateMatch,
|
||||
} from '../../api/hooks';
|
||||
import type {
|
||||
ApiMatch,
|
||||
ApiMatchScheduleItem,
|
||||
MatchGameMode,
|
||||
MatchMutationRequest,
|
||||
} from '../../api/types';
|
||||
import type { MatchMutationRequest } from '../../api/types';
|
||||
import { DEFAULT_COMMUNITY_ID } from '../../config';
|
||||
|
||||
const DEFAULT_FORM: MatchMutationRequest = {
|
||||
@@ -32,7 +32,6 @@ const DEFAULT_FORM: MatchMutationRequest = {
|
||||
|
||||
const GAME_MODE_LABEL: Record<MatchGameMode, string> = {
|
||||
pair: '페어',
|
||||
bracket: '브래킷',
|
||||
'round-robin': '라운드 로빈',
|
||||
'double-elimination': '더블 엘리미네이션',
|
||||
};
|
||||
@@ -93,7 +92,7 @@ function parseLines(value: string) {
|
||||
.filter(Boolean);
|
||||
}
|
||||
|
||||
function parseSchedule(value: string): ApiMatchScheduleItem[] {
|
||||
function parseSchedule(value: string): MatchScheduleItemView[] {
|
||||
return parseLines(value).map((line) => {
|
||||
const [time, ...labelParts] = line.split('|').map((part) => part.trim());
|
||||
return {
|
||||
@@ -103,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;
|
||||
@@ -131,7 +130,7 @@ function makeForm(match?: ApiMatch): MatchMutationRequest & {
|
||||
gameMode: match.gameMode ?? 'pair',
|
||||
roundRobinMaxRounds: match.roundRobinMaxRounds,
|
||||
doubleEliminationResetFinalEnabled:
|
||||
match.doubleElimination?.resetFinalEnabled ?? true,
|
||||
match.doubleEliminationResetFinalEnabled ?? true,
|
||||
prizes: match.prizes,
|
||||
notices: match.notices,
|
||||
schedule: match.schedule,
|
||||
@@ -150,7 +149,7 @@ export default function MatchAdminPage() {
|
||||
const createMutation = useCreateMatch(communityId);
|
||||
const updateMutation = useUpdateMatch(communityId);
|
||||
const deleteMutation = useDeleteMatch(communityId);
|
||||
const [editing, setEditing] = useState<ApiMatch | null>(null);
|
||||
const [editing, setEditing] = useState<MatchDetailResponse | null>(null);
|
||||
const [showForm, setShowForm] = useState(false);
|
||||
const [form, setForm] = useState(makeForm());
|
||||
const [message, setMessage] = useState<string | null>(null);
|
||||
@@ -182,7 +181,7 @@ export default function MatchAdminPage() {
|
||||
setMessage(null);
|
||||
}
|
||||
|
||||
function openEdit(match: ApiMatch) {
|
||||
function openEdit(match: MatchDetailResponse) {
|
||||
setEditing(match);
|
||||
setForm(makeForm(match));
|
||||
setShowForm(true);
|
||||
@@ -533,7 +532,7 @@ export default function MatchAdminPage() {
|
||||
{match.gameMode === 'double-elimination' && (
|
||||
<span className="block text-xs text-base-content/30">
|
||||
GF 리셋{' '}
|
||||
{match.doubleElimination?.resetFinalEnabled
|
||||
{match.doubleEliminationResetFinalEnabled
|
||||
? '허용'
|
||||
: '없음'}
|
||||
</span>
|
||||
@@ -551,7 +550,15 @@ export default function MatchAdminPage() {
|
||||
<button
|
||||
type="button"
|
||||
className="text-xs px-2 py-1 border border-red-500/20 text-red-400 hover:bg-red-500/10"
|
||||
disabled={deleteMutation.isPending}
|
||||
disabled={
|
||||
deleteMutation.isPending ||
|
||||
match.status !== 'recruiting'
|
||||
}
|
||||
title={
|
||||
match.status === 'recruiting'
|
||||
? '내전 삭제'
|
||||
: '팀 구성이 확정된 내전 기록은 삭제할 수 없습니다.'
|
||||
}
|
||||
onClick={() => {
|
||||
if (!window.confirm('이 내전을 삭제할까요?')) return;
|
||||
deleteMutation.mutate(match._id, {
|
||||
|
||||
@@ -0,0 +1,94 @@
|
||||
interface RevisionedSnapshot {
|
||||
revision: number;
|
||||
}
|
||||
|
||||
export type TeamProgressErrorContent = {
|
||||
kind:
|
||||
| "unauthorized"
|
||||
| "forbidden"
|
||||
| "not-found"
|
||||
| "not-ready"
|
||||
| "server"
|
||||
| "network"
|
||||
| "unknown";
|
||||
title: string;
|
||||
description: string;
|
||||
};
|
||||
|
||||
export function isConsistentTeamProgressSnapshot(
|
||||
competition: RevisionedSnapshot | null | undefined,
|
||||
teamView: RevisionedSnapshot | null | undefined,
|
||||
): boolean {
|
||||
return Boolean(
|
||||
competition &&
|
||||
teamView &&
|
||||
competition.revision === teamView.revision,
|
||||
);
|
||||
}
|
||||
|
||||
export function getTeamProgressErrorContent(
|
||||
errors: readonly unknown[],
|
||||
): TeamProgressErrorContent {
|
||||
const statuses = errors.flatMap((error) => {
|
||||
if (typeof error !== "object" || error === null || !("status" in error)) {
|
||||
return [];
|
||||
}
|
||||
return typeof error.status === "number" ? [error.status] : [];
|
||||
});
|
||||
|
||||
if (statuses.includes(401)) {
|
||||
return {
|
||||
kind: "unauthorized",
|
||||
title: "로그인이 필요합니다",
|
||||
description: "팀 진행 정보를 보려면 로그인한 뒤 다시 시도해 주세요.",
|
||||
};
|
||||
}
|
||||
if (statuses.includes(403)) {
|
||||
return {
|
||||
kind: "forbidden",
|
||||
title: "팀 진행 정보를 볼 권한이 없습니다",
|
||||
description:
|
||||
"이 내전에 참여한 팀원 계정으로 로그인했는지 확인해 주세요.",
|
||||
};
|
||||
}
|
||||
if (statuses.includes(404)) {
|
||||
return {
|
||||
kind: "not-found",
|
||||
title: "팀 진행 정보를 찾을 수 없습니다",
|
||||
description: "내전이 삭제되었거나 Competition이 아직 준비되지 않았습니다.",
|
||||
};
|
||||
}
|
||||
if (statuses.includes(409)) {
|
||||
return {
|
||||
kind: "not-ready",
|
||||
title: "Competition이 아직 준비되지 않았습니다",
|
||||
description: "팀 구성이 완료된 뒤 다시 시도해 주세요.",
|
||||
};
|
||||
}
|
||||
if (statuses.some((status) => status >= 500 && status <= 599)) {
|
||||
return {
|
||||
kind: "server",
|
||||
title: "서버에서 팀 진행 정보를 불러오지 못했습니다",
|
||||
description: "잠시 후 다시 시도해 주세요.",
|
||||
};
|
||||
}
|
||||
if (errors.some(isNetworkError)) {
|
||||
return {
|
||||
kind: "network",
|
||||
title: "네트워크에 연결할 수 없습니다",
|
||||
description: "인터넷 연결을 확인한 뒤 다시 시도해 주세요.",
|
||||
};
|
||||
}
|
||||
return {
|
||||
kind: "unknown",
|
||||
title: "팀 진행 정보를 불러오지 못했습니다",
|
||||
description: "일시적인 오류일 수 있습니다. 다시 시도해 주세요.",
|
||||
};
|
||||
}
|
||||
|
||||
function isNetworkError(error: unknown): boolean {
|
||||
return (
|
||||
error instanceof TypeError ||
|
||||
(error instanceof Error && error.name === "TypeError")
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
import assert from "node:assert/strict";
|
||||
import test from "node:test";
|
||||
import {
|
||||
executeAuthScopedQuery,
|
||||
resolveAuthQueryScope,
|
||||
} from "../src/api/auth-query-scope.ts";
|
||||
|
||||
test("waits for MSAL before an anonymous optional-auth query starts", () => {
|
||||
const scope = resolveAuthQueryScope({
|
||||
authUserId: null,
|
||||
accountKey: null,
|
||||
msalConfigured: true,
|
||||
msalReady: false,
|
||||
});
|
||||
|
||||
assert.equal(scope.ready, false);
|
||||
assert.deepEqual(scope.cacheKey, [null, null]);
|
||||
});
|
||||
|
||||
test("allows an anonymous query once MSAL initialization finishes", () => {
|
||||
const scope = resolveAuthQueryScope({
|
||||
authUserId: null,
|
||||
accountKey: null,
|
||||
msalConfigured: true,
|
||||
msalReady: true,
|
||||
});
|
||||
|
||||
assert.equal(scope.ready, true);
|
||||
});
|
||||
|
||||
test("allows dev auth during MSAL startup and scopes its cache by user", () => {
|
||||
const first = resolveAuthQueryScope({
|
||||
authUserId: "dev-user-1",
|
||||
accountKey: null,
|
||||
msalConfigured: true,
|
||||
msalReady: false,
|
||||
});
|
||||
const second = resolveAuthQueryScope({
|
||||
authUserId: "dev-user-2",
|
||||
accountKey: null,
|
||||
msalConfigured: true,
|
||||
msalReady: false,
|
||||
});
|
||||
|
||||
assert.equal(first.ready, true);
|
||||
assert.notDeepEqual(first.cacheKey, second.cacheKey);
|
||||
});
|
||||
|
||||
test("separates optional-auth query caches by MSAL account", () => {
|
||||
const first = resolveAuthQueryScope({
|
||||
authUserId: null,
|
||||
accountKey: "account-1",
|
||||
msalConfigured: true,
|
||||
msalReady: true,
|
||||
});
|
||||
const second = resolveAuthQueryScope({
|
||||
authUserId: null,
|
||||
accountKey: "account-2",
|
||||
msalConfigured: true,
|
||||
msalReady: true,
|
||||
});
|
||||
|
||||
assert.notDeepEqual(first.cacheKey, second.cacheKey);
|
||||
});
|
||||
|
||||
test("keeps the existing dev or anonymous request path when no account exists", async () => {
|
||||
let tokenAcquisitions = 0;
|
||||
|
||||
const result = await executeAuthScopedQuery({
|
||||
accountKey: null,
|
||||
acquireAccessToken: () => {
|
||||
tokenAcquisitions += 1;
|
||||
return Promise.resolve("unused-token");
|
||||
},
|
||||
request: (authorizationHeader) =>
|
||||
Promise.resolve(authorizationHeader ?? "dev-or-anonymous"),
|
||||
});
|
||||
|
||||
assert.equal(result, "dev-or-anonymous");
|
||||
assert.equal(tokenAcquisitions, 0);
|
||||
});
|
||||
|
||||
test("does not run an anonymous request when account token acquisition fails", async () => {
|
||||
let requests = 0;
|
||||
|
||||
await assert.rejects(
|
||||
executeAuthScopedQuery({
|
||||
accountKey: "account-1",
|
||||
acquireAccessToken: () => Promise.reject(new Error("token failed")),
|
||||
request: () => {
|
||||
requests += 1;
|
||||
return Promise.resolve("must-not-run");
|
||||
},
|
||||
}),
|
||||
/token failed/,
|
||||
);
|
||||
assert.equal(requests, 0);
|
||||
});
|
||||
|
||||
test("sends an explicit bearer token for an authenticated account", async () => {
|
||||
const authorizationHeader = await executeAuthScopedQuery({
|
||||
accountKey: "account-1",
|
||||
acquireAccessToken: () => Promise.resolve("access-token"),
|
||||
request: (header) => Promise.resolve(header),
|
||||
});
|
||||
|
||||
assert.equal(authorizationHeader, "Bearer access-token");
|
||||
});
|
||||
@@ -0,0 +1,57 @@
|
||||
import assert from "node:assert/strict";
|
||||
import test from "node:test";
|
||||
import {
|
||||
getTeamProgressErrorContent,
|
||||
isConsistentTeamProgressSnapshot,
|
||||
} from "../src/pages/match-team-progress-state.ts";
|
||||
|
||||
test("only accepts Competition and team snapshots with the same revision", () => {
|
||||
assert.equal(
|
||||
isConsistentTeamProgressSnapshot({ revision: 7 }, { revision: 7 }),
|
||||
true,
|
||||
);
|
||||
assert.equal(
|
||||
isConsistentTeamProgressSnapshot({ revision: 7 }, { revision: 8 }),
|
||||
false,
|
||||
);
|
||||
assert.equal(isConsistentTeamProgressSnapshot(undefined, { revision: 7 }), false);
|
||||
});
|
||||
|
||||
test("describes a 401 response as an authentication error", () => {
|
||||
assert.equal(
|
||||
getTeamProgressErrorContent([{ status: 401 }]).kind,
|
||||
"unauthorized",
|
||||
);
|
||||
});
|
||||
|
||||
test("describes a 403 response as a team access error", () => {
|
||||
assert.equal(
|
||||
getTeamProgressErrorContent([{ status: 403 }]).kind,
|
||||
"forbidden",
|
||||
);
|
||||
});
|
||||
|
||||
test("describes a 404 response as missing Competition data", () => {
|
||||
assert.equal(getTeamProgressErrorContent([{ status: 404 }]).kind, "not-found");
|
||||
});
|
||||
|
||||
test("describes a 5xx response as a server error", () => {
|
||||
assert.equal(getTeamProgressErrorContent([{ status: 503 }]).kind, "server");
|
||||
});
|
||||
|
||||
test("describes a failed fetch as a network error", () => {
|
||||
assert.equal(
|
||||
getTeamProgressErrorContent([new TypeError("Failed to fetch")]).kind,
|
||||
"network",
|
||||
);
|
||||
});
|
||||
|
||||
test("prioritizes authentication and authorization errors from either query", () => {
|
||||
assert.equal(
|
||||
getTeamProgressErrorContent([
|
||||
new TypeError("Failed to fetch"),
|
||||
{ status: 403 },
|
||||
]).kind,
|
||||
"forbidden",
|
||||
);
|
||||
});
|
||||
@@ -0,0 +1,391 @@
|
||||
# Spec: Competition Result Domain
|
||||
|
||||
## Objective
|
||||
|
||||
Replace the positional, duplicated tournament result state currently stored across
|
||||
`Match.result`, `Match.doubleElimination`, and `TournamentCode` with a dedicated
|
||||
Competition aggregate.
|
||||
|
||||
The replacement must make accepted game evidence and explicit administrative
|
||||
adjudications the durable facts. A single deterministic projector derives every
|
||||
score, leader, series outcome, bracket participant, standing, placement, and
|
||||
competition outcome.
|
||||
|
||||
The change fixes the production failure where `WB_R2_M2` was stored with bracket
|
||||
slots `A=8, B=3`, while the independently sorted series score used `A=3, B=8`,
|
||||
causing team 3 to advance despite team 8 winning two games.
|
||||
|
||||
## Approved Product Decisions
|
||||
|
||||
- Recruitment and team building remain on `Match`; competitive play is a separate
|
||||
one-to-one `Competition` aggregate.
|
||||
- Team identity is an opaque string/ObjectId and is independent from display order
|
||||
and seed number.
|
||||
- The API and web app switch to the new contract together. No legacy result response
|
||||
adapter or dual canonical write path remains after cutover.
|
||||
- The unused `bracket` mode is removed. Legacy documents using it migrate to
|
||||
`paired-series`, matching their actual historical execution path.
|
||||
- Round-robin ranking uses series wins, game differential, and a tied-group
|
||||
head-to-head mini-table. Remaining ties share the same rank.
|
||||
- Parent-result reversal is strict by default. Administrators can request an impact
|
||||
preview and execute an explicit, hash-confirmed cascade reversal.
|
||||
- Full event sourcing is out of scope. Competition configuration is a state snapshot;
|
||||
accepted results, adjudications, and reversals form an append-only fact ledger.
|
||||
|
||||
## Tech Stack
|
||||
|
||||
- NestJS 11 and Mongoose 9 in `apps/api`
|
||||
- React 19, TypeScript, and Vite in `apps/web`
|
||||
- pnpm workspace with shared wire contracts under `packages/contracts`
|
||||
- MongoDB transactions for command atomicity
|
||||
- Redis locks only as duplicate-work optimization
|
||||
- Jest for API/domain tests
|
||||
|
||||
## Commands
|
||||
|
||||
- API unit/integration tests: `pnpm --filter api test`
|
||||
- Focused API test: `pnpm --filter api exec jest --runInBand <test-path>`
|
||||
- API build: `pnpm --filter api build`
|
||||
- Web build/typecheck: `pnpm --filter web build`
|
||||
- Migration dry-run: `pnpm --filter api competition:migrate -- --dry-run`
|
||||
- Migration apply: `pnpm --filter api competition:migrate -- --apply`
|
||||
|
||||
## Project Structure
|
||||
|
||||
- `packages/contracts/` owns public Competition/Series/Game DTOs and branded wire IDs.
|
||||
- `apps/api/src/modules/competition/domain/` owns format definitions, graph generation,
|
||||
invariant validation, and pure projectors.
|
||||
- `apps/api/src/modules/competition/` owns persistence, commands, presenters, and HTTP
|
||||
integration.
|
||||
- `apps/api/src/modules/global/database/migrations/` owns pure migration planning and
|
||||
database application.
|
||||
- Existing `riot_match` remains the immutable external evidence archive.
|
||||
- Existing `match_stats` remains a rebuildable read model and gains source revision
|
||||
checks.
|
||||
|
||||
## Domain Model
|
||||
|
||||
### Match and Competition
|
||||
|
||||
`Match` continues to own recruiting, participants, team building, notices, prizes,
|
||||
and scheduling metadata. It receives a unique optional `competitionId`.
|
||||
|
||||
`Competition` owns:
|
||||
|
||||
- immutable team snapshots after the first accepted result;
|
||||
- a format-specific, versioned Series graph;
|
||||
- a monotonic revision;
|
||||
- a projector version;
|
||||
- a rebuildable current projection cache.
|
||||
|
||||
Exactly one Competition may reference a Match.
|
||||
|
||||
Competition creation is an explicit side effect of the finalized team-building
|
||||
workflow. Read endpoints never create state. If a finalized Match is observed before
|
||||
its Competition has been linked, the API reports that initialization is still in
|
||||
progress instead of attempting a lazy bootstrap.
|
||||
|
||||
After `competitionId` is linked, the Match cannot return to recruiting, change its
|
||||
game count, reset or undo its auction, or be hard-deleted through ordinary Match
|
||||
operations. Corrections happen through Competition facts and reversals; replacing the
|
||||
event requires a new Match. The legacy-import bulk-delete operation is the one
|
||||
explicit destructive exception and removes the whole aggregate and its dependent
|
||||
read models transactionally.
|
||||
|
||||
Joining a Match is an authenticated self-service action. The normal participant
|
||||
endpoint always derives the participant from the authenticated user; only the
|
||||
administrator endpoint may add another community member.
|
||||
|
||||
### Identifiers
|
||||
|
||||
- `CompetitionId`, `TeamId`, `SeriesId`, `GameSlotId`, `GameId`, and `FactId` are
|
||||
opaque strings on the wire and ObjectIds in MongoDB.
|
||||
- Display order, seed, round, ordinal, and global display number are never identities.
|
||||
- `WB_R2_M2` is an optional diagnostic/display code, never a parsed control key.
|
||||
- Migration identifiers are deterministic from the Match ID, entity kind, and legacy
|
||||
key so migration is idempotent.
|
||||
|
||||
### Formats
|
||||
|
||||
Supported formats are:
|
||||
|
||||
- `paired-series`: independent fixed-game Series with no overall champion;
|
||||
- `round-robin`: fixed-game Series with shared-rank standings;
|
||||
- `double-elimination`: first-to rules per upper, lower, grand-final, and reset-final
|
||||
stage.
|
||||
|
||||
Fixed-game Series complete only after all configured GameSlots are filled and may
|
||||
draw. First-to Series complete as soon as a team reaches the threshold and cannot
|
||||
draw.
|
||||
|
||||
The legacy double-elimination defaults remain upper=`Match.gameCount`, lower=BO1,
|
||||
grand final=BO1, reset final=BO1.
|
||||
|
||||
### Series Graph
|
||||
|
||||
Every Series has:
|
||||
|
||||
- an opaque ID and optional display code;
|
||||
- explicit stage, round, and display order;
|
||||
- exactly two local slots named A and B;
|
||||
- exactly one source per target slot;
|
||||
- a Series rule;
|
||||
- stable GameSlots identified by Series ID and ordinal;
|
||||
- optional activation rules.
|
||||
|
||||
Only incoming slot sources are stored. Reverse winner/loser destinations are derived.
|
||||
The graph must be acyclic. GF_RESET is created as a stable inactive conditional node,
|
||||
not appended at runtime.
|
||||
|
||||
### Durable Facts
|
||||
|
||||
`competition_fact` is append-only and supports:
|
||||
|
||||
- `game-accepted`;
|
||||
- `game-voided`;
|
||||
- `series-adjudicated`;
|
||||
- `adjudication-reversed`.
|
||||
|
||||
Every fact carries competition ID, command ID, revision, ordinal within revision,
|
||||
schema version, actor, occurrence/record timestamps, and optional causation ID.
|
||||
|
||||
An accepted game records its stable Series/GameSlot, Riot evidence ID and payload
|
||||
hash, mapping algorithm version and confidence, blue/red/winner team IDs, the mapping
|
||||
snapshot used at acceptance time, and a normalized legacy evidence fallback.
|
||||
|
||||
Facts are never updated or deleted. Reversal facts reference the exact fact they
|
||||
invalidate.
|
||||
|
||||
### Administrative Adjudication
|
||||
|
||||
- Walkover requires no active games.
|
||||
- Forfeit may retain partial played-game scores.
|
||||
- Administrative outcome requires a reason and an explicit winner or draw.
|
||||
- At most one active adjudication exists per Series.
|
||||
- Administrative outcome determines the official result while played scores remain
|
||||
visible.
|
||||
- Draw adjudication is invalid for elimination formats.
|
||||
|
||||
### Projection
|
||||
|
||||
The projector is pure, deterministic, versioned, and free of implicit time or random
|
||||
inputs. It derives:
|
||||
|
||||
- actual team in each Series slot;
|
||||
- score entries shaped as `{ slot, teamId, gameWins }`;
|
||||
- Series state;
|
||||
- `leaderTeamId` only for an in-progress Series;
|
||||
- `winnerTeamId` only in a completed outcome;
|
||||
- bracket progression and connectors;
|
||||
- active GameSlots;
|
||||
- round-robin standings and shared ranks;
|
||||
- double-elimination placements and champion;
|
||||
- overall Competition phase/outcome.
|
||||
|
||||
The projector rejects inconsistent evidence rather than guessing. In particular, an
|
||||
accepted game's team set must equal the projected Series team set, ordinals and Riot
|
||||
claims must be unique, and no game may be accepted after completion.
|
||||
|
||||
Round-robin tie order is:
|
||||
|
||||
1. overall series wins;
|
||||
2. overall game differential;
|
||||
3. tied-group mini-table series wins;
|
||||
4. tied-group mini-table game differential;
|
||||
5. shared rank.
|
||||
|
||||
### Tournament Code Assignment
|
||||
|
||||
`TournamentCode` remains the pool resource. Assignment history moves to a separate
|
||||
`tournament_code_assignment` collection keyed by Competition, Series, and GameSlot.
|
||||
Assignments transition through reserved, used, released, or voided without deleting
|
||||
history. Active code and active GameSlot assignments are uniquely indexed.
|
||||
|
||||
Accepting a code-backed Riot game atomically commits the accepted fact, assignment
|
||||
use, code consumption, Competition revision/projection, and outbox events.
|
||||
|
||||
Reversal releases only codes that are in a releasable terminal state and removes all
|
||||
obsolete Match code bindings in the same transaction. Public/team reads validate the
|
||||
active assignment, code state, and Match binding instead of returning stale codes.
|
||||
Expired reserved codes also terminate their active assignment and Match binding
|
||||
atomically so the slot can be provisioned again without an administrative replacement
|
||||
endpoint.
|
||||
|
||||
## Command Semantics
|
||||
|
||||
All Competition mutations require an idempotency key and expected revision.
|
||||
|
||||
Within a MongoDB transaction, the shared command runner:
|
||||
|
||||
1. verifies revision and idempotency;
|
||||
2. appends fact(s);
|
||||
3. runs the projector;
|
||||
4. persists revision and projection;
|
||||
5. updates TournamentCodeAssignment where applicable;
|
||||
6. inserts outbox records;
|
||||
7. commits atomically.
|
||||
|
||||
Transient transaction/write-conflict failures use a bounded retry. Idempotency is
|
||||
rechecked on every attempt, so a concurrent successful command is replayed rather
|
||||
than duplicated. Outbox delivery uses bounded attempts and moves permanently failing
|
||||
events to an explicit `dead-letter` state for operator recovery.
|
||||
|
||||
External Riot fetches occur before the transaction. A stale revision returns HTTP 412,
|
||||
a valid-state conflict returns 409, and invalid input returns 422.
|
||||
|
||||
Strict reversal rejects any descendant accepted game, adjudication, or used code.
|
||||
Reserved descendant codes may be released atomically. Cascade reversal requires a
|
||||
preview generated at the same source revision and an unchanged impact hash. It emits
|
||||
individual reversal facts joined by one causation ID.
|
||||
|
||||
## Public API
|
||||
|
||||
- Public Match and Competition responses are explicit DTOs, never spread Mongoose
|
||||
documents.
|
||||
- The shared Match contract is the single wire definition used by API presenters and
|
||||
web consumers. Authentication is optional on public Match reads solely to compute
|
||||
the required `joined` flag; anonymous reads receive `joined: false`.
|
||||
- Public responses exclude tournament codes, audit actors, and internal fact payloads.
|
||||
- Team view exposes only the authenticated user's team slots and code assignments.
|
||||
- Administrator fact view exposes the audit ledger.
|
||||
- GET responses expose revision/ETag; commands require `If-Match` and
|
||||
`Idempotency-Key`.
|
||||
- The web client never parses Series codes or recomputes official winners/standings.
|
||||
- Storage, domain, and wire types remain separate.
|
||||
|
||||
## Migration
|
||||
|
||||
Migration builds new collections without dual canonical writes.
|
||||
|
||||
- Team, Series, and GameSlot IDs are deterministic.
|
||||
- Riot-backed legacy games become accepted-game facts.
|
||||
- Normalized games without raw archives use explicit legacy evidence.
|
||||
- Winner-only records with no games become administrative adjudications; games are
|
||||
never fabricated.
|
||||
- Active walkovers become walkover adjudications.
|
||||
- Legacy `seriesResults`, bracket winners, and placements are diagnostic only and are
|
||||
not trusted as source facts.
|
||||
- The known A/B positional bug is repaired by projecting accepted games.
|
||||
- Ambiguous mappings, evidence conflicts, or already-played invalid descendants are
|
||||
quarantined.
|
||||
- Legacy `bracket` format becomes `paired-series` with a warning.
|
||||
- Native Mongo migration reads do not receive Mongoose defaults. The hydration
|
||||
boundary restores the historical Match default only when `gameMode` is absent or
|
||||
`null`, mapping it to `pair`; an explicitly stored unknown mode remains
|
||||
quarantined instead of being guessed.
|
||||
- A persisted legacy round-robin `gameSchedule` is authoritative. Migration
|
||||
normalizes it into explicit seed-based pairings on the Competition format so the
|
||||
immutable Series graph reproduces the historical opponents and rounds instead of
|
||||
generating a different canonical schedule. Matches without a persisted schedule
|
||||
continue to use deterministic canonical round-robin generation.
|
||||
- Legacy TournamentCode `gameNumber` is a global GameSlot number, not a Series
|
||||
ordinal. Migration resolves it through accepted Riot evidence first, then the
|
||||
persisted format topology (`gameSchedule` or double-elimination bracket layout),
|
||||
and only uses canonical flattened graph order when no persisted topology exists.
|
||||
- TournamentCode `bracketMatchId`, global `gameNumber`, Riot evidence, and resolved
|
||||
Series/GameSlot must agree. A multi-slot Series is never assigned to its first
|
||||
GameSlot as a fallback; missing, conflicting, duplicated, or out-of-range evidence
|
||||
is quarantined without changing the legacy Match or TournamentCode.
|
||||
- Dry-run is the default and emits machine-readable and human-readable reports.
|
||||
- Apply is resumable, idempotent, transactionally scoped per Match, and verifies fact
|
||||
replay equality after every write.
|
||||
- Apply explicitly creates or verifies every Competition unique/partial index before
|
||||
migrating a Match. Existing target-data/index-definition conflicts block apply with
|
||||
a machine-readable preflight report; source Matches that collide with an already
|
||||
accepted global identity are quarantined rather than guessed or partially written.
|
||||
- Limited apply runs persist the last terminal Match `_id` in a migration checkpoint.
|
||||
The next run resumes strictly after that cursor; a failed Match does not advance the
|
||||
cursor, and an explicit `--after` cursor may override the checkpoint for recovery.
|
||||
- An explicit limited-apply `--after` cursor durably replaces an older checkpoint
|
||||
before scanning, so a failure on the first overridden Match is retried by the next
|
||||
ordinary limited apply.
|
||||
- Dry-run never creates indexes, uses a persisted resume checkpoint, or updates
|
||||
checkpoints; it always audits the requested source range from the beginning unless
|
||||
an explicit `--after` cursor is supplied.
|
||||
|
||||
Legacy Match fields remain untouched for rollback until the new runtime is verified,
|
||||
then a separate cleanup migration removes them.
|
||||
|
||||
## Testing Strategy
|
||||
|
||||
- TDD for graph generation, Series projection, Competition projection, commands, and
|
||||
migration planning.
|
||||
- Unit tests dominate and use pure fixtures.
|
||||
- Integration tests cover Mongo transactions, revision races, idempotency, assignments,
|
||||
and API presenters.
|
||||
- Migration fixtures cover the supplied `data.txt` failure and all ambiguous legacy
|
||||
categories.
|
||||
- API and web production builds are required.
|
||||
- Staging smoke verification covers recruiting through completion and reversal.
|
||||
|
||||
## Code Style
|
||||
|
||||
Prefer explicit discriminated unions and pure functions:
|
||||
|
||||
```ts
|
||||
switch (series.rule.type) {
|
||||
case "first-to":
|
||||
return projectFirstToSeries(series, facts);
|
||||
case "fixed-games":
|
||||
return projectFixedGamesSeries(series, facts);
|
||||
}
|
||||
```
|
||||
|
||||
Never infer identity from ordering and never use a positional score without carrying
|
||||
its `teamId` in the same object.
|
||||
|
||||
## Boundaries
|
||||
|
||||
### Always
|
||||
|
||||
- Write a failing test before behavioral code.
|
||||
- Rebuild official state with the one Competition projector.
|
||||
- Use transactions and expected revisions for mutations.
|
||||
- Preserve accepted evidence and reversal history.
|
||||
- Keep every increment buildable and commit verified slices atomically.
|
||||
|
||||
### Ask First
|
||||
|
||||
- Adding runtime dependencies.
|
||||
- Changing authentication/authorization policy outside Competition endpoints.
|
||||
- Broadening supported team counts or tournament formats.
|
||||
- Applying a migration to a non-test database.
|
||||
|
||||
### Never
|
||||
|
||||
- Treat Redis locks as the correctness boundary.
|
||||
- Dual-write old and new canonical result models.
|
||||
- Parse `WB_*`/`LB_*` codes for control flow.
|
||||
- Delete facts to implement correction.
|
||||
- Fabricate Riot evidence for legacy results.
|
||||
- Expose tournament codes on a public endpoint.
|
||||
- Reintroduce legacy seed reshuffling, positional bracket mutation, or unauthenticated
|
||||
tournament-code replacement endpoints.
|
||||
|
||||
## Success Criteria
|
||||
|
||||
- The supplied `WB_R2_M2` fixture projects team 8 as winner, team 8 into WB_FINAL,
|
||||
and team 3 into LB_R2_M1.
|
||||
- No persisted positional `teamAWins/teamBWins` projection is a source of truth.
|
||||
- In-progress Series cannot expose a winner in TypeScript or API output.
|
||||
- Result, code assignment, projection, and outbox transitions are atomic and
|
||||
idempotent.
|
||||
- Pair, round-robin, and double-elimination flows complete end to end.
|
||||
- Reversal preview/cascade is revision- and hash-protected.
|
||||
- Statistics cannot regress to an older source revision.
|
||||
- A legacy stats builder cannot overwrite a Competition-backed fragment, and a late
|
||||
builder cannot resurrect stats after its Match/Competition has been deleted.
|
||||
- Double-elimination seeds are persisted before the finalized team-build timestamp is
|
||||
exposed, and an expired reserved code can be provisioned again automatically.
|
||||
- Migration dry-run reports zero unclassified documents before apply.
|
||||
- Historical Matches without a persisted `gameMode` plan as `paired-series`, while
|
||||
an explicitly invalid legacy mode is still reported as
|
||||
`UNSUPPORTED_LEGACY_GAME_MODE`.
|
||||
- Competition unique/partial indexes are verified before the first apply write, and
|
||||
repeated limited apply runs advance without rescanning the first page.
|
||||
- API tests and API/web production builds pass.
|
||||
- Legacy result writers, serializers, and frontend code are removed after cutover.
|
||||
|
||||
## Open Questions
|
||||
|
||||
None. Product and architecture decisions were approved before implementation.
|
||||
@@ -0,0 +1,25 @@
|
||||
{
|
||||
"name": "@lolympus/contracts",
|
||||
"version": "0.1.0",
|
||||
"private": true,
|
||||
"type": "module",
|
||||
"sideEffects": false,
|
||||
"main": "./dist/index.js",
|
||||
"types": "./src/index.ts",
|
||||
"exports": {
|
||||
".": {
|
||||
"types": "./src/index.ts",
|
||||
"import": "./dist/index.js"
|
||||
}
|
||||
},
|
||||
"files": [
|
||||
"dist"
|
||||
],
|
||||
"scripts": {
|
||||
"build": "tsc -p tsconfig.build.json",
|
||||
"typecheck": "tsc -p tsconfig.json"
|
||||
},
|
||||
"devDependencies": {
|
||||
"typescript": "^5.7.3"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
import type { CompetitionDetailResponse } from "./competition.js";
|
||||
import type { SeriesAdjudicationDecision } from "./facts.js";
|
||||
import type {
|
||||
CompetitionFactId,
|
||||
GameSlotId,
|
||||
SeriesId,
|
||||
TeamId,
|
||||
} from "./ids.js";
|
||||
|
||||
export interface SwapCompetitionSeedsRequest {
|
||||
firstSeedNumber: number;
|
||||
secondSeedNumber: number;
|
||||
}
|
||||
|
||||
export interface CreateSeriesAdjudicationRequest {
|
||||
decision: SeriesAdjudicationDecision;
|
||||
reason: string;
|
||||
}
|
||||
|
||||
export type SeriesReversalMode = "strict" | "cascade";
|
||||
|
||||
export interface SeriesReversalPreviewRequest {
|
||||
mode: SeriesReversalMode;
|
||||
reason: string;
|
||||
}
|
||||
|
||||
export interface SeriesReversalImpact {
|
||||
seriesIds: SeriesId[];
|
||||
factIds: CompetitionFactId[];
|
||||
gameSlotIds: GameSlotId[];
|
||||
teamIds: TeamId[];
|
||||
releasesReservedCodes: number;
|
||||
voidsUsedCodes: number;
|
||||
requiresStatsRebuild: boolean;
|
||||
}
|
||||
|
||||
export interface SeriesReversalPreviewResponse {
|
||||
sourceRevision: number;
|
||||
impactHash: string;
|
||||
impact: SeriesReversalImpact;
|
||||
}
|
||||
|
||||
export interface ReverseSeriesResultRequest {
|
||||
mode: SeriesReversalMode;
|
||||
reason: string;
|
||||
impactHash: string;
|
||||
}
|
||||
|
||||
export interface CompetitionCommandResponse {
|
||||
competition: CompetitionDetailResponse;
|
||||
}
|
||||
|
||||
export interface ApiErrorResponse {
|
||||
error: {
|
||||
code: string;
|
||||
message: string;
|
||||
details?: unknown;
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,164 @@
|
||||
import type { CompetitionFormat } from "./format.js";
|
||||
import type { CompetitionGameView, GameSlotView } from "./game.js";
|
||||
import type {
|
||||
CommunityId,
|
||||
CompetitionId,
|
||||
MatchId,
|
||||
SeriesId,
|
||||
TeamId,
|
||||
UserId,
|
||||
} from "./ids.js";
|
||||
import type {
|
||||
IsoDateTime,
|
||||
SeriesDefinition,
|
||||
SeriesProjection,
|
||||
SeriesSlot,
|
||||
SeriesStageType,
|
||||
} from "./series.js";
|
||||
|
||||
export type CompetitionPhase =
|
||||
| "ready"
|
||||
| "running"
|
||||
| "completed"
|
||||
| "cancelled";
|
||||
export type PlayerPosition = "TOP" | "JGL" | "MID" | "ADC" | "SUP";
|
||||
|
||||
export interface CompetitionTeamMemberView {
|
||||
userId: UserId;
|
||||
displayName: string;
|
||||
gameName?: string;
|
||||
tagLine?: string;
|
||||
profileIconId?: number;
|
||||
assignedPosition?: PlayerPosition;
|
||||
cost?: number;
|
||||
}
|
||||
|
||||
export interface CompetitionTeamView {
|
||||
teamId: TeamId;
|
||||
displayOrder: number;
|
||||
name: string;
|
||||
captainUserId?: UserId;
|
||||
members: CompetitionTeamMemberView[];
|
||||
}
|
||||
|
||||
export interface RoundRobinStandingView {
|
||||
rank: number;
|
||||
teamId: TeamId;
|
||||
seriesPlayed: number;
|
||||
seriesWins: number;
|
||||
seriesLosses: number;
|
||||
seriesDraws: number;
|
||||
gameWins: number;
|
||||
gameLosses: number;
|
||||
gameDiff: number;
|
||||
}
|
||||
|
||||
export interface CompetitionPlacementView {
|
||||
rank: number;
|
||||
teamId: TeamId;
|
||||
}
|
||||
|
||||
export type CompetitionOutcome =
|
||||
| {
|
||||
type: "paired-series";
|
||||
completedSeriesIds: SeriesId[];
|
||||
drawnSeriesIds: SeriesId[];
|
||||
completedAt: IsoDateTime;
|
||||
}
|
||||
| {
|
||||
type: "round-robin";
|
||||
standings: RoundRobinStandingView[];
|
||||
leaderTeamIds: TeamId[];
|
||||
completedAt: IsoDateTime;
|
||||
}
|
||||
| {
|
||||
type: "double-elimination";
|
||||
placements: CompetitionPlacementView[];
|
||||
championTeamId: TeamId;
|
||||
completedAt: IsoDateTime;
|
||||
};
|
||||
|
||||
export interface BracketRoundView {
|
||||
stage: SeriesStageType;
|
||||
roundNumber?: number;
|
||||
displayOrder: number;
|
||||
label: string;
|
||||
seriesIds: SeriesId[];
|
||||
}
|
||||
|
||||
export interface SeriesConnectorView {
|
||||
from: {
|
||||
seriesId: SeriesId;
|
||||
select: "winner" | "loser" | "slot-a" | "slot-b";
|
||||
};
|
||||
to: {
|
||||
seriesId: SeriesId;
|
||||
slot: SeriesSlot;
|
||||
};
|
||||
}
|
||||
|
||||
interface CompetitionProjectionBase {
|
||||
sourceRevision: number;
|
||||
projectorVersion: number;
|
||||
phase: CompetitionPhase;
|
||||
series: SeriesProjection[];
|
||||
games: CompetitionGameView[];
|
||||
gameSlots: GameSlotView[];
|
||||
rounds: BracketRoundView[];
|
||||
connectors: SeriesConnectorView[];
|
||||
}
|
||||
|
||||
export interface PairedSeriesCompetitionProjection
|
||||
extends CompetitionProjectionBase {
|
||||
formatType: "paired-series";
|
||||
standings?: never;
|
||||
placements?: never;
|
||||
outcome?: Extract<CompetitionOutcome, { type: "paired-series" }>;
|
||||
}
|
||||
|
||||
export interface RoundRobinCompetitionProjection
|
||||
extends CompetitionProjectionBase {
|
||||
formatType: "round-robin";
|
||||
standings: RoundRobinStandingView[];
|
||||
placements?: never;
|
||||
outcome?: Extract<CompetitionOutcome, { type: "round-robin" }>;
|
||||
}
|
||||
|
||||
export interface DoubleEliminationCompetitionProjection
|
||||
extends CompetitionProjectionBase {
|
||||
formatType: "double-elimination";
|
||||
standings?: never;
|
||||
placements: CompetitionPlacementView[];
|
||||
outcome?: Extract<CompetitionOutcome, { type: "double-elimination" }>;
|
||||
}
|
||||
|
||||
export type CompetitionProjection =
|
||||
| PairedSeriesCompetitionProjection
|
||||
| RoundRobinCompetitionProjection
|
||||
| DoubleEliminationCompetitionProjection;
|
||||
|
||||
export interface CompetitionDefinitionView {
|
||||
id: CompetitionId;
|
||||
matchId: MatchId;
|
||||
communityId: CommunityId;
|
||||
schemaVersion: number;
|
||||
revision: number;
|
||||
phase: CompetitionPhase;
|
||||
teams: CompetitionTeamView[];
|
||||
format: CompetitionFormat;
|
||||
seriesGraph: SeriesDefinition[];
|
||||
}
|
||||
|
||||
export interface CompetitionDetailResponse {
|
||||
id: CompetitionId;
|
||||
matchId: MatchId;
|
||||
communityId: CommunityId;
|
||||
schemaVersion: number;
|
||||
revision: number;
|
||||
phase: CompetitionPhase;
|
||||
teams: CompetitionTeamView[];
|
||||
format: CompetitionFormat;
|
||||
projection: CompetitionProjection;
|
||||
createdAt: IsoDateTime;
|
||||
updatedAt: IsoDateTime;
|
||||
}
|
||||
Loaded 100 of 111 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user