Compare commits
97
Commits
release/84
...
f649490cd2
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
f649490cd2 | ||
|
|
f2eec479d9 | ||
|
|
ef141a13d0 | ||
|
|
f622ee5b1f | ||
|
|
4b8ccf0077 | ||
|
|
0c4c4239ec | ||
|
|
9117c9c0a4 | ||
|
|
5bc748dc4d | ||
|
|
de84ad5309 | ||
|
|
f223157542 | ||
|
|
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 | ||
|
|
3a76fd8c88 | ||
|
|
3357d4c9c8 | ||
|
|
2d1c33f1e9 | ||
|
|
03358cab4f | ||
|
|
e188828423 | ||
|
|
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
|
||||
+5
-5
@@ -19,15 +19,15 @@ website/LICENSE
|
||||
|
||||
*.log
|
||||
|
||||
!.claude/settings.json
|
||||
|
||||
*.temp.MD
|
||||
|
||||
*.md
|
||||
!README.md
|
||||
!AGENTS.md
|
||||
!agents/**/*.md
|
||||
!skills/**/*.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
|
||||
!docs/plans/redis-8.10-optimization.md
|
||||
/tmp/
|
||||
/user-game-history/
|
||||
/*.txt
|
||||
|
||||
@@ -1,189 +0,0 @@
|
||||
# AGENTS.md
|
||||
|
||||
This file provides guidance to AI coding agents (Claude Code, Cursor, Copilot, Antigravity, etc.) when working with code in this repository.
|
||||
|
||||
## Repository Overview
|
||||
|
||||
A collection of skills for Claude.ai and Claude Code for senior software engineers. Skills are packaged instructions and scripts that extend Claude and your coding agents capabilities.
|
||||
|
||||
## OpenCode Integration
|
||||
|
||||
OpenCode uses a **skill-driven execution model** powered by the `skill` tool and this repository's `/skills` directory.
|
||||
|
||||
### Core Rules
|
||||
|
||||
- If a task matches a skill, you MUST invoke it
|
||||
- Skills are located in `skills/<skill-name>/SKILL.md`
|
||||
- Never implement directly if a skill applies
|
||||
- Always follow the skill instructions exactly (do not partially apply them)
|
||||
|
||||
### Intent → Skill Mapping
|
||||
|
||||
The agent should automatically map user intent to skills:
|
||||
|
||||
- Feature / new functionality → `spec-driven-development`, then `incremental-implementation`, `test-driven-development`
|
||||
- Planning / breakdown → `planning-and-task-breakdown`
|
||||
- Bug / failure / unexpected behavior → `debugging-and-error-recovery`
|
||||
- Code review → `code-review-and-quality`
|
||||
- Refactoring / simplification → `code-simplification`
|
||||
- API or interface design → `api-and-interface-design`
|
||||
- UI work → `frontend-ui-engineering`
|
||||
|
||||
### Lifecycle Mapping (Implicit Commands)
|
||||
|
||||
OpenCode does not support slash commands like `/spec` or `/plan`.
|
||||
|
||||
Instead, the agent must internally follow this lifecycle:
|
||||
|
||||
- DEFINE → `spec-driven-development`
|
||||
- PLAN → `planning-and-task-breakdown`
|
||||
- BUILD → `incremental-implementation` + `test-driven-development`
|
||||
- VERIFY → `debugging-and-error-recovery`
|
||||
- REVIEW → `code-review-and-quality`
|
||||
- SHIP → `shipping-and-launch`
|
||||
|
||||
### Execution Model
|
||||
|
||||
For every request:
|
||||
|
||||
1. Determine if any skill applies (even 1% chance)
|
||||
2. Invoke the appropriate skill using the `skill` tool
|
||||
3. Follow the skill workflow strictly
|
||||
4. Only proceed to implementation after required steps (spec, plan, etc.) are complete
|
||||
|
||||
### Anti-Rationalization
|
||||
|
||||
The following thoughts are incorrect and must be ignored:
|
||||
|
||||
- "This is too small for a skill"
|
||||
- "I can just quickly implement this"
|
||||
- "I’ll gather context first"
|
||||
|
||||
Correct behavior:
|
||||
|
||||
- Always check for and use skills first
|
||||
|
||||
This ensures OpenCode behaves similarly to Claude Code with full workflow enforcement.
|
||||
|
||||
## Orchestration: Personas, Skills, and Commands
|
||||
|
||||
This repo has three composable layers. They have different jobs and should not be confused:
|
||||
|
||||
- **Skills** (`skills/<name>/SKILL.md`) — workflows with steps and exit criteria. The *how*. Mandatory hops when an intent matches.
|
||||
- **Personas** (`agents/<role>.md`) — roles with a perspective and an output format. The *who*.
|
||||
- **Slash commands** (`.claude/commands/*.md`) — user-facing entry points. The *when*. The orchestration layer.
|
||||
|
||||
Composition rule: **the user (or a slash command) is the orchestrator. Personas do not invoke other personas.** A persona may invoke skills.
|
||||
|
||||
The only multi-persona orchestration pattern this repo endorses is **parallel fan-out with a merge step** — used by `/ship` to run `code-reviewer`, `security-auditor`, and `test-engineer` concurrently and synthesize their reports. Do not build a "router" persona that decides which other persona to call; that's the job of slash commands and intent mapping.
|
||||
|
||||
See [agents/README.md](agents/README.md) for the decision matrix and [references/orchestration-patterns.md](references/orchestration-patterns.md) for the full pattern catalog.
|
||||
|
||||
**Claude Code interop:** the personas in `agents/` work as Claude Code subagents (auto-discovered from this plugin's `agents/` directory) and as Agent Teams teammates (referenced by name when spawning). Two platform constraints align with our rules: subagents cannot spawn other subagents, and teams cannot nest. Plugin agents silently ignore the `hooks`, `mcpServers`, and `permissionMode` frontmatter fields.
|
||||
|
||||
## Creating a New Skill
|
||||
|
||||
### Directory Structure
|
||||
|
||||
```
|
||||
skills/
|
||||
{skill-name}/ # kebab-case directory name
|
||||
SKILL.md # Required: skill definition
|
||||
scripts/ # Required: executable scripts
|
||||
{script-name}.sh # Bash scripts (preferred)
|
||||
{skill-name}.zip # Required: packaged for distribution
|
||||
```
|
||||
|
||||
### Naming Conventions
|
||||
|
||||
- **Skill directory**: `kebab-case` (e.g. `web-quality`)
|
||||
- **SKILL.md**: Always uppercase, always this exact filename
|
||||
- **Scripts**: `kebab-case.sh` (e.g., `deploy.sh`, `fetch-logs.sh`)
|
||||
- **Zip file**: Must match directory name exactly: `{skill-name}.zip`
|
||||
|
||||
### SKILL.md Format
|
||||
|
||||
```markdown
|
||||
---
|
||||
name: {skill-name}
|
||||
description: {One sentence describing what the skill does, followed by one or more "Use when" trigger conditions. Include trigger phrases like "Deploy my app" or "Check logs" when helpful.}
|
||||
---
|
||||
|
||||
# {Skill Title}
|
||||
|
||||
{Brief overview of what the skill does and why it matters.}
|
||||
|
||||
## How It Works
|
||||
|
||||
{Numbered list explaining the skill's workflow}
|
||||
|
||||
Equivalent headings like `Workflow`, `Core Process`, or `When to Use` are fine when they communicate the same structure clearly.
|
||||
|
||||
## Usage (Optional)
|
||||
|
||||
Include this section only if the skill ships runnable helpers under `scripts/`. Markdown-only skills can omit both the section and the directory entirely.
|
||||
|
||||
```bash
|
||||
bash /mnt/skills/user/{skill-name}/scripts/{script}.sh [args]
|
||||
```
|
||||
|
||||
**Arguments:**
|
||||
- `arg1` - Description (defaults to X)
|
||||
|
||||
**Examples:**
|
||||
{Show 2-3 common usage patterns}
|
||||
|
||||
## Output
|
||||
|
||||
{Show example output users will see}
|
||||
|
||||
## Present Results to User
|
||||
|
||||
{Template for how Claude should format results when presenting to users}
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
{Common issues and solutions, especially network/permissions errors}
|
||||
```
|
||||
|
||||
### Best Practices for Context Efficiency
|
||||
|
||||
Skills are loaded on-demand — only the skill name and description are loaded at startup. The full `SKILL.md` loads into context only when the agent decides the skill is relevant. To minimize context usage:
|
||||
|
||||
- **Keep SKILL.md under 500 lines** — put detailed reference material in separate files
|
||||
- **Write specific descriptions** — helps the agent know exactly when to activate the skill
|
||||
- **Use progressive disclosure** — reference supporting files that get read only when needed
|
||||
- **Prefer scripts over inline code** — script execution doesn't consume context (only output does)
|
||||
- **File references work one level deep** — link directly from SKILL.md to supporting files
|
||||
|
||||
### Script Requirements
|
||||
|
||||
- Use `#!/bin/bash` shebang
|
||||
- Use `set -e` for fail-fast behavior
|
||||
- Write status messages to stderr: `echo "Message" >&2`
|
||||
- Write machine-readable output (JSON) to stdout
|
||||
- Include a cleanup trap for temp files
|
||||
- Reference the script path as `/mnt/skills/user/{skill-name}/scripts/{script}.sh`
|
||||
|
||||
### Creating the Zip Package
|
||||
|
||||
After creating or updating a skill:
|
||||
|
||||
```bash
|
||||
cd skills
|
||||
zip -r {skill-name}.zip {skill-name}/
|
||||
```
|
||||
|
||||
### End-User Installation
|
||||
|
||||
Document these two installation methods for users:
|
||||
|
||||
**Claude Code:**
|
||||
```bash
|
||||
cp -r skills/{skill-name} ~/.claude/skills/
|
||||
```
|
||||
|
||||
**claude.ai:**
|
||||
Add the skill to project knowledge or paste SKILL.md contents into the conversation.
|
||||
|
||||
If the skill requires network access, instruct users to add required domains at `claude.ai/settings/capabilities`.
|
||||
+10
-5
@@ -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,24 +14,27 @@ 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
|
||||
|
||||
FROM gcr.io/distroless/nodejs24-debian13:nonroot AS runtime
|
||||
FROM gcr.io/distroless/nodejs26-debian13:nonroot AS runtime
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
@@ -41,11 +44,13 @@ 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
|
||||
|
||||
EXPOSE 10712
|
||||
EXPOSE 3000
|
||||
|
||||
ENV NEW_RELIC_HOME=/app/apps/api \
|
||||
NEW_RELIC_APP_NAME=lolympus \
|
||||
|
||||
@@ -94,9 +94,8 @@ LOLYMPUS는 이 반복 작업을 줄이는 데 초점을 맞췄습니다. 운영
|
||||
- TypeScript
|
||||
- TanStack Query
|
||||
- NestJS
|
||||
- MongoDB
|
||||
- Redis
|
||||
- Redis 8.4 (경매 실시간 상태 전용)
|
||||
- MongoDB 8.3
|
||||
- Redis 8.10 (일반 캐시/스트림과 경매 실시간 상태 공유)
|
||||
- NATS
|
||||
- Riot API
|
||||
- pnpm workspace
|
||||
@@ -118,9 +117,9 @@ scripts/ deployment and maintenance scripts
|
||||
|
||||
- Node.js 24 이상
|
||||
- pnpm 10.4.1 (`packageManager` 기준, `corepack enable`로 활성화 권장)
|
||||
- MongoDB 7.0, 일반 캐시/스트림용 Redis, 경매 실시간 상태 전용 Redis 8.4, NATS 실행 환경
|
||||
- MongoDB 8.3, Redis 8.10, NATS 실행 환경
|
||||
|
||||
경매 Redis는 라이브 경매 상태의 source of truth로 사용되므로 일반 캐시/스트림 Redis와 물리적으로 분리해야 합니다. API는 `REDIS_URL`/`REDIS_ENDPOINT`와 별도로 `AUCTION_REDIS_URL`/`AUCTION_REDIS_ENDPOINT`를 읽고, 두 값이 같은 호스트/포트를 가리키면 부팅을 거부합니다.
|
||||
일반 캐시/스트림, 경매 실시간 상태, WebSocket Pub/Sub는 `GARNET_ENDPOINT`로 지정한 하나의 Redis 인스턴스를 공유합니다. 값은 `host:port`, `redis://...`, `rediss://...` 형식을 지원합니다. 인증이 필요하면 기존 `GARNET_USERID`(또는 `GARNET_USERNAME`)와 `GARNET_PASSWORD`를 설정합니다. `REDIS_*`, `AUCTION_REDIS_*`, `GARNET_URL` 연결 설정은 사용하지 않습니다. 경매 점검 스크립트도 같은 설정을 사용합니다.
|
||||
|
||||
## 실행 방법
|
||||
|
||||
@@ -132,6 +131,21 @@ pnpm start:web:dev
|
||||
|
||||
웹 앱은 기본적으로 `apps/web/.env.development` 값을 사용합니다. API 환경값은 `apps/project.env`와 실행 환경의 시크릿 설정을 함께 확인합니다.
|
||||
|
||||
### Redis 변경 검증
|
||||
|
||||
Redis 8.10.x의 `XREADGROUP CLAIM`, `XACKDEL ACKED`, `DELEX`, `SET IFEQ`, `INCREX`, `HSETEX`를 사용합니다. 스트림의 대기 읽기는 별도 연결에서 실행하며, 처리되지 않은 작업은 길이 제한을 초과해도 보존합니다.
|
||||
|
||||
```bash
|
||||
pnpm --filter api test -- --runInBand
|
||||
pnpm --filter api typecheck
|
||||
pnpm --filter api test:redis
|
||||
pnpm --filter api build
|
||||
```
|
||||
|
||||
`test:redis`는 PATH의 `redis-server` 또는 `REDIS_TEST_SERVER`에 지정한 실행 파일로 Redis 8.10.x를 직접 실행합니다. 임의의 로컬 포트와 일회용 암호를 사용하고, 저장을 비활성화하며, 종료 후 프로세스와 임시 디렉터리를 정리합니다. 애플리케이션 Redis 연결 설정은 사용하지 않습니다. Windows에서는 PowerShell에서 `$env:REDIS_TEST_SERVER = 'C:\tools\redis\redis-server.exe'`처럼 지정할 수 있습니다.
|
||||
|
||||
커뮤니티 통계 캐시는 `riot:communitystats:v2:{communityId}:scope` Hash로 전환됩니다. 항목별 TTL은 일반 5분, 완성된 상세 24시간, 미완성 상세 60초를 유지합니다. 이전 String 캐시는 기존 TTL로 만료되며 새 캐시는 첫 조회에 생성됩니다. 구버전과 신버전은 무효화 대상이 다르므로 API 인스턴스를 같은 버전으로 함께 전환해야 합니다. 구현 범위와 검증 기록은 [Redis 변경 계획](docs/plans/redis-8.10-optimization.md)을 참고하세요.
|
||||
|
||||
### API New Relic APM
|
||||
|
||||
API 서버는 `newrelic` Node.js agent를 앱 코드보다 먼저 preload합니다. Docker 런타임과 `pnpm start:api:*` 스크립트 모두 `NEW_RELIC_HOME`을 API 패키지로 지정해 `apps/api/newrelic.cjs` 설정을 읽습니다.
|
||||
@@ -164,6 +178,8 @@ API 성능 계측은 기본 비활성화이며 필요할 때 `API_PERF_OBSERVABI
|
||||
| `pnpm start:web:dev` | 웹 앱 개발 서버 실행 |
|
||||
| `pnpm start:api:dev` | API 서버 dev 환경 실행 |
|
||||
| `pnpm --filter api test` | API 테스트 실행 |
|
||||
| `pnpm --filter api typecheck` | 테스트를 포함한 API 타입 검사 |
|
||||
| `pnpm --filter api test:redis` | 격리된 Redis 8.10 통합 테스트 실행 |
|
||||
| `pnpm --filter api perf:routes` | API 성능 리포트 대상 route 출력 |
|
||||
| `pnpm --filter api perf:report` | API 성능 리포트 생성 |
|
||||
| `pnpm --filter web build:staging` | 웹 staging 빌드 검증 |
|
||||
|
||||
@@ -1,120 +0,0 @@
|
||||
# Agent Personas
|
||||
|
||||
Specialist personas that play a single role with a single perspective. Each persona is a Markdown file consumed as a system prompt by your harness (Claude Code, Cursor, Copilot, etc.).
|
||||
|
||||
| Persona | Role | Best for |
|
||||
|---------|------|----------|
|
||||
| [code-reviewer](code-reviewer.md) | Senior Staff Engineer | Five-axis review before merge |
|
||||
| [security-auditor](security-auditor.md) | Security Engineer | Vulnerability detection, OWASP-style audit |
|
||||
| [test-engineer](test-engineer.md) | QA Engineer | Test strategy, coverage analysis, Prove-It pattern |
|
||||
|
||||
## How personas relate to skills and commands
|
||||
|
||||
Three layers, each with a distinct job:
|
||||
|
||||
| Layer | What it is | Example | Composition role |
|
||||
|-------|-----------|---------|------------------|
|
||||
| **Skill** | A workflow with steps and exit criteria | `code-review-and-quality` | The *how* — invoked from inside a persona or command |
|
||||
| **Persona** | A role with a perspective and an output format | `code-reviewer` | The *who* — adopts a viewpoint, produces a report |
|
||||
| **Command** | A user-facing entry point | `/review`, `/ship` | The *when* — composes personas and skills |
|
||||
|
||||
The user (or a slash command) is the orchestrator. **Personas do not call other personas.** Skills are mandatory hops inside a persona's workflow.
|
||||
|
||||
## When to use each
|
||||
|
||||
### Direct persona invocation
|
||||
Pick this when you want one perspective on the current change and the user is in the loop.
|
||||
|
||||
- "Review this PR" → invoke `code-reviewer` directly
|
||||
- "Are there security issues in `auth.ts`?" → invoke `security-auditor` directly
|
||||
- "What tests are missing for the checkout flow?" → invoke `test-engineer` directly
|
||||
|
||||
### Slash command (single persona behind it)
|
||||
Pick this when there's a repeatable workflow you'd otherwise re-explain every time.
|
||||
|
||||
- `/review` → wraps `code-reviewer` with the project's review skill
|
||||
- `/test` → wraps `test-engineer` with TDD skill
|
||||
|
||||
### Slash command (orchestrator — fan-out)
|
||||
Pick this only when **independent** investigations can run in parallel and produce reports that a single agent then merges.
|
||||
|
||||
- `/ship` → fans out to `code-reviewer` + `security-auditor` + `test-engineer` in parallel, then synthesizes their reports into a go/no-go decision
|
||||
|
||||
This is the only orchestration pattern this repo endorses. See [references/orchestration-patterns.md](../references/orchestration-patterns.md) for the full pattern catalog and anti-patterns.
|
||||
|
||||
## Decision matrix
|
||||
|
||||
```
|
||||
Is the work a single perspective on a single artifact?
|
||||
├── Yes → Direct persona invocation
|
||||
└── No → Are the sub-tasks independent (no shared mutable state, no ordering)?
|
||||
├── Yes → Slash command with parallel fan-out (e.g. /ship)
|
||||
└── No → Sequential slash commands run by the user (/spec → /plan → /build → /test → /review)
|
||||
```
|
||||
|
||||
## Worked example: valid orchestration
|
||||
|
||||
`/ship` is the canonical fan-out orchestrator in this repo:
|
||||
|
||||
```
|
||||
/ship
|
||||
├── (parallel) code-reviewer → review report
|
||||
├── (parallel) security-auditor → audit report
|
||||
└── (parallel) test-engineer → coverage report
|
||||
↓
|
||||
merge phase (main agent)
|
||||
↓
|
||||
go/no-go decision + rollback plan
|
||||
```
|
||||
|
||||
Why this works:
|
||||
- Each sub-agent operates on the same diff but produces a **different perspective**
|
||||
- They have no dependencies on each other → genuine parallelism, real wall-clock savings
|
||||
- Each runs in a fresh context window → main session stays uncluttered
|
||||
- The merge step is small and benefits from full context, so it stays in the main agent
|
||||
|
||||
## Worked example: invalid orchestration (do not build this)
|
||||
|
||||
A `meta-orchestrator` persona whose job is "decide which other persona to call":
|
||||
|
||||
```
|
||||
/work-on-pr → meta-orchestrator
|
||||
↓ (decides "this needs a review")
|
||||
code-reviewer
|
||||
↓ (returns)
|
||||
meta-orchestrator (paraphrases result)
|
||||
↓
|
||||
user
|
||||
```
|
||||
|
||||
Why this fails:
|
||||
- Pure routing layer with no domain value
|
||||
- Adds two paraphrasing hops → information loss + 2× token cost
|
||||
- The user already knows they want a review; let them call `/review` directly
|
||||
- Replicates work that slash commands and `AGENTS.md` intent-mapping already do
|
||||
|
||||
## Rules for personas
|
||||
|
||||
1. A persona is a single role with a single output format. If you find yourself adding a second role, create a second persona.
|
||||
2. **Personas do not invoke other personas.** Composition is the job of slash commands or the user. On Claude Code this is also a hard platform constraint — *"subagents cannot spawn other subagents"* — so the rule is enforced for you.
|
||||
3. A persona may invoke skills (the *how*).
|
||||
4. Every persona file ends with a "Composition" block stating where it fits.
|
||||
|
||||
## Claude Code interop
|
||||
|
||||
The personas in this repo are designed to work as Claude Code subagents and as Agent Teams teammates without modification:
|
||||
|
||||
- **As subagents:** auto-discovered when this plugin is enabled (no path config needed). Use the Agent tool with `subagent_type: code-reviewer` (or `security-auditor`, `test-engineer`). `/ship` is the canonical example.
|
||||
- **As Agent Teams teammates** (experimental, requires `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`): reference the same persona name when spawning a teammate. The persona's body is **appended to** the teammate's system prompt as additional instructions (not a replacement), so your persona text sits on top of the team-coordination instructions the lead installs (SendMessage, task-list tools, etc.).
|
||||
|
||||
Subagents only report results back to the main agent. Agent Teams let teammates message each other directly. Use subagents when reports are enough; use Agent Teams when sub-agents need to challenge each other's findings (e.g. competing-hypothesis debugging). See [references/orchestration-patterns.md](../references/orchestration-patterns.md) for the full mapping.
|
||||
|
||||
Plugin agents do not support `hooks`, `mcpServers`, or `permissionMode` frontmatter — those fields are silently ignored. Avoid relying on them when authoring new personas here.
|
||||
|
||||
## Adding a new persona
|
||||
|
||||
1. Create `agents/<role>.md` with the same frontmatter format used by existing personas.
|
||||
2. Define the role, scope, output format, and rules.
|
||||
3. Add a **Composition** block at the bottom (Invoke directly when / Invoke via / Do not invoke from another persona).
|
||||
4. Add the persona to the table at the top of this file.
|
||||
5. If the persona enables a new orchestration pattern, document it in `references/orchestration-patterns.md` rather than inventing the pattern in the persona file itself.
|
||||
@@ -1,97 +0,0 @@
|
||||
---
|
||||
name: code-reviewer
|
||||
description: Senior code reviewer that evaluates changes across five dimensions — correctness, readability, architecture, security, and performance. Use for thorough code review before merge.
|
||||
---
|
||||
|
||||
# Senior Code Reviewer
|
||||
|
||||
You are an experienced Staff Engineer conducting a thorough code review. Your role is to evaluate the proposed changes and provide actionable, categorized feedback.
|
||||
|
||||
## Review Framework
|
||||
|
||||
Evaluate every change across these five dimensions:
|
||||
|
||||
### 1. Correctness
|
||||
- Does the code do what the spec/task says it should?
|
||||
- Are edge cases handled (null, empty, boundary values, error paths)?
|
||||
- Do the tests actually verify the behavior? Are they testing the right things?
|
||||
- Are there race conditions, off-by-one errors, or state inconsistencies?
|
||||
|
||||
### 2. Readability
|
||||
- Can another engineer understand this without explanation?
|
||||
- Are names descriptive and consistent with project conventions?
|
||||
- Is the control flow straightforward (no deeply nested logic)?
|
||||
- Is the code well-organized (related code grouped, clear boundaries)?
|
||||
|
||||
### 3. Architecture
|
||||
- Does the change follow existing patterns or introduce a new one?
|
||||
- If a new pattern, is it justified and documented?
|
||||
- Are module boundaries maintained? Any circular dependencies?
|
||||
- Is the abstraction level appropriate (not over-engineered, not too coupled)?
|
||||
- Are dependencies flowing in the right direction?
|
||||
|
||||
### 4. Security
|
||||
- Is user input validated and sanitized at system boundaries?
|
||||
- Are secrets kept out of code, logs, and version control?
|
||||
- Is authentication/authorization checked where needed?
|
||||
- Are queries parameterized? Is output encoded?
|
||||
- Any new dependencies with known vulnerabilities?
|
||||
|
||||
### 5. Performance
|
||||
- Any N+1 query patterns?
|
||||
- Any unbounded loops or unconstrained data fetching?
|
||||
- Any synchronous operations that should be async?
|
||||
- Any unnecessary re-renders (in UI components)?
|
||||
- Any missing pagination on list endpoints?
|
||||
|
||||
## Output Format
|
||||
|
||||
Categorize every finding:
|
||||
|
||||
**Critical** — Must fix before merge (security vulnerability, data loss risk, broken functionality)
|
||||
|
||||
**Important** — Should fix before merge (missing test, wrong abstraction, poor error handling)
|
||||
|
||||
**Suggestion** — Consider for improvement (naming, code style, optional optimization)
|
||||
|
||||
## Review Output Template
|
||||
|
||||
```markdown
|
||||
## Review Summary
|
||||
|
||||
**Verdict:** APPROVE | REQUEST CHANGES
|
||||
|
||||
**Overview:** [1-2 sentences summarizing the change and overall assessment]
|
||||
|
||||
### Critical Issues
|
||||
- [File:line] [Description and recommended fix]
|
||||
|
||||
### Important Issues
|
||||
- [File:line] [Description and recommended fix]
|
||||
|
||||
### Suggestions
|
||||
- [File:line] [Description]
|
||||
|
||||
### What's Done Well
|
||||
- [Positive observation — always include at least one]
|
||||
|
||||
### Verification Story
|
||||
- Tests reviewed: [yes/no, observations]
|
||||
- Build verified: [yes/no]
|
||||
- Security checked: [yes/no, observations]
|
||||
```
|
||||
|
||||
## Rules
|
||||
|
||||
1. Review the tests first — they reveal intent and coverage
|
||||
2. Read the spec or task description before reviewing code
|
||||
3. Every Critical and Important finding should include a specific fix recommendation
|
||||
4. Don't approve code with Critical issues
|
||||
5. Acknowledge what's done well — specific praise motivates good practices
|
||||
6. If you're uncertain about something, say so and suggest investigation rather than guessing
|
||||
|
||||
## Composition
|
||||
|
||||
- **Invoke directly when:** the user asks for a review of a specific change, file, or PR.
|
||||
- **Invoke via:** `/review` (single-perspective review) or `/ship` (parallel fan-out alongside `security-auditor` and `test-engineer`).
|
||||
- **Do not invoke from another persona.** If you find yourself wanting to delegate to `security-auditor` or `test-engineer`, surface that as a recommendation in your report instead — orchestration belongs to slash commands, not personas. See [agents/README.md](README.md).
|
||||
@@ -1,101 +0,0 @@
|
||||
---
|
||||
name: security-auditor
|
||||
description: Security engineer focused on vulnerability detection, threat modeling, and secure coding practices. Use for security-focused code review, threat analysis, or hardening recommendations.
|
||||
---
|
||||
|
||||
# Security Auditor
|
||||
|
||||
You are an experienced Security Engineer conducting a security review. Your role is to identify vulnerabilities, assess risk, and recommend mitigations. You focus on practical, exploitable issues rather than theoretical risks.
|
||||
|
||||
## Review Scope
|
||||
|
||||
### 1. Input Handling
|
||||
- Is all user input validated at system boundaries?
|
||||
- Are there injection vectors (SQL, NoSQL, OS command, LDAP)?
|
||||
- Is HTML output encoded to prevent XSS?
|
||||
- Are file uploads restricted by type, size, and content?
|
||||
- Are URL redirects validated against an allowlist?
|
||||
|
||||
### 2. Authentication & Authorization
|
||||
- Are passwords hashed with a strong algorithm (bcrypt, scrypt, argon2)?
|
||||
- Are sessions managed securely (httpOnly, secure, sameSite cookies)?
|
||||
- Is authorization checked on every protected endpoint?
|
||||
- Can users access resources belonging to other users (IDOR)?
|
||||
- Are password reset tokens time-limited and single-use?
|
||||
- Is rate limiting applied to authentication endpoints?
|
||||
|
||||
### 3. Data Protection
|
||||
- Are secrets in environment variables (not code)?
|
||||
- Are sensitive fields excluded from API responses and logs?
|
||||
- Is data encrypted in transit (HTTPS) and at rest (if required)?
|
||||
- Is PII handled according to applicable regulations?
|
||||
- Are database backups encrypted?
|
||||
|
||||
### 4. Infrastructure
|
||||
- Are security headers configured (CSP, HSTS, X-Frame-Options)?
|
||||
- Is CORS restricted to specific origins?
|
||||
- Are dependencies audited for known vulnerabilities?
|
||||
- Are error messages generic (no stack traces or internal details to users)?
|
||||
- Is the principle of least privilege applied to service accounts?
|
||||
|
||||
### 5. Third-Party Integrations
|
||||
- Are API keys and tokens stored securely?
|
||||
- Are webhook payloads verified (signature validation)?
|
||||
- Are third-party scripts loaded from trusted CDNs with integrity hashes?
|
||||
- Are OAuth flows using PKCE and state parameters?
|
||||
|
||||
## Severity Classification
|
||||
|
||||
| Severity | Criteria | Action |
|
||||
|----------|----------|--------|
|
||||
| **Critical** | Exploitable remotely, leads to data breach or full compromise | Fix immediately, block release |
|
||||
| **High** | Exploitable with some conditions, significant data exposure | Fix before release |
|
||||
| **Medium** | Limited impact or requires authenticated access to exploit | Fix in current sprint |
|
||||
| **Low** | Theoretical risk or defense-in-depth improvement | Schedule for next sprint |
|
||||
| **Info** | Best practice recommendation, no current risk | Consider adopting |
|
||||
|
||||
## Output Format
|
||||
|
||||
```markdown
|
||||
## Security Audit Report
|
||||
|
||||
### Summary
|
||||
- Critical: [count]
|
||||
- High: [count]
|
||||
- Medium: [count]
|
||||
- Low: [count]
|
||||
|
||||
### Findings
|
||||
|
||||
#### [CRITICAL] [Finding title]
|
||||
- **Location:** [file:line]
|
||||
- **Description:** [What the vulnerability is]
|
||||
- **Impact:** [What an attacker could do]
|
||||
- **Proof of concept:** [How to exploit it]
|
||||
- **Recommendation:** [Specific fix with code example]
|
||||
|
||||
#### [HIGH] [Finding title]
|
||||
...
|
||||
|
||||
### Positive Observations
|
||||
- [Security practices done well]
|
||||
|
||||
### Recommendations
|
||||
- [Proactive improvements to consider]
|
||||
```
|
||||
|
||||
## Rules
|
||||
|
||||
1. Focus on exploitable vulnerabilities, not theoretical risks
|
||||
2. Every finding must include a specific, actionable recommendation
|
||||
3. Provide proof of concept or exploitation scenario for Critical/High findings
|
||||
4. Acknowledge good security practices — positive reinforcement matters
|
||||
5. Check the OWASP Top 10 as a minimum baseline
|
||||
6. Review dependencies for known CVEs
|
||||
7. Never suggest disabling security controls as a "fix"
|
||||
|
||||
## Composition
|
||||
|
||||
- **Invoke directly when:** the user wants a security-focused pass on a specific change, file, or system component.
|
||||
- **Invoke via:** `/ship` (parallel fan-out alongside `code-reviewer` and `test-engineer`), or any future `/audit` command.
|
||||
- **Do not invoke from another persona.** If `code-reviewer` flags something that warrants a deeper security pass, the user or a slash command initiates that pass — not the reviewer. See [agents/README.md](README.md).
|
||||
@@ -1,95 +0,0 @@
|
||||
---
|
||||
name: test-engineer
|
||||
description: QA engineer specialized in test strategy, test writing, and coverage analysis. Use for designing test suites, writing tests for existing code, or evaluating test quality.
|
||||
---
|
||||
|
||||
# Test Engineer
|
||||
|
||||
You are an experienced QA Engineer focused on test strategy and quality assurance. Your role is to design test suites, write tests, analyze coverage gaps, and ensure that code changes are properly verified.
|
||||
|
||||
## Approach
|
||||
|
||||
### 1. Analyze Before Writing
|
||||
|
||||
Before writing any test:
|
||||
- Read the code being tested to understand its behavior
|
||||
- Identify the public API / interface (what to test)
|
||||
- Identify edge cases and error paths
|
||||
- Check existing tests for patterns and conventions
|
||||
|
||||
### 2. Test at the Right Level
|
||||
|
||||
```
|
||||
Pure logic, no I/O → Unit test
|
||||
Crosses a boundary → Integration test
|
||||
Critical user flow → E2E test
|
||||
```
|
||||
|
||||
Test at the lowest level that captures the behavior. Don't write E2E tests for things unit tests can cover.
|
||||
|
||||
### 3. Follow the Prove-It Pattern for Bugs
|
||||
|
||||
When asked to write a test for a bug:
|
||||
1. Write a test that demonstrates the bug (must FAIL with current code)
|
||||
2. Confirm the test fails
|
||||
3. Report the test is ready for the fix implementation
|
||||
|
||||
### 4. Write Descriptive Tests
|
||||
|
||||
```
|
||||
describe('[Module/Function name]', () => {
|
||||
it('[expected behavior in plain English]', () => {
|
||||
// Arrange → Act → Assert
|
||||
});
|
||||
});
|
||||
```
|
||||
|
||||
### 5. Cover These Scenarios
|
||||
|
||||
For every function or component:
|
||||
|
||||
| Scenario | Example |
|
||||
|----------|---------|
|
||||
| Happy path | Valid input produces expected output |
|
||||
| Empty input | Empty string, empty array, null, undefined |
|
||||
| Boundary values | Min, max, zero, negative |
|
||||
| Error paths | Invalid input, network failure, timeout |
|
||||
| Concurrency | Rapid repeated calls, out-of-order responses |
|
||||
|
||||
## Output Format
|
||||
|
||||
When analyzing test coverage:
|
||||
|
||||
```markdown
|
||||
## Test Coverage Analysis
|
||||
|
||||
### Current Coverage
|
||||
- [X] tests covering [Y] functions/components
|
||||
- Coverage gaps identified: [list]
|
||||
|
||||
### Recommended Tests
|
||||
1. **[Test name]** — [What it verifies, why it matters]
|
||||
2. **[Test name]** — [What it verifies, why it matters]
|
||||
|
||||
### Priority
|
||||
- Critical: [Tests that catch potential data loss or security issues]
|
||||
- High: [Tests for core business logic]
|
||||
- Medium: [Tests for edge cases and error handling]
|
||||
- Low: [Tests for utility functions and formatting]
|
||||
```
|
||||
|
||||
## Rules
|
||||
|
||||
1. Test behavior, not implementation details
|
||||
2. Each test should verify one concept
|
||||
3. Tests should be independent — no shared mutable state between tests
|
||||
4. Avoid snapshot tests unless reviewing every change to the snapshot
|
||||
5. Mock at system boundaries (database, network), not between internal functions
|
||||
6. Every test name should read like a specification
|
||||
7. A test that never fails is as useless as a test that always fails
|
||||
|
||||
## Composition
|
||||
|
||||
- **Invoke directly when:** the user asks for test design, coverage analysis, or a Prove-It test for a specific bug.
|
||||
- **Invoke via:** `/test` (TDD workflow) or `/ship` (parallel fan-out for coverage gap analysis alongside `code-reviewer` and `security-auditor`).
|
||||
- **Do not invoke from another persona.** Recommendations to add tests belong in your report; the user or a slash command decides when to act on them. See [agents/README.md](README.md).
|
||||
@@ -62,8 +62,61 @@ $ pnpm run test:e2e
|
||||
|
||||
# test coverage
|
||||
$ pnpm run test:cov
|
||||
|
||||
# auction cancellation/undo transactions against a real local MongoDB replica set
|
||||
$ pnpm run test:mongodb
|
||||
```
|
||||
|
||||
`test:mongodb` requires `mongod` on PATH, or `MONGODB_TEST_SERVER` set to its
|
||||
executable path. The runner starts an isolated replica set on a random loopback
|
||||
port, uses a temporary database directory, and removes it after the tests. It
|
||||
does not use the application's database connection settings.
|
||||
|
||||
## Auction durability
|
||||
|
||||
Accepted Redis bids now enter `auction:bidArchivePayloads` and
|
||||
`auction:bidArchiveQueue` atomically with the bid. The durability scheduler saves
|
||||
them to `auctionBidRecords` using deterministic IDs before removing queue entries.
|
||||
Recent state snapshots remain capped at 1000 bids; the archive is not capped and
|
||||
retains accepted bids across undo/cancellation for audit. These records begin with
|
||||
this deployment; bids already discarded by an older version cannot be recovered.
|
||||
`GET /communities/:communityId/matches/:matchId/auction/bids/history` pages through
|
||||
the current lifecycle's persisted archive using `afterRevision` and `limit` (1–200).
|
||||
Persistence is asynchronous, so an empty last page may gain entries afterward.
|
||||
|
||||
Invalid archive entries are moved atomically to `auction:bidArchiveDeadLetterQueue`
|
||||
and `auction:bidArchiveDeadLetterPayloads`. The payload stores the original text
|
||||
(or `null` for a missing payload), error, ID, and quarantine time. Monitor these
|
||||
keys and review quarantined data before repairing/requeuing it; it is not retried
|
||||
automatically or expired. Other bids continue to persist. Mongo write failures
|
||||
leave valid entries in the pending queue for idempotent retries.
|
||||
|
||||
Older in-flight rounds can produce `bidRoundId: ''`; the archive treats this as
|
||||
an absent optional round ID. Empty player IDs and other invalid field types
|
||||
remain validation errors.
|
||||
|
||||
Cancellation commits its completion marker and pending cleanup fields in Match.
|
||||
The scheduler retries cleanup after restarts, with a delay capped at 60 seconds.
|
||||
Reset notifications include the lifecycle to protect a newly started auction.
|
||||
Dead-letter status notifications use `auction:deadLetterStatusQueue`; failures to
|
||||
persist or mirror the terminal status are retried without rerunning the side effect.
|
||||
Older side-effect dead letters are also reconciled automatically.
|
||||
|
||||
Before deploying the cleanup worker, create its partial Match index using the
|
||||
additive, repeatable migration below. Schema declarations alone do not create
|
||||
indexes when `MONGODB_AUTO_INDEX` is disabled (the default). Choose the target
|
||||
environment explicitly; dry-run does not create indexes or modify documents.
|
||||
|
||||
```bash
|
||||
pnpm --filter api auction:indexes -- --env staging --dry-run
|
||||
pnpm --filter api auction:indexes -- --env staging --apply
|
||||
# Use --env prod for production.
|
||||
```
|
||||
|
||||
The index is `{ auctionCancellationCleanupRetryAt: 1 }`, restricted to
|
||||
`{ auctionCancellationCleanupPending: true }`. The worker only reads due pending
|
||||
entries; it no longer scans legacy cancellation markers without a pending flag.
|
||||
|
||||
## Deployment
|
||||
|
||||
When you're ready to deploy your NestJS application to production, there are some key steps you can take to ensure it runs as efficiently as possible. Check out the [deployment documentation](https://docs.nestjs.com/deployment) for more information.
|
||||
|
||||
@@ -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',
|
||||
},
|
||||
},
|
||||
);
|
||||
+15
-9
@@ -8,6 +8,8 @@
|
||||
"scripts": {
|
||||
"build": "nest build",
|
||||
"format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
|
||||
"competition:migrate": "ts-node src/modules/global/database/migrations/run-competition-domain.ts",
|
||||
"auction:indexes": "ts-node src/modules/global/database/migrations/run-auction-cancellation-index.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",
|
||||
@@ -21,26 +23,30 @@
|
||||
"start:debug": "nest start --debug --watch",
|
||||
"lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
|
||||
"test": "jest",
|
||||
"typecheck": "tsc --noEmit --incremental false",
|
||||
"test:redis": "node test/run-redis-tests.mjs",
|
||||
"test:mongodb": "node test/run-mongo-tests.mjs",
|
||||
"test:watch": "jest --watch",
|
||||
"test:cov": "jest --coverage",
|
||||
"test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
|
||||
"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 +61,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({
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
import mongoose from 'mongoose';
|
||||
import { AuctionBidArchiveService } from './auction-bid-archive.service';
|
||||
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
|
||||
function bid(overrides: Record<string, unknown> = {}) {
|
||||
return {
|
||||
_id: `${matchId}:life:${String(1).padStart(16, '0')}`,
|
||||
matchId,
|
||||
auctionLifecycleId: 'life',
|
||||
revision: 1,
|
||||
bidRequestId: 'bid-1',
|
||||
bidderUserId: new mongoose.Types.ObjectId().toString(),
|
||||
playerUserId: new mongoose.Types.ObjectId().toString(),
|
||||
bidderTeamIndex: 1,
|
||||
bidPointAmount: 10,
|
||||
bidPlacedAtTimestampMS: 1_700_000_000_000,
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
function fixture(payload: Record<string, unknown>) {
|
||||
const raw = JSON.stringify(payload);
|
||||
const commands: string[][] = [];
|
||||
const sendCommand = jest.fn(async (command: string[]) => {
|
||||
commands.push(command);
|
||||
if (command[0] === 'ZRANGE') return [payload._id];
|
||||
if (command[0] === 'HMGET') return [raw];
|
||||
return 1;
|
||||
});
|
||||
const bulkWrite = jest.fn(async (operations: unknown[]) => ({
|
||||
matchedCount: 0,
|
||||
upsertedCount: operations.length,
|
||||
}));
|
||||
const service = new AuctionBidArchiveService(
|
||||
{ getModel: async () => ({ bulkWrite }) } as never,
|
||||
{ raw: () => ({ sendCommand }) } as never,
|
||||
);
|
||||
return { service, bulkWrite, commands };
|
||||
}
|
||||
|
||||
function savedEvent(bulkWrite: jest.Mock) {
|
||||
const [[operations]] = bulkWrite.mock.calls as unknown as [
|
||||
[
|
||||
Array<{
|
||||
updateOne: { update: { $setOnInsert: Record<string, unknown> } };
|
||||
}>,
|
||||
],
|
||||
];
|
||||
return operations[0].updateOne.update.$setOnInsert;
|
||||
}
|
||||
|
||||
function quarantined(commands: string[][]) {
|
||||
return commands.some(
|
||||
(command) =>
|
||||
command[0] === 'EVAL' &&
|
||||
command[1].includes("redis.call('ZADD', KEYS[4]"),
|
||||
);
|
||||
}
|
||||
|
||||
it('archives a pre-upgrade bid with an empty round ID without the field', async () => {
|
||||
const f = fixture(bid({ bidRoundId: '' }));
|
||||
await expect(f.service.persistPendingBids()).resolves.toBe(1);
|
||||
expect(quarantined(f.commands)).toBe(false);
|
||||
expect(savedEvent(f.bulkWrite)).not.toHaveProperty('bidRoundId');
|
||||
});
|
||||
|
||||
it('keeps a non-empty round ID on the archived bid', async () => {
|
||||
const f = fixture(bid({ bidRoundId: 'round-1' }));
|
||||
await expect(f.service.persistPendingBids()).resolves.toBe(1);
|
||||
expect(savedEvent(f.bulkWrite)).toMatchObject({ bidRoundId: 'round-1' });
|
||||
});
|
||||
|
||||
it.each([' ', null, 1])(
|
||||
'still quarantines an invalid round ID %j',
|
||||
async (bidRoundId) => {
|
||||
const f = fixture(bid({ bidRoundId }));
|
||||
await expect(f.service.persistPendingBids()).resolves.toBe(0);
|
||||
expect(f.bulkWrite).not.toHaveBeenCalled();
|
||||
expect(quarantined(f.commands)).toBe(true);
|
||||
},
|
||||
);
|
||||
@@ -0,0 +1,242 @@
|
||||
import {
|
||||
BadRequestException,
|
||||
Injectable,
|
||||
Logger,
|
||||
NotFoundException,
|
||||
} from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import type { AuctionBidRecord } from '../global/database/schema';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import { AuctionRedisService } from './redis/auction-redis.service';
|
||||
import {
|
||||
AUCTION_BID_ARCHIVE_PAYLOADS_KEY,
|
||||
AUCTION_BID_ARCHIVE_QUEUE_KEY,
|
||||
AUCTION_BID_ARCHIVE_DEAD_LETTER_QUEUE_KEY,
|
||||
AUCTION_BID_ARCHIVE_DEAD_LETTER_PAYLOADS_KEY,
|
||||
} from './redis/auction-redis.keys';
|
||||
|
||||
// Compare the payload as well as the ID: a concurrent repair must not be moved
|
||||
// or acknowledged by a worker that read an older value.
|
||||
const QUARANTINE_BID_ARCHIVE_SCRIPT = `
|
||||
local moved = 0
|
||||
for i = 2, #ARGV, 4 do
|
||||
local current = redis.call('HGET', KEYS[1], ARGV[i])
|
||||
local matches = (ARGV[i+1] == '0' and current == false) or (ARGV[i+1] == '1' and current == ARGV[i+2])
|
||||
if matches and redis.call('ZSCORE', KEYS[2], ARGV[i]) then
|
||||
redis.call('HSET', KEYS[3], ARGV[i], ARGV[i+3])
|
||||
redis.call('ZADD', KEYS[4], ARGV[1], ARGV[i])
|
||||
redis.call('HDEL', KEYS[1], ARGV[i])
|
||||
redis.call('ZREM', KEYS[2], ARGV[i])
|
||||
moved = moved + 1
|
||||
end
|
||||
end
|
||||
return moved
|
||||
`;
|
||||
|
||||
@Injectable()
|
||||
export class AuctionBidArchiveService {
|
||||
private readonly logger = new Logger(AuctionBidArchiveService.name);
|
||||
|
||||
constructor(
|
||||
private readonly database: ConnectionService,
|
||||
private readonly redis: AuctionRedisService,
|
||||
) {}
|
||||
|
||||
public async persistPendingBids(limit = 200): Promise<number> {
|
||||
const client = this.redis.raw();
|
||||
const reply = await client.sendCommand([
|
||||
'ZRANGE',
|
||||
AUCTION_BID_ARCHIVE_QUEUE_KEY,
|
||||
'0',
|
||||
String(limit - 1),
|
||||
]);
|
||||
const ids = Array.isArray(reply) ? reply.map(String) : [];
|
||||
if (!ids.length) return 0;
|
||||
const values = await client.sendCommand<Array<string | null>>([
|
||||
'HMGET',
|
||||
AUCTION_BID_ARCHIVE_PAYLOADS_KEY,
|
||||
...ids,
|
||||
]);
|
||||
const valid: Array<{ event: AuctionBidRecord; raw: string }> = [];
|
||||
const invalid: Array<{ id: string; raw: string | null; error: string }> =
|
||||
[];
|
||||
for (let index = 0; index < ids.length; index++) {
|
||||
const raw = values[index] ?? null;
|
||||
try {
|
||||
valid.push({ event: parseBidArchiveEvent(ids[index], raw), raw: raw! });
|
||||
} catch (error) {
|
||||
invalid.push({
|
||||
id: ids[index],
|
||||
raw,
|
||||
error: String(error).slice(0, 2000),
|
||||
});
|
||||
}
|
||||
}
|
||||
if (invalid.length) {
|
||||
const now = Date.now();
|
||||
const moved = await client.sendCommand<number>([
|
||||
'EVAL',
|
||||
QUARANTINE_BID_ARCHIVE_SCRIPT,
|
||||
'4',
|
||||
AUCTION_BID_ARCHIVE_PAYLOADS_KEY,
|
||||
AUCTION_BID_ARCHIVE_QUEUE_KEY,
|
||||
AUCTION_BID_ARCHIVE_DEAD_LETTER_PAYLOADS_KEY,
|
||||
AUCTION_BID_ARCHIVE_DEAD_LETTER_QUEUE_KEY,
|
||||
String(now),
|
||||
...invalid.flatMap(({ id, raw, error }) => [
|
||||
id,
|
||||
raw === null ? '0' : '1',
|
||||
raw ?? '',
|
||||
JSON.stringify({
|
||||
id,
|
||||
rawPayload: raw,
|
||||
error,
|
||||
quarantinedAtTimestampMS: now,
|
||||
}),
|
||||
]),
|
||||
]);
|
||||
if (moved > 0)
|
||||
this.logger.warn(`Quarantined ${moved} invalid bid archive events.`);
|
||||
}
|
||||
if (valid.length) {
|
||||
const model = await this.database.getModel('auctionBidRecord');
|
||||
// The deterministic _id is the dedupe key, including after a crash between
|
||||
// Mongo acknowledgement and Redis cleanup. Never trim unpersisted events.
|
||||
const result = await model.bulkWrite(
|
||||
valid.map(({ event }) => ({
|
||||
updateOne: {
|
||||
filter: { _id: event._id },
|
||||
update: { $setOnInsert: event },
|
||||
upsert: true,
|
||||
},
|
||||
})),
|
||||
{ ordered: false, throwOnValidationError: true },
|
||||
);
|
||||
// A partial/ambiguous write leaves valid entries queued. Replaying the
|
||||
// upserts is safe; assuming that a resolved bulkWrite saved all is not.
|
||||
if (result.matchedCount + result.upsertedCount !== valid.length) {
|
||||
throw new Error(
|
||||
'Bid archive batch was not fully acknowledged by MongoDB.',
|
||||
);
|
||||
}
|
||||
await client.sendCommand([
|
||||
'EVAL',
|
||||
"for i = 1, #ARGV, 2 do if redis.call('HGET', KEYS[1], ARGV[i]) == ARGV[i+1] then redis.call('HDEL', KEYS[1], ARGV[i]); redis.call('ZREM', KEYS[2], ARGV[i]) end end return 1",
|
||||
'2',
|
||||
AUCTION_BID_ARCHIVE_PAYLOADS_KEY,
|
||||
AUCTION_BID_ARCHIVE_QUEUE_KEY,
|
||||
...valid.flatMap(({ event, raw }) => [event._id, raw]),
|
||||
]);
|
||||
}
|
||||
return valid.length;
|
||||
}
|
||||
|
||||
public async list(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
afterRevision = -1,
|
||||
limit = 100,
|
||||
) {
|
||||
if (
|
||||
!Number.isSafeInteger(afterRevision) ||
|
||||
afterRevision < -1 ||
|
||||
!Number.isSafeInteger(limit) ||
|
||||
limit < 1 ||
|
||||
limit > 200
|
||||
) {
|
||||
throw new BadRequestException('Invalid bid history cursor or limit.');
|
||||
}
|
||||
const AuctionModel = await this.database.getModel('auction');
|
||||
const auction = await AuctionModel.findOne({ matchId })
|
||||
.select({ auctionLifecycleId: 1 })
|
||||
.lean()
|
||||
.exec();
|
||||
if (!auction) throw new NotFoundException('Auction not found.');
|
||||
const prefix = `${matchId.toString()}:${auction.auctionLifecycleId}:`;
|
||||
const model = await this.database.getModel('auctionBidRecord');
|
||||
// The built-in _id index supports ordered pagination without an additional
|
||||
// production index or an unbounded array inside an Auction document.
|
||||
const items = await model
|
||||
.find({
|
||||
_id: {
|
||||
$gt:
|
||||
afterRevision < 0
|
||||
? prefix
|
||||
: prefix + String(afterRevision).padStart(16, '0'),
|
||||
$lt: prefix + '\uffff',
|
||||
},
|
||||
})
|
||||
.sort({ _id: 1 })
|
||||
.limit(limit + 1)
|
||||
.lean()
|
||||
.exec();
|
||||
const hasMore = items.length > limit;
|
||||
if (hasMore) items.pop();
|
||||
return {
|
||||
items,
|
||||
hasMore,
|
||||
nextRevision: items.at(-1)?.revision ?? afterRevision,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
function parseBidArchiveEvent(
|
||||
id: string,
|
||||
raw: string | null,
|
||||
): AuctionBidRecord {
|
||||
if (raw === null) throw new Error('Missing bid archive payload.');
|
||||
const value: unknown = JSON.parse(raw);
|
||||
if (!value || typeof value !== 'object' || Array.isArray(value)) {
|
||||
throw new Error('Bid archive payload must be an object.');
|
||||
}
|
||||
const event = value as Record<string, unknown>;
|
||||
const string = (field: string): string => {
|
||||
const value = event[field];
|
||||
if (typeof value !== 'string' || !value.trim()) {
|
||||
throw new Error(`Invalid bid archive ${field}.`);
|
||||
}
|
||||
return value;
|
||||
};
|
||||
const integer = (field: string, minimum = 0): number => {
|
||||
const value = event[field];
|
||||
if (
|
||||
typeof value !== 'number' ||
|
||||
!Number.isSafeInteger(value) ||
|
||||
value < minimum
|
||||
) {
|
||||
throw new Error(`Invalid bid archive ${field}.`);
|
||||
}
|
||||
return value;
|
||||
};
|
||||
const objectId = (field: string): mongoose.Types.ObjectId => {
|
||||
const value = string(field);
|
||||
if (!mongoose.isObjectIdOrHexString(value)) {
|
||||
throw new Error(`Invalid bid archive ${field}.`);
|
||||
}
|
||||
return new mongoose.Types.ObjectId(value);
|
||||
};
|
||||
const matchId = objectId('matchId');
|
||||
const auctionLifecycleId = string('auctionLifecycleId');
|
||||
const revision = integer('revision');
|
||||
const expectedId = `${matchId.toString()}:${auctionLifecycleId}:${String(revision).padStart(16, '0')}`;
|
||||
if (event._id !== id || id !== expectedId) {
|
||||
throw new Error('Bid archive identity does not match its payload.');
|
||||
}
|
||||
return {
|
||||
_id: id,
|
||||
matchId,
|
||||
auctionLifecycleId,
|
||||
revision,
|
||||
bidRequestId: string('bidRequestId'),
|
||||
bidderUserId: objectId('bidderUserId'),
|
||||
bidderTeamIndex: integer('bidderTeamIndex', 1),
|
||||
bidPointAmount: integer('bidPointAmount'),
|
||||
bidPlacedAtTimestampMS: integer('bidPlacedAtTimestampMS'),
|
||||
...(event.playerUserId !== undefined
|
||||
? { playerUserId: objectId('playerUserId') }
|
||||
: {}),
|
||||
// Pre-upgrade rounds have no Redis round ID; the bid Lua records ''.
|
||||
...(event.bidRoundId !== undefined && event.bidRoundId !== ''
|
||||
? { bidRoundId: string('bidRoundId') }
|
||||
: {}),
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,154 @@
|
||||
import { NotFoundException } from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import { AuctionService } from './auction.service';
|
||||
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
|
||||
function sessionQuery<T>(value: T) {
|
||||
return { session: async () => value };
|
||||
}
|
||||
|
||||
function fixture(options: {
|
||||
auction: Record<string, unknown> | null;
|
||||
match: Record<string, unknown>;
|
||||
failRedisCleanup?: boolean;
|
||||
}) {
|
||||
const session = {
|
||||
startTransaction: jest.fn(),
|
||||
commitTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
abortTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
endSession: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const deleteMany = jest.fn(() => sessionQuery(undefined));
|
||||
const models: Record<string, unknown> = {
|
||||
auction: { findOne: () => sessionQuery(options.auction) },
|
||||
auctionHistory: { deleteMany },
|
||||
auctionSideEffectApplication: { deleteMany },
|
||||
match: { findById: () => sessionQuery(options.match) },
|
||||
};
|
||||
const redisCommands: string[][] = [];
|
||||
const sendCommand = jest.fn(async (command: string[]) => {
|
||||
redisCommands.push(command);
|
||||
if (command[0] === 'EVAL' && options.failRedisCleanup)
|
||||
throw new Error('redis unavailable');
|
||||
return command[0] === 'SCAN' ? ['0', []] : 1;
|
||||
});
|
||||
const service = new AuctionService(
|
||||
{
|
||||
getModel: async (name: string) => models[name],
|
||||
createSession: async () => session,
|
||||
} as never,
|
||||
{} as never,
|
||||
{ releaseFromMatch: jest.fn().mockResolvedValue(undefined) } as never,
|
||||
{ cancelPolling: jest.fn().mockResolvedValue(undefined) } as never,
|
||||
{
|
||||
acquireTokenLock: async () => true,
|
||||
releaseTokenLock: async () => true,
|
||||
raw: () => ({ sendCommand }),
|
||||
} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
return { service, session, redisCommands };
|
||||
}
|
||||
|
||||
function liveMatch(): Record<string, unknown> {
|
||||
return {
|
||||
communityId,
|
||||
status: 'team-built',
|
||||
teams: [],
|
||||
tournamentCodeIds: [],
|
||||
gameSchedule: [],
|
||||
participants: [],
|
||||
save: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
}
|
||||
|
||||
function redisAuction() {
|
||||
return {
|
||||
_id: new mongoose.Types.ObjectId(),
|
||||
auctionEngineVersion: 'redis-v1',
|
||||
auctionLifecycleId: 'life',
|
||||
deleteOne: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
}
|
||||
|
||||
it('records the cancelled lifecycle and still succeeds when Redis cleanup fails', async () => {
|
||||
const match = liveMatch();
|
||||
const f = fixture({
|
||||
auction: redisAuction(),
|
||||
match,
|
||||
failRedisCleanup: true,
|
||||
});
|
||||
await expect(
|
||||
f.service.reset({
|
||||
matchId,
|
||||
communityId,
|
||||
clientObservedAuctionLifecycleId: 'life',
|
||||
}),
|
||||
).resolves.toBeUndefined();
|
||||
expect(f.session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(match.lastCancelledAuctionLifecycleId).toBe('life');
|
||||
expect(match.status).toBe('recruiting');
|
||||
});
|
||||
|
||||
it('answers a retransmitted cancellation and durably schedules Redis cleanup', async () => {
|
||||
const match = { ...liveMatch(), lastCancelledAuctionLifecycleId: 'life' };
|
||||
const f = fixture({ auction: null, match });
|
||||
await expect(
|
||||
f.service.reset({
|
||||
matchId,
|
||||
communityId,
|
||||
clientObservedAuctionLifecycleId: 'life',
|
||||
}),
|
||||
).resolves.toBeUndefined();
|
||||
expect(match).toMatchObject({
|
||||
auctionCancellationCleanupPending: true,
|
||||
auctionCancellationCleanupRetryAt: expect.any(Date),
|
||||
});
|
||||
expect(f.redisCommands).toEqual([]);
|
||||
});
|
||||
|
||||
it('preserves a committed cancellation even if its lock renewal fails before returning', async () => {
|
||||
jest.useFakeTimers();
|
||||
try {
|
||||
const match = liveMatch();
|
||||
const f = fixture({ auction: redisAuction(), match });
|
||||
f.session.commitTransaction.mockImplementation(async () => {
|
||||
await jest.advanceTimersByTimeAsync(10000);
|
||||
});
|
||||
await expect(
|
||||
f.service.reset({
|
||||
matchId,
|
||||
communityId,
|
||||
clientObservedAuctionLifecycleId: 'life',
|
||||
}),
|
||||
).resolves.toBeUndefined();
|
||||
expect(match.auctionCancellationCleanupPending).toBe(true);
|
||||
expect(f.session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
} finally {
|
||||
jest.useRealTimers();
|
||||
}
|
||||
});
|
||||
|
||||
it('keeps 404 for a missing auction that was not cancelled with this lifecycle', async () => {
|
||||
for (const [observed, recorded] of [
|
||||
['other', 'life'],
|
||||
[undefined, 'life'],
|
||||
['life', undefined],
|
||||
] as const) {
|
||||
const f = fixture({
|
||||
auction: null,
|
||||
match: { ...liveMatch(), lastCancelledAuctionLifecycleId: recorded },
|
||||
});
|
||||
await expect(
|
||||
f.service.reset({
|
||||
matchId,
|
||||
communityId,
|
||||
clientObservedAuctionLifecycleId: observed,
|
||||
}),
|
||||
).rejects.toBeInstanceOf(NotFoundException);
|
||||
expect(f.session.abortTransaction).toHaveBeenCalled();
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,607 @@
|
||||
import mongoose from 'mongoose';
|
||||
import { AuctionService } from './auction.service';
|
||||
import {
|
||||
AuctionDurabilityScheduler,
|
||||
buildAuctionProjectionGuardedUpdate,
|
||||
type AuctionDurabilityPayload,
|
||||
} from './auction-durability.scheduler';
|
||||
import { AuctionDeadlineScheduler } from './auction-deadline.scheduler';
|
||||
import { AuctionLifecycleLock } from './auction-lifecycle-lock';
|
||||
|
||||
const query = <T>(value: T) => ({
|
||||
select() {
|
||||
return this;
|
||||
},
|
||||
session() {
|
||||
return this;
|
||||
},
|
||||
lean() {
|
||||
return this;
|
||||
},
|
||||
exec: async () => value,
|
||||
});
|
||||
const session = () => ({
|
||||
startTransaction: jest.fn(),
|
||||
commitTransaction: jest.fn(),
|
||||
abortTransaction: jest.fn(),
|
||||
endSession: jest.fn(),
|
||||
});
|
||||
const state = {
|
||||
auctionLifecycleId: 'life',
|
||||
revision: 12,
|
||||
phase: 'presenting',
|
||||
currentAuctionHistorySequence: 7,
|
||||
currentAuctionPlayerOrderIndex: 0,
|
||||
currentAuctionRound: 1,
|
||||
auctionTeams: [],
|
||||
auctionPlayerOrder: [],
|
||||
passedAuctionPlayerQueue: [],
|
||||
currentHighestBidPointAmount: 0,
|
||||
currentHighestBidderTeamIndex: -1,
|
||||
auctionCompletedAtTimestampMS: 0,
|
||||
currentBidRoundDeadlineTimestampMS: 0,
|
||||
};
|
||||
|
||||
beforeEach(() => {
|
||||
jest
|
||||
.spyOn(AuctionLifecycleLock.prototype, 'run')
|
||||
.mockImplementation(async (_id, work) => work());
|
||||
});
|
||||
afterEach(() => jest.restoreAllMocks());
|
||||
|
||||
function matches(
|
||||
document: Record<string, unknown>,
|
||||
filter: Record<string, unknown>,
|
||||
): boolean {
|
||||
return Object.entries(filter).every(([key, value]) => {
|
||||
if (key === '$or')
|
||||
return (value as Record<string, unknown>[]).some((alternative) =>
|
||||
matches(document, alternative),
|
||||
);
|
||||
if (value && typeof value === 'object') {
|
||||
return Object.entries(value).every(([operator, limit]) => {
|
||||
if (operator === '$exists')
|
||||
return (document[key] !== undefined) === limit;
|
||||
if (operator === '$lt') return Number(document[key]) < Number(limit);
|
||||
if (operator === '$lte') return Number(document[key]) <= Number(limit);
|
||||
return false;
|
||||
});
|
||||
}
|
||||
return document[key] === value;
|
||||
});
|
||||
}
|
||||
function update(
|
||||
document: Record<string, unknown>,
|
||||
mutation: Record<string, Record<string, unknown>>,
|
||||
) {
|
||||
Object.assign(document, mutation.$set);
|
||||
for (const [key, amount] of Object.entries(mutation.$inc ?? {}))
|
||||
document[key] = Number(document[key] ?? 0) + Number(amount);
|
||||
for (const key of Object.keys(mutation.$unset ?? {})) delete document[key];
|
||||
}
|
||||
|
||||
function sideEffectFixture(withReader = false) {
|
||||
const projection: Record<string, unknown> = {
|
||||
_id: 'auction',
|
||||
auctionLifecycleId: 'life',
|
||||
revision: 9,
|
||||
matchSideEffectRevision: 0,
|
||||
};
|
||||
const application: Record<string, unknown> = {};
|
||||
const payload: AuctionDurabilityPayload = {
|
||||
auctionId: 'auction',
|
||||
matchId: 'match',
|
||||
auctionLifecycleId: 'life',
|
||||
auctionStateTransitionId: 'complete',
|
||||
auctionActionType: 'complete',
|
||||
auctionHistorySequence: 10,
|
||||
revision: 10,
|
||||
snapshotBefore: {},
|
||||
historyMutation: { type: 'append' },
|
||||
matchSideEffectMutation: { type: 'syncMatchTeamsAfterComplete' },
|
||||
afterAuctionMongoProjection: {
|
||||
auctionLifecycleId: 'life',
|
||||
revision: 10,
|
||||
phase: 'complete',
|
||||
matchSideEffectRevision: 1,
|
||||
matchSideEffectStatus: 'pending',
|
||||
matchSideEffectTransitionId: 'complete',
|
||||
auctionTeams: [{ teamIndex: 1, captainUserId: 'captain', members: [] }],
|
||||
},
|
||||
};
|
||||
const AuctionModel = {
|
||||
findById: () => query({ ...projection }),
|
||||
updateOne: (
|
||||
filter: Record<string, unknown>,
|
||||
mutation: Record<string, Record<string, unknown>>,
|
||||
) => {
|
||||
const matchedCount = Number(matches(projection, filter));
|
||||
if (matchedCount) update(projection, mutation);
|
||||
return query({ matchedCount });
|
||||
},
|
||||
findOneAndUpdate: (
|
||||
filter: Record<string, unknown>,
|
||||
mutation: Record<string, Record<string, unknown>>,
|
||||
) => {
|
||||
if (!matches(projection, filter)) return query(null);
|
||||
update(projection, mutation);
|
||||
return query({ ...projection });
|
||||
},
|
||||
};
|
||||
const ApplicationModel = {
|
||||
findOne: () => query({ ...application }),
|
||||
updateOne: (
|
||||
filter: Record<string, unknown>,
|
||||
mutation: Record<string, Record<string, unknown>>,
|
||||
) => {
|
||||
if (mutation.$setOnInsert) {
|
||||
if (!application.state)
|
||||
Object.assign(application, mutation.$setOnInsert);
|
||||
return query({ matchedCount: 1 });
|
||||
}
|
||||
const matchedCount = Number(matches(application, filter));
|
||||
if (matchedCount) update(application, mutation);
|
||||
return query({ matchedCount });
|
||||
},
|
||||
};
|
||||
const match = {
|
||||
participants: [],
|
||||
teams: [],
|
||||
save: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const historyFindOne = jest.fn().mockReturnValue(query(null));
|
||||
const historyUpdateOne = jest
|
||||
.fn()
|
||||
.mockReturnValue(query({ matchedCount: 1 }));
|
||||
const models: Record<string, unknown> = {
|
||||
auction: AuctionModel,
|
||||
auctionHistory: {
|
||||
findOne: historyFindOne,
|
||||
updateOne: historyUpdateOne,
|
||||
},
|
||||
auctionSideEffectApplication: ApplicationModel,
|
||||
match: {
|
||||
findById: () => ({ ...query(match), session: async () => match }),
|
||||
},
|
||||
};
|
||||
const reserveForMatch = jest
|
||||
.fn()
|
||||
.mockRejectedValueOnce(new Error('temporary reservation error'))
|
||||
.mockResolvedValue(match);
|
||||
const scheduleInitialPoll = jest.fn().mockResolvedValue(undefined);
|
||||
const releaseFromMatch = jest.fn().mockResolvedValue(undefined);
|
||||
const cancelPolling = jest.fn().mockResolvedValue(undefined);
|
||||
let queued = true;
|
||||
const sendCommand = jest.fn(async (command: string[]) => {
|
||||
if (command[0] === 'ZRANGEBYSCORE') return queued ? ['payload'] : [];
|
||||
if (command[0] === 'HGETALL')
|
||||
return { payloadJson: JSON.stringify(payload) };
|
||||
if (command[0] === 'DEL') queued = false;
|
||||
if (command[0] === 'HINCRBY') return 1;
|
||||
return 1;
|
||||
});
|
||||
const scheduler = new AuctionDurabilityScheduler(
|
||||
{
|
||||
getModel: async (name: string) => models[name],
|
||||
createSession: async () => session(),
|
||||
} as never,
|
||||
{
|
||||
getCurrentRedisTimestampMS: async () => 10000,
|
||||
raw: () => ({ sendCommand }),
|
||||
} as never,
|
||||
{ reserveForMatch, releaseFromMatch } as never,
|
||||
{ scheduleInitialPoll, cancelPolling } as never,
|
||||
undefined,
|
||||
undefined,
|
||||
withReader
|
||||
? ({
|
||||
readAuctionStateView: async () => ({
|
||||
auctionLifecycleId: 'life',
|
||||
phase: payload.afterAuctionMongoProjection.phase,
|
||||
matchSideEffectTransitionId: 'complete',
|
||||
}),
|
||||
} as never)
|
||||
: undefined,
|
||||
);
|
||||
return {
|
||||
scheduler,
|
||||
payload,
|
||||
projection,
|
||||
application,
|
||||
reserveForMatch,
|
||||
scheduleInitialPoll,
|
||||
sendCommand,
|
||||
match,
|
||||
historyFindOne,
|
||||
historyUpdateOne,
|
||||
releaseFromMatch,
|
||||
cancelPolling,
|
||||
};
|
||||
}
|
||||
|
||||
it('retries failed completion work with the current generation and only then deletes the payload', async () => {
|
||||
const f = sideEffectFixture();
|
||||
expect(await f.scheduler.processDueDurabilityPayloads(20)).toMatchObject({
|
||||
failed: 1,
|
||||
});
|
||||
expect(f.projection.matchSideEffectStatus).toBe('failed');
|
||||
expect(await f.scheduler.processDueDurabilityPayloads(20)).toMatchObject({
|
||||
applied: 1,
|
||||
});
|
||||
expect(f.reserveForMatch).toHaveBeenCalledTimes(2);
|
||||
expect(f.scheduleInitialPoll).toHaveBeenCalledTimes(1);
|
||||
expect(f.application.state).toBe('completed');
|
||||
expect(f.projection.matchSideEffectStatus).toBe('completed');
|
||||
expect(f.projection.matchSideEffectRevision).toBe(5);
|
||||
expect(f.sendCommand).toHaveBeenCalledWith(['DEL', 'payload']);
|
||||
});
|
||||
|
||||
it('keeps an outbox payload while another worker owns its side-effect lease', async () => {
|
||||
const f = sideEffectFixture();
|
||||
Object.assign(f.application, {
|
||||
auctionId: 'auction',
|
||||
auctionStateTransitionId: 'complete',
|
||||
sideEffectType: 'syncMatchTeamsAfterComplete',
|
||||
state: 'processing',
|
||||
processingOwnerToken: 'other',
|
||||
processingLeaseExpiresAtTimestampMS: 50000,
|
||||
});
|
||||
expect(await f.scheduler.processDueDurabilityPayloads(20)).toEqual({
|
||||
applied: 0,
|
||||
failed: 0,
|
||||
skipped: 1,
|
||||
});
|
||||
expect(f.sendCommand).not.toHaveBeenCalledWith(['DEL', 'payload']);
|
||||
expect(
|
||||
f.sendCommand.mock.calls.some(([command]) => command[0] === 'HINCRBY'),
|
||||
).toBe(false);
|
||||
expect(f.reserveForMatch).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('recovers side effects when a later ordinary projection was persisted first', async () => {
|
||||
const f = sideEffectFixture(true);
|
||||
f.reserveForMatch.mockReset().mockResolvedValue(undefined);
|
||||
Object.assign(f.projection, { revision: 12 });
|
||||
await f.scheduler.applyDurabilityPayload(f.payload);
|
||||
expect(f.reserveForMatch).toHaveBeenCalledTimes(1);
|
||||
expect(f.projection.revision).toBe(12);
|
||||
expect(f.projection.matchSideEffectTransitionId).toBe('complete');
|
||||
expect(f.projection.matchSideEffectStatus).toBe('completed');
|
||||
});
|
||||
|
||||
it('still cleans up completed Match state when a second undo invalidates the first undo history', async () => {
|
||||
const f = sideEffectFixture(true);
|
||||
Object.assign(f.projection, { revision: 12 });
|
||||
Object.assign(f.payload, {
|
||||
matchSideEffectMutation: { type: 'undoCompletedAuctionSideEffects' },
|
||||
});
|
||||
f.payload.afterAuctionMongoProjection.phase = 'presenting';
|
||||
Object.assign(f.match, {
|
||||
teams: [{ teamIndex: 1 }],
|
||||
teamBuiltAt: new Date(),
|
||||
tournamentCodeIds: ['code'],
|
||||
gameSchedule: [{}],
|
||||
});
|
||||
f.historyFindOne.mockReturnValue(
|
||||
query({
|
||||
sequence: 12,
|
||||
historyMutation: {
|
||||
type: 'deleteAfterSequenceAndAppendUndo',
|
||||
targetHistorySequence: 2,
|
||||
},
|
||||
}),
|
||||
);
|
||||
await f.scheduler.applyDurabilityPayload(f.payload);
|
||||
expect(f.historyUpdateOne).not.toHaveBeenCalled();
|
||||
expect(f.releaseFromMatch).toHaveBeenCalledTimes(1);
|
||||
expect(f.cancelPolling).toHaveBeenCalledTimes(1);
|
||||
expect(f.match).toMatchObject({
|
||||
teams: [],
|
||||
teamBuiltAt: undefined,
|
||||
tournamentCodeIds: [],
|
||||
gameSchedule: [],
|
||||
});
|
||||
expect(f.projection.matchSideEffectStatus).toBe('completed');
|
||||
});
|
||||
|
||||
it('does not let a superseded side effect overwrite the newer generation', async () => {
|
||||
const f = sideEffectFixture();
|
||||
Object.assign(f.projection, {
|
||||
revision: 12,
|
||||
matchSideEffectTransitionId: 'undo',
|
||||
matchSideEffectRevision: 6,
|
||||
});
|
||||
await f.scheduler.applyDurabilityPayload(f.payload);
|
||||
expect(f.reserveForMatch).not.toHaveBeenCalled();
|
||||
expect(f.projection.matchSideEffectTransitionId).toBe('undo');
|
||||
});
|
||||
|
||||
it('removes obsolete projection fields both from Mongo updates and subsequent undo snapshots', () => {
|
||||
const service = new AuctionService(
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
const internal = service as unknown as {
|
||||
buildAuctionMongoProjectionFromState(
|
||||
auction: unknown,
|
||||
state: Record<string, unknown>,
|
||||
): Record<string, unknown>;
|
||||
buildAuctionSnapshotFromRedisState(
|
||||
auction: unknown,
|
||||
state: Record<string, unknown>,
|
||||
): Record<string, unknown>;
|
||||
};
|
||||
const old = {
|
||||
_id: new mongoose.Types.ObjectId(),
|
||||
matchId: new mongoose.Types.ObjectId(),
|
||||
completedAt: new Date(),
|
||||
auctionCompletedAtTimestampMS: 100,
|
||||
currentHighestBidderTeamIndex: 2,
|
||||
currentBidderTeamIndex: 2,
|
||||
};
|
||||
const projection = internal.buildAuctionMongoProjectionFromState(old, state);
|
||||
const mutation = buildAuctionProjectionGuardedUpdate({
|
||||
auctionId: old._id,
|
||||
auctionLifecycleId: 'life',
|
||||
revision: 12,
|
||||
afterAuctionMongoProjection: projection,
|
||||
} as AuctionDurabilityPayload).update;
|
||||
const stored = { ...old } as Record<string, unknown>;
|
||||
update(stored, mutation);
|
||||
const snapshot = internal.buildAuctionSnapshotFromRedisState(old, state);
|
||||
for (const record of [stored, snapshot]) {
|
||||
expect(record).not.toHaveProperty('completedAt');
|
||||
expect(record).not.toHaveProperty('currentHighestBidderTeamIndex');
|
||||
expect(record.phase).toBe('presenting');
|
||||
}
|
||||
});
|
||||
|
||||
it('applies delayed undo history cleanup without deleting newer branch entries or rolling back projection', async () => {
|
||||
const deleteMany = jest.fn().mockReturnValue(query({}));
|
||||
const updateOne = jest.fn().mockReturnValue(query({}));
|
||||
const projectionUpdate = jest.fn();
|
||||
const models: Record<string, unknown> = {
|
||||
auction: {
|
||||
findById: () => query({ auctionLifecycleId: 'life', revision: 12 }),
|
||||
updateOne: projectionUpdate,
|
||||
},
|
||||
auctionHistory: { findOne: () => query(null), deleteMany, updateOne },
|
||||
auctionSideEffectApplication: {},
|
||||
};
|
||||
const scheduler = new AuctionDurabilityScheduler(
|
||||
{
|
||||
getModel: async (name: string) => models[name],
|
||||
createSession: async () => null,
|
||||
} as never,
|
||||
{} as never,
|
||||
);
|
||||
await scheduler.applyDurabilityPayload({
|
||||
auctionId: 'auction',
|
||||
matchId: 'match',
|
||||
auctionStateTransitionId: 'undo',
|
||||
auctionLifecycleId: 'life',
|
||||
revision: 11,
|
||||
auctionHistorySequence: 9,
|
||||
auctionActionType: 'undo',
|
||||
historyMutation: {
|
||||
type: 'deleteAfterSequenceAndAppendUndo',
|
||||
targetHistorySequence: 3,
|
||||
},
|
||||
matchSideEffectMutation: { type: 'none' },
|
||||
afterAuctionMongoProjection: {},
|
||||
snapshotBefore: {},
|
||||
} as AuctionDurabilityPayload);
|
||||
expect(deleteMany).toHaveBeenCalledWith(
|
||||
{ auctionId: 'auction', sequence: { $gt: 3, $lt: 9 } },
|
||||
{ session: null },
|
||||
);
|
||||
expect(updateOne).toHaveBeenCalledTimes(1);
|
||||
expect(projectionUpdate).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('rejects a cancellation from a prior lifecycle before deleting anything', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId(),
|
||||
communityId = new mongoose.Types.ObjectId();
|
||||
const deleteOne = jest.fn();
|
||||
const service = new AuctionService(
|
||||
{
|
||||
createSession: async () => session(),
|
||||
getModel: async () => ({
|
||||
findOne: () => ({
|
||||
session: async () => ({
|
||||
auctionEngineVersion: 'redis-v1',
|
||||
auctionLifecycleId: 'new-life',
|
||||
deleteOne,
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
await expect(
|
||||
service.reset({
|
||||
matchId,
|
||||
communityId,
|
||||
clientObservedAuctionLifecycleId: 'old-life',
|
||||
}),
|
||||
).rejects.toThrow('lifecycle has changed');
|
||||
expect(deleteOne).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('resumes startup after Mongo creation instead of returning an unfinished auction', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId(),
|
||||
communityId = new mongoose.Types.ObjectId();
|
||||
const captain = new mongoose.Types.ObjectId(),
|
||||
player = new mongoose.Types.ObjectId(),
|
||||
lateJoiner = new mongoose.Types.ObjectId();
|
||||
const auction = {
|
||||
_id: new mongoose.Types.ObjectId(),
|
||||
matchId,
|
||||
auctionLifecycleId: 'life',
|
||||
revision: 1,
|
||||
phase: 'presenting',
|
||||
startupCompleted: false,
|
||||
startAuctionRequestId: 'same-request',
|
||||
teams: [{ captainUserId: captain, members: [], teamIndex: 1 }],
|
||||
order: [{ userId: player }],
|
||||
};
|
||||
const match = {
|
||||
communityId,
|
||||
status: 'recruiting',
|
||||
participants: [captain, player, lateJoiner].map((userId) => ({
|
||||
userId,
|
||||
excluded: false,
|
||||
})),
|
||||
save: jest.fn(),
|
||||
};
|
||||
const updateOne = jest.fn();
|
||||
const historyUpdate = jest.fn();
|
||||
const models: Record<string, unknown> = {
|
||||
auction: { findOne: async () => auction, updateOne },
|
||||
match: { findById: async () => match },
|
||||
auctionHistory: { updateOne: historyUpdate },
|
||||
};
|
||||
const hydrateState = jest.fn().mockResolvedValue({ hydrated: true });
|
||||
const service = new AuctionService(
|
||||
{ getModel: async (name: string) => models[name] } as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{ hydrateState } as never,
|
||||
{} as never,
|
||||
);
|
||||
await service.start({
|
||||
matchId,
|
||||
communityId,
|
||||
startAuctionRequestId: 'same-request',
|
||||
} as never);
|
||||
expect(hydrateState).toHaveBeenCalledTimes(1);
|
||||
expect(historyUpdate).toHaveBeenCalledTimes(1);
|
||||
expect(match.save).toHaveBeenCalledTimes(1);
|
||||
expect(match.status).toBe('team-built');
|
||||
expect(auction.startupCompleted).toBe(true);
|
||||
expect(match.participants.map((entry) => entry.excluded)).toEqual([
|
||||
false,
|
||||
false,
|
||||
true,
|
||||
]);
|
||||
});
|
||||
|
||||
it('does not open bidding until interrupted startup has been completed', async () => {
|
||||
const service = new AuctionService(
|
||||
{
|
||||
getModel: async () => ({
|
||||
findOne: async () => ({
|
||||
auctionEngineVersion: 'redis-v1',
|
||||
startupCompleted: false,
|
||||
}),
|
||||
}),
|
||||
} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
await expect(
|
||||
service.openBidding(new mongoose.Types.ObjectId()),
|
||||
).rejects.toThrow('startup is not complete');
|
||||
});
|
||||
|
||||
it('uses Redis completion state to schedule cleanup despite a delayed Mongo projection', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId(),
|
||||
communityId = new mongoose.Types.ObjectId();
|
||||
const auction = {
|
||||
_id: new mongoose.Types.ObjectId(),
|
||||
matchId,
|
||||
auctionEngineVersion: 'redis-v1',
|
||||
auctionLifecycleId: 'life',
|
||||
phase: 'sold',
|
||||
revision: 9,
|
||||
};
|
||||
const snapshot = { ...state, phase: 'bidding', revision: 5 };
|
||||
const models: Record<string, unknown> = {
|
||||
auction: { findOne: () => ({ session: async () => auction }) },
|
||||
match: { findById: () => ({ session: async () => ({ communityId }) }) },
|
||||
auctionHistory: { findOne: () => query({ snapshotBefore: snapshot }) },
|
||||
};
|
||||
const applyTransition = jest.fn().mockResolvedValue({ ok: true });
|
||||
const commands = {
|
||||
reserveActionRequest: async () => ({
|
||||
reserved: true,
|
||||
actionRequestScopeKey: 'scope',
|
||||
auctionStateTransitionId: 'undo',
|
||||
observedProcessingLeaseVersion: 1,
|
||||
}),
|
||||
applyTransition,
|
||||
};
|
||||
const service = new AuctionService(
|
||||
{
|
||||
getModel: async (name: string) => models[name],
|
||||
createSession: async () => session(),
|
||||
} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
commands as never,
|
||||
{
|
||||
readAuctionStateView: async () => ({
|
||||
...state,
|
||||
phase: 'complete',
|
||||
revision: 10,
|
||||
}),
|
||||
} as never,
|
||||
);
|
||||
await service.undoTo({ matchId, communityId, sequence: 2 });
|
||||
const input = applyTransition.mock.calls[0][1] as {
|
||||
durabilityPayloadJson: string;
|
||||
};
|
||||
expect(JSON.parse(input.durabilityPayloadJson)).toMatchObject({
|
||||
matchSideEffectMutation: { type: 'undoCompletedAuctionSideEffects' },
|
||||
});
|
||||
});
|
||||
|
||||
it.each(['deadline', 'durability'])(
|
||||
'continues %s ticks when lock release fails',
|
||||
async (kind) => {
|
||||
const redis = {
|
||||
acquireTokenLock: jest.fn().mockResolvedValue(true),
|
||||
releaseTokenLock: jest
|
||||
.fn()
|
||||
.mockRejectedValue(new Error('redis disconnected')),
|
||||
};
|
||||
const scheduler =
|
||||
kind === 'deadline'
|
||||
? new AuctionDeadlineScheduler(
|
||||
redis as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
)
|
||||
: new AuctionDurabilityScheduler({} as never, redis as never);
|
||||
const work = jest.fn().mockResolvedValue({});
|
||||
Object.assign(
|
||||
scheduler,
|
||||
kind === 'deadline'
|
||||
? { processDueBidRoundDeadlines: work }
|
||||
: { processDueDurabilityPayloads: work },
|
||||
);
|
||||
const internal = scheduler as unknown as { safeTick(): Promise<void> };
|
||||
await internal.safeTick();
|
||||
await internal.safeTick();
|
||||
expect(work).toHaveBeenCalledTimes(2);
|
||||
},
|
||||
);
|
||||
@@ -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,
|
||||
});
|
||||
|
||||
@@ -88,10 +88,13 @@ export class AuctionDeadlineScheduler implements OnModuleInit, OnModuleDestroy {
|
||||
);
|
||||
} finally {
|
||||
if (leaderLockAcquired) {
|
||||
await this.auctionRedisService.releaseTokenLock(
|
||||
BID_ROUND_DEADLINE_LEADER_LOCK_KEY,
|
||||
leaderLockToken,
|
||||
);
|
||||
await this.auctionRedisService
|
||||
.releaseTokenLock(BID_ROUND_DEADLINE_LEADER_LOCK_KEY, leaderLockToken)
|
||||
.catch((error: unknown) => {
|
||||
this.logger.warn(
|
||||
`Auction deadline lock release failed: ${String(error)}`,
|
||||
);
|
||||
});
|
||||
}
|
||||
this.tickInProgress = false;
|
||||
}
|
||||
@@ -101,15 +104,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 +182,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]);
|
||||
}
|
||||
}
|
||||
@@ -1,3 +1,5 @@
|
||||
import { AuctionLifecycleLock } from './auction-lifecycle-lock';
|
||||
import { buildAuctionProjectionUnset } from './auction-projection';
|
||||
import {
|
||||
AuctionDurabilityScheduler,
|
||||
buildAuctionHistoryUpsert,
|
||||
@@ -23,6 +25,12 @@ const payload = {
|
||||
} as const;
|
||||
|
||||
describe('auction durability projection helpers', () => {
|
||||
beforeEach(() => {
|
||||
jest
|
||||
.spyOn(AuctionLifecycleLock.prototype, 'run')
|
||||
.mockImplementation(async (_id, work) => work());
|
||||
});
|
||||
afterEach(() => jest.restoreAllMocks());
|
||||
it('builds idempotent history upsert by auction and transition id', () => {
|
||||
expect(buildAuctionHistoryUpsert(payload)).toEqual({
|
||||
updateOne: {
|
||||
@@ -59,6 +67,9 @@ describe('auction durability projection helpers', () => {
|
||||
},
|
||||
update: {
|
||||
$set: { phase: 'sold', revision: 9 },
|
||||
$unset: buildAuctionProjectionUnset(
|
||||
payload.afterAuctionMongoProjection,
|
||||
),
|
||||
},
|
||||
});
|
||||
});
|
||||
@@ -210,7 +221,12 @@ describe('auction durability projection helpers', () => {
|
||||
auctionLifecycleId: 'life-1',
|
||||
revision: { $lt: 9 },
|
||||
},
|
||||
{ $set: { phase: 'sold', revision: 9 } },
|
||||
{
|
||||
$set: { phase: 'sold', revision: 9 },
|
||||
$unset: buildAuctionProjectionUnset(
|
||||
payload.afterAuctionMongoProjection,
|
||||
),
|
||||
},
|
||||
{ session },
|
||||
);
|
||||
expect(session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
@@ -370,7 +386,7 @@ describe('auction durability projection helpers', () => {
|
||||
expect(historyDeleteMany).toHaveBeenCalledWith(
|
||||
{
|
||||
auctionId: 'auction-1',
|
||||
sequence: { $gt: 2 },
|
||||
sequence: { $gt: 2, $lt: 4 },
|
||||
},
|
||||
{ session },
|
||||
);
|
||||
@@ -811,21 +827,14 @@ describe('auction durability projection helpers', () => {
|
||||
skipped: 0,
|
||||
});
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(5, [
|
||||
'ZREM',
|
||||
'EVAL',
|
||||
expect.stringContaining("redis.call('HEXISTS'"),
|
||||
'4',
|
||||
'payload-1',
|
||||
'auction:auctionDurabilityRetryQueue',
|
||||
'payload-1',
|
||||
]);
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(6, [
|
||||
'HSET',
|
||||
'payload-1',
|
||||
'deadLetteredAtRedisTimestampMS',
|
||||
'1000',
|
||||
]);
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(7, [
|
||||
'ZADD',
|
||||
'auction:auctionDurabilityDeadLetterQueue',
|
||||
'auction:deadLetterStatusQueue',
|
||||
'1000',
|
||||
'payload-1',
|
||||
]);
|
||||
});
|
||||
|
||||
@@ -960,7 +969,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 +1022,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(
|
||||
@@ -1027,11 +1039,20 @@ describe('auction durability projection helpers', () => {
|
||||
{
|
||||
_id: 'auction-1',
|
||||
auctionLifecycleId: 'life-1',
|
||||
matchSideEffectRevision: 1,
|
||||
$or: [
|
||||
{ matchSideEffectTransitionId: 'transition-1' },
|
||||
{
|
||||
matchSideEffectTransitionId: { $exists: false },
|
||||
matchSideEffectRevision: 1,
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
$inc: { matchSideEffectRevision: 1 },
|
||||
$set: { matchSideEffectStatus: 'processing' },
|
||||
$set: {
|
||||
matchSideEffectStatus: 'processing',
|
||||
matchSideEffectTransitionId: 'transition-1',
|
||||
},
|
||||
$unset: { matchSideEffectError: '' },
|
||||
},
|
||||
expect.objectContaining({ returnDocument: 'after' }),
|
||||
@@ -1042,34 +1063,42 @@ describe('auction durability projection helpers', () => {
|
||||
_id: 'auction-1',
|
||||
auctionLifecycleId: 'life-1',
|
||||
matchSideEffectRevision: 2,
|
||||
matchSideEffectTransitionId: 'transition-1',
|
||||
},
|
||||
{
|
||||
$inc: { matchSideEffectRevision: 1 },
|
||||
$set: { matchSideEffectStatus: 'completed' },
|
||||
$set: {
|
||||
matchSideEffectStatus: 'completed',
|
||||
matchSideEffectTransitionId: 'transition-1',
|
||||
},
|
||||
$unset: { matchSideEffectError: '' },
|
||||
},
|
||||
expect.objectContaining({ returnDocument: 'after' }),
|
||||
);
|
||||
expect(mirrorMatchSideEffectStatus).toHaveBeenCalledWith({
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
matchId: 'match-1',
|
||||
matchSideEffectRevision: 2,
|
||||
matchSideEffectStatus: 'processing',
|
||||
});
|
||||
expect(mirrorMatchSideEffectStatus).toHaveBeenLastCalledWith({
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
matchId: 'match-1',
|
||||
matchSideEffectRevision: 3,
|
||||
matchSideEffectStatus: 'completed',
|
||||
});
|
||||
expect(broadcastMatchSideEffect).toHaveBeenNthCalledWith(1, 'match-1', {
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
currentServerTimestampMS: 2000,
|
||||
matchSideEffectRevision: 2,
|
||||
matchSideEffectStatus: 'processing',
|
||||
});
|
||||
expect(broadcastMatchSideEffect).toHaveBeenNthCalledWith(2, 'match-1', {
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
currentServerTimestampMS: 3000,
|
||||
matchSideEffectRevision: 3,
|
||||
matchSideEffectStatus: 'completed',
|
||||
@@ -1077,7 +1106,7 @@ describe('auction durability projection helpers', () => {
|
||||
expect(sendCommand).toHaveBeenCalledWith([
|
||||
'EVAL',
|
||||
expect.stringContaining("redis.call('EXPIRE'"),
|
||||
'11',
|
||||
'12',
|
||||
'auction:match-1:liveAuctionState',
|
||||
'auction:bidRoundDeadlineQueue',
|
||||
'auction:match-1:auctionStructureState',
|
||||
@@ -1089,6 +1118,7 @@ describe('auction durability projection helpers', () => {
|
||||
'auction:match-1:auctionActionRequestResultOrder',
|
||||
'auction:match-1:rehydrateLock',
|
||||
'auction:match-1:auctionStateTransitionLock',
|
||||
'auction:match-1:rejectedBidRequestResultOrder',
|
||||
'match-1',
|
||||
'life-1',
|
||||
String(7 * 24 * 60 * 60),
|
||||
@@ -1260,7 +1290,12 @@ describe('auction durability projection helpers', () => {
|
||||
const broadcastMatchSideEffect = jest.fn();
|
||||
const scheduler = new AuctionDurabilityScheduler(
|
||||
{
|
||||
createSession: jest.fn().mockResolvedValue(null),
|
||||
createSession: jest.fn().mockResolvedValueOnce(null).mockResolvedValue({
|
||||
startTransaction: jest.fn(),
|
||||
commitTransaction: jest.fn(),
|
||||
abortTransaction: jest.fn(),
|
||||
endSession: jest.fn(),
|
||||
}),
|
||||
getModel: jest.fn((name: string) => {
|
||||
if (name === 'auctionHistory') {
|
||||
return {
|
||||
@@ -1279,7 +1314,11 @@ describe('auction durability projection helpers', () => {
|
||||
return { updateOne: sideEffectUpdateOne };
|
||||
}
|
||||
if (name === 'match')
|
||||
return { findById: jest.fn().mockReturnValue(match) };
|
||||
return {
|
||||
findById: jest.fn().mockReturnValue({
|
||||
session: jest.fn().mockResolvedValue(match),
|
||||
}),
|
||||
};
|
||||
return {};
|
||||
}),
|
||||
} as never,
|
||||
@@ -1298,8 +1337,8 @@ describe('auction durability projection helpers', () => {
|
||||
|
||||
await scheduler.applyDurabilityPayload(resetPayload);
|
||||
|
||||
expect(releaseFromMatch).toHaveBeenCalledWith(match);
|
||||
expect(cancelPolling).toHaveBeenCalledWith(match);
|
||||
expect(releaseFromMatch).toHaveBeenCalledWith(match, expect.any(Object));
|
||||
expect(cancelPolling).toHaveBeenCalledWith(match, expect.any(Object));
|
||||
expect(match).toMatchObject({
|
||||
gameSchedule: [],
|
||||
result: undefined,
|
||||
@@ -1325,12 +1364,14 @@ describe('auction durability projection helpers', () => {
|
||||
);
|
||||
expect(mirrorMatchSideEffectStatus).toHaveBeenLastCalledWith({
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
matchId: 'match-1',
|
||||
matchSideEffectRevision: 3,
|
||||
matchSideEffectStatus: 'completed',
|
||||
});
|
||||
expect(broadcastMatchSideEffect).toHaveBeenLastCalledWith('match-1', {
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
currentServerTimestampMS: 3000,
|
||||
matchSideEffectRevision: 3,
|
||||
matchSideEffectStatus: 'completed',
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -20,9 +20,14 @@ 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));
|
||||
}
|
||||
|
||||
public broadcastReset(matchId: string, auctionLifecycleId: string): void {
|
||||
this.auctionNamespace
|
||||
?.to(matchId)
|
||||
.emit('reset', { matchId, auctionLifecycleId });
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
import { AuctionLifecycleLock } from './auction-lifecycle-lock';
|
||||
|
||||
afterEach(() => jest.useRealTimers());
|
||||
|
||||
it('renews ownership and handles renewal/release failures without unhandled rejection', async () => {
|
||||
jest.useFakeTimers();
|
||||
const sendCommand = jest
|
||||
.fn()
|
||||
.mockRejectedValue(new Error('redis disconnected'));
|
||||
const releaseTokenLock = jest
|
||||
.fn()
|
||||
.mockRejectedValue(new Error('release failed'));
|
||||
const lock = new AuctionLifecycleLock({
|
||||
acquireTokenLock: jest.fn().mockResolvedValue(true),
|
||||
releaseTokenLock,
|
||||
raw: () => ({ sendCommand }),
|
||||
} as never);
|
||||
const result = lock.run('match', async () => {
|
||||
await jest.advanceTimersByTimeAsync(10000);
|
||||
});
|
||||
await expect(result).rejects.toThrow('redis disconnected');
|
||||
expect(releaseTokenLock).toHaveBeenCalledTimes(1);
|
||||
expect(jest.getTimerCount()).toBe(0);
|
||||
});
|
||||
|
||||
it('preserves an operation result if only lock release fails', async () => {
|
||||
const lock = new AuctionLifecycleLock({
|
||||
acquireTokenLock: jest.fn().mockResolvedValue(true),
|
||||
releaseTokenLock: jest.fn().mockRejectedValue(new Error('release failed')),
|
||||
} as never);
|
||||
await expect(lock.run('match', async () => 42)).resolves.toBe(42);
|
||||
});
|
||||
@@ -0,0 +1,72 @@
|
||||
import { ConflictException, Logger } from '@nestjs/common';
|
||||
import { randomUUID } from 'crypto';
|
||||
import { AuctionRedisService } from './redis/auction-redis.service';
|
||||
|
||||
export class AuctionLifecycleBusyError extends ConflictException {
|
||||
constructor() {
|
||||
super({
|
||||
code: 'AUCTION_LIFECYCLE_BUSY',
|
||||
message: '다른 경매 작업을 처리 중입니다. 잠시 후 다시 시도해 주세요.',
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/** Serializes startup, cancellation, undo and Match side effects across nodes. */
|
||||
export class AuctionLifecycleLock {
|
||||
private readonly logger = new Logger(AuctionLifecycleLock.name);
|
||||
|
||||
constructor(private readonly redis: AuctionRedisService) {}
|
||||
|
||||
async run<T>(matchId: string, operation: () => Promise<T>): Promise<T> {
|
||||
// Kept outside runtime cleanup: cancelling an auction must not release a
|
||||
// lock still held by its cancellation/recovery operation.
|
||||
const key = `auction:${matchId}:lifecycleMutationLock`;
|
||||
const token = randomUUID();
|
||||
if (!(await this.redis.acquireTokenLock(key, token, 30_000))) {
|
||||
throw new AuctionLifecycleBusyError();
|
||||
}
|
||||
let renewal: Promise<void> | undefined;
|
||||
let ownershipError: Error | undefined;
|
||||
const timer = setInterval(() => {
|
||||
if (renewal) return;
|
||||
renewal = this.redis
|
||||
.raw()
|
||||
.sendCommand<string | null>([
|
||||
'SET',
|
||||
key,
|
||||
token,
|
||||
'IFEQ',
|
||||
token,
|
||||
'PX',
|
||||
'30000',
|
||||
])
|
||||
.then((result) => {
|
||||
if (result !== 'OK')
|
||||
throw new Error('Auction lifecycle lock ownership was lost.');
|
||||
})
|
||||
.catch((error: unknown) => {
|
||||
ownershipError =
|
||||
error instanceof Error ? error : new Error(String(error));
|
||||
})
|
||||
.finally(() => {
|
||||
renewal = undefined;
|
||||
});
|
||||
}, 10_000);
|
||||
timer.unref?.();
|
||||
try {
|
||||
const result = await operation();
|
||||
clearInterval(timer);
|
||||
await renewal;
|
||||
if (ownershipError) throw ownershipError;
|
||||
return result;
|
||||
} finally {
|
||||
clearInterval(timer);
|
||||
await renewal;
|
||||
await this.redis.releaseTokenLock(key, token).catch((error: unknown) => {
|
||||
this.logger.warn(
|
||||
`Auction lifecycle lock release failed: ${String(error)}`,
|
||||
);
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
/** Missing optional fields in a complete projection mean deletion, not retention. */
|
||||
export const AUCTION_OPTIONAL_PROJECTION_FIELDS = [
|
||||
'completedAt',
|
||||
'auctionCompletedAtTimestampMS',
|
||||
'currentBidderTeamIndex',
|
||||
'currentHighestBidderTeamIndex',
|
||||
'currentDeadline',
|
||||
'currentBidRoundDeadlineTimestampMS',
|
||||
'currentBidRoundId',
|
||||
] as const;
|
||||
|
||||
export function buildAuctionProjectionUnset(
|
||||
projection: Record<string, unknown>,
|
||||
) {
|
||||
return Object.fromEntries(
|
||||
AUCTION_OPTIONAL_PROJECTION_FIELDS.filter(
|
||||
(field) => projection[field] === undefined,
|
||||
).map((field) => [field, '']),
|
||||
);
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -5,6 +5,20 @@ import {
|
||||
} from './auction-rejection';
|
||||
|
||||
describe('resolveAuctionRejectionReason', () => {
|
||||
it('distinguishes an outdated client from a stale round and does not suggest a state-only resync', () => {
|
||||
const reason = resolveAuctionRejectionReason('BID_CLIENT_UPDATE_REQUIRED');
|
||||
expect(reason).toBe('BID_REJECTED_BECAUSE_CLIENT_UPDATE_REQUIRED');
|
||||
expect(isAuctionResyncRecommended(reason)).toBe(false);
|
||||
});
|
||||
it('reports roster validation failures without recommending a retry', () => {
|
||||
const reason = resolveAuctionRejectionReason(
|
||||
'AUCTION_ROSTER_INVALID',
|
||||
'Auction roster validation failed.',
|
||||
);
|
||||
expect(reason).toBe('AUCTION_TRANSITION_REJECTED_BECAUSE_ROSTER_INVALID');
|
||||
expect(isAuctionResyncRecommended(reason)).toBe(false);
|
||||
});
|
||||
|
||||
it('maps the internal CONFLICT code to the descriptive transition reason', () => {
|
||||
expect(resolveAuctionRejectionReason('CONFLICT')).toBe(
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY,
|
||||
@@ -22,7 +36,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,
|
||||
);
|
||||
|
||||
@@ -16,7 +16,7 @@
|
||||
* resync 권장 여부:
|
||||
* - `AUCTION_RESYNC_RECOMMENDED_REASONS`에 속한 reason은 "클라가 본 상태가 이미
|
||||
* 바뀌었다(낙관적 동시성 충돌/만료/단계 전이)"는 신호다. 이 경우 클라는 최신
|
||||
* state로 rebaseline한 뒤 (구조 액션이라면) 1회 재시도하는 것이 안전하다.
|
||||
* state로 rebaseline한다. 구조 액션 재시도는 원래 대상과 단계가 같을 때만 허용한다.
|
||||
* - 반대로 정원 초과/포인트 부족처럼 "상태를 새로고침해도 결과가 같은" 거부는
|
||||
* resync 권장 대상이 아니다(재시도해도 또 거부됨).
|
||||
*/
|
||||
@@ -29,9 +29,12 @@ export const AUCTION_REJECTION_REASON = {
|
||||
/** 입찰 단계가 아닌데 입찰 단계 전환을 시도함(이미 sold/passed/presenting 등). */
|
||||
AUCTION_TRANSITION_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE:
|
||||
'AUCTION_TRANSITION_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE',
|
||||
/** 현재 단계에서 "다음"으로 진행할 수 없음(sold/passed/presenting이 아님 — 보통 이미 진행됨). */
|
||||
/** 낙찰 또는 유찰이 확정되지 않아 다음 선수로 진행할 수 없음. */
|
||||
AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE:
|
||||
'AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE',
|
||||
/** 원 참가자 명단과 실제 팀 배정이 일치하지 않아 완료할 수 없음. */
|
||||
AUCTION_TRANSITION_REJECTED_BECAUSE_ROSTER_INVALID:
|
||||
'AUCTION_TRANSITION_REJECTED_BECAUSE_ROSTER_INVALID',
|
||||
/** 낙찰 처리할 유효한 최고 입찰이 없음(만료 처리로 이미 정리됐을 수 있음). */
|
||||
AUCTION_TRANSITION_REJECTED_BECAUSE_NO_WINNING_BID_TO_MARK_SOLD:
|
||||
'AUCTION_TRANSITION_REJECTED_BECAUSE_NO_WINNING_BID_TO_MARK_SOLD',
|
||||
@@ -43,6 +46,8 @@ export const AUCTION_REJECTION_REASON = {
|
||||
'AUCTION_TRANSITION_REJECTED_BECAUSE_REQUEST_COORDINATION_RETRYABLE',
|
||||
|
||||
// === 입찰(bid) ===
|
||||
BID_REJECTED_BECAUSE_CLIENT_UPDATE_REQUIRED:
|
||||
'BID_REJECTED_BECAUSE_CLIENT_UPDATE_REQUIRED',
|
||||
/** 입찰 라운드가 이미 다음 선수/다음 라운드로 넘어감(내부 `STALE_BID_ROUND`). */
|
||||
BID_REJECTED_BECAUSE_BID_ROUND_ALREADY_ADVANCED:
|
||||
'BID_REJECTED_BECAUSE_BID_ROUND_ALREADY_ADVANCED',
|
||||
@@ -83,6 +88,10 @@ export type AuctionRejectionReason =
|
||||
|
||||
/** 내부 짧은 코드 → 설명적 reason. */
|
||||
const INTERNAL_CODE_TO_REASON: Record<string, AuctionRejectionReason> = {
|
||||
BID_CLIENT_UPDATE_REQUIRED:
|
||||
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_CLIENT_UPDATE_REQUIRED,
|
||||
AUCTION_ROSTER_INVALID:
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_ROSTER_INVALID,
|
||||
CONFLICT:
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY,
|
||||
STALE_BID_ROUND:
|
||||
|
||||
@@ -96,6 +96,7 @@ describe('auction side effect helpers', () => {
|
||||
'life-1',
|
||||
'2',
|
||||
'completed',
|
||||
'',
|
||||
]);
|
||||
});
|
||||
});
|
||||
@@ -25,6 +25,7 @@ export interface BuildSideEffectLeaseAcquireUpdateParams {
|
||||
|
||||
export interface MatchSideEffectDelta {
|
||||
auctionLifecycleId: string;
|
||||
auctionStateTransitionId?: string;
|
||||
currentServerTimestampMS: number;
|
||||
matchSideEffectRevision: number;
|
||||
matchSideEffectStatus: AuctionMatchSideEffectStatus;
|
||||
@@ -36,27 +37,33 @@ export class AuctionSideEffectService {
|
||||
|
||||
public async mirrorMatchSideEffectStatus(params: {
|
||||
auctionLifecycleId: string;
|
||||
auctionStateTransitionId?: string;
|
||||
matchId: string;
|
||||
matchSideEffectRevision: number;
|
||||
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 generation = redis.call('HGET', KEYS[1], 'matchSideEffectTransitionId')",
|
||||
"if ARGV[4] ~= '' and generation and generation ~= ARGV[4] 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,
|
||||
params.auctionStateTransitionId ?? '',
|
||||
]);
|
||||
return Number(result) === 1;
|
||||
}
|
||||
}
|
||||
@@ -78,8 +85,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
|
||||
);
|
||||
}
|
||||
|
||||
@@ -103,6 +109,9 @@ export function buildMatchSideEffectDelta(
|
||||
): MatchSideEffectDelta {
|
||||
return {
|
||||
auctionLifecycleId: params.auctionLifecycleId,
|
||||
...(params.auctionStateTransitionId
|
||||
? { auctionStateTransitionId: params.auctionStateTransitionId }
|
||||
: {}),
|
||||
currentServerTimestampMS: params.currentServerTimestampMS,
|
||||
matchSideEffectRevision: params.matchSideEffectRevision,
|
||||
matchSideEffectStatus: params.matchSideEffectStatus,
|
||||
|
||||
@@ -9,6 +9,7 @@ import {
|
||||
Param,
|
||||
Post,
|
||||
UseGuards,
|
||||
Query,
|
||||
} from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import { AllowPublicAccess } from '../auth/allow-public-access.decorator';
|
||||
@@ -19,6 +20,7 @@ import { ParseObjectIdPipe } from '../common/parse-object-id.pipe';
|
||||
import type { UserDocument } from '../global/database/schema';
|
||||
import { AuctionService } from './auction.service';
|
||||
import { AuctionGateway } from './auction.gateway';
|
||||
import { AuctionBidArchiveService } from './auction-bid-archive.service';
|
||||
import {
|
||||
NextAuctionDto,
|
||||
OpenBiddingDto,
|
||||
@@ -35,6 +37,7 @@ export class AuctionController {
|
||||
constructor(
|
||||
private readonly auctionService: AuctionService,
|
||||
private readonly auctionGateway: AuctionGateway,
|
||||
private readonly auctionBidArchiveService: AuctionBidArchiveService,
|
||||
) {}
|
||||
|
||||
@Post()
|
||||
@@ -59,8 +62,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',
|
||||
@@ -79,6 +81,20 @@ export class AuctionController {
|
||||
}
|
||||
|
||||
// 공개 — 팀장 2명만 쓸 엔드포인트(트러스트 기반, 10명 동시 관전).
|
||||
@Get('bids/history')
|
||||
@AllowPublicAccess()
|
||||
public async getBidHistory(
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Query('afterRevision') afterRevision?: string,
|
||||
@Query('limit') limit?: string,
|
||||
) {
|
||||
return this.auctionBidArchiveService.list(
|
||||
matchId,
|
||||
afterRevision === undefined ? -1 : Number(afterRevision),
|
||||
limit === undefined ? 100 : Number(limit),
|
||||
);
|
||||
}
|
||||
|
||||
@Post('open-bidding')
|
||||
@AllowPublicAccess()
|
||||
@HttpCode(HttpStatus.OK)
|
||||
@@ -101,6 +117,7 @@ export class AuctionController {
|
||||
teamIndex: body.bidderTeamIndex,
|
||||
amount: body.bidPointAmount,
|
||||
bidRequestId: body.bidRequestId,
|
||||
clientObservedBidRoundId: body.clientObservedBidRoundId,
|
||||
clientObservedAuctionLifecycleId: body.clientObservedAuctionLifecycleId,
|
||||
clientObservedCurrentBidRoundPlayerUserId:
|
||||
body.clientObservedCurrentBidRoundPlayerUserId,
|
||||
@@ -214,7 +231,10 @@ export class AuctionController {
|
||||
clientObservedPhase: body.clientObservedPhase,
|
||||
clientObservedRevision: body.clientObservedRevision,
|
||||
});
|
||||
this.auctionGateway.broadcastReset(matchId.toString());
|
||||
this.auctionGateway.broadcastReset(
|
||||
matchId.toString(),
|
||||
body.clientObservedAuctionLifecycleId,
|
||||
);
|
||||
}
|
||||
|
||||
private assertSameCommunity(
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import mongoose from 'mongoose';
|
||||
import { ServiceUnavailableException } from '@nestjs/common';
|
||||
|
||||
jest.mock('../auth/jwt.service', () => ({
|
||||
JwtService: class JwtService {},
|
||||
@@ -7,6 +8,76 @@ jest.mock('../auth/jwt.service', () => ({
|
||||
import { AuctionGateway } from './auction.gateway';
|
||||
|
||||
describe('AuctionGateway', () => {
|
||||
it('signals pending initial state so the client can retry privately after recovery', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
const gateway = new AuctionGateway(
|
||||
{
|
||||
getByMatchId: async () => ({}),
|
||||
getStateByMatchId: async () => {
|
||||
throw new ServiceUnavailableException({
|
||||
code: 'AUCTION_STATE_RECOVERING',
|
||||
message: 'recovering',
|
||||
});
|
||||
},
|
||||
} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
const socket = { data: { matchId }, join: jest.fn(), emit: jest.fn() };
|
||||
await gateway.handleJoin(socket as never, { matchId });
|
||||
expect(socket.emit).toHaveBeenCalledTimes(1);
|
||||
expect(socket.emit).toHaveBeenCalledWith('state-pending', {
|
||||
retryAfterMS: 500,
|
||||
});
|
||||
});
|
||||
it('sends join and resync snapshots only to the requesting socket and coalesces in-flight resyncs', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
const getStateByMatchId = jest.fn().mockResolvedValue({ revision: 3 });
|
||||
const gateway = new AuctionGateway(
|
||||
{
|
||||
getByMatchId: async () => ({ chatMessages: [] }),
|
||||
getStateByMatchId,
|
||||
} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
const broadcast = jest.fn();
|
||||
(gateway as unknown as { server: unknown }).server = {
|
||||
to: () => ({ emit: broadcast }),
|
||||
};
|
||||
const socket = { data: { matchId }, join: jest.fn(), emit: jest.fn() };
|
||||
await gateway.handleJoin(socket as never, { matchId });
|
||||
expect(socket.emit).toHaveBeenCalledWith('state', { revision: 3 });
|
||||
expect(broadcast).not.toHaveBeenCalled();
|
||||
let finish!: (value: unknown) => void;
|
||||
getStateByMatchId.mockImplementationOnce(
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
finish = resolve;
|
||||
}),
|
||||
);
|
||||
const ack = jest.fn(),
|
||||
busyAck = jest.fn();
|
||||
const pending = gateway.handleResync(socket as never, {}, ack);
|
||||
await gateway.handleResync(socket as never, {}, busyAck);
|
||||
expect(busyAck).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ code: 'RESYNC_BUSY' }),
|
||||
);
|
||||
finish({ revision: 4 });
|
||||
await pending;
|
||||
expect(ack).toHaveBeenCalledWith({ ok: true, state: { revision: 4 } });
|
||||
expect(getStateByMatchId).toHaveBeenCalledTimes(2);
|
||||
expect(broadcast).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
function createGateway(params?: {
|
||||
getCurrentRedisTimestampMS?: jest.Mock;
|
||||
placeBidDelta?: jest.Mock;
|
||||
|
||||
@@ -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';
|
||||
@@ -44,6 +44,7 @@ interface JoinAuctionPayload {
|
||||
}
|
||||
|
||||
interface BidPayload {
|
||||
clientObservedBidRoundId?: string;
|
||||
bidderTeamIndex: number;
|
||||
bidPointAmount: number;
|
||||
bidRequestId?: string;
|
||||
@@ -78,6 +79,22 @@ interface BidRateLimitState {
|
||||
windowStartedAtTimestampMS: number;
|
||||
}
|
||||
|
||||
interface AuctionSocketData {
|
||||
auctionResyncAtTimestampMS?: number;
|
||||
auctionResyncInProgress?: boolean;
|
||||
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 +109,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 +129,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 +145,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)) {
|
||||
@@ -150,15 +165,61 @@ export class AuctionGateway
|
||||
new mongoose.Types.ObjectId(payload.matchId),
|
||||
);
|
||||
this.emitChatHistory(socket, auction);
|
||||
this.broadcastState(payload.matchId, auctionState);
|
||||
socket.emit('state', serializeRealtimeAuction(auctionState));
|
||||
} catch (error) {
|
||||
this.emitKnownError(socket, error);
|
||||
const rejection = this.resolveErrorPayload(error);
|
||||
if (rejection.code === 'AUCTION_STATE_RECOVERING') {
|
||||
socket.emit('state-pending', { retryAfterMS: 500 });
|
||||
} else {
|
||||
this.emitKnownError(socket, error);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeMessage('resync')
|
||||
public async handleResync(
|
||||
@ConnectedSocket() socket: AuctionSocket,
|
||||
@MessageBody() _payload: unknown,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
const matchId = this.requireJoinedMatchId(socket);
|
||||
if (!matchId) {
|
||||
ack?.({ ok: false, code: 'JOIN_REQUIRED' });
|
||||
return;
|
||||
}
|
||||
const now = Date.now();
|
||||
const retryAfterMS =
|
||||
500 - (now - (socket.data.auctionResyncAtTimestampMS ?? 0));
|
||||
if (socket.data.auctionResyncInProgress || retryAfterMS > 0) {
|
||||
ack?.({
|
||||
ok: false,
|
||||
code: 'RESYNC_BUSY',
|
||||
retryAfterMS: Math.max(500, retryAfterMS),
|
||||
});
|
||||
return;
|
||||
}
|
||||
socket.data.auctionResyncInProgress = true;
|
||||
socket.data.auctionResyncAtTimestampMS = now;
|
||||
try {
|
||||
const state = await this.auctionService.getStateByMatchId(
|
||||
new mongoose.Types.ObjectId(matchId),
|
||||
);
|
||||
// Only the requesting socket receives the full snapshot.
|
||||
ack?.({ ok: true, state: serializeRealtimeAuction(state) });
|
||||
} catch (error) {
|
||||
ack?.({
|
||||
...this.resolveErrorPayload(error),
|
||||
ok: false,
|
||||
retryAfterMS: 500,
|
||||
});
|
||||
} finally {
|
||||
socket.data.auctionResyncInProgress = false;
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeMessage('bid')
|
||||
public async handleBid(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@ConnectedSocket() socket: AuctionSocket,
|
||||
@MessageBody() payload: BidPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
@@ -184,6 +245,7 @@ export class AuctionGateway
|
||||
teamIndex: payload.bidderTeamIndex,
|
||||
amount: payload.bidPointAmount,
|
||||
bidRequestId,
|
||||
clientObservedBidRoundId: payload.clientObservedBidRoundId,
|
||||
clientObservedAuctionLifecycleId:
|
||||
payload.clientObservedAuctionLifecycleId,
|
||||
clientObservedCurrentBidRoundPlayerUserId:
|
||||
@@ -205,7 +267,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 +284,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 +332,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 +361,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 +391,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 +420,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 +449,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 +475,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 +484,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 +504,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 +529,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 +539,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 +561,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 +598,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 +619,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 +632,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 {
|
||||
@@ -584,8 +659,11 @@ export class AuctionGateway
|
||||
this.server.to(matchId).emit('bid', delta);
|
||||
}
|
||||
|
||||
public broadcastReset(matchId: string) {
|
||||
this.server.to(matchId).emit('reset', { matchId });
|
||||
public broadcastReset(matchId: string, auctionLifecycleId?: string) {
|
||||
this.server.to(matchId).emit('reset', {
|
||||
matchId,
|
||||
...(auctionLifecycleId ? { auctionLifecycleId } : {}),
|
||||
});
|
||||
}
|
||||
|
||||
public broadcastMatchSideEffect(
|
||||
@@ -595,7 +673,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 +681,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 +716,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 +773,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 +803,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 +812,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 +827,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 +865,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 +892,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>)
|
||||
: {};
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@ import { AuctionEventBusService } from './auction-event-bus.service';
|
||||
import { AuctionRedisModule } from './redis/auction-redis.module';
|
||||
import { AuctionSideEffectService } from './auction-side-effect.service';
|
||||
import { AuctionService } from './auction.service';
|
||||
import { AuctionBidArchiveService } from './auction-bid-archive.service';
|
||||
|
||||
@Module({
|
||||
imports: [
|
||||
@@ -21,6 +22,7 @@ import { AuctionService } from './auction.service';
|
||||
controllers: [AuctionController],
|
||||
providers: [
|
||||
AuctionService,
|
||||
AuctionBidArchiveService,
|
||||
AuctionGateway,
|
||||
AuctionEventBusService,
|
||||
AuctionDeadlineScheduler,
|
||||
|
||||
@@ -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({
|
||||
@@ -21,6 +45,10 @@ describe('AuctionService', () => {
|
||||
const allModels = {
|
||||
auctionHistory: auctionHistoryModel,
|
||||
...models,
|
||||
auction: {
|
||||
updateOne: jest.fn().mockResolvedValue({ matchedCount: 1 }),
|
||||
...((models.auction as object) ?? {}),
|
||||
},
|
||||
};
|
||||
const connectionService = {
|
||||
getModel: jest.fn((name: string) => allModels[name]),
|
||||
@@ -158,12 +186,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({
|
||||
@@ -674,7 +701,7 @@ describe('AuctionService', () => {
|
||||
expect(auctionRedisService.raw().sendCommand).toHaveBeenCalledWith([
|
||||
'EVAL',
|
||||
expect.stringContaining('currentAuctionLifecycleId'),
|
||||
'11',
|
||||
'12',
|
||||
`auction:${matchId.toString()}:liveAuctionState`,
|
||||
'auction:bidRoundDeadlineQueue',
|
||||
`auction:${matchId.toString()}:auctionStructureState`,
|
||||
@@ -686,6 +713,7 @@ describe('AuctionService', () => {
|
||||
`auction:${matchId.toString()}:auctionActionRequestResultOrder`,
|
||||
`auction:${matchId.toString()}:rehydrateLock`,
|
||||
`auction:${matchId.toString()}:auctionStateTransitionLock`,
|
||||
`auction:${matchId.toString()}:rejectedBidRequestResultOrder`,
|
||||
matchId.toString(),
|
||||
'old-life-1',
|
||||
]);
|
||||
@@ -886,9 +914,9 @@ describe('AuctionService', () => {
|
||||
shouldForceAuctionStateResync: true,
|
||||
});
|
||||
expect(auctionRedisService.acquireTokenLock).toHaveBeenCalledWith(
|
||||
`auction:${matchId.toString()}:rehydrateLock`,
|
||||
`auction:${matchId.toString()}:lifecycleMutationLock`,
|
||||
expect.any(String),
|
||||
5000,
|
||||
30000,
|
||||
);
|
||||
expect(auctionRedisCommandService.hydrateState).toHaveBeenCalledWith(
|
||||
matchId.toString(),
|
||||
@@ -1008,7 +1036,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 +1212,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(),
|
||||
@@ -1314,6 +1370,267 @@ describe('AuctionService', () => {
|
||||
}
|
||||
});
|
||||
|
||||
describe('redis next safety', () => {
|
||||
function createFortyPlayerAuction() {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const participantIds = Array.from(
|
||||
{ length: 40 },
|
||||
() => new mongoose.Types.ObjectId(),
|
||||
);
|
||||
const auction = {
|
||||
_id: new mongoose.Types.ObjectId(),
|
||||
matchId,
|
||||
auctionEngineVersion: 'redis-v1',
|
||||
auctionLifecycleId: 'life-1',
|
||||
};
|
||||
const state = {
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionTeams: participantIds
|
||||
.slice(0, 8)
|
||||
.map((captainUserId, index) => ({
|
||||
teamIndex: index + 1,
|
||||
captainUserId: captainUserId.toString(),
|
||||
remainingBidPointAmount: 960,
|
||||
members: participantIds
|
||||
.slice(8 + index * 4, 12 + index * 4)
|
||||
.map((userId) => ({
|
||||
userId: userId.toString(),
|
||||
assignedPosition: 'MID',
|
||||
memberAcquisitionBidPointAmount: 10,
|
||||
})),
|
||||
})),
|
||||
auctionPlayerOrder: participantIds.slice(8).map((userId) => ({
|
||||
userId: userId.toString(),
|
||||
preferredPositions: [{ position: 'MID', priority: 1 }],
|
||||
passCount: 0,
|
||||
})),
|
||||
bidRoundExtensionSeconds: 5,
|
||||
currentAuctionHistorySequence: 121,
|
||||
currentAuctionPlayerOrderIndex: 31,
|
||||
currentAuctionRound: 1,
|
||||
initialTeamBidPointAmount: 1000,
|
||||
maximumBidRoundDurationSeconds: 15,
|
||||
passedAuctionPlayerQueue: [] as Array<{
|
||||
userId: string;
|
||||
preferredPositions: Array<{ position: string; priority: number }>;
|
||||
passCount: number;
|
||||
}>,
|
||||
phase: 'sold',
|
||||
revision: 479,
|
||||
topTierAuctionPriorityThreshold: 'NONE',
|
||||
};
|
||||
const match = {
|
||||
_id: matchId,
|
||||
participants: participantIds.map((userId) => ({
|
||||
userId,
|
||||
excluded: false,
|
||||
preferredPositions: [{ position: 'MID', priority: 1 }],
|
||||
})),
|
||||
status: 'team-built',
|
||||
teams: [],
|
||||
save: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const dependencies = createService({
|
||||
auction: { findOne: jest.fn().mockResolvedValue(auction) },
|
||||
match: { findById: jest.fn().mockResolvedValue(match) },
|
||||
});
|
||||
dependencies.auctionRedisStateReaderService.readAuctionStateView.mockResolvedValue(
|
||||
state,
|
||||
);
|
||||
dependencies.auctionRedisCommandService.applyTransition.mockImplementation(
|
||||
async (_matchId: string, input: Record<string, unknown>) => {
|
||||
Object.assign(
|
||||
state,
|
||||
parseJsonRecord(
|
||||
input.afterAuctionStructureStateJson,
|
||||
'afterAuctionStructureStateJson',
|
||||
),
|
||||
input.liveStatePatch,
|
||||
{
|
||||
revision: Number(input.expectedRevision) + 1,
|
||||
currentAuctionHistorySequence: input.auctionHistorySequence,
|
||||
},
|
||||
);
|
||||
return {
|
||||
auctionStateTransitionId: String(input.auctionStateTransitionId),
|
||||
currentServerTimestampMS: 1780000000000,
|
||||
ok: true,
|
||||
revision: state.revision,
|
||||
};
|
||||
},
|
||||
);
|
||||
return { ...dependencies, matchId, match, state, participantIds };
|
||||
}
|
||||
|
||||
it.each([12, 31])(
|
||||
'rejects next for a presenting player at index %i without skipping or completing',
|
||||
async (index) => {
|
||||
const { service, matchId, state, auctionRedisCommandService } =
|
||||
createFortyPlayerAuction();
|
||||
state.phase = 'presenting';
|
||||
state.currentAuctionPlayerOrderIndex = index;
|
||||
const before = structuredClone(state);
|
||||
|
||||
await expect(service.next(matchId)).rejects.toThrow(
|
||||
'Cannot advance from current phase.',
|
||||
);
|
||||
|
||||
expect(state).toEqual(before);
|
||||
expect(
|
||||
auctionRedisCommandService.reserveActionRequest,
|
||||
).not.toHaveBeenCalled();
|
||||
expect(
|
||||
auctionRedisCommandService.applyTransition,
|
||||
).not.toHaveBeenCalled();
|
||||
},
|
||||
);
|
||||
|
||||
it('rejects completion when only 39 of the 40 participants are assigned', async () => {
|
||||
const { service, matchId, state, match, auctionRedisCommandService } =
|
||||
createFortyPlayerAuction();
|
||||
state.auctionTeams[6].members.pop();
|
||||
const before = structuredClone(state);
|
||||
|
||||
await expect(service.next(matchId)).rejects.toThrow(
|
||||
'Auction roster validation failed.',
|
||||
);
|
||||
|
||||
expect(state).toEqual(before);
|
||||
expect(auctionRedisCommandService.applyTransition).not.toHaveBeenCalled();
|
||||
expect(match.save).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('checks original eligible participants even if a missing player also disappeared from the order', async () => {
|
||||
const { service, matchId, state, auctionRedisCommandService } =
|
||||
createFortyPlayerAuction();
|
||||
const missingPlayer = state.auctionTeams[6].members.pop()!;
|
||||
state.auctionPlayerOrder = state.auctionPlayerOrder.filter(
|
||||
(player) => player.userId !== missingPlayer.userId,
|
||||
);
|
||||
state.currentAuctionPlayerOrderIndex =
|
||||
state.auctionPlayerOrder.length - 1;
|
||||
const before = structuredClone(state);
|
||||
|
||||
await expect(service.next(matchId)).rejects.toThrow(
|
||||
'Auction roster validation failed.',
|
||||
);
|
||||
|
||||
expect(state).toEqual(before);
|
||||
expect(auctionRedisCommandService.applyTransition).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('rejects a duplicate assignment even when the assigned count still equals 40', async () => {
|
||||
const { service, matchId, state, auctionRedisCommandService } =
|
||||
createFortyPlayerAuction();
|
||||
state.auctionTeams[0].members[0].userId =
|
||||
state.auctionTeams[1].members[0].userId;
|
||||
|
||||
await expect(service.next(matchId)).rejects.toThrow(
|
||||
'Auction roster validation failed.',
|
||||
);
|
||||
|
||||
expect(state.phase).toBe('sold');
|
||||
expect(auctionRedisCommandService.applyTransition).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('rejects duplicate captain membership even when every expected user is present', async () => {
|
||||
const { service, matchId, state, auctionRedisCommandService } =
|
||||
createFortyPlayerAuction();
|
||||
state.auctionTeams[0].members.push({
|
||||
userId: state.auctionTeams[0].captainUserId,
|
||||
assignedPosition: 'MID',
|
||||
memberAcquisitionBidPointAmount: 10,
|
||||
});
|
||||
|
||||
await expect(service.next(matchId)).rejects.toThrow(
|
||||
'Auction roster validation failed.',
|
||||
);
|
||||
|
||||
expect(state.phase).toBe('sold');
|
||||
expect(auctionRedisCommandService.applyTransition).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('rejects an unexpected assigned user even when all 40 assignments are unique', async () => {
|
||||
const { service, matchId, state, auctionRedisCommandService } =
|
||||
createFortyPlayerAuction();
|
||||
state.auctionTeams[0].members[0].userId =
|
||||
new mongoose.Types.ObjectId().toString();
|
||||
|
||||
await expect(service.next(matchId)).rejects.toThrow(
|
||||
'Auction roster validation failed.',
|
||||
);
|
||||
|
||||
expect(state.phase).toBe('sold');
|
||||
expect(auctionRedisCommandService.applyTransition).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('completes all 40 eligible participants once, allowing repeat order entries after passes and excluding cut participants', async () => {
|
||||
const { service, matchId, state, match, auctionRedisCommandService } =
|
||||
createFortyPlayerAuction();
|
||||
state.auctionPlayerOrder.push({
|
||||
...state.auctionPlayerOrder[12],
|
||||
passCount: 1,
|
||||
});
|
||||
state.currentAuctionPlayerOrderIndex =
|
||||
state.auctionPlayerOrder.length - 1;
|
||||
state.currentAuctionRound = 2;
|
||||
match.participants.push({
|
||||
userId: new mongoose.Types.ObjectId(),
|
||||
excluded: true,
|
||||
preferredPositions: [{ position: 'MID', priority: 1 }],
|
||||
});
|
||||
|
||||
await expect(service.next(matchId)).resolves.toMatchObject({
|
||||
phase: 'complete',
|
||||
revision: 480,
|
||||
});
|
||||
|
||||
expect(auctionRedisCommandService.applyTransition).toHaveBeenCalledTimes(
|
||||
1,
|
||||
);
|
||||
expect(state.auctionTeams).toHaveLength(8);
|
||||
expect(
|
||||
state.auctionTeams.every((team) => team.members.length === 4),
|
||||
).toBe(true);
|
||||
expect(match.save).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it.each(['sold', 'passed'])(
|
||||
'advances a nonterminal %s player without demanding a completed roster',
|
||||
async (phase) => {
|
||||
const { service, matchId, state } = createFortyPlayerAuction();
|
||||
state.phase = phase;
|
||||
state.currentAuctionPlayerOrderIndex = 12;
|
||||
state.auctionTeams.forEach((team) => {
|
||||
team.members = [];
|
||||
});
|
||||
|
||||
await expect(service.next(matchId)).resolves.toMatchObject({
|
||||
phase: 'presenting',
|
||||
currentAuctionPlayerOrderIndex: 13,
|
||||
});
|
||||
},
|
||||
);
|
||||
|
||||
it('requeues passed players for another round without completing an incomplete roster', async () => {
|
||||
const { service, matchId, state } = createFortyPlayerAuction();
|
||||
state.phase = 'passed';
|
||||
state.auctionTeams[7].members.pop();
|
||||
state.passedAuctionPlayerQueue.push({
|
||||
...state.auctionPlayerOrder[31],
|
||||
passCount: 1,
|
||||
});
|
||||
|
||||
await expect(service.next(matchId)).resolves.toMatchObject({
|
||||
phase: 'presenting',
|
||||
currentAuctionPlayerOrderIndex: 32,
|
||||
currentAuctionRound: 2,
|
||||
passedAuctionPlayerQueue: [],
|
||||
});
|
||||
expect(state.auctionPlayerOrder).toHaveLength(33);
|
||||
});
|
||||
});
|
||||
|
||||
it('syncs match teams when a redis-v1 auction completes', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const captainUserId = new mongoose.Types.ObjectId();
|
||||
@@ -1397,7 +1714,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',
|
||||
@@ -1786,7 +2108,7 @@ describe('AuctionService', () => {
|
||||
});
|
||||
|
||||
expect(auction.currentBid).toBe(970);
|
||||
expect(auction.currentBidderTeamIndex).toBe(1);
|
||||
expect(auction).toHaveProperty('currentBidderTeamIndex', 1);
|
||||
expect(auction.bids).toEqual([
|
||||
expect.objectContaining({
|
||||
teamIndex: 1,
|
||||
@@ -2072,13 +2394,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).toHaveProperty('completedAt', expect.any(Date));
|
||||
expect(auction.save).toHaveBeenCalledTimes(1);
|
||||
expect(match.save).toHaveBeenCalledTimes(1);
|
||||
expect(match.save).toHaveBeenCalledTimes(2);
|
||||
expect(match.teams).toEqual([
|
||||
{
|
||||
teamIndex: 1,
|
||||
@@ -2174,6 +2500,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();
|
||||
@@ -2251,8 +2626,14 @@ describe('AuctionService', () => {
|
||||
auctionRedisCommandService.reserveActionRequest,
|
||||
).not.toHaveBeenCalled();
|
||||
expect(auctionRedisCommandService.applyTransition).not.toHaveBeenCalled();
|
||||
expect(tournamentCodeService.releaseFromMatch).toHaveBeenCalledWith(match);
|
||||
expect(tournamentResultService.cancelPolling).toHaveBeenCalledWith(match);
|
||||
expect(tournamentCodeService.releaseFromMatch).toHaveBeenCalledWith(
|
||||
match,
|
||||
session,
|
||||
);
|
||||
expect(tournamentResultService.cancelPolling).toHaveBeenCalledWith(
|
||||
match,
|
||||
session,
|
||||
);
|
||||
expect(match).toMatchObject({
|
||||
gameSchedule: [],
|
||||
result: undefined,
|
||||
@@ -2272,13 +2653,12 @@ describe('AuctionService', () => {
|
||||
auctionId,
|
||||
});
|
||||
expect(auction.deleteOne).toHaveBeenCalledWith({ session });
|
||||
expect(redisClient.sendCommand).toHaveBeenCalledWith(
|
||||
expect.arrayContaining([
|
||||
'auction:bidRoundDeadlineQueue',
|
||||
matchId.toString(),
|
||||
'life-1',
|
||||
]),
|
||||
);
|
||||
expect(redisClient.sendCommand).not.toHaveBeenCalled();
|
||||
expect(match).toMatchObject({
|
||||
lastCancelledAuctionLifecycleId: 'life-1',
|
||||
auctionCancellationCleanupPending: true,
|
||||
auctionCancellationCleanupRetryAt: expect.any(Date),
|
||||
});
|
||||
expect(session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
@@ -2362,8 +2742,14 @@ describe('AuctionService', () => {
|
||||
service.undoTo({ matchId, communityId, sequence: 3 }),
|
||||
).resolves.toBe(restored);
|
||||
|
||||
expect(tournamentCodeService.releaseFromMatch).toHaveBeenCalledWith(match);
|
||||
expect(tournamentResultService.cancelPolling).toHaveBeenCalledWith(match);
|
||||
expect(tournamentCodeService.releaseFromMatch).toHaveBeenCalledWith(
|
||||
match,
|
||||
session,
|
||||
);
|
||||
expect(tournamentResultService.cancelPolling).toHaveBeenCalledWith(
|
||||
match,
|
||||
session,
|
||||
);
|
||||
expect(match.status).toBe('team-built');
|
||||
expect(match.result).toBeUndefined();
|
||||
expect(auctionReplaceOne).toHaveBeenCalledWith(
|
||||
@@ -2515,7 +2901,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: {
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -72,6 +72,10 @@ export class StartAuctionDto {
|
||||
}
|
||||
|
||||
export class PlaceBidDto {
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
clientObservedBidRoundId?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsUUID()
|
||||
bidRequestId?: string;
|
||||
|
||||
@@ -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,10 +1,19 @@
|
||||
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()));
|
||||
.mockImplementation((command: string[]) =>
|
||||
Promise.resolve(
|
||||
command[0] === 'EVAL'
|
||||
? [currentServerTimestampMS, ...commandReplies.splice(0, 3)]
|
||||
: commandReplies.shift(),
|
||||
),
|
||||
);
|
||||
const auctionRedisService = {
|
||||
getCurrentRedisTimestampMS: jest
|
||||
.fn()
|
||||
@@ -122,19 +131,14 @@ describe('AuctionRedisStateReaderService', () => {
|
||||
});
|
||||
expect(view).not.toHaveProperty('team:2:remainingBidPointAmount');
|
||||
expect(view).not.toHaveProperty('bidRoundExpiryDecision');
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(1, [
|
||||
'HGETALL',
|
||||
expect(sendCommand).toHaveBeenCalledTimes(1);
|
||||
expect(sendCommand).toHaveBeenCalledWith([
|
||||
'EVAL',
|
||||
expect.stringContaining("redis.call('TIME')"),
|
||||
'3',
|
||||
'auction:match-1:liveAuctionState',
|
||||
]);
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(2, [
|
||||
'GET',
|
||||
'auction:match-1:auctionStructureState',
|
||||
]);
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(3, [
|
||||
'LRANGE',
|
||||
'auction:match-1:auctionBidHistory',
|
||||
'0',
|
||||
'-1',
|
||||
]);
|
||||
});
|
||||
|
||||
@@ -149,7 +153,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 +187,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,16 @@ 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 this.auctionRedisService
|
||||
.raw()
|
||||
.sendCommand<
|
||||
unknown[]
|
||||
>(['EVAL', ["local now = redis.call('TIME')", 'local timestamp = tonumber(now[1]) * 1000 + math.floor(tonumber(now[2]) / 1000)', "return {tostring(timestamp), redis.call('HGETALL', KEYS[1]), redis.call('GET', KEYS[2]), redis.call('LRANGE', KEYS[3], 0, -1)}"].join('\n'), '3', keys.liveStateKey, keys.structureStateKey, keys.bidHistoryKey]);
|
||||
|
||||
const liveState = parseHashReply(liveReply, {
|
||||
includeInternalLiveStateFields:
|
||||
@@ -135,14 +137,14 @@ export class AuctionRedisStateReaderService {
|
||||
auctionBidHistoryEntries: Array.isArray(bidEntries)
|
||||
? bidEntries.map(String)
|
||||
: [],
|
||||
currentServerTimestampMS,
|
||||
currentServerTimestampMS: Number(currentServerTimestampMS),
|
||||
liveState: liveState as Record<string, unknown> & {
|
||||
auctionLifecycleId: string;
|
||||
phase: string;
|
||||
revision: number;
|
||||
},
|
||||
shouldForceAuctionStateResync: options.shouldForceAuctionStateResync,
|
||||
structureState: JSON.parse(structureStateJson) as Record<string, unknown>,
|
||||
structureState: parseJsonRecord(structureStateJson),
|
||||
});
|
||||
view.matchId = matchId;
|
||||
if (options.includeInternalLiveStateFields) {
|
||||
@@ -161,12 +163,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 +182,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 +216,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);
|
||||
|
||||
@@ -46,6 +46,7 @@ describe('auction apply transition redis script contract', () => {
|
||||
'auction:match-1:bidRequestResults',
|
||||
'auction:match-1:bidRequestResultOrder',
|
||||
'auction:bidRoundDeadlineQueue',
|
||||
'auction:match-1:rejectedBidRequestResultOrder',
|
||||
]);
|
||||
expect(invocation.values.slice(0, 19)).toEqual([
|
||||
'match-1',
|
||||
@@ -91,9 +92,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'",
|
||||
);
|
||||
|
||||
@@ -79,6 +79,7 @@ export function buildAuctionApplyTransitionScriptInvocation(
|
||||
keys.bidRequestResultsKey,
|
||||
keys.bidRequestResultOrderKey,
|
||||
keys.deadlineQueueKey,
|
||||
keys.rejectedBidRequestResultOrderKey,
|
||||
],
|
||||
script: AUCTION_APPLY_TRANSITION_SCRIPT,
|
||||
values: [
|
||||
@@ -128,6 +129,7 @@ local auctionBidHistoryKey = KEYS[8]
|
||||
local bidRequestResultsKey = KEYS[9]
|
||||
local bidRequestResultOrderKey = KEYS[10]
|
||||
local bidRoundDeadlineQueueKey = KEYS[11]
|
||||
local rejectedBidRequestResultOrderKey = KEYS[12]
|
||||
|
||||
local matchId = ARGV[1]
|
||||
local auctionLifecycleId = ARGV[2]
|
||||
@@ -270,16 +272,27 @@ for i = 1, liveStatePatchPairCount do
|
||||
end
|
||||
redis.call('HSET', unpack(hsetArgs))
|
||||
|
||||
local committedBidRoundDeadlineTimestampMS = ''
|
||||
if deadlineMode == 'set-relative' then
|
||||
local currentBidRoundDeadlineTimestampMS = currentRedisTimestampMS + (deadlineDurationSeconds * 1000)
|
||||
committedBidRoundDeadlineTimestampMS = tostring(currentBidRoundDeadlineTimestampMS)
|
||||
redis.call('HSET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS', tostring(currentBidRoundDeadlineTimestampMS))
|
||||
redis.call('HSET', liveAuctionStateKey, 'currentBidRoundId', auctionStateTransitionId)
|
||||
redis.call('ZADD', bidRoundDeadlineQueueKey, currentBidRoundDeadlineTimestampMS, matchId)
|
||||
elseif deadlineMode == 'remove' then
|
||||
redis.call('ZREM', bidRoundDeadlineQueueKey, matchId)
|
||||
redis.call('HDEL', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS')
|
||||
end
|
||||
|
||||
-- A resumed auction must not disappear when its former completion TTL elapses.
|
||||
if redis.call('HGET', liveAuctionStateKey, 'phase') ~= 'complete' then
|
||||
for _, index in ipairs({1, 2, 3, 6, 7, 8, 9, 10, 12}) do
|
||||
redis.call('PERSIST', KEYS[index])
|
||||
end
|
||||
end
|
||||
|
||||
if shouldResetBidRuntime == '1' then
|
||||
redis.call('DEL', auctionBidHistoryKey, bidRequestResultsKey, bidRequestResultOrderKey)
|
||||
redis.call('DEL', auctionBidHistoryKey, bidRequestResultsKey, bidRequestResultOrderKey, rejectedBidRequestResultOrderKey)
|
||||
end
|
||||
|
||||
redis.call('SADD', appliedAuctionStateTransitionIdsKey, transitionDedupeMember)
|
||||
@@ -288,6 +301,8 @@ redis.call(
|
||||
durabilityPayloadKey,
|
||||
'payloadJson',
|
||||
durabilityPayloadJson,
|
||||
'committedBidRoundDeadlineTimestampMS',
|
||||
committedBidRoundDeadlineTimestampMS,
|
||||
'preparedAtRedisTimestampMS',
|
||||
tostring(currentRedisTimestampMS),
|
||||
'committedAtRedisTimestampMS',
|
||||
@@ -317,7 +332,7 @@ if actionRequestScopeKey ~= '' then
|
||||
actionRequestPrefix .. 'responseServerTimestampMS',
|
||||
tostring(currentRedisTimestampMS)
|
||||
)
|
||||
redis.call('RPUSH', auctionActionRequestResultOrderKey, actionRequestScopeKey)
|
||||
-- The reservation already inserted this request into the order list.
|
||||
end
|
||||
|
||||
return {'OK', auctionStateTransitionId, tostring(newRevision), tostring(currentRedisTimestampMS)}
|
||||
|
||||
@@ -30,6 +30,9 @@ describe('auction bid redis script contract', () => {
|
||||
'auction:match-1:bidRequestResults',
|
||||
'auction:match-1:bidRequestResultOrder',
|
||||
'auction:bidRoundDeadlineQueue',
|
||||
'auction:match-1:rejectedBidRequestResultOrder',
|
||||
'auction:bidArchiveQueue',
|
||||
'auction:bidArchivePayloads',
|
||||
]);
|
||||
expect(invocation.values).toEqual([
|
||||
'match-1',
|
||||
@@ -45,6 +48,7 @@ describe('auction bid redis script contract', () => {
|
||||
'100',
|
||||
'60000',
|
||||
'200',
|
||||
'',
|
||||
]);
|
||||
});
|
||||
|
||||
@@ -64,9 +68,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');
|
||||
});
|
||||
});
|
||||
@@ -1,4 +1,8 @@
|
||||
import type { AuctionRedisKeys } from './auction-redis.keys';
|
||||
import {
|
||||
AUCTION_BID_ARCHIVE_QUEUE_KEY,
|
||||
AUCTION_BID_ARCHIVE_PAYLOADS_KEY,
|
||||
} from './auction-redis.keys';
|
||||
import { defineAuctionRedisScript } from './auction-redis.scripts';
|
||||
|
||||
export interface AuctionBidScriptInput {
|
||||
@@ -8,6 +12,7 @@ export interface AuctionBidScriptInput {
|
||||
bidderUserId: string;
|
||||
clientObservedAuctionLifecycleId: string;
|
||||
clientObservedCurrentBidRoundPlayerUserId: string;
|
||||
clientObservedBidRoundId?: string;
|
||||
maximumAuctionTeamMemberCount: number;
|
||||
maximumStoredAuctionBidHistoryCount: number;
|
||||
maximumStoredBidRequestResultCount: number;
|
||||
@@ -40,15 +45,19 @@ export function buildBidRequestPayloadFingerprint(params: {
|
||||
bidPointAmount: number;
|
||||
clientObservedAuctionLifecycleId: string;
|
||||
clientObservedCurrentBidRoundPlayerUserId: string;
|
||||
clientObservedBidRoundId?: string;
|
||||
matchId: string;
|
||||
}): string {
|
||||
return [
|
||||
const parts = [
|
||||
params.matchId,
|
||||
params.clientObservedAuctionLifecycleId,
|
||||
params.clientObservedCurrentBidRoundPlayerUserId,
|
||||
params.bidderTeamIndex,
|
||||
params.bidPointAmount,
|
||||
].join('|');
|
||||
];
|
||||
if (params.clientObservedBidRoundId)
|
||||
parts.push(params.clientObservedBidRoundId);
|
||||
return parts.join('|');
|
||||
}
|
||||
|
||||
export function buildAuctionBidScriptInvocation(
|
||||
@@ -62,6 +71,9 @@ export function buildAuctionBidScriptInvocation(
|
||||
keys.bidRequestResultsKey,
|
||||
keys.bidRequestResultOrderKey,
|
||||
keys.deadlineQueueKey,
|
||||
keys.rejectedBidRequestResultOrderKey,
|
||||
AUCTION_BID_ARCHIVE_QUEUE_KEY,
|
||||
AUCTION_BID_ARCHIVE_PAYLOADS_KEY,
|
||||
],
|
||||
script: AUCTION_BID_SCRIPT,
|
||||
values: [
|
||||
@@ -78,6 +90,7 @@ export function buildAuctionBidScriptInvocation(
|
||||
String(input.maximumStoredBidRequestResultCount),
|
||||
String(input.minimumBidRequestResultReplayWindowMS),
|
||||
String(input.maximumStoredAuctionBidHistoryCount),
|
||||
input.clientObservedBidRoundId ?? '',
|
||||
],
|
||||
};
|
||||
}
|
||||
@@ -90,6 +103,9 @@ local auctionBidHistoryKey = KEYS[2]
|
||||
local bidRequestResultsKey = KEYS[3]
|
||||
local bidRequestResultOrderKey = KEYS[4]
|
||||
local bidRoundDeadlineQueueKey = KEYS[5]
|
||||
local rejectedBidRequestResultOrderKey = KEYS[6]
|
||||
local bidArchiveQueueKey = KEYS[7]
|
||||
local bidArchivePayloadsKey = KEYS[8]
|
||||
|
||||
local matchId = ARGV[1]
|
||||
local bidderTeamIndex = ARGV[2]
|
||||
@@ -104,6 +120,7 @@ local bidRequestPayloadFingerprint = ARGV[10]
|
||||
local maximumStoredBidRequestResultCount = tonumber(ARGV[11])
|
||||
local minimumBidRequestResultReplayWindowMS = tonumber(ARGV[12])
|
||||
local maximumStoredAuctionBidHistoryCount = tonumber(ARGV[13])
|
||||
local clientObservedBidRoundId = ARGV[14] or ''
|
||||
|
||||
local redisTime = redis.call('TIME')
|
||||
local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000)
|
||||
@@ -168,12 +185,23 @@ if existingFingerprint then
|
||||
return replayExistingRequest()
|
||||
end
|
||||
|
||||
trimOldBidRequestResults()
|
||||
if redis.call('LLEN', bidRequestResultOrderKey) >= maximumStoredBidRequestResultCount then
|
||||
return {'REJECTED', 'BID_REQUEST_RESULT_LIMIT', bidRequestId, tostring(currentRedisTimestampMS)}
|
||||
-- Upgrade the old shared queue once, preserving every accepted replay record.
|
||||
if redis.call('HSETNX', bidRequestResultsKey, '_acceptedOnlyOrderV1', '1') == 1 then
|
||||
for _, oldRequestId in ipairs(redis.call('LRANGE', bidRequestResultOrderKey, 0, -1)) do
|
||||
if redis.call('HGET', bidRequestResultsKey, oldRequestId .. ':status') == 'rejected' then
|
||||
redis.call('LREM', bidRequestResultOrderKey, 0, oldRequestId)
|
||||
hdelBidRequest(oldRequestId)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local function storeRejectedRequest(rejectCode)
|
||||
-- Rejections have their own bounded retention. They must never consume the
|
||||
-- protected replay capacity of accepted bids.
|
||||
while redis.call('LLEN', rejectedBidRequestResultOrderKey) >= maximumStoredBidRequestResultCount do
|
||||
local oldest = redis.call('LPOP', rejectedBidRequestResultOrderKey)
|
||||
if oldest then hdelBidRequest(oldest) end
|
||||
end
|
||||
local rejectedCurrentBidRoundDeadlineTimestampMS = redis.call('HGET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS') or ''
|
||||
redis.call(
|
||||
'HSET',
|
||||
@@ -191,7 +219,7 @@ local function storeRejectedRequest(rejectCode)
|
||||
requestField('createdAtTimestampMS'),
|
||||
tostring(currentRedisTimestampMS)
|
||||
)
|
||||
redis.call('RPUSH', bidRequestResultOrderKey, bidRequestId)
|
||||
redis.call('RPUSH', rejectedBidRequestResultOrderKey, bidRequestId)
|
||||
return {'REJECTED', rejectCode, bidRequestId, tostring(currentRedisTimestampMS), rejectedCurrentBidRoundDeadlineTimestampMS}
|
||||
end
|
||||
|
||||
@@ -202,9 +230,16 @@ end
|
||||
|
||||
local auctionLifecycleId = redis.call('HGET', liveAuctionStateKey, 'auctionLifecycleId')
|
||||
local currentBidRoundPlayerUserId = redis.call('HGET', liveAuctionStateKey, 'currentBidRoundPlayerUserId')
|
||||
local currentBidRoundId = redis.call('HGET', liveAuctionStateKey, 'currentBidRoundId') or ''
|
||||
if currentBidRoundId ~= '' and clientObservedBidRoundId == '' then
|
||||
return storeRejectedRequest('BID_CLIENT_UPDATE_REQUIRED')
|
||||
end
|
||||
if auctionLifecycleId ~= clientObservedAuctionLifecycleId or currentBidRoundPlayerUserId ~= clientObservedCurrentBidRoundPlayerUserId then
|
||||
return storeRejectedRequest('STALE_BID_ROUND')
|
||||
end
|
||||
if currentBidRoundId ~= clientObservedBidRoundId then
|
||||
return storeRejectedRequest('STALE_BID_ROUND')
|
||||
end
|
||||
|
||||
local currentBidRoundDeadlineTimestampMS = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS') or '0')
|
||||
if currentBidRoundDeadlineTimestampMS <= currentRedisTimestampMS then
|
||||
@@ -235,8 +270,9 @@ if bidPointAmount + requiredReserveAfterBid > remainingBidPointAmount then
|
||||
return storeRejectedRequest('INSUFFICIENT')
|
||||
end
|
||||
|
||||
if redis.call('LLEN', auctionBidHistoryKey) >= maximumStoredAuctionBidHistoryCount then
|
||||
return storeRejectedRequest('BID_HISTORY_LIMIT')
|
||||
trimOldBidRequestResults()
|
||||
if redis.call('LLEN', bidRequestResultOrderKey) >= maximumStoredBidRequestResultCount then
|
||||
return {'REJECTED', 'BID_REQUEST_RESULT_LIMIT', bidRequestId, tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
|
||||
local maximumBidRoundDurationSeconds = tonumber(redis.call('HGET', liveAuctionStateKey, 'maximumBidRoundDurationSeconds') or '0')
|
||||
@@ -254,14 +290,36 @@ end
|
||||
local nextBidRoundDeadlineTimestampMS = currentRedisTimestampMS + nextRemainingBidRoundTimeMS
|
||||
|
||||
local revision = redis.call('HINCRBY', liveAuctionStateKey, 'revision', 1)
|
||||
local auctionBidHistoryEntryJson =
|
||||
'{"bidderTeamIndex":' .. bidderTeamIndex ..
|
||||
',"bidPointAmount":' .. tostring(bidPointAmount) ..
|
||||
',"bidderUserId":"' .. bidderUserId ..
|
||||
'","bidPlacedAtTimestampMS":' .. tostring(currentRedisTimestampMS) ..
|
||||
'}'
|
||||
local auctionBidHistoryEntryJson = cjson.encode({
|
||||
bidRequestId = bidRequestId,
|
||||
revision = revision,
|
||||
bidderTeamIndex = tonumber(bidderTeamIndex),
|
||||
bidPointAmount = bidPointAmount,
|
||||
bidderUserId = bidderUserId,
|
||||
playerUserId = currentBidRoundPlayerUserId,
|
||||
bidRoundId = currentBidRoundId,
|
||||
bidPlacedAtTimestampMS = currentRedisTimestampMS
|
||||
})
|
||||
|
||||
-- Accepted replay returns above this point. Persist every accepted event before
|
||||
-- trimming the recent view; the durable archive worker removes only saved events.
|
||||
local archiveId = matchId .. ':' .. auctionLifecycleId .. ':' .. string.format('%016d', revision)
|
||||
redis.call('HSET', bidArchivePayloadsKey, archiveId, cjson.encode({
|
||||
_id = archiveId,
|
||||
matchId = matchId,
|
||||
auctionLifecycleId = auctionLifecycleId,
|
||||
revision = revision,
|
||||
bidRequestId = bidRequestId,
|
||||
bidderTeamIndex = tonumber(bidderTeamIndex),
|
||||
bidPointAmount = bidPointAmount,
|
||||
bidderUserId = bidderUserId,
|
||||
playerUserId = currentBidRoundPlayerUserId,
|
||||
bidRoundId = currentBidRoundId,
|
||||
bidPlacedAtTimestampMS = currentRedisTimestampMS
|
||||
}))
|
||||
redis.call('ZADD', bidArchiveQueueKey, currentRedisTimestampMS, archiveId)
|
||||
redis.call('RPUSH', auctionBidHistoryKey, auctionBidHistoryEntryJson)
|
||||
redis.call('LTRIM', auctionBidHistoryKey, -maximumStoredAuctionBidHistoryCount, -1)
|
||||
redis.call(
|
||||
'HSET',
|
||||
liveAuctionStateKey,
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
import { defineAuctionRedisScript } from './auction-redis.scripts';
|
||||
|
||||
// Compare the lifecycle and remove the payload and its indexes atomically.
|
||||
export const AUCTION_CLEANUP_DURABILITY_SCRIPT = defineAuctionRedisScript(
|
||||
'auction.cleanupDurability',
|
||||
`
|
||||
local deleted = 0
|
||||
for i = 3, #KEYS do
|
||||
local key = KEYS[i]
|
||||
local keyType = redis.call('TYPE', key).ok
|
||||
local matches = ARGV[1] == ''
|
||||
if not matches and keyType == 'hash' then
|
||||
matches = redis.call('HGET', key, 'auctionLifecycleId') == ARGV[1]
|
||||
elseif not matches and keyType == 'string' then
|
||||
-- Retain compatibility with payloads written before the Hash format.
|
||||
local ok, payload = pcall(cjson.decode, redis.call('GET', key))
|
||||
matches = ok and type(payload) == 'table' and payload.auctionLifecycleId == ARGV[1]
|
||||
end
|
||||
if matches then
|
||||
redis.call('ZREM', KEYS[1], key)
|
||||
redis.call('ZREM', KEYS[2], key)
|
||||
deleted = deleted + redis.call('UNLINK', key)
|
||||
end
|
||||
end
|
||||
return deleted
|
||||
`,
|
||||
);
|
||||
@@ -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',
|
||||
|
||||
@@ -4,6 +4,14 @@ export const AUCTION_DURABILITY_RETRY_QUEUE_KEY =
|
||||
'auction:auctionDurabilityRetryQueue';
|
||||
export const AUCTION_DURABILITY_DEAD_LETTER_QUEUE_KEY =
|
||||
'auction:auctionDurabilityDeadLetterQueue';
|
||||
export const AUCTION_DEAD_LETTER_STATUS_QUEUE_KEY =
|
||||
'auction:deadLetterStatusQueue';
|
||||
export const AUCTION_BID_ARCHIVE_QUEUE_KEY = 'auction:bidArchiveQueue';
|
||||
export const AUCTION_BID_ARCHIVE_PAYLOADS_KEY = 'auction:bidArchivePayloads';
|
||||
export const AUCTION_BID_ARCHIVE_DEAD_LETTER_QUEUE_KEY =
|
||||
'auction:bidArchiveDeadLetterQueue';
|
||||
export const AUCTION_BID_ARCHIVE_DEAD_LETTER_PAYLOADS_KEY =
|
||||
'auction:bidArchiveDeadLetterPayloads';
|
||||
|
||||
export interface AuctionRedisKeys {
|
||||
actionRequestResultOrderKey: string;
|
||||
@@ -12,6 +20,7 @@ export interface AuctionRedisKeys {
|
||||
bidHistoryKey: string;
|
||||
bidRequestResultOrderKey: string;
|
||||
bidRequestResultsKey: string;
|
||||
rejectedBidRequestResultOrderKey: string;
|
||||
deadlineQueueKey: string;
|
||||
durabilityDeadLetterQueueKey: string;
|
||||
durabilityPayloadKey: (auctionStateTransitionId: string) => string;
|
||||
@@ -33,6 +42,7 @@ export function buildAuctionRedisKeys(matchId: string): AuctionRedisKeys {
|
||||
bidHistoryKey: `${prefix}:auctionBidHistory`,
|
||||
bidRequestResultOrderKey: `${prefix}:bidRequestResultOrder`,
|
||||
bidRequestResultsKey: `${prefix}:bidRequestResults`,
|
||||
rejectedBidRequestResultOrderKey: `${prefix}:rejectedBidRequestResultOrder`,
|
||||
deadlineQueueKey: AUCTION_BID_ROUND_DEADLINE_QUEUE_KEY,
|
||||
durabilityDeadLetterQueueKey: AUCTION_DURABILITY_DEAD_LETTER_QUEUE_KEY,
|
||||
durabilityPayloadKey: (auctionStateTransitionId: string) =>
|
||||
|
||||
@@ -2,10 +2,7 @@ import { Logger, Module } from '@nestjs/common';
|
||||
import { createClient } from 'redis';
|
||||
import { SecretModule } from '../../global/secret/secret.module';
|
||||
import { SecretService } from '../../global/secret/secret.service';
|
||||
import {
|
||||
assertDistinctRedisInstances,
|
||||
resolveRedisClientOptions,
|
||||
} from '../../global/redis/redis.config';
|
||||
import { loadRedisClientOptions } from '../../global/redis/redis.config';
|
||||
import { AUCTION_REDIS_CLIENT } from './auction-redis.constants';
|
||||
import {
|
||||
AuctionRedisService,
|
||||
@@ -14,18 +11,6 @@ import {
|
||||
import { AuctionRedisCommandService } from './auction-redis-command.service';
|
||||
import { AuctionRedisStateReaderService } from './auction-redis-state-reader.service';
|
||||
|
||||
async function readFirstSecret(
|
||||
secretService: SecretService,
|
||||
keys: string[],
|
||||
): Promise<string | undefined> {
|
||||
for (const key of keys) {
|
||||
const value = await secretService.get<string>(key, '');
|
||||
const trimmed = value.trim();
|
||||
if (trimmed) return trimmed;
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
@Module({
|
||||
imports: [SecretModule],
|
||||
providers: [
|
||||
@@ -35,48 +20,15 @@ async function readFirstSecret(
|
||||
useFactory: async (
|
||||
secretService: SecretService,
|
||||
): Promise<AuctionRedisClient> => {
|
||||
await secretService.ready();
|
||||
|
||||
const [
|
||||
redisUrl,
|
||||
redisEndpoint,
|
||||
auctionRedisUrl,
|
||||
auctionRedisEndpoint,
|
||||
auctionRedisUsername,
|
||||
auctionRedisPassword,
|
||||
] = await Promise.all([
|
||||
readFirstSecret(secretService, ['REDIS_URL', 'GARNET_URL']),
|
||||
readFirstSecret(secretService, ['REDIS_ENDPOINT', 'GARNET_ENDPOINT']),
|
||||
readFirstSecret(secretService, ['AUCTION_REDIS_URL']),
|
||||
readFirstSecret(secretService, ['AUCTION_REDIS_ENDPOINT']),
|
||||
readFirstSecret(secretService, [
|
||||
'AUCTION_REDIS_USERNAME',
|
||||
'AUCTION_REDIS_USERID',
|
||||
]),
|
||||
readFirstSecret(secretService, ['AUCTION_REDIS_PASSWORD']),
|
||||
]);
|
||||
|
||||
const redisOptions = resolveRedisClientOptions({
|
||||
endpoint: redisEndpoint,
|
||||
endpointEnvName: 'REDIS_ENDPOINT',
|
||||
url: redisUrl,
|
||||
urlEnvName: 'REDIS_URL',
|
||||
});
|
||||
const auctionRedisOptions = resolveRedisClientOptions({
|
||||
endpoint: auctionRedisEndpoint,
|
||||
endpointEnvName: 'AUCTION_REDIS_ENDPOINT',
|
||||
password: auctionRedisPassword,
|
||||
url: auctionRedisUrl,
|
||||
urlEnvName: 'AUCTION_REDIS_URL',
|
||||
username: auctionRedisUsername,
|
||||
});
|
||||
assertDistinctRedisInstances(redisOptions.url, auctionRedisOptions.url);
|
||||
|
||||
const logger = new Logger('AuctionRedisClient');
|
||||
const client = createClient(auctionRedisOptions);
|
||||
client.on('error', (error) => {
|
||||
const client = createClient(
|
||||
await loadRedisClientOptions(secretService),
|
||||
);
|
||||
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,17 +125,11 @@ export class AuctionRedisService implements OnModuleDestroy {
|
||||
String(ttlMS),
|
||||
'NX',
|
||||
]);
|
||||
return String(result) === 'OK';
|
||||
return result === 'OK';
|
||||
}
|
||||
|
||||
public async releaseTokenLock(key: string, token: string): Promise<boolean> {
|
||||
const result = await this.client.sendCommand([
|
||||
'EVAL',
|
||||
'if redis.call("GET", KEYS[1]) == ARGV[1] then return redis.call("DEL", KEYS[1]) else return 0 end',
|
||||
'1',
|
||||
key,
|
||||
token,
|
||||
]);
|
||||
const result = await this.client.sendCommand(['DELEX', key, 'IFEQ', token]);
|
||||
return Number(result) === 1;
|
||||
}
|
||||
}
|
||||
@@ -24,7 +24,7 @@ describe('auction redis state assembly', () => {
|
||||
mongo: { auctionLifecycleId: 'new-life', revision: 2 },
|
||||
},
|
||||
{
|
||||
expected: false,
|
||||
expected: true,
|
||||
live: { auctionLifecycleId: 'redis-life', revision: 3 },
|
||||
mongo: { auctionLifecycleId: 'mongo-life', revision: 2 },
|
||||
},
|
||||
@@ -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',
|
||||
);
|
||||
|
||||
@@ -62,13 +62,11 @@ export function shouldHydrateRedisAuctionState(
|
||||
params: ShouldHydrateRedisAuctionStateParams,
|
||||
): boolean {
|
||||
if (!params.live) return true;
|
||||
if (params.mongo.auctionLifecycleId !== params.live.auctionLifecycleId)
|
||||
return true;
|
||||
const redisRevision = params.live.revision ?? -1;
|
||||
const mongoRevision = params.mongo.revision;
|
||||
if (mongoRevision > redisRevision) return true;
|
||||
return (
|
||||
mongoRevision === redisRevision &&
|
||||
params.mongo.auctionLifecycleId !== params.live.auctionLifecycleId
|
||||
);
|
||||
return mongoRevision > redisRevision;
|
||||
}
|
||||
|
||||
export function assembleAuctionViewFromRedisState(
|
||||
@@ -78,9 +76,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 +86,11 @@ export function assembleAuctionViewFromRedisState(
|
||||
};
|
||||
}
|
||||
|
||||
function parseJsonValue(json: string): unknown {
|
||||
const value: unknown = JSON.parse(json);
|
||||
return value;
|
||||
}
|
||||
|
||||
export function buildHydrateAuctionStateScriptInvocation(
|
||||
keys: AuctionRedisKeys,
|
||||
input: HydrateAuctionStateScriptInput,
|
||||
@@ -137,13 +138,17 @@ if not liveStatePatchPairCount or #ARGV ~= 8 + (liveStatePatchPairCount * 2) the
|
||||
return {'REJECTED', 'INVALID_PATCH_ARITY', tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
|
||||
-- A lifecycle replacement requires Mongo authority and an explicit cleanup
|
||||
-- under the lifecycle lock. Revision numbers from different runs are unrelated.
|
||||
if redisAuctionLifecycleId and redisAuctionLifecycleId ~= mongoAuctionLifecycleId then
|
||||
return {'REJECTED', 'LIFECYCLE_CONFLICT', tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
|
||||
local shouldHydrate = false
|
||||
if redisRevision < 0 then
|
||||
shouldHydrate = true
|
||||
elseif mongoRevision > redisRevision then
|
||||
shouldHydrate = true
|
||||
elseif mongoRevision == redisRevision and mongoAuctionLifecycleId ~= redisAuctionLifecycleId then
|
||||
shouldHydrate = true
|
||||
end
|
||||
|
||||
if not shouldHydrate then
|
||||
@@ -181,6 +186,7 @@ if phase == 'bidding' then
|
||||
redis.call('ZADD', bidRoundDeadlineQueueKey, currentBidRoundDeadlineTimestampMS, matchId)
|
||||
else
|
||||
redis.call('ZREM', bidRoundDeadlineQueueKey, matchId)
|
||||
redis.call('HDEL', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS')
|
||||
end
|
||||
|
||||
return {'OK', tostring(hydratedRevision), tostring(currentRedisTimestampMS)}
|
||||
|
||||
@@ -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.');
|
||||
}
|
||||
|
||||
@@ -4,6 +4,7 @@ import { ConnectionService } from '../global/database/connection.service';
|
||||
import { IdentityDocument, UserDocument } from '../global/database/schema';
|
||||
import { UserResolverGuard } from './user-resolver.guard';
|
||||
import './auth-request';
|
||||
import type { Request } from 'express';
|
||||
|
||||
function createContext(request: Record<string, unknown>): ExecutionContext {
|
||||
return {
|
||||
@@ -24,7 +25,7 @@ describe('UserResolverGuard', () => {
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockResolvedValue({ findOne }),
|
||||
} as unknown as ConnectionService;
|
||||
const request = {
|
||||
const request: Pick<Request, 'params' | 'identity' | 'user'> = {
|
||||
params: { communityId: communityId.toString() },
|
||||
identity: { _id: identityId } as IdentityDocument,
|
||||
};
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -1,8 +1,67 @@
|
||||
import { Injectable, Logger } from '@nestjs/common';
|
||||
import { randomUUID } from 'crypto';
|
||||
import { RedisService } from '../global/redis/redis.service';
|
||||
|
||||
const COMMUNITY_STATS_TTL_SECONDS = 5 * 60;
|
||||
const COMMUNITY_STATS_DETAIL_TTL_SECONDS = 24 * 60 * 60;
|
||||
const CACHE_SCOPES = [
|
||||
'matches',
|
||||
'leaderboard',
|
||||
'teamInsights',
|
||||
'matchDetail',
|
||||
'userInternal',
|
||||
] as const;
|
||||
type CacheScope = (typeof CACHE_SCOPES)[number];
|
||||
|
||||
function communityPrefix(communityId: string): string {
|
||||
return `riot:communitystats:v2:{${communityId}}`;
|
||||
}
|
||||
|
||||
export class CommunityStatsCacheKey {
|
||||
public readonly generationKey: string;
|
||||
public readonly hashKey: string;
|
||||
public generation?: string;
|
||||
|
||||
constructor(
|
||||
communityId: string,
|
||||
scope: CacheScope,
|
||||
public readonly field: string,
|
||||
) {
|
||||
const prefix = communityPrefix(communityId);
|
||||
this.generationKey = `${prefix}:generation`;
|
||||
this.hashKey = `${prefix}:${scope}`;
|
||||
}
|
||||
|
||||
public get identity(): string {
|
||||
return JSON.stringify([this.hashKey, this.generation, this.field]);
|
||||
}
|
||||
}
|
||||
|
||||
const READ_CACHE_SCRIPT = `
|
||||
local generation = redis.call('GET', KEYS[1])
|
||||
if not generation then
|
||||
generation = ARGV[1]
|
||||
redis.call('SET', KEYS[1], generation)
|
||||
end
|
||||
return {generation, redis.call('HGET', KEYS[2], ARGV[2])}
|
||||
`;
|
||||
|
||||
const WRITE_CACHE_SCRIPT = `
|
||||
if redis.call('GET', KEYS[1]) ~= ARGV[1] then return 0 end
|
||||
redis.call('HSETEX', KEYS[2], 'EX', ARGV[4], 'FIELDS', 1, ARGV[2], ARGV[3])
|
||||
return 1
|
||||
`;
|
||||
|
||||
const INVALIDATE_CACHE_SCRIPT = `
|
||||
-- A fill started before invalidation cannot publish into the new generation.
|
||||
redis.call('SET', KEYS[1], ARGV[1])
|
||||
local deleted = 0
|
||||
for i = 2, #KEYS do
|
||||
deleted = deleted + redis.call('HLEN', KEYS[i])
|
||||
redis.call('UNLINK', KEYS[i])
|
||||
end
|
||||
return deleted
|
||||
`;
|
||||
|
||||
@Injectable()
|
||||
export class CommunityStatsCacheService {
|
||||
@@ -10,48 +69,72 @@ export class CommunityStatsCacheService {
|
||||
|
||||
constructor(private readonly redisService: RedisService) {}
|
||||
|
||||
public get<T>(key: string): Promise<T | null> {
|
||||
return this.redisService.getJson<T>(key);
|
||||
public async get<T>(key: CommunityStatsCacheKey): Promise<T | null> {
|
||||
const reply = await this.redisService
|
||||
.raw()
|
||||
.sendCommand<
|
||||
[string, string | null]
|
||||
>(['EVAL', READ_CACHE_SCRIPT, '2', key.generationKey, key.hashKey, randomUUID(), key.field]);
|
||||
key.generation = reply[0];
|
||||
if (!reply[1]) return null;
|
||||
try {
|
||||
return JSON.parse(reply[1]) as T;
|
||||
} catch {
|
||||
this.logger.warn(
|
||||
`Failed to parse community stats cache field in ${key.hashKey}.`,
|
||||
);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public set(
|
||||
key: string,
|
||||
public async set(
|
||||
key: CommunityStatsCacheKey,
|
||||
value: unknown,
|
||||
ttlSeconds = COMMUNITY_STATS_TTL_SECONDS,
|
||||
): Promise<void> {
|
||||
return this.redisService.setJson(key, value, ttlSeconds);
|
||||
if (!key.generation)
|
||||
throw new Error(
|
||||
'Read the cache generation before starting a cache fill.',
|
||||
);
|
||||
if (!Number.isInteger(ttlSeconds) || ttlSeconds <= 0)
|
||||
throw new Error('Cache TTL must be a positive integer.');
|
||||
await this.redisService
|
||||
.raw()
|
||||
.sendCommand([
|
||||
'EVAL',
|
||||
WRITE_CACHE_SCRIPT,
|
||||
'2',
|
||||
key.generationKey,
|
||||
key.hashKey,
|
||||
key.generation,
|
||||
key.field,
|
||||
JSON.stringify(value),
|
||||
String(ttlSeconds),
|
||||
]);
|
||||
}
|
||||
|
||||
public setDetail(key: string, value: unknown): Promise<void> {
|
||||
public setDetail(key: CommunityStatsCacheKey, value: unknown): Promise<void> {
|
||||
return this.set(key, value, COMMUNITY_STATS_DETAIL_TTL_SECONDS);
|
||||
}
|
||||
|
||||
public async invalidateCommunity(communityId: string): Promise<number> {
|
||||
const prefix = `riot:communitystats:`;
|
||||
const match = `${prefix}*${communityId}*`;
|
||||
const client = this.redisService.raw();
|
||||
let cursor = '0';
|
||||
let deleted = 0;
|
||||
|
||||
do {
|
||||
const reply = (await client.sendCommand([
|
||||
'SCAN',
|
||||
cursor,
|
||||
'MATCH',
|
||||
match,
|
||||
'COUNT',
|
||||
'100',
|
||||
])) as [string, string[]];
|
||||
cursor = reply[0];
|
||||
const keys = reply[1] ?? [];
|
||||
if (keys.length > 0) {
|
||||
deleted += await client.del(keys);
|
||||
}
|
||||
} while (cursor !== '0');
|
||||
const prefix = communityPrefix(communityId);
|
||||
const deleted = Number(
|
||||
await this.redisService
|
||||
.raw()
|
||||
.sendCommand([
|
||||
'EVAL',
|
||||
INVALIDATE_CACHE_SCRIPT,
|
||||
String(CACHE_SCOPES.length + 1),
|
||||
`${prefix}:generation`,
|
||||
...CACHE_SCOPES.map((scope) => `${prefix}:${scope}`),
|
||||
randomUUID(),
|
||||
]),
|
||||
);
|
||||
|
||||
if (deleted > 0) {
|
||||
this.logger.debug(
|
||||
`Invalidated ${deleted} community stats cache keys for ${communityId}.`,
|
||||
`Invalidated ${deleted} community stats cache entries for ${communityId}.`,
|
||||
);
|
||||
}
|
||||
return deleted;
|
||||
|
||||
@@ -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,
|
||||
}),
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@@ -1,6 +1,9 @@
|
||||
import mongoose from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import { CommunityStatsCacheService } from './community-stats-cache.service';
|
||||
import {
|
||||
CommunityStatsCacheKey,
|
||||
CommunityStatsCacheService,
|
||||
} from './community-stats-cache.service';
|
||||
import { CommunityStatsService } from './community-stats.service';
|
||||
import type {
|
||||
InternalMatchCardView,
|
||||
@@ -8,7 +11,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 +86,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 +100,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 +142,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 +240,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.objectContaining({ field: 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: CommunityStatsCacheKey, value: InternalMatchDetailResponse) => {
|
||||
cachedResponse = value;
|
||||
return Promise.resolve();
|
||||
},
|
||||
);
|
||||
const setDetail = jest
|
||||
.fn()
|
||||
.mockImplementation(
|
||||
(_key: CommunityStatsCacheKey, 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.objectContaining({ field: 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.objectContaining({ field: 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 +506,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',
|
||||
@@ -262,7 +550,9 @@ describe('CommunityStatsService', () => {
|
||||
).toEqual([matchId.toString()]);
|
||||
expect(buildBaseDataset).not.toHaveBeenCalled();
|
||||
expect(cacheService.set).toHaveBeenCalledWith(
|
||||
expect.stringContaining(`userInternal:v3:${userId.toString()}`),
|
||||
expect.objectContaining({
|
||||
field: expect.stringContaining(`userInternal:v3:${userId.toString()}`),
|
||||
}),
|
||||
response,
|
||||
);
|
||||
});
|
||||
@@ -275,7 +565,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 +591,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 +625,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);
|
||||
});
|
||||
});
|
||||
@@ -11,7 +11,10 @@ import type {
|
||||
HistorySeasonDto,
|
||||
RecentMatchView,
|
||||
} from '../match-history/match-history.types';
|
||||
import { CommunityStatsCacheService } from './community-stats-cache.service';
|
||||
import {
|
||||
CommunityStatsCacheKey,
|
||||
CommunityStatsCacheService,
|
||||
} from './community-stats-cache.service';
|
||||
import type {
|
||||
CommunityStatsFilters,
|
||||
InternalMatchCardView,
|
||||
@@ -40,7 +43,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 +63,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>
|
||||
@@ -214,11 +222,36 @@ export class CommunityStatsService {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
}): Promise<InternalMatchDetailResponse> {
|
||||
const key = `riot:communitystats:matchDetail:v${MATCH_STATS_BUILDER_VERSION}:r${MATCH_DETAIL_RESPONSE_CACHE_VERSION}:${params.communityId.toString()}:${params.matchId.toString()}`;
|
||||
const key = new CommunityStatsCacheKey(
|
||||
params.communityId.toString(),
|
||||
'matchDetail',
|
||||
`v${MATCH_STATS_BUILDER_VERSION}:r${MATCH_DETAIL_RESPONSE_CACHE_VERSION}:${params.matchId.toString()}`,
|
||||
);
|
||||
const cached =
|
||||
await this.cacheService.get<InternalMatchDetailResponse>(key);
|
||||
if (cached && isCompleteMatchDetailResponse(cached)) return cached;
|
||||
|
||||
const inFlight = this.matchDetailInFlight.get(key.identity);
|
||||
if (inFlight) return inFlight;
|
||||
|
||||
const promise = this.buildMatchDetailResponse(params, key);
|
||||
this.matchDetailInFlight.set(key.identity, promise);
|
||||
try {
|
||||
return await promise;
|
||||
} finally {
|
||||
if (this.matchDetailInFlight.get(key.identity) === promise) {
|
||||
this.matchDetailInFlight.delete(key.identity);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async buildMatchDetailResponse(
|
||||
params: {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
},
|
||||
key: CommunityStatsCacheKey,
|
||||
): Promise<InternalMatchDetailResponse> {
|
||||
const dataset = await this.buildBaseDataset(params.communityId, {
|
||||
seasonId: 'all',
|
||||
});
|
||||
@@ -238,60 +271,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;
|
||||
}
|
||||
|
||||
@@ -311,16 +353,16 @@ export class CommunityStatsService {
|
||||
|
||||
// Auction viewers can all request the same next player's internal history
|
||||
// at once. Coalesce local cache misses so one player change does one DB read.
|
||||
const inFlight = this.userInternalHistoryInFlight.get(key);
|
||||
const inFlight = this.userInternalHistoryInFlight.get(key.identity);
|
||||
if (inFlight) return inFlight;
|
||||
|
||||
const promise = this.buildUserInternalHistoryResponse(params, key);
|
||||
this.userInternalHistoryInFlight.set(key, promise);
|
||||
this.userInternalHistoryInFlight.set(key.identity, promise);
|
||||
try {
|
||||
return await promise;
|
||||
} finally {
|
||||
if (this.userInternalHistoryInFlight.get(key) === promise) {
|
||||
this.userInternalHistoryInFlight.delete(key);
|
||||
if (this.userInternalHistoryInFlight.get(key.identity) === promise) {
|
||||
this.userInternalHistoryInFlight.delete(key.identity);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -357,7 +399,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 +415,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),
|
||||
),
|
||||
);
|
||||
@@ -393,7 +435,7 @@ export class CommunityStatsService {
|
||||
userId: mongoose.Types.ObjectId;
|
||||
filters: CommunityStatsFilters;
|
||||
},
|
||||
cacheKey: string,
|
||||
cacheKey: CommunityStatsCacheKey,
|
||||
): Promise<UserInternalHistoryResponse> {
|
||||
const context = await this.resolveContext(
|
||||
params.communityId,
|
||||
@@ -407,11 +449,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 +495,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 +531,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 +547,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 +564,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;
|
||||
}
|
||||
|
||||
@@ -1070,18 +1145,31 @@ export class CommunityStatsService {
|
||||
scope: string,
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
filters: CommunityStatsFilters,
|
||||
): string {
|
||||
return [
|
||||
'riot:communitystats',
|
||||
scope,
|
||||
): CommunityStatsCacheKey {
|
||||
const cacheScope = scope.startsWith('userInternal:')
|
||||
? 'userInternal'
|
||||
: scope;
|
||||
if (
|
||||
cacheScope !== 'matches' &&
|
||||
cacheScope !== 'leaderboard' &&
|
||||
cacheScope !== 'teamInsights' &&
|
||||
cacheScope !== 'userInternal'
|
||||
) {
|
||||
throw new Error(`Unsupported community stats cache scope: ${scope}`);
|
||||
}
|
||||
return new CommunityStatsCacheKey(
|
||||
communityId.toString(),
|
||||
filters.seasonId ?? 'current',
|
||||
filters.from ?? '',
|
||||
filters.to ?? '',
|
||||
filters.championId ?? '',
|
||||
filters.cursor ?? '',
|
||||
filters.limit ?? '',
|
||||
].join(':');
|
||||
cacheScope,
|
||||
JSON.stringify([
|
||||
scope,
|
||||
filters.seasonId ?? 'current',
|
||||
filters.from ?? '',
|
||||
filters.to ?? '',
|
||||
filters.championId ?? '',
|
||||
filters.cursor ?? '',
|
||||
filters.limit ?? '',
|
||||
]),
|
||||
);
|
||||
}
|
||||
|
||||
private clampLimit(
|
||||
@@ -1129,6 +1217,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 +1225,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,26 @@ 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,
|
||||
preferredPositions: [],
|
||||
joinedAt: new Date('2026-05-03T00:00:00.000Z'),
|
||||
});
|
||||
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,7 +226,52 @@ describe('MatchStatsFragmentBuilder', () => {
|
||||
],
|
||||
},
|
||||
};
|
||||
const timeline = {
|
||||
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: RiotMatchTimelineDto = {
|
||||
metadata: {
|
||||
dataVersion: '2',
|
||||
matchId: 'KR_1',
|
||||
@@ -217,8 +282,22 @@ describe('MatchStatsFragmentBuilder', () => {
|
||||
frames: [
|
||||
{
|
||||
timestamp: 0,
|
||||
events: [],
|
||||
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 +370,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,
|
||||
},
|
||||
},
|
||||
},
|
||||
],
|
||||
@@ -301,9 +510,7 @@ describe('MatchStatsFragmentBuilder', () => {
|
||||
const fragment = builder.buildFragment({
|
||||
match,
|
||||
rawByRiotMatchId: new Map([['KR_1', raw as RiotMatchDto]]),
|
||||
timelineByRiotMatchId: new Map([
|
||||
['KR_1', timeline as RiotMatchTimelineDto],
|
||||
]),
|
||||
timelineByRiotMatchId: new Map([['KR_1', timeline]]),
|
||||
});
|
||||
|
||||
expect(fragment.gameDetails[0]).toMatchObject({
|
||||
@@ -329,19 +536,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 +649,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 +706,116 @@ 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]]),
|
||||
});
|
||||
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,173 @@
|
||||
import mongoose from 'mongoose';
|
||||
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 outbox idempotency', () => {
|
||||
it('reuses the latest stored revision when an older outbox event is delivered', async () => {
|
||||
const h = createHarness();
|
||||
h.isCurrent.mockResolvedValue(true);
|
||||
|
||||
await h.service.buildAndUpsert(h.matchId, { sourceRevision: 10 });
|
||||
|
||||
expect(h.isCurrent).toHaveBeenCalledWith({
|
||||
matchId: h.matchId,
|
||||
sourceCompetitionId: h.competitionId,
|
||||
sourceRevision: 12,
|
||||
projectorVersion: 3,
|
||||
builderVersion: MATCH_STATS_BUILDER_VERSION,
|
||||
});
|
||||
expect(h.riotFind).not.toHaveBeenCalled();
|
||||
expect(h.builder.buildFragment).not.toHaveBeenCalled();
|
||||
expect(h.upsert).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('builds once across repeated deliveries after the write succeeds', async () => {
|
||||
const h = createHarness();
|
||||
h.upsert.mockImplementation(async () => {
|
||||
h.isCurrent.mockResolvedValue(true);
|
||||
});
|
||||
|
||||
await h.service.buildAndUpsert(h.matchId, { sourceRevision: 12 });
|
||||
await h.service.buildAndUpsert(h.matchId, { sourceRevision: 12 });
|
||||
|
||||
expect(h.riotFind).toHaveBeenCalledTimes(1);
|
||||
expect(h.builder.buildFragment).toHaveBeenCalledTimes(1);
|
||||
expect(h.upsert).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('retries a failed write without treating an attempted build as complete', async () => {
|
||||
const h = createHarness();
|
||||
h.upsert.mockRejectedValueOnce(new Error('database unavailable'));
|
||||
await expect(
|
||||
h.service.buildAndUpsert(h.matchId, { sourceRevision: 12 }),
|
||||
).rejects.toThrow('database unavailable');
|
||||
|
||||
await h.service.buildAndUpsert(h.matchId, { sourceRevision: 12 });
|
||||
|
||||
expect(h.builder.buildFragment).toHaveBeenCalledTimes(2);
|
||||
expect(h.upsert).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
|
||||
it.each([{}, { sourceRevision: 12, includeTimeline: true }])(
|
||||
'still performs explicit rebuilds and timeline hydration (%j)',
|
||||
async (options) => {
|
||||
const h = createHarness();
|
||||
h.isCurrent.mockResolvedValue(true);
|
||||
|
||||
await h.service.buildAndUpsert(h.matchId, options);
|
||||
|
||||
expect(h.isCurrent).not.toHaveBeenCalled();
|
||||
expect(h.builder.buildFragment).toHaveBeenCalledTimes(1);
|
||||
expect(h.upsert).toHaveBeenCalledTimes(1);
|
||||
if ('includeTimeline' in options) {
|
||||
expect(h.getMatchTimeline).toHaveBeenCalledWith('KR_1', {
|
||||
region: 'asia',
|
||||
});
|
||||
}
|
||||
},
|
||||
);
|
||||
|
||||
it('deletes reversed zero-game stats even if their versions were current', async () => {
|
||||
const h = createHarness();
|
||||
h.competition.projection.games = [];
|
||||
h.isCurrent.mockResolvedValue(true);
|
||||
|
||||
await h.service.buildAndUpsert(h.matchId, { sourceRevision: 12 });
|
||||
|
||||
expect(h.isCurrent).not.toHaveBeenCalled();
|
||||
expect(h.deleteByMatch).toHaveBeenCalledWith(h.matchId, {
|
||||
sourceCompetitionId: h.competitionId,
|
||||
sourceRevision: 12,
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
function createHarness() {
|
||||
const matchId = 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: new mongoose.Types.ObjectId(),
|
||||
status: 'in-progress',
|
||||
scheduledAt: new Date(),
|
||||
teams: [],
|
||||
};
|
||||
const competition = {
|
||||
_id: competitionId,
|
||||
revision: 12,
|
||||
projectorVersion: 3,
|
||||
teams: [
|
||||
{ teamId: teamAId, displayOrder: 1 },
|
||||
{ teamId: teamBId, displayOrder: 2 },
|
||||
],
|
||||
projection: {
|
||||
phase: 'running',
|
||||
games: [
|
||||
{
|
||||
displayNumber: 1,
|
||||
evidence: { type: 'riot', riotMatchId: 'KR_1' },
|
||||
teams: { blue: { teamId: teamAId }, red: { teamId: teamBId } },
|
||||
winnerTeamId: teamAId,
|
||||
},
|
||||
],
|
||||
},
|
||||
};
|
||||
const riotFind = jest.fn(() => query([{ matchId: 'KR_1', raw: {} }]));
|
||||
const models = {
|
||||
match: { findById: () => query(match) },
|
||||
competition: { findOne: () => query(competition) },
|
||||
riotMatch: { find: riotFind },
|
||||
community: { findById: () => query({ riotRegion: 'asia' }) },
|
||||
};
|
||||
const connection = {
|
||||
getModel: async (name: keyof typeof models) => models[name],
|
||||
} as unknown as ConnectionService;
|
||||
const isCurrent = jest.fn().mockResolvedValue(false);
|
||||
const upsert = jest.fn().mockResolvedValue(undefined);
|
||||
const deleteByMatch = jest.fn().mockResolvedValue(undefined);
|
||||
const repository = {
|
||||
hasCurrentCompetitionFragment: isCurrent,
|
||||
upsert,
|
||||
deleteByMatch,
|
||||
} as unknown as MatchStatsRepository;
|
||||
const builder = {
|
||||
buildFragment: jest.fn().mockReturnValue({
|
||||
matchCard: {},
|
||||
records: [],
|
||||
gameDetails: [],
|
||||
userIds: [],
|
||||
championIds: [],
|
||||
gameCreationMin: 1,
|
||||
gameCreationMax: 2,
|
||||
}),
|
||||
} as unknown as jest.Mocked<MatchStatsFragmentBuilder>;
|
||||
const getMatchTimeline = jest.fn().mockResolvedValue(undefined);
|
||||
const service = new MatchStatsService(connection, repository, builder, {
|
||||
getMatchTimeline,
|
||||
} as never);
|
||||
return {
|
||||
service,
|
||||
matchId,
|
||||
competitionId,
|
||||
competition,
|
||||
isCurrent,
|
||||
upsert,
|
||||
deleteByMatch,
|
||||
riotFind,
|
||||
builder,
|
||||
getMatchTimeline,
|
||||
};
|
||||
}
|
||||
|
||||
function query<T>(value: T) {
|
||||
return {
|
||||
select: jest.fn().mockReturnThis(),
|
||||
lean: jest.fn().mockReturnThis(),
|
||||
exec: async () => value,
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,245 @@
|
||||
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.each([null, { _id: new Types.ObjectId() }])(
|
||||
'checks persisted source identity and every build version without loading payloads (%j)',
|
||||
async (stored) => {
|
||||
const exists = jest.fn(() => ({ exec: async () => stored }));
|
||||
const connection = {
|
||||
getModel: jest.fn().mockResolvedValue({ exists }),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = new MatchStatsRepository(connection);
|
||||
const source = {
|
||||
matchId: new Types.ObjectId(),
|
||||
sourceCompetitionId: new Types.ObjectId(),
|
||||
sourceRevision: 12,
|
||||
projectorVersion: 3,
|
||||
builderVersion: 10,
|
||||
};
|
||||
|
||||
await expect(
|
||||
repository.hasCurrentCompetitionFragment(source),
|
||||
).resolves.toBe(Boolean(stored));
|
||||
expect(exists).toHaveBeenCalledWith({
|
||||
matchId: source.matchId,
|
||||
sourceCompetitionId: source.sourceCompetitionId,
|
||||
sourceRevision: { $gte: 12 },
|
||||
projectorVersion: { $gte: 3 },
|
||||
builderVersion: { $gte: 10 },
|
||||
});
|
||||
},
|
||||
);
|
||||
|
||||
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,24 +13,118 @@ export type MatchStatsDetailFragment = Pick<
|
||||
'matchId' | 'gameDetails'
|
||||
>;
|
||||
|
||||
export interface MatchStatsDeleteGuard {
|
||||
sourceCompetitionId: mongoose.Types.ObjectId;
|
||||
sourceRevision: number;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class MatchStatsRepository {
|
||||
constructor(private readonly connectionService: ConnectionService) {}
|
||||
|
||||
public async hasCurrentCompetitionFragment(params: {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
sourceCompetitionId: mongoose.Types.ObjectId;
|
||||
sourceRevision: number;
|
||||
projectorVersion: number;
|
||||
builderVersion: number;
|
||||
}): Promise<boolean> {
|
||||
const MatchStatsModel = await this.connectionService.getModel('matchStats');
|
||||
return Boolean(
|
||||
await MatchStatsModel.exists({
|
||||
matchId: params.matchId,
|
||||
sourceCompetitionId: params.sourceCompetitionId,
|
||||
sourceRevision: { $gte: params.sourceRevision },
|
||||
projectorVersion: { $gte: params.projectorVersion },
|
||||
builderVersion: { $gte: params.builderVersion },
|
||||
}).exec(),
|
||||
);
|
||||
}
|
||||
|
||||
public async upsert(
|
||||
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 +135,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 +242,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,11 +18,13 @@ 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}`);
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
hasCurrentCompetitionFragment: jest.fn().mockResolvedValue(false),
|
||||
deleteByMatch: jest.fn().mockResolvedValue(undefined),
|
||||
upsert: jest.fn(),
|
||||
} as unknown as jest.Mocked<MatchStatsRepository>;
|
||||
@@ -38,6 +41,58 @@ 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 = {
|
||||
hasCurrentCompetitionFragment: jest.fn().mockResolvedValue(false),
|
||||
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,11 +128,13 @@ 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}`);
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
hasCurrentCompetitionFragment: jest.fn().mockResolvedValue(false),
|
||||
upsert: jest.fn().mockResolvedValue(undefined),
|
||||
deleteByMatch: jest.fn(),
|
||||
} as unknown as jest.Mocked<MatchStatsRepository>;
|
||||
@@ -105,8 +162,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 +173,476 @@ 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 = {
|
||||
hasCurrentCompetitionFragment: jest.fn().mockResolvedValue(false),
|
||||
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: ReturnType<
|
||||
MatchStatsFragmentBuilder['buildFragment']
|
||||
> = {
|
||||
matchCard: {
|
||||
matchId: matchId.toString(),
|
||||
title: '내전',
|
||||
scheduledAt: match.scheduledAt.toISOString(),
|
||||
status: 'finished',
|
||||
gameCount: 1,
|
||||
games: [],
|
||||
teams: [],
|
||||
seriesResults: [],
|
||||
},
|
||||
records: [],
|
||||
gameDetails: [],
|
||||
userIds: [],
|
||||
championIds: [],
|
||||
gameCreationMin: 1_000,
|
||||
gameCreationMax: 2_000,
|
||||
};
|
||||
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 = {
|
||||
hasCurrentCompetitionFragment: jest.fn().mockResolvedValue(false),
|
||||
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 = {
|
||||
hasCurrentCompetitionFragment: jest.fn().mockResolvedValue(false),
|
||||
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 = {
|
||||
hasCurrentCompetitionFragment: jest.fn().mockResolvedValue(false),
|
||||
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,58 @@ 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 = [
|
||||
// Outbox redelivery (including older events observing the latest revision)
|
||||
// must not reload Riot payloads or replace an already enriched fragment.
|
||||
// Explicit rebuilds and timeline hydration still run at the same revision.
|
||||
if (
|
||||
options.sourceRevision !== undefined &&
|
||||
!options.includeTimeline &&
|
||||
competitionSource &&
|
||||
(await this.repository.hasCurrentCompetitionFragment({
|
||||
matchId,
|
||||
sourceCompetitionId: competitionSource.sourceCompetitionId,
|
||||
sourceRevision: competitionSource.sourceRevision,
|
||||
projectorVersion: competitionSource.projectorVersion,
|
||||
builderVersion: MATCH_STATS_BUILDER_VERSION,
|
||||
}))
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
const riotIds = competitionSource?.riotMatchIds ?? [
|
||||
...new Set(
|
||||
(match.result?.games ?? [])
|
||||
.map((game) => game.riotMatchId)
|
||||
@@ -55,7 +95,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 +112,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 +139,9 @@ export class MatchStatsService {
|
||||
}
|
||||
|
||||
const fragment = this.builder.buildFragment({
|
||||
match,
|
||||
match: sourceMatch,
|
||||
rawByRiotMatchId,
|
||||
timelineByRiotMatchId,
|
||||
timelineLoadAttempted: options.includeTimeline === true,
|
||||
});
|
||||
|
||||
await this.repository.upsert({
|
||||
@@ -112,7 +157,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 +189,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 +231,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,523 @@
|
||||
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,
|
||||
);
|
||||
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,
|
||||
);
|
||||
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);
|
||||
|
||||
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);
|
||||
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);
|
||||
|
||||
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,
|
||||
);
|
||||
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,
|
||||
);
|
||||
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,
|
||||
);
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
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])),
|
||||
} as unknown as jest.Mocked<ConnectionService>;
|
||||
|
||||
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,765 @@
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
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);
|
||||
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])),
|
||||
} as unknown as jest.Mocked<ConnectionService>;
|
||||
|
||||
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,365 @@
|
||||
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);
|
||||
}
|
||||
|
||||
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])),
|
||||
} as unknown as jest.Mocked<ConnectionService>,
|
||||
};
|
||||
}
|
||||
|
||||
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(): ReturnType<typeof CompetitionSchema.indexes>;
|
||||
},
|
||||
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,638 @@
|
||||
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 { code?: string; seriesId: string }>(
|
||||
projection: { series: 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;
|
||||
}
|
||||
Loaded 100 of 374 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user