Compare commits

...
24 Commits
Author SHA1 Message Date
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
122 changed files with 22881 additions and 930 deletions

No files matched your search

+5 -2
View File
@@ -91,7 +91,8 @@ LOLYMPUS는 이 반복 작업을 줄이는 데 초점을 맞췄습니다. 운영
- TanStack Query - TanStack Query
- NestJS - NestJS
- MongoDB - MongoDB
- Redis/Garnet - Redis
- Redis 8.4 (경매 실시간 상태 전용)
- NATS - NATS
- Riot API - Riot API
- pnpm workspace - pnpm workspace
@@ -113,7 +114,9 @@ scripts/ deployment and maintenance scripts
- Node.js 24 이상 - Node.js 24 이상
- pnpm 10.4.1 (`packageManager` 기준, `corepack enable`로 활성화 권장) - 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`를 읽고, 두 값이 같은 호스트/포트를 가리키면 부팅을 거부합니다.
## 실행 방법 ## 실행 방법
+1
View File
@@ -32,6 +32,7 @@
"@nestjs/platform-socket.io": "^11.1.19", "@nestjs/platform-socket.io": "^11.1.19",
"@nestjs/swagger": "^11.2.7", "@nestjs/swagger": "^11.2.7",
"@nestjs/websockets": "^11.1.19", "@nestjs/websockets": "^11.1.19",
"@socket.io/redis-adapter": "^8.3.0",
"class-transformer": "^0.5.1", "class-transformer": "^0.5.1",
"class-validator": "^0.15.1", "class-validator": "^0.15.1",
"jose": "^6.2.2", "jose": "^6.2.2",
+4
View File
@@ -2,6 +2,7 @@ import { ValidationPipe } from '@nestjs/common';
import { NestFactory } from '@nestjs/core'; import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module'; import { AppModule } from './app.module';
import { createCorsOrigin } from './cors-origin'; import { createCorsOrigin } from './cors-origin';
import { RedisIoAdapter } from './redis-io.adapter';
async function bootstrap() { async function bootstrap() {
const app = await NestFactory.create(AppModule, { const app = await NestFactory.create(AppModule, {
@@ -10,6 +11,9 @@ async function bootstrap() {
const nodeEnv = process.env.NODE_ENV; const nodeEnv = process.env.NODE_ENV;
const isDev = nodeEnv === 'dev'; const isDev = nodeEnv === 'dev';
const redisIoAdapter = new RedisIoAdapter(app);
await redisIoAdapter.connectToRedis();
app.useWebSocketAdapter(redisIoAdapter);
app.enableCors({ app.enableCors({
origin: createCorsOrigin(nodeEnv), 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 { AuctionService } from './auction.service';
import { AuctionGateway } from './auction.gateway'; import { AuctionGateway } from './auction.gateway';
import { import {
NextAuctionDto,
OpenBiddingDto,
PassedAuctionDto,
PlaceBidDto, PlaceBidDto,
ResetAuctionDto,
SoldDto, SoldDto,
StartAuctionDto, StartAuctionDto,
UndoAuctionDto, UndoAuctionDto,
@@ -47,18 +51,22 @@ export class AuctionController {
return this.auctionService.start({ return this.auctionService.start({
matchId, matchId,
communityId, communityId,
startAuctionRequestId: body.startAuctionRequestId,
actorUserId: currentUser._id,
captains: body.captains.map((c) => ({ captains: body.captains.map((c) => ({
teamIndex: c.teamIndex, teamIndex: c.teamIndex,
userId: new mongoose.Types.ObjectId(c.userId), userId: new mongoose.Types.ObjectId(c.userId),
initialPoints: c.initialPoints, initialTeamBidPointAmount: c.initialTeamBidPointAmount,
})), })),
initialPoints: body.initialPoints ?? 1000, initialTeamBidPointAmount: body.initialTeamBidPointAmount ?? 1000,
maxTimerSeconds: body.maxTimerSeconds ?? 30, maximumBidRoundDurationSeconds:
bidExtensionSeconds: body.bidExtensionSeconds ?? 5, body.maximumBidRoundDurationSeconds ?? 30,
topTierThreshold: body.topTierThreshold ?? 'NONE', bidRoundExtensionSeconds: body.bidRoundExtensionSeconds ?? 5,
manualTopTierUserIds: (body.manualTopTierUserIds ?? []).map( topTierAuctionPriorityThreshold:
(userId) => new mongoose.Types.ObjectId(userId), body.topTierAuctionPriorityThreshold ?? 'NONE',
), manualTopTierAuctionPriorityUserIds: (
body.manualTopTierAuctionPriorityUserIds ?? []
).map((userId) => new mongoose.Types.ObjectId(userId)),
}); });
} }
@@ -67,7 +75,7 @@ export class AuctionController {
public async getAuction( public async getAuction(
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
) { ) {
return this.auctionService.getByMatchId(matchId); return this.auctionService.getStateByMatchId(matchId);
} }
// 공개 — 팀장 2명만 쓸 엔드포인트(트러스트 기반, 10명 동시 관전). // 공개 — 팀장 2명만 쓸 엔드포인트(트러스트 기반, 10명 동시 관전).
@@ -76,23 +84,26 @@ export class AuctionController {
@HttpCode(HttpStatus.OK) @HttpCode(HttpStatus.OK)
public async openBidding( public async openBidding(
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
@Body() body: OpenBiddingDto = {},
) { ) {
return this.auctionService.openBidding(matchId); return this.auctionService.openBidding(matchId, body);
} }
@Post('bids') @Post('bids')
@AllowPublicAccess() @AllowPublicAccess()
@HttpCode(HttpStatus.OK) @HttpCode(HttpStatus.OK)
public async placeBid( public async placeBid(
@CurrentUser() currentUser: UserDocument | undefined,
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
@Body() body: PlaceBidDto, @Body() body: PlaceBidDto,
) { ) {
return this.auctionService.placeBid({ return this.auctionService.placeBid({
matchId, matchId,
teamIndex: body.teamIndex, teamIndex: body.bidderTeamIndex,
amount: body.amount, amount: body.bidPointAmount,
bidderUserId: this.resolveBidder(currentUser, body.bidderUserId), bidRequestId: body.bidRequestId,
clientObservedAuctionLifecycleId: body.clientObservedAuctionLifecycleId,
clientObservedCurrentBidRoundPlayerUserId:
body.clientObservedCurrentBidRoundPlayerUserId,
}); });
} }
@@ -106,16 +117,35 @@ export class AuctionController {
return this.auctionService.markSold({ return this.auctionService.markSold({
matchId, matchId,
assignedPosition: body.assignedPosition, 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') @Post('next')
@AllowPublicAccess() @AllowPublicAccess()
@HttpCode(HttpStatus.OK) @HttpCode(HttpStatus.OK)
public async next( public async next(
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
@Body() body: NextAuctionDto = {},
) { ) {
return this.auctionService.next(matchId); return this.auctionService.next(matchId, body);
} }
@Get('history') @Get('history')
@@ -147,6 +177,14 @@ export class AuctionController {
matchId, matchId,
communityId, communityId,
sequence: body.sequence, 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); this.auctionGateway.broadcastState(matchId.toString(), auction);
return auction; return auction;
@@ -161,24 +199,24 @@ export class AuctionController {
@Param('communityId', ParseObjectIdPipe) @Param('communityId', ParseObjectIdPipe)
communityId: mongoose.Types.ObjectId, communityId: mongoose.Types.ObjectId,
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
@Body() body: ResetAuctionDto = {},
) { ) {
this.assertSameCommunity(currentUser, communityId); 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()); 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( private assertSameCommunity(
user: UserDocument, user: UserDocument,
communityId: mongoose.Types.ObjectId, 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 { Logger } from '@nestjs/common';
import { randomUUID } from 'crypto';
import { performance } from 'perf_hooks';
import { import {
Ack,
ConnectedSocket, ConnectedSocket,
MessageBody, MessageBody,
OnGatewayConnection, OnGatewayConnection,
OnGatewayDisconnect, OnGatewayInit,
SubscribeMessage, SubscribeMessage,
WebSocketGateway, WebSocketGateway,
WebSocketServer, WebSocketServer,
@@ -23,26 +26,64 @@ import type {
UserDocument, UserDocument,
} from '../global/database/schema'; } from '../global/database/schema';
import { AuctionService } from './auction.service'; 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 { interface JoinAuctionPayload {
matchId: string; matchId: string;
} }
interface BidPayload { interface BidPayload {
teamIndex: number; bidderTeamIndex: number;
amount: number; bidPointAmount: number;
bidderUserId?: string; bidRequestId?: string;
clientObservedAuctionLifecycleId?: string;
clientObservedCurrentBidRoundPlayerUserId?: string;
}
interface TimeSyncPayload {
clientSentAtTimestampMS?: number;
sequence?: number;
} }
interface SoldPayload { interface SoldPayload {
auctionActionRequestId?: string;
assignedPosition?: Position; assignedPosition?: Position;
clientObservedAuctionLifecycleId?: string;
clientObservedCurrentAuctionPlayerOrderIndex?: number;
clientObservedCurrentBidRoundPlayerUserId?: string;
clientObservedPhase?: string;
clientObservedRevision?: number;
} }
type AuctionActionPayload = Omit<SoldPayload, 'assignedPosition'>;
interface ChatMessagePayload { interface ChatMessagePayload {
message?: string; message?: string;
displayName?: 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({ @WebSocketGateway({
namespace: '/auction', namespace: '/auction',
cors: { cors: {
@@ -52,13 +93,12 @@ interface ChatMessagePayload {
}, },
}) })
export class AuctionGateway export class AuctionGateway
implements OnGatewayConnection, OnGatewayDisconnect implements OnGatewayConnection, OnGatewayInit
{ {
@WebSocketServer() @WebSocketServer()
private server!: Namespace; private server!: Namespace;
private readonly logger = new Logger(AuctionGateway.name); private readonly logger = new Logger(AuctionGateway.name);
private readonly roomTimers = new Map<string, NodeJS.Timeout>();
constructor( constructor(
private readonly auctionService: AuctionService, private readonly auctionService: AuctionService,
@@ -66,8 +106,14 @@ export class AuctionGateway
private readonly jwtService: JwtService, private readonly jwtService: JwtService,
private readonly identityService: IdentityService, private readonly identityService: IdentityService,
private readonly connectionService: ConnectionService, 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) { public async handleConnection(socket: Socket) {
try { try {
await this.authenticateSocket(socket); 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') @SubscribeMessage('join')
public async handleJoin( public async handleJoin(
@ConnectedSocket() socket: Socket, @ConnectedSocket() socket: Socket,
@@ -106,8 +146,11 @@ export class AuctionGateway
const auction = await this.auctionService.getByMatchId( const auction = await this.auctionService.getByMatchId(
new mongoose.Types.ObjectId(payload.matchId), new mongoose.Types.ObjectId(payload.matchId),
); );
const auctionState = await this.auctionService.getStateByMatchId(
new mongoose.Types.ObjectId(payload.matchId),
);
this.emitChatHistory(socket, auction); this.emitChatHistory(socket, auction);
this.broadcastState(payload.matchId, auction); this.broadcastState(payload.matchId, auctionState);
} catch (error) { } catch (error) {
this.emitKnownError(socket, error); this.emitKnownError(socket, error);
} }
@@ -117,41 +160,133 @@ export class AuctionGateway
public async handleBid( public async handleBid(
@ConnectedSocket() socket: Socket, @ConnectedSocket() socket: Socket,
@MessageBody() payload: BidPayload, @MessageBody() payload: BidPayload,
@Ack() ack?: (response: Record<string, unknown>) => void,
) { ) {
const gatewayBidStartedAtMS = performance.now();
const matchId = this.requireJoinedMatchId(socket); const matchId = this.requireJoinedMatchId(socket);
if (!matchId) return; if (!matchId) return;
const bidderUserId = this.resolveBidderUserId(socket, payload?.bidderUserId); const bidRequestId = payload.bidRequestId ?? randomUUID();
if (payload?.bidderUserId && !bidderUserId) { if (!this.consumeBidRateLimit(socket)) {
this.emitError(socket, 'Invalid bidderUserId.'); 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; return;
} }
try { try {
const auction = await this.auctionService.placeBid({ const bidResult = await this.auctionService.placeBidDelta({
matchId: new mongoose.Types.ObjectId(matchId), matchId: new mongoose.Types.ObjectId(matchId),
teamIndex: payload.teamIndex, teamIndex: payload.bidderTeamIndex,
amount: payload.amount, amount: payload.bidPointAmount,
bidderUserId, 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) { } 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') @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); const matchId = this.requireJoinedMatchId(socket);
if (!matchId) return; if (!matchId) return;
try { try {
const auction = await this.auctionService.openBidding( const auction = await this.auctionService.openBidding(
new mongoose.Types.ObjectId(matchId), new mongoose.Types.ObjectId(matchId),
this.toSocketAuctionActionRequest(payload),
); );
this.broadcastState(matchId, auction); this.broadcastState(matchId, auction);
ack?.({
auctionActionRequestId: payload?.auctionActionRequestId,
ok: true,
});
} catch (error) { } catch (error) {
this.emitKnownError(socket, 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( public async handleSold(
@ConnectedSocket() socket: Socket, @ConnectedSocket() socket: Socket,
@MessageBody() payload: SoldPayload, @MessageBody() payload: SoldPayload,
@Ack() ack?: (response: Record<string, unknown>) => void,
) { ) {
const matchId = this.requireJoinedMatchId(socket); const matchId = this.requireJoinedMatchId(socket);
if (!matchId) return; if (!matchId) return;
@@ -167,25 +303,78 @@ export class AuctionGateway
const auction = await this.auctionService.markSold({ const auction = await this.auctionService.markSold({
matchId: new mongoose.Types.ObjectId(matchId), matchId: new mongoose.Types.ObjectId(matchId),
assignedPosition: payload?.assignedPosition, assignedPosition: payload?.assignedPosition,
...this.toSocketAuctionActionRequest(payload),
}); });
this.broadcastState(matchId, auction); this.broadcastState(matchId, auction);
ack?.({
auctionActionRequestId: payload?.auctionActionRequestId,
ok: true,
});
} catch (error) { } catch (error) {
this.emitKnownError(socket, error); this.emitKnownError(socket, error);
ack?.({
...(await this.resolveRejectionAckFields(matchId, error)),
auctionActionRequestId: payload?.auctionActionRequestId,
rejected: true,
});
} }
} }
@SubscribeMessage('next') @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); const matchId = this.requireJoinedMatchId(socket);
if (!matchId) return; if (!matchId) return;
try { try {
const auction = await this.auctionService.next( const auction = await this.auctionService.next(
new mongoose.Types.ObjectId(matchId), new mongoose.Types.ObjectId(matchId),
this.toSocketAuctionActionRequest(payload),
); );
this.broadcastState(matchId, auction); this.broadcastState(matchId, auction);
ack?.({
auctionActionRequestId: payload?.auctionActionRequestId,
ok: true,
});
} catch (error) { } catch (error) {
this.emitKnownError(socket, 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; 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 { private getSocketMatchId(socket: Socket): string | undefined {
return typeof socket.data.matchId === 'string' return typeof socket.data.matchId === 'string'
? socket.data.matchId ? socket.data.matchId
: undefined; : undefined;
} }
private resolveBidderUserId( private toAuctionActionRequest(payload?: AuctionActionPayload) {
socket: Socket, return {
payloadBidderUserId?: string, auctionActionRequestId: payload?.auctionActionRequestId,
): mongoose.Types.ObjectId | undefined { clientObservedAuctionLifecycleId:
const candidate = payload?.clientObservedAuctionLifecycleId,
payloadBidderUserId ?? clientObservedCurrentAuctionPlayerOrderIndex:
(socket.data.user as UserDocument | undefined)?._id.toString() ?? payload?.clientObservedCurrentAuctionPlayerOrderIndex,
this.readHandshakeUserId(socket); clientObservedCurrentBidRoundPlayerUserId:
if (!candidate || !mongoose.isValidObjectId(candidate)) { payload?.clientObservedCurrentBidRoundPlayerUserId,
return undefined; clientObservedPhase: payload?.clientObservedPhase,
} clientObservedRevision: payload?.clientObservedRevision,
return new mongoose.Types.ObjectId(candidate); };
}
private toSocketAuctionActionRequest(payload?: AuctionActionPayload) {
return {
...this.toAuctionActionRequest(payload),
shouldBroadcastStateAfterDurability: false,
};
} }
private readHandshakeUserId(socket: Socket): string | undefined { private readHandshakeUserId(socket: Socket): string | undefined {
@@ -359,16 +576,25 @@ export class AuctionGateway
return typeof value === 'string' && value.length > 0 ? value : undefined; return typeof value === 'string' && value.length > 0 ? value : undefined;
} }
public broadcastState(matchId: string, auction: AuctionDocument) { public broadcastState(matchId: string, auction: AuctionStateResponse) {
this.server.to(matchId).emit('state', this.serializeAuction(auction)); this.server.to(matchId).emit('state', serializeRealtimeAuction(auction));
this.syncRoomTimer(matchId, auction); }
public broadcastBid(matchId: string, delta: Record<string, unknown>) {
this.server.to(matchId).emit('bid', delta);
} }
public broadcastReset(matchId: string) { public broadcastReset(matchId: string) {
this.clearRoomTimer(matchId);
this.server.to(matchId).emit('reset', { 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) { private emitChatHistory(socket: Socket, auction: AuctionDocument) {
socket.emit('chat-history', { socket.emit('chat-history', {
messages: (auction.chatMessages ?? []).map((message) => 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) { private emitKnownError(socket: Socket, error: unknown) {
const message = this.emitError(socket, this.resolveErrorPayload(error).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 });
} }
private emitError(socket: Socket, message: string) { private emitError(socket: Socket, message: string) {
socket.emit('error', { message }); socket.emit('error', { message });
} }
private serializeAuction(auction: AuctionDocument) { private serializeAuction(auction: AuctionStateResponse) {
return JSON.parse(JSON.stringify(auction)); 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) { private serializeChatMessage(message: AuctionChatMessage) {
return JSON.parse(JSON.stringify(message)); 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 { TournamentResultModule } from '../tournament-result/tournament-result.module';
import { AuctionGateway } from './auction.gateway'; import { AuctionGateway } from './auction.gateway';
import { AuctionController } from './auction.controller'; 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'; import { AuctionService } from './auction.service';
@Module({ @Module({
imports: [RiotModule, TournamentCodeModule, TournamentResultModule], imports: [
RiotModule,
TournamentCodeModule,
TournamentResultModule,
AuctionRedisModule,
],
controllers: [AuctionController], controllers: [AuctionController],
providers: [AuctionService, AuctionGateway], providers: [
AuctionService,
AuctionGateway,
AuctionEventBusService,
AuctionDeadlineScheduler,
AuctionDurabilityScheduler,
AuctionSideEffectService,
],
exports: [AuctionService], exports: [AuctionService],
}) })
export class AuctionModule {} 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, IsInt,
IsMongoId, IsMongoId,
IsOptional, IsOptional,
IsString,
IsUUID,
Max, Max,
Min, Min,
ValidateNested, ValidateNested,
@@ -28,10 +30,13 @@ class CaptainAssignmentDto {
@IsInt() @IsInt()
@Min(100) @Min(100)
@Max(100000) @Max(100000)
initialPoints?: number; initialTeamBidPointAmount?: number;
} }
export class StartAuctionDto { export class StartAuctionDto {
@IsUUID()
startAuctionRequestId!: string;
@IsArray() @IsArray()
@ArrayMinSize(2) @ArrayMinSize(2)
@ArrayMaxSize(16) @ArrayMaxSize(16)
@@ -43,50 +48,92 @@ export class StartAuctionDto {
@IsInt() @IsInt()
@Min(100) @Min(100)
@Max(100000) @Max(100000)
initialPoints?: number; initialTeamBidPointAmount?: number;
@IsOptional() @IsOptional()
@IsEnum(AUCTION_TOP_TIER_THRESHOLDS) @IsEnum(AUCTION_TOP_TIER_THRESHOLDS)
topTierThreshold?: AuctionTopTierThreshold; topTierAuctionPriorityThreshold?: AuctionTopTierThreshold;
@IsOptional() @IsOptional()
@IsArray() @IsArray()
@ArrayMaxSize(100) @ArrayMaxSize(100)
@IsMongoId({ each: true }) @IsMongoId({ each: true })
manualTopTierUserIds?: string[]; manualTopTierAuctionPriorityUserIds?: string[];
@IsOptional() @IsOptional()
@IsInt() @IsInt()
@Min(5) @Min(5)
maxTimerSeconds?: number; maximumBidRoundDurationSeconds?: number;
@IsOptional() @IsOptional()
@IsInt() @IsInt()
@Min(0) @Min(0)
bidExtensionSeconds?: number; bidRoundExtensionSeconds?: number;
} }
export class PlaceBidDto { export class PlaceBidDto {
@IsInt() @IsOptional()
@Min(1) @IsUUID()
teamIndex!: number; bidRequestId?: string;
@IsInt() @IsInt()
@Min(1) @Min(1)
amount!: number; bidderTeamIndex!: number;
@IsInt()
@Min(1)
bidPointAmount!: number;
@IsOptional() @IsOptional()
@IsMongoId() clientObservedAuctionLifecycleId?: string;
bidderUserId?: 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() @IsOptional()
@IsEnum(['TOP', 'JGL', 'MID', 'ADC', 'SUP']) @IsEnum(['TOP', 'JGL', 'MID', 'ADC', 'SUP'])
assignedPosition?: '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() @IsInt()
@Min(1) @Min(1)
sequence!: number; 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 { 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_TTL_SECONDS = 5 * 60;
const COMMUNITY_STATS_DETAIL_TTL_SECONDS = 24 * 60 * 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 { export class CommunityStatsCacheService {
private readonly logger = new Logger(CommunityStatsCacheService.name); 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> { public get<T>(key: string): Promise<T | null> {
return this.garnetService.getJson<T>(key); return this.redisService.getJson<T>(key);
} }
public set( public set(
@@ -19,7 +19,7 @@ export class CommunityStatsCacheService {
value: unknown, value: unknown,
ttlSeconds = COMMUNITY_STATS_TTL_SECONDS, ttlSeconds = COMMUNITY_STATS_TTL_SECONDS,
): Promise<void> { ): Promise<void> {
return this.garnetService.setJson(key, value, ttlSeconds); return this.redisService.setJson(key, value, ttlSeconds);
} }
public setDetail(key: string, value: unknown): Promise<void> { public setDetail(key: string, value: unknown): Promise<void> {
@@ -29,7 +29,7 @@ export class CommunityStatsCacheService {
public async invalidateCommunity(communityId: string): Promise<number> { public async invalidateCommunity(communityId: string): Promise<number> {
const prefix = `riot:communitystats:`; const prefix = `riot:communitystats:`;
const match = `${prefix}*${communityId}*`; const match = `${prefix}*${communityId}*`;
const client = this.garnetService.raw(); const client = this.redisService.raw();
let cursor = '0'; let cursor = '0';
let deleted = 0; let deleted = 0;
@@ -1,4 +1,5 @@
import { Module } from '@nestjs/common'; import { Module } from '@nestjs/common';
import { RiotModule } from '../riot/riot.module';
import { CommunityStatsCacheService } from './community-stats-cache.service'; import { CommunityStatsCacheService } from './community-stats-cache.service';
import { CommunityStatsController } from './community-stats.controller'; import { CommunityStatsController } from './community-stats.controller';
import { CommunityStatsService } from './community-stats.service'; import { CommunityStatsService } from './community-stats.service';
@@ -7,6 +8,7 @@ import { MatchStatsRepository } from './match-stats.repository';
import { MatchStatsService } from './match-stats.service'; import { MatchStatsService } from './match-stats.service';
@Module({ @Module({
imports: [RiotModule],
controllers: [CommunityStatsController], controllers: [CommunityStatsController],
providers: [ providers: [
CommunityStatsService, CommunityStatsService,
@@ -0,0 +1,194 @@
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,
);
});
});
@@ -36,6 +36,7 @@ const DEFAULT_LIST_LIMIT = 20;
const MAX_LIST_LIMIT = 50; const MAX_LIST_LIMIT = 50;
const MAX_MATCH_SCAN = 300; const MAX_MATCH_SCAN = 300;
const MIN_HIGHLIGHT_GAMES = 5; const MIN_HIGHLIGHT_GAMES = 5;
const MATCH_DETAIL_RESPONSE_CACHE_VERSION = 3;
interface CommunityStatsContext { interface CommunityStatsContext {
community: CommunityDocument; community: CommunityDocument;
@@ -205,10 +206,10 @@ export class CommunityStatsService {
communityId: mongoose.Types.ObjectId; communityId: mongoose.Types.ObjectId;
matchId: mongoose.Types.ObjectId; matchId: mongoose.Types.ObjectId;
}): Promise<InternalMatchDetailResponse> { }): 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 = const cached =
await this.cacheService.get<InternalMatchDetailResponse>(key); await this.cacheService.get<InternalMatchDetailResponse>(key);
if (cached) return cached; if (cached && isCompleteMatchDetailResponse(cached)) return cached;
const dataset = await this.buildBaseDataset(params.communityId, { const dataset = await this.buildBaseDataset(params.communityId, {
seasonId: 'all', seasonId: 'all',
@@ -217,26 +218,42 @@ export class CommunityStatsService {
(item) => item.matchId === params.matchId.toString(), (item) => item.matchId === params.matchId.toString(),
); );
if (!match) throw new NotFoundException('Internal match not found.'); 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 = { const response: InternalMatchDetailResponse = {
match, match,
games: (dataset.detailsByMatchId.get(match.matchId) ?? []).map( games: gameDetails.map(
(game) => ({ (game) => ({
gameNumber: game.gameNumber, gameNumber: game.gameNumber,
riotMatchId: game.riotMatchId, riotMatchId: game.riotMatchId,
gameCreation: game.gameCreation, gameCreation: game.gameCreation,
gameDuration: game.gameDuration, gameDuration: game.gameDuration,
gameVersion: game.gameVersion,
timeline: game.timeline ?? [],
objectiveEvents: game.objectiveEvents ?? [],
teams: game.teams.map((team) => ({ teams: game.teams.map((team) => ({
teamIndex: team.teamIndex, teamIndex: team.teamIndex,
side: team.side, side: team.side,
win: team.win, win: team.win,
objectives: team.objectives, objectives: team.objectives,
bans: team.bans ?? [],
participants: team.participants.map((record) => ({ participants: team.participants.map((record) => ({
userId: record.userId, userId: record.userId,
summonerName: record.summonerName, summonerName: record.summonerName,
tagLine: record.tagLine,
teamIndex: record.teamIndex, teamIndex: record.teamIndex,
side: record.side, side: record.side,
teamPosition: record.teamPosition, teamPosition: record.teamPosition,
championId: record.championId, championId: record.championId,
championLevel: record.championLevel,
kills: record.kills, kills: record.kills,
deaths: record.deaths, deaths: record.deaths,
assists: record.assists, assists: record.assists,
@@ -245,13 +262,21 @@ export class CommunityStatsService {
gold: record.gold, gold: record.gold,
gpm: record.gpm, gpm: record.gpm,
damageDealtToChampions: record.damageDealtToChampions, damageDealtToChampions: record.damageDealtToChampions,
damageTaken: record.damageTaken,
damageShare: record.damageShare, damageShare: record.damageShare,
killParticipation: record.killParticipation, killParticipation: record.killParticipation,
visionScore: record.visionScore, visionScore: record.visionScore,
wardsPlaced: record.wardsPlaced,
wardsKilled: record.wardsKilled,
controlWardsBought: record.controlWardsBought,
firstBloodKill: record.firstBloodKill ?? false,
firstBloodAssist: record.firstBloodAssist ?? false,
items: record.items, items: record.items,
trinket: record.trinket, trinket: record.trinket,
summonerSpells: record.summonerSpells, summonerSpells: record.summonerSpells,
perks: record.perks, perks: record.perks,
itemBuild: record.itemBuild ?? [],
skillBuild: record.skillBuild ?? [],
win: record.win, win: record.win,
})), })),
})), })),
@@ -990,3 +1015,23 @@ export class CommunityStatsService {
return Math.round(value * 10) / 10; 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'; import type { RecentMatchView, HistorySeasonDto } from '../match-history/match-history.types';
export interface CommunityStatsFilters { export interface CommunityStatsFilters {
@@ -108,18 +114,43 @@ export interface InternalMatchDetailResponse {
riotMatchId: string; riotMatchId: string;
gameCreation: number; gameCreation: number;
gameDuration: 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<{ teams: Array<{
teamIndex: number; teamIndex: number;
side: TeamSide; side: TeamSide;
win: boolean; 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<{ participants: Array<{
userId: string | null; userId: string | null;
summonerName: string; summonerName: string;
tagLine: string;
teamIndex: number; teamIndex: number;
side: TeamSide; side: TeamSide;
teamPosition: string; teamPosition: string;
championId: number; championId: number;
championLevel: number;
kills: number; kills: number;
deaths: number; deaths: number;
assists: number; assists: number;
@@ -128,13 +159,21 @@ export interface InternalMatchDetailResponse {
gold: number; gold: number;
gpm: number; gpm: number;
damageDealtToChampions: number; damageDealtToChampions: number;
damageTaken: number;
damageShare: number; damageShare: number;
killParticipation: number; killParticipation: number;
visionScore: number; visionScore: number;
wardsPlaced: number;
wardsKilled: number;
controlWardsBought: number;
firstBloodKill: boolean;
firstBloodAssist: boolean;
items: number[]; items: number[];
trinket: number; trinket: number;
summonerSpells: [number, number]; summonerSpells: [number, number];
perks: { primaryStyle?: number; subStyle?: number; keystone?: number }; perks: MatchStatsRunePerks;
itemBuild: MatchStatsItemBuildEvent[];
skillBuild: MatchStatsSkillBuildEvent[];
win: boolean; win: boolean;
}>; }>;
}>; }>;
@@ -1,5 +1,6 @@
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import type { MatchDocument } from '../global/database/schema'; import type { MatchDocument } from '../global/database/schema';
import type { RiotMatchDto, RiotMatchTimelineDto } from '../riot/riot.types';
import { MatchStatsFragmentBuilder } from './match-stats-fragment.builder'; import { MatchStatsFragmentBuilder } from './match-stats-fragment.builder';
function makeMatch(): MatchDocument { function makeMatch(): MatchDocument {
@@ -95,4 +96,301 @@ describe('MatchStatsFragmentBuilder', () => {
}); });
expect(fragment.gameDetails[0].teams[0].participants).toHaveLength(1); 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 { import type {
MatchDocument, MatchDocument,
MatchGameResultParticipant, MatchGameResultParticipant,
MatchStatsItemBuildEvent,
MatchStatsObjectiveEvent,
MatchStatsObjectiveSummary,
MatchStatsSkillBuildEvent,
MatchStatsTimelinePoint,
TeamSide, TeamSide,
} from '../global/database/schema'; } 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 { InternalMatchCardView } from './community-stats.types';
import type { import type {
InternalGameDetail, InternalGameDetail,
@@ -13,11 +22,18 @@ import type {
MatchStatsFragment, MatchStatsFragment,
} from './match-stats.types'; } from './match-stats.types';
interface ParticipantBuildEvents {
items: MatchStatsItemBuildEvent[];
skills: MatchStatsSkillBuildEvent[];
}
@Injectable() @Injectable()
export class MatchStatsFragmentBuilder { export class MatchStatsFragmentBuilder {
public buildFragment(params: { public buildFragment(params: {
match: MatchDocument; match: MatchDocument;
rawByRiotMatchId: Map<string, RiotMatchDto>; rawByRiotMatchId: Map<string, RiotMatchDto>;
timelineByRiotMatchId?: Map<string, RiotMatchTimelineDto>;
timelineLoadAttempted?: boolean;
}): MatchStatsFragment { }): MatchStatsFragment {
const games = [...(params.match.result?.games ?? [])].sort( const games = [...(params.match.result?.games ?? [])].sort(
(left, right) => left.gameNumber - right.gameNumber, (left, right) => left.gameNumber - right.gameNumber,
@@ -25,8 +41,15 @@ export class MatchStatsFragmentBuilder {
const matchCard = this.toMatchCard(params.match, games); const matchCard = this.toMatchCard(params.match, games);
const gameDetails = games.map((game) => { const gameDetails = games.map((game) => {
const raw = params.rawByRiotMatchId.get(game.riotMatchId); const raw = params.rawByRiotMatchId.get(game.riotMatchId);
const timeline = params.timelineByRiotMatchId?.get(game.riotMatchId);
return raw return raw
? this.toGameDetail(params.match, game, raw) ? this.toGameDetail(
params.match,
game,
raw,
timeline,
params.timelineLoadAttempted === true,
)
: this.toFallbackGameDetail(params.match, game); : this.toFallbackGameDetail(params.match, game);
}); });
const records = gameDetails.flatMap((detail) => const records = gameDetails.flatMap((detail) =>
@@ -106,6 +129,8 @@ export class MatchStatsFragmentBuilder {
match: MatchDocument, match: MatchDocument,
game: NonNullable<MatchDocument['result']>['games'][number], game: NonNullable<MatchDocument['result']>['games'][number],
raw: RiotMatchDto, raw: RiotMatchDto,
timeline?: RiotMatchTimelineDto,
timelineLoadAttempted = false,
): InternalGameDetail { ): InternalGameDetail {
const puuidByUserId = new Map( const puuidByUserId = new Map(
match.participants match.participants
@@ -129,13 +154,29 @@ export class MatchStatsFragmentBuilder {
rawTeamIdBySide.set(participant.side, rawParticipant.teamId); 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 { return {
gameNumber: game.gameNumber, gameNumber: game.gameNumber,
riotMatchId: game.riotMatchId, riotMatchId: game.riotMatchId,
gameCreation: game.gameCreation, gameCreation: game.gameCreation,
gameDuration: game.gameDuration, gameDuration: game.gameDuration,
gameVersion: raw.info.gameVersion,
winnerSide: game.winnerSide, winnerSide: game.winnerSide,
timeline: this.toTimeline(raw, rawTeamIdBySide, timeline),
timelineLoaded: timelineLoadAttempted || Boolean(timeline),
objectiveEvents,
teams: (['blue', 'red'] as TeamSide[]).map((side) => { teams: (['blue', 'red'] as TeamSide[]).map((side) => {
const teamIndex = const teamIndex =
side === 'blue' ? game.blueTeamIndex : game.redTeamIndex; side === 'blue' ? game.blueTeamIndex : game.redTeamIndex;
@@ -158,25 +199,35 @@ export class MatchStatsFragmentBuilder {
teamIndex, teamIndex,
side, side,
win: game.winnerSide === side, win: game.winnerSide === side,
objectives: { objectives: this.toObjectiveSummary(
baron: rawTeam?.objectives?.baron?.kills ?? 0, rawTeam,
dragon: rawTeam?.objectives?.dragon?.kills ?? 0, timelineObjectives.get(side),
tower: rawTeam?.objectives?.tower?.kills ?? 0, Boolean(timeline),
}, ),
bans: (rawTeam?.bans ?? []).map((ban) => ({
championId: ban.championId,
pickTurn: ban.pickTurn,
})),
participants: game.participants participants: game.participants
.filter((participant) => participant.side === side) .filter((participant) => participant.side === side)
.map((participant) => .map((participant) => {
this.toRecord({ const rawParticipant = rawByPuuid.get(
puuidByUserId.get(participant.userId.toString()) ?? '',
);
return this.toRecord({
match, match,
game, game,
participant, participant,
rawParticipant: rawByPuuid.get( rawParticipant,
puuidByUserId.get(participant.userId.toString()) ?? '', buildEvents: rawParticipant
), ? buildEventsByParticipantId.get(
rawParticipant.participantId,
)
: undefined,
teamKills, teamKills,
teamDamage, teamDamage,
}), });
), }),
}; };
}), }),
}; };
@@ -192,11 +243,15 @@ export class MatchStatsFragmentBuilder {
gameCreation: game.gameCreation, gameCreation: game.gameCreation,
gameDuration: game.gameDuration, gameDuration: game.gameDuration,
winnerSide: game.winnerSide, winnerSide: game.winnerSide,
timeline: [],
timelineLoaded: false,
objectiveEvents: [],
teams: (['blue', 'red'] as TeamSide[]).map((side) => ({ teams: (['blue', 'red'] as TeamSide[]).map((side) => ({
teamIndex: side === 'blue' ? game.blueTeamIndex : game.redTeamIndex, teamIndex: side === 'blue' ? game.blueTeamIndex : game.redTeamIndex,
side, side,
win: game.winnerSide === side, win: game.winnerSide === side,
objectives: { baron: 0, dragon: 0, tower: 0 }, objectives: emptyObjectives(),
bans: [],
participants: game.participants participants: game.participants
.filter((participant) => participant.side === side) .filter((participant) => participant.side === side)
.map((participant) => .map((participant) =>
@@ -217,11 +272,19 @@ export class MatchStatsFragmentBuilder {
game: NonNullable<MatchDocument['result']>['games'][number]; game: NonNullable<MatchDocument['result']>['games'][number];
participant: MatchGameResultParticipant; participant: MatchGameResultParticipant;
rawParticipant?: RiotMatchParticipantDto; rawParticipant?: RiotMatchParticipantDto;
buildEvents?: ParticipantBuildEvents;
teamKills: number; teamKills: number;
teamDamage: number; teamDamage: number;
}): InternalRecord { }): InternalRecord {
const { match, game, participant, rawParticipant, teamKills, teamDamage } = const {
params; match,
game,
participant,
rawParticipant,
buildEvents,
teamKills,
teamDamage,
} = params;
const snapshot = match.participants.find((item) => const snapshot = match.participants.find((item) =>
item.userId.equals(participant.userId), item.userId.equals(participant.userId),
); );
@@ -262,6 +325,7 @@ export class MatchStatsFragmentBuilder {
rawParticipant?.riotIdGameName ?? rawParticipant?.riotIdGameName ??
rawParticipant?.summonerName ?? rawParticipant?.summonerName ??
'Unknown', 'Unknown',
tagLine: snapshot?.tagLine ?? rawParticipant?.riotIdTagLine ?? '',
profileIconId: snapshot?.profileIconId ?? 0, profileIconId: snapshot?.profileIconId ?? 0,
teamIndex: participant.teamIndex, teamIndex: participant.teamIndex,
side: participant.side, side: participant.side,
@@ -290,6 +354,8 @@ export class MatchStatsFragmentBuilder {
), ),
wardsPlaced: rawParticipant?.wardsPlaced ?? 0, wardsPlaced: rawParticipant?.wardsPlaced ?? 0,
wardsKilled: rawParticipant?.wardsKilled ?? 0, wardsKilled: rawParticipant?.wardsKilled ?? 0,
firstBloodKill: booleanField(rawParticipant, 'firstBloodKill'),
firstBloodAssist: booleanField(rawParticipant, 'firstBloodAssist'),
items: [ items: [
rawParticipant?.item0 ?? 0, rawParticipant?.item0 ?? 0,
rawParticipant?.item1 ?? 0, rawParticipant?.item1 ?? 0,
@@ -304,6 +370,8 @@ export class MatchStatsFragmentBuilder {
rawParticipant?.summoner2Id ?? 0, rawParticipant?.summoner2Id ?? 0,
], ],
perks: rawParticipant ? this.resolvePerks(rawParticipant) : {}, perks: rawParticipant ? this.resolvePerks(rawParticipant) : {},
itemBuild: buildEvents?.items ?? [],
skillBuild: buildEvents?.skills ?? [],
rating, rating,
}; };
} }
@@ -319,6 +387,250 @@ export class MatchStatsFragmentBuilder {
primaryStyle: primary?.style, primaryStyle: primary?.style,
subStyle: sub?.style, subStyle: sub?.style,
keystone: primary?.selections[0]?.perk, 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; 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 { function round(value: number): number {
return Math.round(value * 10) / 10; return Math.round(value * 10) / 10;
} }
@@ -365,3 +698,22 @@ function numberField(
const value = participant?.[key]; const value = participant?.[key];
return typeof value === 'number' && Number.isFinite(value) ? value : 0; 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, connectionService,
repository, repository,
{} as MatchStatsFragmentBuilder, {} as MatchStatsFragmentBuilder,
{ getMatchTimeline: jest.fn() } as never,
); );
await service.buildAndUpsert(matchId); await service.buildAndUpsert(matchId);
@@ -53,7 +54,20 @@ describe('MatchStatsService', () => {
}); });
const riotFind = jest.fn().mockReturnValue({ const riotFind = jest.fn().mockReturnValue({
lean: () => ({ 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 = { const connectionService = {
@@ -82,6 +96,7 @@ describe('MatchStatsService', () => {
connectionService, connectionService,
repository, repository,
builder, builder,
{ getMatchTimeline: jest.fn() } as never,
); );
await service.buildAndUpsert(matchId); await service.buildAndUpsert(matchId);
@@ -89,6 +104,8 @@ describe('MatchStatsService', () => {
expect(builder.buildFragment).toHaveBeenCalledWith({ expect(builder.buildFragment).toHaveBeenCalledWith({
match, match,
rawByRiotMatchId: expect.any(Map), rawByRiotMatchId: expect.any(Map),
timelineByRiotMatchId: expect.any(Map),
timelineLoadAttempted: false,
}); });
expect(repository.upsert).toHaveBeenCalledWith( expect(repository.upsert).toHaveBeenCalledWith(
expect.objectContaining({ expect.objectContaining({
@@ -97,7 +114,7 @@ describe('MatchStatsService', () => {
scheduledAt, scheduledAt,
gameCreationMin: 1_000, gameCreationMin: 1_000,
gameCreationMax: 2_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 mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service'; import { ConnectionService } from '../global/database/connection.service';
import type { MatchDocument } from '../global/database/schema'; 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 { MatchStatsFragmentBuilder } from './match-stats-fragment.builder';
import { MatchStatsRepository } from './match-stats.repository'; import { MatchStatsRepository } from './match-stats.repository';
import { MATCH_STATS_BUILDER_VERSION } from './match-stats.types'; import { MATCH_STATS_BUILDER_VERSION } from './match-stats.types';
@Injectable() @Injectable()
export class MatchStatsService { export class MatchStatsService {
private readonly logger = new Logger(MatchStatsService.name);
constructor( constructor(
private readonly connectionService: ConnectionService, private readonly connectionService: ConnectionService,
private readonly repository: MatchStatsRepository, private readonly repository: MatchStatsRepository,
private readonly builder: MatchStatsFragmentBuilder, 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 MatchModel = await this.connectionService.getModel('match');
const RiotMatchModel = await this.connectionService.getModel('riotMatch'); const RiotMatchModel = await this.connectionService.getModel('riotMatch');
const match = await MatchModel.findById(matchId).exec(); const match = await MatchModel.findById(matchId).exec();
@@ -41,7 +53,51 @@ export class MatchStatsService {
const rawByRiotMatchId = new Map( const rawByRiotMatchId = new Map(
riotDocs.map((doc) => [doc.matchId, doc.raw as unknown as RiotMatchDto]), 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({ await this.repository.upsert({
matchId: match._id, matchId: match._id,
@@ -101,4 +157,29 @@ export class MatchStatsService {
Boolean(match.result?.games?.length) 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'; } from '../global/database/schema';
import type { InternalMatchCardView } from './community-stats.types'; 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 InternalRecord = MatchStatsRecord;
export type InternalGameDetail = MatchStatsGameDetail; 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() { 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; ] as const;
export type AuctionTopTierThreshold = export type AuctionTopTierThreshold =
(typeof AUCTION_TOP_TIER_THRESHOLDS)[number]; (typeof AUCTION_TOP_TIER_THRESHOLDS)[number];
export type AuctionActionType = export const AUCTION_ACTION_TYPES = [
| 'start' 'start',
| 'open-bidding' 'open-bidding',
| 'bid' 'bid',
| 'sold' 'sold',
| 'passed' 'passed',
| 'next' 'next',
| 'complete'; '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 { export interface MongooseTimestamps {
createdAt: Date; createdAt: Date;
@@ -398,6 +426,8 @@ export interface RiotMatch extends MongooseTimestamps {
queueId?: number; queueId?: number;
participantPuuids: string[]; participantPuuids: string[];
raw: Record<string, unknown>; // Riot API Match-V5 원본 응답 전체 raw: Record<string, unknown>; // Riot API Match-V5 원본 응답 전체
timeline?: Record<string, unknown>; // Riot API Match-V5 timeline 원본 응답 전체
timelineFetchedAt?: Date;
fetchedAt: Date; fetchedAt: Date;
} }
@@ -487,6 +517,7 @@ export interface MatchSeriesResult {
export interface MatchGameAssignment { export interface MatchGameAssignment {
gameNumber: number; gameNumber: number;
roundNumber?: number;
teamAIndex: number; teamAIndex: number;
teamBIndex: number; teamBIndex: number;
} }
@@ -524,6 +555,7 @@ export interface Match extends MongooseTimestamps {
maxParticipants: number; maxParticipants: number;
gameCount: number; gameCount: number;
gameMode: MatchGameMode; gameMode: MatchGameMode;
roundRobinMaxRounds?: number;
tournamentCodeIds: mongoose.Types.ObjectId[]; tournamentCodeIds: mongoose.Types.ObjectId[];
gameSchedule: MatchGameAssignment[]; gameSchedule: MatchGameAssignment[];
teamBuiltAt?: Date; teamBuiltAt?: Date;
@@ -612,6 +644,20 @@ export interface AuctionTeam {
members: AuctionTeamMember[]; 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 { export interface AuctionBid {
teamIndex: number; teamIndex: number;
amount: number; amount: number;
@@ -619,6 +665,13 @@ export interface AuctionBid {
timestamp: Date; timestamp: Date;
} }
export interface AuctionBidHistoryEntry {
bidderTeamIndex: number;
bidPointAmount: number;
bidderUserId: mongoose.Types.ObjectId;
bidPlacedAtTimestampMS: number;
}
export interface AuctionChatMessage { export interface AuctionChatMessage {
id: string; id: string;
userId?: mongoose.Types.ObjectId; userId?: mongoose.Types.ObjectId;
@@ -630,6 +683,17 @@ export interface AuctionChatMessage {
export interface Auction extends MongooseTimestamps { export interface Auction extends MongooseTimestamps {
matchId: mongoose.Types.ObjectId; matchId: mongoose.Types.ObjectId;
phase: AuctionPhase; 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[]; teams: AuctionTeam[];
order: AuctionPlayerSnapshot[]; order: AuctionPlayerSnapshot[];
passedQueue: AuctionPlayerSnapshot[]; passedQueue: AuctionPlayerSnapshot[];
@@ -647,6 +711,22 @@ export interface Auction extends MongooseTimestamps {
chatMessages: AuctionChatMessage[]; chatMessages: AuctionChatMessage[];
startedAt?: Date; startedAt?: Date;
completedAt?: 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>; export type AuctionDocument = HydratedDocument<Auction>;
@@ -656,14 +736,72 @@ export interface AuctionHistoryEntry extends MongooseTimestamps {
matchId: mongoose.Types.ObjectId; matchId: mongoose.Types.ObjectId;
sequence: number; sequence: number;
action: AuctionActionType; action: AuctionActionType;
auctionStateTransitionId?: string;
auctionLifecycleId?: string;
revision?: number;
actorUserId?: mongoose.Types.ObjectId; actorUserId?: mongoose.Types.ObjectId;
snapshotBefore: Record<string, unknown>; snapshotBefore: Record<string, unknown>;
historyMutation?: AuctionHistoryMutation;
matchSideEffectMutation?: Record<string, unknown>;
takenAt: Date; takenAt: Date;
} }
export type AuctionHistoryEntryDocument = HydratedDocument<AuctionHistoryEntry>; 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) ===== // ===== 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 { export interface MatchStatsRecord {
matchId: string; matchId: string;
title: string; title: string;
@@ -674,6 +812,7 @@ export interface MatchStatsRecord {
gameDuration: number; gameDuration: number;
userId: string; userId: string;
summonerName: string; summonerName: string;
tagLine: string;
profileIconId: number; profileIconId: number;
teamIndex: number; teamIndex: number;
side: TeamSide; side: TeamSide;
@@ -696,10 +835,14 @@ export interface MatchStatsRecord {
controlWardsBought: number; controlWardsBought: number;
wardsPlaced: number; wardsPlaced: number;
wardsKilled: number; wardsKilled: number;
firstBloodKill: boolean;
firstBloodAssist: boolean;
items: number[]; items: number[];
trinket: number; trinket: number;
summonerSpells: [number, number]; summonerSpells: [number, number];
perks: { primaryStyle?: number; subStyle?: number; keystone?: number }; perks: MatchStatsRunePerks;
itemBuild: MatchStatsItemBuildEvent[];
skillBuild: MatchStatsSkillBuildEvent[];
rating: number; rating: number;
} }
@@ -708,16 +851,46 @@ export interface MatchStatsGameDetail {
riotMatchId: string; riotMatchId: string;
gameCreation: number; gameCreation: number;
gameDuration: number; gameDuration: number;
gameVersion?: string;
winnerSide: TeamSide; winnerSide: TeamSide;
timeline: MatchStatsTimelinePoint[];
timelineLoaded?: boolean;
objectiveEvents: MatchStatsObjectiveEvent[];
teams: Array<{ teams: Array<{
teamIndex: number; teamIndex: number;
side: TeamSide; side: TeamSide;
win: boolean; win: boolean;
objectives: { baron: number; dragon: number; tower: number }; objectives: MatchStatsObjectiveSummary;
bans: Array<{ championId: number; pickTurn: number }>;
participants: MatchStatsRecord[]; 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 { export interface MatchStats extends MongooseTimestamps {
matchId: mongoose.Types.ObjectId; matchId: mongoose.Types.ObjectId;
communityId: mongoose.Types.ObjectId; communityId: mongoose.Types.ObjectId;
@@ -1133,6 +1306,8 @@ export const RiotMatchSchema = new Schema<RiotMatch>(
queueId: { type: Number }, queueId: { type: Number },
participantPuuids: { type: [String], required: true, default: [] }, participantPuuids: { type: [String], required: true, default: [] },
raw: { type: Schema.Types.Mixed, 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 }, fetchedAt: { type: Date, required: true, default: Date.now },
}, },
{ {
@@ -1151,7 +1326,6 @@ export const TournamentCodeSchema = new Schema<TournamentCode>(
type: String, type: String,
required: true, required: true,
trim: true, trim: true,
uppercase: true,
}, },
region: { type: String, required: true, default: 'kr' }, region: { type: String, required: true, default: 'kr' },
mapType: { mapType: {
@@ -1284,6 +1458,7 @@ const MatchSeriesResultSubSchema = new Schema<MatchSeriesResult>(
const MatchGameAssignmentSubSchema = new Schema<MatchGameAssignment>( const MatchGameAssignmentSubSchema = new Schema<MatchGameAssignment>(
{ {
gameNumber: { type: Number, required: true, min: 1 }, gameNumber: { type: Number, required: true, min: 1 },
roundNumber: { type: Number, required: false, min: 1 },
teamAIndex: { type: Number, required: true, min: 1 }, teamAIndex: { type: Number, required: true, min: 1 },
teamBIndex: { 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, required: true,
default: 'pair', default: 'pair',
}, },
roundRobinMaxRounds: { type: Number, required: false, min: 1 },
tournamentCodeIds: { tournamentCodeIds: {
type: [{ type: Schema.Types.ObjectId, ref: 'tournamentCode' }], type: [{ type: Schema.Types.ObjectId, ref: 'tournamentCode' }],
required: true, required: true,
@@ -1571,6 +1747,34 @@ const AuctionTeamSubSchema = new Schema<AuctionTeam>(
{ _id: false }, { _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>( const AuctionBidSubSchema = new Schema<AuctionBid>(
{ {
teamIndex: { type: Number, required: true, min: 1 }, teamIndex: { type: Number, required: true, min: 1 },
@@ -1581,6 +1785,16 @@ const AuctionBidSubSchema = new Schema<AuctionBid>(
{ _id: false }, { _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>( const AuctionChatMessageSubSchema = new Schema<AuctionChatMessage>(
{ {
id: { type: String, required: true }, id: { type: String, required: true },
@@ -1606,6 +1820,40 @@ export const AuctionSchema = new Schema<Auction>(
required: true, required: true,
default: 'waiting', 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: [] }, teams: { type: [AuctionTeamSubSchema], required: true, default: [] },
order: { order: {
type: [AuctionPlayerSnapshotSubSchema], type: [AuctionPlayerSnapshotSubSchema],
@@ -1645,6 +1893,55 @@ export const AuctionSchema = new Schema<Auction>(
}, },
startedAt: { type: Date, required: false }, startedAt: { type: Date, required: false },
completedAt: { 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, timestamps: true,
@@ -1652,7 +1949,7 @@ export const AuctionSchema = new Schema<Auction>(
}, },
); );
const AuctionHistoryEntrySchema = new Schema<AuctionHistoryEntry>( export const AuctionHistoryEntrySchema = new Schema<AuctionHistoryEntry>(
{ {
auctionId: { auctionId: {
type: Schema.Types.ObjectId, type: Schema.Types.ObjectId,
@@ -1669,19 +1966,16 @@ const AuctionHistoryEntrySchema = new Schema<AuctionHistoryEntry>(
sequence: { type: Number, required: true, min: 1 }, sequence: { type: Number, required: true, min: 1 },
action: { action: {
type: String, type: String,
enum: [ enum: AUCTION_ACTION_TYPES,
'start',
'open-bidding',
'bid',
'sold',
'passed',
'next',
'complete',
],
required: true, 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 }, actorUserId: { type: Schema.Types.ObjectId, ref: 'user', required: false },
snapshotBefore: { type: Schema.Types.Mixed, required: true }, 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 }, 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 });
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( export const MatchStatsSchema: mongoose.Schema<MatchStats> = new Schema(
{ {
@@ -1765,6 +2127,11 @@ export const tournamentModelDefinitions: ModelDefinition[] = [
schema: AuctionHistoryEntrySchema, schema: AuctionHistoryEntrySchema,
schemaName: 'auctionHistory', schemaName: 'auctionHistory',
}, },
{
name: 'auctionSideEffectApplication',
schema: AuctionSideEffectApplicationSchema,
schemaName: 'auctionSideEffectApplication',
},
{ {
name: 'matchStats', name: 'matchStats',
schema: MatchStatsSchema, schema: MatchStatsSchema,
@@ -1785,5 +2152,6 @@ export interface TournamentModelTypes {
match: Match; match: Match;
auction: Auction; auction: Auction;
auctionHistory: AuctionHistoryEntry; auctionHistory: AuctionHistoryEntry;
auctionSideEffectApplication: AuctionSideEffectApplication;
matchStats: MatchStats; 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 { SecretModule } from './secret/secret.module';
import { NatsModule } from './nats/nats.module'; import { NatsModule } from './nats/nats.module';
import { DatabaseModule } from './database/database.module'; import { DatabaseModule } from './database/database.module';
import { GarnetModule } from './garnet/garnet.module'; import { RedisModule } from './redis/redis.module';
@Global() @Global()
@Module({ @Module({
imports: [SecretModule, NatsModule, DatabaseModule, GarnetModule], imports: [SecretModule, NatsModule, DatabaseModule, RedisModule],
providers: [], providers: [],
exports: [SecretModule, NatsModule, DatabaseModule, GarnetModule], exports: [SecretModule, NatsModule, DatabaseModule, RedisModule],
}) })
export class GlobalModule {} export class GlobalModule {}
@@ -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 { Inject, Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
import type { createClient } from 'redis'; 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 { export interface StreamEntry {
deliveriesCounter?: number; deliveriesCounter?: number;
@@ -48,12 +48,10 @@ function normalizeStreamFields(fields: unknown): Record<string, string> {
} }
@Injectable() @Injectable()
export class GarnetService implements OnModuleDestroy { export class RedisService implements OnModuleDestroy {
private readonly logger = new Logger(GarnetService.name); private readonly logger = new Logger(RedisService.name);
constructor( constructor(@Inject(REDIS_CLIENT) private readonly client: RedisClient) {}
@Inject(GARNET_CLIENT) private readonly client: GarnetRedisClient,
) {}
async onModuleDestroy() { async onModuleDestroy() {
try { try {
@@ -63,7 +61,7 @@ export class GarnetService implements OnModuleDestroy {
} }
} }
public raw(): GarnetRedisClient { public raw(): RedisClient {
return this.client; return this.client;
} }
@@ -16,7 +16,7 @@ import type {
RiotMatch as StoredRiotMatch, RiotMatch as StoredRiotMatch,
UserDocument, UserDocument,
} from '../global/database/schema'; } 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 { RIOT_JOB_LOW_STREAM } from '../riot-job-queue/riot-job-queue.types';
import { RiotMatchService } from '../riot/riot-match.service'; import { RiotMatchService } from '../riot/riot-match.service';
import type { RiotMatchDto, RiotRegionalRoute } from '../riot/riot.types'; import type { RiotMatchDto, RiotRegionalRoute } from '../riot/riot.types';
@@ -53,7 +53,7 @@ export class LegacyImportService {
constructor( constructor(
private readonly connectionService: ConnectionService, private readonly connectionService: ConnectionService,
private readonly garnetService: GarnetService, private readonly redisService: RedisService,
private readonly riotMatchService: RiotMatchService, private readonly riotMatchService: RiotMatchService,
private readonly communityStatsService: CommunityStatsService, private readonly communityStatsService: CommunityStatsService,
private readonly matchStatsService: MatchStatsService, private readonly matchStatsService: MatchStatsService,
@@ -80,7 +80,7 @@ export class LegacyImportService {
}): Promise<StartLegacyImportResponse> { }): Promise<StartLegacyImportResponse> {
const lockKey = this.communityLockKey(params.communityId); const lockKey = this.communityLockKey(params.communityId);
const jobId = randomUUID(); const jobId = randomUUID();
const acquired = await this.garnetService.setStringIfAbsent( const acquired = await this.redisService.setStringIfAbsent(
lockKey, lockKey,
jobId, jobId,
LEGACY_IMPORT_LOCK_TTL_SECONDS, LEGACY_IMPORT_LOCK_TTL_SECONDS,
@@ -148,7 +148,7 @@ export class LegacyImportService {
triggeredBy: params.triggeredBy.toString(), triggeredBy: params.triggeredBy.toString(),
region: (community.riotRegion ?? 'asia') as RiotRegionalRoute, region: (community.riotRegion ?? 'asia') as RiotRegionalRoute,
}; };
await this.garnetService.appendStream( await this.redisService.appendStream(
RIOT_JOB_LOW_STREAM, RIOT_JOB_LOW_STREAM,
{ job: JSON.stringify(job) }, { job: JSON.stringify(job) },
{ maxLen: 10_000 }, { maxLen: 10_000 },
@@ -160,7 +160,7 @@ export class LegacyImportService {
{ jobId }, { jobId },
{ $set: { state: 'completed', completedAt: new Date() } }, { $set: { state: 'completed', completedAt: new Date() } },
).exec(); ).exec();
await this.garnetService.delete(lockKey); await this.redisService.delete(lockKey);
} }
return { return {
@@ -169,7 +169,7 @@ export class LegacyImportService {
etaSeconds: windows.length * LEGACY_IMPORT_MEMBER_AVG_SECONDS, etaSeconds: windows.length * LEGACY_IMPORT_MEMBER_AVG_SECONDS,
}; };
} catch (error) { } catch (error) {
await this.garnetService.delete(lockKey); await this.redisService.delete(lockKey);
throw error; throw error;
} }
} }
@@ -220,7 +220,7 @@ export class LegacyImportService {
).exec(); ).exec();
if (!job) if (!job)
throw new NotFoundException('Running legacy import job not found.'); 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; return job;
} }
@@ -500,7 +500,7 @@ export class LegacyImportService {
userByPuuid: UserByPuuidMap, userByPuuid: UserByPuuidMap,
): Promise<ImportOutcome> { ): Promise<ImportOutcome> {
const lockKey = `legacy-import:match:${riotMatchId}`; const lockKey = `legacy-import:match:${riotMatchId}`;
const acquired = await this.garnetService.setStringIfAbsent( const acquired = await this.redisService.setStringIfAbsent(
lockKey, lockKey,
job.parentJobId, job.parentJobId,
MATCH_IMPORT_LOCK_TTL_SECONDS, MATCH_IMPORT_LOCK_TTL_SECONDS,
@@ -577,7 +577,7 @@ export class LegacyImportService {
}); });
return 'error'; return 'error';
} finally { } finally {
await this.garnetService.delete(lockKey); await this.redisService.delete(lockKey);
} }
} }
@@ -656,7 +656,7 @@ export class LegacyImportService {
if (completed) { if (completed) {
await Promise.all([ await Promise.all([
this.garnetService.delete( this.redisService.delete(
this.communityLockKey(new mongoose.Types.ObjectId(job.communityId)), this.communityLockKey(new mongoose.Types.ObjectId(job.communityId)),
), ),
this.communityStatsService.invalidateCommunity( this.communityStatsService.invalidateCommunity(
@@ -1,4 +1,4 @@
import type { RiotLane } from '../global/database/schema'; import type { MatchStatsRunePerks, RiotLane } from '../global/database/schema';
import type { import type {
RiotQueueGroup, RiotQueueGroup,
RiotRankFilter, RiotRankFilter,
@@ -121,7 +121,7 @@ export interface RecentMatchTeamParticipantView {
items: number[]; items: number[];
trinket: number; trinket: number;
summonerSpells: [number, number]; summonerSpells: [number, number];
perks: { primaryStyle?: number; subStyle?: number; keystone?: number }; perks: MatchStatsRunePerks;
totalCs: number; totalCs: number;
csPerMin: number; csPerMin: number;
goldEarned: number; goldEarned: number;
@@ -162,7 +162,7 @@ export interface RecentMatchView {
items: number[]; items: number[];
trinket: number; trinket: number;
summonerSpells: [number, number]; summonerSpells: [number, number];
perks: { primaryStyle?: number; subStyle?: number; keystone?: number }; perks: MatchStatsRunePerks;
teams: Array<{ teams: Array<{
side: 100 | 200; side: 100 | 200;
win: boolean; win: boolean;
@@ -101,6 +101,11 @@ export class CreateMatchDto {
@IsEnum(MATCH_GAME_MODES) @IsEnum(MATCH_GAME_MODES)
gameMode?: MatchGameMode; gameMode?: MatchGameMode;
@IsOptional()
@IsInt()
@Min(1)
roundRobinMaxRounds?: number;
@IsOptional() @IsOptional()
@IsArray() @IsArray()
@IsString({ each: true }) @IsString({ each: true })
@@ -156,6 +161,11 @@ export class UpdateMatchDto {
@IsEnum(MATCH_GAME_MODES) @IsEnum(MATCH_GAME_MODES)
gameMode?: MatchGameMode; gameMode?: MatchGameMode;
@IsOptional()
@IsInt()
@Min(1)
roundRobinMaxRounds?: number;
@IsOptional() @IsOptional()
@IsArray() @IsArray()
@IsString({ each: true }) @IsString({ each: true })
@@ -193,3 +203,17 @@ export class JoinMatchDto {
@IsString() @IsString()
userId?: string; 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, UserDocument,
} from '../global/database/schema'; } from '../global/database/schema';
import { import {
AddParticipantDto,
CreateMatchDto, CreateMatchDto,
JoinMatchDto, JoinMatchDto,
UpdateMatchDto, UpdateMatchDto,
@@ -56,6 +57,7 @@ export class MatchController {
maxParticipants: body.maxParticipants ?? 10, maxParticipants: body.maxParticipants ?? 10,
gameCount: body.gameCount, gameCount: body.gameCount,
gameMode: body.gameMode ?? 'pair', gameMode: body.gameMode ?? 'pair',
roundRobinMaxRounds: body.roundRobinMaxRounds,
prizes: body.prizes ?? [], prizes: body.prizes ?? [],
notices: body.notices ?? [], notices: body.notices ?? [],
schedule: body.schedule ?? [], 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') @Patch(':matchId/participants/:userId')
@Roles('admin', 'owner') @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 () => { it('returns a paginated match list with total count', async () => {
const communityId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId();
const { service, MatchModel, sort, skip, limit } = const { service, MatchModel, sort, skip, limit } =
@@ -165,6 +206,54 @@ describe('MatchService', () => {
expect(sort).toHaveBeenCalledWith({ scheduledAt: -1 }); 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 () => { it('clears game schedule when a built match returns to recruiting', async () => {
const communityId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId();
const match = { const match = {
@@ -203,6 +292,29 @@ describe('MatchService', () => {
expect(matchStatsService.removeByMatch).toHaveBeenCalledWith(match._id); 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 () => { it('releases reserved codes when returning a built match to recruiting', async () => {
const communityId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId();
const codeId = new mongoose.Types.ObjectId(); const codeId = new mongoose.Types.ObjectId();
+32 -4
View File
@@ -13,6 +13,7 @@ import {
MatchDocument, MatchDocument,
MatchSeriesResult, MatchSeriesResult,
MatchStatus, MatchStatus,
POSITIONS,
Position, Position,
PositionPreference, PositionPreference,
TierInfo, TierInfo,
@@ -64,7 +65,7 @@ interface MatchListFilter {
interface JoinMatchParams { interface JoinMatchParams {
matchId: mongoose.Types.ObjectId; matchId: mongoose.Types.ObjectId;
userId: mongoose.Types.ObjectId; userId: mongoose.Types.ObjectId;
preferredPositions: PositionPreference[]; preferredPositions?: PositionPreference[];
// 특정 RiotAccount(puuid)로 참가하고 싶을 때 지정. 없으면 primary 사용. // 특정 RiotAccount(puuid)로 참가하고 싶을 때 지정. 없으면 primary 사용.
riotPuuid?: string; riotPuuid?: string;
} }
@@ -213,10 +214,12 @@ export class MatchService {
const previousStatus = match.status; const previousStatus = match.status;
if ( if (
previousStatus !== 'recruiting' && 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( 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); match.set(params.patch);
@@ -293,7 +296,10 @@ export class MatchService {
tagLine: selectedRiot?.tagLine, tagLine: selectedRiot?.tagLine,
profileIconId: selectedRiot?.profileIconId, profileIconId: selectedRiot?.profileIconId,
tier: selectedTier, tier: selectedTier,
preferredPositions: params.preferredPositions, preferredPositions: this.resolveJoinPreferredPositions(
params.preferredPositions,
user.preferredPositions,
),
joinedAt: new Date(), joinedAt: new Date(),
excluded: false, 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 { private buildListFilter(query: ListMatchesQuery): MatchListFilter {
const filter: MatchListFilter = { const filter: MatchListFilter = {
communityId: query.communityId, communityId: query.communityId,
@@ -1,5 +1,5 @@
import mongoose from 'mongoose'; 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 { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service';
import { RiotRateLimiterService } from '../riot/riot-rate-limiter.service'; import { RiotRateLimiterService } from '../riot/riot-rate-limiter.service';
import { BackgroundRefreshScheduler } from './background-refresh.scheduler'; import { BackgroundRefreshScheduler } from './background-refresh.scheduler';
@@ -33,13 +33,13 @@ function makeScheduler() {
const rawClient = { const rawClient = {
sendCommand: jest.fn().mockResolvedValue(1), sendCommand: jest.fn().mockResolvedValue(1),
}; };
const garnet = { const redis = {
getString: jest.fn().mockResolvedValue(null), getString: jest.fn().mockResolvedValue(null),
setString: jest.fn().mockResolvedValue(undefined), setString: jest.fn().mockResolvedValue(undefined),
setStringIfAbsent: jest.fn().mockResolvedValue(true), setStringIfAbsent: jest.fn().mockResolvedValue(true),
delete: jest.fn().mockResolvedValue(1), delete: jest.fn().mockResolvedValue(1),
raw: jest.fn().mockReturnValue(rawClient), 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 = { const rateLimiter = {
isRefreshWindowOpen: jest.fn().mockResolvedValue(true), isRefreshWindowOpen: jest.fn().mockResolvedValue(true),
} as unknown as jest.Mocked<RiotRateLimiterService>; } as unknown as jest.Mocked<RiotRateLimiterService>;
@@ -51,7 +51,7 @@ function makeScheduler() {
findStaleAccounts: jest.fn().mockResolvedValue([]), findStaleAccounts: jest.fn().mockResolvedValue([]),
} as unknown as jest.Mocked<StaleAccountRepository>; } as unknown as jest.Mocked<StaleAccountRepository>;
const scheduler = new BackgroundRefreshScheduler( const scheduler = new BackgroundRefreshScheduler(
garnet, redis,
rateLimiter, rateLimiter,
enrichmentService, enrichmentService,
staleAccountRepository, staleAccountRepository,
@@ -59,7 +59,7 @@ function makeScheduler() {
return { return {
scheduler, scheduler,
garnet, redis,
rawClient, rawClient,
rateLimiter, rateLimiter,
enrichmentService, enrichmentService,
@@ -115,8 +115,8 @@ describe('BackgroundRefreshScheduler', () => {
it('does not query stale accounts when another leader holds the lock', async () => { it('does not query stale accounts when another leader holds the lock', async () => {
jest.useFakeTimers().setSystemTime(new Date('2026-05-02T18:00:00.000Z')); jest.useFakeTimers().setSystemTime(new Date('2026-05-02T18:00:00.000Z'));
const { scheduler, garnet, staleAccountRepository } = makeScheduler(); const { scheduler, redis, staleAccountRepository } = makeScheduler();
garnet.getString.mockResolvedValue('another-consumer'); redis.getString.mockResolvedValue('another-consumer');
await scheduler.tick(); await scheduler.tick();
@@ -193,12 +193,12 @@ describe('BackgroundRefreshScheduler', () => {
it('skips candidates already in failure backoff', async () => { it('skips candidates already in failure backoff', async () => {
jest.useFakeTimers().setSystemTime(new Date('2026-05-02T18:00:00.000Z')); jest.useFakeTimers().setSystemTime(new Date('2026-05-02T18:00:00.000Z'));
const { scheduler, garnet, enrichmentService, staleAccountRepository } = const { scheduler, redis, enrichmentService, staleAccountRepository } =
makeScheduler(); makeScheduler();
staleAccountRepository.findStaleAccounts.mockResolvedValue([ staleAccountRepository.findStaleAccounts.mockResolvedValue([
candidate('skip-me'), 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'; if (key.includes('riot:bg:fail:skip-me')) return '3';
return null; return null;
}); });
@@ -9,7 +9,7 @@ import {
RiotAccountEnrichmentService, RiotAccountEnrichmentService,
} from '../riot/riot-account-enrichment.service'; } from '../riot/riot-account-enrichment.service';
import { RiotRateLimiterService } from '../riot/riot-rate-limiter.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 { isInKstBackgroundWindow } from './kst-window.util';
import { StaleAccountRepository } from './stale-account.repository'; import { StaleAccountRepository } from './stale-account.repository';
@@ -41,7 +41,7 @@ export class BackgroundRefreshScheduler
private readonly consumer = `${process.pid}:${Math.random().toString(36).slice(2)}`; private readonly consumer = `${process.pid}:${Math.random().toString(36).slice(2)}`;
constructor( constructor(
private readonly garnet: GarnetService, private readonly redis: RedisService,
private readonly rateLimiter: RiotRateLimiterService, private readonly rateLimiter: RiotRateLimiterService,
private readonly enrichmentService: RiotAccountEnrichmentService, private readonly enrichmentService: RiotAccountEnrichmentService,
private readonly staleAccountRepository: StaleAccountRepository, private readonly staleAccountRepository: StaleAccountRepository,
@@ -158,9 +158,9 @@ export class BackgroundRefreshScheduler
} }
private async tryBecomeLeader(): Promise<boolean> { 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) { if (current === this.consumer) {
await this.garnet.setString( await this.redis.setString(
LEADER_KEY, LEADER_KEY,
this.consumer, this.consumer,
LEADER_TTL_SECONDS, LEADER_TTL_SECONDS,
@@ -169,7 +169,7 @@ export class BackgroundRefreshScheduler
} }
if (current) return false; if (current) return false;
return this.garnet.setStringIfAbsent( return this.redis.setStringIfAbsent(
LEADER_KEY, LEADER_KEY,
this.consumer, this.consumer,
LEADER_TTL_SECONDS, LEADER_TTL_SECONDS,
@@ -178,9 +178,9 @@ export class BackgroundRefreshScheduler
private async renewLeaderIfHeld(): Promise<void> { private async renewLeaderIfHeld(): Promise<void> {
try { try {
const current = await this.garnet.getString(LEADER_KEY); const current = await this.redis.getString(LEADER_KEY);
if (current !== this.consumer) return; if (current !== this.consumer) return;
await this.garnet.setString( await this.redis.setString(
LEADER_KEY, LEADER_KEY,
this.consumer, this.consumer,
LEADER_TTL_SECONDS, LEADER_TTL_SECONDS,
@@ -200,7 +200,7 @@ export class BackgroundRefreshScheduler
} }
private async getFailureCount(puuid: string): Promise<number> { 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); const count = Number(raw ?? 0);
if (!Number.isFinite(count) || count < 0) return 0; if (!Number.isFinite(count) || count < 0) return 0;
return count; return count;
@@ -208,7 +208,7 @@ export class BackgroundRefreshScheduler
private async bumpFailureCounter(puuid: string): Promise<void> { private async bumpFailureCounter(puuid: string): Promise<void> {
const key = this.failureBackoffKey(puuid); const key = this.failureBackoffKey(puuid);
const client = this.garnet.raw(); const client = this.redis.raw();
const response = await client.sendCommand(['INCR', key]); const response = await client.sendCommand(['INCR', key]);
await client.sendCommand([ await client.sendCommand([
'EXPIRE', 'EXPIRE',
@@ -225,7 +225,7 @@ export class BackgroundRefreshScheduler
} }
private async clearFailureCounter(puuid: string): Promise<void> { 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 { private isFailedEnrichment(result: EnrichResult): boolean {
@@ -13,7 +13,7 @@ import type {
RiotAccount, RiotAccount,
UserDocument, UserDocument,
} from '../global/database/schema'; } from '../global/database/schema';
import { GarnetService } from '../global/garnet/garnet.service'; import { RedisService } from '../global/redis/redis.service';
import { import {
isRiotQueueGroup, isRiotQueueGroup,
resolveRiotQueueIds, resolveRiotQueueIds,
@@ -51,7 +51,7 @@ interface RefreshContext {
export class RiotJobQueueService { export class RiotJobQueueService {
constructor( constructor(
private readonly connectionService: ConnectionService, private readonly connectionService: ConnectionService,
private readonly garnetService: GarnetService, private readonly redisService: RedisService,
) {} ) {}
public async enqueueRefresh(params: { public async enqueueRefresh(params: {
@@ -64,12 +64,12 @@ export class RiotJobQueueService {
const context = await this.resolveContext(params); const context = await this.resolveContext(params);
const queueGroups = this.normalizeQueueGroups(params.queueGroups); const queueGroups = this.normalizeQueueGroups(params.queueGroups);
const stream = this.resolveStream(params.priority); 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) => const dedupKeys = queueGroups.map((queueGroup) =>
this.dedupKey(context.account.puuid, queueGroup), this.dedupKey(context.account.puuid, queueGroup),
); );
const existingJobIds = await Promise.all( 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); const needsNewJob = existingJobIds.some((jobId) => !jobId);
@@ -114,13 +114,13 @@ export class RiotJobQueueService {
requestedBy: params.requestedBy, requestedBy: params.requestedBy,
priority: params.priority, priority: params.priority,
}; };
const acquired = await this.garnetService.setStringIfAbsent( const acquired = await this.redisService.setStringIfAbsent(
dedupKeys[index], dedupKeys[index],
job.jobId, job.jobId,
RIOT_JOB_DEDUP_TTL_SECONDS, RIOT_JOB_DEDUP_TTL_SECONDS,
); );
if (!acquired) { if (!acquired) {
const jobId = await this.garnetService.getString(dedupKeys[index]); const jobId = await this.redisService.getString(dedupKeys[index]);
if (!jobId) continue; if (!jobId) continue;
const status = await this.getStatus(jobId); const status = await this.getStatus(jobId);
subJobs.push({ subJobs.push({
@@ -149,7 +149,7 @@ export class RiotJobQueueService {
await Promise.all([ await Promise.all([
this.setStatus(status), this.setStatus(status),
this.garnetService.appendStream( this.redisService.appendStream(
stream, stream,
{ job: JSON.stringify(job) }, { job: JSON.stringify(job) },
{ maxLen: 10_000 }, { maxLen: 10_000 },
@@ -209,7 +209,7 @@ export class RiotJobQueueService {
} }
public async promoteDueScheduledJobs(limit = 100): Promise<number> { public async promoteDueScheduledJobs(limit = 100): Promise<number> {
const client = this.garnetService.raw(); const client = this.redisService.raw();
const raw = (await client.sendCommand([ const raw = (await client.sendCommand([
'ZRANGEBYSCORE', 'ZRANGEBYSCORE',
RIOT_JOB_SCHEDULED_ZSET, RIOT_JOB_SCHEDULED_ZSET,
@@ -239,13 +239,13 @@ export class RiotJobQueueService {
} }
public async getStatus(jobId: string): Promise<RiotJobStatus | null> { 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( public async getParentStatus(
parentJobId: string, parentJobId: string,
): Promise<RiotParentJobStatus | null> { ): Promise<RiotParentJobStatus | null> {
const jobIds = await this.garnetService.getJson<string[]>( const jobIds = await this.redisService.getJson<string[]>(
this.parentKey(parentJobId), this.parentKey(parentJobId),
); );
if (!jobIds) return null; if (!jobIds) return null;
@@ -296,7 +296,7 @@ export class RiotJobQueueService {
}; };
await Promise.all([ await Promise.all([
this.setStatus(next), 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); return this.toEvent(next);
} }
@@ -317,7 +317,7 @@ export class RiotJobQueueService {
}; };
await Promise.all([ await Promise.all([
this.setStatus(next), 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); return this.toEvent(next);
} }
@@ -400,7 +400,7 @@ export class RiotJobQueueService {
} }
private async appendJob(job: RiotRefreshSubJob | PollTournamentResultJob) { private async appendJob(job: RiotRefreshSubJob | PollTournamentResultJob) {
await this.garnetService.appendStream( await this.redisService.appendStream(
this.resolveStream(job.priority), this.resolveStream(job.priority),
{ job: JSON.stringify(job) }, { job: JSON.stringify(job) },
{ maxLen: 10_000 }, { maxLen: 10_000 },
@@ -411,7 +411,7 @@ export class RiotJobQueueService {
job: PollTournamentResultJob, job: PollTournamentResultJob,
deferUntilMs: number, deferUntilMs: number,
): Promise<void> { ): Promise<void> {
await this.garnetService.raw().sendCommand([ await this.redisService.raw().sendCommand([
'ZADD', 'ZADD',
RIOT_JOB_SCHEDULED_ZSET, RIOT_JOB_SCHEDULED_ZSET,
String(deferUntilMs), String(deferUntilMs),
@@ -442,7 +442,7 @@ export class RiotJobQueueService {
} }
private async setStatus(status: RiotJobStatus): Promise<void> { private async setStatus(status: RiotJobStatus): Promise<void> {
await this.garnetService.setJson( await this.redisService.setJson(
this.statusKey(status.jobId), this.statusKey(status.jobId),
status, status,
RIOT_JOB_STATUS_TTL_SECONDS, RIOT_JOB_STATUS_TTL_SECONDS,
@@ -450,7 +450,7 @@ export class RiotJobQueueService {
} }
private async setParent(parentJobId: string, jobIds: string[]): Promise<void> { private async setParent(parentJobId: string, jobIds: string[]): Promise<void> {
await this.garnetService.setJson( await this.redisService.setJson(
this.parentKey(parentJobId), this.parentKey(parentJobId),
jobIds, jobIds,
RIOT_JOB_STATUS_TTL_SECONDS, RIOT_JOB_STATUS_TTL_SECONDS,
@@ -1,6 +1,6 @@
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service'; 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 { LegacyImportService } from '../legacy-import/legacy-import.service';
import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service'; import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service';
import { RiotRecentMatchesService } from '../riot/riot-recent-matches.service'; import { RiotRecentMatchesService } from '../riot/riot-recent-matches.service';
@@ -15,10 +15,10 @@ function execResult<T>(value: T) {
} }
function makeWorker() { function makeWorker() {
const garnetService = { const redisService = {
acknowledgeStream: jest.fn().mockResolvedValue(undefined), acknowledgeStream: jest.fn().mockResolvedValue(undefined),
deleteStreamEntries: jest.fn().mockResolvedValue(undefined), deleteStreamEntries: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<GarnetService>; } as unknown as jest.Mocked<RedisService>;
const jobQueueService = { const jobQueueService = {
markProcessing: jest.fn().mockResolvedValue(undefined), markProcessing: jest.fn().mockResolvedValue(undefined),
markCompleted: jest.fn().mockResolvedValue({ markCompleted: jest.fn().mockResolvedValue({
@@ -53,7 +53,7 @@ function makeWorker() {
} as unknown as jest.Mocked<RiotAccountEnrichmentService>; } as unknown as jest.Mocked<RiotAccountEnrichmentService>;
const worker = new RiotJobWorkerService( const worker = new RiotJobWorkerService(
garnetService, redisService,
jobQueueService, jobQueueService,
recentMatchesService, recentMatchesService,
connectionService, connectionService,
@@ -65,7 +65,7 @@ function makeWorker() {
return { return {
worker, worker,
garnetService, redisService,
jobQueueService, jobQueueService,
recentMatchesService, recentMatchesService,
connectionService, connectionService,
@@ -76,7 +76,7 @@ function makeWorker() {
describe('RiotJobWorkerService', () => { describe('RiotJobWorkerService', () => {
it('acknowledges and deletes invalid stream entries', async () => { it('acknowledges and deletes invalid stream entries', async () => {
const { worker, garnetService } = makeWorker(); const { worker, redisService } = makeWorker();
await ( await (
worker as unknown as { worker as unknown as {
@@ -90,19 +90,19 @@ describe('RiotJobWorkerService', () => {
message: { job: 'not-json' }, message: { job: 'not-json' },
}); });
expect(garnetService.acknowledgeStream).toHaveBeenCalledWith( expect(redisService.acknowledgeStream).toHaveBeenCalledWith(
'riot:queue:high', 'riot:queue:high',
RIOT_JOB_GROUP, RIOT_JOB_GROUP,
'bad-1', 'bad-1',
); );
expect(garnetService.deleteStreamEntries).toHaveBeenCalledWith( expect(redisService.deleteStreamEntries).toHaveBeenCalledWith(
'riot:queue:high', 'riot:queue:high',
'bad-1', 'bad-1',
); );
}); });
it('refreshes league entries while processing user history refresh jobs', async () => { it('refreshes league entries while processing user history refresh jobs', async () => {
const { worker, enrichmentService, recentMatchesService, garnetService } = const { worker, enrichmentService, recentMatchesService, redisService } =
makeWorker(); makeWorker();
const userId = new mongoose.Types.ObjectId().toString(); const userId = new mongoose.Types.ObjectId().toString();
const job: RiotRefreshSubJob = { const job: RiotRefreshSubJob = {
@@ -136,19 +136,19 @@ describe('RiotJobWorkerService', () => {
puuid: 'puuid-1', puuid: 'puuid-1',
platform: 'kr', platform: 'kr',
}); });
expect(garnetService.acknowledgeStream).toHaveBeenCalledWith( expect(redisService.acknowledgeStream).toHaveBeenCalledWith(
'riot:queue:high', 'riot:queue:high',
RIOT_JOB_GROUP, RIOT_JOB_GROUP,
'1-0', '1-0',
); );
expect(garnetService.deleteStreamEntries).toHaveBeenCalledWith( expect(redisService.deleteStreamEntries).toHaveBeenCalledWith(
'riot:queue:high', 'riot:queue:high',
'1-0', '1-0',
); );
expect( expect(
garnetService.acknowledgeStream.mock.invocationCallOrder[0], redisService.acknowledgeStream.mock.invocationCallOrder[0],
).toBeLessThan( ).toBeLessThan(
garnetService.deleteStreamEntries.mock.invocationCallOrder[0], redisService.deleteStreamEntries.mock.invocationCallOrder[0],
); );
}); });
}); });
@@ -6,7 +6,7 @@ import {
} from '@nestjs/common'; } from '@nestjs/common';
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service'; 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 { LegacyImportService } from '../legacy-import/legacy-import.service';
import type { LegacyImportMemberJob } from '../legacy-import/legacy-import.types'; import type { LegacyImportMemberJob } from '../legacy-import/legacy-import.types';
import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service'; import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service';
@@ -33,7 +33,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
private stopped = false; private stopped = false;
constructor( constructor(
private readonly garnetService: GarnetService, private readonly redisService: RedisService,
private readonly jobQueueService: RiotJobQueueService, private readonly jobQueueService: RiotJobQueueService,
private readonly recentMatchesService: RiotRecentMatchesService, private readonly recentMatchesService: RiotRecentMatchesService,
private readonly connectionService: ConnectionService, private readonly connectionService: ConnectionService,
@@ -145,7 +145,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
stream: string, stream: string,
id: string, id: string,
): Promise<void> { ): 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); await this.deleteAcknowledgedEntry(stream, id);
} }
@@ -154,7 +154,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
id: string, id: string,
): Promise<void> { ): Promise<void> {
try { try {
await this.garnetService.deleteStreamEntries(stream, id); await this.redisService.deleteStreamEntries(stream, id);
} catch (error) { } catch (error) {
this.logger.warn( this.logger.warn(
`Failed to delete acknowledged Riot job stream entry ${stream} ${id}: ${ `Failed to delete acknowledged Riot job stream entry ${stream} ${id}: ${
@@ -226,7 +226,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
stream: string, stream: string,
blockMs: number, blockMs: number,
): Promise<{ stream: string; message: StreamEntry } | null> { ): Promise<{ stream: string; message: StreamEntry } | null> {
const result = await this.garnetService.readGroup( const result = await this.redisService.readGroup(
stream, stream,
RIOT_JOB_GROUP, RIOT_JOB_GROUP,
this.consumer, this.consumer,
@@ -241,7 +241,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
await Promise.all( await Promise.all(
[RIOT_JOB_HIGH_STREAM, RIOT_JOB_LOW_STREAM].map(async (stream) => { [RIOT_JOB_HIGH_STREAM, RIOT_JOB_LOW_STREAM].map(async (stream) => {
try { try {
await this.garnetService.createConsumerGroup(stream, RIOT_JOB_GROUP); await this.redisService.createConsumerGroup(stream, RIOT_JOB_GROUP);
} catch (error) { } catch (error) {
const message = const message =
error instanceof Error ? error.message : String(error); error instanceof Error ? error.message : String(error);
@@ -252,9 +252,9 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
} }
private async tryBecomeLeader(): Promise<boolean> { 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) { if (current === this.consumer) {
await this.garnetService.setString( await this.redisService.setString(
LEADER_KEY, LEADER_KEY,
this.consumer, this.consumer,
LEADER_TTL_SECONDS, LEADER_TTL_SECONDS,
@@ -262,7 +262,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
return true; return true;
} }
if (current) return false; if (current) return false;
return this.garnetService.setStringIfAbsent( return this.redisService.setStringIfAbsent(
LEADER_KEY, LEADER_KEY,
this.consumer, this.consumer,
LEADER_TTL_SECONDS, LEADER_TTL_SECONDS,
@@ -1,5 +1,5 @@
import { Injectable, Logger } from '@nestjs/common'; 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_BASE = 'https://ddragon.leagueoflegends.com';
const DDRAGON_CDN = `${DDRAGON_BASE}/cdn`; const DDRAGON_CDN = `${DDRAGON_BASE}/cdn`;
@@ -75,13 +75,13 @@ export class RiotDdragonService {
private readonly logger = new Logger(RiotDdragonService.name); private readonly logger = new Logger(RiotDdragonService.name);
private inflight = new Map<string, Promise<DdragonManifest>>(); 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> { public async getManifest(locale: string = DEFAULT_LOCALE): Promise<DdragonManifest> {
const normalizedLocale = normalizeLocale(locale); const normalizedLocale = normalizeLocale(locale);
const cacheKey = manifestCacheKey(normalizedLocale); const cacheKey = manifestCacheKey(normalizedLocale);
const cached = await this.garnetService.getJson<DdragonManifest>(cacheKey); const cached = await this.redisService.getJson<DdragonManifest>(cacheKey);
if (cached) return cached; if (cached) return cached;
const pending = this.inflight.get(cacheKey); const pending = this.inflight.get(cacheKey);
@@ -89,7 +89,7 @@ export class RiotDdragonService {
const promise = this.buildManifest(normalizedLocale) const promise = this.buildManifest(normalizedLocale)
.then(async (manifest) => { .then(async (manifest) => {
await this.garnetService.setJson(cacheKey, manifest, CACHE_TTL_SECONDS); await this.redisService.setJson(cacheKey, manifest, CACHE_TTL_SECONDS);
return manifest; return manifest;
}) })
.finally(() => { .finally(() => {
@@ -106,4 +106,112 @@ describe('RiotMatchService', () => {
expect(match.info.participants[0].teamPosition).toBe(''); expect(match.info.participants[0].teamPosition).toBe('');
expect(match.info.participants[0].individualPosition).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, RiotMatchPerkStyleSelectionDto,
RiotMatchStatPerksDto, RiotMatchStatPerksDto,
RiotMatchTeamDto, RiotMatchTeamDto,
RiotMatchTimelineDto,
RiotMatchTimelineEventDto,
RiotMatchTimelineFrameDto,
RiotMatchTimelineInfoDto,
RiotMatchTimelineParticipantDto,
RiotMatchTimelineParticipantFrameDto,
RiotMatchType, RiotMatchType,
} from './riot.types'; } from './riot.types';
@@ -66,6 +72,20 @@ export class RiotMatchService {
parseMatchResponse, 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( 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 { function parseMatchMetadata(value: unknown): RiotMatchMetadataDto {
if (!isRecord(value)) { if (!isRecord(value)) {
throw new TypeError('Riot match metadata must be an object.'); 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( function parseParticipant(
value: unknown, value: unknown,
index: number, index: number,
@@ -504,12 +755,22 @@ function parseObjectives(
baron: parseObjective(value.baron, teamIndex, 'baron'), baron: parseObjective(value.baron, teamIndex, 'baron'),
champion: parseObjective(value.champion, teamIndex, 'champion'), champion: parseObjective(value.champion, teamIndex, 'champion'),
dragon: parseObjective(value.dragon, teamIndex, 'dragon'), dragon: parseObjective(value.dragon, teamIndex, 'dragon'),
horde: optionalObjective(value.horde, teamIndex, 'horde'),
inhibitor: parseObjective(value.inhibitor, teamIndex, 'inhibitor'), inhibitor: parseObjective(value.inhibitor, teamIndex, 'inhibitor'),
riftHerald: parseObjective(value.riftHerald, teamIndex, 'riftHerald'), riftHerald: parseObjective(value.riftHerald, teamIndex, 'riftHerald'),
tower: parseObjective(value.tower, teamIndex, 'tower'), 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( function parseObjective(
value: unknown, value: unknown,
teamIndex: number, 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'; import { RiotRateLimiterService } from './riot-rate-limiter.service';
function makeService(sendCommand = jest.fn().mockResolvedValue(0)) { function makeService(sendCommand = jest.fn().mockResolvedValue(0)) {
const garnet = { const redis = {
getString: jest.fn().mockResolvedValue(null), getString: jest.fn().mockResolvedValue(null),
raw: jest.fn().mockReturnValue({ sendCommand }), raw: jest.fn().mockReturnValue({ sendCommand }),
setString: jest.fn().mockResolvedValue(undefined), setString: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<GarnetService>; } as unknown as jest.Mocked<RedisService>;
return { return {
service: new RiotRateLimiterService(garnet), service: new RiotRateLimiterService(redis),
garnet, redis,
sendCommand, sendCommand,
}; };
} }
@@ -51,12 +51,12 @@ describe('RiotRateLimiterService', () => {
it('records the 120 second app rate observation from Riot headers', async () => { it('records the 120 second app rate observation from Riot headers', async () => {
jest.spyOn(Date, 'now').mockReturnValue(1_000_000); 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'); await service.recordAppRateLimitObservation('47:120,3:1', '100:120,20:1');
expect(garnet.setString).toHaveBeenCalledTimes(1); expect(redis.setString).toHaveBeenCalledTimes(1);
const [key, raw, ttl] = garnet.setString.mock.calls[0]; const [key, raw, ttl] = redis.setString.mock.calls[0];
expect(key).toBe('riot:app:rl:observed'); expect(key).toBe('riot:app:rl:observed');
expect(ttl).toBe(300); expect(ttl).toBe(300);
expect(JSON.parse(raw)).toEqual({ 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 () => { 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); jest.spyOn(Date, 'now').mockReturnValue(1_060_000);
garnet.getString.mockResolvedValueOnce( redis.getString.mockResolvedValueOnce(
observedState({ observedState({
count120: 80, count120: 80,
observedAt: 1_050_000, observedAt: 1_050_000,
@@ -81,13 +81,13 @@ describe('RiotRateLimiterService', () => {
await service.recordAppRateLimitObservation('2:120', null); 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, count120: 2,
windowStartAt: 1_060_000, windowStartAt: 1_060_000,
}); });
jest.spyOn(Date, 'now').mockReturnValue(1_240_000); jest.spyOn(Date, 'now').mockReturnValue(1_240_000);
garnet.getString.mockResolvedValueOnce( redis.getString.mockResolvedValueOnce(
observedState({ observedState({
count120: 20, count120: 20,
observedAt: 1_120_000, observedAt: 1_120_000,
@@ -97,18 +97,18 @@ describe('RiotRateLimiterService', () => {
await service.recordAppRateLimitObservation('25:120', null); 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, count120: 25,
windowStartAt: 1_240_000, windowStartAt: 1_240_000,
}); });
}); });
it('opens the refresh gate when there is no active observation', async () => { 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); await expect(service.isRefreshWindowOpen(0.5)).resolves.toBe(true);
garnet.getString.mockResolvedValueOnce( redis.getString.mockResolvedValueOnce(
observedState({ observedState({
count120: 90, count120: 90,
observedAt: 1_000_000, observedAt: 1_000_000,
@@ -129,8 +129,8 @@ describe('RiotRateLimiterService', () => {
'checks tail headroom for refresh gate ratio=$ratio count=$count120', 'checks tail headroom for refresh gate ratio=$ratio count=$count120',
async ({ ratio, count120, expected }) => { async ({ ratio, count120, expected }) => {
jest.spyOn(Date, 'now').mockReturnValue(1_070_000); jest.spyOn(Date, 'now').mockReturnValue(1_070_000);
const { service, garnet } = makeService(); const { service, redis } = makeService();
garnet.getString.mockResolvedValue( redis.getString.mockResolvedValue(
observedState({ observedState({
count120, count120,
observedAt: 1_069_000, observedAt: 1_069_000,
@@ -144,8 +144,8 @@ describe('RiotRateLimiterService', () => {
it('keeps the refresh gate closed before the 120 second window tail', async () => { it('keeps the refresh gate closed before the 120 second window tail', async () => {
jest.spyOn(Date, 'now').mockReturnValue(1_050_000); jest.spyOn(Date, 'now').mockReturnValue(1_050_000);
const { service, garnet } = makeService(); const { service, redis } = makeService();
garnet.getString.mockResolvedValue( redis.getString.mockResolvedValue(
observedState({ observedState({
count120: 10, count120: 10,
observedAt: 1_049_000, observedAt: 1_049_000,
@@ -1,6 +1,6 @@
import { Injectable, Logger } from '@nestjs/common'; import { Injectable, Logger } from '@nestjs/common';
import type { RiotPlatformRoute, RiotRegionalRoute } from './riot.types'; import type { RiotPlatformRoute, RiotRegionalRoute } from './riot.types';
import { GarnetService } from '../global/garnet/garnet.service'; import { RedisService } from '../global/redis/redis.service';
const APP_LIMITS = [ const APP_LIMITS = [
{ windowMs: 1_000, max: 15 }, { windowMs: 1_000, max: 15 },
@@ -85,7 +85,7 @@ return 0
export class RiotRateLimiterService { export class RiotRateLimiterService {
private readonly logger = new Logger(RiotRateLimiterService.name); private readonly logger = new Logger(RiotRateLimiterService.name);
constructor(private readonly garnet: GarnetService) {} constructor(private readonly redis: RedisService) {}
public async acquire( public async acquire(
route: RiotRegionalRoute | RiotPlatformRoute, route: RiotRegionalRoute | RiotPlatformRoute,
@@ -133,7 +133,7 @@ export class RiotRateLimiterService {
// Concurrent responses can race here. This observation is advisory, so // Concurrent responses can race here. This observation is advisory, so
// last-writer-wins is acceptable and self-corrects on the next Riot header. // last-writer-wins is acceptable and self-corrects on the next Riot header.
await this.garnet.setString( await this.redis.setString(
APP_OBSERVED_KEY, APP_OBSERVED_KEY,
JSON.stringify(observation), JSON.stringify(observation),
APP_OBSERVED_TTL_SECONDS, APP_OBSERVED_TTL_SECONDS,
@@ -167,7 +167,7 @@ export class RiotRateLimiterService {
now: number, now: number,
cost: number, cost: number,
): Promise<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 member = `${process.pid}:${now}:${Math.random().toString(36).slice(2)}`;
const argumentsList = [ const argumentsList = [
String(now), String(now),
@@ -190,7 +190,7 @@ export class RiotRateLimiterService {
} }
private async getAppRateObservation(): Promise<AppRateObservation | null> { 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; if (!raw) return null;
try { try {
@@ -4,7 +4,7 @@ import type {
RiotMatch as StoredRiotMatch, RiotMatch as StoredRiotMatch,
} from '../global/database/schema'; } from '../global/database/schema';
import { ConnectionService } from '../global/database/connection.service'; 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 type { RiotRegionalRoute } from './riot.types';
import { RiotMatchService } from './riot-match.service'; import { RiotMatchService } from './riot-match.service';
@@ -22,7 +22,7 @@ export class RiotRecentMatchesService {
constructor( constructor(
private readonly connectionService: ConnectionService, private readonly connectionService: ConnectionService,
private readonly matchService: RiotMatchService, private readonly matchService: RiotMatchService,
private readonly garnetService: GarnetService, private readonly redisService: RedisService,
) {} ) {}
public async syncRecentMatches(params: { public async syncRecentMatches(params: {
@@ -37,7 +37,7 @@ export class RiotRecentMatchesService {
const lockKey = `riot:enrich:matches:${params.puuid}`; const lockKey = `riot:enrich:matches:${params.puuid}`;
const lockValue = `${process.pid}:${Date.now()}`; const lockValue = `${process.pid}:${Date.now()}`;
const acquired = await this.garnetService.setStringIfAbsent( const acquired = await this.redisService.setStringIfAbsent(
lockKey, lockKey,
lockValue, lockValue,
MATCH_ENRICHMENT_LOCK_TTL_SECONDS, MATCH_ENRICHMENT_LOCK_TTL_SECONDS,
@@ -103,7 +103,7 @@ export class RiotRecentMatchesService {
return this.loadFromDb({ puuid: params.puuid, limit, queueId }); return this.loadFromDb({ puuid: params.puuid, limit, queueId });
} finally { } finally {
await this.garnetService.delete(lockKey).catch((error: unknown) => { await this.redisService.delete(lockKey).catch((error: unknown) => {
this.logger.warn( this.logger.warn(
`Failed to release recent matches lock for ${params.puuid}: ${ `Failed to release recent matches lock for ${params.puuid}: ${
(error as Error)?.message ?? error (error as Error)?.message ?? error
+54
View File
@@ -134,6 +134,11 @@ export interface RiotMatchDto {
info: RiotMatchInfoDto; info: RiotMatchInfoDto;
} }
export interface RiotMatchTimelineDto {
metadata: RiotMatchMetadataDto;
info: RiotMatchTimelineInfoDto;
}
export interface RiotMatchMetadataDto { export interface RiotMatchMetadataDto {
dataVersion: string; dataVersion: string;
matchId: string; matchId: string;
@@ -240,6 +245,7 @@ export interface RiotMatchObjectivesDto {
baron: RiotMatchObjectiveDto; baron: RiotMatchObjectiveDto;
champion: RiotMatchObjectiveDto; champion: RiotMatchObjectiveDto;
dragon: RiotMatchObjectiveDto; dragon: RiotMatchObjectiveDto;
horde?: RiotMatchObjectiveDto;
inhibitor: RiotMatchObjectiveDto; inhibitor: RiotMatchObjectiveDto;
riftHerald: RiotMatchObjectiveDto; riftHerald: RiotMatchObjectiveDto;
tower: RiotMatchObjectiveDto; tower: RiotMatchObjectiveDto;
@@ -249,3 +255,51 @@ export interface RiotMatchObjectiveDto {
first: boolean; first: boolean;
kills: number; 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 { import {
resolveRoundRobinTeamCount, resolveRoundRobinTeamCount,
roundRobinGameSchedule,
roundRobinPairCount, roundRobinPairCount,
roundRobinPairs, roundRobinPairs,
shuffleInPlace, shuffleInPlace,
@@ -25,6 +26,30 @@ describe('round-robin util', () => {
expect(roundRobinPairCount(6)).toBe(15); 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', () => { it('resolves team count from teams first, then active participants', () => {
expect( expect(
resolveRoundRobinTeamCount({ resolveRoundRobinTeamCount({
@@ -3,11 +3,23 @@ export interface RoundRobinPair {
teamBIndex: number; teamBIndex: number;
} }
export interface RoundRobinGameAssignment extends RoundRobinPair {
gameNumber: number;
roundNumber: number;
}
export interface RoundRobinTeamCountInput { export interface RoundRobinTeamCountInput {
teams?: Array<{ teamIndex: number }>; teams?: Array<{ teamIndex: number }>;
participants: Array<{ excluded?: boolean }>; participants: Array<{ excluded?: boolean }>;
} }
export interface RoundRobinGameScheduleOptions {
gamesPerPair?: number;
maxRounds?: number;
rng?: () => number;
shuffleTeams?: boolean;
}
export function roundRobinPairs(teamCount: number): RoundRobinPair[] { export function roundRobinPairs(teamCount: number): RoundRobinPair[] {
const pairs: RoundRobinPair[] = []; const pairs: RoundRobinPair[] = [];
for (let teamAIndex = 1; teamAIndex <= teamCount; teamAIndex += 1) { for (let teamAIndex = 1; teamAIndex <= teamCount; teamAIndex += 1) {
@@ -27,6 +39,70 @@ export function roundRobinPairCount(teamCount: number): number {
return (teamCount * (teamCount - 1)) / 2; 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( export function resolveRoundRobinTeamCount(
match: RoundRobinTeamCountInput, match: RoundRobinTeamCountInput,
): number { ): 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,19 @@
import { Module } from '@nestjs/common'; import { Module } from '@nestjs/common';
import { TournamentCodeController } from './tournament-code.controller'; 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 { TournamentCodeScheduler } from './tournament-code.scheduler';
import { TournamentCodeService } from './tournament-code.service'; import { TournamentCodeService } from './tournament-code.service';
import { TournamentCodeVendorService } from './tournament-code-vendor.service';
@Module({ @Module({
controllers: [TournamentCodeController], controllers: [TournamentCodeController, TournamentCodeReplacementController],
providers: [TournamentCodeService, TournamentCodeScheduler], providers: [
TournamentCodeService,
TournamentCodeVendorService,
TournamentCodeAutoProvisionService,
TournamentCodeScheduler,
],
exports: [TournamentCodeService], exports: [TournamentCodeService],
}) })
export class TournamentCodeModule {} export class TournamentCodeModule {}
@@ -1,4 +1,5 @@
import { Injectable, Logger, OnModuleDestroy, OnModuleInit } from '@nestjs/common'; import { Injectable, Logger, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
import { TournamentCodeAutoProvisionService } from './tournament-code-auto-provision.service';
import { TournamentCodeService } from './tournament-code.service'; import { TournamentCodeService } from './tournament-code.service';
@Injectable() @Injectable()
@@ -6,8 +7,12 @@ export class TournamentCodeScheduler implements OnModuleInit, OnModuleDestroy {
private readonly logger = new Logger(TournamentCodeScheduler.name); private readonly logger = new Logger(TournamentCodeScheduler.name);
private attachTimer?: NodeJS.Timeout; private attachTimer?: NodeJS.Timeout;
private expireTimer?: NodeJS.Timeout; private expireTimer?: NodeJS.Timeout;
private refillTimer?: NodeJS.Timeout;
constructor(private readonly tournamentCodeService: TournamentCodeService) {} constructor(
private readonly tournamentCodeService: TournamentCodeService,
private readonly autoProvisionService: TournamentCodeAutoProvisionService,
) {}
public onModuleInit() { public onModuleInit() {
this.attachTimer = setInterval(() => { this.attachTimer = setInterval(() => {
@@ -16,16 +21,26 @@ export class TournamentCodeScheduler implements OnModuleInit, OnModuleDestroy {
this.expireTimer = setInterval(() => { this.expireTimer = setInterval(() => {
void this.markExpired(); void this.markExpired();
}, 60 * 60 * 1000); }, 60 * 60 * 1000);
if (isAutoProvisionEnabled()) {
this.refillTimer = setInterval(() => {
void this.ensureVendorPool();
}, 5 * 60 * 1000);
}
this.attachTimer.unref?.(); this.attachTimer.unref?.();
this.expireTimer.unref?.(); this.expireTimer.unref?.();
this.refillTimer?.unref?.();
void this.attachPending(); void this.attachPending();
void this.markExpired(); void this.markExpired();
if (isAutoProvisionEnabled()) {
void this.ensureVendorPool();
}
} }
public onModuleDestroy() { public onModuleDestroy() {
if (this.attachTimer) clearInterval(this.attachTimer); if (this.attachTimer) clearInterval(this.attachTimer);
if (this.expireTimer) clearInterval(this.expireTimer); if (this.expireTimer) clearInterval(this.expireTimer);
if (this.refillTimer) clearInterval(this.refillTimer);
} }
private async attachPending() { private async attachPending() {
@@ -54,4 +69,23 @@ export class TournamentCodeScheduler implements OnModuleInit, OnModuleDestroy {
); );
} }
} }
private async ensureVendorPool() {
try {
await this.autoProvisionService.ensurePool();
} catch (error) {
this.logger.warn(
`Failed to auto-provision tournament codes: ${
error instanceof Error ? error.message : error
}`,
);
}
}
}
function isAutoProvisionEnabled(): boolean {
const raw = process.env.TOURNAMENT_CODE_AUTO_PROVISION_ENABLED
?.trim()
.toLowerCase();
return raw !== 'false' && raw !== '0' && raw !== 'off';
} }
@@ -1,4 +1,8 @@
import type { MatchDocument } from '../global/database/schema'; import {
TournamentCodeSchema,
type MatchDocument,
} from '../global/database/schema';
import mongoose from 'mongoose';
import { TournamentCodeService } from './tournament-code.service'; import { TournamentCodeService } from './tournament-code.service';
type TournamentCodeServiceInternals = TournamentCodeService & { type TournamentCodeServiceInternals = TournamentCodeService & {
@@ -8,6 +12,12 @@ type TournamentCodeServiceInternals = TournamentCodeService & {
gameNumber: number, gameNumber: number,
): { teamAIndex: number; teamBIndex: number }; ): { teamAIndex: number; teamBIndex: number };
ensureGameSchedule(match: MatchDocument): void; ensureGameSchedule(match: MatchDocument): void;
replaceForMatchGame(params: {
communityId: mongoose.Types.ObjectId;
matchId: mongoose.Types.ObjectId;
gameNumber: number;
}): Promise<unknown>;
attachPendingMatches(communityId?: mongoose.Types.ObjectId): Promise<number>;
}; };
function createService() { function createService() {
@@ -19,10 +29,12 @@ function createService() {
interface MatchOverrides { interface MatchOverrides {
gameCount?: number; gameCount?: number;
gameMode?: 'pair' | 'bracket' | 'round-robin'; gameMode?: 'pair' | 'bracket' | 'round-robin';
roundRobinMaxRounds?: number;
participants?: Array<{ excluded?: boolean }>; participants?: Array<{ excluded?: boolean }>;
teams?: Array<{ teamIndex: number }>; teams?: Array<{ teamIndex: number }>;
gameSchedule?: Array<{ gameSchedule?: Array<{
gameNumber: number; gameNumber: number;
roundNumber?: number;
teamAIndex: number; teamAIndex: number;
teamBIndex: number; teamBIndex: number;
}>; }>;
@@ -30,11 +42,15 @@ interface MatchOverrides {
function createMatch(overrides: MatchOverrides): MatchDocument { function createMatch(overrides: MatchOverrides): MatchDocument {
return { return {
_id: new mongoose.Types.ObjectId(),
status: 'in-progress',
gameCount: 1, gameCount: 1,
gameMode: 'pair', gameMode: 'pair',
participants: [], participants: [],
teams: [], teams: [],
tournamentCodeIds: [],
gameSchedule: [], gameSchedule: [],
save: jest.fn().mockResolvedValue(undefined),
...overrides, ...overrides,
} as unknown as MatchDocument; } as unknown as MatchDocument;
} }
@@ -102,15 +118,32 @@ describe('TournamentCodeService round-robin scheduling', () => {
).toBe(15); ).toBe(15);
}); });
it('calculates limited round-robin slots from max rounds', () => {
const service = createService();
expect(
service.resolveRequiredSlots(
createMatch({
gameMode: 'round-robin',
gameCount: 1,
roundRobinMaxRounds: 3,
teams: Array.from({ length: 8 }, (_, index) => ({
teamIndex: index + 1,
})),
}),
),
).toBe(12);
});
it('uses persisted round-robin game schedule for game refs', () => { it('uses persisted round-robin game schedule for game refs', () => {
const service = createService(); const service = createService();
const match = createMatch({ const match = createMatch({
gameMode: 'round-robin', gameMode: 'round-robin',
gameCount: 2, gameCount: 2,
gameSchedule: [ gameSchedule: [
{ gameNumber: 1, teamAIndex: 2, teamBIndex: 5 }, { gameNumber: 1, roundNumber: 1, teamAIndex: 2, teamBIndex: 5 },
{ gameNumber: 2, teamAIndex: 2, teamBIndex: 5 }, { gameNumber: 2, roundNumber: 1, teamAIndex: 2, teamBIndex: 5 },
{ gameNumber: 3, teamAIndex: 1, teamBIndex: 4 }, { gameNumber: 3, roundNumber: 2, teamAIndex: 1, teamBIndex: 4 },
], ],
}); });
@@ -124,7 +157,7 @@ describe('TournamentCodeService round-robin scheduling', () => {
}); });
}); });
it('falls back to lexicographic round-robin pairs before schedule is persisted', () => { it('falls back to round-based pairs before schedule is persisted', () => {
const service = createService(); const service = createService();
const match = createMatch({ const match = createMatch({
gameMode: 'round-robin', gameMode: 'round-robin',
@@ -137,10 +170,10 @@ describe('TournamentCodeService round-robin scheduling', () => {
expect(service.resolveSeriesRefForGameNumber(match, 1)).toEqual({ expect(service.resolveSeriesRefForGameNumber(match, 1)).toEqual({
teamAIndex: 1, teamAIndex: 1,
teamBIndex: 2, teamBIndex: 4,
}); });
expect(service.resolveSeriesRefForGameNumber(match, 2)).toEqual({ expect(service.resolveSeriesRefForGameNumber(match, 2)).toEqual({
teamAIndex: 1, teamAIndex: 2,
teamBIndex: 3, teamBIndex: 3,
}); });
}); });
@@ -173,6 +206,105 @@ describe('TournamentCodeService round-robin scheduling', () => {
expect(pair.gameSchedule).toEqual([]); expect(pair.gameSchedule).toEqual([]);
}); });
it('creates a limited round-robin schedule grouped by playable rounds', () => {
const service = createService();
const roundRobin = createMatch({
gameMode: 'round-robin',
gameCount: 1,
roundRobinMaxRounds: 3,
teams: Array.from({ length: 8 }, (_, index) => ({
teamIndex: index + 1,
})),
gameSchedule: [],
});
service.ensureGameSchedule(roundRobin);
expect(roundRobin.gameSchedule).toHaveLength(12);
for (const roundNumber of [1, 2, 3]) {
const round = roundRobin.gameSchedule.filter(
(game) => game.roundNumber === roundNumber,
);
expect(round).toHaveLength(4);
expect(new Set(round.flatMap((game) => [game.teamAIndex, game.teamBIndex])).size)
.toBe(8);
}
});
it('leaves legacy round-robin schedules without round numbers unchanged', () => {
const service = createService();
const roundRobin = createMatch({
gameMode: 'round-robin',
gameCount: 1,
teams: Array.from({ length: 6 }, (_, index) => ({
teamIndex: index + 1,
})),
gameSchedule: [
{ gameNumber: 1, teamAIndex: 2, teamBIndex: 5 },
{ gameNumber: 2, teamAIndex: 1, teamBIndex: 2 },
{ gameNumber: 3, teamAIndex: 4, teamBIndex: 5 },
{ gameNumber: 4, teamAIndex: 1, teamBIndex: 6 },
{ gameNumber: 5, teamAIndex: 5, teamBIndex: 6 },
{ gameNumber: 6, teamAIndex: 4, teamBIndex: 6 },
],
});
const persisted = [...roundRobin.gameSchedule];
service.ensureGameSchedule(roundRobin);
expect(roundRobin.gameSchedule).toEqual(persisted);
});
it('does not expose round numbers for legacy round-robin slots', async () => {
const codeFindExec = jest.fn().mockResolvedValue([]);
const connectionService = {
getModel: jest.fn().mockResolvedValue({
find: jest.fn().mockReturnValue({ exec: codeFindExec }),
}),
};
const service = new TournamentCodeService(
connectionService as never,
) as unknown as TournamentCodeServiceInternals;
const slots = await service.buildSlots(
createMatch({
gameMode: 'round-robin',
gameCount: 1,
teams: Array.from({ length: 6 }, (_, index) => ({
teamIndex: index + 1,
})),
gameSchedule: [
{ gameNumber: 1, teamAIndex: 2, teamBIndex: 5 },
{ gameNumber: 2, teamAIndex: 1, teamBIndex: 2 },
{ gameNumber: 3, teamAIndex: 4, teamBIndex: 5 },
{ gameNumber: 4, teamAIndex: 1, teamBIndex: 6 },
{ gameNumber: 5, teamAIndex: 5, teamBIndex: 6 },
{ gameNumber: 6, teamAIndex: 4, teamBIndex: 6 },
{ gameNumber: 7, teamAIndex: 2, teamBIndex: 6 },
{ gameNumber: 8, teamAIndex: 3, teamBIndex: 5 },
{ gameNumber: 9, teamAIndex: 2, teamBIndex: 3 },
{ gameNumber: 10, teamAIndex: 1, teamBIndex: 4 },
{ gameNumber: 11, teamAIndex: 3, teamBIndex: 6 },
{ gameNumber: 12, teamAIndex: 1, teamBIndex: 3 },
{ gameNumber: 13, teamAIndex: 3, teamBIndex: 4 },
{ gameNumber: 14, teamAIndex: 1, teamBIndex: 5 },
{ gameNumber: 15, teamAIndex: 2, teamBIndex: 4 },
],
}),
);
expect(slots).toHaveLength(15);
expect(slots[0]).toEqual(
expect.objectContaining({
gameNumber: 1,
roundNumber: undefined,
teamAIndex: 2,
teamBIndex: 5,
}),
);
expect(slots.every((slot) => slot.roundNumber === undefined)).toBe(true);
});
it('does not expose fallback round-robin slots before the schedule is persisted', async () => { it('does not expose fallback round-robin slots before the schedule is persisted', async () => {
const service = createService(); const service = createService();
const slots = await service.buildSlots( const slots = await service.buildSlots(
@@ -189,3 +321,282 @@ describe('TournamentCodeService round-robin scheduling', () => {
expect(slots).toEqual([]); expect(slots).toEqual([]);
}); });
}); });
describe('TournamentCodeService bulk upload', () => {
it('preserves tournament code casing at the schema layer', async () => {
const connection = mongoose.createConnection();
try {
const TournamentCodeModel = connection.model(
'TournamentCodeCasingSpec',
TournamentCodeSchema,
);
const code = new TournamentCodeModel({
code: ' AbC-12345 ',
expiresAt: new Date(Date.now() + 60 * 60 * 1000),
uploadedBy: new mongoose.Types.ObjectId(),
});
expect(code.code).toBe('AbC-12345');
} finally {
await connection.close();
}
});
it('stores tournament codes with the exact casing from input', async () => {
const insertMany = jest.fn().mockResolvedValue(undefined);
const TournamentCodeModel = {
find: jest.fn().mockReturnValue({
select: jest.fn().mockReturnValue({
lean: jest.fn().mockReturnValue({
exec: jest.fn().mockResolvedValue([]),
}),
}),
}),
insertMany,
};
const connectionService = {
getModel: jest.fn().mockResolvedValue(TournamentCodeModel),
};
const service = new TournamentCodeService(
connectionService as never,
) as unknown as TournamentCodeServiceInternals;
service.attachPendingMatches = jest.fn().mockResolvedValue(0);
await service.bulkUpload({
communityId: new mongoose.Types.ObjectId(),
uploadedBy: new mongoose.Types.ObjectId(),
codes: [
{
code: ' AbC-12345 ',
expiresAt: new Date(Date.now() + 60 * 60 * 1000).toISOString(),
},
],
});
expect(insertMany).toHaveBeenCalledWith(
[
expect.objectContaining({
code: 'AbC-12345',
}),
],
{ ordered: false },
);
});
});
describe('TournamentCodeService pool stats', () => {
it('counts only available codes that are usable beyond the expiry margin', async () => {
const countDocuments = jest.fn().mockReturnValue({
exec: jest.fn().mockResolvedValue(12),
});
const connectionService = {
getModel: jest.fn().mockResolvedValue({ countDocuments }),
};
const service = new TournamentCodeService(connectionService as never);
await expect(service.countUsableAvailable()).resolves.toBe(12);
expect(countDocuments).toHaveBeenCalledWith({
state: 'available',
expiresAt: {
$gt: expect.any(Date),
},
});
});
});
describe('TournamentCodeService code replacement', () => {
function queryResult<T>(value: T) {
return { exec: jest.fn().mockResolvedValue(value) };
}
function createCode(overrides: Record<string, unknown>) {
return {
_id: new mongoose.Types.ObjectId(),
code: 'CODE',
state: 'reserved',
expiresAt: new Date(Date.now() + 60 * 60 * 1000),
matchId: new mongoose.Types.ObjectId(),
gameNumber: 1,
reservedAt: new Date(),
releasedAt: undefined,
riotMatchId: undefined,
save: jest.fn().mockResolvedValue(undefined),
...overrides,
};
}
function createReplacementFixture(params?: {
currentCode?: Record<string, unknown> | null;
replacementCode?: Record<string, unknown> | null;
match?: MatchDocument;
}) {
const communityId = new mongoose.Types.ObjectId();
const matchId = new mongoose.Types.ObjectId();
const oldCodeId = new mongoose.Types.ObjectId();
const newCodeId = new mongoose.Types.ObjectId();
const match =
params?.match ??
createMatch({
_id: matchId,
communityId,
status: 'in-progress',
gameCount: 1,
participants: Array.from({ length: 10 }, () => ({})),
teams: [{ teamIndex: 1 }, { teamIndex: 2 }],
tournamentCodeIds: [oldCodeId],
} as unknown as MatchOverrides);
const currentCode =
params?.currentCode === null
? null
: createCode({
_id: oldCodeId,
code: 'OLD-CODE',
matchId,
gameNumber: 1,
...(params?.currentCode ?? {}),
});
const replacementCode =
params?.replacementCode === null
? null
: createCode({
_id: newCodeId,
code: 'NEW-CODE',
matchId,
gameNumber: 1,
...(params?.replacementCode ?? {}),
});
const MatchModel = {
findOne: jest.fn().mockReturnValue(queryResult(match)),
};
const TournamentCodeModel = {
findOne: jest.fn().mockReturnValue(queryResult(currentCode)),
findOneAndUpdate: jest.fn().mockReturnValue(queryResult(replacementCode)),
};
const connectionService = {
getModel: jest.fn().mockImplementation((modelName: string) => {
if (modelName === 'match') return Promise.resolve(MatchModel);
if (modelName === 'tournamentCode') {
return Promise.resolve(TournamentCodeModel);
}
throw new Error(`Unexpected model: ${modelName}`);
}),
};
const service = new TournamentCodeService(
connectionService as never,
) as unknown as TournamentCodeServiceInternals;
return {
match,
communityId,
matchId,
currentCode,
replacementCode,
MatchModel,
TournamentCodeModel,
service,
};
}
it('replaces a reserved code on the same game slot', async () => {
const {
match,
communityId,
matchId,
currentCode,
replacementCode,
MatchModel,
TournamentCodeModel,
service,
} = createReplacementFixture();
const slot = await service.replaceForMatchGame({
communityId,
matchId,
gameNumber: 1,
});
expect(slot).toEqual(
expect.objectContaining({
gameNumber: 1,
teamAIndex: 1,
teamBIndex: 2,
code: 'NEW-CODE',
state: 'reserved',
}),
);
expect(MatchModel.findOne).toHaveBeenCalledWith({
_id: matchId,
communityId,
});
expect(TournamentCodeModel.findOneAndUpdate).toHaveBeenCalledWith(
expect.objectContaining({
state: 'available',
region: 'kr',
mapType: 'SUMMONERS_RIFT',
teamSize: 5,
}),
expect.objectContaining({
$set: expect.objectContaining({
state: 'reserved',
matchId,
gameNumber: 1,
}),
}),
expect.objectContaining({ returnDocument: 'after' }),
);
expect(currentCode?.state).toBe('released');
expect(currentCode?.matchId).toBeUndefined();
expect(currentCode?.gameNumber).toBeUndefined();
expect(currentCode?.save).toHaveBeenCalled();
expect(match.tournamentCodeIds.map((id) => id.toString())).toEqual([
replacementCode?._id.toString(),
]);
expect(match.save).toHaveBeenCalled();
});
it('rejects replacement after the game result is collected', async () => {
const matchId = new mongoose.Types.ObjectId();
const communityId = new mongoose.Types.ObjectId();
const fixture = createReplacementFixture({
match: createMatch({
_id: matchId,
communityId,
status: 'in-progress',
gameCount: 1,
participants: Array.from({ length: 10 }, () => ({})),
teams: [{ teamIndex: 1 }, { teamIndex: 2 }],
tournamentCodeIds: [new mongoose.Types.ObjectId()],
result: {
riotMatchIds: ['KR_1'],
games: [{ gameNumber: 1 }],
seriesResults: [],
},
} as unknown as MatchOverrides),
});
await expect(
fixture.service.replaceForMatchGame({
communityId,
matchId,
gameNumber: 1,
}),
).rejects.toThrow('already has a collected result');
expect(fixture.TournamentCodeModel.findOne).not.toHaveBeenCalled();
expect(fixture.TournamentCodeModel.findOneAndUpdate).not.toHaveBeenCalled();
});
it('leaves the current code untouched when no replacement code is available', async () => {
const { match, communityId, matchId, currentCode, service } =
createReplacementFixture({
replacementCode: null,
});
await expect(
service.replaceForMatchGame({ communityId, matchId, gameNumber: 1 }),
).rejects.toThrow('No available tournament code');
expect(currentCode?.save).not.toHaveBeenCalled();
expect(match.save).not.toHaveBeenCalled();
});
});
@@ -25,10 +25,8 @@ import type {
TournamentCodeUploadItem, TournamentCodeUploadItem,
} from './tournament-code.types'; } from './tournament-code.types';
import { import {
roundRobinGameSchedule,
resolveRoundRobinTeamCount, resolveRoundRobinTeamCount,
roundRobinPairCount,
roundRobinPairs,
shuffleInPlace,
} from './round-robin.util'; } from './round-robin.util';
const DEFAULT_REGION = 'kr'; const DEFAULT_REGION = 'kr';
@@ -39,7 +37,7 @@ export class TournamentCodeService {
constructor(private readonly connectionService: ConnectionService) {} constructor(private readonly connectionService: ConnectionService) {}
public async bulkUpload(params: { public async bulkUpload(params: {
communityId: mongoose.Types.ObjectId; communityId?: mongoose.Types.ObjectId;
uploadedBy: mongoose.Types.ObjectId; uploadedBy: mongoose.Types.ObjectId;
codes: TournamentCodeUploadItem[]; codes: TournamentCodeUploadItem[];
}): Promise<BulkUploadTournamentCodesResponse> { }): Promise<BulkUploadTournamentCodesResponse> {
@@ -123,6 +121,17 @@ export class TournamentCodeService {
}; };
} }
public async countUsableAvailable(): Promise<number> {
const TournamentCodeModel =
await this.connectionService.getModel('tournamentCode');
return TournamentCodeModel.countDocuments({
state: 'available',
expiresAt: {
$gt: new Date(Date.now() + TOURNAMENT_CODE_EXPIRY_MARGIN_MS),
},
}).exec();
}
public async list(params: { public async list(params: {
state?: TournamentCodeState; state?: TournamentCodeState;
limit?: number; limit?: number;
@@ -275,6 +284,111 @@ export class TournamentCodeService {
return match; return match;
} }
public async replaceForMatchGame(params: {
communityId: mongoose.Types.ObjectId;
matchId: mongoose.Types.ObjectId;
gameNumber: number;
}): Promise<TournamentCodeSlotView> {
const MatchModel = await this.connectionService.getModel('match');
const TournamentCodeModel =
await this.connectionService.getModel('tournamentCode');
const match = await MatchModel.findOne({
_id: params.matchId,
communityId: params.communityId,
}).exec();
if (!match) throw new NotFoundException('Match not found.');
if (match.status !== 'team-built' && match.status !== 'in-progress') {
throw new BadRequestException(
'Tournament codes can only be replaced while the match is ready or in progress.',
);
}
match.gameCount = match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT;
match.tournamentCodeIds = match.tournamentCodeIds ?? [];
this.ensureGameSchedule(match);
const requiredSlots = this.resolveRequiredSlots(match);
if (
!Number.isInteger(params.gameNumber) ||
params.gameNumber < 1 ||
params.gameNumber > requiredSlots
) {
throw new BadRequestException('Invalid tournament code game number.');
}
if (
(match.result?.games ?? []).some(
(game) => game.gameNumber === params.gameNumber,
)
) {
throw new BadRequestException(
'This game already has a collected result and cannot be replaced.',
);
}
const currentCode = await TournamentCodeModel.findOne({
_id: { $in: match.tournamentCodeIds },
matchId: match._id,
gameNumber: params.gameNumber,
}).exec();
if (!currentCode) {
throw new NotFoundException('Assigned tournament code not found.');
}
if (currentCode.state === 'used' || currentCode.riotMatchId) {
throw new BadRequestException('Used tournament codes cannot be replaced.');
}
const expiresAfter = new Date(Date.now() + TOURNAMENT_CODE_EXPIRY_MARGIN_MS);
const replacement = await TournamentCodeModel.findOneAndUpdate(
{
state: 'available',
region: DEFAULT_REGION,
mapType: 'SUMMONERS_RIFT',
teamSize: 5,
expiresAt: { $gt: expiresAfter },
},
{
$set: {
state: 'reserved',
matchId: match._id,
gameNumber: params.gameNumber,
reservedAt: new Date(),
},
$unset: { releasedAt: 1 },
},
{ sort: { expiresAt: 1 }, returnDocument: 'after' },
).exec();
if (!replacement) {
throw new BadRequestException('No available tournament code to replace with.');
}
currentCode.state = 'released';
currentCode.matchId = undefined;
currentCode.gameNumber = undefined;
currentCode.reservedAt = undefined;
currentCode.releasedAt = new Date();
currentCode.riotMatchId = undefined;
match.tournamentCodeIds = this.replaceTournamentCodeId(
match.tournamentCodeIds,
currentCode._id,
replacement._id,
);
await currentCode.save();
await match.save();
return {
gameNumber: params.gameNumber,
roundNumber: this.resolveRoundNumberForGameNumber(
match,
params.gameNumber,
),
...this.resolveSeriesRefForGameNumber(match, params.gameNumber),
code: replacement.code,
expiresAt: replacement.expiresAt.toISOString(),
state: replacement.state,
riotMatchId: replacement.riotMatchId ?? null,
};
}
public async releaseFromMatch( public async releaseFromMatch(
matchOrId: MatchDocument | mongoose.Types.ObjectId, matchOrId: MatchDocument | mongoose.Types.ObjectId,
): Promise<void> { ): Promise<void> {
@@ -368,6 +482,7 @@ export class TournamentCodeService {
const seriesRef = this.resolveSeriesRefForGameNumber(match, gameNumber); const seriesRef = this.resolveSeriesRefForGameNumber(match, gameNumber);
return { return {
gameNumber, gameNumber,
roundNumber: this.resolveRoundNumberForGameNumber(match, gameNumber),
...seriesRef, ...seriesRef,
code: null, code: null,
expiresAt: null, expiresAt: null,
@@ -377,6 +492,7 @@ export class TournamentCodeService {
} }
return { return {
gameNumber, gameNumber,
roundNumber: this.resolveRoundNumberForGameNumber(match, gameNumber),
...this.resolveSeriesRefForGameNumber(match, gameNumber), ...this.resolveSeriesRefForGameNumber(match, gameNumber),
code: code.code, code: code.code,
expiresAt: code.expiresAt.toISOString(), expiresAt: code.expiresAt.toISOString(),
@@ -387,7 +503,22 @@ export class TournamentCodeService {
} }
private normalizeCode(code: string | undefined): string { private normalizeCode(code: string | undefined): string {
return (code ?? '').trim().toUpperCase(); return (code ?? '').trim();
}
private replaceTournamentCodeId(
currentIds: mongoose.Types.ObjectId[],
oldId: mongoose.Types.ObjectId,
newId: mongoose.Types.ObjectId,
): mongoose.Types.ObjectId[] {
let replaced = false;
const next = currentIds.map((id) => {
if (id.toString() !== oldId.toString()) return id;
replaced = true;
return newId;
});
if (!replaced) next.push(newId);
return next;
} }
private resolveRequiredSlots(match: MatchDocument): number { private resolveRequiredSlots(match: MatchDocument): number {
@@ -395,8 +526,10 @@ export class TournamentCodeService {
const gameMode = match.gameMode ?? 'pair'; const gameMode = match.gameMode ?? 'pair';
if (gameMode === 'round-robin') { if (gameMode === 'round-robin') {
const teamCount = resolveRoundRobinTeamCount(match); if ((match.gameSchedule?.length ?? 0) > 0) {
return roundRobinPairCount(teamCount) * gameCount; return match.gameSchedule.length;
}
return this.buildRoundRobinGameSchedule(match).length;
} }
const teamCount = (match.teams ?? []).length; const teamCount = (match.teams ?? []).length;
@@ -426,13 +559,18 @@ export class TournamentCodeService {
}; };
} }
const teamCount = resolveRoundRobinTeamCount(match); const fallback = this.buildRoundRobinGameSchedule(match).find(
const perSeries = match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT; (entry) => entry.gameNumber === gameNumber,
const pairIndex = Math.max(0, Math.ceil(gameNumber / perSeries) - 1); );
return roundRobinPairs(teamCount)[pairIndex] ?? { return fallback
teamAIndex: 1, ? {
teamBIndex: 2, teamAIndex: fallback.teamAIndex,
}; teamBIndex: fallback.teamBIndex,
}
: {
teamAIndex: 1,
teamBIndex: 2,
};
} }
const perSeries = match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT; const perSeries = match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT;
@@ -450,21 +588,33 @@ export class TournamentCodeService {
const teamCount = resolveRoundRobinTeamCount(match); const teamCount = resolveRoundRobinTeamCount(match);
if (teamCount < 2) return; if (teamCount < 2) return;
const gameCount = match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT; match.gameSchedule = this.buildRoundRobinGameSchedule(match);
const pairs = shuffleInPlace([...roundRobinPairs(teamCount)]); }
const schedule: MatchGameAssignment[] = [];
for (let pairIndex = 0; pairIndex < pairs.length; pairIndex += 1) { private resolveRoundNumberForGameNumber(
const pair = pairs[pairIndex]; match: MatchDocument,
for (let gameIndex = 0; gameIndex < gameCount; gameIndex += 1) { gameNumber: number,
schedule.push({ ): number | undefined {
gameNumber: pairIndex * gameCount + gameIndex + 1, if ((match.gameMode ?? 'pair') !== 'round-robin') return undefined;
teamAIndex: pair.teamAIndex,
teamBIndex: pair.teamBIndex,
});
}
}
match.gameSchedule = schedule; const persisted = match.gameSchedule?.find(
(entry) => entry.gameNumber === gameNumber,
);
if (persisted) return persisted.roundNumber;
return this.buildRoundRobinGameSchedule(match).find(
(entry) => entry.gameNumber === gameNumber,
)?.roundNumber;
}
private buildRoundRobinGameSchedule(
match: MatchDocument,
shuffleTeams = false,
): MatchGameAssignment[] {
return roundRobinGameSchedule(resolveRoundRobinTeamCount(match), {
gamesPerPair: match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT,
maxRounds: match.roundRobinMaxRounds,
shuffleTeams,
});
} }
} }
@@ -24,6 +24,7 @@ export interface BulkUploadTournamentCodesResponse {
export interface TournamentCodeSlotView { export interface TournamentCodeSlotView {
gameNumber: number; gameNumber: number;
roundNumber?: number;
teamAIndex: number; teamAIndex: number;
teamBIndex: number; teamBIndex: number;
code: string | null; code: string | null;
Loaded 100 of 122 files, more files were not shown because too many files have changed in this diff. Show more