release/86 #2
No files matched your search
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
@@ -4,6 +4,47 @@ import type { MatchStats } from '../global/database/schema';
|
||||
import { MatchStatsRepository } from './match-stats.repository';
|
||||
|
||||
describe('MatchStatsRepository', () => {
|
||||
it('does not let a legacy upsert overwrite a Competition-backed fragment', async () => {
|
||||
const fragment = {
|
||||
...statsFragment(12),
|
||||
sourceCompetitionId: undefined,
|
||||
sourceRevision: undefined,
|
||||
projectorVersion: undefined,
|
||||
};
|
||||
const updateOne = jest
|
||||
.fn()
|
||||
.mockReturnValueOnce({
|
||||
exec: jest.fn().mockResolvedValue({ matchedCount: 0 }),
|
||||
})
|
||||
.mockReturnValueOnce({
|
||||
exec: jest
|
||||
.fn()
|
||||
.mockResolvedValue({ matchedCount: 1, upsertedCount: 0 }),
|
||||
});
|
||||
const connection = {
|
||||
getModel: jest.fn().mockResolvedValue({ updateOne }),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = new MatchStatsRepository(connection);
|
||||
|
||||
await repository.upsert(fragment);
|
||||
|
||||
expect(updateOne).toHaveBeenNthCalledWith(
|
||||
1,
|
||||
{
|
||||
matchId: fragment.matchId,
|
||||
sourceCompetitionId: { $exists: false },
|
||||
},
|
||||
{ $set: fragment },
|
||||
{ upsert: false },
|
||||
);
|
||||
expect(updateOne).toHaveBeenNthCalledWith(
|
||||
2,
|
||||
{ matchId: fragment.matchId },
|
||||
{ $setOnInsert: fragment },
|
||||
{ upsert: true },
|
||||
);
|
||||
});
|
||||
|
||||
it('only updates a Competition projection when its revision is not stale', async () => {
|
||||
const updateOne = jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue({ matchedCount: 1, upsertedCount: 0 }),
|
||||
@@ -36,6 +77,122 @@ describe('MatchStatsRepository', () => {
|
||||
{ upsert: false },
|
||||
);
|
||||
});
|
||||
|
||||
it('converges concurrent initial upserts to the highest Competition revision', async () => {
|
||||
const older = statsFragment(12);
|
||||
const newer = {
|
||||
...statsFragment(13),
|
||||
matchId: older.matchId,
|
||||
sourceCompetitionId: older.sourceCompetitionId,
|
||||
};
|
||||
let stored: ReturnType<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) {
|
||||
|
||||
@@ -13,6 +13,11 @@ export type MatchStatsDetailFragment = Pick<
|
||||
'matchId' | 'gameDetails'
|
||||
>;
|
||||
|
||||
export interface MatchStatsDeleteGuard {
|
||||
sourceCompetitionId: mongoose.Types.ObjectId;
|
||||
sourceRevision: number;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class MatchStatsRepository {
|
||||
constructor(private readonly connectionService: ConnectionService) {}
|
||||
@@ -25,30 +30,33 @@ export class MatchStatsRepository {
|
||||
!fragment.sourceCompetitionId ||
|
||||
fragment.sourceRevision === undefined
|
||||
) {
|
||||
await MatchStatsModel.updateOne(
|
||||
{ matchId: fragment.matchId },
|
||||
const updated = await MatchStatsModel.updateOne(
|
||||
{
|
||||
matchId: fragment.matchId,
|
||||
sourceCompetitionId: { $exists: false },
|
||||
},
|
||||
{ $set: fragment },
|
||||
{ upsert: true },
|
||||
{ upsert: false },
|
||||
).exec();
|
||||
if (updated.matchedCount > 0) return;
|
||||
|
||||
// A legacy builder must never overwrite a Competition-backed fragment
|
||||
// that appeared while the legacy source was being read.
|
||||
try {
|
||||
await MatchStatsModel.updateOne(
|
||||
{ matchId: fragment.matchId },
|
||||
{ $setOnInsert: fragment },
|
||||
{ upsert: true },
|
||||
).exec();
|
||||
} catch (error) {
|
||||
if (!isDuplicateKeyError(error)) throw error;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
const revisionGuard = competitionRevisionGuard(fragment);
|
||||
const updated = await MatchStatsModel.updateOne(
|
||||
{
|
||||
matchId: fragment.matchId,
|
||||
$or: [
|
||||
{ sourceCompetitionId: { $exists: false } },
|
||||
{ sourceCompetitionId: fragment.sourceCompetitionId },
|
||||
],
|
||||
$and: [
|
||||
{
|
||||
$or: [
|
||||
{ sourceRevision: { $exists: false } },
|
||||
{ sourceRevision: { $lte: fragment.sourceRevision } },
|
||||
],
|
||||
},
|
||||
],
|
||||
},
|
||||
revisionGuard,
|
||||
{ $set: fragment },
|
||||
{ upsert: false },
|
||||
).exec();
|
||||
@@ -56,16 +64,48 @@ export class MatchStatsRepository {
|
||||
|
||||
// If no read model exists, insert it. If a newer revision won the race,
|
||||
// this filter matches it and $setOnInsert intentionally changes nothing.
|
||||
try {
|
||||
await MatchStatsModel.updateOne(
|
||||
{ matchId: fragment.matchId },
|
||||
{ $setOnInsert: fragment },
|
||||
{ upsert: true },
|
||||
).exec();
|
||||
} catch (error) {
|
||||
if (!isDuplicateKeyError(error)) throw error;
|
||||
}
|
||||
|
||||
// A lower revision can win the initial insert between the guarded miss and
|
||||
// the upsert. Re-run the monotonic CAS so every concurrent builder converges
|
||||
// to the highest source revision; a newer winner simply does not match.
|
||||
await MatchStatsModel.updateOne(
|
||||
{ matchId: fragment.matchId },
|
||||
{ $setOnInsert: fragment },
|
||||
{ upsert: true },
|
||||
revisionGuard,
|
||||
{ $set: fragment },
|
||||
{ upsert: false },
|
||||
).exec();
|
||||
}
|
||||
|
||||
public async deleteByMatch(matchId: mongoose.Types.ObjectId): Promise<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(
|
||||
@@ -76,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> {
|
||||
@@ -173,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
|
||||
);
|
||||
}
|
||||
@@ -39,6 +39,57 @@ describe('MatchStatsService', () => {
|
||||
expect(repository.upsert).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('revision-guards deletion when a Competition reversal leaves zero games', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const competitionId = new mongoose.Types.ObjectId();
|
||||
const match = {
|
||||
_id: matchId,
|
||||
communityId,
|
||||
scheduledAt: new Date('2026-07-12T10:00:00.000Z'),
|
||||
status: 'in-progress',
|
||||
teams: [],
|
||||
result: undefined,
|
||||
};
|
||||
const competition = {
|
||||
_id: competitionId,
|
||||
revision: 12,
|
||||
projectorVersion: 3,
|
||||
teams: [],
|
||||
projection: { phase: 'ready', games: [] },
|
||||
};
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockImplementation(async (name: string) => {
|
||||
if (name === 'match') {
|
||||
return { findById: () => queryResult(match, false) };
|
||||
}
|
||||
if (name === 'competition') {
|
||||
return { findOne: () => queryResult(competition) };
|
||||
}
|
||||
if (name === 'riotMatch') return {};
|
||||
throw new Error(`Unexpected model: ${name}`);
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
deleteByMatch: jest.fn().mockResolvedValue(undefined),
|
||||
upsert: jest.fn(),
|
||||
} as unknown as jest.Mocked<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();
|
||||
@@ -237,6 +288,92 @@ describe('MatchStatsService', () => {
|
||||
);
|
||||
});
|
||||
|
||||
it('removes a fragment written after its Competition Match was deleted', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const competitionId = new mongoose.Types.ObjectId();
|
||||
const teamAId = new mongoose.Types.ObjectId();
|
||||
const teamBId = new mongoose.Types.ObjectId();
|
||||
const match = {
|
||||
_id: matchId,
|
||||
communityId,
|
||||
scheduledAt: new Date('2026-07-12T10:00:00.000Z'),
|
||||
status: 'in-progress',
|
||||
teams: [],
|
||||
result: undefined,
|
||||
};
|
||||
const competition = {
|
||||
_id: competitionId,
|
||||
revision: 12,
|
||||
projectorVersion: 3,
|
||||
teams: [
|
||||
{ teamId: teamAId, legacyTeamIndex: 1, displayOrder: 1 },
|
||||
{ teamId: teamBId, legacyTeamIndex: 2, displayOrder: 2 },
|
||||
],
|
||||
projection: {
|
||||
phase: 'running',
|
||||
games: [
|
||||
{
|
||||
id: new mongoose.Types.ObjectId(),
|
||||
displayNumber: 1,
|
||||
evidence: { type: 'legacy', legacyReference: 'legacy:1' },
|
||||
teams: {
|
||||
blue: { teamId: teamAId.toString() },
|
||||
red: { teamId: teamBId.toString() },
|
||||
},
|
||||
winnerTeamId: teamAId.toString(),
|
||||
},
|
||||
],
|
||||
},
|
||||
};
|
||||
const findById = jest
|
||||
.fn()
|
||||
.mockReturnValueOnce(queryResult(match, false))
|
||||
.mockReturnValueOnce(queryResult(null, false));
|
||||
const findCompetition = jest.fn().mockReturnValue(queryResult(competition));
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockImplementation(async (name: string) => {
|
||||
if (name === 'match') return { findById };
|
||||
if (name === 'competition') return { findOne: findCompetition };
|
||||
if (name === 'riotMatch') return {};
|
||||
throw new Error(`Unexpected model: ${name}`);
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
upsert: jest.fn().mockResolvedValue(undefined),
|
||||
deleteByMatch: jest.fn().mockResolvedValue(undefined),
|
||||
deleteLegacyByMatch: jest.fn(),
|
||||
} as unknown as jest.Mocked<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();
|
||||
|
||||
@@ -48,7 +48,14 @@ export class MatchStatsService {
|
||||
: undefined;
|
||||
const sourceMatch = competitionSource?.match ?? match;
|
||||
if (!this.isEligible(sourceMatch)) {
|
||||
await this.repository.deleteByMatch(matchId);
|
||||
if (competitionSource) {
|
||||
await this.repository.deleteByMatch(matchId, {
|
||||
sourceCompetitionId: competitionSource.sourceCompetitionId,
|
||||
sourceRevision: competitionSource.sourceRevision,
|
||||
});
|
||||
} else {
|
||||
await this.repository.deleteByMatch(matchId);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -135,6 +142,11 @@ export class MatchStatsService {
|
||||
}
|
||||
: {}),
|
||||
});
|
||||
|
||||
// Source reads and the read-model write are intentionally separated by
|
||||
// Riot/timeline work. Revalidate after the write so a concurrent aggregate
|
||||
// deletion cannot resurrect MatchStats after the delete transaction.
|
||||
await this.removeFragmentIfSourceChanged(matchId, competitionSource);
|
||||
}
|
||||
|
||||
public async removeByMatch(matchId: mongoose.Types.ObjectId): Promise<void> {
|
||||
@@ -196,6 +208,49 @@ export class MatchStatsService {
|
||||
? (region as RiotRegionalRoute)
|
||||
: 'asia';
|
||||
}
|
||||
|
||||
private async removeFragmentIfSourceChanged(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
source:
|
||||
| {
|
||||
sourceCompetitionId: mongoose.Types.ObjectId;
|
||||
sourceRevision: number;
|
||||
}
|
||||
| undefined,
|
||||
): Promise<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 {
|
||||
|
||||
@@ -193,8 +193,37 @@ describe('CompetitionBootstrapService', () => {
|
||||
});
|
||||
});
|
||||
|
||||
it('rejects double elimination until authoritative seeds are persisted', async () => {
|
||||
const harness = createHarness();
|
||||
const service = new CompetitionBootstrapService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
await expect(
|
||||
service.bootstrap(
|
||||
matchSnapshot({
|
||||
gameMode: 'double-elimination',
|
||||
teamCount: 4,
|
||||
gameCount: 3,
|
||||
}),
|
||||
),
|
||||
).rejects.toMatchObject({
|
||||
code: 'INVALID_MATCH_TEAM_SNAPSHOT',
|
||||
httpStatus: 422,
|
||||
});
|
||||
|
||||
expect(harness.connectionService.createSession).not.toHaveBeenCalled();
|
||||
expect(harness.competitionModel.findOneAndUpdate).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('rejects incomplete and duplicate team assignments before opening a transaction', async () => {
|
||||
const cases: Array<[string, (match: CompetitionBootstrapMatch) => void]> = [
|
||||
[
|
||||
'the Match lifecycle is still recruiting',
|
||||
(match) => {
|
||||
match.status = 'recruiting';
|
||||
},
|
||||
],
|
||||
[
|
||||
'an active participant is not assigned',
|
||||
(match) => {
|
||||
@@ -288,6 +317,8 @@ describe('CompetitionBootstrapService', () => {
|
||||
expect(harness.matchModel.updateOne).toHaveBeenCalledWith(
|
||||
{
|
||||
_id: MATCH_ID,
|
||||
status: 'team-built',
|
||||
teamBuiltAt: new Date('2026-07-12T00:05:00.000Z'),
|
||||
$or: [
|
||||
{ competitionId: { $exists: false } },
|
||||
{ competitionId: null },
|
||||
@@ -404,6 +435,8 @@ function matchSnapshot(params: {
|
||||
return {
|
||||
_id: MATCH_ID,
|
||||
communityId: COMMUNITY_ID,
|
||||
status: 'team-built',
|
||||
teamBuiltAt: new Date('2026-07-12T00:05:00.000Z'),
|
||||
gameCount: params.gameCount ?? 3,
|
||||
gameMode: params.gameMode,
|
||||
...(params.roundRobinMaxRounds === undefined
|
||||
|
||||
@@ -5,6 +5,7 @@ import { ConnectionService } from '../global/database/connection.service';
|
||||
import type {
|
||||
MatchGameMode,
|
||||
MatchParticipant,
|
||||
MatchStatus,
|
||||
MatchTeam,
|
||||
} from '../global/database/schema';
|
||||
import type {
|
||||
@@ -30,6 +31,8 @@ export interface CompetitionBootstrapMatch {
|
||||
_id: Types.ObjectId;
|
||||
communityId: Types.ObjectId;
|
||||
competitionId?: Types.ObjectId;
|
||||
status: MatchStatus;
|
||||
teamBuiltAt: Date;
|
||||
gameCount: number;
|
||||
gameMode: MatchGameMode;
|
||||
roundRobinMaxRounds?: number;
|
||||
@@ -142,6 +145,8 @@ export class CompetitionBootstrapService {
|
||||
const linkResult = await MatchModel.updateOne(
|
||||
{
|
||||
_id: match._id,
|
||||
status: match.status,
|
||||
teamBuiltAt: match.teamBuiltAt,
|
||||
$or: [
|
||||
{ competitionId: { $exists: false } },
|
||||
{ competitionId: null },
|
||||
@@ -206,6 +211,13 @@ function buildCompetitionInsertPayload(
|
||||
): CompetitionInsertPayload {
|
||||
assertObjectId(match._id, 'Match ID');
|
||||
assertObjectId(match.communityId, 'Community ID');
|
||||
if (match.status === 'recruiting' || !(match.teamBuiltAt instanceof Date)) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'INVALID_MATCH_TEAM_SNAPSHOT',
|
||||
'Competition bootstrap requires a finalized team-built Match lifecycle.',
|
||||
422,
|
||||
);
|
||||
}
|
||||
assertPositiveInteger(match.gameCount, 'Match game count');
|
||||
|
||||
const competitionId = stableObjectId(match._id, 'competition');
|
||||
@@ -405,7 +417,11 @@ function applySeeds(
|
||||
): void {
|
||||
if (match.gameMode !== 'double-elimination') return;
|
||||
const configuredSeeds = match.doubleElimination?.seeds ?? [];
|
||||
if (configuredSeeds.length === 0) return;
|
||||
if (configuredSeeds.length === 0) {
|
||||
throw invalidTeamSnapshot(
|
||||
'Double-elimination seeds must be finalized before Competition bootstrap.',
|
||||
);
|
||||
}
|
||||
if (configuredSeeds.length !== teams.length) {
|
||||
throw invalidTeamSnapshot(
|
||||
'Double-elimination seeds must include every built team exactly once.',
|
||||
|
||||
@@ -106,6 +106,49 @@ describe('CompetitionCommandService', () => {
|
||||
expect(harness.session.abortTransaction).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('replays a concurrently committed identical command after a duplicate-key race', async () => {
|
||||
const harness = createHarness();
|
||||
let committedReceipt: Record<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(
|
||||
@@ -382,6 +425,39 @@ describe('CompetitionCommandService', () => {
|
||||
{ session: harness.session },
|
||||
);
|
||||
expect(harness.tournamentCodeModel.updateMany).toHaveBeenCalled();
|
||||
expect(harness.matchModel.updateOne).toHaveBeenCalledWith(
|
||||
{ _id: reversal.competition.matchId },
|
||||
{
|
||||
$pull: {
|
||||
tournamentCodeIds: {
|
||||
$in: [reversal.parentCodeId, reversal.childCodeId],
|
||||
},
|
||||
},
|
||||
},
|
||||
{ session: harness.session },
|
||||
);
|
||||
const [, codeReversalPipeline] = harness.tournamentCodeModel.updateMany.mock
|
||||
.calls[0] as unknown as [
|
||||
Record<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 } }),
|
||||
@@ -390,6 +466,50 @@ describe('CompetitionCommandService', () => {
|
||||
expect(harness.outboxModel.insertMany).toHaveBeenCalledTimes(1);
|
||||
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('retries a cascade reversal after a transient transaction conflict', async () => {
|
||||
const reversal = reversalFixture();
|
||||
const harness = createHarness({
|
||||
competition: reversal.competition,
|
||||
facts: reversal.facts,
|
||||
assignments: reversal.assignments,
|
||||
});
|
||||
harness.factModel.insertMany
|
||||
.mockRejectedValueOnce(
|
||||
Object.assign(new Error('write conflict'), {
|
||||
code: 112,
|
||||
codeName: 'WriteConflict',
|
||||
}),
|
||||
)
|
||||
.mockResolvedValueOnce([]);
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
const preview = await service.previewSeriesReversal({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
seriesId: reversal.parentSeriesId,
|
||||
mode: 'cascade',
|
||||
});
|
||||
|
||||
await expect(
|
||||
service.reverseSeries({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
idempotencyKey: 'admin:reverse:transient-retry',
|
||||
actor: { type: 'user', userId: USER_ID },
|
||||
seriesId: reversal.parentSeriesId,
|
||||
mode: 'cascade',
|
||||
reason: 'Wrong result ingestion',
|
||||
impactHash: preview.impactHash,
|
||||
}),
|
||||
).resolves.toMatchObject({ revision: 8, replayed: false });
|
||||
|
||||
expect(harness.connectionService.createSession).toHaveBeenCalledTimes(2);
|
||||
expect(harness.factModel.insertMany).toHaveBeenCalledTimes(2);
|
||||
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
});
|
||||
|
||||
const COMPETITION_ID = new Types.ObjectId('64b000000000000000000001');
|
||||
@@ -496,12 +616,18 @@ function createHarness(
|
||||
updateOne: jest.fn().mockResolvedValue({ modifiedCount: 1 }),
|
||||
updateMany: jest.fn().mockResolvedValue({ modifiedCount: 2 }),
|
||||
};
|
||||
const matchModel = {
|
||||
updateOne: jest
|
||||
.fn()
|
||||
.mockResolvedValue({ matchedCount: 1, modifiedCount: 1 }),
|
||||
};
|
||||
const models: Record<string, unknown> = {
|
||||
competition: competitionModel,
|
||||
competitionFact: factModel,
|
||||
competitionOutbox: outboxModel,
|
||||
tournamentCodeAssignment: assignmentModel,
|
||||
tournamentCode: tournamentCodeModel,
|
||||
match: matchModel,
|
||||
};
|
||||
const connectionService = {
|
||||
createSession: jest.fn().mockResolvedValue(session),
|
||||
@@ -515,6 +641,7 @@ function createHarness(
|
||||
outboxModel,
|
||||
assignmentModel,
|
||||
tournamentCodeModel,
|
||||
matchModel,
|
||||
connectionService,
|
||||
};
|
||||
}
|
||||
@@ -612,6 +739,8 @@ function reversalFixture() {
|
||||
childFactId,
|
||||
parentGameSlotId,
|
||||
childGameSlotId,
|
||||
parentCodeId,
|
||||
childCodeId,
|
||||
competition: {
|
||||
...competitionDocument(7),
|
||||
seriesGraph: [
|
||||
|
||||
@@ -14,6 +14,7 @@ import {
|
||||
} from './domain/competition-reversal';
|
||||
|
||||
type PersistenceId = string | mongoose.Types.ObjectId;
|
||||
const COMMAND_TRANSACTION_ATTEMPTS = 3;
|
||||
|
||||
export type CompetitionCommandActor =
|
||||
| { type: 'system' }
|
||||
@@ -211,283 +212,316 @@ export class CompetitionCommandService {
|
||||
throw invalidCommandError();
|
||||
}
|
||||
|
||||
const session = await this.connectionService.createSession();
|
||||
if (!session) {
|
||||
throw new CompetitionCommandError(
|
||||
'COMPETITION_TRANSACTION_UNAVAILABLE',
|
||||
'A MongoDB transaction is required for Competition commands.',
|
||||
500,
|
||||
);
|
||||
}
|
||||
|
||||
try {
|
||||
session.startTransaction();
|
||||
const [CompetitionModel, FactModel, OutboxModel, AssignmentModel] =
|
||||
await Promise.all([
|
||||
this.connectionService.getModel('competition'),
|
||||
this.connectionService.getModel('competitionFact'),
|
||||
this.connectionService.getModel('competitionOutbox'),
|
||||
this.connectionService.getModel('tournamentCodeAssignment'),
|
||||
]);
|
||||
const requestHash = requestHashFor(envelope);
|
||||
const commandId = commandIdFor(envelope);
|
||||
const receipt = await OutboxModel.findOne({
|
||||
competitionId: command.competitionId,
|
||||
idempotencyKey: command.idempotencyKey,
|
||||
})
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec();
|
||||
if (receipt) {
|
||||
const replay = await this.replay(
|
||||
CompetitionModel,
|
||||
command.competitionId,
|
||||
requestHash,
|
||||
receipt,
|
||||
session,
|
||||
let lastRetryableError: unknown;
|
||||
for (
|
||||
let attempt = 1;
|
||||
attempt <= COMMAND_TRANSACTION_ATTEMPTS;
|
||||
attempt += 1
|
||||
) {
|
||||
const session = await this.connectionService.createSession();
|
||||
if (!session) {
|
||||
throw new CompetitionCommandError(
|
||||
'COMPETITION_TRANSACTION_UNAVAILABLE',
|
||||
'A MongoDB transaction is required for Competition commands.',
|
||||
500,
|
||||
);
|
||||
await session.commitTransaction();
|
||||
return replay;
|
||||
}
|
||||
|
||||
const competition = await CompetitionModel.findById(command.competitionId)
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec();
|
||||
if (!competition) throw competitionNotFound(command.competitionId);
|
||||
assertExpectedRevision(competition.revision, command.expectedRevision);
|
||||
|
||||
const [existingFacts, assignments] = await Promise.all([
|
||||
FactModel.find({ competitionId: command.competitionId })
|
||||
.sort({ revision: 1, ordinalWithinRevision: 1 })
|
||||
try {
|
||||
session.startTransaction();
|
||||
const [CompetitionModel, FactModel, OutboxModel, AssignmentModel] =
|
||||
await Promise.all([
|
||||
this.connectionService.getModel('competition'),
|
||||
this.connectionService.getModel('competitionFact'),
|
||||
this.connectionService.getModel('competitionOutbox'),
|
||||
this.connectionService.getModel('tournamentCodeAssignment'),
|
||||
]);
|
||||
const requestHash = requestHashFor(envelope);
|
||||
const commandId = commandIdFor(envelope);
|
||||
const receipt = await OutboxModel.findOne({
|
||||
competitionId: command.competitionId,
|
||||
idempotencyKey: command.idempotencyKey,
|
||||
})
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec(),
|
||||
AssignmentModel.find({ competitionId: command.competitionId })
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec() as Promise<AssignmentRecord[]>,
|
||||
]);
|
||||
const input = reversalInput(
|
||||
competition,
|
||||
command,
|
||||
existingFacts,
|
||||
assignments,
|
||||
);
|
||||
const preview = assertReversalPreview(input, command.impactHash);
|
||||
const nextRevision = command.expectedRevision + 1;
|
||||
const recordedAt = new Date();
|
||||
const occurredAt = command.occurredAt ?? recordedAt;
|
||||
const rawFacts = buildReversalFacts({
|
||||
preview,
|
||||
facts: input.facts,
|
||||
competitionId: idString(command.competitionId),
|
||||
commandId,
|
||||
nextRevision,
|
||||
actor: toPlain(command.actor) as Readonly<Record<string, unknown>>,
|
||||
reason: command.reason.trim(),
|
||||
occurredAt,
|
||||
});
|
||||
const reversalFacts = rawFacts.map((rawFact) =>
|
||||
persistenceReversalFact(rawFact, command, commandId, requestHash),
|
||||
);
|
||||
const projection = projectCompetition({
|
||||
competitionId: idString(command.competitionId),
|
||||
revision: nextRevision,
|
||||
projectorVersion: competition.projectorVersion,
|
||||
teams: toPlain(competition.teams) as never,
|
||||
format: toPlain(competition.format) as never,
|
||||
seriesGraph: toPlain(competition.seriesGraph) as never,
|
||||
facts: [...existingFacts, ...reversalFacts].map(factForProjection),
|
||||
});
|
||||
|
||||
await FactModel.insertMany(reversalFacts, { session });
|
||||
const updated = await CompetitionModel.findOneAndUpdate(
|
||||
{ _id: command.competitionId, revision: command.expectedRevision },
|
||||
{
|
||||
$inc: { revision: 1 },
|
||||
$set: {
|
||||
projection,
|
||||
projectorVersion: competition.projectorVersion,
|
||||
phase: projection.phase,
|
||||
},
|
||||
},
|
||||
{ new: true, runValidators: true, session },
|
||||
)
|
||||
.lean()
|
||||
.exec();
|
||||
if (!updated) throw staleRevisionError(command.expectedRevision);
|
||||
|
||||
await this.applyReversalAssignments(
|
||||
command.competitionId,
|
||||
preview,
|
||||
assignments,
|
||||
commandId,
|
||||
recordedAt,
|
||||
session,
|
||||
);
|
||||
await OutboxModel.insertMany(
|
||||
[
|
||||
buildOutbox(
|
||||
.exec();
|
||||
if (receipt) {
|
||||
const replay = await this.replay(
|
||||
CompetitionModel,
|
||||
command.competitionId,
|
||||
envelope,
|
||||
commandId,
|
||||
requestHash,
|
||||
nextRevision,
|
||||
reversalFacts,
|
||||
projection,
|
||||
updated,
|
||||
recordedAt,
|
||||
),
|
||||
],
|
||||
{ session },
|
||||
);
|
||||
await session.commitTransaction();
|
||||
return {
|
||||
competition: updated,
|
||||
commandId,
|
||||
revision: nextRevision,
|
||||
replayed: false,
|
||||
};
|
||||
} catch (error) {
|
||||
await session.abortTransaction().catch(() => undefined);
|
||||
throw error;
|
||||
} finally {
|
||||
await session.endSession();
|
||||
receipt,
|
||||
session,
|
||||
);
|
||||
await session.commitTransaction();
|
||||
return replay;
|
||||
}
|
||||
|
||||
const competition = await CompetitionModel.findById(
|
||||
command.competitionId,
|
||||
)
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec();
|
||||
if (!competition) throw competitionNotFound(command.competitionId);
|
||||
assertExpectedRevision(competition.revision, command.expectedRevision);
|
||||
|
||||
const [existingFacts, assignments] = await Promise.all([
|
||||
FactModel.find({ competitionId: command.competitionId })
|
||||
.sort({ revision: 1, ordinalWithinRevision: 1 })
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec(),
|
||||
AssignmentModel.find({ competitionId: command.competitionId })
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec() as Promise<AssignmentRecord[]>,
|
||||
]);
|
||||
const input = reversalInput(
|
||||
competition,
|
||||
command,
|
||||
existingFacts,
|
||||
assignments,
|
||||
);
|
||||
const preview = assertReversalPreview(input, command.impactHash);
|
||||
const nextRevision = command.expectedRevision + 1;
|
||||
const recordedAt = new Date();
|
||||
const occurredAt = command.occurredAt ?? recordedAt;
|
||||
const rawFacts = buildReversalFacts({
|
||||
preview,
|
||||
facts: input.facts,
|
||||
competitionId: idString(command.competitionId),
|
||||
commandId,
|
||||
nextRevision,
|
||||
actor: toPlain(command.actor) as Readonly<Record<string, unknown>>,
|
||||
reason: command.reason.trim(),
|
||||
occurredAt,
|
||||
});
|
||||
const reversalFacts = rawFacts.map((rawFact) =>
|
||||
persistenceReversalFact(rawFact, command, commandId, requestHash),
|
||||
);
|
||||
const projection = projectCompetition({
|
||||
competitionId: idString(command.competitionId),
|
||||
revision: nextRevision,
|
||||
projectorVersion: competition.projectorVersion,
|
||||
teams: toPlain(competition.teams) as never,
|
||||
format: toPlain(competition.format) as never,
|
||||
seriesGraph: toPlain(competition.seriesGraph) as never,
|
||||
facts: [...existingFacts, ...reversalFacts].map(factForProjection),
|
||||
});
|
||||
|
||||
await FactModel.insertMany(reversalFacts, { session });
|
||||
const updated = await CompetitionModel.findOneAndUpdate(
|
||||
{ _id: command.competitionId, revision: command.expectedRevision },
|
||||
{
|
||||
$inc: { revision: 1 },
|
||||
$set: {
|
||||
projection,
|
||||
projectorVersion: competition.projectorVersion,
|
||||
phase: projection.phase,
|
||||
},
|
||||
},
|
||||
{ new: true, runValidators: true, session },
|
||||
)
|
||||
.lean()
|
||||
.exec();
|
||||
if (!updated) throw staleRevisionError(command.expectedRevision);
|
||||
|
||||
await this.applyReversalAssignments(
|
||||
command.competitionId,
|
||||
competition.matchId,
|
||||
preview,
|
||||
assignments,
|
||||
commandId,
|
||||
recordedAt,
|
||||
session,
|
||||
);
|
||||
await OutboxModel.insertMany(
|
||||
[
|
||||
buildOutbox(
|
||||
command.competitionId,
|
||||
envelope,
|
||||
commandId,
|
||||
requestHash,
|
||||
nextRevision,
|
||||
reversalFacts,
|
||||
projection,
|
||||
updated,
|
||||
recordedAt,
|
||||
),
|
||||
],
|
||||
{ session },
|
||||
);
|
||||
await session.commitTransaction();
|
||||
return {
|
||||
competition: updated,
|
||||
commandId,
|
||||
revision: nextRevision,
|
||||
replayed: false,
|
||||
};
|
||||
} catch (error) {
|
||||
await session.abortTransaction().catch(() => undefined);
|
||||
if (
|
||||
attempt < COMMAND_TRANSACTION_ATTEMPTS &&
|
||||
isRetryableCommandTransactionError(error)
|
||||
) {
|
||||
lastRetryableError = error;
|
||||
continue;
|
||||
}
|
||||
throw error;
|
||||
} finally {
|
||||
await session.endSession();
|
||||
}
|
||||
}
|
||||
throw lastRetryableError;
|
||||
}
|
||||
|
||||
private async runCommand(
|
||||
command: CommandEnvelope,
|
||||
): Promise<CompetitionCommandResult> {
|
||||
validateEnvelope(command);
|
||||
const session = await this.connectionService.createSession();
|
||||
if (!session) {
|
||||
throw new CompetitionCommandError(
|
||||
'COMPETITION_TRANSACTION_UNAVAILABLE',
|
||||
'A MongoDB transaction is required for Competition commands.',
|
||||
500,
|
||||
);
|
||||
}
|
||||
let lastRetryableError: unknown;
|
||||
for (
|
||||
let attempt = 1;
|
||||
attempt <= COMMAND_TRANSACTION_ATTEMPTS;
|
||||
attempt += 1
|
||||
) {
|
||||
const session = await this.connectionService.createSession();
|
||||
if (!session) {
|
||||
throw new CompetitionCommandError(
|
||||
'COMPETITION_TRANSACTION_UNAVAILABLE',
|
||||
'A MongoDB transaction is required for Competition commands.',
|
||||
500,
|
||||
);
|
||||
}
|
||||
|
||||
try {
|
||||
session.startTransaction();
|
||||
const CompetitionModel =
|
||||
await this.connectionService.getModel('competition');
|
||||
const FactModel =
|
||||
await this.connectionService.getModel('competitionFact');
|
||||
const OutboxModel =
|
||||
await this.connectionService.getModel('competitionOutbox');
|
||||
const requestHash = requestHashFor(command);
|
||||
const commandId = commandIdFor(command);
|
||||
const competitionId = command.competitionId;
|
||||
try {
|
||||
session.startTransaction();
|
||||
const CompetitionModel =
|
||||
await this.connectionService.getModel('competition');
|
||||
const FactModel =
|
||||
await this.connectionService.getModel('competitionFact');
|
||||
const OutboxModel =
|
||||
await this.connectionService.getModel('competitionOutbox');
|
||||
const requestHash = requestHashFor(command);
|
||||
const commandId = commandIdFor(command);
|
||||
const competitionId = command.competitionId;
|
||||
|
||||
const receipt = await OutboxModel.findOne({
|
||||
competitionId,
|
||||
idempotencyKey: command.idempotencyKey,
|
||||
})
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec();
|
||||
if (receipt) {
|
||||
const replay = await this.replay(
|
||||
CompetitionModel,
|
||||
const receipt = await OutboxModel.findOne({
|
||||
competitionId,
|
||||
idempotencyKey: command.idempotencyKey,
|
||||
})
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec();
|
||||
if (receipt) {
|
||||
const replay = await this.replay(
|
||||
CompetitionModel,
|
||||
competitionId,
|
||||
requestHash,
|
||||
receipt,
|
||||
session,
|
||||
);
|
||||
await session.commitTransaction();
|
||||
return replay;
|
||||
}
|
||||
|
||||
const competition = await CompetitionModel.findById(competitionId)
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec();
|
||||
if (!competition) {
|
||||
throw new CompetitionCommandError(
|
||||
'COMPETITION_NOT_FOUND',
|
||||
'Competition not found.',
|
||||
404,
|
||||
{ competitionId: idString(competitionId) },
|
||||
);
|
||||
}
|
||||
assertExpectedRevision(competition.revision, command.expectedRevision);
|
||||
|
||||
const existingFacts = await FactModel.find({ competitionId })
|
||||
.sort({ revision: 1, ordinalWithinRevision: 1 })
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec();
|
||||
const nextRevision = command.expectedRevision + 1;
|
||||
const recordedAt = new Date();
|
||||
const fact = buildFact(
|
||||
command,
|
||||
commandId,
|
||||
requestHash,
|
||||
receipt,
|
||||
session,
|
||||
nextRevision,
|
||||
recordedAt,
|
||||
);
|
||||
const projection = projectCompetition({
|
||||
competitionId: idString(competitionId),
|
||||
revision: nextRevision,
|
||||
projectorVersion: competition.projectorVersion,
|
||||
teams: toPlain(competition.teams) as never,
|
||||
format: toPlain(competition.format) as never,
|
||||
seriesGraph: toPlain(competition.seriesGraph) as never,
|
||||
facts: [...existingFacts, fact].map(factForProjection),
|
||||
});
|
||||
|
||||
await FactModel.insertMany([fact], { session });
|
||||
const updated = await CompetitionModel.findOneAndUpdate(
|
||||
{ _id: competitionId, revision: command.expectedRevision },
|
||||
{
|
||||
$inc: { revision: 1 },
|
||||
$set: {
|
||||
projection,
|
||||
projectorVersion: competition.projectorVersion,
|
||||
phase: projection.phase,
|
||||
},
|
||||
},
|
||||
{ new: true, runValidators: true, session },
|
||||
)
|
||||
.lean()
|
||||
.exec();
|
||||
if (!updated) {
|
||||
throw staleRevisionError(command.expectedRevision);
|
||||
}
|
||||
|
||||
await this.applyTournamentCode(command, commandId, recordedAt, session);
|
||||
await OutboxModel.insertMany(
|
||||
[
|
||||
buildOutbox(
|
||||
competitionId,
|
||||
command,
|
||||
commandId,
|
||||
requestHash,
|
||||
nextRevision,
|
||||
fact,
|
||||
projection,
|
||||
updated,
|
||||
recordedAt,
|
||||
),
|
||||
],
|
||||
{ session },
|
||||
);
|
||||
await session.commitTransaction();
|
||||
return replay;
|
||||
return {
|
||||
competition: updated,
|
||||
commandId,
|
||||
revision: nextRevision,
|
||||
replayed: false,
|
||||
};
|
||||
} catch (error) {
|
||||
await session.abortTransaction().catch(() => undefined);
|
||||
if (
|
||||
attempt < COMMAND_TRANSACTION_ATTEMPTS &&
|
||||
isRetryableCommandTransactionError(error)
|
||||
) {
|
||||
lastRetryableError = error;
|
||||
continue;
|
||||
}
|
||||
throw error;
|
||||
} finally {
|
||||
await session.endSession();
|
||||
}
|
||||
|
||||
const competition = await CompetitionModel.findById(competitionId)
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec();
|
||||
if (!competition) {
|
||||
throw new CompetitionCommandError(
|
||||
'COMPETITION_NOT_FOUND',
|
||||
'Competition not found.',
|
||||
404,
|
||||
{ competitionId: idString(competitionId) },
|
||||
);
|
||||
}
|
||||
assertExpectedRevision(competition.revision, command.expectedRevision);
|
||||
|
||||
const existingFacts = await FactModel.find({ competitionId })
|
||||
.sort({ revision: 1, ordinalWithinRevision: 1 })
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec();
|
||||
const nextRevision = command.expectedRevision + 1;
|
||||
const recordedAt = new Date();
|
||||
const fact = buildFact(
|
||||
command,
|
||||
commandId,
|
||||
requestHash,
|
||||
nextRevision,
|
||||
recordedAt,
|
||||
);
|
||||
const projection = projectCompetition({
|
||||
competitionId: idString(competitionId),
|
||||
revision: nextRevision,
|
||||
projectorVersion: competition.projectorVersion,
|
||||
teams: toPlain(competition.teams) as never,
|
||||
format: toPlain(competition.format) as never,
|
||||
seriesGraph: toPlain(competition.seriesGraph) as never,
|
||||
facts: [...existingFacts, fact].map(factForProjection),
|
||||
});
|
||||
|
||||
await FactModel.insertMany([fact], { session });
|
||||
const updated = await CompetitionModel.findOneAndUpdate(
|
||||
{ _id: competitionId, revision: command.expectedRevision },
|
||||
{
|
||||
$inc: { revision: 1 },
|
||||
$set: {
|
||||
projection,
|
||||
projectorVersion: competition.projectorVersion,
|
||||
phase: projection.phase,
|
||||
},
|
||||
},
|
||||
{ new: true, runValidators: true, session },
|
||||
)
|
||||
.lean()
|
||||
.exec();
|
||||
if (!updated) {
|
||||
throw staleRevisionError(command.expectedRevision);
|
||||
}
|
||||
|
||||
await this.applyTournamentCode(command, commandId, recordedAt, session);
|
||||
await OutboxModel.insertMany(
|
||||
[
|
||||
buildOutbox(
|
||||
competitionId,
|
||||
command,
|
||||
commandId,
|
||||
requestHash,
|
||||
nextRevision,
|
||||
fact,
|
||||
projection,
|
||||
updated,
|
||||
recordedAt,
|
||||
),
|
||||
],
|
||||
{ session },
|
||||
);
|
||||
await session.commitTransaction();
|
||||
return {
|
||||
competition: updated,
|
||||
commandId,
|
||||
revision: nextRevision,
|
||||
replayed: false,
|
||||
};
|
||||
} catch (error) {
|
||||
await session.abortTransaction().catch(() => undefined);
|
||||
throw error;
|
||||
} finally {
|
||||
await session.endSession();
|
||||
}
|
||||
throw lastRetryableError;
|
||||
}
|
||||
|
||||
private async replay(
|
||||
@@ -595,6 +629,7 @@ export class CompetitionCommandService {
|
||||
|
||||
private async applyReversalAssignments(
|
||||
competitionId: PersistenceId,
|
||||
matchId: PersistenceId,
|
||||
preview: SeriesReversalPreview,
|
||||
assignments: AssignmentRecord[],
|
||||
commandId: string,
|
||||
@@ -638,6 +673,14 @@ export class CompetitionCommandService {
|
||||
tournamentCodeReversalStatePipeline(recordedAt),
|
||||
{ session },
|
||||
);
|
||||
const MatchModel = (await this.connectionService.getModel(
|
||||
'match',
|
||||
)) as mongoose.Model<any>;
|
||||
await MatchModel.updateOne(
|
||||
{ _id: matchId },
|
||||
{ $pull: { tournamentCodeIds: { $in: codeIds } } },
|
||||
{ session },
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -956,6 +999,22 @@ function tournamentCodeReversalStatePipeline(
|
||||
releasedAt: {
|
||||
$cond: [{ $eq: ['$state', 'reserved'] }, recordedAt, '$releasedAt'],
|
||||
},
|
||||
matchId: {
|
||||
$cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$matchId'],
|
||||
},
|
||||
gameNumber: {
|
||||
$cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$gameNumber'],
|
||||
},
|
||||
bracketMatchId: {
|
||||
$cond: [
|
||||
{ $eq: ['$state', 'reserved'] },
|
||||
'$$REMOVE',
|
||||
'$bracketMatchId',
|
||||
],
|
||||
},
|
||||
reservedAt: {
|
||||
$cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$reservedAt'],
|
||||
},
|
||||
},
|
||||
},
|
||||
];
|
||||
@@ -968,6 +1027,21 @@ function persistenceObjectId(value: PersistenceId): PersistenceId {
|
||||
: value;
|
||||
}
|
||||
|
||||
function isRetryableCommandTransactionError(error: unknown): boolean {
|
||||
const candidate = error as {
|
||||
code?: number;
|
||||
codeName?: string;
|
||||
hasErrorLabel?: (label: string) => boolean;
|
||||
};
|
||||
return Boolean(
|
||||
candidate?.code === 11_000 ||
|
||||
candidate?.code === 112 ||
|
||||
candidate?.codeName === 'WriteConflict' ||
|
||||
candidate?.hasErrorLabel?.('TransientTransactionError') ||
|
||||
candidate?.hasErrorLabel?.('UnknownTransactionCommitResult'),
|
||||
);
|
||||
}
|
||||
|
||||
function competitionNotFound(
|
||||
competitionId: PersistenceId,
|
||||
): CompetitionCommandError {
|
||||
|
||||
@@ -1,29 +1,24 @@
|
||||
import { ForbiddenException } from '@nestjs/common';
|
||||
import { ConflictException, ForbiddenException } from '@nestjs/common';
|
||||
import { Types } from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import { CompetitionBootstrapService } from './competition-bootstrap.service';
|
||||
import { CompetitionQueryService } from './competition-query.service';
|
||||
|
||||
describe('CompetitionQueryService', () => {
|
||||
it('bootstraps a built Match once when its Competition is first read', async () => {
|
||||
it('does not let a public read race the team-build bootstrap workflow', async () => {
|
||||
const harness = createHarness({ competition: null });
|
||||
const bootstrapped = competitionDocument();
|
||||
harness.bootstrapService.bootstrap.mockResolvedValue(bootstrapped);
|
||||
const service = createService(harness);
|
||||
|
||||
const result = await service.getCompetition({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
});
|
||||
await expect(
|
||||
service.getCompetition({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
}),
|
||||
).rejects.toBeInstanceOf(ConflictException);
|
||||
|
||||
expect(harness.matchModel.findOne).toHaveBeenCalledWith({
|
||||
_id: MATCH_ID,
|
||||
communityId: COMMUNITY_ID,
|
||||
});
|
||||
expect(harness.bootstrapService.bootstrap).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ _id: MATCH_ID, status: 'team-built' }),
|
||||
);
|
||||
expect(result).toBe(bootstrapped);
|
||||
});
|
||||
|
||||
it('returns an explicit team view with codes only for the callers team', async () => {
|
||||
@@ -56,6 +51,7 @@ describe('CompetitionQueryService', () => {
|
||||
expect(JSON.stringify(result)).not.toContain('OPPONENT-SECRET-CODE');
|
||||
expect(harness.tournamentCodeModel.find).toHaveBeenCalledWith({
|
||||
_id: { $in: [TEAM_A_CODE_ID] },
|
||||
state: { $in: ['reserved', 'used'] },
|
||||
});
|
||||
});
|
||||
|
||||
@@ -71,6 +67,20 @@ describe('CompetitionQueryService', () => {
|
||||
).rejects.toBeInstanceOf(ForbiddenException);
|
||||
});
|
||||
|
||||
it('does not expose a stale code whose active assignment no longer matches', async () => {
|
||||
const harness = createHarness();
|
||||
harness.tournamentCodeModel.find.mockReturnValueOnce(queryResult([]));
|
||||
const service = createService(harness);
|
||||
|
||||
await expect(
|
||||
service.getTeamView({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
userId: TEAM_A_USER_ID,
|
||||
}),
|
||||
).rejects.toBeInstanceOf(ConflictException);
|
||||
});
|
||||
|
||||
it('pages facts in immutable revision order using an opaque cursor', async () => {
|
||||
const harness = createHarness();
|
||||
harness.factModel.find.mockReturnValueOnce(
|
||||
@@ -116,7 +126,6 @@ const GAME_SLOT_ID = 'slot-1';
|
||||
function createService(harness: ReturnType<typeof createHarness>) {
|
||||
return new CompetitionQueryService(
|
||||
harness.connectionService as ConnectionService,
|
||||
harness.bootstrapService as unknown as CompetitionBootstrapService,
|
||||
);
|
||||
}
|
||||
|
||||
@@ -167,11 +176,15 @@ function createHarness(options: { competition?: unknown } = {}) {
|
||||
{
|
||||
_id: TEAM_A_CODE_ID,
|
||||
code: 'TEAM-A-SECRET-CODE',
|
||||
state: 'reserved',
|
||||
matchId: MATCH_ID,
|
||||
expiresAt: new Date('2026-07-13T00:00:00.000Z'),
|
||||
},
|
||||
{
|
||||
_id: TEAM_B_CODE_ID,
|
||||
code: 'OPPONENT-SECRET-CODE',
|
||||
state: 'reserved',
|
||||
matchId: MATCH_ID,
|
||||
expiresAt: new Date('2026-07-13T00:00:00.000Z'),
|
||||
},
|
||||
]),
|
||||
@@ -196,7 +209,6 @@ function createHarness(options: { competition?: unknown } = {}) {
|
||||
connectionService: {
|
||||
getModel: jest.fn((name: string) => Promise.resolve(models[name])),
|
||||
},
|
||||
bootstrapService: { bootstrap: jest.fn() },
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -13,7 +13,6 @@ import {
|
||||
import mongoose from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import type { Competition, CompetitionFact } from './competition.schema';
|
||||
import { CompetitionBootstrapService } from './competition-bootstrap.service';
|
||||
|
||||
type PersistenceId = string | mongoose.Types.ObjectId;
|
||||
type CompetitionRecord = Competition & { _id: mongoose.Types.ObjectId };
|
||||
@@ -30,25 +29,12 @@ interface CompetitionProjectionSource {
|
||||
|
||||
@Injectable()
|
||||
export class CompetitionQueryService {
|
||||
constructor(
|
||||
private readonly connectionService: ConnectionService,
|
||||
private readonly bootstrapService: CompetitionBootstrapService,
|
||||
) {}
|
||||
constructor(private readonly connectionService: ConnectionService) {}
|
||||
|
||||
/** Resolve the one-to-one aggregate, lazily freezing a completed team build. */
|
||||
/** Resolve the aggregate created by the finalized team-build workflow. */
|
||||
public async getCompetition(
|
||||
scope: CompetitionScope,
|
||||
): Promise<CompetitionRecord> {
|
||||
const CompetitionModel =
|
||||
await this.connectionService.getModel('competition');
|
||||
const existing = await CompetitionModel.findOne({
|
||||
matchId: scope.matchId,
|
||||
communityId: scope.communityId,
|
||||
})
|
||||
.lean()
|
||||
.exec();
|
||||
if (existing) return existing as CompetitionRecord;
|
||||
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const match = await MatchModel.findOne({
|
||||
_id: scope.matchId,
|
||||
@@ -66,7 +52,19 @@ export class CompetitionQueryService {
|
||||
'Competition is unavailable until team building is complete.',
|
||||
);
|
||||
}
|
||||
return this.bootstrapService.bootstrap(match as never);
|
||||
|
||||
const CompetitionModel =
|
||||
await this.connectionService.getModel('competition');
|
||||
const existing = await CompetitionModel.findOne({
|
||||
matchId: scope.matchId,
|
||||
communityId: scope.communityId,
|
||||
})
|
||||
.lean()
|
||||
.exec();
|
||||
if (existing) return existing as CompetitionRecord;
|
||||
throw new ConflictException(
|
||||
'Competition is still being initialized by the team-build workflow.',
|
||||
);
|
||||
}
|
||||
|
||||
public async getTeamView(
|
||||
@@ -126,7 +124,10 @@ export class CompetitionQueryService {
|
||||
const TournamentCodeModel =
|
||||
await this.connectionService.getModel('tournamentCode');
|
||||
const codes = codeIds.length
|
||||
? await TournamentCodeModel.find({ _id: { $in: codeIds } })
|
||||
? await TournamentCodeModel.find({
|
||||
_id: { $in: codeIds },
|
||||
state: { $in: ['reserved', 'used'] },
|
||||
})
|
||||
.lean()
|
||||
.exec()
|
||||
: [];
|
||||
@@ -150,6 +151,17 @@ export class CompetitionQueryService {
|
||||
const code = assignment
|
||||
? codeById.get(idString(assignment.tournamentCodeId))
|
||||
: undefined;
|
||||
if (
|
||||
assignment &&
|
||||
(!code ||
|
||||
code.state !== assignment.state ||
|
||||
!code.matchId ||
|
||||
!sameId(code.matchId, competition.matchId))
|
||||
) {
|
||||
throw new ConflictException(
|
||||
'Tournament Code assignment is inconsistent and cannot be exposed.',
|
||||
);
|
||||
}
|
||||
return {
|
||||
gameSlotId: gameSlotId as never,
|
||||
seriesId: idString(slot.seriesId as PersistenceId) as never,
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import {
|
||||
COMPETITION_OUTBOX_STATES,
|
||||
CompetitionFactSchema,
|
||||
CompetitionOutboxSchema,
|
||||
CompetitionSchema,
|
||||
@@ -93,6 +94,13 @@ describe('Competition persistence schemas', () => {
|
||||
]);
|
||||
});
|
||||
|
||||
it('defines a terminal dead-letter state for poison outbox events', () => {
|
||||
expect(COMPETITION_OUTBOX_STATES).toContain('dead-letter');
|
||||
expect(CompetitionOutboxSchema.path('state').options.enum).toContain(
|
||||
'dead-letter',
|
||||
);
|
||||
});
|
||||
|
||||
it('allows only one active assignment for a code or GameSlot', () => {
|
||||
expectIndexes(TournamentCodeAssignmentSchema, [
|
||||
{
|
||||
|
||||
@@ -20,6 +20,7 @@ export const COMPETITION_OUTBOX_STATES = [
|
||||
'pending',
|
||||
'published',
|
||||
'failed',
|
||||
'dead-letter',
|
||||
] as const;
|
||||
export type CompetitionOutboxState = (typeof COMPETITION_OUTBOX_STATES)[number];
|
||||
|
||||
@@ -32,6 +33,110 @@ export const TOURNAMENT_CODE_ASSIGNMENT_STATES = [
|
||||
export type TournamentCodeAssignmentState =
|
||||
(typeof TOURNAMENT_CODE_ASSIGNMENT_STATES)[number];
|
||||
|
||||
export interface CompetitionDomainInvariantIndex {
|
||||
collection:
|
||||
| 'match'
|
||||
| 'competition'
|
||||
| 'competition_fact'
|
||||
| 'competition_outbox'
|
||||
| 'tournament_code_assignment';
|
||||
key: mongoose.IndexDefinition;
|
||||
options: mongoose.IndexOptions & { name: string; unique: true };
|
||||
}
|
||||
|
||||
/**
|
||||
* Database-enforced Competition identities. Runtime schemas and the one-off
|
||||
* migration consume this same list so production cannot silently run with a
|
||||
* weaker set of uniqueness guarantees than command handling expects.
|
||||
*/
|
||||
export const COMPETITION_DOMAIN_INVARIANT_INDEXES: CompetitionDomainInvariantIndex[] =
|
||||
[
|
||||
{
|
||||
collection: 'match',
|
||||
key: { competitionId: 1 },
|
||||
options: {
|
||||
name: 'competitionId_1',
|
||||
unique: true,
|
||||
partialFilterExpression: {
|
||||
competitionId: { $type: 'objectId' },
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
collection: 'competition',
|
||||
key: { matchId: 1 },
|
||||
options: { name: 'matchId_1', unique: true },
|
||||
},
|
||||
{
|
||||
collection: 'competition_fact',
|
||||
key: { competitionId: 1, revision: 1, ordinalWithinRevision: 1 },
|
||||
options: {
|
||||
name: 'competitionId_1_revision_1_ordinalWithinRevision_1',
|
||||
unique: true,
|
||||
},
|
||||
},
|
||||
{
|
||||
collection: 'competition_fact',
|
||||
key: { competitionId: 1, commandId: 1, ordinalWithinRevision: 1 },
|
||||
options: {
|
||||
name: 'competitionId_1_commandId_1_ordinalWithinRevision_1',
|
||||
unique: true,
|
||||
},
|
||||
},
|
||||
{
|
||||
collection: 'competition_fact',
|
||||
key: { 'evidence.riotMatchId': 1 },
|
||||
options: {
|
||||
name: 'evidence.riotMatchId_1',
|
||||
unique: true,
|
||||
partialFilterExpression: {
|
||||
type: 'game-accepted',
|
||||
'evidence.riotMatchId': { $type: 'string' },
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
collection: 'competition_outbox',
|
||||
key: { eventId: 1 },
|
||||
options: { name: 'eventId_1', unique: true },
|
||||
},
|
||||
{
|
||||
collection: 'competition_outbox',
|
||||
key: { competitionId: 1, idempotencyKey: 1 },
|
||||
options: {
|
||||
name: 'competitionId_1_idempotencyKey_1',
|
||||
unique: true,
|
||||
},
|
||||
},
|
||||
{
|
||||
collection: 'tournament_code_assignment',
|
||||
key: { gameSlotId: 1 },
|
||||
options: {
|
||||
name: 'gameSlotId_1',
|
||||
unique: true,
|
||||
partialFilterExpression: { state: { $in: ['reserved', 'used'] } },
|
||||
},
|
||||
},
|
||||
{
|
||||
collection: 'tournament_code_assignment',
|
||||
key: { tournamentCodeId: 1 },
|
||||
options: {
|
||||
name: 'tournamentCodeId_1',
|
||||
unique: true,
|
||||
partialFilterExpression: { state: { $in: ['reserved', 'used'] } },
|
||||
},
|
||||
},
|
||||
{
|
||||
collection: 'tournament_code_assignment',
|
||||
key: { riotMatchId: 1 },
|
||||
options: {
|
||||
name: 'riotMatchId_1',
|
||||
unique: true,
|
||||
partialFilterExpression: { riotMatchId: { $type: 'string' } },
|
||||
},
|
||||
},
|
||||
];
|
||||
|
||||
export interface CompetitionTeamMemberSnapshot {
|
||||
userId: mongoose.Types.ObjectId;
|
||||
displayName: string;
|
||||
@@ -200,7 +305,7 @@ export const CompetitionSchema: mongoose.Schema<Competition> =
|
||||
{ timestamps: true, collection: 'competition' },
|
||||
);
|
||||
|
||||
CompetitionSchema.index({ matchId: 1 }, { unique: true });
|
||||
applyCompetitionDomainInvariantIndexes(CompetitionSchema, 'competition');
|
||||
CompetitionSchema.index({ communityId: 1, phase: 1, updatedAt: -1 });
|
||||
|
||||
export const CompetitionFactSchema = new Schema<CompetitionFact>(
|
||||
@@ -238,23 +343,9 @@ export const CompetitionFactSchema = new Schema<CompetitionFact>(
|
||||
{ timestamps: true, collection: 'competition_fact' },
|
||||
);
|
||||
|
||||
CompetitionFactSchema.index(
|
||||
{ competitionId: 1, revision: 1, ordinalWithinRevision: 1 },
|
||||
{ unique: true },
|
||||
);
|
||||
CompetitionFactSchema.index(
|
||||
{ competitionId: 1, commandId: 1, ordinalWithinRevision: 1 },
|
||||
{ unique: true },
|
||||
);
|
||||
CompetitionFactSchema.index(
|
||||
{ 'evidence.riotMatchId': 1 },
|
||||
{
|
||||
unique: true,
|
||||
partialFilterExpression: {
|
||||
type: 'game-accepted',
|
||||
'evidence.riotMatchId': { $type: 'string' },
|
||||
},
|
||||
},
|
||||
applyCompetitionDomainInvariantIndexes(
|
||||
CompetitionFactSchema,
|
||||
'competition_fact',
|
||||
);
|
||||
CompetitionFactSchema.index({ competitionId: 1, seriesId: 1, recordedAt: 1 });
|
||||
|
||||
@@ -286,12 +377,11 @@ export const CompetitionOutboxSchema = new Schema<CompetitionOutbox>(
|
||||
{ timestamps: true, collection: 'competition_outbox' },
|
||||
);
|
||||
|
||||
CompetitionOutboxSchema.index({ eventId: 1 }, { unique: true });
|
||||
CompetitionOutboxSchema.index({ state: 1, availableAt: 1 });
|
||||
CompetitionOutboxSchema.index(
|
||||
{ competitionId: 1, idempotencyKey: 1 },
|
||||
{ unique: true },
|
||||
applyCompetitionDomainInvariantIndexes(
|
||||
CompetitionOutboxSchema,
|
||||
'competition_outbox',
|
||||
);
|
||||
CompetitionOutboxSchema.index({ state: 1, availableAt: 1 });
|
||||
|
||||
export const TournamentCodeAssignmentSchema =
|
||||
new Schema<TournamentCodeAssignment>(
|
||||
@@ -323,30 +413,22 @@ export const TournamentCodeAssignmentSchema =
|
||||
{ timestamps: true, collection: 'tournament_code_assignment' },
|
||||
);
|
||||
|
||||
const activeAssignmentFilter = { state: { $in: ['reserved', 'used'] } };
|
||||
TournamentCodeAssignmentSchema.index(
|
||||
{ gameSlotId: 1 },
|
||||
{
|
||||
unique: true,
|
||||
partialFilterExpression: activeAssignmentFilter,
|
||||
},
|
||||
);
|
||||
TournamentCodeAssignmentSchema.index(
|
||||
{ tournamentCodeId: 1 },
|
||||
{
|
||||
unique: true,
|
||||
partialFilterExpression: activeAssignmentFilter,
|
||||
},
|
||||
);
|
||||
TournamentCodeAssignmentSchema.index(
|
||||
{ riotMatchId: 1 },
|
||||
{
|
||||
unique: true,
|
||||
partialFilterExpression: { riotMatchId: { $type: 'string' } },
|
||||
},
|
||||
applyCompetitionDomainInvariantIndexes(
|
||||
TournamentCodeAssignmentSchema,
|
||||
'tournament_code_assignment',
|
||||
);
|
||||
TournamentCodeAssignmentSchema.index({ competitionId: 1, state: 1 });
|
||||
|
||||
export function applyCompetitionDomainInvariantIndexes(
|
||||
schema: mongoose.Schema,
|
||||
collection: CompetitionDomainInvariantIndex['collection'],
|
||||
): void {
|
||||
for (const index of COMPETITION_DOMAIN_INVARIANT_INDEXES) {
|
||||
if (index.collection !== collection) continue;
|
||||
schema.index(index.key, index.options);
|
||||
}
|
||||
}
|
||||
|
||||
export const competitionModelDefinitions: Array<{
|
||||
name: string;
|
||||
schema: mongoose.Schema;
|
||||
|
||||
@@ -307,6 +307,114 @@ describe('projectCompetition', () => {
|
||||
expect(projection.games).toEqual([]);
|
||||
});
|
||||
|
||||
it('rejects an accepted game that targets a Series outside the graph', () => {
|
||||
const competitionId = 'competition-unknown-game-series';
|
||||
const teams = [seededTeam('team-1', 1), seededTeam('team-2', 2)];
|
||||
const format = {
|
||||
type: 'paired-series' as const,
|
||||
rule: fixedGames(1),
|
||||
};
|
||||
const seriesGraph = generateSeriesGraph({ competitionId, teams, format });
|
||||
const accepted = acceptedGameFactory(competitionId)(
|
||||
seriesGraph[0],
|
||||
1,
|
||||
'team-1',
|
||||
'team-2',
|
||||
'team-1',
|
||||
);
|
||||
|
||||
expect(() =>
|
||||
projectCompetition({
|
||||
competitionId,
|
||||
revision: 1,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts: [{ ...accepted, seriesId: 'series-does-not-exist' }],
|
||||
}),
|
||||
).toThrow(
|
||||
expect.objectContaining({
|
||||
code: 'GAME_SERIES_MISMATCH',
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('rejects an accepted game that targets an unknown GameSlot', () => {
|
||||
const competitionId = 'competition-unknown-game-slot';
|
||||
const teams = [seededTeam('team-1', 1), seededTeam('team-2', 2)];
|
||||
const format = {
|
||||
type: 'paired-series' as const,
|
||||
rule: fixedGames(1),
|
||||
};
|
||||
const seriesGraph = generateSeriesGraph({ competitionId, teams, format });
|
||||
const accepted = acceptedGameFactory(competitionId)(
|
||||
seriesGraph[0],
|
||||
1,
|
||||
'team-1',
|
||||
'team-2',
|
||||
'team-1',
|
||||
);
|
||||
|
||||
expect(() =>
|
||||
projectCompetition({
|
||||
competitionId,
|
||||
revision: 1,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts: [{ ...accepted, gameSlotId: 'slot-does-not-exist' }],
|
||||
}),
|
||||
).toThrow(
|
||||
expect.objectContaining({
|
||||
code: 'GAME_SLOT_INVALID',
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('rejects an adjudication that targets a Series outside the graph', () => {
|
||||
const competitionId = 'competition-unknown-adjudication-series';
|
||||
const teams = [seededTeam('team-1', 1), seededTeam('team-2', 2)];
|
||||
const format = {
|
||||
type: 'paired-series' as const,
|
||||
rule: fixedGames(1),
|
||||
};
|
||||
const seriesGraph = generateSeriesGraph({ competitionId, teams, format });
|
||||
|
||||
expect(() =>
|
||||
projectCompetition({
|
||||
competitionId,
|
||||
revision: 1,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts: [
|
||||
{
|
||||
id: 'fact-unknown-adjudication-series',
|
||||
type: 'series-adjudicated',
|
||||
competitionId,
|
||||
revision: 1,
|
||||
ordinalWithinRevision: 1,
|
||||
commandId: 'command-unknown-adjudication-series',
|
||||
schemaVersion: 1,
|
||||
actor: { type: 'user' },
|
||||
occurredAt: new Date('2026-07-12T00:00:01.000Z'),
|
||||
recordedAt: new Date('2026-07-12T00:00:02.000Z'),
|
||||
seriesId: 'series-does-not-exist',
|
||||
decision: { type: 'administrative', winnerTeamId: 'team-1' },
|
||||
reason: 'Manual correction',
|
||||
},
|
||||
],
|
||||
}),
|
||||
).toThrow(
|
||||
expect.objectContaining({
|
||||
code: 'ADJUDICATION_INVALID',
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('completes an eight-team double elimination with shared elimination-round placements', () => {
|
||||
const competitionId = 'competition-eight-team-completion';
|
||||
const teams = Array.from({ length: 8 }, (_, index) =>
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
import { assertCompetitionInvariant } from './domain-error';
|
||||
import type {
|
||||
CompetitionGraphFormat,
|
||||
CompetitionGraphTeam,
|
||||
@@ -130,6 +131,7 @@ export interface CompetitionProjection {
|
||||
export function projectCompetition(
|
||||
input: ProjectCompetitionInput,
|
||||
): CompetitionProjection {
|
||||
assertPrimaryFactTargetsGraph(input.seriesGraph, input.facts);
|
||||
const teamBySeed = new Map<number, string>();
|
||||
const knownTeams = new Set<string>();
|
||||
for (const team of input.teams) {
|
||||
@@ -279,6 +281,68 @@ export function projectCompetition(
|
||||
}
|
||||
}
|
||||
|
||||
function assertPrimaryFactTargetsGraph(
|
||||
graph: readonly SeriesDefinition[],
|
||||
facts: readonly unknown[],
|
||||
): void {
|
||||
const definitionsById = new Map(
|
||||
graph.map((definition) => [definition.id, definition]),
|
||||
);
|
||||
|
||||
for (const fact of facts) {
|
||||
if (!isRecord(fact)) continue;
|
||||
|
||||
if (fact.type === 'game-accepted') {
|
||||
const seriesId =
|
||||
typeof fact.seriesId === 'string' ? fact.seriesId : undefined;
|
||||
const definition = seriesId ? definitionsById.get(seriesId) : undefined;
|
||||
assertCompetitionInvariant(
|
||||
definition !== undefined,
|
||||
'GAME_SERIES_MISMATCH',
|
||||
`Accepted game targets an unknown Series ${String(fact.seriesId)}`,
|
||||
{ factId: fact.id, seriesId: fact.seriesId },
|
||||
);
|
||||
|
||||
const gameSlot = definition.gameSlots.find(
|
||||
({ id }) => id === fact.gameSlotId,
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
gameSlot !== undefined,
|
||||
'GAME_SLOT_INVALID',
|
||||
`Accepted game targets an unknown GameSlot ${String(fact.gameSlotId)}`,
|
||||
{
|
||||
factId: fact.id,
|
||||
seriesId: definition.id,
|
||||
gameSlotId: fact.gameSlotId,
|
||||
},
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
gameSlot.ordinal === fact.ordinal,
|
||||
'GAME_ORDINAL_INVALID',
|
||||
`Accepted game ordinal does not match GameSlot ${gameSlot.id}`,
|
||||
{
|
||||
factId: fact.id,
|
||||
gameSlotId: gameSlot.id,
|
||||
expectedOrdinal: gameSlot.ordinal,
|
||||
actualOrdinal: fact.ordinal,
|
||||
},
|
||||
);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (fact.type === 'series-adjudicated') {
|
||||
const seriesId =
|
||||
typeof fact.seriesId === 'string' ? fact.seriesId : undefined;
|
||||
assertCompetitionInvariant(
|
||||
seriesId !== undefined && definitionsById.has(seriesId),
|
||||
'ADJUDICATION_INVALID',
|
||||
`Adjudication targets an unknown Series ${String(fact.seriesId)}`,
|
||||
{ factId: fact.id, seriesId: fact.seriesId },
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function asProjectorDefinition(
|
||||
definition: SeriesDefinition,
|
||||
): SeriesDefinitionLike {
|
||||
|
||||
@@ -36,6 +36,7 @@ describe('migrateCompetitionDomain', () => {
|
||||
expect(startSession).not.toHaveBeenCalled();
|
||||
expect(db.writeCount).toBe(0);
|
||||
expect(db.docs('competition')).toHaveLength(0);
|
||||
expect(db.createdIndexes).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('applies one Match atomically and converges on an already-applied replay', async () => {
|
||||
@@ -181,6 +182,309 @@ describe('migrateCompetitionDomain', () => {
|
||||
});
|
||||
expect(db.writeCount).toBe(0);
|
||||
});
|
||||
|
||||
it('ensures every Competition unique or partial index before the first apply write', async () => {
|
||||
const match = readyMatch();
|
||||
const db = new MemoryMigrationDb({
|
||||
match: [match],
|
||||
riotMatch: [riotArchive()],
|
||||
tournamentCode: [usedTournamentCode(match)],
|
||||
});
|
||||
|
||||
const result = await migrateCompetitionDomain(db, {
|
||||
dryRun: false,
|
||||
startSession: () => Promise.resolve(new FakeSession()),
|
||||
});
|
||||
|
||||
expect(result.indexPreflight).toMatchObject({
|
||||
status: 'ensured',
|
||||
requiredIndexes: 10,
|
||||
conflicts: [],
|
||||
});
|
||||
expect(result.indexPreflight.ensuredIndexes).toHaveLength(10);
|
||||
expect(db.createdIndexes).toHaveLength(10);
|
||||
expect(db.createdIndexes).toEqual(
|
||||
expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
collection: 'match',
|
||||
key: { competitionId: 1 },
|
||||
options: expect.objectContaining({
|
||||
unique: true,
|
||||
partialFilterExpression: {
|
||||
competitionId: { $type: 'objectId' },
|
||||
},
|
||||
}),
|
||||
}),
|
||||
expect.objectContaining({
|
||||
collection: 'competition',
|
||||
key: { matchId: 1 },
|
||||
options: expect.objectContaining({ unique: true }),
|
||||
}),
|
||||
expect.objectContaining({
|
||||
collection: 'competition_fact',
|
||||
key: { 'evidence.riotMatchId': 1 },
|
||||
options: expect.objectContaining({
|
||||
unique: true,
|
||||
partialFilterExpression: expect.any(Object),
|
||||
}),
|
||||
}),
|
||||
expect.objectContaining({
|
||||
collection: 'tournament_code_assignment',
|
||||
key: { gameSlotId: 1 },
|
||||
options: expect.objectContaining({
|
||||
unique: true,
|
||||
partialFilterExpression: expect.any(Object),
|
||||
}),
|
||||
}),
|
||||
]),
|
||||
);
|
||||
expect(db.operations.indexOf('create-index')).toBeLessThan(
|
||||
db.operations.indexOf('write'),
|
||||
);
|
||||
});
|
||||
|
||||
it('blocks apply with a machine-readable report when a required index cannot be created', async () => {
|
||||
const match = readyMatch();
|
||||
const db = new MemoryMigrationDb({ match: [match] });
|
||||
db.indexCreationError = Object.assign(
|
||||
new Error('E11000 duplicate key while building competitionId_1'),
|
||||
{
|
||||
code: 11000,
|
||||
keyPattern: { competitionId: 1 },
|
||||
keyValue: { competitionId: match._id },
|
||||
},
|
||||
);
|
||||
const startSession = jest.fn(() => Promise.resolve(new FakeSession()));
|
||||
|
||||
const result = await migrateCompetitionDomain(db, {
|
||||
dryRun: false,
|
||||
startSession,
|
||||
});
|
||||
|
||||
expect(result.indexPreflight).toMatchObject({
|
||||
status: 'blocked',
|
||||
conflicts: [
|
||||
expect.objectContaining({
|
||||
collection: 'match',
|
||||
code: 11000,
|
||||
keyValue: {
|
||||
competitionId: (match._id as mongoose.Types.ObjectId).toHexString(),
|
||||
},
|
||||
}),
|
||||
],
|
||||
});
|
||||
expect(result.matches).toEqual([]);
|
||||
expect(result.summary.scanned).toBe(0);
|
||||
expect(startSession).not.toHaveBeenCalled();
|
||||
expect(db.writeCount).toBe(0);
|
||||
});
|
||||
|
||||
it('quarantines a later Match that reuses an already accepted global Riot identity', async () => {
|
||||
const firstMatch = readyMatch('KR_SHARED_MIGRATION');
|
||||
const secondMatch = readyMatch('KR_SHARED_MIGRATION');
|
||||
const db = new MemoryMigrationDb({
|
||||
match: [firstMatch, secondMatch],
|
||||
riotMatch: [riotArchive('KR_SHARED_MIGRATION')],
|
||||
tournamentCode: [
|
||||
usedTournamentCode(firstMatch, 'KR_SHARED_MIGRATION'),
|
||||
usedTournamentCode(secondMatch, 'KR_SHARED_MIGRATION'),
|
||||
],
|
||||
});
|
||||
|
||||
const result = await migrateCompetitionDomain(db, {
|
||||
dryRun: false,
|
||||
startSession: () => Promise.resolve(new FakeSession()),
|
||||
});
|
||||
|
||||
expect(result.summary).toMatchObject({ applied: 1, quarantined: 1 });
|
||||
expect(result.matches).toContainEqual(
|
||||
expect.objectContaining({
|
||||
status: 'quarantined',
|
||||
reasons: expect.arrayContaining([
|
||||
expect.objectContaining({ code: 'GLOBAL_UNIQUE_INDEX_CONFLICT' }),
|
||||
]),
|
||||
}),
|
||||
);
|
||||
expect(db.docs('competition_fact')).toHaveLength(1);
|
||||
expect(db.docs('competition_migration_quarantine')).toHaveLength(1);
|
||||
});
|
||||
|
||||
it('resumes repeated limited apply runs after the durable Match checkpoint', async () => {
|
||||
const firstMatch = readyMatch('KR_BATCH_1');
|
||||
const secondMatch = readyMatch('KR_BATCH_2');
|
||||
const db = new MemoryMigrationDb({
|
||||
match: [firstMatch, secondMatch],
|
||||
riotMatch: [riotArchive('KR_BATCH_1'), riotArchive('KR_BATCH_2')],
|
||||
tournamentCode: [
|
||||
usedTournamentCode(firstMatch, 'KR_BATCH_1'),
|
||||
usedTournamentCode(secondMatch, 'KR_BATCH_2'),
|
||||
],
|
||||
});
|
||||
|
||||
const first = await migrateCompetitionDomain(db, {
|
||||
dryRun: false,
|
||||
limit: 1,
|
||||
startSession: () => Promise.resolve(new FakeSession()),
|
||||
});
|
||||
const second = await migrateCompetitionDomain(db, {
|
||||
dryRun: false,
|
||||
limit: 1,
|
||||
startSession: () => Promise.resolve(new FakeSession()),
|
||||
});
|
||||
|
||||
expect(first.summary).toMatchObject({ scanned: 1, applied: 1 });
|
||||
expect(first.resume).toMatchObject({
|
||||
strategy: 'checkpoint',
|
||||
hasMore: true,
|
||||
completed: false,
|
||||
});
|
||||
expect(second.summary).toMatchObject({ scanned: 1, applied: 1 });
|
||||
expect(second.matches[0].matchId).not.toBe(first.matches[0].matchId);
|
||||
expect(second.resume).toMatchObject({
|
||||
strategy: 'checkpoint',
|
||||
startedAfterMatchId: first.matches[0].matchId,
|
||||
hasMore: false,
|
||||
completed: true,
|
||||
});
|
||||
expect(db.docs('competition')).toHaveLength(2);
|
||||
expect(db.docs('competition_migration_checkpoint')).toHaveLength(1);
|
||||
});
|
||||
|
||||
it('does not let an apply checkpoint silently narrow a later dry-run', async () => {
|
||||
const firstMatch = readyMatch('KR_DRY_RUN_1');
|
||||
const secondMatch = readyMatch('KR_DRY_RUN_2');
|
||||
const db = new MemoryMigrationDb({
|
||||
match: [firstMatch, secondMatch],
|
||||
riotMatch: [riotArchive('KR_DRY_RUN_1'), riotArchive('KR_DRY_RUN_2')],
|
||||
tournamentCode: [
|
||||
usedTournamentCode(firstMatch, 'KR_DRY_RUN_1'),
|
||||
usedTournamentCode(secondMatch, 'KR_DRY_RUN_2'),
|
||||
],
|
||||
});
|
||||
const applied = await migrateCompetitionDomain(db, {
|
||||
dryRun: false,
|
||||
limit: 1,
|
||||
startSession: () => Promise.resolve(new FakeSession()),
|
||||
});
|
||||
|
||||
const dryRun = await migrateCompetitionDomain(db, {
|
||||
dryRun: true,
|
||||
limit: 1,
|
||||
});
|
||||
|
||||
expect(dryRun.resume.strategy).toBe('none');
|
||||
expect(dryRun.matches[0].matchId).toBe(applied.matches[0].matchId);
|
||||
});
|
||||
|
||||
it('does not advance a limited-run checkpoint past a failed Match', async () => {
|
||||
const match = readyMatch('KR_RETRY_AFTER_FAILURE');
|
||||
const db = new MemoryMigrationDb({
|
||||
match: [match],
|
||||
riotMatch: [riotArchive('KR_RETRY_AFTER_FAILURE')],
|
||||
tournamentCode: [usedTournamentCode(match, 'KR_RETRY_AFTER_FAILURE')],
|
||||
});
|
||||
|
||||
const failed = await migrateCompetitionDomain(db, {
|
||||
dryRun: false,
|
||||
limit: 1,
|
||||
startSession: () => Promise.resolve(undefined),
|
||||
});
|
||||
|
||||
expect(failed.summary).toMatchObject({ scanned: 1, failed: 1 });
|
||||
expect(failed.resume).toMatchObject({
|
||||
strategy: 'checkpoint',
|
||||
hasMore: true,
|
||||
completed: false,
|
||||
});
|
||||
expect(db.docs('competition_migration_checkpoint')).toHaveLength(0);
|
||||
|
||||
const retried = await migrateCompetitionDomain(db, {
|
||||
dryRun: false,
|
||||
limit: 1,
|
||||
startSession: () => Promise.resolve(new FakeSession()),
|
||||
});
|
||||
|
||||
expect(db.docs('competition_migration_checkpoint')).toHaveLength(1);
|
||||
expect(retried.matches[0].matchId).toBe(failed.matches[0].matchId);
|
||||
expect(retried.summary).toMatchObject({ scanned: 1, applied: 1 });
|
||||
});
|
||||
|
||||
it('durably overrides a later checkpoint before an explicit earlier retry can fail', async () => {
|
||||
const retryMatch = readyMatch('KR_EXPLICIT_RETRY');
|
||||
const laterMatch = readyMatch('KR_LATER_CHECKPOINT');
|
||||
const explicitAfter = '000000000000000000000000';
|
||||
const migrationRunId = '20260712-competition-domain';
|
||||
const db = new MemoryMigrationDb({
|
||||
match: [retryMatch, laterMatch],
|
||||
riotMatch: [
|
||||
riotArchive('KR_EXPLICIT_RETRY'),
|
||||
riotArchive('KR_LATER_CHECKPOINT'),
|
||||
],
|
||||
tournamentCode: [
|
||||
usedTournamentCode(retryMatch, 'KR_EXPLICIT_RETRY'),
|
||||
usedTournamentCode(laterMatch, 'KR_LATER_CHECKPOINT'),
|
||||
],
|
||||
competition_migration_checkpoint: [
|
||||
{
|
||||
_id: migrationRunId,
|
||||
migrationRunId,
|
||||
lastMatchId: laterMatch._id,
|
||||
status: 'running',
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
const failed = await migrateCompetitionDomain(db, {
|
||||
dryRun: false,
|
||||
limit: 1,
|
||||
afterMatchId: explicitAfter,
|
||||
startSession: () => Promise.resolve(undefined),
|
||||
});
|
||||
|
||||
expect(failed.summary).toMatchObject({ scanned: 1, failed: 1 });
|
||||
expect(
|
||||
String(db.docs('competition_migration_checkpoint')[0].lastMatchId),
|
||||
).toBe(explicitAfter);
|
||||
|
||||
const retried = await migrateCompetitionDomain(db, {
|
||||
dryRun: false,
|
||||
limit: 1,
|
||||
startSession: () => Promise.resolve(new FakeSession()),
|
||||
});
|
||||
|
||||
expect(retried.matches[0].matchId).toBe(failed.matches[0].matchId);
|
||||
expect(retried.summary).toMatchObject({ scanned: 1, applied: 1 });
|
||||
});
|
||||
|
||||
it('does not persist an explicit checkpoint override during dry-run', async () => {
|
||||
const match = readyMatch('KR_DRY_EXPLICIT_CURSOR');
|
||||
const migrationRunId = '20260712-competition-domain';
|
||||
const persistedCheckpoint = objectId();
|
||||
const db = new MemoryMigrationDb({
|
||||
match: [match],
|
||||
riotMatch: [riotArchive('KR_DRY_EXPLICIT_CURSOR')],
|
||||
tournamentCode: [usedTournamentCode(match, 'KR_DRY_EXPLICIT_CURSOR')],
|
||||
competition_migration_checkpoint: [
|
||||
{
|
||||
_id: migrationRunId,
|
||||
migrationRunId,
|
||||
lastMatchId: persistedCheckpoint,
|
||||
status: 'running',
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
await migrateCompetitionDomain(db, {
|
||||
dryRun: true,
|
||||
limit: 1,
|
||||
afterMatchId: '000000000000000000000000',
|
||||
});
|
||||
|
||||
expect(
|
||||
String(db.docs('competition_migration_checkpoint')[0].lastMatchId),
|
||||
).toBe(persistedCheckpoint.toHexString());
|
||||
expect(db.writeCount).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
class FakeSession implements CompetitionDomainMigrationSession {
|
||||
@@ -211,6 +515,13 @@ type AnyDoc = Record<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)) {
|
||||
@@ -227,6 +538,23 @@ class MemoryMigrationDb implements CompetitionDomainMigrationDb {
|
||||
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)),
|
||||
@@ -240,6 +568,7 @@ class MemoryMigrationDb implements CompetitionDomainMigrationDb {
|
||||
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));
|
||||
@@ -251,6 +580,7 @@ class MemoryMigrationDb implements CompetitionDomainMigrationDb {
|
||||
if (!doc) return { matchedCount: 0, modifiedCount: 0 };
|
||||
if (inserted) Object.assign(doc, update.$setOnInsert ?? {});
|
||||
Object.assign(doc, update.$set ?? {});
|
||||
for (const field of Object.keys(update.$unset ?? {})) delete doc[field];
|
||||
return {
|
||||
matchedCount: inserted ? 0 : 1,
|
||||
modifiedCount: 1,
|
||||
@@ -258,6 +588,7 @@ class MemoryMigrationDb implements CompetitionDomainMigrationDb {
|
||||
};
|
||||
},
|
||||
async deleteOne(filter: Record<string, unknown>) {
|
||||
owner.operations.push('write');
|
||||
owner.writeCount += 1;
|
||||
const docs = owner.docs(name);
|
||||
const index = docs.findIndex((doc) => matches(doc, filter));
|
||||
@@ -318,6 +649,9 @@ function matches(doc: AnyDoc, filter: Record<string, unknown>): boolean {
|
||||
sameValue(actual, candidate),
|
||||
);
|
||||
}
|
||||
if ('$gt' in expected) {
|
||||
return String(actual) > String(expected.$gt);
|
||||
}
|
||||
}
|
||||
return sameValue(actual, expected);
|
||||
});
|
||||
@@ -348,7 +682,7 @@ function isRecord(value: unknown): value is Record<string, any> {
|
||||
return value !== null && typeof value === 'object' && !Array.isArray(value);
|
||||
}
|
||||
|
||||
function readyMatch(): AnyDoc {
|
||||
function readyMatch(riotMatchId = 'KR_MIGRATION_1'): AnyDoc {
|
||||
const matchId = objectId();
|
||||
const codeId = objectId();
|
||||
return {
|
||||
@@ -362,11 +696,11 @@ function readyMatch(): AnyDoc {
|
||||
gameSchedule: [{ gameNumber: 1, teamAIndex: 1, teamBIndex: 2 }],
|
||||
tournamentCodeIds: [codeId],
|
||||
result: {
|
||||
riotMatchIds: ['KR_MIGRATION_1'],
|
||||
riotMatchIds: [riotMatchId],
|
||||
games: [
|
||||
{
|
||||
gameNumber: 1,
|
||||
riotMatchId: 'KR_MIGRATION_1',
|
||||
riotMatchId,
|
||||
blueTeamIndex: 1,
|
||||
redTeamIndex: 2,
|
||||
winnerTeamIndex: 1,
|
||||
@@ -383,23 +717,26 @@ function readyMatch(): AnyDoc {
|
||||
};
|
||||
}
|
||||
|
||||
function usedTournamentCode(match = readyMatch()): AnyDoc {
|
||||
function usedTournamentCode(
|
||||
match = readyMatch(),
|
||||
riotMatchId = 'KR_MIGRATION_1',
|
||||
): AnyDoc {
|
||||
return {
|
||||
_id: match.tournamentCodeIds[0],
|
||||
matchId: match._id,
|
||||
state: 'used',
|
||||
gameNumber: 1,
|
||||
riotMatchId: 'KR_MIGRATION_1',
|
||||
riotMatchId,
|
||||
reservedAt: new Date('2026-07-01T00:30:00.000Z'),
|
||||
usedAt: new Date('2026-07-01T01:00:00.000Z'),
|
||||
};
|
||||
}
|
||||
|
||||
function riotArchive(): AnyDoc {
|
||||
function riotArchive(matchId = 'KR_MIGRATION_1'): AnyDoc {
|
||||
return {
|
||||
_id: objectId(),
|
||||
matchId: 'KR_MIGRATION_1',
|
||||
raw: { metadata: { matchId: 'KR_MIGRATION_1' } },
|
||||
matchId,
|
||||
raw: { metadata: { matchId } },
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -1,6 +1,10 @@
|
||||
import { createHash } from 'node:crypto';
|
||||
import mongoose from 'mongoose';
|
||||
import { projectCompetition } from '../../../competition/domain/competition-projector';
|
||||
import {
|
||||
COMPETITION_DOMAIN_INVARIANT_INDEXES,
|
||||
type CompetitionDomainInvariantIndex,
|
||||
} from '../../../competition/competition.schema';
|
||||
import {
|
||||
planCompetitionMigration,
|
||||
type CompetitionMigrationAssignment,
|
||||
@@ -21,6 +25,10 @@ export interface CompetitionDomainMigrationCursor extends AsyncIterable<AnyDocum
|
||||
}
|
||||
|
||||
export interface CompetitionDomainMigrationCollection {
|
||||
createIndex(
|
||||
key: mongoose.IndexDefinition,
|
||||
options: mongoose.IndexOptions,
|
||||
): Promise<string>;
|
||||
find(
|
||||
filter: Record<string, unknown>,
|
||||
options?: { session?: CompetitionDomainMigrationSession },
|
||||
@@ -34,6 +42,7 @@ export interface CompetitionDomainMigrationCollection {
|
||||
update: {
|
||||
$set?: Record<string, unknown>;
|
||||
$setOnInsert?: Record<string, unknown>;
|
||||
$unset?: Record<string, unknown>;
|
||||
},
|
||||
options?: {
|
||||
session?: CompetitionDomainMigrationSession;
|
||||
@@ -64,6 +73,7 @@ export interface CompetitionDomainMigrationSession {
|
||||
export interface CompetitionDomainMigrationOptions {
|
||||
dryRun?: boolean;
|
||||
limit?: number;
|
||||
afterMatchId?: string;
|
||||
migrationRunId?: string;
|
||||
now?: Date;
|
||||
startSession?: () => Promise<CompetitionDomainMigrationSession | undefined>;
|
||||
@@ -118,10 +128,37 @@ export interface CompetitionDomainMigrationSummary {
|
||||
export interface CompetitionDomainMigrationResult {
|
||||
migrationRunId: string;
|
||||
mode: 'dry-run' | 'apply';
|
||||
indexPreflight: CompetitionDomainIndexPreflight;
|
||||
resume: CompetitionDomainMigrationResume;
|
||||
summary: CompetitionDomainMigrationSummary;
|
||||
matches: CompetitionDomainMigrationMatchResult[];
|
||||
}
|
||||
|
||||
export interface CompetitionDomainMigrationResume {
|
||||
strategy: 'none' | 'cursor' | 'checkpoint';
|
||||
startedAfterMatchId?: string;
|
||||
checkpointAfterMatchId?: string;
|
||||
hasMore: boolean;
|
||||
completed: boolean;
|
||||
}
|
||||
|
||||
export interface CompetitionDomainIndexConflict {
|
||||
collection: CompetitionDomainInvariantIndex['collection'];
|
||||
indexName: string;
|
||||
key: Record<string, unknown>;
|
||||
code?: number;
|
||||
keyPattern?: Record<string, unknown>;
|
||||
keyValue?: unknown;
|
||||
message: string;
|
||||
}
|
||||
|
||||
export interface CompetitionDomainIndexPreflight {
|
||||
status: 'dry-run' | 'ensured' | 'blocked';
|
||||
requiredIndexes: number;
|
||||
ensuredIndexes: string[];
|
||||
conflicts: CompetitionDomainIndexConflict[];
|
||||
}
|
||||
|
||||
/**
|
||||
* Plans or applies the clean-break Competition migration. Apply mode owns one
|
||||
* Mongo transaction per Match so a process can be stopped and safely resumed.
|
||||
@@ -135,9 +172,43 @@ export async function migrateCompetitionDomain(
|
||||
options.migrationRunId?.trim() || DEFAULT_MIGRATION_RUN_ID;
|
||||
assertOptions(options);
|
||||
|
||||
const matchSnapshots = await scanMatches(db, options.limit);
|
||||
const resumeStart = await resolveResumeStart(
|
||||
db,
|
||||
migrationRunId,
|
||||
options,
|
||||
dryRun,
|
||||
);
|
||||
|
||||
const indexPreflight = await ensureCompetitionDomainIndexes(db, dryRun);
|
||||
if (indexPreflight.status === 'blocked') {
|
||||
return {
|
||||
migrationRunId,
|
||||
mode: 'apply',
|
||||
indexPreflight,
|
||||
resume: resumeReport(resumeStart, undefined, true, false),
|
||||
summary: summarize([]),
|
||||
matches: [],
|
||||
};
|
||||
}
|
||||
if (!dryRun && options.limit !== undefined && options.afterMatchId) {
|
||||
await persistMigrationCheckpoint(db, {
|
||||
migrationRunId,
|
||||
matchId: options.afterMatchId,
|
||||
completed: false,
|
||||
resetMatchStatus: true,
|
||||
observedAt: options.now ?? new Date(),
|
||||
});
|
||||
}
|
||||
|
||||
const scan = await scanMatches(
|
||||
db,
|
||||
options.limit,
|
||||
resumeStart.startedAfterMatchId,
|
||||
);
|
||||
const matches: CompetitionDomainMigrationMatchResult[] = [];
|
||||
for (const [index, scannedMatch] of matchSnapshots.entries()) {
|
||||
let checkpointAfterMatchId = resumeStart.startedAfterMatchId;
|
||||
let haltedOnFailure = false;
|
||||
for (const [index, scannedMatch] of scan.matches.entries()) {
|
||||
const result = dryRun
|
||||
? await inspectMatch(db, scannedMatch, migrationRunId)
|
||||
: await applyMatch(db, scannedMatch, migrationRunId, options);
|
||||
@@ -146,29 +217,216 @@ export async function migrateCompetitionDomain(
|
||||
index: index + 1,
|
||||
matchId: result.matchId,
|
||||
status: result.status,
|
||||
total: matchSnapshots.length,
|
||||
total: scan.matches.length,
|
||||
});
|
||||
if (!dryRun && options.limit !== undefined) {
|
||||
if (result.status === 'failed') {
|
||||
haltedOnFailure = true;
|
||||
break;
|
||||
}
|
||||
await persistMigrationCheckpoint(db, {
|
||||
migrationRunId,
|
||||
matchId: result.matchId,
|
||||
matchStatus: result.status,
|
||||
completed: false,
|
||||
observedAt: options.now ?? new Date(),
|
||||
});
|
||||
checkpointAfterMatchId = result.matchId;
|
||||
}
|
||||
}
|
||||
|
||||
const hasMore =
|
||||
scan.hasMore || haltedOnFailure || matches.length < scan.matches.length;
|
||||
const completed =
|
||||
!hasMore && !matches.some(({ status }) => status === 'failed');
|
||||
if (!dryRun && options.limit !== undefined && completed) {
|
||||
await persistMigrationCheckpoint(db, {
|
||||
migrationRunId,
|
||||
matchId: checkpointAfterMatchId,
|
||||
completed: true,
|
||||
observedAt: options.now ?? new Date(),
|
||||
});
|
||||
}
|
||||
|
||||
return {
|
||||
migrationRunId,
|
||||
mode: dryRun ? 'dry-run' : 'apply',
|
||||
indexPreflight,
|
||||
resume: resumeReport(
|
||||
resumeStart,
|
||||
checkpointAfterMatchId,
|
||||
hasMore,
|
||||
completed,
|
||||
),
|
||||
summary: summarize(matches),
|
||||
matches,
|
||||
};
|
||||
}
|
||||
|
||||
interface ResumeStart {
|
||||
strategy: CompetitionDomainMigrationResume['strategy'];
|
||||
startedAfterMatchId?: string;
|
||||
}
|
||||
|
||||
async function resolveResumeStart(
|
||||
db: CompetitionDomainMigrationDb,
|
||||
migrationRunId: string,
|
||||
options: CompetitionDomainMigrationOptions,
|
||||
dryRun: boolean,
|
||||
): Promise<ResumeStart> {
|
||||
if (dryRun || options.limit === undefined) {
|
||||
return {
|
||||
strategy: options.afterMatchId ? 'cursor' : 'none',
|
||||
...(options.afterMatchId
|
||||
? { startedAfterMatchId: options.afterMatchId }
|
||||
: {}),
|
||||
};
|
||||
}
|
||||
if (options.afterMatchId) {
|
||||
return {
|
||||
strategy: 'cursor',
|
||||
startedAfterMatchId: options.afterMatchId,
|
||||
};
|
||||
}
|
||||
const checkpoint = await db
|
||||
.collection('competition_migration_checkpoint')
|
||||
.findOne({ _id: migrationRunId });
|
||||
const checkpointMatchId = optionalIdString(checkpoint?.lastMatchId);
|
||||
if (checkpointMatchId) assertMatchCursor(checkpointMatchId);
|
||||
return {
|
||||
strategy: 'checkpoint',
|
||||
...(checkpointMatchId ? { startedAfterMatchId: checkpointMatchId } : {}),
|
||||
};
|
||||
}
|
||||
|
||||
function resumeReport(
|
||||
start: ResumeStart,
|
||||
checkpointAfterMatchId: string | undefined,
|
||||
hasMore: boolean,
|
||||
completed: boolean,
|
||||
): CompetitionDomainMigrationResume {
|
||||
return {
|
||||
strategy: start.strategy,
|
||||
...(start.startedAfterMatchId
|
||||
? { startedAfterMatchId: start.startedAfterMatchId }
|
||||
: {}),
|
||||
...(checkpointAfterMatchId ? { checkpointAfterMatchId } : {}),
|
||||
hasMore,
|
||||
completed,
|
||||
};
|
||||
}
|
||||
|
||||
async function persistMigrationCheckpoint(
|
||||
db: CompetitionDomainMigrationDb,
|
||||
params: {
|
||||
migrationRunId: string;
|
||||
matchId?: string;
|
||||
matchStatus?: CompetitionDomainMigrationMatchResult['status'];
|
||||
completed: boolean;
|
||||
resetMatchStatus?: boolean;
|
||||
observedAt: Date;
|
||||
},
|
||||
): Promise<void> {
|
||||
await db.collection('competition_migration_checkpoint').updateOne(
|
||||
{ _id: params.migrationRunId },
|
||||
{
|
||||
$set: {
|
||||
migrationRunId: params.migrationRunId,
|
||||
status: params.completed ? 'completed' : 'running',
|
||||
...(params.matchId
|
||||
? { lastMatchId: persistenceId(params.matchId) }
|
||||
: {}),
|
||||
...(params.matchStatus ? { lastMatchStatus: params.matchStatus } : {}),
|
||||
updatedAt: params.observedAt,
|
||||
},
|
||||
$setOnInsert: {
|
||||
_id: params.migrationRunId,
|
||||
createdAt: params.observedAt,
|
||||
},
|
||||
...(params.resetMatchStatus ? { $unset: { lastMatchStatus: 1 } } : {}),
|
||||
},
|
||||
{ upsert: true },
|
||||
);
|
||||
}
|
||||
|
||||
async function ensureCompetitionDomainIndexes(
|
||||
db: CompetitionDomainMigrationDb,
|
||||
dryRun: boolean,
|
||||
): Promise<CompetitionDomainIndexPreflight> {
|
||||
if (dryRun) {
|
||||
return {
|
||||
status: 'dry-run',
|
||||
requiredIndexes: COMPETITION_DOMAIN_INVARIANT_INDEXES.length,
|
||||
ensuredIndexes: [],
|
||||
conflicts: [],
|
||||
};
|
||||
}
|
||||
|
||||
const ensuredIndexes: string[] = [];
|
||||
const conflicts: CompetitionDomainIndexConflict[] = [];
|
||||
for (const index of COMPETITION_DOMAIN_INVARIANT_INDEXES) {
|
||||
try {
|
||||
const createdName = await db
|
||||
.collection(index.collection)
|
||||
.createIndex(index.key, index.options);
|
||||
ensuredIndexes.push(createdName);
|
||||
} catch (error) {
|
||||
conflicts.push(indexConflict(index, error));
|
||||
}
|
||||
}
|
||||
return {
|
||||
status: conflicts.length > 0 ? 'blocked' : 'ensured',
|
||||
requiredIndexes: COMPETITION_DOMAIN_INVARIANT_INDEXES.length,
|
||||
ensuredIndexes,
|
||||
conflicts,
|
||||
};
|
||||
}
|
||||
|
||||
function indexConflict(
|
||||
index: CompetitionDomainInvariantIndex,
|
||||
error: unknown,
|
||||
): CompetitionDomainIndexConflict {
|
||||
const record = isRecord(error) ? error : {};
|
||||
const code =
|
||||
typeof record.code === 'number' && Number.isInteger(record.code)
|
||||
? record.code
|
||||
: undefined;
|
||||
const keyPattern = isRecord(record.keyPattern)
|
||||
? (canonicalValue(record.keyPattern) as Record<string, unknown>)
|
||||
: undefined;
|
||||
const keyValue =
|
||||
record.keyValue === undefined ? undefined : canonicalValue(record.keyValue);
|
||||
return {
|
||||
collection: index.collection,
|
||||
indexName: index.options.name,
|
||||
key: canonicalValue(index.key) as Record<string, unknown>,
|
||||
...(code === undefined ? {} : { code }),
|
||||
...(keyPattern ? { keyPattern } : {}),
|
||||
...(keyValue === undefined ? {} : { keyValue }),
|
||||
message: error instanceof Error ? error.message : String(error),
|
||||
};
|
||||
}
|
||||
|
||||
async function scanMatches(
|
||||
db: CompetitionDomainMigrationDb,
|
||||
limit: number | undefined,
|
||||
): Promise<AnyDocument[]> {
|
||||
return readCursor(
|
||||
afterMatchId: string | undefined,
|
||||
): Promise<{ matches: AnyDocument[]; hasMore: boolean }> {
|
||||
const scanned = await readCursor(
|
||||
db
|
||||
.collection('match')
|
||||
.find(MATCH_SCAN_FILTER)
|
||||
.find({
|
||||
...MATCH_SCAN_FILTER,
|
||||
...(afterMatchId ? { _id: { $gt: persistenceId(afterMatchId) } } : {}),
|
||||
})
|
||||
.sort({ _id: 1 })
|
||||
.limit(limit ?? 0),
|
||||
.limit(limit === undefined ? 0 : limit + 1),
|
||||
);
|
||||
if (limit === undefined) return { matches: scanned, hasMore: false };
|
||||
return {
|
||||
matches: scanned.slice(0, limit),
|
||||
hasMore: scanned.length > limit,
|
||||
};
|
||||
}
|
||||
|
||||
async function inspectMatch(
|
||||
@@ -260,6 +518,30 @@ async function applyMatch(
|
||||
};
|
||||
}
|
||||
|
||||
const uniquenessConflicts = await findReadyPlanUniquenessConflicts(
|
||||
db,
|
||||
plan,
|
||||
session,
|
||||
);
|
||||
if (uniquenessConflicts.length > 0) {
|
||||
await persistQuarantine(
|
||||
db,
|
||||
currentMatch,
|
||||
uniquenessConflicts,
|
||||
plan.warnings,
|
||||
migrationRunId,
|
||||
options.now ?? new Date(),
|
||||
session,
|
||||
);
|
||||
await session.commitTransaction();
|
||||
return {
|
||||
status: 'quarantined',
|
||||
matchId,
|
||||
warnings: plan.warnings,
|
||||
reasons: uniquenessConflicts,
|
||||
};
|
||||
}
|
||||
|
||||
await upsertReadyPlan(db, plan, session);
|
||||
await verifyReadyPlan(db, plan, session);
|
||||
|
||||
@@ -305,6 +587,123 @@ async function applyMatch(
|
||||
}
|
||||
}
|
||||
|
||||
interface UniqueIdentityCheck {
|
||||
collection: 'competition' | 'competition_fact' | 'tournament_code_assignment';
|
||||
indexName: string;
|
||||
filter: Record<string, unknown>;
|
||||
expectedDocumentId: string;
|
||||
}
|
||||
|
||||
async function findReadyPlanUniquenessConflicts(
|
||||
db: CompetitionDomainMigrationDb,
|
||||
plan: ReadyCompetitionMigrationPlan,
|
||||
session: CompetitionDomainMigrationSession,
|
||||
): Promise<CompetitionMigrationIssue[]> {
|
||||
const checks: UniqueIdentityCheck[] = [
|
||||
{
|
||||
collection: 'competition',
|
||||
indexName: 'matchId_1',
|
||||
filter: { matchId: persistenceId(plan.competition.matchId) },
|
||||
expectedDocumentId: plan.competition.id,
|
||||
},
|
||||
];
|
||||
|
||||
for (const fact of plan.facts) {
|
||||
checks.push(
|
||||
{
|
||||
collection: 'competition_fact',
|
||||
indexName: 'competitionId_1_revision_1_ordinalWithinRevision_1',
|
||||
filter: {
|
||||
competitionId: persistenceId(fact.competitionId),
|
||||
revision: fact.revision,
|
||||
ordinalWithinRevision: fact.ordinalWithinRevision,
|
||||
},
|
||||
expectedDocumentId: fact.id,
|
||||
},
|
||||
{
|
||||
collection: 'competition_fact',
|
||||
indexName: 'competitionId_1_commandId_1_ordinalWithinRevision_1',
|
||||
filter: {
|
||||
competitionId: persistenceId(fact.competitionId),
|
||||
commandId: fact.commandId,
|
||||
ordinalWithinRevision: fact.ordinalWithinRevision,
|
||||
},
|
||||
expectedDocumentId: fact.id,
|
||||
},
|
||||
);
|
||||
if (fact.type === 'game-accepted' && fact.evidence.type === 'riot') {
|
||||
checks.push({
|
||||
collection: 'competition_fact',
|
||||
indexName: 'evidence.riotMatchId_1',
|
||||
filter: {
|
||||
type: 'game-accepted',
|
||||
'evidence.riotMatchId': fact.evidence.riotMatchId,
|
||||
},
|
||||
expectedDocumentId: fact.id,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
for (const assignment of plan.assignments) {
|
||||
if (assignment.state === 'reserved' || assignment.state === 'used') {
|
||||
checks.push(
|
||||
{
|
||||
collection: 'tournament_code_assignment',
|
||||
indexName: 'gameSlotId_1',
|
||||
filter: {
|
||||
gameSlotId: persistenceId(assignment.gameSlotId),
|
||||
state: { $in: ['reserved', 'used'] },
|
||||
},
|
||||
expectedDocumentId: assignment.id,
|
||||
},
|
||||
{
|
||||
collection: 'tournament_code_assignment',
|
||||
indexName: 'tournamentCodeId_1',
|
||||
filter: {
|
||||
tournamentCodeId: persistenceId(assignment.tournamentCodeId),
|
||||
state: { $in: ['reserved', 'used'] },
|
||||
},
|
||||
expectedDocumentId: assignment.id,
|
||||
},
|
||||
);
|
||||
}
|
||||
if (assignment.riotMatchId) {
|
||||
checks.push({
|
||||
collection: 'tournament_code_assignment',
|
||||
indexName: 'riotMatchId_1',
|
||||
filter: { riotMatchId: assignment.riotMatchId },
|
||||
expectedDocumentId: assignment.id,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const conflicts: CompetitionMigrationIssue[] = [];
|
||||
// Mongo sessions do not support parallel operations inside one transaction.
|
||||
for (const check of checks) {
|
||||
const existing = await db
|
||||
.collection(check.collection)
|
||||
.findOne(check.filter, { session });
|
||||
if (!existing || idString(existing._id) === check.expectedDocumentId) {
|
||||
continue;
|
||||
}
|
||||
conflicts.push({
|
||||
code: 'GLOBAL_UNIQUE_INDEX_CONFLICT',
|
||||
message: `Migration input conflicts with ${check.collection}.${check.indexName}.`,
|
||||
details: {
|
||||
collection: check.collection,
|
||||
indexName: check.indexName,
|
||||
key: canonicalValue(check.filter) as Record<string, unknown>,
|
||||
expectedDocumentId: check.expectedDocumentId,
|
||||
conflictingDocumentId: idString(existing._id),
|
||||
...(existing.competitionId
|
||||
? { conflictingCompetitionId: idString(existing.competitionId) }
|
||||
: {}),
|
||||
},
|
||||
});
|
||||
}
|
||||
return conflicts;
|
||||
}
|
||||
|
||||
async function hydrateLegacyMatch(
|
||||
db: CompetitionDomainMigrationDb,
|
||||
match: AnyDocument,
|
||||
@@ -819,6 +1218,17 @@ function assertOptions(options: CompetitionDomainMigrationOptions): void {
|
||||
if (options.dryRun === false && !options.startSession) {
|
||||
throw new Error('Apply mode requires a transaction session factory.');
|
||||
}
|
||||
if (options.afterMatchId !== undefined) {
|
||||
assertMatchCursor(options.afterMatchId);
|
||||
}
|
||||
}
|
||||
|
||||
function assertMatchCursor(value: string): void {
|
||||
if (!/^[a-f\d]{24}$/i.test(value)) {
|
||||
throw new Error(
|
||||
'Competition migration afterMatchId must be a 24-character hexadecimal Match ObjectId.',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
async function readCursor(
|
||||
|
||||
@@ -31,4 +31,22 @@ describe('competition domain migration CLI', () => {
|
||||
nodeEnv: 'dev',
|
||||
});
|
||||
});
|
||||
|
||||
it('accepts an explicit Match cursor for limited-run recovery', () => {
|
||||
expect(
|
||||
parseCliOptions([
|
||||
'--apply',
|
||||
'--limit=25',
|
||||
'--after',
|
||||
'66a000000000000000000123',
|
||||
]),
|
||||
).toMatchObject({
|
||||
dryRun: false,
|
||||
limit: 25,
|
||||
afterMatchId: '66a000000000000000000123',
|
||||
});
|
||||
expect(() => parseCliOptions(['--after', 'not-an-object-id'])).toThrow(
|
||||
'--after requires a 24-character hexadecimal Match ObjectId.',
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -15,6 +15,7 @@ export interface CompetitionDomainCliOptions {
|
||||
dryRun: boolean;
|
||||
help: boolean;
|
||||
limit?: number;
|
||||
afterMatchId?: string;
|
||||
nodeEnv: string;
|
||||
}
|
||||
|
||||
@@ -60,6 +61,7 @@ export function parseCliOptions(argv: string[]): CompetitionDomainCliOptions {
|
||||
let dryRun = true;
|
||||
let help = false;
|
||||
let limit: number | undefined;
|
||||
let afterMatchId: string | undefined;
|
||||
let nodeEnv = process.env.NODE_ENV ?? 'dev';
|
||||
|
||||
for (let index = 0; index < argv.length; index += 1) {
|
||||
@@ -95,6 +97,15 @@ export function parseCliOptions(argv: string[]): CompetitionDomainCliOptions {
|
||||
limit = positiveInteger(argument.slice('--limit='.length), '--limit');
|
||||
continue;
|
||||
}
|
||||
if (argument === '--after') {
|
||||
afterMatchId = matchObjectId(argv[index + 1]);
|
||||
index += 1;
|
||||
continue;
|
||||
}
|
||||
if (argument.startsWith('--after=')) {
|
||||
afterMatchId = matchObjectId(argument.slice('--after='.length));
|
||||
continue;
|
||||
}
|
||||
if (argument === '--help' || argument === '-h') {
|
||||
help = true;
|
||||
continue;
|
||||
@@ -105,7 +116,7 @@ export function parseCliOptions(argv: string[]): CompetitionDomainCliOptions {
|
||||
if (!['dev', 'staging', 'prod'].includes(nodeEnv)) {
|
||||
throw new Error('--env must be dev, staging, or prod.');
|
||||
}
|
||||
return { dryRun, help, limit, nodeEnv };
|
||||
return { dryRun, help, limit, afterMatchId, nodeEnv };
|
||||
}
|
||||
|
||||
function positiveInteger(value: string | undefined, label: string): number {
|
||||
@@ -116,6 +127,15 @@ function positiveInteger(value: string | undefined, label: string): number {
|
||||
return parsed;
|
||||
}
|
||||
|
||||
function matchObjectId(value: string | undefined): string {
|
||||
if (!value || !/^[a-f\d]{24}$/i.test(value)) {
|
||||
throw new Error(
|
||||
'--after requires a 24-character hexadecimal Match ObjectId.',
|
||||
);
|
||||
}
|
||||
return value.toLowerCase();
|
||||
}
|
||||
|
||||
function printHelp(): void {
|
||||
process.stdout.write(`Usage:
|
||||
pnpm --silent --filter api competition:migrate
|
||||
@@ -125,7 +145,8 @@ Options:
|
||||
--dry-run Plan and report without writes. Default.
|
||||
--apply Apply one transaction per Match.
|
||||
--env <env> dev | staging | prod. Default: NODE_ENV or dev.
|
||||
--limit <n> Scan at most n Matches in deterministic _id order.
|
||||
--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.
|
||||
`);
|
||||
@@ -153,6 +174,7 @@ async function main(): Promise<void> {
|
||||
{
|
||||
dryRun: options.dryRun,
|
||||
limit: options.limit,
|
||||
afterMatchId: options.afterMatchId,
|
||||
startSession: options.dryRun
|
||||
? undefined
|
||||
: async () => connection.startSession(),
|
||||
@@ -164,11 +186,15 @@ async function main(): Promise<void> {
|
||||
`db=${resolveMongoDbName(options.nodeEnv)} scanned=${summary.scanned} ` +
|
||||
`ready=${summary.ready} applied=${summary.applied} ` +
|
||||
`alreadyApplied=${summary.alreadyApplied} quarantined=${summary.quarantined} ` +
|
||||
`failed=${summary.failed} unclassified=${summary.unclassified}\n`,
|
||||
`failed=${summary.failed} unclassified=${summary.unclassified} ` +
|
||||
`indexPreflight=${result.indexPreflight.status} ` +
|
||||
`resume=${result.resume.checkpointAfterMatchId ?? 'none'} ` +
|
||||
`completed=${result.resume.completed}\n`,
|
||||
);
|
||||
process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
|
||||
|
||||
if (summary.failed > 0) process.exitCode = 1;
|
||||
if (result.indexPreflight.status === 'blocked') process.exitCode = 1;
|
||||
else if (summary.failed > 0) process.exitCode = 1;
|
||||
else if (summary.quarantined > 0) process.exitCode = 2;
|
||||
} finally {
|
||||
await app.close().catch((error: unknown) => {
|
||||
|
||||
@@ -8,6 +8,7 @@ import {
|
||||
CompetitionFact,
|
||||
CompetitionOutbox,
|
||||
TournamentCodeAssignment,
|
||||
applyCompetitionDomainInvariantIndexes,
|
||||
competitionModelDefinitions,
|
||||
} from '../../competition/competition.schema';
|
||||
import { ModelDefinition } from './types';
|
||||
@@ -465,6 +466,7 @@ export interface TournamentCode extends MongooseTimestamps {
|
||||
reservedAt?: Date;
|
||||
usedAt?: Date;
|
||||
releasedAt?: Date;
|
||||
voidedAt?: Date;
|
||||
riotMatchId?: string;
|
||||
uploadedBy: mongoose.Types.ObjectId;
|
||||
uploadedAt: Date;
|
||||
@@ -1501,6 +1503,7 @@ export const TournamentCodeSchema = new Schema<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 },
|
||||
@@ -1952,13 +1955,7 @@ export const MatchSchema = new Schema<Match>(
|
||||
);
|
||||
|
||||
MatchSchema.index({ communityId: 1, scheduledAt: -1 });
|
||||
MatchSchema.index(
|
||||
{ competitionId: 1 },
|
||||
{
|
||||
unique: true,
|
||||
partialFilterExpression: { competitionId: { $type: 'objectId' } },
|
||||
},
|
||||
);
|
||||
applyCompetitionDomainInvariantIndexes(MatchSchema, 'match');
|
||||
MatchSchema.index({ communityId: 1, status: 1, scheduledAt: -1 });
|
||||
MatchSchema.index(
|
||||
{ communityId: 1, shortCode: 1 },
|
||||
|
||||
@@ -294,16 +294,40 @@ describe('Legacy import Competition result cutover', () => {
|
||||
|
||||
it('cascades admin deletion through Competition facts and read models', async () => {
|
||||
const fixture = createImportFixture();
|
||||
const session = {
|
||||
startTransaction: jest.fn(),
|
||||
commitTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
abortTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
endSession: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const competitionFactModel = deleteManyModel();
|
||||
const competitionOutboxModel = deleteManyModel();
|
||||
const assignmentModel = deleteManyModel();
|
||||
const reservedCodeId = new mongoose.Types.ObjectId();
|
||||
const usedCodeId = new mongoose.Types.ObjectId();
|
||||
const assignmentModel = {
|
||||
...deleteManyModel(),
|
||||
find: jest.fn().mockReturnValue({
|
||||
select: jest.fn().mockReturnValue({
|
||||
session: jest.fn().mockReturnValue({
|
||||
lean: jest.fn().mockReturnValue(
|
||||
execResult([
|
||||
{ tournamentCodeId: reservedCodeId, state: 'reserved' },
|
||||
{ tournamentCodeId: usedCodeId, state: 'used' },
|
||||
]),
|
||||
),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
};
|
||||
const competitionModel = {
|
||||
...deleteManyModel(),
|
||||
find: jest.fn().mockReturnValue({
|
||||
select: jest.fn().mockReturnValue({
|
||||
lean: jest
|
||||
.fn()
|
||||
.mockReturnValue(execResult([{ _id: fixture.competition._id }])),
|
||||
session: jest.fn().mockReturnValue({
|
||||
lean: jest
|
||||
.fn()
|
||||
.mockReturnValue(execResult([{ _id: fixture.competition._id }])),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
};
|
||||
@@ -311,11 +335,44 @@ describe('Legacy import Competition result cutover', () => {
|
||||
find: jest.fn().mockReturnValue({
|
||||
select: jest
|
||||
.fn()
|
||||
.mockReturnValue(execResult([{ _id: fixture.match._id }])),
|
||||
.mockReturnValue(sessionResult([{ _id: fixture.match._id }])),
|
||||
}),
|
||||
deleteMany: jest.fn().mockReturnValue(execResult({ deletedCount: 1 })),
|
||||
deleteMany: jest.fn().mockReturnValue(sessionResult({ deletedCount: 1 })),
|
||||
};
|
||||
const tournamentCodeModel = {
|
||||
find: jest.fn().mockReturnValue({
|
||||
select: jest.fn().mockReturnValue({
|
||||
session: jest.fn().mockReturnValue({
|
||||
lean: jest.fn().mockReturnValue(
|
||||
execResult([
|
||||
{
|
||||
_id: reservedCodeId,
|
||||
state: 'reserved',
|
||||
matchId: fixture.match._id,
|
||||
},
|
||||
{
|
||||
_id: usedCodeId,
|
||||
state: 'used',
|
||||
matchId: fixture.match._id,
|
||||
},
|
||||
]),
|
||||
),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
updateMany: jest
|
||||
.fn()
|
||||
.mockReturnValue(sessionResult({ matchedCount: 1, modifiedCount: 1 })),
|
||||
};
|
||||
const matchStatsModel = deleteManyModel();
|
||||
const quarantineCollection = {
|
||||
deleteMany: jest.fn().mockResolvedValue({ deletedCount: 1 }),
|
||||
};
|
||||
const connectionService = {
|
||||
createSession: jest.fn().mockResolvedValue(session),
|
||||
getConnection: jest.fn().mockResolvedValue({
|
||||
collection: jest.fn().mockReturnValue(quarantineCollection),
|
||||
}),
|
||||
getModel: jest.fn((name: string) => {
|
||||
const models: Record<string, unknown> = {
|
||||
match: matchModel,
|
||||
@@ -323,6 +380,8 @@ describe('Legacy import Competition result cutover', () => {
|
||||
competitionFact: competitionFactModel,
|
||||
competitionOutbox: competitionOutboxModel,
|
||||
tournamentCodeAssignment: assignmentModel,
|
||||
tournamentCode: tournamentCodeModel,
|
||||
matchStats: matchStatsModel,
|
||||
};
|
||||
const model = models[name];
|
||||
return model
|
||||
@@ -330,15 +389,11 @@ describe('Legacy import Competition result cutover', () => {
|
||||
: Promise.reject(new Error(`Unexpected model ${name}`));
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const matchStatsService = {
|
||||
removeByMatches: jest.fn().mockResolvedValue(undefined),
|
||||
} as unknown as jest.Mocked<MatchStatsService>;
|
||||
const communityStatsService = {
|
||||
invalidateCommunity: jest.fn().mockResolvedValue(undefined),
|
||||
} as unknown as jest.Mocked<CommunityStatsService>;
|
||||
const service = createService({
|
||||
connectionService,
|
||||
matchStatsService,
|
||||
communityStatsService,
|
||||
});
|
||||
|
||||
@@ -360,9 +415,98 @@ describe('Legacy import Competition result cutover', () => {
|
||||
expect(competitionModel.deleteMany).toHaveBeenCalledWith({
|
||||
_id: { $in: [fixture.competition._id] },
|
||||
});
|
||||
expect(matchStatsService.removeByMatches).toHaveBeenCalledWith([
|
||||
fixture.match._id,
|
||||
]);
|
||||
expect(tournamentCodeModel.updateMany).toHaveBeenCalledTimes(2);
|
||||
expect(matchStatsModel.deleteMany).toHaveBeenCalledWith({
|
||||
matchId: { $in: [fixture.match._id] },
|
||||
});
|
||||
expect(session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(session.abortTransaction).not.toHaveBeenCalled();
|
||||
expect(communityStatsService.invalidateCommunity).toHaveBeenCalledWith(
|
||||
fixture.match.communityId,
|
||||
);
|
||||
});
|
||||
|
||||
it('aborts legacy deletion when an active assignment points to another Match code', async () => {
|
||||
const harness = createBulkDeleteFailureHarness({
|
||||
codeMatchId: new mongoose.Types.ObjectId(),
|
||||
});
|
||||
|
||||
await expect(
|
||||
harness.service.bulkDeleteLegacyMatches({
|
||||
communityId: harness.fixture.match.communityId,
|
||||
body: { matchIds: [harness.fixture.match._id.toString()] },
|
||||
}),
|
||||
).rejects.toThrow(/Tournament Code assignment/);
|
||||
|
||||
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.session.commitTransaction).not.toHaveBeenCalled();
|
||||
expect(harness.matchModel.deleteMany).not.toHaveBeenCalled();
|
||||
expect(harness.competitionFactModel.deleteMany).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('aborts legacy deletion when a validated Tournament Code transition does not update exactly once', async () => {
|
||||
const harness = createBulkDeleteFailureHarness({
|
||||
updateResult: { matchedCount: 0, modifiedCount: 0 },
|
||||
});
|
||||
|
||||
await expect(
|
||||
harness.service.bulkDeleteLegacyMatches({
|
||||
communityId: harness.fixture.match.communityId,
|
||||
body: { matchIds: [harness.fixture.match._id.toString()] },
|
||||
}),
|
||||
).rejects.toThrow(/Tournament Code transition/);
|
||||
|
||||
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.session.commitTransaction).not.toHaveBeenCalled();
|
||||
expect(harness.matchModel.deleteMany).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('invalidates community caches again when a committed deletion is retried', async () => {
|
||||
const harness = createBulkDeleteFailureHarness({});
|
||||
harness.matchModel.find
|
||||
.mockReset()
|
||||
.mockReturnValueOnce({
|
||||
select: jest
|
||||
.fn()
|
||||
.mockReturnValue(sessionResult([{ _id: harness.fixture.match._id }])),
|
||||
})
|
||||
.mockReturnValueOnce({
|
||||
select: jest.fn().mockReturnValue(sessionResult([])),
|
||||
});
|
||||
harness.communityStatsService.invalidateCommunity
|
||||
.mockRejectedValueOnce(new Error('Redis unavailable'))
|
||||
.mockResolvedValueOnce(0);
|
||||
|
||||
await expect(
|
||||
harness.service.bulkDeleteLegacyMatches({
|
||||
communityId: harness.fixture.match.communityId,
|
||||
body: { matchIds: [harness.fixture.match._id.toString()] },
|
||||
}),
|
||||
).rejects.toThrow('Redis unavailable');
|
||||
|
||||
await expect(
|
||||
harness.service.bulkDeleteLegacyMatches({
|
||||
communityId: harness.fixture.match.communityId,
|
||||
body: { matchIds: [harness.fixture.match._id.toString()] },
|
||||
}),
|
||||
).resolves.toEqual({ deleted: 0 });
|
||||
expect(
|
||||
harness.communityStatsService.invalidateCommunity,
|
||||
).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
|
||||
it('removes migration quarantine records in the same legacy deletion transaction', async () => {
|
||||
const harness = createBulkDeleteFailureHarness({});
|
||||
|
||||
await harness.service.bulkDeleteLegacyMatches({
|
||||
communityId: harness.fixture.match.communityId,
|
||||
body: { matchIds: [harness.fixture.match._id.toString()] },
|
||||
});
|
||||
|
||||
expect(harness.quarantineCollection.deleteMany).toHaveBeenCalledWith(
|
||||
{ _id: { $in: [harness.fixture.match._id] } },
|
||||
{ session: harness.session },
|
||||
);
|
||||
});
|
||||
|
||||
it('rebuilds a historical legacy Match into Competition facts without rewriting Match.result', async () => {
|
||||
@@ -707,10 +851,135 @@ function execResult<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(execResult({ acknowledged: true, deletedCount: 1 })),
|
||||
.mockReturnValue(sessionResult({ acknowledged: true, deletedCount: 1 })),
|
||||
};
|
||||
}
|
||||
|
||||
function createBulkDeleteFailureHarness(options: {
|
||||
codeMatchId?: mongoose.Types.ObjectId;
|
||||
codeState?: 'reserved' | 'used';
|
||||
assignmentState?: 'reserved' | 'used';
|
||||
updateResult?: { matchedCount: number; modifiedCount: number };
|
||||
}) {
|
||||
const fixture = createImportFixture();
|
||||
const session = {
|
||||
startTransaction: jest.fn(),
|
||||
commitTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
abortTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
endSession: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const tournamentCodeId = new mongoose.Types.ObjectId();
|
||||
const assignmentState = options.assignmentState ?? 'reserved';
|
||||
const codeState = options.codeState ?? assignmentState;
|
||||
const assignmentModel = {
|
||||
...deleteManyModel(),
|
||||
find: jest.fn().mockReturnValue({
|
||||
select: jest.fn().mockReturnValue({
|
||||
session: jest.fn().mockReturnValue({
|
||||
lean: jest
|
||||
.fn()
|
||||
.mockReturnValue(
|
||||
execResult([{ tournamentCodeId, state: assignmentState }]),
|
||||
),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
};
|
||||
const competitionModel = {
|
||||
...deleteManyModel(),
|
||||
find: jest.fn().mockReturnValue({
|
||||
select: jest.fn().mockReturnValue({
|
||||
session: jest.fn().mockReturnValue({
|
||||
lean: jest
|
||||
.fn()
|
||||
.mockReturnValue(execResult([{ _id: fixture.competition._id }])),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
};
|
||||
const matchModel = {
|
||||
find: jest.fn().mockReturnValue({
|
||||
select: jest
|
||||
.fn()
|
||||
.mockReturnValue(sessionResult([{ _id: fixture.match._id }])),
|
||||
}),
|
||||
deleteMany: jest.fn().mockReturnValue(sessionResult({ deletedCount: 1 })),
|
||||
};
|
||||
const tournamentCodeModel = {
|
||||
find: jest.fn().mockReturnValue({
|
||||
select: jest.fn().mockReturnValue({
|
||||
session: jest.fn().mockReturnValue({
|
||||
lean: jest.fn().mockReturnValue(
|
||||
execResult([
|
||||
{
|
||||
_id: tournamentCodeId,
|
||||
state: codeState,
|
||||
matchId: options.codeMatchId ?? fixture.match._id,
|
||||
},
|
||||
]),
|
||||
),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
updateMany: jest
|
||||
.fn()
|
||||
.mockReturnValue(
|
||||
sessionResult(
|
||||
options.updateResult ?? { matchedCount: 1, modifiedCount: 1 },
|
||||
),
|
||||
),
|
||||
};
|
||||
const competitionFactModel = deleteManyModel();
|
||||
const competitionOutboxModel = deleteManyModel();
|
||||
const matchStatsModel = deleteManyModel();
|
||||
const quarantineCollection = {
|
||||
deleteMany: jest.fn().mockResolvedValue({ deletedCount: 1 }),
|
||||
};
|
||||
const connectionService = {
|
||||
createSession: jest.fn().mockResolvedValue(session),
|
||||
getConnection: jest.fn().mockResolvedValue({
|
||||
collection: jest.fn().mockReturnValue(quarantineCollection),
|
||||
}),
|
||||
getModel: jest.fn((name: string) => {
|
||||
const models: Record<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,
|
||||
};
|
||||
}
|
||||
@@ -2,6 +2,7 @@ import {
|
||||
BadRequestException,
|
||||
ConflictException,
|
||||
Injectable,
|
||||
InternalServerErrorException,
|
||||
Logger,
|
||||
NotFoundException,
|
||||
} from '@nestjs/common';
|
||||
@@ -381,60 +382,194 @@ export class LegacyImportService {
|
||||
.filter((id) => mongoose.isValidObjectId(id))
|
||||
.map((id) => new mongoose.Types.ObjectId(id));
|
||||
if (ids.length === 0) return { deleted: 0 };
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const targets = await MatchModel.find({
|
||||
_id: { $in: ids },
|
||||
communityId: params.communityId,
|
||||
legacyImported: true,
|
||||
})
|
||||
.select({ _id: 1 })
|
||||
.exec();
|
||||
const targetIds = targets.map((match) => match._id);
|
||||
if (targetIds.length === 0) return { deleted: 0 };
|
||||
|
||||
const [
|
||||
MatchModel,
|
||||
CompetitionModel,
|
||||
CompetitionFactModel,
|
||||
CompetitionOutboxModel,
|
||||
AssignmentModel,
|
||||
TournamentCodeModel,
|
||||
MatchStatsModel,
|
||||
connection,
|
||||
] = await Promise.all([
|
||||
this.connectionService.getModel('match'),
|
||||
this.connectionService.getModel('competition'),
|
||||
this.connectionService.getModel('competitionFact'),
|
||||
this.connectionService.getModel('competitionOutbox'),
|
||||
this.connectionService.getModel('tournamentCodeAssignment'),
|
||||
this.connectionService.getModel('tournamentCode'),
|
||||
this.connectionService.getModel('matchStats'),
|
||||
this.connectionService.getConnection(),
|
||||
]);
|
||||
const competitions = await CompetitionModel.find({
|
||||
matchId: { $in: targetIds },
|
||||
})
|
||||
.select({ _id: 1 })
|
||||
.lean()
|
||||
.exec();
|
||||
const competitionIds = competitions.map(({ _id }) => _id);
|
||||
if (competitionIds.length > 0) {
|
||||
await Promise.all([
|
||||
CompetitionFactModel.deleteMany({
|
||||
competitionId: { $in: competitionIds },
|
||||
}).exec(),
|
||||
CompetitionOutboxModel.deleteMany({
|
||||
competitionId: { $in: competitionIds },
|
||||
}).exec(),
|
||||
AssignmentModel.deleteMany({
|
||||
competitionId: { $in: competitionIds },
|
||||
}).exec(),
|
||||
]);
|
||||
await CompetitionModel.deleteMany({
|
||||
_id: { $in: competitionIds },
|
||||
}).exec();
|
||||
const session = await this.connectionService.createSession();
|
||||
if (!session) {
|
||||
throw new InternalServerErrorException(
|
||||
'A MongoDB transaction is required to delete legacy Matches.',
|
||||
);
|
||||
}
|
||||
|
||||
let deleted = 0;
|
||||
try {
|
||||
session.startTransaction();
|
||||
const targets = await MatchModel.find({
|
||||
_id: { $in: ids },
|
||||
communityId: params.communityId,
|
||||
legacyImported: true,
|
||||
})
|
||||
.select({ _id: 1 })
|
||||
.session(session)
|
||||
.exec();
|
||||
const targetIds = targets.map((match) => match._id);
|
||||
if (targetIds.length === 0) {
|
||||
await session.commitTransaction();
|
||||
} else {
|
||||
const competitions = await CompetitionModel.find({
|
||||
matchId: { $in: targetIds },
|
||||
})
|
||||
.select({ _id: 1 })
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec();
|
||||
const competitionIds = competitions.map(({ _id }) => _id);
|
||||
if (competitionIds.length > 0) {
|
||||
const assignments = await AssignmentModel.find({
|
||||
competitionId: { $in: competitionIds },
|
||||
state: { $in: ['reserved', 'used'] },
|
||||
})
|
||||
.select({ tournamentCodeId: 1, state: 1 })
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec();
|
||||
const assignmentCodeIds = assignments.map(
|
||||
({ tournamentCodeId }) => tournamentCodeId,
|
||||
);
|
||||
const uniqueAssignmentCodeIds = new Set(
|
||||
assignmentCodeIds.map((id) => id.toString()),
|
||||
);
|
||||
if (uniqueAssignmentCodeIds.size !== assignmentCodeIds.length) {
|
||||
throw new ConflictException(
|
||||
'Tournament Code assignments contain a duplicate active code identity.',
|
||||
);
|
||||
}
|
||||
const tournamentCodes =
|
||||
assignmentCodeIds.length === 0
|
||||
? []
|
||||
: await TournamentCodeModel.find({
|
||||
_id: { $in: assignmentCodeIds },
|
||||
})
|
||||
.select({ _id: 1, state: 1, matchId: 1 })
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec();
|
||||
const tournamentCodeById = new Map(
|
||||
tournamentCodes.map((code) => [code._id.toString(), code]),
|
||||
);
|
||||
const targetIdSet = new Set(targetIds.map((id) => id.toString()));
|
||||
for (const assignment of assignments) {
|
||||
const code = tournamentCodeById.get(
|
||||
assignment.tournamentCodeId.toString(),
|
||||
);
|
||||
if (
|
||||
!code ||
|
||||
code.state !== assignment.state ||
|
||||
!code.matchId ||
|
||||
!targetIdSet.has(code.matchId.toString())
|
||||
) {
|
||||
throw new ConflictException(
|
||||
'Tournament Code assignment ownership or state does not match the target legacy Match.',
|
||||
);
|
||||
}
|
||||
}
|
||||
const releasedCodeIds = assignments
|
||||
.filter(({ state }) => state === 'reserved')
|
||||
.map(({ tournamentCodeId }) => tournamentCodeId);
|
||||
const voidedCodeIds = assignments
|
||||
.filter(({ state }) => state === 'used')
|
||||
.map(({ tournamentCodeId }) => tournamentCodeId);
|
||||
const terminalAt = new Date();
|
||||
if (releasedCodeIds.length > 0) {
|
||||
const released = await TournamentCodeModel.updateMany(
|
||||
{
|
||||
_id: { $in: releasedCodeIds },
|
||||
matchId: { $in: targetIds },
|
||||
state: 'reserved',
|
||||
},
|
||||
{
|
||||
$set: { state: 'released', releasedAt: terminalAt },
|
||||
$unset: legacyTournamentCodeBindingUnset(),
|
||||
},
|
||||
)
|
||||
.session(session)
|
||||
.exec();
|
||||
assertExactTournamentCodeTransition(
|
||||
released,
|
||||
releasedCodeIds.length,
|
||||
);
|
||||
}
|
||||
if (voidedCodeIds.length > 0) {
|
||||
const voided = await TournamentCodeModel.updateMany(
|
||||
{
|
||||
_id: { $in: voidedCodeIds },
|
||||
matchId: { $in: targetIds },
|
||||
state: 'used',
|
||||
},
|
||||
{
|
||||
$set: { state: 'voided', voidedAt: terminalAt },
|
||||
$unset: legacyTournamentCodeBindingUnset(),
|
||||
},
|
||||
)
|
||||
.session(session)
|
||||
.exec();
|
||||
assertExactTournamentCodeTransition(voided, voidedCodeIds.length);
|
||||
}
|
||||
|
||||
await CompetitionFactModel.deleteMany({
|
||||
competitionId: { $in: competitionIds },
|
||||
})
|
||||
.session(session)
|
||||
.exec();
|
||||
await CompetitionOutboxModel.deleteMany({
|
||||
competitionId: { $in: competitionIds },
|
||||
})
|
||||
.session(session)
|
||||
.exec();
|
||||
await AssignmentModel.deleteMany({
|
||||
competitionId: { $in: competitionIds },
|
||||
})
|
||||
.session(session)
|
||||
.exec();
|
||||
await CompetitionModel.deleteMany({
|
||||
_id: { $in: competitionIds },
|
||||
})
|
||||
.session(session)
|
||||
.exec();
|
||||
}
|
||||
|
||||
await connection
|
||||
.collection('competition_migration_quarantine')
|
||||
.deleteMany({ _id: { $in: targetIds } }, { session });
|
||||
const result = await MatchModel.deleteMany({
|
||||
_id: { $in: targetIds },
|
||||
communityId: params.communityId,
|
||||
legacyImported: true,
|
||||
})
|
||||
.session(session)
|
||||
.exec();
|
||||
await MatchStatsModel.deleteMany({ matchId: { $in: targetIds } })
|
||||
.session(session)
|
||||
.exec();
|
||||
deleted = result.deletedCount ?? 0;
|
||||
await session.commitTransaction();
|
||||
}
|
||||
} catch (error) {
|
||||
await session.abortTransaction().catch(() => undefined);
|
||||
throw error;
|
||||
} finally {
|
||||
await session.endSession().catch(() => undefined);
|
||||
}
|
||||
|
||||
const result = await MatchModel.deleteMany({
|
||||
_id: { $in: targetIds },
|
||||
communityId: params.communityId,
|
||||
legacyImported: true,
|
||||
}).exec();
|
||||
await this.matchStatsService.removeByMatches(targetIds);
|
||||
await this.communityStatsService.invalidateCommunity(params.communityId);
|
||||
return { deleted: result.deletedCount ?? 0 };
|
||||
return { deleted };
|
||||
}
|
||||
|
||||
public async rebuildLegacyMatches(params: {
|
||||
@@ -1322,6 +1457,29 @@ function optionalNumber(value: unknown): number | undefined {
|
||||
: undefined;
|
||||
}
|
||||
|
||||
function legacyTournamentCodeBindingUnset(): Record<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),
|
||||
|
||||
@@ -1,7 +1,9 @@
|
||||
import 'reflect-metadata';
|
||||
import { BadRequestException, ValidationPipe } from '@nestjs/common';
|
||||
import { plainToInstance } from 'class-transformer';
|
||||
import { validateSync } from 'class-validator';
|
||||
import { CreateMatchDto } from './create-match.dto';
|
||||
import mongoose from 'mongoose';
|
||||
import { CreateMatchDto, JoinMatchDto } from './create-match.dto';
|
||||
|
||||
describe('CreateMatchDto game mode cutover', () => {
|
||||
it('rejects the removed live bracket mode', () => {
|
||||
@@ -31,3 +33,31 @@ describe('CreateMatchDto game mode cutover', () => {
|
||||
},
|
||||
);
|
||||
});
|
||||
|
||||
describe('JoinMatchDto self-join boundary', () => {
|
||||
it('rejects a caller-supplied userId', async () => {
|
||||
const pipe = new ValidationPipe({
|
||||
whitelist: true,
|
||||
forbidNonWhitelisted: true,
|
||||
transform: true,
|
||||
});
|
||||
|
||||
try {
|
||||
await pipe.transform(
|
||||
{
|
||||
preferredPositions: [{ position: 'MID', priority: 1 }],
|
||||
userId: new mongoose.Types.ObjectId().toString(),
|
||||
},
|
||||
{ type: 'body', metatype: JoinMatchDto },
|
||||
);
|
||||
throw new Error('Expected validation to reject userId.');
|
||||
} catch (error) {
|
||||
expect(error).toBeInstanceOf(BadRequestException);
|
||||
expect((error as BadRequestException).getResponse()).toEqual({
|
||||
error: 'Bad Request',
|
||||
message: ['property userId should not exist'],
|
||||
statusCode: 400,
|
||||
});
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -215,10 +215,6 @@ export class JoinMatchDto {
|
||||
@ValidateNested({ each: true })
|
||||
@Type(() => PositionPreferenceDto)
|
||||
preferredPositions!: PositionPreferenceDto[];
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
userId?: string;
|
||||
}
|
||||
|
||||
export class AddParticipantDto {
|
||||
@@ -234,13 +230,3 @@ export class AddParticipantDto {
|
||||
@IsString()
|
||||
riotPuuid?: string;
|
||||
}
|
||||
|
||||
export class SwapDoubleEliminationSeedsDto {
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
leftSeedNumber!: number;
|
||||
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
rightSeedNumber!: number;
|
||||
}
|
||||
@@ -9,6 +9,7 @@ describe('presentPublicMatch', () => {
|
||||
competitionId: oid('3'),
|
||||
shortCode: '33NW',
|
||||
title: '내전',
|
||||
joined: false,
|
||||
description: '설명',
|
||||
mapId: 11,
|
||||
status: 'in-progress',
|
||||
@@ -25,6 +26,16 @@ describe('presentPublicMatch', () => {
|
||||
gameName: '선수',
|
||||
tagLine: 'KR1',
|
||||
profileIconId: 1,
|
||||
tier: {
|
||||
queueType: 'RANKED_SOLO_5x5',
|
||||
tier: 'GOLD',
|
||||
rank: 'I',
|
||||
leaguePoints: 42,
|
||||
wins: 10,
|
||||
losses: 5,
|
||||
fetchedAt: new Date('2026-07-10T00:00:00.000Z'),
|
||||
puuid: 'secret-tier-puuid',
|
||||
},
|
||||
preferredPositions: [
|
||||
{ position: 'MID', priority: 1 },
|
||||
{ position: 'SUP', priority: 2 },
|
||||
@@ -65,6 +76,15 @@ describe('presentPublicMatch', () => {
|
||||
expect.objectContaining({
|
||||
userId: oid('5').toString(),
|
||||
joinedAt: '2026-07-01T00:00:00.000Z',
|
||||
tier: {
|
||||
queueType: 'RANKED_SOLO_5x5',
|
||||
tier: 'GOLD',
|
||||
rank: 'I',
|
||||
leaguePoints: 42,
|
||||
wins: 10,
|
||||
losses: 5,
|
||||
fetchedAt: '2026-07-10T00:00:00.000Z',
|
||||
},
|
||||
}),
|
||||
],
|
||||
teams: [
|
||||
@@ -89,6 +109,7 @@ describe('presentPublicMatch', () => {
|
||||
expect(response).not.toHaveProperty('resultPollState');
|
||||
expect(response).not.toHaveProperty('legacyImportSource');
|
||||
expect(response.participants[0]).not.toHaveProperty('puuid');
|
||||
expect(response.participants[0]?.tier).not.toHaveProperty('puuid');
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
import type { MatchDetailResponse, MatchTierView } from '@lolympus/contracts';
|
||||
import type {
|
||||
MatchGameMode,
|
||||
MatchStatus,
|
||||
@@ -57,12 +58,12 @@ interface PublicMatchSource {
|
||||
export function presentPublicMatch(
|
||||
source: PublicMatchSource,
|
||||
options: { joined?: boolean } = {},
|
||||
) {
|
||||
): MatchDetailResponse {
|
||||
return {
|
||||
_id: source._id.toString(),
|
||||
communityId: source.communityId.toString(),
|
||||
_id: source._id.toString() as never,
|
||||
communityId: source.communityId.toString() as never,
|
||||
...(source.competitionId
|
||||
? { competitionId: source.competitionId.toString() }
|
||||
? { competitionId: source.competitionId.toString() as never }
|
||||
: {}),
|
||||
...(source.shortCode ? { shortCode: source.shortCode } : {}),
|
||||
title: source.title,
|
||||
@@ -82,32 +83,37 @@ export function presentPublicMatch(
|
||||
source.doubleElimination?.resetFinalEnabled ?? false,
|
||||
}
|
||||
: {}),
|
||||
...(source.hostUserId ? { hostUserId: source.hostUserId.toString() } : {}),
|
||||
participants: source.participants.map((participant) => ({
|
||||
userId: participant.userId.toString(),
|
||||
...(participant.gameName ? { gameName: participant.gameName } : {}),
|
||||
...(participant.tagLine ? { tagLine: participant.tagLine } : {}),
|
||||
...(participant.profileIconId === undefined
|
||||
? {}
|
||||
: { profileIconId: participant.profileIconId }),
|
||||
...(participant.tier === undefined
|
||||
? {}
|
||||
: { tier: toWireValue(participant.tier) }),
|
||||
preferredPositions: participant.preferredPositions.map((preference) => ({
|
||||
position: preference.position,
|
||||
priority: preference.priority,
|
||||
})),
|
||||
joinedAt: asIso(participant.joinedAt),
|
||||
excluded: participant.excluded ?? false,
|
||||
})),
|
||||
...(source.hostUserId
|
||||
? { hostUserId: source.hostUserId.toString() as never }
|
||||
: {}),
|
||||
participants: source.participants.map((participant) => {
|
||||
const tier = toPublicTier(participant.tier);
|
||||
return {
|
||||
userId: participant.userId.toString() as never,
|
||||
...(participant.gameName ? { gameName: participant.gameName } : {}),
|
||||
...(participant.tagLine ? { tagLine: participant.tagLine } : {}),
|
||||
...(participant.profileIconId === undefined
|
||||
? {}
|
||||
: { profileIconId: participant.profileIconId }),
|
||||
...(tier ? { tier } : {}),
|
||||
preferredPositions: participant.preferredPositions.map(
|
||||
(preference) => ({
|
||||
position: preference.position,
|
||||
priority: preference.priority,
|
||||
}),
|
||||
),
|
||||
joinedAt: asIso(participant.joinedAt),
|
||||
excluded: participant.excluded ?? false,
|
||||
};
|
||||
}),
|
||||
teams: source.teams.map((team) => ({
|
||||
teamIndex: team.teamIndex,
|
||||
name: team.name,
|
||||
...(team.captainUserId
|
||||
? { captainUserId: team.captainUserId.toString() }
|
||||
? { captainUserId: team.captainUserId.toString() as never }
|
||||
: {}),
|
||||
members: team.members.map((member) => ({
|
||||
userId: member.userId.toString(),
|
||||
userId: member.userId.toString() as never,
|
||||
assignedPosition: member.assignedPosition,
|
||||
...(member.cost === undefined ? {} : { cost: member.cost }),
|
||||
})),
|
||||
@@ -115,7 +121,7 @@ export function presentPublicMatch(
|
||||
prizes: [...source.prizes],
|
||||
notices: [...source.notices],
|
||||
schedule: source.schedule.map(({ time, label }) => ({ time, label })),
|
||||
...(options.joined === undefined ? {} : { joined: options.joined }),
|
||||
joined: options.joined ?? false,
|
||||
createdAt: asIso(source.createdAt),
|
||||
updatedAt: asIso(source.updatedAt),
|
||||
};
|
||||
@@ -125,13 +131,29 @@ function asIso(value: Date | string): string {
|
||||
return value instanceof Date ? value.toISOString() : value;
|
||||
}
|
||||
|
||||
function toWireValue(value: unknown): unknown {
|
||||
if (value instanceof Date) return value.toISOString();
|
||||
if (Array.isArray(value)) return value.map(toWireValue);
|
||||
if (typeof value === 'object' && value !== null) {
|
||||
return Object.fromEntries(
|
||||
Object.entries(value).map(([key, child]) => [key, toWireValue(child)]),
|
||||
);
|
||||
function toPublicTier(value: unknown): MatchTierView | undefined {
|
||||
if (typeof value !== 'object' || value === null || Array.isArray(value)) {
|
||||
return undefined;
|
||||
}
|
||||
return value;
|
||||
const tier = value as Record<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,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,
|
||||
@@ -23,7 +27,6 @@ import {
|
||||
AddParticipantDto,
|
||||
CreateMatchDto,
|
||||
JoinMatchDto,
|
||||
SwapDoubleEliminationSeedsDto,
|
||||
UpdateMatchDto,
|
||||
UpdateParticipantDto,
|
||||
} from './dto/create-match.dto';
|
||||
@@ -41,9 +44,9 @@ export class MatchController {
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Body() body: CreateMatchDto,
|
||||
) {
|
||||
): Promise<MatchDetailResponse> {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
return this.matchService.create({
|
||||
const match = await this.matchService.create({
|
||||
communityId,
|
||||
hostUserId: currentUser._id,
|
||||
data: {
|
||||
@@ -62,6 +65,7 @@ export class MatchController {
|
||||
schedule: body.schedule ?? [],
|
||||
},
|
||||
});
|
||||
return this.matchService.serialize(match, { joined: false });
|
||||
}
|
||||
|
||||
// 공개 — 커뮤니티 내 매치 리스트. 로그인 시 본인 참여 여부를 함께 반환.
|
||||
@@ -78,7 +82,7 @@ export class MatchController {
|
||||
@Query('scheduledFrom') scheduledFrom?: string,
|
||||
@Query('scheduledTo') scheduledTo?: string,
|
||||
@Query('sort') sort?: 'asc' | 'desc',
|
||||
) {
|
||||
): Promise<MatchListResponse> {
|
||||
const result = await this.matchService.listPage({
|
||||
communityId,
|
||||
status,
|
||||
@@ -108,10 +112,20 @@ export class MatchController {
|
||||
@Get(':matchId')
|
||||
@AllowPublicAccess()
|
||||
public async getMatch(
|
||||
@CurrentUser() currentUser: UserDocument | undefined,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
) {
|
||||
const match = await this.matchService.getById(matchId);
|
||||
return this.matchService.serialize(match);
|
||||
): Promise<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')
|
||||
@@ -123,48 +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);
|
||||
}
|
||||
|
||||
@Delete(':matchId')
|
||||
@@ -181,20 +165,25 @@ export class MatchController {
|
||||
await this.matchService.remove({ matchId, communityId });
|
||||
}
|
||||
|
||||
// 공개 — 참여 (로그인된 유저는 자기 자신, 비로그인은 body.userId 사용).
|
||||
// 커뮤니티 멤버 본인 참여. 다른 유저 추가는 관리자 전용 경로를 사용한다.
|
||||
@Post(':matchId/participants')
|
||||
@AllowPublicAccess()
|
||||
@Roles('owner', 'admin', 'member')
|
||||
@UseGuards(RolesGuard)
|
||||
public async joinMatch(
|
||||
@CurrentUser() currentUser: UserDocument | undefined,
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Body() body: JoinMatchDto,
|
||||
) {
|
||||
const userId = this.resolveJoinerUserId(currentUser, body.userId);
|
||||
return this.matchService.join({
|
||||
): Promise<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 });
|
||||
}
|
||||
|
||||
// 관리자 전용 — 커뮤니티 유저를 모집중 매치에 직접 추가한다.
|
||||
@@ -208,15 +197,20 @@ export class MatchController {
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Param('userId', ParseObjectIdPipe) userId: mongoose.Types.ObjectId,
|
||||
@Body() body: AddParticipantDto | undefined,
|
||||
) {
|
||||
): Promise<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),
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
// 관리자 전용 — 참가자 주/부 포지션 변경.
|
||||
@@ -230,7 +224,7 @@ export class MatchController {
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Param('userId', ParseObjectIdPipe) userId: mongoose.Types.ObjectId,
|
||||
@Body() body: UpdateParticipantDto,
|
||||
) {
|
||||
): Promise<MatchDetailResponse> {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
const match = await this.matchService.updateParticipantPositions({
|
||||
matchId,
|
||||
@@ -239,7 +233,11 @@ export class MatchController {
|
||||
mainPosition: body.mainPosition,
|
||||
subPosition: body.subPosition,
|
||||
});
|
||||
return this.matchService.serialize(match);
|
||||
return this.matchService.serialize(match, {
|
||||
joined: match.participants.some((participant) =>
|
||||
participant.userId.equals(currentUser._id),
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
// 관리자 전용 — 참가자 강제 제외.
|
||||
@@ -262,19 +260,6 @@ export class MatchController {
|
||||
});
|
||||
}
|
||||
|
||||
private resolveJoinerUserId(
|
||||
currentUser: UserDocument | undefined,
|
||||
bodyUserId?: string,
|
||||
): mongoose.Types.ObjectId {
|
||||
if (currentUser) return currentUser._id;
|
||||
if (!bodyUserId || !mongoose.isValidObjectId(bodyUserId)) {
|
||||
throw new BadRequestException(
|
||||
'userId is required when not authenticated.',
|
||||
);
|
||||
}
|
||||
return new mongoose.Types.ObjectId(bodyUserId);
|
||||
}
|
||||
|
||||
private assertSameCommunity(
|
||||
user: UserDocument,
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
|
||||
@@ -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,14 +1,11 @@
|
||||
import {
|
||||
BadRequestException,
|
||||
ConflictException,
|
||||
Injectable,
|
||||
InternalServerErrorException,
|
||||
NotFoundException,
|
||||
} from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import {
|
||||
reshuffleDoubleEliminationSeeds,
|
||||
swapDoubleEliminationSeeds,
|
||||
} from '../double-elimination/double-elimination.util';
|
||||
import { MatchStatsService } from '../community-stats/match-stats.service';
|
||||
import { CommunityStatsService } from '../community-stats/community-stats.service';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
@@ -76,6 +73,7 @@ interface MatchListFilter {
|
||||
|
||||
interface JoinMatchParams {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
communityId?: mongoose.Types.ObjectId;
|
||||
userId: mongoose.Types.ObjectId;
|
||||
preferredPositions?: PositionPreference[];
|
||||
// 특정 RiotAccount(puuid)로 참가하고 싶을 때 지정. 없으면 primary 사용.
|
||||
@@ -101,17 +99,6 @@ interface UpdateParticipantPositionsParams {
|
||||
subPosition: Position;
|
||||
}
|
||||
|
||||
interface DoubleEliminationAdminParams {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
actorUserId: mongoose.Types.ObjectId;
|
||||
}
|
||||
|
||||
interface SwapDoubleEliminationSeedsParams extends DoubleEliminationAdminParams {
|
||||
leftSeedNumber: number;
|
||||
rightSeedNumber: number;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class MatchService {
|
||||
constructor(
|
||||
@@ -197,9 +184,10 @@ export class MatchService {
|
||||
|
||||
public async getById(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
): Promise<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;
|
||||
}
|
||||
@@ -224,15 +212,24 @@ export class MatchService {
|
||||
throw new BadRequestException('Match does not belong to this community.');
|
||||
}
|
||||
const previousStatus = match.status;
|
||||
if (
|
||||
previousStatus !== 'recruiting' &&
|
||||
params.patch.status === 'recruiting'
|
||||
) {
|
||||
throw new ConflictException(
|
||||
'A finalized team build cannot return to recruiting. Preserve its immutable lifecycle and create a new Match instead.',
|
||||
);
|
||||
}
|
||||
if (
|
||||
previousStatus !== 'recruiting' &&
|
||||
('maxParticipants' in params.patch ||
|
||||
'gameCount' in params.patch ||
|
||||
'gameMode' in params.patch ||
|
||||
'roundRobinMaxRounds' in params.patch ||
|
||||
'doubleEliminationResetFinalEnabled' in params.patch)
|
||||
) {
|
||||
throw new BadRequestException(
|
||||
'maxParticipants, gameMode, roundRobinMaxRounds, and doubleEliminationResetFinalEnabled can only be changed while recruiting.',
|
||||
'maxParticipants, gameCount, gameMode, roundRobinMaxRounds, and doubleEliminationResetFinalEnabled can only be changed while recruiting.',
|
||||
);
|
||||
}
|
||||
const patchToSet =
|
||||
@@ -252,21 +249,8 @@ export class MatchService {
|
||||
})
|
||||
: this.stripMatchConfigInput(params.patch);
|
||||
match.set(patchToSet);
|
||||
if (previousStatus !== 'recruiting' && match.status === 'recruiting') {
|
||||
if (match.tournamentCodeIds.length > 0) {
|
||||
await this.tournamentCodeService.releaseFromMatch(match);
|
||||
}
|
||||
match.tournamentCodeIds = [];
|
||||
match.gameSchedule = [];
|
||||
match.teamBuiltAt = undefined;
|
||||
match.result = undefined;
|
||||
match.resultPollState = undefined;
|
||||
}
|
||||
await match.save();
|
||||
if (previousStatus !== 'recruiting' && match.status === 'recruiting') {
|
||||
await this.matchStatsService.removeByMatch(match._id);
|
||||
await this.communityStatsService.invalidateCommunity(params.communityId);
|
||||
} else if (match.result?.games?.length) {
|
||||
if (match.result?.games?.length) {
|
||||
await this.matchStatsService.buildAndUpsert(match._id);
|
||||
await this.communityStatsService.invalidateCommunity(params.communityId);
|
||||
}
|
||||
@@ -283,62 +267,31 @@ export class MatchService {
|
||||
if (!match.communityId.equals(params.communityId)) {
|
||||
throw new BadRequestException('Match does not belong to this community.');
|
||||
}
|
||||
if (match.status !== 'recruiting') {
|
||||
throw new ConflictException(
|
||||
'Only a recruiting Match can be hard-deleted. Finalized Match history must be preserved.',
|
||||
);
|
||||
}
|
||||
if (match.competitionId) {
|
||||
throw new ConflictException(
|
||||
'A Match with a Competition cannot be hard-deleted. Preserve the immutable ledger and archive the Match instead.',
|
||||
);
|
||||
}
|
||||
await this.tournamentCodeService.releaseFromMatch(match);
|
||||
await this.matchStatsService.removeByMatch(match._id);
|
||||
await match.deleteOne();
|
||||
await this.communityStatsService.invalidateCommunity(params.communityId);
|
||||
}
|
||||
|
||||
public async reshuffleDoubleEliminationSeeds(
|
||||
params: DoubleEliminationAdminParams,
|
||||
): Promise<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 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)
|
||||
@@ -362,7 +315,7 @@ export class MatchService {
|
||||
const updatedMatch = await MatchModel.findOneAndUpdate(
|
||||
{
|
||||
_id: params.matchId,
|
||||
communityId: user.communityId,
|
||||
communityId: params.communityId ?? user.communityId,
|
||||
status: 'recruiting',
|
||||
'participants.userId': { $ne: user._id },
|
||||
$expr: { $lt: [{ $size: '$participants' }, '$maxParticipants'] },
|
||||
@@ -438,85 +391,6 @@ export class MatchService {
|
||||
return gameCount % 2 === 0 ? gameCount + 1 : gameCount;
|
||||
}
|
||||
|
||||
private async loadDoubleEliminationMatch(params: {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
}): Promise<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 async releaseReservedDoubleEliminationCodes(
|
||||
match: MatchDocument,
|
||||
): 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',
|
||||
bracketMatchId: { $exists: true },
|
||||
}).exec();
|
||||
if (codes.length === 0) return;
|
||||
const releasedIds = codes.map((code) => code._id.toString());
|
||||
await TournamentCodeModel.updateMany(
|
||||
{ _id: { $in: codes.map((code) => code._id) } },
|
||||
{
|
||||
$set: { state: 'released', releasedAt: new Date() },
|
||||
$unset: {
|
||||
matchId: 1,
|
||||
gameNumber: 1,
|
||||
bracketMatchId: 1,
|
||||
reservedAt: 1,
|
||||
},
|
||||
},
|
||||
).exec();
|
||||
match.tournamentCodeIds = ids.filter(
|
||||
(id) => !releasedIds.includes(id.toString()),
|
||||
);
|
||||
}
|
||||
|
||||
public async cancelJoin(
|
||||
params: CancelMatchJoinParams,
|
||||
): Promise<MatchDocument> {
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
/* eslint-disable @typescript-eslint/no-unsafe-assignment */
|
||||
import mongoose from 'mongoose';
|
||||
import { Logger } from '@nestjs/common';
|
||||
import { CommunityStatsService } from '../community-stats/community-stats.service';
|
||||
import { MatchStatsService } from '../community-stats/match-stats.service';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
@@ -7,6 +8,10 @@ import { CompetitionAssignmentProvisioner } from './competition-assignment.provi
|
||||
import { CompetitionOutboxProcessor } from './competition-outbox.processor';
|
||||
|
||||
describe('CompetitionOutboxProcessor', () => {
|
||||
afterEach(() => {
|
||||
jest.restoreAllMocks();
|
||||
});
|
||||
|
||||
it('leases a projection event and applies idempotent downstream effects', async () => {
|
||||
const competitionId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
@@ -158,6 +163,59 @@ describe('CompetitionOutboxProcessor', () => {
|
||||
},
|
||||
);
|
||||
});
|
||||
|
||||
it('dead-letters a poison event after the delivery attempt limit', async () => {
|
||||
const event = {
|
||||
_id: new mongoose.Types.ObjectId(),
|
||||
competitionId: new mongoose.Types.ObjectId(),
|
||||
revision: 2,
|
||||
type: 'competition.projection-updated',
|
||||
state: 'pending',
|
||||
attemptCount: 10,
|
||||
};
|
||||
const updateOne = jest.fn(() => executable({ matchedCount: 1 }));
|
||||
const models = {
|
||||
competitionOutbox: {
|
||||
findOneAndUpdate: jest
|
||||
.fn()
|
||||
.mockReturnValueOnce(leanExecutable(event))
|
||||
.mockReturnValueOnce(leanExecutable(null)),
|
||||
updateOne,
|
||||
},
|
||||
competition: {
|
||||
findById: jest.fn(() => leanExecutable(null)),
|
||||
},
|
||||
match: {},
|
||||
};
|
||||
const errorLog = jest
|
||||
.spyOn(Logger.prototype, 'error')
|
||||
.mockImplementation(() => undefined);
|
||||
const processor = new CompetitionOutboxProcessor(
|
||||
{
|
||||
getModel: jest.fn((name: keyof typeof models) =>
|
||||
Promise.resolve(models[name]),
|
||||
),
|
||||
} as unknown as ConnectionService,
|
||||
{ provisionReadyAssignments: jest.fn() } as never,
|
||||
{ buildAndUpsert: jest.fn() } as never,
|
||||
{ invalidateCommunity: jest.fn() } as never,
|
||||
);
|
||||
|
||||
await expect(processor.drainOnce()).resolves.toBe(1);
|
||||
|
||||
expect(updateOne).toHaveBeenCalledWith(
|
||||
{ _id: event._id, state: 'pending', attemptCount: 10 },
|
||||
{
|
||||
$set: {
|
||||
state: 'dead-letter',
|
||||
lastError: 'Competition no longer exists.',
|
||||
},
|
||||
},
|
||||
);
|
||||
expect(errorLog).toHaveBeenCalledWith(
|
||||
expect.stringContaining('moved to dead-letter after 10 attempts'),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
function leanExecutable<T>(value: T) {
|
||||
|
||||
@@ -15,6 +15,7 @@ const DRAIN_INTERVAL_MS = 5_000;
|
||||
const PROCESSING_LEASE_MS = 60_000;
|
||||
const MAX_EVENTS_PER_DRAIN = 20;
|
||||
const MAX_RETRY_DELAY_MS = 5 * 60_000;
|
||||
const MAX_DELIVERY_ATTEMPTS = 10;
|
||||
|
||||
interface ClaimedOutboxEvent {
|
||||
_id: mongoose.Types.ObjectId;
|
||||
@@ -130,18 +131,33 @@ export class CompetitionOutboxProcessor
|
||||
$unset: { lastError: 1 },
|
||||
}).exec();
|
||||
} catch (error) {
|
||||
const lastError = errorMessage(error).slice(0, 2_000);
|
||||
if (event.attemptCount >= MAX_DELIVERY_ATTEMPTS) {
|
||||
const terminal = await OutboxModel.updateOne(leaseFilter(event), {
|
||||
$set: {
|
||||
state: 'dead-letter',
|
||||
lastError,
|
||||
},
|
||||
}).exec();
|
||||
if (terminal.matchedCount > 0) {
|
||||
this.logger.error(
|
||||
`Competition outbox event ${event._id.toString()} moved to dead-letter after ${event.attemptCount} attempts: ${lastError}`,
|
||||
);
|
||||
}
|
||||
return;
|
||||
}
|
||||
const availableAt = new Date(
|
||||
Date.now() + retryDelayMilliseconds(event.attemptCount),
|
||||
);
|
||||
await OutboxModel.updateOne(leaseFilter(event), {
|
||||
$set: {
|
||||
state: 'failed',
|
||||
lastError: errorMessage(error).slice(0, 2_000),
|
||||
lastError,
|
||||
availableAt,
|
||||
},
|
||||
}).exec();
|
||||
this.logger.warn(
|
||||
`Competition outbox event ${event._id.toString()} failed: ${errorMessage(error)}`,
|
||||
`Competition outbox event ${event._id.toString()} failed: ${lastError}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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}`);
|
||||
}
|
||||
+87
-48
@@ -5,6 +5,9 @@ import type {
|
||||
CompetitionCommandResponse,
|
||||
CompetitionDetailResponse,
|
||||
CreateSeriesAdjudicationRequest,
|
||||
MatchDetailResponse,
|
||||
MatchLifecycleStatus,
|
||||
MatchListResponse,
|
||||
ReverseSeriesResultRequest,
|
||||
SeriesId,
|
||||
SeriesReversalPreviewRequest,
|
||||
@@ -18,6 +21,10 @@ import {
|
||||
MSAL_API_SCOPE,
|
||||
MSAL_SILENT_REDIRECT_URI,
|
||||
} from '../lib/auth/msal.config';
|
||||
import {
|
||||
executeAuthScopedQuery,
|
||||
resolveAuthQueryScope,
|
||||
} from './auth-query-scope';
|
||||
import type {
|
||||
ApiAuction,
|
||||
ApiAuctionHistoryEntry,
|
||||
@@ -31,7 +38,6 @@ import type {
|
||||
LegacyImportJobsResponse,
|
||||
LegacyImportMembersResponse,
|
||||
LegacyMatchListResponse,
|
||||
ApiMatch,
|
||||
ApiRecentMatchesResponse,
|
||||
ApiRecentSummaryResponse,
|
||||
ApiTeamInsightsResponse,
|
||||
@@ -41,9 +47,7 @@ import type {
|
||||
DdragonManifest,
|
||||
StartLegacyImportRequest,
|
||||
StartLegacyImportResponse,
|
||||
MatchStatus,
|
||||
MatchMutationRequest,
|
||||
MatchesResponse,
|
||||
ManualTournamentResultCollectResponse,
|
||||
MeResponse,
|
||||
RiotQueueGroup,
|
||||
@@ -59,7 +63,7 @@ import type {
|
||||
const DDRAGON_MANIFEST_STALE_MS = 24 * 60 * 60 * 1000;
|
||||
|
||||
interface MatchesQueryOptions {
|
||||
status?: MatchStatus;
|
||||
status?: MatchLifecycleStatus;
|
||||
limit?: number;
|
||||
page?: number;
|
||||
offset?: number;
|
||||
@@ -101,6 +105,45 @@ function createMatchesPath(
|
||||
return `/communities/${communityId}/matches${queryString ? `?${queryString}` : ''}`;
|
||||
}
|
||||
|
||||
function useOptionalAuthQueryScope() {
|
||||
const authUserId = useAuthUserId();
|
||||
const { accounts, inProgress, instance } = useMsal();
|
||||
const account = isMsalConfigured
|
||||
? (instance.getActiveAccount() ?? accounts[0] ?? null)
|
||||
: null;
|
||||
const scope = resolveAuthQueryScope({
|
||||
authUserId,
|
||||
accountKey: account?.homeAccountId ?? null,
|
||||
msalConfigured: isMsalConfigured,
|
||||
msalReady: inProgress === InteractionStatus.None,
|
||||
});
|
||||
|
||||
const fetch = <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],
|
||||
@@ -114,10 +157,13 @@ export function useMatches(
|
||||
options: MatchesQueryOptions,
|
||||
communityId = DEFAULT_COMMUNITY_ID,
|
||||
) {
|
||||
const authScope = useOptionalAuthQueryScope();
|
||||
|
||||
return useQuery({
|
||||
queryKey: [
|
||||
'matches',
|
||||
communityId,
|
||||
...authScope.cacheKey,
|
||||
options.status ?? null,
|
||||
options.limit ?? null,
|
||||
options.page ?? null,
|
||||
@@ -127,13 +173,12 @@ export function useMatches(
|
||||
options.sort ?? null,
|
||||
],
|
||||
queryFn: async () => {
|
||||
const response = await apiFetch<MatchesResponse>(
|
||||
const response = await authScope.fetch<MatchListResponse>(
|
||||
createMatchesPath(communityId, options),
|
||||
{ auth: 'none' },
|
||||
);
|
||||
return response.matches;
|
||||
},
|
||||
enabled: Boolean(communityId),
|
||||
enabled: Boolean(communityId && authScope.ready),
|
||||
});
|
||||
}
|
||||
|
||||
@@ -141,10 +186,13 @@ export function useMatchesPage(
|
||||
options: MatchesQueryOptions,
|
||||
communityId = DEFAULT_COMMUNITY_ID,
|
||||
) {
|
||||
const authScope = useOptionalAuthQueryScope();
|
||||
|
||||
return useQuery({
|
||||
queryKey: [
|
||||
'matches-page',
|
||||
communityId,
|
||||
...authScope.cacheKey,
|
||||
options.status ?? null,
|
||||
options.limit ?? null,
|
||||
options.page ?? null,
|
||||
@@ -154,10 +202,10 @@ export function useMatchesPage(
|
||||
options.sort ?? null,
|
||||
],
|
||||
queryFn: () =>
|
||||
apiFetch<MatchesResponse>(createMatchesPath(communityId, options), {
|
||||
auth: 'none',
|
||||
}),
|
||||
enabled: Boolean(communityId),
|
||||
authScope.fetch<MatchListResponse>(
|
||||
createMatchesPath(communityId, options),
|
||||
),
|
||||
enabled: Boolean(communityId && authScope.ready),
|
||||
placeholderData: (previousData) => previousData,
|
||||
});
|
||||
}
|
||||
@@ -166,15 +214,25 @@ export function useMatch(
|
||||
matchId: string | undefined,
|
||||
communityId = DEFAULT_COMMUNITY_ID,
|
||||
) {
|
||||
return useQuery({
|
||||
queryKey: ['match', communityId, matchId ?? null],
|
||||
const authScope = useOptionalAuthQueryScope();
|
||||
const queryKey = [
|
||||
'match',
|
||||
communityId,
|
||||
matchId ?? null,
|
||||
...authScope.cacheKey,
|
||||
] as const;
|
||||
|
||||
const query = useQuery({
|
||||
queryKey,
|
||||
queryFn: () =>
|
||||
apiFetch<ApiMatch>(`/communities/${communityId}/matches/${matchId}`, {
|
||||
auth: 'none',
|
||||
}),
|
||||
enabled: Boolean(communityId && matchId),
|
||||
authScope.fetch<MatchDetailResponse>(
|
||||
`/communities/${communityId}/matches/${matchId}`,
|
||||
),
|
||||
enabled: Boolean(communityId && matchId && authScope.ready),
|
||||
retry: false,
|
||||
});
|
||||
|
||||
return { ...query, queryKey };
|
||||
}
|
||||
|
||||
export function useCompetition(
|
||||
@@ -426,7 +484,7 @@ export function useResetAuction(communityId = DEFAULT_COMMUNITY_ID) {
|
||||
export function useCreateMatch(communityId = DEFAULT_COMMUNITY_ID) {
|
||||
return useMutation({
|
||||
mutationFn: (body: MatchMutationRequest) =>
|
||||
apiFetch<ApiMatch>(`/communities/${communityId}/matches`, {
|
||||
apiFetch<MatchDetailResponse>(`/communities/${communityId}/matches`, {
|
||||
method: 'POST',
|
||||
body: JSON.stringify(body),
|
||||
}),
|
||||
@@ -442,10 +500,13 @@ export function useUpdateMatch(communityId = DEFAULT_COMMUNITY_ID) {
|
||||
matchId: string;
|
||||
body: Partial<MatchMutationRequest>;
|
||||
}) =>
|
||||
apiFetch<ApiMatch>(`/communities/${communityId}/matches/${matchId}`, {
|
||||
method: 'PATCH',
|
||||
body: JSON.stringify(body),
|
||||
}),
|
||||
apiFetch<MatchDetailResponse>(
|
||||
`/communities/${communityId}/matches/${matchId}`,
|
||||
{
|
||||
method: 'PATCH',
|
||||
body: JSON.stringify(body),
|
||||
},
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
@@ -1028,34 +1089,12 @@ export function useRebuildLegacyMatches(communityId = DEFAULT_COMMUNITY_ID) {
|
||||
}
|
||||
|
||||
export function useMe() {
|
||||
const authUserId = useAuthUserId();
|
||||
const { accounts, inProgress, instance } = useMsal();
|
||||
const account = isMsalConfigured
|
||||
? (instance.getActiveAccount() ?? accounts[0] ?? null)
|
||||
: null;
|
||||
const accountKey = account?.homeAccountId ?? null;
|
||||
const isMsalReady =
|
||||
!isMsalConfigured || inProgress === InteractionStatus.None;
|
||||
const authScope = useOptionalAuthQueryScope();
|
||||
|
||||
return useQuery({
|
||||
queryKey: ['me', authUserId, accountKey],
|
||||
queryFn: async () => {
|
||||
if (!account) {
|
||||
return apiFetch<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,
|
||||
});
|
||||
}
|
||||
@@ -1,15 +1,17 @@
|
||||
import type {
|
||||
MatchDetailResponse,
|
||||
MatchLifecycleStatus,
|
||||
MatchParticipantView,
|
||||
} from "@lolympus/contracts";
|
||||
import type {
|
||||
ApiAuction,
|
||||
ApiAuctionPlayerSnapshot,
|
||||
ApiAuctionTeam,
|
||||
ApiMatch,
|
||||
ApiMatchParticipant,
|
||||
ApiPositionPreference,
|
||||
ApiRiotLaneStats,
|
||||
ApiRiotRecentStatsSummary,
|
||||
ApiTierHistoryEntry,
|
||||
ApiTierInfo,
|
||||
MatchStatus,
|
||||
Position,
|
||||
RiotLane,
|
||||
} from "./types";
|
||||
@@ -46,7 +48,7 @@ export interface MatchDetailView {
|
||||
title: string;
|
||||
date: string;
|
||||
time: string;
|
||||
status: MatchStatus;
|
||||
status: MatchLifecycleStatus;
|
||||
description: string;
|
||||
map: string;
|
||||
maxParticipants: number;
|
||||
@@ -180,7 +182,7 @@ function resolveMainAndSubPosition(
|
||||
}
|
||||
|
||||
function mapMatchParticipantToView(
|
||||
participant: ApiMatchParticipant,
|
||||
participant: MatchParticipantView,
|
||||
): ParticipantView {
|
||||
const { mainPosition, subPosition } = resolveMainAndSubPosition(
|
||||
participant.preferredPositions,
|
||||
@@ -383,7 +385,9 @@ export function buildDefaultPreferredPositions() {
|
||||
}));
|
||||
}
|
||||
|
||||
export function mapApiMatchToMatchDetail(match: ApiMatch): MatchDetailView {
|
||||
export function mapApiMatchToMatchDetail(
|
||||
match: MatchDetailResponse,
|
||||
): MatchDetailView {
|
||||
const formattedDate = formatKoreanDate(match.scheduledAt);
|
||||
const participants = match.participants.map(mapMatchParticipantToView);
|
||||
const participantLookup = new Map(
|
||||
@@ -439,7 +443,7 @@ export function mapApiMatchToMatchDetail(match: ApiMatch): MatchDetailView {
|
||||
|
||||
export function mapApiAuctionToAuctionState(
|
||||
auction: ApiAuction,
|
||||
match: ApiMatch,
|
||||
match: MatchDetailResponse,
|
||||
now = new Date(),
|
||||
): AuctionStateView {
|
||||
const participantLookup = new Map(
|
||||
|
||||
+12
-87
@@ -1,15 +1,14 @@
|
||||
export type Position = 'TOP' | 'JGL' | 'MID' | 'ADC' | 'SUP';
|
||||
import type {
|
||||
MatchGameMode,
|
||||
MatchPosition,
|
||||
MatchPositionPreferenceView,
|
||||
MatchScheduleItemView,
|
||||
MatchTierView,
|
||||
} from '@lolympus/contracts';
|
||||
|
||||
export type Position = MatchPosition;
|
||||
export type RiotLane = 'TOP' | 'JUNGLE' | 'MIDDLE' | 'BOTTOM' | 'UTILITY';
|
||||
export type TeamSide = 'blue' | 'red';
|
||||
export type MatchGameMode =
|
||||
| 'pair'
|
||||
| 'round-robin'
|
||||
| 'double-elimination';
|
||||
export type MatchStatus =
|
||||
| 'recruiting'
|
||||
| 'team-built'
|
||||
| 'in-progress'
|
||||
| 'finished';
|
||||
export type AuctionPhase =
|
||||
| 'waiting'
|
||||
| 'presenting'
|
||||
@@ -25,20 +24,8 @@ export type AuctionTopTierThreshold =
|
||||
| 'MANUAL';
|
||||
export type CommunityRole = 'owner' | 'admin' | 'member';
|
||||
|
||||
export interface ApiPositionPreference {
|
||||
position: Position;
|
||||
priority: number;
|
||||
}
|
||||
|
||||
export interface ApiTierInfo {
|
||||
queueType: string;
|
||||
tier: string;
|
||||
rank: string;
|
||||
leaguePoints: number;
|
||||
wins: number;
|
||||
losses: number;
|
||||
fetchedAt: string;
|
||||
}
|
||||
export type ApiPositionPreference = MatchPositionPreferenceView;
|
||||
export type ApiTierInfo = MatchTierView;
|
||||
|
||||
export interface ApiChampionMasteryEntry {
|
||||
puuid?: string;
|
||||
@@ -142,36 +129,6 @@ export type TournamentCodeState =
|
||||
| 'released'
|
||||
| 'voided';
|
||||
|
||||
export interface ApiMatchParticipant {
|
||||
userId: string;
|
||||
puuid?: string;
|
||||
gameName?: string;
|
||||
tagLine?: string;
|
||||
profileIconId?: number;
|
||||
tier?: ApiTierInfo;
|
||||
preferredPositions: ApiPositionPreference[];
|
||||
joinedAt: string;
|
||||
excluded?: boolean;
|
||||
}
|
||||
|
||||
export interface ApiMatchTeamMember {
|
||||
userId: string;
|
||||
assignedPosition: Position;
|
||||
cost?: number;
|
||||
}
|
||||
|
||||
export interface ApiMatchTeam {
|
||||
teamIndex: number;
|
||||
name: string;
|
||||
captainUserId?: string;
|
||||
members: ApiMatchTeamMember[];
|
||||
}
|
||||
|
||||
export interface ApiMatchScheduleItem {
|
||||
time: string;
|
||||
label: string;
|
||||
}
|
||||
|
||||
export interface ManualTournamentResultCollectResponse {
|
||||
scanned: number;
|
||||
matched: number;
|
||||
@@ -180,31 +137,6 @@ export interface ManualTournamentResultCollectResponse {
|
||||
gameNumbers: number[];
|
||||
}
|
||||
|
||||
export interface ApiMatch {
|
||||
_id: string;
|
||||
communityId: string;
|
||||
shortCode?: string;
|
||||
title: string;
|
||||
description: string;
|
||||
mapId: number;
|
||||
status: MatchStatus;
|
||||
scheduledAt: string;
|
||||
maxParticipants: number;
|
||||
gameCount: number;
|
||||
gameMode: MatchGameMode;
|
||||
roundRobinMaxRounds?: number;
|
||||
doubleEliminationResetFinalEnabled?: boolean;
|
||||
hostUserId?: string;
|
||||
participants: ApiMatchParticipant[];
|
||||
teams: ApiMatchTeam[];
|
||||
prizes: string[];
|
||||
notices: string[];
|
||||
schedule: ApiMatchScheduleItem[];
|
||||
joined?: boolean;
|
||||
createdAt: string;
|
||||
updatedAt: string;
|
||||
}
|
||||
|
||||
export interface ApiAuctionPlayerSnapshot {
|
||||
userId: string;
|
||||
puuid: string;
|
||||
@@ -336,13 +268,6 @@ export interface MeResponse {
|
||||
memberships: ApiMembership[];
|
||||
}
|
||||
|
||||
export interface MatchesResponse {
|
||||
matches: ApiMatch[];
|
||||
total: number;
|
||||
page: number;
|
||||
limit: number;
|
||||
}
|
||||
|
||||
export interface MatchMutationRequest {
|
||||
title: string;
|
||||
description?: string;
|
||||
@@ -355,7 +280,7 @@ export interface MatchMutationRequest {
|
||||
doubleEliminationResetFinalEnabled?: boolean;
|
||||
prizes?: string[];
|
||||
notices?: string[];
|
||||
schedule?: ApiMatchScheduleItem[];
|
||||
schedule?: MatchScheduleItemView[];
|
||||
}
|
||||
|
||||
export interface DdragonChampionEntry {
|
||||
|
||||
@@ -1,5 +1,9 @@
|
||||
import { useEffect, useState } from "react";
|
||||
import { useMutation, useQueryClient } from "@tanstack/react-query";
|
||||
import type {
|
||||
MatchDetailResponse,
|
||||
MatchParticipantView,
|
||||
} from "@lolympus/contracts";
|
||||
import { ChevronLeft, Search, X } from "lucide-react";
|
||||
import { Link, useLocation, useNavigate, useParams } from "react-router";
|
||||
import {
|
||||
@@ -37,8 +41,6 @@ import type {
|
||||
AuctionTopTierThreshold,
|
||||
ApiCommunityUserSearchCandidate,
|
||||
ApiCommunityUserSearchRiotAccount,
|
||||
ApiMatch,
|
||||
ApiMatchParticipant,
|
||||
ApiPositionPreference,
|
||||
ApiTierInfo,
|
||||
ManualTournamentResultCollectResponse,
|
||||
@@ -138,7 +140,7 @@ function parseAuctionSecondsInput(value: string, min: number) {
|
||||
return seconds;
|
||||
}
|
||||
|
||||
function buildAuctionParticipantPool(participants: ApiMatchParticipant[]) {
|
||||
function buildAuctionParticipantPool(participants: MatchParticipantView[]) {
|
||||
const ordered = [...participants].sort(
|
||||
(left, right) =>
|
||||
new Date(left.joinedAt).getTime() - new Date(right.joinedAt).getTime(),
|
||||
@@ -148,7 +150,7 @@ function buildAuctionParticipantPool(participants: ApiMatchParticipant[]) {
|
||||
}
|
||||
|
||||
function buildCaptainSlots(
|
||||
participants: ApiMatchParticipant[],
|
||||
participants: MatchParticipantView[],
|
||||
): CaptainSelectionSlot[] {
|
||||
const teamCount = Math.floor(
|
||||
buildAuctionParticipantPool(participants).length / 5,
|
||||
@@ -1451,7 +1453,7 @@ export default function MatchDetailPage() {
|
||||
},
|
||||
});
|
||||
|
||||
const matchQueryKey = ["match", DEFAULT_COMMUNITY_ID, id ?? null];
|
||||
const matchQueryKey = matchQuery.queryKey;
|
||||
|
||||
const addParticipantMutation = useMutation({
|
||||
mutationFn: ({
|
||||
@@ -1463,7 +1465,7 @@ export default function MatchDetailPage() {
|
||||
preferredPositions: ApiPositionPreference[];
|
||||
riotPuuid?: string;
|
||||
}) =>
|
||||
apiFetch<ApiMatch>(
|
||||
apiFetch<MatchDetailResponse>(
|
||||
`/communities/${DEFAULT_COMMUNITY_ID}/matches/${id}/participants/${userId}`,
|
||||
{
|
||||
method: "POST",
|
||||
@@ -1488,9 +1490,10 @@ export default function MatchDetailPage() {
|
||||
),
|
||||
onMutate: async (userId: string) => {
|
||||
await queryClient.cancelQueries({ queryKey: matchQueryKey });
|
||||
const previous = queryClient.getQueryData<ApiMatch>(matchQueryKey);
|
||||
const previous =
|
||||
queryClient.getQueryData<MatchDetailResponse>(matchQueryKey);
|
||||
if (previous) {
|
||||
queryClient.setQueryData<ApiMatch>(matchQueryKey, {
|
||||
queryClient.setQueryData<MatchDetailResponse>(matchQueryKey, {
|
||||
...previous,
|
||||
participants: previous.participants.filter(
|
||||
(participant) => participant.userId !== userId,
|
||||
@@ -1531,9 +1534,10 @@ export default function MatchDetailPage() {
|
||||
),
|
||||
onMutate: async ({ userId, mainPosition, subPosition }) => {
|
||||
await queryClient.cancelQueries({ queryKey: matchQueryKey });
|
||||
const previous = queryClient.getQueryData<ApiMatch>(matchQueryKey);
|
||||
const previous =
|
||||
queryClient.getQueryData<MatchDetailResponse>(matchQueryKey);
|
||||
if (previous) {
|
||||
queryClient.setQueryData<ApiMatch>(matchQueryKey, {
|
||||
queryClient.setQueryData<MatchDetailResponse>(matchQueryKey, {
|
||||
...previous,
|
||||
participants: previous.participants.map((participant) =>
|
||||
participant.userId === userId
|
||||
@@ -1759,7 +1763,7 @@ export default function MatchDetailPage() {
|
||||
const manualPriorityCandidates = auctionParticipantPool.filter(
|
||||
(participant) => !selectedCaptainIds.includes(participant.userId),
|
||||
);
|
||||
const manualPriorityCandidateIds = new Set(
|
||||
const manualPriorityCandidateIds = new Set<string>(
|
||||
manualPriorityCandidates.map((participant) => participant.userId),
|
||||
);
|
||||
const selectedManualTopTierUserIds =
|
||||
|
||||
@@ -1,41 +1,112 @@
|
||||
import { useState } from "react";
|
||||
import { useEffect, useRef, useState } from "react";
|
||||
import { Link, useParams } from "react-router";
|
||||
import { useCompetition, useTeamCompetition } from "../api/hooks";
|
||||
import { SeriesScoreCard } from "../components/competition/SeriesScoreCard";
|
||||
import { DEFAULT_COMMUNITY_ID } from "../config";
|
||||
import {
|
||||
getTeamProgressErrorContent,
|
||||
isConsistentTeamProgressSnapshot,
|
||||
type TeamProgressErrorContent,
|
||||
} from "./match-team-progress-state";
|
||||
|
||||
export default function MatchTeamProgressPage() {
|
||||
const { id } = useParams();
|
||||
const competitionQuery = useCompetition(id, DEFAULT_COMMUNITY_ID);
|
||||
const teamQuery = useTeamCompetition(id, DEFAULT_COMMUNITY_ID);
|
||||
const refetchCompetition = competitionQuery.refetch;
|
||||
const refetchTeam = teamQuery.refetch;
|
||||
const [copiedSlotId, setCopiedSlotId] = useState<string | null>(null);
|
||||
const lastAutoRefetchedMismatchRef = useRef<string | null>(null);
|
||||
const competition = competitionQuery.data;
|
||||
const teamView = teamQuery.data;
|
||||
const hasQueryError = Boolean(
|
||||
competitionQuery.error || teamQuery.error,
|
||||
);
|
||||
const isRefetching = competitionQuery.isFetching || teamQuery.isFetching;
|
||||
const revisionsMatch = isConsistentTeamProgressSnapshot(
|
||||
competition,
|
||||
teamView,
|
||||
);
|
||||
const revisionMismatchKey =
|
||||
competition && teamView && !revisionsMatch
|
||||
? `${competition.revision}:${teamView.revision}`
|
||||
: null;
|
||||
|
||||
useEffect(() => {
|
||||
if (!revisionMismatchKey) {
|
||||
lastAutoRefetchedMismatchRef.current = null;
|
||||
return;
|
||||
}
|
||||
if (
|
||||
hasQueryError ||
|
||||
isRefetching ||
|
||||
lastAutoRefetchedMismatchRef.current === revisionMismatchKey
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
lastAutoRefetchedMismatchRef.current = revisionMismatchKey;
|
||||
void Promise.all([refetchCompetition(), refetchTeam()]).catch(
|
||||
() => undefined,
|
||||
);
|
||||
}, [
|
||||
hasQueryError,
|
||||
isRefetching,
|
||||
refetchCompetition,
|
||||
refetchTeam,
|
||||
revisionMismatchKey,
|
||||
]);
|
||||
|
||||
function retryBoth() {
|
||||
void Promise.all([refetchCompetition(), refetchTeam()]).catch(
|
||||
() => undefined,
|
||||
);
|
||||
}
|
||||
|
||||
if (competitionQuery.isLoading || teamQuery.isLoading) {
|
||||
return <TeamProgressLoadingState />;
|
||||
}
|
||||
|
||||
if (hasQueryError) {
|
||||
return (
|
||||
<main
|
||||
className="mx-auto max-w-5xl space-y-3 px-4 py-12 sm:px-6"
|
||||
aria-busy="true"
|
||||
aria-label="팀 진행 정보를 불러오는 중"
|
||||
>
|
||||
<div className="h-7 w-48 animate-pulse bg-base-200" />
|
||||
<div className="h-32 animate-pulse bg-base-200/70" />
|
||||
</main>
|
||||
<TeamProgressProblemState
|
||||
content={getTeamProgressErrorContent(
|
||||
[competitionQuery.error, teamQuery.error].filter(Boolean),
|
||||
)}
|
||||
isRetrying={isRefetching}
|
||||
matchId={id}
|
||||
onRetry={retryBoth}
|
||||
/>
|
||||
);
|
||||
}
|
||||
|
||||
const competition = competitionQuery.data;
|
||||
const teamView = teamQuery.data;
|
||||
if (!competition || !teamView) {
|
||||
return (
|
||||
<main className="mx-auto max-w-5xl px-4 py-20 text-center">
|
||||
<h1 className="text-lg font-bold">팀 진행 정보를 볼 수 없습니다</h1>
|
||||
<p className="mt-2 text-sm text-base-content/45">
|
||||
이 내전에 참여한 계정으로 로그인했는지 확인해주세요.
|
||||
</p>
|
||||
<Link to={`/match/${id}`} className="btn btn-primary btn-sm mt-5">
|
||||
내전 상세로
|
||||
</Link>
|
||||
</main>
|
||||
<TeamProgressProblemState
|
||||
content={getTeamProgressErrorContent([])}
|
||||
isRetrying={isRefetching}
|
||||
matchId={id}
|
||||
onRetry={retryBoth}
|
||||
/>
|
||||
);
|
||||
}
|
||||
|
||||
if (!revisionsMatch) {
|
||||
return (
|
||||
<TeamProgressProblemState
|
||||
content={{
|
||||
kind: "unknown",
|
||||
title: isRefetching
|
||||
? "최신 경기 정보를 맞추는 중입니다"
|
||||
: "경기 정보의 revision이 일치하지 않습니다",
|
||||
description: isRefetching
|
||||
? "Competition과 팀 정보를 함께 다시 불러오고 있습니다."
|
||||
: "일관된 경기 정보를 표시할 수 없어 두 응답을 다시 확인해야 합니다.",
|
||||
}}
|
||||
isRetrying={isRefetching}
|
||||
matchId={id}
|
||||
onRetry={retryBoth}
|
||||
/>
|
||||
);
|
||||
}
|
||||
|
||||
@@ -208,6 +279,59 @@ export default function MatchTeamProgressPage() {
|
||||
);
|
||||
}
|
||||
|
||||
function TeamProgressLoadingState() {
|
||||
return (
|
||||
<main
|
||||
className="mx-auto max-w-5xl space-y-3 px-4 py-12 sm:px-6"
|
||||
aria-busy="true"
|
||||
aria-label="팀 진행 정보를 불러오는 중"
|
||||
>
|
||||
<div className="h-7 w-48 animate-pulse bg-base-200" />
|
||||
<div className="h-32 animate-pulse bg-base-200/70" />
|
||||
</main>
|
||||
);
|
||||
}
|
||||
|
||||
function TeamProgressProblemState({
|
||||
content,
|
||||
isRetrying,
|
||||
matchId,
|
||||
onRetry,
|
||||
}: {
|
||||
content: TeamProgressErrorContent;
|
||||
isRetrying: boolean;
|
||||
matchId: string | undefined;
|
||||
onRetry: () => void;
|
||||
}) {
|
||||
return (
|
||||
<main className="mx-auto max-w-5xl px-4 py-20 sm:px-6">
|
||||
<section
|
||||
role="alert"
|
||||
aria-busy={isRetrying}
|
||||
className="border border-base-content/10 bg-base-100 px-5 py-8 text-center"
|
||||
>
|
||||
<h1 className="text-lg font-bold">{content.title}</h1>
|
||||
<p className="mt-2 text-sm text-base-content/45">
|
||||
{content.description}
|
||||
</p>
|
||||
<div className="mt-5 flex flex-wrap justify-center gap-2">
|
||||
<button
|
||||
type="button"
|
||||
className="btn btn-primary btn-sm"
|
||||
disabled={isRetrying}
|
||||
onClick={onRetry}
|
||||
>
|
||||
{isRetrying ? "다시 불러오는 중..." : "다시 시도"}
|
||||
</button>
|
||||
<Link to={`/match/${matchId}`} className="btn btn-ghost btn-sm">
|
||||
내전 상세로
|
||||
</Link>
|
||||
</div>
|
||||
</section>
|
||||
</main>
|
||||
);
|
||||
}
|
||||
|
||||
function EmptyState({ message }: { message: string }) {
|
||||
return (
|
||||
<p
|
||||
|
||||
@@ -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 = {
|
||||
@@ -92,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 {
|
||||
@@ -102,11 +102,11 @@ function parseSchedule(value: string): ApiMatchScheduleItem[] {
|
||||
});
|
||||
}
|
||||
|
||||
function scheduleToText(schedule: ApiMatchScheduleItem[] = []) {
|
||||
function scheduleToText(schedule: MatchScheduleItemView[] = []) {
|
||||
return schedule.map((item) => `${item.time}|${item.label}`).join('\n');
|
||||
}
|
||||
|
||||
function makeForm(match?: ApiMatch): MatchMutationRequest & {
|
||||
function makeForm(match?: MatchDetailResponse): MatchMutationRequest & {
|
||||
prizesText: string;
|
||||
noticesText: string;
|
||||
scheduleText: string;
|
||||
@@ -149,7 +149,7 @@ export default function MatchAdminPage() {
|
||||
const createMutation = useCreateMatch(communityId);
|
||||
const updateMutation = useUpdateMatch(communityId);
|
||||
const deleteMutation = useDeleteMatch(communityId);
|
||||
const [editing, setEditing] = useState<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);
|
||||
@@ -181,7 +181,7 @@ export default function MatchAdminPage() {
|
||||
setMessage(null);
|
||||
}
|
||||
|
||||
function openEdit(match: ApiMatch) {
|
||||
function openEdit(match: MatchDetailResponse) {
|
||||
setEditing(match);
|
||||
setForm(makeForm(match));
|
||||
setShowForm(true);
|
||||
@@ -550,7 +550,15 @@ export default function MatchAdminPage() {
|
||||
<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",
|
||||
);
|
||||
});
|
||||
@@ -44,7 +44,7 @@ causing team 3 to advance despite team 8 winning two games.
|
||||
## Commands
|
||||
|
||||
- API unit/integration tests: `pnpm --filter api test`
|
||||
- Focused API test: `pnpm --filter api test -- --runInBand <test-path>`
|
||||
- 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`
|
||||
@@ -80,6 +80,22 @@ and scheduling metadata. It receives a unique optional `competitionId`.
|
||||
|
||||
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
|
||||
@@ -188,6 +204,13 @@ 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.
|
||||
@@ -202,6 +225,11 @@ Within a MongoDB transaction, the shared command runner:
|
||||
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.
|
||||
|
||||
@@ -214,6 +242,9 @@ individual reversal facts joined by one causation ID.
|
||||
|
||||
- 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.
|
||||
@@ -241,6 +272,19 @@ Migration builds new collections without dual canonical writes.
|
||||
- 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.
|
||||
@@ -263,9 +307,9 @@ Prefer explicit discriminated unions and pure functions:
|
||||
|
||||
```ts
|
||||
switch (series.rule.type) {
|
||||
case 'first-to':
|
||||
case "first-to":
|
||||
return projectFirstToSeries(series, facts);
|
||||
case 'fixed-games':
|
||||
case "fixed-games":
|
||||
return projectFixedGamesSeries(series, facts);
|
||||
}
|
||||
```
|
||||
@@ -298,6 +342,8 @@ its `teamId` in the same object.
|
||||
- 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
|
||||
|
||||
@@ -310,7 +356,13 @@ its `teamId` in the same object.
|
||||
- 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.
|
||||
- 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.
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import type { CompetitionDetailResponse, CompetitionPhase } from "./competition.js";
|
||||
import type { CompetitionPhase } from "./competition.js";
|
||||
import type { CompetitionFormatType } from "./format.js";
|
||||
import type {
|
||||
CommunityId,
|
||||
@@ -13,11 +13,16 @@ import type { IsoDateTime, SeriesProjection } from "./series.js";
|
||||
|
||||
export type MatchLifecycleStatus =
|
||||
| "recruiting"
|
||||
| "team-building"
|
||||
| "ready"
|
||||
| "running"
|
||||
| "completed"
|
||||
| "cancelled";
|
||||
| "team-built"
|
||||
| "in-progress"
|
||||
| "finished";
|
||||
|
||||
export type MatchGameMode =
|
||||
| "pair"
|
||||
| "round-robin"
|
||||
| "double-elimination";
|
||||
|
||||
export type MatchPosition = "TOP" | "JGL" | "MID" | "ADC" | "SUP";
|
||||
|
||||
export interface MatchCompetitionSummaryView {
|
||||
id: CompetitionId;
|
||||
@@ -25,48 +30,79 @@ export interface MatchCompetitionSummaryView {
|
||||
formatType: CompetitionFormatType;
|
||||
}
|
||||
|
||||
export interface MatchSummaryResponse {
|
||||
id: MatchId;
|
||||
communityId: CommunityId;
|
||||
shortCode?: string;
|
||||
title: string;
|
||||
description: string;
|
||||
scheduledAt: IsoDateTime;
|
||||
status: MatchLifecycleStatus;
|
||||
maxParticipants: number;
|
||||
participantCount: number;
|
||||
joined: boolean;
|
||||
competition?: MatchCompetitionSummaryView;
|
||||
createdAt: IsoDateTime;
|
||||
updatedAt: IsoDateTime;
|
||||
export interface MatchPositionPreferenceView {
|
||||
position: MatchPosition;
|
||||
priority: number;
|
||||
}
|
||||
|
||||
export interface MatchTierView {
|
||||
queueType: string;
|
||||
tier: string;
|
||||
rank: string;
|
||||
leaguePoints: number;
|
||||
wins: number;
|
||||
losses: number;
|
||||
fetchedAt: IsoDateTime;
|
||||
}
|
||||
|
||||
export interface MatchParticipantView {
|
||||
userId: UserId;
|
||||
displayName: string;
|
||||
gameName?: string;
|
||||
tagLine?: string;
|
||||
profileIconId?: number;
|
||||
tier?: MatchTierView;
|
||||
preferredPositions: MatchPositionPreferenceView[];
|
||||
joinedAt: IsoDateTime;
|
||||
excluded: boolean;
|
||||
}
|
||||
|
||||
export interface MatchTeamMemberView {
|
||||
userId: UserId;
|
||||
assignedPosition: MatchPosition;
|
||||
cost?: number;
|
||||
}
|
||||
|
||||
export interface MatchTeamView {
|
||||
teamIndex: number;
|
||||
name: string;
|
||||
captainUserId?: UserId;
|
||||
members: MatchTeamMemberView[];
|
||||
}
|
||||
|
||||
export interface MatchScheduleItemView {
|
||||
time: string;
|
||||
label: string;
|
||||
}
|
||||
|
||||
export interface MatchDetailResponse
|
||||
extends Omit<MatchSummaryResponse, "competition"> {
|
||||
/** Canonical wire DTO returned by both Match list and detail endpoints. */
|
||||
export interface MatchDetailResponse {
|
||||
_id: MatchId;
|
||||
communityId: CommunityId;
|
||||
competitionId?: CompetitionId;
|
||||
shortCode?: string;
|
||||
title: string;
|
||||
description: string;
|
||||
mapId: number;
|
||||
status: MatchLifecycleStatus;
|
||||
scheduledAt: IsoDateTime;
|
||||
maxParticipants: number;
|
||||
gameCount: number;
|
||||
gameMode: MatchGameMode;
|
||||
roundRobinMaxRounds?: number;
|
||||
doubleEliminationResetFinalEnabled?: boolean;
|
||||
hostUserId?: UserId;
|
||||
participants: MatchParticipantView[];
|
||||
teams: MatchTeamView[];
|
||||
prizes: string[];
|
||||
notices: string[];
|
||||
schedule: MatchScheduleItemView[];
|
||||
competition?: CompetitionDetailResponse;
|
||||
joined: boolean;
|
||||
createdAt: IsoDateTime;
|
||||
updatedAt: IsoDateTime;
|
||||
}
|
||||
|
||||
export type MatchSummaryResponse = MatchDetailResponse;
|
||||
|
||||
export interface TeamTournamentCodeView {
|
||||
gameSlotId: GameSlotId;
|
||||
seriesId: SeriesId;
|
||||
@@ -87,9 +123,8 @@ export interface TeamCompetitionViewResponse {
|
||||
}
|
||||
|
||||
export interface MatchListResponse {
|
||||
matches: MatchSummaryResponse[];
|
||||
matches: MatchDetailResponse[];
|
||||
total: number;
|
||||
page: number;
|
||||
pageSize: number;
|
||||
totalItems: number;
|
||||
totalPages: number;
|
||||
limit: number;
|
||||
}
|
||||
Reference in new issue
Block a user