Compare commits

...
32 Commits
Author SHA1 Message Date
dahyeon 8567948084 fix: recover stale auction durability history 2026-06-26 04:02:11 -07:00
dahyeon 37f1f4225d fix: prevent auction snapshot mutation 2026-06-26 03:12:13 -07:00
dahyeon 6dbc643c44 chore: add api new relic observability 2026-06-26 01:22:55 -07:00
dahyeon d2fc126fed chore: reflect observability updates in release 83 2026-06-25 23:57:51 -07:00
dahyeon ab721873f3 fix: prevent empty-team auction completion state 2026-06-25 05:26:09 -07:00
dahyeon 2984bd1604 fix: resume tournament result polling after delayed codes 2026-06-25 04:58:10 -07:00
dahyeon e50a683336 feat: enhance auction internal profile 2026-06-24 02:47:10 -07:00
dahyeon 9c69e35cfa fix: smooth auction timer bar 2026-06-23 22:48:41 -07:00
dahyeonandClaude Opus 4.8 55b80e62cd fix: recover auction client from rejected transitions
거부(특히 낙관적 동시성 CONFLICT)를 받은 클라가 낡은 상태에 멈춰 후속
액션을 반복 거부받던 문제를 해결한다.

- 서버: 거부 ack에 설명적 거부코드(auctionRejectionReason)와 resync 권장
  여부, 그리고 resync 권장 거부에 한해 최신 권위 state를 동봉한다. 구조 전환
  거부는 내부 code(CONFLICT 등)를 구조화해 던져 매핑 가능하게 한다.
- 클라: 거부 시 동봉된 state로 즉시 rebaseline(없으면 join으로 재요청)하고,
  "낡은 화면" 거부면 구조 액션을 1회 자동 재시도한다. 거부 문구를 거부코드
  기반 한국어로 매핑한다(error 이벤트 채널 포함).

신규 auction-rejection 모듈로 짧은 내부 코드를 맥락이 담긴 설명적 코드로
변환한다.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-06-23 13:26:45 -07:00
dahyeonandClaude Opus 4.8 09d304d782 fix: pass event bus to deadline scheduler in rehearsal script
직전 커밋에서 AuctionDeadlineScheduler 생성자에 추가한 AuctionEventBusService
인자를 rehearsal 스크립트의 직접 생성부에도 반영해 빌드를 복구한다.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-06-23 11:54:38 -07:00
dahyeonandClaude Opus 4.8 46c8007e94 fix: broadcast auction state immediately on auto expiry
자동 만료(EXPIRE_PREPARE → completePreparedExpiry)는 게이트웨이를 거치지
않아 만료 확정 결과를 클라이언트에 즉시 알리는 동기 broadcast가 없었다.
그 결과 클라는 입찰 라운드 revision에 멈춰, 0초 근처 입찰 직후 "다음" 등
후속 액션에서 stale 관측값으로 CONFLICT를 반복했다.

AuctionDeadlineScheduler에 AuctionEventBusService를 주입해 만료 확정 직후
최신 state를 1차 broadcast한다. durability worker의 방송은 Mongo 성공 +
~1초 tick에 묶인 크래시 복구 백업임을 주석으로 명확히 했다.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-06-23 11:49:48 -07:00
dahyeon b367328df0 Improve auction realtime bid responsiveness 2026-06-23 09:46:38 -07:00
dahyeon c6f5a7077f fix: clear auction cache after cancellation 2026-06-23 03:43:12 -07:00
dahyeon 7c372f0392 fix: fully cancel redis auctions 2026-06-23 03:34:45 -07:00
dahyeon e8bb20d988 feat: redesign auction engine with redis sot 2026-06-23 03:16:04 -07:00
dahyeon 737702d78c chore: point dev web api to shared host 2026-06-22 12:16:28 -07:00
dahyeon 98c2323ff2 fix: sync auction timer with server time 2026-06-22 12:16:18 -07:00
dahyeon d2fe4604dd fix: show solo queue tier graph in auction 2026-06-22 05:07:28 -07:00
dahyeon b0dc857463 fix: reserve auction points for remaining slots 2026-06-22 04:37:06 -07:00
dahyeon bac29ac933 feat: auto provision tournament codes 2026-06-20 02:29:30 -07:00
dahyeon 65bc214fb2 feat: add finished match detail tabs 2026-06-20 01:19:39 -07:00
dahyeon 0434a5db66 feat: refine match game detail ux 2026-06-20 01:04:03 -07:00
dahyeon 747adfcb11 feat: improve match game detail ux 2026-06-19 16:57:28 -07:00
dahyeon 7b5604873e feat: add match game detail analytics 2026-06-20 07:26:20 +09:00
dahyeon c6da2013bd feat: add team page tournament code replacement 2026-06-19 04:01:22 -07:00
dahyeon b9881fcb6f fix: allow public tournament code replacement 2026-06-19 03:56:44 -07:00
dahyeon 303886ed53 feat: allow tournament code replacement 2026-06-19 03:43:53 -07:00
dahyeon 1272c81fa9 chore: add round-robin match repair script 2026-06-19 02:33:18 -07:00
dahyeon ade5735dc2 refactor: remove legacy round-robin repair 2026-06-19 01:36:34 -07:00
dahyeon 7399968fe8 fix: repair legacy round-robin schedules 2026-06-19 01:31:27 -07:00
dahyeon 658592973e feat: add limited round-robin scheduling 2026-06-19 01:13:50 -07:00
dahyeon 24983aeb09 feat: allow admins to add match participants 2026-06-16 06:39:50 -07:00
137 changed files with 26954 additions and 1322 deletions

No files matched your search

+1 -1
View File
@@ -1 +1 @@
77
83
+8 -1
View File
@@ -41,9 +41,16 @@ 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 --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
CMD ["apps/api/dist/main.js"]
ENV NEW_RELIC_HOME=/app/apps/api \
NEW_RELIC_APP_NAME=lolympus \
NEW_RELIC_AI_MONITORING_ENABLED=true \
NEW_RELIC_CUSTOM_INSIGHTS_EVENTS_MAX_SAMPLES_STORED=100000 \
NEW_RELIC_SPAN_EVENTS_MAX_SAMPLES_STORED=10000
CMD ["--import", "/app/apps/api/node_modules/newrelic/esm-loader.mjs", "-r", "/app/apps/api/node_modules/newrelic", "apps/api/dist/main.js"]
+27 -7
View File
@@ -4,7 +4,7 @@ LOLYMPUS는 리그 오브 레전드 커뮤니티의 여러 이벤트 중 내전(
<p align="center">
<video
src="https://git.dahyeon.us/dahyeon/lolympus-tournament-support/raw/branch/release/77/docs/screenshots/lolympus-demo.mp4"
src="https://git.dahyeon.us/dahyeon/lolympus-tournament-support/raw/branch/release/83/docs/screenshots/lolympus-demo.mp4"
poster="docs/screenshots/lolympus-auction.png"
width="960"
autoplay="autoplay"
@@ -13,20 +13,20 @@ LOLYMPUS는 리그 오브 레전드 커뮤니티의 여러 이벤트 중 내전(
playsinline="playsinline"
controls
>
<a href="https://git.dahyeon.us/dahyeon/lolympus-tournament-support/raw/branch/release/77/docs/screenshots/lolympus-demo.mp4">3초 간격 데모 영상 보기</a>
<a href="https://git.dahyeon.us/dahyeon/lolympus-tournament-support/raw/branch/release/83/docs/screenshots/lolympus-demo.mp4">3초 간격 데모 영상 보기</a>
</video>
</p>
<p align="center">
<a href="https://git.dahyeon.us/dahyeon/lolympus-tournament-support/raw/branch/release/77/docs/screenshots/lolympus-demo.mp4">3초 간격 데모 영상 보기</a>
<a href="https://git.dahyeon.us/dahyeon/lolympus-tournament-support/raw/branch/release/83/docs/screenshots/lolympus-demo.mp4">3초 간격 데모 영상 보기</a>
</p>
## 배포 주소
| Environment | Version | URL |
| ----------- | ------- | -------------------------------------- |
| Production | v77 | <https://lolympus.dahyeon.us/> |
| Staging | v77 | <https://890c50be.lolympus.pages.dev/> |
| Production | v83 | <https://lolympus.dahyeon.us/> |
| Staging | v83 | <https://release-83.lolympus.pages.dev/> |
## 개요
@@ -91,7 +91,8 @@ LOLYMPUS는 이 반복 작업을 줄이는 데 초점을 맞췄습니다. 운영
- TanStack Query
- NestJS
- MongoDB
- Redis/Garnet
- Redis
- Redis 8.4 (경매 실시간 상태 전용)
- NATS
- Riot API
- pnpm workspace
@@ -113,7 +114,9 @@ scripts/ deployment and maintenance scripts
- Node.js 24 이상
- pnpm 10.4.1 (`packageManager` 기준, `corepack enable`로 활성화 권장)
- MongoDB 7.0, Redis 5.0 이상, NATS 실행 환경
- MongoDB 7.0, 일반 캐시/스트림용 Redis, 경매 실시간 상태 전용 Redis 8.4, NATS 실행 환경
경매 Redis는 라이브 경매 상태의 source of truth로 사용되므로 일반 캐시/스트림 Redis와 물리적으로 분리해야 합니다. API는 `REDIS_URL`/`REDIS_ENDPOINT`와 별도로 `AUCTION_REDIS_URL`/`AUCTION_REDIS_ENDPOINT`를 읽고, 두 값이 같은 호스트/포트를 가리키면 부팅을 거부합니다.
## 실행 방법
@@ -125,6 +128,23 @@ pnpm start:web:dev
웹 앱은 기본적으로 `apps/web/.env.development` 값을 사용합니다. API 환경값은 `apps/project.env`와 실행 환경의 시크릿 설정을 함께 확인합니다.
### API New Relic APM
API 서버는 `newrelic` Node.js agent를 앱 코드보다 먼저 preload합니다. Docker 런타임과 `pnpm start:api:*` 스크립트 모두 `NEW_RELIC_HOME`을 API 패키지로 지정해 `apps/api/newrelic.cjs` 설정을 읽습니다.
Kubernetes에서는 Infisical이 `NEW_RELIC_LICENSE_KEY`를 프로세스 시작 전에 환경변수로 주입해야 합니다. 저장소에는 라이선스 키를 두지 않습니다.
비밀이 아닌 기본값은 Dockerfile과 `apps/api/newrelic.cjs`에 정의되어 있으며 필요하면 런타임 환경변수로 덮어쓸 수 있습니다.
```bash
NEW_RELIC_APP_NAME=lolympus
NEW_RELIC_AI_MONITORING_ENABLED=true
NEW_RELIC_CUSTOM_INSIGHTS_EVENTS_MAX_SAMPLES_STORED=100000
NEW_RELIC_SPAN_EVENTS_MAX_SAMPLES_STORED=10000
```
New Relic Node agent의 정수 환경변수는 `100k` 같은 축약형 대신 `100000`처럼 숫자 문자열을 사용합니다.
카카오톡 기반 명령어 기능은 Dakao(커스텀 카카오톡 게이트웨이) 연동이 필요합니다. Dakao가 실행 중이 아니거나 NATS를 통해 API 서버와 연결되어 있지 않으면 일정 조회, 내전 참가, 참가 취소, 계정 등록 같은 카카오톡 명령어는 사용할 수 없습니다.
## 커맨드
+69
View File
@@ -0,0 +1,69 @@
'use strict';
function readBoolean(name, defaultValue) {
const value = process.env[name];
if (value == null || value === '') return defaultValue;
return !['0', 'false', 'f', 'no', 'n', 'disabled'].includes(
value.toLowerCase(),
);
}
function readInteger(name, defaultValue) {
const rawValue = process.env[name]?.trim();
if (!rawValue) return defaultValue;
if (/^\d+$/.test(rawValue)) {
return Number.parseInt(rawValue, 10);
}
process.env[name] = String(defaultValue);
return defaultValue;
}
const hasLicenseKey = Boolean(process.env.NEW_RELIC_LICENSE_KEY);
exports.config = {
app_name: [process.env.NEW_RELIC_APP_NAME || 'lolympus'],
license_key: process.env.NEW_RELIC_LICENSE_KEY || '',
agent_enabled: readBoolean('NEW_RELIC_ENABLED', hasLicenseKey),
distributed_tracing: {
enabled: true,
},
ai_monitoring: {
enabled: readBoolean('NEW_RELIC_AI_MONITORING_ENABLED', true),
},
custom_insights_events: {
max_samples_stored: readInteger(
'NEW_RELIC_CUSTOM_INSIGHTS_EVENTS_MAX_SAMPLES_STORED',
100000,
),
},
span_events: {
max_samples_stored: readInteger(
'NEW_RELIC_SPAN_EVENTS_MAX_SAMPLES_STORED',
10000,
),
},
logging: {
level: process.env.NEW_RELIC_LOG_LEVEL || 'info',
},
instrumentation: {
timers: {
enabled: false,
},
},
allow_all_headers: false,
attributes: {
exclude: [
'request.headers.cookie',
'request.headers.authorization',
'request.headers.proxyAuthorization',
'request.headers.setCookie*',
'response.headers.cookie',
'response.headers.authorization',
'response.headers.proxyAuthorization',
'response.headers.setCookie*',
],
},
};
+5 -3
View File
@@ -10,9 +10,9 @@
"format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
"seed:dev": "ts-node src/seed.ts",
"seed:dakao-participant": "ts-node src/seed-dakao-participant.ts",
"start:dev": "node -e \"process.env.NODE_ENV='dev'; require('./dist/main.js')\"",
"start:staging": "node -e \"process.env.NODE_ENV='staging'; require('./dist/main.js')\"",
"start:prod": "node -e \"process.env.NODE_ENV='prod'; require('./dist/main.js')\"",
"start:dev": "NODE_ENV=dev NEW_RELIC_HOME=. node --import newrelic/esm-loader.mjs -r newrelic dist/main.js",
"start:staging": "NODE_ENV=staging NEW_RELIC_HOME=. node --import newrelic/esm-loader.mjs -r newrelic dist/main.js",
"start:prod": "NODE_ENV=prod NEW_RELIC_HOME=. node --import newrelic/esm-loader.mjs -r newrelic dist/main.js",
"pm2:dev": "pm2 start npm --name lolympus-tournament-support --update-env -- run start:dev",
"pm2:staging": "pm2 start npm --name lolympus-tournament-support --update-env -- run start:staging",
"pm2:prod": "pm2 start npm --name lolympus-tournament-support --update-env -- run start:prod",
@@ -32,11 +32,13 @@
"@nestjs/platform-socket.io": "^11.1.19",
"@nestjs/swagger": "^11.2.7",
"@nestjs/websockets": "^11.1.19",
"@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",
"nats": "^2.29.3",
"newrelic": "^14.1.2",
"redis": "^5.12.1",
"reflect-metadata": "^0.2.2",
"rxjs": "^7.8.1",
+4
View File
@@ -2,6 +2,7 @@ import { ValidationPipe } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { createCorsOrigin } from './cors-origin';
import { RedisIoAdapter } from './redis-io.adapter';
async function bootstrap() {
const app = await NestFactory.create(AppModule, {
@@ -10,6 +11,9 @@ async function bootstrap() {
const nodeEnv = process.env.NODE_ENV;
const isDev = nodeEnv === 'dev';
const redisIoAdapter = new RedisIoAdapter(app);
await redisIoAdapter.connectToRedis();
app.useWebSocketAdapter(redisIoAdapter);
app.enableCors({
origin: createCorsOrigin(nodeEnv),
@@ -0,0 +1,217 @@
import { AuctionRedisService } from './redis/auction-redis.service';
import { AuctionDeadlineScheduler } from './auction-deadline.scheduler';
import { AuctionRedisCommandService } from './redis/auction-redis-command.service';
import { AuctionService } from './auction.service';
import { AuctionEventBusService } from './auction-event-bus.service';
function makeScheduler(params: {
dueReply?: unknown;
leaderLockAcquired?: boolean;
expireReply?: unknown;
completedState?: unknown;
currentRedisTimestampMS?: number;
}) {
const sendCommand = jest.fn().mockResolvedValue(params.dueReply ?? []);
const redis = {
acquireTokenLock: jest
.fn()
.mockResolvedValue(params.leaderLockAcquired ?? true),
getCurrentRedisTimestampMS: jest
.fn()
.mockResolvedValue(params.currentRedisTimestampMS ?? 1000),
releaseTokenLock: jest.fn().mockResolvedValue(true),
raw: jest.fn().mockReturnValue({ sendCommand }),
} as unknown as jest.Mocked<AuctionRedisService>;
const redisCommand = {
expirePrepare: jest.fn().mockResolvedValue(
params.expireReply ?? {
auctionStateTransitionId: 'expire-1',
bidRoundExpiryDecision: 'passed',
currentServerTimestampMS: 1000,
ok: true,
revision: 2,
},
),
} as unknown as jest.Mocked<AuctionRedisCommandService>;
const auctionService = {
completePreparedExpiry: jest
.fn()
.mockResolvedValue(params.completedState ?? { phase: 'passed' }),
} as unknown as jest.Mocked<AuctionService>;
const eventBus = {
broadcastState: jest.fn(),
} as unknown as jest.Mocked<AuctionEventBusService>;
return {
auctionService,
eventBus,
redis,
redisCommand,
scheduler: new AuctionDeadlineScheduler(
redis,
redisCommand,
auctionService,
eventBus,
),
sendCommand,
};
}
describe('AuctionDeadlineScheduler', () => {
afterEach(() => {
jest.restoreAllMocks();
});
it('starts and clears the deadline tick timer', () => {
const setIntervalSpy = jest.spyOn(global, 'setInterval');
const clearIntervalSpy = jest.spyOn(global, 'clearInterval');
const { scheduler } = makeScheduler({});
scheduler.onModuleInit();
scheduler.onModuleDestroy();
expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 1000);
expect(clearIntervalSpy).toHaveBeenCalledTimes(1);
});
it('processes a deadline tick only while holding the Redis leader lock', async () => {
const { redis, scheduler } = makeScheduler({});
const processDueBidRoundDeadlinesSpy = jest
.spyOn(scheduler, 'processDueBidRoundDeadlines')
.mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 });
await (scheduler as unknown as { safeTick: () => Promise<void> }).safeTick();
const leaderLockToken = redis.acquireTokenLock.mock.calls[0]?.[1];
expect(redis.acquireTokenLock).toHaveBeenCalledWith(
'auction:bidRoundDeadlineScheduler:leader',
expect.any(String),
2500,
);
expect(processDueBidRoundDeadlinesSpy).toHaveBeenCalledWith(20);
expect(redis.releaseTokenLock).toHaveBeenCalledWith(
'auction:bidRoundDeadlineScheduler:leader',
leaderLockToken,
);
});
it('skips deadline tick work when another instance holds the leader lock', async () => {
const { redis, scheduler } = makeScheduler({ leaderLockAcquired: false });
const processDueBidRoundDeadlinesSpy = jest
.spyOn(scheduler, 'processDueBidRoundDeadlines')
.mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 });
await (scheduler as unknown as { safeTick: () => Promise<void> }).safeTick();
expect(processDueBidRoundDeadlinesSpy).not.toHaveBeenCalled();
expect(redis.releaseTokenLock).not.toHaveBeenCalled();
});
it('reads due match ids from the Redis deadline queue with a batch limit', async () => {
const { redis, scheduler } = makeScheduler({
dueReply: ['match-1', 'match-2'],
});
await expect(scheduler.readDueMatchIds(1_000, 2)).resolves.toEqual([
'match-1',
'match-2',
]);
expect(redis.raw().sendCommand).toHaveBeenCalledWith([
'ZRANGEBYSCORE',
'auction:bidRoundDeadlineQueue',
'-inf',
'1000',
'LIMIT',
'0',
'2',
]);
});
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,
});
await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({
completed: 1,
prepared: 1,
skipped: 0,
});
expect(redisCommand.expirePrepare).toHaveBeenCalledWith(
matchId,
expect.objectContaining({
bidRoundExpiryRetryDelayMS: 3000,
matchId,
}),
);
expect(auctionService.completePreparedExpiry).toHaveBeenCalledTimes(1);
// 만료 확정 결과는 즉시 1차 broadcast돼야 한다(클라가 입찰 라운드에 멈춰
// 후속 액션에서 CONFLICT가 반복되는 것을 막는 핵심 동작).
expect(eventBus.broadcastState).toHaveBeenCalledWith(matchId, completedState);
});
it('skips noop expiry preparations', async () => {
const { auctionService, eventBus, scheduler } = makeScheduler({
dueReply: ['665f2f01f1f1f1f1f1f1f1f1'],
expireReply: {
code: 'NOT_DUE',
currentServerTimestampMS: 1000,
noop: true,
},
});
await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({
completed: 0,
prepared: 0,
skipped: 1,
});
expect(auctionService.completePreparedExpiry).not.toHaveBeenCalled();
expect(eventBus.broadcastState).not.toHaveBeenCalled();
});
it('removes invalid deadline queue members', async () => {
const { scheduler, sendCommand } = makeScheduler({
dueReply: ['not-a-match-id'],
});
await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({
completed: 0,
prepared: 0,
skipped: 1,
});
expect(sendCommand).toHaveBeenLastCalledWith([
'ZREM',
'auction:bidRoundDeadlineQueue',
'not-a-match-id',
]);
});
it('continues processing later deadline items after one item fails', async () => {
const matchIds = [
'665f2f01f1f1f1f1f1f1f1f1',
'665f2f02f1f1f1f1f1f1f1f1',
];
const { auctionService, redisCommand, scheduler } = makeScheduler({
dueReply: matchIds,
});
redisCommand.expirePrepare
.mockRejectedValueOnce(new Error('temporary redis error'))
.mockResolvedValueOnce({
auctionStateTransitionId: 'expire-2',
bidRoundExpiryDecision: 'passed',
currentServerTimestampMS: 1000,
ok: true,
revision: 3,
});
await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({
completed: 1,
prepared: 1,
skipped: 1,
});
expect(redisCommand.expirePrepare).toHaveBeenCalledTimes(2);
expect(auctionService.completePreparedExpiry).toHaveBeenCalledTimes(1);
});
});
@@ -0,0 +1,187 @@
import {
Injectable,
Logger,
OnModuleDestroy,
OnModuleInit,
} from '@nestjs/common';
import { randomUUID } from 'crypto';
import mongoose from 'mongoose';
import { AuctionService } from './auction.service';
import { AuctionEventBusService } from './auction-event-bus.service';
import { AuctionRedisCommandService } from './redis/auction-redis-command.service';
import { AuctionRedisService } from './redis/auction-redis.service';
const BID_ROUND_DEADLINE_QUEUE_KEY = 'auction:bidRoundDeadlineQueue';
const BID_ROUND_EXPIRY_RETRY_DELAY_MS = 3000;
const BID_ROUND_DEADLINE_TICK_INTERVAL_MS = 1000;
const BID_ROUND_DEADLINE_BATCH_LIMIT = 20;
const BID_ROUND_DEADLINE_LEADER_LOCK_KEY =
'auction:bidRoundDeadlineScheduler:leader';
const BID_ROUND_DEADLINE_LEADER_LOCK_TTL_MS = 2500;
/**
* 입찰 라운드 마감(deadline)을 감시해 자동으로 만료시키는 단일 리더 스위퍼.
*
* 만료는 2단계로 처리한다(정확히-1회 + 노드 크래시 복구를 위해):
* 1) EXPIRE_PREPARE Lua: `bidding → expiring`으로 flip하고 만료 결정/컨텍스트를
* `liveAuctionState`에 고정 + deadline ZSET에 재시도 점수 재등록.
* 2) `completePreparedExpiry`: 고정된 컨텍스트로 APPLY_TRANSITION을 돌려
* `sold`/`passed`로 확정하고 Mongo durability outbox를 enqueue.
*
* 중요(브로드캐스트 책임):
* - 관리자 수동 전환(sold/next 등)은 게이트웨이가 응답 직후 동기로 `state`를
* broadcast하지만, 자동 만료는 게이트웨이를 거치지 않는다.
* - 따라서 만료 확정 결과를 클라이언트에 즉시 알리는 1차 전달 책임은 이 스위퍼에
* 있다. 여기서 broadcast하지 않으면 클라는 입찰 라운드 revision에 멈춰 있다가
* "다음" 등 후속 액션에서 stale 관측값으로 CONFLICT를 반복하게 된다.
* - `AuctionDurabilityScheduler`의 broadcast는 Mongo 영속화 성공에 묶인 ~1초 주기의
* "노드 크래시 복구용 백업"이지 1차 전달 경로가 아니다(중복 emit돼도 클라
* revision 가드로 무해).
*
* 멀티 인스턴스: 리더 락을 잡은 한 인스턴스만 만료를 처리/방송하고, socket.io Redis
* adapter가 전 인스턴스 소켓으로 fanout한다.
*/
@Injectable()
export class AuctionDeadlineScheduler implements OnModuleInit, OnModuleDestroy {
private readonly logger = new Logger(AuctionDeadlineScheduler.name);
private tickTimer?: NodeJS.Timeout;
private tickInProgress = false;
constructor(
private readonly auctionRedisService: AuctionRedisService,
private readonly auctionRedisCommandService: AuctionRedisCommandService,
private readonly auctionService: AuctionService,
// 만료 확정 결과를 클라이언트에 즉시 알리기 위한 1차 broadcast 채널.
private readonly auctionEventBusService: AuctionEventBusService,
) {}
public onModuleInit(): void {
this.tickTimer = setInterval(
() => void this.safeTick(),
BID_ROUND_DEADLINE_TICK_INTERVAL_MS,
);
this.tickTimer.unref?.();
}
public onModuleDestroy(): void {
if (this.tickTimer) clearInterval(this.tickTimer);
}
private async safeTick(): Promise<void> {
if (this.tickInProgress) return;
this.tickInProgress = true;
const leaderLockToken = randomUUID();
let leaderLockAcquired = false;
try {
leaderLockAcquired = await this.auctionRedisService.acquireTokenLock(
BID_ROUND_DEADLINE_LEADER_LOCK_KEY,
leaderLockToken,
BID_ROUND_DEADLINE_LEADER_LOCK_TTL_MS,
);
if (!leaderLockAcquired) return;
await this.processDueBidRoundDeadlines(BID_ROUND_DEADLINE_BATCH_LIMIT);
} catch (error) {
this.logger.warn(
`Auction deadline tick failed: ${
error instanceof Error ? error.message : error
}`,
);
} finally {
if (leaderLockAcquired) {
await this.auctionRedisService.releaseTokenLock(
BID_ROUND_DEADLINE_LEADER_LOCK_KEY,
leaderLockToken,
);
}
this.tickInProgress = false;
}
}
public async readDueMatchIds(
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),
]);
return Array.isArray(reply) ? reply.map(String) : [];
}
public async processDueBidRoundDeadlines(batchLimit: number): Promise<{
completed: number;
prepared: number;
skipped: number;
}> {
const currentRedisTimestampMS =
await this.auctionRedisService.getCurrentRedisTimestampMS();
const matchIds = await this.readDueMatchIds(
currentRedisTimestampMS,
batchLimit,
);
let prepared = 0;
let completed = 0;
let skipped = 0;
for (const matchId of matchIds) {
if (!mongoose.isValidObjectId(matchId)) {
skipped += 1;
await this.removeBidRoundDeadlineQueueEntry(matchId);
continue;
}
try {
// 1단계: 만료 결정/컨텍스트 고정(bidding → expiring). 아직 마감 전이거나
// 이미 다른 phase면 noop으로 빠진다(stale ZSET 엔트리는 Lua가 정리).
const result = await this.auctionRedisCommandService.expirePrepare(
matchId,
{
auctionStateTransitionId: `expire:${matchId}:${randomUUID()}`,
bidRoundExpiryRetryDelayMS: BID_ROUND_EXPIRY_RETRY_DELAY_MS,
matchId,
},
);
if ('noop' in result) {
skipped += 1;
continue;
}
prepared += 1;
// 2단계: 고정된 컨텍스트로 sold/passed 확정. 재진입(다른 인스턴스/다음 틱)해도
// appliedAuctionStateTransitionIds dedupe로 정확히-1회만 반영된다.
const completedState = await this.auctionService.completePreparedExpiry(
new mongoose.Types.ObjectId(matchId),
);
if (completedState) {
completed += 1;
// 1차 전달: 만료 확정 즉시 최신 state를 방송한다. 이게 없으면 클라가
// 입찰 라운드에 멈춰 후속 액션에서 CONFLICT가 반복된다(durability
// worker 백업 방송은 Mongo 성공 + ~1초 tick에 묶여 1차 전달로 부적합).
// 이미 처리된 전환은 completePreparedExpiry가 null을 반환하므로 중복
// 방송되지 않고, 혹시 겹쳐도 클라 revision 가드로 무해하다.
this.auctionEventBusService.broadcastState(matchId, completedState);
}
} catch (error) {
skipped += 1;
this.logger.warn(
`Auction deadline item failed for ${matchId}: ${
error instanceof Error ? error.message : error
}`,
);
}
}
return { completed, prepared, skipped };
}
private async removeBidRoundDeadlineQueueEntry(matchId: string): Promise<void> {
await this.auctionRedisService.raw().sendCommand([
'ZREM',
BID_ROUND_DEADLINE_QUEUE_KEY,
matchId,
]);
}
}
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,28 @@
import { Injectable } from '@nestjs/common';
import type { Namespace } from 'socket.io';
import type { AuctionStateResponse } from './auction.service';
import type { MatchSideEffectDelta } from './auction-side-effect.service';
import { serializeRealtimeAuction } from './auction-realtime-serializer';
@Injectable()
export class AuctionEventBusService {
private auctionNamespace?: Namespace;
public attachAuctionNamespace(namespace: Namespace): void {
this.auctionNamespace = namespace;
}
public broadcastMatchSideEffect(
matchId: string,
delta: MatchSideEffectDelta,
): void {
this.auctionNamespace?.to(matchId).emit('match-side-effect', delta);
}
public broadcastState(matchId: string, state: AuctionStateResponse): void {
this.auctionNamespace?.to(matchId).emit(
'state',
serializeRealtimeAuction(state),
);
}
}
@@ -0,0 +1,103 @@
import type { AuctionStateResponse } from './auction.service';
export function serializeRealtimeAuction(auction: AuctionStateResponse) {
const serialized = JSON.parse(JSON.stringify(auction)) as Record<
string,
unknown
>;
const auctionPlayerOrder = getRecordArray(
serialized.auctionPlayerOrder ?? serialized.order,
);
const currentAuctionPlayerOrderIndex = Number(
serialized.currentAuctionPlayerOrderIndex ?? serialized.currentIndex ?? 0,
);
const currentBidRoundPlayerUserId =
typeof serialized.currentBidRoundPlayerUserId === 'string'
? serialized.currentBidRoundPlayerUserId
: getStringField(
auctionPlayerOrder[currentAuctionPlayerOrderIndex],
'userId',
);
if (Array.isArray(serialized.auctionPlayerOrder)) {
serialized.auctionPlayerOrder = auctionPlayerOrder.map((player) =>
serializeRealtimeAuctionPlayer(player, currentBidRoundPlayerUserId),
);
} else if (Array.isArray(serialized.order)) {
serialized.order = auctionPlayerOrder.map((player) =>
serializeRealtimeAuctionPlayer(player, currentBidRoundPlayerUserId),
);
}
const passedAuctionPlayerQueue = getRecordArray(
serialized.passedAuctionPlayerQueue ?? serialized.passedQueue,
);
if (Array.isArray(serialized.passedAuctionPlayerQueue)) {
serialized.passedAuctionPlayerQueue = passedAuctionPlayerQueue.map(
(player) =>
serializeRealtimeAuctionPlayer(player, currentBidRoundPlayerUserId),
);
} else if (Array.isArray(serialized.passedQueue)) {
serialized.passedQueue = passedAuctionPlayerQueue.map((player) =>
serializeRealtimeAuctionPlayer(player, currentBidRoundPlayerUserId),
);
}
if ('auctionPlayerOrder' in serialized) delete serialized.order;
if ('auctionTeams' in serialized) delete serialized.teams;
if ('passedAuctionPlayerQueue' in serialized) delete serialized.passedQueue;
if ('auctionBidHistory' in serialized) delete serialized.bids;
if ('maximumBidRoundDurationSeconds' in serialized) {
delete serialized.maxTimerSeconds;
}
if ('bidRoundExtensionSeconds' in serialized) {
delete serialized.bidExtensionSeconds;
}
if ('initialTeamBidPointAmount' in serialized) {
delete serialized.initialPoints;
}
if ('topTierAuctionPriorityThreshold' in serialized) {
delete serialized.topTierThreshold;
}
if ('manualTopTierAuctionPriorityUserIds' in serialized) {
delete serialized.manualTopTierUserIds;
}
return serialized;
}
function serializeRealtimeAuctionPlayer(
player: Record<string, unknown>,
currentBidRoundPlayerUserId?: string,
) {
if (getStringField(player, 'userId') === currentBidRoundPlayerUserId) {
return player;
}
const {
masteries: _masteries,
puuid: _puuid,
recentStatsSummary: _recentStatsSummary,
tierHistory: _tierHistory,
...lightweightPlayer
} = player;
return lightweightPlayer;
}
function getRecordArray(value: unknown): Array<Record<string, unknown>> {
return Array.isArray(value)
? value.filter(
(item): item is Record<string, unknown> =>
typeof item === 'object' && item !== null,
)
: [];
}
function getStringField(
value: Record<string, unknown> | undefined,
fieldName: string,
): string | undefined {
const fieldValue = value?.[fieldName];
return typeof fieldValue === 'string' ? fieldValue : undefined;
}
@@ -0,0 +1,82 @@
import {
AUCTION_REJECTION_REASON,
isAuctionResyncRecommended,
resolveAuctionRejectionReason,
} from './auction-rejection';
describe('resolveAuctionRejectionReason', () => {
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,
);
});
it('maps internal bid codes to descriptive bid reasons', () => {
expect(resolveAuctionRejectionReason('EXPIRED')).toBe(
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_BID_ROUND_DEADLINE_PASSED,
);
expect(resolveAuctionRejectionReason('TOO_LOW')).toBe(
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_AMOUNT_NOT_HIGHER_THAN_CURRENT_HIGHEST,
);
});
it('maps known BadRequest messages without a structured code', () => {
expect(
resolveAuctionRejectionReason(undefined, 'Cannot advance from current phase.'),
).toBe(
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE,
);
});
it('falls back via the message when the code carries the full sentence', () => {
// 구조 전환 경로는 code 자리에 message 문장이 들어올 수 있다.
expect(
resolveAuctionRejectionReason('Auction is not in bidding phase.'),
).toBe(
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE,
);
});
it('treats internal coordination codes as retryable', () => {
expect(resolveAuctionRejectionReason('ACTION_REQUEST_LEASE_EXPIRED')).toBe(
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_REQUEST_COORDINATION_RETRYABLE,
);
expect(resolveAuctionRejectionReason('INVALID_DEADLINE_MODE')).toBe(
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_REQUEST_COORDINATION_RETRYABLE,
);
});
it('falls back to the unrecognized reason for unknown input', () => {
expect(resolveAuctionRejectionReason('SOMETHING_NEW', 'weird')).toBe(
AUCTION_REJECTION_REASON.AUCTION_REQUEST_REJECTED_FOR_UNRECOGNIZED_REASON,
);
});
});
describe('isAuctionResyncRecommended', () => {
it('recommends resync for stale-view rejections', () => {
expect(
isAuctionResyncRecommended(
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY,
),
).toBe(true);
expect(
isAuctionResyncRecommended(
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_BID_ROUND_DEADLINE_PASSED,
),
).toBe(true);
});
it('does not recommend resync for genuine constraint rejections', () => {
expect(
isAuctionResyncRecommended(
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_TEAM_ROSTER_FULL,
),
).toBe(false);
expect(
isAuctionResyncRecommended(
AUCTION_REJECTION_REASON.AUCTION_REQUEST_REJECTED_FOR_UNRECOGNIZED_REASON,
),
).toBe(false);
});
});
@@ -0,0 +1,170 @@
/**
* 경매 거부(rejection)를 클라이언트에 알릴 때 쓰는 "설명적 거부코드" 체계.
*
* 배경:
* - 내부 Lua/서비스는 `CONFLICT`, `EXPIRED`, `TOO_LOW` 같은 짧은 코드를 쓴다.
* 이 코드들은 구현 디테일이고, 그대로 클라/운영자에게 노출하면 "무엇이 왜
* 거부됐는지"를 알기 어렵다(특히 `CONFLICT`는 원인이 광범위하다).
* - 그래서 ack의 `code`/`message`는 그대로 두되(진단/하위호환), 별도로
* `auctionRejectionReason`이라는 **맥락을 코드 이름에 담은 안정적 식별자**를
* 함께 내려준다. 클라는 이 reason을 사람이 읽는 문구로 매핑한다(프론트 사전).
*
* 명명 규칙:
* - 다소 길어지더라도 "무엇이(BID/AUCTION_TRANSITION) + 왜(BECAUSE_...)"를
* 이름만으로 알 수 있게 풀어쓴다.
*
* resync 권장 여부:
* - `AUCTION_RESYNC_RECOMMENDED_REASONS`에 속한 reason은 "클라가 본 상태가 이미
* 바뀌었다(낙관적 동시성 충돌/만료/단계 전이)"는 신호다. 이 경우 클라는 최신
* state로 rebaseline한 뒤 (구조 액션이라면) 1회 재시도하는 것이 안전하다.
* - 반대로 정원 초과/포인트 부족처럼 "상태를 새로고침해도 결과가 같은" 거부는
* resync 권장 대상이 아니다(재시도해도 또 거부됨).
*/
export const AUCTION_REJECTION_REASON = {
// === 구조 전환(낙찰/유찰/다음/입찰오픈) ===
/** 내가 본 revision/phase/선수가 commit 직전 이미 바뀜(낙관적 동시성 충돌, 내부 `CONFLICT`). */
AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY:
'AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY',
/** 입찰 단계가 아닌데 입찰 단계 전환을 시도함(이미 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_NO_WINNING_BID_TO_MARK_SOLD:
'AUCTION_TRANSITION_REJECTED_BECAUSE_NO_WINNING_BID_TO_MARK_SOLD',
/** 진행 중인 입찰이 있는 선수를 유찰 처리하려 함. */
AUCTION_TRANSITION_REJECTED_BECAUSE_ACTIVE_BID_PRESENT:
'AUCTION_TRANSITION_REJECTED_BECAUSE_ACTIVE_BID_PRESENT',
/** 전환 요청 조정(예약/리스/멱등) 단계의 일시적 거부 — 최신 상태로 재시도하면 보통 해소됨. */
AUCTION_TRANSITION_REJECTED_BECAUSE_REQUEST_COORDINATION_RETRYABLE:
'AUCTION_TRANSITION_REJECTED_BECAUSE_REQUEST_COORDINATION_RETRYABLE',
// === 입찰(bid) ===
/** 입찰 라운드가 이미 다음 선수/다음 라운드로 넘어감(내부 `STALE_BID_ROUND`). */
BID_REJECTED_BECAUSE_BID_ROUND_ALREADY_ADVANCED:
'BID_REJECTED_BECAUSE_BID_ROUND_ALREADY_ADVANCED',
/** 입찰 라운드 마감 시각이 이미 지남(내부 `EXPIRED`). */
BID_REJECTED_BECAUSE_BID_ROUND_DEADLINE_PASSED:
'BID_REJECTED_BECAUSE_BID_ROUND_DEADLINE_PASSED',
/** 경매가 입찰 단계가 아님(내부 `PHASE`). */
BID_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE:
'BID_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE',
/** 입찰 금액이 현재 최고가보다 높지 않음(내부 `TOO_LOW`). */
BID_REJECTED_BECAUSE_AMOUNT_NOT_HIGHER_THAN_CURRENT_HIGHEST:
'BID_REJECTED_BECAUSE_AMOUNT_NOT_HIGHER_THAN_CURRENT_HIGHEST',
/** 팀 정원이 이미 가득 참(내부 `FULL`). */
BID_REJECTED_BECAUSE_TEAM_ROSTER_FULL:
'BID_REJECTED_BECAUSE_TEAM_ROSTER_FULL',
/** 남은 슬롯 최소 확보분을 고려하면 포인트가 부족함(내부 `INSUFFICIENT`). */
BID_REJECTED_BECAUSE_INSUFFICIENT_REMAINING_POINTS_FOR_SLOTS:
'BID_REJECTED_BECAUSE_INSUFFICIENT_REMAINING_POINTS_FOR_SLOTS',
/** 알 수 없는 팀 인덱스(내부 `UNKNOWN_TEAM`). */
BID_REJECTED_BECAUSE_UNKNOWN_TEAM: 'BID_REJECTED_BECAUSE_UNKNOWN_TEAM',
/** 같은 요청 id에 다른 내용이 온 멱등성 충돌(내부 `DUPLICATE_REQUEST_CONFLICT`). */
BID_REJECTED_BECAUSE_DUPLICATE_REQUEST_PAYLOAD_CONFLICT:
'BID_REJECTED_BECAUSE_DUPLICATE_REQUEST_PAYLOAD_CONFLICT',
/** 짧은 시간에 너무 많은 입찰 요청(게이트웨이 rate limit). */
BID_REJECTED_BECAUSE_RATE_LIMITED: 'BID_REJECTED_BECAUSE_RATE_LIMITED',
// === 공통/그 외 ===
/** 실시간 상태를 아직 사용할 수 없음(재접속/재조회 필요). */
AUCTION_REQUEST_REJECTED_BECAUSE_REALTIME_STATE_UNAVAILABLE:
'AUCTION_REQUEST_REJECTED_BECAUSE_REALTIME_STATE_UNAVAILABLE',
/** 위 어디에도 해당하지 않는 미분류 거부(원문 message로 안내). */
AUCTION_REQUEST_REJECTED_FOR_UNRECOGNIZED_REASON:
'AUCTION_REQUEST_REJECTED_FOR_UNRECOGNIZED_REASON',
} as const;
export type AuctionRejectionReason =
(typeof AUCTION_REJECTION_REASON)[keyof typeof AUCTION_REJECTION_REASON];
/** 내부 짧은 코드 → 설명적 reason. */
const INTERNAL_CODE_TO_REASON: Record<string, AuctionRejectionReason> = {
CONFLICT:
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY,
STALE_BID_ROUND:
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_BID_ROUND_ALREADY_ADVANCED,
EXPIRED:
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_BID_ROUND_DEADLINE_PASSED,
PHASE:
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE,
TOO_LOW:
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_AMOUNT_NOT_HIGHER_THAN_CURRENT_HIGHEST,
FULL: AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_TEAM_ROSTER_FULL,
INSUFFICIENT:
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_INSUFFICIENT_REMAINING_POINTS_FOR_SLOTS,
UNKNOWN_TEAM: AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_UNKNOWN_TEAM,
DUPLICATE_REQUEST_CONFLICT:
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_DUPLICATE_REQUEST_PAYLOAD_CONFLICT,
BID_RATE_LIMITED: AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_RATE_LIMITED,
};
/** 구조화된 code 없이 message만 던지는 BadRequest(구조 전환 검증 등) → 설명적 reason. */
const MESSAGE_TO_REASON: Record<string, AuctionRejectionReason> = {
'Auction is not in bidding phase.':
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE,
'Cannot advance from current phase.':
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE,
'No bid to mark sold.':
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_NO_WINNING_BID_TO_MARK_SOLD,
'Cannot pass a player with an active bid.':
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_ACTIVE_BID_PRESENT,
'Auction realtime state is not available.':
AUCTION_REJECTION_REASON.AUCTION_REQUEST_REJECTED_BECAUSE_REALTIME_STATE_UNAVAILABLE,
};
/**
* resync(최신 state로 rebaseline 후 재시도)가 권장되는 reason 집합.
* "내가 본 상태가 낡았을 뿐, 다시 보면 가능할 수 있는" 거부들이다.
*/
export const AUCTION_RESYNC_RECOMMENDED_REASONS: ReadonlySet<AuctionRejectionReason> =
new Set<AuctionRejectionReason>([
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY,
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE,
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE,
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_NO_WINNING_BID_TO_MARK_SOLD,
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_ACTIVE_BID_PRESENT,
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_REQUEST_COORDINATION_RETRYABLE,
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_BID_ROUND_ALREADY_ADVANCED,
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_BID_ROUND_DEADLINE_PASSED,
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE,
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_AMOUNT_NOT_HIGHER_THAN_CURRENT_HIGHEST,
AUCTION_REJECTION_REASON.AUCTION_REQUEST_REJECTED_BECAUSE_REALTIME_STATE_UNAVAILABLE,
]);
/**
* 내부 거부 code(짧은 코드) 또는 BadRequest message로부터 설명적 reason을 해석한다.
* 둘 다 모르면 미분류 reason으로 떨어뜨린다(원문 message는 ack에 그대로 남는다).
*/
export function resolveAuctionRejectionReason(
internalCode?: string,
message?: string,
): AuctionRejectionReason {
if (internalCode && INTERNAL_CODE_TO_REASON[internalCode]) {
return INTERNAL_CODE_TO_REASON[internalCode];
}
if (message && MESSAGE_TO_REASON[message]) {
return MESSAGE_TO_REASON[message];
}
// 구조 전환 경로는 code 자리에 message 문장이 들어올 수 있어 한 번 더 확인한다.
if (internalCode && MESSAGE_TO_REASON[internalCode]) {
return MESSAGE_TO_REASON[internalCode];
}
if (
internalCode &&
(internalCode.startsWith('ACTION_REQUEST_') ||
internalCode.startsWith('INVALID_'))
) {
return AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_REQUEST_COORDINATION_RETRYABLE;
}
return AUCTION_REJECTION_REASON.AUCTION_REQUEST_REJECTED_FOR_UNRECOGNIZED_REASON;
}
export function isAuctionResyncRecommended(
reason: AuctionRejectionReason,
): boolean {
return AUCTION_RESYNC_RECOMMENDED_REASONS.has(reason);
}
@@ -0,0 +1,101 @@
import {
AuctionSideEffectService,
buildMatchSideEffectDelta,
buildSideEffectApplicationIdentity,
buildSideEffectLeaseAcquireUpdate,
canAcquireSideEffectLease,
} from './auction-side-effect.service';
describe('auction side effect helpers', () => {
it('builds idempotency identity from transition and side effect type', () => {
expect(
buildSideEffectApplicationIdentity({
auctionId: 'auction-1',
auctionStateTransitionId: 'transition-1',
sideEffectType: 'syncMatchTeams',
}),
).toEqual({
auctionId: 'auction-1',
auctionStateTransitionId: 'transition-1',
sideEffectType: 'syncMatchTeams',
});
});
it('allows lease acquisition for pending, failed, or stale processing items only', () => {
expect(canAcquireSideEffectLease({ state: 'pending' }, 1000)).toBe(true);
expect(canAcquireSideEffectLease({ state: 'failed' }, 1000)).toBe(true);
expect(
canAcquireSideEffectLease(
{ processingLeaseExpiresAtTimestampMS: 999, state: 'processing' },
1000,
),
).toBe(true);
expect(
canAcquireSideEffectLease(
{ processingLeaseExpiresAtTimestampMS: 1001, state: 'processing' },
1000,
),
).toBe(false);
expect(canAcquireSideEffectLease({ state: 'completed' }, 1000)).toBe(false);
});
it('builds lease acquire update with Redis TIME timestamps', () => {
expect(
buildSideEffectLeaseAcquireUpdate({
currentRedisTimestampMS: 1000,
leaseDurationMS: 5000,
ownerToken: 'worker-1',
}),
).toEqual({
$inc: { attempts: 1 },
$set: {
processingLeaseExpiresAtTimestampMS: 6000,
processingOwnerToken: 'worker-1',
processingStartedAtTimestampMS: 1000,
state: 'processing',
},
});
});
it('builds side-effect socket delta independently from auction revision', () => {
expect(
buildMatchSideEffectDelta({
auctionLifecycleId: 'life-1',
currentServerTimestampMS: 1000,
matchSideEffectRevision: 3,
matchSideEffectStatus: 'completed',
}),
).toEqual({
auctionLifecycleId: 'life-1',
currentServerTimestampMS: 1000,
matchSideEffectRevision: 3,
matchSideEffectStatus: 'completed',
});
});
it('mirrors side-effect status into Redis live state with lifecycle and revision guard', async () => {
const sendCommand = jest.fn().mockResolvedValue(1);
const service = new AuctionSideEffectService({
raw: jest.fn().mockReturnValue({ sendCommand }),
} as never);
await expect(
service.mirrorMatchSideEffectStatus({
auctionLifecycleId: 'life-1',
matchId: 'match-1',
matchSideEffectRevision: 2,
matchSideEffectStatus: 'completed',
}),
).resolves.toBe(true);
expect(sendCommand).toHaveBeenCalledWith([
'EVAL',
expect.stringContaining('auctionLifecycleId'),
'1',
'auction:match-1:liveAuctionState',
'life-1',
'2',
'completed',
]);
});
});
@@ -0,0 +1,110 @@
import { Injectable } from '@nestjs/common';
import type {
AuctionMatchSideEffectStatus,
AuctionSideEffectApplicationState,
} from '../global/database/schema';
import { buildAuctionRedisKeys } from './redis/auction-redis.keys';
import { AuctionRedisService } from './redis/auction-redis.service';
export interface SideEffectApplicationIdentity {
auctionId: unknown;
auctionStateTransitionId: string;
sideEffectType: string;
}
export interface SideEffectLeaseState {
processingLeaseExpiresAtTimestampMS?: number;
state: AuctionSideEffectApplicationState;
}
export interface BuildSideEffectLeaseAcquireUpdateParams {
currentRedisTimestampMS: number;
leaseDurationMS: number;
ownerToken: string;
}
export interface MatchSideEffectDelta {
auctionLifecycleId: string;
currentServerTimestampMS: number;
matchSideEffectRevision: number;
matchSideEffectStatus: AuctionMatchSideEffectStatus;
}
@Injectable()
export class AuctionSideEffectService {
constructor(private readonly auctionRedisService: AuctionRedisService) {}
public async mirrorMatchSideEffectStatus(params: {
auctionLifecycleId: 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,
]);
return Number(result) === 1;
}
}
export function buildSideEffectApplicationIdentity(
params: SideEffectApplicationIdentity,
): SideEffectApplicationIdentity {
return {
auctionId: params.auctionId,
auctionStateTransitionId: params.auctionStateTransitionId,
sideEffectType: params.sideEffectType,
};
}
export function canAcquireSideEffectLease(
state: SideEffectLeaseState,
currentRedisTimestampMS: number,
): boolean {
if (state.state === 'pending' || state.state === 'failed') return true;
if (state.state !== 'processing') return false;
return (
(state.processingLeaseExpiresAtTimestampMS ?? 0) <=
currentRedisTimestampMS
);
}
export function buildSideEffectLeaseAcquireUpdate(
params: BuildSideEffectLeaseAcquireUpdateParams,
) {
return {
$inc: { attempts: 1 },
$set: {
processingLeaseExpiresAtTimestampMS:
params.currentRedisTimestampMS + params.leaseDurationMS,
processingOwnerToken: params.ownerToken,
processingStartedAtTimestampMS: params.currentRedisTimestampMS,
state: 'processing',
},
};
}
export function buildMatchSideEffectDelta(
params: MatchSideEffectDelta,
): MatchSideEffectDelta {
return {
auctionLifecycleId: params.auctionLifecycleId,
currentServerTimestampMS: params.currentServerTimestampMS,
matchSideEffectRevision: params.matchSideEffectRevision,
matchSideEffectStatus: params.matchSideEffectStatus,
};
}
@@ -20,7 +20,11 @@ import type { UserDocument } from '../global/database/schema';
import { AuctionService } from './auction.service';
import { AuctionGateway } from './auction.gateway';
import {
NextAuctionDto,
OpenBiddingDto,
PassedAuctionDto,
PlaceBidDto,
ResetAuctionDto,
SoldDto,
StartAuctionDto,
UndoAuctionDto,
@@ -47,18 +51,22 @@ export class AuctionController {
return this.auctionService.start({
matchId,
communityId,
startAuctionRequestId: body.startAuctionRequestId,
actorUserId: currentUser._id,
captains: body.captains.map((c) => ({
teamIndex: c.teamIndex,
userId: new mongoose.Types.ObjectId(c.userId),
initialPoints: c.initialPoints,
initialTeamBidPointAmount: c.initialTeamBidPointAmount,
})),
initialPoints: body.initialPoints ?? 1000,
maxTimerSeconds: body.maxTimerSeconds ?? 30,
bidExtensionSeconds: body.bidExtensionSeconds ?? 5,
topTierThreshold: body.topTierThreshold ?? 'NONE',
manualTopTierUserIds: (body.manualTopTierUserIds ?? []).map(
(userId) => new mongoose.Types.ObjectId(userId),
),
initialTeamBidPointAmount: body.initialTeamBidPointAmount ?? 1000,
maximumBidRoundDurationSeconds:
body.maximumBidRoundDurationSeconds ?? 30,
bidRoundExtensionSeconds: body.bidRoundExtensionSeconds ?? 5,
topTierAuctionPriorityThreshold:
body.topTierAuctionPriorityThreshold ?? 'NONE',
manualTopTierAuctionPriorityUserIds: (
body.manualTopTierAuctionPriorityUserIds ?? []
).map((userId) => new mongoose.Types.ObjectId(userId)),
});
}
@@ -67,7 +75,7 @@ export class AuctionController {
public async getAuction(
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
) {
return this.auctionService.getByMatchId(matchId);
return this.auctionService.getStateByMatchId(matchId);
}
// 공개 — 팀장 2명만 쓸 엔드포인트(트러스트 기반, 10명 동시 관전).
@@ -76,23 +84,26 @@ export class AuctionController {
@HttpCode(HttpStatus.OK)
public async openBidding(
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
@Body() body: OpenBiddingDto = {},
) {
return this.auctionService.openBidding(matchId);
return this.auctionService.openBidding(matchId, body);
}
@Post('bids')
@AllowPublicAccess()
@HttpCode(HttpStatus.OK)
public async placeBid(
@CurrentUser() currentUser: UserDocument | undefined,
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
@Body() body: PlaceBidDto,
) {
return this.auctionService.placeBid({
matchId,
teamIndex: body.teamIndex,
amount: body.amount,
bidderUserId: this.resolveBidder(currentUser, body.bidderUserId),
teamIndex: body.bidderTeamIndex,
amount: body.bidPointAmount,
bidRequestId: body.bidRequestId,
clientObservedAuctionLifecycleId: body.clientObservedAuctionLifecycleId,
clientObservedCurrentBidRoundPlayerUserId:
body.clientObservedCurrentBidRoundPlayerUserId,
});
}
@@ -106,16 +117,35 @@ export class AuctionController {
return this.auctionService.markSold({
matchId,
assignedPosition: body.assignedPosition,
auctionActionRequestId: body.auctionActionRequestId,
clientObservedAuctionLifecycleId: body.clientObservedAuctionLifecycleId,
clientObservedCurrentAuctionPlayerOrderIndex:
body.clientObservedCurrentAuctionPlayerOrderIndex,
clientObservedCurrentBidRoundPlayerUserId:
body.clientObservedCurrentBidRoundPlayerUserId,
clientObservedPhase: body.clientObservedPhase,
clientObservedRevision: body.clientObservedRevision,
});
}
@Post('passed')
@AllowPublicAccess()
@HttpCode(HttpStatus.OK)
public async markPassed(
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
@Body() body: PassedAuctionDto = {},
) {
return this.auctionService.markPassed(matchId, body);
}
@Post('next')
@AllowPublicAccess()
@HttpCode(HttpStatus.OK)
public async next(
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
@Body() body: NextAuctionDto = {},
) {
return this.auctionService.next(matchId);
return this.auctionService.next(matchId, body);
}
@Get('history')
@@ -147,6 +177,14 @@ export class AuctionController {
matchId,
communityId,
sequence: body.sequence,
auctionActionRequestId: body.auctionActionRequestId,
clientObservedAuctionLifecycleId: body.clientObservedAuctionLifecycleId,
clientObservedCurrentAuctionPlayerOrderIndex:
body.clientObservedCurrentAuctionPlayerOrderIndex,
clientObservedCurrentBidRoundPlayerUserId:
body.clientObservedCurrentBidRoundPlayerUserId,
clientObservedPhase: body.clientObservedPhase,
clientObservedRevision: body.clientObservedRevision,
});
this.auctionGateway.broadcastState(matchId.toString(), auction);
return auction;
@@ -161,24 +199,24 @@ export class AuctionController {
@Param('communityId', ParseObjectIdPipe)
communityId: mongoose.Types.ObjectId,
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
@Body() body: ResetAuctionDto = {},
) {
this.assertSameCommunity(currentUser, communityId);
await this.auctionService.reset({ matchId, communityId });
await this.auctionService.reset({
matchId,
communityId,
auctionActionRequestId: body.auctionActionRequestId,
clientObservedAuctionLifecycleId: body.clientObservedAuctionLifecycleId,
clientObservedCurrentAuctionPlayerOrderIndex:
body.clientObservedCurrentAuctionPlayerOrderIndex,
clientObservedCurrentBidRoundPlayerUserId:
body.clientObservedCurrentBidRoundPlayerUserId,
clientObservedPhase: body.clientObservedPhase,
clientObservedRevision: body.clientObservedRevision,
});
this.auctionGateway.broadcastReset(matchId.toString());
}
private resolveBidder(
currentUser: UserDocument | undefined,
bodyBidder?: string,
): mongoose.Types.ObjectId | undefined {
if (currentUser) return currentUser._id;
if (!bodyBidder) return undefined;
if (!mongoose.isValidObjectId(bodyBidder)) {
throw new BadRequestException('Invalid bidderUserId.');
}
return new mongoose.Types.ObjectId(bodyBidder);
}
private assertSameCommunity(
user: UserDocument,
communityId: mongoose.Types.ObjectId,
@@ -0,0 +1,319 @@
import mongoose from 'mongoose';
jest.mock('../auth/jwt.service', () => ({
JwtService: class JwtService {},
}));
import { AuctionGateway } from './auction.gateway';
describe('AuctionGateway', () => {
function createGateway(params?: {
getCurrentRedisTimestampMS?: jest.Mock;
placeBidDelta?: jest.Mock;
}) {
const auctionService = {
placeBidDelta: params?.placeBidDelta ?? jest.fn(),
};
const auctionRedisService = {
getCurrentRedisTimestampMS:
params?.getCurrentRedisTimestampMS ??
jest.fn().mockResolvedValue(1780000000000),
};
const gateway = new AuctionGateway(
auctionService as never,
{ resolveDevUserById: jest.fn() } as never,
{ verify: jest.fn() } as never,
{ findOrCreateByOid: jest.fn() } as never,
{ getModel: jest.fn() } as never,
{ attachAuctionNamespace: jest.fn() } as never,
auctionRedisService as never,
);
const emit = jest.fn();
const to = jest.fn().mockReturnValue({ emit });
(gateway as unknown as { server: { to: jest.Mock } }).server = { to };
return {
auctionService,
emit,
gateway,
auctionRedisService,
to,
};
}
it('broadcasts a bid delta and acknowledges the matching bid request', async () => {
const matchId = new mongoose.Types.ObjectId().toString();
const auctionBidHistoryEntry = {
bidderTeamIndex: 2,
bidderUserId: 'captain-2',
bidPlacedAtTimestampMS: 1780000000000,
bidPointAmount: 120,
};
const placeBidDelta = jest.fn().mockResolvedValue({
auctionBidHistoryEntry,
auctionLifecycleId: 'life-1',
currentBidRoundDeadlineTimestampMS: 1780000030000,
currentHighestBidderTeamIndex: 2,
currentHighestBidPointAmount: 120,
currentServerTimestampMS: 1780000000000,
revision: 9,
});
const { emit, gateway, to } = createGateway({ placeBidDelta });
const ack = jest.fn();
await gateway.handleBid(
{ data: { matchId }, emit: jest.fn() } as never,
{
bidPointAmount: 120,
bidderTeamIndex: 2,
bidRequestId: 'bid-1',
clientObservedAuctionLifecycleId: 'life-1',
clientObservedCurrentBidRoundPlayerUserId: 'player-1',
},
ack,
);
expect(placeBidDelta).toHaveBeenCalledWith({
amount: 120,
bidRequestId: 'bid-1',
clientObservedAuctionLifecycleId: 'life-1',
clientObservedCurrentBidRoundPlayerUserId: 'player-1',
matchId: new mongoose.Types.ObjectId(matchId),
teamIndex: 2,
});
expect(to).toHaveBeenCalledWith(matchId);
expect(emit).toHaveBeenCalledWith('bid', {
auctionBidHistoryEntry,
auctionLifecycleId: 'life-1',
bidRequestId: 'bid-1',
currentBidRoundDeadlineTimestampMS: 1780000030000,
currentHighestBidderTeamIndex: 2,
currentHighestBidPointAmount: 120,
currentServerTimestampMS: 1780000000000,
revision: 9,
});
expect(ack).toHaveBeenCalledWith(
expect.objectContaining({
bidDelta: {
auctionBidHistoryEntry,
auctionLifecycleId: 'life-1',
bidRequestId: 'bid-1',
currentBidRoundDeadlineTimestampMS: 1780000030000,
currentHighestBidderTeamIndex: 2,
currentHighestBidPointAmount: 120,
currentServerTimestampMS: 1780000000000,
revision: 9,
},
bidRequestId: 'bid-1',
bidServerTiming: expect.objectContaining({
gatewayTotalDurationMS: expect.any(Number),
}),
ok: true,
}),
);
});
it('generates one bid request id when the client omits it', async () => {
const matchId = new mongoose.Types.ObjectId().toString();
const placeBidDelta = jest.fn().mockResolvedValue({
auctionBidHistoryEntry: {
bidderTeamIndex: 1,
bidPointAmount: 50,
},
auctionLifecycleId: 'life-1',
currentHighestBidderTeamIndex: 1,
currentHighestBidPointAmount: 50,
revision: 3,
});
const { emit, gateway } = createGateway({ placeBidDelta });
const ack = jest.fn();
await gateway.handleBid(
{ data: { matchId }, emit: jest.fn() } as never,
{
bidPointAmount: 50,
bidderTeamIndex: 1,
},
ack,
);
const generatedBidRequestId = placeBidDelta.mock.calls[0][0].bidRequestId;
expect(generatedBidRequestId).toEqual(expect.any(String));
expect(generatedBidRequestId).not.toHaveLength(0);
expect(emit).toHaveBeenCalledWith(
'bid',
expect.objectContaining({
bidRequestId: generatedBidRequestId,
}),
);
expect(ack).toHaveBeenCalledWith(
expect.objectContaining({
bidRequestId: generatedBidRequestId,
ok: true,
}),
);
});
it('acknowledges bid failures with the request id used for the attempt', async () => {
const matchId = new mongoose.Types.ObjectId().toString();
const placeBidDelta = jest.fn().mockRejectedValue({
getResponse: () => ({
bidDiagnostics: {
currentBidRoundDeadlineTimestampMS: 1780000002500,
currentServerTimestampMS: 1780000003000,
},
bidServerTiming: {
redisBidCommandDurationMS: 2,
redisBidContextReadDurationMS: 1,
serviceTotalDurationMS: 4,
},
code: 'EXPIRED',
message: 'Bid deadline has already expired.',
}),
});
const socketEmit = jest.fn();
const { gateway } = createGateway({ placeBidDelta });
const ack = jest.fn();
await gateway.handleBid(
{ data: { matchId }, emit: socketEmit } as never,
{
bidPointAmount: 50,
bidderTeamIndex: 1,
bidRequestId: 'bid-1',
},
ack,
);
expect(socketEmit).toHaveBeenCalledWith('error', {
message: 'Bid deadline has already expired.',
});
expect(ack).toHaveBeenCalledWith(
expect.objectContaining({
bidDiagnostics: {
currentBidRoundDeadlineTimestampMS: 1780000002500,
currentServerTimestampMS: 1780000003000,
},
bidRequestId: 'bid-1',
bidServerTiming: expect.objectContaining({
gatewayTotalDurationMS: expect.any(Number),
redisBidCommandDurationMS: 2,
redisBidContextReadDurationMS: 1,
serviceTotalDurationMS: 4,
}),
code: 'EXPIRED',
message: 'Bid deadline has already expired.',
rejected: true,
}),
);
});
it('acknowledges time sync with Redis server time', async () => {
const getCurrentRedisTimestampMS = jest
.fn()
.mockResolvedValue(1780000001234);
const { gateway } = createGateway({ getCurrentRedisTimestampMS });
const ack = jest.fn();
await gateway.handleTimeSync(
{
clientSentAtTimestampMS: 1780000000000,
sequence: 7,
},
ack,
);
expect(getCurrentRedisTimestampMS).toHaveBeenCalledTimes(1);
expect(ack).toHaveBeenCalledWith(
expect.objectContaining({
clientSentAtTimestampMS: 1780000000000,
currentServerTimestampMS: 1780000001234,
ok: true,
sequence: 7,
}),
);
});
it('rate limits excessive bid requests from the same socket', async () => {
jest.spyOn(Date, 'now').mockReturnValue(1780000000000);
const matchId = new mongoose.Types.ObjectId().toString();
const placeBidDelta = jest.fn().mockResolvedValue({
auctionBidHistoryEntry: {
bidderTeamIndex: 1,
bidPointAmount: 50,
},
currentHighestBidderTeamIndex: 1,
currentHighestBidPointAmount: 50,
revision: 3,
});
const socketEmit = jest.fn();
const socket = { data: { matchId }, emit: socketEmit };
const { gateway } = createGateway({ placeBidDelta });
const acknowledgements: Array<Record<string, unknown>> = [];
for (let index = 0; index < 9; index += 1) {
await gateway.handleBid(
socket as never,
{
bidPointAmount: 50,
bidderTeamIndex: 1,
bidRequestId: `bid-${index}`,
},
(response) => acknowledgements.push(response),
);
}
expect(placeBidDelta).toHaveBeenCalledTimes(8);
expect(socketEmit).toHaveBeenCalledWith('error', {
message: '입찰 요청이 너무 많습니다. 잠시 후 다시 시도해주세요.',
});
expect(acknowledgements[8]).toEqual({
bidRequestId: 'bid-8',
code: 'BID_RATE_LIMITED',
message: '입찰 요청이 너무 많습니다. 잠시 후 다시 시도해주세요.',
rejected: true,
});
});
it('allows bid requests again after the rate limit window resets', async () => {
const nowSpy = jest.spyOn(Date, 'now');
nowSpy.mockReturnValue(1780000000000);
const matchId = new mongoose.Types.ObjectId().toString();
const placeBidDelta = jest.fn().mockResolvedValue({
auctionBidHistoryEntry: {
bidderTeamIndex: 1,
bidPointAmount: 50,
},
currentHighestBidderTeamIndex: 1,
currentHighestBidPointAmount: 50,
revision: 3,
});
const socket = { data: { matchId }, emit: jest.fn() };
const { gateway } = createGateway({ placeBidDelta });
for (let index = 0; index < 8; index += 1) {
await gateway.handleBid(
socket as never,
{
bidPointAmount: 50,
bidderTeamIndex: 1,
bidRequestId: `bid-${index}`,
},
jest.fn(),
);
}
nowSpy.mockReturnValue(1780000001000);
await gateway.handleBid(
socket as never,
{
bidPointAmount: 50,
bidderTeamIndex: 1,
bidRequestId: 'bid-reset',
},
jest.fn(),
);
expect(placeBidDelta).toHaveBeenCalledTimes(9);
});
});
+457 -114
View File
@@ -1,9 +1,12 @@
import { Logger } from '@nestjs/common';
import { randomUUID } from 'crypto';
import { performance } from 'perf_hooks';
import {
Ack,
ConnectedSocket,
MessageBody,
OnGatewayConnection,
OnGatewayDisconnect,
OnGatewayInit,
SubscribeMessage,
WebSocketGateway,
WebSocketServer,
@@ -23,26 +26,64 @@ import type {
UserDocument,
} from '../global/database/schema';
import { AuctionService } from './auction.service';
import type {
AuctionBidDeltaResponse,
AuctionStateResponse,
} from './auction.service';
import { AuctionEventBusService } from './auction-event-bus.service';
import {
isAuctionResyncRecommended,
resolveAuctionRejectionReason,
} from './auction-rejection';
import type { MatchSideEffectDelta } from './auction-side-effect.service';
import { serializeRealtimeAuction } from './auction-realtime-serializer';
import { AuctionRedisService } from './redis/auction-redis.service';
interface JoinAuctionPayload {
matchId: string;
}
interface BidPayload {
teamIndex: number;
amount: number;
bidderUserId?: string;
bidderTeamIndex: number;
bidPointAmount: number;
bidRequestId?: string;
clientObservedAuctionLifecycleId?: string;
clientObservedCurrentBidRoundPlayerUserId?: string;
}
interface TimeSyncPayload {
clientSentAtTimestampMS?: number;
sequence?: number;
}
interface SoldPayload {
auctionActionRequestId?: string;
assignedPosition?: Position;
clientObservedAuctionLifecycleId?: string;
clientObservedCurrentAuctionPlayerOrderIndex?: number;
clientObservedCurrentBidRoundPlayerUserId?: string;
clientObservedPhase?: string;
clientObservedRevision?: number;
}
type AuctionActionPayload = Omit<SoldPayload, 'assignedPosition'>;
interface ChatMessagePayload {
message?: string;
displayName?: string;
}
interface BidRateLimitState {
count: number;
windowStartedAtTimestampMS: number;
}
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';
const BID_RATE_LIMIT_REJECTION_MESSAGE =
'입찰 요청이 너무 많습니다. 잠시 후 다시 시도해주세요.';
@WebSocketGateway({
namespace: '/auction',
cors: {
@@ -52,13 +93,12 @@ interface ChatMessagePayload {
},
})
export class AuctionGateway
implements OnGatewayConnection, OnGatewayDisconnect
implements OnGatewayConnection, OnGatewayInit
{
@WebSocketServer()
private server!: Namespace;
private readonly logger = new Logger(AuctionGateway.name);
private readonly roomTimers = new Map<string, NodeJS.Timeout>();
constructor(
private readonly auctionService: AuctionService,
@@ -66,8 +106,14 @@ export class AuctionGateway
private readonly jwtService: JwtService,
private readonly identityService: IdentityService,
private readonly connectionService: ConnectionService,
private readonly auctionEventBusService: AuctionEventBusService,
private readonly auctionRedisService: AuctionRedisService,
) {}
public afterInit(server: Namespace): void {
this.auctionEventBusService.attachAuctionNamespace(server);
}
public async handleConnection(socket: Socket) {
try {
await this.authenticateSocket(socket);
@@ -82,12 +128,6 @@ export class AuctionGateway
}
}
public handleDisconnect(socket: Socket) {
const matchId = this.getSocketMatchId(socket);
if (!matchId) return;
this.maybeClearRoomTimer(matchId);
}
@SubscribeMessage('join')
public async handleJoin(
@ConnectedSocket() socket: Socket,
@@ -106,8 +146,11 @@ export class AuctionGateway
const auction = await this.auctionService.getByMatchId(
new mongoose.Types.ObjectId(payload.matchId),
);
const auctionState = await this.auctionService.getStateByMatchId(
new mongoose.Types.ObjectId(payload.matchId),
);
this.emitChatHistory(socket, auction);
this.broadcastState(payload.matchId, auction);
this.broadcastState(payload.matchId, auctionState);
} catch (error) {
this.emitKnownError(socket, error);
}
@@ -117,41 +160,133 @@ export class AuctionGateway
public async handleBid(
@ConnectedSocket() socket: Socket,
@MessageBody() payload: BidPayload,
@Ack() ack?: (response: Record<string, unknown>) => void,
) {
const gatewayBidStartedAtMS = performance.now();
const matchId = this.requireJoinedMatchId(socket);
if (!matchId) return;
const bidderUserId = this.resolveBidderUserId(socket, payload?.bidderUserId);
if (payload?.bidderUserId && !bidderUserId) {
this.emitError(socket, 'Invalid bidderUserId.');
const bidRequestId = payload.bidRequestId ?? randomUUID();
if (!this.consumeBidRateLimit(socket)) {
this.emitError(socket, BID_RATE_LIMIT_REJECTION_MESSAGE);
ack?.({
bidRequestId,
code: BID_RATE_LIMIT_REJECTION_CODE,
message: BID_RATE_LIMIT_REJECTION_MESSAGE,
rejected: true,
});
return;
}
try {
const auction = await this.auctionService.placeBid({
const bidResult = await this.auctionService.placeBidDelta({
matchId: new mongoose.Types.ObjectId(matchId),
teamIndex: payload.teamIndex,
amount: payload.amount,
bidderUserId,
teamIndex: payload.bidderTeamIndex,
amount: payload.bidPointAmount,
bidRequestId,
clientObservedAuctionLifecycleId:
payload.clientObservedAuctionLifecycleId,
clientObservedCurrentBidRoundPlayerUserId:
payload.clientObservedCurrentBidRoundPlayerUserId,
});
const bidDelta = this.isBidDeltaResponse(bidResult)
? {
...bidResult,
bidRequestId: bidResult.bidRequestId ?? bidRequestId,
}
: this.buildBidDeltaFromAuctionState(bidResult, bidRequestId);
const bidServerTiming = this.extractBidServerTiming(bidDelta);
const broadcastBidDelta = this.stripBidServerTiming(bidDelta);
if (broadcastBidDelta) {
this.broadcastBid(matchId, broadcastBidDelta);
} else {
this.broadcastState(matchId, bidResult as AuctionStateResponse);
}
ack?.({
...(bidDelta
? {}
: { state: this.serializeAuction(bidResult as AuctionStateResponse) }),
ok: true,
bidRequestId,
bidDelta: broadcastBidDelta,
bidServerTiming: this.buildGatewayBidTiming(
gatewayBidStartedAtMS,
bidServerTiming,
),
});
this.broadcastState(matchId, auction);
} catch (error) {
this.emitKnownError(socket, error);
const rejectionAckFields = await this.resolveRejectionAckFields(
matchId,
error,
);
const bidServerTiming = this.extractBidServerTiming(rejectionAckFields);
this.emitError(socket, String(rejectionAckFields.message ?? ''));
ack?.({
...rejectionAckFields,
bidRequestId,
bidServerTiming: this.buildGatewayBidTiming(
gatewayBidStartedAtMS,
bidServerTiming,
),
rejected: true,
});
}
}
@SubscribeMessage('time-sync')
public async handleTimeSync(
@MessageBody() payload: TimeSyncPayload,
@Ack() ack?: (response: Record<string, unknown>) => void,
) {
const receivedAtMonotonicMS = performance.now();
try {
const currentServerTimestampMS =
await this.auctionRedisService.getCurrentRedisTimestampMS();
ack?.({
clientSentAtTimestampMS: payload?.clientSentAtTimestampMS,
currentServerTimestampMS,
ok: true,
sequence: payload?.sequence,
serverProcessingDurationMS:
Math.round((performance.now() - receivedAtMonotonicMS) * 10) / 10,
});
} catch (error) {
const errorPayload = this.resolveErrorPayload(error);
ack?.({
...errorPayload,
clientSentAtTimestampMS: payload?.clientSentAtTimestampMS,
rejected: true,
sequence: payload?.sequence,
});
}
}
@SubscribeMessage('open-bidding')
public async handleOpenBidding(@ConnectedSocket() socket: Socket) {
public async handleOpenBidding(
@ConnectedSocket() socket: Socket,
@MessageBody() payload: AuctionActionPayload,
@Ack() ack?: (response: Record<string, unknown>) => void,
) {
const matchId = this.requireJoinedMatchId(socket);
if (!matchId) return;
try {
const auction = await this.auctionService.openBidding(
new mongoose.Types.ObjectId(matchId),
this.toSocketAuctionActionRequest(payload),
);
this.broadcastState(matchId, auction);
ack?.({
auctionActionRequestId: payload?.auctionActionRequestId,
ok: true,
});
} catch (error) {
this.emitKnownError(socket, error);
ack?.({
...(await this.resolveRejectionAckFields(matchId, error)),
auctionActionRequestId: payload?.auctionActionRequestId,
rejected: true,
});
}
}
@@ -159,6 +294,7 @@ export class AuctionGateway
public async handleSold(
@ConnectedSocket() socket: Socket,
@MessageBody() payload: SoldPayload,
@Ack() ack?: (response: Record<string, unknown>) => void,
) {
const matchId = this.requireJoinedMatchId(socket);
if (!matchId) return;
@@ -167,25 +303,78 @@ export class AuctionGateway
const auction = await this.auctionService.markSold({
matchId: new mongoose.Types.ObjectId(matchId),
assignedPosition: payload?.assignedPosition,
...this.toSocketAuctionActionRequest(payload),
});
this.broadcastState(matchId, auction);
ack?.({
auctionActionRequestId: payload?.auctionActionRequestId,
ok: true,
});
} catch (error) {
this.emitKnownError(socket, error);
ack?.({
...(await this.resolveRejectionAckFields(matchId, error)),
auctionActionRequestId: payload?.auctionActionRequestId,
rejected: true,
});
}
}
@SubscribeMessage('next')
public async handleNext(@ConnectedSocket() socket: Socket) {
public async handleNext(
@ConnectedSocket() socket: Socket,
@MessageBody() payload: AuctionActionPayload,
@Ack() ack?: (response: Record<string, unknown>) => void,
) {
const matchId = this.requireJoinedMatchId(socket);
if (!matchId) return;
try {
const auction = await this.auctionService.next(
new mongoose.Types.ObjectId(matchId),
this.toSocketAuctionActionRequest(payload),
);
this.broadcastState(matchId, auction);
ack?.({
auctionActionRequestId: payload?.auctionActionRequestId,
ok: true,
});
} catch (error) {
this.emitKnownError(socket, error);
ack?.({
...(await this.resolveRejectionAckFields(matchId, error)),
auctionActionRequestId: payload?.auctionActionRequestId,
rejected: true,
});
}
}
@SubscribeMessage('passed')
public async handlePassed(
@ConnectedSocket() socket: Socket,
@MessageBody() payload: AuctionActionPayload,
@Ack() ack?: (response: Record<string, unknown>) => void,
) {
const matchId = this.requireJoinedMatchId(socket);
if (!matchId) return;
try {
const auction = await this.auctionService.markPassed(
new mongoose.Types.ObjectId(matchId),
this.toSocketAuctionActionRequest(payload),
);
this.broadcastState(matchId, auction);
ack?.({
auctionActionRequestId: payload?.auctionActionRequestId,
ok: true,
});
} catch (error) {
this.emitKnownError(socket, error);
ack?.({
...(await this.resolveRejectionAckFields(matchId, error)),
auctionActionRequestId: payload?.auctionActionRequestId,
rejected: true,
});
}
}
@@ -226,24 +415,52 @@ export class AuctionGateway
return matchId;
}
private consumeBidRateLimit(socket: Socket): boolean {
const currentTimestampMS = Date.now();
const previousState = socket.data
.auctionBidRateLimit as BidRateLimitState | undefined;
if (
!previousState ||
currentTimestampMS - previousState.windowStartedAtTimestampMS >=
BID_RATE_LIMIT_WINDOW_MS
) {
socket.data.auctionBidRateLimit = {
count: 1,
windowStartedAtTimestampMS: currentTimestampMS,
};
return true;
}
previousState.count += 1;
socket.data.auctionBidRateLimit = previousState;
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 resolveBidderUserId(
socket: Socket,
payloadBidderUserId?: string,
): mongoose.Types.ObjectId | undefined {
const candidate =
payloadBidderUserId ??
(socket.data.user as UserDocument | undefined)?._id.toString() ??
this.readHandshakeUserId(socket);
if (!candidate || !mongoose.isValidObjectId(candidate)) {
return undefined;
}
return new mongoose.Types.ObjectId(candidate);
private toAuctionActionRequest(payload?: AuctionActionPayload) {
return {
auctionActionRequestId: payload?.auctionActionRequestId,
clientObservedAuctionLifecycleId:
payload?.clientObservedAuctionLifecycleId,
clientObservedCurrentAuctionPlayerOrderIndex:
payload?.clientObservedCurrentAuctionPlayerOrderIndex,
clientObservedCurrentBidRoundPlayerUserId:
payload?.clientObservedCurrentBidRoundPlayerUserId,
clientObservedPhase: payload?.clientObservedPhase,
clientObservedRevision: payload?.clientObservedRevision,
};
}
private toSocketAuctionActionRequest(payload?: AuctionActionPayload) {
return {
...this.toAuctionActionRequest(payload),
shouldBroadcastStateAfterDurability: false,
};
}
private readHandshakeUserId(socket: Socket): string | undefined {
@@ -359,16 +576,25 @@ export class AuctionGateway
return typeof value === 'string' && value.length > 0 ? value : undefined;
}
public broadcastState(matchId: string, auction: AuctionDocument) {
this.server.to(matchId).emit('state', this.serializeAuction(auction));
this.syncRoomTimer(matchId, auction);
public broadcastState(matchId: string, auction: AuctionStateResponse) {
this.server.to(matchId).emit('state', serializeRealtimeAuction(auction));
}
public broadcastBid(matchId: string, delta: Record<string, unknown>) {
this.server.to(matchId).emit('bid', delta);
}
public broadcastReset(matchId: string) {
this.clearRoomTimer(matchId);
this.server.to(matchId).emit('reset', { matchId });
}
public broadcastMatchSideEffect(
matchId: string,
delta: MatchSideEffectDelta,
) {
this.server.to(matchId).emit('match-side-effect', delta);
}
private emitChatHistory(socket: Socket, auction: AuctionDocument) {
socket.emit('chat-history', {
messages: (auction.chatMessages ?? []).map((message) =>
@@ -377,90 +603,207 @@ export class AuctionGateway
});
}
private syncRoomTimer(matchId: string, auction: AuctionDocument) {
this.clearRoomTimer(matchId);
if (!auction.currentDeadline) return;
const deadline = auction.currentDeadline;
const deadlineIso = deadline.toISOString();
if (Date.now() >= deadline.getTime()) {
void this.handleDeadlineExpiry(matchId);
return;
}
this.server.to(matchId).emit('tick', {
deadline: deadlineIso,
serverTime: new Date().toISOString(),
});
const timer = setInterval(() => {
this.server.to(matchId).emit('tick', {
deadline: deadlineIso,
serverTime: new Date().toISOString(),
});
if (Date.now() >= deadline.getTime()) {
this.clearRoomTimer(matchId);
void this.handleDeadlineExpiry(matchId);
}
}, 1000);
this.roomTimers.set(matchId, timer);
}
private async handleDeadlineExpiry(matchIdStr: string) {
const matchId = new mongoose.Types.ObjectId(matchIdStr);
const auction = await this.auctionService
.getByMatchId(matchId)
.catch(() => null);
if (!auction || auction.phase !== 'bidding') return;
if (!auction.currentDeadline || auction.currentDeadline.getTime() > Date.now()) {
return;
}
try {
const nextAuction =
auction.currentBid > 0
? await this.auctionService.markSold({ matchId })
: await this.auctionService.markPassed(matchId);
this.broadcastState(matchIdStr, nextAuction);
} catch (error) {
this.emitKnownErrorToRoom(matchIdStr, error);
}
}
private maybeClearRoomTimer(matchId: string) {
const room = this.server.adapter.rooms.get(matchId);
if (room && room.size > 0) return;
this.clearRoomTimer(matchId);
}
private clearRoomTimer(matchId: string) {
const timer = this.roomTimers.get(matchId);
if (!timer) return;
clearInterval(timer);
this.roomTimers.delete(matchId);
}
private emitKnownError(socket: Socket, error: unknown) {
const message =
error instanceof Error ? error.message : 'Unexpected auction gateway error.';
this.emitError(socket, message);
}
private emitKnownErrorToRoom(matchId: string, error: unknown) {
const message =
error instanceof Error ? error.message : 'Unexpected auction gateway error.';
this.server.to(matchId).emit('error', { message });
this.emitError(socket, this.resolveErrorPayload(error).message);
}
private emitError(socket: Socket, message: string) {
socket.emit('error', { message });
}
private serializeAuction(auction: AuctionDocument) {
private serializeAuction(auction: AuctionStateResponse) {
return JSON.parse(JSON.stringify(auction));
}
/**
* 거부 ack에 실을 공통 필드를 만든다.
*
* - `code`/`message`: 기존 내부 코드/문구(진단·하위호환).
* - `auctionRejectionReason`: 맥락을 담은 설명적 거부코드(클라가 문구로 매핑).
* - `resyncRecommended`: "내가 본 상태가 낡았다"는 신호면 true.
* - `state`: resync 권장 거부에 한해 최신 권위 state를 동봉해, 클라가 join
* 왕복 없이 즉시 rebaseline하도록 한다(후속 액션의 반복 CONFLICT 차단).
*/
private async resolveRejectionAckFields(
matchId: string,
error: unknown,
): Promise<Record<string, unknown>> {
const errorPayload = this.resolveErrorPayload(error);
const auctionRejectionReason = resolveAuctionRejectionReason(
typeof errorPayload.code === 'string' ? errorPayload.code : undefined,
errorPayload.message,
);
const resyncRecommended = isAuctionResyncRecommended(auctionRejectionReason);
const state = resyncRecommended
? await this.fetchSerializedAuctionState(matchId)
: undefined;
return {
...errorPayload,
auctionRejectionReason,
resyncRecommended,
...(state ? { state } : {}),
};
}
private async fetchSerializedAuctionState(
matchId: string,
): Promise<Record<string, unknown> | undefined> {
try {
const state = await this.auctionService.getStateByMatchId(
new mongoose.Types.ObjectId(matchId),
);
return state ? this.serializeAuction(state) : undefined;
} catch {
return undefined;
}
}
private resolveErrorPayload(error: unknown): Record<string, unknown> & {
message: string;
} {
const response =
typeof (error as { getResponse?: unknown })?.getResponse === 'function'
? (error as { getResponse: () => unknown }).getResponse()
: undefined;
if (typeof response === 'object' && response !== null) {
const record = response as Record<string, unknown>;
const message = Array.isArray(record.message)
? record.message.join(', ')
: typeof record.message === 'string'
? record.message
: error instanceof Error
? error.message
: 'Unexpected auction gateway error.';
return {
...record,
code:
typeof record.code === 'string'
? record.code
: error instanceof Error
? error.message
: 'UNKNOWN',
message,
};
}
return {
code: error instanceof Error ? error.message : 'UNKNOWN',
message:
error instanceof Error ? error.message : 'Unexpected auction gateway error.',
};
}
private buildGatewayBidTiming(
gatewayBidStartedAtMS: number,
bidServerTiming?: Record<string, unknown>,
): Record<string, unknown> {
return {
...(bidServerTiming ?? {}),
gatewayTotalDurationMS:
Math.round((performance.now() - gatewayBidStartedAtMS) * 10) / 10,
};
}
private extractBidServerTiming(
bidDelta: Record<string, unknown> | null,
): Record<string, unknown> | undefined {
const timing = bidDelta?.bidServerTiming;
return typeof timing === 'object' && timing !== null
? (timing as Record<string, unknown>)
: undefined;
}
private stripBidServerTiming(
bidDelta: Record<string, unknown> | null,
): Record<string, unknown> | null {
if (!bidDelta || !('bidServerTiming' in bidDelta)) return bidDelta;
const { bidServerTiming: _bidServerTiming, ...publicBidDelta } = bidDelta;
return publicBidDelta;
}
private buildBidDeltaFromAuctionState(
auction: AuctionStateResponse,
bidRequestId?: string,
): Record<string, unknown> | null {
const serialized = this.serializeAuction(auction) as Record<string, unknown>;
const revision = Number(serialized.revision);
const currentHighestBidPointAmount = Number(
serialized.currentHighestBidPointAmount ?? serialized.currentBid,
);
const currentHighestBidderTeamIndex = Number(
serialized.currentHighestBidderTeamIndex ??
serialized.currentBidderTeamIndex,
);
const currentBidRoundDeadlineTimestampMS = Number(
serialized.currentBidRoundDeadlineTimestampMS ??
(typeof serialized.currentDeadline === 'string'
? Date.parse(serialized.currentDeadline)
: 0),
);
const redisBidHistory = Array.isArray(serialized.auctionBidHistory)
? serialized.auctionBidHistory
: [];
const legacyBidHistory = Array.isArray(serialized.bids)
? serialized.bids
: [];
const auctionBidHistoryEntry =
redisBidHistory[redisBidHistory.length - 1] ??
this.convertLegacyBidToRedisBidHistoryEntry(
legacyBidHistory[legacyBidHistory.length - 1],
);
if (
!Number.isFinite(currentHighestBidPointAmount) ||
!Number.isFinite(currentHighestBidderTeamIndex) ||
!auctionBidHistoryEntry
) {
return null;
}
return {
auctionBidHistoryEntry,
auctionLifecycleId: serialized.auctionLifecycleId,
bidRequestId,
currentBidRoundDeadlineTimestampMS: Number.isFinite(
currentBidRoundDeadlineTimestampMS,
)
? currentBidRoundDeadlineTimestampMS
: undefined,
currentHighestBidPointAmount,
currentHighestBidderTeamIndex,
currentServerTimestampMS: serialized.currentServerTimestampMS,
revision: Number.isFinite(revision) ? revision : undefined,
};
}
private isBidDeltaResponse(
value: unknown,
): value is AuctionBidDeltaResponse {
return (
typeof value === 'object' &&
value !== null &&
'auctionBidHistoryEntry' in value &&
'currentHighestBidPointAmount' in value &&
'currentHighestBidderTeamIndex' in value &&
'revision' in value
);
}
private convertLegacyBidToRedisBidHistoryEntry(
bid: unknown,
): Record<string, unknown> | null {
if (!bid || typeof bid !== 'object') return null;
const record = bid as Record<string, unknown>;
return {
bidderTeamIndex: record.teamIndex,
bidPointAmount: record.amount,
bidderUserId: record.bidderUserId,
bidPlacedAtTimestampMS:
typeof record.timestamp === 'string'
? Date.parse(record.timestamp)
: undefined,
};
}
private serializeChatMessage(message: AuctionChatMessage) {
return JSON.parse(JSON.stringify(message));
}
+19 -2
View File
@@ -4,12 +4,29 @@ import { TournamentCodeModule } from '../tournament-code/tournament-code.module'
import { TournamentResultModule } from '../tournament-result/tournament-result.module';
import { AuctionGateway } from './auction.gateway';
import { AuctionController } from './auction.controller';
import { AuctionDeadlineScheduler } from './auction-deadline.scheduler';
import { AuctionDurabilityScheduler } from './auction-durability.scheduler';
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';
@Module({
imports: [RiotModule, TournamentCodeModule, TournamentResultModule],
imports: [
RiotModule,
TournamentCodeModule,
TournamentResultModule,
AuctionRedisModule,
],
controllers: [AuctionController],
providers: [AuctionService, AuctionGateway],
providers: [
AuctionService,
AuctionGateway,
AuctionEventBusService,
AuctionDeadlineScheduler,
AuctionDurabilityScheduler,
AuctionSideEffectService,
],
exports: [AuctionService],
})
export class AuctionModule {}
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+61 -14
View File
@@ -7,6 +7,8 @@ import {
IsInt,
IsMongoId,
IsOptional,
IsString,
IsUUID,
Max,
Min,
ValidateNested,
@@ -28,10 +30,13 @@ class CaptainAssignmentDto {
@IsInt()
@Min(100)
@Max(100000)
initialPoints?: number;
initialTeamBidPointAmount?: number;
}
export class StartAuctionDto {
@IsUUID()
startAuctionRequestId!: string;
@IsArray()
@ArrayMinSize(2)
@ArrayMaxSize(16)
@@ -43,50 +48,92 @@ export class StartAuctionDto {
@IsInt()
@Min(100)
@Max(100000)
initialPoints?: number;
initialTeamBidPointAmount?: number;
@IsOptional()
@IsEnum(AUCTION_TOP_TIER_THRESHOLDS)
topTierThreshold?: AuctionTopTierThreshold;
topTierAuctionPriorityThreshold?: AuctionTopTierThreshold;
@IsOptional()
@IsArray()
@ArrayMaxSize(100)
@IsMongoId({ each: true })
manualTopTierUserIds?: string[];
manualTopTierAuctionPriorityUserIds?: string[];
@IsOptional()
@IsInt()
@Min(5)
maxTimerSeconds?: number;
maximumBidRoundDurationSeconds?: number;
@IsOptional()
@IsInt()
@Min(0)
bidExtensionSeconds?: number;
bidRoundExtensionSeconds?: number;
}
export class PlaceBidDto {
@IsInt()
@Min(1)
teamIndex!: number;
@IsOptional()
@IsUUID()
bidRequestId?: string;
@IsInt()
@Min(1)
amount!: number;
bidderTeamIndex!: number;
@IsInt()
@Min(1)
bidPointAmount!: number;
@IsOptional()
@IsMongoId()
bidderUserId?: string;
clientObservedAuctionLifecycleId?: string;
@IsOptional()
clientObservedCurrentBidRoundPlayerUserId?: string;
}
export class SoldDto {
export class AuctionActionRequestDto {
@IsOptional()
@IsUUID()
auctionActionRequestId?: string;
@IsOptional()
@IsString()
clientObservedAuctionLifecycleId?: string;
@IsOptional()
@IsInt()
@Min(0)
clientObservedRevision?: number;
@IsOptional()
@IsString()
clientObservedPhase?: string;
@IsOptional()
@IsString()
clientObservedCurrentBidRoundPlayerUserId?: string;
@IsOptional()
@IsInt()
@Min(0)
clientObservedCurrentAuctionPlayerOrderIndex?: number;
}
export class SoldDto extends AuctionActionRequestDto {
@IsOptional()
@IsEnum(['TOP', 'JGL', 'MID', 'ADC', 'SUP'])
assignedPosition?: 'TOP' | 'JGL' | 'MID' | 'ADC' | 'SUP';
}
export class UndoAuctionDto {
export class OpenBiddingDto extends AuctionActionRequestDto {}
export class NextAuctionDto extends AuctionActionRequestDto {}
export class PassedAuctionDto extends AuctionActionRequestDto {}
export class ResetAuctionDto extends AuctionActionRequestDto {}
export class UndoAuctionDto extends AuctionActionRequestDto {
@IsInt()
@Min(1)
sequence!: number;
@@ -0,0 +1,379 @@
import { AuctionRedisService } from './auction-redis.service';
import { AuctionRedisCommandService } from './auction-redis-command.service';
import { AUCTION_APPLY_TRANSITION_SCRIPT } from './auction-redis.apply-transition';
import { AUCTION_BID_SCRIPT } from './auction-redis.bid';
import { AUCTION_EXPIRE_PREPARE_SCRIPT } from './auction-redis.expire-prepare';
import { AUCTION_RESERVE_ACTION_REQUEST_SCRIPT } from './auction-redis.reserve-action';
import { AUCTION_HYDRATE_STATE_SCRIPT } from './auction-redis.state';
function makeService(reply: unknown) {
const auctionRedisService = {
evalScript: jest.fn().mockResolvedValue(reply),
} as unknown as jest.Mocked<AuctionRedisService>;
return {
auctionRedisService,
service: new AuctionRedisCommandService(auctionRedisService),
};
}
describe('AuctionRedisCommandService', () => {
it('executes BID script and parses successful reply', async () => {
const { service, auctionRedisService } = makeService([
'OK',
'bid-1',
'9',
'1000',
'120',
'2',
'31000',
'{"bidPointAmount":120}',
]);
await expect(
service.placeBid('match-1', {
bidderTeamIndex: 2,
bidPointAmount: 120,
bidRequestId: 'bid-1',
bidderUserId: 'captain-2',
clientObservedAuctionLifecycleId: 'life-1',
clientObservedCurrentBidRoundPlayerUserId: 'player-1',
maximumAuctionTeamMemberCount: 5,
maximumStoredAuctionBidHistoryCount: 200,
maximumStoredBidRequestResultCount: 100,
matchId: 'match-1',
minimumBidPointReservePerRemainingAuctionTeamMemberSlot: 10,
minimumBidRequestResultReplayWindowMS: 60_000,
}),
).resolves.toEqual({
auctionBidHistoryEntry: { bidPointAmount: 120 },
bidRequestId: 'bid-1',
currentHighestBidderTeamIndex: 2,
currentHighestBidPointAmount: 120,
currentBidRoundDeadlineTimestampMS: 31_000,
currentServerTimestampMS: 1_000,
ok: true,
revision: 9,
});
expect(auctionRedisService.evalScript).toHaveBeenCalledWith(
AUCTION_BID_SCRIPT,
expect.arrayContaining(['auction:match-1:liveAuctionState']),
expect.arrayContaining(['match-1', '2', '120']),
);
});
it('parses BID rejected reply', async () => {
const { service } = makeService([
'REJECTED',
'TOO_LOW',
'bid-1',
'1000',
'31000',
]);
await expect(
service.placeBid('match-1', {
bidderTeamIndex: 2,
bidPointAmount: 120,
bidRequestId: 'bid-1',
bidderUserId: 'captain-2',
clientObservedAuctionLifecycleId: 'life-1',
clientObservedCurrentBidRoundPlayerUserId: 'player-1',
maximumAuctionTeamMemberCount: 5,
maximumStoredAuctionBidHistoryCount: 200,
maximumStoredBidRequestResultCount: 100,
matchId: 'match-1',
minimumBidPointReservePerRemainingAuctionTeamMemberSlot: 10,
minimumBidRequestResultReplayWindowMS: 60_000,
}),
).resolves.toEqual({
bidRequestId: 'bid-1',
code: 'TOO_LOW',
currentBidRoundDeadlineTimestampMS: 31_000,
currentServerTimestampMS: 1000,
rejected: true,
});
});
it('executes reserve action request and parses lease metadata', async () => {
const { service, auctionRedisService } = makeService([
'RESERVED',
'life-1:request-1',
'transition-1',
'',
'2',
'1',
'1000',
]);
await expect(
service.reserveActionRequest('match-1', {
auctionActionRequestId: 'request-1',
auctionActionType: 'sold',
auctionStateTransitionId: 'transition-1',
clientObservedAuctionLifecycleId: 'life-1',
clientObservedPhase: 'bidding',
clientObservedRevision: 8,
leaseDurationMS: 10_000,
maximumStoredAuctionActionRequestResultCount: 100,
minimumAuctionActionRequestResultReplayWindowMS: 60_000,
processingOwnerToken: 'owner-1',
}),
).resolves.toEqual({
actionRequestScopeKey: 'life-1:request-1',
auctionStateTransitionId: 'transition-1',
currentServerTimestampMS: 1000,
newAuctionLifecycleId: '',
observedProcessingLeaseVersion: 2,
reserved: true,
wasLeaseExpired: true,
});
expect(auctionRedisService.evalScript).toHaveBeenCalledWith(
AUCTION_RESERVE_ACTION_REQUEST_SCRIPT,
expect.arrayContaining(['auction:match-1:auctionActionRequestResults']),
expect.arrayContaining(['life-1', 'request-1', 'sold']),
);
});
it('parses reserve action request replay refetch metadata', async () => {
const { service } = makeService([
'REPLAY',
'applied',
'life-1:request-1',
'11',
'',
'transition-1',
'',
'2',
'3000',
'',
'1',
]);
await expect(
service.reserveActionRequest('match-1', {
auctionActionRequestId: 'request-1',
auctionActionType: 'sold',
auctionStateTransitionId: 'transition-1',
clientObservedAuctionLifecycleId: 'life-1',
clientObservedPhase: 'bidding',
clientObservedRevision: 8,
leaseDurationMS: 10_000,
maximumStoredAuctionActionRequestResultCount: 100,
minimumAuctionActionRequestResultReplayWindowMS: 60_000,
processingOwnerToken: 'owner-1',
}),
).resolves.toEqual({
actionRequestScopeKey: 'life-1:request-1',
currentServerTimestampMS: 3000,
isReplay: true,
requiresRefetch: true,
replayStatus: 'applied',
revision: 11,
});
});
it('executes apply transition and parses successful reply', async () => {
const { service, auctionRedisService } = makeService([
'OK',
'transition-1',
'11',
'2000',
]);
await expect(
service.applyTransition('match-1', {
afterAuctionStructureStateJson: '{"auctionTeams":[]}',
auctionHistorySequence: 5,
auctionLifecycleId: 'life-1',
auctionStateTransitionId: 'transition-1',
broadcastStateRevision: 11,
deadline: { mode: 'remove' },
durabilityPayloadJson: '{"auctionStateTransitionId":"transition-1"}',
expectedPhase: 'bidding',
expectedRevision: 10,
liveStatePatch: { phase: 'sold' },
matchId: 'match-1',
shouldBroadcastState: true,
}),
).resolves.toEqual({
auctionStateTransitionId: 'transition-1',
currentServerTimestampMS: 2000,
ok: true,
revision: 11,
});
expect(auctionRedisService.evalScript).toHaveBeenCalledWith(
AUCTION_APPLY_TRANSITION_SCRIPT,
expect.arrayContaining(['auction:match-1:liveAuctionState']),
expect.arrayContaining(['match-1', 'life-1', 'transition-1']),
);
});
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,
}),
).resolves.toEqual({
auctionStateTransitionId: 'transition-1',
currentServerTimestampMS: 2100,
isReplay: true,
replayStatus: 'APPLIED',
});
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,
}),
).resolves.toEqual({
auctionStateTransitionId: 'transition-1',
code: 'CONFLICT',
currentServerTimestampMS: 2200,
rejected: true,
});
});
it('executes expire prepare and parses expiry decisions', async () => {
const { service, auctionRedisService } = makeService([
'OK',
'sold',
'expire-1',
'12',
'3000',
]);
await expect(
service.expirePrepare('match-1', {
auctionStateTransitionId: 'expire-1',
bidRoundExpiryRetryDelayMS: 3000,
matchId: 'match-1',
}),
).resolves.toEqual({
auctionStateTransitionId: 'expire-1',
bidRoundExpiryDecision: 'sold',
currentServerTimestampMS: 3000,
isReplay: undefined,
ok: true,
revision: 12,
});
expect(auctionRedisService.evalScript).toHaveBeenCalledWith(
AUCTION_EXPIRE_PREPARE_SCRIPT,
expect.arrayContaining(['auction:match-1:liveAuctionState']),
expect.arrayContaining(['match-1', 'expire-1']),
);
});
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',
}),
).resolves.toMatchObject({
auctionStateTransitionId: 'expire-1',
bidRoundExpiryDecision: 'passed',
currentServerTimestampMS: 3100,
isReplay: true,
ok: true,
revision: 12,
});
await expect(
makeService(['NOOP', 'NOT_DUE', '3200']).service.expirePrepare(
'match-1',
{
auctionStateTransitionId: 'expire-1',
bidRoundExpiryRetryDelayMS: 3000,
matchId: 'match-1',
},
),
).resolves.toEqual({
code: 'NOT_DUE',
currentServerTimestampMS: 3200,
noop: true,
});
});
it('executes hydrate state and parses hydrate/noop replies', async () => {
const { service, auctionRedisService } = makeService(['OK', '7', '4000']);
await expect(
service.hydrateState('match-1', {
auctionHistorySequence: 3,
auctionLifecycleId: 'life-1',
maximumBidRoundDurationSeconds: 30,
matchId: 'match-1',
phase: 'presenting',
revision: 6,
structureStateJson: '{"auctionTeams":[]}',
}),
).resolves.toEqual({
currentServerTimestampMS: 4000,
hydrated: true,
revision: 7,
});
expect(auctionRedisService.evalScript).toHaveBeenCalledWith(
AUCTION_HYDRATE_STATE_SCRIPT,
expect.arrayContaining(['auction:match-1:liveAuctionState']),
expect.arrayContaining(['match-1', 'life-1', '6']),
);
await expect(
makeService(['NOOP', '8', '4100']).service.hydrateState('match-1', {
auctionHistorySequence: 3,
auctionLifecycleId: 'life-1',
maximumBidRoundDurationSeconds: 30,
matchId: 'match-1',
phase: 'presenting',
revision: 6,
structureStateJson: '{}',
}),
).resolves.toEqual({
currentServerTimestampMS: 4100,
noop: true,
revision: 8,
});
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: '{}',
}),
).resolves.toEqual({
code: 'INVALID_PATCH_ARITY',
currentServerTimestampMS: 4200,
rejected: true,
});
});
});
@@ -0,0 +1,384 @@
import { Injectable } from '@nestjs/common';
import {
type AuctionApplyTransitionScriptInput,
buildAuctionApplyTransitionScriptInvocation,
} from './auction-redis.apply-transition';
import {
type AuctionBidScriptInput,
buildAuctionBidScriptInvocation,
} from './auction-redis.bid';
import {
type AuctionExpirePrepareScriptInput,
buildAuctionExpirePrepareScriptInvocation,
} from './auction-redis.expire-prepare';
import { buildAuctionRedisKeys } from './auction-redis.keys';
import { AuctionRedisService } from './auction-redis.service';
import {
type AuctionReserveActionRequestScriptInput,
buildAuctionReserveActionRequestScriptInvocation,
} from './auction-redis.reserve-action';
import {
type HydrateAuctionStateScriptInput,
buildHydrateAuctionStateScriptInvocation,
} from './auction-redis.state';
export type AuctionBidCommandResult =
| {
auctionBidHistoryEntry: Record<string, unknown>;
bidRequestId: string;
currentBidRoundDeadlineTimestampMS: number;
currentHighestBidderTeamIndex: number;
currentHighestBidPointAmount: number;
currentServerTimestampMS: number;
isReplay?: boolean;
ok: true;
revision: number;
}
| {
bidRequestId: string;
code: string;
currentBidRoundDeadlineTimestampMS?: number;
currentServerTimestampMS: number;
isReplay?: boolean;
rejected: true;
};
export type AuctionReserveActionRequestCommandResult =
| {
actionRequestScopeKey: string;
auctionStateTransitionId: string;
currentServerTimestampMS: number;
newAuctionLifecycleId: string;
observedProcessingLeaseVersion: number;
reserved: true;
wasLeaseExpired: boolean;
}
| {
actionRequestScopeKey: string;
code: string;
currentServerTimestampMS: number;
rejected: true;
}
| {
actionRequestScopeKey: string;
currentServerTimestampMS: number;
isReplay: true;
requiresRefetch?: boolean;
replayStatus: string;
responseJson?: string;
revision?: number;
};
export type AuctionApplyTransitionCommandResult =
| {
auctionStateTransitionId: string;
currentServerTimestampMS: number;
ok: true;
revision: number;
}
| {
auctionStateTransitionId: string;
currentServerTimestampMS: number;
isReplay: true;
replayStatus: string;
}
| {
auctionStateTransitionId: string;
code: string;
currentServerTimestampMS: number;
rejected: true;
};
export type AuctionExpirePrepareCommandResult =
| {
auctionStateTransitionId: string;
bidRoundExpiryDecision: 'passed' | 'sold';
currentServerTimestampMS: number;
isReplay?: boolean;
ok: true;
revision: number;
}
| {
code: string;
currentServerTimestampMS: number;
noop: true;
};
export type AuctionHydrateStateCommandResult =
| {
currentServerTimestampMS: number;
hydrated: true;
revision: number;
}
| {
currentServerTimestampMS: number;
noop: true;
revision: number;
}
| {
code: string;
currentServerTimestampMS: number;
rejected: true;
};
@Injectable()
export class AuctionRedisCommandService {
constructor(private readonly auctionRedisService: AuctionRedisService) {}
public async placeBid(
matchId: string,
input: AuctionBidScriptInput,
): Promise<AuctionBidCommandResult> {
const invocation = buildAuctionBidScriptInvocation(
buildAuctionRedisKeys(matchId),
input,
);
const reply = await this.auctionRedisService.evalScript<unknown[]>(
invocation.script,
invocation.keys,
invocation.values,
);
return parseBidCommandReply(reply);
}
public async reserveActionRequest(
matchId: string,
input: AuctionReserveActionRequestScriptInput,
): Promise<AuctionReserveActionRequestCommandResult> {
const invocation = buildAuctionReserveActionRequestScriptInvocation(
buildAuctionRedisKeys(matchId),
input,
);
const reply = await this.auctionRedisService.evalScript<unknown[]>(
invocation.script,
invocation.keys,
invocation.values,
);
return parseReserveActionRequestReply(reply);
}
public async applyTransition(
matchId: string,
input: AuctionApplyTransitionScriptInput,
): Promise<AuctionApplyTransitionCommandResult> {
const invocation = buildAuctionApplyTransitionScriptInvocation(
buildAuctionRedisKeys(matchId),
input,
);
const reply = await this.auctionRedisService.evalScript<unknown[]>(
invocation.script,
invocation.keys,
invocation.values,
);
return parseApplyTransitionReply(reply);
}
public async expirePrepare(
matchId: string,
input: AuctionExpirePrepareScriptInput,
): Promise<AuctionExpirePrepareCommandResult> {
const invocation = buildAuctionExpirePrepareScriptInvocation(
buildAuctionRedisKeys(matchId),
input,
);
const reply = await this.auctionRedisService.evalScript<unknown[]>(
invocation.script,
invocation.keys,
invocation.values,
);
return parseExpirePrepareReply(reply);
}
public async hydrateState(
matchId: string,
input: HydrateAuctionStateScriptInput,
): Promise<AuctionHydrateStateCommandResult> {
const invocation = buildHydrateAuctionStateScriptInvocation(
buildAuctionRedisKeys(matchId),
input,
);
const reply = await this.auctionRedisService.evalScript<unknown[]>(
invocation.script,
invocation.keys,
invocation.values,
);
return parseHydrateStateReply(reply);
}
}
function parseBidCommandReply(reply: unknown[]): AuctionBidCommandResult {
const values = reply.map(String);
const kind = values[0];
if (kind === 'OK') {
return {
auctionBidHistoryEntry: JSON.parse(values[7] || '{}') as Record<
string,
unknown
>,
bidRequestId: values[1],
currentBidRoundDeadlineTimestampMS: numberValue(values[6]),
currentHighestBidderTeamIndex: numberValue(values[5]),
currentHighestBidPointAmount: numberValue(values[4]),
currentServerTimestampMS: numberValue(values[3]),
ok: true,
revision: numberValue(values[2]),
};
}
if (kind === 'REPLAY') {
const status = values[1];
if (status === 'ok') {
return {
auctionBidHistoryEntry: JSON.parse(values[8] || '{}') as Record<
string,
unknown
>,
bidRequestId: values[2],
currentBidRoundDeadlineTimestampMS: numberValue(values[7]),
currentHighestBidderTeamIndex: numberValue(values[6]),
currentHighestBidPointAmount: numberValue(values[5]),
currentServerTimestampMS: numberValue(values[9]),
isReplay: true,
ok: true,
revision: numberValue(values[3]),
};
}
return {
bidRequestId: values[2],
code: values[4] || status,
currentBidRoundDeadlineTimestampMS: optionalNumberValue(values[7]),
currentServerTimestampMS: numberValue(values[9]),
isReplay: true,
rejected: true,
};
}
return {
bidRequestId: values[2] ?? '',
code: values[1] ?? 'UNKNOWN',
currentBidRoundDeadlineTimestampMS: optionalNumberValue(values[4]),
currentServerTimestampMS: numberValue(values[3]),
rejected: true,
};
}
function parseReserveActionRequestReply(
reply: unknown[],
): AuctionReserveActionRequestCommandResult {
const values = reply.map(String);
const kind = values[0];
if (kind === 'RESERVED') {
return {
actionRequestScopeKey: values[1],
auctionStateTransitionId: values[2],
currentServerTimestampMS: numberValue(values[6]),
newAuctionLifecycleId: values[3],
observedProcessingLeaseVersion: numberValue(values[4]),
reserved: true,
wasLeaseExpired: values[5] === '1',
};
}
if (kind === 'REPLAY') {
return {
actionRequestScopeKey: values[2],
currentServerTimestampMS: numberValue(values[8]),
isReplay: true,
requiresRefetch: values[10] === '1' || undefined,
replayStatus: values[1],
responseJson: values[9] || undefined,
revision: values[3] ? numberValue(values[3]) : undefined,
};
}
return {
actionRequestScopeKey: values[2] ?? '',
code: values[1] ?? 'UNKNOWN',
currentServerTimestampMS: numberValue(values[3]),
rejected: true,
};
}
function parseApplyTransitionReply(
reply: unknown[],
): AuctionApplyTransitionCommandResult {
const values = reply.map(String);
const kind = values[0];
if (kind === 'OK') {
return {
auctionStateTransitionId: values[1],
currentServerTimestampMS: numberValue(values[3]),
ok: true,
revision: numberValue(values[2]),
};
}
if (kind === 'REPLAY') {
return {
auctionStateTransitionId: values[2],
currentServerTimestampMS: numberValue(values[3]),
isReplay: true,
replayStatus: values[1],
};
}
return {
auctionStateTransitionId: values[2] ?? '',
code: values[1] ?? 'UNKNOWN',
currentServerTimestampMS: numberValue(values[3]),
rejected: true,
};
}
function parseExpirePrepareReply(
reply: unknown[],
): AuctionExpirePrepareCommandResult {
const values = reply.map(String);
const kind = values[0];
if (kind === 'OK' || kind === 'REPLAY') {
return {
auctionStateTransitionId: values[2],
bidRoundExpiryDecision:
values[1] === 'sold' || values[1] === 'passed' ? values[1] : 'passed',
currentServerTimestampMS: numberValue(values[4]),
isReplay: kind === 'REPLAY' || undefined,
ok: true,
revision: numberValue(values[3]),
};
}
return {
code: values[1] ?? 'UNKNOWN',
currentServerTimestampMS: numberValue(values[2]),
noop: true,
};
}
function parseHydrateStateReply(
reply: unknown[],
): AuctionHydrateStateCommandResult {
const values = reply.map(String);
if (values[0] === 'OK') {
return {
currentServerTimestampMS: numberValue(values[2]),
hydrated: true,
revision: numberValue(values[1]),
};
}
if (values[0] === 'REJECTED') {
return {
code: values[1] ?? 'UNKNOWN',
currentServerTimestampMS: numberValue(values[2]),
rejected: true,
};
}
return {
currentServerTimestampMS: numberValue(values[2]),
noop: true,
revision: numberValue(values[1]),
};
}
function numberValue(value: string | undefined): number {
const parsed = Number(value);
return Number.isFinite(parsed) ? parsed : 0;
}
function optionalNumberValue(value: string | undefined): number | undefined {
if (value === undefined || value === '') return undefined;
const parsed = Number(value);
return Number.isFinite(parsed) ? parsed : undefined;
}
@@ -0,0 +1,153 @@
import mongoose from 'mongoose';
import {
buildAuctionRedisLiveStatePatchFromStructure,
buildAuctionRedisStructureState,
convertLegacyAuctionTeamsToRedisTeams,
} from './auction-redis-projection';
describe('auction redis projection helpers', () => {
it('converts legacy auction team fields to redis-v1 names', () => {
const captainUserId = new mongoose.Types.ObjectId();
const memberUserId = new mongoose.Types.ObjectId();
expect(
convertLegacyAuctionTeamsToRedisTeams([
{
teamIndex: 1,
captainUserId,
points: 970,
members: [
{
userId: memberUserId,
assignedPosition: 'ADC',
cost: 30,
},
],
},
]),
).toEqual([
{
teamIndex: 1,
captainUserId,
remainingBidPointAmount: 970,
members: [
{
userId: memberUserId,
assignedPosition: 'ADC',
memberAcquisitionBidPointAmount: 30,
},
],
},
]);
});
it('builds the redis structure state with only structure/config fields', () => {
const captainUserId = new mongoose.Types.ObjectId();
const playerUserId = new mongoose.Types.ObjectId();
expect(
buildAuctionRedisStructureState({
auctionPlayerOrder: [
{
userId: playerUserId,
puuid: 'puuid',
gameName: 'Player',
tagLine: 'KR1',
profileIconId: 1,
preferredPositions: [{ position: 'MID', priority: 1 }],
tiers: [],
tierHistory: [],
masteries: [],
passCount: 0,
},
],
auctionTeams: [
{
teamIndex: 1,
captainUserId,
remainingBidPointAmount: 1000,
members: [],
},
],
bidRoundExtensionSeconds: 5,
currentAuctionPlayerOrderIndex: 0,
currentAuctionRound: 1,
initialTeamBidPointAmount: 1000,
manualTopTierAuctionPriorityUserIds: [],
maximumBidRoundDurationSeconds: 30,
passedAuctionPlayerQueue: [],
topTierAuctionPriorityThreshold: 'NONE',
}),
).toMatchObject({
auctionPlayerOrder: [expect.objectContaining({ userId: playerUserId })],
auctionTeams: [
expect.objectContaining({
captainUserId,
remainingBidPointAmount: 1000,
teamIndex: 1,
}),
],
bidRoundExtensionSeconds: 5,
currentAuctionPlayerOrderIndex: 0,
currentAuctionRound: 1,
initialTeamBidPointAmount: 1000,
maximumBidRoundDurationSeconds: 30,
passedAuctionPlayerQueue: [],
topTierAuctionPriorityThreshold: 'NONE',
});
});
it('builds live state patch required by BID Lua', () => {
const captainUserId = new mongoose.Types.ObjectId();
const playerUserId = new mongoose.Types.ObjectId();
expect(
buildAuctionRedisLiveStatePatchFromStructure({
auctionPlayerOrder: [
{
userId: playerUserId,
puuid: 'puuid',
gameName: 'Player',
tagLine: 'KR1',
profileIconId: 1,
preferredPositions: [{ position: 'MID', priority: 1 }],
tiers: [],
tierHistory: [],
masteries: [],
passCount: 0,
},
],
auctionTeams: [
{
teamIndex: 2,
captainUserId,
remainingBidPointAmount: 970,
members: [
{
userId: new mongoose.Types.ObjectId(),
assignedPosition: 'ADC',
memberAcquisitionBidPointAmount: 30,
},
],
},
],
bidRoundExtensionSeconds: 5,
currentAuctionPlayerOrderIndex: 0,
currentAuctionRound: 1,
initialTeamBidPointAmount: 1000,
manualTopTierAuctionPriorityUserIds: [],
maximumBidRoundDurationSeconds: 30,
passedAuctionPlayerQueue: [],
topTierAuctionPriorityThreshold: 'NONE',
}),
).toEqual({
bidRoundExtensionSeconds: 5,
currentAuctionPlayerOrderIndex: 0,
currentBidRoundPlayerUserId: playerUserId.toString(),
maximumBidRoundDurationSeconds: 30,
'team:2:assignedAuctionTeamMemberCount': 2,
'team:2:captainUserId': captainUserId.toString(),
'team:2:remainingBidPointAmount': 970,
});
});
});
@@ -0,0 +1,94 @@
import type {
AuctionPlayerSnapshot,
AuctionTeam,
AuctionTopTierThreshold,
RedisAuctionTeam,
} from '../../global/database/schema';
import type mongoose from 'mongoose';
export interface AuctionRedisStructureStateInput {
auctionPlayerOrder: AuctionPlayerSnapshot[];
auctionTeams: RedisAuctionTeam[];
bidRoundExtensionSeconds: number;
currentAuctionPlayerOrderIndex: number;
currentAuctionRound: number;
initialTeamBidPointAmount: number;
manualTopTierAuctionPriorityUserIds: mongoose.Types.ObjectId[];
maximumBidRoundDurationSeconds: number;
passedAuctionPlayerQueue: AuctionPlayerSnapshot[];
topTierAuctionPriorityThreshold: AuctionTopTierThreshold;
}
export function convertLegacyAuctionTeamsToRedisTeams(
teams: AuctionTeam[],
): RedisAuctionTeam[] {
return teams.map((team) => ({
teamIndex: team.teamIndex,
captainUserId: team.captainUserId,
remainingBidPointAmount: team.points,
members: team.members.map((member) => ({
userId: member.userId,
assignedPosition: member.assignedPosition,
memberAcquisitionBidPointAmount: member.cost,
})),
}));
}
export function buildAuctionRedisStructureState(
input: AuctionRedisStructureStateInput,
): Record<string, unknown> {
return {
auctionPlayerOrder: input.auctionPlayerOrder,
auctionTeams: input.auctionTeams,
bidRoundExtensionSeconds: input.bidRoundExtensionSeconds,
currentAuctionPlayerOrderIndex: input.currentAuctionPlayerOrderIndex,
currentAuctionRound: input.currentAuctionRound,
initialTeamBidPointAmount: input.initialTeamBidPointAmount,
manualTopTierAuctionPriorityUserIds:
input.manualTopTierAuctionPriorityUserIds,
maximumBidRoundDurationSeconds: input.maximumBidRoundDurationSeconds,
passedAuctionPlayerQueue: input.passedAuctionPlayerQueue,
topTierAuctionPriorityThreshold: input.topTierAuctionPriorityThreshold,
};
}
export function buildAuctionRedisLiveStatePatchFromStructure(
input: AuctionRedisStructureStateInput,
): Record<string, string | number> {
const patch: Record<string, string | number> = {
bidRoundExtensionSeconds: input.bidRoundExtensionSeconds,
currentAuctionPlayerOrderIndex: input.currentAuctionPlayerOrderIndex,
maximumBidRoundDurationSeconds: input.maximumBidRoundDurationSeconds,
};
const currentPlayer =
input.auctionPlayerOrder[input.currentAuctionPlayerOrderIndex];
if (currentPlayer) {
patch.currentBidRoundPlayerUserId = currentPlayer.userId.toString();
}
for (const team of input.auctionTeams) {
patch[`team:${team.teamIndex}:captainUserId`] =
team.captainUserId.toString();
patch[`team:${team.teamIndex}:remainingBidPointAmount`] =
team.remainingBidPointAmount;
patch[`team:${team.teamIndex}:assignedAuctionTeamMemberCount`] =
countAuctionTeamMembersIncludingCaptain(team);
}
return patch;
}
export function stringifyAuctionRedisStructureState(
input: AuctionRedisStructureStateInput,
): string {
return JSON.stringify(buildAuctionRedisStructureState(input));
}
function countAuctionTeamMembersIncludingCaptain(team: RedisAuctionTeam): number {
const userIds = new Set<string>([team.captainUserId.toString()]);
for (const member of team.members) {
userIds.add(member.userId.toString());
}
return userIds.size;
}
@@ -0,0 +1,200 @@
import { AuctionRedisService } from './auction-redis.service';
import { AuctionRedisStateReaderService } from './auction-redis-state-reader.service';
function makeService(commandReplies: unknown[], currentServerTimestampMS = 1000) {
const sendCommand = jest
.fn()
.mockImplementation(() => Promise.resolve(commandReplies.shift()));
const auctionRedisService = {
getCurrentRedisTimestampMS: jest
.fn()
.mockResolvedValue(currentServerTimestampMS),
raw: jest.fn().mockReturnValue({ sendCommand }),
} as unknown as jest.Mocked<AuctionRedisService>;
return {
auctionRedisService,
sendCommand,
service: new AuctionRedisStateReaderService(auctionRedisService),
};
}
describe('AuctionRedisStateReaderService', () => {
it('reads live state identity', async () => {
const { service, sendCommand } = makeService([['life-1', '7']]);
await expect(service.readLiveStateIdentity('match-1')).resolves.toEqual({
auctionLifecycleId: 'life-1',
revision: 7,
});
expect(sendCommand).toHaveBeenCalledWith([
'HMGET',
'auction:match-1:liveAuctionState',
'auctionLifecycleId',
'revision',
]);
});
it('returns null when live state identity is missing', async () => {
const { service } = makeService([[null, null]]);
await expect(service.readLiveStateIdentity('match-1')).resolves.toBeNull();
});
it('reads bid context from the live state hot path fields', async () => {
const { service, sendCommand } = makeService([
['bidding', 'life-1', 'player-1', 'captain-2'],
]);
await expect(service.readBidContext('match-1', 2)).resolves.toEqual({
auctionLifecycleId: 'life-1',
bidderTeamCaptainUserId: 'captain-2',
currentBidRoundPlayerUserId: 'player-1',
phase: 'bidding',
});
expect(sendCommand).toHaveBeenCalledTimes(1);
expect(sendCommand).toHaveBeenCalledWith([
'HMGET',
'auction:match-1:liveAuctionState',
'phase',
'auctionLifecycleId',
'currentBidRoundPlayerUserId',
'team:2:captainUserId',
]);
});
it('falls back to structure state when bid context has no live captain field', async () => {
const { service, sendCommand } = makeService([
['bidding', 'life-1', 'player-1', null],
'{"auctionTeams":[{"teamIndex":2,"captainUserId":"captain-2"}]}',
]);
await expect(service.readBidContext('match-1', 2)).resolves.toEqual({
auctionLifecycleId: 'life-1',
bidderTeamCaptainUserId: 'captain-2',
currentBidRoundPlayerUserId: 'player-1',
phase: 'bidding',
});
expect(sendCommand).toHaveBeenNthCalledWith(2, [
'GET',
'auction:match-1:auctionStructureState',
]);
});
it('assembles a public auction view from Redis state', async () => {
const { service, sendCommand } = makeService([
[
'auctionLifecycleId',
'life-1',
'phase',
'expiring',
'revision',
'8',
'currentHighestBidPointAmount',
'100',
'currentHighestBidderTeamIndex',
'2',
'team:2:remainingBidPointAmount',
'900',
'bidRoundExpiryDecision',
'sold',
],
'{"auctionTeams":[{"teamIndex":1}]}',
['{"bidPointAmount":100,"bidderTeamIndex":2}'],
]);
const view = await service.readAuctionStateView('match-1', {
shouldForceAuctionStateResync: true,
});
expect(view).toMatchObject({
auctionBidHistory: [{ bidPointAmount: 100, bidderTeamIndex: 2 }],
auctionLifecycleId: 'life-1',
auctionTeams: [{ teamIndex: 1 }],
canPlaceBidInCurrentBidRound: false,
currentHighestBidderTeamIndex: 2,
currentHighestBidPointAmount: 100,
currentServerTimestampMS: 1000,
isAuctionStateTransitionInProgress: true,
phase: 'bidding',
revision: 8,
shouldForceAuctionStateResync: true,
});
expect(view).not.toHaveProperty('team:2:remainingBidPointAmount');
expect(view).not.toHaveProperty('bidRoundExpiryDecision');
expect(sendCommand).toHaveBeenNthCalledWith(1, [
'HGETALL',
'auction:match-1:liveAuctionState',
]);
expect(sendCommand).toHaveBeenNthCalledWith(2, [
'GET',
'auction:match-1:auctionStructureState',
]);
expect(sendCommand).toHaveBeenNthCalledWith(3, [
'LRANGE',
'auction:match-1:auctionBidHistory',
'0',
'-1',
]);
});
it('assembles state when HGETALL returns an object', async () => {
const { service } = makeService([
{
auctionLifecycleId: 'life-1',
phase: 'presenting',
revision: '3',
},
'{"auctionTeams":[]}',
[],
]);
await expect(service.readAuctionStateView('match-1')).resolves.toMatchObject({
auctionLifecycleId: 'life-1',
auctionTeams: [],
phase: 'presenting',
revision: 3,
});
});
it('can expose internal live fields for server-side expiry completion', async () => {
const { service } = makeService([
{
auctionLifecycleId: 'life-1',
bidRoundExpiryDecision: 'sold',
phase: 'expiring',
revision: '4',
'team:1:remainingBidPointAmount': '900',
},
'{"auctionTeams":[]}',
[],
]);
await expect(
service.readAuctionStateView('match-1', {
includeInternalLiveStateFields: true,
}),
).resolves.toMatchObject({
bidRoundExpiryDecision: 'sold',
redisInternalPhase: 'expiring',
'team:1:remainingBidPointAmount': '900',
});
});
it('returns null when live or structure state is absent', async () => {
await expect(
makeService([[], '{"auctionTeams":[]}', []]).service.readAuctionStateView(
'match-1',
),
).resolves.toBeNull();
await expect(
makeService([
{ auctionLifecycleId: 'life-1', phase: 'presenting', revision: '1' },
null,
[],
]).service.readAuctionStateView('match-1'),
).resolves.toBeNull();
});
});
@@ -0,0 +1,229 @@
import { Injectable } from '@nestjs/common';
import { buildAuctionRedisKeys } from './auction-redis.keys';
import { AuctionRedisService } from './auction-redis.service';
import { assembleAuctionViewFromRedisState } from './auction-redis.state';
const NUMERIC_LIVE_STATE_FIELDS = new Set([
'bidRoundExpiryPlayerOrderIndex',
'bidRoundExpiryRevision',
'bidRoundExpiryWinningBidPointAmount',
'bidRoundExpiryWinningBidderTeamIndex',
'currentAuctionHistorySequence',
'currentAuctionPlayerOrderIndex',
'currentBidRoundDeadlineTimestampMS',
'currentHighestBidPointAmount',
'currentHighestBidderTeamIndex',
'matchSideEffectRevision',
'revision',
]);
export interface AuctionRedisLiveStateIdentity {
auctionLifecycleId?: string;
revision?: number;
}
export interface AuctionRedisBidContext {
auctionLifecycleId: string;
bidderTeamCaptainUserId?: string;
currentBidRoundPlayerUserId?: string;
phase: string;
}
export interface AuctionRedisStateViewReadOptions {
includeInternalLiveStateFields?: boolean;
shouldForceAuctionStateResync?: boolean;
}
@Injectable()
export class AuctionRedisStateReaderService {
constructor(private readonly auctionRedisService: AuctionRedisService) {}
public async readLiveStateIdentity(
matchId: string,
): Promise<AuctionRedisLiveStateIdentity | null> {
const keys = buildAuctionRedisKeys(matchId);
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;
const revision =
typeof reply[1] === 'string' || typeof reply[1] === 'number'
? Number(reply[1])
: Number.NaN;
if (!auctionLifecycleId && !Number.isFinite(revision)) return null;
return {
auctionLifecycleId,
revision: Number.isFinite(revision) ? revision : undefined,
};
}
public async readBidContext(
matchId: string,
bidderTeamIndex: number,
): 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,
]);
if (!Array.isArray(liveReply)) return null;
const phase = stringValue(liveReply[0]);
const auctionLifecycleId = stringValue(liveReply[1]);
const currentBidRoundPlayerUserId = stringValue(liveReply[2]);
const liveCaptainUserId = stringValue(liveReply[3]);
if (!phase || !auctionLifecycleId) return null;
return {
auctionLifecycleId,
bidderTeamCaptainUserId:
liveCaptainUserId ??
(await this.readBidderTeamCaptainUserIdFromStructure(
keys.structureStateKey,
bidderTeamIndex,
)),
currentBidRoundPlayerUserId,
phase,
};
}
public async readAuctionStateView(
matchId: string,
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 liveState = parseHashReply(liveReply, {
includeInternalLiveStateFields:
options.includeInternalLiveStateFields ?? false,
});
if (!liveState) return null;
if (
typeof liveState.auctionLifecycleId !== 'string' ||
typeof liveState.phase !== 'string' ||
typeof liveState.revision !== 'number'
) {
return null;
}
if (typeof structureStateJson !== 'string' || !structureStateJson) {
return null;
}
const view = assembleAuctionViewFromRedisState({
auctionBidHistoryEntries: Array.isArray(bidEntries)
? bidEntries.map(String)
: [],
currentServerTimestampMS,
liveState: liveState as Record<string, unknown> & {
auctionLifecycleId: string;
phase: string;
revision: number;
},
shouldForceAuctionStateResync: options.shouldForceAuctionStateResync,
structureState: JSON.parse(structureStateJson) as Record<string, unknown>,
});
view.matchId = matchId;
if (options.includeInternalLiveStateFields) {
view.redisInternalPhase = liveState.phase;
}
return view;
}
private async readBidderTeamCaptainUserIdFromStructure(
structureStateKey: string,
bidderTeamIndex: number,
): Promise<string | undefined> {
const structureStateJson = await this.auctionRedisService
.raw()
.sendCommand(['GET', structureStateKey]);
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 bidderTeam = auctionTeams.find((entry) => {
if (!entry || typeof entry !== 'object') return false;
return (
Number((entry as Record<string, unknown>).teamIndex) === bidderTeamIndex
);
});
if (!bidderTeam || typeof bidderTeam !== 'object') return undefined;
return stringValue((bidderTeam as Record<string, unknown>).captainUserId);
}
}
function stringValue(value: unknown): string | undefined {
return typeof value === 'string' && value ? value : undefined;
}
function parseHashReply(
reply: unknown,
options: { includeInternalLiveStateFields?: boolean } = {},
): Record<string, unknown> | null {
if (!reply) return null;
if (Array.isArray(reply)) {
if (reply.length === 0) return null;
const entries: [string, unknown][] = [];
for (let index = 0; index < reply.length; index += 2) {
entries.push([String(reply[index]), reply[index + 1]]);
}
return parseHashEntries(entries, options);
}
if (typeof reply === 'object') {
const entries = Object.entries(reply as Record<string, unknown>);
if (entries.length === 0) return null;
return parseHashEntries(entries, options);
}
return null;
}
function parseHashEntries(
entries: [string, unknown][],
options: { includeInternalLiveStateFields?: boolean } = {},
): Record<string, unknown> {
const result: Record<string, unknown> = {};
for (const [field, rawValue] of entries) {
if (!options.includeInternalLiveStateFields && isInternalLiveStateField(field)) {
continue;
}
const value = String(rawValue);
if (NUMERIC_LIVE_STATE_FIELDS.has(field)) {
const parsed = Number(value);
result[field] = Number.isFinite(parsed) ? parsed : 0;
continue;
}
result[field] = value;
}
return result;
}
function isInternalLiveStateField(field: string): boolean {
return field.startsWith('team:') || field.startsWith('bidRoundExpiry');
}
@@ -0,0 +1,113 @@
import { buildAuctionRedisKeys } from './auction-redis.keys';
import {
AUCTION_APPLY_TRANSITION_SCRIPT,
buildAuctionApplyTransitionScriptInvocation,
} from './auction-redis.apply-transition';
describe('auction apply transition redis script contract', () => {
it('builds APPLY_TRANSITION keys and values in a stable order', () => {
const keys = buildAuctionRedisKeys('match-1');
const invocation = buildAuctionApplyTransitionScriptInvocation(keys, {
actionRequest: {
observedProcessingLeaseVersion: 3,
processingOwnerToken: 'owner-1',
scopeKey: 'life-1:request-1',
},
afterAuctionStructureStateJson: '{"auctionTeams":[]}',
auctionHistorySequence: 4,
auctionLifecycleId: 'life-1',
auctionStateTransitionId: 'transition-1',
broadcastStateRevision: 9,
deadline: { durationSeconds: 30, mode: 'set-relative' },
durabilityPayloadJson: '{"revision":9}',
expectedCurrentAuctionPlayerOrderIndex: 2,
expectedCurrentBidRoundPlayerUserId: 'player-1',
expectedAuctionHistorySequence: 3,
expectedPhase: 'bidding',
expectedRevision: 8,
liveStatePatch: {
currentAuctionHistorySequence: 4,
phase: 'sold',
},
matchId: 'match-1',
shouldBroadcastState: true,
});
expect(invocation.script).toBe(AUCTION_APPLY_TRANSITION_SCRIPT);
expect(invocation.keys).toEqual([
'auction:match-1:liveAuctionState',
'auction:match-1:auctionStructureState',
'auction:match-1:appliedAuctionStateTransitionIds',
'auction:match-1:durability:transition-1',
'auction:auctionDurabilityRetryQueue',
'auction:match-1:auctionActionRequestResults',
'auction:match-1:auctionActionRequestResultOrder',
'auction:match-1:auctionBidHistory',
'auction:match-1:bidRequestResults',
'auction:match-1:bidRequestResultOrder',
'auction:bidRoundDeadlineQueue',
]);
expect(invocation.values.slice(0, 19)).toEqual([
'match-1',
'life-1',
'transition-1',
'8',
'3',
'bidding',
'player-1',
'2',
'{"auctionTeams":[]}',
'4',
'{"revision":9}',
'1',
'9',
'set-relative',
'30',
'0',
'life-1:request-1',
'owner-1',
'3',
]);
expect(invocation.values.slice(19)).toEqual([
'2',
'currentAuctionHistorySequence',
'4',
'phase',
'sold',
]);
});
it('keeps critical atomicity guards in Lua', () => {
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain("redis.call('TIME')");
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
'ACTION_REQUEST_LEASE_VERSION_MISMATCH',
);
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
'ACTION_REQUEST_TRANSITION_MISMATCH',
);
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
'INVALID_PATCH_ARITY',
);
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('HINCRBY'",
);
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
'currentAuctionHistorySequence',
);
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
'storeValidatedActionRequestRejection',
);
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
"actionRequestPrefix .. 'status'",
);
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
"actionRequestPrefix .. 'requiresRefetch'",
);
});
});
@@ -0,0 +1,325 @@
import type { AuctionRedisKeys } from './auction-redis.keys';
import { defineAuctionRedisScript } from './auction-redis.scripts';
export type ApplyTransitionDeadlineInput =
| { mode: 'none' }
| { mode: 'remove' }
| { durationSeconds: number; mode: 'set-relative' };
export interface ApplyTransitionActionRequestInput {
observedProcessingLeaseVersion: number;
processingOwnerToken: string;
scopeKey: string;
}
export interface AuctionApplyTransitionScriptInput {
actionRequest?: ApplyTransitionActionRequestInput;
afterAuctionStructureStateJson: string;
auctionHistorySequence: number;
auctionLifecycleId: string;
auctionStateTransitionId: string;
broadcastStateRevision: number;
deadline: ApplyTransitionDeadlineInput;
durabilityPayloadJson: string;
expectedCurrentAuctionPlayerOrderIndex?: number;
expectedCurrentBidRoundPlayerUserId?: string;
expectedAuctionHistorySequence?: number;
expectedPhase: string;
expectedRevision: number;
liveStatePatch: Record<string, string | number | boolean | null | undefined>;
matchId: string;
shouldBroadcastState: boolean;
shouldResetBidRuntime?: boolean;
}
export interface AuctionApplyTransitionScriptInvocation {
keys: string[];
script: typeof AUCTION_APPLY_TRANSITION_SCRIPT;
values: string[];
}
function stringifyRedisValue(value: string | number | boolean | null): string {
if (typeof value === 'boolean') return value ? '1' : '0';
if (value === null) return '';
return String(value);
}
function flattenLiveStatePatch(
liveStatePatch: AuctionApplyTransitionScriptInput['liveStatePatch'],
): string[] {
return Object.entries(liveStatePatch)
.filter(([, value]) => value !== undefined)
.sort(([a], [b]) => a.localeCompare(b))
.flatMap(([key, value]) => [
key,
stringifyRedisValue(value as string | number | boolean | null),
]);
}
export function buildAuctionApplyTransitionScriptInvocation(
keys: AuctionRedisKeys,
input: AuctionApplyTransitionScriptInput,
): AuctionApplyTransitionScriptInvocation {
const liveStatePatchPairs = flattenLiveStatePatch(input.liveStatePatch);
const deadlineDurationSeconds =
input.deadline.mode === 'set-relative'
? String(input.deadline.durationSeconds)
: '0';
return {
keys: [
keys.liveStateKey,
keys.structureStateKey,
keys.appliedTransitionIdsKey,
keys.durabilityPayloadKey(input.auctionStateTransitionId),
keys.durabilityRetryQueueKey,
keys.actionRequestResultsKey,
keys.actionRequestResultOrderKey,
keys.bidHistoryKey,
keys.bidRequestResultsKey,
keys.bidRequestResultOrderKey,
keys.deadlineQueueKey,
],
script: AUCTION_APPLY_TRANSITION_SCRIPT,
values: [
input.matchId,
input.auctionLifecycleId,
input.auctionStateTransitionId,
String(input.expectedRevision),
String(
input.expectedAuctionHistorySequence ??
input.auctionHistorySequence - 1,
),
input.expectedPhase,
input.expectedCurrentBidRoundPlayerUserId ?? '',
input.expectedCurrentAuctionPlayerOrderIndex === undefined
? ''
: String(input.expectedCurrentAuctionPlayerOrderIndex),
input.afterAuctionStructureStateJson,
String(input.auctionHistorySequence),
input.durabilityPayloadJson,
input.shouldBroadcastState ? '1' : '0',
String(input.broadcastStateRevision),
input.deadline.mode,
deadlineDurationSeconds,
input.shouldResetBidRuntime ? '1' : '0',
input.actionRequest?.scopeKey ?? '',
input.actionRequest?.processingOwnerToken ?? '',
input.actionRequest?.observedProcessingLeaseVersion === undefined
? ''
: String(input.actionRequest.observedProcessingLeaseVersion),
String(liveStatePatchPairs.length / 2),
...liveStatePatchPairs,
],
};
}
export const AUCTION_APPLY_TRANSITION_SCRIPT = defineAuctionRedisScript(
'auction.applyTransition',
`
local liveAuctionStateKey = KEYS[1]
local auctionStructureStateKey = KEYS[2]
local appliedAuctionStateTransitionIdsKey = KEYS[3]
local durabilityPayloadKey = KEYS[4]
local durabilityRetryQueueKey = KEYS[5]
local auctionActionRequestResultsKey = KEYS[6]
local auctionActionRequestResultOrderKey = KEYS[7]
local auctionBidHistoryKey = KEYS[8]
local bidRequestResultsKey = KEYS[9]
local bidRequestResultOrderKey = KEYS[10]
local bidRoundDeadlineQueueKey = KEYS[11]
local matchId = ARGV[1]
local auctionLifecycleId = ARGV[2]
local auctionStateTransitionId = ARGV[3]
local expectedRevision = tonumber(ARGV[4])
local expectedAuctionHistorySequence = tonumber(ARGV[5])
local expectedPhase = ARGV[6]
local expectedCurrentBidRoundPlayerUserId = ARGV[7]
local expectedCurrentAuctionPlayerOrderIndex = ARGV[8]
local afterAuctionStructureStateJson = ARGV[9]
local auctionHistorySequence = tonumber(ARGV[10])
local durabilityPayloadJson = ARGV[11]
local shouldBroadcastState = ARGV[12]
local broadcastStateRevision = tonumber(ARGV[13])
local deadlineMode = ARGV[14]
local deadlineDurationSeconds = tonumber(ARGV[15])
local shouldResetBidRuntime = ARGV[16]
local actionRequestScopeKey = ARGV[17]
local processingOwnerToken = ARGV[18]
local observedProcessingLeaseVersion = ARGV[19]
local liveStatePatchPairCount = tonumber(ARGV[20])
local redisTime = redis.call('TIME')
local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000)
local validatedActionRequestScopeKey = ''
local function storeValidatedActionRequestRejection(code)
if validatedActionRequestScopeKey == '' then
return
end
local actionRequestPrefix = validatedActionRequestScopeKey .. ':'
redis.call(
'HSET',
auctionActionRequestResultsKey,
actionRequestPrefix .. 'status',
'rejected',
actionRequestPrefix .. 'rejectCode',
code,
actionRequestPrefix .. 'requiresRefetch',
'1',
actionRequestPrefix .. 'responseServerTimestampMS',
tostring(currentRedisTimestampMS)
)
end
local function reject(code)
storeValidatedActionRequestRejection(code)
return {'REJECTED', code, auctionStateTransitionId, tostring(currentRedisTimestampMS)}
end
if not liveStatePatchPairCount then
return reject('INVALID_PATCH_ARITY')
end
if #ARGV ~= 20 + (liveStatePatchPairCount * 2) then
return reject('INVALID_PATCH_ARITY')
end
if not durabilityPayloadJson or durabilityPayloadJson == '' then
return reject('MISSING_DURABILITY_PAYLOAD')
end
if shouldBroadcastState ~= '0' and shouldBroadcastState ~= '1' then
return reject('INVALID_SHOULD_BROADCAST_STATE')
end
if shouldBroadcastState == '1' and not broadcastStateRevision then
return reject('INVALID_BROADCAST_STATE_REVISION')
end
if deadlineMode ~= 'none' and deadlineMode ~= 'remove' and deadlineMode ~= 'set-relative' then
return reject('INVALID_DEADLINE_MODE')
end
if deadlineMode == 'set-relative' and (not deadlineDurationSeconds or deadlineDurationSeconds <= 0) then
return reject('INVALID_DEADLINE_DURATION')
end
if actionRequestScopeKey ~= '' then
local actionRequestPrefix = actionRequestScopeKey .. ':'
local storedTransitionId = redis.call('HGET', auctionActionRequestResultsKey, actionRequestPrefix .. 'auctionStateTransitionId')
if not storedTransitionId then
return reject('ACTION_REQUEST_NOT_RESERVED')
end
if storedTransitionId ~= auctionStateTransitionId then
return reject('ACTION_REQUEST_TRANSITION_MISMATCH')
end
local storedOwnerToken = redis.call('HGET', auctionActionRequestResultsKey, actionRequestPrefix .. 'processingOwnerToken')
local leaseExpiresAtTimestampMS = tonumber(redis.call('HGET', auctionActionRequestResultsKey, actionRequestPrefix .. 'processingLeaseExpiresAtTimestampMS') or '0')
if leaseExpiresAtTimestampMS <= currentRedisTimestampMS then
return reject('ACTION_REQUEST_LEASE_EXPIRED')
end
if storedOwnerToken ~= processingOwnerToken then
return reject('ACTION_REQUEST_IN_PROGRESS')
end
local storedLeaseVersion = redis.call('HGET', auctionActionRequestResultsKey, actionRequestPrefix .. 'processingLeaseVersion') or ''
if storedLeaseVersion ~= observedProcessingLeaseVersion then
return reject('ACTION_REQUEST_LEASE_VERSION_MISMATCH')
end
validatedActionRequestScopeKey = actionRequestScopeKey
end
local currentRevision = tonumber(redis.call('HGET', liveAuctionStateKey, 'revision') or '-1')
if currentRevision ~= expectedRevision then
return reject('CONFLICT')
end
local currentAuctionHistorySequence = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentAuctionHistorySequence') or '-1')
if currentAuctionHistorySequence ~= expectedAuctionHistorySequence then
return reject('CONFLICT')
end
if redis.call('HGET', liveAuctionStateKey, 'auctionLifecycleId') ~= auctionLifecycleId then
return reject('CONFLICT')
end
if redis.call('HGET', liveAuctionStateKey, 'phase') ~= expectedPhase then
return reject('CONFLICT')
end
if expectedCurrentBidRoundPlayerUserId ~= '' and redis.call('HGET', liveAuctionStateKey, 'currentBidRoundPlayerUserId') ~= expectedCurrentBidRoundPlayerUserId then
return reject('CONFLICT')
end
if expectedCurrentAuctionPlayerOrderIndex ~= '' and redis.call('HGET', liveAuctionStateKey, 'currentAuctionPlayerOrderIndex') ~= expectedCurrentAuctionPlayerOrderIndex then
return reject('CONFLICT')
end
local transitionDedupeMember = auctionLifecycleId .. ':' .. auctionStateTransitionId
if redis.call('SISMEMBER', appliedAuctionStateTransitionIdsKey, transitionDedupeMember) == 1 then
return {'REPLAY', 'APPLIED', auctionStateTransitionId, tostring(currentRedisTimestampMS)}
end
local newRevision = redis.call('HINCRBY', liveAuctionStateKey, 'revision', 1)
redis.call('SET', auctionStructureStateKey, afterAuctionStructureStateJson)
local hsetArgs = {
liveAuctionStateKey,
'auctionLifecycleId',
auctionLifecycleId,
'currentAuctionHistorySequence',
tostring(auctionHistorySequence),
'lastAppliedAuctionStateTransitionId',
auctionStateTransitionId
}
local patchIndex = 21
for i = 1, liveStatePatchPairCount do
table.insert(hsetArgs, ARGV[patchIndex])
table.insert(hsetArgs, ARGV[patchIndex + 1])
patchIndex = patchIndex + 2
end
redis.call('HSET', unpack(hsetArgs))
if deadlineMode == 'set-relative' then
local currentBidRoundDeadlineTimestampMS = currentRedisTimestampMS + (deadlineDurationSeconds * 1000)
redis.call('HSET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS', tostring(currentBidRoundDeadlineTimestampMS))
redis.call('ZADD', bidRoundDeadlineQueueKey, currentBidRoundDeadlineTimestampMS, matchId)
elseif deadlineMode == 'remove' then
redis.call('ZREM', bidRoundDeadlineQueueKey, matchId)
end
if shouldResetBidRuntime == '1' then
redis.call('DEL', auctionBidHistoryKey, bidRequestResultsKey, bidRequestResultOrderKey)
end
redis.call('SADD', appliedAuctionStateTransitionIdsKey, transitionDedupeMember)
redis.call(
'HSET',
durabilityPayloadKey,
'payloadJson',
durabilityPayloadJson,
'preparedAtRedisTimestampMS',
tostring(currentRedisTimestampMS),
'committedAtRedisTimestampMS',
tostring(currentRedisTimestampMS),
'auctionLifecycleId',
auctionLifecycleId,
'revision',
tostring(newRevision),
'shouldBroadcastState',
shouldBroadcastState,
'broadcastStateRevision',
tostring(broadcastStateRevision)
)
redis.call('ZADD', durabilityRetryQueueKey, currentRedisTimestampMS, durabilityPayloadKey)
if actionRequestScopeKey ~= '' then
local actionRequestPrefix = actionRequestScopeKey .. ':'
redis.call(
'HSET',
auctionActionRequestResultsKey,
actionRequestPrefix .. 'status',
'applied',
actionRequestPrefix .. 'revision',
tostring(newRevision),
actionRequestPrefix .. 'requiresRefetch',
'1',
actionRequestPrefix .. 'responseServerTimestampMS',
tostring(currentRedisTimestampMS)
)
redis.call('RPUSH', auctionActionRequestResultOrderKey, actionRequestScopeKey)
end
return {'OK', auctionStateTransitionId, tostring(newRevision), tostring(currentRedisTimestampMS)}
`,
);
@@ -0,0 +1,72 @@
import { buildAuctionRedisKeys } from './auction-redis.keys';
import {
AUCTION_BID_SCRIPT,
buildAuctionBidScriptInvocation,
buildBidRequestPayloadFingerprint,
} from './auction-redis.bid';
describe('auction bid redis script contract', () => {
it('builds the BID script KEYS and ARGV in the documented order', () => {
const keys = buildAuctionRedisKeys('match-1');
const invocation = buildAuctionBidScriptInvocation(keys, {
bidderTeamIndex: 2,
bidPointAmount: 120,
bidRequestId: 'bid-1',
bidderUserId: 'captain-2',
clientObservedAuctionLifecycleId: 'life-1',
clientObservedCurrentBidRoundPlayerUserId: 'player-1',
maximumAuctionTeamMemberCount: 5,
maximumStoredAuctionBidHistoryCount: 200,
maximumStoredBidRequestResultCount: 100,
matchId: 'match-1',
minimumBidPointReservePerRemainingAuctionTeamMemberSlot: 10,
minimumBidRequestResultReplayWindowMS: 60_000,
});
expect(invocation.script).toBe(AUCTION_BID_SCRIPT);
expect(invocation.keys).toEqual([
'auction:match-1:liveAuctionState',
'auction:match-1:auctionBidHistory',
'auction:match-1:bidRequestResults',
'auction:match-1:bidRequestResultOrder',
'auction:bidRoundDeadlineQueue',
]);
expect(invocation.values).toEqual([
'match-1',
'2',
'120',
'5',
'10',
'bid-1',
'captain-2',
'life-1',
'player-1',
'match-1|life-1|player-1|2|120',
'100',
'60000',
'200',
]);
});
it('keeps bid fingerprints stable and timestamp-free', () => {
expect(
buildBidRequestPayloadFingerprint({
bidderTeamIndex: 2,
bidPointAmount: 120,
clientObservedAuctionLifecycleId: 'life-1',
clientObservedCurrentBidRoundPlayerUserId: 'player-1',
matchId: 'match-1',
}),
).toBe('match-1|life-1|player-1|2|120');
});
it('uses Redis TIME and scalar hash fields rather than JSON parsing', () => {
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).not.toContain('cjson.decode');
});
});
@@ -0,0 +1,313 @@
import type { AuctionRedisKeys } from './auction-redis.keys';
import { defineAuctionRedisScript } from './auction-redis.scripts';
export interface AuctionBidScriptInput {
bidderTeamIndex: number;
bidPointAmount: number;
bidRequestId: string;
bidderUserId: string;
clientObservedAuctionLifecycleId: string;
clientObservedCurrentBidRoundPlayerUserId: string;
maximumAuctionTeamMemberCount: number;
maximumStoredAuctionBidHistoryCount: number;
maximumStoredBidRequestResultCount: number;
matchId: string;
minimumBidPointReservePerRemainingAuctionTeamMemberSlot: number;
minimumBidRequestResultReplayWindowMS: number;
}
export interface AuctionBidScriptInvocation {
keys: string[];
script: typeof AUCTION_BID_SCRIPT;
values: string[];
}
const BID_RESULT_HASH_SUFFIXES = [
'fingerprint',
'status',
'revision',
'rejectCode',
'currentHighestBidPointAmount',
'currentHighestBidderTeamIndex',
'currentBidRoundDeadlineTimestampMS',
'auctionBidHistoryEntryJson',
'responseServerTimestampMS',
'createdAtTimestampMS',
] as const;
export function buildBidRequestPayloadFingerprint(params: {
bidderTeamIndex: number;
bidPointAmount: number;
clientObservedAuctionLifecycleId: string;
clientObservedCurrentBidRoundPlayerUserId: string;
matchId: string;
}): string {
return [
params.matchId,
params.clientObservedAuctionLifecycleId,
params.clientObservedCurrentBidRoundPlayerUserId,
params.bidderTeamIndex,
params.bidPointAmount,
].join('|');
}
export function buildAuctionBidScriptInvocation(
keys: AuctionRedisKeys,
input: AuctionBidScriptInput,
): AuctionBidScriptInvocation {
return {
keys: [
keys.liveStateKey,
keys.bidHistoryKey,
keys.bidRequestResultsKey,
keys.bidRequestResultOrderKey,
keys.deadlineQueueKey,
],
script: AUCTION_BID_SCRIPT,
values: [
input.matchId,
String(input.bidderTeamIndex),
String(input.bidPointAmount),
String(input.maximumAuctionTeamMemberCount),
String(input.minimumBidPointReservePerRemainingAuctionTeamMemberSlot),
input.bidRequestId,
input.bidderUserId,
input.clientObservedAuctionLifecycleId,
input.clientObservedCurrentBidRoundPlayerUserId,
buildBidRequestPayloadFingerprint(input),
String(input.maximumStoredBidRequestResultCount),
String(input.minimumBidRequestResultReplayWindowMS),
String(input.maximumStoredAuctionBidHistoryCount),
],
};
}
export const AUCTION_BID_SCRIPT = defineAuctionRedisScript(
'auction.bid',
`
local liveAuctionStateKey = KEYS[1]
local auctionBidHistoryKey = KEYS[2]
local bidRequestResultsKey = KEYS[3]
local bidRequestResultOrderKey = KEYS[4]
local bidRoundDeadlineQueueKey = KEYS[5]
local matchId = ARGV[1]
local bidderTeamIndex = ARGV[2]
local bidPointAmount = tonumber(ARGV[3])
local maximumAuctionTeamMemberCount = tonumber(ARGV[4])
local minimumBidPointReservePerRemainingAuctionTeamMemberSlot = tonumber(ARGV[5])
local bidRequestId = ARGV[6]
local bidderUserId = ARGV[7]
local clientObservedAuctionLifecycleId = ARGV[8]
local clientObservedCurrentBidRoundPlayerUserId = ARGV[9]
local bidRequestPayloadFingerprint = ARGV[10]
local maximumStoredBidRequestResultCount = tonumber(ARGV[11])
local minimumBidRequestResultReplayWindowMS = tonumber(ARGV[12])
local maximumStoredAuctionBidHistoryCount = tonumber(ARGV[13])
local redisTime = redis.call('TIME')
local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000)
local function requestField(suffix)
return bidRequestId .. ':' .. suffix
end
local function hdelBidRequest(requestId)
redis.call(
'HDEL',
bidRequestResultsKey,
requestId .. ':fingerprint',
requestId .. ':status',
requestId .. ':revision',
requestId .. ':rejectCode',
requestId .. ':currentHighestBidPointAmount',
requestId .. ':currentHighestBidderTeamIndex',
requestId .. ':currentBidRoundDeadlineTimestampMS',
requestId .. ':auctionBidHistoryEntryJson',
requestId .. ':responseServerTimestampMS',
requestId .. ':createdAtTimestampMS'
)
end
local function trimOldBidRequestResults()
while redis.call('LLEN', bidRequestResultOrderKey) >= maximumStoredBidRequestResultCount do
local oldestBidRequestId = redis.call('LINDEX', bidRequestResultOrderKey, 0)
if not oldestBidRequestId then
return
end
local createdAtTimestampMS = tonumber(redis.call('HGET', bidRequestResultsKey, oldestBidRequestId .. ':createdAtTimestampMS') or '0')
if createdAtTimestampMS > currentRedisTimestampMS - minimumBidRequestResultReplayWindowMS then
return
end
redis.call('LPOP', bidRequestResultOrderKey)
hdelBidRequest(oldestBidRequestId)
end
end
local function replayExistingRequest()
local status = redis.call('HGET', bidRequestResultsKey, requestField('status')) or ''
return {
'REPLAY',
status,
bidRequestId,
redis.call('HGET', bidRequestResultsKey, requestField('revision')) or '',
redis.call('HGET', bidRequestResultsKey, requestField('rejectCode')) or '',
redis.call('HGET', bidRequestResultsKey, requestField('currentHighestBidPointAmount')) or '',
redis.call('HGET', bidRequestResultsKey, requestField('currentHighestBidderTeamIndex')) or '',
redis.call('HGET', bidRequestResultsKey, requestField('currentBidRoundDeadlineTimestampMS')) or '',
redis.call('HGET', bidRequestResultsKey, requestField('auctionBidHistoryEntryJson')) or '',
redis.call('HGET', bidRequestResultsKey, requestField('responseServerTimestampMS')) or tostring(currentRedisTimestampMS)
}
end
local existingFingerprint = redis.call('HGET', bidRequestResultsKey, requestField('fingerprint'))
if existingFingerprint then
if existingFingerprint ~= bidRequestPayloadFingerprint then
return {'REJECTED', 'DUPLICATE_REQUEST_CONFLICT', bidRequestId, tostring(currentRedisTimestampMS)}
end
return replayExistingRequest()
end
trimOldBidRequestResults()
if redis.call('LLEN', bidRequestResultOrderKey) >= maximumStoredBidRequestResultCount then
return {'REJECTED', 'BID_REQUEST_RESULT_LIMIT', bidRequestId, tostring(currentRedisTimestampMS)}
end
local function storeRejectedRequest(rejectCode)
local rejectedCurrentBidRoundDeadlineTimestampMS = redis.call('HGET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS') or ''
redis.call(
'HSET',
bidRequestResultsKey,
requestField('fingerprint'),
bidRequestPayloadFingerprint,
requestField('status'),
'rejected',
requestField('rejectCode'),
rejectCode,
requestField('currentBidRoundDeadlineTimestampMS'),
rejectedCurrentBidRoundDeadlineTimestampMS,
requestField('responseServerTimestampMS'),
tostring(currentRedisTimestampMS),
requestField('createdAtTimestampMS'),
tostring(currentRedisTimestampMS)
)
redis.call('RPUSH', bidRequestResultOrderKey, bidRequestId)
return {'REJECTED', rejectCode, bidRequestId, tostring(currentRedisTimestampMS), rejectedCurrentBidRoundDeadlineTimestampMS}
end
local phase = redis.call('HGET', liveAuctionStateKey, 'phase')
if phase ~= 'bidding' then
return storeRejectedRequest('PHASE')
end
local auctionLifecycleId = redis.call('HGET', liveAuctionStateKey, 'auctionLifecycleId')
local currentBidRoundPlayerUserId = redis.call('HGET', liveAuctionStateKey, 'currentBidRoundPlayerUserId')
if auctionLifecycleId ~= clientObservedAuctionLifecycleId or currentBidRoundPlayerUserId ~= clientObservedCurrentBidRoundPlayerUserId then
return storeRejectedRequest('STALE_BID_ROUND')
end
local currentBidRoundDeadlineTimestampMS = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS') or '0')
if currentBidRoundDeadlineTimestampMS <= currentRedisTimestampMS then
return storeRejectedRequest('EXPIRED')
end
local currentHighestBidPointAmount = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentHighestBidPointAmount') or '0')
if bidPointAmount <= currentHighestBidPointAmount then
return storeRejectedRequest('TOO_LOW')
end
local remainingBidPointAmountField = 'team:' .. bidderTeamIndex .. ':remainingBidPointAmount'
local assignedAuctionTeamMemberCountField = 'team:' .. bidderTeamIndex .. ':assignedAuctionTeamMemberCount'
local remainingBidPointAmountRaw = redis.call('HGET', liveAuctionStateKey, remainingBidPointAmountField)
if not remainingBidPointAmountRaw then
return storeRejectedRequest('UNKNOWN_TEAM')
end
local assignedAuctionTeamMemberCount = tonumber(redis.call('HGET', liveAuctionStateKey, assignedAuctionTeamMemberCountField) or '0')
if assignedAuctionTeamMemberCount >= maximumAuctionTeamMemberCount then
return storeRejectedRequest('FULL')
end
local remainingBidPointAmount = tonumber(remainingBidPointAmountRaw)
local remainingSlotsAfterBid = maximumAuctionTeamMemberCount - assignedAuctionTeamMemberCount - 1
local requiredReserveAfterBid = remainingSlotsAfterBid * minimumBidPointReservePerRemainingAuctionTeamMemberSlot
if bidPointAmount + requiredReserveAfterBid > remainingBidPointAmount then
return storeRejectedRequest('INSUFFICIENT')
end
if redis.call('LLEN', auctionBidHistoryKey) >= maximumStoredAuctionBidHistoryCount then
return storeRejectedRequest('BID_HISTORY_LIMIT')
end
local maximumBidRoundDurationSeconds = tonumber(redis.call('HGET', liveAuctionStateKey, 'maximumBidRoundDurationSeconds') or '0')
local bidRoundExtensionSeconds = tonumber(redis.call('HGET', liveAuctionStateKey, 'bidRoundExtensionSeconds') or '0')
local remainingBidRoundTimeMS = currentBidRoundDeadlineTimestampMS - currentRedisTimestampMS
local nextRemainingBidRoundTimeMS = remainingBidRoundTimeMS
local bidRoundExtensionMS = bidRoundExtensionSeconds * 1000
local maximumBidRoundDurationMS = maximumBidRoundDurationSeconds * 1000
if nextRemainingBidRoundTimeMS < bidRoundExtensionMS then
nextRemainingBidRoundTimeMS = bidRoundExtensionMS
end
if nextRemainingBidRoundTimeMS > maximumBidRoundDurationMS then
nextRemainingBidRoundTimeMS = maximumBidRoundDurationMS
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) ..
'}'
redis.call('RPUSH', auctionBidHistoryKey, auctionBidHistoryEntryJson)
redis.call(
'HSET',
liveAuctionStateKey,
'currentHighestBidPointAmount',
tostring(bidPointAmount),
'currentHighestBidderTeamIndex',
bidderTeamIndex,
'currentBidRoundDeadlineTimestampMS',
tostring(nextBidRoundDeadlineTimestampMS)
)
redis.call('ZADD', bidRoundDeadlineQueueKey, nextBidRoundDeadlineTimestampMS, matchId)
redis.call(
'HSET',
bidRequestResultsKey,
requestField('fingerprint'),
bidRequestPayloadFingerprint,
requestField('status'),
'ok',
requestField('revision'),
tostring(revision),
requestField('currentHighestBidPointAmount'),
tostring(bidPointAmount),
requestField('currentHighestBidderTeamIndex'),
bidderTeamIndex,
requestField('currentBidRoundDeadlineTimestampMS'),
tostring(nextBidRoundDeadlineTimestampMS),
requestField('auctionBidHistoryEntryJson'),
auctionBidHistoryEntryJson,
requestField('responseServerTimestampMS'),
tostring(currentRedisTimestampMS),
requestField('createdAtTimestampMS'),
tostring(currentRedisTimestampMS)
)
redis.call('RPUSH', bidRequestResultOrderKey, bidRequestId)
return {
'OK',
bidRequestId,
tostring(revision),
tostring(currentRedisTimestampMS),
tostring(bidPointAmount),
bidderTeamIndex,
tostring(nextBidRoundDeadlineTimestampMS),
auctionBidHistoryEntryJson
}
`,
);
export const BID_RESULT_HASH_FIELD_SUFFIXES = BID_RESULT_HASH_SUFFIXES;
@@ -0,0 +1 @@
export const AUCTION_REDIS_CLIENT = Symbol('AUCTION_REDIS_CLIENT');
@@ -0,0 +1,38 @@
import { buildAuctionRedisKeys } from './auction-redis.keys';
import {
AUCTION_EXPIRE_PREPARE_SCRIPT,
buildAuctionExpirePrepareScriptInvocation,
} from './auction-redis.expire-prepare';
describe('auction expire prepare redis script contract', () => {
it('builds EXPIRE_PREPARE keys and values', () => {
const invocation = buildAuctionExpirePrepareScriptInvocation(
buildAuctionRedisKeys('match-1'),
{
auctionStateTransitionId: 'expire-1',
bidRoundExpiryRetryDelayMS: 3_000,
matchId: 'match-1',
},
);
expect(invocation.script).toBe(AUCTION_EXPIRE_PREPARE_SCRIPT);
expect(invocation.keys).toEqual([
'auction:match-1:liveAuctionState',
'auction:bidRoundDeadlineQueue',
]);
expect(invocation.values).toEqual(['match-1', 'expire-1', '3000']);
});
it('freezes expiry context with Redis TIME and expiring phase', () => {
expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain("redis.call('TIME')");
expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain("'phase'");
expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain("'expiring'");
expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain(
'bidRoundExpiryRevision',
);
expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain(
'bidRoundExpiryWinningBidderTeamIndex',
);
expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain("'ZADD'");
});
});
@@ -0,0 +1,107 @@
import type { AuctionRedisKeys } from './auction-redis.keys';
import { defineAuctionRedisScript } from './auction-redis.scripts';
export interface AuctionExpirePrepareScriptInput {
auctionStateTransitionId: string;
bidRoundExpiryRetryDelayMS: number;
matchId: string;
}
export interface AuctionExpirePrepareScriptInvocation {
keys: string[];
script: typeof AUCTION_EXPIRE_PREPARE_SCRIPT;
values: string[];
}
export function buildAuctionExpirePrepareScriptInvocation(
keys: AuctionRedisKeys,
input: AuctionExpirePrepareScriptInput,
): AuctionExpirePrepareScriptInvocation {
return {
keys: [keys.liveStateKey, keys.deadlineQueueKey],
script: AUCTION_EXPIRE_PREPARE_SCRIPT,
values: [
input.matchId,
input.auctionStateTransitionId,
String(input.bidRoundExpiryRetryDelayMS),
],
};
}
export const AUCTION_EXPIRE_PREPARE_SCRIPT = defineAuctionRedisScript(
'auction.expirePrepare',
`
local liveAuctionStateKey = KEYS[1]
local bidRoundDeadlineQueueKey = KEYS[2]
local matchId = ARGV[1]
local auctionStateTransitionId = ARGV[2]
local bidRoundExpiryRetryDelayMS = tonumber(ARGV[3])
local redisTime = redis.call('TIME')
local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000)
local phase = redis.call('HGET', liveAuctionStateKey, 'phase')
if phase == 'expiring' then
return {
'REPLAY',
redis.call('HGET', liveAuctionStateKey, 'bidRoundExpiryDecision') or '',
redis.call('HGET', liveAuctionStateKey, 'bidRoundExpiryAuctionStateTransitionId') or '',
redis.call('HGET', liveAuctionStateKey, 'bidRoundExpiryRevision') or '',
tostring(currentRedisTimestampMS)
}
end
if phase ~= 'bidding' then
redis.call('ZREM', bidRoundDeadlineQueueKey, matchId)
return {'NOOP', 'PHASE', tostring(currentRedisTimestampMS)}
end
local currentBidRoundDeadlineTimestampMS = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS') or '0')
if currentBidRoundDeadlineTimestampMS > currentRedisTimestampMS then
return {'NOOP', 'NOT_DUE', tostring(currentRedisTimestampMS)}
end
local currentHighestBidPointAmount = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentHighestBidPointAmount') or '0')
local currentHighestBidderTeamIndex = redis.call('HGET', liveAuctionStateKey, 'currentHighestBidderTeamIndex') or '-1'
local bidRoundExpiryDecision = 'passed'
if currentHighestBidPointAmount > 0 then
bidRoundExpiryDecision = 'sold'
end
local revision = redis.call('HINCRBY', liveAuctionStateKey, 'revision', 1)
redis.call(
'HSET',
liveAuctionStateKey,
'phase',
'expiring',
'bidRoundExpiryDecision',
bidRoundExpiryDecision,
'bidRoundExpiryAuctionStateTransitionId',
auctionStateTransitionId,
'bidRoundExpiryPlayerUserId',
redis.call('HGET', liveAuctionStateKey, 'currentBidRoundPlayerUserId') or '',
'bidRoundExpiryPlayerOrderIndex',
redis.call('HGET', liveAuctionStateKey, 'currentAuctionPlayerOrderIndex') or '',
'bidRoundExpiryWinningBidPointAmount',
tostring(currentHighestBidPointAmount),
'bidRoundExpiryWinningBidderTeamIndex',
currentHighestBidderTeamIndex,
'bidRoundExpiryRevision',
tostring(revision)
)
redis.call(
'ZADD',
bidRoundDeadlineQueueKey,
currentRedisTimestampMS + bidRoundExpiryRetryDelayMS,
matchId
)
return {
'OK',
bidRoundExpiryDecision,
auctionStateTransitionId,
tostring(revision),
tostring(currentRedisTimestampMS)
}
`,
);
@@ -0,0 +1,29 @@
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',
actionRequestResultsKey: 'auction:match-1:auctionActionRequestResults',
appliedTransitionIdsKey: 'auction:match-1:appliedAuctionStateTransitionIds',
bidHistoryKey: 'auction:match-1:auctionBidHistory',
bidRequestResultOrderKey: 'auction:match-1:bidRequestResultOrder',
bidRequestResultsKey: 'auction:match-1:bidRequestResults',
deadlineQueueKey: 'auction:bidRoundDeadlineQueue',
durabilityDeadLetterQueueKey: 'auction:auctionDurabilityDeadLetterQueue',
durabilityPayloadKeyPrefix: 'auction:match-1:durability:',
durabilityRetryQueueKey: 'auction:auctionDurabilityRetryQueue',
liveStateKey: 'auction:match-1:liveAuctionState',
rehydrateLockKey: 'auction:match-1:rehydrateLock',
stateTransitionLockKey: 'auction:match-1:auctionStateTransitionLock',
structureStateKey: 'auction:match-1:auctionStructureState',
});
});
it('builds transition durability payload keys', () => {
const keys = buildAuctionRedisKeys('match-1');
expect(keys.durabilityPayloadKey('transition-1')).toBe(
'auction:match-1:durability:transition-1',
);
});
});
@@ -0,0 +1,47 @@
export const AUCTION_BID_ROUND_DEADLINE_QUEUE_KEY =
'auction:bidRoundDeadlineQueue';
export const AUCTION_DURABILITY_RETRY_QUEUE_KEY =
'auction:auctionDurabilityRetryQueue';
export const AUCTION_DURABILITY_DEAD_LETTER_QUEUE_KEY =
'auction:auctionDurabilityDeadLetterQueue';
export interface AuctionRedisKeys {
actionRequestResultOrderKey: string;
actionRequestResultsKey: string;
appliedTransitionIdsKey: string;
bidHistoryKey: string;
bidRequestResultOrderKey: string;
bidRequestResultsKey: string;
deadlineQueueKey: string;
durabilityDeadLetterQueueKey: string;
durabilityPayloadKey: (auctionStateTransitionId: string) => string;
durabilityPayloadKeyPrefix: string;
durabilityRetryQueueKey: string;
liveStateKey: string;
rehydrateLockKey: string;
stateTransitionLockKey: string;
structureStateKey: string;
}
export function buildAuctionRedisKeys(matchId: string): AuctionRedisKeys {
const prefix = `auction:${matchId}`;
const durabilityPayloadKeyPrefix = `${prefix}:durability:`;
return {
actionRequestResultOrderKey: `${prefix}:auctionActionRequestResultOrder`,
actionRequestResultsKey: `${prefix}:auctionActionRequestResults`,
appliedTransitionIdsKey: `${prefix}:appliedAuctionStateTransitionIds`,
bidHistoryKey: `${prefix}:auctionBidHistory`,
bidRequestResultOrderKey: `${prefix}:bidRequestResultOrder`,
bidRequestResultsKey: `${prefix}:bidRequestResults`,
deadlineQueueKey: AUCTION_BID_ROUND_DEADLINE_QUEUE_KEY,
durabilityDeadLetterQueueKey: AUCTION_DURABILITY_DEAD_LETTER_QUEUE_KEY,
durabilityPayloadKey: (auctionStateTransitionId: string) =>
`${durabilityPayloadKeyPrefix}${auctionStateTransitionId}`,
durabilityPayloadKeyPrefix,
durabilityRetryQueueKey: AUCTION_DURABILITY_RETRY_QUEUE_KEY,
liveStateKey: `${prefix}:liveAuctionState`,
rehydrateLockKey: `${prefix}:rehydrateLock`,
stateTransitionLockKey: `${prefix}:auctionStateTransitionLock`,
structureStateKey: `${prefix}:auctionStructureState`,
};
}
@@ -0,0 +1,100 @@
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 { AUCTION_REDIS_CLIENT } from './auction-redis.constants';
import {
AuctionRedisService,
type AuctionRedisClient,
} from './auction-redis.service';
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: [
{
provide: AUCTION_REDIS_CLIENT,
inject: [SecretService],
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) => {
logger.error(
`Auction Redis client error: ${error?.message ?? error}`,
);
});
await client.connect();
logger.log('Auction Redis connected');
return client;
},
},
AuctionRedisService,
AuctionRedisCommandService,
AuctionRedisStateReaderService,
],
exports: [
AuctionRedisService,
AuctionRedisCommandService,
AuctionRedisStateReaderService,
AUCTION_REDIS_CLIENT,
],
})
export class AuctionRedisModule {}
@@ -0,0 +1,77 @@
import { buildAuctionRedisKeys } from './auction-redis.keys';
import {
AUCTION_RESERVE_ACTION_REQUEST_SCRIPT,
buildActionRequestPayloadFingerprint,
buildAuctionReserveActionRequestScriptInvocation,
} from './auction-redis.reserve-action';
describe('auction reserve action request redis script contract', () => {
it('builds RESERVE_AUCTION_ACTION_REQUEST keys and values', () => {
const invocation = buildAuctionReserveActionRequestScriptInvocation(
buildAuctionRedisKeys('match-1'),
{
auctionActionRequestId: 'request-1',
auctionActionType: 'sold',
auctionStateTransitionId: 'transition-1',
clientObservedAuctionLifecycleId: 'life-1',
clientObservedPhase: 'bidding',
clientObservedRevision: 8,
leaseDurationMS: 10_000,
maximumStoredAuctionActionRequestResultCount: 100,
minimumAuctionActionRequestResultReplayWindowMS: 60_000,
newAuctionLifecycleId: undefined,
processingOwnerToken: 'owner-1',
},
);
expect(invocation.script).toBe(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT);
expect(invocation.keys).toEqual([
'auction:match-1:auctionActionRequestResults',
'auction:match-1:auctionActionRequestResultOrder',
]);
expect(invocation.values).toEqual([
'life-1',
'request-1',
'sold',
'transition-1',
'',
'owner-1',
'10000',
'100',
'60000',
'life-1|request-1|sold|8|bidding||',
]);
});
it('builds stable action request fingerprints', () => {
expect(
buildActionRequestPayloadFingerprint({
auctionActionRequestId: 'request-1',
auctionActionType: 'next',
clientObservedAuctionLifecycleId: 'life-1',
clientObservedCurrentAuctionPlayerOrderIndex: 3,
clientObservedCurrentBidRoundPlayerUserId: 'player-1',
clientObservedPhase: 'sold',
clientObservedRevision: 9,
}),
).toBe('life-1|request-1|next|9|sold|player-1|3');
});
it('keeps lease version and replay guards in Lua', () => {
expect(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT.lua).toContain(
"redis.call('TIME')",
);
expect(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT.lua).toContain(
'processingLeaseVersion',
);
expect(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT.lua).toContain(
'ACTION_REQUEST_IN_PROGRESS',
);
expect(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT.lua).toContain(
'ACTION_REQUEST_RESULT_LIMIT',
);
expect(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT.lua).toContain(
'DUPLICATE_ACTION_REQUEST_CONFLICT',
);
});
});
@@ -0,0 +1,233 @@
import type { AuctionRedisKeys } from './auction-redis.keys';
import { defineAuctionRedisScript } from './auction-redis.scripts';
export interface AuctionReserveActionRequestScriptInput {
auctionActionRequestId: string;
auctionActionType: string;
auctionStateTransitionId: string;
clientObservedAuctionLifecycleId: string;
clientObservedCurrentAuctionPlayerOrderIndex?: number;
clientObservedCurrentBidRoundPlayerUserId?: string;
clientObservedPhase: string;
clientObservedRevision: number;
leaseDurationMS: number;
maximumStoredAuctionActionRequestResultCount: number;
minimumAuctionActionRequestResultReplayWindowMS: number;
newAuctionLifecycleId?: string;
processingOwnerToken: string;
}
export interface AuctionReserveActionRequestScriptInvocation {
keys: string[];
script: typeof AUCTION_RESERVE_ACTION_REQUEST_SCRIPT;
values: string[];
}
export function buildActionRequestPayloadFingerprint(params: {
auctionActionRequestId: string;
auctionActionType: string;
clientObservedAuctionLifecycleId: string;
clientObservedCurrentAuctionPlayerOrderIndex?: number;
clientObservedCurrentBidRoundPlayerUserId?: string;
clientObservedPhase: string;
clientObservedRevision: number;
}): string {
return [
params.clientObservedAuctionLifecycleId,
params.auctionActionRequestId,
params.auctionActionType,
params.clientObservedRevision,
params.clientObservedPhase,
params.clientObservedCurrentBidRoundPlayerUserId ?? '',
params.clientObservedCurrentAuctionPlayerOrderIndex ?? '',
].join('|');
}
export function buildAuctionReserveActionRequestScriptInvocation(
keys: AuctionRedisKeys,
input: AuctionReserveActionRequestScriptInput,
): AuctionReserveActionRequestScriptInvocation {
return {
keys: [keys.actionRequestResultsKey, keys.actionRequestResultOrderKey],
script: AUCTION_RESERVE_ACTION_REQUEST_SCRIPT,
values: [
input.clientObservedAuctionLifecycleId,
input.auctionActionRequestId,
input.auctionActionType,
input.auctionStateTransitionId,
input.newAuctionLifecycleId ?? '',
input.processingOwnerToken,
String(input.leaseDurationMS),
String(input.maximumStoredAuctionActionRequestResultCount),
String(input.minimumAuctionActionRequestResultReplayWindowMS),
buildActionRequestPayloadFingerprint(input),
],
};
}
export const AUCTION_RESERVE_ACTION_REQUEST_SCRIPT = defineAuctionRedisScript(
'auction.reserveActionRequest',
`
local auctionActionRequestResultsKey = KEYS[1]
local auctionActionRequestResultOrderKey = KEYS[2]
local clientObservedAuctionLifecycleId = ARGV[1]
local auctionActionRequestId = ARGV[2]
local auctionActionType = ARGV[3]
local auctionStateTransitionId = ARGV[4]
local newAuctionLifecycleId = ARGV[5]
local processingOwnerToken = ARGV[6]
local leaseDurationMS = tonumber(ARGV[7])
local maximumStoredAuctionActionRequestResultCount = tonumber(ARGV[8])
local minimumAuctionActionRequestResultReplayWindowMS = tonumber(ARGV[9])
local actionRequestPayloadFingerprint = ARGV[10]
local redisTime = redis.call('TIME')
local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000)
local actionRequestScopeKey = clientObservedAuctionLifecycleId .. ':' .. auctionActionRequestId
local function requestField(suffix)
return actionRequestScopeKey .. ':' .. suffix
end
local function hdelActionRequest(scopeKey)
redis.call(
'HDEL',
auctionActionRequestResultsKey,
scopeKey .. ':fingerprint',
scopeKey .. ':status',
scopeKey .. ':revision',
scopeKey .. ':rejectCode',
scopeKey .. ':auctionActionType',
scopeKey .. ':auctionStateTransitionId',
scopeKey .. ':newAuctionLifecycleId',
scopeKey .. ':processingOwnerToken',
scopeKey .. ':processingLeaseExpiresAtTimestampMS',
scopeKey .. ':processingLeaseVersion',
scopeKey .. ':responseServerTimestampMS',
scopeKey .. ':responseJson',
scopeKey .. ':requiresRefetch',
scopeKey .. ':createdAtTimestampMS'
)
end
local function trimOldActionRequestResults()
while redis.call('LLEN', auctionActionRequestResultOrderKey) >= maximumStoredAuctionActionRequestResultCount do
local oldestActionRequestScopeKey = redis.call('LINDEX', auctionActionRequestResultOrderKey, 0)
if not oldestActionRequestScopeKey then
return
end
local createdAtTimestampMS = tonumber(redis.call('HGET', auctionActionRequestResultsKey, oldestActionRequestScopeKey .. ':createdAtTimestampMS') or '0')
if createdAtTimestampMS > currentRedisTimestampMS - minimumAuctionActionRequestResultReplayWindowMS then
return
end
redis.call('LPOP', auctionActionRequestResultOrderKey)
hdelActionRequest(oldestActionRequestScopeKey)
end
end
local existingFingerprint = redis.call('HGET', auctionActionRequestResultsKey, requestField('fingerprint'))
if existingFingerprint then
if existingFingerprint ~= actionRequestPayloadFingerprint then
return {'REJECTED', 'DUPLICATE_ACTION_REQUEST_CONFLICT', actionRequestScopeKey, tostring(currentRedisTimestampMS)}
end
local status = redis.call('HGET', auctionActionRequestResultsKey, requestField('status')) or ''
if status == 'applied' or status == 'rejected' then
return {
'REPLAY',
status,
actionRequestScopeKey,
redis.call('HGET', auctionActionRequestResultsKey, requestField('revision')) or '',
redis.call('HGET', auctionActionRequestResultsKey, requestField('rejectCode')) or '',
redis.call('HGET', auctionActionRequestResultsKey, requestField('auctionStateTransitionId')) or '',
redis.call('HGET', auctionActionRequestResultsKey, requestField('newAuctionLifecycleId')) or '',
redis.call('HGET', auctionActionRequestResultsKey, requestField('processingLeaseVersion')) or '',
redis.call('HGET', auctionActionRequestResultsKey, requestField('responseServerTimestampMS')) or tostring(currentRedisTimestampMS),
redis.call('HGET', auctionActionRequestResultsKey, requestField('responseJson')) or '',
redis.call('HGET', auctionActionRequestResultsKey, requestField('requiresRefetch')) or ''
}
end
local leaseExpiresAtTimestampMS = tonumber(redis.call('HGET', auctionActionRequestResultsKey, requestField('processingLeaseExpiresAtTimestampMS')) or '0')
local storedOwnerToken = redis.call('HGET', auctionActionRequestResultsKey, requestField('processingOwnerToken')) or ''
local storedLeaseVersion = tonumber(redis.call('HGET', auctionActionRequestResultsKey, requestField('processingLeaseVersion')) or '1')
if leaseExpiresAtTimestampMS > currentRedisTimestampMS and storedOwnerToken ~= processingOwnerToken then
return {'REJECTED', 'ACTION_REQUEST_IN_PROGRESS', actionRequestScopeKey, tostring(currentRedisTimestampMS)}
end
local nextLeaseVersion = storedLeaseVersion
local wasLeaseExpired = '0'
if leaseExpiresAtTimestampMS <= currentRedisTimestampMS then
nextLeaseVersion = storedLeaseVersion + 1
wasLeaseExpired = '1'
end
redis.call(
'HSET',
auctionActionRequestResultsKey,
requestField('status'),
'processing',
requestField('processingOwnerToken'),
processingOwnerToken,
requestField('processingLeaseExpiresAtTimestampMS'),
tostring(currentRedisTimestampMS + leaseDurationMS),
requestField('processingLeaseVersion'),
tostring(nextLeaseVersion),
requestField('responseServerTimestampMS'),
tostring(currentRedisTimestampMS)
)
return {
'RESERVED',
actionRequestScopeKey,
redis.call('HGET', auctionActionRequestResultsKey, requestField('auctionStateTransitionId')) or auctionStateTransitionId,
redis.call('HGET', auctionActionRequestResultsKey, requestField('newAuctionLifecycleId')) or '',
tostring(nextLeaseVersion),
wasLeaseExpired,
tostring(currentRedisTimestampMS)
}
end
trimOldActionRequestResults()
if redis.call('LLEN', auctionActionRequestResultOrderKey) >= maximumStoredAuctionActionRequestResultCount then
return {'REJECTED', 'ACTION_REQUEST_RESULT_LIMIT', actionRequestScopeKey, tostring(currentRedisTimestampMS)}
end
redis.call(
'HSET',
auctionActionRequestResultsKey,
requestField('fingerprint'),
actionRequestPayloadFingerprint,
requestField('status'),
'processing',
requestField('auctionActionType'),
auctionActionType,
requestField('auctionStateTransitionId'),
auctionStateTransitionId,
requestField('newAuctionLifecycleId'),
newAuctionLifecycleId,
requestField('processingOwnerToken'),
processingOwnerToken,
requestField('processingLeaseExpiresAtTimestampMS'),
tostring(currentRedisTimestampMS + leaseDurationMS),
requestField('processingLeaseVersion'),
'1',
requestField('responseServerTimestampMS'),
tostring(currentRedisTimestampMS),
requestField('createdAtTimestampMS'),
tostring(currentRedisTimestampMS)
)
redis.call('RPUSH', auctionActionRequestResultOrderKey, actionRequestScopeKey)
return {
'RESERVED',
actionRequestScopeKey,
auctionStateTransitionId,
newAuctionLifecycleId,
'1',
'0',
tostring(currentRedisTimestampMS)
}
`,
);
@@ -0,0 +1,14 @@
import { createHash } from 'crypto';
import { defineAuctionRedisScript } from './auction-redis.scripts';
describe('auction redis scripts', () => {
it('stores normalized Lua and its SHA1', () => {
const script = defineAuctionRedisScript('test', 'return 1\n');
expect(script).toEqual({
lua: 'return 1\n',
name: 'test',
sha: createHash('sha1').update('return 1\n').digest('hex'),
});
});
});
@@ -0,0 +1,18 @@
import { createHash } from 'crypto';
export interface AuctionRedisScriptDefinition {
lua: string;
name: string;
sha: string;
}
export function defineAuctionRedisScript(
name: string,
lua: string,
): AuctionRedisScriptDefinition {
return {
lua,
name,
sha: createHash('sha1').update(lua).digest('hex'),
};
}
@@ -0,0 +1,64 @@
import {
AuctionRedisNoscriptError,
AuctionRedisService,
} from './auction-redis.service';
function makeService(sendCommand: jest.Mock) {
const client = {
destroy: jest.fn(),
quit: jest.fn().mockResolvedValue(undefined),
sendCommand,
};
return new AuctionRedisService(client as never);
}
describe('AuctionRedisService', () => {
it('uses Redis TIME as the timestamp source', async () => {
const service = makeService(jest.fn().mockResolvedValue(['1781700000', '123000']));
await expect(service.getCurrentRedisTimestampMS()).resolves.toBe(
1_781_700_000_123,
);
});
it('loads and retries a script once when EVALSHA returns NOSCRIPT', async () => {
const sendCommand = jest
.fn()
.mockRejectedValueOnce(new AuctionRedisNoscriptError())
.mockResolvedValueOnce('sha-from-redis')
.mockResolvedValueOnce(['ok']);
const service = makeService(sendCommand);
await expect(
service.evalShaWithReload({
keys: ['auction:state:1'],
script: 'return 1',
scriptSha: 'old-sha',
values: ['v1'],
}),
).resolves.toEqual(['ok']);
expect(sendCommand.mock.calls).toEqual([
[['EVALSHA', 'old-sha', '1', 'auction:state:1', 'v1']],
[['SCRIPT', 'LOAD', 'return 1']],
[['EVALSHA', 'sha-from-redis', '1', 'auction:state:1', 'v1']],
]);
});
it('does not reload scripts for non-NOSCRIPT errors', async () => {
const error = new Error('OOM command not allowed');
const sendCommand = jest.fn().mockRejectedValue(error);
const service = makeService(sendCommand);
await expect(
service.evalShaWithReload({
keys: [],
script: 'return 1',
scriptSha: 'sha',
values: [],
}),
).rejects.toBe(error);
expect(sendCommand).toHaveBeenCalledTimes(1);
});
});
@@ -0,0 +1,131 @@
import { Inject, Injectable, OnModuleDestroy } from '@nestjs/common';
import type { createClient } from 'redis';
import { AUCTION_REDIS_CLIENT } from './auction-redis.constants';
import type { AuctionRedisScriptDefinition } from './auction-redis.scripts';
export type AuctionRedisClient = ReturnType<typeof createClient>;
export interface EvalShaWithReloadParams {
keys: string[];
script: string;
scriptSha: string;
values: string[];
}
export class AuctionRedisNoscriptError extends Error {
constructor(message = 'NOSCRIPT No matching script. Please use EVAL.') {
super(message);
this.name = 'AuctionRedisNoscriptError';
}
}
function isNoscriptError(error: unknown): boolean {
if (error instanceof AuctionRedisNoscriptError) return true;
const message =
error instanceof Error ? error.message : typeof error === 'string' ? error : '';
return /\bNOSCRIPT\b/iu.test(message);
}
function buildEvalShaCommand(
scriptSha: string,
keys: string[],
values: string[],
): string[] {
return ['EVALSHA', scriptSha, String(keys.length), ...keys, ...values];
}
function parseRedisTimeReply(reply: unknown): number {
if (Array.isArray(reply) && reply.length >= 2) {
const seconds = Number(reply[0]);
const microseconds = Number(reply[1]);
if (Number.isFinite(seconds) && Number.isFinite(microseconds)) {
return seconds * 1000 + Math.floor(microseconds / 1000);
}
}
throw new Error(`Unexpected Redis TIME reply: ${JSON.stringify(reply)}`);
}
@Injectable()
export class AuctionRedisService implements OnModuleDestroy {
constructor(
@Inject(AUCTION_REDIS_CLIENT)
private readonly client: AuctionRedisClient,
) {}
async onModuleDestroy() {
try {
await this.client.quit();
} catch {
this.client.destroy();
}
}
public raw(): AuctionRedisClient {
return this.client;
}
public async getCurrentRedisTimestampMS(): Promise<number> {
const reply = await this.client.sendCommand(['TIME']);
return parseRedisTimeReply(reply);
}
public async evalShaWithReload<T = unknown>(
params: EvalShaWithReloadParams,
): Promise<T> {
try {
return (await this.client.sendCommand(
buildEvalShaCommand(params.scriptSha, params.keys, params.values),
)) as T;
} catch (error) {
if (!isNoscriptError(error)) throw error;
}
const loadedSha = String(
await this.client.sendCommand(['SCRIPT', 'LOAD', params.script]),
);
return (await this.client.sendCommand(
buildEvalShaCommand(loadedSha, params.keys, params.values),
)) as T;
}
public async evalScript<T = unknown>(
script: AuctionRedisScriptDefinition,
keys: string[],
values: string[],
): Promise<T> {
return this.evalShaWithReload<T>({
keys,
script: script.lua,
scriptSha: script.sha,
values,
});
}
public async acquireTokenLock(
key: string,
token: string,
ttlMS: number,
): Promise<boolean> {
const result = await this.client.sendCommand([
'SET',
key,
token,
'PX',
String(ttlMS),
'NX',
]);
return String(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,
]);
return Number(result) === 1;
}
}
@@ -0,0 +1,111 @@
import { buildAuctionRedisKeys } from './auction-redis.keys';
import {
AUCTION_HYDRATE_STATE_SCRIPT,
assembleAuctionViewFromRedisState,
buildHydrateAuctionStateScriptInvocation,
shouldHydrateRedisAuctionState,
} from './auction-redis.state';
describe('auction redis state assembly', () => {
it.each([
{
expected: true,
live: null,
mongo: { auctionLifecycleId: 'life-1', revision: 1 },
},
{
expected: true,
live: { auctionLifecycleId: 'life-1', revision: 1 },
mongo: { auctionLifecycleId: 'life-1', revision: 2 },
},
{
expected: true,
live: { auctionLifecycleId: 'old-life', revision: 2 },
mongo: { auctionLifecycleId: 'new-life', revision: 2 },
},
{
expected: false,
live: { auctionLifecycleId: 'redis-life', revision: 3 },
mongo: { auctionLifecycleId: 'mongo-life', revision: 2 },
},
])('decides rehydrate need: %#', ({ live, mongo, expected }) => {
expect(shouldHydrateRedisAuctionState({ live, mongo })).toBe(expected);
});
it('assembles public view and maps internal expiring phase to bidding', () => {
expect(
assembleAuctionViewFromRedisState({
auctionBidHistoryEntries: ['{"bidPointAmount":100}'],
currentServerTimestampMS: 1_000,
liveState: {
auctionLifecycleId: 'life-1',
currentBidRoundPlayerUserId: 'player-1',
phase: 'expiring',
revision: 3,
},
shouldForceAuctionStateResync: true,
structureState: {
auctionTeams: [],
},
}),
).toMatchObject({
auctionBidHistory: [{ bidPointAmount: 100 }],
auctionLifecycleId: 'life-1',
canPlaceBidInCurrentBidRound: false,
currentBidRoundPlayerUserId: 'player-1',
currentServerTimestampMS: 1000,
isAuctionStateTransitionInProgress: true,
phase: 'bidding',
revision: 3,
shouldForceAuctionStateResync: true,
});
});
it('builds HYDRATE invocation and keeps CAS conditions in Lua', () => {
const invocation = buildHydrateAuctionStateScriptInvocation(
buildAuctionRedisKeys('match-1'),
{
auctionHistorySequence: 4,
auctionLifecycleId: 'life-1',
liveStatePatch: {
'team:1:assignedAuctionTeamMemberCount': 1,
'team:1:remainingBidPointAmount': 1000,
},
maximumBidRoundDurationSeconds: 30,
matchId: 'match-1',
phase: 'bidding',
revision: 7,
structureStateJson: '{"auctionTeams":[]}',
},
);
expect(invocation.script).toBe(AUCTION_HYDRATE_STATE_SCRIPT);
expect(invocation.keys).toEqual([
'auction:match-1:liveAuctionState',
'auction:match-1:auctionStructureState',
'auction:bidRoundDeadlineQueue',
]);
expect(invocation.values).toEqual([
'match-1',
'life-1',
'7',
'bidding',
'4',
'30',
'{"auctionTeams":[]}',
'2',
'team:1:assignedAuctionTeamMemberCount',
'1',
'team:1:remainingBidPointAmount',
'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(
'mongoRevision > redisRevision',
);
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain("redis.call('ZADD'");
});
});
@@ -0,0 +1,188 @@
import type { AuctionRedisKeys } from './auction-redis.keys';
import { defineAuctionRedisScript } from './auction-redis.scripts';
export interface AuctionRedisRevisionIdentity {
auctionLifecycleId?: string;
revision?: number;
}
export interface ShouldHydrateRedisAuctionStateParams {
live: AuctionRedisRevisionIdentity | null;
mongo: Required<AuctionRedisRevisionIdentity>;
}
export interface AssembleAuctionViewParams {
auctionBidHistoryEntries: string[];
currentServerTimestampMS: number;
liveState: Record<string, unknown> & {
auctionLifecycleId: string;
phase: string;
revision: number;
};
shouldForceAuctionStateResync?: boolean;
structureState: Record<string, unknown>;
}
export interface HydrateAuctionStateScriptInput {
auctionHistorySequence: number;
auctionLifecycleId: string;
liveStatePatch?: Record<string, string | number | boolean | null | undefined>;
maximumBidRoundDurationSeconds: number;
matchId: string;
phase: string;
revision: number;
structureStateJson: string;
}
export interface HydrateAuctionStateScriptInvocation {
keys: string[];
script: typeof AUCTION_HYDRATE_STATE_SCRIPT;
values: string[];
}
function stringifyRedisValue(value: string | number | boolean | null): string {
if (typeof value === 'boolean') return value ? '1' : '0';
if (value === null) return '';
return String(value);
}
function flattenLiveStatePatch(
liveStatePatch: HydrateAuctionStateScriptInput['liveStatePatch'],
): string[] {
return Object.entries(liveStatePatch ?? {})
.filter(([, value]) => value !== undefined)
.sort(([a], [b]) => a.localeCompare(b))
.flatMap(([key, value]) => [
key,
stringifyRedisValue(value as string | number | boolean | null),
]);
}
export function shouldHydrateRedisAuctionState(
params: ShouldHydrateRedisAuctionStateParams,
): boolean {
if (!params.live) 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
);
}
export function assembleAuctionViewFromRedisState(
params: AssembleAuctionViewParams,
): Record<string, unknown> {
const isExpiring = params.liveState.phase === 'expiring';
return {
...params.structureState,
...params.liveState,
auctionBidHistory: params.auctionBidHistoryEntries.map((entry) =>
JSON.parse(entry),
),
canPlaceBidInCurrentBidRound: !isExpiring,
currentServerTimestampMS: params.currentServerTimestampMS,
isAuctionStateTransitionInProgress: isExpiring,
phase: isExpiring ? 'bidding' : params.liveState.phase,
shouldForceAuctionStateResync:
params.shouldForceAuctionStateResync || undefined,
};
}
export function buildHydrateAuctionStateScriptInvocation(
keys: AuctionRedisKeys,
input: HydrateAuctionStateScriptInput,
): HydrateAuctionStateScriptInvocation {
const liveStatePatchPairs = flattenLiveStatePatch(input.liveStatePatch);
return {
keys: [keys.liveStateKey, keys.structureStateKey, keys.deadlineQueueKey],
script: AUCTION_HYDRATE_STATE_SCRIPT,
values: [
input.matchId,
input.auctionLifecycleId,
String(input.revision),
input.phase,
String(input.auctionHistorySequence),
String(input.maximumBidRoundDurationSeconds),
input.structureStateJson,
String(liveStatePatchPairs.length / 2),
...liveStatePatchPairs,
],
};
}
export const AUCTION_HYDRATE_STATE_SCRIPT = defineAuctionRedisScript(
'auction.hydrateState',
`
local liveAuctionStateKey = KEYS[1]
local auctionStructureStateKey = KEYS[2]
local bidRoundDeadlineQueueKey = KEYS[3]
local matchId = ARGV[1]
local mongoAuctionLifecycleId = ARGV[2]
local mongoRevision = tonumber(ARGV[3])
local phase = ARGV[4]
local auctionHistorySequence = ARGV[5]
local maximumBidRoundDurationSeconds = tonumber(ARGV[6])
local structureStateJson = ARGV[7]
local liveStatePatchPairCount = tonumber(ARGV[8])
local redisTime = redis.call('TIME')
local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000)
local redisRevision = tonumber(redis.call('HGET', liveAuctionStateKey, 'revision') or '-1')
local redisAuctionLifecycleId = redis.call('HGET', liveAuctionStateKey, 'auctionLifecycleId')
if not liveStatePatchPairCount or #ARGV ~= 8 + (liveStatePatchPairCount * 2) then
return {'REJECTED', 'INVALID_PATCH_ARITY', 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
return {'NOOP', tostring(redisRevision), tostring(currentRedisTimestampMS)}
end
local hydratedRevision = mongoRevision + 1
redis.call('SET', auctionStructureStateKey, structureStateJson)
local hsetArgs = {
liveAuctionStateKey,
'auctionLifecycleId',
mongoAuctionLifecycleId,
'revision',
tostring(hydratedRevision),
'phase',
phase,
'currentAuctionHistorySequence',
auctionHistorySequence,
'currentHighestBidPointAmount',
'0',
'currentHighestBidderTeamIndex',
'-1'
}
local patchIndex = 9
for i = 1, liveStatePatchPairCount do
table.insert(hsetArgs, ARGV[patchIndex])
table.insert(hsetArgs, ARGV[patchIndex + 1])
patchIndex = patchIndex + 2
end
redis.call('HSET', unpack(hsetArgs))
if phase == 'bidding' then
local currentBidRoundDeadlineTimestampMS = currentRedisTimestampMS + (maximumBidRoundDurationSeconds * 1000)
redis.call('HSET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS', tostring(currentBidRoundDeadlineTimestampMS))
redis.call('ZADD', bidRoundDeadlineQueueKey, currentBidRoundDeadlineTimestampMS, matchId)
else
redis.call('ZREM', bidRoundDeadlineQueueKey, matchId)
end
return {'OK', tostring(hydratedRevision), tostring(currentRedisTimestampMS)}
`,
);
@@ -1,5 +1,5 @@
import { Injectable, Logger } from '@nestjs/common';
import { GarnetService } from '../global/garnet/garnet.service';
import { RedisService } from '../global/redis/redis.service';
const COMMUNITY_STATS_TTL_SECONDS = 5 * 60;
const COMMUNITY_STATS_DETAIL_TTL_SECONDS = 24 * 60 * 60;
@@ -8,10 +8,10 @@ const COMMUNITY_STATS_DETAIL_TTL_SECONDS = 24 * 60 * 60;
export class CommunityStatsCacheService {
private readonly logger = new Logger(CommunityStatsCacheService.name);
constructor(private readonly garnetService: GarnetService) {}
constructor(private readonly redisService: RedisService) {}
public get<T>(key: string): Promise<T | null> {
return this.garnetService.getJson<T>(key);
return this.redisService.getJson<T>(key);
}
public set(
@@ -19,7 +19,7 @@ export class CommunityStatsCacheService {
value: unknown,
ttlSeconds = COMMUNITY_STATS_TTL_SECONDS,
): Promise<void> {
return this.garnetService.setJson(key, value, ttlSeconds);
return this.redisService.setJson(key, value, ttlSeconds);
}
public setDetail(key: string, value: unknown): Promise<void> {
@@ -29,7 +29,7 @@ export class CommunityStatsCacheService {
public async invalidateCommunity(communityId: string): Promise<number> {
const prefix = `riot:communitystats:`;
const match = `${prefix}*${communityId}*`;
const client = this.garnetService.raw();
const client = this.redisService.raw();
let cursor = '0';
let deleted = 0;
@@ -1,4 +1,5 @@
import { Module } from '@nestjs/common';
import { RiotModule } from '../riot/riot.module';
import { CommunityStatsCacheService } from './community-stats-cache.service';
import { CommunityStatsController } from './community-stats.controller';
import { CommunityStatsService } from './community-stats.service';
@@ -7,6 +8,7 @@ import { MatchStatsRepository } from './match-stats.repository';
import { MatchStatsService } from './match-stats.service';
@Module({
imports: [RiotModule],
controllers: [CommunityStatsController],
providers: [
CommunityStatsService,
@@ -0,0 +1,244 @@
import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service';
import { CommunityStatsCacheService } from './community-stats-cache.service';
import { CommunityStatsService } from './community-stats.service';
import type {
InternalMatchCardView,
InternalMatchDetailResponse,
} from './community-stats.types';
import { MatchStatsRepository } from './match-stats.repository';
import { MatchStatsService } from './match-stats.service';
import type { InternalGameDetail, InternalRecord } from './match-stats.types';
function objectives() {
return {
tower: 1,
dragon: 0,
inhibitor: 0,
baron: 0,
riftHerald: 0,
voidGrub: 0,
elderDragon: 0,
};
}
function record(matchId: mongoose.Types.ObjectId): InternalRecord {
return {
matchId: matchId.toString(),
title: '내전',
scheduledAt: new Date('2026-06-18T12:00:00.000Z'),
gameNumber: 1,
riotMatchId: 'KR_1',
gameCreation: 1_000,
gameDuration: 1_800,
userId: new mongoose.Types.ObjectId().toString(),
summonerName: 'Player',
tagLine: 'KR1',
profileIconId: 1,
teamIndex: 1,
side: 'blue',
championId: 266,
championLevel: 15,
teamPosition: 'TOP',
kills: 5,
deaths: 1,
assists: 7,
win: true,
cs: 200,
csPerMin: 6.7,
gold: 12_000,
gpm: 400,
damageDealtToChampions: 18_000,
damageTaken: 20_000,
damageShare: 30,
killParticipation: 60,
visionScore: 18,
controlWardsBought: 1,
wardsPlaced: 8,
wardsKilled: 2,
firstBloodKill: false,
firstBloodAssist: false,
items: [1054, 3071, 0, 0, 0, 0],
trinket: 3340,
summonerSpells: [4, 12],
perks: {
primaryStyle: 8000,
subStyle: 8400,
keystone: 8010,
selectedPerkIds: [8010, 9111, 9105, 8299, 8444, 8451],
styles: [
{ styleId: 8000, perkIds: [8010, 9111, 9105, 8299] },
{ styleId: 8400, perkIds: [8444, 8451] },
],
statPerks: { defense: 5001, flex: 5008, offense: 5005 },
},
itemBuild: [{ timestamp: 10, itemId: 1054, type: 'purchased' }],
skillBuild: [{ timestamp: 11, skillSlot: 1, level: 1 }],
rating: 8.5,
};
}
describe('CommunityStatsService', () => {
it('ignores stale detail cache entries missing timeline build fields', 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: true,
timeline: [
{
timestamp: 0,
blue: { gold: 500, xp: 0 },
red: { gold: 500, xp: 0 },
goldDiff: 0,
xpDiff: 0,
},
],
objectiveEvents: [],
teams: [
{
teamIndex: 1,
side: 'blue',
win: true,
objectives: objectives(),
bans: [],
participants: [participant],
},
],
};
const staleCache = {
match,
games: [
{
gameNumber: 1,
riotMatchId: 'KR_1',
gameCreation: 1_000,
gameDuration: 1_800,
teams: [
{
teamIndex: 1,
side: 'blue',
win: true,
objectives: { tower: 1, dragon: 0, baron: 0 },
participants: [
{
summonerName: 'Player',
perks: {
primaryStyle: 8000,
subStyle: 8400,
keystone: 8010,
},
},
],
},
],
},
],
} as unknown as InternalMatchDetailResponse;
const cacheService = {
get: jest.fn().mockResolvedValue(staleCache),
setDetail: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<CommunityStatsCacheService>;
const matchStatsService = {
buildAndUpsert: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<MatchStatsService>;
const service = new CommunityStatsService(
{} as ConnectionService,
cacheService,
{} as MatchStatsRepository,
matchStatsService,
);
(service as unknown as { buildBaseDataset: jest.Mock }).buildBaseDataset =
jest.fn().mockResolvedValue({
season: {
id: 'all',
label: '전체',
startTime: null,
endTime: null,
},
matches: [match],
records: [participant],
detailsByMatchId: new Map([[matchId.toString(), [gameDetail]]]),
});
const response = 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(matchStatsService.buildAndUpsert).not.toHaveBeenCalled();
expect(cacheService.setDetail).toHaveBeenCalledWith(
expect.stringContaining(':r3:'),
response,
);
});
it('includes internal match route fields in user internal history matches', async () => {
const communityId = new mongoose.Types.ObjectId();
const matchId = new mongoose.Types.ObjectId();
const userId = new mongoose.Types.ObjectId();
const participant = record(matchId);
participant.userId = userId.toString();
participant.gameNumber = 2;
participant.riotMatchId = 'KR_1234';
const cacheService = {
get: jest.fn().mockResolvedValue(null),
set: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<CommunityStatsCacheService>;
const service = new CommunityStatsService(
{} as ConnectionService,
cacheService,
{} as MatchStatsRepository,
{} as MatchStatsService,
);
(service as unknown as { buildBaseDataset: jest.Mock }).buildBaseDataset =
jest.fn().mockResolvedValue({
season: {
id: 'all',
label: '전체',
startTime: null,
endTime: null,
},
matches: [],
records: [participant],
detailsByMatchId: new Map(),
});
const response = await service.getUserInternalHistory({
communityId,
userId,
filters: { limit: 5 },
});
expect(response.matches[0]).toMatchObject({
matchId: 'KR_1234',
internalMatchId: matchId.toString(),
gameNumber: 2,
queueLabel: '내전',
});
expect(cacheService.set).toHaveBeenCalledWith(
expect.stringContaining(`userInternal:v2:${userId.toString()}`),
response,
);
});
});
@@ -36,6 +36,7 @@ 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;
interface CommunityStatsContext {
community: CommunityDocument;
@@ -205,10 +206,10 @@ export class CommunityStatsService {
communityId: mongoose.Types.ObjectId;
matchId: mongoose.Types.ObjectId;
}): Promise<InternalMatchDetailResponse> {
const key = `riot:communitystats:matchDetail:${params.communityId.toString()}:${params.matchId.toString()}`;
const key = `riot:communitystats:matchDetail:v${MATCH_STATS_BUILDER_VERSION}:r${MATCH_DETAIL_RESPONSE_CACHE_VERSION}:${params.communityId.toString()}:${params.matchId.toString()}`;
const cached =
await this.cacheService.get<InternalMatchDetailResponse>(key);
if (cached) return cached;
if (cached && isCompleteMatchDetailResponse(cached)) return cached;
const dataset = await this.buildBaseDataset(params.communityId, {
seasonId: 'all',
@@ -217,26 +218,42 @@ export class CommunityStatsService {
(item) => item.matchId === params.matchId.toString(),
);
if (!match) throw new NotFoundException('Internal match not found.');
let gameDetails = dataset.detailsByMatchId.get(match.matchId) ?? [];
if (gameDetails.some((game) => game.timelineLoaded !== true)) {
await this.matchStatsService.buildAndUpsert(params.matchId, {
includeTimeline: true,
});
const refreshedDataset = await this.buildBaseDataset(params.communityId, {
seasonId: 'all',
});
gameDetails = refreshedDataset.detailsByMatchId.get(match.matchId) ?? [];
}
const response: InternalMatchDetailResponse = {
match,
games: (dataset.detailsByMatchId.get(match.matchId) ?? []).map(
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,
@@ -245,13 +262,21 @@ export class CommunityStatsService {
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,
})),
})),
@@ -268,7 +293,7 @@ export class CommunityStatsService {
filters: CommunityStatsFilters;
}): Promise<UserInternalHistoryResponse> {
const key = this.cacheKey(
`userInternal:${params.userId.toString()}`,
`userInternal:v2:${params.userId.toString()}`,
params.communityId,
params.filters,
);
@@ -764,6 +789,8 @@ export class CommunityStatsService {
?.find((game) => game.riotMatchId === record.riotMatchId);
return {
matchId: record.riotMatchId,
internalMatchId: record.matchId,
gameNumber: record.gameNumber,
queueId: 0,
queueLabel: '내전',
gameCreation: record.gameCreation,
@@ -990,3 +1017,23 @@ export class CommunityStatsService {
return Math.round(value * 10) / 10;
}
}
function isCompleteMatchDetailResponse(
response: InternalMatchDetailResponse,
): boolean {
return response.games.every(
(game) =>
Array.isArray(game.timeline) &&
Array.isArray(game.objectiveEvents) &&
game.teams.every(
(team) =>
Array.isArray(team.bans) &&
team.participants.every(
(participant) =>
typeof participant.tagLine === 'string' &&
Array.isArray(participant.itemBuild) &&
Array.isArray(participant.skillBuild),
),
),
);
}
@@ -1,4 +1,10 @@
import type { RiotLane, TeamSide } from '../global/database/schema';
import type {
MatchStatsItemBuildEvent,
MatchStatsRunePerks,
MatchStatsSkillBuildEvent,
RiotLane,
TeamSide,
} from '../global/database/schema';
import type { RecentMatchView, HistorySeasonDto } from '../match-history/match-history.types';
export interface CommunityStatsFilters {
@@ -108,18 +114,43 @@ export interface InternalMatchDetailResponse {
riotMatchId: string;
gameCreation: number;
gameDuration: number;
gameVersion?: string;
timeline: Array<{
timestamp: number;
blue: { gold: number; xp: number };
red: { gold: number; xp: number };
goldDiff: number;
xpDiff: number;
}>;
objectiveEvents: Array<{
timestamp: number;
side: TeamSide;
type: 'dragon' | 'elderDragon' | 'baron' | 'riftHerald' | 'voidGrub';
monsterSubType?: string;
}>;
teams: Array<{
teamIndex: number;
side: TeamSide;
win: boolean;
objectives: { baron: number; dragon: number; tower: number };
objectives: {
tower: number;
dragon: number;
inhibitor: number;
baron: number;
riftHerald: number;
voidGrub: number;
elderDragon: number;
};
bans: Array<{ championId: number; pickTurn: number }>;
participants: Array<{
userId: string | null;
summonerName: string;
tagLine: string;
teamIndex: number;
side: TeamSide;
teamPosition: string;
championId: number;
championLevel: number;
kills: number;
deaths: number;
assists: number;
@@ -128,13 +159,21 @@ export interface InternalMatchDetailResponse {
gold: number;
gpm: number;
damageDealtToChampions: number;
damageTaken: number;
damageShare: number;
killParticipation: number;
visionScore: number;
wardsPlaced: number;
wardsKilled: number;
controlWardsBought: number;
firstBloodKill: boolean;
firstBloodAssist: boolean;
items: number[];
trinket: number;
summonerSpells: [number, number];
perks: { primaryStyle?: number; subStyle?: number; keystone?: number };
perks: MatchStatsRunePerks;
itemBuild: MatchStatsItemBuildEvent[];
skillBuild: MatchStatsSkillBuildEvent[];
win: boolean;
}>;
}>;
@@ -1,5 +1,6 @@
import mongoose from 'mongoose';
import type { MatchDocument } from '../global/database/schema';
import type { RiotMatchDto, RiotMatchTimelineDto } from '../riot/riot.types';
import { MatchStatsFragmentBuilder } from './match-stats-fragment.builder';
function makeMatch(): MatchDocument {
@@ -95,4 +96,301 @@ describe('MatchStatsFragmentBuilder', () => {
});
expect(fragment.gameDetails[0].teams[0].participants).toHaveLength(1);
});
it('builds rich set detail from raw Riot match data', () => {
const builder = new MatchStatsFragmentBuilder();
const match = makeMatch();
const raw = {
metadata: {
dataVersion: '2',
matchId: 'KR_1',
participants: ['puuid-1'],
},
info: {
gameCreation: 1_000,
gameDuration: 1_800,
gameId: 1,
gameMode: 'CLASSIC',
gameName: 'teambuilder-match-1',
gameStartTimestamp: 1_000,
gameType: 'CUSTOM_GAME',
gameVersion: '16.11.1.1234',
mapId: 11,
participants: [
{
assists: 7,
champExperience: 15_000,
champLevel: 15,
championId: 266,
championName: 'Aatrox',
deaths: 1,
firstBloodAssist: false,
firstBloodKill: true,
goldEarned: 12_345,
goldSpent: 11_000,
individualPosition: 'TOP',
item0: 1054,
item1: 3071,
item2: 0,
item3: 0,
item4: 0,
item5: 0,
item6: 3340,
kills: 5,
neutralMinionsKilled: 8,
participantId: 1,
perks: {
statPerks: { defense: 5001, flex: 5008, offense: 5005 },
styles: [
{
description: 'primaryStyle',
style: 8000,
selections: [
{ perk: 8010, var1: 0, var2: 0, var3: 0 },
{ perk: 9111, var1: 0, var2: 0, var3: 0 },
{ perk: 9105, var1: 0, var2: 0, var3: 0 },
{ perk: 8299, var1: 0, var2: 0, var3: 0 },
],
},
{
description: 'subStyle',
style: 8400,
selections: [
{ perk: 8444, var1: 0, var2: 0, var3: 0 },
{ perk: 8451, var1: 0, var2: 0, var3: 0 },
],
},
],
},
puuid: 'puuid-1',
riotIdGameName: 'Player',
riotIdTagLine: 'KR1',
summoner1Id: 4,
summoner2Id: 12,
summonerId: 'summoner-1',
summonerLevel: 100,
summonerName: 'Player',
teamId: 100,
teamPosition: 'TOP',
timePlayed: 1_800,
totalDamageDealtToChampions: 18_765,
totalDamageTaken: 24_321,
totalMinionsKilled: 220,
visionScore: 18,
visionWardsBoughtInGame: 2,
wardsKilled: 3,
wardsPlaced: 11,
win: true,
},
],
platformId: 'KR',
queueId: 0,
teams: [
{
bans: [
{ championId: 14, pickTurn: 1 },
{ championId: 43, pickTurn: 2 },
],
objectives: {
baron: { first: true, kills: 1 },
champion: { first: true, kills: 5 },
dragon: { first: true, kills: 2 },
horde: { first: false, kills: 3 },
inhibitor: { first: false, kills: 0 },
riftHerald: { first: false, kills: 0 },
tower: { first: true, kills: 7 },
},
teamId: 100,
win: true,
},
],
},
};
const timeline = {
metadata: {
dataVersion: '2',
matchId: 'KR_1',
participants: ['puuid-1'],
},
info: {
frameInterval: 60_000,
frames: [
{
timestamp: 0,
participantFrames: {
'1': { participantId: 1, totalGold: 500, xp: 0 },
},
},
{
timestamp: 60_000,
events: [
{
type: 'ITEM_PURCHASED',
timestamp: 10_000,
participantId: 1,
itemId: 1054,
},
{
type: 'SKILL_LEVEL_UP',
timestamp: 11_000,
participantId: 1,
skillSlot: 1,
levelUpType: 'NORMAL',
},
{
type: 'ITEM_DESTROYED',
timestamp: 12_000,
participantId: 1,
itemId: 2003,
},
{
type: 'ITEM_UNDO',
timestamp: 13_000,
participantId: 1,
beforeId: 1054,
afterId: 3071,
},
{
type: 'ELITE_MONSTER_KILL',
timestamp: 20_000,
killerTeamId: 100,
monsterType: 'DRAGON',
monsterSubType: 'FIRE_DRAGON',
},
{
type: 'ELITE_MONSTER_KILL',
timestamp: 30_000,
killerTeamId: 100,
monsterType: 'DRAGON',
monsterSubType: 'ELDER_DRAGON',
},
{
type: 'ELITE_MONSTER_KILL',
timestamp: 40_000,
killerId: 1,
monsterType: 'HORDE',
},
{
type: 'SKILL_LEVEL_UP',
timestamp: 45_000,
participantId: 1,
skillSlot: 3,
levelUpType: 'NORMAL',
},
{
type: 'ELITE_MONSTER_KILL',
timestamp: 50_000,
killerTeamId: 100,
monsterType: 'BARON_NASHOR',
},
{
type: 'ELITE_MONSTER_KILL',
timestamp: 55_000,
killerTeamId: 100,
monsterType: 'RIFTHERALD',
},
],
participantFrames: {
'1': { participantId: 1, totalGold: 1_150, xp: 550 },
},
},
],
},
};
const fragment = builder.buildFragment({
match,
rawByRiotMatchId: new Map([['KR_1', raw as RiotMatchDto]]),
timelineByRiotMatchId: new Map([
['KR_1', timeline as RiotMatchTimelineDto],
]),
});
expect(fragment.gameDetails[0]).toMatchObject({
gameVersion: '16.11.1.1234',
objectiveEvents: [
{
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' },
],
timeline: [
{
timestamp: 0,
blue: { gold: 500, xp: 0 },
red: { gold: 0, xp: 0 },
goldDiff: 500,
xpDiff: 0,
},
{
timestamp: 60,
blue: { gold: 1_150, xp: 550 },
red: { gold: 0, xp: 0 },
goldDiff: 1_150,
xpDiff: 550,
},
],
});
expect(fragment.gameDetails[0].teams[0].bans).toEqual([
{ championId: 14, pickTurn: 1 },
{ championId: 43, pickTurn: 2 },
]);
expect(fragment.gameDetails[0].teams[0].objectives).toMatchObject({
baron: 1,
dragon: 1,
elderDragon: 1,
inhibitor: 0,
riftHerald: 1,
tower: 7,
voidGrub: 1,
});
expect(fragment.records[0]).toMatchObject({
championLevel: 15,
cs: 228,
damageDealtToChampions: 18_765,
damageTaken: 24_321,
firstBloodKill: true,
firstBloodAssist: false,
controlWardsBought: 2,
wardsKilled: 3,
wardsPlaced: 11,
perks: {
primaryStyle: 8000,
subStyle: 8400,
keystone: 8010,
selectedPerkIds: [8010, 9111, 9105, 8299, 8444, 8451],
styles: [
{ styleId: 8000, perkIds: [8010, 9111, 9105, 8299] },
{ styleId: 8400, perkIds: [8444, 8451] },
],
statPerks: { defense: 5001, flex: 5008, offense: 5005 },
},
itemBuild: [
{ timestamp: 10, itemId: 1054, type: 'purchased' },
{ timestamp: 12, itemId: 2003, type: 'destroyed' },
{
timestamp: 13,
itemId: 3071,
type: 'undo',
beforeId: 1054,
afterId: 3071,
},
],
skillBuild: [
{ timestamp: 11, skillSlot: 1, level: 1, levelUpType: 'NORMAL' },
{ timestamp: 45, skillSlot: 3, level: 2, levelUpType: 'NORMAL' },
],
});
});
});
@@ -3,9 +3,18 @@ import mongoose from 'mongoose';
import type {
MatchDocument,
MatchGameResultParticipant,
MatchStatsItemBuildEvent,
MatchStatsObjectiveEvent,
MatchStatsObjectiveSummary,
MatchStatsSkillBuildEvent,
MatchStatsTimelinePoint,
TeamSide,
} from '../global/database/schema';
import type { RiotMatchDto, RiotMatchParticipantDto } from '../riot/riot.types';
import type {
RiotMatchDto,
RiotMatchParticipantDto,
RiotMatchTimelineDto,
} from '../riot/riot.types';
import type { InternalMatchCardView } from './community-stats.types';
import type {
InternalGameDetail,
@@ -13,11 +22,18 @@ import type {
MatchStatsFragment,
} from './match-stats.types';
interface ParticipantBuildEvents {
items: MatchStatsItemBuildEvent[];
skills: MatchStatsSkillBuildEvent[];
}
@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,
@@ -25,8 +41,15 @@ export class MatchStatsFragmentBuilder {
const matchCard = this.toMatchCard(params.match, games);
const gameDetails = games.map((game) => {
const raw = params.rawByRiotMatchId.get(game.riotMatchId);
const timeline = params.timelineByRiotMatchId?.get(game.riotMatchId);
return raw
? this.toGameDetail(params.match, game, raw)
? this.toGameDetail(
params.match,
game,
raw,
timeline,
params.timelineLoadAttempted === true,
)
: this.toFallbackGameDetail(params.match, game);
});
const records = gameDetails.flatMap((detail) =>
@@ -106,6 +129,8 @@ export class MatchStatsFragmentBuilder {
match: MatchDocument,
game: NonNullable<MatchDocument['result']>['games'][number],
raw: RiotMatchDto,
timeline?: RiotMatchTimelineDto,
timelineLoadAttempted = false,
): InternalGameDetail {
const puuidByUserId = new Map(
match.participants
@@ -129,13 +154,29 @@ export class MatchStatsFragmentBuilder {
rawTeamIdBySide.set(participant.side, rawParticipant.teamId);
}
}
const sideByParticipantId = this.toSideByParticipantId(
raw,
rawTeamIdBySide,
);
const objectiveEvents = this.toObjectiveEvents(
timeline,
rawTeamIdBySide,
sideByParticipantId,
);
const timelineObjectives = this.toTimelineObjectives(objectiveEvents);
const buildEventsByParticipantId =
this.toBuildEventsByParticipantId(timeline);
return {
gameNumber: game.gameNumber,
riotMatchId: game.riotMatchId,
gameCreation: game.gameCreation,
gameDuration: game.gameDuration,
gameVersion: raw.info.gameVersion,
winnerSide: game.winnerSide,
timeline: this.toTimeline(raw, rawTeamIdBySide, timeline),
timelineLoaded: timelineLoadAttempted || Boolean(timeline),
objectiveEvents,
teams: (['blue', 'red'] as TeamSide[]).map((side) => {
const teamIndex =
side === 'blue' ? game.blueTeamIndex : game.redTeamIndex;
@@ -158,25 +199,35 @@ export class MatchStatsFragmentBuilder {
teamIndex,
side,
win: game.winnerSide === side,
objectives: {
baron: rawTeam?.objectives?.baron?.kills ?? 0,
dragon: rawTeam?.objectives?.dragon?.kills ?? 0,
tower: rawTeam?.objectives?.tower?.kills ?? 0,
},
objectives: this.toObjectiveSummary(
rawTeam,
timelineObjectives.get(side),
Boolean(timeline),
),
bans: (rawTeam?.bans ?? []).map((ban) => ({
championId: ban.championId,
pickTurn: ban.pickTurn,
})),
participants: game.participants
.filter((participant) => participant.side === side)
.map((participant) =>
this.toRecord({
.map((participant) => {
const rawParticipant = rawByPuuid.get(
puuidByUserId.get(participant.userId.toString()) ?? '',
);
return this.toRecord({
match,
game,
participant,
rawParticipant: rawByPuuid.get(
puuidByUserId.get(participant.userId.toString()) ?? '',
),
rawParticipant,
buildEvents: rawParticipant
? buildEventsByParticipantId.get(
rawParticipant.participantId,
)
: undefined,
teamKills,
teamDamage,
}),
),
});
}),
};
}),
};
@@ -192,11 +243,15 @@ export class MatchStatsFragmentBuilder {
gameCreation: game.gameCreation,
gameDuration: game.gameDuration,
winnerSide: game.winnerSide,
timeline: [],
timelineLoaded: false,
objectiveEvents: [],
teams: (['blue', 'red'] as TeamSide[]).map((side) => ({
teamIndex: side === 'blue' ? game.blueTeamIndex : game.redTeamIndex,
side,
win: game.winnerSide === side,
objectives: { baron: 0, dragon: 0, tower: 0 },
objectives: emptyObjectives(),
bans: [],
participants: game.participants
.filter((participant) => participant.side === side)
.map((participant) =>
@@ -217,11 +272,19 @@ export class MatchStatsFragmentBuilder {
game: NonNullable<MatchDocument['result']>['games'][number];
participant: MatchGameResultParticipant;
rawParticipant?: RiotMatchParticipantDto;
buildEvents?: ParticipantBuildEvents;
teamKills: number;
teamDamage: number;
}): InternalRecord {
const { match, game, participant, rawParticipant, teamKills, teamDamage } =
params;
const {
match,
game,
participant,
rawParticipant,
buildEvents,
teamKills,
teamDamage,
} = params;
const snapshot = match.participants.find((item) =>
item.userId.equals(participant.userId),
);
@@ -262,6 +325,7 @@ export class MatchStatsFragmentBuilder {
rawParticipant?.riotIdGameName ??
rawParticipant?.summonerName ??
'Unknown',
tagLine: snapshot?.tagLine ?? rawParticipant?.riotIdTagLine ?? '',
profileIconId: snapshot?.profileIconId ?? 0,
teamIndex: participant.teamIndex,
side: participant.side,
@@ -290,6 +354,8 @@ export class MatchStatsFragmentBuilder {
),
wardsPlaced: rawParticipant?.wardsPlaced ?? 0,
wardsKilled: rawParticipant?.wardsKilled ?? 0,
firstBloodKill: booleanField(rawParticipant, 'firstBloodKill'),
firstBloodAssist: booleanField(rawParticipant, 'firstBloodAssist'),
items: [
rawParticipant?.item0 ?? 0,
rawParticipant?.item1 ?? 0,
@@ -304,6 +370,8 @@ export class MatchStatsFragmentBuilder {
rawParticipant?.summoner2Id ?? 0,
],
perks: rawParticipant ? this.resolvePerks(rawParticipant) : {},
itemBuild: buildEvents?.items ?? [],
skillBuild: buildEvents?.skills ?? [],
rating,
};
}
@@ -319,6 +387,250 @@ export class MatchStatsFragmentBuilder {
primaryStyle: primary?.style,
subStyle: sub?.style,
keystone: primary?.selections[0]?.perk,
selectedPerkIds: participant.perks.styles.flatMap((style) =>
style.selections.map((selection) => selection.perk),
),
styles: participant.perks.styles.map((style) => ({
styleId: style.style,
perkIds: style.selections.map((selection) => selection.perk),
})),
statPerks: {
offense: participant.perks.statPerks.offense,
flex: participant.perks.statPerks.flex,
defense: participant.perks.statPerks.defense,
},
};
}
private toBuildEventsByParticipantId(
timeline?: RiotMatchTimelineDto,
): Map<number, ParticipantBuildEvents> {
const buildEventsByParticipantId = new Map<number, ParticipantBuildEvents>();
if (!timeline?.info.frames.length) return buildEventsByParticipantId;
const getEvents = (participantId: number): ParticipantBuildEvents => {
const current = buildEventsByParticipantId.get(participantId);
if (current) return current;
const created: ParticipantBuildEvents = { items: [], skills: [] };
buildEventsByParticipantId.set(participantId, created);
return created;
};
for (const frame of timeline.info.frames) {
for (const event of frame.events ?? []) {
const participantId = event.participantId;
if (!participantId) continue;
const timestamp = Math.max(0, Math.round(event.timestamp / 1000));
if (event.type === 'SKILL_LEVEL_UP' && isSkillSlot(event.skillSlot)) {
const skills = getEvents(participantId).skills;
skills.push({
timestamp,
skillSlot: event.skillSlot,
level: skills.length + 1,
levelUpType: event.levelUpType,
});
continue;
}
const itemType = toItemBuildType(event.type);
if (!itemType) continue;
const itemId = event.itemId ?? event.afterId ?? event.beforeId ?? 0;
if (itemId <= 0) continue;
getEvents(participantId).items.push({
timestamp,
itemId,
type: itemType,
beforeId: event.beforeId,
afterId: event.afterId,
});
}
}
for (const events of buildEventsByParticipantId.values()) {
events.items.sort((left, right) => left.timestamp - right.timestamp);
events.skills.sort((left, right) => left.timestamp - right.timestamp);
}
return buildEventsByParticipantId;
}
private toTimeline(
raw: RiotMatchDto,
rawTeamIdBySide: Map<TeamSide, number>,
timeline?: RiotMatchTimelineDto,
): MatchStatsTimelinePoint[] {
if (!timeline?.info.frames.length) return [];
const sideByParticipantId = this.toSideByParticipantId(
raw,
rawTeamIdBySide,
);
const points = timeline.info.frames.map((frame) => {
const point: MatchStatsTimelinePoint = {
timestamp: Math.max(0, Math.round(frame.timestamp / 1000)),
blue: { gold: 0, xp: 0 },
red: { gold: 0, xp: 0 },
goldDiff: 0,
xpDiff: 0,
};
for (const participantFrame of Object.values(frame.participantFrames)) {
const side = sideByParticipantId.get(participantFrame.participantId);
if (!side) continue;
point[side].gold += participantFrame.totalGold;
point[side].xp += participantFrame.xp;
}
point.goldDiff = point.blue.gold - point.red.gold;
point.xpDiff = point.blue.xp - point.red.xp;
return point;
});
return points.filter(
(point, index) =>
index === 0 || point.timestamp !== points[index - 1].timestamp,
);
}
private toSideByParticipantId(
raw: RiotMatchDto,
rawTeamIdBySide: Map<TeamSide, number>,
): Map<number, TeamSide> {
const blueTeamId = rawTeamIdBySide.get('blue') ?? 100;
const redTeamId = rawTeamIdBySide.get('red') ?? 200;
const sideByParticipantId = new Map<number, TeamSide>();
for (const participant of raw.info.participants) {
if (participant.teamId === blueTeamId) {
sideByParticipantId.set(participant.participantId, 'blue');
}
if (participant.teamId === redTeamId) {
sideByParticipantId.set(participant.participantId, 'red');
}
}
return sideByParticipantId;
}
private toObjectiveEvents(
timeline: RiotMatchTimelineDto | undefined,
rawTeamIdBySide: Map<TeamSide, number>,
sideByParticipantId: Map<number, TeamSide>,
): MatchStatsObjectiveEvent[] {
if (!timeline?.info.frames.length) return [];
const sideByTeamId = new Map<number, TeamSide>();
for (const [side, teamId] of rawTeamIdBySide.entries()) {
sideByTeamId.set(teamId, side);
}
const objectiveEvents: MatchStatsObjectiveEvent[] = [];
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 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;
}
}
}
return objectiveEvents.sort((left, right) => left.timestamp - right.timestamp);
}
private toTimelineObjectives(
objectiveEvents: MatchStatsObjectiveEvent[],
): Map<TeamSide, MatchStatsObjectiveSummary> {
const objectives = new Map<TeamSide, MatchStatsObjectiveSummary>([
['blue', emptyObjectives()],
['red', emptyObjectives()],
]);
for (const event of objectiveEvents) {
const current = objectives.get(event.side) ?? emptyObjectives();
switch (event.type) {
case 'baron':
current.baron += 1;
break;
case 'riftHerald':
current.riftHerald += 1;
break;
case 'voidGrub':
current.voidGrub += 1;
break;
case 'dragon':
current.dragon += 1;
break;
case 'elderDragon':
current.elderDragon += 1;
break;
default:
break;
}
objectives.set(event.side, current);
}
return objectives;
}
private toObjectiveSummary(
rawTeam:
| RiotMatchDto['info']['teams'][number]
| undefined,
timelineObjectives: MatchStatsObjectiveSummary | undefined,
hasTimeline: boolean,
): MatchStatsObjectiveSummary {
const rawObjectives = rawTeam?.objectives;
return {
tower: rawObjectives?.tower?.kills ?? 0,
dragon: hasTimeline
? (timelineObjectives?.dragon ?? 0)
: (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,
};
}
@@ -354,6 +666,27 @@ function average(value: number, total: number): number {
return total > 0 ? round(value / total) : 0;
}
function isSkillSlot(value: number | undefined): value is 1 | 2 | 3 | 4 {
return value === 1 || value === 2 || value === 3 || value === 4;
}
function toItemBuildType(
value: string,
): MatchStatsItemBuildEvent['type'] | null {
switch (value) {
case 'ITEM_PURCHASED':
return 'purchased';
case 'ITEM_SOLD':
return 'sold';
case 'ITEM_DESTROYED':
return 'destroyed';
case 'ITEM_UNDO':
return 'undo';
default:
return null;
}
}
function round(value: number): number {
return Math.round(value * 10) / 10;
}
@@ -365,3 +698,22 @@ function numberField(
const value = participant?.[key];
return typeof value === 'number' && Number.isFinite(value) ? value : 0;
}
function booleanField(
participant: RiotMatchParticipantDto | undefined,
key: string,
): boolean {
return participant?.[key] === true;
}
function emptyObjectives(): MatchStatsObjectiveSummary {
return {
tower: 0,
dragon: 0,
inhibitor: 0,
baron: 0,
riftHerald: 0,
voidGrub: 0,
elderDragon: 0,
};
}
@@ -29,6 +29,7 @@ describe('MatchStatsService', () => {
connectionService,
repository,
{} as MatchStatsFragmentBuilder,
{ getMatchTimeline: jest.fn() } as never,
);
await service.buildAndUpsert(matchId);
@@ -53,7 +54,20 @@ describe('MatchStatsService', () => {
});
const riotFind = jest.fn().mockReturnValue({
lean: () => ({
exec: jest.fn().mockResolvedValue([{ matchId: 'KR_1', raw: {} }]),
exec: jest.fn().mockResolvedValue([
{
matchId: 'KR_1',
raw: {},
timeline: {
metadata: {
dataVersion: '2',
matchId: 'KR_1',
participants: [],
},
info: { frameInterval: 60_000, frames: [] },
},
},
]),
}),
});
const connectionService = {
@@ -82,6 +96,7 @@ describe('MatchStatsService', () => {
connectionService,
repository,
builder,
{ getMatchTimeline: jest.fn() } as never,
);
await service.buildAndUpsert(matchId);
@@ -89,6 +104,8 @@ describe('MatchStatsService', () => {
expect(builder.buildFragment).toHaveBeenCalledWith({
match,
rawByRiotMatchId: expect.any(Map),
timelineByRiotMatchId: expect.any(Map),
timelineLoadAttempted: false,
});
expect(repository.upsert).toHaveBeenCalledWith(
expect.objectContaining({
@@ -97,7 +114,7 @@ describe('MatchStatsService', () => {
scheduledAt,
gameCreationMin: 1_000,
gameCreationMax: 2_000,
builderVersion: 1,
builderVersion: 9,
}),
);
});
@@ -1,21 +1,33 @@
import { Injectable } from '@nestjs/common';
import { Injectable, Logger } from '@nestjs/common';
import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service';
import type { MatchDocument } from '../global/database/schema';
import type { RiotMatchDto } from '../riot/riot.types';
import { RiotMatchService } from '../riot/riot-match.service';
import {
RIOT_REGIONAL_ROUTES,
type RiotMatchDto,
type RiotMatchTimelineDto,
type RiotRegionalRoute,
} from '../riot/riot.types';
import { MatchStatsFragmentBuilder } from './match-stats-fragment.builder';
import { MatchStatsRepository } from './match-stats.repository';
import { MATCH_STATS_BUILDER_VERSION } from './match-stats.types';
@Injectable()
export class MatchStatsService {
private readonly logger = new Logger(MatchStatsService.name);
constructor(
private readonly connectionService: ConnectionService,
private readonly repository: MatchStatsRepository,
private readonly builder: MatchStatsFragmentBuilder,
private readonly riotMatchService: RiotMatchService,
) {}
public async buildAndUpsert(matchId: mongoose.Types.ObjectId): Promise<void> {
public async buildAndUpsert(
matchId: mongoose.Types.ObjectId,
options: { includeTimeline?: boolean } = {},
): Promise<void> {
const MatchModel = await this.connectionService.getModel('match');
const RiotMatchModel = await this.connectionService.getModel('riotMatch');
const match = await MatchModel.findById(matchId).exec();
@@ -41,7 +53,51 @@ export class MatchStatsService {
const rawByRiotMatchId = new Map(
riotDocs.map((doc) => [doc.matchId, doc.raw as unknown as RiotMatchDto]),
);
const fragment = this.builder.buildFragment({ match, rawByRiotMatchId });
const timelineByRiotMatchId = new Map<string, RiotMatchTimelineDto>();
for (const doc of riotDocs) {
if (isRiotMatchTimelineDto(doc.timeline)) {
timelineByRiotMatchId.set(doc.matchId, doc.timeline);
}
}
if (
options.includeTimeline &&
riotDocs.length > 0 &&
timelineByRiotMatchId.size < riotDocs.length
) {
const region = await this.resolveRiotRegion(match.communityId);
for (const doc of riotDocs) {
if (timelineByRiotMatchId.has(doc.matchId)) continue;
try {
const timeline = await this.riotMatchService.getMatchTimeline(
doc.matchId,
{ region },
);
await RiotMatchModel.updateOne(
{ matchId: doc.matchId },
{
$set: {
timeline: timeline as unknown as Record<string, unknown>,
timelineFetchedAt: new Date(),
},
},
).exec();
timelineByRiotMatchId.set(doc.matchId, timeline);
} catch (error) {
this.logger.warn(
`Failed to fetch match timeline for ${doc.matchId}: ${
error instanceof Error ? error.message : error
}`,
);
}
}
}
const fragment = this.builder.buildFragment({
match,
rawByRiotMatchId,
timelineByRiotMatchId,
timelineLoadAttempted: options.includeTimeline === true,
});
await this.repository.upsert({
matchId: match._id,
@@ -101,4 +157,29 @@ export class MatchStatsService {
Boolean(match.result?.games?.length)
);
}
private async resolveRiotRegion(
communityId: mongoose.Types.ObjectId,
): Promise<RiotRegionalRoute> {
const CommunityModel = await this.connectionService.getModel('community');
const community = await CommunityModel.findById(communityId)
.select({ riotRegion: 1 })
.lean()
.exec();
const region = community?.riotRegion;
return RIOT_REGIONAL_ROUTES.includes(region as RiotRegionalRoute)
? (region as RiotRegionalRoute)
: 'asia';
}
}
function isRiotMatchTimelineDto(
value: unknown,
): value is RiotMatchTimelineDto {
if (!isRecord(value) || !isRecord(value.info)) return false;
return Array.isArray(value.info.frames);
}
function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === 'object' && value !== null;
}
@@ -4,7 +4,7 @@ import type {
} from '../global/database/schema';
import type { InternalMatchCardView } from './community-stats.types';
export const MATCH_STATS_BUILDER_VERSION = 1;
export const MATCH_STATS_BUILDER_VERSION = 9;
export type InternalRecord = MatchStatsRecord;
export type InternalGameDetail = MatchStatsGameDetail;
@@ -0,0 +1,94 @@
import {
AuctionHistoryEntrySchema,
AuctionSchema,
AuctionSideEffectApplicationSchema,
tournamentModelDefinitions,
} from './schema';
function indexWithKeys(
schemaIndexes: ReturnType<typeof AuctionSchema.indexes>,
expectedKeys: Record<string, 1 | -1>,
) {
return schemaIndexes.find(([keys]) => {
return JSON.stringify(keys) === JSON.stringify(expectedKeys);
});
}
describe('auction Redis schema foundation', () => {
it('defines Redis v1 projection metadata on auction documents', () => {
expect(AuctionSchema.path('revision')).toBeDefined();
expect(AuctionSchema.path('auctionEngineVersion')).toBeDefined();
expect(AuctionSchema.path('auctionLifecycleId')).toBeDefined();
expect(AuctionSchema.path('lastAppliedAuctionStateTransitionId')).toBeDefined();
expect(AuctionSchema.path('currentAuctionHistorySequence')).toBeDefined();
expect(AuctionSchema.path('startAuctionRequestId')).toBeDefined();
expect(AuctionSchema.path('startAuctionStateTransitionId')).toBeDefined();
expect(AuctionSchema.path('matchSideEffectStatus')).toBeDefined();
expect(AuctionSchema.path('matchSideEffectRevision')).toBeDefined();
});
it('defines the new auction state field names for migration targets', () => {
expect(AuctionSchema.path('auctionTeams')).toBeDefined();
expect(AuctionSchema.path('auctionPlayerOrder')).toBeDefined();
expect(AuctionSchema.path('passedAuctionPlayerQueue')).toBeDefined();
expect(AuctionSchema.path('currentAuctionRound')).toBeDefined();
expect(AuctionSchema.path('currentAuctionPlayerOrderIndex')).toBeDefined();
expect(AuctionSchema.path('auctionBidHistory')).toBeDefined();
expect(AuctionSchema.path('currentHighestBidPointAmount')).toBeDefined();
expect(AuctionSchema.path('currentHighestBidderTeamIndex')).toBeDefined();
expect(AuctionSchema.path('currentBidRoundDeadlineTimestampMS')).toBeDefined();
expect(AuctionSchema.path('maximumBidRoundDurationSeconds')).toBeDefined();
expect(AuctionSchema.path('bidRoundExtensionSeconds')).toBeDefined();
expect(AuctionSchema.path('initialTeamBidPointAmount')).toBeDefined();
expect(AuctionSchema.path('topTierAuctionPriorityThreshold')).toBeDefined();
expect(AuctionSchema.path('manualTopTierAuctionPriorityUserIds')).toBeDefined();
expect(AuctionSchema.path('auctionStartedAtTimestampMS')).toBeDefined();
expect(AuctionSchema.path('auctionCompletedAtTimestampMS')).toBeDefined();
});
it('adds history transition fields and reset/undo action enum values', () => {
expect(AuctionHistoryEntrySchema.path('auctionStateTransitionId')).toBeDefined();
expect(AuctionHistoryEntrySchema.path('auctionLifecycleId')).toBeDefined();
expect(AuctionHistoryEntrySchema.path('revision')).toBeDefined();
expect(AuctionHistoryEntrySchema.path('historyMutation')).toBeDefined();
expect(AuctionHistoryEntrySchema.path('matchSideEffectMutation')).toBeDefined();
expect(
AuctionHistoryEntrySchema.path<string>('action').options.enum,
).toEqual(
expect.arrayContaining(['start', 'open-bidding', 'bid', 'sold', 'passed', 'next', 'complete', 'reset', 'undo']),
);
});
it('adds unique history indexes for sequence and transition idempotency', () => {
const indexes = AuctionHistoryEntrySchema.indexes();
expect(indexWithKeys(indexes, { auctionId: 1, sequence: 1 })?.[1]).toMatchObject({
unique: true,
});
expect(
indexWithKeys(indexes, { auctionId: 1, auctionStateTransitionId: 1 })?.[1],
).toMatchObject({ unique: true, sparse: true });
});
it('registers auction side effect application model with lease fields and unique idempotency index', () => {
expect(AuctionSideEffectApplicationSchema.path('processingOwnerToken')).toBeDefined();
expect(
AuctionSideEffectApplicationSchema.path('processingLeaseExpiresAtTimestampMS'),
).toBeDefined();
expect(AuctionSideEffectApplicationSchema.path('payloadChecksum')).toBeDefined();
const indexes = AuctionSideEffectApplicationSchema.indexes();
expect(
indexWithKeys(indexes, {
auctionId: 1,
auctionStateTransitionId: 1,
sideEffectType: 1,
})?.[1],
).toMatchObject({ unique: true });
expect(
tournamentModelDefinitions.some(
(definition) => definition.name === 'auctionSideEffectApplication',
),
).toBe(true);
});
});
@@ -95,6 +95,6 @@ export class ConnectionService implements OnModuleInit {
}
public async onModuleDestroy() {
this.connection?.close();
await this.connection?.close();
}
}
@@ -0,0 +1,219 @@
import { migrateAuctionRedisFieldRename } from './20260622-auction-redis-field-rename';
type Doc = Record<string, unknown> & { _id: string };
function createDb(params: { auctions?: Doc[]; history?: Doc[] }) {
const collections = {
auction: params.auctions ?? [],
auctionHistory: params.history ?? [],
};
return {
collections,
db: {
collection(name: string) {
const docs =
name === 'auction'
? collections.auction
: name === 'auctionHistory'
? collections.auctionHistory
: [];
return {
find() {
return {
limit() {
return {
async *[Symbol.asyncIterator]() {
for (const doc of docs) yield doc;
},
};
},
};
},
async bulkWrite(writes: Array<{
updateOne: {
filter: { _id: unknown };
update: {
$set?: Record<string, unknown>;
$unset?: Record<string, ''>;
};
};
}>) {
for (const write of writes) {
const doc = docs.find((item) => item._id === write.updateOne.filter._id);
if (!doc) continue;
Object.assign(doc, write.updateOne.update.$set ?? {});
for (const key of Object.keys(write.updateOne.update.$unset ?? {})) {
delete doc[key];
}
}
},
};
},
},
};
}
describe('migrateAuctionRedisFieldRename', () => {
it('renames auction fields and nested bid/team fields', async () => {
const deadline = new Date('2026-06-22T01:02:03.004Z');
const { db, collections } = createDb({
auctions: [
{
_id: 'auction-1',
teams: [
{
teamIndex: 1,
captainUserId: 'u1',
points: 900,
members: [{ userId: 'u1', assignedPosition: 'TOP', cost: 100 }],
},
],
order: [{ userId: 'p1', passCount: 0 }],
passedQueue: [{ userId: 'p2', passCount: 1 }],
auctionRound: 2,
currentIndex: 3,
bids: [
{
teamIndex: 1,
amount: 120,
bidderUserId: 'u1',
timestamp: deadline,
},
],
currentBid: 120,
currentBidderTeamIndex: 1,
currentDeadline: deadline,
maxTimerSeconds: 30,
bidExtensionSeconds: 5,
initialPoints: 1000,
topTierThreshold: 'DIAMOND',
manualTopTierUserIds: ['u2'],
startedAt: deadline,
completedAt: deadline,
},
],
});
const dryRunStats = await migrateAuctionRedisFieldRename(db, {
dryRun: true,
});
expect(dryRunStats.changedAuctions).toBe(1);
expect(collections.auction[0]).toHaveProperty('teams');
const stats = await migrateAuctionRedisFieldRename(db, { dryRun: false });
expect(stats.changedAuctions).toBe(1);
expect(collections.auction[0]).toMatchObject({
auctionEngineVersion: 'legacy-renamed',
auctionLifecycleId: 'legacy-auction:auction-1',
revision: 0,
currentAuctionHistorySequence: 0,
matchSideEffectStatus: 'none',
matchSideEffectRevision: 0,
auctionTeams: [
{
teamIndex: 1,
captainUserId: 'u1',
remainingBidPointAmount: 900,
members: [
{
userId: 'u1',
assignedPosition: 'TOP',
memberAcquisitionBidPointAmount: 100,
},
],
},
],
auctionPlayerOrder: [{ userId: 'p1', passCount: 0 }],
passedAuctionPlayerQueue: [{ userId: 'p2', passCount: 1 }],
currentAuctionRound: 2,
currentAuctionPlayerOrderIndex: 3,
auctionBidHistory: [
{
bidderTeamIndex: 1,
bidPointAmount: 120,
bidderUserId: 'u1',
bidPlacedAtTimestampMS: deadline.getTime(),
},
],
currentHighestBidPointAmount: 120,
currentHighestBidderTeamIndex: 1,
currentBidRoundDeadlineTimestampMS: deadline.getTime(),
maximumBidRoundDurationSeconds: 30,
bidRoundExtensionSeconds: 5,
initialTeamBidPointAmount: 1000,
topTierAuctionPriorityThreshold: 'DIAMOND',
manualTopTierAuctionPriorityUserIds: ['u2'],
auctionStartedAtTimestampMS: deadline.getTime(),
auctionCompletedAtTimestampMS: deadline.getTime(),
});
expect(collections.auction[0]).not.toHaveProperty('teams');
expect(collections.auction[0]).not.toHaveProperty('bids');
expect(collections.auction[0]).not.toHaveProperty('currentDeadline');
});
it('renames history snapshots and adds transition metadata', async () => {
const { db, collections } = createDb({
history: [
{
_id: 'history-1',
auctionId: 'auction-1',
matchId: 'match-1',
sequence: 2,
action: 'sold',
snapshotBefore: {
currentBid: 100,
bids: [{ teamIndex: 1, amount: 100, timestamp: 123 }],
},
},
],
});
await migrateAuctionRedisFieldRename(db, { dryRun: false });
expect(collections.auctionHistory[0]).toMatchObject({
auctionLifecycleId: 'legacy-auction:auction-1',
auctionStateTransitionId: 'legacy-history:auction-1:2',
revision: 2,
historyMutation: { type: 'append' },
matchSideEffectMutation: { type: 'none' },
snapshotBefore: {
currentHighestBidPointAmount: 100,
auctionBidHistory: [
{
bidderTeamIndex: 1,
bidPointAmount: 100,
bidPlacedAtTimestampMS: 123,
},
],
},
});
});
it('is idempotent after applying updates', async () => {
const { db } = createDb({
auctions: [{ _id: 'auction-1', teams: [] }],
history: [{ _id: 'history-1', auctionId: 'auction-1', sequence: 1 }],
});
await migrateAuctionRedisFieldRename(db, { dryRun: false });
const stats = await migrateAuctionRedisFieldRename(db, { dryRun: false });
expect(stats.changedAuctions).toBe(0);
expect(stats.changedHistoryEntries).toBe(0);
});
it('fails apply when duplicate history sequences would break unique indexes', async () => {
const { db } = createDb({
history: [
{ _id: 'h1', auctionId: 'auction-1', sequence: 1 },
{ _id: 'h2', auctionId: 'auction-1', sequence: 1 },
],
});
await expect(
migrateAuctionRedisFieldRename(db, { dryRun: false }),
).rejects.toThrow('Duplicate auctionHistory sequence');
});
});
@@ -0,0 +1,336 @@
interface MigrationCollection {
find(filter: Record<string, unknown>): {
limit(limit: number): AsyncIterable<AnyDoc>;
};
bulkWrite(
writes: Array<{
updateOne: {
filter: { _id: unknown };
update: { $set?: Record<string, unknown>; $unset?: Record<string, ''> };
};
}>,
options: { ordered: boolean },
): Promise<unknown>;
}
interface MigrationDb {
collection(name: string): MigrationCollection;
}
interface MigrationOptions {
dryRun?: boolean;
limit?: number;
}
interface MigrationStats {
changedAuctions: number;
changedHistoryEntries: number;
duplicateHistorySequences: number;
scannedAuctions: number;
scannedHistoryEntries: number;
}
type AnyDoc = Record<string, unknown> & { _id: unknown };
type UpdateDoc = { $set?: Record<string, unknown>; $unset?: Record<string, ''> };
const AUCTION_FIELD_RENAMES: Array<{
from: string;
to: string;
transform?: (value: unknown) => unknown;
}> = [
{ from: 'teams', to: 'auctionTeams', transform: transformAuctionTeams },
{ from: 'order', to: 'auctionPlayerOrder' },
{ from: 'passedQueue', to: 'passedAuctionPlayerQueue' },
{ from: 'auctionRound', to: 'currentAuctionRound' },
{ from: 'currentIndex', to: 'currentAuctionPlayerOrderIndex' },
{ from: 'bids', to: 'auctionBidHistory', transform: transformAuctionBidHistory },
{ from: 'currentBid', to: 'currentHighestBidPointAmount' },
{ from: 'currentBidderTeamIndex', to: 'currentHighestBidderTeamIndex' },
{
from: 'currentDeadline',
to: 'currentBidRoundDeadlineTimestampMS',
transform: toTimestampMS,
},
{ from: 'maxTimerSeconds', to: 'maximumBidRoundDurationSeconds' },
{ from: 'bidExtensionSeconds', to: 'bidRoundExtensionSeconds' },
{ from: 'initialPoints', to: 'initialTeamBidPointAmount' },
{ from: 'topTierThreshold', to: 'topTierAuctionPriorityThreshold' },
{
from: 'manualTopTierUserIds',
to: 'manualTopTierAuctionPriorityUserIds',
},
{
from: 'startedAt',
to: 'auctionStartedAtTimestampMS',
transform: toTimestampMS,
},
{
from: 'completedAt',
to: 'auctionCompletedAtTimestampMS',
transform: toTimestampMS,
},
];
export async function migrateAuctionRedisFieldRename(
db: MigrationDb,
options: MigrationOptions = {},
): Promise<MigrationStats> {
const dryRun = options.dryRun ?? true;
const stats: MigrationStats = {
changedAuctions: 0,
changedHistoryEntries: 0,
duplicateHistorySequences: 0,
scannedAuctions: 0,
scannedHistoryEntries: 0,
};
stats.duplicateHistorySequences = await countDuplicateHistorySequences(
db.collection('auctionHistory'),
options.limit,
);
if (!dryRun && stats.duplicateHistorySequences > 0) {
throw new Error(
`Duplicate auctionHistory sequence entries found: ${stats.duplicateHistorySequences}`,
);
}
await migrateCollection(
db.collection('auction'),
options.limit,
dryRun,
stats,
'auction',
);
await migrateCollection(
db.collection('auctionHistory'),
options.limit,
dryRun,
stats,
'auctionHistory',
);
return stats;
}
async function migrateCollection(
collection: MigrationCollection,
limit: number | undefined,
dryRun: boolean,
stats: MigrationStats,
kind: 'auction' | 'auctionHistory',
) {
const writes: Array<{
updateOne: {
filter: { _id: unknown };
update: UpdateDoc;
};
}> = [];
for await (const doc of collection.find({}).limit(limit ?? 0)) {
if (kind === 'auction') stats.scannedAuctions += 1;
if (kind === 'auctionHistory') stats.scannedHistoryEntries += 1;
const update =
kind === 'auction' ? migrateAuctionDoc(doc) : migrateHistoryDoc(doc);
if (!update) continue;
if (kind === 'auction') stats.changedAuctions += 1;
if (kind === 'auctionHistory') stats.changedHistoryEntries += 1;
writes.push({
updateOne: {
filter: { _id: doc._id },
update,
},
});
}
if (!dryRun && writes.length > 0) {
await collection.bulkWrite(writes, { ordered: false });
}
}
async function countDuplicateHistorySequences(
collection: MigrationCollection,
limit: number | undefined,
): Promise<number> {
const seen = new Set<string>();
const duplicates = new Set<string>();
for await (const doc of collection.find({}).limit(limit ?? 0)) {
const auctionId = stringifyId(doc.auctionId);
const sequence = typeof doc.sequence === 'number' ? doc.sequence : undefined;
if (!auctionId || sequence === undefined) continue;
const key = `${auctionId}:${sequence}`;
if (seen.has(key)) duplicates.add(key);
seen.add(key);
}
return duplicates.size;
}
function migrateAuctionDoc(doc: AnyDoc): UpdateDoc | null {
const set: Record<string, unknown> = {};
const unset: Record<string, ''> = {};
for (const rename of AUCTION_FIELD_RENAMES) {
renameField(doc, rename.from, rename.to, set, unset, rename.transform);
}
setDefault(doc, set, 'revision', 0);
setDefault(doc, set, 'currentAuctionHistorySequence', 0);
setDefault(doc, set, 'auctionEngineVersion', 'legacy-renamed');
setDefault(doc, set, 'auctionLifecycleId', legacyAuctionLifecycleId(doc._id));
setDefault(doc, set, 'matchSideEffectStatus', 'none');
setDefault(doc, set, 'matchSideEffectRevision', 0);
return buildUpdate(set, unset);
}
function migrateHistoryDoc(doc: AnyDoc): UpdateDoc | null {
const set: Record<string, unknown> = {};
const unset: Record<string, ''> = {};
const auctionId = stringifyId(doc.auctionId);
const sequence = typeof doc.sequence === 'number' ? doc.sequence : 0;
setDefault(
doc,
set,
'auctionLifecycleId',
auctionId ? legacyAuctionLifecycleId(auctionId) : undefined,
);
setDefault(
doc,
set,
'auctionStateTransitionId',
auctionId ? `legacy-history:${auctionId}:${sequence}` : undefined,
);
setDefault(doc, set, 'revision', sequence);
setDefault(doc, set, 'historyMutation', { type: 'append' });
setDefault(doc, set, 'matchSideEffectMutation', { type: 'none' });
const snapshotBefore = isRecord(doc.snapshotBefore)
? migrateAuctionSnapshot(doc.snapshotBefore)
: undefined;
if (snapshotBefore?.changed) {
set.snapshotBefore = snapshotBefore.value;
}
return buildUpdate(set, unset);
}
function migrateAuctionSnapshot(snapshot: Record<string, unknown>): {
changed: boolean;
value: Record<string, unknown>;
} {
const value = { ...snapshot };
let changed = false;
for (const rename of AUCTION_FIELD_RENAMES) {
if (!(rename.from in value)) continue;
if (!(rename.to in value)) {
value[rename.to] = rename.transform
? rename.transform(value[rename.from])
: value[rename.from];
}
delete value[rename.from];
changed = true;
}
return { changed, value };
}
function renameField(
doc: Record<string, unknown>,
from: string,
to: string,
set: Record<string, unknown>,
unset: Record<string, ''>,
transform?: (value: unknown) => unknown,
) {
if (!(from in doc)) return;
if (!(to in doc)) {
set[to] = transform ? transform(doc[from]) : doc[from];
}
unset[from] = '';
}
function setDefault(
doc: Record<string, unknown>,
set: Record<string, unknown>,
key: string,
value: unknown,
) {
if (value === undefined || key in doc || key in set) return;
set[key] = value;
}
function buildUpdate(
set: Record<string, unknown>,
unset: Record<string, ''>,
): UpdateDoc | null {
const update: UpdateDoc = {};
if (Object.keys(set).length > 0) update.$set = set;
if (Object.keys(unset).length > 0) update.$unset = unset;
return update.$set || update.$unset ? update : null;
}
function transformAuctionTeams(value: unknown): unknown[] {
return asArray(value).map((team) => {
const next = { ...team };
if ('points' in next && !('remainingBidPointAmount' in next)) {
next.remainingBidPointAmount = next.points;
}
delete next.points;
next.members = asArray(next.members).map((member) => {
const migratedMember = { ...member };
if (
'cost' in migratedMember &&
!('memberAcquisitionBidPointAmount' in migratedMember)
) {
migratedMember.memberAcquisitionBidPointAmount = migratedMember.cost;
}
delete migratedMember.cost;
return migratedMember;
});
return next;
});
}
function transformAuctionBidHistory(value: unknown): unknown[] {
return asArray(value).map((bid) => {
const next: Record<string, unknown> = {};
if ('teamIndex' in bid) next.bidderTeamIndex = bid.teamIndex;
if ('amount' in bid) next.bidPointAmount = bid.amount;
if ('bidderUserId' in bid) next.bidderUserId = bid.bidderUserId;
if ('timestamp' in bid) {
next.bidPlacedAtTimestampMS = toTimestampMS(bid.timestamp);
}
return next;
});
}
function toTimestampMS(value: unknown): unknown {
if (value instanceof Date) return value.getTime();
if (typeof value === 'number') return value;
if (typeof value === 'string') {
const parsed = Date.parse(value);
return Number.isNaN(parsed) ? value : parsed;
}
return value;
}
function legacyAuctionLifecycleId(value: unknown): string {
return `legacy-auction:${stringifyId(value) ?? 'unknown'}`;
}
function stringifyId(value: unknown): string | undefined {
if (value === undefined || value === null) return undefined;
return typeof value === 'string' ? value : String(value);
}
function asArray(value: unknown): Record<string, unknown>[] {
return Array.isArray(value)
? value.filter(isRecord).map((item) => ({ ...item }))
: [];
}
function isRecord(value: unknown): value is Record<string, unknown> {
return Boolean(value && typeof value === 'object' && !Array.isArray(value));
}
@@ -0,0 +1,680 @@
import 'reflect-metadata';
import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { NestFactory } from '@nestjs/core';
import mongoose from 'mongoose';
import { readFile } from 'node:fs/promises';
import { resolve } from 'node:path';
import {
ConnectionService,
resolveMongoDbName,
} from '../connection.service';
import type {
MatchDocument,
MatchGameAssignment,
MatchGameResult,
MatchSeriesResult,
TournamentCodeDocument,
} from '../schema';
import { SecretModule } from '../../secret/secret.module';
import { MatchStatsFragmentBuilder } from '../../../community-stats/match-stats-fragment.builder';
import { MatchStatsRepository } from '../../../community-stats/match-stats.repository';
import { MatchStatsService } from '../../../community-stats/match-stats.service';
interface CliOptions {
dryRun: boolean;
matchId: mongoose.Types.ObjectId;
maxRounds: number;
nodeEnv: string;
}
interface ResultGamePlan {
oldGameNumber: number;
newGameNumber: number;
roundNumber: number;
teamAIndex: number;
teamBIndex: number;
game: MatchGameResult;
}
interface RepairPlan {
schedule: MatchGameAssignment[];
gamePlans: ResultGamePlan[];
seriesResults: MatchSeriesResult[];
winnerTeamIndex?: number;
usedCodeByOldGameNumber: Map<number, TournamentCodeDocument>;
releasedCodes: TournamentCodeDocument[];
}
@Module({
imports: [
ConfigModule.forRoot({
isGlobal: true,
envFilePath: [
resolve(__dirname, '../../../../../../project.env'),
resolve(process.cwd(), '../project.env'),
resolve(process.cwd(), 'apps/project.env'),
resolve(process.cwd(), 'project.env'),
],
}),
SecretModule,
],
providers: [
ConnectionService,
MatchStatsFragmentBuilder,
MatchStatsRepository,
MatchStatsService,
],
})
class RepairModule {}
async function loadMachineEnvFile() {
const homeDir = process.env.HOME ?? process.env.USERPROFILE;
if (!homeDir) return;
const machineEnvFile = resolve(homeDir, 'source/global-env-vars.txt');
try {
const file = await readFile(machineEnvFile, 'utf8');
for (const rawLine of file.split(/\r?\n/)) {
const line = rawLine.trim();
if (!line || line.startsWith('#')) continue;
const matched = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
if (!matched) continue;
const [, key, rawValue] = matched;
process.env[key] = rawValue.replace(/^["']|["']$/g, '');
}
} catch {
// 로컬 machine env 파일이 없으면 그냥 지나간다.
}
}
function parseArgs(argv: string[]): CliOptions {
let dryRun = true;
let matchId: mongoose.Types.ObjectId | undefined;
let maxRounds = 3;
let nodeEnv = process.env.NODE_ENV ?? 'dev';
for (let index = 0; index < argv.length; index += 1) {
const arg = argv[index];
if (arg === '--apply') {
dryRun = false;
continue;
}
if (arg === '--dry-run') {
dryRun = true;
continue;
}
if (arg === '--match-id') {
const value = argv[index + 1];
if (!value || !mongoose.isValidObjectId(value)) {
throw new Error('--match-id requires a valid ObjectId.');
}
matchId = new mongoose.Types.ObjectId(value);
index += 1;
continue;
}
if (arg.startsWith('--match-id=')) {
const value = arg.slice('--match-id='.length);
if (!mongoose.isValidObjectId(value)) {
throw new Error('--match-id requires a valid ObjectId.');
}
matchId = new mongoose.Types.ObjectId(value);
continue;
}
if (arg === '--max-rounds') {
maxRounds = parsePositiveInteger(argv[index + 1], '--max-rounds');
index += 1;
continue;
}
if (arg.startsWith('--max-rounds=')) {
maxRounds = parsePositiveInteger(
arg.slice('--max-rounds='.length),
'--max-rounds',
);
continue;
}
if (arg === '--env') {
const value = argv[index + 1];
if (!value) throw new Error('--env requires dev, staging, or prod.');
nodeEnv = value;
index += 1;
continue;
}
if (arg.startsWith('--env=')) {
nodeEnv = arg.slice('--env='.length);
continue;
}
if (arg === '--help' || arg === '-h') {
printHelp();
process.exit(0);
}
throw new Error(`Unknown argument: ${arg}`);
}
if (!matchId) throw new Error('--match-id is required.');
if (!['dev', 'staging', 'prod'].includes(nodeEnv)) {
throw new Error('--env must be dev, staging, or prod.');
}
return { dryRun, matchId, maxRounds, nodeEnv };
}
function parsePositiveInteger(value: string | undefined, label: string) {
const parsed = Number(value);
if (!Number.isInteger(parsed) || parsed < 1) {
throw new Error(`${label} requires a positive integer.`);
}
return parsed;
}
function printHelp() {
console.log(`Usage:
pnpm --filter api exec ts-node src/modules/global/database/migrations/repair-limited-round-robin-finished-match.ts --match-id <id> --max-rounds 3 --dry-run
pnpm --filter api exec ts-node src/modules/global/database/migrations/repair-limited-round-robin-finished-match.ts --match-id <id> --max-rounds 3 --env prod --apply
Options:
--match-id <id> Match ObjectId to repair.
--max-rounds <n> Number of round-robin rounds to keep. Default: 3.
--dry-run Print the repair plan without writing. Default.
--apply Apply match, tournament code, and stats updates.
--env <env> dev | staging | prod. Default: NODE_ENV or dev.
`);
}
async function main() {
const options = parseArgs(process.argv.slice(2));
process.env.NODE_ENV = options.nodeEnv;
await loadMachineEnvFile();
const app = await NestFactory.createApplicationContext(RepairModule, {
logger: ['log', 'warn', 'error'],
});
try {
const connectionService = app.get(ConnectionService);
const matchStatsService = app.get(MatchStatsService);
const MatchModel = await connectionService.getModel('match');
const TournamentCodeModel =
await connectionService.getModel('tournamentCode');
const match = await MatchModel.findById(options.matchId).exec();
if (!match) {
throw new Error(`Match not found: ${options.matchId.toString()}`);
}
const codes = await TournamentCodeModel.find({
_id: { $in: match.tournamentCodeIds ?? [] },
})
.sort({ gameNumber: 1, reservedAt: 1, _id: 1 })
.exec();
const plan = buildRepairPlan(match, codes, options.maxRounds);
printPlan(options, match, codes, plan);
if (options.dryRun) {
console.log('No writes were made. Re-run with --apply to update MongoDB.');
return;
}
const now = new Date();
const session = await (await connectionService.getConnection()).startSession();
try {
await session.withTransaction(async () => {
await applyTournamentCodeUpdates(plan, now, session);
await MatchModel.updateOne(
{ _id: match._id },
{
$set: {
status: 'finished',
roundRobinMaxRounds: options.maxRounds,
gameSchedule: plan.schedule,
tournamentCodeIds: [
...plan.usedCodeByOldGameNumber.values(),
].map((code) => code._id),
resultPollState: {
startedAt: match.resultPollState?.startedAt ?? now,
lastPolledAt: now,
lastPollOutcome: 'matched',
matchedCount: plan.gamePlans.length,
expandedToAllPuuids: true,
state: 'complete',
},
result: {
winnerTeamIndex: plan.winnerTeamIndex,
mvpUserId: match.result?.mvpUserId,
riotMatchIds: plan.gamePlans.map(
(gamePlan) => gamePlan.game.riotMatchId,
),
games: plan.gamePlans.map((gamePlan) => ({
...toPlainGame(gamePlan.game),
gameNumber: gamePlan.newGameNumber,
})),
seriesResults: plan.seriesResults,
},
},
},
{ session },
).exec();
});
} finally {
await session.endSession();
}
await matchStatsService.buildAndUpsert(match._id);
console.log('Repair applied and match stats rebuilt.');
} finally {
await app.close();
await mongoose.disconnect();
}
}
function buildRepairPlan(
match: MatchDocument,
codes: TournamentCodeDocument[],
maxRounds: number,
): RepairPlan {
if (match.gameMode !== 'round-robin') {
throw new Error(`Expected round-robin match, got ${match.gameMode}.`);
}
const games = [...(match.result?.games ?? [])]
.map(toPlainGame)
.sort((left, right) => left.gameNumber - right.gameNumber);
if (games.length === 0) {
throw new Error('Match has no result games to preserve.');
}
const teamIndexes = [...new Set(match.teams.map((team) => team.teamIndex))]
.filter((teamIndex) => Number.isInteger(teamIndex) && teamIndex > 0)
.sort((left, right) => left - right);
if (teamIndexes.length < 2) {
throw new Error('Match needs at least two teams.');
}
if (teamIndexes.length % 2 !== 0) {
throw new Error('This repair script currently expects an even team count.');
}
const gamesPerRound = teamIndexes.length / 2;
const requiredGames = gamesPerRound * maxRounds;
if (games.length !== requiredGames) {
throw new Error(
`Expected ${requiredGames} result games for ${maxRounds} rounds and ${teamIndexes.length} teams, got ${games.length}.`,
);
}
validateResultGames(games, teamIndexes);
const rounds = partitionIntoRounds(games, teamIndexes, maxRounds);
const gamePlans = rounds.flatMap((roundGames, roundIndex) =>
sortRoundGames(roundGames).map((game, gameIndex) => ({
oldGameNumber: game.gameNumber,
newGameNumber: roundIndex * gamesPerRound + gameIndex + 1,
roundNumber: roundIndex + 1,
teamAIndex: Math.min(game.blueTeamIndex, game.redTeamIndex),
teamBIndex: Math.max(game.blueTeamIndex, game.redTeamIndex),
game,
})),
);
const schedule = gamePlans.map(
({ newGameNumber, roundNumber, teamAIndex, teamBIndex }) => ({
gameNumber: newGameNumber,
roundNumber,
teamAIndex,
teamBIndex,
}),
);
const usedOldGameNumbers = new Set(
gamePlans.map((gamePlan) => gamePlan.oldGameNumber),
);
const usedCodeByOldGameNumber = resolveUsedCodesByOldGameNumber(
codes,
gamePlans,
);
const releasedCodes = codes.filter(
(code) => !usedOldGameNumbers.has(code.gameNumber ?? 0),
);
const unsafeReleased = releasedCodes.filter((code) => code.state === 'used');
if (unsafeReleased.length > 0) {
throw new Error(
`Refusing to release used tournament codes without matching result games: ${unsafeReleased
.map((code) => formatCode(code))
.join(', ')}`,
);
}
const updatedGames = gamePlans.map((gamePlan) => ({
...toPlainGame(gamePlan.game),
gameNumber: gamePlan.newGameNumber,
}));
const seriesResults = buildSeriesResults(updatedGames);
return {
schedule,
gamePlans,
seriesResults,
winnerTeamIndex: resolveMatchWinnerTeamIndex(seriesResults),
usedCodeByOldGameNumber,
releasedCodes,
};
}
function validateResultGames(games: MatchGameResult[], teamIndexes: number[]) {
const validTeamIndexes = new Set(teamIndexes);
const pairKeys = new Set<string>();
const gameNumbers = new Set<number>();
for (const game of games) {
if (gameNumbers.has(game.gameNumber)) {
throw new Error(`Duplicate result gameNumber: ${game.gameNumber}.`);
}
gameNumbers.add(game.gameNumber);
if (!validTeamIndexes.has(game.blueTeamIndex)) {
throw new Error(`Invalid blueTeamIndex ${game.blueTeamIndex}.`);
}
if (!validTeamIndexes.has(game.redTeamIndex)) {
throw new Error(`Invalid redTeamIndex ${game.redTeamIndex}.`);
}
if (game.blueTeamIndex === game.redTeamIndex) {
throw new Error(`Game ${game.gameNumber} has the same team twice.`);
}
const key = pairKey(game);
if (pairKeys.has(key)) {
throw new Error(`Duplicate team pair in results: ${key}.`);
}
pairKeys.add(key);
}
}
function partitionIntoRounds(
games: MatchGameResult[],
teamIndexes: number[],
maxRounds: number,
): MatchGameResult[][] {
const targetPerRound = teamIndexes.length / 2;
const unused = new Set(games.map((game) => game.gameNumber));
const byGameNumber = new Map(games.map((game) => [game.gameNumber, game]));
const rounds: MatchGameResult[][] = [];
function fillRound(roundIndex: number): boolean {
if (roundIndex === maxRounds) return unused.size === 0;
const candidates = enumerateRoundCandidates(
[...unused]
.map((gameNumber) => byGameNumber.get(gameNumber))
.filter((game): game is MatchGameResult => Boolean(game)),
teamIndexes,
targetPerRound,
);
for (const candidate of candidates) {
for (const game of candidate) unused.delete(game.gameNumber);
rounds[roundIndex] = candidate;
if (fillRound(roundIndex + 1)) return true;
for (const game of candidate) unused.add(game.gameNumber);
}
rounds.length = roundIndex;
return false;
}
if (!fillRound(0)) {
throw new Error('Could not partition result games into simultaneous rounds.');
}
return rounds;
}
function enumerateRoundCandidates(
availableGames: MatchGameResult[],
teamIndexes: number[],
targetPerRound: number,
): MatchGameResult[][] {
const candidates: MatchGameResult[][] = [];
function visit(usedTeams: Set<number>, chosen: MatchGameResult[]) {
if (chosen.length === targetPerRound) {
candidates.push([...chosen]);
return;
}
const nextTeam = teamIndexes.find((teamIndex) => !usedTeams.has(teamIndex));
if (!nextTeam) return;
const nextGames = availableGames
.filter((game) => {
if (!includesTeam(game, nextTeam)) return false;
return (
!usedTeams.has(game.blueTeamIndex) &&
!usedTeams.has(game.redTeamIndex)
);
})
.sort((left, right) => left.gameNumber - right.gameNumber);
for (const game of nextGames) {
chosen.push(game);
usedTeams.add(game.blueTeamIndex);
usedTeams.add(game.redTeamIndex);
visit(usedTeams, chosen);
usedTeams.delete(game.blueTeamIndex);
usedTeams.delete(game.redTeamIndex);
chosen.pop();
}
}
visit(new Set<number>(), []);
return candidates;
}
function sortRoundGames(games: MatchGameResult[]) {
return [...games].sort(
(left, right) =>
Math.min(left.blueTeamIndex, left.redTeamIndex) -
Math.min(right.blueTeamIndex, right.redTeamIndex) ||
Math.max(left.blueTeamIndex, left.redTeamIndex) -
Math.max(right.blueTeamIndex, right.redTeamIndex),
);
}
function resolveUsedCodesByOldGameNumber(
codes: TournamentCodeDocument[],
gamePlans: ResultGamePlan[],
): Map<number, TournamentCodeDocument> {
const byGameNumber = new Map<number, TournamentCodeDocument[]>();
for (const code of codes) {
if (!code.gameNumber) continue;
const existing = byGameNumber.get(code.gameNumber) ?? [];
existing.push(code);
byGameNumber.set(code.gameNumber, existing);
}
const result = new Map<number, TournamentCodeDocument>();
for (const gamePlan of gamePlans) {
const candidates = byGameNumber.get(gamePlan.oldGameNumber) ?? [];
if (candidates.length !== 1) {
throw new Error(
`Expected exactly one tournament code for old game ${gamePlan.oldGameNumber}, got ${candidates.length}.`,
);
}
const [code] = candidates;
if (code.riotMatchId && code.riotMatchId !== gamePlan.game.riotMatchId) {
throw new Error(
`Tournament code ${formatCode(code)} has riotMatchId ${code.riotMatchId}, expected ${gamePlan.game.riotMatchId}.`,
);
}
result.set(gamePlan.oldGameNumber, code);
}
return result;
}
async function applyTournamentCodeUpdates(
plan: RepairPlan,
now: Date,
session: mongoose.ClientSession,
) {
const usedOperations = plan.gamePlans.map((gamePlan) => {
const code = plan.usedCodeByOldGameNumber.get(gamePlan.oldGameNumber);
if (!code) {
throw new Error(`Missing tournament code for ${gamePlan.oldGameNumber}.`);
}
return code.updateOne(
{
$set: {
state: 'used',
gameNumber: gamePlan.newGameNumber,
riotMatchId: gamePlan.game.riotMatchId,
usedAt: resolveGameEndedAt(gamePlan.game),
},
$unset: {
releasedAt: '',
},
},
{ session },
);
});
const releasedOperations = plan.releasedCodes.map((code) =>
code.updateOne(
{
$set: {
state: 'released',
releasedAt: now,
},
$unset: {
matchId: '',
gameNumber: '',
reservedAt: '',
usedAt: '',
riotMatchId: '',
},
},
{ session },
),
);
await Promise.all([...usedOperations, ...releasedOperations]);
}
function buildSeriesResults(games: MatchGameResult[]): MatchSeriesResult[] {
const bySeries = new Map<string, MatchSeriesResult>();
for (const game of games) {
const teamAIndex = Math.min(game.blueTeamIndex, game.redTeamIndex);
const teamBIndex = Math.max(game.blueTeamIndex, game.redTeamIndex);
const key = `${teamAIndex}:${teamBIndex}`;
const current =
bySeries.get(key) ??
({
teamAIndex,
teamBIndex,
teamAWins: 0,
teamBWins: 0,
} satisfies MatchSeriesResult);
if (game.winnerTeamIndex === teamAIndex) current.teamAWins += 1;
if (game.winnerTeamIndex === teamBIndex) current.teamBWins += 1;
current.winnerTeamIndex =
current.teamAWins > current.teamBWins
? teamAIndex
: current.teamBWins > current.teamAWins
? teamBIndex
: undefined;
bySeries.set(key, current);
}
return [...bySeries.values()].sort(
(left, right) =>
left.teamAIndex - right.teamAIndex ||
left.teamBIndex - right.teamBIndex,
);
}
function resolveMatchWinnerTeamIndex(seriesResults: MatchSeriesResult[]) {
const winsByTeam = new Map<number, number>();
for (const series of seriesResults) {
if (!series.winnerTeamIndex) continue;
winsByTeam.set(
series.winnerTeamIndex,
(winsByTeam.get(series.winnerTeamIndex) ?? 0) + 1,
);
}
const sorted = [...winsByTeam.entries()].sort(
(left, right) => right[1] - left[1],
);
if (sorted.length === 0) return undefined;
if (sorted.length > 1 && sorted[0][1] === sorted[1][1]) return undefined;
return sorted[0][0];
}
function printPlan(
options: CliOptions,
match: MatchDocument,
codes: TournamentCodeDocument[],
plan: RepairPlan,
) {
console.log(
`[limited round-robin repair] mode=${options.dryRun ? 'dry-run' : 'apply'} env=${options.nodeEnv} db=${resolveMongoDbName(options.nodeEnv)}`,
);
console.log(
`[limited round-robin repair] match=${match._id.toString()} title="${match.title}"`,
);
console.log(
`[limited round-robin repair] status ${match.status} -> finished, maxRounds=${options.maxRounds}`,
);
console.log(
`[limited round-robin repair] resultGames=${plan.gamePlans.length} codes kept=${plan.usedCodeByOldGameNumber.size} codes released=${plan.releasedCodes.length} previousCodeIds=${codes.length}`,
);
console.log(
`[limited round-robin repair] winnerTeamIndex=${plan.winnerTeamIndex ?? '(tie)'}`,
);
for (const gamePlan of plan.gamePlans) {
console.log(
` R${gamePlan.roundNumber} G${gamePlan.newGameNumber}: ${gamePlan.teamAIndex}팀 vs ${gamePlan.teamBIndex}팀 (old G${gamePlan.oldGameNumber}, riot=${gamePlan.game.riotMatchId})`,
);
}
}
function toPlainGame(game: MatchGameResult): MatchGameResult {
const maybeSubdocument = game as unknown as {
toObject?: () => MatchGameResult;
};
const objectValue =
typeof maybeSubdocument.toObject === 'function'
? maybeSubdocument.toObject()
: game;
return {
...objectValue,
participants: [...(objectValue.participants ?? [])],
};
}
function includesTeam(game: MatchGameResult, teamIndex: number) {
return game.blueTeamIndex === teamIndex || game.redTeamIndex === teamIndex;
}
function pairKey(game: MatchGameResult) {
const teamAIndex = Math.min(game.blueTeamIndex, game.redTeamIndex);
const teamBIndex = Math.max(game.blueTeamIndex, game.redTeamIndex);
return `${teamAIndex}:${teamBIndex}`;
}
function resolveGameEndedAt(game: MatchGameResult) {
return new Date(game.gameCreation + game.gameDuration * 1000);
}
function formatCode(code: TournamentCodeDocument) {
return `${code._id.toString()}(gameNumber=${code.gameNumber ?? 'none'}, state=${code.state})`;
}
void main()
.then(() => {
process.exit(0);
})
.catch((error: unknown) => {
console.error(error instanceof Error ? error.message : error);
process.exit(1);
});
@@ -0,0 +1,363 @@
import 'reflect-metadata';
import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { NestFactory } from '@nestjs/core';
import mongoose from 'mongoose';
import { readFile } from 'node:fs/promises';
import { resolve } from 'node:path';
import { ConnectionService, resolveMongoDbName } from '../connection.service';
import { SecretModule } from '../../secret/secret.module';
import { migrateAuctionRedisFieldRename } from './20260622-auction-redis-field-rename';
interface CliOptions {
duplicateSampleLimit: number;
dryRun: boolean;
limit?: number;
listDuplicates: boolean;
nodeEnv: string;
repairDuplicateSequences: boolean;
}
interface DuplicateSequenceRepairStats {
affectedAuctions: number;
changedAuctionSequenceFields: number;
changedHistoryEntries: number;
scannedHistoryEntries: number;
}
@Module({
imports: [
ConfigModule.forRoot({
isGlobal: true,
envFilePath: [
resolve(__dirname, '../../../../../../project.env'),
resolve(process.cwd(), '../project.env'),
resolve(process.cwd(), 'apps/project.env'),
resolve(process.cwd(), 'project.env'),
],
}),
SecretModule,
],
providers: [ConnectionService],
})
class MigrationModule {}
async function loadMachineEnvFile() {
const homeDir = process.env.HOME ?? process.env.USERPROFILE;
if (!homeDir) return;
const machineEnvFile = resolve(homeDir, 'source/global-env-vars.txt');
try {
const file = await readFile(machineEnvFile, 'utf8');
for (const rawLine of file.split(/\r?\n/)) {
const line = rawLine.trim();
if (!line || line.startsWith('#')) continue;
const matched = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
if (!matched) continue;
const [, key, rawValue] = matched;
process.env[key] = rawValue.replace(/^["']|["']$/g, '');
}
} catch {
// 로컬 machine env 파일이 없으면 그냥 지나간다.
}
}
function parseArgs(argv: string[]): CliOptions {
let dryRun = true;
let duplicateSampleLimit = 20;
let limit: number | undefined;
let listDuplicates = false;
let nodeEnv = process.env.NODE_ENV ?? 'dev';
let repairDuplicateSequences = false;
for (let index = 0; index < argv.length; index += 1) {
const arg = argv[index];
if (arg === '--apply') {
dryRun = false;
continue;
}
if (arg === '--dry-run') {
dryRun = true;
continue;
}
if (arg === '--list-duplicates') {
listDuplicates = true;
continue;
}
if (arg === '--repair-duplicate-sequences') {
repairDuplicateSequences = true;
continue;
}
if (arg === '--duplicate-sample-limit') {
duplicateSampleLimit = parsePositiveInteger(
argv[index + 1],
'--duplicate-sample-limit',
);
index += 1;
continue;
}
if (arg.startsWith('--duplicate-sample-limit=')) {
duplicateSampleLimit = parsePositiveInteger(
arg.slice('--duplicate-sample-limit='.length),
'--duplicate-sample-limit',
);
continue;
}
if (arg === '--env') {
const value = argv[index + 1];
if (!value) throw new Error('--env requires dev, staging, or prod.');
nodeEnv = value;
index += 1;
continue;
}
if (arg.startsWith('--env=')) {
nodeEnv = arg.slice('--env='.length);
continue;
}
if (arg === '--limit') {
limit = parsePositiveInteger(argv[index + 1], '--limit');
index += 1;
continue;
}
if (arg.startsWith('--limit=')) {
limit = parsePositiveInteger(arg.slice('--limit='.length), '--limit');
continue;
}
if (arg === '--help' || arg === '-h') {
printHelp();
process.exit(0);
}
throw new Error(`Unknown argument: ${arg}`);
}
if (!['dev', 'staging', 'prod'].includes(nodeEnv)) {
throw new Error('--env must be dev, staging, or prod.');
}
return {
duplicateSampleLimit,
dryRun,
limit,
listDuplicates,
nodeEnv,
repairDuplicateSequences,
};
}
function parsePositiveInteger(value: string | undefined, label: string) {
const parsed = Number(value);
if (!Number.isInteger(parsed) || parsed < 1) {
throw new Error(`${label} requires a positive integer.`);
}
return parsed;
}
function printHelp() {
console.log(`Usage:
pnpm --filter api exec ts-node src/modules/global/database/migrations/run-auction-redis-field-rename.ts [--dry-run]
pnpm --filter api exec ts-node src/modules/global/database/migrations/run-auction-redis-field-rename.ts --env staging --apply
Options:
--dry-run Print affected counts without writing. Default.
--apply Apply auction and auctionHistory field updates.
--env <env> dev | staging | prod. Default: NODE_ENV or dev.
--limit <n> Only scan first n documents per collection.
--list-duplicates
Print duplicate auctionHistory auctionId+sequence samples.
--duplicate-sample-limit <n>
Max duplicate groups to print. Default: 20.
--repair-duplicate-sequences
Resequence affected auctionHistory rows by takenAt/createdAt/_id before migration.
`);
}
async function findAuctionIdsWithDuplicateHistorySequences(
db: NonNullable<mongoose.Connection['db']>,
): Promise<unknown[]> {
const groups = await db
.collection('auctionHistory')
.aggregate([
{
$group: {
_id: { auctionId: '$auctionId', sequence: '$sequence' },
count: { $sum: 1 },
},
},
{ $match: { count: { $gt: 1 } } },
{ $group: { _id: '$_id.auctionId' } },
])
.toArray();
return groups.map((group) => group._id).filter(Boolean);
}
async function listDuplicateHistorySequences(
db: NonNullable<mongoose.Connection['db']>,
sampleLimit: number,
) {
return db
.collection('auctionHistory')
.aggregate([
{
$group: {
_id: { auctionId: '$auctionId', sequence: '$sequence' },
actions: { $push: '$action' },
count: { $sum: 1 },
createdAtValues: { $push: '$createdAt' },
historyIds: { $push: '$_id' },
matchIds: { $addToSet: '$matchId' },
takenAtValues: { $push: '$takenAt' },
},
},
{ $match: { count: { $gt: 1 } } },
{ $sort: { count: -1, '_id.sequence': 1 } },
{ $limit: sampleLimit },
])
.toArray();
}
function printDuplicateHistorySequences(groups: Awaited<
ReturnType<typeof listDuplicateHistorySequences>
>) {
if (groups.length === 0) {
console.log('No duplicate auctionHistory auctionId+sequence groups found.');
return;
}
console.log('Duplicate auctionHistory auctionId+sequence groups:');
console.table(
groups.map((group) => ({
actions: (group.actions as unknown[]).map(String).join(', '),
auctionId: String(group._id?.auctionId ?? ''),
count: group.count,
createdAt: (group.createdAtValues as unknown[]).map(String).join(', '),
historyIds: (group.historyIds as unknown[]).map(String).join(', '),
matchIds: (group.matchIds as unknown[]).map(String).join(', '),
sequence: group._id?.sequence,
takenAt: (group.takenAtValues as unknown[]).map(String).join(', '),
})),
);
}
async function repairDuplicateHistorySequences(
db: NonNullable<mongoose.Connection['db']>,
dryRun: boolean,
): Promise<DuplicateSequenceRepairStats> {
const historyCollection = db.collection('auctionHistory');
const auctionCollection = db.collection('auction');
const affectedAuctionIds = await findAuctionIdsWithDuplicateHistorySequences(db);
const stats: DuplicateSequenceRepairStats = {
affectedAuctions: affectedAuctionIds.length,
changedAuctionSequenceFields: 0,
changedHistoryEntries: 0,
scannedHistoryEntries: 0,
};
for (const auctionId of affectedAuctionIds) {
const histories = await historyCollection
.find({ auctionId })
.project({ _id: 1, createdAt: 1, sequence: 1, takenAt: 1 })
.sort({ takenAt: 1, createdAt: 1, _id: 1 })
.toArray();
stats.scannedHistoryEntries += histories.length;
const writes = histories
.map((history, index) => ({
history,
nextSequence: index + 1,
}))
.filter(({ history, nextSequence }) => history.sequence !== nextSequence);
stats.changedHistoryEntries += writes.length;
stats.changedAuctionSequenceFields += 1;
if (dryRun) continue;
if (writes.length > 0) {
await historyCollection.bulkWrite(
writes.map(({ history, nextSequence }) => ({
updateOne: {
filter: { _id: history._id },
update: { $set: { sequence: nextSequence } },
},
})),
{ ordered: true },
);
}
await auctionCollection.updateOne(
{ _id: auctionId } as Record<string, unknown>,
{ $set: { currentAuctionHistorySequence: histories.length } },
);
}
return stats;
}
async function main() {
const options = parseArgs(process.argv.slice(2));
process.env.NODE_ENV = options.nodeEnv;
process.env.SECRET_SOURCE = process.env.SECRET_SOURCE || 'infisical';
await loadMachineEnvFile();
const app = await NestFactory.createApplicationContext(MigrationModule, {
logger: ['log', 'warn', 'error'],
});
try {
const connectionService = app.get(ConnectionService);
const connection = await connectionService.getConnection();
if (!connection.db) {
throw new Error('MongoDB connection has no db handle.');
}
const dbName = resolveMongoDbName(options.nodeEnv);
console.log(
`[auction redis field rename migration] mode=${
options.dryRun ? 'dry-run' : 'apply'
} env=${options.nodeEnv} db=${dbName}`,
);
if (options.repairDuplicateSequences) {
const repairStats = await repairDuplicateHistorySequences(
connection.db,
options.dryRun,
);
console.log('Duplicate auctionHistory sequence repair:');
console.table(repairStats);
}
const stats = await migrateAuctionRedisFieldRename(
connection.db as Parameters<typeof migrateAuctionRedisFieldRename>[0],
{
dryRun: options.dryRun,
limit: options.limit,
},
);
console.table(stats);
if (options.listDuplicates && stats.duplicateHistorySequences > 0) {
const duplicateGroups = await listDuplicateHistorySequences(
connection.db,
options.duplicateSampleLimit,
);
printDuplicateHistorySequences(duplicateGroups);
}
if (options.dryRun) {
console.log(
'No writes were made. Re-run with --apply to update documents.',
);
} else {
console.log('Migration applied.');
}
} finally {
await app.close();
await mongoose.disconnect();
}
}
void main().catch((error: unknown) => {
console.error(error instanceof Error ? error.message : error);
process.exitCode = 1;
});
+389 -21
View File
@@ -153,14 +153,42 @@ export const AUCTION_TOP_TIER_THRESHOLDS = [
] as const;
export type AuctionTopTierThreshold =
(typeof AUCTION_TOP_TIER_THRESHOLDS)[number];
export type AuctionActionType =
| 'start'
| 'open-bidding'
| 'bid'
| 'sold'
| 'passed'
| 'next'
| 'complete';
export const AUCTION_ACTION_TYPES = [
'start',
'open-bidding',
'bid',
'sold',
'passed',
'next',
'complete',
'reset',
'undo',
] as const;
export type AuctionActionType = (typeof AUCTION_ACTION_TYPES)[number];
export const AUCTION_ENGINE_VERSIONS = ['redis-v1', 'legacy-renamed'] as const;
export type AuctionEngineVersion = (typeof AUCTION_ENGINE_VERSIONS)[number];
export const AUCTION_MATCH_SIDE_EFFECT_STATUSES = [
'none',
'pending',
'processing',
'completed',
'failed',
] as const;
export type AuctionMatchSideEffectStatus =
(typeof AUCTION_MATCH_SIDE_EFFECT_STATUSES)[number];
export const AUCTION_SIDE_EFFECT_APPLICATION_STATES = [
'pending',
'processing',
'completed',
'failed',
] as const;
export type AuctionSideEffectApplicationState =
(typeof AUCTION_SIDE_EFFECT_APPLICATION_STATES)[number];
export type AuctionHistoryMutation =
| { type: 'append' }
| { targetHistorySequence: number; type: 'deleteAfterSequenceAndAppendUndo' }
| { resetMode: 'clear-history' | 'preserve-audit'; type: 'reset' };
export interface MongooseTimestamps {
createdAt: Date;
@@ -398,6 +426,8 @@ export interface RiotMatch extends MongooseTimestamps {
queueId?: number;
participantPuuids: string[];
raw: Record<string, unknown>; // Riot API Match-V5 원본 응답 전체
timeline?: Record<string, unknown>; // Riot API Match-V5 timeline 원본 응답 전체
timelineFetchedAt?: Date;
fetchedAt: Date;
}
@@ -487,6 +517,7 @@ export interface MatchSeriesResult {
export interface MatchGameAssignment {
gameNumber: number;
roundNumber?: number;
teamAIndex: number;
teamBIndex: number;
}
@@ -524,6 +555,7 @@ export interface Match extends MongooseTimestamps {
maxParticipants: number;
gameCount: number;
gameMode: MatchGameMode;
roundRobinMaxRounds?: number;
tournamentCodeIds: mongoose.Types.ObjectId[];
gameSchedule: MatchGameAssignment[];
teamBuiltAt?: Date;
@@ -612,6 +644,20 @@ export interface AuctionTeam {
members: AuctionTeamMember[];
}
export interface RedisAuctionTeamMember {
userId: mongoose.Types.ObjectId;
assignedPosition: Position;
memberAcquisitionBidPointAmount: number;
}
export interface RedisAuctionTeam {
teamIndex: number;
name?: string;
captainUserId: mongoose.Types.ObjectId;
remainingBidPointAmount: number;
members: RedisAuctionTeamMember[];
}
export interface AuctionBid {
teamIndex: number;
amount: number;
@@ -619,6 +665,13 @@ export interface AuctionBid {
timestamp: Date;
}
export interface AuctionBidHistoryEntry {
bidderTeamIndex: number;
bidPointAmount: number;
bidderUserId: mongoose.Types.ObjectId;
bidPlacedAtTimestampMS: number;
}
export interface AuctionChatMessage {
id: string;
userId?: mongoose.Types.ObjectId;
@@ -630,6 +683,17 @@ export interface AuctionChatMessage {
export interface Auction extends MongooseTimestamps {
matchId: mongoose.Types.ObjectId;
phase: AuctionPhase;
revision: number;
auctionEngineVersion?: AuctionEngineVersion;
auctionLifecycleId?: string;
lastAppliedAuctionStateTransitionId?: string;
currentAuctionHistorySequence: number;
startAuctionRequestId?: string;
startAuctionStateTransitionId?: string;
auctionStartedByUserId?: mongoose.Types.ObjectId;
matchSideEffectStatus: AuctionMatchSideEffectStatus;
matchSideEffectRevision: number;
matchSideEffectError?: string;
teams: AuctionTeam[];
order: AuctionPlayerSnapshot[];
passedQueue: AuctionPlayerSnapshot[];
@@ -647,6 +711,22 @@ export interface Auction extends MongooseTimestamps {
chatMessages: AuctionChatMessage[];
startedAt?: Date;
completedAt?: Date;
auctionTeams?: RedisAuctionTeam[];
auctionPlayerOrder?: AuctionPlayerSnapshot[];
passedAuctionPlayerQueue?: AuctionPlayerSnapshot[];
currentAuctionRound?: number;
currentAuctionPlayerOrderIndex?: number;
auctionBidHistory?: AuctionBidHistoryEntry[];
currentHighestBidPointAmount?: number;
currentHighestBidderTeamIndex?: number;
currentBidRoundDeadlineTimestampMS?: number;
maximumBidRoundDurationSeconds?: number;
bidRoundExtensionSeconds?: number;
initialTeamBidPointAmount?: number;
topTierAuctionPriorityThreshold?: AuctionTopTierThreshold;
manualTopTierAuctionPriorityUserIds?: mongoose.Types.ObjectId[];
auctionStartedAtTimestampMS?: number;
auctionCompletedAtTimestampMS?: number;
}
export type AuctionDocument = HydratedDocument<Auction>;
@@ -656,14 +736,72 @@ export interface AuctionHistoryEntry extends MongooseTimestamps {
matchId: mongoose.Types.ObjectId;
sequence: number;
action: AuctionActionType;
auctionStateTransitionId?: string;
auctionLifecycleId?: string;
revision?: number;
actorUserId?: mongoose.Types.ObjectId;
snapshotBefore: Record<string, unknown>;
historyMutation?: AuctionHistoryMutation;
matchSideEffectMutation?: Record<string, unknown>;
takenAt: Date;
}
export type AuctionHistoryEntryDocument = HydratedDocument<AuctionHistoryEntry>;
export interface AuctionSideEffectApplication extends MongooseTimestamps {
auctionId: mongoose.Types.ObjectId;
matchId: mongoose.Types.ObjectId;
auctionStateTransitionId: string;
auctionLifecycleId: string;
sideEffectType: string;
state: AuctionSideEffectApplicationState;
payload: Record<string, unknown>;
payloadChecksum: string;
attempts: number;
processingStartedAtTimestampMS?: number;
processingLeaseExpiresAtTimestampMS?: number;
processingOwnerToken?: string;
completedAtTimestampMS?: number;
lastError?: string;
}
export type AuctionSideEffectApplicationDocument =
HydratedDocument<AuctionSideEffectApplication>;
// ===== MatchStats (precomputed internal stats fragment) =====
export interface MatchStatsRuneStyleSelection {
styleId: number;
perkIds: number[];
}
export interface MatchStatsRunePerks {
primaryStyle?: number;
subStyle?: number;
keystone?: number;
selectedPerkIds?: number[];
styles?: MatchStatsRuneStyleSelection[];
statPerks?: {
offense?: number;
flex?: number;
defense?: number;
};
}
export interface MatchStatsItemBuildEvent {
timestamp: number;
itemId: number;
type: 'purchased' | 'sold' | 'destroyed' | 'undo';
beforeId?: number;
afterId?: number;
}
export interface MatchStatsSkillBuildEvent {
timestamp: number;
skillSlot: 1 | 2 | 3 | 4;
level: number;
levelUpType?: string;
}
export interface MatchStatsRecord {
matchId: string;
title: string;
@@ -674,6 +812,7 @@ export interface MatchStatsRecord {
gameDuration: number;
userId: string;
summonerName: string;
tagLine: string;
profileIconId: number;
teamIndex: number;
side: TeamSide;
@@ -696,10 +835,14 @@ export interface MatchStatsRecord {
controlWardsBought: number;
wardsPlaced: number;
wardsKilled: number;
firstBloodKill: boolean;
firstBloodAssist: boolean;
items: number[];
trinket: number;
summonerSpells: [number, number];
perks: { primaryStyle?: number; subStyle?: number; keystone?: number };
perks: MatchStatsRunePerks;
itemBuild: MatchStatsItemBuildEvent[];
skillBuild: MatchStatsSkillBuildEvent[];
rating: number;
}
@@ -708,16 +851,46 @@ export interface MatchStatsGameDetail {
riotMatchId: string;
gameCreation: number;
gameDuration: number;
gameVersion?: string;
winnerSide: TeamSide;
timeline: MatchStatsTimelinePoint[];
timelineLoaded?: boolean;
objectiveEvents: MatchStatsObjectiveEvent[];
teams: Array<{
teamIndex: number;
side: TeamSide;
win: boolean;
objectives: { baron: number; dragon: number; tower: number };
objectives: MatchStatsObjectiveSummary;
bans: Array<{ championId: number; pickTurn: number }>;
participants: MatchStatsRecord[];
}>;
}
export interface MatchStatsObjectiveSummary {
tower: number;
dragon: number;
inhibitor: number;
baron: number;
riftHerald: number;
voidGrub: number;
elderDragon: number;
}
export interface MatchStatsObjectiveEvent {
timestamp: number;
side: TeamSide;
type: 'dragon' | 'elderDragon' | 'baron' | 'riftHerald' | 'voidGrub';
monsterSubType?: string;
}
export interface MatchStatsTimelinePoint {
timestamp: number;
blue: { gold: number; xp: number };
red: { gold: number; xp: number };
goldDiff: number;
xpDiff: number;
}
export interface MatchStats extends MongooseTimestamps {
matchId: mongoose.Types.ObjectId;
communityId: mongoose.Types.ObjectId;
@@ -1133,6 +1306,8 @@ export const RiotMatchSchema = new Schema<RiotMatch>(
queueId: { type: Number },
participantPuuids: { type: [String], required: true, default: [] },
raw: { type: Schema.Types.Mixed, required: true, default: () => ({}) },
timeline: { type: Schema.Types.Mixed },
timelineFetchedAt: { type: Date },
fetchedAt: { type: Date, required: true, default: Date.now },
},
{
@@ -1151,7 +1326,6 @@ export const TournamentCodeSchema = new Schema<TournamentCode>(
type: String,
required: true,
trim: true,
uppercase: true,
},
region: { type: String, required: true, default: 'kr' },
mapType: {
@@ -1284,6 +1458,7 @@ const MatchSeriesResultSubSchema = new Schema<MatchSeriesResult>(
const MatchGameAssignmentSubSchema = new Schema<MatchGameAssignment>(
{
gameNumber: { type: Number, required: true, min: 1 },
roundNumber: { type: Number, required: false, min: 1 },
teamAIndex: { type: Number, required: true, min: 1 },
teamBIndex: { type: Number, required: true, min: 1 },
},
@@ -1389,6 +1564,7 @@ export const MatchSchema = new Schema<Match>(
required: true,
default: 'pair',
},
roundRobinMaxRounds: { type: Number, required: false, min: 1 },
tournamentCodeIds: {
type: [{ type: Schema.Types.ObjectId, ref: 'tournamentCode' }],
required: true,
@@ -1571,6 +1747,34 @@ const AuctionTeamSubSchema = new Schema<AuctionTeam>(
{ _id: false },
);
const RedisAuctionTeamMemberSubSchema = new Schema<RedisAuctionTeamMember>(
{
userId: { type: Schema.Types.ObjectId, ref: 'user', required: true },
assignedPosition: { type: String, enum: POSITIONS, required: true },
memberAcquisitionBidPointAmount: {
type: Number,
required: true,
default: 0,
},
},
{ _id: false },
);
const RedisAuctionTeamSubSchema = new Schema<RedisAuctionTeam>(
{
teamIndex: { type: Number, required: true, min: 1 },
name: { type: String, required: false },
captainUserId: { type: Schema.Types.ObjectId, ref: 'user', required: true },
remainingBidPointAmount: { type: Number, required: true, default: 0 },
members: {
type: [RedisAuctionTeamMemberSubSchema],
required: true,
default: [],
},
},
{ _id: false },
);
const AuctionBidSubSchema = new Schema<AuctionBid>(
{
teamIndex: { type: Number, required: true, min: 1 },
@@ -1581,6 +1785,16 @@ const AuctionBidSubSchema = new Schema<AuctionBid>(
{ _id: false },
);
const AuctionBidHistoryEntrySubSchema = new Schema<AuctionBidHistoryEntry>(
{
bidderTeamIndex: { type: Number, required: true, min: 1 },
bidPointAmount: { type: Number, required: true },
bidderUserId: { type: Schema.Types.ObjectId, ref: 'user', required: true },
bidPlacedAtTimestampMS: { type: Number, required: true },
},
{ _id: false },
);
const AuctionChatMessageSubSchema = new Schema<AuctionChatMessage>(
{
id: { type: String, required: true },
@@ -1606,6 +1820,40 @@ export const AuctionSchema = new Schema<Auction>(
required: true,
default: 'waiting',
},
revision: { type: Number, required: true, default: 0, min: 0 },
auctionEngineVersion: {
type: String,
enum: AUCTION_ENGINE_VERSIONS,
required: false,
},
auctionLifecycleId: { type: String, required: false },
lastAppliedAuctionStateTransitionId: { type: String, required: false },
currentAuctionHistorySequence: {
type: Number,
required: true,
default: 0,
min: 0,
},
startAuctionRequestId: { type: String, required: false },
startAuctionStateTransitionId: { type: String, required: false },
auctionStartedByUserId: {
type: Schema.Types.ObjectId,
ref: 'user',
required: false,
},
matchSideEffectStatus: {
type: String,
enum: AUCTION_MATCH_SIDE_EFFECT_STATUSES,
required: true,
default: 'none',
},
matchSideEffectRevision: {
type: Number,
required: true,
default: 0,
min: 0,
},
matchSideEffectError: { type: String, required: false },
teams: { type: [AuctionTeamSubSchema], required: true, default: [] },
order: {
type: [AuctionPlayerSnapshotSubSchema],
@@ -1645,6 +1893,55 @@ export const AuctionSchema = new Schema<Auction>(
},
startedAt: { type: Date, required: false },
completedAt: { type: Date, required: false },
auctionTeams: {
type: [RedisAuctionTeamSubSchema],
required: false,
default: undefined,
},
auctionPlayerOrder: {
type: [AuctionPlayerSnapshotSubSchema],
required: false,
default: undefined,
},
passedAuctionPlayerQueue: {
type: [AuctionPlayerSnapshotSubSchema],
required: false,
default: undefined,
},
currentAuctionRound: { type: Number, required: false, min: 1 },
currentAuctionPlayerOrderIndex: { type: Number, required: false, min: 0 },
auctionBidHistory: {
type: [AuctionBidHistoryEntrySubSchema],
required: false,
default: undefined,
},
currentHighestBidPointAmount: { type: Number, required: false, min: 0 },
currentHighestBidderTeamIndex: { type: Number, required: false, min: 1 },
currentBidRoundDeadlineTimestampMS: {
type: Number,
required: false,
min: 0,
},
maximumBidRoundDurationSeconds: {
type: Number,
required: false,
min: 1,
},
bidRoundExtensionSeconds: { type: Number, required: false, min: 0 },
initialTeamBidPointAmount: { type: Number, required: false, min: 0 },
topTierAuctionPriorityThreshold: {
type: String,
enum: AUCTION_TOP_TIER_THRESHOLDS,
required: false,
},
manualTopTierAuctionPriorityUserIds: {
type: [Schema.Types.ObjectId],
ref: 'user',
required: false,
default: undefined,
},
auctionStartedAtTimestampMS: { type: Number, required: false, min: 0 },
auctionCompletedAtTimestampMS: { type: Number, required: false, min: 0 },
},
{
timestamps: true,
@@ -1652,7 +1949,7 @@ export const AuctionSchema = new Schema<Auction>(
},
);
const AuctionHistoryEntrySchema = new Schema<AuctionHistoryEntry>(
export const AuctionHistoryEntrySchema = new Schema<AuctionHistoryEntry>(
{
auctionId: {
type: Schema.Types.ObjectId,
@@ -1669,19 +1966,16 @@ const AuctionHistoryEntrySchema = new Schema<AuctionHistoryEntry>(
sequence: { type: Number, required: true, min: 1 },
action: {
type: String,
enum: [
'start',
'open-bidding',
'bid',
'sold',
'passed',
'next',
'complete',
],
enum: AUCTION_ACTION_TYPES,
required: true,
},
auctionStateTransitionId: { type: String, required: false },
auctionLifecycleId: { type: String, required: false },
revision: { type: Number, required: false, min: 0 },
actorUserId: { type: Schema.Types.ObjectId, ref: 'user', required: false },
snapshotBefore: { type: Schema.Types.Mixed, required: true },
historyMutation: { type: Schema.Types.Mixed, required: false },
matchSideEffectMutation: { type: Schema.Types.Mixed, required: false },
takenAt: { type: Date, required: true, default: Date.now },
},
{
@@ -1691,6 +1985,74 @@ const AuctionHistoryEntrySchema = new Schema<AuctionHistoryEntry>(
);
AuctionHistoryEntrySchema.index({ auctionId: 1, sequence: -1 });
AuctionHistoryEntrySchema.index(
{ auctionId: 1, sequence: 1 },
{ unique: true },
);
AuctionHistoryEntrySchema.index(
{ auctionId: 1, auctionStateTransitionId: 1 },
{ sparse: true, unique: true },
);
export const AuctionSideEffectApplicationSchema =
new Schema<AuctionSideEffectApplication>(
{
auctionId: {
type: Schema.Types.ObjectId,
ref: 'auction',
required: true,
index: true,
},
matchId: {
type: Schema.Types.ObjectId,
ref: 'match',
required: true,
index: true,
},
auctionStateTransitionId: { type: String, required: true },
auctionLifecycleId: { type: String, required: true },
sideEffectType: { type: String, required: true },
state: {
type: String,
enum: AUCTION_SIDE_EFFECT_APPLICATION_STATES,
required: true,
default: 'pending',
},
payload: { type: Schema.Types.Mixed, required: true, default: {} },
payloadChecksum: { type: String, required: true },
attempts: { type: Number, required: true, default: 0, min: 0 },
processingStartedAtTimestampMS: {
type: Number,
required: false,
min: 0,
},
processingLeaseExpiresAtTimestampMS: {
type: Number,
required: false,
min: 0,
},
processingOwnerToken: { type: String, required: false },
completedAtTimestampMS: { type: Number, required: false, min: 0 },
lastError: { type: String, required: false },
},
{
timestamps: true,
collection: 'auctionSideEffectApplications',
},
);
AuctionSideEffectApplicationSchema.index(
{
auctionId: 1,
auctionStateTransitionId: 1,
sideEffectType: 1,
},
{ unique: true },
);
AuctionSideEffectApplicationSchema.index({
state: 1,
processingLeaseExpiresAtTimestampMS: 1,
});
export const MatchStatsSchema: mongoose.Schema<MatchStats> = new Schema(
{
@@ -1765,6 +2127,11 @@ export const tournamentModelDefinitions: ModelDefinition[] = [
schema: AuctionHistoryEntrySchema,
schemaName: 'auctionHistory',
},
{
name: 'auctionSideEffectApplication',
schema: AuctionSideEffectApplicationSchema,
schemaName: 'auctionSideEffectApplication',
},
{
name: 'matchStats',
schema: MatchStatsSchema,
@@ -1785,5 +2152,6 @@ export interface TournamentModelTypes {
match: Match;
auction: Auction;
auctionHistory: AuctionHistoryEntry;
auctionSideEffectApplication: AuctionSideEffectApplication;
matchStats: MatchStats;
}
@@ -1 +0,0 @@
export const GARNET_CLIENT = Symbol('GARNET_CLIENT');
@@ -1,57 +0,0 @@
import { Logger, Module } from '@nestjs/common';
import { createClient } from 'redis';
import { SecretModule } from '../secret/secret.module';
import { SecretService } from '../secret/secret.service';
import { GARNET_CLIENT } from './garnet.constants';
import { GarnetService, type GarnetRedisClient } from './garnet.service';
function normalizeGarnetUrl(endpoint: string): string {
const trimmed = endpoint.trim();
if (!trimmed) {
throw new Error('GARNET_ENDPOINT cannot be empty');
}
if (/^redis(s)?:\/\//iu.test(trimmed)) {
return trimmed;
}
return `redis://${trimmed}`;
}
@Module({
imports: [SecretModule],
providers: [
{
provide: GARNET_CLIENT,
inject: [SecretService],
useFactory: async (
secretService: SecretService,
): Promise<GarnetRedisClient> => {
await secretService.ready();
const [endpoint, username, password] = await Promise.all([
secretService.get<string>('GARNET_ENDPOINT'),
secretService.get<string>('GARNET_USERID'),
secretService.get<string>('GARNET_PASSWORD'),
]);
const logger = new Logger('GarnetClient');
const client = createClient({
url: normalizeGarnetUrl(endpoint),
username,
password,
});
client.on('error', (error) => {
logger.error(`Garnet client error: ${error?.message ?? error}`);
});
await client.connect();
logger.log('Garnet connected');
return client;
},
},
GarnetService,
],
exports: [GarnetService, GARNET_CLIENT],
})
export class GarnetModule {}
+3 -3
View File
@@ -2,12 +2,12 @@ import { Module, Global } from '@nestjs/common';
import { SecretModule } from './secret/secret.module';
import { NatsModule } from './nats/nats.module';
import { DatabaseModule } from './database/database.module';
import { GarnetModule } from './garnet/garnet.module';
import { RedisModule } from './redis/redis.module';
@Global()
@Module({
imports: [SecretModule, NatsModule, DatabaseModule, GarnetModule],
imports: [SecretModule, NatsModule, DatabaseModule, RedisModule],
providers: [],
exports: [SecretModule, NatsModule, DatabaseModule, GarnetModule],
exports: [SecretModule, NatsModule, DatabaseModule, RedisModule],
})
export class GlobalModule {}
@@ -0,0 +1,39 @@
// [AUCTION-DEBUG] 경매 "중복 멤버" 조사용 서버 계측 래퍼. 조사 종료 후 호출부와 함께
// 제거 대상(범용으로 남길 거면 이 마커만 떼면 됨).
import newrelicAgent from 'newrelic';
export type NewRelicAttributeValue = string | number | boolean | null;
// newrelic 기본 export는 타입이 느슨해 unsafe-call로 잡힌다. 우리가 쓰는 부분만
// 좁게 타입을 고정한다(에이전트는 -r newrelic로 이미 preload됨).
interface NewRelicCustomEventApi {
recordCustomEvent(
eventType: string,
attributes: Record<string, NewRelicAttributeValue>,
): void;
}
const agent = newrelicAgent as unknown as NewRelicCustomEventApi;
/**
* 서버 커스텀 이벤트를 New Relic으로 보낸다(클라의 addPageAction 대응).
*
* - 에이전트는 `-r newrelic`로 이미 preload되어 있으므로 여기서 import만 하면 된다.
* - `recordCustomEvent`는 활성 트랜잭션이 없어도 동작하므로 durability 스케줄러
* tick이나 socket.io 핸들러처럼 HTTP 컨텍스트 밖에서도 그대로 호출할 수 있다.
* - 평탄한 스칼라만 받는다(중첩 객체/배열 불가). undefined 속성은 제거한다.
* - 에이전트 비활성/테스트 환경에서도 호출부가 깨지지 않도록 예외를 삼킨다.
*/
export function recordNewRelicCustomEvent(
eventType: string,
attributes: Record<string, NewRelicAttributeValue | undefined>,
): void {
try {
const flat: Record<string, NewRelicAttributeValue> = {};
for (const [key, value] of Object.entries(attributes)) {
if (value !== undefined) flat[key] = value;
}
agent.recordCustomEvent(eventType, flat);
} catch {
// 관측성 실패가 비즈니스 로직을 막아선 안 된다.
}
}
@@ -0,0 +1,59 @@
import {
assertDistinctRedisInstances,
normalizeRedisUrl,
resolveRedisClientOptions,
} from './redis.config';
describe('redis.config', () => {
it('normalizes host:port endpoints into redis URLs', () => {
expect(normalizeRedisUrl('127.0.0.1:6379', 'REDIS_ENDPOINT')).toBe(
'redis://127.0.0.1:6379',
);
expect(normalizeRedisUrl('rediss://cache.example.com:6380')).toBe(
'rediss://cache.example.com:6380',
);
});
it('throws a clear error for empty endpoints', () => {
expect(() => normalizeRedisUrl(' ', 'REDIS_ENDPOINT')).toThrow(
'REDIS_ENDPOINT cannot be empty',
);
});
it('keeps credentials optional when resolving client options', () => {
expect(
resolveRedisClientOptions({
endpoint: 'redis.internal:6379',
username: '',
password: undefined,
endpointEnvName: 'REDIS_ENDPOINT',
}),
).toEqual({
url: 'redis://redis.internal:6379',
});
});
it('rejects auction Redis when it points at the same physical Redis instance', () => {
expect(() =>
assertDistinctRedisInstances(
'redis://cache.internal:6379/0',
'redis://cache.internal:6379/1',
),
).toThrow('AUCTION_REDIS must use a separate Redis instance');
});
it('allows different Redis hosts or ports', () => {
expect(() =>
assertDistinctRedisInstances(
'redis://cache.internal:6379',
'redis://auction.internal:6379',
),
).not.toThrow();
expect(() =>
assertDistinctRedisInstances(
'redis://cache.internal:6379',
'redis://cache.internal:6380',
),
).not.toThrow();
});
});
@@ -0,0 +1,77 @@
export interface RedisClientOptions {
password?: string;
url: string;
username?: string;
}
export interface ResolveRedisClientOptionsParams {
endpoint?: string;
endpointEnvName?: string;
password?: string;
url?: string;
urlEnvName?: string;
username?: string;
}
function trimOptional(value: string | undefined): string | undefined {
const trimmed = value?.trim();
return trimmed ? trimmed : undefined;
}
export function normalizeRedisUrl(
endpointOrUrl: string,
envName = 'REDIS_URL',
): string {
const trimmed = endpointOrUrl.trim();
if (!trimmed) {
throw new Error(`${envName} cannot be empty`);
}
if (/^redis(s)?:\/\//iu.test(trimmed)) {
return trimmed;
}
return `redis://${trimmed}`;
}
export function resolveRedisClientOptions(
params: ResolveRedisClientOptionsParams,
): RedisClientOptions {
const url = trimOptional(params.url);
const endpoint = trimOptional(params.endpoint);
const selectedEndpoint = url ?? endpoint;
const selectedEnvName = url
? (params.urlEnvName ?? 'REDIS_URL')
: (params.endpointEnvName ?? 'REDIS_ENDPOINT');
if (!selectedEndpoint) {
throw new Error(`${selectedEnvName} cannot be empty`);
}
const options: RedisClientOptions = {
url: normalizeRedisUrl(selectedEndpoint, selectedEnvName),
};
const username = trimOptional(params.username);
const password = trimOptional(params.password);
if (username) options.username = username;
if (password) options.password = password;
return options;
}
function parseRedisInstanceIdentity(redisUrl: string): string {
const url = new URL(normalizeRedisUrl(redisUrl));
const hostname = url.hostname.toLowerCase();
const port = url.port || '6379';
return `${hostname}:${port}`;
}
export function assertDistinctRedisInstances(
redisUrl: string,
auctionRedisUrl: string,
): void {
const redisIdentity = parseRedisInstanceIdentity(redisUrl);
const auctionRedisIdentity = parseRedisInstanceIdentity(auctionRedisUrl);
if (redisIdentity === auctionRedisIdentity) {
throw new Error(
'AUCTION_REDIS must use a separate Redis instance from REDIS because auction Redis is a live state source of truth.',
);
}
}
@@ -0,0 +1 @@
export const REDIS_CLIENT = Symbol('REDIS_CLIENT');
@@ -0,0 +1,68 @@
import { Logger, Module } from '@nestjs/common';
import { createClient } from 'redis';
import { SecretModule } from '../secret/secret.module';
import { SecretService } from '../secret/secret.service';
import { REDIS_CLIENT } from './redis.constants';
import { resolveRedisClientOptions } from './redis.config';
import { RedisService, type RedisClient } from './redis.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: [
{
provide: REDIS_CLIENT,
inject: [SecretService],
useFactory: async (secretService: SecretService): Promise<RedisClient> => {
await secretService.ready();
const [url, endpoint, username, password] = await Promise.all([
readFirstSecret(secretService, ['REDIS_URL', 'GARNET_URL']),
readFirstSecret(secretService, ['REDIS_ENDPOINT', 'GARNET_ENDPOINT']),
readFirstSecret(secretService, [
'REDIS_USERNAME',
'REDIS_USERID',
'GARNET_USERNAME',
'GARNET_USERID',
]),
readFirstSecret(secretService, ['REDIS_PASSWORD', 'GARNET_PASSWORD']),
]);
const logger = new Logger('RedisClient');
const client = createClient(
resolveRedisClientOptions({
endpoint,
endpointEnvName: 'REDIS_ENDPOINT',
password,
url,
urlEnvName: 'REDIS_URL',
username,
}),
);
client.on('error', (error) => {
logger.error(`Redis client error: ${error?.message ?? error}`);
});
await client.connect();
logger.log('Redis connected');
return client;
},
},
RedisService,
],
exports: [RedisService, REDIS_CLIENT],
})
export class RedisModule {}
@@ -1,8 +1,8 @@
import { Inject, Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
import type { createClient } from 'redis';
import { GARNET_CLIENT } from './garnet.constants';
import { REDIS_CLIENT } from './redis.constants';
export type GarnetRedisClient = ReturnType<typeof createClient>;
export type RedisClient = ReturnType<typeof createClient>;
export interface StreamEntry {
deliveriesCounter?: number;
@@ -48,12 +48,10 @@ function normalizeStreamFields(fields: unknown): Record<string, string> {
}
@Injectable()
export class GarnetService implements OnModuleDestroy {
private readonly logger = new Logger(GarnetService.name);
export class RedisService implements OnModuleDestroy {
private readonly logger = new Logger(RedisService.name);
constructor(
@Inject(GARNET_CLIENT) private readonly client: GarnetRedisClient,
) {}
constructor(@Inject(REDIS_CLIENT) private readonly client: RedisClient) {}
async onModuleDestroy() {
try {
@@ -63,7 +61,7 @@ export class GarnetService implements OnModuleDestroy {
}
}
public raw(): GarnetRedisClient {
public raw(): RedisClient {
return this.client;
}
@@ -16,7 +16,7 @@ import type {
RiotMatch as StoredRiotMatch,
UserDocument,
} from '../global/database/schema';
import { GarnetService } from '../global/garnet/garnet.service';
import { RedisService } from '../global/redis/redis.service';
import { RIOT_JOB_LOW_STREAM } from '../riot-job-queue/riot-job-queue.types';
import { RiotMatchService } from '../riot/riot-match.service';
import type { RiotMatchDto, RiotRegionalRoute } from '../riot/riot.types';
@@ -53,7 +53,7 @@ export class LegacyImportService {
constructor(
private readonly connectionService: ConnectionService,
private readonly garnetService: GarnetService,
private readonly redisService: RedisService,
private readonly riotMatchService: RiotMatchService,
private readonly communityStatsService: CommunityStatsService,
private readonly matchStatsService: MatchStatsService,
@@ -80,7 +80,7 @@ export class LegacyImportService {
}): Promise<StartLegacyImportResponse> {
const lockKey = this.communityLockKey(params.communityId);
const jobId = randomUUID();
const acquired = await this.garnetService.setStringIfAbsent(
const acquired = await this.redisService.setStringIfAbsent(
lockKey,
jobId,
LEGACY_IMPORT_LOCK_TTL_SECONDS,
@@ -148,7 +148,7 @@ export class LegacyImportService {
triggeredBy: params.triggeredBy.toString(),
region: (community.riotRegion ?? 'asia') as RiotRegionalRoute,
};
await this.garnetService.appendStream(
await this.redisService.appendStream(
RIOT_JOB_LOW_STREAM,
{ job: JSON.stringify(job) },
{ maxLen: 10_000 },
@@ -160,7 +160,7 @@ export class LegacyImportService {
{ jobId },
{ $set: { state: 'completed', completedAt: new Date() } },
).exec();
await this.garnetService.delete(lockKey);
await this.redisService.delete(lockKey);
}
return {
@@ -169,7 +169,7 @@ export class LegacyImportService {
etaSeconds: windows.length * LEGACY_IMPORT_MEMBER_AVG_SECONDS,
};
} catch (error) {
await this.garnetService.delete(lockKey);
await this.redisService.delete(lockKey);
throw error;
}
}
@@ -220,7 +220,7 @@ export class LegacyImportService {
).exec();
if (!job)
throw new NotFoundException('Running legacy import job not found.');
await this.garnetService.delete(this.communityLockKey(params.communityId));
await this.redisService.delete(this.communityLockKey(params.communityId));
return job;
}
@@ -500,7 +500,7 @@ export class LegacyImportService {
userByPuuid: UserByPuuidMap,
): Promise<ImportOutcome> {
const lockKey = `legacy-import:match:${riotMatchId}`;
const acquired = await this.garnetService.setStringIfAbsent(
const acquired = await this.redisService.setStringIfAbsent(
lockKey,
job.parentJobId,
MATCH_IMPORT_LOCK_TTL_SECONDS,
@@ -577,7 +577,7 @@ export class LegacyImportService {
});
return 'error';
} finally {
await this.garnetService.delete(lockKey);
await this.redisService.delete(lockKey);
}
}
@@ -656,7 +656,7 @@ export class LegacyImportService {
if (completed) {
await Promise.all([
this.garnetService.delete(
this.redisService.delete(
this.communityLockKey(new mongoose.Types.ObjectId(job.communityId)),
),
this.communityStatsService.invalidateCommunity(
@@ -1,4 +1,4 @@
import type { RiotLane } from '../global/database/schema';
import type { MatchStatsRunePerks, RiotLane } from '../global/database/schema';
import type {
RiotQueueGroup,
RiotRankFilter,
@@ -121,7 +121,7 @@ export interface RecentMatchTeamParticipantView {
items: number[];
trinket: number;
summonerSpells: [number, number];
perks: { primaryStyle?: number; subStyle?: number; keystone?: number };
perks: MatchStatsRunePerks;
totalCs: number;
csPerMin: number;
goldEarned: number;
@@ -135,6 +135,8 @@ export interface RecentMatchTeamParticipantView {
export interface RecentMatchView {
matchId: string;
internalMatchId?: string;
gameNumber?: number;
queueId: number;
queueLabel: string;
gameCreation: number;
@@ -162,7 +164,7 @@ export interface RecentMatchView {
items: number[];
trinket: number;
summonerSpells: [number, number];
perks: { primaryStyle?: number; subStyle?: number; keystone?: number };
perks: MatchStatsRunePerks;
teams: Array<{
side: 100 | 200;
win: boolean;
@@ -101,6 +101,11 @@ export class CreateMatchDto {
@IsEnum(MATCH_GAME_MODES)
gameMode?: MatchGameMode;
@IsOptional()
@IsInt()
@Min(1)
roundRobinMaxRounds?: number;
@IsOptional()
@IsArray()
@IsString({ each: true })
@@ -156,6 +161,11 @@ export class UpdateMatchDto {
@IsEnum(MATCH_GAME_MODES)
gameMode?: MatchGameMode;
@IsOptional()
@IsInt()
@Min(1)
roundRobinMaxRounds?: number;
@IsOptional()
@IsArray()
@IsString({ each: true })
@@ -193,3 +203,17 @@ export class JoinMatchDto {
@IsString()
userId?: string;
}
export class AddParticipantDto {
@IsOptional()
@IsArray()
@ArrayMinSize(1)
@ArrayMaxSize(5)
@ValidateNested({ each: true })
@Type(() => PositionPreferenceDto)
preferredPositions?: PositionPreferenceDto[];
@IsOptional()
@IsString()
riotPuuid?: string;
}
@@ -24,6 +24,7 @@ import type {
UserDocument,
} from '../global/database/schema';
import {
AddParticipantDto,
CreateMatchDto,
JoinMatchDto,
UpdateMatchDto,
@@ -56,6 +57,7 @@ export class MatchController {
maxParticipants: body.maxParticipants ?? 10,
gameCount: body.gameCount,
gameMode: body.gameMode ?? 'pair',
roundRobinMaxRounds: body.roundRobinMaxRounds,
prizes: body.prizes ?? [],
notices: body.notices ?? [],
schedule: body.schedule ?? [],
@@ -149,6 +151,28 @@ export class MatchController {
});
}
// 관리자 전용 — 커뮤니티 유저를 모집중 매치에 직접 추가한다.
@Post(':matchId/participants/:userId')
@Roles('admin', 'owner')
@UseGuards(RolesGuard)
public async addParticipant(
@CurrentUser() currentUser: UserDocument,
@Param('communityId', ParseObjectIdPipe)
communityId: mongoose.Types.ObjectId,
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
@Param('userId', ParseObjectIdPipe) userId: mongoose.Types.ObjectId,
@Body() body: AddParticipantDto | undefined,
) {
this.assertSameCommunity(currentUser, communityId);
const match = await this.matchService.join({
matchId,
userId,
preferredPositions: body?.preferredPositions,
riotPuuid: body?.riotPuuid,
});
return this.matchService.serialize(match);
}
// 관리자 전용 — 참가자 주/부 포지션 변경.
@Patch(':matchId/participants/:userId')
@Roles('admin', 'owner')
@@ -80,6 +80,47 @@ describe('MatchService', () => {
};
}
function createServiceWithJoinModels(params: {
user: Record<string, unknown> | null;
match: Record<string, unknown> | null;
}) {
const UserModel = {
findById: jest.fn().mockResolvedValue(params.user),
};
const MatchModel = {
findById: jest.fn().mockResolvedValue(params.match),
};
const connectionService = {
getModel: jest.fn().mockImplementation(async (name: string) => {
if (name === 'user') return UserModel;
if (name === 'match') return MatchModel;
return {};
}),
};
const tournamentCodeService = {
buildSlots: jest.fn().mockResolvedValue([]),
releaseFromMatch: jest.fn().mockResolvedValue(undefined),
};
const communityStatsService = {
invalidateCommunity: jest.fn().mockResolvedValue(undefined),
};
const matchStatsService = {
buildAndUpsert: jest.fn().mockResolvedValue(undefined),
removeByMatch: jest.fn().mockResolvedValue(undefined),
};
return {
service: new MatchService(
connectionService as never,
tournamentCodeService as never,
communityStatsService as never,
matchStatsService as never,
),
UserModel,
MatchModel,
};
}
it('returns a paginated match list with total count', async () => {
const communityId = new mongoose.Types.ObjectId();
const { service, MatchModel, sort, skip, limit } =
@@ -165,6 +206,54 @@ describe('MatchService', () => {
expect(sort).toHaveBeenCalledWith({ scheduledAt: -1 });
});
it('uses saved user preferences when joining without explicit positions', async () => {
const communityId = new mongoose.Types.ObjectId();
const userId = new mongoose.Types.ObjectId();
const matchId = new mongoose.Types.ObjectId();
const user = {
_id: userId,
communityId,
preferredPositions: [{ position: 'MID', priority: 1 }],
riotAccounts: [
{
puuid: 'puuid-1',
gameName: 'Dahyeon',
tagLine: 'KR1',
profileIconId: 7,
isPrimary: true,
tiers: [],
},
],
};
const match = {
_id: matchId,
communityId,
status: 'recruiting',
maxParticipants: 10,
participants: [],
save: jest.fn().mockResolvedValue(undefined),
};
const { service } = createServiceWithJoinModels({ user, match });
await service.join({
matchId,
userId,
});
expect(match.participants).toEqual([
expect.objectContaining({
userId,
puuid: 'puuid-1',
gameName: 'Dahyeon',
tagLine: 'KR1',
profileIconId: 7,
preferredPositions: [{ position: 'MID', priority: 1 }],
excluded: false,
}),
]);
expect(match.save).toHaveBeenCalledTimes(1);
});
it('clears game schedule when a built match returns to recruiting', async () => {
const communityId = new mongoose.Types.ObjectId();
const match = {
@@ -203,6 +292,29 @@ describe('MatchService', () => {
expect(matchStatsService.removeByMatch).toHaveBeenCalledWith(match._id);
});
it('rejects round-robin max round changes after recruiting', async () => {
const communityId = new mongoose.Types.ObjectId();
const match = {
communityId,
status: 'team-built',
tournamentCodeIds: [],
set: jest.fn(),
save: jest.fn().mockResolvedValue(undefined),
};
const { service } = createService(match);
await expect(
service.update({
matchId: new mongoose.Types.ObjectId(),
communityId,
patch: { roundRobinMaxRounds: 3 },
}),
).rejects.toThrow(
'maxParticipants, gameMode, and roundRobinMaxRounds can only be changed while recruiting.',
);
expect(match.set).not.toHaveBeenCalled();
});
it('releases reserved codes when returning a built match to recruiting', async () => {
const communityId = new mongoose.Types.ObjectId();
const codeId = new mongoose.Types.ObjectId();
+32 -4
View File
@@ -13,6 +13,7 @@ import {
MatchDocument,
MatchSeriesResult,
MatchStatus,
POSITIONS,
Position,
PositionPreference,
TierInfo,
@@ -64,7 +65,7 @@ interface MatchListFilter {
interface JoinMatchParams {
matchId: mongoose.Types.ObjectId;
userId: mongoose.Types.ObjectId;
preferredPositions: PositionPreference[];
preferredPositions?: PositionPreference[];
// 특정 RiotAccount(puuid)로 참가하고 싶을 때 지정. 없으면 primary 사용.
riotPuuid?: string;
}
@@ -213,10 +214,12 @@ export class MatchService {
const previousStatus = match.status;
if (
previousStatus !== 'recruiting' &&
('maxParticipants' in params.patch || 'gameMode' in params.patch)
('maxParticipants' in params.patch ||
'gameMode' in params.patch ||
'roundRobinMaxRounds' in params.patch)
) {
throw new BadRequestException(
'maxParticipants and gameMode can only be changed while recruiting.',
'maxParticipants, gameMode, and roundRobinMaxRounds can only be changed while recruiting.',
);
}
match.set(params.patch);
@@ -293,7 +296,10 @@ export class MatchService {
tagLine: selectedRiot?.tagLine,
profileIconId: selectedRiot?.profileIconId,
tier: selectedTier,
preferredPositions: params.preferredPositions,
preferredPositions: this.resolveJoinPreferredPositions(
params.preferredPositions,
user.preferredPositions,
),
joinedAt: new Date(),
excluded: false,
});
@@ -436,6 +442,28 @@ export class MatchService {
};
}
private resolveJoinPreferredPositions(
requested: PositionPreference[] | undefined,
saved: PositionPreference[] | undefined,
): PositionPreference[] {
const source = requested?.length
? requested
: saved?.length
? saved
: POSITIONS.map((position, index) => ({
position,
priority: index + 1,
}));
return [...source]
.sort((left, right) => left.priority - right.priority)
.slice(0, 5)
.map((preference, index) => ({
position: preference.position,
priority: index + 1,
}));
}
private buildListFilter(query: ListMatchesQuery): MatchListFilter {
const filter: MatchListFilter = {
communityId: query.communityId,
@@ -1,5 +1,5 @@
import mongoose from 'mongoose';
import { GarnetService } from '../global/garnet/garnet.service';
import { RedisService } from '../global/redis/redis.service';
import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service';
import { RiotRateLimiterService } from '../riot/riot-rate-limiter.service';
import { BackgroundRefreshScheduler } from './background-refresh.scheduler';
@@ -33,13 +33,13 @@ function makeScheduler() {
const rawClient = {
sendCommand: jest.fn().mockResolvedValue(1),
};
const garnet = {
const redis = {
getString: jest.fn().mockResolvedValue(null),
setString: jest.fn().mockResolvedValue(undefined),
setStringIfAbsent: jest.fn().mockResolvedValue(true),
delete: jest.fn().mockResolvedValue(1),
raw: jest.fn().mockReturnValue(rawClient),
} as unknown as jest.Mocked<GarnetService> & { raw: jest.Mock };
} as unknown as jest.Mocked<RedisService> & { raw: jest.Mock };
const rateLimiter = {
isRefreshWindowOpen: jest.fn().mockResolvedValue(true),
} as unknown as jest.Mocked<RiotRateLimiterService>;
@@ -51,7 +51,7 @@ function makeScheduler() {
findStaleAccounts: jest.fn().mockResolvedValue([]),
} as unknown as jest.Mocked<StaleAccountRepository>;
const scheduler = new BackgroundRefreshScheduler(
garnet,
redis,
rateLimiter,
enrichmentService,
staleAccountRepository,
@@ -59,7 +59,7 @@ function makeScheduler() {
return {
scheduler,
garnet,
redis,
rawClient,
rateLimiter,
enrichmentService,
@@ -115,8 +115,8 @@ describe('BackgroundRefreshScheduler', () => {
it('does not query stale accounts when another leader holds the lock', async () => {
jest.useFakeTimers().setSystemTime(new Date('2026-05-02T18:00:00.000Z'));
const { scheduler, garnet, staleAccountRepository } = makeScheduler();
garnet.getString.mockResolvedValue('another-consumer');
const { scheduler, redis, staleAccountRepository } = makeScheduler();
redis.getString.mockResolvedValue('another-consumer');
await scheduler.tick();
@@ -193,12 +193,12 @@ describe('BackgroundRefreshScheduler', () => {
it('skips candidates already in failure backoff', async () => {
jest.useFakeTimers().setSystemTime(new Date('2026-05-02T18:00:00.000Z'));
const { scheduler, garnet, enrichmentService, staleAccountRepository } =
const { scheduler, redis, enrichmentService, staleAccountRepository } =
makeScheduler();
staleAccountRepository.findStaleAccounts.mockResolvedValue([
candidate('skip-me'),
]);
garnet.getString.mockImplementation(async (key: string) => {
redis.getString.mockImplementation(async (key: string) => {
if (key.includes('riot:bg:fail:skip-me')) return '3';
return null;
});
@@ -9,7 +9,7 @@ import {
RiotAccountEnrichmentService,
} from '../riot/riot-account-enrichment.service';
import { RiotRateLimiterService } from '../riot/riot-rate-limiter.service';
import { GarnetService } from '../global/garnet/garnet.service';
import { RedisService } from '../global/redis/redis.service';
import { isInKstBackgroundWindow } from './kst-window.util';
import { StaleAccountRepository } from './stale-account.repository';
@@ -41,7 +41,7 @@ export class BackgroundRefreshScheduler
private readonly consumer = `${process.pid}:${Math.random().toString(36).slice(2)}`;
constructor(
private readonly garnet: GarnetService,
private readonly redis: RedisService,
private readonly rateLimiter: RiotRateLimiterService,
private readonly enrichmentService: RiotAccountEnrichmentService,
private readonly staleAccountRepository: StaleAccountRepository,
@@ -158,9 +158,9 @@ export class BackgroundRefreshScheduler
}
private async tryBecomeLeader(): Promise<boolean> {
const current = await this.garnet.getString(LEADER_KEY);
const current = await this.redis.getString(LEADER_KEY);
if (current === this.consumer) {
await this.garnet.setString(
await this.redis.setString(
LEADER_KEY,
this.consumer,
LEADER_TTL_SECONDS,
@@ -169,7 +169,7 @@ export class BackgroundRefreshScheduler
}
if (current) return false;
return this.garnet.setStringIfAbsent(
return this.redis.setStringIfAbsent(
LEADER_KEY,
this.consumer,
LEADER_TTL_SECONDS,
@@ -178,9 +178,9 @@ export class BackgroundRefreshScheduler
private async renewLeaderIfHeld(): Promise<void> {
try {
const current = await this.garnet.getString(LEADER_KEY);
const current = await this.redis.getString(LEADER_KEY);
if (current !== this.consumer) return;
await this.garnet.setString(
await this.redis.setString(
LEADER_KEY,
this.consumer,
LEADER_TTL_SECONDS,
@@ -200,7 +200,7 @@ export class BackgroundRefreshScheduler
}
private async getFailureCount(puuid: string): Promise<number> {
const raw = await this.garnet.getString(this.failureBackoffKey(puuid));
const raw = await this.redis.getString(this.failureBackoffKey(puuid));
const count = Number(raw ?? 0);
if (!Number.isFinite(count) || count < 0) return 0;
return count;
@@ -208,7 +208,7 @@ export class BackgroundRefreshScheduler
private async bumpFailureCounter(puuid: string): Promise<void> {
const key = this.failureBackoffKey(puuid);
const client = this.garnet.raw();
const client = this.redis.raw();
const response = await client.sendCommand(['INCR', key]);
await client.sendCommand([
'EXPIRE',
@@ -225,7 +225,7 @@ export class BackgroundRefreshScheduler
}
private async clearFailureCounter(puuid: string): Promise<void> {
await this.garnet.delete(this.failureBackoffKey(puuid));
await this.redis.delete(this.failureBackoffKey(puuid));
}
private isFailedEnrichment(result: EnrichResult): boolean {
@@ -13,7 +13,7 @@ import type {
RiotAccount,
UserDocument,
} from '../global/database/schema';
import { GarnetService } from '../global/garnet/garnet.service';
import { RedisService } from '../global/redis/redis.service';
import {
isRiotQueueGroup,
resolveRiotQueueIds,
@@ -51,7 +51,7 @@ interface RefreshContext {
export class RiotJobQueueService {
constructor(
private readonly connectionService: ConnectionService,
private readonly garnetService: GarnetService,
private readonly redisService: RedisService,
) {}
public async enqueueRefresh(params: {
@@ -64,12 +64,12 @@ export class RiotJobQueueService {
const context = await this.resolveContext(params);
const queueGroups = this.normalizeQueueGroups(params.queueGroups);
const stream = this.resolveStream(params.priority);
const streamLength = await this.garnetService.streamLength(stream);
const streamLength = await this.redisService.streamLength(stream);
const dedupKeys = queueGroups.map((queueGroup) =>
this.dedupKey(context.account.puuid, queueGroup),
);
const existingJobIds = await Promise.all(
dedupKeys.map((key) => this.garnetService.getString(key)),
dedupKeys.map((key) => this.redisService.getString(key)),
);
const needsNewJob = existingJobIds.some((jobId) => !jobId);
@@ -114,13 +114,13 @@ export class RiotJobQueueService {
requestedBy: params.requestedBy,
priority: params.priority,
};
const acquired = await this.garnetService.setStringIfAbsent(
const acquired = await this.redisService.setStringIfAbsent(
dedupKeys[index],
job.jobId,
RIOT_JOB_DEDUP_TTL_SECONDS,
);
if (!acquired) {
const jobId = await this.garnetService.getString(dedupKeys[index]);
const jobId = await this.redisService.getString(dedupKeys[index]);
if (!jobId) continue;
const status = await this.getStatus(jobId);
subJobs.push({
@@ -149,7 +149,7 @@ export class RiotJobQueueService {
await Promise.all([
this.setStatus(status),
this.garnetService.appendStream(
this.redisService.appendStream(
stream,
{ job: JSON.stringify(job) },
{ maxLen: 10_000 },
@@ -209,7 +209,7 @@ export class RiotJobQueueService {
}
public async promoteDueScheduledJobs(limit = 100): Promise<number> {
const client = this.garnetService.raw();
const client = this.redisService.raw();
const raw = (await client.sendCommand([
'ZRANGEBYSCORE',
RIOT_JOB_SCHEDULED_ZSET,
@@ -239,13 +239,13 @@ export class RiotJobQueueService {
}
public async getStatus(jobId: string): Promise<RiotJobStatus | null> {
return this.garnetService.getJson<RiotJobStatus>(this.statusKey(jobId));
return this.redisService.getJson<RiotJobStatus>(this.statusKey(jobId));
}
public async getParentStatus(
parentJobId: string,
): Promise<RiotParentJobStatus | null> {
const jobIds = await this.garnetService.getJson<string[]>(
const jobIds = await this.redisService.getJson<string[]>(
this.parentKey(parentJobId),
);
if (!jobIds) return null;
@@ -296,7 +296,7 @@ export class RiotJobQueueService {
};
await Promise.all([
this.setStatus(next),
this.garnetService.delete(this.dedupKey(job.puuid, job.queueGroup)),
this.redisService.delete(this.dedupKey(job.puuid, job.queueGroup)),
]);
return this.toEvent(next);
}
@@ -317,7 +317,7 @@ export class RiotJobQueueService {
};
await Promise.all([
this.setStatus(next),
this.garnetService.delete(this.dedupKey(job.puuid, job.queueGroup)),
this.redisService.delete(this.dedupKey(job.puuid, job.queueGroup)),
]);
return this.toEvent(next);
}
@@ -400,7 +400,7 @@ export class RiotJobQueueService {
}
private async appendJob(job: RiotRefreshSubJob | PollTournamentResultJob) {
await this.garnetService.appendStream(
await this.redisService.appendStream(
this.resolveStream(job.priority),
{ job: JSON.stringify(job) },
{ maxLen: 10_000 },
@@ -411,7 +411,7 @@ export class RiotJobQueueService {
job: PollTournamentResultJob,
deferUntilMs: number,
): Promise<void> {
await this.garnetService.raw().sendCommand([
await this.redisService.raw().sendCommand([
'ZADD',
RIOT_JOB_SCHEDULED_ZSET,
String(deferUntilMs),
@@ -442,7 +442,7 @@ export class RiotJobQueueService {
}
private async setStatus(status: RiotJobStatus): Promise<void> {
await this.garnetService.setJson(
await this.redisService.setJson(
this.statusKey(status.jobId),
status,
RIOT_JOB_STATUS_TTL_SECONDS,
@@ -450,7 +450,7 @@ export class RiotJobQueueService {
}
private async setParent(parentJobId: string, jobIds: string[]): Promise<void> {
await this.garnetService.setJson(
await this.redisService.setJson(
this.parentKey(parentJobId),
jobIds,
RIOT_JOB_STATUS_TTL_SECONDS,
@@ -1,6 +1,6 @@
import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service';
import { GarnetService } from '../global/garnet/garnet.service';
import { RedisService } from '../global/redis/redis.service';
import { LegacyImportService } from '../legacy-import/legacy-import.service';
import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service';
import { RiotRecentMatchesService } from '../riot/riot-recent-matches.service';
@@ -15,10 +15,10 @@ function execResult<T>(value: T) {
}
function makeWorker() {
const garnetService = {
const redisService = {
acknowledgeStream: jest.fn().mockResolvedValue(undefined),
deleteStreamEntries: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<GarnetService>;
} as unknown as jest.Mocked<RedisService>;
const jobQueueService = {
markProcessing: jest.fn().mockResolvedValue(undefined),
markCompleted: jest.fn().mockResolvedValue({
@@ -53,7 +53,7 @@ function makeWorker() {
} as unknown as jest.Mocked<RiotAccountEnrichmentService>;
const worker = new RiotJobWorkerService(
garnetService,
redisService,
jobQueueService,
recentMatchesService,
connectionService,
@@ -65,7 +65,7 @@ function makeWorker() {
return {
worker,
garnetService,
redisService,
jobQueueService,
recentMatchesService,
connectionService,
@@ -76,7 +76,7 @@ function makeWorker() {
describe('RiotJobWorkerService', () => {
it('acknowledges and deletes invalid stream entries', async () => {
const { worker, garnetService } = makeWorker();
const { worker, redisService } = makeWorker();
await (
worker as unknown as {
@@ -90,19 +90,19 @@ describe('RiotJobWorkerService', () => {
message: { job: 'not-json' },
});
expect(garnetService.acknowledgeStream).toHaveBeenCalledWith(
expect(redisService.acknowledgeStream).toHaveBeenCalledWith(
'riot:queue:high',
RIOT_JOB_GROUP,
'bad-1',
);
expect(garnetService.deleteStreamEntries).toHaveBeenCalledWith(
expect(redisService.deleteStreamEntries).toHaveBeenCalledWith(
'riot:queue:high',
'bad-1',
);
});
it('refreshes league entries while processing user history refresh jobs', async () => {
const { worker, enrichmentService, recentMatchesService, garnetService } =
const { worker, enrichmentService, recentMatchesService, redisService } =
makeWorker();
const userId = new mongoose.Types.ObjectId().toString();
const job: RiotRefreshSubJob = {
@@ -136,19 +136,19 @@ describe('RiotJobWorkerService', () => {
puuid: 'puuid-1',
platform: 'kr',
});
expect(garnetService.acknowledgeStream).toHaveBeenCalledWith(
expect(redisService.acknowledgeStream).toHaveBeenCalledWith(
'riot:queue:high',
RIOT_JOB_GROUP,
'1-0',
);
expect(garnetService.deleteStreamEntries).toHaveBeenCalledWith(
expect(redisService.deleteStreamEntries).toHaveBeenCalledWith(
'riot:queue:high',
'1-0',
);
expect(
garnetService.acknowledgeStream.mock.invocationCallOrder[0],
redisService.acknowledgeStream.mock.invocationCallOrder[0],
).toBeLessThan(
garnetService.deleteStreamEntries.mock.invocationCallOrder[0],
redisService.deleteStreamEntries.mock.invocationCallOrder[0],
);
});
});
@@ -6,7 +6,7 @@ import {
} from '@nestjs/common';
import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service';
import { GarnetService, StreamEntry } from '../global/garnet/garnet.service';
import { RedisService, StreamEntry } from '../global/redis/redis.service';
import { LegacyImportService } from '../legacy-import/legacy-import.service';
import type { LegacyImportMemberJob } from '../legacy-import/legacy-import.types';
import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service';
@@ -33,7 +33,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
private stopped = false;
constructor(
private readonly garnetService: GarnetService,
private readonly redisService: RedisService,
private readonly jobQueueService: RiotJobQueueService,
private readonly recentMatchesService: RiotRecentMatchesService,
private readonly connectionService: ConnectionService,
@@ -145,7 +145,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
stream: string,
id: string,
): Promise<void> {
await this.garnetService.acknowledgeStream(stream, RIOT_JOB_GROUP, id);
await this.redisService.acknowledgeStream(stream, RIOT_JOB_GROUP, id);
await this.deleteAcknowledgedEntry(stream, id);
}
@@ -154,7 +154,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
id: string,
): Promise<void> {
try {
await this.garnetService.deleteStreamEntries(stream, id);
await this.redisService.deleteStreamEntries(stream, id);
} catch (error) {
this.logger.warn(
`Failed to delete acknowledged Riot job stream entry ${stream} ${id}: ${
@@ -226,7 +226,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
stream: string,
blockMs: number,
): Promise<{ stream: string; message: StreamEntry } | null> {
const result = await this.garnetService.readGroup(
const result = await this.redisService.readGroup(
stream,
RIOT_JOB_GROUP,
this.consumer,
@@ -241,7 +241,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
await Promise.all(
[RIOT_JOB_HIGH_STREAM, RIOT_JOB_LOW_STREAM].map(async (stream) => {
try {
await this.garnetService.createConsumerGroup(stream, RIOT_JOB_GROUP);
await this.redisService.createConsumerGroup(stream, RIOT_JOB_GROUP);
} catch (error) {
const message =
error instanceof Error ? error.message : String(error);
@@ -252,9 +252,9 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
}
private async tryBecomeLeader(): Promise<boolean> {
const current = await this.garnetService.getString(LEADER_KEY);
const current = await this.redisService.getString(LEADER_KEY);
if (current === this.consumer) {
await this.garnetService.setString(
await this.redisService.setString(
LEADER_KEY,
this.consumer,
LEADER_TTL_SECONDS,
@@ -262,7 +262,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
return true;
}
if (current) return false;
return this.garnetService.setStringIfAbsent(
return this.redisService.setStringIfAbsent(
LEADER_KEY,
this.consumer,
LEADER_TTL_SECONDS,
@@ -1,5 +1,5 @@
import { Injectable, Logger } from '@nestjs/common';
import { GarnetService } from '../global/garnet/garnet.service';
import { RedisService } from '../global/redis/redis.service';
const DDRAGON_BASE = 'https://ddragon.leagueoflegends.com';
const DDRAGON_CDN = `${DDRAGON_BASE}/cdn`;
@@ -75,13 +75,13 @@ export class RiotDdragonService {
private readonly logger = new Logger(RiotDdragonService.name);
private inflight = new Map<string, Promise<DdragonManifest>>();
constructor(private readonly garnetService: GarnetService) {}
constructor(private readonly redisService: RedisService) {}
public async getManifest(locale: string = DEFAULT_LOCALE): Promise<DdragonManifest> {
const normalizedLocale = normalizeLocale(locale);
const cacheKey = manifestCacheKey(normalizedLocale);
const cached = await this.garnetService.getJson<DdragonManifest>(cacheKey);
const cached = await this.redisService.getJson<DdragonManifest>(cacheKey);
if (cached) return cached;
const pending = this.inflight.get(cacheKey);
@@ -89,7 +89,7 @@ export class RiotDdragonService {
const promise = this.buildManifest(normalizedLocale)
.then(async (manifest) => {
await this.garnetService.setJson(cacheKey, manifest, CACHE_TTL_SECONDS);
await this.redisService.setJson(cacheKey, manifest, CACHE_TTL_SECONDS);
return manifest;
})
.finally(() => {
@@ -106,4 +106,112 @@ describe('RiotMatchService', () => {
expect(match.info.participants[0].teamPosition).toBe('');
expect(match.info.participants[0].individualPosition).toBe('');
});
it('fetches and parses match timeline frames', async () => {
const payload = {
metadata: {
dataVersion: '2',
matchId: 'KR_8188913502',
participants: ['puuid-1'],
},
info: {
frameInterval: 60_000,
gameId: 8188913502,
participants: [{ participantId: 1, puuid: 'puuid-1' }],
frames: [
{
timestamp: 60_000,
events: [
{
type: 'ELITE_MONSTER_KILL',
timestamp: 30_000,
killerTeamId: 100,
monsterType: 'DRAGON',
monsterSubType: 'ELDER_DRAGON',
},
{
type: 'ITEM_PURCHASED',
timestamp: 40_000,
participantId: 1,
itemId: 1054,
},
{
type: 'ITEM_UNDO',
timestamp: 45_000,
participantId: 1,
beforeId: 1054,
afterId: 3071,
},
{
type: 'SKILL_LEVEL_UP',
timestamp: 50_000,
participantId: 1,
skillSlot: 3,
levelUpType: 'NORMAL',
},
],
participantFrames: {
'1': {
currentGold: 650,
jungleMinionsKilled: 0,
level: 2,
minionsKilled: 6,
participantId: 1,
totalGold: 1_150,
xp: 550,
},
},
},
],
},
};
const riotClientService = {
get: jest.fn(
async <T>(
_path: string,
_options: unknown,
parser?: RiotResponseParser<T>,
) => (parser ? parser(payload) : (payload as T)),
),
} as unknown as RiotClientService;
const service = new RiotMatchService(riotClientService);
const timeline = await service.getMatchTimeline('KR_8188913502', {
region: 'asia',
});
expect(riotClientService.get).toHaveBeenCalledWith(
'/lol/match/v5/matches/KR_8188913502/timeline',
expect.objectContaining({ region: 'asia' }),
expect.any(Function),
);
expect(timeline.info.frames[0].participantFrames['1']).toMatchObject({
participantId: 1,
totalGold: 1_150,
xp: 550,
});
expect(timeline.info.frames[0].events[0]).toMatchObject({
type: 'ELITE_MONSTER_KILL',
killerTeamId: 100,
monsterType: 'DRAGON',
monsterSubType: 'ELDER_DRAGON',
});
expect(timeline.info.frames[0].events[1]).toMatchObject({
type: 'ITEM_PURCHASED',
participantId: 1,
itemId: 1054,
});
expect(timeline.info.frames[0].events[2]).toMatchObject({
type: 'ITEM_UNDO',
participantId: 1,
beforeId: 1054,
afterId: 3071,
});
expect(timeline.info.frames[0].events[3]).toMatchObject({
type: 'SKILL_LEVEL_UP',
participantId: 1,
skillSlot: 3,
levelUpType: 'NORMAL',
});
});
});
@@ -15,6 +15,12 @@ import {
RiotMatchPerkStyleSelectionDto,
RiotMatchStatPerksDto,
RiotMatchTeamDto,
RiotMatchTimelineDto,
RiotMatchTimelineEventDto,
RiotMatchTimelineFrameDto,
RiotMatchTimelineInfoDto,
RiotMatchTimelineParticipantDto,
RiotMatchTimelineParticipantFrameDto,
RiotMatchType,
} from './riot.types';
@@ -66,6 +72,20 @@ export class RiotMatchService {
parseMatchResponse,
);
}
public async getMatchTimeline(
matchId: string,
options: RiotMatchLookupOptions = {},
): Promise<RiotMatchTimelineDto> {
return this.riotClientService.get<RiotMatchTimelineDto>(
`/lol/match/v5/matches/${encodeURIComponent(matchId)}/timeline`,
{
region: options.region,
signal: options.signal,
},
parseMatchTimelineResponse,
);
}
}
function validateMatchIdsLookupOptions(
@@ -115,6 +135,48 @@ function parseMatchResponse(value: unknown): RiotMatchDto {
};
}
function parseMatchTimelineResponse(value: unknown): RiotMatchTimelineDto {
if (!isRecord(value)) {
throw new TypeError('Riot match timeline response must be an object.');
}
return {
metadata: parseMatchMetadata(value.metadata),
info: parseMatchTimelineInfo(value.info),
};
}
function parseMatchTimelineInfo(value: unknown): RiotMatchTimelineInfoDto {
if (!isRecord(value)) {
throw new TypeError('Riot match timeline info must be an object.');
}
const frames = value.frames;
if (!Array.isArray(frames)) {
throw new TypeError('Riot match timeline info.frames must be an array.');
}
const participants = value.participants;
if (participants !== undefined && !Array.isArray(participants)) {
throw new TypeError(
'Riot match timeline info.participants must be an array when present.',
);
}
return {
...value,
frameInterval: requireNumber(
value.frameInterval,
'timeline.info.frameInterval',
),
frames: frames.map((frame, index) => parseTimelineFrame(frame, index)),
gameId: optionalNumber(value.gameId, 'timeline.info.gameId'),
participants: participants?.map((participant, index) =>
parseTimelineParticipant(participant, index),
),
};
}
function parseMatchMetadata(value: unknown): RiotMatchMetadataDto {
if (!isRecord(value)) {
throw new TypeError('Riot match metadata must be an object.');
@@ -211,6 +273,195 @@ function parseMatchInfo(value: unknown): RiotMatchInfoDto {
};
}
function parseTimelineParticipant(
value: unknown,
index: number,
): RiotMatchTimelineParticipantDto {
if (!isRecord(value)) {
throw new TypeError(`timeline.info.participants[${index}] must be an object.`);
}
return {
...value,
participantId: requireNumber(
value.participantId,
`timeline.info.participants[${index}].participantId`,
),
puuid: requireString(value.puuid, `timeline.info.participants[${index}].puuid`),
};
}
function parseTimelineFrame(
value: unknown,
index: number,
): RiotMatchTimelineFrameDto {
if (!isRecord(value)) {
throw new TypeError(`timeline.info.frames[${index}] must be an object.`);
}
const participantFrames = value.participantFrames;
if (!isRecord(participantFrames)) {
throw new TypeError(
`timeline.info.frames[${index}].participantFrames must be an object.`,
);
}
const events = value.events;
if (events !== undefined && !Array.isArray(events)) {
throw new TypeError(
`timeline.info.frames[${index}].events must be an array when present.`,
);
}
return {
...value,
events: (events ?? []).map((event, eventIndex) =>
parseTimelineEvent(event, index, eventIndex),
),
timestamp: requireNumber(
value.timestamp,
`timeline.info.frames[${index}].timestamp`,
),
participantFrames: Object.fromEntries(
Object.entries(participantFrames).map(([key, participantFrame]) => [
key,
parseTimelineParticipantFrame(participantFrame, index, key),
]),
),
};
}
function parseTimelineEvent(
value: unknown,
frameIndex: number,
eventIndex: number,
): RiotMatchTimelineEventDto {
if (!isRecord(value)) {
throw new TypeError(
`timeline.info.frames[${frameIndex}].events[${eventIndex}] must be an object.`,
);
}
const assistingParticipantIds = value.assistingParticipantIds;
if (
assistingParticipantIds !== undefined &&
(!Array.isArray(assistingParticipantIds) ||
!assistingParticipantIds.every(isFiniteNumber))
) {
throw new TypeError(
`timeline.info.frames[${frameIndex}].events[${eventIndex}].assistingParticipantIds must be an array of numbers when present.`,
);
}
return {
...value,
afterId: optionalNumber(
value.afterId,
`timeline.info.frames[${frameIndex}].events[${eventIndex}].afterId`,
),
assistingParticipantIds,
beforeId: optionalNumber(
value.beforeId,
`timeline.info.frames[${frameIndex}].events[${eventIndex}].beforeId`,
),
buildingType: optionalString(
value.buildingType,
`timeline.info.frames[${frameIndex}].events[${eventIndex}].buildingType`,
),
itemId: optionalNumber(
value.itemId,
`timeline.info.frames[${frameIndex}].events[${eventIndex}].itemId`,
),
killerId: optionalNumber(
value.killerId,
`timeline.info.frames[${frameIndex}].events[${eventIndex}].killerId`,
),
killerTeamId: optionalNumber(
value.killerTeamId,
`timeline.info.frames[${frameIndex}].events[${eventIndex}].killerTeamId`,
),
levelUpType: optionalString(
value.levelUpType,
`timeline.info.frames[${frameIndex}].events[${eventIndex}].levelUpType`,
),
monsterSubType: optionalString(
value.monsterSubType,
`timeline.info.frames[${frameIndex}].events[${eventIndex}].monsterSubType`,
),
monsterType: optionalString(
value.monsterType,
`timeline.info.frames[${frameIndex}].events[${eventIndex}].monsterType`,
),
participantId: optionalNumber(
value.participantId,
`timeline.info.frames[${frameIndex}].events[${eventIndex}].participantId`,
),
skillSlot: optionalNumber(
value.skillSlot,
`timeline.info.frames[${frameIndex}].events[${eventIndex}].skillSlot`,
),
teamId: optionalNumber(
value.teamId,
`timeline.info.frames[${frameIndex}].events[${eventIndex}].teamId`,
),
timestamp: requireNumber(
value.timestamp,
`timeline.info.frames[${frameIndex}].events[${eventIndex}].timestamp`,
),
towerType: optionalString(
value.towerType,
`timeline.info.frames[${frameIndex}].events[${eventIndex}].towerType`,
),
type: requireString(
value.type,
`timeline.info.frames[${frameIndex}].events[${eventIndex}].type`,
),
};
}
function parseTimelineParticipantFrame(
value: unknown,
frameIndex: number,
key: string,
): RiotMatchTimelineParticipantFrameDto {
if (!isRecord(value)) {
throw new TypeError(
`timeline.info.frames[${frameIndex}].participantFrames.${key} must be an object.`,
);
}
return {
...value,
currentGold: optionalNumber(
value.currentGold,
`timeline.info.frames[${frameIndex}].participantFrames.${key}.currentGold`,
),
jungleMinionsKilled: optionalNumber(
value.jungleMinionsKilled,
`timeline.info.frames[${frameIndex}].participantFrames.${key}.jungleMinionsKilled`,
),
level: optionalNumber(
value.level,
`timeline.info.frames[${frameIndex}].participantFrames.${key}.level`,
),
minionsKilled: optionalNumber(
value.minionsKilled,
`timeline.info.frames[${frameIndex}].participantFrames.${key}.minionsKilled`,
),
participantId: requireNumber(
value.participantId,
`timeline.info.frames[${frameIndex}].participantFrames.${key}.participantId`,
),
totalGold: requireNumber(
value.totalGold,
`timeline.info.frames[${frameIndex}].participantFrames.${key}.totalGold`,
),
xp: requireNumber(
value.xp,
`timeline.info.frames[${frameIndex}].participantFrames.${key}.xp`,
),
};
}
function parseParticipant(
value: unknown,
index: number,
@@ -504,12 +755,22 @@ function parseObjectives(
baron: parseObjective(value.baron, teamIndex, 'baron'),
champion: parseObjective(value.champion, teamIndex, 'champion'),
dragon: parseObjective(value.dragon, teamIndex, 'dragon'),
horde: optionalObjective(value.horde, teamIndex, 'horde'),
inhibitor: parseObjective(value.inhibitor, teamIndex, 'inhibitor'),
riftHerald: parseObjective(value.riftHerald, teamIndex, 'riftHerald'),
tower: parseObjective(value.tower, teamIndex, 'tower'),
};
}
function optionalObjective(
value: unknown,
teamIndex: number,
key: keyof RiotMatchObjectivesDto,
): RiotMatchObjectiveDto | undefined {
if (value === undefined || value === null) return undefined;
return parseObjective(value, teamIndex, key);
}
function parseObjective(
value: unknown,
teamIndex: number,
@@ -1,15 +1,15 @@
import { GarnetService } from '../global/garnet/garnet.service';
import { RedisService } from '../global/redis/redis.service';
import { RiotRateLimiterService } from './riot-rate-limiter.service';
function makeService(sendCommand = jest.fn().mockResolvedValue(0)) {
const garnet = {
const redis = {
getString: jest.fn().mockResolvedValue(null),
raw: jest.fn().mockReturnValue({ sendCommand }),
setString: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<GarnetService>;
} as unknown as jest.Mocked<RedisService>;
return {
service: new RiotRateLimiterService(garnet),
garnet,
service: new RiotRateLimiterService(redis),
redis,
sendCommand,
};
}
@@ -51,12 +51,12 @@ describe('RiotRateLimiterService', () => {
it('records the 120 second app rate observation from Riot headers', async () => {
jest.spyOn(Date, 'now').mockReturnValue(1_000_000);
const { service, garnet } = makeService();
const { service, redis } = makeService();
await service.recordAppRateLimitObservation('47:120,3:1', '100:120,20:1');
expect(garnet.setString).toHaveBeenCalledTimes(1);
const [key, raw, ttl] = garnet.setString.mock.calls[0];
expect(redis.setString).toHaveBeenCalledTimes(1);
const [key, raw, ttl] = redis.setString.mock.calls[0];
expect(key).toBe('riot:app:rl:observed');
expect(ttl).toBe(300);
expect(JSON.parse(raw)).toEqual({
@@ -68,10 +68,10 @@ describe('RiotRateLimiterService', () => {
});
it('resets the inferred window when Riot count decreases or observation is stale', async () => {
const { service, garnet } = makeService();
const { service, redis } = makeService();
jest.spyOn(Date, 'now').mockReturnValue(1_060_000);
garnet.getString.mockResolvedValueOnce(
redis.getString.mockResolvedValueOnce(
observedState({
count120: 80,
observedAt: 1_050_000,
@@ -81,13 +81,13 @@ describe('RiotRateLimiterService', () => {
await service.recordAppRateLimitObservation('2:120', null);
expect(JSON.parse(garnet.setString.mock.calls[0][1])).toMatchObject({
expect(JSON.parse(redis.setString.mock.calls[0][1])).toMatchObject({
count120: 2,
windowStartAt: 1_060_000,
});
jest.spyOn(Date, 'now').mockReturnValue(1_240_000);
garnet.getString.mockResolvedValueOnce(
redis.getString.mockResolvedValueOnce(
observedState({
count120: 20,
observedAt: 1_120_000,
@@ -97,18 +97,18 @@ describe('RiotRateLimiterService', () => {
await service.recordAppRateLimitObservation('25:120', null);
expect(JSON.parse(garnet.setString.mock.calls[1][1])).toMatchObject({
expect(JSON.parse(redis.setString.mock.calls[1][1])).toMatchObject({
count120: 25,
windowStartAt: 1_240_000,
});
});
it('opens the refresh gate when there is no active observation', async () => {
const { service, garnet } = makeService();
const { service, redis } = makeService();
await expect(service.isRefreshWindowOpen(0.5)).resolves.toBe(true);
garnet.getString.mockResolvedValueOnce(
redis.getString.mockResolvedValueOnce(
observedState({
count120: 90,
observedAt: 1_000_000,
@@ -129,8 +129,8 @@ describe('RiotRateLimiterService', () => {
'checks tail headroom for refresh gate ratio=$ratio count=$count120',
async ({ ratio, count120, expected }) => {
jest.spyOn(Date, 'now').mockReturnValue(1_070_000);
const { service, garnet } = makeService();
garnet.getString.mockResolvedValue(
const { service, redis } = makeService();
redis.getString.mockResolvedValue(
observedState({
count120,
observedAt: 1_069_000,
@@ -144,8 +144,8 @@ describe('RiotRateLimiterService', () => {
it('keeps the refresh gate closed before the 120 second window tail', async () => {
jest.spyOn(Date, 'now').mockReturnValue(1_050_000);
const { service, garnet } = makeService();
garnet.getString.mockResolvedValue(
const { service, redis } = makeService();
redis.getString.mockResolvedValue(
observedState({
count120: 10,
observedAt: 1_049_000,
@@ -1,6 +1,6 @@
import { Injectable, Logger } from '@nestjs/common';
import type { RiotPlatformRoute, RiotRegionalRoute } from './riot.types';
import { GarnetService } from '../global/garnet/garnet.service';
import { RedisService } from '../global/redis/redis.service';
const APP_LIMITS = [
{ windowMs: 1_000, max: 15 },
@@ -85,7 +85,7 @@ return 0
export class RiotRateLimiterService {
private readonly logger = new Logger(RiotRateLimiterService.name);
constructor(private readonly garnet: GarnetService) {}
constructor(private readonly redis: RedisService) {}
public async acquire(
route: RiotRegionalRoute | RiotPlatformRoute,
@@ -133,7 +133,7 @@ export class RiotRateLimiterService {
// Concurrent responses can race here. This observation is advisory, so
// last-writer-wins is acceptable and self-corrects on the next Riot header.
await this.garnet.setString(
await this.redis.setString(
APP_OBSERVED_KEY,
JSON.stringify(observation),
APP_OBSERVED_TTL_SECONDS,
@@ -167,7 +167,7 @@ export class RiotRateLimiterService {
now: number,
cost: number,
): Promise<number> {
const client = this.garnet.raw();
const client = this.redis.raw();
const member = `${process.pid}:${now}:${Math.random().toString(36).slice(2)}`;
const argumentsList = [
String(now),
@@ -190,7 +190,7 @@ export class RiotRateLimiterService {
}
private async getAppRateObservation(): Promise<AppRateObservation | null> {
const raw = await this.garnet.getString(APP_OBSERVED_KEY);
const raw = await this.redis.getString(APP_OBSERVED_KEY);
if (!raw) return null;
try {
@@ -4,7 +4,7 @@ import type {
RiotMatch as StoredRiotMatch,
} from '../global/database/schema';
import { ConnectionService } from '../global/database/connection.service';
import { GarnetService } from '../global/garnet/garnet.service';
import { RedisService } from '../global/redis/redis.service';
import type { RiotRegionalRoute } from './riot.types';
import { RiotMatchService } from './riot-match.service';
@@ -22,7 +22,7 @@ export class RiotRecentMatchesService {
constructor(
private readonly connectionService: ConnectionService,
private readonly matchService: RiotMatchService,
private readonly garnetService: GarnetService,
private readonly redisService: RedisService,
) {}
public async syncRecentMatches(params: {
@@ -37,7 +37,7 @@ export class RiotRecentMatchesService {
const lockKey = `riot:enrich:matches:${params.puuid}`;
const lockValue = `${process.pid}:${Date.now()}`;
const acquired = await this.garnetService.setStringIfAbsent(
const acquired = await this.redisService.setStringIfAbsent(
lockKey,
lockValue,
MATCH_ENRICHMENT_LOCK_TTL_SECONDS,
@@ -103,7 +103,7 @@ export class RiotRecentMatchesService {
return this.loadFromDb({ puuid: params.puuid, limit, queueId });
} finally {
await this.garnetService.delete(lockKey).catch((error: unknown) => {
await this.redisService.delete(lockKey).catch((error: unknown) => {
this.logger.warn(
`Failed to release recent matches lock for ${params.puuid}: ${
(error as Error)?.message ?? error
+54
View File
@@ -134,6 +134,11 @@ export interface RiotMatchDto {
info: RiotMatchInfoDto;
}
export interface RiotMatchTimelineDto {
metadata: RiotMatchMetadataDto;
info: RiotMatchTimelineInfoDto;
}
export interface RiotMatchMetadataDto {
dataVersion: string;
matchId: string;
@@ -240,6 +245,7 @@ export interface RiotMatchObjectivesDto {
baron: RiotMatchObjectiveDto;
champion: RiotMatchObjectiveDto;
dragon: RiotMatchObjectiveDto;
horde?: RiotMatchObjectiveDto;
inhibitor: RiotMatchObjectiveDto;
riftHerald: RiotMatchObjectiveDto;
tower: RiotMatchObjectiveDto;
@@ -249,3 +255,51 @@ export interface RiotMatchObjectiveDto {
first: boolean;
kills: number;
}
export interface RiotMatchTimelineInfoDto extends Record<string, unknown> {
frameInterval: number;
frames: RiotMatchTimelineFrameDto[];
gameId?: number;
participants?: RiotMatchTimelineParticipantDto[];
}
export interface RiotMatchTimelineParticipantDto extends Record<string, unknown> {
participantId: number;
puuid: string;
}
export interface RiotMatchTimelineFrameDto extends Record<string, unknown> {
timestamp: number;
events: RiotMatchTimelineEventDto[];
participantFrames: Record<string, RiotMatchTimelineParticipantFrameDto>;
}
export interface RiotMatchTimelineEventDto extends Record<string, unknown> {
type: string;
timestamp: number;
afterId?: number;
assistingParticipantIds?: number[];
beforeId?: number;
buildingType?: string;
itemId?: number;
killerId?: number;
killerTeamId?: number;
levelUpType?: string;
monsterSubType?: string;
monsterType?: string;
participantId?: number;
skillSlot?: number;
teamId?: number;
towerType?: string;
}
export interface RiotMatchTimelineParticipantFrameDto
extends Record<string, unknown> {
participantId: number;
totalGold: number;
xp: number;
currentGold?: number;
jungleMinionsKilled?: number;
level?: number;
minionsKilled?: number;
}
@@ -1,5 +1,6 @@
import {
resolveRoundRobinTeamCount,
roundRobinGameSchedule,
roundRobinPairCount,
roundRobinPairs,
shuffleInPlace,
@@ -25,6 +26,30 @@ describe('round-robin util', () => {
expect(roundRobinPairCount(6)).toBe(15);
});
it('builds round-robin games grouped into simultaneously playable rounds', () => {
const schedule = roundRobinGameSchedule(6, { gamesPerPair: 1 });
expect(schedule).toHaveLength(15);
for (const roundNumber of [1, 2, 3, 4, 5]) {
const round = schedule.filter((game) => game.roundNumber === roundNumber);
expect(round).toHaveLength(3);
expect(new Set(round.flatMap((game) => [game.teamAIndex, game.teamBIndex])))
.toHaveProperty('size', 6);
}
});
it('limits round-robin games by max rounds', () => {
const schedule = roundRobinGameSchedule(8, {
gamesPerPair: 1,
maxRounds: 3,
});
expect(schedule).toHaveLength(12);
expect(new Set(schedule.map((game) => game.roundNumber))).toEqual(
new Set([1, 2, 3]),
);
});
it('resolves team count from teams first, then active participants', () => {
expect(
resolveRoundRobinTeamCount({
@@ -3,11 +3,23 @@ export interface RoundRobinPair {
teamBIndex: number;
}
export interface RoundRobinGameAssignment extends RoundRobinPair {
gameNumber: number;
roundNumber: number;
}
export interface RoundRobinTeamCountInput {
teams?: Array<{ teamIndex: number }>;
participants: Array<{ excluded?: boolean }>;
}
export interface RoundRobinGameScheduleOptions {
gamesPerPair?: number;
maxRounds?: number;
rng?: () => number;
shuffleTeams?: boolean;
}
export function roundRobinPairs(teamCount: number): RoundRobinPair[] {
const pairs: RoundRobinPair[] = [];
for (let teamAIndex = 1; teamAIndex <= teamCount; teamAIndex += 1) {
@@ -27,6 +39,70 @@ export function roundRobinPairCount(teamCount: number): number {
return (teamCount * (teamCount - 1)) / 2;
}
export function roundRobinRoundCount(teamCount: number): number {
if (teamCount < 2) return 0;
return teamCount % 2 === 0 ? teamCount - 1 : teamCount;
}
export function roundRobinGameSchedule(
teamCount: number,
options: RoundRobinGameScheduleOptions = {},
): RoundRobinGameAssignment[] {
if (teamCount < 2) return [];
const rawGamesPerPair = options.gamesPerPair ?? 1;
const gamesPerPair = Number.isFinite(rawGamesPerPair)
? Math.max(1, Math.floor(rawGamesPerPair))
: 1;
const fullRoundCount = roundRobinRoundCount(teamCount);
const requestedRoundCount =
typeof options.maxRounds === 'number' && Number.isFinite(options.maxRounds)
? Math.floor(options.maxRounds)
: fullRoundCount;
const roundLimit = Math.max(
0,
Math.min(fullRoundCount, requestedRoundCount),
);
if (roundLimit === 0) return [];
const bye = 0;
const teams = Array.from({ length: teamCount }, (_, index) => index + 1);
if (options.shuffleTeams) shuffleInPlace(teams, options.rng);
if (teams.length % 2 === 1) teams.push(bye);
const rotating = [...teams];
const schedule: RoundRobinGameAssignment[] = [];
let gameNumber = 1;
for (let roundIndex = 0; roundIndex < roundLimit; roundIndex += 1) {
const roundNumber = 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;
const teamAIndex = Math.min(left, right);
const teamBIndex = Math.max(left, right);
for (let gameIndex = 0; gameIndex < gamesPerPair; gameIndex += 1) {
schedule.push({
gameNumber,
roundNumber,
teamAIndex,
teamBIndex,
});
gameNumber += 1;
}
}
const fixed = rotating[0];
const tail = rotating.slice(1);
tail.unshift(tail.pop() as number);
rotating.splice(0, rotating.length, fixed, ...tail);
}
return schedule;
}
export function resolveRoundRobinTeamCount(
match: RoundRobinTeamCountInput,
): number {
@@ -0,0 +1,111 @@
import {
SYSTEM_TOURNAMENT_CODE_UPLOADED_BY,
TournamentCodeAutoProvisionService,
} from './tournament-code-auto-provision.service';
import { TournamentCodeService } from './tournament-code.service';
import { TournamentCodeVendorService } from './tournament-code-vendor.service';
describe('TournamentCodeAutoProvisionService', () => {
function createFixture(params?: {
availableCounts?: number[];
vendorCodes?: string[];
}) {
const availableCounts = [...(params?.availableCounts ?? [30])];
const vendorCodes = [...(params?.vendorCodes ?? [])];
const tournamentCodeService = {
countUsableAvailable: jest.fn().mockImplementation(async () => {
return availableCounts.shift() ?? 30;
}),
bulkUpload: jest.fn().mockResolvedValue({
inserted: 1,
duplicates: [],
invalid: [],
}),
} as unknown as jest.Mocked<TournamentCodeService>;
const vendorService = {
fetchTournamentCode: jest.fn().mockImplementation(async () => {
const code = vendorCodes.shift();
if (!code) throw new Error('No vendor code');
return code;
}),
} as unknown as jest.Mocked<TournamentCodeVendorService>;
const service = new TournamentCodeAutoProvisionService(
tournamentCodeService,
vendorService,
);
jest
.spyOn(
service as unknown as { sleepBeforeVendorRequest(): Promise<void> },
'sleepBeforeVendorRequest',
)
.mockResolvedValue(undefined);
return { service, tournamentCodeService, vendorService };
}
it('does nothing when the usable pool already meets the target', async () => {
const { service, tournamentCodeService, vendorService } = createFixture({
availableCounts: [30],
});
await expect(service.ensurePool()).resolves.toMatchObject({
target: 30,
before: 30,
after: 30,
requested: 0,
inserted: 0,
});
expect(vendorService.fetchTournamentCode).not.toHaveBeenCalled();
expect(tournamentCodeService.bulkUpload).not.toHaveBeenCalled();
});
it('requests vendor codes until the pool reaches 30', async () => {
const { service, tournamentCodeService, vendorService } = createFixture({
availableCounts: [28, 29, 30],
vendorCodes: ['KR05090-aBc', 'KR05090-dEf'],
});
const result = await service.ensurePool();
expect(result).toMatchObject({
target: 30,
before: 28,
after: 30,
requested: 2,
inserted: 2,
});
expect(vendorService.fetchTournamentCode).toHaveBeenCalledTimes(2);
expect(
(
service as unknown as {
sleepBeforeVendorRequest: jest.Mock;
}
).sleepBeforeVendorRequest,
).toHaveBeenCalledTimes(2);
expect(tournamentCodeService.bulkUpload).toHaveBeenCalledWith({
uploadedBy: SYSTEM_TOURNAMENT_CODE_UPLOADED_BY,
codes: [
expect.objectContaining({
code: 'KR05090-aBc',
source: 'deeplol-vendor',
spectatorType: 'ALL',
}),
],
});
});
it('shares an in-flight refill instead of starting overlapping vendor loops', async () => {
const { service, vendorService } = createFixture({
availableCounts: [29, 30],
vendorCodes: ['KR05090-aBc'],
});
const [left, right] = await Promise.all([
service.ensurePool(),
service.ensurePool(),
]);
expect(left).toBe(right);
expect(vendorService.fetchTournamentCode).toHaveBeenCalledTimes(1);
});
});
@@ -0,0 +1,128 @@
import { Injectable, Logger } from '@nestjs/common';
import mongoose from 'mongoose';
import { TOURNAMENT_CODE_EXPIRY_MARGIN_MS } from './tournament-code.constants';
import { TournamentCodeService } from './tournament-code.service';
import {
resolveVendorRequestDelayMs,
TournamentCodeVendorService,
} from './tournament-code-vendor.service';
const DEFAULT_POOL_TARGET = 30;
const DEFAULT_VENDOR_CODE_EXPIRES_IN_MS = 14 * 24 * 60 * 60 * 1000;
const MAX_REFILL_ATTEMPTS_MULTIPLIER = 2;
export const SYSTEM_TOURNAMENT_CODE_UPLOADED_BY = new mongoose.Types.ObjectId(
'000000000000000000000000',
);
export interface TournamentCodeAutoProvisionResult {
target: number;
before: number;
after: number;
requested: number;
inserted: number;
duplicates: number;
invalid: number;
}
@Injectable()
export class TournamentCodeAutoProvisionService {
private readonly logger = new Logger(TournamentCodeAutoProvisionService.name);
private inFlight?: Promise<TournamentCodeAutoProvisionResult>;
constructor(
private readonly tournamentCodeService: TournamentCodeService,
private readonly vendorService: TournamentCodeVendorService,
) {}
public async ensurePool(): Promise<TournamentCodeAutoProvisionResult> {
if (this.inFlight) return this.inFlight;
this.inFlight = this.refillPool().finally(() => {
this.inFlight = undefined;
});
return this.inFlight;
}
public async sleepBeforeVendorRequest(): Promise<void> {
await sleep(resolveVendorRequestDelayMs());
}
private async refillPool(): Promise<TournamentCodeAutoProvisionResult> {
const target = resolvePoolTarget();
const before = await this.tournamentCodeService.countUsableAvailable();
let after = before;
let requested = 0;
let inserted = 0;
let duplicates = 0;
let invalid = 0;
const maxAttempts = Math.max(
1,
(target - before) * MAX_REFILL_ATTEMPTS_MULTIPLIER,
);
while (after < target && requested < maxAttempts) {
await this.sleepBeforeVendorRequest();
const code = await this.vendorService.fetchTournamentCode();
requested += 1;
const uploadResult = await this.tournamentCodeService.bulkUpload({
uploadedBy: SYSTEM_TOURNAMENT_CODE_UPLOADED_BY,
codes: [
{
code,
expiresAt: resolveVendorCodeExpiresAt().toISOString(),
spectatorType: 'ALL',
source: 'deeplol-vendor',
notes: 'auto-provisioned from Deeplol vendor',
},
],
});
inserted += uploadResult.inserted;
duplicates += uploadResult.duplicates.length;
invalid += uploadResult.invalid.length;
after = await this.tournamentCodeService.countUsableAvailable();
}
if (inserted > 0 || before < target) {
this.logger.log(
`Tournament code pool refill: before=${before} after=${after} target=${target} requested=${requested} inserted=${inserted} duplicates=${duplicates} invalid=${invalid}`,
);
}
return {
target,
before,
after,
requested,
inserted,
duplicates,
invalid,
};
}
}
function resolvePoolTarget(): number {
const configured = Number(process.env.TOURNAMENT_CODE_POOL_TARGET);
return Number.isInteger(configured) && configured > 0
? configured
: DEFAULT_POOL_TARGET;
}
function resolveVendorCodeExpiresAt(): Date {
const configuredHours = Number(
process.env.TOURNAMENT_CODE_VENDOR_EXPIRES_IN_HOURS,
);
const expiresInMs =
Number.isFinite(configuredHours) && configuredHours > 0
? configuredHours * 60 * 60 * 1000
: DEFAULT_VENDOR_CODE_EXPIRES_IN_MS;
return new Date(
Date.now() + Math.max(expiresInMs, TOURNAMENT_CODE_EXPIRY_MARGIN_MS),
);
}
function sleep(ms: number): Promise<void> {
return new Promise((resolve) => setTimeout(resolve, ms));
}
@@ -0,0 +1,47 @@
import mongoose from 'mongoose';
import { METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED } from '../auth/allow-public-access.decorator';
import { TournamentCodeReplacementController } from './tournament-code-replacement.controller';
import type { TournamentCodeService } from './tournament-code.service';
describe('TournamentCodeReplacementController', () => {
function createFixture() {
const service = {
replaceForMatchGame: jest.fn().mockResolvedValue({
gameNumber: 1,
code: 'NEW-CODE',
}),
} as unknown as jest.Mocked<
Pick<TournamentCodeService, 'replaceForMatchGame'>
>;
const controller = new TournamentCodeReplacementController(
service as unknown as TournamentCodeService,
);
const communityId = new mongoose.Types.ObjectId();
const matchId = new mongoose.Types.ObjectId();
return { controller, service, communityId, matchId };
}
it('allows public replacement requests', async () => {
const { controller, service, communityId, matchId } = createFixture();
await expect(
controller.replaceForMatchGame(communityId, matchId, 1),
).resolves.toEqual(expect.objectContaining({ code: 'NEW-CODE' }));
expect(service.replaceForMatchGame).toHaveBeenCalledWith({
communityId,
matchId,
gameNumber: 1,
});
});
it('marks the replacement endpoint as public access', () => {
expect(
Reflect.getMetadata(
METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED,
TournamentCodeReplacementController.prototype.replaceForMatchGame,
),
).toBe(true);
});
});
@@ -0,0 +1,30 @@
import {
Controller,
Param,
ParseIntPipe,
Post,
} from '@nestjs/common';
import mongoose from 'mongoose';
import { AllowPublicAccess } from '../auth/allow-public-access.decorator';
import { ParseObjectIdPipe } from '../common/parse-object-id.pipe';
import { TournamentCodeService } from './tournament-code.service';
@Controller('communities/:communityId/tournament-codes')
export class TournamentCodeReplacementController {
constructor(private readonly tournamentCodeService: TournamentCodeService) {}
@Post('matches/:matchId/games/:gameNumber/replace')
@AllowPublicAccess()
public async replaceForMatchGame(
@Param('communityId', ParseObjectIdPipe)
communityId: mongoose.Types.ObjectId,
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
@Param('gameNumber', ParseIntPipe) gameNumber: number,
) {
return this.tournamentCodeService.replaceForMatchGame({
communityId,
matchId,
gameNumber,
});
}
}
@@ -0,0 +1,95 @@
import {
buildDeeplolTournamentCodeRequest,
resolveVendorRequestDelayMs,
TournamentCodeVendorService,
} from './tournament-code-vendor.service';
describe('TournamentCodeVendorService', () => {
const originalFetch = global.fetch;
afterEach(() => {
global.fetch = originalFetch;
jest.restoreAllMocks();
});
it('builds the Deeplol request URL and browser-like headers', () => {
const request = buildDeeplolTournamentCodeRequest();
expect(request.url.toString()).toBe(
'https://b2c-api.deeplol.gg/tournament/tournament_code?server_id=212&server_name=%EB%A1%A4%EB%A6%BC%ED%91%B8%EC%8A%A4&server_comment=LPS_%EB%82%B4%EC%A0%84&spectator_type=ALL&pick_type=TOURNAMENT_DRAFT&map_name=SUMMONERS_RIFT&platform_id=KR',
);
expect(request.headers).toMatchObject({
accept: '*/*',
'accept-encoding': 'gzip, deflate, br, zstd',
'accept-language': 'ko,en;q=0.9,en-US;q=0.8',
'cache-control': 'no-cache',
host: 'b2c-api.deeplol.gg',
origin: 'https://clash.deeplol.gg',
pragma: 'no-cache',
priority: 'u=1, i',
referer: 'https://clash.deeplol.gg/',
'sec-ch-ua':
'"Microsoft Edge";v="149", "Chromium";v="149", "Not)A;Brand";v="24"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-platform': '"Windows"',
'sec-fetch-dest': 'empty',
'sec-fetch-mode': 'cors',
'sec-fetch-site': 'same-site',
'user-agent':
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36 Edg/149.0.0.0',
});
expect(Object.keys(request.headers)).not.toContain(':authority');
});
it('fetches the first tournament code from the vendor response', async () => {
global.fetch = jest.fn().mockResolvedValue({
ok: true,
status: 200,
json: jest.fn().mockResolvedValue({
tournament_code_list: [
'KR05090-85d64e26-0a7d-438b-9ada-11784e46add3',
],
}),
});
const service = new TournamentCodeVendorService();
await expect(service.fetchTournamentCode()).resolves.toBe(
'KR05090-85d64e26-0a7d-438b-9ada-11784e46add3',
);
expect(global.fetch).toHaveBeenCalledWith(
expect.stringContaining(
'https://b2c-api.deeplol.gg/tournament/tournament_code?',
),
expect.objectContaining({
method: 'GET',
headers: expect.objectContaining({
origin: 'https://clash.deeplol.gg',
referer: 'https://clash.deeplol.gg/',
}),
signal: expect.any(AbortSignal),
}),
);
});
it('rejects malformed vendor responses', async () => {
global.fetch = jest.fn().mockResolvedValue({
ok: true,
status: 200,
json: jest.fn().mockResolvedValue({
tournament_code_list: [null],
}),
});
const service = new TournamentCodeVendorService();
await expect(service.fetchTournamentCode()).rejects.toThrow(
'Vendor tournament code response is malformed.',
);
});
it('generates mostly near-5-second delays with occasional extra delay', () => {
expect(resolveVendorRequestDelayMs(() => 0.1)).toBe(5_050);
expect(resolveVendorRequestDelayMs(() => 0.84)).toBe(5_420);
expect(resolveVendorRequestDelayMs(() => 0.9)).toBe(8_700);
expect(resolveVendorRequestDelayMs(() => 0)).toBeGreaterThanOrEqual(5_000);
});
});
@@ -0,0 +1,152 @@
import { Injectable } from '@nestjs/common';
const DEFAULT_VENDOR_URL =
'https://b2c-api.deeplol.gg/tournament/tournament_code';
const DEFAULT_FETCH_TIMEOUT_MS = 10_000;
const MIN_REQUEST_DELAY_MS = 5_000;
const DEFAULT_QUERY_PARAMS = {
server_id: '212',
server_name: '롤림푸스',
server_comment: 'LPS_내전',
spectator_type: 'ALL',
pick_type: 'TOURNAMENT_DRAFT',
map_name: 'SUMMONERS_RIFT',
platform_id: 'KR',
} as const;
const BROWSER_LIKE_HEADERS = {
accept: '*/*',
'accept-encoding': 'gzip, deflate, br, zstd',
'accept-language': 'ko,en;q=0.9,en-US;q=0.8',
'cache-control': 'no-cache',
host: 'b2c-api.deeplol.gg',
origin: 'https://clash.deeplol.gg',
pragma: 'no-cache',
priority: 'u=1, i',
referer: 'https://clash.deeplol.gg/',
'sec-ch-ua':
'"Microsoft Edge";v="149", "Chromium";v="149", "Not)A;Brand";v="24"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-platform': '"Windows"',
'sec-fetch-dest': 'empty',
'sec-fetch-mode': 'cors',
'sec-fetch-site': 'same-site',
'user-agent':
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36 Edg/149.0.0.0',
} as const;
interface DeeplolTournamentCodeResponse {
tournament_code_list?: unknown;
}
export interface DeeplolTournamentCodeRequest {
url: URL;
headers: Record<string, string>;
}
@Injectable()
export class TournamentCodeVendorService {
public async fetchTournamentCode(): Promise<string> {
const request = buildDeeplolTournamentCodeRequest();
const controller = new AbortController();
const timeout = setTimeout(() => {
controller.abort();
}, resolveFetchTimeoutMs());
try {
const response = await fetch(request.url.toString(), {
method: 'GET',
headers: request.headers,
signal: controller.signal,
});
if (!response.ok) {
throw new Error(
`Vendor tournament code request failed (${response.status}).`,
);
}
const payload = (await response.json()) as DeeplolTournamentCodeResponse;
return parseVendorTournamentCode(payload);
} finally {
clearTimeout(timeout);
}
}
}
export function buildDeeplolTournamentCodeRequest(
env: NodeJS.ProcessEnv = process.env,
): DeeplolTournamentCodeRequest {
const url = new URL(
env.TOURNAMENT_CODE_VENDOR_URL?.trim() || DEFAULT_VENDOR_URL,
);
const params = {
server_id:
env.TOURNAMENT_CODE_VENDOR_SERVER_ID ?? DEFAULT_QUERY_PARAMS.server_id,
server_name:
env.TOURNAMENT_CODE_VENDOR_SERVER_NAME ??
DEFAULT_QUERY_PARAMS.server_name,
server_comment:
env.TOURNAMENT_CODE_VENDOR_SERVER_COMMENT ??
DEFAULT_QUERY_PARAMS.server_comment,
spectator_type:
env.TOURNAMENT_CODE_VENDOR_SPECTATOR_TYPE ??
DEFAULT_QUERY_PARAMS.spectator_type,
pick_type:
env.TOURNAMENT_CODE_VENDOR_PICK_TYPE ?? DEFAULT_QUERY_PARAMS.pick_type,
map_name:
env.TOURNAMENT_CODE_VENDOR_MAP_NAME ?? DEFAULT_QUERY_PARAMS.map_name,
platform_id:
env.TOURNAMENT_CODE_VENDOR_PLATFORM_ID ??
DEFAULT_QUERY_PARAMS.platform_id,
};
for (const [key, value] of Object.entries(params)) {
url.searchParams.set(key, value);
}
return {
url,
headers: {
...BROWSER_LIKE_HEADERS,
host: url.host,
},
};
}
export function resolveVendorRequestDelayMs(
random: () => number = Math.random,
): number {
const roll = clampRandom(random());
if (roll < 0.85) {
return MIN_REQUEST_DELAY_MS + Math.round(roll * 500);
}
return MIN_REQUEST_DELAY_MS + 100 + Math.round(roll * 4_000);
}
function parseVendorTournamentCode(
payload: DeeplolTournamentCodeResponse,
): string {
const codes = payload.tournament_code_list;
if (
!Array.isArray(codes) ||
typeof codes[0] !== 'string' ||
!codes[0].trim()
) {
throw new Error('Vendor tournament code response is malformed.');
}
return codes[0].trim();
}
function resolveFetchTimeoutMs(): number {
const configured = Number(process.env.TOURNAMENT_CODE_VENDOR_TIMEOUT_MS);
return Number.isFinite(configured) && configured > 0
? configured
: DEFAULT_FETCH_TIMEOUT_MS;
}
function clampRandom(value: number): number {
if (!Number.isFinite(value)) return 0;
return Math.min(1, Math.max(0, value));
}
@@ -1,11 +1,21 @@
import { Module } from '@nestjs/common';
import { TournamentResultModule } from '../tournament-result/tournament-result.module';
import { TournamentCodeController } from './tournament-code.controller';
import { TournamentCodeAutoProvisionService } from './tournament-code-auto-provision.service';
import { TournamentCodeReplacementController } from './tournament-code-replacement.controller';
import { TournamentCodeScheduler } from './tournament-code.scheduler';
import { TournamentCodeService } from './tournament-code.service';
import { TournamentCodeVendorService } from './tournament-code-vendor.service';
@Module({
controllers: [TournamentCodeController],
providers: [TournamentCodeService, TournamentCodeScheduler],
imports: [TournamentResultModule],
controllers: [TournamentCodeController, TournamentCodeReplacementController],
providers: [
TournamentCodeService,
TournamentCodeVendorService,
TournamentCodeAutoProvisionService,
TournamentCodeScheduler,
],
exports: [TournamentCodeService],
})
export class TournamentCodeModule {}
Loaded 100 of 137 files, more files were not shown because too many files have changed in this diff. Show more