Compare commits
82
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
cd1525c87a | ||
|
|
337970a12b | ||
|
|
58e24ccd75 | ||
|
|
827fc5b6b4 | ||
|
|
384d460ad6 | ||
|
|
71085d0ac4 | ||
|
|
904f1fc4a4 | ||
|
|
f526257d9c | ||
|
|
34a47c053e | ||
|
|
e3f39fd8b8 | ||
|
|
4385ba7b8b | ||
|
|
9cd5850d43 | ||
|
|
79534cf43c | ||
|
|
03be85d07b | ||
|
|
d269bdd92b | ||
|
|
2bac89d3dc | ||
|
|
760da1cbea | ||
|
|
ca786fd80a | ||
|
|
ac0d2b53f0 | ||
|
|
a4215f86fb | ||
|
|
a24726d7da | ||
|
|
bb68be14fa | ||
|
|
9e2f2c61e7 | ||
|
|
fd1fa2366c | ||
|
|
96fede9fe5 | ||
|
|
80fef25af3 | ||
|
|
1f75c6318a | ||
|
|
8ec9edc35f | ||
|
|
61f1db0e6a | ||
|
|
c9140b8622 | ||
|
|
4e10998794 | ||
|
|
b115072005 | ||
|
|
03e88a03bc | ||
|
|
43c25c05cd | ||
|
|
dc77b37494 | ||
|
|
bb32c26694 | ||
|
|
81b951889f | ||
|
|
96bae0ce28 | ||
|
|
a88562b208 | ||
|
|
3bd3120eb1 | ||
|
|
3c60081ece | ||
|
|
aa675199af | ||
|
|
9f698a8fec | ||
|
|
075fb52848 | ||
|
|
738d274095 | ||
|
|
ef47de7e4f | ||
|
|
489d040d8f | ||
|
|
6b1c450752 | ||
|
|
bbcb2f43dc | ||
|
|
a307780752 | ||
|
|
c2f89f9cb2 | ||
|
|
640e593676 | ||
|
|
ee96f8d48b | ||
|
|
683d602d63 | ||
|
|
7ea2002975 | ||
|
|
ec92494211 | ||
|
|
6bddb666fc | ||
|
|
7db97c540b | ||
|
|
6aa2cb9009 | ||
|
|
575cd911cb | ||
|
|
78a2c7cf0d | ||
|
|
0c2c7b59fc | ||
|
|
5049220e03 | ||
|
|
ab9c48b1e6 | ||
|
|
2958106e42 | ||
|
|
ce07bfa0c8 | ||
|
|
4d6fa2625e | ||
|
|
ee4c3eeb27 | ||
|
|
55e5b8df70 | ||
|
|
f3286e7fd1 | ||
|
|
e6e434d13f | ||
|
|
28e9ac1529 | ||
|
|
874d785381 | ||
|
|
0c31a78df0 | ||
|
|
3b274b4ec2 | ||
|
|
59b9ef79e5 | ||
|
|
5d4fe443d0 | ||
|
|
39112ff7ff | ||
|
|
2135af7107 | ||
|
|
05a83db886 | ||
|
|
f4ba3d524f | ||
|
|
c155f26272 |
No files matched your search
@@ -0,0 +1,4 @@
|
||||
[mcp_servers.playwright_macos]
|
||||
url = "http://100.96.0.26:8931/mcp"
|
||||
tool_timeout_sec = 120
|
||||
startup_timeout_sec = 30
|
||||
@@ -26,6 +26,10 @@ website/LICENSE
|
||||
*.md
|
||||
!README.md
|
||||
!AGENTS.md
|
||||
!docs/specs/internal-match-game-analysis.md
|
||||
!docs/plans/internal-match-game-analysis-p0-p1.md
|
||||
!docs/specs/double-elimination-connector-routing.md
|
||||
!docs/plans/double-elimination-connector-routing.md
|
||||
!agents/**/*.md
|
||||
!skills/**/*.md
|
||||
/tmp/
|
||||
|
||||
+8
-3
@@ -1,11 +1,11 @@
|
||||
# syntax=docker/dockerfile:1.7
|
||||
|
||||
FROM node:24-bookworm-slim AS pnpm-base
|
||||
FROM node:26-bookworm-slim AS pnpm-base
|
||||
|
||||
ENV PNPM_HOME=/pnpm
|
||||
ENV PATH="${PNPM_HOME}:${PATH}"
|
||||
|
||||
RUN corepack enable
|
||||
RUN npm install --global pnpm@10.4.1
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
@@ -14,20 +14,23 @@ FROM pnpm-base AS deps
|
||||
COPY package.json pnpm-lock.yaml pnpm-workspace.yaml ./
|
||||
COPY apps/api/package.json apps/api/package.json
|
||||
COPY apps/web/package.json apps/web/package.json
|
||||
COPY packages/contracts/package.json packages/contracts/package.json
|
||||
|
||||
RUN pnpm install --frozen-lockfile --filter api... --filter lolympus-tournament-support
|
||||
|
||||
FROM deps AS build
|
||||
|
||||
COPY packages/contracts packages/contracts
|
||||
COPY apps/api apps/api
|
||||
|
||||
RUN pnpm --filter api build
|
||||
RUN pnpm --filter api... build
|
||||
|
||||
FROM pnpm-base AS prod-deps
|
||||
|
||||
COPY package.json pnpm-lock.yaml pnpm-workspace.yaml ./
|
||||
COPY apps/api/package.json apps/api/package.json
|
||||
COPY apps/web/package.json apps/web/package.json
|
||||
COPY packages/contracts/package.json packages/contracts/package.json
|
||||
|
||||
RUN pnpm install --prod --frozen-lockfile --filter api... --filter lolympus-tournament-support
|
||||
|
||||
@@ -41,6 +44,8 @@ COPY --from=prod-deps --chown=nonroot:nonroot /app/package.json ./package.json
|
||||
COPY --from=prod-deps --chown=nonroot:nonroot /app/node_modules ./node_modules
|
||||
COPY --from=prod-deps --chown=nonroot:nonroot /app/apps/api/package.json ./apps/api/package.json
|
||||
COPY --from=prod-deps --chown=nonroot:nonroot /app/apps/api/node_modules ./apps/api/node_modules
|
||||
COPY --from=build --chown=nonroot:nonroot /app/packages/contracts/package.json ./packages/contracts/package.json
|
||||
COPY --from=build --chown=nonroot:nonroot /app/packages/contracts/dist ./packages/contracts/dist
|
||||
COPY --chown=nonroot:nonroot apps/api/newrelic.cjs ./apps/api/newrelic.cjs
|
||||
COPY --from=build --chown=nonroot:nonroot /app/apps/api/dist ./apps/api/dist
|
||||
COPY --chown=nonroot:nonroot apps/project.env ./project.env
|
||||
|
||||
@@ -29,7 +29,28 @@ export default tseslint.config(
|
||||
'@typescript-eslint/no-explicit-any': 'off',
|
||||
'@typescript-eslint/no-floating-promises': 'warn',
|
||||
'@typescript-eslint/no-unsafe-argument': 'warn',
|
||||
"prettier/prettier": ["error", { endOfLine: "auto" }],
|
||||
'prettier/prettier': ['error', { endOfLine: 'auto' }],
|
||||
},
|
||||
},
|
||||
{
|
||||
files: ['**/*.spec.ts', 'test/**/*.ts'],
|
||||
rules: {
|
||||
'@typescript-eslint/no-unsafe-assignment': 'off',
|
||||
'@typescript-eslint/no-unsafe-call': 'off',
|
||||
'@typescript-eslint/no-unsafe-member-access': 'off',
|
||||
'@typescript-eslint/no-unsafe-return': 'off',
|
||||
'@typescript-eslint/no-this-alias': 'off',
|
||||
'@typescript-eslint/require-await': 'off',
|
||||
'@typescript-eslint/unbound-method': 'off',
|
||||
},
|
||||
},
|
||||
{
|
||||
files: ['src/modules/global/database/migrations/**/*.ts'],
|
||||
rules: {
|
||||
'@typescript-eslint/no-unsafe-assignment': 'off',
|
||||
'@typescript-eslint/no-unsafe-call': 'off',
|
||||
'@typescript-eslint/no-unsafe-member-access': 'off',
|
||||
'@typescript-eslint/no-unsafe-return': 'off',
|
||||
},
|
||||
},
|
||||
);
|
||||
+11
-9
@@ -8,6 +8,7 @@
|
||||
"scripts": {
|
||||
"build": "nest build",
|
||||
"format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
|
||||
"competition:migrate": "ts-node src/modules/global/database/migrations/run-competition-domain.ts",
|
||||
"seed:dev": "ts-node src/seed.ts",
|
||||
"seed:dakao-participant": "ts-node src/seed-dakao-participant.ts",
|
||||
"start:dev": "NODE_ENV=dev NEW_RELIC_HOME=. node --import newrelic/esm-loader.mjs -r newrelic dist/main.js",
|
||||
@@ -27,20 +28,21 @@
|
||||
"test:e2e": "jest --config ./test/jest-e2e.json"
|
||||
},
|
||||
"dependencies": {
|
||||
"@nestjs/common": "^11.0.1",
|
||||
"@lolympus/contracts": "workspace:*",
|
||||
"@nestjs/common": "^11.1.28",
|
||||
"@nestjs/config": "^4.0.4",
|
||||
"@nestjs/core": "^11.0.1",
|
||||
"@nestjs/platform-express": "^11.0.1",
|
||||
"@nestjs/platform-socket.io": "^11.1.19",
|
||||
"@nestjs/swagger": "^11.2.7",
|
||||
"@nestjs/websockets": "^11.1.19",
|
||||
"@nestjs/core": "^11.1.28",
|
||||
"@nestjs/platform-express": "^11.1.28",
|
||||
"@nestjs/platform-socket.io": "^11.1.28",
|
||||
"@nestjs/swagger": "^11.4.6",
|
||||
"@nestjs/websockets": "^11.1.28",
|
||||
"@socket.io/redis-adapter": "^8.3.0",
|
||||
"class-transformer": "^0.5.1",
|
||||
"class-validator": "^0.15.1",
|
||||
"jose": "^6.2.2",
|
||||
"mongoose": "^9.4.1",
|
||||
"mongoose": "9.4.1",
|
||||
"nats": "^2.29.3",
|
||||
"newrelic": "^14.1.2",
|
||||
"newrelic": "^14.3.3",
|
||||
"redis": "^5.12.1",
|
||||
"reflect-metadata": "^0.2.2",
|
||||
"rxjs": "^7.8.1",
|
||||
@@ -55,7 +57,7 @@
|
||||
"@nestjs/testing": "^11.0.1",
|
||||
"@types/express": "^5.0.0",
|
||||
"@types/jest": "^30.0.0",
|
||||
"@types/node": "^24.0.0",
|
||||
"@types/node": "^26.1.1",
|
||||
"@types/supertest": "^7.0.0",
|
||||
"eslint": "^9.18.0",
|
||||
"eslint-config-prettier": "^10.0.1",
|
||||
|
||||
@@ -8,6 +8,7 @@ import { AuctionModule } from './modules/auction/auction.module';
|
||||
import { AuthModule } from './modules/auth/auth.module';
|
||||
import { CommunityModule } from './modules/community/community.module';
|
||||
import { CommunityStatsModule } from './modules/community-stats/community-stats.module';
|
||||
import { CompetitionModule } from './modules/competition/competition.module';
|
||||
import { DakaoModule } from './modules/dakao/dakao.module';
|
||||
import { GlobalModule } from './modules/global/global.module';
|
||||
import { LegacyImportModule } from './modules/legacy-import/legacy-import.module';
|
||||
@@ -31,6 +32,7 @@ import { UserModule } from './modules/user/user.module';
|
||||
BackgroundRefreshModule,
|
||||
CommunityModule,
|
||||
CommunityStatsModule,
|
||||
CompetitionModule,
|
||||
MatchModule,
|
||||
MatchHistoryModule,
|
||||
LegacyImportModule,
|
||||
|
||||
@@ -18,7 +18,14 @@ async function bootstrap() {
|
||||
app.enableCors({
|
||||
origin: createCorsOrigin(nodeEnv),
|
||||
credentials: true,
|
||||
allowedHeaders: ['Authorization', 'Content-Type', 'X-Auth-User-Id'],
|
||||
allowedHeaders: [
|
||||
'Authorization',
|
||||
'Content-Type',
|
||||
'X-Auth-User-Id',
|
||||
'If-Match',
|
||||
'Idempotency-Key',
|
||||
],
|
||||
exposedHeaders: ['ETag'],
|
||||
});
|
||||
app.useGlobalPipes(
|
||||
new ValidationPipe({
|
||||
|
||||
@@ -79,7 +79,9 @@ describe('AuctionDeadlineScheduler', () => {
|
||||
.spyOn(scheduler, 'processDueBidRoundDeadlines')
|
||||
.mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 });
|
||||
|
||||
await (scheduler as unknown as { safeTick: () => Promise<void> }).safeTick();
|
||||
await (
|
||||
scheduler as unknown as { safeTick: () => Promise<void> }
|
||||
).safeTick();
|
||||
|
||||
const leaderLockToken = redis.acquireTokenLock.mock.calls[0]?.[1];
|
||||
expect(redis.acquireTokenLock).toHaveBeenCalledWith(
|
||||
@@ -100,7 +102,9 @@ describe('AuctionDeadlineScheduler', () => {
|
||||
.spyOn(scheduler, 'processDueBidRoundDeadlines')
|
||||
.mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 });
|
||||
|
||||
await (scheduler as unknown as { safeTick: () => Promise<void> }).safeTick();
|
||||
await (
|
||||
scheduler as unknown as { safeTick: () => Promise<void> }
|
||||
).safeTick();
|
||||
|
||||
expect(processDueBidRoundDeadlinesSpy).not.toHaveBeenCalled();
|
||||
expect(redis.releaseTokenLock).not.toHaveBeenCalled();
|
||||
@@ -129,10 +133,12 @@ describe('AuctionDeadlineScheduler', () => {
|
||||
it('prepares and completes due auction deadlines', async () => {
|
||||
const matchId = '665f2f01f1f1f1f1f1f1f1f1';
|
||||
const completedState = { phase: 'passed', revision: 3 };
|
||||
const { auctionService, eventBus, redisCommand, scheduler } = makeScheduler({
|
||||
dueReply: [matchId],
|
||||
completedState,
|
||||
});
|
||||
const { auctionService, eventBus, redisCommand, scheduler } = makeScheduler(
|
||||
{
|
||||
dueReply: [matchId],
|
||||
completedState,
|
||||
},
|
||||
);
|
||||
|
||||
await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({
|
||||
completed: 1,
|
||||
@@ -149,7 +155,10 @@ describe('AuctionDeadlineScheduler', () => {
|
||||
expect(auctionService.completePreparedExpiry).toHaveBeenCalledTimes(1);
|
||||
// 만료 확정 결과는 즉시 1차 broadcast돼야 한다(클라가 입찰 라운드에 멈춰
|
||||
// 후속 액션에서 CONFLICT가 반복되는 것을 막는 핵심 동작).
|
||||
expect(eventBus.broadcastState).toHaveBeenCalledWith(matchId, completedState);
|
||||
expect(eventBus.broadcastState).toHaveBeenCalledWith(
|
||||
matchId,
|
||||
completedState,
|
||||
);
|
||||
});
|
||||
|
||||
it('skips noop expiry preparations', async () => {
|
||||
@@ -189,10 +198,7 @@ describe('AuctionDeadlineScheduler', () => {
|
||||
});
|
||||
|
||||
it('continues processing later deadline items after one item fails', async () => {
|
||||
const matchIds = [
|
||||
'665f2f01f1f1f1f1f1f1f1f1',
|
||||
'665f2f02f1f1f1f1f1f1f1f1',
|
||||
];
|
||||
const matchIds = ['665f2f01f1f1f1f1f1f1f1f1', '665f2f02f1f1f1f1f1f1f1f1'];
|
||||
const { auctionService, redisCommand, scheduler } = makeScheduler({
|
||||
dueReply: matchIds,
|
||||
});
|
||||
|
||||
@@ -101,15 +101,17 @@ export class AuctionDeadlineScheduler implements OnModuleInit, OnModuleDestroy {
|
||||
currentRedisTimestampMS: number,
|
||||
batchLimit: number,
|
||||
): Promise<string[]> {
|
||||
const reply = await this.auctionRedisService.raw().sendCommand([
|
||||
'ZRANGEBYSCORE',
|
||||
BID_ROUND_DEADLINE_QUEUE_KEY,
|
||||
'-inf',
|
||||
String(currentRedisTimestampMS),
|
||||
'LIMIT',
|
||||
'0',
|
||||
String(batchLimit),
|
||||
]);
|
||||
const reply = await this.auctionRedisService
|
||||
.raw()
|
||||
.sendCommand([
|
||||
'ZRANGEBYSCORE',
|
||||
BID_ROUND_DEADLINE_QUEUE_KEY,
|
||||
'-inf',
|
||||
String(currentRedisTimestampMS),
|
||||
'LIMIT',
|
||||
'0',
|
||||
String(batchLimit),
|
||||
]);
|
||||
return Array.isArray(reply) ? reply.map(String) : [];
|
||||
}
|
||||
|
||||
@@ -177,11 +179,11 @@ export class AuctionDeadlineScheduler implements OnModuleInit, OnModuleDestroy {
|
||||
return { completed, prepared, skipped };
|
||||
}
|
||||
|
||||
private async removeBidRoundDeadlineQueueEntry(matchId: string): Promise<void> {
|
||||
await this.auctionRedisService.raw().sendCommand([
|
||||
'ZREM',
|
||||
BID_ROUND_DEADLINE_QUEUE_KEY,
|
||||
matchId,
|
||||
]);
|
||||
private async removeBidRoundDeadlineQueueEntry(
|
||||
matchId: string,
|
||||
): Promise<void> {
|
||||
await this.auctionRedisService
|
||||
.raw()
|
||||
.sendCommand(['ZREM', BID_ROUND_DEADLINE_QUEUE_KEY, matchId]);
|
||||
}
|
||||
}
|
||||
@@ -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 =
|
||||
|
||||
@@ -20,9 +20,8 @@ export class AuctionEventBusService {
|
||||
}
|
||||
|
||||
public broadcastState(matchId: string, state: AuctionStateResponse): void {
|
||||
this.auctionNamespace?.to(matchId).emit(
|
||||
'state',
|
||||
serializeRealtimeAuction(state),
|
||||
);
|
||||
this.auctionNamespace
|
||||
?.to(matchId)
|
||||
.emit('state', serializeRealtimeAuction(state));
|
||||
}
|
||||
}
|
||||
@@ -74,13 +74,11 @@ function serializeRealtimeAuctionPlayer(
|
||||
return player;
|
||||
}
|
||||
|
||||
const {
|
||||
masteries: _masteries,
|
||||
puuid: _puuid,
|
||||
recentStatsSummary: _recentStatsSummary,
|
||||
tierHistory: _tierHistory,
|
||||
...lightweightPlayer
|
||||
} = player;
|
||||
const lightweightPlayer = { ...player };
|
||||
delete lightweightPlayer.masteries;
|
||||
delete lightweightPlayer.puuid;
|
||||
delete lightweightPlayer.recentStatsSummary;
|
||||
delete lightweightPlayer.tierHistory;
|
||||
|
||||
return lightweightPlayer;
|
||||
}
|
||||
|
||||
@@ -22,7 +22,10 @@ describe('resolveAuctionRejectionReason', () => {
|
||||
|
||||
it('maps known BadRequest messages without a structured code', () => {
|
||||
expect(
|
||||
resolveAuctionRejectionReason(undefined, 'Cannot advance from current phase.'),
|
||||
resolveAuctionRejectionReason(
|
||||
undefined,
|
||||
'Cannot advance from current phase.',
|
||||
),
|
||||
).toBe(
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE,
|
||||
);
|
||||
|
||||
@@ -41,22 +41,24 @@ export class AuctionSideEffectService {
|
||||
matchSideEffectStatus: AuctionMatchSideEffectStatus;
|
||||
}): Promise<boolean> {
|
||||
const keys = buildAuctionRedisKeys(params.matchId);
|
||||
const result = await this.auctionRedisService.raw().sendCommand([
|
||||
'EVAL',
|
||||
[
|
||||
"if redis.call('HGET', KEYS[1], 'auctionLifecycleId') ~= ARGV[1] then return 0 end",
|
||||
"local currentRevision = tonumber(redis.call('HGET', KEYS[1], 'matchSideEffectRevision') or '-1')",
|
||||
'local nextRevision = tonumber(ARGV[2])',
|
||||
'if currentRevision >= nextRevision then return 0 end',
|
||||
"redis.call('HSET', KEYS[1], 'matchSideEffectRevision', ARGV[2], 'matchSideEffectStatus', ARGV[3])",
|
||||
'return 1',
|
||||
].join('\n'),
|
||||
'1',
|
||||
keys.liveStateKey,
|
||||
params.auctionLifecycleId,
|
||||
String(params.matchSideEffectRevision),
|
||||
params.matchSideEffectStatus,
|
||||
]);
|
||||
const result = await this.auctionRedisService
|
||||
.raw()
|
||||
.sendCommand([
|
||||
'EVAL',
|
||||
[
|
||||
"if redis.call('HGET', KEYS[1], 'auctionLifecycleId') ~= ARGV[1] then return 0 end",
|
||||
"local currentRevision = tonumber(redis.call('HGET', KEYS[1], 'matchSideEffectRevision') or '-1')",
|
||||
'local nextRevision = tonumber(ARGV[2])',
|
||||
'if currentRevision >= nextRevision then return 0 end',
|
||||
"redis.call('HSET', KEYS[1], 'matchSideEffectRevision', ARGV[2], 'matchSideEffectStatus', ARGV[3])",
|
||||
'return 1',
|
||||
].join('\n'),
|
||||
'1',
|
||||
keys.liveStateKey,
|
||||
params.auctionLifecycleId,
|
||||
String(params.matchSideEffectRevision),
|
||||
params.matchSideEffectStatus,
|
||||
]);
|
||||
return Number(result) === 1;
|
||||
}
|
||||
}
|
||||
@@ -78,8 +80,7 @@ export function canAcquireSideEffectLease(
|
||||
if (state.state === 'pending' || state.state === 'failed') return true;
|
||||
if (state.state !== 'processing') return false;
|
||||
return (
|
||||
(state.processingLeaseExpiresAtTimestampMS ?? 0) <=
|
||||
currentRedisTimestampMS
|
||||
(state.processingLeaseExpiresAtTimestampMS ?? 0) <= currentRedisTimestampMS
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
@@ -59,8 +59,7 @@ export class AuctionController {
|
||||
initialTeamBidPointAmount: c.initialTeamBidPointAmount,
|
||||
})),
|
||||
initialTeamBidPointAmount: body.initialTeamBidPointAmount ?? 1000,
|
||||
maximumBidRoundDurationSeconds:
|
||||
body.maximumBidRoundDurationSeconds ?? 30,
|
||||
maximumBidRoundDurationSeconds: body.maximumBidRoundDurationSeconds ?? 30,
|
||||
bidRoundExtensionSeconds: body.bidRoundExtensionSeconds ?? 5,
|
||||
topTierAuctionPriorityThreshold:
|
||||
body.topTierAuctionPriorityThreshold ?? 'NONE',
|
||||
|
||||
@@ -13,7 +13,7 @@ import {
|
||||
} from '@nestjs/websockets';
|
||||
import mongoose from 'mongoose';
|
||||
import type { JWTPayload } from 'jose';
|
||||
import { Namespace, Socket } from 'socket.io';
|
||||
import type { DefaultEventsMap, Namespace, Socket } from 'socket.io';
|
||||
import { AuthService } from '../auth/auth.service';
|
||||
import { IdentityService } from '../auth/identity.service';
|
||||
import { JwtService } from '../auth/jwt.service';
|
||||
@@ -78,6 +78,20 @@ interface BidRateLimitState {
|
||||
windowStartedAtTimestampMS: number;
|
||||
}
|
||||
|
||||
interface AuctionSocketData {
|
||||
auctionBidRateLimit?: BidRateLimitState;
|
||||
identity?: IdentityDocument;
|
||||
matchId?: string;
|
||||
user?: UserDocument;
|
||||
}
|
||||
|
||||
type AuctionSocket = Socket<
|
||||
DefaultEventsMap,
|
||||
DefaultEventsMap,
|
||||
DefaultEventsMap,
|
||||
AuctionSocketData
|
||||
>;
|
||||
|
||||
const BID_RATE_LIMIT_WINDOW_MS = 1000;
|
||||
const BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW = 8;
|
||||
const BID_RATE_LIMIT_REJECTION_CODE = 'BID_RATE_LIMITED';
|
||||
@@ -92,9 +106,7 @@ const BID_RATE_LIMIT_REJECTION_MESSAGE =
|
||||
allowedHeaders: ['Authorization', 'Content-Type', 'X-Auth-User-Id'],
|
||||
},
|
||||
})
|
||||
export class AuctionGateway
|
||||
implements OnGatewayConnection, OnGatewayInit
|
||||
{
|
||||
export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
|
||||
@WebSocketServer()
|
||||
private server!: Namespace;
|
||||
|
||||
@@ -114,14 +126,14 @@ export class AuctionGateway
|
||||
this.auctionEventBusService.attachAuctionNamespace(server);
|
||||
}
|
||||
|
||||
public async handleConnection(socket: Socket) {
|
||||
public async handleConnection(socket: AuctionSocket) {
|
||||
try {
|
||||
await this.authenticateSocket(socket);
|
||||
this.logger.debug(`Auction client connected: ${socket.id}`);
|
||||
} catch (err) {
|
||||
this.logger.warn(
|
||||
`Auction client authentication failed: ${
|
||||
err instanceof Error ? err.message : err
|
||||
err instanceof Error ? err.message : String(err)
|
||||
}`,
|
||||
);
|
||||
socket.disconnect(true);
|
||||
@@ -130,7 +142,7 @@ export class AuctionGateway
|
||||
|
||||
@SubscribeMessage('join')
|
||||
public async handleJoin(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@ConnectedSocket() socket: AuctionSocket,
|
||||
@MessageBody() payload: JoinAuctionPayload,
|
||||
) {
|
||||
if (!payload?.matchId || !mongoose.isValidObjectId(payload.matchId)) {
|
||||
@@ -158,7 +170,7 @@ export class AuctionGateway
|
||||
|
||||
@SubscribeMessage('bid')
|
||||
public async handleBid(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@ConnectedSocket() socket: AuctionSocket,
|
||||
@MessageBody() payload: BidPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
@@ -205,7 +217,9 @@ export class AuctionGateway
|
||||
ack?.({
|
||||
...(bidDelta
|
||||
? {}
|
||||
: { state: this.serializeAuction(bidResult as AuctionStateResponse) }),
|
||||
: {
|
||||
state: this.serializeAuction(bidResult as AuctionStateResponse),
|
||||
}),
|
||||
ok: true,
|
||||
bidRequestId,
|
||||
bidDelta: broadcastBidDelta,
|
||||
@@ -220,7 +234,12 @@ export class AuctionGateway
|
||||
error,
|
||||
);
|
||||
const bidServerTiming = this.extractBidServerTiming(rejectionAckFields);
|
||||
this.emitError(socket, String(rejectionAckFields.message ?? ''));
|
||||
this.emitError(
|
||||
socket,
|
||||
typeof rejectionAckFields.message === 'string'
|
||||
? rejectionAckFields.message
|
||||
: '',
|
||||
);
|
||||
ack?.({
|
||||
...rejectionAckFields,
|
||||
bidRequestId,
|
||||
@@ -263,7 +282,7 @@ export class AuctionGateway
|
||||
|
||||
@SubscribeMessage('open-bidding')
|
||||
public async handleOpenBidding(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@ConnectedSocket() socket: AuctionSocket,
|
||||
@MessageBody() payload: AuctionActionPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
@@ -292,7 +311,7 @@ export class AuctionGateway
|
||||
|
||||
@SubscribeMessage('sold')
|
||||
public async handleSold(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@ConnectedSocket() socket: AuctionSocket,
|
||||
@MessageBody() payload: SoldPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
@@ -322,7 +341,7 @@ export class AuctionGateway
|
||||
|
||||
@SubscribeMessage('next')
|
||||
public async handleNext(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@ConnectedSocket() socket: AuctionSocket,
|
||||
@MessageBody() payload: AuctionActionPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
@@ -351,7 +370,7 @@ export class AuctionGateway
|
||||
|
||||
@SubscribeMessage('passed')
|
||||
public async handlePassed(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@ConnectedSocket() socket: AuctionSocket,
|
||||
@MessageBody() payload: AuctionActionPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
@@ -380,7 +399,7 @@ export class AuctionGateway
|
||||
|
||||
@SubscribeMessage('chat-message')
|
||||
public async handleChatMessage(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@ConnectedSocket() socket: AuctionSocket,
|
||||
@MessageBody() payload: ChatMessagePayload,
|
||||
) {
|
||||
const matchId = this.requireJoinedMatchId(socket);
|
||||
@@ -406,7 +425,7 @@ export class AuctionGateway
|
||||
}
|
||||
}
|
||||
|
||||
private requireJoinedMatchId(socket: Socket): string | null {
|
||||
private requireJoinedMatchId(socket: AuctionSocket): string | null {
|
||||
const matchId = this.getSocketMatchId(socket);
|
||||
if (!matchId) {
|
||||
this.emitError(socket, 'Join a match room before sending events.');
|
||||
@@ -415,10 +434,9 @@ export class AuctionGateway
|
||||
return matchId;
|
||||
}
|
||||
|
||||
private consumeBidRateLimit(socket: Socket): boolean {
|
||||
private consumeBidRateLimit(socket: AuctionSocket): boolean {
|
||||
const currentTimestampMS = Date.now();
|
||||
const previousState = socket.data
|
||||
.auctionBidRateLimit as BidRateLimitState | undefined;
|
||||
const previousState = socket.data.auctionBidRateLimit;
|
||||
if (
|
||||
!previousState ||
|
||||
currentTimestampMS - previousState.windowStartedAtTimestampMS >=
|
||||
@@ -436,10 +454,8 @@ export class AuctionGateway
|
||||
return previousState.count <= BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW;
|
||||
}
|
||||
|
||||
private getSocketMatchId(socket: Socket): string | undefined {
|
||||
return typeof socket.data.matchId === 'string'
|
||||
? socket.data.matchId
|
||||
: undefined;
|
||||
private getSocketMatchId(socket: AuctionSocket): string | undefined {
|
||||
return socket.data.matchId;
|
||||
}
|
||||
|
||||
private toAuctionActionRequest(payload?: AuctionActionPayload) {
|
||||
@@ -463,8 +479,9 @@ export class AuctionGateway
|
||||
};
|
||||
}
|
||||
|
||||
private readHandshakeUserId(socket: Socket): string | undefined {
|
||||
const authUserId = socket.handshake.auth['x-auth-user-id'];
|
||||
private readHandshakeUserId(socket: AuctionSocket): string | undefined {
|
||||
const handshakeAuth = socket.handshake.auth as Record<string, unknown>;
|
||||
const authUserId = handshakeAuth['x-auth-user-id'];
|
||||
if (typeof authUserId === 'string') return authUserId;
|
||||
|
||||
const header = socket.handshake.headers['x-auth-user-id'];
|
||||
@@ -472,16 +489,16 @@ export class AuctionGateway
|
||||
}
|
||||
|
||||
private resolveSocketUserId(
|
||||
socket: Socket,
|
||||
socket: AuctionSocket,
|
||||
): mongoose.Types.ObjectId | undefined {
|
||||
return (socket.data.user as UserDocument | undefined)?._id;
|
||||
return socket.data.user?._id;
|
||||
}
|
||||
|
||||
private resolveChatDisplayName(
|
||||
socket: Socket,
|
||||
socket: AuctionSocket,
|
||||
fallbackDisplayName?: string,
|
||||
): string {
|
||||
const user = socket.data.user as UserDocument | undefined;
|
||||
const user = socket.data.user;
|
||||
const primaryRiotAccount =
|
||||
user?.riotAccounts.find((entry) => entry.isPrimary) ??
|
||||
user?.riotAccounts[0];
|
||||
@@ -494,14 +511,14 @@ export class AuctionGateway
|
||||
if (user?.kakaoTalkNickname) return user.kakaoTalkNickname;
|
||||
if (user?.discordNickname) return user.discordNickname;
|
||||
|
||||
const identity = socket.data.identity as IdentityDocument | undefined;
|
||||
const identity = socket.data.identity;
|
||||
if (identity?.displayName) return identity.displayName;
|
||||
if (identity?.email) return identity.email;
|
||||
|
||||
return fallbackDisplayName ?? '관전자';
|
||||
}
|
||||
|
||||
private async authenticateSocket(socket: Socket): Promise<void> {
|
||||
private async authenticateSocket(socket: AuctionSocket): Promise<void> {
|
||||
const fallback = await this.authService.resolveDevUserById(
|
||||
this.readHandshakeUserId(socket),
|
||||
);
|
||||
@@ -531,14 +548,20 @@ export class AuctionGateway
|
||||
});
|
||||
}
|
||||
|
||||
private readHandshakeToken(socket: Socket): string | undefined {
|
||||
const authToken = socket.handshake.auth.token;
|
||||
private readHandshakeToken(socket: AuctionSocket): string | undefined {
|
||||
const handshakeAuth = socket.handshake.auth as Record<string, unknown>;
|
||||
const authToken = handshakeAuth.token;
|
||||
if (typeof authToken === 'string' && authToken.trim()) {
|
||||
return authToken.trim().replace(/^Bearer\s+/i, '');
|
||||
}
|
||||
|
||||
const header = socket.handshake.headers.authorization;
|
||||
const authorization = Array.isArray(header) ? header[0] : header;
|
||||
const header: unknown = socket.handshake.headers.authorization;
|
||||
const authorization =
|
||||
typeof header === 'string'
|
||||
? header
|
||||
: Array.isArray(header) && typeof header[0] === 'string'
|
||||
? header[0]
|
||||
: undefined;
|
||||
if (authorization?.startsWith('Bearer ')) {
|
||||
return authorization.slice('Bearer '.length).trim();
|
||||
}
|
||||
@@ -546,10 +569,11 @@ export class AuctionGateway
|
||||
}
|
||||
|
||||
private async resolveSocketUserForMatch(
|
||||
socket: Socket,
|
||||
socket: AuctionSocket,
|
||||
matchId: string,
|
||||
): Promise<void> {
|
||||
if (socket.data.user || !socket.data.identity) return;
|
||||
const identity = socket.data.identity;
|
||||
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const match = await MatchModel.findById(matchId).select({
|
||||
@@ -558,10 +582,11 @@ export class AuctionGateway
|
||||
if (!match) return;
|
||||
|
||||
const UserModel = await this.connectionService.getModel('user');
|
||||
socket.data.user = await UserModel.findOne({
|
||||
const user = await UserModel.findOne({
|
||||
communityId: match.communityId,
|
||||
identityId: (socket.data.identity as IdentityDocument)._id,
|
||||
identityId: identity._id,
|
||||
}).exec();
|
||||
socket.data.user = user ?? undefined;
|
||||
}
|
||||
|
||||
private requireStringClaim(payload: JWTPayload, key: string): string {
|
||||
@@ -595,7 +620,7 @@ export class AuctionGateway
|
||||
this.server.to(matchId).emit('match-side-effect', delta);
|
||||
}
|
||||
|
||||
private emitChatHistory(socket: Socket, auction: AuctionDocument) {
|
||||
private emitChatHistory(socket: AuctionSocket, auction: AuctionDocument) {
|
||||
socket.emit('chat-history', {
|
||||
messages: (auction.chatMessages ?? []).map((message) =>
|
||||
this.serializeChatMessage(message),
|
||||
@@ -603,16 +628,21 @@ export class AuctionGateway
|
||||
});
|
||||
}
|
||||
|
||||
private emitKnownError(socket: Socket, error: unknown) {
|
||||
private emitKnownError(socket: AuctionSocket, error: unknown) {
|
||||
this.emitError(socket, this.resolveErrorPayload(error).message);
|
||||
}
|
||||
|
||||
private emitError(socket: Socket, message: string) {
|
||||
private emitError(socket: AuctionSocket, message: string) {
|
||||
socket.emit('error', { message });
|
||||
}
|
||||
|
||||
private serializeAuction(auction: AuctionStateResponse) {
|
||||
return JSON.parse(JSON.stringify(auction));
|
||||
private serializeAuction(
|
||||
auction: AuctionStateResponse,
|
||||
): Record<string, unknown> {
|
||||
const serialized: unknown = JSON.parse(JSON.stringify(auction));
|
||||
return typeof serialized === 'object' && serialized !== null
|
||||
? (serialized as Record<string, unknown>)
|
||||
: {};
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -633,7 +663,9 @@ export class AuctionGateway
|
||||
typeof errorPayload.code === 'string' ? errorPayload.code : undefined,
|
||||
errorPayload.message,
|
||||
);
|
||||
const resyncRecommended = isAuctionResyncRecommended(auctionRejectionReason);
|
||||
const resyncRecommended = isAuctionResyncRecommended(
|
||||
auctionRejectionReason,
|
||||
);
|
||||
const state = resyncRecommended
|
||||
? await this.fetchSerializedAuctionState(matchId)
|
||||
: undefined;
|
||||
@@ -688,7 +720,9 @@ export class AuctionGateway
|
||||
return {
|
||||
code: error instanceof Error ? error.message : 'UNKNOWN',
|
||||
message:
|
||||
error instanceof Error ? error.message : 'Unexpected auction gateway error.',
|
||||
error instanceof Error
|
||||
? error.message
|
||||
: 'Unexpected auction gateway error.',
|
||||
};
|
||||
}
|
||||
|
||||
@@ -716,7 +750,8 @@ export class AuctionGateway
|
||||
bidDelta: Record<string, unknown> | null,
|
||||
): Record<string, unknown> | null {
|
||||
if (!bidDelta || !('bidServerTiming' in bidDelta)) return bidDelta;
|
||||
const { bidServerTiming: _bidServerTiming, ...publicBidDelta } = bidDelta;
|
||||
const publicBidDelta = { ...bidDelta };
|
||||
delete publicBidDelta.bidServerTiming;
|
||||
return publicBidDelta;
|
||||
}
|
||||
|
||||
@@ -724,7 +759,7 @@ export class AuctionGateway
|
||||
auction: AuctionStateResponse,
|
||||
bidRequestId?: string,
|
||||
): Record<string, unknown> | null {
|
||||
const serialized = this.serializeAuction(auction) as Record<string, unknown>;
|
||||
const serialized = this.serializeAuction(auction);
|
||||
const revision = Number(serialized.revision);
|
||||
const currentHighestBidPointAmount = Number(
|
||||
serialized.currentHighestBidPointAmount ?? serialized.currentBid,
|
||||
@@ -739,11 +774,13 @@ export class AuctionGateway
|
||||
? Date.parse(serialized.currentDeadline)
|
||||
: 0),
|
||||
);
|
||||
const redisBidHistory = Array.isArray(serialized.auctionBidHistory)
|
||||
? serialized.auctionBidHistory
|
||||
const redisBidHistory: unknown[] = Array.isArray(
|
||||
serialized.auctionBidHistory,
|
||||
)
|
||||
? (serialized.auctionBidHistory as unknown[])
|
||||
: [];
|
||||
const legacyBidHistory = Array.isArray(serialized.bids)
|
||||
? serialized.bids
|
||||
const legacyBidHistory: unknown[] = Array.isArray(serialized.bids)
|
||||
? (serialized.bids as unknown[])
|
||||
: [];
|
||||
const auctionBidHistoryEntry =
|
||||
redisBidHistory[redisBidHistory.length - 1] ??
|
||||
@@ -775,9 +812,7 @@ export class AuctionGateway
|
||||
};
|
||||
}
|
||||
|
||||
private isBidDeltaResponse(
|
||||
value: unknown,
|
||||
): value is AuctionBidDeltaResponse {
|
||||
private isBidDeltaResponse(value: unknown): value is AuctionBidDeltaResponse {
|
||||
return (
|
||||
typeof value === 'object' &&
|
||||
value !== null &&
|
||||
@@ -804,7 +839,12 @@ export class AuctionGateway
|
||||
};
|
||||
}
|
||||
|
||||
private serializeChatMessage(message: AuctionChatMessage) {
|
||||
return JSON.parse(JSON.stringify(message));
|
||||
private serializeChatMessage(
|
||||
message: AuctionChatMessage,
|
||||
): Record<string, unknown> {
|
||||
const serialized: unknown = JSON.parse(JSON.stringify(message));
|
||||
return typeof serialized === 'object' && serialized !== null
|
||||
? (serialized as Record<string, unknown>)
|
||||
: {};
|
||||
}
|
||||
}
|
||||
@@ -2,6 +2,30 @@ import mongoose from 'mongoose';
|
||||
import { AuctionService } from './auction.service';
|
||||
|
||||
describe('AuctionService', () => {
|
||||
function requireRecord(
|
||||
value: unknown,
|
||||
label: string,
|
||||
): Record<string, unknown> {
|
||||
if (!value || typeof value !== 'object' || Array.isArray(value)) {
|
||||
throw new Error(`${label} must be an object.`);
|
||||
}
|
||||
return value as Record<string, unknown>;
|
||||
}
|
||||
|
||||
function requireArray(value: unknown, label: string): unknown[] {
|
||||
if (!Array.isArray(value)) {
|
||||
throw new Error(`${label} must be an array.`);
|
||||
}
|
||||
return value as unknown[];
|
||||
}
|
||||
|
||||
function parseJsonRecord(value: unknown, label: string) {
|
||||
if (typeof value !== 'string') {
|
||||
throw new Error(`${label} must be a JSON string.`);
|
||||
}
|
||||
return requireRecord(JSON.parse(value) as unknown, label);
|
||||
}
|
||||
|
||||
function createService(models: Record<string, unknown>) {
|
||||
const auctionHistoryModel = {
|
||||
findOne: jest.fn().mockReturnValue({
|
||||
@@ -158,12 +182,11 @@ describe('AuctionService', () => {
|
||||
it('rejects non-positive or fractional bid amounts before loading auction state', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const auctionFindOne = jest.fn();
|
||||
const { service, auctionRedisCommandService, auctionRedisService } =
|
||||
createService({
|
||||
auction: {
|
||||
findOne: auctionFindOne,
|
||||
},
|
||||
});
|
||||
const { service, auctionRedisCommandService } = createService({
|
||||
auction: {
|
||||
findOne: auctionFindOne,
|
||||
},
|
||||
});
|
||||
|
||||
await expect(
|
||||
service.placeBid({
|
||||
@@ -1008,7 +1031,12 @@ describe('AuctionService', () => {
|
||||
);
|
||||
const transitionInput =
|
||||
auctionRedisCommandService.applyTransition.mock.calls[0][1];
|
||||
expect(JSON.parse(transitionInput.durabilityPayloadJson)).toMatchObject({
|
||||
expect(
|
||||
parseJsonRecord(
|
||||
transitionInput.durabilityPayloadJson,
|
||||
'durabilityPayloadJson',
|
||||
),
|
||||
).toMatchObject({
|
||||
afterAuctionMongoProjection: expect.objectContaining({
|
||||
phase: 'bidding',
|
||||
revision: 2,
|
||||
@@ -1179,17 +1207,40 @@ describe('AuctionService', () => {
|
||||
|
||||
const transitionInput =
|
||||
auctionRedisCommandService.applyTransition.mock.calls[0][1];
|
||||
const durabilityPayload = JSON.parse(transitionInput.durabilityPayloadJson);
|
||||
expect(durabilityPayload.snapshotBefore).toMatchObject({
|
||||
const durabilityPayload = parseJsonRecord(
|
||||
transitionInput.durabilityPayloadJson,
|
||||
'durabilityPayloadJson',
|
||||
);
|
||||
const snapshotBefore = requireRecord(
|
||||
durabilityPayload.snapshotBefore,
|
||||
'snapshotBefore',
|
||||
);
|
||||
const snapshotBeforeTeams = requireArray(
|
||||
snapshotBefore.auctionTeams,
|
||||
'snapshotBefore.auctionTeams',
|
||||
);
|
||||
const snapshotBeforeTeam = requireRecord(
|
||||
snapshotBeforeTeams[0],
|
||||
'snapshotBefore.auctionTeams[0]',
|
||||
);
|
||||
const afterAuctionMongoProjection = requireRecord(
|
||||
durabilityPayload.afterAuctionMongoProjection,
|
||||
'afterAuctionMongoProjection',
|
||||
);
|
||||
const projectedTeams = requireArray(
|
||||
afterAuctionMongoProjection.auctionTeams,
|
||||
'afterAuctionMongoProjection.auctionTeams',
|
||||
);
|
||||
const projectedTeam = requireRecord(
|
||||
projectedTeams[0],
|
||||
'afterAuctionMongoProjection.auctionTeams[0]',
|
||||
);
|
||||
expect(snapshotBefore).toMatchObject({
|
||||
phase: 'bidding',
|
||||
revision: 4,
|
||||
});
|
||||
expect(durabilityPayload.snapshotBefore.auctionTeams[0].members).toEqual(
|
||||
[],
|
||||
);
|
||||
expect(
|
||||
durabilityPayload.afterAuctionMongoProjection.auctionTeams[0].members,
|
||||
).toEqual([
|
||||
expect(snapshotBeforeTeam.members).toEqual([]);
|
||||
expect(projectedTeam.members).toEqual([
|
||||
expect.objectContaining({
|
||||
memberAcquisitionBidPointAmount: 120,
|
||||
userId: playerUserId.toString(),
|
||||
@@ -1397,7 +1448,12 @@ describe('AuctionService', () => {
|
||||
});
|
||||
const [, transitionInput] =
|
||||
auctionRedisCommandService.applyTransition.mock.calls.at(-1) ?? [];
|
||||
expect(JSON.parse(transitionInput.durabilityPayloadJson)).toMatchObject({
|
||||
expect(
|
||||
parseJsonRecord(
|
||||
transitionInput.durabilityPayloadJson,
|
||||
'durabilityPayloadJson',
|
||||
),
|
||||
).toMatchObject({
|
||||
afterAuctionMongoProjection: {
|
||||
matchSideEffectStatus: 'pending',
|
||||
phase: 'complete',
|
||||
@@ -2072,13 +2128,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 +2234,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();
|
||||
@@ -2515,7 +2624,10 @@ describe('AuctionService', () => {
|
||||
durationSeconds: 30,
|
||||
mode: 'set-relative',
|
||||
});
|
||||
const durabilityPayload = JSON.parse(transitionInput.durabilityPayloadJson);
|
||||
const durabilityPayload = parseJsonRecord(
|
||||
transitionInput.durabilityPayloadJson,
|
||||
'durabilityPayloadJson',
|
||||
);
|
||||
expect(durabilityPayload).toMatchObject({
|
||||
auctionActionType: 'undo',
|
||||
historyMutation: {
|
||||
|
||||
@@ -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)
|
||||
}`,
|
||||
);
|
||||
}
|
||||
|
||||
@@ -210,21 +210,25 @@ describe('AuctionRedisCommandService', () => {
|
||||
|
||||
it('parses apply transition replay and rejected replies', async () => {
|
||||
await expect(
|
||||
makeService(['REPLAY', 'APPLIED', 'transition-1', '2100'])
|
||||
.service.applyTransition('match-1', {
|
||||
afterAuctionStructureStateJson: '{}',
|
||||
auctionHistorySequence: 5,
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
broadcastStateRevision: 11,
|
||||
deadline: { mode: 'none' },
|
||||
durabilityPayloadJson: '{}',
|
||||
expectedPhase: 'sold',
|
||||
expectedRevision: 10,
|
||||
liveStatePatch: {},
|
||||
matchId: 'match-1',
|
||||
shouldBroadcastState: false,
|
||||
}),
|
||||
makeService([
|
||||
'REPLAY',
|
||||
'APPLIED',
|
||||
'transition-1',
|
||||
'2100',
|
||||
]).service.applyTransition('match-1', {
|
||||
afterAuctionStructureStateJson: '{}',
|
||||
auctionHistorySequence: 5,
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
broadcastStateRevision: 11,
|
||||
deadline: { mode: 'none' },
|
||||
durabilityPayloadJson: '{}',
|
||||
expectedPhase: 'sold',
|
||||
expectedRevision: 10,
|
||||
liveStatePatch: {},
|
||||
matchId: 'match-1',
|
||||
shouldBroadcastState: false,
|
||||
}),
|
||||
).resolves.toEqual({
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
currentServerTimestampMS: 2100,
|
||||
@@ -233,21 +237,25 @@ describe('AuctionRedisCommandService', () => {
|
||||
});
|
||||
|
||||
await expect(
|
||||
makeService(['REJECTED', 'CONFLICT', 'transition-1', '2200'])
|
||||
.service.applyTransition('match-1', {
|
||||
afterAuctionStructureStateJson: '{}',
|
||||
auctionHistorySequence: 5,
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
broadcastStateRevision: 11,
|
||||
deadline: { mode: 'none' },
|
||||
durabilityPayloadJson: '{}',
|
||||
expectedPhase: 'sold',
|
||||
expectedRevision: 10,
|
||||
liveStatePatch: {},
|
||||
matchId: 'match-1',
|
||||
shouldBroadcastState: false,
|
||||
}),
|
||||
makeService([
|
||||
'REJECTED',
|
||||
'CONFLICT',
|
||||
'transition-1',
|
||||
'2200',
|
||||
]).service.applyTransition('match-1', {
|
||||
afterAuctionStructureStateJson: '{}',
|
||||
auctionHistorySequence: 5,
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
broadcastStateRevision: 11,
|
||||
deadline: { mode: 'none' },
|
||||
durabilityPayloadJson: '{}',
|
||||
expectedPhase: 'sold',
|
||||
expectedRevision: 10,
|
||||
liveStatePatch: {},
|
||||
matchId: 'match-1',
|
||||
shouldBroadcastState: false,
|
||||
}),
|
||||
).resolves.toEqual({
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
code: 'CONFLICT',
|
||||
@@ -288,12 +296,17 @@ describe('AuctionRedisCommandService', () => {
|
||||
|
||||
it('parses expire prepare replay and noop replies', async () => {
|
||||
await expect(
|
||||
makeService(['REPLAY', 'passed', 'expire-1', '12', '3100'])
|
||||
.service.expirePrepare('match-1', {
|
||||
auctionStateTransitionId: 'expire-1',
|
||||
bidRoundExpiryRetryDelayMS: 3000,
|
||||
matchId: 'match-1',
|
||||
}),
|
||||
makeService([
|
||||
'REPLAY',
|
||||
'passed',
|
||||
'expire-1',
|
||||
'12',
|
||||
'3100',
|
||||
]).service.expirePrepare('match-1', {
|
||||
auctionStateTransitionId: 'expire-1',
|
||||
bidRoundExpiryRetryDelayMS: 3000,
|
||||
matchId: 'match-1',
|
||||
}),
|
||||
).resolves.toMatchObject({
|
||||
auctionStateTransitionId: 'expire-1',
|
||||
bidRoundExpiryDecision: 'passed',
|
||||
@@ -360,16 +373,19 @@ describe('AuctionRedisCommandService', () => {
|
||||
});
|
||||
|
||||
await expect(
|
||||
makeService(['REJECTED', 'INVALID_PATCH_ARITY', '4200'])
|
||||
.service.hydrateState('match-1', {
|
||||
auctionHistorySequence: 3,
|
||||
auctionLifecycleId: 'life-1',
|
||||
maximumBidRoundDurationSeconds: 30,
|
||||
matchId: 'match-1',
|
||||
phase: 'presenting',
|
||||
revision: 6,
|
||||
structureStateJson: '{}',
|
||||
}),
|
||||
makeService([
|
||||
'REJECTED',
|
||||
'INVALID_PATCH_ARITY',
|
||||
'4200',
|
||||
]).service.hydrateState('match-1', {
|
||||
auctionHistorySequence: 3,
|
||||
auctionLifecycleId: 'life-1',
|
||||
maximumBidRoundDurationSeconds: 30,
|
||||
matchId: 'match-1',
|
||||
phase: 'presenting',
|
||||
revision: 6,
|
||||
structureStateJson: '{}',
|
||||
}),
|
||||
).resolves.toEqual({
|
||||
code: 'INVALID_PATCH_ARITY',
|
||||
currentServerTimestampMS: 4200,
|
||||
|
||||
@@ -85,7 +85,9 @@ export function stringifyAuctionRedisStructureState(
|
||||
return JSON.stringify(buildAuctionRedisStructureState(input));
|
||||
}
|
||||
|
||||
function countAuctionTeamMembersIncludingCaptain(team: RedisAuctionTeam): number {
|
||||
function countAuctionTeamMembersIncludingCaptain(
|
||||
team: RedisAuctionTeam,
|
||||
): number {
|
||||
const userIds = new Set<string>([team.captainUserId.toString()]);
|
||||
for (const member of team.members) {
|
||||
userIds.add(member.userId.toString());
|
||||
|
||||
@@ -1,7 +1,10 @@
|
||||
import { AuctionRedisService } from './auction-redis.service';
|
||||
import { AuctionRedisStateReaderService } from './auction-redis-state-reader.service';
|
||||
|
||||
function makeService(commandReplies: unknown[], currentServerTimestampMS = 1000) {
|
||||
function makeService(
|
||||
commandReplies: unknown[],
|
||||
currentServerTimestampMS = 1000,
|
||||
) {
|
||||
const sendCommand = jest
|
||||
.fn()
|
||||
.mockImplementation(() => Promise.resolve(commandReplies.shift()));
|
||||
@@ -149,7 +152,9 @@ describe('AuctionRedisStateReaderService', () => {
|
||||
[],
|
||||
]);
|
||||
|
||||
await expect(service.readAuctionStateView('match-1')).resolves.toMatchObject({
|
||||
await expect(
|
||||
service.readAuctionStateView('match-1'),
|
||||
).resolves.toMatchObject({
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionTeams: [],
|
||||
phase: 'presenting',
|
||||
@@ -181,7 +186,6 @@ describe('AuctionRedisStateReaderService', () => {
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
it('returns null when live or structure state is absent', async () => {
|
||||
await expect(
|
||||
makeService([[], '{"auctionTeams":[]}', []]).service.readAuctionStateView(
|
||||
|
||||
@@ -42,12 +42,14 @@ export class AuctionRedisStateReaderService {
|
||||
matchId: string,
|
||||
): Promise<AuctionRedisLiveStateIdentity | null> {
|
||||
const keys = buildAuctionRedisKeys(matchId);
|
||||
const reply = await this.auctionRedisService.raw().sendCommand([
|
||||
'HMGET',
|
||||
keys.liveStateKey,
|
||||
'auctionLifecycleId',
|
||||
'revision',
|
||||
]);
|
||||
const reply = await this.auctionRedisService
|
||||
.raw()
|
||||
.sendCommand([
|
||||
'HMGET',
|
||||
keys.liveStateKey,
|
||||
'auctionLifecycleId',
|
||||
'revision',
|
||||
]);
|
||||
if (!Array.isArray(reply)) return null;
|
||||
const auctionLifecycleId =
|
||||
typeof reply[0] === 'string' && reply[0] ? reply[0] : undefined;
|
||||
@@ -68,14 +70,16 @@ export class AuctionRedisStateReaderService {
|
||||
): Promise<AuctionRedisBidContext | null> {
|
||||
const keys = buildAuctionRedisKeys(matchId);
|
||||
const bidderTeamCaptainUserIdField = `team:${bidderTeamIndex}:captainUserId`;
|
||||
const liveReply = await this.auctionRedisService.raw().sendCommand([
|
||||
'HMGET',
|
||||
keys.liveStateKey,
|
||||
'phase',
|
||||
'auctionLifecycleId',
|
||||
'currentBidRoundPlayerUserId',
|
||||
bidderTeamCaptainUserIdField,
|
||||
]);
|
||||
const liveReply = await this.auctionRedisService
|
||||
.raw()
|
||||
.sendCommand([
|
||||
'HMGET',
|
||||
keys.liveStateKey,
|
||||
'phase',
|
||||
'auctionLifecycleId',
|
||||
'currentBidRoundPlayerUserId',
|
||||
bidderTeamCaptainUserIdField,
|
||||
]);
|
||||
if (!Array.isArray(liveReply)) return null;
|
||||
|
||||
const phase = stringValue(liveReply[0]);
|
||||
@@ -102,18 +106,23 @@ export class AuctionRedisStateReaderService {
|
||||
options: AuctionRedisStateViewReadOptions = {},
|
||||
): Promise<Record<string, unknown> | null> {
|
||||
const keys = buildAuctionRedisKeys(matchId);
|
||||
const [currentServerTimestampMS, liveReply, structureStateJson, bidEntries] =
|
||||
await Promise.all([
|
||||
this.auctionRedisService.getCurrentRedisTimestampMS(),
|
||||
this.auctionRedisService.raw().sendCommand(['HGETALL', keys.liveStateKey]),
|
||||
this.auctionRedisService.raw().sendCommand(['GET', keys.structureStateKey]),
|
||||
this.auctionRedisService.raw().sendCommand([
|
||||
'LRANGE',
|
||||
keys.bidHistoryKey,
|
||||
'0',
|
||||
'-1',
|
||||
]),
|
||||
]);
|
||||
const [
|
||||
currentServerTimestampMS,
|
||||
liveReply,
|
||||
structureStateJson,
|
||||
bidEntries,
|
||||
] = await Promise.all([
|
||||
this.auctionRedisService.getCurrentRedisTimestampMS(),
|
||||
this.auctionRedisService
|
||||
.raw()
|
||||
.sendCommand(['HGETALL', keys.liveStateKey]),
|
||||
this.auctionRedisService
|
||||
.raw()
|
||||
.sendCommand(['GET', keys.structureStateKey]),
|
||||
this.auctionRedisService
|
||||
.raw()
|
||||
.sendCommand(['LRANGE', keys.bidHistoryKey, '0', '-1']),
|
||||
]);
|
||||
|
||||
const liveState = parseHashReply(liveReply, {
|
||||
includeInternalLiveStateFields:
|
||||
@@ -142,7 +151,7 @@ export class AuctionRedisStateReaderService {
|
||||
revision: number;
|
||||
},
|
||||
shouldForceAuctionStateResync: options.shouldForceAuctionStateResync,
|
||||
structureState: JSON.parse(structureStateJson) as Record<string, unknown>,
|
||||
structureState: parseJsonRecord(structureStateJson),
|
||||
});
|
||||
view.matchId = matchId;
|
||||
if (options.includeInternalLiveStateFields) {
|
||||
@@ -161,12 +170,9 @@ export class AuctionRedisStateReaderService {
|
||||
if (typeof structureStateJson !== 'string' || !structureStateJson) {
|
||||
return undefined;
|
||||
}
|
||||
const structureState = JSON.parse(structureStateJson) as Record<
|
||||
string,
|
||||
unknown
|
||||
>;
|
||||
const auctionTeams = Array.isArray(structureState.auctionTeams)
|
||||
? structureState.auctionTeams
|
||||
const structureState = parseJsonRecord(structureStateJson);
|
||||
const auctionTeams: unknown[] = Array.isArray(structureState.auctionTeams)
|
||||
? (structureState.auctionTeams as unknown[])
|
||||
: [];
|
||||
const bidderTeam = auctionTeams.find((entry) => {
|
||||
if (!entry || typeof entry !== 'object') return false;
|
||||
@@ -183,6 +189,13 @@ function stringValue(value: unknown): string | undefined {
|
||||
return typeof value === 'string' && value ? value : undefined;
|
||||
}
|
||||
|
||||
function parseJsonRecord(json: string): Record<string, unknown> {
|
||||
const value: unknown = JSON.parse(json);
|
||||
return typeof value === 'object' && value !== null
|
||||
? (value as Record<string, unknown>)
|
||||
: {};
|
||||
}
|
||||
|
||||
function parseHashReply(
|
||||
reply: unknown,
|
||||
options: { includeInternalLiveStateFields?: boolean } = {},
|
||||
@@ -210,7 +223,10 @@ function parseHashEntries(
|
||||
): Record<string, unknown> {
|
||||
const result: Record<string, unknown> = {};
|
||||
for (const [field, rawValue] of entries) {
|
||||
if (!options.includeInternalLiveStateFields && isInternalLiveStateField(field)) {
|
||||
if (
|
||||
!options.includeInternalLiveStateFields &&
|
||||
isInternalLiveStateField(field)
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
const value = String(rawValue);
|
||||
|
||||
@@ -91,9 +91,7 @@ describe('auction apply transition redis script contract', () => {
|
||||
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
|
||||
'shouldBroadcastState',
|
||||
);
|
||||
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
|
||||
"redis.call('SADD'",
|
||||
);
|
||||
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain("redis.call('SADD'");
|
||||
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
|
||||
"redis.call('HINCRBY'",
|
||||
);
|
||||
|
||||
@@ -64,9 +64,7 @@ describe('auction bid redis script contract', () => {
|
||||
expect(AUCTION_BID_SCRIPT.lua).toContain("redis.call('TIME')");
|
||||
expect(AUCTION_BID_SCRIPT.lua).toContain("redis.call('HINCRBY'");
|
||||
expect(AUCTION_BID_SCRIPT.lua).toContain('BID_REQUEST_RESULT_LIMIT');
|
||||
expect(AUCTION_BID_SCRIPT.lua).toContain(
|
||||
'currentHighestBidPointAmount',
|
||||
);
|
||||
expect(AUCTION_BID_SCRIPT.lua).toContain('currentHighestBidPointAmount');
|
||||
expect(AUCTION_BID_SCRIPT.lua).not.toContain('cjson.decode');
|
||||
});
|
||||
});
|
||||
@@ -3,9 +3,11 @@ import { buildAuctionRedisKeys } from './auction-redis.keys';
|
||||
describe('auction redis keys', () => {
|
||||
it('builds lifecycle-safe key names from match id', () => {
|
||||
expect(buildAuctionRedisKeys('match-1')).toMatchObject({
|
||||
actionRequestResultOrderKey: 'auction:match-1:auctionActionRequestResultOrder',
|
||||
actionRequestResultOrderKey:
|
||||
'auction:match-1:auctionActionRequestResultOrder',
|
||||
actionRequestResultsKey: 'auction:match-1:auctionActionRequestResults',
|
||||
appliedTransitionIdsKey: 'auction:match-1:appliedAuctionStateTransitionIds',
|
||||
appliedTransitionIdsKey:
|
||||
'auction:match-1:appliedAuctionStateTransitionIds',
|
||||
bidHistoryKey: 'auction:match-1:auctionBidHistory',
|
||||
bidRequestResultOrderKey: 'auction:match-1:bidRequestResultOrder',
|
||||
bidRequestResultsKey: 'auction:match-1:bidRequestResults',
|
||||
|
||||
@@ -74,9 +74,11 @@ async function readFirstSecret(
|
||||
|
||||
const logger = new Logger('AuctionRedisClient');
|
||||
const client = createClient(auctionRedisOptions);
|
||||
client.on('error', (error) => {
|
||||
client.on('error', (error: unknown) => {
|
||||
logger.error(
|
||||
`Auction Redis client error: ${error?.message ?? error}`,
|
||||
`Auction Redis client error: ${
|
||||
error instanceof Error ? error.message : String(error)
|
||||
}`,
|
||||
);
|
||||
});
|
||||
|
||||
|
||||
@@ -15,7 +15,9 @@ function makeService(sendCommand: jest.Mock) {
|
||||
|
||||
describe('AuctionRedisService', () => {
|
||||
it('uses Redis TIME as the timestamp source', async () => {
|
||||
const service = makeService(jest.fn().mockResolvedValue(['1781700000', '123000']));
|
||||
const service = makeService(
|
||||
jest.fn().mockResolvedValue(['1781700000', '123000']),
|
||||
);
|
||||
|
||||
await expect(service.getCurrentRedisTimestampMS()).resolves.toBe(
|
||||
1_781_700_000_123,
|
||||
|
||||
@@ -22,7 +22,11 @@ export class AuctionRedisNoscriptError extends Error {
|
||||
function isNoscriptError(error: unknown): boolean {
|
||||
if (error instanceof AuctionRedisNoscriptError) return true;
|
||||
const message =
|
||||
error instanceof Error ? error.message : typeof error === 'string' ? error : '';
|
||||
error instanceof Error
|
||||
? error.message
|
||||
: typeof error === 'string'
|
||||
? error
|
||||
: '';
|
||||
return /\bNOSCRIPT\b/iu.test(message);
|
||||
}
|
||||
|
||||
@@ -81,9 +85,15 @@ export class AuctionRedisService implements OnModuleDestroy {
|
||||
if (!isNoscriptError(error)) throw error;
|
||||
}
|
||||
|
||||
const loadedSha = String(
|
||||
await this.client.sendCommand(['SCRIPT', 'LOAD', params.script]),
|
||||
);
|
||||
const loadedShaReply = await this.client.sendCommand([
|
||||
'SCRIPT',
|
||||
'LOAD',
|
||||
params.script,
|
||||
]);
|
||||
if (typeof loadedShaReply !== 'string') {
|
||||
throw new Error('Redis SCRIPT LOAD returned a non-string SHA.');
|
||||
}
|
||||
const loadedSha = loadedShaReply;
|
||||
return (await this.client.sendCommand(
|
||||
buildEvalShaCommand(loadedSha, params.keys, params.values),
|
||||
)) as T;
|
||||
@@ -107,7 +117,7 @@ export class AuctionRedisService implements OnModuleDestroy {
|
||||
token: string,
|
||||
ttlMS: number,
|
||||
): Promise<boolean> {
|
||||
const result = await this.client.sendCommand([
|
||||
const result = await this.client.sendCommand<string | null>([
|
||||
'SET',
|
||||
key,
|
||||
token,
|
||||
@@ -115,7 +125,7 @@ export class AuctionRedisService implements OnModuleDestroy {
|
||||
String(ttlMS),
|
||||
'NX',
|
||||
]);
|
||||
return String(result) === 'OK';
|
||||
return result === 'OK';
|
||||
}
|
||||
|
||||
public async releaseTokenLock(key: string, token: string): Promise<boolean> {
|
||||
|
||||
@@ -100,9 +100,7 @@ describe('auction redis state assembly', () => {
|
||||
'1000',
|
||||
]);
|
||||
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain("redis.call('TIME')");
|
||||
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain(
|
||||
'INVALID_PATCH_ARITY',
|
||||
);
|
||||
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain('INVALID_PATCH_ARITY');
|
||||
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain(
|
||||
'mongoRevision > redisRevision',
|
||||
);
|
||||
|
||||
@@ -78,9 +78,7 @@ export function assembleAuctionViewFromRedisState(
|
||||
return {
|
||||
...params.structureState,
|
||||
...params.liveState,
|
||||
auctionBidHistory: params.auctionBidHistoryEntries.map((entry) =>
|
||||
JSON.parse(entry),
|
||||
),
|
||||
auctionBidHistory: params.auctionBidHistoryEntries.map(parseJsonValue),
|
||||
canPlaceBidInCurrentBidRound: !isExpiring,
|
||||
currentServerTimestampMS: params.currentServerTimestampMS,
|
||||
isAuctionStateTransitionInProgress: isExpiring,
|
||||
@@ -90,6 +88,11 @@ export function assembleAuctionViewFromRedisState(
|
||||
};
|
||||
}
|
||||
|
||||
function parseJsonValue(json: string): unknown {
|
||||
const value: unknown = JSON.parse(json);
|
||||
return value;
|
||||
}
|
||||
|
||||
export function buildHydrateAuctionStateScriptInvocation(
|
||||
keys: AuctionRedisKeys,
|
||||
input: HydrateAuctionStateScriptInput,
|
||||
|
||||
@@ -1,8 +1,5 @@
|
||||
import type { JWTHeaderParameters, JWTPayload } from 'jose';
|
||||
import type {
|
||||
IdentityDocument,
|
||||
UserDocument,
|
||||
} from '../global/database/schema';
|
||||
import type { IdentityDocument, UserDocument } from '../global/database/schema';
|
||||
import type { IdentityProviderName } from './jwt.service';
|
||||
|
||||
declare module 'express' {
|
||||
|
||||
@@ -2,10 +2,7 @@ import { Injectable } from '@nestjs/common';
|
||||
import type { Request } from 'express';
|
||||
import mongoose from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import {
|
||||
IdentityDocument,
|
||||
UserDocument,
|
||||
} from '../global/database/schema';
|
||||
import { IdentityDocument, UserDocument } from '../global/database/schema';
|
||||
import { SecretService } from '../global/secret/secret.service';
|
||||
import './auth-request';
|
||||
|
||||
|
||||
@@ -26,8 +26,7 @@ export class JwtAuthGuard implements CanActivate {
|
||||
METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED,
|
||||
[context.getHandler(), context.getClass()],
|
||||
);
|
||||
const authz = request.headers?.authorization;
|
||||
const authzHeader = Array.isArray(authz) ? authz[0] : authz;
|
||||
const authzHeader = request.get('authorization');
|
||||
|
||||
if (!authzHeader) {
|
||||
const fallback =
|
||||
@@ -74,7 +73,7 @@ export class JwtAuthGuard implements CanActivate {
|
||||
|
||||
private pickIdPFromToken(token: string): IdentityProviderName {
|
||||
try {
|
||||
const { iss } = decodeJwt(token) as { iss?: string };
|
||||
const { iss } = decodeJwt(token);
|
||||
if (!iss) {
|
||||
throw new Error('Token has no issuer (iss) claim');
|
||||
}
|
||||
@@ -84,7 +83,8 @@ export class JwtAuthGuard implements CanActivate {
|
||||
}
|
||||
throw new Error(`Unknown issuer: ${iss}`);
|
||||
} catch (err) {
|
||||
const message = err instanceof Error ? err.message : 'Unable to decode token';
|
||||
const message =
|
||||
err instanceof Error ? err.message : 'Unable to decode token';
|
||||
throw new UnauthorizedException(message);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -35,11 +35,13 @@ export class JwtService {
|
||||
throw new Error('Empty token');
|
||||
}
|
||||
|
||||
if (identityProvider !== 'MICROSOFT_ENTRAID') {
|
||||
throw new Error(`Identity provider not configured: ${identityProvider}`);
|
||||
const provider =
|
||||
identityProvider === 'MICROSOFT_ENTRAID'
|
||||
? await this.getEntraConfig()
|
||||
: undefined;
|
||||
if (!provider) {
|
||||
throw new Error('Identity provider not configured.');
|
||||
}
|
||||
|
||||
const provider = await this.getEntraConfig();
|
||||
const result = await jwtVerify(token, provider.jwks, {
|
||||
issuer: provider.issuer,
|
||||
audience: provider.audience,
|
||||
@@ -48,14 +50,22 @@ export class JwtService {
|
||||
});
|
||||
|
||||
const { payload, protectedHeader } = result;
|
||||
if (!provider.allowedAlgs.includes(protectedHeader.alg as string)) {
|
||||
if (!provider.allowedAlgs.includes(protectedHeader.alg)) {
|
||||
throw new Error(`Unexpected alg: ${protectedHeader.alg}`);
|
||||
}
|
||||
if (payload.ver && payload.ver !== '2.0') {
|
||||
throw new Error(`Unsupported Entra token version: ${payload.ver}`);
|
||||
if (
|
||||
payload.ver !== undefined &&
|
||||
(typeof payload.ver !== 'string' || payload.ver !== '2.0')
|
||||
) {
|
||||
throw new Error(
|
||||
`Unsupported Entra token version: ${formatClaimValue(payload.ver)}`,
|
||||
);
|
||||
}
|
||||
if (payload.tid && payload.tid !== provider.tenantId) {
|
||||
throw new Error(`Unexpected tenant: ${payload.tid}`);
|
||||
if (
|
||||
payload.tid !== undefined &&
|
||||
(typeof payload.tid !== 'string' || payload.tid !== provider.tenantId)
|
||||
) {
|
||||
throw new Error(`Unexpected tenant: ${formatClaimValue(payload.tid)}`);
|
||||
}
|
||||
|
||||
return result;
|
||||
@@ -98,3 +108,16 @@ export class JwtService {
|
||||
return this.entraConfig;
|
||||
}
|
||||
}
|
||||
|
||||
function formatClaimValue(value: unknown): string {
|
||||
if (
|
||||
typeof value === 'string' ||
|
||||
typeof value === 'number' ||
|
||||
typeof value === 'boolean' ||
|
||||
typeof value === 'bigint'
|
||||
) {
|
||||
return String(value);
|
||||
}
|
||||
if (value === null) return 'null';
|
||||
return JSON.stringify(value) ?? typeof value;
|
||||
}
|
||||
@@ -7,7 +7,7 @@ import {
|
||||
} from '@nestjs/common';
|
||||
import { Reflector } from '@nestjs/core';
|
||||
import type { Request } from 'express';
|
||||
import { CommunityRole, UserDocument } from '../global/database/schema';
|
||||
import type { CommunityRole } from '../global/database/schema';
|
||||
import { ROLES_KEY } from './roles.decorator';
|
||||
import './auth-request';
|
||||
|
||||
@@ -23,7 +23,7 @@ export class RolesGuard implements CanActivate {
|
||||
if (!requiredRoles || requiredRoles.length === 0) return true;
|
||||
|
||||
const req = context.switchToHttp().getRequest<Request>();
|
||||
const user = req.user as UserDocument | undefined;
|
||||
const user = req.user;
|
||||
if (!user && req.identity) {
|
||||
throw new ForbiddenException('No membership in this community.');
|
||||
}
|
||||
|
||||
@@ -7,9 +7,10 @@ import {
|
||||
import mongoose from 'mongoose';
|
||||
|
||||
@Injectable()
|
||||
export class ParseObjectIdPipe
|
||||
implements PipeTransform<string, mongoose.Types.ObjectId>
|
||||
{
|
||||
export class ParseObjectIdPipe implements PipeTransform<
|
||||
string,
|
||||
mongoose.Types.ObjectId
|
||||
> {
|
||||
public transform(
|
||||
value: string,
|
||||
metadata: ArgumentMetadata,
|
||||
|
||||
@@ -34,16 +34,29 @@ export class CommunityStatsCacheService {
|
||||
let deleted = 0;
|
||||
|
||||
do {
|
||||
const reply = (await client.sendCommand([
|
||||
const reply = await client.sendCommand([
|
||||
'SCAN',
|
||||
cursor,
|
||||
'MATCH',
|
||||
match,
|
||||
'COUNT',
|
||||
'100',
|
||||
])) as [string, string[]];
|
||||
cursor = reply[0];
|
||||
const keys = reply[1] ?? [];
|
||||
]);
|
||||
if (!Array.isArray(reply)) {
|
||||
throw new Error('Redis SCAN returned an invalid response.');
|
||||
}
|
||||
const values = reply as unknown[];
|
||||
const nextCursor = values[0];
|
||||
const rawKeys = values[1];
|
||||
if (typeof nextCursor !== 'string') {
|
||||
throw new Error('Redis SCAN returned an invalid cursor.');
|
||||
}
|
||||
cursor = nextCursor;
|
||||
const keys = Array.isArray(rawKeys)
|
||||
? (rawKeys as unknown[]).filter(
|
||||
(key): key is string => typeof key === 'string',
|
||||
)
|
||||
: [];
|
||||
if (keys.length > 0) {
|
||||
deleted += await client.del(keys);
|
||||
}
|
||||
|
||||
@@ -23,7 +23,14 @@ export class CommunityStatsController {
|
||||
) {
|
||||
return this.communityStatsService.getMatches({
|
||||
communityId,
|
||||
filters: this.toFilters({ seasonId, from, to, championId, cursor, limit }),
|
||||
filters: this.toFilters({
|
||||
seasonId,
|
||||
from,
|
||||
to,
|
||||
championId,
|
||||
cursor,
|
||||
limit,
|
||||
}),
|
||||
});
|
||||
}
|
||||
|
||||
@@ -85,7 +92,14 @@ export class CommunityStatsController {
|
||||
return this.communityStatsService.getUserInternalHistory({
|
||||
communityId,
|
||||
userId,
|
||||
filters: this.toFilters({ seasonId, from, to, championId, cursor, limit }),
|
||||
filters: this.toFilters({
|
||||
seasonId,
|
||||
from,
|
||||
to,
|
||||
championId,
|
||||
cursor,
|
||||
limit,
|
||||
}),
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@@ -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 {
|
||||
@@ -79,7 +83,7 @@ function record(matchId: mongoose.Types.ObjectId): InternalRecord {
|
||||
}
|
||||
|
||||
describe('CommunityStatsService', () => {
|
||||
it('ignores stale detail cache entries missing timeline build fields', async () => {
|
||||
it('ignores detail caches missing unified events or containing invalid checkpoints', async () => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const match: InternalMatchCardView = {
|
||||
@@ -93,6 +97,20 @@ describe('CommunityStatsService', () => {
|
||||
seriesResults: [],
|
||||
};
|
||||
const participant = record(matchId);
|
||||
Object.assign(participant, {
|
||||
participantId: 1,
|
||||
checkpoints: {
|
||||
at10: {
|
||||
timestamp: 590,
|
||||
gold: 5_200,
|
||||
cs: 90,
|
||||
xp: 4_200,
|
||||
kills: 1,
|
||||
deaths: 1,
|
||||
assists: 1,
|
||||
},
|
||||
},
|
||||
});
|
||||
const gameDetail: InternalGameDetail = {
|
||||
gameNumber: 1,
|
||||
riotMatchId: 'KR_1',
|
||||
@@ -121,38 +139,81 @@ describe('CommunityStatsService', () => {
|
||||
},
|
||||
],
|
||||
};
|
||||
const staleCache = {
|
||||
match,
|
||||
games: [
|
||||
Object.assign(gameDetail, {
|
||||
timelineEvents: [
|
||||
{
|
||||
gameNumber: 1,
|
||||
riotMatchId: 'KR_1',
|
||||
gameCreation: 1_000,
|
||||
gameDuration: 1_800,
|
||||
teams: [
|
||||
timestamp: 300,
|
||||
side: 'blue',
|
||||
type: 'championKill',
|
||||
killerParticipantId: 1,
|
||||
victimParticipantId: 2,
|
||||
assistingParticipantIds: [],
|
||||
},
|
||||
],
|
||||
});
|
||||
const otherwiseCompleteCachedGame = {
|
||||
gameNumber: 1,
|
||||
riotMatchId: 'KR_1',
|
||||
gameCreation: 1_000,
|
||||
gameDuration: 1_800,
|
||||
timeline: [],
|
||||
objectiveEvents: [],
|
||||
teams: [
|
||||
{
|
||||
teamIndex: 1,
|
||||
side: 'blue' as const,
|
||||
win: true,
|
||||
objectives: objectives(),
|
||||
bans: [],
|
||||
participants: [
|
||||
{
|
||||
teamIndex: 1,
|
||||
side: 'blue',
|
||||
win: true,
|
||||
objectives: { tower: 1, dragon: 0, baron: 0 },
|
||||
participants: [
|
||||
{
|
||||
summonerName: 'Player',
|
||||
perks: {
|
||||
primaryStyle: 8000,
|
||||
subStyle: 8400,
|
||||
keystone: 8010,
|
||||
},
|
||||
},
|
||||
],
|
||||
summonerName: 'Cached Player',
|
||||
tagLine: 'KR1',
|
||||
itemBuild: [],
|
||||
skillBuild: [],
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
};
|
||||
const missingTimelineEventsCache = {
|
||||
match,
|
||||
games: [otherwiseCompleteCachedGame],
|
||||
} as unknown as InternalMatchDetailResponse;
|
||||
const invalidCheckpointCache = {
|
||||
match,
|
||||
games: [
|
||||
{
|
||||
...otherwiseCompleteCachedGame,
|
||||
timelineEvents: [],
|
||||
teams: otherwiseCompleteCachedGame.teams.map((team) => ({
|
||||
...team,
|
||||
participants: team.participants.map((cachedParticipant) => ({
|
||||
...cachedParticipant,
|
||||
participantId: 1,
|
||||
checkpoints: {
|
||||
at10: {
|
||||
timestamp: '590',
|
||||
gold: 5_200,
|
||||
cs: 90,
|
||||
xp: 4_200,
|
||||
kills: 1,
|
||||
deaths: 1,
|
||||
assists: 1,
|
||||
},
|
||||
},
|
||||
})),
|
||||
})),
|
||||
},
|
||||
],
|
||||
} as unknown as InternalMatchDetailResponse;
|
||||
const setDetail = jest.fn().mockResolvedValue(undefined);
|
||||
const cacheService = {
|
||||
get: jest.fn().mockResolvedValue(staleCache),
|
||||
setDetail: jest.fn().mockResolvedValue(undefined),
|
||||
get: jest
|
||||
.fn()
|
||||
.mockResolvedValueOnce(missingTimelineEventsCache)
|
||||
.mockResolvedValueOnce(invalidCheckpointCache),
|
||||
setDetail,
|
||||
} as unknown as jest.Mocked<CommunityStatsCacheService>;
|
||||
const matchStatsService = {
|
||||
buildAndUpsert: jest.fn().mockResolvedValue(undefined),
|
||||
@@ -176,22 +237,245 @@ describe('CommunityStatsService', () => {
|
||||
detailsByMatchId: new Map([[matchId.toString(), [gameDetail]]]),
|
||||
});
|
||||
|
||||
const response = await service.getMatchDetail({ communityId, matchId });
|
||||
const missingEventsResponse = await service.getMatchDetail({
|
||||
communityId,
|
||||
matchId,
|
||||
});
|
||||
const invalidCheckpointResponse = await service.getMatchDetail({
|
||||
communityId,
|
||||
matchId,
|
||||
});
|
||||
|
||||
expect(response.games[0].timeline).toHaveLength(1);
|
||||
expect(response.games[0].teams[0].participants[0].itemBuild).toHaveLength(
|
||||
1,
|
||||
);
|
||||
expect(response.games[0].teams[0].participants[0].perks).toMatchObject({
|
||||
selectedPerkIds: [8010, 9111, 9105, 8299, 8444, 8451],
|
||||
expect(missingEventsResponse.games[0].timeline).toHaveLength(1);
|
||||
expect(invalidCheckpointResponse.games[0].timeline).toHaveLength(1);
|
||||
expect(invalidCheckpointResponse.games[0]).toMatchObject({
|
||||
timelineEvents: [
|
||||
{
|
||||
timestamp: 300,
|
||||
side: 'blue',
|
||||
type: 'championKill',
|
||||
},
|
||||
],
|
||||
});
|
||||
expect(
|
||||
invalidCheckpointResponse.games[0].teams[0].participants[0],
|
||||
).toMatchObject({
|
||||
participantId: 1,
|
||||
checkpoints: {
|
||||
at10: {
|
||||
timestamp: 590,
|
||||
gold: 5_200,
|
||||
cs: 90,
|
||||
xp: 4_200,
|
||||
kills: 1,
|
||||
deaths: 1,
|
||||
assists: 1,
|
||||
},
|
||||
},
|
||||
itemBuild: [{ timestamp: 10, itemId: 1054, type: 'purchased' }],
|
||||
perks: {
|
||||
selectedPerkIds: [8010, 9111, 9105, 8299, 8444, 8451],
|
||||
},
|
||||
});
|
||||
expect(matchStatsService.buildAndUpsert).not.toHaveBeenCalled();
|
||||
expect(cacheService.setDetail).toHaveBeenCalledWith(
|
||||
expect.stringContaining(':r3:'),
|
||||
response,
|
||||
expect(setDetail).toHaveBeenCalledTimes(2);
|
||||
expect(setDetail).toHaveBeenNthCalledWith(
|
||||
2,
|
||||
expect.stringContaining(':r4:'),
|
||||
invalidCheckpointResponse,
|
||||
);
|
||||
});
|
||||
|
||||
it('backs off failed timeline hydration and retries after the short cache expires', async () => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const match: InternalMatchCardView = {
|
||||
matchId: matchId.toString(),
|
||||
title: '내전',
|
||||
scheduledAt: '2026-06-18T12:00:00.000Z',
|
||||
status: 'finished',
|
||||
gameCount: 1,
|
||||
games: [],
|
||||
teams: [],
|
||||
seriesResults: [],
|
||||
};
|
||||
const participant = record(matchId);
|
||||
const gameDetail: InternalGameDetail = {
|
||||
gameNumber: 1,
|
||||
riotMatchId: 'KR_1',
|
||||
gameCreation: 1_000,
|
||||
gameDuration: 1_800,
|
||||
winnerSide: 'blue',
|
||||
timelineLoaded: false,
|
||||
timeline: [],
|
||||
objectiveEvents: [],
|
||||
timelineEvents: [],
|
||||
teams: [
|
||||
{
|
||||
teamIndex: 1,
|
||||
side: 'blue',
|
||||
win: true,
|
||||
objectives: objectives(),
|
||||
bans: [],
|
||||
participants: [participant],
|
||||
},
|
||||
],
|
||||
};
|
||||
const dataset = (timelineLoaded: boolean) => ({
|
||||
season: {
|
||||
id: 'all',
|
||||
label: '전체',
|
||||
startTime: null,
|
||||
endTime: null,
|
||||
},
|
||||
matches: [match],
|
||||
records: [participant],
|
||||
detailsByMatchId: new Map([
|
||||
[matchId.toString(), [{ ...gameDetail, timelineLoaded }]],
|
||||
]),
|
||||
});
|
||||
let cachedResponse: InternalMatchDetailResponse | null = null;
|
||||
const set = jest
|
||||
.fn()
|
||||
.mockImplementation(
|
||||
(_key: string, value: InternalMatchDetailResponse) => {
|
||||
cachedResponse = value;
|
||||
return Promise.resolve();
|
||||
},
|
||||
);
|
||||
const setDetail = jest
|
||||
.fn()
|
||||
.mockImplementation(
|
||||
(_key: string, value: InternalMatchDetailResponse) => {
|
||||
cachedResponse = value;
|
||||
return Promise.resolve();
|
||||
},
|
||||
);
|
||||
const cacheService = {
|
||||
get: jest.fn().mockImplementation(() => Promise.resolve(cachedResponse)),
|
||||
set,
|
||||
setDetail,
|
||||
} as unknown as jest.Mocked<CommunityStatsCacheService>;
|
||||
const buildAndUpsert = jest.fn().mockResolvedValue(undefined);
|
||||
const service = new CommunityStatsService(
|
||||
{} as ConnectionService,
|
||||
cacheService,
|
||||
{} as MatchStatsRepository,
|
||||
{ buildAndUpsert } as unknown as MatchStatsService,
|
||||
);
|
||||
(service as unknown as { buildBaseDataset: jest.Mock }).buildBaseDataset =
|
||||
jest
|
||||
.fn()
|
||||
.mockResolvedValueOnce(dataset(false))
|
||||
.mockResolvedValueOnce(dataset(false))
|
||||
.mockResolvedValueOnce(dataset(false))
|
||||
.mockResolvedValueOnce(dataset(true));
|
||||
|
||||
const fallback = await service.getMatchDetail({ communityId, matchId });
|
||||
const backedOff = await service.getMatchDetail({ communityId, matchId });
|
||||
|
||||
expect(backedOff).toBe(fallback);
|
||||
expect(buildAndUpsert).toHaveBeenCalledTimes(1);
|
||||
expect(set).toHaveBeenCalledWith(
|
||||
expect.stringContaining(':r4:'),
|
||||
fallback,
|
||||
60,
|
||||
);
|
||||
expect(setDetail).not.toHaveBeenCalled();
|
||||
|
||||
cachedResponse = null;
|
||||
const recovered = await service.getMatchDetail({ communityId, matchId });
|
||||
|
||||
expect(buildAndUpsert).toHaveBeenCalledTimes(2);
|
||||
expect(setDetail).toHaveBeenCalledTimes(1);
|
||||
expect(setDetail).toHaveBeenCalledWith(
|
||||
expect.stringContaining(':r4:'),
|
||||
recovered,
|
||||
);
|
||||
});
|
||||
|
||||
it('coalesces concurrent internal match detail cache misses', async () => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const match: InternalMatchCardView = {
|
||||
matchId: matchId.toString(),
|
||||
title: '내전',
|
||||
scheduledAt: '2026-06-18T12:00:00.000Z',
|
||||
status: 'finished',
|
||||
gameCount: 1,
|
||||
games: [],
|
||||
teams: [],
|
||||
seriesResults: [],
|
||||
};
|
||||
const participant = record(matchId);
|
||||
const dataset = {
|
||||
season: {
|
||||
id: 'all',
|
||||
label: '전체',
|
||||
startTime: null,
|
||||
endTime: null,
|
||||
},
|
||||
matches: [match],
|
||||
records: [participant],
|
||||
detailsByMatchId: new Map([
|
||||
[
|
||||
matchId.toString(),
|
||||
[
|
||||
{
|
||||
gameNumber: 1,
|
||||
riotMatchId: 'KR_1',
|
||||
gameCreation: 1_000,
|
||||
gameDuration: 1_800,
|
||||
winnerSide: 'blue' as const,
|
||||
timelineLoaded: true,
|
||||
timeline: [],
|
||||
objectiveEvents: [],
|
||||
timelineEvents: [],
|
||||
teams: [
|
||||
{
|
||||
teamIndex: 1,
|
||||
side: 'blue' as const,
|
||||
win: true,
|
||||
objectives: objectives(),
|
||||
bans: [],
|
||||
participants: [participant],
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
],
|
||||
]),
|
||||
};
|
||||
let resolveDataset: ((value: typeof dataset) => void) | undefined;
|
||||
const datasetPromise = new Promise<typeof dataset>((resolve) => {
|
||||
resolveDataset = resolve;
|
||||
});
|
||||
const setDetail = jest.fn().mockResolvedValue(undefined);
|
||||
const cacheService = {
|
||||
get: jest.fn().mockResolvedValue(null),
|
||||
setDetail,
|
||||
} as unknown as jest.Mocked<CommunityStatsCacheService>;
|
||||
const service = new CommunityStatsService(
|
||||
{} as ConnectionService,
|
||||
cacheService,
|
||||
{} as MatchStatsRepository,
|
||||
{} as MatchStatsService,
|
||||
);
|
||||
const buildBaseDataset = jest.fn().mockReturnValue(datasetPromise);
|
||||
(service as unknown as { buildBaseDataset: jest.Mock }).buildBaseDataset =
|
||||
buildBaseDataset;
|
||||
|
||||
const first = service.getMatchDetail({ communityId, matchId });
|
||||
const second = service.getMatchDetail({ communityId, matchId });
|
||||
await Promise.resolve();
|
||||
resolveDataset?.(dataset);
|
||||
const [firstResponse, secondResponse] = await Promise.all([first, second]);
|
||||
|
||||
expect(firstResponse).toBe(secondResponse);
|
||||
expect(buildBaseDataset).toHaveBeenCalledTimes(1);
|
||||
expect(setDetail).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('includes internal match route fields in user internal history matches', async () => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
@@ -219,8 +503,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 +560,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 +586,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 +620,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);
|
||||
});
|
||||
});
|
||||
@@ -40,7 +40,8 @@ const DEFAULT_LIST_LIMIT = 20;
|
||||
const MAX_LIST_LIMIT = 50;
|
||||
const MAX_MATCH_SCAN = 300;
|
||||
const MIN_HIGHLIGHT_GAMES = 5;
|
||||
const MATCH_DETAIL_RESPONSE_CACHE_VERSION = 3;
|
||||
const MATCH_DETAIL_RESPONSE_CACHE_VERSION = 4;
|
||||
const INCOMPLETE_MATCH_DETAIL_TTL_SECONDS = 60;
|
||||
|
||||
interface CommunityStatsContext {
|
||||
community: CommunityDocument;
|
||||
@@ -59,6 +60,10 @@ interface BaseDataset {
|
||||
@Injectable()
|
||||
export class CommunityStatsService {
|
||||
private readonly logger = new Logger(CommunityStatsService.name);
|
||||
private readonly matchDetailInFlight = new Map<
|
||||
string,
|
||||
Promise<InternalMatchDetailResponse>
|
||||
>();
|
||||
private readonly userInternalHistoryInFlight = new Map<
|
||||
string,
|
||||
Promise<UserInternalHistoryResponse>
|
||||
@@ -219,6 +224,27 @@ export class CommunityStatsService {
|
||||
await this.cacheService.get<InternalMatchDetailResponse>(key);
|
||||
if (cached && isCompleteMatchDetailResponse(cached)) return cached;
|
||||
|
||||
const inFlight = this.matchDetailInFlight.get(key);
|
||||
if (inFlight) return inFlight;
|
||||
|
||||
const promise = this.buildMatchDetailResponse(params, key);
|
||||
this.matchDetailInFlight.set(key, promise);
|
||||
try {
|
||||
return await promise;
|
||||
} finally {
|
||||
if (this.matchDetailInFlight.get(key) === promise) {
|
||||
this.matchDetailInFlight.delete(key);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async buildMatchDetailResponse(
|
||||
params: {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
},
|
||||
key: string,
|
||||
): Promise<InternalMatchDetailResponse> {
|
||||
const dataset = await this.buildBaseDataset(params.communityId, {
|
||||
seasonId: 'all',
|
||||
});
|
||||
@@ -238,60 +264,69 @@ 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 ?? [],
|
||||
timelineEvents: game.timelineEvents ?? 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) => ({
|
||||
participantId: record.participantId,
|
||||
checkpoints: record.checkpoints,
|
||||
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);
|
||||
if (gameDetails.every((game) => game.timelineLoaded === true)) {
|
||||
await this.cacheService.setDetail(key, response);
|
||||
} else {
|
||||
await this.cacheService.set(
|
||||
key,
|
||||
response,
|
||||
INCOMPLETE_MATCH_DETAIL_TTL_SECONDS,
|
||||
);
|
||||
}
|
||||
return response;
|
||||
}
|
||||
|
||||
@@ -357,7 +392,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 +408,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 +442,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 +488,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 +524,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 +540,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 +557,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;
|
||||
}
|
||||
|
||||
@@ -1129,6 +1197,7 @@ function isCompleteMatchDetailResponse(
|
||||
(game) =>
|
||||
Array.isArray(game.timeline) &&
|
||||
Array.isArray(game.objectiveEvents) &&
|
||||
Array.isArray(game.timelineEvents) &&
|
||||
game.teams.every(
|
||||
(team) =>
|
||||
Array.isArray(team.bans) &&
|
||||
@@ -1136,8 +1205,41 @@ function isCompleteMatchDetailResponse(
|
||||
(participant) =>
|
||||
typeof participant.tagLine === 'string' &&
|
||||
Array.isArray(participant.itemBuild) &&
|
||||
Array.isArray(participant.skillBuild),
|
||||
Array.isArray(participant.skillBuild) &&
|
||||
isOptionalFiniteNumber(participant.participantId) &&
|
||||
isCompleteParticipantCheckpoints(participant.checkpoints),
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
function isCompleteParticipantCheckpoints(value: unknown): boolean {
|
||||
if (value === undefined) return true;
|
||||
if (!isRecord(value)) return false;
|
||||
return ['at10', 'at15'].every((key) => {
|
||||
const checkpoint = value[key];
|
||||
if (checkpoint === undefined) return true;
|
||||
if (!isRecord(checkpoint)) return false;
|
||||
return [
|
||||
'timestamp',
|
||||
'gold',
|
||||
'cs',
|
||||
'xp',
|
||||
'kills',
|
||||
'deaths',
|
||||
'assists',
|
||||
].every((field) => isFiniteNumber(checkpoint[field]));
|
||||
});
|
||||
}
|
||||
|
||||
function isOptionalFiniteNumber(value: unknown): boolean {
|
||||
return value === undefined || isFiniteNumber(value);
|
||||
}
|
||||
|
||||
function isFiniteNumber(value: unknown): value is number {
|
||||
return typeof value === 'number' && Number.isFinite(value);
|
||||
}
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return typeof value === 'object' && value !== null && !Array.isArray(value);
|
||||
}
|
||||
@@ -1,11 +1,16 @@
|
||||
import type {
|
||||
MatchStatsParticipantCheckpoints,
|
||||
MatchStatsItemBuildEvent,
|
||||
MatchStatsRunePerks,
|
||||
MatchStatsSkillBuildEvent,
|
||||
MatchStatsTimelineEvent,
|
||||
RiotLane,
|
||||
TeamSide,
|
||||
} from '../global/database/schema';
|
||||
import type { RecentMatchView, HistorySeasonDto } from '../match-history/match-history.types';
|
||||
import type {
|
||||
RecentMatchView,
|
||||
HistorySeasonDto,
|
||||
} from '../match-history/match-history.types';
|
||||
|
||||
export interface CommunityStatsFilters {
|
||||
seasonId?: string;
|
||||
@@ -78,7 +83,9 @@ export interface LeaderboardRow {
|
||||
avgCsPerMin: number;
|
||||
avgDamageShare: number;
|
||||
avgVisionScore: number;
|
||||
byLane: Partial<Record<RiotLane, { games: number; wins: number; kda: number }>>;
|
||||
byLane: Partial<
|
||||
Record<RiotLane, { games: number; wins: number; kda: number }>
|
||||
>;
|
||||
topChampions: Array<{ championId: number; games: number; winRate: number }>;
|
||||
}
|
||||
|
||||
@@ -128,6 +135,7 @@ export interface InternalMatchDetailResponse {
|
||||
type: 'dragon' | 'elderDragon' | 'baron' | 'riftHerald' | 'voidGrub';
|
||||
monsterSubType?: string;
|
||||
}>;
|
||||
timelineEvents: MatchStatsTimelineEvent[];
|
||||
teams: Array<{
|
||||
teamIndex: number;
|
||||
side: TeamSide;
|
||||
@@ -143,6 +151,8 @@ export interface InternalMatchDetailResponse {
|
||||
};
|
||||
bans: Array<{ championId: number; pickTurn: number }>;
|
||||
participants: Array<{
|
||||
participantId?: number;
|
||||
checkpoints?: MatchStatsParticipantCheckpoints;
|
||||
userId: string | null;
|
||||
summonerName: string;
|
||||
tagLine: string;
|
||||
|
||||
@@ -100,6 +100,24 @@ describe('MatchStatsFragmentBuilder', () => {
|
||||
it('builds rich set detail from raw Riot match data', () => {
|
||||
const builder = new MatchStatsFragmentBuilder();
|
||||
const match = makeMatch();
|
||||
const redUserId = new mongoose.Types.ObjectId();
|
||||
match.participants.push({
|
||||
userId: redUserId,
|
||||
puuid: 'puuid-2',
|
||||
gameName: 'Opponent',
|
||||
profileIconId: 8,
|
||||
});
|
||||
match.teams[1].members.push({ userId: redUserId, assignedPosition: 'TOP' });
|
||||
match.result?.games[0].participants.push({
|
||||
userId: redUserId,
|
||||
teamIndex: 2,
|
||||
side: 'red',
|
||||
championId: 24,
|
||||
kills: 1,
|
||||
deaths: 3,
|
||||
assists: 0,
|
||||
win: false,
|
||||
});
|
||||
const raw = {
|
||||
metadata: {
|
||||
dataVersion: '2',
|
||||
@@ -206,6 +224,51 @@ describe('MatchStatsFragmentBuilder', () => {
|
||||
],
|
||||
},
|
||||
};
|
||||
raw.info.participants.push(
|
||||
{
|
||||
...raw.info.participants[0],
|
||||
assists: 0,
|
||||
championId: 24,
|
||||
championName: 'Jax',
|
||||
deaths: 3,
|
||||
kills: 1,
|
||||
participantId: 2,
|
||||
puuid: 'puuid-2',
|
||||
riotIdGameName: 'Opponent',
|
||||
summonerId: 'summoner-2',
|
||||
summonerName: 'Opponent',
|
||||
teamId: 200,
|
||||
win: false,
|
||||
},
|
||||
{
|
||||
...raw.info.participants[0],
|
||||
assists: 2,
|
||||
championId: 64,
|
||||
championName: 'LeeSin',
|
||||
deaths: 0,
|
||||
kills: 1,
|
||||
participantId: 3,
|
||||
puuid: 'puuid-3',
|
||||
riotIdGameName: 'Jungler',
|
||||
summonerId: 'summoner-3',
|
||||
summonerName: 'Jungler',
|
||||
teamId: 100,
|
||||
},
|
||||
);
|
||||
raw.info.teams.push({
|
||||
bans: [],
|
||||
objectives: {
|
||||
baron: { first: false, kills: 0 },
|
||||
champion: { first: false, kills: 3 },
|
||||
dragon: { first: false, kills: 0 },
|
||||
horde: { first: false, kills: 0 },
|
||||
inhibitor: { first: false, kills: 0 },
|
||||
riftHerald: { first: false, kills: 0 },
|
||||
tower: { first: false, kills: 0 },
|
||||
},
|
||||
teamId: 200,
|
||||
win: false,
|
||||
});
|
||||
const timeline = {
|
||||
metadata: {
|
||||
dataVersion: '2',
|
||||
@@ -218,7 +281,20 @@ describe('MatchStatsFragmentBuilder', () => {
|
||||
{
|
||||
timestamp: 0,
|
||||
participantFrames: {
|
||||
'1': { participantId: 1, totalGold: 500, xp: 0 },
|
||||
'1': {
|
||||
participantId: 1,
|
||||
totalGold: 500,
|
||||
xp: 0,
|
||||
minionsKilled: 0,
|
||||
jungleMinionsKilled: 0,
|
||||
},
|
||||
'2': {
|
||||
participantId: 2,
|
||||
totalGold: 500,
|
||||
xp: 0,
|
||||
minionsKilled: 0,
|
||||
jungleMinionsKilled: 0,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
@@ -291,7 +367,137 @@ describe('MatchStatsFragmentBuilder', () => {
|
||||
},
|
||||
],
|
||||
participantFrames: {
|
||||
'1': { participantId: 1, totalGold: 1_150, xp: 550 },
|
||||
'1': {
|
||||
participantId: 1,
|
||||
totalGold: 1_150,
|
||||
xp: 550,
|
||||
minionsKilled: 5,
|
||||
jungleMinionsKilled: 1,
|
||||
},
|
||||
'2': {
|
||||
participantId: 2,
|
||||
totalGold: 1_050,
|
||||
xp: 500,
|
||||
minionsKilled: 4,
|
||||
jungleMinionsKilled: 0,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
timestamp: 540_000,
|
||||
events: [
|
||||
{
|
||||
type: 'CHAMPION_KILL',
|
||||
timestamp: 300_000,
|
||||
killerId: 1,
|
||||
victimId: 2,
|
||||
assistingParticipantIds: [3],
|
||||
},
|
||||
{
|
||||
type: 'CHAMPION_KILL',
|
||||
timestamp: 400_000,
|
||||
killerId: 0,
|
||||
victimId: 1,
|
||||
},
|
||||
{
|
||||
type: 'BUILDING_KILL',
|
||||
timestamp: 450_000,
|
||||
killerId: 0,
|
||||
teamId: 200,
|
||||
buildingType: 'TOWER_BUILDING',
|
||||
towerType: 'OUTER_TURRET',
|
||||
},
|
||||
{
|
||||
type: 'BUILDING_KILL',
|
||||
timestamp: 450_000,
|
||||
killerId: 1,
|
||||
teamId: 200,
|
||||
buildingType: 'INHIBITOR_BUILDING',
|
||||
},
|
||||
{
|
||||
type: 'CHAMPION_KILL',
|
||||
timestamp: 500_000,
|
||||
killerId: 3,
|
||||
victimId: 2,
|
||||
assistingParticipantIds: [1],
|
||||
},
|
||||
],
|
||||
participantFrames: {
|
||||
'1': {
|
||||
participantId: 1,
|
||||
totalGold: 4_900,
|
||||
xp: 3_900,
|
||||
minionsKilled: 72,
|
||||
jungleMinionsKilled: 8,
|
||||
},
|
||||
'2': {
|
||||
participantId: 2,
|
||||
totalGold: 4_300,
|
||||
xp: 3_500,
|
||||
minionsKilled: 68,
|
||||
jungleMinionsKilled: 2,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
timestamp: 590_000,
|
||||
events: [],
|
||||
participantFrames: {
|
||||
'1': {
|
||||
participantId: 1,
|
||||
totalGold: 5_200,
|
||||
xp: 4_200,
|
||||
minionsKilled: 80,
|
||||
jungleMinionsKilled: 10,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
timestamp: 900_000,
|
||||
events: [
|
||||
{
|
||||
type: 'CHAMPION_KILL',
|
||||
timestamp: 900_000,
|
||||
killerId: 1,
|
||||
victimId: 2,
|
||||
assistingParticipantIds: [3],
|
||||
},
|
||||
],
|
||||
participantFrames: {
|
||||
'1': {
|
||||
participantId: 1,
|
||||
totalGold: 8_100,
|
||||
xp: 7_300,
|
||||
minionsKilled: 130,
|
||||
jungleMinionsKilled: 15,
|
||||
},
|
||||
'2': {
|
||||
participantId: 2,
|
||||
totalGold: 6_700,
|
||||
xp: 6_100,
|
||||
minionsKilled: 115,
|
||||
jungleMinionsKilled: 5,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
timestamp: 1_800_000,
|
||||
events: [],
|
||||
participantFrames: {
|
||||
'1': {
|
||||
participantId: 1,
|
||||
totalGold: 12_500,
|
||||
xp: 14_000,
|
||||
minionsKilled: 205,
|
||||
jungleMinionsKilled: 23,
|
||||
},
|
||||
'2': {
|
||||
participantId: 2,
|
||||
totalGold: 10_200,
|
||||
xp: 12_700,
|
||||
minionsKilled: 190,
|
||||
jungleMinionsKilled: 10,
|
||||
},
|
||||
},
|
||||
},
|
||||
],
|
||||
@@ -329,19 +535,105 @@ describe('MatchStatsFragmentBuilder', () => {
|
||||
{
|
||||
timestamp: 0,
|
||||
blue: { gold: 500, xp: 0 },
|
||||
red: { gold: 0, xp: 0 },
|
||||
goldDiff: 500,
|
||||
red: { gold: 500, xp: 0 },
|
||||
goldDiff: 0,
|
||||
xpDiff: 0,
|
||||
},
|
||||
{
|
||||
timestamp: 60,
|
||||
blue: { gold: 1_150, xp: 550 },
|
||||
red: { gold: 1_050, xp: 500 },
|
||||
goldDiff: 100,
|
||||
xpDiff: 50,
|
||||
},
|
||||
{
|
||||
timestamp: 540,
|
||||
blue: { gold: 4_900, xp: 3_900 },
|
||||
red: { gold: 4_300, xp: 3_500 },
|
||||
goldDiff: 600,
|
||||
xpDiff: 400,
|
||||
},
|
||||
{
|
||||
timestamp: 590,
|
||||
blue: { gold: 5_200, xp: 4_200 },
|
||||
red: { gold: 0, xp: 0 },
|
||||
goldDiff: 1_150,
|
||||
xpDiff: 550,
|
||||
goldDiff: 5_200,
|
||||
xpDiff: 4_200,
|
||||
},
|
||||
{
|
||||
timestamp: 900,
|
||||
blue: { gold: 8_100, xp: 7_300 },
|
||||
red: { gold: 6_700, xp: 6_100 },
|
||||
goldDiff: 1_400,
|
||||
xpDiff: 1_200,
|
||||
},
|
||||
{
|
||||
timestamp: 1_800,
|
||||
blue: { gold: 12_500, xp: 14_000 },
|
||||
red: { gold: 10_200, xp: 12_700 },
|
||||
goldDiff: 2_300,
|
||||
xpDiff: 1_300,
|
||||
},
|
||||
],
|
||||
});
|
||||
expect(fragment.gameDetails[0].timelineEvents).toEqual([
|
||||
{
|
||||
timestamp: 20,
|
||||
side: 'blue',
|
||||
type: 'dragon',
|
||||
monsterSubType: 'FIRE_DRAGON',
|
||||
},
|
||||
{
|
||||
timestamp: 30,
|
||||
side: 'blue',
|
||||
type: 'elderDragon',
|
||||
monsterSubType: 'ELDER_DRAGON',
|
||||
},
|
||||
{ timestamp: 40, side: 'blue', type: 'voidGrub' },
|
||||
{ timestamp: 50, side: 'blue', type: 'baron' },
|
||||
{ timestamp: 55, side: 'blue', type: 'riftHerald' },
|
||||
{
|
||||
timestamp: 300,
|
||||
side: 'blue',
|
||||
type: 'championKill',
|
||||
killerParticipantId: 1,
|
||||
victimParticipantId: 2,
|
||||
assistingParticipantIds: [3],
|
||||
},
|
||||
{
|
||||
timestamp: 400,
|
||||
type: 'championKill',
|
||||
victimParticipantId: 1,
|
||||
},
|
||||
{
|
||||
timestamp: 450,
|
||||
side: 'blue',
|
||||
type: 'tower',
|
||||
towerType: 'OUTER_TURRET',
|
||||
},
|
||||
{
|
||||
timestamp: 450,
|
||||
side: 'blue',
|
||||
type: 'inhibitor',
|
||||
killerParticipantId: 1,
|
||||
},
|
||||
{
|
||||
timestamp: 500,
|
||||
side: 'blue',
|
||||
type: 'championKill',
|
||||
killerParticipantId: 3,
|
||||
victimParticipantId: 2,
|
||||
assistingParticipantIds: [1],
|
||||
},
|
||||
{
|
||||
timestamp: 900,
|
||||
side: 'blue',
|
||||
type: 'championKill',
|
||||
killerParticipantId: 1,
|
||||
victimParticipantId: 2,
|
||||
assistingParticipantIds: [3],
|
||||
},
|
||||
]);
|
||||
expect(fragment.gameDetails[0].teams[0].bans).toEqual([
|
||||
{ championId: 14, pickTurn: 1 },
|
||||
{ championId: 43, pickTurn: 2 },
|
||||
@@ -356,6 +648,27 @@ describe('MatchStatsFragmentBuilder', () => {
|
||||
voidGrub: 1,
|
||||
});
|
||||
expect(fragment.records[0]).toMatchObject({
|
||||
participantId: 1,
|
||||
checkpoints: {
|
||||
at10: {
|
||||
timestamp: 590,
|
||||
gold: 5_200,
|
||||
cs: 90,
|
||||
xp: 4_200,
|
||||
kills: 1,
|
||||
deaths: 1,
|
||||
assists: 1,
|
||||
},
|
||||
at15: {
|
||||
timestamp: 900,
|
||||
gold: 8_100,
|
||||
cs: 145,
|
||||
xp: 7_300,
|
||||
kills: 2,
|
||||
deaths: 1,
|
||||
assists: 1,
|
||||
},
|
||||
},
|
||||
championLevel: 15,
|
||||
cs: 228,
|
||||
damageDealtToChampions: 18_765,
|
||||
@@ -392,5 +705,118 @@ describe('MatchStatsFragmentBuilder', () => {
|
||||
{ timestamp: 45, skillSlot: 3, level: 2, levelUpType: 'NORMAL' },
|
||||
],
|
||||
});
|
||||
expect(fragment.records[1]).toMatchObject({
|
||||
participantId: 2,
|
||||
checkpoints: {
|
||||
at15: {
|
||||
timestamp: 900,
|
||||
gold: 6_700,
|
||||
cs: 120,
|
||||
xp: 6_100,
|
||||
kills: 0,
|
||||
deaths: 3,
|
||||
assists: 0,
|
||||
},
|
||||
},
|
||||
});
|
||||
expect(fragment.records[1].checkpoints).not.toHaveProperty('at10');
|
||||
|
||||
const timelineWithoutEvents = {
|
||||
...timeline,
|
||||
info: {
|
||||
...timeline.info,
|
||||
frames: timeline.info.frames.map((frame) => ({
|
||||
...frame,
|
||||
events: [],
|
||||
})),
|
||||
},
|
||||
} as RiotMatchTimelineDto;
|
||||
const objectiveFallback = builder.buildFragment({
|
||||
match,
|
||||
rawByRiotMatchId: new Map([['KR_1', raw as RiotMatchDto]]),
|
||||
timelineByRiotMatchId: new Map([['KR_1', timelineWithoutEvents]]),
|
||||
});
|
||||
expect(objectiveFallback.gameDetails[0].teams[0].objectives).toMatchObject({
|
||||
baron: 1,
|
||||
dragon: 2,
|
||||
elderDragon: 0,
|
||||
riftHerald: 0,
|
||||
voidGrub: 3,
|
||||
});
|
||||
|
||||
const dragonOnlyTimeline = {
|
||||
...timeline,
|
||||
info: {
|
||||
...timeline.info,
|
||||
frames: timeline.info.frames.map((frame) => ({
|
||||
...frame,
|
||||
events: (frame.events ?? []).filter(
|
||||
(event) =>
|
||||
event.type !== 'ELITE_MONSTER_KILL' ||
|
||||
event.monsterType === 'DRAGON',
|
||||
),
|
||||
})),
|
||||
},
|
||||
} as RiotMatchTimelineDto;
|
||||
const partialObjectiveFallback = builder.buildFragment({
|
||||
match,
|
||||
rawByRiotMatchId: new Map([['KR_1', raw as RiotMatchDto]]),
|
||||
timelineByRiotMatchId: new Map([['KR_1', dragonOnlyTimeline]]),
|
||||
});
|
||||
expect(
|
||||
partialObjectiveFallback.gameDetails[0].teams[0].objectives,
|
||||
).toMatchObject({
|
||||
baron: 1,
|
||||
dragon: 1,
|
||||
elderDragon: 1,
|
||||
riftHerald: 0,
|
||||
voidGrub: 3,
|
||||
});
|
||||
|
||||
const shortMatch = {
|
||||
...match,
|
||||
result: {
|
||||
...match.result!,
|
||||
games: match.result!.games.map((game) => ({
|
||||
...game,
|
||||
gameDuration: 599,
|
||||
})),
|
||||
},
|
||||
} as MatchDocument;
|
||||
const shortFragment = builder.buildFragment({
|
||||
match: shortMatch,
|
||||
rawByRiotMatchId: new Map([
|
||||
[
|
||||
'KR_1',
|
||||
{
|
||||
...raw,
|
||||
info: { ...raw.info, gameDuration: 599 },
|
||||
} as RiotMatchDto,
|
||||
],
|
||||
]),
|
||||
timelineByRiotMatchId: new Map([
|
||||
['KR_1', timeline as RiotMatchTimelineDto],
|
||||
]),
|
||||
});
|
||||
expect(
|
||||
shortFragment.records.every((record) => record.checkpoints === undefined),
|
||||
).toBe(true);
|
||||
|
||||
const invalidIntervalTimeline = {
|
||||
...timeline,
|
||||
info: { ...timeline.info, frameInterval: Number.NaN },
|
||||
} as RiotMatchTimelineDto;
|
||||
const invalidIntervalFragment = builder.buildFragment({
|
||||
match,
|
||||
rawByRiotMatchId: new Map([['KR_1', raw as RiotMatchDto]]),
|
||||
timelineByRiotMatchId: new Map([['KR_1', invalidIntervalTimeline]]),
|
||||
});
|
||||
expect(invalidIntervalFragment.gameDetails[0].timelineLoaded).toBe(false);
|
||||
expect(invalidIntervalFragment.gameDetails[0].timeline).toEqual([]);
|
||||
expect(
|
||||
invalidIntervalFragment.records.every(
|
||||
(record) => record.checkpoints === undefined,
|
||||
),
|
||||
).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -3,10 +3,13 @@ import mongoose from 'mongoose';
|
||||
import type {
|
||||
MatchDocument,
|
||||
MatchGameResultParticipant,
|
||||
MatchStatsCheckpoint,
|
||||
MatchStatsItemBuildEvent,
|
||||
MatchStatsObjectiveEvent,
|
||||
MatchStatsObjectiveSummary,
|
||||
MatchStatsParticipantCheckpoints,
|
||||
MatchStatsSkillBuildEvent,
|
||||
MatchStatsTimelineEvent,
|
||||
MatchStatsTimelinePoint,
|
||||
TeamSide,
|
||||
} from '../global/database/schema';
|
||||
@@ -27,13 +30,17 @@ interface ParticipantBuildEvents {
|
||||
skills: MatchStatsSkillBuildEvent[];
|
||||
}
|
||||
|
||||
interface TimelineProjection {
|
||||
objectiveEvents: MatchStatsObjectiveEvent[];
|
||||
timelineEvents: MatchStatsTimelineEvent[];
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class MatchStatsFragmentBuilder {
|
||||
public buildFragment(params: {
|
||||
match: MatchDocument;
|
||||
rawByRiotMatchId: Map<string, RiotMatchDto>;
|
||||
timelineByRiotMatchId?: Map<string, RiotMatchTimelineDto>;
|
||||
timelineLoadAttempted?: boolean;
|
||||
}): MatchStatsFragment {
|
||||
const games = [...(params.match.result?.games ?? [])].sort(
|
||||
(left, right) => left.gameNumber - right.gameNumber,
|
||||
@@ -43,13 +50,7 @@ export class MatchStatsFragmentBuilder {
|
||||
const raw = params.rawByRiotMatchId.get(game.riotMatchId);
|
||||
const timeline = params.timelineByRiotMatchId?.get(game.riotMatchId);
|
||||
return raw
|
||||
? this.toGameDetail(
|
||||
params.match,
|
||||
game,
|
||||
raw,
|
||||
timeline,
|
||||
params.timelineLoadAttempted === true,
|
||||
)
|
||||
? this.toGameDetail(params.match, game, raw, timeline)
|
||||
: this.toFallbackGameDetail(params.match, game);
|
||||
});
|
||||
const records = gameDetails.flatMap((detail) =>
|
||||
@@ -130,8 +131,10 @@ export class MatchStatsFragmentBuilder {
|
||||
game: NonNullable<MatchDocument['result']>['games'][number],
|
||||
raw: RiotMatchDto,
|
||||
timeline?: RiotMatchTimelineDto,
|
||||
timelineLoadAttempted = false,
|
||||
): InternalGameDetail {
|
||||
const usableTimeline = isUsableTimeline(timeline, raw.info.gameDuration)
|
||||
? timeline
|
||||
: undefined;
|
||||
const puuidByUserId = new Map(
|
||||
match.participants
|
||||
.filter((participant) => participant.puuid)
|
||||
@@ -158,14 +161,18 @@ export class MatchStatsFragmentBuilder {
|
||||
raw,
|
||||
rawTeamIdBySide,
|
||||
);
|
||||
const objectiveEvents = this.toObjectiveEvents(
|
||||
timeline,
|
||||
const { objectiveEvents, timelineEvents } = this.toTimelineEvents(
|
||||
usableTimeline,
|
||||
rawTeamIdBySide,
|
||||
sideByParticipantId,
|
||||
);
|
||||
const timelineObjectives = this.toTimelineObjectives(objectiveEvents);
|
||||
const buildEventsByParticipantId =
|
||||
this.toBuildEventsByParticipantId(timeline);
|
||||
this.toBuildEventsByParticipantId(usableTimeline);
|
||||
const checkpointsByParticipantId = this.toCheckpointsByParticipantId(
|
||||
usableTimeline,
|
||||
raw.info.gameDuration,
|
||||
);
|
||||
|
||||
return {
|
||||
gameNumber: game.gameNumber,
|
||||
@@ -174,9 +181,10 @@ export class MatchStatsFragmentBuilder {
|
||||
gameDuration: game.gameDuration,
|
||||
gameVersion: raw.info.gameVersion,
|
||||
winnerSide: game.winnerSide,
|
||||
timeline: this.toTimeline(raw, rawTeamIdBySide, timeline),
|
||||
timelineLoaded: timelineLoadAttempted || Boolean(timeline),
|
||||
timeline: this.toTimeline(raw, rawTeamIdBySide, usableTimeline),
|
||||
timelineLoaded: Boolean(usableTimeline),
|
||||
objectiveEvents,
|
||||
timelineEvents,
|
||||
teams: (['blue', 'red'] as TeamSide[]).map((side) => {
|
||||
const teamIndex =
|
||||
side === 'blue' ? game.blueTeamIndex : game.redTeamIndex;
|
||||
@@ -202,7 +210,6 @@ export class MatchStatsFragmentBuilder {
|
||||
objectives: this.toObjectiveSummary(
|
||||
rawTeam,
|
||||
timelineObjectives.get(side),
|
||||
Boolean(timeline),
|
||||
),
|
||||
bans: (rawTeam?.bans ?? []).map((ban) => ({
|
||||
championId: ban.championId,
|
||||
@@ -220,9 +227,10 @@ export class MatchStatsFragmentBuilder {
|
||||
participant,
|
||||
rawParticipant,
|
||||
buildEvents: rawParticipant
|
||||
? buildEventsByParticipantId.get(
|
||||
rawParticipant.participantId,
|
||||
)
|
||||
? buildEventsByParticipantId.get(rawParticipant.participantId)
|
||||
: undefined,
|
||||
checkpoints: rawParticipant
|
||||
? checkpointsByParticipantId.get(rawParticipant.participantId)
|
||||
: undefined,
|
||||
teamKills,
|
||||
teamDamage,
|
||||
@@ -246,6 +254,7 @@ export class MatchStatsFragmentBuilder {
|
||||
timeline: [],
|
||||
timelineLoaded: false,
|
||||
objectiveEvents: [],
|
||||
timelineEvents: [],
|
||||
teams: (['blue', 'red'] as TeamSide[]).map((side) => ({
|
||||
teamIndex: side === 'blue' ? game.blueTeamIndex : game.redTeamIndex,
|
||||
side,
|
||||
@@ -273,6 +282,7 @@ export class MatchStatsFragmentBuilder {
|
||||
participant: MatchGameResultParticipant;
|
||||
rawParticipant?: RiotMatchParticipantDto;
|
||||
buildEvents?: ParticipantBuildEvents;
|
||||
checkpoints?: MatchStatsParticipantCheckpoints;
|
||||
teamKills: number;
|
||||
teamDamage: number;
|
||||
}): InternalRecord {
|
||||
@@ -282,6 +292,7 @@ export class MatchStatsFragmentBuilder {
|
||||
participant,
|
||||
rawParticipant,
|
||||
buildEvents,
|
||||
checkpoints,
|
||||
teamKills,
|
||||
teamDamage,
|
||||
} = params;
|
||||
@@ -319,6 +330,8 @@ export class MatchStatsFragmentBuilder {
|
||||
riotMatchId: game.riotMatchId,
|
||||
gameCreation: game.gameCreation,
|
||||
gameDuration: game.gameDuration,
|
||||
participantId: rawParticipant?.participantId,
|
||||
checkpoints,
|
||||
userId: participant.userId.toString(),
|
||||
summonerName:
|
||||
snapshot?.gameName ??
|
||||
@@ -405,7 +418,10 @@ export class MatchStatsFragmentBuilder {
|
||||
private toBuildEventsByParticipantId(
|
||||
timeline?: RiotMatchTimelineDto,
|
||||
): Map<number, ParticipantBuildEvents> {
|
||||
const buildEventsByParticipantId = new Map<number, ParticipantBuildEvents>();
|
||||
const buildEventsByParticipantId = new Map<
|
||||
number,
|
||||
ParticipantBuildEvents
|
||||
>();
|
||||
if (!timeline?.info.frames.length) return buildEventsByParticipantId;
|
||||
|
||||
const getEvents = (participantId: number): ParticipantBuildEvents => {
|
||||
@@ -455,6 +471,107 @@ export class MatchStatsFragmentBuilder {
|
||||
return buildEventsByParticipantId;
|
||||
}
|
||||
|
||||
private toCheckpointsByParticipantId(
|
||||
timeline: RiotMatchTimelineDto | undefined,
|
||||
gameDurationSeconds: number,
|
||||
): Map<number, MatchStatsParticipantCheckpoints> {
|
||||
const checkpointsByParticipantId = new Map<
|
||||
number,
|
||||
MatchStatsParticipantCheckpoints
|
||||
>();
|
||||
if (
|
||||
!timeline?.info.frames.length ||
|
||||
!Number.isFinite(timeline.info.frameInterval) ||
|
||||
timeline.info.frameInterval <= 0
|
||||
) {
|
||||
return checkpointsByParticipantId;
|
||||
}
|
||||
|
||||
const participantIds = new Set<number>();
|
||||
const championKillEvents = timeline.info.frames.flatMap((frame) =>
|
||||
(frame.events ?? []).filter((event) => event.type === 'CHAMPION_KILL'),
|
||||
);
|
||||
for (const frame of timeline.info.frames) {
|
||||
for (const participantFrame of Object.values(frame.participantFrames)) {
|
||||
participantIds.add(participantFrame.participantId);
|
||||
}
|
||||
}
|
||||
|
||||
const targets = [
|
||||
['at10', 600_000],
|
||||
['at15', 900_000],
|
||||
] as const;
|
||||
for (const participantId of participantIds) {
|
||||
const checkpoints: MatchStatsParticipantCheckpoints = {};
|
||||
for (const [key, targetTimestamp] of targets) {
|
||||
if (gameDurationSeconds * 1_000 < targetTimestamp) continue;
|
||||
|
||||
const selectedFrame = timeline.info.frames.reduce<
|
||||
RiotMatchTimelineDto['info']['frames'][number] | undefined
|
||||
>((latest, frame) => {
|
||||
if (
|
||||
frame.timestamp > targetTimestamp ||
|
||||
!Object.values(frame.participantFrames).some(
|
||||
(participantFrame) =>
|
||||
participantFrame.participantId === participantId,
|
||||
)
|
||||
) {
|
||||
return latest;
|
||||
}
|
||||
return !latest || frame.timestamp > latest.timestamp ? frame : latest;
|
||||
}, undefined);
|
||||
if (
|
||||
!selectedFrame ||
|
||||
targetTimestamp - selectedFrame.timestamp >=
|
||||
timeline.info.frameInterval
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const participantFrame = Object.values(
|
||||
selectedFrame.participantFrames,
|
||||
).find((frame) => frame.participantId === participantId);
|
||||
if (
|
||||
!participantFrame ||
|
||||
typeof participantFrame.minionsKilled !== 'number' ||
|
||||
!Number.isFinite(participantFrame.minionsKilled) ||
|
||||
typeof participantFrame.jungleMinionsKilled !== 'number' ||
|
||||
!Number.isFinite(participantFrame.jungleMinionsKilled)
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const checkpoint: MatchStatsCheckpoint = {
|
||||
timestamp: Math.max(0, Math.round(selectedFrame.timestamp / 1_000)),
|
||||
gold: participantFrame.totalGold,
|
||||
cs:
|
||||
participantFrame.minionsKilled +
|
||||
participantFrame.jungleMinionsKilled,
|
||||
xp: participantFrame.xp,
|
||||
kills: 0,
|
||||
deaths: 0,
|
||||
assists: 0,
|
||||
};
|
||||
for (const event of championKillEvents) {
|
||||
if (event.timestamp > selectedFrame.timestamp) continue;
|
||||
if (event.killerId === participantId && event.killerId > 0) {
|
||||
checkpoint.kills += 1;
|
||||
}
|
||||
if (event.victimId === participantId) checkpoint.deaths += 1;
|
||||
if (event.assistingParticipantIds?.includes(participantId)) {
|
||||
checkpoint.assists += 1;
|
||||
}
|
||||
}
|
||||
checkpoints[key] = checkpoint;
|
||||
}
|
||||
if (checkpoints.at10 || checkpoints.at15) {
|
||||
checkpointsByParticipantId.set(participantId, checkpoints);
|
||||
}
|
||||
}
|
||||
|
||||
return checkpointsByParticipantId;
|
||||
}
|
||||
|
||||
private toTimeline(
|
||||
raw: RiotMatchDto,
|
||||
rawTeamIdBySide: Map<TeamSide, number>,
|
||||
@@ -511,65 +628,124 @@ export class MatchStatsFragmentBuilder {
|
||||
return sideByParticipantId;
|
||||
}
|
||||
|
||||
private toObjectiveEvents(
|
||||
private toTimelineEvents(
|
||||
timeline: RiotMatchTimelineDto | undefined,
|
||||
rawTeamIdBySide: Map<TeamSide, number>,
|
||||
sideByParticipantId: Map<number, TeamSide>,
|
||||
): MatchStatsObjectiveEvent[] {
|
||||
if (!timeline?.info.frames.length) return [];
|
||||
): TimelineProjection {
|
||||
if (!timeline?.info.frames.length) {
|
||||
return { objectiveEvents: [], timelineEvents: [] };
|
||||
}
|
||||
|
||||
const sideByTeamId = new Map<number, TeamSide>();
|
||||
for (const [side, teamId] of rawTeamIdBySide.entries()) {
|
||||
sideByTeamId.set(teamId, side);
|
||||
}
|
||||
|
||||
const objectiveEvents: MatchStatsObjectiveEvent[] = [];
|
||||
const projected: Array<{
|
||||
sourceSequence: number;
|
||||
event: MatchStatsTimelineEvent;
|
||||
}> = [];
|
||||
let sourceSequence = 0;
|
||||
for (const frame of timeline.info.frames) {
|
||||
for (const event of frame.events ?? []) {
|
||||
if (event.type !== 'ELITE_MONSTER_KILL') continue;
|
||||
const side =
|
||||
(typeof event.killerTeamId === 'number'
|
||||
? sideByTeamId.get(event.killerTeamId)
|
||||
: undefined) ??
|
||||
(typeof event.killerId === 'number'
|
||||
? sideByParticipantId.get(event.killerId)
|
||||
: undefined);
|
||||
if (!side) continue;
|
||||
const currentSequence = sourceSequence;
|
||||
sourceSequence += 1;
|
||||
const timestamp = Math.max(0, Math.round(event.timestamp / 1000));
|
||||
switch (event.monsterType) {
|
||||
case 'BARON_NASHOR':
|
||||
objectiveEvents.push({ timestamp, side, type: 'baron' });
|
||||
break;
|
||||
case 'RIFTHERALD':
|
||||
objectiveEvents.push({ timestamp, side, type: 'riftHerald' });
|
||||
break;
|
||||
case 'HORDE':
|
||||
objectiveEvents.push({ timestamp, side, type: 'voidGrub' });
|
||||
break;
|
||||
case 'DRAGON':
|
||||
if (event.monsterSubType === 'ELDER_DRAGON') {
|
||||
objectiveEvents.push({
|
||||
timestamp,
|
||||
side,
|
||||
type: 'elderDragon',
|
||||
monsterSubType: event.monsterSubType,
|
||||
});
|
||||
} else {
|
||||
objectiveEvents.push({
|
||||
timestamp,
|
||||
side,
|
||||
type: 'dragon',
|
||||
monsterSubType: event.monsterSubType,
|
||||
});
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
if (event.type === 'ELITE_MONSTER_KILL') {
|
||||
const side =
|
||||
(typeof event.killerTeamId === 'number'
|
||||
? sideByTeamId.get(event.killerTeamId)
|
||||
: undefined) ??
|
||||
(typeof event.killerId === 'number'
|
||||
? sideByParticipantId.get(event.killerId)
|
||||
: undefined);
|
||||
if (!side) continue;
|
||||
const objectiveEvent = toObjectiveTimelineEvent({
|
||||
timestamp,
|
||||
side,
|
||||
monsterType: event.monsterType,
|
||||
monsterSubType: event.monsterSubType,
|
||||
});
|
||||
if (objectiveEvent) {
|
||||
projected.push({
|
||||
sourceSequence: currentSequence,
|
||||
event: objectiveEvent,
|
||||
});
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (event.type === 'CHAMPION_KILL') {
|
||||
const side =
|
||||
typeof event.killerId === 'number' && event.killerId > 0
|
||||
? sideByParticipantId.get(event.killerId)
|
||||
: undefined;
|
||||
projected.push({
|
||||
sourceSequence: currentSequence,
|
||||
event: {
|
||||
timestamp,
|
||||
type: 'championKill',
|
||||
...(side ? { side } : {}),
|
||||
...(typeof event.killerId === 'number' && event.killerId > 0
|
||||
? { killerParticipantId: event.killerId }
|
||||
: {}),
|
||||
...(typeof event.victimId === 'number' && event.victimId > 0
|
||||
? { victimParticipantId: event.victimId }
|
||||
: {}),
|
||||
...(event.assistingParticipantIds
|
||||
? { assistingParticipantIds: event.assistingParticipantIds }
|
||||
: {}),
|
||||
},
|
||||
});
|
||||
continue;
|
||||
}
|
||||
|
||||
if (event.type !== 'BUILDING_KILL') continue;
|
||||
const destroyedSide =
|
||||
typeof event.teamId === 'number'
|
||||
? sideByTeamId.get(event.teamId)
|
||||
: undefined;
|
||||
const side =
|
||||
(typeof event.killerId === 'number' && event.killerId > 0
|
||||
? sideByParticipantId.get(event.killerId)
|
||||
: undefined) ??
|
||||
(destroyedSide ? oppositeSide(destroyedSide) : undefined);
|
||||
const type =
|
||||
event.buildingType === 'TOWER_BUILDING'
|
||||
? 'tower'
|
||||
: event.buildingType === 'INHIBITOR_BUILDING'
|
||||
? 'inhibitor'
|
||||
: undefined;
|
||||
if (!side || !type) continue;
|
||||
projected.push({
|
||||
sourceSequence: currentSequence,
|
||||
event: {
|
||||
timestamp,
|
||||
side,
|
||||
type,
|
||||
...(typeof event.killerId === 'number' && event.killerId > 0
|
||||
? { killerParticipantId: event.killerId }
|
||||
: {}),
|
||||
...(type === 'tower' && event.towerType
|
||||
? { towerType: event.towerType }
|
||||
: {}),
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return objectiveEvents.sort((left, right) => left.timestamp - right.timestamp);
|
||||
const timelineEvents = projected
|
||||
.sort(
|
||||
(left, right) =>
|
||||
left.event.timestamp - right.event.timestamp ||
|
||||
left.sourceSequence - right.sourceSequence,
|
||||
)
|
||||
.map(({ event }) => event);
|
||||
return {
|
||||
timelineEvents,
|
||||
objectiveEvents: timelineEvents.filter(isObjectiveTimelineEvent),
|
||||
};
|
||||
}
|
||||
|
||||
private toTimelineObjectives(
|
||||
@@ -608,29 +784,32 @@ export class MatchStatsFragmentBuilder {
|
||||
}
|
||||
|
||||
private toObjectiveSummary(
|
||||
rawTeam:
|
||||
| RiotMatchDto['info']['teams'][number]
|
||||
| undefined,
|
||||
rawTeam: RiotMatchDto['info']['teams'][number] | undefined,
|
||||
timelineObjectives: MatchStatsObjectiveSummary | undefined,
|
||||
hasTimeline: boolean,
|
||||
): MatchStatsObjectiveSummary {
|
||||
const rawObjectives = rawTeam?.objectives;
|
||||
const timelineDragon = timelineObjectives?.dragon ?? 0;
|
||||
const timelineElder = timelineObjectives?.elderDragon ?? 0;
|
||||
const hasProjectedDragon = timelineDragon + timelineElder > 0;
|
||||
return {
|
||||
tower: rawObjectives?.tower?.kills ?? 0,
|
||||
dragon: hasTimeline
|
||||
? (timelineObjectives?.dragon ?? 0)
|
||||
dragon: hasProjectedDragon
|
||||
? timelineDragon
|
||||
: (rawObjectives?.dragon?.kills ?? 0),
|
||||
inhibitor: rawObjectives?.inhibitor?.kills ?? 0,
|
||||
baron: hasTimeline
|
||||
? (timelineObjectives?.baron ?? 0)
|
||||
: (rawObjectives?.baron?.kills ?? 0),
|
||||
riftHerald: hasTimeline
|
||||
? (timelineObjectives?.riftHerald ?? 0)
|
||||
: (rawObjectives?.riftHerald?.kills ?? 0),
|
||||
voidGrub: hasTimeline
|
||||
? (timelineObjectives?.voidGrub ?? 0)
|
||||
: (rawObjectives?.horde?.kills ?? 0),
|
||||
elderDragon: timelineObjectives?.elderDragon ?? 0,
|
||||
baron:
|
||||
(timelineObjectives?.baron ?? 0) > 0
|
||||
? (timelineObjectives?.baron ?? 0)
|
||||
: (rawObjectives?.baron?.kills ?? 0),
|
||||
riftHerald:
|
||||
(timelineObjectives?.riftHerald ?? 0) > 0
|
||||
? (timelineObjectives?.riftHerald ?? 0)
|
||||
: (rawObjectives?.riftHerald?.kills ?? 0),
|
||||
voidGrub:
|
||||
(timelineObjectives?.voidGrub ?? 0) > 0
|
||||
? (timelineObjectives?.voidGrub ?? 0)
|
||||
: (rawObjectives?.horde?.kills ?? 0),
|
||||
elderDragon: hasProjectedDragon ? timelineElder : 0,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -687,6 +866,79 @@ function toItemBuildType(
|
||||
}
|
||||
}
|
||||
|
||||
function toObjectiveTimelineEvent(params: {
|
||||
timestamp: number;
|
||||
side: TeamSide;
|
||||
monsterType?: string;
|
||||
monsterSubType?: string;
|
||||
}): MatchStatsObjectiveEvent | null {
|
||||
switch (params.monsterType) {
|
||||
case 'BARON_NASHOR':
|
||||
return { timestamp: params.timestamp, side: params.side, type: 'baron' };
|
||||
case 'RIFTHERALD':
|
||||
return {
|
||||
timestamp: params.timestamp,
|
||||
side: params.side,
|
||||
type: 'riftHerald',
|
||||
};
|
||||
case 'HORDE':
|
||||
return {
|
||||
timestamp: params.timestamp,
|
||||
side: params.side,
|
||||
type: 'voidGrub',
|
||||
};
|
||||
case 'DRAGON':
|
||||
return {
|
||||
timestamp: params.timestamp,
|
||||
side: params.side,
|
||||
type:
|
||||
params.monsterSubType === 'ELDER_DRAGON' ? 'elderDragon' : 'dragon',
|
||||
monsterSubType: params.monsterSubType,
|
||||
};
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function isObjectiveTimelineEvent(
|
||||
event: MatchStatsTimelineEvent,
|
||||
): event is MatchStatsObjectiveEvent {
|
||||
return (
|
||||
event.type === 'dragon' ||
|
||||
event.type === 'elderDragon' ||
|
||||
event.type === 'baron' ||
|
||||
event.type === 'riftHerald' ||
|
||||
event.type === 'voidGrub'
|
||||
);
|
||||
}
|
||||
|
||||
function oppositeSide(side: TeamSide): TeamSide {
|
||||
return side === 'blue' ? 'red' : 'blue';
|
||||
}
|
||||
|
||||
function isUsableTimeline(
|
||||
timeline: RiotMatchTimelineDto | undefined,
|
||||
gameDurationSeconds: number,
|
||||
): timeline is RiotMatchTimelineDto {
|
||||
if (
|
||||
!timeline ||
|
||||
!Number.isFinite(timeline.info.frameInterval) ||
|
||||
timeline.info.frameInterval <= 0 ||
|
||||
!Array.isArray(timeline.info.frames) ||
|
||||
timeline.info.frames.length === 0
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
const finalTimestamp = Math.max(
|
||||
...timeline.info.frames.map((frame) => frame.timestamp),
|
||||
);
|
||||
return (
|
||||
Number.isFinite(finalTimestamp) &&
|
||||
Math.abs(gameDurationSeconds * 1_000 - finalTimestamp) <
|
||||
timeline.info.frameInterval
|
||||
);
|
||||
}
|
||||
|
||||
function round(value: number): number {
|
||||
return Math.round(value * 10) / 10;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,216 @@
|
||||
import { Types } from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import type { MatchStats } from '../global/database/schema';
|
||||
import { MatchStatsRepository } from './match-stats.repository';
|
||||
|
||||
describe('MatchStatsRepository', () => {
|
||||
it('does not let a legacy upsert overwrite a Competition-backed fragment', async () => {
|
||||
const fragment = {
|
||||
...statsFragment(12),
|
||||
sourceCompetitionId: undefined,
|
||||
sourceRevision: undefined,
|
||||
projectorVersion: undefined,
|
||||
};
|
||||
const updateOne = jest
|
||||
.fn()
|
||||
.mockReturnValueOnce({
|
||||
exec: jest.fn().mockResolvedValue({ matchedCount: 0 }),
|
||||
})
|
||||
.mockReturnValueOnce({
|
||||
exec: jest
|
||||
.fn()
|
||||
.mockResolvedValue({ matchedCount: 1, upsertedCount: 0 }),
|
||||
});
|
||||
const connection = {
|
||||
getModel: jest.fn().mockResolvedValue({ updateOne }),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = new MatchStatsRepository(connection);
|
||||
|
||||
await repository.upsert(fragment);
|
||||
|
||||
expect(updateOne).toHaveBeenNthCalledWith(
|
||||
1,
|
||||
{
|
||||
matchId: fragment.matchId,
|
||||
sourceCompetitionId: { $exists: false },
|
||||
},
|
||||
{ $set: fragment },
|
||||
{ upsert: false },
|
||||
);
|
||||
expect(updateOne).toHaveBeenNthCalledWith(
|
||||
2,
|
||||
{ matchId: fragment.matchId },
|
||||
{ $setOnInsert: fragment },
|
||||
{ upsert: true },
|
||||
);
|
||||
});
|
||||
|
||||
it('only updates a Competition projection when its revision is not stale', async () => {
|
||||
const updateOne = jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue({ matchedCount: 1, upsertedCount: 0 }),
|
||||
});
|
||||
const connection = {
|
||||
getModel: jest.fn().mockResolvedValue({ updateOne }),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = new MatchStatsRepository(connection);
|
||||
const fragment = statsFragment(12);
|
||||
|
||||
await repository.upsert(fragment);
|
||||
|
||||
expect(updateOne).toHaveBeenCalledWith(
|
||||
{
|
||||
matchId: fragment.matchId,
|
||||
$or: [
|
||||
{ sourceCompetitionId: { $exists: false } },
|
||||
{ sourceCompetitionId: fragment.sourceCompetitionId },
|
||||
],
|
||||
$and: [
|
||||
{
|
||||
$or: [
|
||||
{ sourceRevision: { $exists: false } },
|
||||
{ sourceRevision: { $lte: 12 } },
|
||||
],
|
||||
},
|
||||
],
|
||||
},
|
||||
{ $set: fragment },
|
||||
{ upsert: false },
|
||||
);
|
||||
});
|
||||
|
||||
it('converges concurrent initial upserts to the highest Competition revision', async () => {
|
||||
const older = statsFragment(12);
|
||||
const newer = {
|
||||
...statsFragment(13),
|
||||
matchId: older.matchId,
|
||||
sourceCompetitionId: older.sourceCompetitionId,
|
||||
};
|
||||
let stored: ReturnType<typeof statsFragment> | undefined;
|
||||
let initialGuardCount = 0;
|
||||
let releaseInitialGuards!: () => void;
|
||||
const initialGuardsReady = new Promise<void>((resolve) => {
|
||||
releaseInitialGuards = resolve;
|
||||
});
|
||||
let releaseOlderInsert!: () => void;
|
||||
const olderInserted = new Promise<void>((resolve) => {
|
||||
releaseOlderInsert = resolve;
|
||||
});
|
||||
const updateOne = jest.fn(
|
||||
(
|
||||
_filter: Record<string, unknown>,
|
||||
update: {
|
||||
$set?: ReturnType<typeof statsFragment>;
|
||||
$setOnInsert?: ReturnType<typeof statsFragment>;
|
||||
},
|
||||
) => ({
|
||||
exec: async () => {
|
||||
const fragment = update.$set ?? update.$setOnInsert!;
|
||||
if (update.$set && !stored && initialGuardCount < 2) {
|
||||
initialGuardCount += 1;
|
||||
if (initialGuardCount === 2) releaseInitialGuards();
|
||||
await initialGuardsReady;
|
||||
return { matchedCount: 0, upsertedCount: 0 };
|
||||
}
|
||||
|
||||
if (update.$setOnInsert) {
|
||||
if (fragment.sourceRevision === 13) await olderInserted;
|
||||
const existed = stored !== undefined;
|
||||
if (!stored) stored = fragment;
|
||||
if (fragment.sourceRevision === 12) releaseOlderInsert();
|
||||
return {
|
||||
matchedCount: existed ? 1 : 0,
|
||||
upsertedCount: existed ? 0 : 1,
|
||||
};
|
||||
}
|
||||
|
||||
if (
|
||||
stored &&
|
||||
stored.sourceCompetitionId?.equals(fragment.sourceCompetitionId) &&
|
||||
stored.sourceRevision <= fragment.sourceRevision
|
||||
) {
|
||||
stored = fragment;
|
||||
return { matchedCount: 1, upsertedCount: 0 };
|
||||
}
|
||||
return { matchedCount: 0, upsertedCount: 0 };
|
||||
},
|
||||
}),
|
||||
);
|
||||
const connection = {
|
||||
getModel: jest.fn().mockResolvedValue({ updateOne }),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = new MatchStatsRepository(connection);
|
||||
|
||||
await Promise.all([repository.upsert(older), repository.upsert(newer)]);
|
||||
|
||||
expect(stored?.sourceRevision).toBe(13);
|
||||
});
|
||||
|
||||
it('guards a zero-game delete so an observed revision cannot remove newer stats', async () => {
|
||||
const matchId = new Types.ObjectId();
|
||||
const sourceCompetitionId = new Types.ObjectId();
|
||||
const deleteOne = jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue({ deletedCount: 0 }),
|
||||
});
|
||||
const connection = {
|
||||
getModel: jest.fn().mockResolvedValue({ deleteOne }),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = new MatchStatsRepository(connection);
|
||||
|
||||
await repository.deleteByMatch(matchId, {
|
||||
sourceCompetitionId,
|
||||
sourceRevision: 12,
|
||||
});
|
||||
|
||||
expect(deleteOne).toHaveBeenCalledWith({
|
||||
matchId,
|
||||
$or: [
|
||||
{ sourceCompetitionId: { $exists: false } },
|
||||
{
|
||||
sourceCompetitionId,
|
||||
$or: [
|
||||
{ sourceRevision: { $exists: false } },
|
||||
{ sourceRevision: { $lte: 12 } },
|
||||
],
|
||||
},
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
it('deletes only non-Competition stats during legacy source cleanup', async () => {
|
||||
const matchId = new Types.ObjectId();
|
||||
const deleteOne = jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue({ deletedCount: 0 }),
|
||||
});
|
||||
const connection = {
|
||||
getModel: jest.fn().mockResolvedValue({ deleteOne }),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = new MatchStatsRepository(connection);
|
||||
|
||||
await repository.deleteLegacyByMatch(matchId);
|
||||
|
||||
expect(deleteOne).toHaveBeenCalledWith({
|
||||
matchId,
|
||||
sourceCompetitionId: { $exists: false },
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
function statsFragment(sourceRevision: number) {
|
||||
return {
|
||||
matchId: new Types.ObjectId(),
|
||||
communityId: new Types.ObjectId(),
|
||||
sourceCompetitionId: new Types.ObjectId(),
|
||||
sourceRevision,
|
||||
projectorVersion: 3,
|
||||
scheduledAt: new Date(),
|
||||
gameCreationMin: 1,
|
||||
gameCreationMax: 2,
|
||||
userIds: [],
|
||||
championIds: [],
|
||||
matchCard: {},
|
||||
records: [],
|
||||
gameDetails: [],
|
||||
builtAt: new Date(),
|
||||
builderVersion: 9,
|
||||
} satisfies Omit<MatchStats, 'createdAt' | 'updatedAt'>;
|
||||
}
|
||||
@@ -13,6 +13,11 @@ export type MatchStatsDetailFragment = Pick<
|
||||
'matchId' | 'gameDetails'
|
||||
>;
|
||||
|
||||
export interface MatchStatsDeleteGuard {
|
||||
sourceCompetitionId: mongoose.Types.ObjectId;
|
||||
sourceRevision: number;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class MatchStatsRepository {
|
||||
constructor(private readonly connectionService: ConnectionService) {}
|
||||
@@ -21,16 +26,86 @@ export class MatchStatsRepository {
|
||||
fragment: Omit<MatchStats, 'createdAt' | 'updatedAt'>,
|
||||
): Promise<void> {
|
||||
const MatchStatsModel = await this.connectionService.getModel('matchStats');
|
||||
await MatchStatsModel.updateOne(
|
||||
{ matchId: fragment.matchId },
|
||||
if (
|
||||
!fragment.sourceCompetitionId ||
|
||||
fragment.sourceRevision === undefined
|
||||
) {
|
||||
const updated = await MatchStatsModel.updateOne(
|
||||
{
|
||||
matchId: fragment.matchId,
|
||||
sourceCompetitionId: { $exists: false },
|
||||
},
|
||||
{ $set: fragment },
|
||||
{ upsert: false },
|
||||
).exec();
|
||||
if (updated.matchedCount > 0) return;
|
||||
|
||||
// A legacy builder must never overwrite a Competition-backed fragment
|
||||
// that appeared while the legacy source was being read.
|
||||
try {
|
||||
await MatchStatsModel.updateOne(
|
||||
{ matchId: fragment.matchId },
|
||||
{ $setOnInsert: fragment },
|
||||
{ upsert: true },
|
||||
).exec();
|
||||
} catch (error) {
|
||||
if (!isDuplicateKeyError(error)) throw error;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
const revisionGuard = competitionRevisionGuard(fragment);
|
||||
const updated = await MatchStatsModel.updateOne(
|
||||
revisionGuard,
|
||||
{ $set: fragment },
|
||||
{ upsert: true },
|
||||
{ upsert: false },
|
||||
).exec();
|
||||
if (updated.matchedCount > 0) return;
|
||||
|
||||
// If no read model exists, insert it. If a newer revision won the race,
|
||||
// this filter matches it and $setOnInsert intentionally changes nothing.
|
||||
try {
|
||||
await MatchStatsModel.updateOne(
|
||||
{ matchId: fragment.matchId },
|
||||
{ $setOnInsert: fragment },
|
||||
{ upsert: true },
|
||||
).exec();
|
||||
} catch (error) {
|
||||
if (!isDuplicateKeyError(error)) throw error;
|
||||
}
|
||||
|
||||
// A lower revision can win the initial insert between the guarded miss and
|
||||
// the upsert. Re-run the monotonic CAS so every concurrent builder converges
|
||||
// to the highest source revision; a newer winner simply does not match.
|
||||
await MatchStatsModel.updateOne(
|
||||
revisionGuard,
|
||||
{ $set: fragment },
|
||||
{ upsert: false },
|
||||
).exec();
|
||||
}
|
||||
|
||||
public async deleteByMatch(matchId: mongoose.Types.ObjectId): Promise<void> {
|
||||
public async deleteByMatch(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
guard?: MatchStatsDeleteGuard,
|
||||
): Promise<void> {
|
||||
const MatchStatsModel = await this.connectionService.getModel('matchStats');
|
||||
await MatchStatsModel.deleteOne({ matchId }).exec();
|
||||
await MatchStatsModel.deleteOne(
|
||||
guard
|
||||
? {
|
||||
matchId,
|
||||
$or: [
|
||||
{ sourceCompetitionId: { $exists: false } },
|
||||
{
|
||||
sourceCompetitionId: guard.sourceCompetitionId,
|
||||
$or: [
|
||||
{ sourceRevision: { $exists: false } },
|
||||
{ sourceRevision: { $lte: guard.sourceRevision } },
|
||||
],
|
||||
},
|
||||
],
|
||||
}
|
||||
: { matchId },
|
||||
).exec();
|
||||
}
|
||||
|
||||
public async deleteByMatches(
|
||||
@@ -41,6 +116,16 @@ export class MatchStatsRepository {
|
||||
await MatchStatsModel.deleteMany({ matchId: { $in: matchIds } }).exec();
|
||||
}
|
||||
|
||||
public async deleteLegacyByMatch(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
): Promise<void> {
|
||||
const MatchStatsModel = await this.connectionService.getModel('matchStats');
|
||||
await MatchStatsModel.deleteOne({
|
||||
matchId,
|
||||
sourceCompetitionId: { $exists: false },
|
||||
}).exec();
|
||||
}
|
||||
|
||||
public async findByMatch(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
): Promise<MatchStatsDocument | null> {
|
||||
@@ -138,3 +223,32 @@ export class MatchStatsRepository {
|
||||
return filter;
|
||||
}
|
||||
}
|
||||
|
||||
function competitionRevisionGuard(
|
||||
fragment: Omit<MatchStats, 'createdAt' | 'updatedAt'>,
|
||||
) {
|
||||
return {
|
||||
matchId: fragment.matchId,
|
||||
$or: [
|
||||
{ sourceCompetitionId: { $exists: false } },
|
||||
{ sourceCompetitionId: fragment.sourceCompetitionId },
|
||||
],
|
||||
$and: [
|
||||
{
|
||||
$or: [
|
||||
{ sourceRevision: { $exists: false } },
|
||||
{ sourceRevision: { $lte: fragment.sourceRevision } },
|
||||
],
|
||||
},
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
function isDuplicateKeyError(error: unknown): boolean {
|
||||
return (
|
||||
typeof error === 'object' &&
|
||||
error !== null &&
|
||||
'code' in error &&
|
||||
error.code === 11_000
|
||||
);
|
||||
}
|
||||
@@ -3,6 +3,7 @@ import { ConnectionService } from '../global/database/connection.service';
|
||||
import { MatchStatsFragmentBuilder } from './match-stats-fragment.builder';
|
||||
import { MatchStatsRepository } from './match-stats.repository';
|
||||
import { MatchStatsService } from './match-stats.service';
|
||||
import { MATCH_STATS_BUILDER_VERSION } from './match-stats.types';
|
||||
|
||||
describe('MatchStatsService', () => {
|
||||
it('deletes an existing fragment when the match is no longer eligible', async () => {
|
||||
@@ -17,6 +18,7 @@ describe('MatchStatsService', () => {
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockImplementation(async (name: string) => {
|
||||
if (name === 'match') return { findById };
|
||||
if (name === 'competition') return { findOne: () => queryResult(null) };
|
||||
if (name === 'riotMatch') return {};
|
||||
throw new Error(`Unexpected model: ${name}`);
|
||||
}),
|
||||
@@ -38,6 +40,57 @@ describe('MatchStatsService', () => {
|
||||
expect(repository.upsert).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('revision-guards deletion when a Competition reversal leaves zero games', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const competitionId = new mongoose.Types.ObjectId();
|
||||
const match = {
|
||||
_id: matchId,
|
||||
communityId,
|
||||
scheduledAt: new Date('2026-07-12T10:00:00.000Z'),
|
||||
status: 'in-progress',
|
||||
teams: [],
|
||||
result: undefined,
|
||||
};
|
||||
const competition = {
|
||||
_id: competitionId,
|
||||
revision: 12,
|
||||
projectorVersion: 3,
|
||||
teams: [],
|
||||
projection: { phase: 'ready', games: [] },
|
||||
};
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockImplementation(async (name: string) => {
|
||||
if (name === 'match') {
|
||||
return { findById: () => queryResult(match, false) };
|
||||
}
|
||||
if (name === 'competition') {
|
||||
return { findOne: () => queryResult(competition) };
|
||||
}
|
||||
if (name === 'riotMatch') return {};
|
||||
throw new Error(`Unexpected model: ${name}`);
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
deleteByMatch: jest.fn().mockResolvedValue(undefined),
|
||||
upsert: jest.fn(),
|
||||
} as unknown as jest.Mocked<MatchStatsRepository>;
|
||||
const service = new MatchStatsService(
|
||||
connectionService,
|
||||
repository,
|
||||
{} as MatchStatsFragmentBuilder,
|
||||
{ getMatchTimeline: jest.fn() } as never,
|
||||
);
|
||||
|
||||
await service.buildAndUpsert(matchId, { sourceRevision: 12 });
|
||||
|
||||
expect(repository.deleteByMatch).toHaveBeenCalledWith(matchId, {
|
||||
sourceCompetitionId: competitionId,
|
||||
sourceRevision: 12,
|
||||
});
|
||||
expect(repository.upsert).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('upserts a fragment for eligible matches', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
@@ -73,6 +126,7 @@ describe('MatchStatsService', () => {
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockImplementation(async (name: string) => {
|
||||
if (name === 'match') return { findById };
|
||||
if (name === 'competition') return { findOne: () => queryResult(null) };
|
||||
if (name === 'riotMatch') return { find: riotFind };
|
||||
throw new Error(`Unexpected model: ${name}`);
|
||||
}),
|
||||
@@ -105,8 +159,10 @@ describe('MatchStatsService', () => {
|
||||
match,
|
||||
rawByRiotMatchId: expect.any(Map),
|
||||
timelineByRiotMatchId: expect.any(Map),
|
||||
timelineLoadAttempted: false,
|
||||
});
|
||||
expect(
|
||||
builder.buildFragment.mock.calls[0][0].timelineByRiotMatchId,
|
||||
).toHaveProperty('size', 0);
|
||||
expect(repository.upsert).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
matchId,
|
||||
@@ -114,8 +170,461 @@ describe('MatchStatsService', () => {
|
||||
scheduledAt,
|
||||
gameCreationMin: 1_000,
|
||||
gameCreationMax: 2_000,
|
||||
builderVersion: 9,
|
||||
builderVersion: MATCH_STATS_BUILDER_VERSION,
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('retries unusable timeline caches and stores a later usable fetch', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const match = {
|
||||
_id: matchId,
|
||||
communityId,
|
||||
scheduledAt: new Date('2026-05-03T00:00:00.000Z'),
|
||||
status: 'finished',
|
||||
result: { games: [{ riotMatchId: 'KR_1' }] },
|
||||
};
|
||||
const emptyTimeline = {
|
||||
info: { frameInterval: 60_000, frames: [] },
|
||||
};
|
||||
const partialTimeline = {
|
||||
info: {
|
||||
frameInterval: 60_000,
|
||||
frames: [{ timestamp: 0, events: [] }],
|
||||
},
|
||||
};
|
||||
const nonPositiveTimeline = {
|
||||
info: {
|
||||
frameInterval: 0,
|
||||
frames: [timelineFrame(120_000)],
|
||||
},
|
||||
};
|
||||
const truncatedTimeline = {
|
||||
info: {
|
||||
frameInterval: 60_000,
|
||||
frames: [timelineFrame()],
|
||||
},
|
||||
};
|
||||
const usableTimeline = {
|
||||
metadata: {
|
||||
dataVersion: '2',
|
||||
matchId: 'KR_1',
|
||||
participants: ['puuid-1'],
|
||||
},
|
||||
info: {
|
||||
frameInterval: 60_000,
|
||||
frames: [timelineFrame(120_000)],
|
||||
},
|
||||
};
|
||||
const cachedTimelines = [
|
||||
emptyTimeline,
|
||||
partialTimeline,
|
||||
nonPositiveTimeline,
|
||||
truncatedTimeline,
|
||||
];
|
||||
let buildIndex = 0;
|
||||
const riotFind = jest.fn().mockImplementation(() => ({
|
||||
lean: () => ({
|
||||
exec: jest.fn().mockResolvedValue([
|
||||
{
|
||||
matchId: 'KR_1',
|
||||
raw: { info: { gameDuration: 120 } },
|
||||
timeline: cachedTimelines[Math.min(buildIndex++, 3)],
|
||||
},
|
||||
]),
|
||||
}),
|
||||
}));
|
||||
const updateExec = jest.fn().mockResolvedValue(undefined);
|
||||
let storedUpdate:
|
||||
| {
|
||||
filter: unknown;
|
||||
update: { $set: { timeline: unknown; timelineFetchedAt: Date } };
|
||||
}
|
||||
| undefined;
|
||||
const updateOne = jest.fn(
|
||||
(
|
||||
filter: unknown,
|
||||
update: { $set: { timeline: unknown; timelineFetchedAt: Date } },
|
||||
) => {
|
||||
storedUpdate = { filter, update };
|
||||
return { exec: updateExec };
|
||||
},
|
||||
);
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockImplementation((name: string) => {
|
||||
if (name === 'match') {
|
||||
return Promise.resolve({ findById: () => queryResult(match, false) });
|
||||
}
|
||||
if (name === 'competition') {
|
||||
return Promise.resolve({ findOne: () => queryResult(null) });
|
||||
}
|
||||
if (name === 'riotMatch') {
|
||||
return Promise.resolve({ find: riotFind, updateOne });
|
||||
}
|
||||
if (name === 'community') {
|
||||
return Promise.resolve({
|
||||
findById: () => ({
|
||||
select: () => queryResult({ riotRegion: 'asia' }),
|
||||
}),
|
||||
});
|
||||
}
|
||||
return Promise.reject(new Error(`Unexpected model: ${name}`));
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
upsert: jest.fn().mockResolvedValue(undefined),
|
||||
deleteByMatch: jest.fn(),
|
||||
deleteLegacyByMatch: jest.fn(),
|
||||
} as unknown as jest.Mocked<MatchStatsRepository>;
|
||||
type BuildParams = Parameters<
|
||||
MatchStatsFragmentBuilder['buildFragment']
|
||||
>[0];
|
||||
const buildCalls: BuildParams[] = [];
|
||||
const builtFragment = {
|
||||
matchCard: { matchId: matchId.toString() },
|
||||
records: [],
|
||||
gameDetails: [],
|
||||
userIds: [],
|
||||
championIds: [],
|
||||
gameCreationMin: 1_000,
|
||||
gameCreationMax: 2_000,
|
||||
} as ReturnType<MatchStatsFragmentBuilder['buildFragment']>;
|
||||
const buildFragment = jest.fn((params: BuildParams) => {
|
||||
buildCalls.push(params);
|
||||
return builtFragment;
|
||||
});
|
||||
const builder = {
|
||||
buildFragment,
|
||||
} as unknown as jest.Mocked<MatchStatsFragmentBuilder>;
|
||||
const getMatchTimeline = jest
|
||||
.fn()
|
||||
.mockRejectedValueOnce(new Error('temporary Riot failure'))
|
||||
.mockRejectedValueOnce(new Error('temporary Riot failure'))
|
||||
.mockRejectedValueOnce(new Error('temporary Riot failure'))
|
||||
.mockResolvedValueOnce(usableTimeline);
|
||||
const service = new MatchStatsService(
|
||||
connectionService,
|
||||
repository,
|
||||
builder,
|
||||
{ getMatchTimeline } as never,
|
||||
);
|
||||
|
||||
await service.buildAndUpsert(matchId, { includeTimeline: true });
|
||||
await service.buildAndUpsert(matchId, { includeTimeline: true });
|
||||
await service.buildAndUpsert(matchId, { includeTimeline: true });
|
||||
await service.buildAndUpsert(matchId, { includeTimeline: true });
|
||||
|
||||
expect(getMatchTimeline).toHaveBeenCalledTimes(4);
|
||||
expect(buildFragment).toHaveBeenCalledTimes(4);
|
||||
expect(buildCalls[0].timelineByRiotMatchId).toHaveProperty('size', 0);
|
||||
expect(buildCalls[1].timelineByRiotMatchId).toHaveProperty('size', 0);
|
||||
expect(buildCalls[2].timelineByRiotMatchId?.get('KR_1')).toBeUndefined();
|
||||
expect(buildCalls[3].timelineByRiotMatchId?.get('KR_1')).toBe(
|
||||
usableTimeline,
|
||||
);
|
||||
for (const call of buildCalls) {
|
||||
expect(call).not.toHaveProperty('timelineLoadAttempted');
|
||||
}
|
||||
expect(updateOne).toHaveBeenCalledTimes(1);
|
||||
expect(storedUpdate?.filter).toEqual({ matchId: 'KR_1' });
|
||||
expect(storedUpdate?.update.$set.timeline).toBe(usableTimeline);
|
||||
expect(storedUpdate?.update.$set.timelineFetchedAt).toBeInstanceOf(Date);
|
||||
expect(updateExec).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('builds from the Competition projection and records its source revision', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const competitionId = new mongoose.Types.ObjectId();
|
||||
const teamAId = new mongoose.Types.ObjectId();
|
||||
const teamBId = new mongoose.Types.ObjectId();
|
||||
const userAId = new mongoose.Types.ObjectId();
|
||||
const userBId = new mongoose.Types.ObjectId();
|
||||
const match = {
|
||||
_id: matchId,
|
||||
communityId,
|
||||
scheduledAt: new Date('2026-07-12T10:00:00.000Z'),
|
||||
status: 'in-progress',
|
||||
teams: [],
|
||||
result: { games: [{ riotMatchId: 'KR_LEGACY_MUST_NOT_BE_USED' }] },
|
||||
};
|
||||
const competition = {
|
||||
_id: competitionId,
|
||||
revision: 12,
|
||||
projectorVersion: 3,
|
||||
teams: [
|
||||
{ teamId: teamAId, legacyTeamIndex: 8, displayOrder: 1 },
|
||||
{ teamId: teamBId, legacyTeamIndex: 3, displayOrder: 2 },
|
||||
],
|
||||
projection: {
|
||||
phase: 'running',
|
||||
games: [
|
||||
{
|
||||
displayNumber: 4,
|
||||
evidence: { type: 'riot', riotMatchId: 'KR_COMPETITION' },
|
||||
teams: {
|
||||
blue: { teamId: teamAId.toString() },
|
||||
red: { teamId: teamBId.toString() },
|
||||
},
|
||||
winnerTeamId: teamAId.toString(),
|
||||
startedAt: '2026-07-12T10:00:00.000Z',
|
||||
durationSeconds: 1800,
|
||||
participants: [
|
||||
participant(userAId, teamAId, 'blue', true),
|
||||
participant(userBId, teamBId, 'red', false),
|
||||
],
|
||||
},
|
||||
],
|
||||
},
|
||||
};
|
||||
const riotFind = jest.fn().mockReturnValue({
|
||||
lean: () => ({
|
||||
exec: jest
|
||||
.fn()
|
||||
.mockResolvedValue([{ matchId: 'KR_COMPETITION', raw: {} }]),
|
||||
}),
|
||||
});
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockImplementation(async (name: string) => {
|
||||
if (name === 'match')
|
||||
return { findById: () => queryResult(match, false) };
|
||||
if (name === 'competition') {
|
||||
return { findOne: () => queryResult(competition) };
|
||||
}
|
||||
if (name === 'riotMatch') return { find: riotFind };
|
||||
throw new Error(`Unexpected model: ${name}`);
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
upsert: jest.fn().mockResolvedValue(undefined),
|
||||
deleteByMatch: jest.fn(),
|
||||
} as unknown as jest.Mocked<MatchStatsRepository>;
|
||||
const builder = {
|
||||
buildFragment: jest.fn().mockReturnValue({
|
||||
matchCard: {},
|
||||
records: [],
|
||||
gameDetails: [],
|
||||
userIds: [],
|
||||
championIds: [],
|
||||
gameCreationMin: 1,
|
||||
gameCreationMax: 2,
|
||||
}),
|
||||
} as unknown as jest.Mocked<MatchStatsFragmentBuilder>;
|
||||
const service = new MatchStatsService(
|
||||
connectionService,
|
||||
repository,
|
||||
builder,
|
||||
{ getMatchTimeline: jest.fn() } as never,
|
||||
);
|
||||
|
||||
await service.buildAndUpsert(matchId, { sourceRevision: 12 });
|
||||
|
||||
expect(riotFind).toHaveBeenCalledWith({
|
||||
matchId: { $in: ['KR_COMPETITION'] },
|
||||
});
|
||||
expect(builder.buildFragment).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
match: expect.objectContaining({
|
||||
result: expect.objectContaining({
|
||||
riotMatchIds: ['KR_COMPETITION'],
|
||||
games: [
|
||||
expect.objectContaining({
|
||||
gameNumber: 4,
|
||||
blueTeamIndex: 8,
|
||||
redTeamIndex: 3,
|
||||
winnerTeamIndex: 8,
|
||||
}),
|
||||
],
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
);
|
||||
expect(repository.upsert).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
sourceCompetitionId: competitionId,
|
||||
sourceRevision: 12,
|
||||
projectorVersion: 3,
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('removes a fragment written after its Competition Match was deleted', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const competitionId = new mongoose.Types.ObjectId();
|
||||
const teamAId = new mongoose.Types.ObjectId();
|
||||
const teamBId = new mongoose.Types.ObjectId();
|
||||
const match = {
|
||||
_id: matchId,
|
||||
communityId,
|
||||
scheduledAt: new Date('2026-07-12T10:00:00.000Z'),
|
||||
status: 'in-progress',
|
||||
teams: [],
|
||||
result: undefined,
|
||||
};
|
||||
const competition = {
|
||||
_id: competitionId,
|
||||
revision: 12,
|
||||
projectorVersion: 3,
|
||||
teams: [
|
||||
{ teamId: teamAId, legacyTeamIndex: 1, displayOrder: 1 },
|
||||
{ teamId: teamBId, legacyTeamIndex: 2, displayOrder: 2 },
|
||||
],
|
||||
projection: {
|
||||
phase: 'running',
|
||||
games: [
|
||||
{
|
||||
id: new mongoose.Types.ObjectId(),
|
||||
displayNumber: 1,
|
||||
evidence: { type: 'legacy', legacyReference: 'legacy:1' },
|
||||
teams: {
|
||||
blue: { teamId: teamAId.toString() },
|
||||
red: { teamId: teamBId.toString() },
|
||||
},
|
||||
winnerTeamId: teamAId.toString(),
|
||||
},
|
||||
],
|
||||
},
|
||||
};
|
||||
const findById = jest
|
||||
.fn()
|
||||
.mockReturnValueOnce(queryResult(match, false))
|
||||
.mockReturnValueOnce(queryResult(null, false));
|
||||
const findCompetition = jest.fn().mockReturnValue(queryResult(competition));
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockImplementation(async (name: string) => {
|
||||
if (name === 'match') return { findById };
|
||||
if (name === 'competition') return { findOne: findCompetition };
|
||||
if (name === 'riotMatch') return {};
|
||||
throw new Error(`Unexpected model: ${name}`);
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
upsert: jest.fn().mockResolvedValue(undefined),
|
||||
deleteByMatch: jest.fn().mockResolvedValue(undefined),
|
||||
deleteLegacyByMatch: jest.fn(),
|
||||
} as unknown as jest.Mocked<MatchStatsRepository>;
|
||||
const builder = {
|
||||
buildFragment: jest.fn().mockReturnValue({
|
||||
matchCard: {},
|
||||
records: [],
|
||||
gameDetails: [],
|
||||
userIds: [],
|
||||
championIds: [],
|
||||
gameCreationMin: 1,
|
||||
gameCreationMax: 2,
|
||||
}),
|
||||
} as unknown as jest.Mocked<MatchStatsFragmentBuilder>;
|
||||
const service = new MatchStatsService(
|
||||
connectionService,
|
||||
repository,
|
||||
builder,
|
||||
{ getMatchTimeline: jest.fn() } as never,
|
||||
);
|
||||
|
||||
await service.buildAndUpsert(matchId, { sourceRevision: 12 });
|
||||
|
||||
expect(repository.upsert).toHaveBeenCalled();
|
||||
expect(repository.deleteByMatch).toHaveBeenCalledWith(matchId, {
|
||||
sourceCompetitionId: competitionId,
|
||||
sourceRevision: 12,
|
||||
});
|
||||
expect(repository.upsert.mock.invocationCallOrder[0]).toBeLessThan(
|
||||
repository.deleteByMatch.mock.invocationCallOrder[0],
|
||||
);
|
||||
});
|
||||
|
||||
it('does not rebuild before the requested Competition revision is visible', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const riotFind = jest.fn();
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockImplementation(async (name: string) => {
|
||||
if (name === 'match') {
|
||||
return {
|
||||
findById: () =>
|
||||
queryResult(
|
||||
{
|
||||
_id: matchId,
|
||||
status: 'in-progress',
|
||||
},
|
||||
false,
|
||||
),
|
||||
};
|
||||
}
|
||||
if (name === 'competition') {
|
||||
return {
|
||||
findOne: () => queryResult({ revision: 11 }),
|
||||
};
|
||||
}
|
||||
if (name === 'riotMatch') return { find: riotFind };
|
||||
throw new Error(`Unexpected model: ${name}`);
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
upsert: jest.fn(),
|
||||
deleteByMatch: jest.fn(),
|
||||
} as unknown as jest.Mocked<MatchStatsRepository>;
|
||||
const builder = {
|
||||
buildFragment: jest.fn(),
|
||||
} as unknown as jest.Mocked<MatchStatsFragmentBuilder>;
|
||||
const service = new MatchStatsService(
|
||||
connectionService,
|
||||
repository,
|
||||
builder,
|
||||
{ getMatchTimeline: jest.fn() } as never,
|
||||
);
|
||||
|
||||
await service.buildAndUpsert(matchId, { sourceRevision: 12 });
|
||||
|
||||
expect(riotFind).not.toHaveBeenCalled();
|
||||
expect(builder.buildFragment).not.toHaveBeenCalled();
|
||||
expect(repository.upsert).not.toHaveBeenCalled();
|
||||
expect(repository.deleteByMatch).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
function participant(
|
||||
userId: mongoose.Types.ObjectId,
|
||||
teamId: mongoose.Types.ObjectId,
|
||||
side: 'blue' | 'red',
|
||||
win: boolean,
|
||||
) {
|
||||
return {
|
||||
userId: userId.toString(),
|
||||
teamId: teamId.toString(),
|
||||
side,
|
||||
summonerName: 'player',
|
||||
tagLine: 'KR1',
|
||||
championId: 1,
|
||||
kills: 1,
|
||||
deaths: 1,
|
||||
assists: 1,
|
||||
win,
|
||||
};
|
||||
}
|
||||
|
||||
function queryResult<T>(value: T, lean = true) {
|
||||
const query = {
|
||||
lean: jest.fn(),
|
||||
exec: jest.fn().mockResolvedValue(value),
|
||||
};
|
||||
query.lean.mockReturnValue(query);
|
||||
return lean ? query : { exec: query.exec };
|
||||
}
|
||||
|
||||
function timelineFrame(timestamp = 0) {
|
||||
return {
|
||||
timestamp,
|
||||
events: [],
|
||||
participantFrames: {
|
||||
'1': {
|
||||
participantId: 1,
|
||||
totalGold: 500,
|
||||
xp: 0,
|
||||
minionsKilled: 0,
|
||||
jungleMinionsKilled: 0,
|
||||
},
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -26,18 +26,40 @@ export class MatchStatsService {
|
||||
|
||||
public async buildAndUpsert(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
options: { includeTimeline?: boolean } = {},
|
||||
options: { includeTimeline?: boolean; sourceRevision?: number } = {},
|
||||
): Promise<void> {
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const CompetitionModel =
|
||||
await this.connectionService.getModel('competition');
|
||||
const RiotMatchModel = await this.connectionService.getModel('riotMatch');
|
||||
const match = await MatchModel.findById(matchId).exec();
|
||||
if (!match) return;
|
||||
if (!this.isEligible(match)) {
|
||||
await this.repository.deleteByMatch(matchId);
|
||||
const competition = await CompetitionModel.findOne({ matchId })
|
||||
.lean()
|
||||
.exec();
|
||||
if (
|
||||
options.sourceRevision !== undefined &&
|
||||
(!competition || competition.revision < options.sourceRevision)
|
||||
) {
|
||||
return;
|
||||
}
|
||||
const competitionSource = competition
|
||||
? competitionStatsSource(match, competition)
|
||||
: undefined;
|
||||
const sourceMatch = competitionSource?.match ?? match;
|
||||
if (!this.isEligible(sourceMatch)) {
|
||||
if (competitionSource) {
|
||||
await this.repository.deleteByMatch(matchId, {
|
||||
sourceCompetitionId: competitionSource.sourceCompetitionId,
|
||||
sourceRevision: competitionSource.sourceRevision,
|
||||
});
|
||||
} else {
|
||||
await this.repository.deleteByMatch(matchId);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
const riotIds = [
|
||||
const riotIds = competitionSource?.riotMatchIds ?? [
|
||||
...new Set(
|
||||
(match.result?.games ?? [])
|
||||
.map((game) => game.riotMatchId)
|
||||
@@ -55,7 +77,7 @@ export class MatchStatsService {
|
||||
);
|
||||
const timelineByRiotMatchId = new Map<string, RiotMatchTimelineDto>();
|
||||
for (const doc of riotDocs) {
|
||||
if (isRiotMatchTimelineDto(doc.timeline)) {
|
||||
if (isUsableRiotMatchTimeline(doc.timeline, doc.raw)) {
|
||||
timelineByRiotMatchId.set(doc.matchId, doc.timeline);
|
||||
}
|
||||
}
|
||||
@@ -72,6 +94,12 @@ export class MatchStatsService {
|
||||
doc.matchId,
|
||||
{ region },
|
||||
);
|
||||
if (!isUsableRiotMatchTimeline(timeline, doc.raw)) {
|
||||
this.logger.warn(
|
||||
`Ignored unusable match timeline for ${doc.matchId}.`,
|
||||
);
|
||||
continue;
|
||||
}
|
||||
await RiotMatchModel.updateOne(
|
||||
{ matchId: doc.matchId },
|
||||
{
|
||||
@@ -93,10 +121,9 @@ export class MatchStatsService {
|
||||
}
|
||||
|
||||
const fragment = this.builder.buildFragment({
|
||||
match,
|
||||
match: sourceMatch,
|
||||
rawByRiotMatchId,
|
||||
timelineByRiotMatchId,
|
||||
timelineLoadAttempted: options.includeTimeline === true,
|
||||
});
|
||||
|
||||
await this.repository.upsert({
|
||||
@@ -112,7 +139,19 @@ export class MatchStatsService {
|
||||
gameDetails: fragment.gameDetails,
|
||||
builtAt: new Date(),
|
||||
builderVersion: MATCH_STATS_BUILDER_VERSION,
|
||||
...(competitionSource
|
||||
? {
|
||||
sourceCompetitionId: competitionSource.sourceCompetitionId,
|
||||
sourceRevision: competitionSource.sourceRevision,
|
||||
projectorVersion: competitionSource.projectorVersion,
|
||||
}
|
||||
: {}),
|
||||
});
|
||||
|
||||
// Source reads and the read-model write are intentionally separated by
|
||||
// Riot/timeline work. Revalidate after the write so a concurrent aggregate
|
||||
// deletion cannot resurrect MatchStats after the delete transaction.
|
||||
await this.removeFragmentIfSourceChanged(matchId, competitionSource);
|
||||
}
|
||||
|
||||
public async removeByMatch(matchId: mongoose.Types.ObjectId): Promise<void> {
|
||||
@@ -132,7 +171,10 @@ export class MatchStatsService {
|
||||
const matches = await MatchModel.find({
|
||||
communityId,
|
||||
status: { $in: ['finished', 'in-progress'] },
|
||||
'result.games.0': { $exists: true },
|
||||
$or: [
|
||||
{ competitionId: { $exists: true } },
|
||||
{ 'result.games.0': { $exists: true } },
|
||||
],
|
||||
})
|
||||
.sort({ scheduledAt: -1 })
|
||||
.select({ _id: 1 })
|
||||
@@ -171,15 +213,262 @@ 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(
|
||||
function isUsableRiotMatchTimeline(
|
||||
value: unknown,
|
||||
rawMatch: unknown,
|
||||
): value is RiotMatchTimelineDto {
|
||||
if (!isRecord(value) || !isRecord(value.info)) return false;
|
||||
return Array.isArray(value.info.frames);
|
||||
if (
|
||||
!isRecord(value) ||
|
||||
!isRecord(value.info) ||
|
||||
!isRecord(rawMatch) ||
|
||||
!isRecord(rawMatch.info)
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
const frameInterval = finiteNumber(value.info.frameInterval);
|
||||
const gameDuration = finiteNumber(rawMatch.info.gameDuration);
|
||||
const frames = value.info.frames;
|
||||
if (
|
||||
frameInterval === undefined ||
|
||||
frameInterval <= 0 ||
|
||||
gameDuration === undefined ||
|
||||
gameDuration < 0 ||
|
||||
!Array.isArray(frames) ||
|
||||
frames.length === 0 ||
|
||||
!frames.every(isUsableTimelineFrame)
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const lastTimestamp = Math.max(
|
||||
...frames.map((frame) => (frame as { timestamp: number }).timestamp),
|
||||
);
|
||||
return Math.abs(gameDuration * 1_000 - lastTimestamp) < frameInterval;
|
||||
}
|
||||
|
||||
function isUsableTimelineFrame(value: unknown): boolean {
|
||||
if (
|
||||
!isRecord(value) ||
|
||||
finiteNumber(value.timestamp) === undefined ||
|
||||
!Array.isArray(value.events) ||
|
||||
!value.events.every(
|
||||
(event) =>
|
||||
isRecord(event) &&
|
||||
typeof event.type === 'string' &&
|
||||
finiteNumber(event.timestamp) !== undefined,
|
||||
) ||
|
||||
!isRecord(value.participantFrames)
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
const participantFrames = Object.values(value.participantFrames);
|
||||
return (
|
||||
participantFrames.length > 0 &&
|
||||
participantFrames.every(
|
||||
(participantFrame) =>
|
||||
isRecord(participantFrame) &&
|
||||
finiteNumber(participantFrame.participantId) !== undefined &&
|
||||
finiteNumber(participantFrame.totalGold) !== undefined &&
|
||||
finiteNumber(participantFrame.xp) !== undefined,
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return typeof value === 'object' && value !== null;
|
||||
}
|
||||
|
||||
function competitionStatsSource(
|
||||
match: MatchDocument,
|
||||
competition: {
|
||||
_id: mongoose.Types.ObjectId;
|
||||
revision: number;
|
||||
projectorVersion: number;
|
||||
teams: unknown[];
|
||||
projection: Record<string, unknown>;
|
||||
},
|
||||
): {
|
||||
match: MatchDocument;
|
||||
riotMatchIds: string[];
|
||||
sourceCompetitionId: mongoose.Types.ObjectId;
|
||||
sourceRevision: number;
|
||||
projectorVersion: number;
|
||||
} {
|
||||
const teamIndexById = new Map<string, number>();
|
||||
for (const rawTeam of competition.teams) {
|
||||
if (!isRecord(rawTeam)) continue;
|
||||
const teamId = identifier(rawTeam.teamId);
|
||||
const legacyTeamIndex = finiteNumber(rawTeam.legacyTeamIndex);
|
||||
const displayOrder = finiteNumber(rawTeam.displayOrder);
|
||||
if (teamId && (legacyTeamIndex ?? displayOrder)) {
|
||||
teamIndexById.set(teamId, legacyTeamIndex ?? displayOrder!);
|
||||
}
|
||||
}
|
||||
|
||||
const rawGames = Array.isArray(competition.projection.games)
|
||||
? competition.projection.games
|
||||
: [];
|
||||
const riotMatchIds = new Set<string>();
|
||||
const games = rawGames.flatMap((rawGame, gameIndex) => {
|
||||
if (!isRecord(rawGame)) return [];
|
||||
const teams = isRecord(rawGame.teams) ? rawGame.teams : undefined;
|
||||
const blue = teams && isRecord(teams.blue) ? teams.blue : undefined;
|
||||
const red = teams && isRecord(teams.red) ? teams.red : undefined;
|
||||
const blueTeamId = identifier(blue?.teamId);
|
||||
const redTeamId = identifier(red?.teamId);
|
||||
const winnerTeamId = identifier(rawGame.winnerTeamId);
|
||||
const blueTeamIndex = blueTeamId
|
||||
? teamIndexById.get(blueTeamId)
|
||||
: undefined;
|
||||
const redTeamIndex = redTeamId ? teamIndexById.get(redTeamId) : undefined;
|
||||
const winnerTeamIndex = winnerTeamId
|
||||
? teamIndexById.get(winnerTeamId)
|
||||
: undefined;
|
||||
if (!blueTeamIndex || !redTeamIndex || !winnerTeamIndex) return [];
|
||||
|
||||
const evidence = isRecord(rawGame.evidence) ? rawGame.evidence : undefined;
|
||||
const riotMatchId =
|
||||
evidence?.type === 'riot' && typeof evidence.riotMatchId === 'string'
|
||||
? evidence.riotMatchId
|
||||
: typeof evidence?.legacyReference === 'string'
|
||||
? evidence.legacyReference
|
||||
: `competition:${identifier(rawGame.id) ?? 'game'}`;
|
||||
if (evidence?.type === 'riot') riotMatchIds.add(riotMatchId);
|
||||
const participantValues = Array.isArray(rawGame.participants)
|
||||
? rawGame.participants
|
||||
: [];
|
||||
const participants = participantValues.flatMap((rawParticipant) => {
|
||||
if (!isRecord(rawParticipant)) return [];
|
||||
const userId = identifier(rawParticipant.userId);
|
||||
const teamId = identifier(rawParticipant.teamId);
|
||||
const teamIndex = teamId ? teamIndexById.get(teamId) : undefined;
|
||||
const side = rawParticipant.side;
|
||||
if (
|
||||
!userId ||
|
||||
!mongoose.isValidObjectId(userId) ||
|
||||
!teamIndex ||
|
||||
(side !== 'blue' && side !== 'red')
|
||||
) {
|
||||
return [];
|
||||
}
|
||||
return [
|
||||
{
|
||||
userId: new mongoose.Types.ObjectId(userId),
|
||||
teamIndex,
|
||||
side,
|
||||
championId: finiteNumber(rawParticipant.championId) ?? 0,
|
||||
kills: finiteNumber(rawParticipant.kills) ?? 0,
|
||||
deaths: finiteNumber(rawParticipant.deaths) ?? 0,
|
||||
assists: finiteNumber(rawParticipant.assists) ?? 0,
|
||||
win: teamId === winnerTeamId,
|
||||
},
|
||||
];
|
||||
});
|
||||
const startedAt = dateFromUnknown(rawGame.startedAt);
|
||||
return [
|
||||
{
|
||||
gameNumber: finiteNumber(rawGame.displayNumber) ?? gameIndex + 1,
|
||||
riotMatchId,
|
||||
blueTeamIndex,
|
||||
redTeamIndex,
|
||||
winnerTeamIndex,
|
||||
winnerSide:
|
||||
winnerTeamIndex === blueTeamIndex
|
||||
? ('blue' as const)
|
||||
: ('red' as const),
|
||||
gameCreation: Number.isNaN(startedAt.getTime())
|
||||
? 0
|
||||
: startedAt.getTime(),
|
||||
gameDuration: finiteNumber(rawGame.durationSeconds) ?? 0,
|
||||
participants,
|
||||
},
|
||||
];
|
||||
});
|
||||
const base =
|
||||
typeof match.toObject === 'function' ? match.toObject() : { ...match };
|
||||
return {
|
||||
match: {
|
||||
...base,
|
||||
status:
|
||||
competition.projection.phase === 'completed'
|
||||
? 'finished'
|
||||
: games.length > 0
|
||||
? 'in-progress'
|
||||
: match.status,
|
||||
result: {
|
||||
riotMatchIds: games.map(({ riotMatchId }) => riotMatchId),
|
||||
games,
|
||||
seriesResults: [],
|
||||
},
|
||||
} as unknown as MatchDocument,
|
||||
riotMatchIds: [...riotMatchIds],
|
||||
sourceCompetitionId: competition._id,
|
||||
sourceRevision: competition.revision,
|
||||
projectorVersion: competition.projectorVersion,
|
||||
};
|
||||
}
|
||||
|
||||
function identifier(value: unknown): string | undefined {
|
||||
if (typeof value === 'string' && value.length > 0) return value;
|
||||
if (value instanceof mongoose.Types.ObjectId) return value.toHexString();
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function dateFromUnknown(value: unknown): Date {
|
||||
if (value instanceof Date) return new Date(value.getTime());
|
||||
if (typeof value === 'string' || typeof value === 'number') {
|
||||
return new Date(value);
|
||||
}
|
||||
return new Date(Number.NaN);
|
||||
}
|
||||
|
||||
function finiteNumber(value: unknown): number | undefined {
|
||||
return typeof value === 'number' && Number.isFinite(value)
|
||||
? value
|
||||
: undefined;
|
||||
}
|
||||
@@ -4,7 +4,7 @@ import type {
|
||||
} from '../global/database/schema';
|
||||
import type { InternalMatchCardView } from './community-stats.types';
|
||||
|
||||
export const MATCH_STATS_BUILDER_VERSION = 9;
|
||||
export const MATCH_STATS_BUILDER_VERSION = 10;
|
||||
|
||||
export type InternalRecord = MatchStatsRecord;
|
||||
export type InternalGameDetail = MatchStatsGameDetail;
|
||||
|
||||
@@ -6,10 +6,7 @@ import {
|
||||
} from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import {
|
||||
CommunityDocument,
|
||||
UserDocument,
|
||||
} from '../global/database/schema';
|
||||
import { CommunityDocument, UserDocument } from '../global/database/schema';
|
||||
|
||||
export interface CreateCommunityInput {
|
||||
name: string;
|
||||
|
||||
@@ -0,0 +1,537 @@
|
||||
import { Types } from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import {
|
||||
CompetitionBootstrapError,
|
||||
CompetitionBootstrapService,
|
||||
type CompetitionBootstrapMatch,
|
||||
} from './competition-bootstrap.service';
|
||||
|
||||
describe('CompetitionBootstrapService', () => {
|
||||
it('creates a deterministic paired-Series Competition and immutable snapshots', async () => {
|
||||
const firstHarness = createHarness();
|
||||
const firstService = new CompetitionBootstrapService(
|
||||
firstHarness.connectionService as ConnectionService,
|
||||
);
|
||||
const match = matchSnapshot({ gameMode: 'pair', teamCount: 2 });
|
||||
|
||||
const first = await firstService.bootstrap(match);
|
||||
|
||||
const inserted = firstHarness.insertedPayloads[0];
|
||||
expect(inserted).toMatchObject({
|
||||
_id: expect.any(Types.ObjectId),
|
||||
matchId: MATCH_ID,
|
||||
communityId: COMMUNITY_ID,
|
||||
schemaVersion: 1,
|
||||
projectorVersion: 1,
|
||||
revision: 0,
|
||||
phase: 'ready',
|
||||
format: {
|
||||
type: 'paired-series',
|
||||
rule: { type: 'fixed-games', gameCount: 3, drawPolicy: 'allow' },
|
||||
},
|
||||
});
|
||||
expect(inserted.teams).toEqual([
|
||||
expect.objectContaining({
|
||||
teamId: expect.any(Types.ObjectId),
|
||||
legacyTeamIndex: 1,
|
||||
displayOrder: 1,
|
||||
seedNumber: 1,
|
||||
name: 'Team 1',
|
||||
members: [
|
||||
expect.objectContaining({
|
||||
userId: USER_IDS[0],
|
||||
displayName: 'Player 1#KR1',
|
||||
gameName: 'Player 1',
|
||||
tagLine: 'KR1',
|
||||
profileIconId: 101,
|
||||
assignedPosition: 'TOP',
|
||||
cost: 10,
|
||||
}),
|
||||
],
|
||||
}),
|
||||
expect.objectContaining({
|
||||
teamId: expect.any(Types.ObjectId),
|
||||
legacyTeamIndex: 2,
|
||||
displayOrder: 2,
|
||||
seedNumber: 2,
|
||||
name: 'Team 2',
|
||||
}),
|
||||
]);
|
||||
expect(inserted.seriesGraph).toHaveLength(1);
|
||||
expect(inserted.seriesGraph[0]).toMatchObject({
|
||||
code: 'PAIR_M1',
|
||||
slots: [
|
||||
{
|
||||
position: 'A',
|
||||
source: {
|
||||
type: 'team',
|
||||
teamId: inserted.teams[0].teamId.toString(),
|
||||
},
|
||||
},
|
||||
{
|
||||
position: 'B',
|
||||
source: {
|
||||
type: 'team',
|
||||
teamId: inserted.teams[1].teamId.toString(),
|
||||
},
|
||||
},
|
||||
],
|
||||
});
|
||||
expect(inserted.projection).toMatchObject({
|
||||
competitionId: inserted._id.toString(),
|
||||
sourceRevision: 0,
|
||||
projectorVersion: 1,
|
||||
formatType: 'paired-series',
|
||||
phase: 'ready',
|
||||
});
|
||||
expect(first._id).toEqual(inserted._id);
|
||||
|
||||
const secondHarness = createHarness();
|
||||
const secondService = new CompetitionBootstrapService(
|
||||
secondHarness.connectionService as ConnectionService,
|
||||
);
|
||||
await secondService.bootstrap({
|
||||
...match,
|
||||
teams: [...match.teams].reverse(),
|
||||
participants: [...match.participants].reverse(),
|
||||
});
|
||||
|
||||
const secondInserted = secondHarness.insertedPayloads[0];
|
||||
expect(secondInserted._id).toEqual(inserted._id);
|
||||
expect(secondInserted.teams.map(({ teamId }) => teamId)).toEqual(
|
||||
inserted.teams.map(({ teamId }) => teamId),
|
||||
);
|
||||
expect(secondInserted.seriesGraph).toEqual(inserted.seriesGraph);
|
||||
});
|
||||
|
||||
it('maps round-robin configuration and preserves a limited round count', async () => {
|
||||
const harness = createHarness();
|
||||
const service = new CompetitionBootstrapService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
await service.bootstrap(
|
||||
matchSnapshot({
|
||||
gameMode: 'round-robin',
|
||||
teamCount: 4,
|
||||
gameCount: 2,
|
||||
roundRobinMaxRounds: 2,
|
||||
}),
|
||||
);
|
||||
|
||||
expect(harness.insertedPayloads[0]).toMatchObject({
|
||||
format: {
|
||||
type: 'round-robin',
|
||||
rule: { type: 'fixed-games', gameCount: 2, drawPolicy: 'allow' },
|
||||
maxRounds: 2,
|
||||
tieBreakers: ['series-wins', 'game-diff', 'head-to-head'],
|
||||
},
|
||||
});
|
||||
expect(harness.insertedPayloads[0].seriesGraph).toHaveLength(4);
|
||||
});
|
||||
|
||||
it('maps double elimination seeds and stage-specific Series rules', async () => {
|
||||
const harness = createHarness();
|
||||
const service = new CompetitionBootstrapService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
const match = matchSnapshot({
|
||||
gameMode: 'double-elimination',
|
||||
teamCount: 4,
|
||||
gameCount: 5,
|
||||
});
|
||||
match.doubleElimination = {
|
||||
teamCount: 4,
|
||||
resetFinalEnabled: true,
|
||||
seeds: [
|
||||
{ seedNumber: 1, teamIndex: 3 },
|
||||
{ seedNumber: 2, teamIndex: 1 },
|
||||
{ seedNumber: 3, teamIndex: 4 },
|
||||
{ seedNumber: 4, teamIndex: 2 },
|
||||
],
|
||||
};
|
||||
|
||||
await service.bootstrap(match);
|
||||
|
||||
const inserted = harness.insertedPayloads[0];
|
||||
expect(inserted.format).toEqual({
|
||||
type: 'double-elimination',
|
||||
teamCount: 4,
|
||||
resetFinalEnabled: true,
|
||||
rules: {
|
||||
upper: { type: 'first-to', winsRequired: 3, maxGames: 5 },
|
||||
lower: { type: 'first-to', winsRequired: 1, maxGames: 1 },
|
||||
grandFinal: { type: 'first-to', winsRequired: 1, maxGames: 1 },
|
||||
resetFinal: { type: 'first-to', winsRequired: 1, maxGames: 1 },
|
||||
},
|
||||
});
|
||||
expect(
|
||||
inserted.teams.map(({ legacyTeamIndex, seedNumber }) => ({
|
||||
legacyTeamIndex,
|
||||
seedNumber,
|
||||
})),
|
||||
).toEqual([
|
||||
{ legacyTeamIndex: 1, seedNumber: 2 },
|
||||
{ legacyTeamIndex: 2, seedNumber: 4 },
|
||||
{ legacyTeamIndex: 3, seedNumber: 1 },
|
||||
{ legacyTeamIndex: 4, seedNumber: 3 },
|
||||
]);
|
||||
expect(
|
||||
inserted.seriesGraph.find(({ code }) => code === 'WB_R1_M1').rule,
|
||||
).toEqual({ type: 'first-to', winsRequired: 3, maxGames: 5 });
|
||||
expect(
|
||||
inserted.seriesGraph.find(({ code }) => code?.startsWith('LB_')).rule,
|
||||
).toEqual({ type: 'first-to', winsRequired: 1, maxGames: 1 });
|
||||
expect(inserted.seriesGraph.find(({ code }) => code === 'GF').rule).toEqual(
|
||||
{ type: 'first-to', winsRequired: 1, maxGames: 1 },
|
||||
);
|
||||
expect(
|
||||
inserted.seriesGraph.find(({ code }) => code === 'GF_RESET'),
|
||||
).toMatchObject({
|
||||
rule: { type: 'first-to', winsRequired: 1, maxGames: 1 },
|
||||
activation: { type: 'grand-final-reset-required' },
|
||||
});
|
||||
});
|
||||
|
||||
it('rejects double elimination until authoritative seeds are persisted', async () => {
|
||||
const harness = createHarness();
|
||||
const service = new CompetitionBootstrapService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
await expect(
|
||||
service.bootstrap(
|
||||
matchSnapshot({
|
||||
gameMode: 'double-elimination',
|
||||
teamCount: 4,
|
||||
gameCount: 3,
|
||||
}),
|
||||
),
|
||||
).rejects.toMatchObject({
|
||||
code: 'INVALID_MATCH_TEAM_SNAPSHOT',
|
||||
httpStatus: 422,
|
||||
});
|
||||
|
||||
expect(harness.connectionService.createSession).not.toHaveBeenCalled();
|
||||
expect(harness.competitionModel.findOneAndUpdate).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('rejects incomplete and duplicate team assignments before opening a transaction', async () => {
|
||||
const cases: Array<[string, (match: CompetitionBootstrapMatch) => void]> = [
|
||||
[
|
||||
'the Match lifecycle is still recruiting',
|
||||
(match) => {
|
||||
match.status = 'recruiting';
|
||||
},
|
||||
],
|
||||
[
|
||||
'an active participant is not assigned',
|
||||
(match) => {
|
||||
match.teams[1].members = [];
|
||||
},
|
||||
],
|
||||
[
|
||||
'the same team index is repeated',
|
||||
(match) => {
|
||||
match.teams[1].teamIndex = match.teams[0].teamIndex;
|
||||
},
|
||||
],
|
||||
[
|
||||
'one member is assigned to multiple teams',
|
||||
(match) => {
|
||||
match.teams[1].members[0].userId = match.teams[0].members[0].userId;
|
||||
},
|
||||
],
|
||||
[
|
||||
'a team member has no participant snapshot',
|
||||
(match) => {
|
||||
match.teams[1].members[0].userId = new Types.ObjectId();
|
||||
},
|
||||
],
|
||||
];
|
||||
|
||||
for (const [label, mutate] of cases) {
|
||||
const harness = createHarness();
|
||||
const service = new CompetitionBootstrapService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
const match = matchSnapshot({ gameMode: 'pair', teamCount: 2 });
|
||||
mutate(match);
|
||||
|
||||
await expect(service.bootstrap(match)).rejects.toMatchObject({
|
||||
name: 'CompetitionBootstrapError',
|
||||
code: 'INVALID_MATCH_TEAM_SNAPSHOT',
|
||||
httpStatus: 422,
|
||||
});
|
||||
expect(harness.connectionService.createSession).not.toHaveBeenCalled();
|
||||
expect(harness.competitionModel.findOneAndUpdate).not.toHaveBeenCalled();
|
||||
expect(label).toBeTruthy();
|
||||
}
|
||||
});
|
||||
|
||||
it('rejects bracket mode live but explicitly maps it for legacy migration', async () => {
|
||||
const liveHarness = createHarness();
|
||||
const liveService = new CompetitionBootstrapService(
|
||||
liveHarness.connectionService as ConnectionService,
|
||||
);
|
||||
const match = matchSnapshot({ gameMode: 'bracket', teamCount: 2 });
|
||||
|
||||
await expect(liveService.bootstrap(match)).rejects.toEqual(
|
||||
expect.objectContaining<Partial<CompetitionBootstrapError>>({
|
||||
code: 'UNSUPPORTED_LIVE_MATCH_MODE',
|
||||
httpStatus: 422,
|
||||
}),
|
||||
);
|
||||
|
||||
const migrationHarness = createHarness();
|
||||
const migrationService = new CompetitionBootstrapService(
|
||||
migrationHarness.connectionService as ConnectionService,
|
||||
);
|
||||
await migrationService.bootstrap(match, { source: 'legacy-migration' });
|
||||
|
||||
expect(migrationHarness.insertedPayloads[0].format.type).toBe(
|
||||
'paired-series',
|
||||
);
|
||||
});
|
||||
|
||||
it('upserts once and links only an unlinked or already-linked Match in one transaction', async () => {
|
||||
const harness = createHarness();
|
||||
const service = new CompetitionBootstrapService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
const competition = await service.bootstrap(
|
||||
matchSnapshot({ gameMode: 'pair', teamCount: 2 }),
|
||||
);
|
||||
|
||||
expect(harness.competitionModel.findOneAndUpdate).toHaveBeenCalledWith(
|
||||
{ matchId: MATCH_ID },
|
||||
{ $setOnInsert: harness.insertedPayloads[0] },
|
||||
expect.objectContaining({
|
||||
upsert: true,
|
||||
returnDocument: 'after',
|
||||
setDefaultsOnInsert: true,
|
||||
session: harness.sessions[0],
|
||||
}),
|
||||
);
|
||||
expect(harness.matchModel.updateOne).toHaveBeenCalledWith(
|
||||
{
|
||||
_id: MATCH_ID,
|
||||
status: 'team-built',
|
||||
teamBuiltAt: new Date('2026-07-12T00:05:00.000Z'),
|
||||
$or: [
|
||||
{ competitionId: { $exists: false } },
|
||||
{ competitionId: null },
|
||||
{ competitionId: competition._id },
|
||||
],
|
||||
},
|
||||
{ $set: { competitionId: competition._id } },
|
||||
{ session: harness.sessions[0] },
|
||||
);
|
||||
expect(harness.sessions[0].commitTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.sessions[0].abortTransaction).not.toHaveBeenCalled();
|
||||
expect(harness.sessions[0].endSession).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('reuses an existing Competition without replacing its immutable snapshot', async () => {
|
||||
const existingId = new Types.ObjectId('64b000000000000000000099');
|
||||
const existing = {
|
||||
_id: existingId,
|
||||
matchId: MATCH_ID,
|
||||
teams: [{ name: 'Original immutable team snapshot' }],
|
||||
revision: 4,
|
||||
};
|
||||
const harness = createHarness({ existingCompetition: existing });
|
||||
const service = new CompetitionBootstrapService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
const result = await service.bootstrap(
|
||||
matchSnapshot({ gameMode: 'pair', teamCount: 2 }),
|
||||
);
|
||||
|
||||
expect(result).toBe(existing);
|
||||
expect(harness.competitionModel.findOneAndUpdate.mock.calls[0][1]).toEqual({
|
||||
$setOnInsert: harness.insertedPayloads[0],
|
||||
});
|
||||
expect(harness.matchModel.updateOne.mock.calls[0][1]).toEqual({
|
||||
$set: { competitionId: existingId },
|
||||
});
|
||||
});
|
||||
|
||||
it('retries a duplicate-key bootstrap race and safely converges on the winner', async () => {
|
||||
const duplicateKey = Object.assign(new Error('duplicate key'), {
|
||||
code: 11000,
|
||||
});
|
||||
const winner = {
|
||||
_id: new Types.ObjectId('64b000000000000000000098'),
|
||||
matchId: MATCH_ID,
|
||||
revision: 0,
|
||||
};
|
||||
const harness = createHarness({
|
||||
competitionResults: [duplicateKey, winner],
|
||||
sessionCount: 2,
|
||||
});
|
||||
const service = new CompetitionBootstrapService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
const result = await service.bootstrap(
|
||||
matchSnapshot({ gameMode: 'pair', teamCount: 2 }),
|
||||
);
|
||||
|
||||
expect(result).toBe(winner);
|
||||
expect(harness.connectionService.createSession).toHaveBeenCalledTimes(2);
|
||||
expect(harness.sessions[0].abortTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.sessions[0].commitTransaction).not.toHaveBeenCalled();
|
||||
expect(harness.sessions[0].endSession).toHaveBeenCalledTimes(1);
|
||||
expect(harness.sessions[1].commitTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.matchModel.updateOne).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('aborts when the Match is already linked to a different Competition', async () => {
|
||||
const harness = createHarness({ matchUpdateResult: { matchedCount: 0 } });
|
||||
const service = new CompetitionBootstrapService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
await expect(
|
||||
service.bootstrap(matchSnapshot({ gameMode: 'pair', teamCount: 2 })),
|
||||
).rejects.toMatchObject({
|
||||
code: 'MATCH_COMPETITION_LINK_CONFLICT',
|
||||
httpStatus: 409,
|
||||
});
|
||||
expect(harness.sessions[0].abortTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.sessions[0].commitTransaction).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
const MATCH_ID = new Types.ObjectId('64b000000000000000000001');
|
||||
const COMMUNITY_ID = new Types.ObjectId('64b000000000000000000002');
|
||||
const USER_IDS = Array.from(
|
||||
{ length: 8 },
|
||||
(_, index) =>
|
||||
new Types.ObjectId(
|
||||
`64b0000000000000000001${String(index + 1).padStart(2, '0')}`,
|
||||
),
|
||||
);
|
||||
|
||||
function matchSnapshot(params: {
|
||||
gameMode: CompetitionBootstrapMatch['gameMode'];
|
||||
teamCount: number;
|
||||
gameCount?: number;
|
||||
roundRobinMaxRounds?: number;
|
||||
}): CompetitionBootstrapMatch {
|
||||
const participants = USER_IDS.slice(0, params.teamCount).map(
|
||||
(userId, index) => ({
|
||||
userId,
|
||||
gameName: `Player ${index + 1}`,
|
||||
tagLine: 'KR1',
|
||||
profileIconId: 101 + index,
|
||||
preferredPositions: [],
|
||||
joinedAt: new Date('2026-07-12T00:00:00.000Z'),
|
||||
}),
|
||||
);
|
||||
return {
|
||||
_id: MATCH_ID,
|
||||
communityId: COMMUNITY_ID,
|
||||
status: 'team-built',
|
||||
teamBuiltAt: new Date('2026-07-12T00:05:00.000Z'),
|
||||
gameCount: params.gameCount ?? 3,
|
||||
gameMode: params.gameMode,
|
||||
...(params.roundRobinMaxRounds === undefined
|
||||
? {}
|
||||
: { roundRobinMaxRounds: params.roundRobinMaxRounds }),
|
||||
participants,
|
||||
teams: participants.map((participant, index) => ({
|
||||
teamIndex: index + 1,
|
||||
name: `Team ${index + 1}`,
|
||||
captainUserId: participant.userId,
|
||||
members: [
|
||||
{
|
||||
userId: participant.userId,
|
||||
assignedPosition: 'TOP',
|
||||
cost: 10 + index,
|
||||
},
|
||||
],
|
||||
})),
|
||||
};
|
||||
}
|
||||
|
||||
interface InsertPayload {
|
||||
_id: Types.ObjectId;
|
||||
teams: Array<{
|
||||
teamId: Types.ObjectId;
|
||||
legacyTeamIndex: number;
|
||||
seedNumber: number;
|
||||
}>;
|
||||
seriesGraph: Array<{ code?: string; rule: unknown }>;
|
||||
[key: string]: any;
|
||||
}
|
||||
|
||||
function createHarness(
|
||||
options: {
|
||||
existingCompetition?: Record<string, unknown>;
|
||||
competitionResults?: Array<Record<string, unknown> | Error>;
|
||||
matchUpdateResult?: { matchedCount: number };
|
||||
sessionCount?: number;
|
||||
} = {},
|
||||
) {
|
||||
const sessions = Array.from(
|
||||
{ length: options.sessionCount ?? 1 },
|
||||
createSession,
|
||||
);
|
||||
const insertedPayloads: InsertPayload[] = [];
|
||||
let competitionCall = 0;
|
||||
const competitionModel = {
|
||||
findOneAndUpdate: jest.fn(
|
||||
(_filter: unknown, update: { $setOnInsert: InsertPayload }) => {
|
||||
insertedPayloads.push(update.$setOnInsert);
|
||||
const selected = options.competitionResults?.[competitionCall++];
|
||||
if (selected instanceof Error) return rejectedQuery(selected);
|
||||
return queryResult(
|
||||
selected ?? options.existingCompetition ?? update.$setOnInsert,
|
||||
);
|
||||
},
|
||||
),
|
||||
};
|
||||
const matchModel = {
|
||||
updateOne: jest
|
||||
.fn()
|
||||
.mockResolvedValue(options.matchUpdateResult ?? { matchedCount: 1 }),
|
||||
};
|
||||
const models: Record<string, unknown> = {
|
||||
competition: competitionModel,
|
||||
match: matchModel,
|
||||
};
|
||||
let sessionIndex = 0;
|
||||
const connectionService = {
|
||||
createSession: jest.fn(() => Promise.resolve(sessions[sessionIndex++])),
|
||||
getModel: jest.fn((name: string) => Promise.resolve(models[name])),
|
||||
};
|
||||
|
||||
return {
|
||||
sessions,
|
||||
insertedPayloads,
|
||||
competitionModel,
|
||||
matchModel,
|
||||
connectionService,
|
||||
};
|
||||
}
|
||||
|
||||
function createSession() {
|
||||
return {
|
||||
startTransaction: jest.fn(),
|
||||
commitTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
abortTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
endSession: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
}
|
||||
|
||||
function queryResult<T>(value: T) {
|
||||
return { exec: jest.fn().mockResolvedValue(value) };
|
||||
}
|
||||
|
||||
function rejectedQuery(error: Error) {
|
||||
return { exec: jest.fn().mockRejectedValue(error) };
|
||||
}
|
||||
@@ -0,0 +1,639 @@
|
||||
import { createHash } from 'node:crypto';
|
||||
import { Injectable } from '@nestjs/common';
|
||||
import mongoose, { Types } from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import type {
|
||||
MatchGameMode,
|
||||
MatchParticipant,
|
||||
MatchStatus,
|
||||
MatchTeam,
|
||||
} from '../global/database/schema';
|
||||
import type {
|
||||
CompetitionDocument,
|
||||
CompetitionTeamSnapshot,
|
||||
} from './competition.schema';
|
||||
import {
|
||||
generateSeriesGraph,
|
||||
type CompetitionGraphFormat,
|
||||
type CompetitionGraphTeam,
|
||||
type SeriesDefinition,
|
||||
} from './domain/series-graph';
|
||||
import {
|
||||
projectCompetition,
|
||||
type CompetitionProjection,
|
||||
} from './domain/competition-projector';
|
||||
|
||||
const COMPETITION_SCHEMA_VERSION = 1;
|
||||
const COMPETITION_PROJECTOR_VERSION = 1;
|
||||
const BOOTSTRAP_TRANSACTION_ATTEMPTS = 3;
|
||||
|
||||
export interface CompetitionBootstrapMatch {
|
||||
_id: Types.ObjectId;
|
||||
communityId: Types.ObjectId;
|
||||
competitionId?: Types.ObjectId;
|
||||
status: MatchStatus;
|
||||
teamBuiltAt: Date;
|
||||
gameCount: number;
|
||||
gameMode: MatchGameMode;
|
||||
roundRobinMaxRounds?: number;
|
||||
participants: MatchParticipant[];
|
||||
teams: MatchTeam[];
|
||||
doubleElimination?: {
|
||||
teamCount: 4 | 8;
|
||||
resetFinalEnabled: boolean;
|
||||
seeds: Array<{ seedNumber: number; teamIndex: number }>;
|
||||
};
|
||||
}
|
||||
|
||||
export interface CompetitionBootstrapOptions {
|
||||
/** `bracket` is accepted only by the explicit legacy migration path. */
|
||||
source?: 'live' | 'legacy-migration';
|
||||
}
|
||||
|
||||
export type CompetitionBootstrapErrorCode =
|
||||
| 'INVALID_MATCH_TEAM_SNAPSHOT'
|
||||
| 'INVALID_MATCH_FORMAT'
|
||||
| 'UNSUPPORTED_LIVE_MATCH_MODE'
|
||||
| 'COMPETITION_TRANSACTION_UNAVAILABLE'
|
||||
| 'COMPETITION_BOOTSTRAP_FAILED'
|
||||
| 'COMPETITION_BOOTSTRAP_RACE'
|
||||
| 'MATCH_COMPETITION_LINK_CONFLICT';
|
||||
|
||||
export class CompetitionBootstrapError extends Error {
|
||||
constructor(
|
||||
public readonly code: CompetitionBootstrapErrorCode,
|
||||
message: string,
|
||||
public readonly httpStatus: 409 | 422 | 500,
|
||||
public readonly details?: Readonly<Record<string, unknown>>,
|
||||
) {
|
||||
super(message);
|
||||
this.name = 'CompetitionBootstrapError';
|
||||
}
|
||||
}
|
||||
|
||||
interface CompetitionInsertPayload {
|
||||
_id: Types.ObjectId;
|
||||
matchId: Types.ObjectId;
|
||||
communityId: Types.ObjectId;
|
||||
schemaVersion: number;
|
||||
projectorVersion: number;
|
||||
revision: number;
|
||||
phase: CompetitionProjection['phase'];
|
||||
teams: CompetitionTeamSnapshot[];
|
||||
format: CompetitionGraphFormat;
|
||||
seriesGraph: SeriesDefinition[];
|
||||
projection: CompetitionProjection;
|
||||
}
|
||||
|
||||
/**
|
||||
* Freezes the recruiting Match into the one-to-one Competition aggregate.
|
||||
* Retries only repeat deterministic upserts, so duplicate creators and unknown
|
||||
* commit outcomes converge without replacing an existing immutable snapshot.
|
||||
*/
|
||||
@Injectable()
|
||||
export class CompetitionBootstrapService {
|
||||
constructor(private readonly connectionService: ConnectionService) {}
|
||||
|
||||
public async bootstrap(
|
||||
match: CompetitionBootstrapMatch,
|
||||
options: CompetitionBootstrapOptions = {},
|
||||
): Promise<CompetitionDocument> {
|
||||
const payload = buildCompetitionInsertPayload(
|
||||
match,
|
||||
options.source ?? 'live',
|
||||
);
|
||||
const [CompetitionModel, MatchModel] = await Promise.all([
|
||||
this.connectionService.getModel('competition'),
|
||||
this.connectionService.getModel('match'),
|
||||
]);
|
||||
|
||||
let lastRetryableError: unknown;
|
||||
for (
|
||||
let attempt = 1;
|
||||
attempt <= BOOTSTRAP_TRANSACTION_ATTEMPTS;
|
||||
attempt += 1
|
||||
) {
|
||||
const session = await this.connectionService.createSession();
|
||||
if (!session) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'COMPETITION_TRANSACTION_UNAVAILABLE',
|
||||
'A MongoDB transaction is required to bootstrap a Competition.',
|
||||
500,
|
||||
);
|
||||
}
|
||||
|
||||
try {
|
||||
session.startTransaction();
|
||||
const competition = await CompetitionModel.findOneAndUpdate(
|
||||
{ matchId: match._id },
|
||||
{ $setOnInsert: payload },
|
||||
{
|
||||
upsert: true,
|
||||
returnDocument: 'after',
|
||||
setDefaultsOnInsert: true,
|
||||
session,
|
||||
},
|
||||
).exec();
|
||||
if (!competition) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'COMPETITION_BOOTSTRAP_FAILED',
|
||||
'Competition upsert returned no document.',
|
||||
500,
|
||||
);
|
||||
}
|
||||
|
||||
const linkResult = await MatchModel.updateOne(
|
||||
{
|
||||
_id: match._id,
|
||||
status: match.status,
|
||||
teamBuiltAt: match.teamBuiltAt,
|
||||
$or: [
|
||||
{ competitionId: { $exists: false } },
|
||||
{ competitionId: null },
|
||||
{ competitionId: competition._id },
|
||||
],
|
||||
},
|
||||
{ $set: { competitionId: competition._id } },
|
||||
{ session },
|
||||
);
|
||||
if (linkResult.matchedCount !== 1) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'MATCH_COMPETITION_LINK_CONFLICT',
|
||||
'Match is missing or linked to a different Competition.',
|
||||
409,
|
||||
{ matchId: match._id.toString() },
|
||||
);
|
||||
}
|
||||
|
||||
await session.commitTransaction();
|
||||
return competition;
|
||||
} catch (error) {
|
||||
await session.abortTransaction().catch(() => undefined);
|
||||
if (
|
||||
attempt < BOOTSTRAP_TRANSACTION_ATTEMPTS &&
|
||||
isRetryableBootstrapError(error)
|
||||
) {
|
||||
lastRetryableError = error;
|
||||
continue;
|
||||
}
|
||||
if (isRetryableBootstrapError(error)) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'COMPETITION_BOOTSTRAP_RACE',
|
||||
'Competition bootstrap did not converge after concurrent writes.',
|
||||
409,
|
||||
{ matchId: match._id.toString() },
|
||||
);
|
||||
}
|
||||
throw error;
|
||||
} finally {
|
||||
await session.endSession().catch(() => undefined);
|
||||
}
|
||||
}
|
||||
|
||||
throw new CompetitionBootstrapError(
|
||||
'COMPETITION_BOOTSTRAP_RACE',
|
||||
'Competition bootstrap retry budget was exhausted.',
|
||||
409,
|
||||
{
|
||||
matchId: match._id.toString(),
|
||||
cause:
|
||||
lastRetryableError instanceof Error
|
||||
? lastRetryableError.message
|
||||
: String(lastRetryableError),
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function buildCompetitionInsertPayload(
|
||||
match: CompetitionBootstrapMatch,
|
||||
source: NonNullable<CompetitionBootstrapOptions['source']>,
|
||||
): CompetitionInsertPayload {
|
||||
assertObjectId(match._id, 'Match ID');
|
||||
assertObjectId(match.communityId, 'Community ID');
|
||||
if (match.status === 'recruiting' || !(match.teamBuiltAt instanceof Date)) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'INVALID_MATCH_TEAM_SNAPSHOT',
|
||||
'Competition bootstrap requires a finalized team-built Match lifecycle.',
|
||||
422,
|
||||
);
|
||||
}
|
||||
assertPositiveInteger(match.gameCount, 'Match game count');
|
||||
|
||||
const competitionId = stableObjectId(match._id, 'competition');
|
||||
const teams = snapshotTeams(match, competitionId);
|
||||
const graphTeams = teams.map(
|
||||
({ teamId, displayOrder, seedNumber }): CompetitionGraphTeam => ({
|
||||
teamId: teamId.toString(),
|
||||
displayOrder,
|
||||
seedNumber,
|
||||
}),
|
||||
);
|
||||
const format = mapMatchFormat(match, teams, source);
|
||||
|
||||
let seriesGraph: SeriesDefinition[];
|
||||
let projection: CompetitionProjection;
|
||||
try {
|
||||
seriesGraph = generateSeriesGraph({
|
||||
competitionId: competitionId.toString(),
|
||||
teams: graphTeams,
|
||||
format,
|
||||
});
|
||||
projection = projectCompetition({
|
||||
competitionId: competitionId.toString(),
|
||||
revision: 0,
|
||||
projectorVersion: COMPETITION_PROJECTOR_VERSION,
|
||||
teams: graphTeams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts: [],
|
||||
});
|
||||
} catch (error) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'INVALID_MATCH_FORMAT',
|
||||
error instanceof Error
|
||||
? error.message
|
||||
: 'The Match cannot produce a valid Competition graph.',
|
||||
422,
|
||||
{
|
||||
matchId: match._id.toString(),
|
||||
domainCode: readErrorCode(error),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
return {
|
||||
_id: competitionId,
|
||||
matchId: match._id,
|
||||
communityId: match.communityId,
|
||||
schemaVersion: COMPETITION_SCHEMA_VERSION,
|
||||
projectorVersion: COMPETITION_PROJECTOR_VERSION,
|
||||
revision: 0,
|
||||
phase: projection.phase,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
projection,
|
||||
};
|
||||
}
|
||||
|
||||
function snapshotTeams(
|
||||
match: CompetitionBootstrapMatch,
|
||||
competitionId: Types.ObjectId,
|
||||
): CompetitionTeamSnapshot[] {
|
||||
if (!Array.isArray(match.teams) || match.teams.length < 2) {
|
||||
throw invalidTeamSnapshot(
|
||||
'A Competition requires at least two built teams.',
|
||||
);
|
||||
}
|
||||
if (!Array.isArray(match.participants)) {
|
||||
throw invalidTeamSnapshot('Match participants are missing.');
|
||||
}
|
||||
|
||||
const participantById = new Map<string, MatchParticipant>();
|
||||
for (const participant of match.participants) {
|
||||
const userId = objectIdString(participant?.userId);
|
||||
if (!userId || participantById.has(userId)) {
|
||||
throw invalidTeamSnapshot(
|
||||
'Match participants must have unique ObjectId user identities.',
|
||||
);
|
||||
}
|
||||
participantById.set(userId, participant);
|
||||
}
|
||||
|
||||
const orderedTeams = [...match.teams].sort(
|
||||
(left, right) => left.teamIndex - right.teamIndex,
|
||||
);
|
||||
const teamIndexes = new Set<number>();
|
||||
const assignedUserIds = new Set<string>();
|
||||
const memberCounts = new Set<number>();
|
||||
const snapshots: CompetitionTeamSnapshot[] = [];
|
||||
|
||||
for (const [displayIndex, team] of orderedTeams.entries()) {
|
||||
if (
|
||||
!Number.isInteger(team.teamIndex) ||
|
||||
team.teamIndex < 1 ||
|
||||
teamIndexes.has(team.teamIndex)
|
||||
) {
|
||||
throw invalidTeamSnapshot(
|
||||
'Built teams must have unique positive integer team indexes.',
|
||||
);
|
||||
}
|
||||
teamIndexes.add(team.teamIndex);
|
||||
if (typeof team.name !== 'string' || team.name.trim().length === 0) {
|
||||
throw invalidTeamSnapshot('Every built team needs a non-empty name.');
|
||||
}
|
||||
if (!Array.isArray(team.members) || team.members.length === 0) {
|
||||
throw invalidTeamSnapshot('Every built team needs at least one member.');
|
||||
}
|
||||
memberCounts.add(team.members.length);
|
||||
|
||||
const memberSnapshots = [...team.members]
|
||||
.sort(compareTeamMembers)
|
||||
.map((member) => {
|
||||
const userId = objectIdString(member.userId);
|
||||
const participant = userId ? participantById.get(userId) : undefined;
|
||||
if (
|
||||
!userId ||
|
||||
!participant ||
|
||||
participant.excluded === true ||
|
||||
assignedUserIds.has(userId)
|
||||
) {
|
||||
throw invalidTeamSnapshot(
|
||||
'Every non-excluded participant must be assigned to exactly one team.',
|
||||
);
|
||||
}
|
||||
assignedUserIds.add(userId);
|
||||
|
||||
const gameName = nonEmptyString(participant.gameName);
|
||||
const tagLine = nonEmptyString(participant.tagLine);
|
||||
return {
|
||||
userId: member.userId,
|
||||
displayName: gameName
|
||||
? tagLine
|
||||
? `${gameName}#${tagLine}`
|
||||
: gameName
|
||||
: userId,
|
||||
...(gameName ? { gameName } : {}),
|
||||
...(tagLine ? { tagLine } : {}),
|
||||
...(participant.profileIconId === undefined
|
||||
? {}
|
||||
: { profileIconId: participant.profileIconId }),
|
||||
assignedPosition: member.assignedPosition,
|
||||
...(member.cost === undefined ? {} : { cost: member.cost }),
|
||||
};
|
||||
});
|
||||
|
||||
if (team.captainUserId) {
|
||||
const captainUserId = team.captainUserId.toString();
|
||||
if (
|
||||
!memberSnapshots.some(
|
||||
({ userId }) => userId.toString() === captainUserId,
|
||||
)
|
||||
) {
|
||||
throw invalidTeamSnapshot('A team captain must belong to that team.');
|
||||
}
|
||||
}
|
||||
|
||||
snapshots.push({
|
||||
teamId: stableObjectId(
|
||||
competitionId,
|
||||
'team',
|
||||
`legacy-team-index:${team.teamIndex}`,
|
||||
),
|
||||
legacyTeamIndex: team.teamIndex,
|
||||
displayOrder: displayIndex + 1,
|
||||
seedNumber: displayIndex + 1,
|
||||
name: team.name.trim(),
|
||||
...(team.captainUserId ? { captainUserId: team.captainUserId } : {}),
|
||||
members: memberSnapshots,
|
||||
});
|
||||
}
|
||||
|
||||
if (memberCounts.size !== 1) {
|
||||
throw invalidTeamSnapshot(
|
||||
'All built teams must have the same member count.',
|
||||
);
|
||||
}
|
||||
const activeParticipantIds = [...participantById]
|
||||
.filter(([, participant]) => participant.excluded !== true)
|
||||
.map(([userId]) => userId);
|
||||
if (
|
||||
activeParticipantIds.length !== assignedUserIds.size ||
|
||||
activeParticipantIds.some((userId) => !assignedUserIds.has(userId))
|
||||
) {
|
||||
throw invalidTeamSnapshot(
|
||||
'Every non-excluded participant must be assigned to exactly one team.',
|
||||
);
|
||||
}
|
||||
|
||||
applySeeds(match, snapshots);
|
||||
return snapshots;
|
||||
}
|
||||
|
||||
function applySeeds(
|
||||
match: CompetitionBootstrapMatch,
|
||||
teams: CompetitionTeamSnapshot[],
|
||||
): void {
|
||||
if (match.gameMode !== 'double-elimination') return;
|
||||
const configuredSeeds = match.doubleElimination?.seeds ?? [];
|
||||
if (configuredSeeds.length === 0) {
|
||||
throw invalidTeamSnapshot(
|
||||
'Double-elimination seeds must be finalized before Competition bootstrap.',
|
||||
);
|
||||
}
|
||||
if (configuredSeeds.length !== teams.length) {
|
||||
throw invalidTeamSnapshot(
|
||||
'Double-elimination seeds must include every built team exactly once.',
|
||||
);
|
||||
}
|
||||
|
||||
const validTeamIndexes = new Set(
|
||||
teams.map(({ legacyTeamIndex }) => legacyTeamIndex as number),
|
||||
);
|
||||
const seedByTeamIndex = new Map<number, number>();
|
||||
const seedNumbers = new Set<number>();
|
||||
for (const seed of configuredSeeds) {
|
||||
if (
|
||||
!Number.isInteger(seed.seedNumber) ||
|
||||
seed.seedNumber < 1 ||
|
||||
seed.seedNumber > teams.length ||
|
||||
seedNumbers.has(seed.seedNumber) ||
|
||||
!validTeamIndexes.has(seed.teamIndex) ||
|
||||
seedByTeamIndex.has(seed.teamIndex)
|
||||
) {
|
||||
throw invalidTeamSnapshot(
|
||||
'Double-elimination seeds must be unique and contiguous.',
|
||||
);
|
||||
}
|
||||
seedNumbers.add(seed.seedNumber);
|
||||
seedByTeamIndex.set(seed.teamIndex, seed.seedNumber);
|
||||
}
|
||||
for (const team of teams) {
|
||||
team.seedNumber = seedByTeamIndex.get(team.legacyTeamIndex as number)!;
|
||||
}
|
||||
}
|
||||
|
||||
function mapMatchFormat(
|
||||
match: CompetitionBootstrapMatch,
|
||||
teams: CompetitionTeamSnapshot[],
|
||||
source: NonNullable<CompetitionBootstrapOptions['source']>,
|
||||
): CompetitionGraphFormat {
|
||||
switch (match.gameMode) {
|
||||
case 'pair':
|
||||
return fixedGameFormat('paired-series', match.gameCount);
|
||||
case 'bracket':
|
||||
if (source !== 'legacy-migration') {
|
||||
throw new CompetitionBootstrapError(
|
||||
'UNSUPPORTED_LIVE_MATCH_MODE',
|
||||
'Legacy bracket mode can only be bootstrapped by migration.',
|
||||
422,
|
||||
);
|
||||
}
|
||||
return fixedGameFormat('paired-series', match.gameCount);
|
||||
case 'round-robin':
|
||||
if (
|
||||
match.roundRobinMaxRounds !== undefined &&
|
||||
(!Number.isInteger(match.roundRobinMaxRounds) ||
|
||||
match.roundRobinMaxRounds < 1)
|
||||
) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'INVALID_MATCH_FORMAT',
|
||||
'Round-robin max rounds must be a positive integer.',
|
||||
422,
|
||||
);
|
||||
}
|
||||
return {
|
||||
type: 'round-robin',
|
||||
rule: fixedGamesRule(match.gameCount),
|
||||
...(match.roundRobinMaxRounds === undefined
|
||||
? {}
|
||||
: { maxRounds: match.roundRobinMaxRounds }),
|
||||
tieBreakers: ['series-wins', 'game-diff', 'head-to-head'],
|
||||
};
|
||||
case 'double-elimination': {
|
||||
if (teams.length !== 4 && teams.length !== 8) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'INVALID_MATCH_FORMAT',
|
||||
'Double elimination supports only four or eight teams.',
|
||||
422,
|
||||
);
|
||||
}
|
||||
if (
|
||||
match.doubleElimination?.teamCount !== undefined &&
|
||||
match.doubleElimination.teamCount !== teams.length
|
||||
) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'INVALID_MATCH_FORMAT',
|
||||
'Double-elimination team count does not match the built teams.',
|
||||
422,
|
||||
);
|
||||
}
|
||||
const bestOfOne = {
|
||||
type: 'first-to' as const,
|
||||
winsRequired: 1,
|
||||
maxGames: 1,
|
||||
};
|
||||
return {
|
||||
type: 'double-elimination',
|
||||
teamCount: teams.length,
|
||||
resetFinalEnabled: match.doubleElimination?.resetFinalEnabled ?? false,
|
||||
rules: {
|
||||
upper: {
|
||||
type: 'first-to',
|
||||
winsRequired: Math.floor(match.gameCount / 2) + 1,
|
||||
maxGames: match.gameCount,
|
||||
},
|
||||
lower: { ...bestOfOne },
|
||||
grandFinal: { ...bestOfOne },
|
||||
resetFinal: { ...bestOfOne },
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function fixedGameFormat(
|
||||
type: 'paired-series',
|
||||
gameCount: number,
|
||||
): Extract<CompetitionGraphFormat, { type: 'paired-series' }> {
|
||||
return { type, rule: fixedGamesRule(gameCount) };
|
||||
}
|
||||
|
||||
function fixedGamesRule(gameCount: number) {
|
||||
return {
|
||||
type: 'fixed-games' as const,
|
||||
gameCount,
|
||||
drawPolicy: 'allow' as const,
|
||||
};
|
||||
}
|
||||
|
||||
function stableObjectId(
|
||||
namespaceId: Types.ObjectId,
|
||||
entityKind: string,
|
||||
...logicalKey: string[]
|
||||
): Types.ObjectId {
|
||||
const hex = createHash('sha256')
|
||||
.update(JSON.stringify([namespaceId.toString(), entityKind, ...logicalKey]))
|
||||
.digest('hex')
|
||||
.slice(0, 24);
|
||||
return new Types.ObjectId(hex);
|
||||
}
|
||||
|
||||
function compareTeamMembers(
|
||||
left: MatchTeam['members'][number],
|
||||
right: MatchTeam['members'][number],
|
||||
): number {
|
||||
const positionOrder = ['TOP', 'JGL', 'MID', 'ADC', 'SUP'];
|
||||
return (
|
||||
positionOrder.indexOf(left.assignedPosition) -
|
||||
positionOrder.indexOf(right.assignedPosition) ||
|
||||
left.userId.toString().localeCompare(right.userId.toString())
|
||||
);
|
||||
}
|
||||
|
||||
function invalidTeamSnapshot(message: string): CompetitionBootstrapError {
|
||||
return new CompetitionBootstrapError(
|
||||
'INVALID_MATCH_TEAM_SNAPSHOT',
|
||||
message,
|
||||
422,
|
||||
);
|
||||
}
|
||||
|
||||
function assertPositiveInteger(value: number, label: string): void {
|
||||
if (!Number.isInteger(value) || value < 1) {
|
||||
throw new CompetitionBootstrapError(
|
||||
'INVALID_MATCH_FORMAT',
|
||||
`${label} must be a positive integer.`,
|
||||
422,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function assertObjectId(
|
||||
value: unknown,
|
||||
label: string,
|
||||
): asserts value is Types.ObjectId {
|
||||
if (!(value instanceof mongoose.Types.ObjectId)) {
|
||||
throw invalidTeamSnapshot(`${label} must be a MongoDB ObjectId.`);
|
||||
}
|
||||
}
|
||||
|
||||
function objectIdString(value: unknown): string | undefined {
|
||||
return value instanceof mongoose.Types.ObjectId
|
||||
? value.toString()
|
||||
: undefined;
|
||||
}
|
||||
|
||||
function nonEmptyString(value: unknown): string | undefined {
|
||||
if (typeof value !== 'string') return undefined;
|
||||
const trimmed = value.trim();
|
||||
return trimmed.length > 0 ? trimmed : undefined;
|
||||
}
|
||||
|
||||
function readErrorCode(error: unknown): string | undefined {
|
||||
if (
|
||||
typeof error === 'object' &&
|
||||
error !== null &&
|
||||
'code' in error &&
|
||||
typeof error.code === 'string'
|
||||
) {
|
||||
return error.code;
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function isRetryableBootstrapError(error: unknown): boolean {
|
||||
const candidate = error as {
|
||||
code?: number;
|
||||
codeName?: string;
|
||||
hasErrorLabel?: (label: string) => boolean;
|
||||
};
|
||||
return Boolean(
|
||||
candidate?.code === 11000 ||
|
||||
candidate?.code === 112 ||
|
||||
candidate?.codeName === 'WriteConflict' ||
|
||||
candidate?.hasErrorLabel?.('TransientTransactionError') ||
|
||||
candidate?.hasErrorLabel?.('UnknownTransactionCommitResult'),
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,787 @@
|
||||
import { Types } from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import { CompetitionCommandService } from './competition-command.service';
|
||||
import { projectCompetition } from './domain/competition-projector';
|
||||
|
||||
jest.mock('./domain/competition-projector', () => ({
|
||||
projectCompetition: jest.fn(),
|
||||
}));
|
||||
|
||||
const mockedProjectCompetition = jest.mocked(projectCompetition);
|
||||
|
||||
describe('CompetitionCommandService', () => {
|
||||
beforeEach(() => {
|
||||
jest.useFakeTimers().setSystemTime(new Date('2026-07-12T10:00:00.000Z'));
|
||||
mockedProjectCompetition.mockReset();
|
||||
mockedProjectCompetition.mockReturnValue(PROJECTION as never);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
jest.useRealTimers();
|
||||
});
|
||||
|
||||
it('rejects a stale expected revision and aborts without writing', async () => {
|
||||
const harness = createHarness({ competitionRevision: 8 });
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
await expect(service.acceptGame(acceptGameCommand())).rejects.toMatchObject(
|
||||
{
|
||||
code: 'STALE_COMPETITION_REVISION',
|
||||
httpStatus: 412,
|
||||
details: { expectedRevision: 7, actualRevision: 8 },
|
||||
},
|
||||
);
|
||||
|
||||
expect(harness.factModel.insertMany).not.toHaveBeenCalled();
|
||||
expect(harness.competitionModel.findOneAndUpdate).not.toHaveBeenCalled();
|
||||
expect(harness.outboxModel.insertMany).not.toHaveBeenCalled();
|
||||
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.session.commitTransaction).not.toHaveBeenCalled();
|
||||
expect(harness.session.endSession).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('uses the expected revision in the persistence CAS and aborts a lost race', async () => {
|
||||
const harness = createHarness({ casResult: null });
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
await expect(service.acceptGame(acceptGameCommand())).rejects.toMatchObject(
|
||||
{
|
||||
code: 'STALE_COMPETITION_REVISION',
|
||||
httpStatus: 412,
|
||||
},
|
||||
);
|
||||
|
||||
const [casFilter, casUpdate, casOptions] = harness.competitionModel
|
||||
.findOneAndUpdate.mock.calls[0] as unknown as [
|
||||
Record<string, unknown>,
|
||||
{ $inc: Record<string, unknown>; $set: Record<string, unknown> },
|
||||
Record<string, unknown>,
|
||||
];
|
||||
expect(casFilter).toEqual({ _id: COMPETITION_ID, revision: 7 });
|
||||
expect(casUpdate).toMatchObject({
|
||||
$inc: { revision: 1 },
|
||||
$set: { projection: PROJECTION },
|
||||
});
|
||||
expect(casOptions).toMatchObject({
|
||||
returnDocument: 'after',
|
||||
session: harness.session,
|
||||
});
|
||||
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.session.commitTransaction).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('replays an exact Idempotency-Key request without appending a second fact', async () => {
|
||||
const harness = createHarness();
|
||||
let storedReceipt: Record<string, unknown> | null = null;
|
||||
harness.outboxModel.findOne.mockImplementation(() =>
|
||||
queryResult(storedReceipt),
|
||||
);
|
||||
harness.outboxModel.insertMany.mockImplementation(
|
||||
([receipt]: Array<Record<string, unknown>>) => {
|
||||
storedReceipt = receipt;
|
||||
return Promise.resolve([receipt]);
|
||||
},
|
||||
);
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
const command = acceptGameCommand();
|
||||
|
||||
const first = await service.acceptGame(command);
|
||||
const replay = await service.acceptGame(command);
|
||||
|
||||
expect(first).toMatchObject({ revision: 8, replayed: false });
|
||||
expect(replay).toMatchObject({
|
||||
commandId: first.commandId,
|
||||
revision: 8,
|
||||
replayed: true,
|
||||
});
|
||||
expect(replay.competition).toEqual(first.competition);
|
||||
expect(harness.factModel.insertMany).toHaveBeenCalledTimes(1);
|
||||
expect(harness.competitionModel.findOneAndUpdate).toHaveBeenCalledTimes(1);
|
||||
expect(harness.outboxModel.insertMany).toHaveBeenCalledTimes(1);
|
||||
expect(mockedProjectCompetition).toHaveBeenCalledTimes(1);
|
||||
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(2);
|
||||
expect(harness.session.abortTransaction).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('replays a concurrently committed identical command after a duplicate-key race', async () => {
|
||||
const harness = createHarness();
|
||||
let committedReceipt: Record<string, unknown> | null = null;
|
||||
harness.outboxModel.findOne.mockImplementation(() =>
|
||||
queryResult(committedReceipt),
|
||||
);
|
||||
harness.factModel.insertMany.mockImplementationOnce(
|
||||
async ([fact]: Array<Record<string, unknown>>) => {
|
||||
committedReceipt = {
|
||||
competitionId: COMPETITION_ID,
|
||||
idempotencyKey: fact.idempotencyKey,
|
||||
requestHash: fact.requestHash,
|
||||
commandId: fact.commandId,
|
||||
revision: fact.revision,
|
||||
payload: {
|
||||
projection: PROJECTION,
|
||||
phase: PROJECTION.phase,
|
||||
},
|
||||
};
|
||||
throw Object.assign(new Error('duplicate command fact'), {
|
||||
code: 11_000,
|
||||
});
|
||||
},
|
||||
);
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
await expect(
|
||||
service.acceptGame(acceptGameCommand()),
|
||||
).resolves.toMatchObject({
|
||||
revision: 8,
|
||||
replayed: true,
|
||||
});
|
||||
|
||||
expect(harness.connectionService.createSession).toHaveBeenCalledTimes(2);
|
||||
expect(harness.factModel.insertMany).toHaveBeenCalledTimes(1);
|
||||
expect(harness.competitionModel.findOneAndUpdate).not.toHaveBeenCalled();
|
||||
expect(harness.outboxModel.insertMany).not.toHaveBeenCalled();
|
||||
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('rejects the same Idempotency-Key when its payload hash differs', async () => {
|
||||
const harness = createHarness();
|
||||
harness.outboxModel.findOne.mockReturnValue(
|
||||
queryResult({
|
||||
idempotencyKey: 'riot:KR_7000000001',
|
||||
requestHash: 'a-different-payload-hash',
|
||||
commandId: 'cmpcmd_original',
|
||||
revision: 8,
|
||||
}),
|
||||
);
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
await expect(service.acceptGame(acceptGameCommand())).rejects.toMatchObject(
|
||||
{
|
||||
code: 'IDEMPOTENCY_KEY_CONFLICT',
|
||||
httpStatus: 409,
|
||||
},
|
||||
);
|
||||
|
||||
expect(harness.competitionModel.findById).not.toHaveBeenCalled();
|
||||
expect(harness.factModel.insertMany).not.toHaveBeenCalled();
|
||||
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('atomically accepts a code-backed game, projects it, and enqueues an event', async () => {
|
||||
const harness = createHarness();
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
const command = {
|
||||
...acceptGameCommand(),
|
||||
tournamentCode: {
|
||||
tournamentCodeId: TOURNAMENT_CODE_ID,
|
||||
riotMatchId: 'KR_7000000001',
|
||||
},
|
||||
};
|
||||
|
||||
const result = await service.acceptGame(command);
|
||||
|
||||
expect(result).toMatchObject({ revision: 8, replayed: false });
|
||||
expect(harness.session.startTransaction).toHaveBeenCalledTimes(1);
|
||||
const [insertedFacts, factOptions] = harness.factModel.insertMany.mock
|
||||
.calls[0] as unknown as [
|
||||
Array<Record<string, unknown>>,
|
||||
Record<string, unknown>,
|
||||
];
|
||||
expect(insertedFacts).toHaveLength(1);
|
||||
expect(insertedFacts[0]).toMatchObject({
|
||||
type: 'game-accepted',
|
||||
revision: 8,
|
||||
ordinalWithinRevision: 1,
|
||||
gameId: GAME_ID,
|
||||
seriesId: SERIES_ID,
|
||||
gameSlotId: GAME_SLOT_ID,
|
||||
startedAt: new Date('2026-07-12T09:30:00.000Z'),
|
||||
durationSeconds: 1_800,
|
||||
participants: [
|
||||
{
|
||||
userId: USER_ID.toHexString(),
|
||||
teamId: TEAM_A_ID.toHexString(),
|
||||
side: 'blue',
|
||||
},
|
||||
],
|
||||
});
|
||||
expect(factOptions).toEqual({ session: harness.session });
|
||||
|
||||
const projectionInput = mockedProjectCompetition.mock.calls[0][0];
|
||||
const projectedFact = projectionInput.facts[0] as Record<string, unknown>;
|
||||
const projectedMapping = projectedFact.mapping as Record<string, unknown>;
|
||||
expect(projectionInput.competitionId).toBe(COMPETITION_ID.toHexString());
|
||||
expect(projectionInput.revision).toBe(8);
|
||||
expect(typeof projectedFact.id).toBe('string');
|
||||
expect(projectedFact).toMatchObject({
|
||||
type: 'game-accepted',
|
||||
seriesId: SERIES_ID.toHexString(),
|
||||
});
|
||||
expect(projectedMapping.winnerTeamId).toBe(TEAM_A_ID.toHexString());
|
||||
|
||||
const [assignmentFilter, assignmentUpdate, assignmentOptions] = harness
|
||||
.assignmentModel.updateOne.mock.calls[0] as unknown as [
|
||||
Record<string, unknown>,
|
||||
{ $set: Record<string, unknown> },
|
||||
Record<string, unknown>,
|
||||
];
|
||||
expect(assignmentFilter).toMatchObject({
|
||||
competitionId: COMPETITION_ID,
|
||||
gameSlotId: GAME_SLOT_ID,
|
||||
tournamentCodeId: TOURNAMENT_CODE_ID,
|
||||
state: 'reserved',
|
||||
});
|
||||
expect(assignmentUpdate.$set.state).toBe('used');
|
||||
expect(assignmentOptions).toEqual({ session: harness.session });
|
||||
|
||||
const [codeFilter, codeUpdate, codeOptions] = harness.tournamentCodeModel
|
||||
.updateOne.mock.calls[0] as unknown as [
|
||||
Record<string, unknown>,
|
||||
{ $set: Record<string, unknown> },
|
||||
Record<string, unknown>,
|
||||
];
|
||||
expect(codeFilter).toEqual({
|
||||
_id: TOURNAMENT_CODE_ID,
|
||||
state: 'reserved',
|
||||
});
|
||||
expect(codeUpdate.$set.state).toBe('used');
|
||||
expect(codeOptions).toEqual({ session: harness.session });
|
||||
|
||||
const [outboxRecords, outboxOptions] = harness.outboxModel.insertMany.mock
|
||||
.calls[0] as unknown as [
|
||||
Array<Record<string, unknown>>,
|
||||
Record<string, unknown>,
|
||||
];
|
||||
expect(outboxRecords).toHaveLength(1);
|
||||
expect(outboxRecords[0]).toMatchObject({
|
||||
revision: 8,
|
||||
type: 'competition.projection-updated',
|
||||
state: 'pending',
|
||||
payload: { projection: PROJECTION },
|
||||
});
|
||||
expect(outboxOptions).toEqual({ session: harness.session });
|
||||
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.session.abortTransaction).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('appends an administrative adjudication through the same command runner', async () => {
|
||||
const harness = createHarness();
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
const result = await service.adjudicateSeries({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
idempotencyKey: 'admin:series:walkover:1',
|
||||
actor: { type: 'user', userId: USER_ID },
|
||||
seriesId: SERIES_ID,
|
||||
decision: { type: 'walkover', winnerTeamId: TEAM_B_ID },
|
||||
reason: 'Opponent did not appear before the deadline.',
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({ revision: 8, replayed: false });
|
||||
expect(harness.factModel.insertMany).toHaveBeenCalledWith(
|
||||
[
|
||||
expect.objectContaining({
|
||||
type: 'series-adjudicated',
|
||||
seriesId: SERIES_ID,
|
||||
decision: { type: 'walkover', winnerTeamId: TEAM_B_ID },
|
||||
reason: 'Opponent did not appear before the deadline.',
|
||||
}),
|
||||
],
|
||||
{ session: harness.session },
|
||||
);
|
||||
expect(harness.assignmentModel.updateOne).not.toHaveBeenCalled();
|
||||
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('previews a strict or cascade reversal against the requested revision', async () => {
|
||||
const reversal = reversalFixture();
|
||||
const harness = createHarness({
|
||||
competition: reversal.competition,
|
||||
facts: reversal.facts,
|
||||
assignments: reversal.assignments,
|
||||
});
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
const preview = await service.previewSeriesReversal({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
seriesId: reversal.parentSeriesId,
|
||||
mode: 'cascade',
|
||||
});
|
||||
|
||||
expect(preview).toMatchObject({
|
||||
sourceRevision: 7,
|
||||
impactHash: expect.stringMatching(/^[a-f0-9]{64}$/),
|
||||
impact: {
|
||||
seriesIds: [
|
||||
reversal.parentSeriesId.toHexString(),
|
||||
reversal.childSeriesId.toHexString(),
|
||||
],
|
||||
factIds: [
|
||||
reversal.parentFactId.toHexString(),
|
||||
reversal.childFactId.toHexString(),
|
||||
],
|
||||
releasesReservedCodes: 1,
|
||||
voidsUsedCodes: 1,
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it('rejects a reversal preview at a stale revision', async () => {
|
||||
const reversal = reversalFixture();
|
||||
const harness = createHarness({ competition: reversal.competition });
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
|
||||
await expect(
|
||||
service.previewSeriesReversal({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 6,
|
||||
seriesId: reversal.parentSeriesId,
|
||||
mode: 'strict',
|
||||
}),
|
||||
).rejects.toMatchObject({
|
||||
code: 'STALE_COMPETITION_REVISION',
|
||||
httpStatus: 412,
|
||||
});
|
||||
});
|
||||
|
||||
it('hash-confirms and atomically appends cascade reversal facts', async () => {
|
||||
const reversal = reversalFixture();
|
||||
const harness = createHarness({
|
||||
competition: reversal.competition,
|
||||
facts: reversal.facts,
|
||||
assignments: reversal.assignments,
|
||||
});
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
const preview = await service.previewSeriesReversal({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
seriesId: reversal.parentSeriesId,
|
||||
mode: 'cascade',
|
||||
});
|
||||
|
||||
const result = await service.reverseSeries({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
idempotencyKey: 'admin:reverse:1',
|
||||
actor: { type: 'user', userId: USER_ID },
|
||||
seriesId: reversal.parentSeriesId,
|
||||
mode: 'cascade',
|
||||
reason: 'Wrong result ingestion',
|
||||
impactHash: preview.impactHash,
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({ revision: 8, replayed: false });
|
||||
expect(harness.factModel.insertMany).toHaveBeenCalledWith(
|
||||
[
|
||||
expect.objectContaining({
|
||||
_id: expect.any(Types.ObjectId),
|
||||
type: 'game-voided',
|
||||
gameAcceptedFactId: reversal.parentFactId,
|
||||
revision: 8,
|
||||
ordinalWithinRevision: 1,
|
||||
reason: 'Wrong result ingestion',
|
||||
}),
|
||||
expect.objectContaining({
|
||||
_id: expect.any(Types.ObjectId),
|
||||
type: 'game-voided',
|
||||
gameAcceptedFactId: reversal.childFactId,
|
||||
revision: 8,
|
||||
ordinalWithinRevision: 2,
|
||||
}),
|
||||
],
|
||||
{ session: harness.session },
|
||||
);
|
||||
expect(harness.assignmentModel.updateMany).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
competitionId: COMPETITION_ID,
|
||||
gameSlotId: {
|
||||
$in: expect.arrayContaining([
|
||||
reversal.parentGameSlotId,
|
||||
reversal.childGameSlotId,
|
||||
]),
|
||||
},
|
||||
}),
|
||||
expect.any(Array),
|
||||
{ session: harness.session },
|
||||
);
|
||||
expect(harness.tournamentCodeModel.updateMany).toHaveBeenCalled();
|
||||
expect(harness.matchModel.updateOne).toHaveBeenCalledWith(
|
||||
{ _id: reversal.competition.matchId },
|
||||
{
|
||||
$pull: {
|
||||
tournamentCodeIds: {
|
||||
$in: [reversal.parentCodeId, reversal.childCodeId],
|
||||
},
|
||||
},
|
||||
},
|
||||
{ session: harness.session },
|
||||
);
|
||||
const [, codeReversalPipeline] = harness.tournamentCodeModel.updateMany.mock
|
||||
.calls[0] as unknown as [
|
||||
Record<string, unknown>,
|
||||
Array<Record<string, any>>,
|
||||
];
|
||||
expect(codeReversalPipeline[0].$set).toMatchObject({
|
||||
state: {
|
||||
$cond: [{ $eq: ['$state', 'reserved'] }, 'released', 'voided'],
|
||||
},
|
||||
matchId: {
|
||||
$cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$matchId'],
|
||||
},
|
||||
gameNumber: {
|
||||
$cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$gameNumber'],
|
||||
},
|
||||
bracketMatchId: {
|
||||
$cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$bracketMatchId'],
|
||||
},
|
||||
reservedAt: {
|
||||
$cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$reservedAt'],
|
||||
},
|
||||
});
|
||||
expect(harness.competitionModel.findOneAndUpdate).toHaveBeenCalledWith(
|
||||
{ _id: COMPETITION_ID, revision: 7 },
|
||||
expect.objectContaining({ $inc: { revision: 1 } }),
|
||||
expect.objectContaining({ session: harness.session }),
|
||||
);
|
||||
expect(harness.outboxModel.insertMany).toHaveBeenCalledTimes(1);
|
||||
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('retries a cascade reversal after a transient transaction conflict', async () => {
|
||||
const reversal = reversalFixture();
|
||||
const harness = createHarness({
|
||||
competition: reversal.competition,
|
||||
facts: reversal.facts,
|
||||
assignments: reversal.assignments,
|
||||
});
|
||||
harness.factModel.insertMany
|
||||
.mockRejectedValueOnce(
|
||||
Object.assign(new Error('write conflict'), {
|
||||
code: 112,
|
||||
codeName: 'WriteConflict',
|
||||
}),
|
||||
)
|
||||
.mockResolvedValueOnce([]);
|
||||
const service = new CompetitionCommandService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
const preview = await service.previewSeriesReversal({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
seriesId: reversal.parentSeriesId,
|
||||
mode: 'cascade',
|
||||
});
|
||||
|
||||
await expect(
|
||||
service.reverseSeries({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
idempotencyKey: 'admin:reverse:transient-retry',
|
||||
actor: { type: 'user', userId: USER_ID },
|
||||
seriesId: reversal.parentSeriesId,
|
||||
mode: 'cascade',
|
||||
reason: 'Wrong result ingestion',
|
||||
impactHash: preview.impactHash,
|
||||
}),
|
||||
).resolves.toMatchObject({ revision: 8, replayed: false });
|
||||
|
||||
expect(harness.connectionService.createSession).toHaveBeenCalledTimes(2);
|
||||
expect(harness.factModel.insertMany).toHaveBeenCalledTimes(2);
|
||||
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
});
|
||||
|
||||
const COMPETITION_ID = new Types.ObjectId('64b000000000000000000001');
|
||||
const SERIES_ID = new Types.ObjectId('64b000000000000000000002');
|
||||
const GAME_SLOT_ID = new Types.ObjectId('64b000000000000000000003');
|
||||
const GAME_ID = new Types.ObjectId('64b000000000000000000004');
|
||||
const TEAM_A_ID = new Types.ObjectId('64b000000000000000000005');
|
||||
const TEAM_B_ID = new Types.ObjectId('64b000000000000000000006');
|
||||
const USER_ID = new Types.ObjectId('64b000000000000000000007');
|
||||
const TOURNAMENT_CODE_ID = new Types.ObjectId('64b000000000000000000008');
|
||||
|
||||
const PROJECTION = {
|
||||
sourceRevision: 8,
|
||||
projectorVersion: 1,
|
||||
phase: 'running',
|
||||
formatType: 'paired-series',
|
||||
series: [],
|
||||
games: [],
|
||||
gameSlots: [],
|
||||
rounds: [],
|
||||
connectors: [],
|
||||
};
|
||||
|
||||
function acceptGameCommand() {
|
||||
return {
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
idempotencyKey: 'riot:KR_7000000001',
|
||||
actor: { type: 'system' as const },
|
||||
occurredAt: new Date('2026-07-12T09:59:00.000Z'),
|
||||
gameId: GAME_ID,
|
||||
seriesId: SERIES_ID,
|
||||
gameSlotId: GAME_SLOT_ID,
|
||||
ordinal: 1,
|
||||
evidence: {
|
||||
type: 'riot' as const,
|
||||
riotMatchId: 'KR_7000000001',
|
||||
payloadHash: 'sha256:riot-payload',
|
||||
},
|
||||
mapping: {
|
||||
mappingVersion: 1,
|
||||
confidence: 1,
|
||||
blueTeamId: TEAM_A_ID,
|
||||
redTeamId: TEAM_B_ID,
|
||||
winnerTeamId: TEAM_A_ID,
|
||||
participantAssignments: [],
|
||||
},
|
||||
startedAt: new Date('2026-07-12T09:30:00.000Z'),
|
||||
durationSeconds: 1_800,
|
||||
participants: [
|
||||
{
|
||||
userId: USER_ID.toHexString(),
|
||||
teamId: TEAM_A_ID.toHexString(),
|
||||
side: 'blue',
|
||||
},
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
function createHarness(
|
||||
options: {
|
||||
competitionRevision?: number;
|
||||
casResult?: Record<string, unknown> | null;
|
||||
competition?: Record<string, unknown>;
|
||||
facts?: Array<Record<string, unknown>>;
|
||||
assignments?: Array<Record<string, unknown>>;
|
||||
} = {},
|
||||
) {
|
||||
const session = {
|
||||
startTransaction: jest.fn(),
|
||||
commitTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
abortTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
endSession: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const competition =
|
||||
options.competition ??
|
||||
competitionDocument(options.competitionRevision ?? 7);
|
||||
const competitionModel = {
|
||||
findById: jest.fn().mockReturnValue(queryResult(competition)),
|
||||
findOneAndUpdate: jest
|
||||
.fn()
|
||||
.mockReturnValue(
|
||||
queryResult(
|
||||
options.casResult === undefined
|
||||
? competitionDocument(8, PROJECTION)
|
||||
: options.casResult,
|
||||
),
|
||||
),
|
||||
};
|
||||
const factModel = {
|
||||
find: jest.fn().mockReturnValue(queryResult(options.facts ?? [])),
|
||||
insertMany: jest.fn().mockResolvedValue([]),
|
||||
};
|
||||
const outboxModel = {
|
||||
findOne: jest.fn().mockReturnValue(queryResult(null)),
|
||||
insertMany: jest.fn().mockResolvedValue([]),
|
||||
};
|
||||
const assignmentModel = {
|
||||
find: jest.fn().mockReturnValue(queryResult(options.assignments ?? [])),
|
||||
updateOne: jest.fn().mockResolvedValue({ modifiedCount: 1 }),
|
||||
updateMany: jest.fn().mockResolvedValue({ modifiedCount: 2 }),
|
||||
};
|
||||
const tournamentCodeModel = {
|
||||
updateOne: jest.fn().mockResolvedValue({ modifiedCount: 1 }),
|
||||
updateMany: jest.fn().mockResolvedValue({ modifiedCount: 2 }),
|
||||
};
|
||||
const matchModel = {
|
||||
updateOne: jest
|
||||
.fn()
|
||||
.mockResolvedValue({ matchedCount: 1, modifiedCount: 1 }),
|
||||
};
|
||||
const models: Record<string, unknown> = {
|
||||
competition: competitionModel,
|
||||
competitionFact: factModel,
|
||||
competitionOutbox: outboxModel,
|
||||
tournamentCodeAssignment: assignmentModel,
|
||||
tournamentCode: tournamentCodeModel,
|
||||
match: matchModel,
|
||||
};
|
||||
const connectionService = {
|
||||
createSession: jest.fn().mockResolvedValue(session),
|
||||
getModel: jest.fn((name: string) => Promise.resolve(models[name])),
|
||||
};
|
||||
|
||||
return {
|
||||
session,
|
||||
competitionModel,
|
||||
factModel,
|
||||
outboxModel,
|
||||
assignmentModel,
|
||||
tournamentCodeModel,
|
||||
matchModel,
|
||||
connectionService,
|
||||
};
|
||||
}
|
||||
|
||||
function competitionDocument(revision: number, projection = PROJECTION) {
|
||||
return {
|
||||
_id: COMPETITION_ID,
|
||||
matchId: new Types.ObjectId('64b000000000000000000010'),
|
||||
communityId: new Types.ObjectId('64b000000000000000000011'),
|
||||
schemaVersion: 1,
|
||||
projectorVersion: 1,
|
||||
revision,
|
||||
phase: 'running',
|
||||
teams: [
|
||||
{ teamId: TEAM_A_ID, displayOrder: 1, seedNumber: 1 },
|
||||
{ teamId: TEAM_B_ID, displayOrder: 2, seedNumber: 2 },
|
||||
],
|
||||
format: {
|
||||
type: 'paired-series',
|
||||
rule: { type: 'first-to', winsRequired: 2, maxGames: 3 },
|
||||
},
|
||||
seriesGraph: [],
|
||||
projection,
|
||||
};
|
||||
}
|
||||
|
||||
function queryResult<T>(value: T) {
|
||||
const query = {
|
||||
session: jest.fn(),
|
||||
sort: jest.fn(),
|
||||
lean: jest.fn(),
|
||||
exec: jest.fn().mockResolvedValue(value),
|
||||
};
|
||||
query.session.mockReturnValue(query);
|
||||
query.sort.mockReturnValue(query);
|
||||
query.lean.mockReturnValue(query);
|
||||
return query;
|
||||
}
|
||||
|
||||
function reversalFixture() {
|
||||
const parentSeriesId = new Types.ObjectId('64b000000000000000000021');
|
||||
const childSeriesId = new Types.ObjectId('64b000000000000000000022');
|
||||
const parentFactId = new Types.ObjectId('64b000000000000000000023');
|
||||
const childFactId = new Types.ObjectId('64b000000000000000000024');
|
||||
const parentGameSlotId = new Types.ObjectId('64b000000000000000000025');
|
||||
const childGameSlotId = new Types.ObjectId('64b000000000000000000026');
|
||||
const parentCodeId = new Types.ObjectId('64b000000000000000000027');
|
||||
const childCodeId = new Types.ObjectId('64b000000000000000000028');
|
||||
const series = (
|
||||
id: Types.ObjectId,
|
||||
sourceA: Record<string, unknown>,
|
||||
sourceB: Record<string, unknown>,
|
||||
) => ({
|
||||
id: id.toHexString(),
|
||||
stage: { type: 'upper', displayOrder: 1 },
|
||||
slots: [
|
||||
{ position: 'A', source: sourceA },
|
||||
{ position: 'B', source: sourceB },
|
||||
],
|
||||
rule: { type: 'first-to', winsRequired: 1, maxGames: 1 },
|
||||
gameSlots: [],
|
||||
});
|
||||
const accepted = (
|
||||
_id: Types.ObjectId,
|
||||
seriesId: Types.ObjectId,
|
||||
gameSlotId: Types.ObjectId,
|
||||
) => ({
|
||||
_id,
|
||||
competitionId: COMPETITION_ID,
|
||||
type: 'game-accepted',
|
||||
revision: 1,
|
||||
ordinalWithinRevision: 1,
|
||||
commandId: `command-${_id.toHexString()}`,
|
||||
idempotencyKey: `key-${_id.toHexString()}`,
|
||||
requestHash: `hash-${_id.toHexString()}`,
|
||||
schemaVersion: 1,
|
||||
actor: { type: 'system' },
|
||||
occurredAt: new Date('2026-07-12T00:00:00.000Z'),
|
||||
recordedAt: new Date('2026-07-12T00:00:00.000Z'),
|
||||
gameId: new Types.ObjectId(),
|
||||
seriesId,
|
||||
gameSlotId,
|
||||
ordinal: 1,
|
||||
evidence: { type: 'legacy', legacyReference: 'legacy' },
|
||||
mapping: {
|
||||
blueTeamId: TEAM_A_ID,
|
||||
redTeamId: TEAM_B_ID,
|
||||
winnerTeamId: TEAM_A_ID,
|
||||
},
|
||||
});
|
||||
return {
|
||||
parentSeriesId,
|
||||
childSeriesId,
|
||||
parentFactId,
|
||||
childFactId,
|
||||
parentGameSlotId,
|
||||
childGameSlotId,
|
||||
parentCodeId,
|
||||
childCodeId,
|
||||
competition: {
|
||||
...competitionDocument(7),
|
||||
seriesGraph: [
|
||||
series(
|
||||
parentSeriesId,
|
||||
{ type: 'team', teamId: TEAM_A_ID.toHexString() },
|
||||
{ type: 'team', teamId: TEAM_B_ID.toHexString() },
|
||||
),
|
||||
series(
|
||||
childSeriesId,
|
||||
{
|
||||
type: 'series-outcome',
|
||||
seriesId: parentSeriesId.toHexString(),
|
||||
select: 'winner',
|
||||
},
|
||||
{ type: 'team', teamId: TEAM_B_ID.toHexString() },
|
||||
),
|
||||
],
|
||||
},
|
||||
facts: [
|
||||
accepted(parentFactId, parentSeriesId, parentGameSlotId),
|
||||
accepted(childFactId, childSeriesId, childGameSlotId),
|
||||
],
|
||||
assignments: [
|
||||
{
|
||||
competitionId: COMPETITION_ID,
|
||||
seriesId: parentSeriesId,
|
||||
gameSlotId: parentGameSlotId,
|
||||
tournamentCodeId: parentCodeId,
|
||||
state: 'used',
|
||||
},
|
||||
{
|
||||
competitionId: COMPETITION_ID,
|
||||
seriesId: childSeriesId,
|
||||
gameSlotId: childGameSlotId,
|
||||
tournamentCodeId: childCodeId,
|
||||
state: 'reserved',
|
||||
},
|
||||
],
|
||||
};
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,367 @@
|
||||
import {
|
||||
ConflictException,
|
||||
ForbiddenException,
|
||||
NotFoundException,
|
||||
} from '@nestjs/common';
|
||||
import { Types } from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import { CompetitionQueryService } from './competition-query.service';
|
||||
|
||||
describe('CompetitionQueryService', () => {
|
||||
it('does not let a public read race the team-build bootstrap workflow', async () => {
|
||||
const harness = createHarness({ competition: null });
|
||||
const service = createService(harness);
|
||||
|
||||
await expect(
|
||||
service.getCompetition({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
}),
|
||||
).rejects.toBeInstanceOf(ConflictException);
|
||||
|
||||
expect(harness.matchModel.findOne).toHaveBeenCalledWith({
|
||||
_id: MATCH_ID,
|
||||
communityId: COMMUNITY_ID,
|
||||
});
|
||||
});
|
||||
|
||||
it('returns an explicit team view with codes only for the callers team', async () => {
|
||||
const harness = createHarness();
|
||||
const service = createService(harness);
|
||||
|
||||
const result = await service.getTeamView({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
userId: TEAM_A_USER_ID,
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({
|
||||
competitionId: COMPETITION_ID.toHexString(),
|
||||
revision: 4,
|
||||
teamId: TEAM_A_ID.toHexString(),
|
||||
activeSeries: [expect.objectContaining({ seriesId: SERIES_ID })],
|
||||
tournamentCodes: [
|
||||
{
|
||||
gameSlotId: GAME_SLOT_ID,
|
||||
seriesId: SERIES_ID,
|
||||
ordinal: 1,
|
||||
displayNumber: 1,
|
||||
state: 'reserved',
|
||||
code: 'TEAM-A-SECRET-CODE',
|
||||
expiresAt: '2026-07-13T00:00:00.000Z',
|
||||
},
|
||||
],
|
||||
});
|
||||
expect(JSON.stringify(result)).not.toContain('OPPONENT-SECRET-CODE');
|
||||
expect(harness.tournamentCodeModel.find).toHaveBeenCalledWith({
|
||||
_id: { $in: [TEAM_A_CODE_ID] },
|
||||
state: { $in: ['reserved', 'used'] },
|
||||
});
|
||||
});
|
||||
|
||||
it('resolves a team view from an explicit team id without a caller identity', async () => {
|
||||
const harness = createHarness();
|
||||
const service = createService(harness);
|
||||
|
||||
const result = await service.getTeamView({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
teamId: TEAM_A_ID,
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({
|
||||
teamId: TEAM_A_ID.toHexString(),
|
||||
activeSeries: [expect.objectContaining({ seriesId: SERIES_ID })],
|
||||
tournamentCodes: [
|
||||
expect.objectContaining({ code: 'TEAM-A-SECRET-CODE' }),
|
||||
],
|
||||
});
|
||||
expect(JSON.stringify(result)).not.toContain('OPPONENT-SECRET-CODE');
|
||||
});
|
||||
|
||||
it('does not resolve a team view for an unknown team id', async () => {
|
||||
const service = createService(createHarness());
|
||||
|
||||
await expect(
|
||||
service.getTeamView({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
teamId: new Types.ObjectId('64c000000000000000000098'),
|
||||
}),
|
||||
).rejects.toBeInstanceOf(NotFoundException);
|
||||
});
|
||||
|
||||
it('does not reveal a team view to an authenticated non-participant', async () => {
|
||||
const service = createService(createHarness());
|
||||
|
||||
await expect(
|
||||
service.getTeamView({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
userId: new Types.ObjectId('64c000000000000000000099'),
|
||||
}),
|
||||
).rejects.toBeInstanceOf(ForbiddenException);
|
||||
});
|
||||
|
||||
it('does not expose a stale code whose active assignment no longer matches', async () => {
|
||||
const harness = createHarness();
|
||||
harness.tournamentCodeModel.find.mockReturnValueOnce(queryResult([]));
|
||||
const service = createService(harness);
|
||||
|
||||
await expect(
|
||||
service.getTeamView({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
userId: TEAM_A_USER_ID,
|
||||
}),
|
||||
).rejects.toBeInstanceOf(ConflictException);
|
||||
});
|
||||
|
||||
it('pages facts in immutable revision order using an opaque cursor', async () => {
|
||||
const harness = createHarness();
|
||||
harness.factModel.find.mockReturnValueOnce(
|
||||
queryResult([
|
||||
factDocument('64c000000000000000000031', 1, 1),
|
||||
factDocument('64c000000000000000000032', 2, 1),
|
||||
factDocument('64c000000000000000000033', 3, 1),
|
||||
]),
|
||||
);
|
||||
const service = createService(harness);
|
||||
|
||||
const first = await service.listFacts({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
limit: 2,
|
||||
});
|
||||
|
||||
expect(first.facts).toHaveLength(2);
|
||||
expect(first.nextCursor).toEqual(expect.any(String));
|
||||
expect(first.facts[0]).toMatchObject({
|
||||
id: '64c000000000000000000031',
|
||||
competitionId: COMPETITION_ID.toHexString(),
|
||||
type: 'game-accepted',
|
||||
revision: 1,
|
||||
});
|
||||
expect(first.facts[0]).not.toHaveProperty('requestHash');
|
||||
expect(first.facts[0]).not.toHaveProperty('idempotencyKey');
|
||||
});
|
||||
});
|
||||
|
||||
const COMMUNITY_ID = new Types.ObjectId('64c000000000000000000001');
|
||||
const MATCH_ID = new Types.ObjectId('64c000000000000000000002');
|
||||
const COMPETITION_ID = new Types.ObjectId('64c000000000000000000003');
|
||||
const TEAM_A_ID = new Types.ObjectId('64c000000000000000000004');
|
||||
const TEAM_B_ID = new Types.ObjectId('64c000000000000000000005');
|
||||
const TEAM_A_USER_ID = new Types.ObjectId('64c000000000000000000006');
|
||||
const TEAM_B_USER_ID = new Types.ObjectId('64c000000000000000000007');
|
||||
const TEAM_A_CODE_ID = new Types.ObjectId('64c000000000000000000008');
|
||||
const TEAM_B_CODE_ID = new Types.ObjectId('64c000000000000000000009');
|
||||
const SERIES_ID = 'series-1';
|
||||
const GAME_SLOT_ID = 'slot-1';
|
||||
|
||||
function createService(harness: ReturnType<typeof createHarness>) {
|
||||
return new CompetitionQueryService(
|
||||
harness.connectionService as ConnectionService,
|
||||
);
|
||||
}
|
||||
|
||||
function createHarness(options: { competition?: unknown } = {}) {
|
||||
const competition =
|
||||
options.competition === undefined
|
||||
? competitionDocument()
|
||||
: options.competition;
|
||||
const competitionModel = {
|
||||
findOne: jest.fn().mockReturnValue(queryResult(competition)),
|
||||
};
|
||||
const matchModel = {
|
||||
findOne: jest.fn().mockReturnValue(
|
||||
queryResult({
|
||||
_id: MATCH_ID,
|
||||
communityId: COMMUNITY_ID,
|
||||
status: 'team-built',
|
||||
teams: [{ teamIndex: 1 }, { teamIndex: 2 }],
|
||||
participants: [],
|
||||
gameMode: 'pair',
|
||||
gameCount: 3,
|
||||
}),
|
||||
),
|
||||
};
|
||||
const assignmentModel = {
|
||||
find: jest.fn().mockReturnValue(
|
||||
queryResult([
|
||||
{
|
||||
competitionId: COMPETITION_ID,
|
||||
seriesId: SERIES_ID,
|
||||
gameSlotId: GAME_SLOT_ID,
|
||||
tournamentCodeId: TEAM_A_CODE_ID,
|
||||
state: 'reserved',
|
||||
},
|
||||
{
|
||||
competitionId: COMPETITION_ID,
|
||||
seriesId: 'series-opponent-only',
|
||||
gameSlotId: 'slot-opponent-only',
|
||||
tournamentCodeId: TEAM_B_CODE_ID,
|
||||
state: 'reserved',
|
||||
},
|
||||
]),
|
||||
),
|
||||
};
|
||||
const tournamentCodeModel = {
|
||||
find: jest.fn().mockReturnValue(
|
||||
queryResult([
|
||||
{
|
||||
_id: TEAM_A_CODE_ID,
|
||||
code: 'TEAM-A-SECRET-CODE',
|
||||
state: 'reserved',
|
||||
matchId: MATCH_ID,
|
||||
expiresAt: new Date('2026-07-13T00:00:00.000Z'),
|
||||
},
|
||||
{
|
||||
_id: TEAM_B_CODE_ID,
|
||||
code: 'OPPONENT-SECRET-CODE',
|
||||
state: 'reserved',
|
||||
matchId: MATCH_ID,
|
||||
expiresAt: new Date('2026-07-13T00:00:00.000Z'),
|
||||
},
|
||||
]),
|
||||
),
|
||||
};
|
||||
const factModel = {
|
||||
find: jest.fn().mockReturnValue(queryResult([])),
|
||||
};
|
||||
const models: Record<string, unknown> = {
|
||||
competition: competitionModel,
|
||||
match: matchModel,
|
||||
tournamentCodeAssignment: assignmentModel,
|
||||
tournamentCode: tournamentCodeModel,
|
||||
competitionFact: factModel,
|
||||
};
|
||||
return {
|
||||
competitionModel,
|
||||
matchModel,
|
||||
assignmentModel,
|
||||
tournamentCodeModel,
|
||||
factModel,
|
||||
connectionService: {
|
||||
getModel: jest.fn((name: string) => Promise.resolve(models[name])),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function competitionDocument() {
|
||||
return {
|
||||
_id: COMPETITION_ID,
|
||||
matchId: MATCH_ID,
|
||||
communityId: COMMUNITY_ID,
|
||||
schemaVersion: 1,
|
||||
projectorVersion: 1,
|
||||
revision: 4,
|
||||
phase: 'running',
|
||||
teams: [
|
||||
{
|
||||
teamId: TEAM_A_ID,
|
||||
displayOrder: 1,
|
||||
seedNumber: 1,
|
||||
name: 'Team A',
|
||||
members: [{ userId: TEAM_A_USER_ID, displayName: 'A' }],
|
||||
},
|
||||
{
|
||||
teamId: TEAM_B_ID,
|
||||
displayOrder: 2,
|
||||
seedNumber: 2,
|
||||
name: 'Team B',
|
||||
members: [{ userId: TEAM_B_USER_ID, displayName: 'B' }],
|
||||
},
|
||||
],
|
||||
format: {
|
||||
type: 'paired-series',
|
||||
rule: { type: 'fixed-games', gameCount: 3, drawPolicy: 'allow' },
|
||||
},
|
||||
seriesGraph: [],
|
||||
projection: {
|
||||
sourceRevision: 4,
|
||||
projectorVersion: 1,
|
||||
phase: 'running',
|
||||
formatType: 'paired-series',
|
||||
series: [
|
||||
{
|
||||
seriesId: SERIES_ID,
|
||||
status: 'in-progress',
|
||||
stage: { type: 'pair', displayOrder: 1 },
|
||||
rule: { type: 'fixed-games', gameCount: 3, drawPolicy: 'allow' },
|
||||
entries: [
|
||||
{ slot: 'A', teamId: TEAM_A_ID.toHexString(), gameWins: 1 },
|
||||
{ slot: 'B', teamId: TEAM_B_ID.toHexString(), gameWins: 0 },
|
||||
],
|
||||
},
|
||||
{
|
||||
seriesId: 'series-opponent-only',
|
||||
status: 'in-progress',
|
||||
stage: { type: 'pair', displayOrder: 2 },
|
||||
rule: { type: 'fixed-games', gameCount: 3, drawPolicy: 'allow' },
|
||||
entries: [
|
||||
{ slot: 'A', teamId: TEAM_B_ID.toHexString(), gameWins: 0 },
|
||||
{ slot: 'B', teamId: 'other-team', gameWins: 1 },
|
||||
],
|
||||
},
|
||||
],
|
||||
games: [],
|
||||
gameSlots: [
|
||||
{
|
||||
id: GAME_SLOT_ID,
|
||||
seriesId: SERIES_ID,
|
||||
ordinal: 1,
|
||||
displayNumber: 1,
|
||||
status: 'reserved',
|
||||
entries: [],
|
||||
},
|
||||
],
|
||||
rounds: [],
|
||||
connectors: [],
|
||||
},
|
||||
createdAt: new Date('2026-07-11T00:00:00.000Z'),
|
||||
updatedAt: new Date('2026-07-12T00:00:00.000Z'),
|
||||
};
|
||||
}
|
||||
|
||||
function factDocument(id: string, revision: number, ordinal: number) {
|
||||
return {
|
||||
_id: new Types.ObjectId(id),
|
||||
competitionId: COMPETITION_ID,
|
||||
type: 'game-accepted',
|
||||
revision,
|
||||
ordinalWithinRevision: ordinal,
|
||||
commandId: `command-${revision}`,
|
||||
idempotencyKey: `secret-${revision}`,
|
||||
requestHash: `hash-${revision}`,
|
||||
schemaVersion: 1,
|
||||
actor: { type: 'system' },
|
||||
occurredAt: new Date('2026-07-12T00:00:00.000Z'),
|
||||
recordedAt: new Date('2026-07-12T00:00:01.000Z'),
|
||||
gameId: new Types.ObjectId('64c000000000000000000041'),
|
||||
seriesId: new Types.ObjectId('64c000000000000000000042'),
|
||||
gameSlotId: new Types.ObjectId('64c000000000000000000043'),
|
||||
ordinal: 1,
|
||||
evidence: { type: 'legacy', legacyReference: 'legacy-1' },
|
||||
mapping: {
|
||||
mappingVersion: 1,
|
||||
confidence: 1,
|
||||
blueTeamId: TEAM_A_ID,
|
||||
redTeamId: TEAM_B_ID,
|
||||
winnerTeamId: TEAM_A_ID,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function queryResult<T>(value: T) {
|
||||
const query = {
|
||||
sort: jest.fn(),
|
||||
limit: jest.fn(),
|
||||
lean: jest.fn(),
|
||||
exec: jest.fn().mockResolvedValue(value),
|
||||
};
|
||||
query.sort.mockReturnValue(query);
|
||||
query.limit.mockReturnValue(query);
|
||||
query.lean.mockReturnValue(query);
|
||||
return query;
|
||||
}
|
||||
@@ -0,0 +1,407 @@
|
||||
import type {
|
||||
CompetitionFactView,
|
||||
CompetitionFactsResponse,
|
||||
TeamCompetitionViewResponse,
|
||||
} from '@lolympus/contracts';
|
||||
import {
|
||||
ConflictException,
|
||||
ForbiddenException,
|
||||
Injectable,
|
||||
NotFoundException,
|
||||
UnprocessableEntityException,
|
||||
} from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import type { Competition, CompetitionFact } from './competition.schema';
|
||||
|
||||
type PersistenceId = string | mongoose.Types.ObjectId;
|
||||
type CompetitionRecord = Competition & { _id: mongoose.Types.ObjectId };
|
||||
|
||||
export interface CompetitionScope {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
}
|
||||
|
||||
/**
|
||||
* A team view is addressed either by the caller's membership (signed-in) or by
|
||||
* an explicit team id. The explicit form exists so that the team progress page
|
||||
* stays usable while community members have not all signed in yet.
|
||||
*/
|
||||
export type TeamViewScope = CompetitionScope &
|
||||
(
|
||||
| { userId: mongoose.Types.ObjectId; teamId?: undefined }
|
||||
| { teamId: mongoose.Types.ObjectId; userId?: undefined }
|
||||
);
|
||||
|
||||
interface CompetitionProjectionSource {
|
||||
series?: Array<Record<string, unknown>>;
|
||||
gameSlots?: Array<Record<string, unknown>>;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class CompetitionQueryService {
|
||||
constructor(private readonly connectionService: ConnectionService) {}
|
||||
|
||||
/** Resolve the aggregate created by the finalized team-build workflow. */
|
||||
public async getCompetition(
|
||||
scope: CompetitionScope,
|
||||
): Promise<CompetitionRecord> {
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const match = await MatchModel.findOne({
|
||||
_id: scope.matchId,
|
||||
communityId: scope.communityId,
|
||||
})
|
||||
.lean()
|
||||
.exec();
|
||||
if (!match) throw new NotFoundException('Match not found.');
|
||||
if (
|
||||
match.status === 'recruiting' ||
|
||||
!Array.isArray(match.teams) ||
|
||||
match.teams.length < 2
|
||||
) {
|
||||
throw new ConflictException(
|
||||
'Competition is unavailable until team building is complete.',
|
||||
);
|
||||
}
|
||||
|
||||
const CompetitionModel =
|
||||
await this.connectionService.getModel('competition');
|
||||
const existing = await CompetitionModel.findOne({
|
||||
matchId: scope.matchId,
|
||||
communityId: scope.communityId,
|
||||
})
|
||||
.lean()
|
||||
.exec();
|
||||
if (existing) return existing as CompetitionRecord;
|
||||
throw new ConflictException(
|
||||
'Competition is still being initialized by the team-build workflow.',
|
||||
);
|
||||
}
|
||||
|
||||
public async getTeamView(
|
||||
scope: TeamViewScope,
|
||||
): Promise<TeamCompetitionViewResponse> {
|
||||
const competition = (await this.getCompetition(scope)) as Competition & {
|
||||
_id: PersistenceId;
|
||||
};
|
||||
const requestedTeamId = scope.teamId;
|
||||
const team = requestedTeamId
|
||||
? competition.teams.find(({ teamId }) => sameId(teamId, requestedTeamId))
|
||||
: competition.teams.find(({ members }) =>
|
||||
members.some(({ userId }) => sameId(userId, scope.userId)),
|
||||
);
|
||||
if (!team) {
|
||||
if (requestedTeamId) {
|
||||
throw new NotFoundException('Competition team not found.');
|
||||
}
|
||||
throw new ForbiddenException(
|
||||
'Only a Competition team member may access the team view.',
|
||||
);
|
||||
}
|
||||
|
||||
const projection = competition.projection as CompetitionProjectionSource;
|
||||
const allSeries = Array.isArray(projection.series) ? projection.series : [];
|
||||
const teamId = idString(team.teamId);
|
||||
const activeSeries = allSeries.filter(
|
||||
(series) =>
|
||||
series.status !== 'completed' &&
|
||||
series.status !== 'inactive' &&
|
||||
Array.isArray(series.entries) &&
|
||||
series.entries.some(
|
||||
(entry) =>
|
||||
isRecord(entry) &&
|
||||
idString(entry.teamId as PersistenceId) === teamId,
|
||||
),
|
||||
);
|
||||
const activeSeriesIds = new Set(
|
||||
activeSeries.map((series) => idString(series.seriesId as PersistenceId)),
|
||||
);
|
||||
const gameSlots = (
|
||||
Array.isArray(projection.gameSlots) ? projection.gameSlots : []
|
||||
).filter((slot) =>
|
||||
activeSeriesIds.has(idString(slot.seriesId as PersistenceId)),
|
||||
);
|
||||
|
||||
const AssignmentModel = await this.connectionService.getModel(
|
||||
'tournamentCodeAssignment',
|
||||
);
|
||||
const queriedAssignments = await AssignmentModel.find({
|
||||
competitionId: competition._id,
|
||||
seriesId: { $in: [...activeSeriesIds] },
|
||||
state: { $in: ['reserved', 'used'] },
|
||||
})
|
||||
.lean()
|
||||
.exec();
|
||||
// Keep this defensive filter even when the persistence query is mocked or
|
||||
// changed: an opponent-only assignment must never cross this boundary.
|
||||
const assignments = queriedAssignments.filter((assignment) =>
|
||||
activeSeriesIds.has(idString(assignment.seriesId)),
|
||||
);
|
||||
const codeIds = assignments.map(({ tournamentCodeId }) => tournamentCodeId);
|
||||
const TournamentCodeModel =
|
||||
await this.connectionService.getModel('tournamentCode');
|
||||
const codes = codeIds.length
|
||||
? await TournamentCodeModel.find({
|
||||
_id: { $in: codeIds },
|
||||
state: { $in: ['reserved', 'used'] },
|
||||
})
|
||||
.lean()
|
||||
.exec()
|
||||
: [];
|
||||
const codeById = new Map(codes.map((code) => [idString(code._id), code]));
|
||||
const assignmentBySlot = new Map(
|
||||
assignments.map((assignment) => [
|
||||
idString(assignment.gameSlotId),
|
||||
assignment,
|
||||
]),
|
||||
);
|
||||
|
||||
return {
|
||||
competitionId: idString(competition._id) as never,
|
||||
revision: competition.revision,
|
||||
phase: competition.phase,
|
||||
teamId: teamId as never,
|
||||
activeSeries: toWire(activeSeries) as never,
|
||||
tournamentCodes: gameSlots.map((slot) => {
|
||||
const gameSlotId = idString(slot.id as PersistenceId);
|
||||
const assignment = assignmentBySlot.get(gameSlotId);
|
||||
const code = assignment
|
||||
? codeById.get(idString(assignment.tournamentCodeId))
|
||||
: undefined;
|
||||
if (
|
||||
assignment &&
|
||||
(!code ||
|
||||
code.state !== assignment.state ||
|
||||
!code.matchId ||
|
||||
!sameId(code.matchId, competition.matchId))
|
||||
) {
|
||||
throw new ConflictException(
|
||||
'Tournament Code assignment is inconsistent and cannot be exposed.',
|
||||
);
|
||||
}
|
||||
return {
|
||||
gameSlotId: gameSlotId as never,
|
||||
seriesId: idString(slot.seriesId as PersistenceId) as never,
|
||||
ordinal: numberValue(slot.ordinal),
|
||||
displayNumber: numberValue(slot.displayNumber),
|
||||
state:
|
||||
assignment?.state === 'reserved' || assignment?.state === 'used'
|
||||
? assignment.state
|
||||
: 'pending',
|
||||
code: typeof code?.code === 'string' ? code.code : null,
|
||||
expiresAt: code?.expiresAt ? isoDate(code.expiresAt) : null,
|
||||
};
|
||||
}),
|
||||
};
|
||||
}
|
||||
|
||||
public async listFacts(
|
||||
scope: CompetitionScope & { cursor?: string; limit?: number },
|
||||
): Promise<CompetitionFactsResponse> {
|
||||
const competition = (await this.getCompetition(scope)) as Competition & {
|
||||
_id: PersistenceId;
|
||||
};
|
||||
const limit = normalizeLimit(scope.limit);
|
||||
const cursor = scope.cursor ? decodeCursor(scope.cursor) : undefined;
|
||||
const cursorFilter = cursor
|
||||
? {
|
||||
$or: [
|
||||
{ revision: { $gt: cursor.revision } },
|
||||
{
|
||||
revision: cursor.revision,
|
||||
ordinalWithinRevision: { $gt: cursor.ordinalWithinRevision },
|
||||
},
|
||||
{
|
||||
revision: cursor.revision,
|
||||
ordinalWithinRevision: cursor.ordinalWithinRevision,
|
||||
_id: { $gt: new mongoose.Types.ObjectId(cursor.id) },
|
||||
},
|
||||
],
|
||||
}
|
||||
: {};
|
||||
const FactModel = await this.connectionService.getModel('competitionFact');
|
||||
const rows = await FactModel.find({
|
||||
competitionId: competition._id,
|
||||
...cursorFilter,
|
||||
})
|
||||
.sort({ revision: 1, ordinalWithinRevision: 1, _id: 1 })
|
||||
.limit(limit + 1)
|
||||
.lean()
|
||||
.exec();
|
||||
const page = rows.slice(0, limit);
|
||||
const last = page.at(-1);
|
||||
return {
|
||||
facts: page.map(presentFact),
|
||||
nextCursor:
|
||||
rows.length > limit && last
|
||||
? encodeCursor({
|
||||
revision: requiredNumber(last.revision, 'revision'),
|
||||
ordinalWithinRevision: requiredNumber(
|
||||
last.ordinalWithinRevision,
|
||||
'ordinalWithinRevision',
|
||||
),
|
||||
id: requiredId(last._id, '_id'),
|
||||
})
|
||||
: null,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
function presentFact(
|
||||
source: CompetitionFact & { _id: mongoose.Types.ObjectId },
|
||||
): CompetitionFactView {
|
||||
const common = {
|
||||
id: requiredId(source._id, '_id') as never,
|
||||
competitionId: requiredId(source.competitionId, 'competitionId') as never,
|
||||
revision: requiredNumber(source.revision, 'revision'),
|
||||
ordinalWithinRevision: requiredNumber(
|
||||
source.ordinalWithinRevision,
|
||||
'ordinalWithinRevision',
|
||||
),
|
||||
commandId: requiredString(source.commandId, 'commandId') as never,
|
||||
schemaVersion: requiredNumber(source.schemaVersion, 'schemaVersion'),
|
||||
actor: toWire(source.actor) as never,
|
||||
occurredAt: isoDate(source.occurredAt),
|
||||
recordedAt: isoDate(source.recordedAt),
|
||||
...(typeof source.causationId === 'string' && source.causationId.length > 0
|
||||
? { causationId: source.causationId }
|
||||
: {}),
|
||||
};
|
||||
switch (source.type) {
|
||||
case 'game-accepted':
|
||||
return {
|
||||
...common,
|
||||
type: 'game-accepted',
|
||||
gameId: requiredId(source.gameId, 'gameId') as never,
|
||||
seriesId: requiredId(source.seriesId, 'seriesId') as never,
|
||||
gameSlotId: requiredId(source.gameSlotId, 'gameSlotId') as never,
|
||||
ordinal: requiredNumber(source.ordinal, 'ordinal'),
|
||||
startedAt: isoDate(source.startedAt ?? source.occurredAt),
|
||||
durationSeconds: numberValue(source.durationSeconds ?? 0),
|
||||
participants: toWire(source.participants ?? []) as never,
|
||||
evidence: toWire(source.evidence) as never,
|
||||
mapping: toWire(source.mapping) as never,
|
||||
};
|
||||
case 'game-voided':
|
||||
return {
|
||||
...common,
|
||||
type: 'game-voided',
|
||||
gameAcceptedFactId: requiredId(
|
||||
source.gameAcceptedFactId,
|
||||
'gameAcceptedFactId',
|
||||
) as never,
|
||||
reason: requiredString(source.reason, 'reason'),
|
||||
};
|
||||
case 'series-adjudicated':
|
||||
return {
|
||||
...common,
|
||||
type: 'series-adjudicated',
|
||||
seriesId: requiredId(source.seriesId, 'seriesId') as never,
|
||||
decision: toWire(source.decision) as never,
|
||||
reason: requiredString(source.reason, 'reason'),
|
||||
};
|
||||
case 'adjudication-reversed':
|
||||
return {
|
||||
...common,
|
||||
type: 'adjudication-reversed',
|
||||
adjudicationFactId: requiredId(
|
||||
source.adjudicationFactId,
|
||||
'adjudicationFactId',
|
||||
) as never,
|
||||
reason: requiredString(source.reason, 'reason'),
|
||||
};
|
||||
default:
|
||||
throw new Error('Unsupported Competition fact type.');
|
||||
}
|
||||
}
|
||||
|
||||
interface FactCursor {
|
||||
revision: number;
|
||||
ordinalWithinRevision: number;
|
||||
id: string;
|
||||
}
|
||||
|
||||
function encodeCursor(cursor: FactCursor): string {
|
||||
return Buffer.from(JSON.stringify(cursor)).toString('base64url');
|
||||
}
|
||||
|
||||
function decodeCursor(value: string): FactCursor {
|
||||
try {
|
||||
const parsed: unknown = JSON.parse(
|
||||
Buffer.from(value, 'base64url').toString('utf8'),
|
||||
);
|
||||
if (
|
||||
!isRecord(parsed) ||
|
||||
!Number.isInteger(parsed.revision) ||
|
||||
!Number.isInteger(parsed.ordinalWithinRevision) ||
|
||||
typeof parsed.id !== 'string' ||
|
||||
!mongoose.isValidObjectId(parsed.id)
|
||||
) {
|
||||
throw new Error('malformed cursor');
|
||||
}
|
||||
return parsed as unknown as FactCursor;
|
||||
} catch {
|
||||
throw new UnprocessableEntityException('Invalid facts cursor.');
|
||||
}
|
||||
}
|
||||
|
||||
function normalizeLimit(value: number | undefined): number {
|
||||
if (value === undefined) return 50;
|
||||
if (!Number.isInteger(value) || value < 1 || value > 100) {
|
||||
throw new UnprocessableEntityException(
|
||||
'Facts page limit must be an integer from 1 through 100.',
|
||||
);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
function sameId(left: PersistenceId, right: PersistenceId): boolean {
|
||||
return idString(left) === idString(right);
|
||||
}
|
||||
|
||||
function idString(value: PersistenceId): string {
|
||||
return value instanceof mongoose.Types.ObjectId
|
||||
? value.toHexString()
|
||||
: String(value);
|
||||
}
|
||||
|
||||
function isoDate(value: unknown): string {
|
||||
if (value instanceof Date) return value.toISOString();
|
||||
if (typeof value === 'string') return value;
|
||||
throw new Error('Competition fact contains an invalid date.');
|
||||
}
|
||||
|
||||
function numberValue(value: unknown): number {
|
||||
return typeof value === 'number' ? value : Number(value);
|
||||
}
|
||||
|
||||
function toWire(value: unknown): unknown {
|
||||
if (value instanceof mongoose.Types.ObjectId) return value.toHexString();
|
||||
if (value instanceof Date) return value.toISOString();
|
||||
if (Array.isArray(value)) return value.map(toWire);
|
||||
if (isRecord(value)) {
|
||||
return Object.fromEntries(
|
||||
Object.entries(value).map(([key, child]) => [key, toWire(child)]),
|
||||
);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return value !== null && typeof value === 'object' && !Array.isArray(value);
|
||||
}
|
||||
|
||||
function requiredId(value: unknown, field: string): string {
|
||||
if (value instanceof mongoose.Types.ObjectId) return value.toHexString();
|
||||
return requiredString(value, field);
|
||||
}
|
||||
|
||||
function requiredString(value: unknown, field: string): string {
|
||||
if (typeof value === 'string' && value.length > 0) return value;
|
||||
throw new Error(`Competition fact contains an invalid ${field}.`);
|
||||
}
|
||||
|
||||
function requiredNumber(value: unknown, field: string): number {
|
||||
if (typeof value === 'number' && Number.isFinite(value)) return value;
|
||||
throw new Error(`Competition fact contains an invalid ${field}.`);
|
||||
}
|
||||
@@ -0,0 +1,411 @@
|
||||
import { HttpException } from '@nestjs/common';
|
||||
import { Types } from 'mongoose';
|
||||
import { METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED } from '../auth/allow-public-access.decorator';
|
||||
import { ROLES_KEY } from '../auth/roles.decorator';
|
||||
import { CompetitionCommandService } from './competition-command.service';
|
||||
import { CompetitionController } from './competition.controller';
|
||||
import { CompetitionQueryService } from './competition-query.service';
|
||||
|
||||
describe('CompetitionController', () => {
|
||||
it('marks the read endpoints public and writes a revision ETag', async () => {
|
||||
const { controller, queryService } = createHarness();
|
||||
const response = { setHeader: jest.fn() };
|
||||
|
||||
const result = await controller.getDetail(
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
response as never,
|
||||
);
|
||||
|
||||
for (const method of ['getDetail', 'getTeamView'] as const) {
|
||||
expect(
|
||||
Reflect.getMetadata(
|
||||
METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED,
|
||||
CompetitionController.prototype[method],
|
||||
),
|
||||
).toBe(true);
|
||||
}
|
||||
expect(response.setHeader).toHaveBeenCalledWith('ETag', '"7"');
|
||||
expect(result).toMatchObject({ revision: 7 });
|
||||
expect(queryService.getCompetition).toHaveBeenCalledWith({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
});
|
||||
});
|
||||
|
||||
it('reads a team view by explicit team id without an authenticated caller', async () => {
|
||||
const { controller, queryService } = createHarness();
|
||||
queryService.getTeamView.mockResolvedValue({ revision: 7 });
|
||||
const response = { setHeader: jest.fn() };
|
||||
|
||||
const result = await controller.getTeamView(
|
||||
undefined,
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
TEAM_A_ID.toHexString(),
|
||||
response as never,
|
||||
);
|
||||
|
||||
expect(queryService.getTeamView).toHaveBeenCalledWith({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
teamId: TEAM_A_ID,
|
||||
});
|
||||
expect(response.setHeader).toHaveBeenCalledWith('ETag', '"7"');
|
||||
expect(result).toMatchObject({ revision: 7 });
|
||||
});
|
||||
|
||||
it('falls back to the membership-scoped team view for a signed-in caller', async () => {
|
||||
const { controller, queryService } = createHarness();
|
||||
queryService.getTeamView.mockResolvedValue({ revision: 7 });
|
||||
|
||||
await controller.getTeamView(adminUser(), COMMUNITY_ID, MATCH_ID);
|
||||
|
||||
expect(queryService.getTeamView).toHaveBeenCalledWith({
|
||||
communityId: COMMUNITY_ID,
|
||||
matchId: MATCH_ID,
|
||||
userId: ADMIN_ID,
|
||||
});
|
||||
});
|
||||
|
||||
it('rejects an anonymous team view request that names no team', async () => {
|
||||
const { controller, queryService } = createHarness();
|
||||
|
||||
await expect(
|
||||
controller.getTeamView(undefined, COMMUNITY_ID, MATCH_ID),
|
||||
).rejects.toMatchObject({
|
||||
status: 401,
|
||||
response: { error: { code: 'COMPETITION_TEAM_UNIDENTIFIED' } },
|
||||
});
|
||||
expect(queryService.getTeamView).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('rejects a malformed team id', async () => {
|
||||
const { controller, queryService } = createHarness();
|
||||
|
||||
await expect(
|
||||
controller.getTeamView(undefined, COMMUNITY_ID, MATCH_ID, 'not-an-id'),
|
||||
).rejects.toMatchObject({
|
||||
status: 422,
|
||||
response: { error: { code: 'INVALID_COMPETITION_REQUEST' } },
|
||||
});
|
||||
expect(queryService.getTeamView).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('protects audit and mutation endpoints with admin roles', () => {
|
||||
for (const method of [
|
||||
'listFacts',
|
||||
'acceptGame',
|
||||
'adjudicateSeries',
|
||||
'previewReversal',
|
||||
'reverseSeries',
|
||||
] as const) {
|
||||
expect(
|
||||
Reflect.getMetadata(ROLES_KEY, CompetitionController.prototype[method]),
|
||||
).toEqual(['owner', 'admin']);
|
||||
}
|
||||
});
|
||||
|
||||
it('requires If-Match and Idempotency-Key for a mutation', async () => {
|
||||
const { controller } = createHarness();
|
||||
|
||||
await expect(
|
||||
controller.acceptGame(
|
||||
adminUser(),
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
undefined,
|
||||
undefined,
|
||||
acceptGameBody(),
|
||||
),
|
||||
).rejects.toMatchObject({
|
||||
status: 422,
|
||||
response: {
|
||||
error: { code: 'INVALID_COMPETITION_COMMAND_HEADERS' },
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it('passes revision, idempotency and the authenticated actor to accept-game', async () => {
|
||||
const { controller, commandService } = createHarness();
|
||||
|
||||
await controller.acceptGame(
|
||||
adminUser(),
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
'W/"7"',
|
||||
'operator:accept:1',
|
||||
acceptGameBody(),
|
||||
);
|
||||
|
||||
expect(commandService.acceptGame).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
expectedRevision: 7,
|
||||
idempotencyKey: 'operator:accept:1',
|
||||
}),
|
||||
);
|
||||
const accepted = commandService.acceptGame.mock.calls[0][0];
|
||||
expect(accepted.competitionId.toHexString()).toBe(
|
||||
COMPETITION_ID.toHexString(),
|
||||
);
|
||||
expect(accepted.actor.userId.toHexString()).toBe(ADMIN_ID.toHexString());
|
||||
expect(accepted.gameId.toHexString()).toBe(GAME_ID.toHexString());
|
||||
expect(accepted.seriesId.toHexString()).toBe(SERIES_ID);
|
||||
expect(accepted.gameSlotId.toHexString()).toBe(GAME_SLOT_ID.toHexString());
|
||||
});
|
||||
|
||||
it('maps command conflicts to the explicit error envelope', async () => {
|
||||
const { controller, commandService } = createHarness();
|
||||
commandService.adjudicateSeries.mockRejectedValue({
|
||||
code: 'IDEMPOTENCY_KEY_CONFLICT',
|
||||
message: 'duplicate key with another payload',
|
||||
httpStatus: 409,
|
||||
details: { idempotencyKey: 'same-key' },
|
||||
});
|
||||
|
||||
let thrown: unknown;
|
||||
try {
|
||||
await controller.adjudicateSeries(
|
||||
adminUser(),
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
new Types.ObjectId(SERIES_ID),
|
||||
'"7"',
|
||||
'same-key',
|
||||
{
|
||||
decision: { type: 'administrative-draw' },
|
||||
reason: '운영 판단',
|
||||
},
|
||||
);
|
||||
} catch (error) {
|
||||
thrown = error;
|
||||
}
|
||||
|
||||
expect(thrown).toBeInstanceOf(HttpException);
|
||||
expect(thrown).toMatchObject({
|
||||
status: 409,
|
||||
response: {
|
||||
error: {
|
||||
code: 'IDEMPOTENCY_KEY_CONFLICT',
|
||||
details: { idempotencyKey: 'same-key' },
|
||||
},
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it.each([
|
||||
{
|
||||
source: {
|
||||
code: 'STALE_COMPETITION_REVISION',
|
||||
message: 'stale',
|
||||
httpStatus: 412,
|
||||
},
|
||||
status: 412,
|
||||
},
|
||||
{
|
||||
source: {
|
||||
code: 'GAME_TEAM_MISMATCH',
|
||||
message: 'invalid evidence mapping',
|
||||
},
|
||||
status: 422,
|
||||
},
|
||||
])('maps $source.code to HTTP $status', async ({ source, status }) => {
|
||||
const { controller, commandService } = createHarness();
|
||||
commandService.acceptGame.mockRejectedValue(source);
|
||||
|
||||
await expect(
|
||||
controller.acceptGame(
|
||||
adminUser(),
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
'"7"',
|
||||
`operator:error:${status}`,
|
||||
acceptGameBody(),
|
||||
),
|
||||
).rejects.toMatchObject({
|
||||
status,
|
||||
response: { error: { code: source.code } },
|
||||
});
|
||||
});
|
||||
|
||||
it('returns an explicit 422 envelope for an invalid command body', async () => {
|
||||
const { controller, commandService } = createHarness();
|
||||
|
||||
await expect(
|
||||
controller.adjudicateSeries(
|
||||
adminUser(),
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
new Types.ObjectId(SERIES_ID),
|
||||
'"7"',
|
||||
'operator:invalid-body:1',
|
||||
{
|
||||
decision: { type: 'walkover' },
|
||||
reason: '',
|
||||
},
|
||||
),
|
||||
).rejects.toMatchObject({
|
||||
status: 422,
|
||||
response: {
|
||||
error: { code: 'INVALID_COMPETITION_REQUEST' },
|
||||
},
|
||||
});
|
||||
expect(commandService.adjudicateSeries).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('rejects malformed game evidence before it reaches the ledger', async () => {
|
||||
const { controller, commandService } = createHarness();
|
||||
|
||||
await expect(
|
||||
controller.acceptGame(
|
||||
adminUser(),
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
'"7"',
|
||||
'operator:bad-evidence:1',
|
||||
{
|
||||
...acceptGameBody(),
|
||||
evidence: { type: 'invented-evidence' },
|
||||
},
|
||||
),
|
||||
).rejects.toMatchObject({
|
||||
status: 422,
|
||||
response: {
|
||||
error: { code: 'INVALID_COMPETITION_REQUEST' },
|
||||
},
|
||||
});
|
||||
expect(commandService.acceptGame).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('requires the same revision for preview and hash-confirmed reversal', async () => {
|
||||
const { controller, commandService } = createHarness();
|
||||
|
||||
await controller.previewReversal(
|
||||
adminUser(),
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
new Types.ObjectId(SERIES_ID),
|
||||
'"7"',
|
||||
{ mode: 'cascade', reason: '잘못 수집됨' },
|
||||
);
|
||||
await controller.reverseSeries(
|
||||
adminUser(),
|
||||
COMMUNITY_ID,
|
||||
MATCH_ID,
|
||||
new Types.ObjectId(SERIES_ID),
|
||||
'"7"',
|
||||
'operator:reverse:1',
|
||||
{
|
||||
mode: 'cascade',
|
||||
reason: '잘못 수집됨',
|
||||
impactHash: 'a'.repeat(64),
|
||||
},
|
||||
);
|
||||
|
||||
expect(commandService.previewSeriesReversal).toHaveBeenCalledWith({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
seriesId: new Types.ObjectId(SERIES_ID),
|
||||
mode: 'cascade',
|
||||
});
|
||||
expect(commandService.reverseSeries).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
competitionId: COMPETITION_ID,
|
||||
expectedRevision: 7,
|
||||
idempotencyKey: 'operator:reverse:1',
|
||||
impactHash: 'a'.repeat(64),
|
||||
}),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
const COMMUNITY_ID = new Types.ObjectId('64d000000000000000000001');
|
||||
const MATCH_ID = new Types.ObjectId('64d000000000000000000002');
|
||||
const COMPETITION_ID = new Types.ObjectId('64d000000000000000000003');
|
||||
const ADMIN_ID = new Types.ObjectId('64d000000000000000000004');
|
||||
const GAME_ID = new Types.ObjectId('64d000000000000000000005');
|
||||
const SERIES_ID = '64d000000000000000000006';
|
||||
const GAME_SLOT_ID = new Types.ObjectId('64d000000000000000000007');
|
||||
const TEAM_A_ID = new Types.ObjectId('64d000000000000000000008');
|
||||
const TEAM_B_ID = new Types.ObjectId('64d000000000000000000009');
|
||||
|
||||
function createHarness() {
|
||||
const competition = {
|
||||
_id: COMPETITION_ID,
|
||||
matchId: MATCH_ID,
|
||||
communityId: COMMUNITY_ID,
|
||||
schemaVersion: 1,
|
||||
revision: 7,
|
||||
phase: 'running',
|
||||
teams: [],
|
||||
format: {
|
||||
type: 'paired-series',
|
||||
rule: { type: 'fixed-games', gameCount: 3, drawPolicy: 'allow' },
|
||||
},
|
||||
projection: {
|
||||
sourceRevision: 7,
|
||||
projectorVersion: 1,
|
||||
phase: 'running',
|
||||
formatType: 'paired-series',
|
||||
series: [],
|
||||
games: [],
|
||||
gameSlots: [],
|
||||
rounds: [],
|
||||
connectors: [],
|
||||
},
|
||||
createdAt: new Date('2026-07-11T00:00:00.000Z'),
|
||||
updatedAt: new Date('2026-07-12T00:00:00.000Z'),
|
||||
};
|
||||
const queryService = {
|
||||
getCompetition: jest.fn().mockResolvedValue(competition),
|
||||
getTeamView: jest.fn(),
|
||||
listFacts: jest.fn(),
|
||||
};
|
||||
const commandService = {
|
||||
acceptGame: jest.fn().mockResolvedValue({ competition, revision: 8 }),
|
||||
adjudicateSeries: jest.fn().mockResolvedValue({ competition, revision: 8 }),
|
||||
previewSeriesReversal: jest.fn().mockResolvedValue({
|
||||
sourceRevision: 7,
|
||||
impactHash: 'a'.repeat(64),
|
||||
impact: {},
|
||||
}),
|
||||
reverseSeries: jest.fn().mockResolvedValue({ competition, revision: 8 }),
|
||||
};
|
||||
return {
|
||||
queryService,
|
||||
commandService,
|
||||
controller: new CompetitionController(
|
||||
queryService as unknown as CompetitionQueryService,
|
||||
commandService as unknown as CompetitionCommandService,
|
||||
),
|
||||
};
|
||||
}
|
||||
|
||||
function adminUser() {
|
||||
return {
|
||||
_id: ADMIN_ID,
|
||||
communityId: COMMUNITY_ID,
|
||||
role: 'admin',
|
||||
} as never;
|
||||
}
|
||||
|
||||
function acceptGameBody() {
|
||||
return {
|
||||
gameId: GAME_ID.toHexString(),
|
||||
seriesId: SERIES_ID,
|
||||
gameSlotId: GAME_SLOT_ID.toHexString(),
|
||||
ordinal: 1,
|
||||
evidence: {
|
||||
type: 'riot',
|
||||
riotMatchId: 'KR_1',
|
||||
payloadHash: 'sha256:value',
|
||||
},
|
||||
mapping: {
|
||||
mappingVersion: 1,
|
||||
confidence: 1,
|
||||
blueTeamId: TEAM_A_ID.toHexString(),
|
||||
redTeamId: TEAM_B_ID.toHexString(),
|
||||
winnerTeamId: TEAM_A_ID.toHexString(),
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,530 @@
|
||||
import type {
|
||||
CompetitionCommandResponse,
|
||||
CompetitionDetailResponse,
|
||||
CompetitionFactsResponse,
|
||||
SeriesReversalPreviewResponse,
|
||||
TeamCompetitionViewResponse,
|
||||
} from '@lolympus/contracts';
|
||||
import {
|
||||
Body,
|
||||
Controller,
|
||||
Get,
|
||||
Headers,
|
||||
HttpException,
|
||||
Param,
|
||||
Post,
|
||||
Query,
|
||||
Res,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import type { Response } from 'express';
|
||||
import mongoose from 'mongoose';
|
||||
import { plainToInstance } from 'class-transformer';
|
||||
import { validateSync, type ValidationError } from 'class-validator';
|
||||
import { AllowPublicAccess } from '../auth/allow-public-access.decorator';
|
||||
import { CurrentUser } from '../auth/current-user.decorator';
|
||||
import { Roles } from '../auth/roles.decorator';
|
||||
import { RolesGuard } from '../auth/roles.guard';
|
||||
import { ParseObjectIdPipe } from '../common/parse-object-id.pipe';
|
||||
import type { UserDocument } from '../global/database/schema';
|
||||
import { CompetitionCommandService } from './competition-command.service';
|
||||
import { presentCompetitionDetail } from './competition.presenter';
|
||||
import { CompetitionQueryService } from './competition-query.service';
|
||||
import {
|
||||
AcceptCompetitionGameDto,
|
||||
AdjudicateCompetitionSeriesDto,
|
||||
CompetitionFactsQueryDto,
|
||||
PreviewCompetitionSeriesReversalDto,
|
||||
ReverseCompetitionSeriesDto,
|
||||
} from './dto/competition-command.dto';
|
||||
|
||||
@Controller('communities/:communityId/matches/:matchId/competition')
|
||||
export class CompetitionController {
|
||||
constructor(
|
||||
private readonly queryService: CompetitionQueryService,
|
||||
private readonly commandService: CompetitionCommandService,
|
||||
) {}
|
||||
|
||||
@Get()
|
||||
@AllowPublicAccess()
|
||||
public async getDetail(
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Res({ passthrough: true }) response: Response,
|
||||
): Promise<CompetitionDetailResponse> {
|
||||
return this.translate(async () => {
|
||||
const competition = await this.queryService.getCompetition({
|
||||
communityId,
|
||||
matchId,
|
||||
});
|
||||
response.setHeader('ETag', revisionEtag(competition.revision));
|
||||
return presentCompetitionDetail(competition as never);
|
||||
});
|
||||
}
|
||||
|
||||
// Temporarily public: community members are not all signed in yet, so the
|
||||
// team progress page addresses a team through an explicit `teamId` instead of
|
||||
// the caller's identity. A signed-in caller with no `teamId` keeps the
|
||||
// membership-scoped behaviour.
|
||||
@Get('team')
|
||||
@AllowPublicAccess()
|
||||
public async getTeamView(
|
||||
@CurrentUser() currentUser: UserDocument | undefined,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Query('teamId') requestedTeamId?: string,
|
||||
@Res({ passthrough: true }) response?: Response,
|
||||
): Promise<TeamCompetitionViewResponse> {
|
||||
return this.translate(async () => {
|
||||
const teamId = parseOptionalObjectId(requestedTeamId, 'teamId');
|
||||
if (!teamId) {
|
||||
if (!currentUser) {
|
||||
throw apiHttpError(
|
||||
401,
|
||||
'COMPETITION_TEAM_UNIDENTIFIED',
|
||||
'Sign in or provide a teamId query parameter to read a team view.',
|
||||
);
|
||||
}
|
||||
assertSameCommunity(currentUser, communityId);
|
||||
}
|
||||
const result = await this.queryService.getTeamView({
|
||||
communityId,
|
||||
matchId,
|
||||
...(teamId ? { teamId } : { userId: currentUser!._id }),
|
||||
});
|
||||
response?.setHeader('ETag', revisionEtag(result.revision));
|
||||
return result;
|
||||
});
|
||||
}
|
||||
|
||||
@Get('facts')
|
||||
@Roles('owner', 'admin')
|
||||
@UseGuards(RolesGuard)
|
||||
public async listFacts(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Query() rawQuery: unknown,
|
||||
): Promise<CompetitionFactsResponse> {
|
||||
return this.translate(async () => {
|
||||
assertSameCommunity(currentUser, communityId);
|
||||
const query = validateDto(CompetitionFactsQueryDto, rawQuery);
|
||||
return this.queryService.listFacts({
|
||||
communityId,
|
||||
matchId,
|
||||
cursor: query.cursor,
|
||||
limit: query.limit,
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
@Post('games/accept')
|
||||
@Roles('owner', 'admin')
|
||||
@UseGuards(RolesGuard)
|
||||
public async acceptGame(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Headers('if-match') ifMatch: string | undefined,
|
||||
@Headers('idempotency-key') idempotencyKey: string | undefined,
|
||||
@Body() rawBody: unknown,
|
||||
): Promise<CompetitionCommandResponse> {
|
||||
return this.translate(async () => {
|
||||
assertSameCommunity(currentUser, communityId);
|
||||
const body = validateDto(AcceptCompetitionGameDto, rawBody);
|
||||
const expectedRevision = requireCommandHeaders(ifMatch, idempotencyKey);
|
||||
const competition = await this.queryService.getCompetition({
|
||||
communityId,
|
||||
matchId,
|
||||
});
|
||||
const result = await this.commandService.acceptGame({
|
||||
competitionId: competition._id,
|
||||
expectedRevision,
|
||||
idempotencyKey: idempotencyKey!,
|
||||
actor: { type: 'user', userId: currentUser._id },
|
||||
gameId: new mongoose.Types.ObjectId(body.gameId),
|
||||
seriesId: new mongoose.Types.ObjectId(body.seriesId),
|
||||
gameSlotId: new mongoose.Types.ObjectId(body.gameSlotId),
|
||||
ordinal: body.ordinal,
|
||||
evidence: { ...body.evidence },
|
||||
mapping: { ...body.mapping },
|
||||
...(body.startedAt ? { startedAt: body.startedAt } : {}),
|
||||
...(body.durationSeconds === undefined
|
||||
? {}
|
||||
: { durationSeconds: body.durationSeconds }),
|
||||
...(body.participants ? { participants: body.participants } : {}),
|
||||
...(body.tournamentCode
|
||||
? {
|
||||
tournamentCode: {
|
||||
tournamentCodeId: new mongoose.Types.ObjectId(
|
||||
body.tournamentCode.tournamentCodeId,
|
||||
),
|
||||
riotMatchId: body.tournamentCode.riotMatchId,
|
||||
},
|
||||
}
|
||||
: {}),
|
||||
});
|
||||
return {
|
||||
competition: presentCompetitionDetail(result.competition as never),
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
@Post('series/:seriesId/adjudications')
|
||||
@Roles('owner', 'admin')
|
||||
@UseGuards(RolesGuard)
|
||||
public async adjudicateSeries(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Param('seriesId', ParseObjectIdPipe) seriesId: mongoose.Types.ObjectId,
|
||||
@Headers('if-match') ifMatch: string | undefined,
|
||||
@Headers('idempotency-key') idempotencyKey: string | undefined,
|
||||
@Body() rawBody: unknown,
|
||||
): Promise<CompetitionCommandResponse> {
|
||||
return this.translate(async () => {
|
||||
assertSameCommunity(currentUser, communityId);
|
||||
const body = validateDto(AdjudicateCompetitionSeriesDto, rawBody);
|
||||
const expectedRevision = requireCommandHeaders(ifMatch, idempotencyKey);
|
||||
const competition = await this.queryService.getCompetition({
|
||||
communityId,
|
||||
matchId,
|
||||
});
|
||||
const decision =
|
||||
body.decision.type === 'administrative-draw'
|
||||
? ({ type: 'administrative-draw' } as const)
|
||||
: {
|
||||
type: body.decision.type,
|
||||
winnerTeamId: new mongoose.Types.ObjectId(
|
||||
body.decision.winnerTeamId!,
|
||||
),
|
||||
};
|
||||
const result = await this.commandService.adjudicateSeries({
|
||||
competitionId: competition._id,
|
||||
expectedRevision,
|
||||
idempotencyKey: idempotencyKey!,
|
||||
actor: { type: 'user', userId: currentUser._id },
|
||||
seriesId,
|
||||
decision,
|
||||
reason: body.reason,
|
||||
});
|
||||
return {
|
||||
competition: presentCompetitionDetail(result.competition as never),
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
@Post('series/:seriesId/reversal-preview')
|
||||
@Roles('owner', 'admin')
|
||||
@UseGuards(RolesGuard)
|
||||
public async previewReversal(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Param('seriesId', ParseObjectIdPipe) seriesId: mongoose.Types.ObjectId,
|
||||
@Headers('if-match') ifMatch: string | undefined,
|
||||
@Body() rawBody: unknown,
|
||||
): Promise<SeriesReversalPreviewResponse> {
|
||||
return this.translate(async () => {
|
||||
assertSameCommunity(currentUser, communityId);
|
||||
const body = validateDto(PreviewCompetitionSeriesReversalDto, rawBody);
|
||||
const expectedRevision = requireRevisionHeader(ifMatch);
|
||||
const competition = await this.queryService.getCompetition({
|
||||
communityId,
|
||||
matchId,
|
||||
});
|
||||
return (await this.commandService.previewSeriesReversal({
|
||||
competitionId: competition._id,
|
||||
expectedRevision,
|
||||
seriesId,
|
||||
mode: body.mode,
|
||||
})) as SeriesReversalPreviewResponse;
|
||||
});
|
||||
}
|
||||
|
||||
@Post('series/:seriesId/reverse')
|
||||
@Roles('owner', 'admin')
|
||||
@UseGuards(RolesGuard)
|
||||
public async reverseSeries(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Param('seriesId', ParseObjectIdPipe) seriesId: mongoose.Types.ObjectId,
|
||||
@Headers('if-match') ifMatch: string | undefined,
|
||||
@Headers('idempotency-key') idempotencyKey: string | undefined,
|
||||
@Body() rawBody: unknown,
|
||||
): Promise<CompetitionCommandResponse> {
|
||||
return this.translate(async () => {
|
||||
assertSameCommunity(currentUser, communityId);
|
||||
const body = validateDto(ReverseCompetitionSeriesDto, rawBody);
|
||||
const expectedRevision = requireCommandHeaders(ifMatch, idempotencyKey);
|
||||
const competition = await this.queryService.getCompetition({
|
||||
communityId,
|
||||
matchId,
|
||||
});
|
||||
const result = await this.commandService.reverseSeries({
|
||||
competitionId: competition._id,
|
||||
expectedRevision,
|
||||
idempotencyKey: idempotencyKey!,
|
||||
actor: { type: 'user', userId: currentUser._id },
|
||||
seriesId,
|
||||
mode: body.mode,
|
||||
reason: body.reason,
|
||||
impactHash: body.impactHash,
|
||||
});
|
||||
return {
|
||||
competition: presentCompetitionDetail(result.competition as never),
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
private async translate<T>(operation: () => Promise<T>): Promise<T> {
|
||||
try {
|
||||
return await operation();
|
||||
} catch (error) {
|
||||
throw explicitHttpError(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function requireCommandHeaders(
|
||||
ifMatch: string | undefined,
|
||||
idempotencyKey: string | undefined,
|
||||
): number {
|
||||
const revision = parseRevision(ifMatch);
|
||||
if (
|
||||
revision === undefined ||
|
||||
typeof idempotencyKey !== 'string' ||
|
||||
idempotencyKey.trim().length === 0 ||
|
||||
idempotencyKey.length > 200
|
||||
) {
|
||||
throw apiHttpError(
|
||||
422,
|
||||
'INVALID_COMPETITION_COMMAND_HEADERS',
|
||||
'A numeric If-Match revision and non-empty Idempotency-Key are required.',
|
||||
);
|
||||
}
|
||||
return revision;
|
||||
}
|
||||
|
||||
function parseOptionalObjectId(
|
||||
value: string | undefined,
|
||||
field: string,
|
||||
): mongoose.Types.ObjectId | undefined {
|
||||
if (value === undefined || value.trim().length === 0) return undefined;
|
||||
if (!mongoose.isValidObjectId(value)) {
|
||||
throw apiHttpError(
|
||||
422,
|
||||
'INVALID_COMPETITION_REQUEST',
|
||||
`The ${field} query parameter must be a valid ObjectId.`,
|
||||
);
|
||||
}
|
||||
return new mongoose.Types.ObjectId(value);
|
||||
}
|
||||
|
||||
function requireRevisionHeader(ifMatch: string | undefined): number {
|
||||
const revision = parseRevision(ifMatch);
|
||||
if (revision === undefined) {
|
||||
throw apiHttpError(
|
||||
422,
|
||||
'INVALID_COMPETITION_COMMAND_HEADERS',
|
||||
'A numeric If-Match revision is required.',
|
||||
);
|
||||
}
|
||||
return revision;
|
||||
}
|
||||
|
||||
function parseRevision(value: string | undefined): number | undefined {
|
||||
if (!value) return undefined;
|
||||
const match = /^(?:W\/)?"?(\d+)"?$/.exec(value.trim());
|
||||
if (!match) return undefined;
|
||||
const revision = Number(match[1]);
|
||||
return Number.isSafeInteger(revision) ? revision : undefined;
|
||||
}
|
||||
|
||||
function revisionEtag(revision: number): string {
|
||||
return `"${revision}"`;
|
||||
}
|
||||
|
||||
function assertSameCommunity(
|
||||
user: UserDocument,
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
): void {
|
||||
if (!user?.communityId?.equals(communityId)) {
|
||||
throw apiHttpError(
|
||||
403,
|
||||
'COMPETITION_COMMUNITY_FORBIDDEN',
|
||||
'The authenticated user does not belong to this community.',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function explicitHttpError(error: unknown): HttpException {
|
||||
if (error instanceof HttpException) {
|
||||
const response = error.getResponse();
|
||||
if (
|
||||
typeof response === 'object' &&
|
||||
response !== null &&
|
||||
'error' in response
|
||||
) {
|
||||
return error;
|
||||
}
|
||||
return apiHttpError(
|
||||
error.getStatus(),
|
||||
statusCodeName(error.getStatus()),
|
||||
typeof response === 'string'
|
||||
? response
|
||||
: error.message || 'Competition request failed.',
|
||||
);
|
||||
}
|
||||
if (isCodedError(error)) {
|
||||
return apiHttpError(
|
||||
error.httpStatus ?? codedErrorStatus(error.code),
|
||||
error.code,
|
||||
error.message,
|
||||
error.details,
|
||||
);
|
||||
}
|
||||
return apiHttpError(
|
||||
500,
|
||||
'COMPETITION_INTERNAL_ERROR',
|
||||
'Competition request failed.',
|
||||
);
|
||||
}
|
||||
|
||||
function codedErrorStatus(code: string): number {
|
||||
switch (code) {
|
||||
case 'REVERSAL_SERIES_NOT_FOUND':
|
||||
case 'REVERSAL_REASON_REQUIRED':
|
||||
return 422;
|
||||
case 'REVERSAL_DESCENDANT_ACTIVITY':
|
||||
case 'REVERSAL_NO_ACTIVE_RESULT':
|
||||
case 'REVERSAL_PREVIEW_STALE':
|
||||
case 'DUPLICATE_FACT_ID':
|
||||
case 'DUPLICATE_GAME_ID':
|
||||
case 'DUPLICATE_RIOT_MATCH_ID':
|
||||
case 'DUPLICATE_GAME_SLOT':
|
||||
case 'DUPLICATE_GAME_ORDINAL':
|
||||
case 'DUPLICATE_ADJUDICATION':
|
||||
case 'FACT_ALREADY_REVERSED':
|
||||
case 'SERIES_ALREADY_COMPLETED':
|
||||
case 'WALKOVER_HAS_ACTIVE_GAMES':
|
||||
return 409;
|
||||
case 'FACT_REFERENCE_NOT_FOUND':
|
||||
case 'FACT_TYPE_INVALID':
|
||||
case 'GAME_SLOT_INVALID':
|
||||
case 'GAME_ORDINAL_INVALID':
|
||||
case 'GAME_SERIES_MISMATCH':
|
||||
case 'GAME_TEAM_MISMATCH':
|
||||
case 'GAME_WINNER_INVALID':
|
||||
case 'SERIES_DEFINITION_INVALID':
|
||||
case 'SERIES_PARTICIPANTS_INVALID':
|
||||
case 'ADJUDICATION_INVALID':
|
||||
case 'ADJUDICATION_DRAW_NOT_ALLOWED':
|
||||
return 422;
|
||||
default:
|
||||
return 500;
|
||||
}
|
||||
}
|
||||
|
||||
function statusCodeName(status: number): string {
|
||||
switch (status) {
|
||||
case 403:
|
||||
return 'COMPETITION_FORBIDDEN';
|
||||
case 404:
|
||||
return 'COMPETITION_NOT_FOUND';
|
||||
case 409:
|
||||
return 'COMPETITION_CONFLICT';
|
||||
case 412:
|
||||
return 'STALE_COMPETITION_REVISION';
|
||||
case 422:
|
||||
return 'INVALID_COMPETITION_REQUEST';
|
||||
default:
|
||||
return 'COMPETITION_REQUEST_FAILED';
|
||||
}
|
||||
}
|
||||
|
||||
function apiHttpError(
|
||||
status: number,
|
||||
code: string,
|
||||
message: string,
|
||||
details?: unknown,
|
||||
): HttpException {
|
||||
return new HttpException(
|
||||
{
|
||||
error: {
|
||||
code,
|
||||
message,
|
||||
...(details === undefined ? {} : { details }),
|
||||
},
|
||||
},
|
||||
status,
|
||||
);
|
||||
}
|
||||
|
||||
function isCodedError(error: unknown): error is {
|
||||
code: string;
|
||||
message: string;
|
||||
httpStatus?: number;
|
||||
details?: unknown;
|
||||
} {
|
||||
return (
|
||||
typeof error === 'object' &&
|
||||
error !== null &&
|
||||
typeof (error as { code?: unknown }).code === 'string' &&
|
||||
typeof (error as { message?: unknown }).message === 'string'
|
||||
);
|
||||
}
|
||||
|
||||
type DtoConstructor<T extends object> = new () => T;
|
||||
|
||||
function validateDto<T extends object>(
|
||||
constructor: DtoConstructor<T>,
|
||||
value: unknown,
|
||||
): T {
|
||||
if (typeof value !== 'object' || value === null || Array.isArray(value)) {
|
||||
throw apiHttpError(
|
||||
422,
|
||||
'INVALID_COMPETITION_REQUEST',
|
||||
'The Competition request body must be an object.',
|
||||
);
|
||||
}
|
||||
const instance = plainToInstance(constructor, value);
|
||||
const errors = validateSync(instance, {
|
||||
whitelist: true,
|
||||
forbidNonWhitelisted: true,
|
||||
forbidUnknownValues: true,
|
||||
});
|
||||
if (errors.length > 0) {
|
||||
throw apiHttpError(
|
||||
422,
|
||||
'INVALID_COMPETITION_REQUEST',
|
||||
'The Competition request payload is invalid.',
|
||||
{ fields: flattenValidationErrors(errors) },
|
||||
);
|
||||
}
|
||||
return instance;
|
||||
}
|
||||
|
||||
function flattenValidationErrors(
|
||||
errors: readonly ValidationError[],
|
||||
prefix = '',
|
||||
): Array<{ field: string; constraints: string[] }> {
|
||||
return errors.flatMap((error) => {
|
||||
const field = prefix ? `${prefix}.${error.property}` : error.property;
|
||||
const current = error.constraints
|
||||
? [{ field, constraints: Object.values(error.constraints) }]
|
||||
: [];
|
||||
return [
|
||||
...current,
|
||||
...flattenValidationErrors(error.children ?? [], field),
|
||||
];
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
export type CompetitionCommandErrorCode =
|
||||
| 'COMPETITION_NOT_FOUND'
|
||||
| 'COMPETITION_TRANSACTION_UNAVAILABLE'
|
||||
| 'IDEMPOTENCY_KEY_CONFLICT'
|
||||
| 'INVALID_COMPETITION_COMMAND'
|
||||
| 'STALE_COMPETITION_REVISION'
|
||||
| 'TOURNAMENT_CODE_ASSIGNMENT_CONFLICT';
|
||||
|
||||
/**
|
||||
* Transport-neutral command failure. Controllers may translate `httpStatus`
|
||||
* directly while command handlers remain usable by jobs and migrations.
|
||||
*/
|
||||
export class CompetitionCommandError extends Error {
|
||||
constructor(
|
||||
public readonly code: CompetitionCommandErrorCode,
|
||||
message: string,
|
||||
public readonly httpStatus: 404 | 409 | 412 | 422 | 500,
|
||||
public readonly details?: Readonly<Record<string, unknown>>,
|
||||
) {
|
||||
super(message);
|
||||
this.name = 'CompetitionCommandError';
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
import { MODULE_METADATA } from '@nestjs/common/constants';
|
||||
import { CompetitionBootstrapService } from './competition-bootstrap.service';
|
||||
import { CompetitionCommandService } from './competition-command.service';
|
||||
import { CompetitionController } from './competition.controller';
|
||||
import { CompetitionModule } from './competition.module';
|
||||
import { CompetitionQueryService } from './competition-query.service';
|
||||
|
||||
describe('CompetitionModule', () => {
|
||||
it('owns and exports the Competition transport and application services', () => {
|
||||
expect(
|
||||
Reflect.getMetadata(MODULE_METADATA.CONTROLLERS, CompetitionModule),
|
||||
).toEqual([CompetitionController]);
|
||||
expect(
|
||||
Reflect.getMetadata(MODULE_METADATA.PROVIDERS, CompetitionModule),
|
||||
).toEqual(
|
||||
expect.arrayContaining([
|
||||
CompetitionBootstrapService,
|
||||
CompetitionCommandService,
|
||||
CompetitionQueryService,
|
||||
]),
|
||||
);
|
||||
expect(
|
||||
Reflect.getMetadata(MODULE_METADATA.EXPORTS, CompetitionModule),
|
||||
).toEqual(
|
||||
expect.arrayContaining([
|
||||
CompetitionBootstrapService,
|
||||
CompetitionCommandService,
|
||||
CompetitionQueryService,
|
||||
]),
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,20 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { CompetitionBootstrapService } from './competition-bootstrap.service';
|
||||
import { CompetitionCommandService } from './competition-command.service';
|
||||
import { CompetitionController } from './competition.controller';
|
||||
import { CompetitionQueryService } from './competition-query.service';
|
||||
|
||||
@Module({
|
||||
controllers: [CompetitionController],
|
||||
providers: [
|
||||
CompetitionBootstrapService,
|
||||
CompetitionCommandService,
|
||||
CompetitionQueryService,
|
||||
],
|
||||
exports: [
|
||||
CompetitionBootstrapService,
|
||||
CompetitionCommandService,
|
||||
CompetitionQueryService,
|
||||
],
|
||||
})
|
||||
export class CompetitionModule {}
|
||||
@@ -0,0 +1,97 @@
|
||||
import { presentCompetitionDetail } from './competition.presenter';
|
||||
|
||||
describe('presentCompetitionDetail', () => {
|
||||
it('returns the explicit public contract without persistence-only fields', () => {
|
||||
const response = presentCompetitionDetail({
|
||||
_id: objectId('competition-1'),
|
||||
matchId: objectId('match-1'),
|
||||
communityId: objectId('community-1'),
|
||||
schemaVersion: 1,
|
||||
projectorVersion: 3,
|
||||
revision: 7,
|
||||
phase: 'running',
|
||||
teams: [
|
||||
{
|
||||
teamId: objectId('team-8'),
|
||||
legacyTeamIndex: 8,
|
||||
displayOrder: 2,
|
||||
seedNumber: 2,
|
||||
name: '똥칼라파워',
|
||||
captainUserId: objectId('captain-8'),
|
||||
members: [
|
||||
{
|
||||
userId: objectId('user-8'),
|
||||
displayName: 'player 8',
|
||||
gameName: '칼라',
|
||||
tagLine: 'KR1',
|
||||
assignedPosition: 'MID',
|
||||
cost: 42,
|
||||
secretPuuid: 'must-not-leak',
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
format: {
|
||||
type: 'paired-series',
|
||||
rule: { type: 'fixed-games', gameCount: 3, drawPolicy: 'allow' },
|
||||
},
|
||||
seriesGraph: [{ internal: true }],
|
||||
projection: {
|
||||
sourceRevision: 7,
|
||||
projectorVersion: 3,
|
||||
phase: 'running',
|
||||
formatType: 'paired-series',
|
||||
series: [],
|
||||
games: [],
|
||||
gameSlots: [],
|
||||
rounds: [],
|
||||
connectors: [],
|
||||
},
|
||||
internalCommandReceipts: [{ idempotencyKey: 'secret' }],
|
||||
createdAt: new Date('2026-07-11T00:00:00.000Z'),
|
||||
updatedAt: new Date('2026-07-12T00:00:00.000Z'),
|
||||
});
|
||||
|
||||
expect(response).toMatchObject({
|
||||
id: 'competition-1',
|
||||
matchId: 'match-1',
|
||||
communityId: 'community-1',
|
||||
schemaVersion: 1,
|
||||
revision: 7,
|
||||
phase: 'running',
|
||||
createdAt: '2026-07-11T00:00:00.000Z',
|
||||
updatedAt: '2026-07-12T00:00:00.000Z',
|
||||
teams: [
|
||||
{
|
||||
teamId: 'team-8',
|
||||
displayOrder: 2,
|
||||
name: '똥칼라파워',
|
||||
captainUserId: 'captain-8',
|
||||
members: [
|
||||
{
|
||||
userId: 'user-8',
|
||||
displayName: 'player 8',
|
||||
gameName: '칼라',
|
||||
tagLine: 'KR1',
|
||||
assignedPosition: 'MID',
|
||||
cost: 42,
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
projection: {
|
||||
sourceRevision: 7,
|
||||
projectorVersion: 3,
|
||||
},
|
||||
});
|
||||
expect(response).not.toHaveProperty('seriesGraph');
|
||||
expect(response).not.toHaveProperty('internalCommandReceipts');
|
||||
expect(response.teams[0]).not.toHaveProperty('legacyTeamIndex');
|
||||
expect(response.teams[0]).not.toHaveProperty('seedNumber');
|
||||
expect(response.teams[0].members[0]).not.toHaveProperty('secretPuuid');
|
||||
});
|
||||
});
|
||||
|
||||
function objectId(value: string) {
|
||||
return { toString: () => value };
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
import type {
|
||||
CommunityId,
|
||||
CompetitionDetailResponse,
|
||||
CompetitionFormat,
|
||||
CompetitionId,
|
||||
CompetitionPhase,
|
||||
CompetitionProjection,
|
||||
MatchId,
|
||||
PlayerPosition,
|
||||
TeamId,
|
||||
UserId,
|
||||
} from '@lolympus/contracts';
|
||||
|
||||
type IdLike = string | { toString(): string };
|
||||
|
||||
interface CompetitionMemberSource {
|
||||
userId: IdLike;
|
||||
displayName: string;
|
||||
gameName?: string;
|
||||
tagLine?: string;
|
||||
profileIconId?: number;
|
||||
assignedPosition?: string;
|
||||
cost?: number;
|
||||
[key: string]: unknown;
|
||||
}
|
||||
|
||||
interface CompetitionTeamSource {
|
||||
teamId: IdLike;
|
||||
displayOrder: number;
|
||||
name: string;
|
||||
captainUserId?: IdLike;
|
||||
members: CompetitionMemberSource[];
|
||||
[key: string]: unknown;
|
||||
}
|
||||
|
||||
export interface CompetitionDetailSource {
|
||||
_id: IdLike;
|
||||
matchId: IdLike;
|
||||
communityId: IdLike;
|
||||
schemaVersion: number;
|
||||
revision: number;
|
||||
phase: CompetitionPhase;
|
||||
teams: CompetitionTeamSource[];
|
||||
format: Record<string, unknown>;
|
||||
projection: Record<string, unknown>;
|
||||
createdAt: Date | string;
|
||||
updatedAt: Date | string;
|
||||
[key: string]: unknown;
|
||||
}
|
||||
|
||||
/** Build the public wire DTO without ever spreading a persistence document. */
|
||||
export function presentCompetitionDetail(
|
||||
source: CompetitionDetailSource,
|
||||
): CompetitionDetailResponse {
|
||||
return {
|
||||
id: asId<CompetitionId>(source._id),
|
||||
matchId: asId<MatchId>(source.matchId),
|
||||
communityId: asId<CommunityId>(source.communityId),
|
||||
schemaVersion: source.schemaVersion,
|
||||
revision: source.revision,
|
||||
phase: source.phase,
|
||||
teams: source.teams.map((team) => ({
|
||||
teamId: asId<TeamId>(team.teamId),
|
||||
displayOrder: team.displayOrder,
|
||||
name: team.name,
|
||||
...(team.captainUserId
|
||||
? { captainUserId: asId<UserId>(team.captainUserId) }
|
||||
: {}),
|
||||
members: team.members.map((member) => ({
|
||||
userId: asId<UserId>(member.userId),
|
||||
displayName: member.displayName,
|
||||
...(member.gameName ? { gameName: member.gameName } : {}),
|
||||
...(member.tagLine ? { tagLine: member.tagLine } : {}),
|
||||
...(member.profileIconId !== undefined
|
||||
? { profileIconId: member.profileIconId }
|
||||
: {}),
|
||||
...(member.assignedPosition
|
||||
? { assignedPosition: member.assignedPosition as PlayerPosition }
|
||||
: {}),
|
||||
...(member.cost !== undefined ? { cost: member.cost } : {}),
|
||||
})),
|
||||
})),
|
||||
format: toWireValue(source.format) as CompetitionFormat,
|
||||
projection: toWireValue(source.projection) as CompetitionProjection,
|
||||
createdAt: asIsoDateTime(source.createdAt),
|
||||
updatedAt: asIsoDateTime(source.updatedAt),
|
||||
};
|
||||
}
|
||||
|
||||
function asId<T extends string>(value: IdLike): T {
|
||||
return value.toString() as T;
|
||||
}
|
||||
|
||||
function asIsoDateTime(value: Date | string): string {
|
||||
return value instanceof Date ? value.toISOString() : value;
|
||||
}
|
||||
|
||||
function toWireValue(value: unknown): unknown {
|
||||
if (value instanceof Date) return value.toISOString();
|
||||
if (Array.isArray(value)) return value.map(toWireValue);
|
||||
if (isPlainRecord(value)) {
|
||||
return Object.fromEntries(
|
||||
Object.entries(value).map(([key, entry]) => [key, toWireValue(entry)]),
|
||||
);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
function isPlainRecord(value: unknown): value is Record<string, unknown> {
|
||||
return (
|
||||
typeof value === 'object' &&
|
||||
value !== null &&
|
||||
Object.getPrototypeOf(value) === Object.prototype
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
import {
|
||||
COMPETITION_OUTBOX_STATES,
|
||||
CompetitionFactSchema,
|
||||
CompetitionOutboxSchema,
|
||||
CompetitionSchema,
|
||||
TournamentCodeAssignmentSchema,
|
||||
competitionModelDefinitions,
|
||||
} from './competition.schema';
|
||||
import {
|
||||
MatchSchema,
|
||||
MatchStatsSchema,
|
||||
tournamentModelDefinitions,
|
||||
} from '../global/database/schema';
|
||||
|
||||
describe('Competition persistence schemas', () => {
|
||||
it('registers every Competition-owned collection', () => {
|
||||
expect(
|
||||
competitionModelDefinitions.map(({ name, schemaName }) => ({
|
||||
name,
|
||||
schemaName,
|
||||
})),
|
||||
).toEqual([
|
||||
{ name: 'competition', schemaName: 'competition' },
|
||||
{ name: 'competitionFact', schemaName: 'competition_fact' },
|
||||
{ name: 'competitionOutbox', schemaName: 'competition_outbox' },
|
||||
{
|
||||
name: 'tournamentCodeAssignment',
|
||||
schemaName: 'tournament_code_assignment',
|
||||
},
|
||||
]);
|
||||
expect(tournamentModelDefinitions).toEqual(
|
||||
expect.arrayContaining(
|
||||
competitionModelDefinitions.map(({ name, schemaName }) =>
|
||||
expect.objectContaining({ name, schemaName }),
|
||||
),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it('links Match and stats projections to the Competition revision', () => {
|
||||
expect(MatchSchema.path('competitionId')).toBeDefined();
|
||||
expect(MatchStatsSchema.path('sourceCompetitionId')).toBeDefined();
|
||||
expect(MatchStatsSchema.path('sourceRevision')).toBeDefined();
|
||||
expect(MatchStatsSchema.path('projectorVersion')).toBeDefined();
|
||||
expectIndexes(MatchSchema, [
|
||||
{
|
||||
keys: { competitionId: 1 },
|
||||
options: { unique: true },
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
it('enforces one Competition per Match and monotonic revisions', () => {
|
||||
expectIndexes(CompetitionSchema, [
|
||||
{
|
||||
keys: { matchId: 1 },
|
||||
options: { unique: true },
|
||||
},
|
||||
{
|
||||
keys: { communityId: 1, phase: 1, updatedAt: -1 },
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
it('makes fact ordering and command replay identities unique', () => {
|
||||
expect(CompetitionFactSchema.path('startedAt')).toBeDefined();
|
||||
expect(CompetitionFactSchema.path('durationSeconds')).toBeDefined();
|
||||
expect(CompetitionFactSchema.path('participants')).toBeDefined();
|
||||
expectIndexes(CompetitionFactSchema, [
|
||||
{
|
||||
keys: { competitionId: 1, revision: 1, ordinalWithinRevision: 1 },
|
||||
options: { unique: true },
|
||||
},
|
||||
{
|
||||
keys: { competitionId: 1, commandId: 1, ordinalWithinRevision: 1 },
|
||||
options: { unique: true },
|
||||
},
|
||||
{
|
||||
keys: { 'evidence.riotMatchId': 1 },
|
||||
options: { unique: true },
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
it('prevents duplicate outbox events', () => {
|
||||
expectIndexes(CompetitionOutboxSchema, [
|
||||
{
|
||||
keys: { eventId: 1 },
|
||||
options: { unique: true },
|
||||
},
|
||||
{
|
||||
keys: { state: 1, availableAt: 1 },
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
it('defines a terminal dead-letter state for poison outbox events', () => {
|
||||
expect(COMPETITION_OUTBOX_STATES).toContain('dead-letter');
|
||||
expect(CompetitionOutboxSchema.path('state').options.enum).toContain(
|
||||
'dead-letter',
|
||||
);
|
||||
});
|
||||
|
||||
it('allows only one active assignment for a code or GameSlot', () => {
|
||||
expectIndexes(TournamentCodeAssignmentSchema, [
|
||||
{
|
||||
keys: { gameSlotId: 1 },
|
||||
options: {
|
||||
unique: true,
|
||||
partialFilterExpression: { state: { $in: ['reserved', 'used'] } },
|
||||
},
|
||||
},
|
||||
{
|
||||
keys: { tournamentCodeId: 1 },
|
||||
options: {
|
||||
unique: true,
|
||||
partialFilterExpression: { state: { $in: ['reserved', 'used'] } },
|
||||
},
|
||||
},
|
||||
{
|
||||
keys: { riotMatchId: 1 },
|
||||
options: { unique: true },
|
||||
},
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
function expectIndexes(
|
||||
schema: {
|
||||
indexes(): Array<[Record<string, number>, Record<string, unknown>]>;
|
||||
},
|
||||
expected: Array<{
|
||||
keys: Record<string, number>;
|
||||
options?: Record<string, unknown>;
|
||||
}>,
|
||||
) {
|
||||
const indexes = schema.indexes();
|
||||
for (const candidate of expected) {
|
||||
expect(indexes).toEqual(
|
||||
expect.arrayContaining([
|
||||
[candidate.keys, expect.objectContaining(candidate.options ?? {})],
|
||||
]),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,463 @@
|
||||
import mongoose, { HydratedDocument, Schema } from 'mongoose';
|
||||
|
||||
export const COMPETITION_PHASES = [
|
||||
'ready',
|
||||
'running',
|
||||
'completed',
|
||||
'cancelled',
|
||||
] as const;
|
||||
export type CompetitionPhase = (typeof COMPETITION_PHASES)[number];
|
||||
|
||||
export const COMPETITION_FACT_TYPES = [
|
||||
'game-accepted',
|
||||
'game-voided',
|
||||
'series-adjudicated',
|
||||
'adjudication-reversed',
|
||||
] as const;
|
||||
export type CompetitionFactType = (typeof COMPETITION_FACT_TYPES)[number];
|
||||
|
||||
export const COMPETITION_OUTBOX_STATES = [
|
||||
'pending',
|
||||
'published',
|
||||
'failed',
|
||||
'dead-letter',
|
||||
] as const;
|
||||
export type CompetitionOutboxState = (typeof COMPETITION_OUTBOX_STATES)[number];
|
||||
|
||||
export const TOURNAMENT_CODE_ASSIGNMENT_STATES = [
|
||||
'reserved',
|
||||
'used',
|
||||
'released',
|
||||
'voided',
|
||||
] as const;
|
||||
export type TournamentCodeAssignmentState =
|
||||
(typeof TOURNAMENT_CODE_ASSIGNMENT_STATES)[number];
|
||||
|
||||
export interface CompetitionDomainInvariantIndex {
|
||||
collection:
|
||||
| 'match'
|
||||
| 'competition'
|
||||
| 'competition_fact'
|
||||
| 'competition_outbox'
|
||||
| 'tournament_code_assignment';
|
||||
key: mongoose.IndexDefinition;
|
||||
options: mongoose.IndexOptions & { name: string; unique: true };
|
||||
}
|
||||
|
||||
/**
|
||||
* Database-enforced Competition identities. Runtime schemas and the one-off
|
||||
* migration consume this same list so production cannot silently run with a
|
||||
* weaker set of uniqueness guarantees than command handling expects.
|
||||
*/
|
||||
export const COMPETITION_DOMAIN_INVARIANT_INDEXES: CompetitionDomainInvariantIndex[] =
|
||||
[
|
||||
{
|
||||
collection: 'match',
|
||||
key: { competitionId: 1 },
|
||||
options: {
|
||||
name: 'competitionId_1',
|
||||
unique: true,
|
||||
partialFilterExpression: {
|
||||
competitionId: { $type: 'objectId' },
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
collection: 'competition',
|
||||
key: { matchId: 1 },
|
||||
options: { name: 'matchId_1', unique: true },
|
||||
},
|
||||
{
|
||||
collection: 'competition_fact',
|
||||
key: { competitionId: 1, revision: 1, ordinalWithinRevision: 1 },
|
||||
options: {
|
||||
name: 'competitionId_1_revision_1_ordinalWithinRevision_1',
|
||||
unique: true,
|
||||
},
|
||||
},
|
||||
{
|
||||
collection: 'competition_fact',
|
||||
key: { competitionId: 1, commandId: 1, ordinalWithinRevision: 1 },
|
||||
options: {
|
||||
name: 'competitionId_1_commandId_1_ordinalWithinRevision_1',
|
||||
unique: true,
|
||||
},
|
||||
},
|
||||
{
|
||||
collection: 'competition_fact',
|
||||
key: { 'evidence.riotMatchId': 1 },
|
||||
options: {
|
||||
name: 'evidence.riotMatchId_1',
|
||||
unique: true,
|
||||
partialFilterExpression: {
|
||||
type: 'game-accepted',
|
||||
'evidence.riotMatchId': { $type: 'string' },
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
collection: 'competition_outbox',
|
||||
key: { eventId: 1 },
|
||||
options: { name: 'eventId_1', unique: true },
|
||||
},
|
||||
{
|
||||
collection: 'competition_outbox',
|
||||
key: { competitionId: 1, idempotencyKey: 1 },
|
||||
options: {
|
||||
name: 'competitionId_1_idempotencyKey_1',
|
||||
unique: true,
|
||||
},
|
||||
},
|
||||
{
|
||||
collection: 'tournament_code_assignment',
|
||||
key: { gameSlotId: 1 },
|
||||
options: {
|
||||
name: 'gameSlotId_1',
|
||||
unique: true,
|
||||
partialFilterExpression: { state: { $in: ['reserved', 'used'] } },
|
||||
},
|
||||
},
|
||||
{
|
||||
collection: 'tournament_code_assignment',
|
||||
key: { tournamentCodeId: 1 },
|
||||
options: {
|
||||
name: 'tournamentCodeId_1',
|
||||
unique: true,
|
||||
partialFilterExpression: { state: { $in: ['reserved', 'used'] } },
|
||||
},
|
||||
},
|
||||
{
|
||||
collection: 'tournament_code_assignment',
|
||||
key: { riotMatchId: 1 },
|
||||
options: {
|
||||
name: 'riotMatchId_1',
|
||||
unique: true,
|
||||
partialFilterExpression: { riotMatchId: { $type: 'string' } },
|
||||
},
|
||||
},
|
||||
];
|
||||
|
||||
export interface CompetitionTeamMemberSnapshot {
|
||||
userId: mongoose.Types.ObjectId;
|
||||
displayName: string;
|
||||
gameName?: string;
|
||||
tagLine?: string;
|
||||
profileIconId?: number;
|
||||
assignedPosition?: string;
|
||||
cost?: number;
|
||||
}
|
||||
|
||||
export interface CompetitionTeamSnapshot {
|
||||
teamId: mongoose.Types.ObjectId;
|
||||
legacyTeamIndex?: number;
|
||||
displayOrder: number;
|
||||
seedNumber: number;
|
||||
name: string;
|
||||
captainUserId?: mongoose.Types.ObjectId;
|
||||
members: CompetitionTeamMemberSnapshot[];
|
||||
}
|
||||
|
||||
export interface Competition {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
schemaVersion: number;
|
||||
projectorVersion: number;
|
||||
revision: number;
|
||||
phase: CompetitionPhase;
|
||||
teams: CompetitionTeamSnapshot[];
|
||||
format: Record<string, unknown>;
|
||||
seriesGraph: Array<Record<string, unknown>>;
|
||||
projection: Record<string, unknown>;
|
||||
createdAt: Date;
|
||||
updatedAt: Date;
|
||||
}
|
||||
|
||||
export type CompetitionDocument = HydratedDocument<Competition>;
|
||||
|
||||
export interface CompetitionFact {
|
||||
competitionId: mongoose.Types.ObjectId;
|
||||
type: CompetitionFactType;
|
||||
revision: number;
|
||||
ordinalWithinRevision: number;
|
||||
commandId: string;
|
||||
idempotencyKey: string;
|
||||
requestHash: string;
|
||||
schemaVersion: number;
|
||||
actor: Record<string, unknown>;
|
||||
occurredAt: Date;
|
||||
recordedAt: Date;
|
||||
causationId?: string;
|
||||
gameId?: mongoose.Types.ObjectId;
|
||||
seriesId?: mongoose.Types.ObjectId;
|
||||
gameSlotId?: mongoose.Types.ObjectId;
|
||||
ordinal?: number;
|
||||
startedAt?: Date;
|
||||
durationSeconds?: number;
|
||||
participants?: Array<Record<string, unknown>>;
|
||||
evidence?: Record<string, unknown>;
|
||||
mapping?: Record<string, unknown>;
|
||||
gameAcceptedFactId?: mongoose.Types.ObjectId;
|
||||
adjudicationFactId?: mongoose.Types.ObjectId;
|
||||
decision?: Record<string, unknown>;
|
||||
reason?: string;
|
||||
createdAt: Date;
|
||||
updatedAt: Date;
|
||||
}
|
||||
|
||||
export type CompetitionFactDocument = HydratedDocument<CompetitionFact>;
|
||||
|
||||
export interface CompetitionOutbox {
|
||||
eventId: string;
|
||||
competitionId: mongoose.Types.ObjectId;
|
||||
revision: number;
|
||||
commandId: string;
|
||||
idempotencyKey: string;
|
||||
requestHash: string;
|
||||
type: string;
|
||||
payload: Record<string, unknown>;
|
||||
state: CompetitionOutboxState;
|
||||
attemptCount: number;
|
||||
availableAt: Date;
|
||||
publishedAt?: Date;
|
||||
lastError?: string;
|
||||
createdAt: Date;
|
||||
updatedAt: Date;
|
||||
}
|
||||
|
||||
export type CompetitionOutboxDocument = HydratedDocument<CompetitionOutbox>;
|
||||
|
||||
export interface TournamentCodeAssignment {
|
||||
competitionId: mongoose.Types.ObjectId;
|
||||
seriesId: mongoose.Types.ObjectId;
|
||||
gameSlotId: mongoose.Types.ObjectId;
|
||||
tournamentCodeId: mongoose.Types.ObjectId;
|
||||
state: TournamentCodeAssignmentState;
|
||||
reservedAt: Date;
|
||||
usedAt?: Date;
|
||||
releasedAt?: Date;
|
||||
voidedAt?: Date;
|
||||
riotMatchId?: string;
|
||||
commandId: string;
|
||||
createdAt: Date;
|
||||
updatedAt: Date;
|
||||
}
|
||||
|
||||
export type TournamentCodeAssignmentDocument =
|
||||
HydratedDocument<TournamentCodeAssignment>;
|
||||
|
||||
const CompetitionTeamMemberSchema = new Schema<CompetitionTeamMemberSnapshot>(
|
||||
{
|
||||
userId: { type: Schema.Types.ObjectId, ref: 'user', required: true },
|
||||
displayName: { type: String, required: true },
|
||||
gameName: { type: String },
|
||||
tagLine: { type: String },
|
||||
profileIconId: { type: Number },
|
||||
assignedPosition: { type: String },
|
||||
cost: { type: Number },
|
||||
},
|
||||
{ _id: false },
|
||||
);
|
||||
|
||||
const CompetitionTeamSchema = new Schema<CompetitionTeamSnapshot>(
|
||||
{
|
||||
teamId: { type: Schema.Types.ObjectId, required: true },
|
||||
legacyTeamIndex: { type: Number, min: 1 },
|
||||
displayOrder: { type: Number, required: true, min: 1 },
|
||||
seedNumber: { type: Number, required: true, min: 1 },
|
||||
name: { type: String, required: true },
|
||||
captainUserId: { type: Schema.Types.ObjectId, ref: 'user' },
|
||||
members: {
|
||||
type: [CompetitionTeamMemberSchema],
|
||||
required: true,
|
||||
default: [],
|
||||
},
|
||||
},
|
||||
{ _id: false },
|
||||
);
|
||||
|
||||
export const CompetitionSchema: mongoose.Schema<Competition> =
|
||||
new Schema<Competition>(
|
||||
{
|
||||
matchId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
ref: 'match',
|
||||
required: true,
|
||||
},
|
||||
communityId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
ref: 'community',
|
||||
required: true,
|
||||
},
|
||||
schemaVersion: { type: Number, required: true, min: 1 },
|
||||
projectorVersion: { type: Number, required: true, min: 1 },
|
||||
revision: { type: Number, required: true, min: 0, default: 0 },
|
||||
phase: {
|
||||
type: String,
|
||||
enum: COMPETITION_PHASES,
|
||||
required: true,
|
||||
default: 'ready',
|
||||
},
|
||||
teams: { type: [CompetitionTeamSchema], required: true },
|
||||
format: { type: Schema.Types.Mixed, required: true },
|
||||
seriesGraph: { type: Schema.Types.Mixed, required: true },
|
||||
projection: { type: Schema.Types.Mixed, required: true },
|
||||
},
|
||||
{ timestamps: true, collection: 'competition' },
|
||||
);
|
||||
|
||||
applyCompetitionDomainInvariantIndexes(CompetitionSchema, 'competition');
|
||||
CompetitionSchema.index({ communityId: 1, phase: 1, updatedAt: -1 });
|
||||
|
||||
export const CompetitionFactSchema = new Schema<CompetitionFact>(
|
||||
{
|
||||
competitionId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
ref: 'competition',
|
||||
required: true,
|
||||
},
|
||||
type: { type: String, enum: COMPETITION_FACT_TYPES, required: true },
|
||||
revision: { type: Number, required: true, min: 1 },
|
||||
ordinalWithinRevision: { type: Number, required: true, min: 1 },
|
||||
commandId: { type: String, required: true },
|
||||
idempotencyKey: { type: String, required: true },
|
||||
requestHash: { type: String, required: true },
|
||||
schemaVersion: { type: Number, required: true, min: 1 },
|
||||
actor: { type: Schema.Types.Mixed, required: true },
|
||||
occurredAt: { type: Date, required: true },
|
||||
recordedAt: { type: Date, required: true },
|
||||
causationId: { type: String },
|
||||
gameId: { type: Schema.Types.ObjectId },
|
||||
seriesId: { type: Schema.Types.ObjectId },
|
||||
gameSlotId: { type: Schema.Types.ObjectId },
|
||||
ordinal: { type: Number, min: 1 },
|
||||
startedAt: { type: Date },
|
||||
durationSeconds: { type: Number, min: 0 },
|
||||
participants: { type: Schema.Types.Mixed },
|
||||
evidence: { type: Schema.Types.Mixed },
|
||||
mapping: { type: Schema.Types.Mixed },
|
||||
gameAcceptedFactId: { type: Schema.Types.ObjectId },
|
||||
adjudicationFactId: { type: Schema.Types.ObjectId },
|
||||
decision: { type: Schema.Types.Mixed },
|
||||
reason: { type: String },
|
||||
},
|
||||
{ timestamps: true, collection: 'competition_fact' },
|
||||
);
|
||||
|
||||
applyCompetitionDomainInvariantIndexes(
|
||||
CompetitionFactSchema,
|
||||
'competition_fact',
|
||||
);
|
||||
CompetitionFactSchema.index({ competitionId: 1, seriesId: 1, recordedAt: 1 });
|
||||
|
||||
export const CompetitionOutboxSchema = new Schema<CompetitionOutbox>(
|
||||
{
|
||||
eventId: { type: String, required: true },
|
||||
competitionId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
ref: 'competition',
|
||||
required: true,
|
||||
},
|
||||
revision: { type: Number, required: true, min: 1 },
|
||||
commandId: { type: String, required: true },
|
||||
idempotencyKey: { type: String, required: true },
|
||||
requestHash: { type: String, required: true },
|
||||
type: { type: String, required: true },
|
||||
payload: { type: Schema.Types.Mixed, required: true },
|
||||
state: {
|
||||
type: String,
|
||||
enum: COMPETITION_OUTBOX_STATES,
|
||||
required: true,
|
||||
default: 'pending',
|
||||
},
|
||||
attemptCount: { type: Number, required: true, min: 0, default: 0 },
|
||||
availableAt: { type: Date, required: true },
|
||||
publishedAt: { type: Date },
|
||||
lastError: { type: String },
|
||||
},
|
||||
{ timestamps: true, collection: 'competition_outbox' },
|
||||
);
|
||||
|
||||
applyCompetitionDomainInvariantIndexes(
|
||||
CompetitionOutboxSchema,
|
||||
'competition_outbox',
|
||||
);
|
||||
CompetitionOutboxSchema.index({ state: 1, availableAt: 1 });
|
||||
|
||||
export const TournamentCodeAssignmentSchema =
|
||||
new Schema<TournamentCodeAssignment>(
|
||||
{
|
||||
competitionId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
ref: 'competition',
|
||||
required: true,
|
||||
},
|
||||
seriesId: { type: Schema.Types.ObjectId, required: true },
|
||||
gameSlotId: { type: Schema.Types.ObjectId, required: true },
|
||||
tournamentCodeId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
ref: 'tournamentCode',
|
||||
required: true,
|
||||
},
|
||||
state: {
|
||||
type: String,
|
||||
enum: TOURNAMENT_CODE_ASSIGNMENT_STATES,
|
||||
required: true,
|
||||
},
|
||||
reservedAt: { type: Date, required: true },
|
||||
usedAt: { type: Date },
|
||||
releasedAt: { type: Date },
|
||||
voidedAt: { type: Date },
|
||||
riotMatchId: { type: String },
|
||||
commandId: { type: String, required: true },
|
||||
},
|
||||
{ timestamps: true, collection: 'tournament_code_assignment' },
|
||||
);
|
||||
|
||||
applyCompetitionDomainInvariantIndexes(
|
||||
TournamentCodeAssignmentSchema,
|
||||
'tournament_code_assignment',
|
||||
);
|
||||
TournamentCodeAssignmentSchema.index({ competitionId: 1, state: 1 });
|
||||
|
||||
export function applyCompetitionDomainInvariantIndexes(
|
||||
schema: mongoose.Schema,
|
||||
collection: CompetitionDomainInvariantIndex['collection'],
|
||||
): void {
|
||||
for (const index of COMPETITION_DOMAIN_INVARIANT_INDEXES) {
|
||||
if (index.collection !== collection) continue;
|
||||
schema.index(index.key, index.options);
|
||||
}
|
||||
}
|
||||
|
||||
export type CompetitionModelName =
|
||||
| 'competition'
|
||||
| 'competitionFact'
|
||||
| 'competitionOutbox'
|
||||
| 'tournamentCodeAssignment';
|
||||
|
||||
export const competitionModelDefinitions: Array<{
|
||||
name: CompetitionModelName;
|
||||
schema: mongoose.Schema;
|
||||
schemaName: string;
|
||||
}> = [
|
||||
{
|
||||
name: 'competition',
|
||||
schema: CompetitionSchema,
|
||||
schemaName: 'competition',
|
||||
},
|
||||
{
|
||||
name: 'competitionFact',
|
||||
schema: CompetitionFactSchema,
|
||||
schemaName: 'competition_fact',
|
||||
},
|
||||
{
|
||||
name: 'competitionOutbox',
|
||||
schema: CompetitionOutboxSchema,
|
||||
schemaName: 'competition_outbox',
|
||||
},
|
||||
{
|
||||
name: 'tournamentCodeAssignment',
|
||||
schema: TournamentCodeAssignmentSchema,
|
||||
schemaName: 'tournament_code_assignment',
|
||||
},
|
||||
];
|
||||
@@ -0,0 +1,637 @@
|
||||
import { projectCompetition } from './competition-projector';
|
||||
import {
|
||||
CompetitionDomainError,
|
||||
type CompetitionDomainErrorCode,
|
||||
} from './domain-error';
|
||||
import { generateSeriesGraph } from './series-graph';
|
||||
|
||||
describe('projectCompetition', () => {
|
||||
it('keeps a three-way round-robin cycle on a shared rank', () => {
|
||||
const competitionId = 'competition-round-robin-tie';
|
||||
const teams = ['team-1', 'team-2', 'team-3'].map((teamId, index) => ({
|
||||
teamId,
|
||||
displayOrder: index + 1,
|
||||
seedNumber: index + 1,
|
||||
}));
|
||||
const format = {
|
||||
type: 'round-robin' as const,
|
||||
rule: fixedGames(1),
|
||||
tieBreakers: ['series-wins', 'game-diff', 'head-to-head'] as const,
|
||||
};
|
||||
const seriesGraph = generateSeriesGraph({
|
||||
competitionId,
|
||||
teams,
|
||||
format,
|
||||
});
|
||||
const accept = acceptedGameFactory(competitionId);
|
||||
const oneVersusTwo = requireRoundRobinSeries(
|
||||
seriesGraph,
|
||||
'team-1',
|
||||
'team-2',
|
||||
);
|
||||
const oneVersusThree = requireRoundRobinSeries(
|
||||
seriesGraph,
|
||||
'team-1',
|
||||
'team-3',
|
||||
);
|
||||
const twoVersusThree = requireRoundRobinSeries(
|
||||
seriesGraph,
|
||||
'team-2',
|
||||
'team-3',
|
||||
);
|
||||
const facts = [
|
||||
accept(oneVersusTwo, 1, 'team-1', 'team-2', 'team-1'),
|
||||
accept(twoVersusThree, 1, 'team-2', 'team-3', 'team-2'),
|
||||
accept(oneVersusThree, 1, 'team-3', 'team-1', 'team-3'),
|
||||
];
|
||||
|
||||
const projection = projectCompetition({
|
||||
competitionId,
|
||||
revision: facts.length,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts,
|
||||
});
|
||||
|
||||
expect(projection.outcome).toEqual({
|
||||
type: 'round-robin',
|
||||
leaderTeamIds: ['team-1', 'team-2', 'team-3'],
|
||||
standings: [
|
||||
standing('team-1', 1),
|
||||
standing('team-2', 1),
|
||||
standing('team-3', 1),
|
||||
],
|
||||
completedAt: '2026-07-12T00:00:03.000Z',
|
||||
});
|
||||
expect(projection.games).toHaveLength(3);
|
||||
expect(projection.gameSlots).toHaveLength(3);
|
||||
expect(projection.rounds).toEqual(
|
||||
expect.arrayContaining([
|
||||
expect.objectContaining({ stage: 'round-robin', roundNumber: 1 }),
|
||||
]),
|
||||
);
|
||||
});
|
||||
|
||||
it('attributes WB_R2_M2 wins to team ids when series and bracket slot orders differ', () => {
|
||||
const competitionId = 'competition-wb-r2-m2-regression';
|
||||
const teams = [
|
||||
seededTeam('team-1', 1),
|
||||
seededTeam('team-8', 2),
|
||||
seededTeam('team-3', 3),
|
||||
seededTeam('team-4', 4),
|
||||
seededTeam('team-5', 5),
|
||||
seededTeam('team-6', 6),
|
||||
seededTeam('team-7', 7),
|
||||
seededTeam('team-2', 8),
|
||||
];
|
||||
const format = doubleEliminationFormat({ upperWinsRequired: 2 });
|
||||
const seriesGraph = generateSeriesGraph({
|
||||
competitionId,
|
||||
teams,
|
||||
format,
|
||||
});
|
||||
const wbRoundOneMatchThree = requireSeries(seriesGraph, 'WB_R1_M3');
|
||||
const wbRoundOneMatchFour = requireSeries(seriesGraph, 'WB_R1_M4');
|
||||
const wbRoundTwoMatchTwo = requireSeries(seriesGraph, 'WB_R2_M2');
|
||||
const accept = acceptedGameFactory(competitionId);
|
||||
const facts = [
|
||||
accept(wbRoundOneMatchThree, 1, 'team-8', 'team-7', 'team-8'),
|
||||
accept(wbRoundOneMatchThree, 2, 'team-7', 'team-8', 'team-8'),
|
||||
accept(wbRoundOneMatchFour, 1, 'team-3', 'team-6', 'team-3'),
|
||||
accept(wbRoundOneMatchFour, 2, 'team-6', 'team-3', 'team-3'),
|
||||
accept(wbRoundTwoMatchTwo, 1, 'team-3', 'team-8', 'team-8'),
|
||||
accept(wbRoundTwoMatchTwo, 2, 'team-8', 'team-3', 'team-3'),
|
||||
accept(wbRoundTwoMatchTwo, 3, 'team-3', 'team-8', 'team-8'),
|
||||
];
|
||||
|
||||
const projection = projectCompetition({
|
||||
competitionId,
|
||||
revision: facts.length,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts,
|
||||
});
|
||||
|
||||
expect(projectedSeries(projection, 'WB_R2_M2')).toMatchObject({
|
||||
status: 'completed',
|
||||
entries: [
|
||||
{ slot: 'A', teamId: 'team-8', gameWins: 2 },
|
||||
{ slot: 'B', teamId: 'team-3', gameWins: 1 },
|
||||
],
|
||||
outcome: {
|
||||
type: 'played',
|
||||
winnerTeamId: 'team-8',
|
||||
loserTeamId: 'team-3',
|
||||
},
|
||||
});
|
||||
expect(projectedSeries(projection, 'WB_FINAL').entries).toContainEqual({
|
||||
slot: 'B',
|
||||
teamId: 'team-8',
|
||||
gameWins: 0,
|
||||
});
|
||||
expect(projectedSeries(projection, 'LB_R2_M1').entries).toContainEqual({
|
||||
slot: 'B',
|
||||
teamId: 'team-3',
|
||||
gameWins: 0,
|
||||
});
|
||||
expect(projection.games).toHaveLength(7);
|
||||
expect(
|
||||
projection.games.filter(
|
||||
(game) => game.seriesId === wbRoundTwoMatchTwo.id,
|
||||
),
|
||||
).toEqual([
|
||||
expect.objectContaining({ winnerTeamId: 'team-8', ordinal: 1 }),
|
||||
expect.objectContaining({ winnerTeamId: 'team-3', ordinal: 2 }),
|
||||
expect.objectContaining({ winnerTeamId: 'team-8', ordinal: 3 }),
|
||||
]);
|
||||
expect(
|
||||
projection.connectors.some(
|
||||
(connector) =>
|
||||
connector.from.seriesId === wbRoundTwoMatchTwo.id &&
|
||||
connector.from.select === 'winner' &&
|
||||
connector.to.slot === 'B',
|
||||
),
|
||||
).toBe(true);
|
||||
});
|
||||
|
||||
it('activates the predefined reset final only when the lower-bracket finalist wins GF', () => {
|
||||
const competitionId = 'competition-grand-final-reset';
|
||||
const teams = Array.from({ length: 4 }, (_, index) =>
|
||||
seededTeam(`team-${index + 1}`, index + 1),
|
||||
);
|
||||
const format = doubleEliminationFormat({ upperWinsRequired: 1 });
|
||||
const seriesGraph = generateSeriesGraph({
|
||||
competitionId,
|
||||
teams,
|
||||
format,
|
||||
});
|
||||
const resetDefinition = requireSeries(seriesGraph, 'GF_RESET');
|
||||
|
||||
const initial = projectCompetition({
|
||||
competitionId,
|
||||
revision: 0,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts: [],
|
||||
});
|
||||
expect(projectedSeries(initial, 'GF_RESET')).toMatchObject({
|
||||
seriesId: resetDefinition.id,
|
||||
status: 'inactive',
|
||||
});
|
||||
|
||||
const accept = acceptedGameFactory(competitionId);
|
||||
const facts = [
|
||||
accept(
|
||||
requireSeries(seriesGraph, 'WB_R1_M1'),
|
||||
1,
|
||||
'team-1',
|
||||
'team-4',
|
||||
'team-1',
|
||||
),
|
||||
accept(
|
||||
requireSeries(seriesGraph, 'WB_R1_M2'),
|
||||
1,
|
||||
'team-2',
|
||||
'team-3',
|
||||
'team-2',
|
||||
),
|
||||
accept(
|
||||
requireSeries(seriesGraph, 'WB_FINAL'),
|
||||
1,
|
||||
'team-1',
|
||||
'team-2',
|
||||
'team-1',
|
||||
),
|
||||
accept(
|
||||
requireSeries(seriesGraph, 'LB_R1_M1'),
|
||||
1,
|
||||
'team-3',
|
||||
'team-4',
|
||||
'team-3',
|
||||
),
|
||||
accept(
|
||||
requireSeries(seriesGraph, 'LB_FINAL'),
|
||||
1,
|
||||
'team-3',
|
||||
'team-2',
|
||||
'team-2',
|
||||
),
|
||||
accept(requireSeries(seriesGraph, 'GF'), 1, 'team-2', 'team-1', 'team-2'),
|
||||
];
|
||||
|
||||
const afterGrandFinal = projectCompetition({
|
||||
competitionId,
|
||||
revision: facts.length,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts,
|
||||
});
|
||||
|
||||
expect(projectedSeries(afterGrandFinal, 'GF_RESET')).toMatchObject({
|
||||
seriesId: resetDefinition.id,
|
||||
status: 'ready',
|
||||
entries: [
|
||||
{ slot: 'A', teamId: 'team-1', gameWins: 0 },
|
||||
{ slot: 'B', teamId: 'team-2', gameWins: 0 },
|
||||
],
|
||||
});
|
||||
expect(afterGrandFinal).not.toHaveProperty('outcome');
|
||||
expect(afterGrandFinal.gameSlots).toEqual(
|
||||
expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
seriesId: resetDefinition.id,
|
||||
status: 'ready',
|
||||
entries: [
|
||||
{ slot: 'A', teamId: 'team-1' },
|
||||
{ slot: 'B', teamId: 'team-2' },
|
||||
],
|
||||
}),
|
||||
]),
|
||||
);
|
||||
});
|
||||
|
||||
it('makes a voided GameSlot ready again when its Series can be replayed', () => {
|
||||
const competitionId = 'competition-replay-voided-slot';
|
||||
const teams = [seededTeam('team-1', 1), seededTeam('team-2', 2)];
|
||||
const format = {
|
||||
type: 'paired-series' as const,
|
||||
rule: fixedGames(1),
|
||||
};
|
||||
const seriesGraph = generateSeriesGraph({
|
||||
competitionId,
|
||||
teams,
|
||||
format,
|
||||
});
|
||||
const definition = seriesGraph[0];
|
||||
const accepted = acceptedGameFactory(competitionId)(
|
||||
definition,
|
||||
1,
|
||||
'team-1',
|
||||
'team-2',
|
||||
'team-1',
|
||||
);
|
||||
|
||||
const projection = projectCompetition({
|
||||
competitionId,
|
||||
revision: 2,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts: [
|
||||
accepted,
|
||||
{
|
||||
id: 'fact-void-game-1',
|
||||
type: 'game-voided',
|
||||
competitionId,
|
||||
revision: 2,
|
||||
ordinalWithinRevision: 1,
|
||||
commandId: 'command-void-game-1',
|
||||
schemaVersion: 1,
|
||||
actor: { type: 'user' as const },
|
||||
occurredAt: new Date('2026-07-12T00:00:02.000Z'),
|
||||
recordedAt: new Date('2026-07-12T00:01:02.000Z'),
|
||||
gameAcceptedFactId: accepted.id,
|
||||
reason: 'Incorrect Riot evidence',
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
expect(projection.phase).toBe('ready');
|
||||
expect(projection.series[0]).toMatchObject({ status: 'ready' });
|
||||
expect(projection.gameSlots[0]).toMatchObject({ status: 'ready' });
|
||||
expect(projection.games).toEqual([]);
|
||||
});
|
||||
|
||||
it('rejects an accepted game that targets a Series outside the graph', () => {
|
||||
const competitionId = 'competition-unknown-game-series';
|
||||
const teams = [seededTeam('team-1', 1), seededTeam('team-2', 2)];
|
||||
const format = {
|
||||
type: 'paired-series' as const,
|
||||
rule: fixedGames(1),
|
||||
};
|
||||
const seriesGraph = generateSeriesGraph({ competitionId, teams, format });
|
||||
const accepted = acceptedGameFactory(competitionId)(
|
||||
seriesGraph[0],
|
||||
1,
|
||||
'team-1',
|
||||
'team-2',
|
||||
'team-1',
|
||||
);
|
||||
|
||||
expectCompetitionDomainError(
|
||||
() =>
|
||||
projectCompetition({
|
||||
competitionId,
|
||||
revision: 1,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts: [{ ...accepted, seriesId: 'series-does-not-exist' }],
|
||||
}),
|
||||
'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',
|
||||
);
|
||||
|
||||
expectCompetitionDomainError(
|
||||
() =>
|
||||
projectCompetition({
|
||||
competitionId,
|
||||
revision: 1,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts: [{ ...accepted, gameSlotId: 'slot-does-not-exist' }],
|
||||
}),
|
||||
'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 });
|
||||
|
||||
expectCompetitionDomainError(
|
||||
() =>
|
||||
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',
|
||||
},
|
||||
],
|
||||
}),
|
||||
'ADJUDICATION_INVALID',
|
||||
);
|
||||
});
|
||||
|
||||
it('completes an eight-team double elimination with shared elimination-round placements', () => {
|
||||
const competitionId = 'competition-eight-team-completion';
|
||||
const teams = Array.from({ length: 8 }, (_, index) =>
|
||||
seededTeam(`team-${index + 1}`, index + 1),
|
||||
);
|
||||
const format = doubleEliminationFormat({ upperWinsRequired: 1 });
|
||||
const seriesGraph = generateSeriesGraph({ competitionId, teams, format });
|
||||
const accept = acceptedGameFactory(competitionId);
|
||||
const facts: ReturnType<typeof accept>[] = [];
|
||||
let projection = projectCompetition({
|
||||
competitionId,
|
||||
revision: 0,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts,
|
||||
});
|
||||
|
||||
for (let guard = 0; projection.phase !== 'completed'; guard += 1) {
|
||||
if (guard > seriesGraph.length) {
|
||||
throw new Error('Double-elimination projection did not converge.');
|
||||
}
|
||||
const playable = projection.series.find(
|
||||
(series) => series.status === 'ready',
|
||||
);
|
||||
if (!playable) throw new Error('Missing playable Series.');
|
||||
const definition = seriesGraph.find(
|
||||
(series) => series.id === playable.seriesId,
|
||||
);
|
||||
const [entryA, entryB] = playable.entries;
|
||||
if (!definition || !entryA.teamId || !entryB.teamId) {
|
||||
throw new Error('Playable Series has unresolved participants.');
|
||||
}
|
||||
facts.push(
|
||||
accept(definition, 1, entryA.teamId, entryB.teamId, entryA.teamId),
|
||||
);
|
||||
projection = projectCompetition({
|
||||
competitionId,
|
||||
revision: facts.length,
|
||||
projectorVersion: 1,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts,
|
||||
});
|
||||
}
|
||||
|
||||
expect(projection.outcome?.type).toBe('double-elimination');
|
||||
if (projection.outcome?.type !== 'double-elimination') {
|
||||
throw new Error('Expected a double-elimination outcome.');
|
||||
}
|
||||
expect(typeof projection.outcome.championTeamId).toBe('string');
|
||||
expect(projection.outcome.placements).toHaveLength(8);
|
||||
expect(projection.placements?.map(({ rank }) => rank)).toEqual([
|
||||
1, 2, 3, 4, 5, 5, 7, 7,
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
function fixedGames(gameCount: number) {
|
||||
return {
|
||||
type: 'fixed-games' as const,
|
||||
gameCount,
|
||||
drawPolicy: 'allow' as const,
|
||||
};
|
||||
}
|
||||
|
||||
function seededTeam(teamId: string, seedNumber: number) {
|
||||
return { teamId, displayOrder: seedNumber, seedNumber };
|
||||
}
|
||||
|
||||
function doubleEliminationFormat(params: { upperWinsRequired: 1 | 2 }) {
|
||||
const upper =
|
||||
params.upperWinsRequired === 1
|
||||
? { type: 'first-to' as const, winsRequired: 1, maxGames: 1 }
|
||||
: { type: 'first-to' as const, winsRequired: 2, maxGames: 3 };
|
||||
const singleGame = {
|
||||
type: 'first-to' as const,
|
||||
winsRequired: 1,
|
||||
maxGames: 1,
|
||||
};
|
||||
return {
|
||||
type: 'double-elimination' as const,
|
||||
resetFinalEnabled: true,
|
||||
rules: {
|
||||
upper,
|
||||
lower: singleGame,
|
||||
grandFinal: singleGame,
|
||||
resetFinal: singleGame,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function requireSeries<
|
||||
T extends { code?: string; id: string; gameSlots: Array<GameSlotLike> },
|
||||
>(graph: T[], code: string): T {
|
||||
const definition = graph.find((series) => series.code === code);
|
||||
if (!definition) throw new Error(`Missing series ${code}`);
|
||||
return definition;
|
||||
}
|
||||
|
||||
function requireRoundRobinSeries<
|
||||
T extends {
|
||||
id: string;
|
||||
gameSlots: Array<GameSlotLike>;
|
||||
slots: Array<{ source: { type: string; teamId?: string } }>;
|
||||
},
|
||||
>(graph: T[], leftTeamId: string, rightTeamId: string): T {
|
||||
const expected = new Set([leftTeamId, rightTeamId]);
|
||||
const definition = graph.find((series) => {
|
||||
const actual = series.slots
|
||||
.filter((slot) => slot.source.type === 'team')
|
||||
.map((slot) => slot.source.teamId);
|
||||
return (
|
||||
actual.length === 2 && actual.every((teamId) => expected.has(teamId!))
|
||||
);
|
||||
});
|
||||
if (!definition) {
|
||||
throw new Error(`Missing round-robin series ${leftTeamId}/${rightTeamId}`);
|
||||
}
|
||||
return definition;
|
||||
}
|
||||
|
||||
function acceptedGameFactory(competitionId: string) {
|
||||
let revision = 0;
|
||||
return <T extends { id: string; gameSlots: Array<GameSlotLike> }>(
|
||||
definition: T,
|
||||
ordinal: number,
|
||||
blueTeamId: string,
|
||||
redTeamId: string,
|
||||
winnerTeamId: string,
|
||||
) => {
|
||||
revision += 1;
|
||||
const gameSlot = definition.gameSlots.find(
|
||||
(candidate) => candidate.ordinal === ordinal,
|
||||
);
|
||||
if (!gameSlot) {
|
||||
throw new Error(`Missing game slot ${definition.id}/${ordinal}`);
|
||||
}
|
||||
return {
|
||||
id: `fact-${revision}`,
|
||||
type: 'game-accepted' as const,
|
||||
competitionId,
|
||||
revision,
|
||||
ordinalWithinRevision: 1,
|
||||
commandId: `command-${revision}`,
|
||||
schemaVersion: 1,
|
||||
actor: { type: 'system' as const },
|
||||
occurredAt: new Date(
|
||||
`2026-07-12T00:00:${String(revision).padStart(2, '0')}.000Z`,
|
||||
),
|
||||
recordedAt: new Date(
|
||||
`2026-07-12T00:01:${String(revision).padStart(2, '0')}.000Z`,
|
||||
),
|
||||
gameId: `game-${revision}`,
|
||||
seriesId: definition.id,
|
||||
gameSlotId: gameSlot.id,
|
||||
ordinal,
|
||||
evidence: {
|
||||
type: 'riot' as const,
|
||||
riotMatchId: `KR_${competitionId}_${revision}`,
|
||||
payloadHash: `sha256:${competitionId}:${revision}`,
|
||||
},
|
||||
mapping: {
|
||||
mappingVersion: 1,
|
||||
confidence: 1,
|
||||
blueTeamId,
|
||||
redTeamId,
|
||||
winnerTeamId,
|
||||
participantAssignments: [],
|
||||
},
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
function projectedSeries<
|
||||
T extends { series: Array<{ code?: string; seriesId: string }> },
|
||||
>(projection: T, code: string) {
|
||||
const series = projection.series.find((candidate) => candidate.code === code);
|
||||
if (!series) throw new Error(`Missing projected series ${code}`);
|
||||
return series;
|
||||
}
|
||||
|
||||
function standing(teamId: string, rank: number) {
|
||||
return {
|
||||
teamId,
|
||||
rank,
|
||||
seriesPlayed: 2,
|
||||
seriesWins: 1,
|
||||
seriesLosses: 1,
|
||||
seriesDraws: 0,
|
||||
gameWins: 1,
|
||||
gameLosses: 1,
|
||||
gameDiff: 0,
|
||||
};
|
||||
}
|
||||
|
||||
interface GameSlotLike {
|
||||
id: string;
|
||||
ordinal: number;
|
||||
}
|
||||
|
||||
function expectCompetitionDomainError(
|
||||
action: () => unknown,
|
||||
expectedCode: CompetitionDomainErrorCode,
|
||||
): void {
|
||||
let thrown: unknown;
|
||||
try {
|
||||
action();
|
||||
} catch (error: unknown) {
|
||||
thrown = error;
|
||||
}
|
||||
|
||||
expect(thrown).toBeInstanceOf(CompetitionDomainError);
|
||||
if (!(thrown instanceof CompetitionDomainError)) {
|
||||
throw new Error(
|
||||
`Expected CompetitionDomainError, received ${String(thrown)}`,
|
||||
);
|
||||
}
|
||||
expect(thrown.code).toBe(expectedCode);
|
||||
}
|
||||
@@ -0,0 +1,995 @@
|
||||
import { assertCompetitionInvariant } from './domain-error';
|
||||
import type {
|
||||
CompetitionGraphFormat,
|
||||
CompetitionGraphTeam,
|
||||
ParticipantSource,
|
||||
SeriesDefinition,
|
||||
} from './series-graph';
|
||||
import {
|
||||
projectSeries,
|
||||
type SeriesDefinitionLike,
|
||||
type SeriesProjection,
|
||||
type SeriesProjectionOutcome,
|
||||
} from './series-projector';
|
||||
|
||||
export interface ProjectCompetitionInput {
|
||||
competitionId: string;
|
||||
revision: number;
|
||||
projectorVersion: number;
|
||||
teams: readonly CompetitionGraphTeam[];
|
||||
format: CompetitionGraphFormat;
|
||||
seriesGraph: readonly SeriesDefinition[];
|
||||
facts: readonly unknown[];
|
||||
}
|
||||
|
||||
export interface RoundRobinStanding {
|
||||
teamId: string;
|
||||
rank: number;
|
||||
seriesPlayed: number;
|
||||
seriesWins: number;
|
||||
seriesLosses: number;
|
||||
seriesDraws: number;
|
||||
gameWins: number;
|
||||
gameLosses: number;
|
||||
gameDiff: number;
|
||||
}
|
||||
|
||||
export interface CompetitionPlacement {
|
||||
teamId: string;
|
||||
rank: number;
|
||||
}
|
||||
|
||||
export interface CompetitionGameProjection {
|
||||
id: string;
|
||||
seriesId: string;
|
||||
gameSlotId: string;
|
||||
ordinal: number;
|
||||
displayNumber: number;
|
||||
evidence:
|
||||
| { type: 'riot'; riotMatchId: string }
|
||||
| { type: 'legacy'; legacyReference: string };
|
||||
teams: {
|
||||
blue: { side: 'blue'; teamId: string };
|
||||
red: { side: 'red'; teamId: string };
|
||||
};
|
||||
winnerTeamId: string;
|
||||
startedAt: string;
|
||||
durationSeconds: number;
|
||||
participants: unknown[];
|
||||
}
|
||||
|
||||
export interface GameSlotProjection {
|
||||
id: string;
|
||||
seriesId: string;
|
||||
ordinal: number;
|
||||
displayNumber: number;
|
||||
status: 'inactive' | 'waiting' | 'ready' | 'completed' | 'voided';
|
||||
entries: [
|
||||
{ slot: 'A'; teamId: string | null },
|
||||
{ slot: 'B'; teamId: string | null },
|
||||
];
|
||||
gameId?: string;
|
||||
}
|
||||
|
||||
export interface BracketRoundProjection {
|
||||
stage: SeriesDefinition['stage']['type'];
|
||||
roundNumber?: number;
|
||||
displayOrder: number;
|
||||
label: string;
|
||||
seriesIds: string[];
|
||||
}
|
||||
|
||||
export interface SeriesConnectorProjection {
|
||||
from: {
|
||||
seriesId: string;
|
||||
select: 'winner' | 'loser' | 'slot-a' | 'slot-b';
|
||||
};
|
||||
to: { seriesId: string; slot: 'A' | 'B' };
|
||||
}
|
||||
|
||||
export type CompetitionProjectionOutcome =
|
||||
| {
|
||||
type: 'paired-series';
|
||||
completedSeriesIds: string[];
|
||||
drawnSeriesIds: string[];
|
||||
completedAt: string;
|
||||
}
|
||||
| {
|
||||
type: 'round-robin';
|
||||
leaderTeamIds: string[];
|
||||
standings: RoundRobinStanding[];
|
||||
completedAt: string;
|
||||
}
|
||||
| {
|
||||
type: 'double-elimination';
|
||||
championTeamId: string;
|
||||
placements: CompetitionPlacement[];
|
||||
completedAt: string;
|
||||
};
|
||||
|
||||
export interface CompetitionProjection {
|
||||
competitionId: string;
|
||||
sourceRevision: number;
|
||||
projectorVersion: number;
|
||||
formatType: CompetitionGraphFormat['type'];
|
||||
phase: 'ready' | 'running' | 'completed';
|
||||
series: SeriesProjection[];
|
||||
games: CompetitionGameProjection[];
|
||||
gameSlots: GameSlotProjection[];
|
||||
rounds: BracketRoundProjection[];
|
||||
connectors: SeriesConnectorProjection[];
|
||||
standings?: RoundRobinStanding[];
|
||||
placements?: CompetitionPlacement[];
|
||||
outcome?: CompetitionProjectionOutcome;
|
||||
}
|
||||
|
||||
/**
|
||||
* Rebuilds all official Competition state from the immutable graph and fact
|
||||
* ledger. Participant identity is always resolved through explicit sources;
|
||||
* display codes and slot/array order are never used as team identity.
|
||||
*/
|
||||
export function projectCompetition(
|
||||
input: ProjectCompetitionInput,
|
||||
): CompetitionProjection {
|
||||
assertPrimaryFactTargetsGraph(input.seriesGraph, input.facts);
|
||||
const teamBySeed = new Map<number, string>();
|
||||
const knownTeams = new Set<string>();
|
||||
for (const team of input.teams) {
|
||||
knownTeams.add(team.teamId);
|
||||
if (team.seedNumber !== undefined) {
|
||||
teamBySeed.set(team.seedNumber, team.teamId);
|
||||
}
|
||||
}
|
||||
|
||||
const definitionsById = new Map(
|
||||
input.seriesGraph.map((definition) => [definition.id, definition]),
|
||||
);
|
||||
const projectedById = new Map<string, SeriesProjection>();
|
||||
const remaining = new Set(input.seriesGraph.map(({ id }) => id));
|
||||
|
||||
// A graph can be stored in any display order. Resolve it as a DAG rather
|
||||
// than relying on that order or parsing diagnostic codes such as WB_R2_M2.
|
||||
let madeProgress = true;
|
||||
while (remaining.size > 0 && madeProgress) {
|
||||
madeProgress = false;
|
||||
|
||||
for (const seriesId of [...remaining]) {
|
||||
const definition = definitionsById.get(seriesId)!;
|
||||
const activation = resolveActivation(definition, projectedById);
|
||||
if (activation === 'pending') continue;
|
||||
|
||||
if (activation === 'inactive') {
|
||||
projectedById.set(
|
||||
definition.id,
|
||||
projectSeries({
|
||||
definition: asProjectorDefinition(definition),
|
||||
participants: resolveAvailableParticipants(
|
||||
definition,
|
||||
knownTeams,
|
||||
teamBySeed,
|
||||
projectedById,
|
||||
),
|
||||
facts: input.facts,
|
||||
active: false,
|
||||
}),
|
||||
);
|
||||
remaining.delete(seriesId);
|
||||
madeProgress = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
const participants = definition.slots.map(({ source }) =>
|
||||
resolveParticipant(source, knownTeams, teamBySeed, projectedById),
|
||||
);
|
||||
if (participants.some((teamId) => teamId === undefined)) continue;
|
||||
|
||||
projectedById.set(
|
||||
definition.id,
|
||||
projectSeries({
|
||||
definition: asProjectorDefinition(definition),
|
||||
participants,
|
||||
facts: input.facts,
|
||||
}),
|
||||
);
|
||||
remaining.delete(seriesId);
|
||||
madeProgress = true;
|
||||
}
|
||||
}
|
||||
|
||||
// An unresolved outcome source is a normal waiting bracket node. Conditional
|
||||
// reset nodes remain inactive until their grand-final condition is known.
|
||||
for (const seriesId of remaining) {
|
||||
const definition = definitionsById.get(seriesId)!;
|
||||
const participants = resolveAvailableParticipants(
|
||||
definition,
|
||||
knownTeams,
|
||||
teamBySeed,
|
||||
projectedById,
|
||||
);
|
||||
projectedById.set(
|
||||
definition.id,
|
||||
projectSeries({
|
||||
definition: asProjectorDefinition(definition),
|
||||
participants,
|
||||
facts: input.facts,
|
||||
...(definition.activation ? { active: false } : {}),
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
const series = input.seriesGraph.map(({ id }) => projectedById.get(id)!);
|
||||
const gameProjection = projectGamesAndSlots(
|
||||
input.seriesGraph,
|
||||
series,
|
||||
input.facts,
|
||||
);
|
||||
const common = {
|
||||
competitionId: input.competitionId,
|
||||
sourceRevision: input.revision,
|
||||
projectorVersion: input.projectorVersion,
|
||||
formatType: input.format.type,
|
||||
series,
|
||||
games: gameProjection.games,
|
||||
gameSlots: gameProjection.gameSlots,
|
||||
rounds: projectRounds(input.seriesGraph),
|
||||
connectors: projectConnectors(input.seriesGraph),
|
||||
};
|
||||
|
||||
switch (input.format.type) {
|
||||
case 'paired-series': {
|
||||
const outcome = pairedSeriesOutcome(series);
|
||||
return {
|
||||
...common,
|
||||
phase: phaseFor(series, outcome),
|
||||
...(outcome ? { outcome } : {}),
|
||||
};
|
||||
}
|
||||
case 'round-robin': {
|
||||
const standings = roundRobinStandings(input.teams, series);
|
||||
const outcome =
|
||||
series.length > 0 &&
|
||||
series.every(({ status }) => status === 'completed')
|
||||
? {
|
||||
type: 'round-robin' as const,
|
||||
leaderTeamIds: standings
|
||||
.filter(({ rank }) => rank === 1)
|
||||
.map(({ teamId }) => teamId),
|
||||
standings,
|
||||
completedAt: competitionCompletedAt(series),
|
||||
}
|
||||
: undefined;
|
||||
return {
|
||||
...common,
|
||||
phase: phaseFor(series, outcome),
|
||||
standings,
|
||||
...(outcome ? { outcome } : {}),
|
||||
};
|
||||
}
|
||||
case 'double-elimination': {
|
||||
const outcome = doubleEliminationOutcome(
|
||||
input.teams,
|
||||
input.format.resetFinalEnabled,
|
||||
series,
|
||||
);
|
||||
return {
|
||||
...common,
|
||||
phase: phaseFor(series, outcome),
|
||||
placements: outcome?.placements ?? [],
|
||||
...(outcome ? { outcome } : {}),
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function assertPrimaryFactTargetsGraph(
|
||||
graph: readonly SeriesDefinition[],
|
||||
facts: readonly unknown[],
|
||||
): void {
|
||||
const definitionsById = new Map(
|
||||
graph.map((definition) => [definition.id, definition]),
|
||||
);
|
||||
|
||||
for (const fact of facts) {
|
||||
if (!isRecord(fact)) continue;
|
||||
|
||||
if (fact.type === 'game-accepted') {
|
||||
const seriesId =
|
||||
typeof fact.seriesId === 'string' ? fact.seriesId : undefined;
|
||||
const definition = seriesId ? definitionsById.get(seriesId) : undefined;
|
||||
assertCompetitionInvariant(
|
||||
definition !== undefined,
|
||||
'GAME_SERIES_MISMATCH',
|
||||
`Accepted game targets an unknown Series ${String(fact.seriesId)}`,
|
||||
{ factId: fact.id, seriesId: fact.seriesId },
|
||||
);
|
||||
|
||||
const gameSlot = definition.gameSlots.find(
|
||||
({ id }) => id === fact.gameSlotId,
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
gameSlot !== undefined,
|
||||
'GAME_SLOT_INVALID',
|
||||
`Accepted game targets an unknown GameSlot ${String(fact.gameSlotId)}`,
|
||||
{
|
||||
factId: fact.id,
|
||||
seriesId: definition.id,
|
||||
gameSlotId: fact.gameSlotId,
|
||||
},
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
gameSlot.ordinal === fact.ordinal,
|
||||
'GAME_ORDINAL_INVALID',
|
||||
`Accepted game ordinal does not match GameSlot ${gameSlot.id}`,
|
||||
{
|
||||
factId: fact.id,
|
||||
gameSlotId: gameSlot.id,
|
||||
expectedOrdinal: gameSlot.ordinal,
|
||||
actualOrdinal: fact.ordinal,
|
||||
},
|
||||
);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (fact.type === 'series-adjudicated') {
|
||||
const seriesId =
|
||||
typeof fact.seriesId === 'string' ? fact.seriesId : undefined;
|
||||
assertCompetitionInvariant(
|
||||
seriesId !== undefined && definitionsById.has(seriesId),
|
||||
'ADJUDICATION_INVALID',
|
||||
`Adjudication targets an unknown Series ${String(fact.seriesId)}`,
|
||||
{ factId: fact.id, seriesId: fact.seriesId },
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function asProjectorDefinition(
|
||||
definition: SeriesDefinition,
|
||||
): SeriesDefinitionLike {
|
||||
return definition as unknown as SeriesDefinitionLike;
|
||||
}
|
||||
|
||||
function resolveActivation(
|
||||
definition: SeriesDefinition,
|
||||
projections: ReadonlyMap<string, SeriesProjection>,
|
||||
): 'active' | 'inactive' | 'pending' {
|
||||
if (!definition.activation) return 'active';
|
||||
|
||||
const grandFinal = projections.get(definition.activation.grandFinalSeriesId);
|
||||
if (!grandFinal || grandFinal.status !== 'completed') return 'pending';
|
||||
if (grandFinal.outcome.type === 'draw') return 'inactive';
|
||||
|
||||
const lowerBracketFinalist = grandFinal.entries.find(
|
||||
({ slot }) => slot === 'B',
|
||||
)?.teamId;
|
||||
return grandFinal.outcome.winnerTeamId === lowerBracketFinalist
|
||||
? 'active'
|
||||
: 'inactive';
|
||||
}
|
||||
|
||||
function resolveAvailableParticipants(
|
||||
definition: SeriesDefinition,
|
||||
knownTeams: ReadonlySet<string>,
|
||||
teamBySeed: ReadonlyMap<number, string>,
|
||||
projections: ReadonlyMap<string, SeriesProjection>,
|
||||
): Array<string | null> {
|
||||
return definition.slots.map(
|
||||
({ source }) =>
|
||||
resolveParticipant(source, knownTeams, teamBySeed, projections) ?? null,
|
||||
);
|
||||
}
|
||||
|
||||
function resolveParticipant(
|
||||
source: ParticipantSource,
|
||||
knownTeams: ReadonlySet<string>,
|
||||
teamBySeed: ReadonlyMap<number, string>,
|
||||
projections: ReadonlyMap<string, SeriesProjection>,
|
||||
): string | undefined {
|
||||
switch (source.type) {
|
||||
case 'team':
|
||||
return knownTeams.has(source.teamId) ? source.teamId : undefined;
|
||||
case 'seed':
|
||||
return teamBySeed.get(source.seedNumber);
|
||||
case 'series-outcome': {
|
||||
const sourceSeries = projections.get(source.seriesId);
|
||||
if (!sourceSeries || sourceSeries.status !== 'completed') {
|
||||
return undefined;
|
||||
}
|
||||
if (sourceSeries.outcome.type === 'draw') return undefined;
|
||||
return source.select === 'winner'
|
||||
? sourceSeries.outcome.winnerTeamId
|
||||
: sourceSeries.outcome.loserTeamId;
|
||||
}
|
||||
case 'series-slot': {
|
||||
const sourceSeries = projections.get(source.seriesId);
|
||||
return (
|
||||
sourceSeries?.entries.find(({ slot }) => slot === source.slot)
|
||||
?.teamId ?? undefined
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function pairedSeriesOutcome(
|
||||
series: readonly SeriesProjection[],
|
||||
):
|
||||
| Extract<CompetitionProjectionOutcome, { type: 'paired-series' }>
|
||||
| undefined {
|
||||
if (
|
||||
series.length === 0 ||
|
||||
!series.every(({ status }) => status === 'completed')
|
||||
) {
|
||||
return undefined;
|
||||
}
|
||||
return {
|
||||
type: 'paired-series',
|
||||
completedSeriesIds: series
|
||||
.filter(
|
||||
(candidate) =>
|
||||
candidate.status === 'completed' && candidate.outcome.type !== 'draw',
|
||||
)
|
||||
.map(({ seriesId }) => seriesId),
|
||||
completedAt: competitionCompletedAt(series),
|
||||
drawnSeriesIds: series
|
||||
.filter(
|
||||
(candidate) =>
|
||||
candidate.status === 'completed' && candidate.outcome.type === 'draw',
|
||||
)
|
||||
.map(({ seriesId }) => seriesId),
|
||||
};
|
||||
}
|
||||
|
||||
function roundRobinStandings(
|
||||
teams: readonly CompetitionGraphTeam[],
|
||||
series: readonly SeriesProjection[],
|
||||
): RoundRobinStanding[] {
|
||||
const standingByTeam = new Map(
|
||||
teams.map((team) => [team.teamId, emptyStanding(team.teamId)]),
|
||||
);
|
||||
const completed = series.filter(
|
||||
(candidate): candidate is SeriesProjection & { status: 'completed' } =>
|
||||
candidate.status === 'completed',
|
||||
);
|
||||
|
||||
for (const projected of completed) {
|
||||
addSeriesToStandings(standingByTeam, projected);
|
||||
}
|
||||
|
||||
const displayOrderByTeam = new Map(
|
||||
teams.map(({ teamId, displayOrder }) => [teamId, displayOrder]),
|
||||
);
|
||||
const base = [...standingByTeam.values()].sort(
|
||||
(left, right) =>
|
||||
right.seriesWins - left.seriesWins ||
|
||||
right.gameDiff - left.gameDiff ||
|
||||
stableTeamOrder(left.teamId, right.teamId, displayOrderByTeam),
|
||||
);
|
||||
|
||||
const ranked: RoundRobinStanding[] = [];
|
||||
let start = 0;
|
||||
while (start < base.length) {
|
||||
let end = start + 1;
|
||||
while (
|
||||
end < base.length &&
|
||||
base[end].seriesWins === base[start].seriesWins &&
|
||||
base[end].gameDiff === base[start].gameDiff
|
||||
) {
|
||||
end += 1;
|
||||
}
|
||||
|
||||
const tiedGroup = base.slice(start, end);
|
||||
const teamIds = new Set(tiedGroup.map(({ teamId }) => teamId));
|
||||
const miniTable = new Map(
|
||||
tiedGroup.map(({ teamId }) => [teamId, emptyMiniTableRow()]),
|
||||
);
|
||||
for (const projected of completed) {
|
||||
const participants = projected.entries.map(({ teamId }) => teamId);
|
||||
if (
|
||||
participants.length === 2 &&
|
||||
participants.every(
|
||||
(teamId): teamId is string => teamId !== null && teamIds.has(teamId),
|
||||
)
|
||||
) {
|
||||
addSeriesToMiniTable(miniTable, projected);
|
||||
}
|
||||
}
|
||||
|
||||
tiedGroup.sort((left, right) => {
|
||||
const leftMini = miniTable.get(left.teamId)!;
|
||||
const rightMini = miniTable.get(right.teamId)!;
|
||||
return (
|
||||
rightMini.seriesWins - leftMini.seriesWins ||
|
||||
rightMini.gameDiff - leftMini.gameDiff ||
|
||||
stableTeamOrder(left.teamId, right.teamId, displayOrderByTeam)
|
||||
);
|
||||
});
|
||||
|
||||
let tiedStart = 0;
|
||||
while (tiedStart < tiedGroup.length) {
|
||||
const reference = miniTable.get(tiedGroup[tiedStart].teamId)!;
|
||||
let tiedEnd = tiedStart + 1;
|
||||
while (tiedEnd < tiedGroup.length) {
|
||||
const candidate = miniTable.get(tiedGroup[tiedEnd].teamId)!;
|
||||
if (
|
||||
candidate.seriesWins !== reference.seriesWins ||
|
||||
candidate.gameDiff !== reference.gameDiff
|
||||
) {
|
||||
break;
|
||||
}
|
||||
tiedEnd += 1;
|
||||
}
|
||||
|
||||
const rank = start + tiedStart + 1;
|
||||
for (const standing of tiedGroup.slice(tiedStart, tiedEnd)) {
|
||||
ranked.push({ ...standing, rank });
|
||||
}
|
||||
tiedStart = tiedEnd;
|
||||
}
|
||||
start = end;
|
||||
}
|
||||
|
||||
return ranked;
|
||||
}
|
||||
|
||||
function emptyStanding(teamId: string): RoundRobinStanding {
|
||||
return {
|
||||
teamId,
|
||||
rank: 0,
|
||||
seriesWins: 0,
|
||||
seriesLosses: 0,
|
||||
seriesDraws: 0,
|
||||
seriesPlayed: 0,
|
||||
gameWins: 0,
|
||||
gameLosses: 0,
|
||||
gameDiff: 0,
|
||||
};
|
||||
}
|
||||
|
||||
function addSeriesToStandings(
|
||||
rows: Map<string, RoundRobinStanding>,
|
||||
projected: SeriesProjection & { status: 'completed' },
|
||||
): void {
|
||||
const [entryA, entryB] = projected.entries;
|
||||
if (entryA.teamId === null || entryB.teamId === null) return;
|
||||
const rowA = rows.get(entryA.teamId);
|
||||
const rowB = rows.get(entryB.teamId);
|
||||
if (!rowA || !rowB) return;
|
||||
|
||||
rowA.gameWins += entryA.gameWins;
|
||||
rowA.gameLosses += entryB.gameWins;
|
||||
rowB.gameWins += entryB.gameWins;
|
||||
rowB.gameLosses += entryA.gameWins;
|
||||
rowA.gameDiff = rowA.gameWins - rowA.gameLosses;
|
||||
rowB.gameDiff = rowB.gameWins - rowB.gameLosses;
|
||||
rowA.seriesPlayed += 1;
|
||||
rowB.seriesPlayed += 1;
|
||||
|
||||
if (projected.outcome.type === 'draw') {
|
||||
rowA.seriesDraws += 1;
|
||||
rowB.seriesDraws += 1;
|
||||
return;
|
||||
}
|
||||
rows.get(projected.outcome.winnerTeamId)!.seriesWins += 1;
|
||||
rows.get(projected.outcome.loserTeamId)!.seriesLosses += 1;
|
||||
}
|
||||
|
||||
interface MiniTableRow {
|
||||
seriesWins: number;
|
||||
gameWins: number;
|
||||
gameLosses: number;
|
||||
gameDiff: number;
|
||||
}
|
||||
|
||||
function emptyMiniTableRow(): MiniTableRow {
|
||||
return { seriesWins: 0, gameWins: 0, gameLosses: 0, gameDiff: 0 };
|
||||
}
|
||||
|
||||
function addSeriesToMiniTable(
|
||||
rows: Map<string, MiniTableRow>,
|
||||
projected: SeriesProjection & { status: 'completed' },
|
||||
): void {
|
||||
const [entryA, entryB] = projected.entries;
|
||||
if (entryA.teamId === null || entryB.teamId === null) return;
|
||||
const rowA = rows.get(entryA.teamId)!;
|
||||
const rowB = rows.get(entryB.teamId)!;
|
||||
rowA.gameWins += entryA.gameWins;
|
||||
rowA.gameLosses += entryB.gameWins;
|
||||
rowB.gameWins += entryB.gameWins;
|
||||
rowB.gameLosses += entryA.gameWins;
|
||||
rowA.gameDiff = rowA.gameWins - rowA.gameLosses;
|
||||
rowB.gameDiff = rowB.gameWins - rowB.gameLosses;
|
||||
if (projected.outcome.type !== 'draw') {
|
||||
rows.get(projected.outcome.winnerTeamId)!.seriesWins += 1;
|
||||
}
|
||||
}
|
||||
|
||||
function doubleEliminationOutcome(
|
||||
teams: readonly CompetitionGraphTeam[],
|
||||
resetFinalEnabled: boolean,
|
||||
series: readonly SeriesProjection[],
|
||||
):
|
||||
| Extract<CompetitionProjectionOutcome, { type: 'double-elimination' }>
|
||||
| undefined {
|
||||
const grandFinal = series.find(({ stage }) => stage.type === 'grand-final');
|
||||
if (!grandFinal || grandFinal.status !== 'completed') return undefined;
|
||||
if (grandFinal.outcome.type === 'draw') return undefined;
|
||||
|
||||
let decisiveOutcome: Exclude<SeriesProjectionOutcome, { type: 'draw' }> =
|
||||
grandFinal.outcome;
|
||||
const lowerFinalist = grandFinal.entries.find(
|
||||
({ slot }) => slot === 'B',
|
||||
)?.teamId;
|
||||
if (resetFinalEnabled && grandFinal.outcome.winnerTeamId === lowerFinalist) {
|
||||
const resetFinal = series.find(({ stage }) => stage.type === 'reset-final');
|
||||
if (!resetFinal || resetFinal.status !== 'completed') return undefined;
|
||||
if (resetFinal.outcome.type === 'draw') return undefined;
|
||||
decisiveOutcome = resetFinal.outcome;
|
||||
}
|
||||
|
||||
const championTeamId = decisiveOutcome.winnerTeamId;
|
||||
const runnerUpTeamId = decisiveOutcome.loserTeamId;
|
||||
const placements: CompetitionPlacement[] = [
|
||||
{ teamId: championTeamId, rank: 1 },
|
||||
{ teamId: runnerUpTeamId, rank: 2 },
|
||||
];
|
||||
const alreadyPlaced = new Set([championTeamId, runnerUpTeamId]);
|
||||
const eliminatedByRound = new Map<number, string[]>();
|
||||
|
||||
for (const projected of series) {
|
||||
if (
|
||||
projected.stage.type !== 'lower' ||
|
||||
projected.status !== 'completed' ||
|
||||
projected.outcome.type === 'draw'
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
const key = projected.stage.roundNumber ?? projected.stage.displayOrder;
|
||||
const eliminated = eliminatedByRound.get(key) ?? [];
|
||||
if (!alreadyPlaced.has(projected.outcome.loserTeamId)) {
|
||||
eliminated.push(projected.outcome.loserTeamId);
|
||||
}
|
||||
eliminatedByRound.set(key, eliminated);
|
||||
}
|
||||
|
||||
let nextRank = 3;
|
||||
for (const [, eliminated] of [...eliminatedByRound].sort(
|
||||
([left], [right]) => right - left,
|
||||
)) {
|
||||
const unique = [...new Set(eliminated)].filter(
|
||||
(teamId) => !alreadyPlaced.has(teamId),
|
||||
);
|
||||
unique.sort(
|
||||
(left, right) =>
|
||||
teamDisplayOrder(left, teams) - teamDisplayOrder(right, teams),
|
||||
);
|
||||
for (const teamId of unique) {
|
||||
placements.push({ teamId, rank: nextRank });
|
||||
alreadyPlaced.add(teamId);
|
||||
}
|
||||
nextRank += unique.length;
|
||||
}
|
||||
|
||||
// With a valid 4/8-team graph every team is accounted for by the decisive
|
||||
// final or a lower-bracket elimination. Keep replay deterministic if an old
|
||||
// migrated graph omitted placement metadata.
|
||||
const unplaced = teams
|
||||
.filter(({ teamId }) => !alreadyPlaced.has(teamId))
|
||||
.sort((left, right) => left.displayOrder - right.displayOrder);
|
||||
for (const { teamId } of unplaced) {
|
||||
placements.push({ teamId, rank: nextRank });
|
||||
nextRank += 1;
|
||||
}
|
||||
|
||||
return {
|
||||
type: 'double-elimination',
|
||||
championTeamId,
|
||||
placements,
|
||||
completedAt: decisiveOutcome.completedAt,
|
||||
};
|
||||
}
|
||||
|
||||
interface AcceptedGameProjectionFact {
|
||||
id: string;
|
||||
type: 'game-accepted';
|
||||
revision: number;
|
||||
ordinalWithinRevision: number;
|
||||
gameId: string;
|
||||
seriesId: string;
|
||||
gameSlotId: string;
|
||||
ordinal: number;
|
||||
occurredAt: Date | string;
|
||||
startedAt?: Date | string;
|
||||
durationSeconds?: number;
|
||||
participants?: unknown[];
|
||||
evidence?: {
|
||||
type?: string;
|
||||
riotMatchId?: string;
|
||||
legacyReference?: string;
|
||||
};
|
||||
mapping: {
|
||||
blueTeamId: string;
|
||||
redTeamId: string;
|
||||
winnerTeamId: string;
|
||||
};
|
||||
}
|
||||
|
||||
interface VoidedGameProjectionFact {
|
||||
type: 'game-voided';
|
||||
revision: number;
|
||||
ordinalWithinRevision: number;
|
||||
gameAcceptedFactId: string;
|
||||
}
|
||||
|
||||
function projectGamesAndSlots(
|
||||
graph: readonly SeriesDefinition[],
|
||||
series: readonly SeriesProjection[],
|
||||
facts: readonly unknown[],
|
||||
): {
|
||||
games: CompetitionGameProjection[];
|
||||
gameSlots: GameSlotProjection[];
|
||||
} {
|
||||
const acceptedByFactId = new Map<string, AcceptedGameProjectionFact>();
|
||||
const activeBySlotId = new Map<string, AcceptedGameProjectionFact>();
|
||||
|
||||
for (const fact of projectionGameFacts(facts)) {
|
||||
if (fact.type === 'game-accepted') {
|
||||
acceptedByFactId.set(fact.id, fact);
|
||||
activeBySlotId.set(fact.gameSlotId, fact);
|
||||
continue;
|
||||
}
|
||||
const accepted = acceptedByFactId.get(fact.gameAcceptedFactId);
|
||||
if (!accepted) continue;
|
||||
if (activeBySlotId.get(accepted.gameSlotId)?.id === accepted.id) {
|
||||
activeBySlotId.delete(accepted.gameSlotId);
|
||||
}
|
||||
}
|
||||
|
||||
const displayNumberBySlotId = new Map<string, number>();
|
||||
let displayNumber = 0;
|
||||
for (const definition of graph) {
|
||||
for (const slot of [...definition.gameSlots].sort(
|
||||
(left, right) => left.ordinal - right.ordinal,
|
||||
)) {
|
||||
displayNumber += 1;
|
||||
displayNumberBySlotId.set(slot.id, displayNumber);
|
||||
}
|
||||
}
|
||||
|
||||
const games = [...activeBySlotId.values()]
|
||||
.sort(
|
||||
(left, right) =>
|
||||
(displayNumberBySlotId.get(left.gameSlotId) ?? 0) -
|
||||
(displayNumberBySlotId.get(right.gameSlotId) ?? 0),
|
||||
)
|
||||
.map((fact) => ({
|
||||
id: fact.gameId,
|
||||
seriesId: fact.seriesId,
|
||||
gameSlotId: fact.gameSlotId,
|
||||
ordinal: fact.ordinal,
|
||||
displayNumber: displayNumberBySlotId.get(fact.gameSlotId) ?? 0,
|
||||
evidence:
|
||||
fact.evidence?.type === 'riot' && fact.evidence.riotMatchId
|
||||
? {
|
||||
type: 'riot' as const,
|
||||
riotMatchId: fact.evidence.riotMatchId,
|
||||
}
|
||||
: {
|
||||
type: 'legacy' as const,
|
||||
legacyReference:
|
||||
fact.evidence?.legacyReference ?? `fact:${fact.id}`,
|
||||
},
|
||||
teams: {
|
||||
blue: {
|
||||
side: 'blue' as const,
|
||||
teamId: fact.mapping.blueTeamId,
|
||||
},
|
||||
red: { side: 'red' as const, teamId: fact.mapping.redTeamId },
|
||||
},
|
||||
winnerTeamId: fact.mapping.winnerTeamId,
|
||||
startedAt: toIsoString(fact.startedAt ?? fact.occurredAt),
|
||||
durationSeconds:
|
||||
typeof fact.durationSeconds === 'number' ? fact.durationSeconds : 0,
|
||||
participants: Array.isArray(fact.participants)
|
||||
? [...fact.participants]
|
||||
: [],
|
||||
}));
|
||||
|
||||
const projectedBySeriesId = new Map(
|
||||
series.map((projection) => [projection.seriesId, projection]),
|
||||
);
|
||||
const gameSlots = graph.flatMap((definition) => {
|
||||
const projected = projectedBySeriesId.get(definition.id)!;
|
||||
const entries: GameSlotProjection['entries'] = [
|
||||
{
|
||||
slot: 'A',
|
||||
teamId:
|
||||
projected.entries.find(({ slot }) => slot === 'A')?.teamId ?? null,
|
||||
},
|
||||
{
|
||||
slot: 'B',
|
||||
teamId:
|
||||
projected.entries.find(({ slot }) => slot === 'B')?.teamId ?? null,
|
||||
},
|
||||
];
|
||||
return [...definition.gameSlots]
|
||||
.sort((left, right) => left.ordinal - right.ordinal)
|
||||
.map((slot) => {
|
||||
const game = activeBySlotId.get(slot.id);
|
||||
const status = game
|
||||
? ('completed' as const)
|
||||
: gameSlotStatus(projected.status);
|
||||
return {
|
||||
id: slot.id,
|
||||
seriesId: definition.id,
|
||||
ordinal: slot.ordinal,
|
||||
displayNumber: displayNumberBySlotId.get(slot.id) ?? 0,
|
||||
status,
|
||||
entries,
|
||||
...(game ? { gameId: game.gameId } : {}),
|
||||
};
|
||||
});
|
||||
});
|
||||
|
||||
return { games, gameSlots };
|
||||
}
|
||||
|
||||
function projectionGameFacts(
|
||||
facts: readonly unknown[],
|
||||
): Array<AcceptedGameProjectionFact | VoidedGameProjectionFact> {
|
||||
return facts
|
||||
.filter(
|
||||
(fact): fact is AcceptedGameProjectionFact | VoidedGameProjectionFact =>
|
||||
isRecord(fact) &&
|
||||
(fact.type === 'game-accepted' || fact.type === 'game-voided'),
|
||||
)
|
||||
.sort(
|
||||
(left, right) =>
|
||||
left.revision - right.revision ||
|
||||
left.ordinalWithinRevision - right.ordinalWithinRevision,
|
||||
);
|
||||
}
|
||||
|
||||
function gameSlotStatus(
|
||||
status: SeriesProjection['status'],
|
||||
): GameSlotProjection['status'] {
|
||||
switch (status) {
|
||||
case 'inactive':
|
||||
return 'inactive';
|
||||
case 'waiting':
|
||||
return 'waiting';
|
||||
case 'ready':
|
||||
case 'in-progress':
|
||||
return 'ready';
|
||||
case 'completed':
|
||||
return 'inactive';
|
||||
}
|
||||
}
|
||||
|
||||
function projectRounds(
|
||||
graph: readonly SeriesDefinition[],
|
||||
): BracketRoundProjection[] {
|
||||
const rounds = new Map<string, BracketRoundProjection>();
|
||||
for (const definition of graph) {
|
||||
const { type: stage, roundNumber, displayOrder } = definition.stage;
|
||||
const key = `${stage}:${roundNumber ?? 'none'}`;
|
||||
const existing = rounds.get(key);
|
||||
if (existing) {
|
||||
existing.seriesIds.push(definition.id);
|
||||
existing.displayOrder = Math.min(existing.displayOrder, displayOrder);
|
||||
continue;
|
||||
}
|
||||
rounds.set(key, {
|
||||
stage,
|
||||
...(roundNumber !== undefined ? { roundNumber } : {}),
|
||||
displayOrder,
|
||||
label: roundLabel(stage, roundNumber),
|
||||
seriesIds: [definition.id],
|
||||
});
|
||||
}
|
||||
return [...rounds.values()].sort(
|
||||
(left, right) => left.displayOrder - right.displayOrder,
|
||||
);
|
||||
}
|
||||
|
||||
function roundLabel(
|
||||
stage: SeriesDefinition['stage']['type'],
|
||||
roundNumber?: number,
|
||||
): string {
|
||||
switch (stage) {
|
||||
case 'pair':
|
||||
return 'Pair';
|
||||
case 'round-robin':
|
||||
return `Round ${roundNumber ?? 1}`;
|
||||
case 'upper':
|
||||
return `Upper ${roundNumber ?? 1}`;
|
||||
case 'lower':
|
||||
return `Lower ${roundNumber ?? 1}`;
|
||||
case 'grand-final':
|
||||
return 'Grand Final';
|
||||
case 'reset-final':
|
||||
return 'Reset Final';
|
||||
}
|
||||
}
|
||||
|
||||
function projectConnectors(
|
||||
graph: readonly SeriesDefinition[],
|
||||
): SeriesConnectorProjection[] {
|
||||
const connectors: SeriesConnectorProjection[] = [];
|
||||
for (const definition of graph) {
|
||||
for (const { position, source } of definition.slots) {
|
||||
if (source.type === 'series-outcome') {
|
||||
connectors.push({
|
||||
from: {
|
||||
seriesId: source.seriesId,
|
||||
select: source.select,
|
||||
},
|
||||
to: { seriesId: definition.id, slot: position },
|
||||
});
|
||||
continue;
|
||||
}
|
||||
if (source.type === 'series-slot') {
|
||||
connectors.push({
|
||||
from: {
|
||||
seriesId: source.seriesId,
|
||||
select: source.slot === 'A' ? 'slot-a' : 'slot-b',
|
||||
},
|
||||
to: { seriesId: definition.id, slot: position },
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
return connectors;
|
||||
}
|
||||
|
||||
function competitionCompletedAt(series: readonly SeriesProjection[]): string {
|
||||
return series
|
||||
.filter(
|
||||
(projection): projection is SeriesProjection & { status: 'completed' } =>
|
||||
projection.status === 'completed',
|
||||
)
|
||||
.map(({ outcome }) => outcome.completedAt)
|
||||
.sort()
|
||||
.at(-1)!;
|
||||
}
|
||||
|
||||
function toIsoString(value: Date | string): string {
|
||||
return value instanceof Date ? value.toISOString() : value;
|
||||
}
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return typeof value === 'object' && value !== null;
|
||||
}
|
||||
|
||||
function phaseFor(
|
||||
series: readonly SeriesProjection[],
|
||||
outcome: CompetitionProjectionOutcome | undefined,
|
||||
): CompetitionProjection['phase'] {
|
||||
if (outcome) return 'completed';
|
||||
return series.some(
|
||||
({ status }) => status === 'in-progress' || status === 'completed',
|
||||
)
|
||||
? 'running'
|
||||
: 'ready';
|
||||
}
|
||||
|
||||
function stableTeamOrder(
|
||||
left: string,
|
||||
right: string,
|
||||
displayOrderByTeam: ReadonlyMap<string, number>,
|
||||
): number {
|
||||
return (
|
||||
(displayOrderByTeam.get(left) ?? Number.MAX_SAFE_INTEGER) -
|
||||
(displayOrderByTeam.get(right) ?? Number.MAX_SAFE_INTEGER) ||
|
||||
left.localeCompare(right)
|
||||
);
|
||||
}
|
||||
|
||||
function teamDisplayOrder(
|
||||
teamId: string,
|
||||
teams: readonly CompetitionGraphTeam[],
|
||||
): number {
|
||||
return (
|
||||
teams.find((candidate) => candidate.teamId === teamId)?.displayOrder ??
|
||||
Number.MAX_SAFE_INTEGER
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,238 @@
|
||||
import {
|
||||
assertReversalPreview,
|
||||
buildReversalFacts,
|
||||
CompetitionReversalError,
|
||||
previewSeriesReversal,
|
||||
} from './competition-reversal';
|
||||
|
||||
describe('Competition reversal planning', () => {
|
||||
const graph = [
|
||||
series('series-parent', [team('team-8'), team('team-3')]),
|
||||
series('series-child', [winner('series-parent'), loser('series-parent')]),
|
||||
];
|
||||
const facts = [
|
||||
accepted('fact-parent', 'series-parent', 'slot-parent', 'team-8', 'team-3'),
|
||||
accepted('fact-child', 'series-child', 'slot-child', 'team-8', 'team-3'),
|
||||
];
|
||||
const assignments = [
|
||||
assignment('assignment-parent', 'series-parent', 'slot-parent', 'used'),
|
||||
assignment('assignment-child', 'series-child', 'slot-child', 'reserved'),
|
||||
];
|
||||
|
||||
it('rejects strict reversal when a descendant has result activity', () => {
|
||||
expectCompetitionReversalError(
|
||||
() =>
|
||||
previewSeriesReversal({
|
||||
competitionId: 'competition-1',
|
||||
revision: 2,
|
||||
seriesId: 'series-parent',
|
||||
mode: 'strict',
|
||||
graph,
|
||||
facts,
|
||||
assignments,
|
||||
}),
|
||||
'REVERSAL_DESCENDANT_ACTIVITY',
|
||||
);
|
||||
});
|
||||
|
||||
it('builds a deterministic cascade impact from graph descendants', () => {
|
||||
const first = previewSeriesReversal({
|
||||
competitionId: 'competition-1',
|
||||
revision: 2,
|
||||
seriesId: 'series-parent',
|
||||
mode: 'cascade',
|
||||
graph,
|
||||
facts,
|
||||
assignments,
|
||||
});
|
||||
const second = previewSeriesReversal({
|
||||
competitionId: 'competition-1',
|
||||
revision: 2,
|
||||
seriesId: 'series-parent',
|
||||
mode: 'cascade',
|
||||
graph,
|
||||
facts,
|
||||
assignments,
|
||||
});
|
||||
const extraAssignments = [
|
||||
...assignments,
|
||||
assignment('assignment-extra-z', 'series-child', 'slot-z', 'reserved'),
|
||||
assignment('assignment-extra-a', 'series-child', 'slot-a', 'reserved'),
|
||||
];
|
||||
const unorderedFirst = previewSeriesReversal({
|
||||
competitionId: 'competition-1',
|
||||
revision: 2,
|
||||
seriesId: 'series-parent',
|
||||
mode: 'cascade',
|
||||
graph,
|
||||
facts,
|
||||
assignments: extraAssignments,
|
||||
});
|
||||
const unorderedSecond = previewSeriesReversal({
|
||||
competitionId: 'competition-1',
|
||||
revision: 2,
|
||||
seriesId: 'series-parent',
|
||||
mode: 'cascade',
|
||||
graph,
|
||||
facts,
|
||||
assignments: [...extraAssignments].reverse(),
|
||||
});
|
||||
|
||||
expect(second).toEqual(first);
|
||||
expect(unorderedSecond).toEqual(unorderedFirst);
|
||||
expect(first).toEqual({
|
||||
sourceRevision: 2,
|
||||
impactHash: expect.stringMatching(/^[a-f0-9]{64}$/),
|
||||
impact: {
|
||||
seriesIds: ['series-parent', 'series-child'],
|
||||
factIds: ['fact-parent', 'fact-child'],
|
||||
gameSlotIds: ['slot-child', 'slot-parent'],
|
||||
teamIds: ['team-3', 'team-8'],
|
||||
releasesReservedCodes: 1,
|
||||
voidsUsedCodes: 1,
|
||||
requiresStatsRebuild: true,
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it('rejects a stale or changed preview before emitting reversal facts', () => {
|
||||
const preview = previewSeriesReversal({
|
||||
competitionId: 'competition-1',
|
||||
revision: 2,
|
||||
seriesId: 'series-parent',
|
||||
mode: 'cascade',
|
||||
graph,
|
||||
facts,
|
||||
assignments,
|
||||
});
|
||||
|
||||
expectCompetitionReversalError(
|
||||
() =>
|
||||
assertReversalPreview(
|
||||
{
|
||||
competitionId: 'competition-1',
|
||||
revision: 3,
|
||||
seriesId: 'series-parent',
|
||||
mode: 'cascade',
|
||||
graph,
|
||||
facts,
|
||||
assignments,
|
||||
},
|
||||
preview.impactHash,
|
||||
),
|
||||
'REVERSAL_PREVIEW_STALE',
|
||||
);
|
||||
});
|
||||
|
||||
it('emits one append-only reversal fact for every active result fact', () => {
|
||||
const preview = previewSeriesReversal({
|
||||
competitionId: 'competition-1',
|
||||
revision: 2,
|
||||
seriesId: 'series-parent',
|
||||
mode: 'cascade',
|
||||
graph,
|
||||
facts,
|
||||
assignments,
|
||||
});
|
||||
|
||||
expect(
|
||||
buildReversalFacts({
|
||||
preview,
|
||||
facts,
|
||||
competitionId: 'competition-1',
|
||||
commandId: 'command-reverse',
|
||||
nextRevision: 3,
|
||||
actor: { type: 'user', userId: 'admin-1' },
|
||||
reason: '잘못 수집된 게임',
|
||||
occurredAt: new Date('2026-07-12T01:00:00.000Z'),
|
||||
}),
|
||||
).toEqual([
|
||||
expect.objectContaining({
|
||||
type: 'game-voided',
|
||||
gameAcceptedFactId: 'fact-parent',
|
||||
revision: 3,
|
||||
ordinalWithinRevision: 1,
|
||||
}),
|
||||
expect.objectContaining({
|
||||
type: 'game-voided',
|
||||
gameAcceptedFactId: 'fact-child',
|
||||
revision: 3,
|
||||
ordinalWithinRevision: 2,
|
||||
}),
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
function expectCompetitionReversalError(
|
||||
action: () => unknown,
|
||||
expectedCode: CompetitionReversalError['code'],
|
||||
): void {
|
||||
let thrown: unknown;
|
||||
try {
|
||||
action();
|
||||
} catch (error: unknown) {
|
||||
thrown = error;
|
||||
}
|
||||
|
||||
expect(thrown).toBeInstanceOf(CompetitionReversalError);
|
||||
if (!(thrown instanceof CompetitionReversalError)) {
|
||||
throw new Error(
|
||||
`Expected CompetitionReversalError, received ${String(thrown)}`,
|
||||
);
|
||||
}
|
||||
expect(thrown.code).toBe(expectedCode);
|
||||
}
|
||||
|
||||
function series(id: string, sources: Array<Record<string, unknown>>) {
|
||||
return {
|
||||
id,
|
||||
stage: { type: 'upper' as const, displayOrder: 1 },
|
||||
slots: [
|
||||
{ position: 'A' as const, source: sources[0] },
|
||||
{ position: 'B' as const, source: sources[1] },
|
||||
],
|
||||
rule: { type: 'first-to' as const, winsRequired: 1, maxGames: 1 },
|
||||
gameSlots: [{ id: id.replace('series', 'slot'), seriesId: id, ordinal: 1 }],
|
||||
};
|
||||
}
|
||||
|
||||
function team(teamId: string) {
|
||||
return { type: 'team', teamId };
|
||||
}
|
||||
|
||||
function winner(seriesId: string) {
|
||||
return { type: 'series-outcome', seriesId, select: 'winner' };
|
||||
}
|
||||
|
||||
function loser(seriesId: string) {
|
||||
return { type: 'series-outcome', seriesId, select: 'loser' };
|
||||
}
|
||||
|
||||
function accepted(
|
||||
id: string,
|
||||
seriesId: string,
|
||||
gameSlotId: string,
|
||||
winnerTeamId: string,
|
||||
loserTeamId: string,
|
||||
) {
|
||||
return {
|
||||
id,
|
||||
type: 'game-accepted',
|
||||
seriesId,
|
||||
gameSlotId,
|
||||
mapping: {
|
||||
blueTeamId: winnerTeamId,
|
||||
redTeamId: loserTeamId,
|
||||
winnerTeamId,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function assignment(
|
||||
id: string,
|
||||
seriesId: string,
|
||||
gameSlotId: string,
|
||||
state: 'reserved' | 'used',
|
||||
) {
|
||||
return { id, seriesId, gameSlotId, state };
|
||||
}
|
||||
@@ -0,0 +1,362 @@
|
||||
import { createHash } from 'node:crypto';
|
||||
|
||||
export type SeriesReversalMode = 'strict' | 'cascade';
|
||||
|
||||
interface ReversalGraphSeries {
|
||||
id: string;
|
||||
slots: ReadonlyArray<{
|
||||
source: Readonly<{
|
||||
type?: unknown;
|
||||
seriesId?: unknown;
|
||||
}>;
|
||||
}>;
|
||||
}
|
||||
|
||||
interface ReversalFactBase {
|
||||
id: string;
|
||||
type: string;
|
||||
seriesId?: string;
|
||||
}
|
||||
|
||||
interface AcceptedGameFact extends ReversalFactBase {
|
||||
type: 'game-accepted';
|
||||
seriesId: string;
|
||||
gameSlotId: string;
|
||||
mapping: {
|
||||
blueTeamId: string;
|
||||
redTeamId: string;
|
||||
winnerTeamId: string;
|
||||
};
|
||||
}
|
||||
|
||||
interface AdjudicatedFact extends ReversalFactBase {
|
||||
type: 'series-adjudicated';
|
||||
seriesId: string;
|
||||
decision:
|
||||
| { type: string; winnerTeamId?: string }
|
||||
| { type: 'administrative-draw' };
|
||||
}
|
||||
|
||||
interface VoidedGameFact extends ReversalFactBase {
|
||||
type: 'game-voided';
|
||||
gameAcceptedFactId: string;
|
||||
}
|
||||
|
||||
interface ReversedAdjudicationFact extends ReversalFactBase {
|
||||
type: 'adjudication-reversed';
|
||||
adjudicationFactId: string;
|
||||
}
|
||||
|
||||
type ReversalFact =
|
||||
| AcceptedGameFact
|
||||
| AdjudicatedFact
|
||||
| VoidedGameFact
|
||||
| ReversedAdjudicationFact;
|
||||
|
||||
interface ReversalAssignment {
|
||||
seriesId: string;
|
||||
gameSlotId: string;
|
||||
state: string;
|
||||
}
|
||||
|
||||
export interface ReversalPreviewInput {
|
||||
competitionId: string;
|
||||
revision: number;
|
||||
seriesId: string;
|
||||
mode: SeriesReversalMode;
|
||||
graph: readonly ReversalGraphSeries[];
|
||||
facts: readonly unknown[];
|
||||
assignments: readonly ReversalAssignment[];
|
||||
}
|
||||
|
||||
export interface SeriesReversalImpact {
|
||||
seriesIds: string[];
|
||||
factIds: string[];
|
||||
gameSlotIds: string[];
|
||||
teamIds: string[];
|
||||
releasesReservedCodes: number;
|
||||
voidsUsedCodes: number;
|
||||
requiresStatsRebuild: boolean;
|
||||
}
|
||||
|
||||
export interface SeriesReversalPreview {
|
||||
sourceRevision: number;
|
||||
impactHash: string;
|
||||
impact: SeriesReversalImpact;
|
||||
}
|
||||
|
||||
export class CompetitionReversalError extends Error {
|
||||
constructor(
|
||||
public readonly code:
|
||||
| 'REVERSAL_SERIES_NOT_FOUND'
|
||||
| 'REVERSAL_NO_ACTIVE_RESULT'
|
||||
| 'REVERSAL_DESCENDANT_ACTIVITY'
|
||||
| 'REVERSAL_PREVIEW_STALE'
|
||||
| 'REVERSAL_REASON_REQUIRED',
|
||||
message: string,
|
||||
public readonly details?: Readonly<Record<string, unknown>>,
|
||||
) {
|
||||
super(message);
|
||||
this.name = 'CompetitionReversalError';
|
||||
}
|
||||
}
|
||||
|
||||
/** Calculate the exact immutable facts and code assignments affected by a reversal. */
|
||||
export function previewSeriesReversal(
|
||||
input: ReversalPreviewInput,
|
||||
): SeriesReversalPreview {
|
||||
const seriesOrder = affectedSeries(input.graph, input.seriesId);
|
||||
const facts = normalizeReversalFacts(input.facts);
|
||||
const active = activeResultFacts(facts);
|
||||
const affectedSet = new Set(seriesOrder);
|
||||
const descendantSet = new Set(seriesOrder.slice(1));
|
||||
const descendantActivity = active.filter((fact) =>
|
||||
descendantSet.has(fact.seriesId),
|
||||
);
|
||||
const descendantUsedAssignments = input.assignments.filter(
|
||||
(assignment) =>
|
||||
descendantSet.has(assignment.seriesId) && assignment.state === 'used',
|
||||
);
|
||||
|
||||
if (
|
||||
input.mode === 'strict' &&
|
||||
(descendantActivity.length > 0 || descendantUsedAssignments.length > 0)
|
||||
) {
|
||||
throw new CompetitionReversalError(
|
||||
'REVERSAL_DESCENDANT_ACTIVITY',
|
||||
'A descendant Series has result or used-code activity. Preview a cascade reversal.',
|
||||
{
|
||||
seriesIds: [
|
||||
...new Set([
|
||||
...descendantActivity.map(({ seriesId }) => seriesId),
|
||||
...descendantUsedAssignments.map(({ seriesId }) => seriesId),
|
||||
]),
|
||||
],
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
const selectedFacts = active.filter(
|
||||
(fact) =>
|
||||
fact.seriesId === input.seriesId ||
|
||||
(input.mode === 'cascade' && descendantSet.has(fact.seriesId)),
|
||||
);
|
||||
if (!selectedFacts.some(({ seriesId }) => seriesId === input.seriesId)) {
|
||||
throw new CompetitionReversalError(
|
||||
'REVERSAL_NO_ACTIVE_RESULT',
|
||||
`Series ${input.seriesId} has no active result to reverse.`,
|
||||
{ seriesId: input.seriesId },
|
||||
);
|
||||
}
|
||||
|
||||
const factOrder = new Map(
|
||||
seriesOrder.map((seriesId, index) => [seriesId, index]),
|
||||
);
|
||||
selectedFacts.sort(
|
||||
(left, right) =>
|
||||
factOrder.get(left.seriesId)! - factOrder.get(right.seriesId)!,
|
||||
);
|
||||
const assignments = input.assignments.filter((assignment) =>
|
||||
affectedSet.has(assignment.seriesId),
|
||||
);
|
||||
const teamIds = new Set<string>();
|
||||
const gameSlotIds = new Set<string>();
|
||||
for (const fact of selectedFacts) {
|
||||
if (fact.type === 'game-accepted') {
|
||||
gameSlotIds.add(fact.gameSlotId);
|
||||
teamIds.add(fact.mapping.blueTeamId);
|
||||
teamIds.add(fact.mapping.redTeamId);
|
||||
} else if ('winnerTeamId' in fact.decision && fact.decision.winnerTeamId) {
|
||||
teamIds.add(fact.decision.winnerTeamId);
|
||||
}
|
||||
}
|
||||
for (const assignment of assignments) gameSlotIds.add(assignment.gameSlotId);
|
||||
|
||||
const impact: SeriesReversalImpact = {
|
||||
seriesIds: seriesOrder,
|
||||
factIds: selectedFacts.map(({ id }) => id),
|
||||
gameSlotIds: [...gameSlotIds].sort(),
|
||||
teamIds: [...teamIds].sort(),
|
||||
releasesReservedCodes: assignments.filter(
|
||||
({ state }) => state === 'reserved',
|
||||
).length,
|
||||
voidsUsedCodes: assignments.filter(({ state }) => state === 'used').length,
|
||||
requiresStatsRebuild: selectedFacts.some(
|
||||
({ type }) => type === 'game-accepted',
|
||||
),
|
||||
};
|
||||
return {
|
||||
sourceRevision: input.revision,
|
||||
impactHash: hashImpact(input, impact),
|
||||
impact,
|
||||
};
|
||||
}
|
||||
|
||||
export function assertReversalPreview(
|
||||
input: ReversalPreviewInput,
|
||||
expectedImpactHash: string,
|
||||
): SeriesReversalPreview {
|
||||
const current = previewSeriesReversal(input);
|
||||
if (current.impactHash !== expectedImpactHash) {
|
||||
throw new CompetitionReversalError(
|
||||
'REVERSAL_PREVIEW_STALE',
|
||||
'The Competition changed after the reversal preview.',
|
||||
{ sourceRevision: input.revision },
|
||||
);
|
||||
}
|
||||
return current;
|
||||
}
|
||||
|
||||
export function buildReversalFacts(input: {
|
||||
preview: SeriesReversalPreview;
|
||||
facts: readonly unknown[];
|
||||
competitionId: string;
|
||||
commandId: string;
|
||||
nextRevision: number;
|
||||
actor: Readonly<Record<string, unknown>>;
|
||||
reason: string;
|
||||
occurredAt: Date;
|
||||
}): Array<Record<string, unknown>> {
|
||||
if (!input.reason.trim()) {
|
||||
throw new CompetitionReversalError(
|
||||
'REVERSAL_REASON_REQUIRED',
|
||||
'A reversal reason is required.',
|
||||
);
|
||||
}
|
||||
const byId = new Map(
|
||||
normalizeReversalFacts(input.facts).map((fact) => [fact.id, fact]),
|
||||
);
|
||||
const causationId = deterministicId(
|
||||
input.competitionId,
|
||||
input.commandId,
|
||||
'reversal',
|
||||
);
|
||||
|
||||
return input.preview.impact.factIds.map((factId, index) => {
|
||||
const target = byId.get(factId);
|
||||
if (!target) {
|
||||
throw new CompetitionReversalError(
|
||||
'REVERSAL_PREVIEW_STALE',
|
||||
`Fact ${factId} no longer matches the preview.`,
|
||||
);
|
||||
}
|
||||
const common = {
|
||||
id: deterministicId(input.competitionId, input.commandId, factId),
|
||||
competitionId: input.competitionId,
|
||||
revision: input.nextRevision,
|
||||
ordinalWithinRevision: index + 1,
|
||||
commandId: input.commandId,
|
||||
schemaVersion: 1,
|
||||
actor: input.actor,
|
||||
occurredAt: input.occurredAt,
|
||||
recordedAt: input.occurredAt,
|
||||
causationId,
|
||||
reason: input.reason,
|
||||
};
|
||||
return target.type === 'game-accepted'
|
||||
? {
|
||||
...common,
|
||||
type: 'game-voided',
|
||||
gameAcceptedFactId: target.id,
|
||||
}
|
||||
: {
|
||||
...common,
|
||||
type: 'adjudication-reversed',
|
||||
adjudicationFactId: target.id,
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
function affectedSeries(
|
||||
graph: readonly ReversalGraphSeries[],
|
||||
sourceSeriesId: string,
|
||||
): string[] {
|
||||
if (!graph.some(({ id }) => id === sourceSeriesId)) {
|
||||
throw new CompetitionReversalError(
|
||||
'REVERSAL_SERIES_NOT_FOUND',
|
||||
`Series ${sourceSeriesId} does not exist.`,
|
||||
);
|
||||
}
|
||||
const affected = new Set([sourceSeriesId]);
|
||||
let changed = true;
|
||||
while (changed) {
|
||||
changed = false;
|
||||
for (const definition of graph) {
|
||||
if (affected.has(definition.id)) continue;
|
||||
if (
|
||||
definition.slots.some(({ source }) =>
|
||||
typeof source.seriesId === 'string'
|
||||
? affected.has(source.seriesId)
|
||||
: false,
|
||||
)
|
||||
) {
|
||||
affected.add(definition.id);
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return graph.filter(({ id }) => affected.has(id)).map(({ id }) => id);
|
||||
}
|
||||
|
||||
function normalizeReversalFacts(facts: readonly unknown[]): ReversalFact[] {
|
||||
return facts.filter((fact): fact is ReversalFact => {
|
||||
if (!isRecord(fact) || typeof fact.id !== 'string') return false;
|
||||
return (
|
||||
fact.type === 'game-accepted' ||
|
||||
fact.type === 'series-adjudicated' ||
|
||||
fact.type === 'game-voided' ||
|
||||
fact.type === 'adjudication-reversed'
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
function activeResultFacts(
|
||||
facts: readonly ReversalFact[],
|
||||
): Array<AcceptedGameFact | AdjudicatedFact> {
|
||||
const voided = new Set(
|
||||
facts
|
||||
.filter((fact): fact is VoidedGameFact => fact.type === 'game-voided')
|
||||
.map(({ gameAcceptedFactId }) => gameAcceptedFactId),
|
||||
);
|
||||
const reversed = new Set(
|
||||
facts
|
||||
.filter(
|
||||
(fact): fact is ReversedAdjudicationFact =>
|
||||
fact.type === 'adjudication-reversed',
|
||||
)
|
||||
.map(({ adjudicationFactId }) => adjudicationFactId),
|
||||
);
|
||||
return facts.filter(
|
||||
(fact): fact is AcceptedGameFact | AdjudicatedFact =>
|
||||
(fact.type === 'game-accepted' && !voided.has(fact.id)) ||
|
||||
(fact.type === 'series-adjudicated' && !reversed.has(fact.id)),
|
||||
);
|
||||
}
|
||||
|
||||
function hashImpact(
|
||||
input: ReversalPreviewInput,
|
||||
impact: SeriesReversalImpact,
|
||||
): string {
|
||||
return createHash('sha256')
|
||||
.update(
|
||||
JSON.stringify({
|
||||
competitionId: input.competitionId,
|
||||
sourceRevision: input.revision,
|
||||
seriesId: input.seriesId,
|
||||
mode: input.mode,
|
||||
impact,
|
||||
}),
|
||||
)
|
||||
.digest('hex');
|
||||
}
|
||||
|
||||
function deterministicId(...parts: string[]): string {
|
||||
return createHash('sha256')
|
||||
.update(JSON.stringify(parts))
|
||||
.digest('hex')
|
||||
.slice(0, 24);
|
||||
}
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return typeof value === 'object' && value !== null;
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
export type CompetitionDomainErrorCode =
|
||||
| 'DUPLICATE_FACT_ID'
|
||||
| 'DUPLICATE_GAME_ID'
|
||||
| 'DUPLICATE_RIOT_MATCH_ID'
|
||||
| 'DUPLICATE_GAME_SLOT'
|
||||
| 'DUPLICATE_GAME_ORDINAL'
|
||||
| 'DUPLICATE_ADJUDICATION'
|
||||
| 'FACT_REFERENCE_NOT_FOUND'
|
||||
| 'FACT_ALREADY_REVERSED'
|
||||
| 'FACT_TYPE_INVALID'
|
||||
| 'GAME_SLOT_INVALID'
|
||||
| 'GAME_ORDINAL_INVALID'
|
||||
| 'GAME_SERIES_MISMATCH'
|
||||
| 'GAME_TEAM_MISMATCH'
|
||||
| 'GAME_WINNER_INVALID'
|
||||
| 'SERIES_ALREADY_COMPLETED'
|
||||
| 'SERIES_DEFINITION_INVALID'
|
||||
| 'SERIES_PARTICIPANTS_INVALID'
|
||||
| 'ADJUDICATION_INVALID'
|
||||
| 'ADJUDICATION_DRAW_NOT_ALLOWED'
|
||||
| 'WALKOVER_HAS_ACTIVE_GAMES';
|
||||
|
||||
/**
|
||||
* A deterministic domain-invariant failure. Command handlers translate these
|
||||
* errors to the appropriate HTTP conflict/validation response; projectors do
|
||||
* not depend on NestJS or transport concerns.
|
||||
*/
|
||||
export class CompetitionDomainError extends Error {
|
||||
constructor(
|
||||
public readonly code: CompetitionDomainErrorCode,
|
||||
message: string,
|
||||
public readonly details?: Readonly<Record<string, unknown>>,
|
||||
) {
|
||||
super(message);
|
||||
this.name = 'CompetitionDomainError';
|
||||
}
|
||||
}
|
||||
|
||||
export function assertCompetitionInvariant(
|
||||
condition: unknown,
|
||||
code: CompetitionDomainErrorCode,
|
||||
message: string,
|
||||
details?: Readonly<Record<string, unknown>>,
|
||||
): asserts condition {
|
||||
if (!condition) {
|
||||
throw new CompetitionDomainError(code, message, details);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,378 @@
|
||||
import { generateSeriesGraph } from './series-graph';
|
||||
|
||||
type GraphInput = Parameters<typeof generateSeriesGraph>[0];
|
||||
type ExplicitRoundRobinPairing = {
|
||||
roundNumber: number;
|
||||
matchNumber: number;
|
||||
teamAId: string;
|
||||
teamBId: string;
|
||||
};
|
||||
type ExplicitRoundRobinGraphInput = Omit<GraphInput, 'format'> & {
|
||||
format: Extract<GraphInput['format'], { type: 'round-robin' }> & {
|
||||
pairings: readonly ExplicitRoundRobinPairing[];
|
||||
};
|
||||
};
|
||||
|
||||
describe('generateSeriesGraph', () => {
|
||||
it('generates a deterministic graph with stable opaque ids', () => {
|
||||
const input = {
|
||||
competitionId: 'competition-deterministic',
|
||||
teams: Array.from({ length: 8 }, (_, index) => ({
|
||||
teamId: `team-${index + 1}`,
|
||||
displayOrder: index + 1,
|
||||
seedNumber: index + 1,
|
||||
})),
|
||||
format: {
|
||||
type: 'double-elimination' as const,
|
||||
resetFinalEnabled: true,
|
||||
rules: {
|
||||
upper: firstTo(2, 3),
|
||||
lower: firstTo(1, 1),
|
||||
grandFinal: firstTo(1, 1),
|
||||
resetFinal: firstTo(1, 1),
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
const first = generateSeriesGraph(input);
|
||||
const second = generateSeriesGraph(input);
|
||||
|
||||
expect(second).toEqual(first);
|
||||
expect(first.map((series) => series.id)).toHaveLength(15);
|
||||
expect(new Set(first.map((series) => series.id))).toHaveProperty(
|
||||
'size',
|
||||
15,
|
||||
);
|
||||
expect(first.every((series) => series.id.length > 0)).toBe(true);
|
||||
});
|
||||
|
||||
it('predefines a conditional grand-final reset node using only slot sources', () => {
|
||||
const graph = generateSeriesGraph({
|
||||
competitionId: 'competition-reset-node',
|
||||
teams: Array.from({ length: 4 }, (_, index) => ({
|
||||
teamId: `team-${index + 1}`,
|
||||
displayOrder: index + 1,
|
||||
seedNumber: index + 1,
|
||||
})),
|
||||
format: {
|
||||
type: 'double-elimination' as const,
|
||||
resetFinalEnabled: true,
|
||||
rules: {
|
||||
upper: firstTo(2, 3),
|
||||
lower: firstTo(1, 1),
|
||||
grandFinal: firstTo(1, 1),
|
||||
resetFinal: firstTo(1, 1),
|
||||
},
|
||||
},
|
||||
});
|
||||
const grandFinal = graph.find((series) => series.code === 'GF');
|
||||
const resetFinal = graph.find((series) => series.code === 'GF_RESET');
|
||||
|
||||
expect(grandFinal).toBeDefined();
|
||||
expect(resetFinal).toMatchObject({
|
||||
stage: { type: 'reset-final' },
|
||||
activation: {
|
||||
type: 'grand-final-reset-required',
|
||||
grandFinalSeriesId: grandFinal!.id,
|
||||
},
|
||||
slots: [
|
||||
{
|
||||
position: 'A',
|
||||
source: {
|
||||
type: 'series-slot',
|
||||
seriesId: grandFinal!.id,
|
||||
slot: 'A',
|
||||
},
|
||||
},
|
||||
{
|
||||
position: 'B',
|
||||
source: {
|
||||
type: 'series-slot',
|
||||
seriesId: grandFinal!.id,
|
||||
slot: 'B',
|
||||
},
|
||||
},
|
||||
],
|
||||
});
|
||||
for (const series of graph) {
|
||||
expect(series).not.toHaveProperty('winnerAdvancesTo');
|
||||
expect(series).not.toHaveProperty('loserAdvancesTo');
|
||||
}
|
||||
});
|
||||
|
||||
it('rejects a first-to rule that can exhaust every GameSlot without a winner', () => {
|
||||
try {
|
||||
generateSeriesGraph({
|
||||
competitionId: 'competition-unfinishable-first-to',
|
||||
teams: Array.from({ length: 4 }, (_, index) => ({
|
||||
teamId: `team-${index + 1}`,
|
||||
displayOrder: index + 1,
|
||||
seedNumber: index + 1,
|
||||
})),
|
||||
format: {
|
||||
type: 'double-elimination',
|
||||
resetFinalEnabled: false,
|
||||
rules: {
|
||||
upper: firstTo(2, 2),
|
||||
lower: firstTo(1, 1),
|
||||
grandFinal: firstTo(1, 1),
|
||||
resetFinal: firstTo(1, 1),
|
||||
},
|
||||
},
|
||||
});
|
||||
throw new Error('Expected INVALID_FIRST_TO_RULE');
|
||||
} catch (error) {
|
||||
expect(error).toMatchObject({ code: 'INVALID_FIRST_TO_RULE' });
|
||||
}
|
||||
});
|
||||
|
||||
it('reproduces an explicit persisted round-robin schedule by TeamId and pairing position', () => {
|
||||
const input: ExplicitRoundRobinGraphInput = {
|
||||
competitionId: 'competition-persisted-round-robin',
|
||||
teams: Array.from({ length: 8 }, (_, index) => ({
|
||||
teamId: `team-${index + 1}`,
|
||||
displayOrder: 8 - index,
|
||||
seedNumber: index + 1,
|
||||
})),
|
||||
format: {
|
||||
type: 'round-robin',
|
||||
rule: fixedGames(1),
|
||||
maxRounds: 3,
|
||||
tieBreakers: ['series-wins', 'game-diff', 'head-to-head'],
|
||||
// Persisted schedules need not arrive in display order. Their explicit
|
||||
// round/match positions, rather than array position, define identity.
|
||||
pairings: [
|
||||
pairing(3, 4, 'team-6', 'team-7'),
|
||||
pairing(1, 2, 'team-3', 'team-4'),
|
||||
pairing(2, 1, 'team-1', 'team-3'),
|
||||
pairing(1, 4, 'team-7', 'team-8'),
|
||||
pairing(3, 1, 'team-1', 'team-4'),
|
||||
pairing(2, 3, 'team-5', 'team-7'),
|
||||
pairing(1, 1, 'team-1', 'team-2'),
|
||||
pairing(3, 3, 'team-5', 'team-8'),
|
||||
pairing(2, 4, 'team-6', 'team-8'),
|
||||
pairing(1, 3, 'team-5', 'team-6'),
|
||||
pairing(3, 2, 'team-2', 'team-3'),
|
||||
pairing(2, 2, 'team-2', 'team-4'),
|
||||
],
|
||||
},
|
||||
};
|
||||
|
||||
const first = generateSeriesGraph(input);
|
||||
const second = generateSeriesGraph({
|
||||
...input,
|
||||
format: {
|
||||
...input.format,
|
||||
pairings: [...input.format.pairings].reverse(),
|
||||
},
|
||||
});
|
||||
|
||||
expect(second).toEqual(first);
|
||||
expect(
|
||||
first.map((series) => ({
|
||||
code: series.code,
|
||||
roundNumber: series.stage.roundNumber,
|
||||
displayOrder: series.stage.displayOrder,
|
||||
sources: series.slots.map((slot) => slot.source),
|
||||
})),
|
||||
).toEqual([
|
||||
roundRobinSeries('RR_R1_M1', 1, 1, 'team-1', 'team-2'),
|
||||
roundRobinSeries('RR_R1_M2', 1, 2, 'team-3', 'team-4'),
|
||||
roundRobinSeries('RR_R1_M3', 1, 3, 'team-5', 'team-6'),
|
||||
roundRobinSeries('RR_R1_M4', 1, 4, 'team-7', 'team-8'),
|
||||
roundRobinSeries('RR_R2_M1', 2, 5, 'team-1', 'team-3'),
|
||||
roundRobinSeries('RR_R2_M2', 2, 6, 'team-2', 'team-4'),
|
||||
roundRobinSeries('RR_R2_M3', 2, 7, 'team-5', 'team-7'),
|
||||
roundRobinSeries('RR_R2_M4', 2, 8, 'team-6', 'team-8'),
|
||||
roundRobinSeries('RR_R3_M1', 3, 9, 'team-1', 'team-4'),
|
||||
roundRobinSeries('RR_R3_M2', 3, 10, 'team-2', 'team-3'),
|
||||
roundRobinSeries('RR_R3_M3', 3, 11, 'team-5', 'team-8'),
|
||||
roundRobinSeries('RR_R3_M4', 3, 12, 'team-6', 'team-7'),
|
||||
]);
|
||||
});
|
||||
|
||||
it.each([
|
||||
{
|
||||
name: 'a TeamId that is absent from the Competition',
|
||||
replacement: pairing(1, 1, 'team-1', 'team-9'),
|
||||
},
|
||||
{
|
||||
name: 'the same TeamId in both slots',
|
||||
replacement: pairing(1, 1, 'team-1', 'team-1'),
|
||||
},
|
||||
{
|
||||
name: 'a non-positive round number',
|
||||
replacement: pairing(0, 1, 'team-1', 'team-2'),
|
||||
},
|
||||
{
|
||||
name: 'a non-positive match number',
|
||||
replacement: pairing(1, 0, 'team-1', 'team-2'),
|
||||
},
|
||||
])(
|
||||
'rejects an explicit round-robin pairing with $name',
|
||||
({ replacement }) => {
|
||||
const input = explicitRoundRobinInput([
|
||||
replacement,
|
||||
pairing(1, 2, 'team-3', 'team-4'),
|
||||
]);
|
||||
|
||||
expectGraphError(input, 'INVALID_ROUND_ROBIN_PAIRING');
|
||||
},
|
||||
);
|
||||
|
||||
it.each([
|
||||
{
|
||||
name: 'round and match position',
|
||||
pairings: [
|
||||
pairing(1, 1, 'team-1', 'team-2'),
|
||||
pairing(1, 1, 'team-3', 'team-4'),
|
||||
],
|
||||
code: 'DUPLICATE_ROUND_ROBIN_PAIRING_POSITION',
|
||||
},
|
||||
{
|
||||
name: 'opponents with reversed slots',
|
||||
pairings: [
|
||||
pairing(1, 1, 'team-1', 'team-2'),
|
||||
pairing(2, 1, 'team-2', 'team-1'),
|
||||
],
|
||||
code: 'DUPLICATE_ROUND_ROBIN_OPPONENTS',
|
||||
},
|
||||
])('rejects a duplicate explicit $name', ({ pairings, code }) => {
|
||||
expectGraphError(explicitRoundRobinInput(pairings), code);
|
||||
});
|
||||
|
||||
it('keeps distinct opponent pairs when opaque TeamIds contain delimiters', () => {
|
||||
const input = explicitRoundRobinInput([
|
||||
pairing(1, 1, 'a', 'b:c'),
|
||||
pairing(1, 2, 'a:b', 'c'),
|
||||
]);
|
||||
input.format.maxRounds = 1;
|
||||
input.teams = ['a', 'b:c', 'a:b', 'c'].map((teamId, index) => ({
|
||||
teamId,
|
||||
displayOrder: index + 1,
|
||||
seedNumber: index + 1,
|
||||
}));
|
||||
|
||||
expect(generateSeriesGraph(input)).toHaveLength(2);
|
||||
});
|
||||
|
||||
it('validates complete odd-team rounds and clamps maxRounds to the full schedule', () => {
|
||||
const pairings = [
|
||||
pairing(1, 1, 'team-2', 'team-5'),
|
||||
pairing(1, 2, 'team-3', 'team-4'),
|
||||
pairing(2, 1, 'team-1', 'team-5'),
|
||||
pairing(2, 2, 'team-2', 'team-3'),
|
||||
pairing(3, 1, 'team-1', 'team-4'),
|
||||
pairing(3, 2, 'team-3', 'team-5'),
|
||||
pairing(4, 1, 'team-1', 'team-3'),
|
||||
pairing(4, 2, 'team-2', 'team-4'),
|
||||
pairing(5, 1, 'team-1', 'team-2'),
|
||||
pairing(5, 2, 'team-4', 'team-5'),
|
||||
];
|
||||
const input = explicitRoundRobinInput(pairings);
|
||||
input.teams = Array.from({ length: 5 }, (_, index) => ({
|
||||
teamId: `team-${index + 1}`,
|
||||
displayOrder: index + 1,
|
||||
seedNumber: index + 1,
|
||||
}));
|
||||
input.format.maxRounds = 10;
|
||||
|
||||
expect(generateSeriesGraph(input)).toHaveLength(10);
|
||||
});
|
||||
|
||||
it.each([
|
||||
{
|
||||
name: 'an expected round',
|
||||
pairings: [
|
||||
pairing(1, 1, 'team-1', 'team-2'),
|
||||
pairing(1, 2, 'team-3', 'team-4'),
|
||||
],
|
||||
},
|
||||
{
|
||||
name: 'a match from an expected round',
|
||||
pairings: [
|
||||
pairing(1, 1, 'team-1', 'team-2'),
|
||||
pairing(1, 2, 'team-3', 'team-4'),
|
||||
pairing(2, 1, 'team-1', 'team-3'),
|
||||
],
|
||||
},
|
||||
])('rejects explicit pairings missing $name', ({ pairings }) => {
|
||||
expectGraphError(
|
||||
explicitRoundRobinInput(pairings),
|
||||
'INCOMPLETE_ROUND_ROBIN_PAIRINGS',
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
function firstTo(winsRequired: number, maxGames: number) {
|
||||
return { type: 'first-to' as const, winsRequired, maxGames };
|
||||
}
|
||||
|
||||
function expectGraphError(input: GraphInput, code: string): void {
|
||||
try {
|
||||
generateSeriesGraph(input);
|
||||
throw new Error(`Expected graph error ${code}.`);
|
||||
} catch (error) {
|
||||
expect(error).toMatchObject({ code });
|
||||
}
|
||||
}
|
||||
|
||||
function fixedGames(gameCount: number) {
|
||||
return {
|
||||
type: 'fixed-games' as const,
|
||||
gameCount,
|
||||
drawPolicy: 'allow' as const,
|
||||
};
|
||||
}
|
||||
|
||||
function pairing(
|
||||
roundNumber: number,
|
||||
matchNumber: number,
|
||||
teamAId: string,
|
||||
teamBId: string,
|
||||
): ExplicitRoundRobinPairing {
|
||||
return {
|
||||
roundNumber,
|
||||
matchNumber,
|
||||
teamAId,
|
||||
teamBId,
|
||||
};
|
||||
}
|
||||
|
||||
function explicitRoundRobinInput(
|
||||
pairings: readonly ExplicitRoundRobinPairing[],
|
||||
): ExplicitRoundRobinGraphInput {
|
||||
return {
|
||||
competitionId: 'competition-explicit-round-robin-validation',
|
||||
teams: Array.from({ length: 4 }, (_, index) => ({
|
||||
teamId: `team-${index + 1}`,
|
||||
displayOrder: index + 1,
|
||||
seedNumber: index + 1,
|
||||
})),
|
||||
format: {
|
||||
type: 'round-robin',
|
||||
rule: fixedGames(1),
|
||||
maxRounds: 2,
|
||||
tieBreakers: ['series-wins', 'game-diff', 'head-to-head'],
|
||||
pairings,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function roundRobinSeries(
|
||||
code: string,
|
||||
roundNumber: number,
|
||||
displayOrder: number,
|
||||
teamAId: string,
|
||||
teamBId: string,
|
||||
) {
|
||||
return {
|
||||
code,
|
||||
roundNumber,
|
||||
displayOrder,
|
||||
sources: [
|
||||
{ type: 'team', teamId: teamAId },
|
||||
{ type: 'team', teamId: teamBId },
|
||||
],
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,786 @@
|
||||
import { createHash } from 'node:crypto';
|
||||
|
||||
export type SeriesSlot = 'A' | 'B';
|
||||
|
||||
export type FirstToSeriesRule = {
|
||||
type: 'first-to';
|
||||
winsRequired: number;
|
||||
maxGames: number;
|
||||
};
|
||||
|
||||
export type FixedGamesSeriesRule = {
|
||||
type: 'fixed-games';
|
||||
gameCount: number;
|
||||
drawPolicy: 'allow' | 'tiebreak-required';
|
||||
};
|
||||
|
||||
export type SeriesRule = FirstToSeriesRule | FixedGamesSeriesRule;
|
||||
|
||||
export type ParticipantSource =
|
||||
| { type: 'team'; teamId: string }
|
||||
| { type: 'seed'; seedNumber: number }
|
||||
| {
|
||||
type: 'series-outcome';
|
||||
seriesId: string;
|
||||
select: 'winner' | 'loser';
|
||||
}
|
||||
| {
|
||||
type: 'series-slot';
|
||||
seriesId: string;
|
||||
slot: SeriesSlot;
|
||||
};
|
||||
|
||||
export type SeriesStageType =
|
||||
| 'pair'
|
||||
| 'round-robin'
|
||||
| 'upper'
|
||||
| 'lower'
|
||||
| 'grand-final'
|
||||
| 'reset-final';
|
||||
|
||||
export interface SeriesDefinition {
|
||||
id: string;
|
||||
code?: string;
|
||||
stage: {
|
||||
type: SeriesStageType;
|
||||
roundNumber?: number;
|
||||
displayOrder: number;
|
||||
};
|
||||
slots: [
|
||||
{ position: 'A'; source: ParticipantSource },
|
||||
{ position: 'B'; source: ParticipantSource },
|
||||
];
|
||||
rule: SeriesRule;
|
||||
schedule?: {
|
||||
date: string;
|
||||
time: string | null;
|
||||
timeZone: 'Asia/Seoul';
|
||||
};
|
||||
activation?: {
|
||||
type: 'grand-final-reset-required';
|
||||
grandFinalSeriesId: string;
|
||||
};
|
||||
gameSlots: Array<{
|
||||
id: string;
|
||||
seriesId: string;
|
||||
ordinal: number;
|
||||
}>;
|
||||
}
|
||||
|
||||
export interface CompetitionGraphTeam {
|
||||
teamId: string;
|
||||
displayOrder: number;
|
||||
seedNumber?: number;
|
||||
}
|
||||
|
||||
export interface RoundRobinPairing {
|
||||
roundNumber: number;
|
||||
matchNumber: number;
|
||||
teamAId: string;
|
||||
teamBId: string;
|
||||
}
|
||||
|
||||
export type CompetitionGraphFormat =
|
||||
| {
|
||||
type: 'paired-series';
|
||||
rule: FixedGamesSeriesRule;
|
||||
}
|
||||
| {
|
||||
type: 'round-robin';
|
||||
rule: FixedGamesSeriesRule;
|
||||
maxRounds?: number;
|
||||
pairings?: readonly RoundRobinPairing[];
|
||||
tieBreakers: readonly ['series-wins', 'game-diff', 'head-to-head'];
|
||||
}
|
||||
| {
|
||||
type: 'double-elimination';
|
||||
teamCount?: 4 | 8;
|
||||
resetFinalEnabled: boolean;
|
||||
rules: {
|
||||
upper: FirstToSeriesRule;
|
||||
lower: FirstToSeriesRule;
|
||||
grandFinal: FirstToSeriesRule;
|
||||
resetFinal: FirstToSeriesRule;
|
||||
};
|
||||
};
|
||||
|
||||
export interface GenerateSeriesGraphInput {
|
||||
competitionId: string;
|
||||
teams: readonly CompetitionGraphTeam[];
|
||||
format: CompetitionGraphFormat;
|
||||
}
|
||||
|
||||
interface DoubleEliminationTemplate {
|
||||
code: string;
|
||||
stage: Extract<
|
||||
SeriesStageType,
|
||||
'upper' | 'lower' | 'grand-final' | 'reset-final'
|
||||
>;
|
||||
roundNumber: number;
|
||||
sources: [TemplateParticipantSource, TemplateParticipantSource];
|
||||
}
|
||||
|
||||
type TemplateParticipantSource =
|
||||
| { type: 'seed'; seedNumber: number }
|
||||
| {
|
||||
type: 'series-outcome';
|
||||
seriesCode: string;
|
||||
select: 'winner' | 'loser';
|
||||
}
|
||||
| { type: 'series-slot'; seriesCode: string; slot: SeriesSlot };
|
||||
|
||||
interface CanonicalRoundRobinPairing {
|
||||
roundNumber: number;
|
||||
teamAIndex: number;
|
||||
teamBIndex: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds the immutable Series graph. Identifiers depend only on the Competition
|
||||
* identity and the logical node/slot key, never on array position or a display
|
||||
* number supplied by a client.
|
||||
*/
|
||||
export function generateSeriesGraph(
|
||||
input: GenerateSeriesGraphInput,
|
||||
): SeriesDefinition[] {
|
||||
assertCompetitionId(input.competitionId);
|
||||
const teams = normalizeTeams(input.teams);
|
||||
|
||||
let graph: SeriesDefinition[];
|
||||
switch (input.format.type) {
|
||||
case 'paired-series':
|
||||
graph = generatePairedSeriesGraph(
|
||||
input.competitionId,
|
||||
teams,
|
||||
input.format.rule,
|
||||
);
|
||||
break;
|
||||
case 'round-robin':
|
||||
graph = generateRoundRobinGraph(input.competitionId, teams, input.format);
|
||||
break;
|
||||
case 'double-elimination':
|
||||
graph = generateDoubleEliminationGraph(
|
||||
input.competitionId,
|
||||
teams,
|
||||
input.format,
|
||||
);
|
||||
break;
|
||||
}
|
||||
|
||||
assertValidGraph(graph);
|
||||
return graph;
|
||||
}
|
||||
|
||||
function generatePairedSeriesGraph(
|
||||
competitionId: string,
|
||||
teams: CompetitionGraphTeam[],
|
||||
rule: FixedGamesSeriesRule,
|
||||
): SeriesDefinition[] {
|
||||
assertFixedGamesRule(rule);
|
||||
if (teams.length < 2 || teams.length % 2 !== 0) {
|
||||
throw graphError(
|
||||
'INVALID_PAIRED_TEAM_COUNT',
|
||||
'Paired Series requires a positive, even number of teams.',
|
||||
);
|
||||
}
|
||||
|
||||
const definitions: SeriesDefinition[] = [];
|
||||
for (let teamIndex = 0; teamIndex < teams.length; teamIndex += 2) {
|
||||
const code = `PAIR_M${teamIndex / 2 + 1}`;
|
||||
definitions.push(
|
||||
createSeriesDefinition({
|
||||
competitionId,
|
||||
code,
|
||||
stage: 'pair',
|
||||
roundNumber: 1,
|
||||
displayOrder: definitions.length + 1,
|
||||
sources: [
|
||||
{ type: 'team', teamId: teams[teamIndex].teamId },
|
||||
{ type: 'team', teamId: teams[teamIndex + 1].teamId },
|
||||
],
|
||||
rule,
|
||||
}),
|
||||
);
|
||||
}
|
||||
return definitions;
|
||||
}
|
||||
|
||||
function generateRoundRobinGraph(
|
||||
competitionId: string,
|
||||
teams: CompetitionGraphTeam[],
|
||||
format: Extract<CompetitionGraphFormat, { type: 'round-robin' }>,
|
||||
): SeriesDefinition[] {
|
||||
assertFixedGamesRule(format.rule);
|
||||
if (teams.length < 2) {
|
||||
throw graphError(
|
||||
'INVALID_ROUND_ROBIN_TEAM_COUNT',
|
||||
'Round robin requires at least two teams.',
|
||||
);
|
||||
}
|
||||
|
||||
const pairings = format.pairings
|
||||
? validateExplicitRoundRobinPairings(
|
||||
teams,
|
||||
format.pairings,
|
||||
format.maxRounds,
|
||||
)
|
||||
: canonicalRoundRobinPairings(teams, format.maxRounds);
|
||||
|
||||
return pairings.map((pairing, index) => {
|
||||
const code = `RR_R${pairing.roundNumber}_M${pairing.matchNumber}`;
|
||||
return createSeriesDefinition({
|
||||
competitionId,
|
||||
code,
|
||||
stage: 'round-robin',
|
||||
roundNumber: pairing.roundNumber,
|
||||
displayOrder: index + 1,
|
||||
sources: [
|
||||
{ type: 'team', teamId: pairing.teamAId },
|
||||
{ type: 'team', teamId: pairing.teamBId },
|
||||
],
|
||||
rule: format.rule,
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
function canonicalRoundRobinPairings(
|
||||
teams: CompetitionGraphTeam[],
|
||||
maxRounds?: number,
|
||||
): RoundRobinPairing[] {
|
||||
const matchNumberByRound = new Map<number, number>();
|
||||
return roundRobinPairings(teams.length, maxRounds).map((pairing) => {
|
||||
const matchNumber = (matchNumberByRound.get(pairing.roundNumber) ?? 0) + 1;
|
||||
matchNumberByRound.set(pairing.roundNumber, matchNumber);
|
||||
return {
|
||||
roundNumber: pairing.roundNumber,
|
||||
matchNumber,
|
||||
teamAId: teams[pairing.teamAIndex].teamId,
|
||||
teamBId: teams[pairing.teamBIndex].teamId,
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
function validateExplicitRoundRobinPairings(
|
||||
teams: CompetitionGraphTeam[],
|
||||
pairings: readonly RoundRobinPairing[],
|
||||
maxRounds?: number,
|
||||
): RoundRobinPairing[] {
|
||||
if (pairings.length === 0) {
|
||||
throw graphError(
|
||||
'INVALID_ROUND_ROBIN_PAIRING',
|
||||
'Explicit round-robin pairings cannot be empty.',
|
||||
);
|
||||
}
|
||||
const teamIds = new Set(teams.map(({ teamId }) => teamId));
|
||||
const positions = new Set<string>();
|
||||
const opponentPairs = new Set<string>();
|
||||
const teamsByRound = new Map<number, Set<string>>();
|
||||
const sorted = pairings
|
||||
.map((pairing) => ({ ...pairing }))
|
||||
.sort(
|
||||
(left, right) =>
|
||||
left.roundNumber - right.roundNumber ||
|
||||
left.matchNumber - right.matchNumber,
|
||||
);
|
||||
|
||||
for (const pairing of sorted) {
|
||||
if (
|
||||
!Number.isInteger(pairing.roundNumber) ||
|
||||
pairing.roundNumber < 1 ||
|
||||
!Number.isInteger(pairing.matchNumber) ||
|
||||
pairing.matchNumber < 1 ||
|
||||
(maxRounds !== undefined && pairing.roundNumber > maxRounds) ||
|
||||
!teamIds.has(pairing.teamAId) ||
|
||||
!teamIds.has(pairing.teamBId) ||
|
||||
pairing.teamAId === pairing.teamBId
|
||||
) {
|
||||
throw graphError(
|
||||
'INVALID_ROUND_ROBIN_PAIRING',
|
||||
'Every explicit round-robin pairing needs a valid position and two known, distinct teams.',
|
||||
);
|
||||
}
|
||||
|
||||
const position = `${pairing.roundNumber}:${pairing.matchNumber}`;
|
||||
if (positions.has(position)) {
|
||||
throw graphError(
|
||||
'DUPLICATE_ROUND_ROBIN_PAIRING_POSITION',
|
||||
`Round-robin pairing position ${position} occurs more than once.`,
|
||||
);
|
||||
}
|
||||
positions.add(position);
|
||||
|
||||
const opponents = JSON.stringify([pairing.teamAId, pairing.teamBId].sort());
|
||||
if (opponentPairs.has(opponents)) {
|
||||
throw graphError(
|
||||
'DUPLICATE_ROUND_ROBIN_OPPONENTS',
|
||||
'A round-robin opponent pair occurs more than once.',
|
||||
);
|
||||
}
|
||||
opponentPairs.add(opponents);
|
||||
|
||||
const roundTeams = teamsByRound.get(pairing.roundNumber) ?? new Set();
|
||||
if (roundTeams.has(pairing.teamAId) || roundTeams.has(pairing.teamBId)) {
|
||||
throw graphError(
|
||||
'INVALID_ROUND_ROBIN_PAIRING',
|
||||
'A team cannot appear in multiple Series in the same round.',
|
||||
);
|
||||
}
|
||||
roundTeams.add(pairing.teamAId);
|
||||
roundTeams.add(pairing.teamBId);
|
||||
teamsByRound.set(pairing.roundNumber, roundTeams);
|
||||
}
|
||||
|
||||
for (const roundNumber of new Set(
|
||||
sorted.map((pairing) => pairing.roundNumber),
|
||||
)) {
|
||||
const matches = sorted.filter(
|
||||
(pairing) => pairing.roundNumber === roundNumber,
|
||||
);
|
||||
if (matches.some((pairing, index) => pairing.matchNumber !== index + 1)) {
|
||||
throw graphError(
|
||||
'INVALID_ROUND_ROBIN_PAIRING',
|
||||
`Round ${roundNumber} match numbers must be contiguous from one.`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
const expectedRoundCount = roundRobinRoundCount(teams.length, maxRounds);
|
||||
const expectedMatchesPerRound = Math.floor(teams.length / 2);
|
||||
for (
|
||||
let roundNumber = 1;
|
||||
roundNumber <= expectedRoundCount;
|
||||
roundNumber += 1
|
||||
) {
|
||||
const matchCount = (teamsByRound.get(roundNumber)?.size ?? 0) / 2;
|
||||
if (matchCount !== expectedMatchesPerRound) {
|
||||
throw graphError(
|
||||
'INCOMPLETE_ROUND_ROBIN_PAIRINGS',
|
||||
`Round ${roundNumber} must contain ${expectedMatchesPerRound} Series.`,
|
||||
);
|
||||
}
|
||||
}
|
||||
if (teamsByRound.size !== expectedRoundCount) {
|
||||
throw graphError(
|
||||
'INCOMPLETE_ROUND_ROBIN_PAIRINGS',
|
||||
`Explicit round-robin pairings must contain rounds 1 through ${expectedRoundCount}.`,
|
||||
);
|
||||
}
|
||||
return sorted;
|
||||
}
|
||||
|
||||
function generateDoubleEliminationGraph(
|
||||
competitionId: string,
|
||||
teams: CompetitionGraphTeam[],
|
||||
format: Extract<CompetitionGraphFormat, { type: 'double-elimination' }>,
|
||||
): SeriesDefinition[] {
|
||||
if (teams.length !== 4 && teams.length !== 8) {
|
||||
throw graphError(
|
||||
'INVALID_DOUBLE_ELIMINATION_TEAM_COUNT',
|
||||
'Double elimination supports only four or eight teams.',
|
||||
);
|
||||
}
|
||||
if (format.teamCount !== undefined && format.teamCount !== teams.length) {
|
||||
throw graphError(
|
||||
'DOUBLE_ELIMINATION_TEAM_COUNT_MISMATCH',
|
||||
'The configured team count does not match the team snapshots.',
|
||||
);
|
||||
}
|
||||
assertContiguousSeeds(teams);
|
||||
assertFirstToRule(format.rules.upper);
|
||||
assertFirstToRule(format.rules.lower);
|
||||
assertFirstToRule(format.rules.grandFinal);
|
||||
assertFirstToRule(format.rules.resetFinal);
|
||||
|
||||
const templates =
|
||||
teams.length === 4
|
||||
? fourTeamDoubleEliminationTemplate()
|
||||
: eightTeamDoubleEliminationTemplate();
|
||||
if (format.resetFinalEnabled) templates.push(resetFinalTemplate());
|
||||
|
||||
return templates.map((template, index) => {
|
||||
const rule = ruleForStage(template.stage, format.rules);
|
||||
const grandFinalSeriesId = stableSeriesId(competitionId, 'GF');
|
||||
return createSeriesDefinition({
|
||||
competitionId,
|
||||
code: template.code,
|
||||
stage: template.stage,
|
||||
roundNumber: template.roundNumber,
|
||||
displayOrder: index + 1,
|
||||
sources: template.sources.map((source) =>
|
||||
resolveTemplateSource(competitionId, source),
|
||||
) as [ParticipantSource, ParticipantSource],
|
||||
rule,
|
||||
activation:
|
||||
template.stage === 'reset-final'
|
||||
? {
|
||||
type: 'grand-final-reset-required',
|
||||
grandFinalSeriesId,
|
||||
}
|
||||
: undefined,
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
function createSeriesDefinition(params: {
|
||||
competitionId: string;
|
||||
code: string;
|
||||
stage: SeriesStageType;
|
||||
roundNumber: number;
|
||||
displayOrder: number;
|
||||
sources: [ParticipantSource, ParticipantSource];
|
||||
rule: SeriesRule;
|
||||
activation?: SeriesDefinition['activation'];
|
||||
}): SeriesDefinition {
|
||||
const id = stableSeriesId(params.competitionId, params.code);
|
||||
const rule = cloneRule(params.rule);
|
||||
const gameCount =
|
||||
rule.type === 'fixed-games' ? rule.gameCount : rule.maxGames;
|
||||
|
||||
return {
|
||||
id,
|
||||
code: params.code,
|
||||
stage: {
|
||||
type: params.stage,
|
||||
roundNumber: params.roundNumber,
|
||||
displayOrder: params.displayOrder,
|
||||
},
|
||||
slots: [
|
||||
{ position: 'A', source: { ...params.sources[0] } },
|
||||
{ position: 'B', source: { ...params.sources[1] } },
|
||||
],
|
||||
rule,
|
||||
...(params.activation ? { activation: { ...params.activation } } : {}),
|
||||
gameSlots: Array.from({ length: gameCount }, (_, index) => ({
|
||||
id: stableGameSlotId(params.competitionId, params.code, index + 1),
|
||||
seriesId: id,
|
||||
ordinal: index + 1,
|
||||
})),
|
||||
};
|
||||
}
|
||||
|
||||
function fourTeamDoubleEliminationTemplate(): DoubleEliminationTemplate[] {
|
||||
return [
|
||||
deSeries('WB_R1_M1', 'upper', 1, seed(1), seed(4)),
|
||||
deSeries('WB_R1_M2', 'upper', 1, seed(2), seed(3)),
|
||||
deSeries('WB_FINAL', 'upper', 2, winner('WB_R1_M1'), winner('WB_R1_M2')),
|
||||
deSeries('LB_R1_M1', 'lower', 1, loser('WB_R1_M1'), loser('WB_R1_M2')),
|
||||
deSeries('LB_FINAL', 'lower', 2, winner('LB_R1_M1'), loser('WB_FINAL')),
|
||||
deSeries('GF', 'grand-final', 1, winner('WB_FINAL'), winner('LB_FINAL')),
|
||||
];
|
||||
}
|
||||
|
||||
function eightTeamDoubleEliminationTemplate(): DoubleEliminationTemplate[] {
|
||||
return [
|
||||
deSeries('WB_R1_M1', 'upper', 1, seed(1), seed(8)),
|
||||
deSeries('WB_R1_M2', 'upper', 1, seed(4), seed(5)),
|
||||
deSeries('WB_R1_M3', 'upper', 1, seed(2), seed(7)),
|
||||
deSeries('WB_R1_M4', 'upper', 1, seed(3), seed(6)),
|
||||
deSeries('WB_R2_M1', 'upper', 2, winner('WB_R1_M1'), winner('WB_R1_M2')),
|
||||
deSeries('WB_R2_M2', 'upper', 2, winner('WB_R1_M3'), winner('WB_R1_M4')),
|
||||
deSeries('WB_FINAL', 'upper', 3, winner('WB_R2_M1'), winner('WB_R2_M2')),
|
||||
deSeries('LB_R1_M1', 'lower', 1, loser('WB_R1_M1'), loser('WB_R1_M2')),
|
||||
deSeries('LB_R1_M2', 'lower', 1, loser('WB_R1_M3'), loser('WB_R1_M4')),
|
||||
deSeries('LB_R2_M1', 'lower', 2, winner('LB_R1_M1'), loser('WB_R2_M2')),
|
||||
deSeries('LB_R2_M2', 'lower', 2, winner('LB_R1_M2'), loser('WB_R2_M1')),
|
||||
deSeries('LB_R3_M1', 'lower', 3, winner('LB_R2_M1'), winner('LB_R2_M2')),
|
||||
deSeries('LB_FINAL', 'lower', 4, winner('LB_R3_M1'), loser('WB_FINAL')),
|
||||
deSeries('GF', 'grand-final', 1, winner('WB_FINAL'), winner('LB_FINAL')),
|
||||
];
|
||||
}
|
||||
|
||||
function resetFinalTemplate(): DoubleEliminationTemplate {
|
||||
return deSeries(
|
||||
'GF_RESET',
|
||||
'reset-final',
|
||||
1,
|
||||
seriesSlot('GF', 'A'),
|
||||
seriesSlot('GF', 'B'),
|
||||
);
|
||||
}
|
||||
|
||||
function deSeries(
|
||||
code: string,
|
||||
stage: DoubleEliminationTemplate['stage'],
|
||||
roundNumber: number,
|
||||
sourceA: TemplateParticipantSource,
|
||||
sourceB: TemplateParticipantSource,
|
||||
): DoubleEliminationTemplate {
|
||||
return { code, stage, roundNumber, sources: [sourceA, sourceB] };
|
||||
}
|
||||
|
||||
function seed(seedNumber: number): TemplateParticipantSource {
|
||||
return { type: 'seed', seedNumber };
|
||||
}
|
||||
|
||||
function winner(seriesCode: string): TemplateParticipantSource {
|
||||
return { type: 'series-outcome', seriesCode, select: 'winner' };
|
||||
}
|
||||
|
||||
function loser(seriesCode: string): TemplateParticipantSource {
|
||||
return { type: 'series-outcome', seriesCode, select: 'loser' };
|
||||
}
|
||||
|
||||
function seriesSlot(
|
||||
seriesCode: string,
|
||||
slot: SeriesSlot,
|
||||
): TemplateParticipantSource {
|
||||
return { type: 'series-slot', seriesCode, slot };
|
||||
}
|
||||
|
||||
function resolveTemplateSource(
|
||||
competitionId: string,
|
||||
source: TemplateParticipantSource,
|
||||
): ParticipantSource {
|
||||
switch (source.type) {
|
||||
case 'seed':
|
||||
return { ...source };
|
||||
case 'series-outcome':
|
||||
return {
|
||||
type: 'series-outcome',
|
||||
seriesId: stableSeriesId(competitionId, source.seriesCode),
|
||||
select: source.select,
|
||||
};
|
||||
case 'series-slot':
|
||||
return {
|
||||
type: 'series-slot',
|
||||
seriesId: stableSeriesId(competitionId, source.seriesCode),
|
||||
slot: source.slot,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
function ruleForStage(
|
||||
stage: DoubleEliminationTemplate['stage'],
|
||||
rules: Extract<
|
||||
CompetitionGraphFormat,
|
||||
{ type: 'double-elimination' }
|
||||
>['rules'],
|
||||
): FirstToSeriesRule {
|
||||
switch (stage) {
|
||||
case 'upper':
|
||||
return rules.upper;
|
||||
case 'lower':
|
||||
return rules.lower;
|
||||
case 'grand-final':
|
||||
return rules.grandFinal;
|
||||
case 'reset-final':
|
||||
return rules.resetFinal;
|
||||
}
|
||||
}
|
||||
|
||||
function roundRobinPairings(
|
||||
teamCount: number,
|
||||
maxRounds?: number,
|
||||
): CanonicalRoundRobinPairing[] {
|
||||
const bye = -1;
|
||||
const rotating = Array.from({ length: teamCount }, (_, index) => index);
|
||||
if (rotating.length % 2 === 1) rotating.push(bye);
|
||||
|
||||
const roundCount = roundRobinRoundCount(teamCount, maxRounds);
|
||||
const pairings: CanonicalRoundRobinPairing[] = [];
|
||||
|
||||
for (let roundIndex = 0; roundIndex < roundCount; roundIndex += 1) {
|
||||
for (let index = 0; index < rotating.length / 2; index += 1) {
|
||||
const left = rotating[index];
|
||||
const right = rotating[rotating.length - 1 - index];
|
||||
if (left === bye || right === bye) continue;
|
||||
pairings.push({
|
||||
roundNumber: roundIndex + 1,
|
||||
teamAIndex: Math.min(left, right),
|
||||
teamBIndex: Math.max(left, right),
|
||||
});
|
||||
}
|
||||
|
||||
const fixed = rotating[0];
|
||||
const tail = rotating.slice(1);
|
||||
tail.unshift(tail.pop() as number);
|
||||
rotating.splice(0, rotating.length, fixed, ...tail);
|
||||
}
|
||||
|
||||
return pairings;
|
||||
}
|
||||
|
||||
function roundRobinRoundCount(teamCount: number, maxRounds?: number): number {
|
||||
const fullRoundCount = teamCount % 2 === 0 ? teamCount - 1 : teamCount;
|
||||
const requestedRounds =
|
||||
maxRounds === undefined
|
||||
? fullRoundCount
|
||||
: Number.isFinite(maxRounds)
|
||||
? Math.floor(maxRounds)
|
||||
: fullRoundCount;
|
||||
return Math.max(0, Math.min(fullRoundCount, requestedRounds));
|
||||
}
|
||||
|
||||
function normalizeTeams(
|
||||
teams: readonly CompetitionGraphTeam[],
|
||||
): CompetitionGraphTeam[] {
|
||||
const normalized = teams.map((team) => ({ ...team }));
|
||||
const teamIds = new Set<string>();
|
||||
const displayOrders = new Set<number>();
|
||||
|
||||
for (const team of normalized) {
|
||||
if (typeof team.teamId !== 'string' || team.teamId.trim().length === 0) {
|
||||
throw graphError('INVALID_TEAM_ID', 'Every team needs an opaque ID.');
|
||||
}
|
||||
if (teamIds.has(team.teamId)) {
|
||||
throw graphError(
|
||||
'DUPLICATE_TEAM_ID',
|
||||
`Duplicate team ID: ${team.teamId}`,
|
||||
);
|
||||
}
|
||||
if (!Number.isInteger(team.displayOrder) || team.displayOrder < 1) {
|
||||
throw graphError(
|
||||
'INVALID_TEAM_DISPLAY_ORDER',
|
||||
'Team display order must be a positive integer.',
|
||||
);
|
||||
}
|
||||
if (displayOrders.has(team.displayOrder)) {
|
||||
throw graphError(
|
||||
'DUPLICATE_TEAM_DISPLAY_ORDER',
|
||||
`Duplicate team display order: ${team.displayOrder}`,
|
||||
);
|
||||
}
|
||||
teamIds.add(team.teamId);
|
||||
displayOrders.add(team.displayOrder);
|
||||
}
|
||||
|
||||
return normalized.sort(
|
||||
(left, right) =>
|
||||
left.displayOrder - right.displayOrder ||
|
||||
left.teamId.localeCompare(right.teamId),
|
||||
);
|
||||
}
|
||||
|
||||
function assertContiguousSeeds(teams: CompetitionGraphTeam[]): void {
|
||||
const seeds = teams.map((team) => team.seedNumber);
|
||||
if (
|
||||
seeds.some((seedNumber) => !Number.isInteger(seedNumber)) ||
|
||||
new Set(seeds).size !== teams.length
|
||||
) {
|
||||
throw graphError(
|
||||
'INVALID_DOUBLE_ELIMINATION_SEEDS',
|
||||
'Double-elimination seeds must be unique integers.',
|
||||
);
|
||||
}
|
||||
const sorted = [...(seeds as number[])].sort((left, right) => left - right);
|
||||
if (sorted.some((seedNumber, index) => seedNumber !== index + 1)) {
|
||||
throw graphError(
|
||||
'INVALID_DOUBLE_ELIMINATION_SEEDS',
|
||||
'Double-elimination seeds must be contiguous from one to the team count.',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function assertCompetitionId(competitionId: string): void {
|
||||
if (typeof competitionId !== 'string' || competitionId.trim().length === 0) {
|
||||
throw graphError(
|
||||
'INVALID_COMPETITION_ID',
|
||||
'Competition ID must be a non-empty string.',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function assertFixedGamesRule(rule: FixedGamesSeriesRule): void {
|
||||
if (!Number.isInteger(rule.gameCount) || rule.gameCount < 1) {
|
||||
throw graphError(
|
||||
'INVALID_FIXED_GAMES_RULE',
|
||||
'Fixed-game Series need a positive game count.',
|
||||
);
|
||||
}
|
||||
if (rule.drawPolicy !== 'allow' && rule.drawPolicy !== 'tiebreak-required') {
|
||||
throw graphError(
|
||||
'INVALID_FIXED_GAMES_RULE',
|
||||
'Fixed-game Series need a supported draw policy.',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function assertFirstToRule(rule: FirstToSeriesRule): void {
|
||||
if (
|
||||
!Number.isInteger(rule.winsRequired) ||
|
||||
rule.winsRequired < 1 ||
|
||||
!Number.isInteger(rule.maxGames) ||
|
||||
rule.maxGames < rule.winsRequired * 2 - 1
|
||||
) {
|
||||
throw graphError(
|
||||
'INVALID_FIRST_TO_RULE',
|
||||
'First-to Series need positive, achievable win and game limits.',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function cloneRule(rule: SeriesRule): SeriesRule {
|
||||
return rule.type === 'fixed-games' ? { ...rule } : { ...rule };
|
||||
}
|
||||
|
||||
function assertValidGraph(graph: SeriesDefinition[]): void {
|
||||
const seriesIndexById = new Map<string, number>();
|
||||
const gameSlotIds = new Set<string>();
|
||||
|
||||
graph.forEach((series, index) => {
|
||||
if (seriesIndexById.has(series.id)) {
|
||||
throw graphError('DUPLICATE_SERIES_ID', 'Series IDs must be unique.');
|
||||
}
|
||||
seriesIndexById.set(series.id, index);
|
||||
for (const gameSlot of series.gameSlots) {
|
||||
if (gameSlotIds.has(gameSlot.id)) {
|
||||
throw graphError(
|
||||
'DUPLICATE_GAME_SLOT_ID',
|
||||
'GameSlot IDs must be unique.',
|
||||
);
|
||||
}
|
||||
gameSlotIds.add(gameSlot.id);
|
||||
}
|
||||
});
|
||||
|
||||
graph.forEach((series, index) => {
|
||||
for (const slot of series.slots) {
|
||||
if (
|
||||
slot.source.type !== 'series-outcome' &&
|
||||
slot.source.type !== 'series-slot'
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
const sourceIndex = seriesIndexById.get(slot.source.seriesId);
|
||||
if (sourceIndex === undefined) {
|
||||
throw graphError(
|
||||
'UNKNOWN_SERIES_SOURCE',
|
||||
`Series ${series.id} references an unknown source.`,
|
||||
);
|
||||
}
|
||||
if (sourceIndex >= index) {
|
||||
throw graphError(
|
||||
'CYCLIC_SERIES_GRAPH',
|
||||
`Series ${series.id} does not follow its source in topological order.`,
|
||||
);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function stableSeriesId(competitionId: string, code: string): string {
|
||||
return stableOpaqueId(competitionId, 'series', code);
|
||||
}
|
||||
|
||||
function stableGameSlotId(
|
||||
competitionId: string,
|
||||
seriesCode: string,
|
||||
ordinal: number,
|
||||
): string {
|
||||
return stableOpaqueId(competitionId, 'game-slot', seriesCode, ordinal);
|
||||
}
|
||||
|
||||
function stableOpaqueId(
|
||||
competitionId: string,
|
||||
entityKind: string,
|
||||
...logicalKey: Array<string | number>
|
||||
): string {
|
||||
return createHash('sha256')
|
||||
.update(JSON.stringify([competitionId, entityKind, ...logicalKey]))
|
||||
.digest('hex')
|
||||
.slice(0, 24);
|
||||
}
|
||||
|
||||
function graphError(code: string, message: string): Error & { code: string } {
|
||||
return Object.assign(new Error(message), { code });
|
||||
}
|
||||
@@ -0,0 +1,458 @@
|
||||
import { projectSeries } from './series-projector';
|
||||
|
||||
describe('projectSeries', () => {
|
||||
it.each([
|
||||
['a known local time', '21:30'],
|
||||
['an unknown local time', null],
|
||||
] as const)('preserves an optional Series schedule with %s', (_, time) => {
|
||||
const schedule = {
|
||||
date: '2026-07-15',
|
||||
time,
|
||||
timeZone: 'Asia/Seoul' as const,
|
||||
};
|
||||
const definition = {
|
||||
...seriesDefinition({
|
||||
id: `series-scheduled-${time ?? 'unknown'}`,
|
||||
stage: 'upper',
|
||||
rule: { type: 'first-to' as const, winsRequired: 1, maxGames: 1 },
|
||||
}),
|
||||
schedule,
|
||||
};
|
||||
|
||||
const projection = projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: [],
|
||||
});
|
||||
|
||||
expect(projection).toMatchObject({
|
||||
status: 'ready',
|
||||
schedule,
|
||||
});
|
||||
});
|
||||
|
||||
it('keeps an existing definition without a schedule explicitly unscheduled', () => {
|
||||
const definition = seriesDefinition({
|
||||
id: 'series-unscheduled',
|
||||
stage: 'upper',
|
||||
rule: { type: 'first-to', winsRequired: 1, maxGames: 1 },
|
||||
});
|
||||
|
||||
const projection = projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: [],
|
||||
});
|
||||
|
||||
expect(projection).not.toHaveProperty('schedule');
|
||||
});
|
||||
|
||||
it.each([
|
||||
[
|
||||
'an impossible calendar date',
|
||||
{ date: '2026-02-30', time: '21:30', timeZone: 'Asia/Seoul' },
|
||||
],
|
||||
[
|
||||
'an out-of-range local time',
|
||||
{ date: '2026-07-15', time: '24:00', timeZone: 'Asia/Seoul' },
|
||||
],
|
||||
[
|
||||
'a non-canonical time zone',
|
||||
{ date: '2026-07-15', time: '21:30', timeZone: 'UTC' },
|
||||
],
|
||||
])('rejects a Series schedule with %s', (_, schedule) => {
|
||||
const definition = {
|
||||
...seriesDefinition({
|
||||
id: `series-invalid-schedule-${schedule.date}-${schedule.time}`,
|
||||
stage: 'upper',
|
||||
rule: { type: 'first-to' as const, winsRequired: 1, maxGames: 1 },
|
||||
}),
|
||||
schedule,
|
||||
} as unknown as Parameters<typeof projectSeries>[0]['definition'];
|
||||
|
||||
expectInvariant(
|
||||
() =>
|
||||
projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: [],
|
||||
}),
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
);
|
||||
});
|
||||
|
||||
it.each([null, false, ''])(
|
||||
'rejects a non-object Series schedule value %p',
|
||||
(schedule) => {
|
||||
const definition = {
|
||||
...seriesDefinition({
|
||||
id: 'series-invalid-schedule-shape',
|
||||
stage: 'upper',
|
||||
rule: { type: 'first-to' as const, winsRequired: 1, maxGames: 1 },
|
||||
}),
|
||||
schedule,
|
||||
} as unknown as Parameters<typeof projectSeries>[0]['definition'];
|
||||
|
||||
expectInvariant(
|
||||
() =>
|
||||
projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: [],
|
||||
}),
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
it('keeps a fixed-games pair in progress until every game slot is filled', () => {
|
||||
const definition = seriesDefinition({
|
||||
id: 'series-pair',
|
||||
stage: 'pair',
|
||||
rule: {
|
||||
type: 'fixed-games',
|
||||
gameCount: 3,
|
||||
drawPolicy: 'allow',
|
||||
},
|
||||
});
|
||||
const firstTwoGames = [
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 1,
|
||||
blueTeamId: 'team-8',
|
||||
redTeamId: 'team-3',
|
||||
winnerTeamId: 'team-8',
|
||||
}),
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 2,
|
||||
blueTeamId: 'team-3',
|
||||
redTeamId: 'team-8',
|
||||
winnerTeamId: 'team-8',
|
||||
}),
|
||||
];
|
||||
|
||||
const inProgress = projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: firstTwoGames,
|
||||
});
|
||||
|
||||
expect(inProgress).toMatchObject({
|
||||
status: 'in-progress',
|
||||
leaderTeamId: 'team-8',
|
||||
entries: [
|
||||
{ slot: 'A', teamId: 'team-8', gameWins: 2 },
|
||||
{ slot: 'B', teamId: 'team-3', gameWins: 0 },
|
||||
],
|
||||
});
|
||||
expect(inProgress).not.toHaveProperty('outcome');
|
||||
|
||||
const completed = projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: [
|
||||
...firstTwoGames,
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 3,
|
||||
blueTeamId: 'team-8',
|
||||
redTeamId: 'team-3',
|
||||
winnerTeamId: 'team-3',
|
||||
}),
|
||||
],
|
||||
});
|
||||
|
||||
expect(completed).toMatchObject({
|
||||
status: 'completed',
|
||||
entries: [
|
||||
{ slot: 'A', teamId: 'team-8', gameWins: 2 },
|
||||
{ slot: 'B', teamId: 'team-3', gameWins: 1 },
|
||||
],
|
||||
outcome: {
|
||||
type: 'played',
|
||||
winnerTeamId: 'team-8',
|
||||
loserTeamId: 'team-3',
|
||||
},
|
||||
});
|
||||
expect(completed).not.toHaveProperty('leaderTeamId');
|
||||
});
|
||||
|
||||
it('reports a leader during first-to play and a winner only after the threshold', () => {
|
||||
const definition = seriesDefinition({
|
||||
id: 'series-first-to',
|
||||
stage: 'upper',
|
||||
rule: { type: 'first-to', winsRequired: 2, maxGames: 3 },
|
||||
});
|
||||
const firstGame = acceptedGame({
|
||||
definition,
|
||||
ordinal: 1,
|
||||
blueTeamId: 'team-8',
|
||||
redTeamId: 'team-3',
|
||||
winnerTeamId: 'team-8',
|
||||
});
|
||||
|
||||
const oneToZero = projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: [firstGame],
|
||||
});
|
||||
|
||||
expect(oneToZero).toMatchObject({
|
||||
status: 'in-progress',
|
||||
leaderTeamId: 'team-8',
|
||||
});
|
||||
expect(oneToZero).not.toHaveProperty('outcome');
|
||||
|
||||
const twoToOne = projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: [
|
||||
firstGame,
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 2,
|
||||
blueTeamId: 'team-8',
|
||||
redTeamId: 'team-3',
|
||||
winnerTeamId: 'team-3',
|
||||
}),
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 3,
|
||||
blueTeamId: 'team-3',
|
||||
redTeamId: 'team-8',
|
||||
winnerTeamId: 'team-8',
|
||||
}),
|
||||
],
|
||||
});
|
||||
|
||||
expect(twoToOne).toMatchObject({
|
||||
status: 'completed',
|
||||
outcome: {
|
||||
type: 'played',
|
||||
winnerTeamId: 'team-8',
|
||||
loserTeamId: 'team-3',
|
||||
decidedByGameIds: [
|
||||
'game-series-first-to-1',
|
||||
'game-series-first-to-2',
|
||||
'game-series-first-to-3',
|
||||
],
|
||||
},
|
||||
});
|
||||
expect(twoToOne).not.toHaveProperty('leaderTeamId');
|
||||
});
|
||||
|
||||
it('rejects accepted evidence whose teams do not match the series participants', () => {
|
||||
const definition = seriesDefinition({
|
||||
id: 'series-invalid-team',
|
||||
stage: 'upper',
|
||||
rule: { type: 'first-to', winsRequired: 2, maxGames: 3 },
|
||||
});
|
||||
|
||||
expectInvariant(
|
||||
() =>
|
||||
projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: [
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 1,
|
||||
blueTeamId: 'team-8',
|
||||
redTeamId: 'team-9',
|
||||
winnerTeamId: 'team-8',
|
||||
}),
|
||||
],
|
||||
}),
|
||||
'GAME_TEAM_MISMATCH',
|
||||
);
|
||||
});
|
||||
|
||||
it('rejects a game accepted after a first-to series was already complete', () => {
|
||||
const definition = seriesDefinition({
|
||||
id: 'series-extra-game',
|
||||
stage: 'upper',
|
||||
rule: { type: 'first-to', winsRequired: 2, maxGames: 3 },
|
||||
});
|
||||
|
||||
expectInvariant(
|
||||
() =>
|
||||
projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: [
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 1,
|
||||
blueTeamId: 'team-8',
|
||||
redTeamId: 'team-3',
|
||||
winnerTeamId: 'team-8',
|
||||
}),
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 2,
|
||||
blueTeamId: 'team-3',
|
||||
redTeamId: 'team-8',
|
||||
winnerTeamId: 'team-8',
|
||||
}),
|
||||
acceptedGame({
|
||||
definition,
|
||||
ordinal: 3,
|
||||
blueTeamId: 'team-8',
|
||||
redTeamId: 'team-3',
|
||||
winnerTeamId: 'team-3',
|
||||
}),
|
||||
],
|
||||
}),
|
||||
'SERIES_ALREADY_COMPLETED',
|
||||
);
|
||||
});
|
||||
|
||||
it('allows an inactive descendant after all of its historical activity was reversed', () => {
|
||||
const definition = seriesDefinition({
|
||||
id: 'series-reversed-descendant',
|
||||
stage: 'upper',
|
||||
rule: { type: 'first-to', winsRequired: 1, maxGames: 1 },
|
||||
});
|
||||
const accepted = acceptedGame({
|
||||
definition,
|
||||
ordinal: 1,
|
||||
blueTeamId: 'team-8',
|
||||
redTeamId: 'team-3',
|
||||
winnerTeamId: 'team-8',
|
||||
});
|
||||
|
||||
expect(
|
||||
projectSeries({
|
||||
definition,
|
||||
participants: [null, null],
|
||||
active: false,
|
||||
facts: [
|
||||
accepted,
|
||||
{
|
||||
id: 'fact-series-reversed-descendant-void',
|
||||
type: 'game-voided',
|
||||
competitionId: 'competition-series-projector',
|
||||
revision: 2,
|
||||
ordinalWithinRevision: 1,
|
||||
commandId: 'command-series-reversed-descendant-void',
|
||||
schemaVersion: 1,
|
||||
actor: { type: 'user' },
|
||||
occurredAt: new Date('2026-07-12T00:02:00.000Z'),
|
||||
recordedAt: new Date('2026-07-12T00:02:01.000Z'),
|
||||
gameAcceptedFactId: accepted.id,
|
||||
reason: 'Cascade reversal',
|
||||
},
|
||||
],
|
||||
}),
|
||||
).toMatchObject({ status: 'inactive' });
|
||||
});
|
||||
|
||||
it('rejects an unfinishable persisted first-to definition', () => {
|
||||
const definition = seriesDefinition({
|
||||
id: 'series-unfinishable',
|
||||
stage: 'upper',
|
||||
rule: { type: 'first-to', winsRequired: 2, maxGames: 2 },
|
||||
});
|
||||
|
||||
expectInvariant(
|
||||
() =>
|
||||
projectSeries({
|
||||
definition,
|
||||
participants: ['team-8', 'team-3'],
|
||||
facts: [],
|
||||
}),
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
function seriesDefinition(params: {
|
||||
id: string;
|
||||
stage: 'pair' | 'upper';
|
||||
rule:
|
||||
| {
|
||||
type: 'fixed-games';
|
||||
gameCount: number;
|
||||
drawPolicy: 'allow';
|
||||
}
|
||||
| { type: 'first-to'; winsRequired: number; maxGames: number };
|
||||
}) {
|
||||
const gameCount =
|
||||
params.rule.type === 'fixed-games'
|
||||
? params.rule.gameCount
|
||||
: params.rule.maxGames;
|
||||
return {
|
||||
id: params.id,
|
||||
code: params.id,
|
||||
stage: { type: params.stage, displayOrder: 1 },
|
||||
slots: [
|
||||
{
|
||||
position: 'A' as const,
|
||||
source: { type: 'team' as const, teamId: 'team-8' },
|
||||
},
|
||||
{
|
||||
position: 'B' as const,
|
||||
source: { type: 'team' as const, teamId: 'team-3' },
|
||||
},
|
||||
],
|
||||
rule: params.rule,
|
||||
gameSlots: Array.from({ length: gameCount }, (_, index) => ({
|
||||
id: `${params.id}-slot-${index + 1}`,
|
||||
seriesId: params.id,
|
||||
ordinal: index + 1,
|
||||
})),
|
||||
};
|
||||
}
|
||||
|
||||
function acceptedGame(params: {
|
||||
definition: ReturnType<typeof seriesDefinition>;
|
||||
ordinal: number;
|
||||
blueTeamId: string;
|
||||
redTeamId: string;
|
||||
winnerTeamId: string;
|
||||
}) {
|
||||
const gameSlot = params.definition.gameSlots.find(
|
||||
(slot) => slot.ordinal === params.ordinal,
|
||||
);
|
||||
if (!gameSlot) throw new Error(`Missing game slot ${params.ordinal}`);
|
||||
|
||||
return {
|
||||
id: `fact-${params.definition.id}-${params.ordinal}`,
|
||||
type: 'game-accepted' as const,
|
||||
competitionId: 'competition-series-projector',
|
||||
revision: params.ordinal,
|
||||
ordinalWithinRevision: 1,
|
||||
commandId: `command-${params.definition.id}-${params.ordinal}`,
|
||||
schemaVersion: 1,
|
||||
actor: { type: 'system' as const },
|
||||
occurredAt: new Date(`2026-07-12T00:0${params.ordinal}:00.000Z`),
|
||||
recordedAt: new Date(`2026-07-12T00:0${params.ordinal}:01.000Z`),
|
||||
gameId: `game-${params.definition.id}-${params.ordinal}`,
|
||||
seriesId: params.definition.id,
|
||||
gameSlotId: gameSlot.id,
|
||||
ordinal: params.ordinal,
|
||||
evidence: {
|
||||
type: 'riot' as const,
|
||||
riotMatchId: `KR_${params.definition.id}_${params.ordinal}`,
|
||||
payloadHash: `sha256:${params.definition.id}:${params.ordinal}`,
|
||||
},
|
||||
mapping: {
|
||||
mappingVersion: 1,
|
||||
confidence: 1,
|
||||
blueTeamId: params.blueTeamId,
|
||||
redTeamId: params.redTeamId,
|
||||
winnerTeamId: params.winnerTeamId,
|
||||
participantAssignments: [],
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function expectInvariant(action: () => unknown, code: string) {
|
||||
try {
|
||||
action();
|
||||
throw new Error(`Expected invariant ${code}`);
|
||||
} catch (error) {
|
||||
expect(error).toMatchObject({ code });
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,866 @@
|
||||
import {
|
||||
assertCompetitionInvariant,
|
||||
CompetitionDomainError,
|
||||
} from './domain-error';
|
||||
|
||||
export type SeriesSlot = 'A' | 'B';
|
||||
|
||||
export type SeriesRule =
|
||||
| { type: 'first-to'; winsRequired: number; maxGames: number }
|
||||
| {
|
||||
type: 'fixed-games';
|
||||
gameCount: number;
|
||||
drawPolicy: 'allow' | 'tiebreak-required';
|
||||
};
|
||||
|
||||
export interface SeriesSchedule {
|
||||
date: string;
|
||||
time: string | null;
|
||||
timeZone: 'Asia/Seoul';
|
||||
}
|
||||
|
||||
export interface SeriesDefinitionLike {
|
||||
id: string;
|
||||
code?: string;
|
||||
stage: {
|
||||
type: string;
|
||||
roundNumber?: number;
|
||||
displayOrder: number;
|
||||
};
|
||||
slots: ReadonlyArray<{
|
||||
position: SeriesSlot;
|
||||
source: Readonly<Record<string, unknown>>;
|
||||
}>;
|
||||
rule: SeriesRule;
|
||||
schedule?: SeriesSchedule;
|
||||
gameSlots: ReadonlyArray<{
|
||||
id: string;
|
||||
seriesId: string;
|
||||
ordinal: number;
|
||||
}>;
|
||||
}
|
||||
|
||||
export interface ProjectSeriesInput {
|
||||
definition: SeriesDefinitionLike;
|
||||
participants: readonly (string | null | undefined)[];
|
||||
facts: readonly unknown[];
|
||||
/** A stable conditional node can exist before it is eligible for play. */
|
||||
active?: boolean;
|
||||
}
|
||||
|
||||
export interface SeriesProjectionEntry {
|
||||
slot: SeriesSlot;
|
||||
teamId: string | null;
|
||||
gameWins: number;
|
||||
}
|
||||
|
||||
export type SeriesProjectionOutcome =
|
||||
| {
|
||||
type: 'played';
|
||||
winnerTeamId: string;
|
||||
loserTeamId: string;
|
||||
decidedByGameIds: string[];
|
||||
completedAt: string;
|
||||
}
|
||||
| {
|
||||
type: 'draw';
|
||||
basis:
|
||||
| { type: 'played'; decidedByGameIds: string[] }
|
||||
| { type: 'administrative'; decisionFactId: string };
|
||||
completedAt: string;
|
||||
}
|
||||
| {
|
||||
type: 'walkover' | 'forfeit' | 'administrative';
|
||||
winnerTeamId: string;
|
||||
loserTeamId: string;
|
||||
decisionFactId: string;
|
||||
completedAt: string;
|
||||
};
|
||||
|
||||
interface SeriesProjectionBase {
|
||||
seriesId: string;
|
||||
code?: string;
|
||||
stage: SeriesDefinitionLike['stage'];
|
||||
rule: SeriesRule;
|
||||
schedule?: SeriesSchedule;
|
||||
entries: [SeriesProjectionEntry, SeriesProjectionEntry];
|
||||
}
|
||||
|
||||
export type SeriesProjection = SeriesProjectionBase &
|
||||
(
|
||||
| { status: 'inactive' | 'waiting' | 'ready' }
|
||||
| { status: 'in-progress'; leaderTeamId?: string }
|
||||
| { status: 'completed'; outcome: SeriesProjectionOutcome }
|
||||
);
|
||||
|
||||
interface FactBase {
|
||||
id: string;
|
||||
type: string;
|
||||
revision: number;
|
||||
ordinalWithinRevision: number;
|
||||
occurredAt: Date | string;
|
||||
recordedAt?: Date | string;
|
||||
}
|
||||
|
||||
interface GameAcceptedFact extends FactBase {
|
||||
type: 'game-accepted';
|
||||
gameId: string;
|
||||
seriesId: string;
|
||||
gameSlotId: string;
|
||||
ordinal: number;
|
||||
evidence?: {
|
||||
type?: string;
|
||||
riotMatchId?: string;
|
||||
};
|
||||
mapping: {
|
||||
blueTeamId: string;
|
||||
redTeamId: string;
|
||||
winnerTeamId: string;
|
||||
};
|
||||
}
|
||||
|
||||
interface GameVoidedFact extends FactBase {
|
||||
type: 'game-voided';
|
||||
gameAcceptedFactId: string;
|
||||
reason?: string;
|
||||
}
|
||||
|
||||
interface SeriesAdjudicatedFact extends FactBase {
|
||||
type: 'series-adjudicated';
|
||||
seriesId: string;
|
||||
decision:
|
||||
| { type: 'walkover' | 'forfeit' | 'administrative'; winnerTeamId: string }
|
||||
| { type: 'administrative-draw' };
|
||||
reason: string;
|
||||
}
|
||||
|
||||
interface AdjudicationReversedFact extends FactBase {
|
||||
type: 'adjudication-reversed';
|
||||
adjudicationFactId: string;
|
||||
reason?: string;
|
||||
}
|
||||
|
||||
type CompetitionFact =
|
||||
| GameAcceptedFact
|
||||
| GameVoidedFact
|
||||
| SeriesAdjudicatedFact
|
||||
| AdjudicationReversedFact;
|
||||
|
||||
interface PlayedState {
|
||||
activeGames: GameAcceptedFact[];
|
||||
winsByTeam: Map<string, number>;
|
||||
completed: boolean;
|
||||
}
|
||||
|
||||
/** Project one Series exclusively from its definition, resolved participants and fact ledger. */
|
||||
export function projectSeries(input: ProjectSeriesInput): SeriesProjection {
|
||||
validateDefinition(input.definition);
|
||||
const participants = normalizeParticipants(input.participants);
|
||||
const facts = normalizeFacts(input.facts);
|
||||
const base = projectionBase(input.definition, participants);
|
||||
|
||||
if (input.active === false) {
|
||||
assertNoSeriesActivity(input.definition.id, facts);
|
||||
return { ...base, status: 'inactive' };
|
||||
}
|
||||
|
||||
if (participants.some((teamId) => teamId === null)) {
|
||||
assertNoSeriesActivity(input.definition.id, facts);
|
||||
return { ...base, status: 'waiting' };
|
||||
}
|
||||
|
||||
const resolvedParticipants = participants as [string, string];
|
||||
const relevantFacts = selectRelevantFacts(input.definition.id, facts);
|
||||
const activeGames = new Map<string, GameAcceptedFact>();
|
||||
const voidedGameFacts = new Set<string>();
|
||||
const adjudications = new Map<string, SeriesAdjudicatedFact>();
|
||||
const reversedAdjudications = new Set<string>();
|
||||
let activeAdjudication: SeriesAdjudicatedFact | undefined;
|
||||
|
||||
for (const fact of relevantFacts) {
|
||||
switch (fact.type) {
|
||||
case 'game-accepted': {
|
||||
assertCompetitionInvariant(
|
||||
activeAdjudication === undefined &&
|
||||
!derivePlayedState(
|
||||
input.definition.rule,
|
||||
[...activeGames.values()],
|
||||
resolvedParticipants,
|
||||
).completed,
|
||||
'SERIES_ALREADY_COMPLETED',
|
||||
`Series ${input.definition.id} was already completed before game ${fact.gameId}`,
|
||||
{ seriesId: input.definition.id, factId: fact.id },
|
||||
);
|
||||
validateAcceptedGame(input.definition, resolvedParticipants, fact);
|
||||
validateActiveGameUniqueness(activeGames.values(), fact);
|
||||
activeGames.set(fact.id, fact);
|
||||
break;
|
||||
}
|
||||
case 'game-voided': {
|
||||
const accepted = facts.find(
|
||||
(candidate): candidate is GameAcceptedFact =>
|
||||
candidate.type === 'game-accepted' &&
|
||||
candidate.id === fact.gameAcceptedFactId,
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
accepted !== undefined,
|
||||
'FACT_REFERENCE_NOT_FOUND',
|
||||
`Voided game fact ${fact.gameAcceptedFactId} does not exist`,
|
||||
{ factId: fact.id, referencedFactId: fact.gameAcceptedFactId },
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
activeGames.has(accepted.id) && !voidedGameFacts.has(accepted.id),
|
||||
'FACT_ALREADY_REVERSED',
|
||||
`Game fact ${accepted.id} is already voided`,
|
||||
{ factId: fact.id, referencedFactId: accepted.id },
|
||||
);
|
||||
activeGames.delete(accepted.id);
|
||||
voidedGameFacts.add(accepted.id);
|
||||
break;
|
||||
}
|
||||
case 'series-adjudicated': {
|
||||
const played = derivePlayedState(
|
||||
input.definition.rule,
|
||||
[...activeGames.values()],
|
||||
resolvedParticipants,
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
!played.completed && activeAdjudication === undefined,
|
||||
activeAdjudication
|
||||
? 'DUPLICATE_ADJUDICATION'
|
||||
: 'SERIES_ALREADY_COMPLETED',
|
||||
`Series ${input.definition.id} already has an official outcome`,
|
||||
{ seriesId: input.definition.id, factId: fact.id },
|
||||
);
|
||||
validateAdjudication(
|
||||
input.definition,
|
||||
resolvedParticipants,
|
||||
played.activeGames,
|
||||
fact,
|
||||
);
|
||||
adjudications.set(fact.id, fact);
|
||||
activeAdjudication = fact;
|
||||
break;
|
||||
}
|
||||
case 'adjudication-reversed': {
|
||||
const adjudication = adjudications.get(fact.adjudicationFactId);
|
||||
assertCompetitionInvariant(
|
||||
adjudication !== undefined,
|
||||
'FACT_REFERENCE_NOT_FOUND',
|
||||
`Adjudication fact ${fact.adjudicationFactId} does not exist or is not active in this Series`,
|
||||
{ factId: fact.id, referencedFactId: fact.adjudicationFactId },
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
!reversedAdjudications.has(adjudication.id) &&
|
||||
activeAdjudication?.id === adjudication.id,
|
||||
'FACT_ALREADY_REVERSED',
|
||||
`Adjudication fact ${adjudication.id} is already reversed`,
|
||||
{ factId: fact.id, referencedFactId: adjudication.id },
|
||||
);
|
||||
reversedAdjudications.add(adjudication.id);
|
||||
activeAdjudication = undefined;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const played = derivePlayedState(
|
||||
input.definition.rule,
|
||||
[...activeGames.values()],
|
||||
resolvedParticipants,
|
||||
);
|
||||
const entries = entriesFor(resolvedParticipants, played.winsByTeam);
|
||||
const projectedBase = { ...base, entries };
|
||||
|
||||
if (activeAdjudication) {
|
||||
return {
|
||||
...projectedBase,
|
||||
status: 'completed',
|
||||
outcome: adjudicatedOutcome(activeAdjudication, resolvedParticipants),
|
||||
};
|
||||
}
|
||||
|
||||
if (played.completed) {
|
||||
return {
|
||||
...projectedBase,
|
||||
status: 'completed',
|
||||
outcome: playedOutcome(
|
||||
input.definition.rule,
|
||||
played.activeGames,
|
||||
resolvedParticipants,
|
||||
played.winsByTeam,
|
||||
),
|
||||
};
|
||||
}
|
||||
|
||||
if (played.activeGames.length === 0) {
|
||||
return { ...projectedBase, status: 'ready' };
|
||||
}
|
||||
|
||||
const leaderTeamId = deriveLeader(resolvedParticipants, played.winsByTeam);
|
||||
return {
|
||||
...projectedBase,
|
||||
status: 'in-progress',
|
||||
...(leaderTeamId ? { leaderTeamId } : {}),
|
||||
};
|
||||
}
|
||||
|
||||
function validateDefinition(definition: SeriesDefinitionLike): void {
|
||||
assertCompetitionInvariant(
|
||||
typeof definition.id === 'string' && definition.id.length > 0,
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
'A Series must have an opaque id',
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
definition.slots.length === 2 &&
|
||||
definition.slots[0]?.position === 'A' &&
|
||||
definition.slots[1]?.position === 'B',
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
`Series ${definition.id} must define exactly the local A and B slots`,
|
||||
);
|
||||
|
||||
const schedule: unknown = definition.schedule;
|
||||
if (schedule !== undefined) {
|
||||
assertCompetitionInvariant(
|
||||
isSeriesSchedule(schedule),
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
`Series ${definition.id} has an invalid schedule`,
|
||||
);
|
||||
}
|
||||
|
||||
const requiredSlots =
|
||||
definition.rule.type === 'fixed-games'
|
||||
? definition.rule.gameCount
|
||||
: definition.rule.maxGames;
|
||||
assertCompetitionInvariant(
|
||||
Number.isInteger(requiredSlots) && requiredSlots > 0,
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
`Series ${definition.id} has an invalid game count`,
|
||||
);
|
||||
if (definition.rule.type === 'first-to') {
|
||||
assertCompetitionInvariant(
|
||||
Number.isInteger(definition.rule.winsRequired) &&
|
||||
definition.rule.winsRequired > 0 &&
|
||||
definition.rule.maxGames >= definition.rule.winsRequired * 2 - 1,
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
`Series ${definition.id} has an invalid first-to threshold`,
|
||||
);
|
||||
}
|
||||
assertCompetitionInvariant(
|
||||
definition.gameSlots.length === requiredSlots,
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
`Series ${definition.id} must predefine every GameSlot`,
|
||||
);
|
||||
|
||||
const ids = new Set<string>();
|
||||
const ordinals = new Set<number>();
|
||||
for (const slot of definition.gameSlots) {
|
||||
assertCompetitionInvariant(
|
||||
slot.seriesId === definition.id &&
|
||||
typeof slot.id === 'string' &&
|
||||
slot.id.length > 0,
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
`GameSlot ${slot.id} does not belong to Series ${definition.id}`,
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
Number.isInteger(slot.ordinal) &&
|
||||
slot.ordinal >= 1 &&
|
||||
slot.ordinal <= requiredSlots,
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
`GameSlot ${slot.id} has an invalid ordinal`,
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
!ids.has(slot.id) && !ordinals.has(slot.ordinal),
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
`Series ${definition.id} has duplicate GameSlot identity or ordinal`,
|
||||
);
|
||||
ids.add(slot.id);
|
||||
ordinals.add(slot.ordinal);
|
||||
}
|
||||
}
|
||||
|
||||
function normalizeParticipants(
|
||||
participants: readonly (string | null | undefined)[],
|
||||
): [string | null, string | null] {
|
||||
assertCompetitionInvariant(
|
||||
participants.length === 2,
|
||||
'SERIES_PARTICIPANTS_INVALID',
|
||||
'A Series projection requires exactly two participant slots',
|
||||
);
|
||||
const normalized = participants.map((teamId) => teamId ?? null) as [
|
||||
string | null,
|
||||
string | null,
|
||||
];
|
||||
for (const teamId of normalized) {
|
||||
assertCompetitionInvariant(
|
||||
teamId === null || (typeof teamId === 'string' && teamId.length > 0),
|
||||
'SERIES_PARTICIPANTS_INVALID',
|
||||
'Resolved participant ids must be opaque non-empty strings',
|
||||
);
|
||||
}
|
||||
assertCompetitionInvariant(
|
||||
normalized[0] === null ||
|
||||
normalized[1] === null ||
|
||||
normalized[0] !== normalized[1],
|
||||
'SERIES_PARTICIPANTS_INVALID',
|
||||
'A team cannot occupy both Series slots',
|
||||
);
|
||||
return normalized;
|
||||
}
|
||||
|
||||
function normalizeFacts(facts: readonly unknown[]): CompetitionFact[] {
|
||||
const normalized = facts.map(normalizeFact).sort(compareFacts);
|
||||
const factIds = new Set<string>();
|
||||
const gameIds = new Set<string>();
|
||||
const riotMatchIds = new Set<string>();
|
||||
|
||||
for (const fact of normalized) {
|
||||
assertCompetitionInvariant(
|
||||
!factIds.has(fact.id),
|
||||
'DUPLICATE_FACT_ID',
|
||||
`Duplicate fact id ${fact.id}`,
|
||||
{ factId: fact.id },
|
||||
);
|
||||
factIds.add(fact.id);
|
||||
|
||||
if (fact.type === 'game-accepted') {
|
||||
assertCompetitionInvariant(
|
||||
!gameIds.has(fact.gameId),
|
||||
'DUPLICATE_GAME_ID',
|
||||
`Duplicate game id ${fact.gameId}`,
|
||||
{ gameId: fact.gameId },
|
||||
);
|
||||
gameIds.add(fact.gameId);
|
||||
const riotMatchId = fact.evidence?.riotMatchId;
|
||||
if (fact.evidence?.type === 'riot' && riotMatchId) {
|
||||
assertCompetitionInvariant(
|
||||
!riotMatchIds.has(riotMatchId),
|
||||
'DUPLICATE_RIOT_MATCH_ID',
|
||||
`Riot match ${riotMatchId} was accepted more than once`,
|
||||
{ riotMatchId },
|
||||
);
|
||||
riotMatchIds.add(riotMatchId);
|
||||
}
|
||||
}
|
||||
}
|
||||
return normalized;
|
||||
}
|
||||
|
||||
function normalizeFact(value: unknown): CompetitionFact {
|
||||
assertCompetitionInvariant(
|
||||
isRecord(value) &&
|
||||
typeof value.id === 'string' &&
|
||||
typeof value.type === 'string' &&
|
||||
Number.isFinite(value.revision) &&
|
||||
Number.isFinite(value.ordinalWithinRevision),
|
||||
'FACT_TYPE_INVALID',
|
||||
'Competition facts require identity and ledger ordering fields',
|
||||
);
|
||||
|
||||
switch (value.type) {
|
||||
case 'game-accepted':
|
||||
case 'game-voided':
|
||||
case 'series-adjudicated':
|
||||
case 'adjudication-reversed':
|
||||
return value as unknown as CompetitionFact;
|
||||
default:
|
||||
throw new CompetitionDomainError(
|
||||
'FACT_TYPE_INVALID',
|
||||
`Unsupported Competition fact type ${value.type}`,
|
||||
{ factType: value.type },
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function selectRelevantFacts(
|
||||
seriesId: string,
|
||||
facts: CompetitionFact[],
|
||||
): CompetitionFact[] {
|
||||
const acceptedSeriesById = new Map(
|
||||
facts
|
||||
.filter((fact): fact is GameAcceptedFact => fact.type === 'game-accepted')
|
||||
.map((fact) => [fact.id, fact.seriesId]),
|
||||
);
|
||||
const adjudicationSeriesById = new Map(
|
||||
facts
|
||||
.filter(
|
||||
(fact): fact is SeriesAdjudicatedFact =>
|
||||
fact.type === 'series-adjudicated',
|
||||
)
|
||||
.map((fact) => [fact.id, fact.seriesId]),
|
||||
);
|
||||
|
||||
return facts.filter((fact) => {
|
||||
switch (fact.type) {
|
||||
case 'game-accepted':
|
||||
case 'series-adjudicated':
|
||||
return fact.seriesId === seriesId;
|
||||
case 'game-voided': {
|
||||
const targetSeriesId = acceptedSeriesById.get(fact.gameAcceptedFactId);
|
||||
assertCompetitionInvariant(
|
||||
targetSeriesId !== undefined,
|
||||
'FACT_REFERENCE_NOT_FOUND',
|
||||
`Voided game fact ${fact.gameAcceptedFactId} does not exist`,
|
||||
{ factId: fact.id, referencedFactId: fact.gameAcceptedFactId },
|
||||
);
|
||||
return targetSeriesId === seriesId;
|
||||
}
|
||||
case 'adjudication-reversed': {
|
||||
const targetSeriesId = adjudicationSeriesById.get(
|
||||
fact.adjudicationFactId,
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
targetSeriesId !== undefined,
|
||||
'FACT_REFERENCE_NOT_FOUND',
|
||||
`Adjudication fact ${fact.adjudicationFactId} does not exist`,
|
||||
{ factId: fact.id, referencedFactId: fact.adjudicationFactId },
|
||||
);
|
||||
return targetSeriesId === seriesId;
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function assertNoSeriesActivity(
|
||||
seriesId: string,
|
||||
facts: CompetitionFact[],
|
||||
): void {
|
||||
const acceptedSeriesById = new Map(
|
||||
facts
|
||||
.filter((fact): fact is GameAcceptedFact => fact.type === 'game-accepted')
|
||||
.map((fact) => [fact.id, fact.seriesId]),
|
||||
);
|
||||
const adjudicationSeriesById = new Map(
|
||||
facts
|
||||
.filter(
|
||||
(fact): fact is SeriesAdjudicatedFact =>
|
||||
fact.type === 'series-adjudicated',
|
||||
)
|
||||
.map((fact) => [fact.id, fact.seriesId]),
|
||||
);
|
||||
const activeGames = new Set<string>();
|
||||
const activeAdjudications = new Set<string>();
|
||||
|
||||
for (const fact of facts) {
|
||||
switch (fact.type) {
|
||||
case 'game-accepted':
|
||||
if (fact.seriesId === seriesId) activeGames.add(fact.id);
|
||||
break;
|
||||
case 'game-voided':
|
||||
if (acceptedSeriesById.get(fact.gameAcceptedFactId) === seriesId) {
|
||||
assertCompetitionInvariant(
|
||||
activeGames.delete(fact.gameAcceptedFactId),
|
||||
'FACT_ALREADY_REVERSED',
|
||||
`Game fact ${fact.gameAcceptedFactId} is already voided`,
|
||||
{ factId: fact.id, referencedFactId: fact.gameAcceptedFactId },
|
||||
);
|
||||
}
|
||||
break;
|
||||
case 'series-adjudicated':
|
||||
if (fact.seriesId === seriesId) activeAdjudications.add(fact.id);
|
||||
break;
|
||||
case 'adjudication-reversed':
|
||||
if (adjudicationSeriesById.get(fact.adjudicationFactId) === seriesId) {
|
||||
assertCompetitionInvariant(
|
||||
activeAdjudications.delete(fact.adjudicationFactId),
|
||||
'FACT_ALREADY_REVERSED',
|
||||
`Adjudication fact ${fact.adjudicationFactId} is already reversed`,
|
||||
{ factId: fact.id, referencedFactId: fact.adjudicationFactId },
|
||||
);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
assertCompetitionInvariant(
|
||||
activeGames.size === 0 && activeAdjudications.size === 0,
|
||||
'SERIES_PARTICIPANTS_INVALID',
|
||||
`Series ${seriesId} cannot contain facts before both participants are active`,
|
||||
{ seriesId },
|
||||
);
|
||||
}
|
||||
|
||||
function validateAcceptedGame(
|
||||
definition: SeriesDefinitionLike,
|
||||
participants: [string, string],
|
||||
fact: GameAcceptedFact,
|
||||
): void {
|
||||
assertCompetitionInvariant(
|
||||
fact.seriesId === definition.id,
|
||||
'GAME_SERIES_MISMATCH',
|
||||
`Game ${fact.gameId} targets a different Series`,
|
||||
);
|
||||
const slot = definition.gameSlots.find(
|
||||
(candidate) => candidate.id === fact.gameSlotId,
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
slot !== undefined,
|
||||
'GAME_SLOT_INVALID',
|
||||
`Game ${fact.gameId} targets an unknown GameSlot`,
|
||||
{ gameId: fact.gameId, gameSlotId: fact.gameSlotId },
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
slot.ordinal === fact.ordinal,
|
||||
'GAME_ORDINAL_INVALID',
|
||||
`Game ${fact.gameId} ordinal does not match its GameSlot`,
|
||||
{ gameId: fact.gameId, ordinal: fact.ordinal },
|
||||
);
|
||||
|
||||
const { blueTeamId, redTeamId, winnerTeamId } = fact.mapping;
|
||||
const expectedTeams = new Set(participants);
|
||||
const actualTeams = new Set([blueTeamId, redTeamId]);
|
||||
assertCompetitionInvariant(
|
||||
actualTeams.size === 2 &&
|
||||
expectedTeams.size === actualTeams.size &&
|
||||
[...expectedTeams].every((teamId) => actualTeams.has(teamId)),
|
||||
'GAME_TEAM_MISMATCH',
|
||||
`Game ${fact.gameId} teams do not match Series ${definition.id}`,
|
||||
{
|
||||
gameId: fact.gameId,
|
||||
expectedTeamIds: participants,
|
||||
actualTeamIds: [blueTeamId, redTeamId],
|
||||
},
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
winnerTeamId === blueTeamId || winnerTeamId === redTeamId,
|
||||
'GAME_WINNER_INVALID',
|
||||
`Game ${fact.gameId} winner is not a participant`,
|
||||
{ gameId: fact.gameId, winnerTeamId },
|
||||
);
|
||||
}
|
||||
|
||||
function validateActiveGameUniqueness(
|
||||
activeGames: Iterable<GameAcceptedFact>,
|
||||
fact: GameAcceptedFact,
|
||||
): void {
|
||||
for (const active of activeGames) {
|
||||
assertCompetitionInvariant(
|
||||
active.gameSlotId !== fact.gameSlotId,
|
||||
'DUPLICATE_GAME_SLOT',
|
||||
`GameSlot ${fact.gameSlotId} already has an accepted game`,
|
||||
{ gameSlotId: fact.gameSlotId },
|
||||
);
|
||||
assertCompetitionInvariant(
|
||||
active.ordinal !== fact.ordinal,
|
||||
'DUPLICATE_GAME_ORDINAL',
|
||||
`Series ordinal ${fact.ordinal} already has an accepted game`,
|
||||
{ ordinal: fact.ordinal },
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function validateAdjudication(
|
||||
definition: SeriesDefinitionLike,
|
||||
participants: [string, string],
|
||||
activeGames: GameAcceptedFact[],
|
||||
fact: SeriesAdjudicatedFact,
|
||||
): void {
|
||||
assertCompetitionInvariant(
|
||||
typeof fact.reason === 'string' && fact.reason.trim().length > 0,
|
||||
'ADJUDICATION_INVALID',
|
||||
`Adjudication ${fact.id} requires a reason`,
|
||||
);
|
||||
if (fact.decision.type === 'administrative-draw') {
|
||||
assertCompetitionInvariant(
|
||||
definition.rule.type === 'fixed-games' &&
|
||||
definition.rule.drawPolicy === 'allow',
|
||||
'ADJUDICATION_DRAW_NOT_ALLOWED',
|
||||
`Series ${definition.id} cannot be adjudicated as a draw`,
|
||||
);
|
||||
return;
|
||||
}
|
||||
assertCompetitionInvariant(
|
||||
participants.includes(fact.decision.winnerTeamId),
|
||||
'ADJUDICATION_INVALID',
|
||||
`Adjudication winner is not a Series participant`,
|
||||
);
|
||||
if (fact.decision.type === 'walkover') {
|
||||
assertCompetitionInvariant(
|
||||
activeGames.length === 0,
|
||||
'WALKOVER_HAS_ACTIVE_GAMES',
|
||||
`Walkover Series ${definition.id} cannot retain played games`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function derivePlayedState(
|
||||
rule: SeriesRule,
|
||||
games: GameAcceptedFact[],
|
||||
participants: [string, string],
|
||||
): PlayedState {
|
||||
const activeGames = [...games].sort(compareGames);
|
||||
const winsByTeam = new Map(participants.map((teamId) => [teamId, 0]));
|
||||
for (const game of activeGames) {
|
||||
const winnerTeamId = game.mapping.winnerTeamId;
|
||||
winsByTeam.set(winnerTeamId, (winsByTeam.get(winnerTeamId) ?? 0) + 1);
|
||||
}
|
||||
const completed =
|
||||
rule.type === 'fixed-games'
|
||||
? activeGames.length === rule.gameCount
|
||||
: participants.some(
|
||||
(teamId) => (winsByTeam.get(teamId) ?? 0) >= rule.winsRequired,
|
||||
);
|
||||
return { activeGames, winsByTeam, completed };
|
||||
}
|
||||
|
||||
function playedOutcome(
|
||||
rule: SeriesRule,
|
||||
activeGames: GameAcceptedFact[],
|
||||
participants: [string, string],
|
||||
winsByTeam: Map<string, number>,
|
||||
): SeriesProjectionOutcome {
|
||||
const decidedByGameIds = activeGames.map((game) => game.gameId);
|
||||
const completedAt = toIsoString(activeGames.at(-1)!.occurredAt);
|
||||
const [teamAId, teamBId] = participants;
|
||||
const teamAWins = winsByTeam.get(teamAId) ?? 0;
|
||||
const teamBWins = winsByTeam.get(teamBId) ?? 0;
|
||||
|
||||
if (teamAWins === teamBWins) {
|
||||
assertCompetitionInvariant(
|
||||
rule.type === 'fixed-games' && rule.drawPolicy === 'allow',
|
||||
'SERIES_DEFINITION_INVALID',
|
||||
'This Series completed tied but its rule requires a winner',
|
||||
);
|
||||
return {
|
||||
type: 'draw',
|
||||
basis: { type: 'played', decidedByGameIds },
|
||||
completedAt,
|
||||
};
|
||||
}
|
||||
|
||||
const winnerTeamId = teamAWins > teamBWins ? teamAId : teamBId;
|
||||
return {
|
||||
type: 'played',
|
||||
winnerTeamId,
|
||||
loserTeamId: winnerTeamId === teamAId ? teamBId : teamAId,
|
||||
decidedByGameIds,
|
||||
completedAt,
|
||||
};
|
||||
}
|
||||
|
||||
function adjudicatedOutcome(
|
||||
fact: SeriesAdjudicatedFact,
|
||||
participants: [string, string],
|
||||
): SeriesProjectionOutcome {
|
||||
const completedAt = toIsoString(fact.occurredAt);
|
||||
if (fact.decision.type === 'administrative-draw') {
|
||||
return {
|
||||
type: 'draw',
|
||||
basis: { type: 'administrative', decisionFactId: fact.id },
|
||||
completedAt,
|
||||
};
|
||||
}
|
||||
const winnerTeamId = fact.decision.winnerTeamId;
|
||||
return {
|
||||
type: fact.decision.type,
|
||||
winnerTeamId,
|
||||
loserTeamId:
|
||||
participants[0] === winnerTeamId ? participants[1] : participants[0],
|
||||
decisionFactId: fact.id,
|
||||
completedAt,
|
||||
};
|
||||
}
|
||||
|
||||
function projectionBase(
|
||||
definition: SeriesDefinitionLike,
|
||||
participants: [string | null, string | null],
|
||||
): SeriesProjectionBase {
|
||||
return {
|
||||
seriesId: definition.id,
|
||||
...(definition.code ? { code: definition.code } : {}),
|
||||
stage: definition.stage,
|
||||
rule: definition.rule,
|
||||
...(definition.schedule ? { schedule: { ...definition.schedule } } : {}),
|
||||
entries: [
|
||||
{ slot: 'A', teamId: participants[0], gameWins: 0 },
|
||||
{ slot: 'B', teamId: participants[1], gameWins: 0 },
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
function isValidLocalDate(value: string): boolean {
|
||||
const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
|
||||
if (!match) return false;
|
||||
const year = Number(match[1]);
|
||||
const month = Number(match[2]);
|
||||
const day = Number(match[3]);
|
||||
const date = new Date(Date.UTC(year, month - 1, day));
|
||||
return (
|
||||
date.getUTCFullYear() === year &&
|
||||
date.getUTCMonth() === month - 1 &&
|
||||
date.getUTCDate() === day
|
||||
);
|
||||
}
|
||||
|
||||
function isSeriesSchedule(value: unknown): value is SeriesSchedule {
|
||||
if (typeof value !== 'object' || value === null || Array.isArray(value)) {
|
||||
return false;
|
||||
}
|
||||
const schedule = value as Record<string, unknown>;
|
||||
return (
|
||||
typeof schedule.date === 'string' &&
|
||||
isValidLocalDate(schedule.date) &&
|
||||
(schedule.time === null ||
|
||||
(typeof schedule.time === 'string' &&
|
||||
/^(?:[01]\d|2[0-3]):[0-5]\d$/.test(schedule.time))) &&
|
||||
schedule.timeZone === 'Asia/Seoul'
|
||||
);
|
||||
}
|
||||
|
||||
function entriesFor(
|
||||
participants: [string, string],
|
||||
winsByTeam: Map<string, number>,
|
||||
): [SeriesProjectionEntry, SeriesProjectionEntry] {
|
||||
return [
|
||||
{
|
||||
slot: 'A',
|
||||
teamId: participants[0],
|
||||
gameWins: winsByTeam.get(participants[0]) ?? 0,
|
||||
},
|
||||
{
|
||||
slot: 'B',
|
||||
teamId: participants[1],
|
||||
gameWins: winsByTeam.get(participants[1]) ?? 0,
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
function deriveLeader(
|
||||
participants: [string, string],
|
||||
winsByTeam: Map<string, number>,
|
||||
): string | undefined {
|
||||
const firstWins = winsByTeam.get(participants[0]) ?? 0;
|
||||
const secondWins = winsByTeam.get(participants[1]) ?? 0;
|
||||
if (firstWins === secondWins) return undefined;
|
||||
return firstWins > secondWins ? participants[0] : participants[1];
|
||||
}
|
||||
|
||||
function compareFacts(left: CompetitionFact, right: CompetitionFact): number {
|
||||
return (
|
||||
left.revision - right.revision ||
|
||||
left.ordinalWithinRevision - right.ordinalWithinRevision ||
|
||||
left.id.localeCompare(right.id)
|
||||
);
|
||||
}
|
||||
|
||||
function compareGames(left: GameAcceptedFact, right: GameAcceptedFact): number {
|
||||
return (
|
||||
left.ordinal - right.ordinal ||
|
||||
left.revision - right.revision ||
|
||||
left.id.localeCompare(right.id)
|
||||
);
|
||||
}
|
||||
|
||||
function toIsoString(value: Date | string): string {
|
||||
const date = value instanceof Date ? value : new Date(value);
|
||||
assertCompetitionInvariant(
|
||||
!Number.isNaN(date.getTime()),
|
||||
'FACT_TYPE_INVALID',
|
||||
'Fact timestamps must be valid dates',
|
||||
);
|
||||
return date.toISOString();
|
||||
}
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return typeof value === 'object' && value !== null;
|
||||
}
|
||||
@@ -0,0 +1,178 @@
|
||||
import { Type } from 'class-transformer';
|
||||
import {
|
||||
IsEnum,
|
||||
IsArray,
|
||||
IsDate,
|
||||
IsInt,
|
||||
IsMongoId,
|
||||
IsNumber,
|
||||
IsObject,
|
||||
IsOptional,
|
||||
IsString,
|
||||
Matches,
|
||||
Max,
|
||||
MaxLength,
|
||||
Min,
|
||||
MinLength,
|
||||
ValidateIf,
|
||||
ValidateNested,
|
||||
} from 'class-validator';
|
||||
|
||||
const ADJUDICATION_TYPES = [
|
||||
'walkover',
|
||||
'forfeit',
|
||||
'administrative',
|
||||
'administrative-draw',
|
||||
] as const;
|
||||
const REVERSAL_MODES = ['strict', 'cascade'] as const;
|
||||
const EVIDENCE_TYPES = ['riot', 'legacy'] as const;
|
||||
|
||||
export class CompetitionGameEvidenceDto {
|
||||
@IsEnum(EVIDENCE_TYPES)
|
||||
type!: (typeof EVIDENCE_TYPES)[number];
|
||||
|
||||
@ValidateIf(({ type }) => type === 'riot')
|
||||
@IsString()
|
||||
@MinLength(1)
|
||||
@MaxLength(128)
|
||||
riotMatchId?: string;
|
||||
|
||||
@ValidateIf(({ type }) => type === 'riot')
|
||||
@IsString()
|
||||
@MinLength(1)
|
||||
@MaxLength(256)
|
||||
payloadHash?: string;
|
||||
|
||||
@ValidateIf(({ type }) => type === 'legacy')
|
||||
@IsString()
|
||||
@MinLength(1)
|
||||
@MaxLength(512)
|
||||
legacyReference?: string;
|
||||
}
|
||||
|
||||
export class CompetitionGameMappingDto {
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
mappingVersion!: number;
|
||||
|
||||
@IsNumber()
|
||||
@Min(0)
|
||||
@Max(1)
|
||||
confidence!: number;
|
||||
|
||||
@IsMongoId()
|
||||
blueTeamId!: string;
|
||||
|
||||
@IsMongoId()
|
||||
redTeamId!: string;
|
||||
|
||||
@IsMongoId()
|
||||
winnerTeamId!: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@IsObject({ each: true })
|
||||
participantAssignments?: Array<Record<string, unknown>>;
|
||||
}
|
||||
|
||||
export class TournamentCodeReferenceDto {
|
||||
@IsMongoId()
|
||||
tournamentCodeId!: string;
|
||||
|
||||
@IsString()
|
||||
@MinLength(1)
|
||||
@MaxLength(128)
|
||||
riotMatchId!: string;
|
||||
}
|
||||
|
||||
export class AcceptCompetitionGameDto {
|
||||
@IsMongoId()
|
||||
gameId!: string;
|
||||
|
||||
@IsMongoId()
|
||||
seriesId!: string;
|
||||
|
||||
@IsMongoId()
|
||||
gameSlotId!: string;
|
||||
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
ordinal!: number;
|
||||
|
||||
@ValidateNested()
|
||||
@Type(() => CompetitionGameEvidenceDto)
|
||||
evidence!: CompetitionGameEvidenceDto;
|
||||
|
||||
@ValidateNested()
|
||||
@Type(() => CompetitionGameMappingDto)
|
||||
mapping!: CompetitionGameMappingDto;
|
||||
|
||||
@IsOptional()
|
||||
@IsDate()
|
||||
@Type(() => Date)
|
||||
startedAt?: Date;
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
@Min(0)
|
||||
durationSeconds?: number;
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@IsObject({ each: true })
|
||||
participants?: Array<Record<string, unknown>>;
|
||||
|
||||
@IsOptional()
|
||||
@ValidateNested()
|
||||
@Type(() => TournamentCodeReferenceDto)
|
||||
tournamentCode?: TournamentCodeReferenceDto;
|
||||
}
|
||||
|
||||
export class CompetitionAdjudicationDecisionDto {
|
||||
@IsEnum(ADJUDICATION_TYPES)
|
||||
type!: (typeof ADJUDICATION_TYPES)[number];
|
||||
|
||||
@ValidateIf(({ type }) => type !== 'administrative-draw')
|
||||
@IsMongoId()
|
||||
winnerTeamId?: string;
|
||||
}
|
||||
|
||||
export class AdjudicateCompetitionSeriesDto {
|
||||
@ValidateNested()
|
||||
@Type(() => CompetitionAdjudicationDecisionDto)
|
||||
decision!: CompetitionAdjudicationDecisionDto;
|
||||
|
||||
@IsString()
|
||||
@MinLength(1)
|
||||
@MaxLength(2000)
|
||||
reason!: string;
|
||||
}
|
||||
|
||||
export class PreviewCompetitionSeriesReversalDto {
|
||||
@IsEnum(REVERSAL_MODES)
|
||||
mode!: (typeof REVERSAL_MODES)[number];
|
||||
|
||||
@IsString()
|
||||
@MinLength(1)
|
||||
@MaxLength(2000)
|
||||
reason!: string;
|
||||
}
|
||||
|
||||
export class ReverseCompetitionSeriesDto extends PreviewCompetitionSeriesReversalDto {
|
||||
@Matches(/^[a-f0-9]{64}$/)
|
||||
impactHash!: string;
|
||||
}
|
||||
|
||||
export class CompetitionFactsQueryDto {
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(512)
|
||||
cursor?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
@Max(100)
|
||||
@Type(() => Number)
|
||||
limit?: number;
|
||||
}
|
||||
@@ -9,7 +9,8 @@ import { DakaoOutboxService } from './dakao-outbox.service';
|
||||
|
||||
const SWEEP_INTERVAL_MS = 60 * 1000;
|
||||
const STALE_OUTBOX_MS = 5 * 60 * 1000;
|
||||
const SWEEP_LOCK_KEY = 'distributed-lock:dakao-outbox:sweep-stale-publish-leases';
|
||||
const SWEEP_LOCK_KEY =
|
||||
'distributed-lock:dakao-outbox:sweep-stale-publish-leases';
|
||||
const SWEEP_LOCK_EXPIRATION_DURATION_MILLISECONDS = 55_000;
|
||||
|
||||
@Injectable()
|
||||
|
||||
@@ -78,35 +78,29 @@ export class DakaoOutboxService {
|
||||
await this.natsService.publishJetStream(params.subject, params.envelope, {
|
||||
messageId: params.eventId,
|
||||
});
|
||||
await OutboxModel.updateOne(
|
||||
updateFilter,
|
||||
{
|
||||
$set: {
|
||||
state: 'published',
|
||||
publishedAt: new Date(),
|
||||
},
|
||||
$inc: { publishAttempts: 1 },
|
||||
$unset: {
|
||||
lastPublishError: '',
|
||||
publishLeaseOwnerIdentifier: '',
|
||||
publishLeaseExpiresAt: '',
|
||||
},
|
||||
await OutboxModel.updateOne(updateFilter, {
|
||||
$set: {
|
||||
state: 'published',
|
||||
publishedAt: new Date(),
|
||||
},
|
||||
).exec();
|
||||
$inc: { publishAttempts: 1 },
|
||||
$unset: {
|
||||
lastPublishError: '',
|
||||
publishLeaseOwnerIdentifier: '',
|
||||
publishLeaseExpiresAt: '',
|
||||
},
|
||||
}).exec();
|
||||
} catch (err) {
|
||||
await OutboxModel.updateOne(
|
||||
updateFilter,
|
||||
{
|
||||
$inc: { publishAttempts: 1 },
|
||||
$set: {
|
||||
lastPublishError: (err as Error)?.message ?? String(err),
|
||||
},
|
||||
$unset: {
|
||||
publishLeaseOwnerIdentifier: '',
|
||||
publishLeaseExpiresAt: '',
|
||||
},
|
||||
await OutboxModel.updateOne(updateFilter, {
|
||||
$inc: { publishAttempts: 1 },
|
||||
$set: {
|
||||
lastPublishError: (err as Error)?.message ?? String(err),
|
||||
},
|
||||
).exec();
|
||||
$unset: {
|
||||
publishLeaseOwnerIdentifier: '',
|
||||
publishLeaseExpiresAt: '',
|
||||
},
|
||||
}).exec();
|
||||
this.logger.error(
|
||||
`Failed to publish Dakao outbox eventId=${params.eventId}: ${
|
||||
(err as Error)?.stack ?? err
|
||||
|
||||
@@ -0,0 +1,122 @@
|
||||
import mongoose from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import { RiotAccountService } from '../riot/riot-account.service';
|
||||
import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service';
|
||||
import { DakaoUserService } from './dakao-user.service';
|
||||
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const params = {
|
||||
communityId,
|
||||
kakaoTalkId: 'new-id',
|
||||
previousNickname: '예전 닉',
|
||||
};
|
||||
|
||||
function setup() {
|
||||
const user = {
|
||||
_id: new mongoose.Types.ObjectId(),
|
||||
communityId,
|
||||
kakaoTalkId: 'old-id',
|
||||
kakaoTalkNickname: '예전 닉',
|
||||
riotAccounts: [{ puuid: 'puuid', gameName: '소환사', tagLine: 'KR1' }],
|
||||
role: 'member',
|
||||
};
|
||||
const find = jest.fn().mockReturnValue({
|
||||
limit: jest
|
||||
.fn()
|
||||
.mockReturnValue({ exec: jest.fn().mockResolvedValue([user]) }),
|
||||
});
|
||||
const findOne = jest
|
||||
.fn()
|
||||
.mockReturnValue({ exec: jest.fn().mockResolvedValue(null) });
|
||||
const update = jest
|
||||
.fn()
|
||||
.mockImplementation(async () => ({ ...user, kakaoTalkId: 'new-id' }));
|
||||
const findOneAndUpdate = jest.fn().mockReturnValue({ exec: update });
|
||||
const service = new DakaoUserService(
|
||||
{
|
||||
getModel: jest
|
||||
.fn()
|
||||
.mockResolvedValue({ find, findOne, findOneAndUpdate }),
|
||||
} as unknown as ConnectionService,
|
||||
{} as RiotAccountService,
|
||||
{} as RiotAccountEnrichmentService,
|
||||
);
|
||||
return { service, user, find, findOne, findOneAndUpdate, update };
|
||||
}
|
||||
|
||||
describe('DakaoUserService.transferKakaoTalkId', () => {
|
||||
it('selects registered users by exact nickname in the current community and changes only the ID', async () => {
|
||||
const { service, user, find, findOneAndUpdate } = setup();
|
||||
expect(await service.transferKakaoTalkId(params)).toBe('transferred');
|
||||
expect(find).toHaveBeenCalledWith({
|
||||
communityId,
|
||||
kakaoTalkNickname: '예전 닉',
|
||||
'riotAccounts.0': { $exists: true },
|
||||
});
|
||||
expect(findOneAndUpdate).toHaveBeenCalledWith(
|
||||
{
|
||||
_id: user._id,
|
||||
communityId,
|
||||
kakaoTalkId: 'old-id',
|
||||
kakaoTalkNickname: '예전 닉',
|
||||
'riotAccounts.0': { $exists: true },
|
||||
},
|
||||
{ $set: { kakaoTalkId: 'new-id' } },
|
||||
{ returnDocument: 'after' },
|
||||
);
|
||||
});
|
||||
|
||||
it.each([
|
||||
['not-found', 0],
|
||||
['ambiguous', 2],
|
||||
] as const)('returns %s without mutation', async (status, count) => {
|
||||
const { service, user, find, findOneAndUpdate } = setup();
|
||||
find.mockReturnValue({
|
||||
limit: () => ({
|
||||
exec: async () => Array.from({ length: count }, () => user),
|
||||
}),
|
||||
});
|
||||
expect(await service.transferKakaoTalkId(params)).toBe(status);
|
||||
expect(findOneAndUpdate).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('does not mutate an already linked user', async () => {
|
||||
const { service, user, findOneAndUpdate } = setup();
|
||||
user.kakaoTalkId = 'new-id';
|
||||
expect(await service.transferKakaoTalkId(params)).toBe('already-linked');
|
||||
expect(findOneAndUpdate).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('refuses an ID occupied by another user', async () => {
|
||||
const { service, findOne, findOneAndUpdate } = setup();
|
||||
findOne.mockReturnValue({
|
||||
exec: async () => ({ _id: new mongoose.Types.ObjectId() }),
|
||||
});
|
||||
expect(await service.transferKakaoTalkId(params)).toBe('id-conflict');
|
||||
expect(findOne).toHaveBeenCalledWith({
|
||||
communityId,
|
||||
kakaoTalkId: 'new-id',
|
||||
});
|
||||
expect(findOneAndUpdate).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('reports a concurrent change instead of overwriting it', async () => {
|
||||
const { service, update } = setup();
|
||||
update.mockResolvedValue(null);
|
||||
expect(await service.transferKakaoTalkId(params)).toBe('changed');
|
||||
});
|
||||
|
||||
it('handles a concurrent ID collision', async () => {
|
||||
const { service, update } = setup();
|
||||
update.mockRejectedValue({ code: 11000 });
|
||||
expect(await service.transferKakaoTalkId(params)).toBe('id-conflict');
|
||||
});
|
||||
|
||||
it('propagates unexpected database failures for retry', async () => {
|
||||
const { service, update } = setup();
|
||||
update.mockRejectedValue(new Error('database unavailable'));
|
||||
await expect(service.transferKakaoTalkId(params)).rejects.toThrow(
|
||||
'database unavailable',
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -105,7 +105,7 @@ describe('DakaoUserService', () => {
|
||||
tagLine: 'KR2',
|
||||
isPrimary: false,
|
||||
});
|
||||
expect((result.user.riotAccounts as RiotAccount[])[0]).toMatchObject({
|
||||
expect(result.user.riotAccounts[0]).toMatchObject({
|
||||
puuid: 'puuid-1',
|
||||
isPrimary: true,
|
||||
});
|
||||
|
||||
@@ -60,6 +60,14 @@ interface ResolvedRiotIdentity {
|
||||
const DEFAULT_RIOT_PLATFORM: RiotPlatformRoute = 'kr';
|
||||
const DEFAULT_RIOT_REGION: RiotRegionalRoute = 'asia';
|
||||
|
||||
export type KakaoDataTransferResult =
|
||||
| 'transferred'
|
||||
| 'already-linked'
|
||||
| 'not-found'
|
||||
| 'ambiguous'
|
||||
| 'id-conflict'
|
||||
| 'changed';
|
||||
|
||||
@Injectable()
|
||||
export class DakaoUserService {
|
||||
private readonly logger = new Logger(DakaoUserService.name);
|
||||
@@ -87,7 +95,7 @@ export class DakaoUserService {
|
||||
if (!community) {
|
||||
throw new DakaoUserError('community_not_found', dakaoProjectId);
|
||||
}
|
||||
return community._id as mongoose.Types.ObjectId;
|
||||
return community._id;
|
||||
}
|
||||
|
||||
public async upsertUser(params: {
|
||||
@@ -127,6 +135,44 @@ export class DakaoUserService {
|
||||
}).exec();
|
||||
}
|
||||
|
||||
public async transferKakaoTalkId(params: {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
kakaoTalkId: string;
|
||||
previousNickname: string;
|
||||
}): Promise<KakaoDataTransferResult> {
|
||||
const UserModel = await this.connectionService.getModel('user');
|
||||
const targetFilter = {
|
||||
communityId: params.communityId,
|
||||
kakaoTalkNickname: params.previousNickname,
|
||||
'riotAccounts.0': { $exists: true },
|
||||
};
|
||||
const candidates = await UserModel.find(targetFilter).limit(2).exec();
|
||||
if (candidates.length === 0) return 'not-found';
|
||||
if (candidates.length > 1) return 'ambiguous';
|
||||
|
||||
const user = candidates[0];
|
||||
if (user.kakaoTalkId === params.kakaoTalkId) return 'already-linked';
|
||||
const occupied = await this.findUserByKakaoTalkId(params);
|
||||
if (occupied) return 'id-conflict';
|
||||
|
||||
try {
|
||||
// Compare the previous ID so concurrent transfers cannot overwrite one another.
|
||||
const updated = await UserModel.findOneAndUpdate(
|
||||
{
|
||||
...targetFilter,
|
||||
_id: user._id,
|
||||
kakaoTalkId: user.kakaoTalkId ?? null,
|
||||
},
|
||||
{ $set: { kakaoTalkId: params.kakaoTalkId } },
|
||||
{ returnDocument: 'after' },
|
||||
).exec();
|
||||
return updated ? 'transferred' : 'changed';
|
||||
} catch (error) {
|
||||
if ((error as { code?: number })?.code === 11000) return 'id-conflict';
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
public async resolveRiotAccount(
|
||||
context: ResolveContext,
|
||||
): Promise<ResolveResult> {
|
||||
|
||||
@@ -12,6 +12,7 @@ import { DakaoUserService } from './dakao-user.service';
|
||||
import { DakaoSendResultSubscriber } from './dakao-send-result.subscriber';
|
||||
import { DakaoUrlShortenerService } from './dakao-url-shortener.service';
|
||||
import { AccountRegisterHandler } from './handlers/account-register.handler';
|
||||
import { DataTransferHandler } from './handlers/data-transfer.handler';
|
||||
import { MatchCancelHandler } from './handlers/match-cancel.handler';
|
||||
import { MatchJoinHandler } from './handlers/match-join.handler';
|
||||
import { MatchListHandler } from './handlers/match-list.handler';
|
||||
@@ -35,6 +36,7 @@ import { PrimaryAccountChangeHandler } from './handlers/primary-account-change.h
|
||||
DakaoUserService,
|
||||
DakaoUrlShortenerService,
|
||||
AccountRegisterHandler,
|
||||
DataTransferHandler,
|
||||
MatchListHandler,
|
||||
MatchJoinHandler,
|
||||
MatchCancelHandler,
|
||||
|
||||
@@ -16,6 +16,7 @@ function makeSubscriber(): DakaoSubscriber {
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
}
|
||||
|
||||
@@ -39,6 +40,48 @@ const event = {
|
||||
} satisfies DakaoInboundEvent;
|
||||
|
||||
describe('DakaoSubscriber', () => {
|
||||
it('routes data transfer with the current sender ID and publishes its reply', async () => {
|
||||
const subscriber = makeSubscriber();
|
||||
const segments = [{ kind: 'text', text: ' 데이터 이관 완료' }];
|
||||
const handle = jest.fn().mockResolvedValue(segments);
|
||||
const sendMessage = jest.fn();
|
||||
const markProcessed = jest.fn();
|
||||
Object.assign(subscriber, {
|
||||
dakaoUserService: {
|
||||
resolveCommunityIdByDakaoProjectId: async () => event.projectId,
|
||||
},
|
||||
dataTransferHandler: { handle },
|
||||
publisher: { sendMessage },
|
||||
inbox: { claim: async () => ({ status: 'claimed' }), markProcessed },
|
||||
});
|
||||
await (
|
||||
subscriber as unknown as {
|
||||
handleEvent: (input: DakaoInboundEvent) => Promise<void>;
|
||||
}
|
||||
).handleEvent({
|
||||
...event,
|
||||
origin: {
|
||||
...event.origin,
|
||||
chatLog: {
|
||||
...event.origin.chatLog,
|
||||
message: '!내전 데이터이관 예전 닉',
|
||||
},
|
||||
},
|
||||
});
|
||||
expect(handle).toHaveBeenCalledWith({
|
||||
communityId: event.projectId,
|
||||
senderUserId: '12345',
|
||||
senderNickname: '프리리',
|
||||
previousNickname: '예전 닉',
|
||||
});
|
||||
expect(sendMessage).toHaveBeenCalledWith({
|
||||
chatroomId: 'chatroom-1',
|
||||
segments,
|
||||
correlationId: 'log-1',
|
||||
});
|
||||
expect(markProcessed).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('renders usage help with star emoticon command lines', () => {
|
||||
const subscriber = makeSubscriber() as unknown as {
|
||||
parseErrorReply: (
|
||||
@@ -74,8 +117,10 @@ describe('DakaoSubscriber', () => {
|
||||
{ kind: 'emoticon', id: '1200281_035', altText: '스타' },
|
||||
{
|
||||
kind: 'text',
|
||||
text: ' !내전 대표계정변경 소환사이름#태그',
|
||||
text: ' !내전 대표계정변경 소환사이름#태그\u3000\n',
|
||||
},
|
||||
{ kind: 'emoticon', id: '1200281_035', altText: '스타' },
|
||||
{ kind: 'text', text: ' !내전 데이터이관 예전닉네임' },
|
||||
]);
|
||||
});
|
||||
|
||||
|
||||
@@ -7,6 +7,7 @@ import { DakaoInboundEvent, DakaoLong, DakaoSegment } from './dakao.types';
|
||||
import { DakaoPublisher } from './dakao.publisher';
|
||||
import { DakaoUserError, DakaoUserService } from './dakao-user.service';
|
||||
import { AccountRegisterHandler } from './handlers/account-register.handler';
|
||||
import { DataTransferHandler } from './handlers/data-transfer.handler';
|
||||
import { MatchCancelHandler } from './handlers/match-cancel.handler';
|
||||
import { MatchJoinHandler } from './handlers/match-join.handler';
|
||||
import { MatchListHandler } from './handlers/match-list.handler';
|
||||
@@ -27,6 +28,7 @@ export class DakaoSubscriber implements OnModuleInit {
|
||||
'!내전 계정등록 소환사이름#태그',
|
||||
'!내전 선호포지션등록 포지션1,포지션2',
|
||||
'!내전 대표계정변경 소환사이름#태그',
|
||||
'!내전 데이터이관 예전닉네임',
|
||||
];
|
||||
|
||||
constructor(
|
||||
@@ -42,6 +44,7 @@ export class DakaoSubscriber implements OnModuleInit {
|
||||
private readonly matchCancelHandler: MatchCancelHandler,
|
||||
private readonly preferredPositionRegisterHandler: PreferredPositionRegisterHandler,
|
||||
private readonly primaryAccountChangeHandler: PrimaryAccountChangeHandler,
|
||||
private readonly dataTransferHandler: DataTransferHandler,
|
||||
) {}
|
||||
|
||||
async onModuleInit() {
|
||||
@@ -119,6 +122,14 @@ export class DakaoSubscriber implements OnModuleInit {
|
||||
const command = parseCommand(event.origin.chatLog.message);
|
||||
|
||||
switch (command.kind) {
|
||||
case 'data-transfer':
|
||||
segments = await this.dataTransferHandler.handle({
|
||||
communityId,
|
||||
senderUserId: event.userId,
|
||||
senderNickname,
|
||||
previousNickname: command.previousNickname,
|
||||
});
|
||||
break;
|
||||
case 'match-list':
|
||||
segments = await this.matchListHandler.handle({
|
||||
communityId,
|
||||
@@ -301,7 +312,7 @@ export class DakaoSubscriber implements OnModuleInit {
|
||||
text:
|
||||
index === this.usageCommands.length - 1
|
||||
? ` ${command}`
|
||||
: ` ${command} \n`,
|
||||
: ` ${command}\u3000\n`,
|
||||
} as const,
|
||||
]);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,49 @@
|
||||
import mongoose from 'mongoose';
|
||||
import {
|
||||
DakaoUserService,
|
||||
KakaoDataTransferResult,
|
||||
} from '../dakao-user.service';
|
||||
import { DataTransferHandler } from './data-transfer.handler';
|
||||
|
||||
const params = {
|
||||
communityId: new mongoose.Types.ObjectId(),
|
||||
senderUserId: 'new-id',
|
||||
senderNickname: '현재 닉',
|
||||
previousNickname: '예전 닉',
|
||||
};
|
||||
|
||||
describe('DataTransferHandler', () => {
|
||||
it.each<[KakaoDataTransferResult, string]>([
|
||||
['transferred', '데이터 이관 완료'],
|
||||
['already-linked', '이미 현재 카카오톡 계정에 연결'],
|
||||
['not-found', '찾을 수 없습니다'],
|
||||
['ambiguous', '여러 명'],
|
||||
['id-conflict', '이미 다른 사용자'],
|
||||
['changed', '변경되었습니다'],
|
||||
])('replies to the sender for %s', async (result, message) => {
|
||||
const transferKakaoTalkId = jest.fn().mockResolvedValue(result);
|
||||
const handler = new DataTransferHandler({
|
||||
transferKakaoTalkId,
|
||||
} as unknown as DakaoUserService);
|
||||
expect(await handler.handle(params)).toEqual([
|
||||
{ kind: 'mention', userId: 'new-id', displayText: '현재 닉' },
|
||||
{ kind: 'text', text: expect.stringContaining(message) },
|
||||
]);
|
||||
expect(transferKakaoTalkId).toHaveBeenCalledWith({
|
||||
communityId: params.communityId,
|
||||
kakaoTalkId: 'new-id',
|
||||
previousNickname: '예전 닉',
|
||||
});
|
||||
});
|
||||
|
||||
it('propagates unexpected failures', async () => {
|
||||
const handler = new DataTransferHandler({
|
||||
transferKakaoTalkId: jest
|
||||
.fn()
|
||||
.mockRejectedValue(new Error('database unavailable')),
|
||||
} as unknown as DakaoUserService);
|
||||
await expect(handler.handle(params)).rejects.toThrow(
|
||||
'database unavailable',
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,46 @@
|
||||
import { Injectable } from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import {
|
||||
DakaoUserService,
|
||||
KakaoDataTransferResult,
|
||||
} from '../dakao-user.service';
|
||||
import { DakaoSegment } from '../dakao.types';
|
||||
|
||||
const RESULT_MESSAGES: Record<KakaoDataTransferResult, string> = {
|
||||
transferred:
|
||||
'데이터 이관 완료. 기존 라이엇 계정과 내전 기록이 현재 카카오톡 계정에 연결되었습니다.',
|
||||
'already-linked': '이미 현재 카카오톡 계정에 연결된 사용자입니다.',
|
||||
'not-found':
|
||||
'해당 예전 닉네임으로 라이엇 계정이 등록된 사용자를 찾을 수 없습니다.',
|
||||
ambiguous:
|
||||
'같은 예전 닉네임으로 등록된 사용자가 여러 명입니다. 운영자에게 문의해주세요.',
|
||||
'id-conflict':
|
||||
'현재 카카오톡 계정에 이미 다른 사용자가 등록되어 있습니다. 운영자에게 문의해주세요.',
|
||||
changed: '이관 중 사용자 정보가 변경되었습니다. 다시 시도해주세요.',
|
||||
};
|
||||
|
||||
@Injectable()
|
||||
export class DataTransferHandler {
|
||||
constructor(private readonly dakaoUserService: DakaoUserService) {}
|
||||
|
||||
public async handle(params: {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
senderUserId: string;
|
||||
senderNickname: string;
|
||||
previousNickname: string;
|
||||
}): Promise<DakaoSegment[]> {
|
||||
const result = await this.dakaoUserService.transferKakaoTalkId({
|
||||
communityId: params.communityId,
|
||||
kakaoTalkId: params.senderUserId,
|
||||
previousNickname: params.previousNickname,
|
||||
});
|
||||
return [
|
||||
{
|
||||
kind: 'mention',
|
||||
userId: params.senderUserId,
|
||||
displayText: params.senderNickname,
|
||||
},
|
||||
{ kind: 'text', text: ` ${RESULT_MESSAGES[result]}` },
|
||||
];
|
||||
}
|
||||
}
|
||||
@@ -104,9 +104,11 @@ describe('MatchCancelHandler', () => {
|
||||
const handler = makeHandler({
|
||||
matchService: {
|
||||
cancelJoin,
|
||||
list: jest.fn().mockResolvedValue([
|
||||
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
|
||||
]),
|
||||
list: jest
|
||||
.fn()
|
||||
.mockResolvedValue([
|
||||
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
|
||||
]),
|
||||
} as Partial<MatchService>,
|
||||
dakaoUserService: {
|
||||
findUserByKakaoTalkId,
|
||||
|
||||
@@ -230,9 +230,11 @@ describe('MatchJoinHandler', () => {
|
||||
const resolveRiotAccount = jest.fn();
|
||||
const handler = makeHandler({
|
||||
matchService: {
|
||||
list: jest.fn().mockResolvedValue([
|
||||
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
|
||||
]),
|
||||
list: jest
|
||||
.fn()
|
||||
.mockResolvedValue([
|
||||
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
|
||||
]),
|
||||
join,
|
||||
} as Partial<MatchService>,
|
||||
dakaoUserService: {
|
||||
@@ -282,9 +284,11 @@ describe('MatchJoinHandler', () => {
|
||||
const join = jest.fn();
|
||||
const handler = makeHandler({
|
||||
matchService: {
|
||||
list: jest.fn().mockResolvedValue([
|
||||
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
|
||||
]),
|
||||
list: jest
|
||||
.fn()
|
||||
.mockResolvedValue([
|
||||
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
|
||||
]),
|
||||
join,
|
||||
} as Partial<MatchService>,
|
||||
dakaoUserService: {
|
||||
|
||||
@@ -44,9 +44,7 @@ export class MatchJoinHandler {
|
||||
return this.errorReply(params, joinTarget);
|
||||
}
|
||||
|
||||
let resolved:
|
||||
| { user: UserDocument; riotAccount: RiotAccount }
|
||||
| string;
|
||||
let resolved: { user: UserDocument; riotAccount: RiotAccount } | string;
|
||||
try {
|
||||
resolved =
|
||||
joinTarget.gameName && joinTarget.tagLine
|
||||
@@ -243,10 +241,7 @@ export class MatchJoinHandler {
|
||||
const gameName = normalizeRiotIdPart(value.slice(splitAt + 1));
|
||||
if (!matchTitlePrefix || !gameName) continue;
|
||||
|
||||
const result = resolveRecruitingMatchReference(
|
||||
matchTitlePrefix,
|
||||
matches,
|
||||
);
|
||||
const result = resolveRecruitingMatchReference(matchTitlePrefix, matches);
|
||||
if (result.kind === 'matched') {
|
||||
return { kind: 'matched', match: result.match, gameName };
|
||||
}
|
||||
|
||||
@@ -22,6 +22,33 @@ function makeHandler(params: {
|
||||
}
|
||||
|
||||
describe('MatchListHandler', () => {
|
||||
afterEach(() => {
|
||||
jest.useRealTimers();
|
||||
});
|
||||
|
||||
it('queries only matches scheduled at or after command processing time', async () => {
|
||||
const now = new Date('2026-07-25T07:30:00.000Z');
|
||||
jest.useFakeTimers().setSystemTime(now);
|
||||
const communityId = objectId('111111111111111111111111');
|
||||
const list = jest.fn().mockResolvedValue([]);
|
||||
const handler = makeHandler({
|
||||
matchService: { list },
|
||||
});
|
||||
|
||||
await handler.handle({
|
||||
communityId,
|
||||
senderUserId: 'kakao-user-1',
|
||||
senderNickname: '프리리',
|
||||
});
|
||||
|
||||
expect(list).toHaveBeenCalledWith({
|
||||
communityId,
|
||||
status: 'recruiting',
|
||||
scheduledFrom: now,
|
||||
limit: 10,
|
||||
});
|
||||
});
|
||||
|
||||
it('prints short codes, compact KST dates, and short links', async () => {
|
||||
const match = {
|
||||
_id: objectId('333333333333333333333333'),
|
||||
|
||||
@@ -19,9 +19,11 @@ export class MatchListHandler {
|
||||
senderUserId: string;
|
||||
senderNickname: string;
|
||||
}): Promise<DakaoSegment[]> {
|
||||
const scheduledFrom = new Date();
|
||||
const matches = await this.matchService.list({
|
||||
communityId: params.communityId,
|
||||
status: 'recruiting',
|
||||
scheduledFrom,
|
||||
limit: 10,
|
||||
});
|
||||
|
||||
|
||||
@@ -20,8 +20,8 @@ export class IdempotencyCache {
|
||||
public remember(key: string): void {
|
||||
this.evictExpired();
|
||||
if (this.entries.size >= MAX_ENTRIES) {
|
||||
const oldestKey = this.entries.keys().next().value;
|
||||
if (oldestKey !== undefined) this.entries.delete(oldestKey);
|
||||
const oldestKey: unknown = this.entries.keys().next().value;
|
||||
if (typeof oldestKey === 'string') this.entries.delete(oldestKey);
|
||||
}
|
||||
this.entries.set(key, Date.now() + TTL_MS);
|
||||
}
|
||||
|
||||
@@ -1,6 +1,19 @@
|
||||
import { CommandParseError, parseCommand } from './command.parser';
|
||||
|
||||
describe('parseCommand', () => {
|
||||
it('parses data transfer with the complete previous nickname', () => {
|
||||
expect(parseCommand(' !내전 데이터이관 예전 닉.* ')).toEqual({
|
||||
kind: 'data-transfer',
|
||||
previousNickname: '예전 닉.*',
|
||||
});
|
||||
});
|
||||
|
||||
it('requires a previous nickname for data transfer', () => {
|
||||
expect(() => parseCommand('!내전 데이터이관 ')).toThrow(
|
||||
new CommandParseError('usage'),
|
||||
);
|
||||
});
|
||||
|
||||
it('parses match-list command (목록)', () => {
|
||||
expect(parseCommand('!내전 목록')).toEqual({ kind: 'match-list' });
|
||||
});
|
||||
|
||||
@@ -7,6 +7,7 @@ import { normalizeRiotIdPart } from '../riot-id.util';
|
||||
|
||||
export type DakaoCommand =
|
||||
| { kind: 'match-list' }
|
||||
| { kind: 'data-transfer'; previousNickname: string }
|
||||
| {
|
||||
kind: 'account-register';
|
||||
gameName: string;
|
||||
@@ -75,6 +76,9 @@ export function parseCommand(rawMessage: string): DakaoCommand {
|
||||
return parseCancelArgs(args);
|
||||
case '계정등록':
|
||||
return parseAccountRegisterArgs(args);
|
||||
case '데이터이관':
|
||||
if (!args) throw new CommandParseError('usage');
|
||||
return { kind: 'data-transfer', previousNickname: args };
|
||||
case '대표계정변경':
|
||||
return parsePrimaryAccountChangeArgs(args);
|
||||
case '선호포지션등록':
|
||||
|
||||
@@ -144,7 +144,7 @@ export function buildDoubleEliminationBracket(
|
||||
teamIndex,
|
||||
}));
|
||||
const bracket: DoubleEliminationBracket = {
|
||||
teamCount: seededTeamIndexes.length as 4 | 8,
|
||||
teamCount: seededTeamIndexes.length,
|
||||
resetFinalEnabled: options.resetFinalEnabled,
|
||||
resetFinalCreated: false,
|
||||
seeds,
|
||||
|
||||
@@ -19,7 +19,9 @@ describe('auction Redis schema foundation', () => {
|
||||
expect(AuctionSchema.path('revision')).toBeDefined();
|
||||
expect(AuctionSchema.path('auctionEngineVersion')).toBeDefined();
|
||||
expect(AuctionSchema.path('auctionLifecycleId')).toBeDefined();
|
||||
expect(AuctionSchema.path('lastAppliedAuctionStateTransitionId')).toBeDefined();
|
||||
expect(
|
||||
AuctionSchema.path('lastAppliedAuctionStateTransitionId'),
|
||||
).toBeDefined();
|
||||
expect(AuctionSchema.path('currentAuctionHistorySequence')).toBeDefined();
|
||||
expect(AuctionSchema.path('startAuctionRequestId')).toBeDefined();
|
||||
expect(AuctionSchema.path('startAuctionStateTransitionId')).toBeDefined();
|
||||
@@ -36,46 +38,75 @@ describe('auction Redis schema foundation', () => {
|
||||
expect(AuctionSchema.path('auctionBidHistory')).toBeDefined();
|
||||
expect(AuctionSchema.path('currentHighestBidPointAmount')).toBeDefined();
|
||||
expect(AuctionSchema.path('currentHighestBidderTeamIndex')).toBeDefined();
|
||||
expect(AuctionSchema.path('currentBidRoundDeadlineTimestampMS')).toBeDefined();
|
||||
expect(
|
||||
AuctionSchema.path('currentBidRoundDeadlineTimestampMS'),
|
||||
).toBeDefined();
|
||||
expect(AuctionSchema.path('maximumBidRoundDurationSeconds')).toBeDefined();
|
||||
expect(AuctionSchema.path('bidRoundExtensionSeconds')).toBeDefined();
|
||||
expect(AuctionSchema.path('initialTeamBidPointAmount')).toBeDefined();
|
||||
expect(AuctionSchema.path('topTierAuctionPriorityThreshold')).toBeDefined();
|
||||
expect(AuctionSchema.path('manualTopTierAuctionPriorityUserIds')).toBeDefined();
|
||||
expect(
|
||||
AuctionSchema.path('manualTopTierAuctionPriorityUserIds'),
|
||||
).toBeDefined();
|
||||
expect(AuctionSchema.path('auctionStartedAtTimestampMS')).toBeDefined();
|
||||
expect(AuctionSchema.path('auctionCompletedAtTimestampMS')).toBeDefined();
|
||||
});
|
||||
|
||||
it('adds history transition fields and reset/undo action enum values', () => {
|
||||
expect(AuctionHistoryEntrySchema.path('auctionStateTransitionId')).toBeDefined();
|
||||
expect(
|
||||
AuctionHistoryEntrySchema.path('auctionStateTransitionId'),
|
||||
).toBeDefined();
|
||||
expect(AuctionHistoryEntrySchema.path('auctionLifecycleId')).toBeDefined();
|
||||
expect(AuctionHistoryEntrySchema.path('revision')).toBeDefined();
|
||||
expect(AuctionHistoryEntrySchema.path('historyMutation')).toBeDefined();
|
||||
expect(AuctionHistoryEntrySchema.path('matchSideEffectMutation')).toBeDefined();
|
||||
expect(
|
||||
AuctionHistoryEntrySchema.path('matchSideEffectMutation'),
|
||||
).toBeDefined();
|
||||
expect(
|
||||
AuctionHistoryEntrySchema.path<string>('action').options.enum,
|
||||
).toEqual(
|
||||
expect.arrayContaining(['start', 'open-bidding', 'bid', 'sold', 'passed', 'next', 'complete', 'reset', 'undo']),
|
||||
expect.arrayContaining([
|
||||
'start',
|
||||
'open-bidding',
|
||||
'bid',
|
||||
'sold',
|
||||
'passed',
|
||||
'next',
|
||||
'complete',
|
||||
'reset',
|
||||
'undo',
|
||||
]),
|
||||
);
|
||||
});
|
||||
|
||||
it('adds unique history indexes for sequence and transition idempotency', () => {
|
||||
const indexes = AuctionHistoryEntrySchema.indexes();
|
||||
|
||||
expect(indexWithKeys(indexes, { auctionId: 1, sequence: 1 })?.[1]).toMatchObject({
|
||||
expect(
|
||||
indexWithKeys(indexes, { auctionId: 1, sequence: 1 })?.[1],
|
||||
).toMatchObject({
|
||||
unique: true,
|
||||
});
|
||||
expect(
|
||||
indexWithKeys(indexes, { auctionId: 1, auctionStateTransitionId: 1 })?.[1],
|
||||
indexWithKeys(indexes, {
|
||||
auctionId: 1,
|
||||
auctionStateTransitionId: 1,
|
||||
})?.[1],
|
||||
).toMatchObject({ unique: true, sparse: true });
|
||||
});
|
||||
|
||||
it('registers auction side effect application model with lease fields and unique idempotency index', () => {
|
||||
expect(AuctionSideEffectApplicationSchema.path('processingOwnerToken')).toBeDefined();
|
||||
expect(
|
||||
AuctionSideEffectApplicationSchema.path('processingLeaseExpiresAtTimestampMS'),
|
||||
AuctionSideEffectApplicationSchema.path('processingOwnerToken'),
|
||||
).toBeDefined();
|
||||
expect(
|
||||
AuctionSideEffectApplicationSchema.path(
|
||||
'processingLeaseExpiresAtTimestampMS',
|
||||
),
|
||||
).toBeDefined();
|
||||
expect(
|
||||
AuctionSideEffectApplicationSchema.path('payloadChecksum'),
|
||||
).toBeDefined();
|
||||
expect(AuctionSideEffectApplicationSchema.path('payloadChecksum')).toBeDefined();
|
||||
|
||||
const indexes = AuctionSideEffectApplicationSchema.indexes();
|
||||
expect(
|
||||
|
||||
@@ -1,9 +1,75 @@
|
||||
import mongoose from 'mongoose';
|
||||
import {
|
||||
ConnectionService,
|
||||
resolveMongoAppName,
|
||||
resolveMongoConnectionOptions,
|
||||
resolveMongoDbName,
|
||||
} from './connection.service';
|
||||
|
||||
function createFakeConnection(connectionId: string) {
|
||||
const models: Record<string, unknown> = {};
|
||||
return {
|
||||
readyState: mongoose.ConnectionStates.connected,
|
||||
models,
|
||||
model: jest.fn((name: string) => {
|
||||
const model = { connectionId, modelName: name };
|
||||
models[name] = model;
|
||||
return model;
|
||||
}),
|
||||
};
|
||||
}
|
||||
|
||||
describe('ConnectionService', () => {
|
||||
afterEach(() => {
|
||||
jest.restoreAllMocks();
|
||||
});
|
||||
|
||||
it('shares one MongoDB connection across concurrent initialization calls', async () => {
|
||||
const connection = createFakeConnection('shared');
|
||||
const createConnection = jest
|
||||
.spyOn(mongoose, 'createConnection')
|
||||
.mockReturnValue({
|
||||
asPromise: jest.fn().mockResolvedValue(connection),
|
||||
} as never);
|
||||
const service = new ConnectionService({
|
||||
get: jest.fn().mockResolvedValue('mongodb://localhost/test'),
|
||||
} as never);
|
||||
|
||||
const [first, second] = await Promise.all([
|
||||
service.getConnection(),
|
||||
service.getConnection(),
|
||||
]);
|
||||
|
||||
expect(first).toBe(connection);
|
||||
expect(second).toBe(connection);
|
||||
expect(createConnection).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('rebuilds models from the replacement connection after disconnect', async () => {
|
||||
const firstConnection = createFakeConnection('first');
|
||||
const secondConnection = createFakeConnection('second');
|
||||
jest
|
||||
.spyOn(mongoose, 'createConnection')
|
||||
.mockReturnValueOnce({
|
||||
asPromise: jest.fn().mockResolvedValue(firstConnection),
|
||||
} as never)
|
||||
.mockReturnValueOnce({
|
||||
asPromise: jest.fn().mockResolvedValue(secondConnection),
|
||||
} as never);
|
||||
const service = new ConnectionService({
|
||||
get: jest.fn().mockResolvedValue('mongodb://localhost/test'),
|
||||
} as never);
|
||||
|
||||
const firstModel = await service.getModel('match');
|
||||
firstConnection.readyState = mongoose.ConnectionStates.disconnected;
|
||||
const secondModel = await service.getModel('match');
|
||||
|
||||
expect(firstModel).toMatchObject({ connectionId: 'first' });
|
||||
expect(secondModel).toMatchObject({ connectionId: 'second' });
|
||||
expect(secondModel).not.toBe(firstModel);
|
||||
});
|
||||
});
|
||||
|
||||
describe('resolveMongoDbName', () => {
|
||||
it('uses production database only for prod', () => {
|
||||
expect(resolveMongoDbName('prod')).toBe('lolympus');
|
||||
|
||||
@@ -2,7 +2,10 @@ import { Injectable, Logger, Scope, OnModuleInit } from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import { applyMongoosePerformancePlugin } from '../observability/mongoose-performance.plugin';
|
||||
import { SecretService } from '../secret/secret.service';
|
||||
import { tournamentModelDefinitions, TournamentModelTypes } from './schema';
|
||||
import {
|
||||
tournamentModelDefinitions,
|
||||
type TournamentModelTypes,
|
||||
} from './schema';
|
||||
|
||||
export function resolveMongoDbName(nodeEnv = process.env.NODE_ENV): string {
|
||||
if (nodeEnv === 'prod') return 'lolympus';
|
||||
@@ -39,9 +42,11 @@ export function resolveMongoConnectionOptions(
|
||||
export class ConnectionService implements OnModuleInit {
|
||||
private readonly logger = new Logger(ConnectionService.name);
|
||||
private connection: mongoose.Connection | null = null;
|
||||
private connectionPromise: Promise<mongoose.Connection> | null = null;
|
||||
constructor(private readonly secretService: SecretService) {}
|
||||
|
||||
private tournamentModels: Map<string, mongoose.Model<any>> | null = null;
|
||||
private tournamentModels: Map<keyof TournamentModelTypes, unknown> | null =
|
||||
null;
|
||||
|
||||
public async getConnection(): Promise<mongoose.Connection> {
|
||||
if (
|
||||
@@ -51,37 +56,55 @@ export class ConnectionService implements OnModuleInit {
|
||||
return this.connection;
|
||||
}
|
||||
|
||||
const pendingConnection = this.connectionPromise ?? this.openConnection();
|
||||
this.connectionPromise = pendingConnection;
|
||||
try {
|
||||
return await pendingConnection;
|
||||
} finally {
|
||||
if (this.connectionPromise === pendingConnection) {
|
||||
this.connectionPromise = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async openConnection(): Promise<mongoose.Connection> {
|
||||
const connectionString = await this.secretService.get(
|
||||
'MONGODB_CONNECTION_STRING',
|
||||
);
|
||||
const dbName = resolveMongoDbName();
|
||||
const appName = resolveMongoAppName();
|
||||
const connectionOptions = resolveMongoConnectionOptions(dbName, appName);
|
||||
const defaultConnection = await mongoose
|
||||
const connection = await mongoose
|
||||
.createConnection(connectionString, connectionOptions)
|
||||
.asPromise();
|
||||
this.connection = defaultConnection;
|
||||
|
||||
this.connection = connection;
|
||||
this.tournamentModels = null;
|
||||
this.logger.log(
|
||||
`MongoDB connection created. dbName=${dbName} appName=${appName} autoIndex=${
|
||||
connectionOptions.autoIndex === true
|
||||
}`,
|
||||
);
|
||||
|
||||
return this.connection;
|
||||
return connection;
|
||||
}
|
||||
|
||||
public async getModel<K extends keyof TournamentModelTypes>(
|
||||
modelKey: K,
|
||||
): Promise<mongoose.Model<TournamentModelTypes[K]>> {
|
||||
if (this.tournamentModels)
|
||||
return this.tournamentModels.get(modelKey) as mongoose.Model<
|
||||
TournamentModelTypes[K]
|
||||
>;
|
||||
|
||||
const models = new Map<K, mongoose.Model<TournamentModelTypes[K]>>();
|
||||
const connection = await this.getConnection();
|
||||
if (this.tournamentModels) {
|
||||
return this.requireTournamentModel(this.tournamentModels, modelKey);
|
||||
}
|
||||
|
||||
const models = new Map<keyof TournamentModelTypes, unknown>();
|
||||
|
||||
tournamentModelDefinitions.forEach((modelDefinition) => {
|
||||
if (!(modelDefinition.schema instanceof mongoose.Schema)) {
|
||||
throw new Error(
|
||||
`Invalid Mongoose schema for model ${modelDefinition.name}.`,
|
||||
);
|
||||
}
|
||||
applyMongoosePerformancePlugin(modelDefinition.schema);
|
||||
// 이미 생성된 경우 컴파일 스킵.
|
||||
if (
|
||||
@@ -91,14 +114,14 @@ export class ConnectionService implements OnModuleInit {
|
||||
)
|
||||
) {
|
||||
models.set(
|
||||
modelDefinition.name as K,
|
||||
modelDefinition.name,
|
||||
connection.models[modelDefinition.name],
|
||||
);
|
||||
return;
|
||||
} else {
|
||||
models.set(
|
||||
modelDefinition.name as K,
|
||||
connection.model<TournamentModelTypes[K]>(
|
||||
modelDefinition.name,
|
||||
connection.model(
|
||||
modelDefinition.name,
|
||||
modelDefinition.schema,
|
||||
modelDefinition.schemaName,
|
||||
@@ -108,7 +131,18 @@ export class ConnectionService implements OnModuleInit {
|
||||
});
|
||||
|
||||
this.tournamentModels = models;
|
||||
return models.get(modelKey) as mongoose.Model<TournamentModelTypes[K]>;
|
||||
return this.requireTournamentModel(models, modelKey);
|
||||
}
|
||||
|
||||
private requireTournamentModel<K extends keyof TournamentModelTypes>(
|
||||
models: ReadonlyMap<keyof TournamentModelTypes, unknown>,
|
||||
modelKey: K,
|
||||
): mongoose.Model<TournamentModelTypes[K]> {
|
||||
const model = models.get(modelKey);
|
||||
if (model === undefined) {
|
||||
throw new Error(`Mongoose model ${modelKey} is not registered.`);
|
||||
}
|
||||
return model as mongoose.Model<TournamentModelTypes[K]>;
|
||||
}
|
||||
|
||||
public async createSession(
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import { DynamicModule, Module } from '@nestjs/common';
|
||||
import { Module } from '@nestjs/common';
|
||||
import { ConnectionService } from './connection.service';
|
||||
|
||||
@Module({
|
||||
|
||||
@@ -45,7 +45,10 @@ export async function migrateAuctionPassHistory(
|
||||
};
|
||||
}> = [];
|
||||
|
||||
for await (const doc of db.collection('auction').find({}).limit(options.limit ?? 0)) {
|
||||
for await (const doc of db
|
||||
.collection('auction')
|
||||
.find({})
|
||||
.limit(options.limit ?? 0)) {
|
||||
stats.scannedAuctions += 1;
|
||||
const set: Record<string, unknown> = {};
|
||||
let changed = false;
|
||||
|
||||
Loaded 100 of 309 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user