Compare commits

..
1 Commits
Author SHA1 Message Date
dahyeon 2004ea03fe chore(web): update staging environment config 2026-07-19 01:07:02 -07:00
211 changed files with 10584 additions and 8659 deletions

No files matched your search

-1
View File
@@ -30,7 +30,6 @@ website/LICENSE
!docs/plans/internal-match-game-analysis-p0-p1.md !docs/plans/internal-match-game-analysis-p0-p1.md
!docs/specs/double-elimination-connector-routing.md !docs/specs/double-elimination-connector-routing.md
!docs/plans/double-elimination-connector-routing.md !docs/plans/double-elimination-connector-routing.md
!docs/plans/redis-8.10-optimization.md
!agents/**/*.md !agents/**/*.md
!skills/**/*.md !skills/**/*.md
/tmp/ /tmp/
-1
View File
@@ -1 +0,0 @@
26
+2 -2
View File
@@ -1,11 +1,11 @@
# syntax=docker/dockerfile:1.7 # syntax=docker/dockerfile:1.7
FROM node:26-bookworm-slim AS pnpm-base FROM node:24-bookworm-slim AS pnpm-base
ENV PNPM_HOME=/pnpm ENV PNPM_HOME=/pnpm
ENV PATH="${PNPM_HOME}:${PATH}" ENV PATH="${PNPM_HOME}:${PATH}"
RUN npm install --global pnpm@10.4.1 RUN corepack enable
WORKDIR /app WORKDIR /app
+5 -21
View File
@@ -94,8 +94,9 @@ LOLYMPUS는 이 반복 작업을 줄이는 데 초점을 맞췄습니다. 운영
- TypeScript - TypeScript
- TanStack Query - TanStack Query
- NestJS - NestJS
- MongoDB 8.3 - MongoDB
- Redis 8.10 (일반 캐시/스트림과 경매 실시간 상태 공유) - Redis
- Redis 8.4 (경매 실시간 상태 전용)
- NATS - NATS
- Riot API - Riot API
- pnpm workspace - pnpm workspace
@@ -117,9 +118,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 8.3, Redis 8.10, NATS 실행 환경 - MongoDB 7.0, 일반 캐시/스트림용 Redis, 경매 실시간 상태 전용 Redis 8.4, NATS 실행 환경
일반 캐시/스트림, 경매 실시간 상태, WebSocket Pub/Sub는 `GARNET_ENDPOINT`로 지정한 하나의 Redis 인스턴스를 공유합니다. 값은 `host:port`, `redis://...`, `rediss://...` 형식을 지원합니다. 인증이 필요하면 기존 `GARNET_USERID`(또는 `GARNET_USERNAME`)와 `GARNET_PASSWORD`를 설정합니다. `REDIS_*`, `AUCTION_REDIS_*`, `GARNET_URL` 연결 설정은 사용하지 않습니다. 경매 점검 스크립트도 같은 설정을 사용합니다. 경매 Redis는 라이브 경매 상태의 source of truth로 사용되므로 일반 캐시/스트림 Redis와 물리적으로 분리해야 합니다. API는 `REDIS_URL`/`REDIS_ENDPOINT`와 별도로 `AUCTION_REDIS_URL`/`AUCTION_REDIS_ENDPOINT`를 읽고, 두 값이 같은 호스트/포트를 가리키면 부팅을 거부합니다.
## 실행 방법 ## 실행 방법
@@ -131,21 +132,6 @@ pnpm start:web:dev
웹 앱은 기본적으로 `apps/web/.env.development` 값을 사용합니다. API 환경값은 `apps/project.env`와 실행 환경의 시크릿 설정을 함께 확인합니다. 웹 앱은 기본적으로 `apps/web/.env.development` 값을 사용합니다. API 환경값은 `apps/project.env`와 실행 환경의 시크릿 설정을 함께 확인합니다.
### Redis 변경 검증
Redis 8.10.x의 `XREADGROUP CLAIM`, `XACKDEL ACKED`, `DELEX`, `SET IFEQ`, `INCREX`, `HSETEX`를 사용합니다. 스트림의 대기 읽기는 별도 연결에서 실행하며, 처리되지 않은 작업은 길이 제한을 초과해도 보존합니다.
```bash
pnpm --filter api test -- --runInBand
pnpm --filter api typecheck
pnpm --filter api test:redis
pnpm --filter api build
```
`test:redis`는 PATH의 `redis-server` 또는 `REDIS_TEST_SERVER`에 지정한 실행 파일로 Redis 8.10.x를 직접 실행합니다. 임의의 로컬 포트와 일회용 암호를 사용하고, 저장을 비활성화하며, 종료 후 프로세스와 임시 디렉터리를 정리합니다. 애플리케이션 Redis 연결 설정은 사용하지 않습니다. Windows에서는 PowerShell에서 `$env:REDIS_TEST_SERVER = 'C:\tools\redis\redis-server.exe'`처럼 지정할 수 있습니다.
커뮤니티 통계 캐시는 `riot:communitystats:v2:{communityId}:scope` Hash로 전환됩니다. 항목별 TTL은 일반 5분, 완성된 상세 24시간, 미완성 상세 60초를 유지합니다. 이전 String 캐시는 기존 TTL로 만료되며 새 캐시는 첫 조회에 생성됩니다. 구버전과 신버전은 무효화 대상이 다르므로 API 인스턴스를 같은 버전으로 함께 전환해야 합니다. 구현 범위와 검증 기록은 [Redis 변경 계획](docs/plans/redis-8.10-optimization.md)을 참고하세요.
### API New Relic APM ### API New Relic APM
API 서버는 `newrelic` Node.js agent를 앱 코드보다 먼저 preload합니다. Docker 런타임과 `pnpm start:api:*` 스크립트 모두 `NEW_RELIC_HOME`을 API 패키지로 지정해 `apps/api/newrelic.cjs` 설정을 읽습니다. API 서버는 `newrelic` Node.js agent를 앱 코드보다 먼저 preload합니다. Docker 런타임과 `pnpm start:api:*` 스크립트 모두 `NEW_RELIC_HOME`을 API 패키지로 지정해 `apps/api/newrelic.cjs` 설정을 읽습니다.
@@ -178,8 +164,6 @@ API 성능 계측은 기본 비활성화이며 필요할 때 `API_PERF_OBSERVABI
| `pnpm start:web:dev` | 웹 앱 개발 서버 실행 | | `pnpm start:web:dev` | 웹 앱 개발 서버 실행 |
| `pnpm start:api:dev` | API 서버 dev 환경 실행 | | `pnpm start:api:dev` | API 서버 dev 환경 실행 |
| `pnpm --filter api test` | API 테스트 실행 | | `pnpm --filter api test` | API 테스트 실행 |
| `pnpm --filter api typecheck` | 테스트를 포함한 API 타입 검사 |
| `pnpm --filter api test:redis` | 격리된 Redis 8.10 통합 테스트 실행 |
| `pnpm --filter api perf:routes` | API 성능 리포트 대상 route 출력 | | `pnpm --filter api perf:routes` | API 성능 리포트 대상 route 출력 |
| `pnpm --filter api perf:report` | API 성능 리포트 생성 | | `pnpm --filter api perf:report` | API 성능 리포트 생성 |
| `pnpm --filter web build:staging` | 웹 staging 빌드 검증 | | `pnpm --filter web build:staging` | 웹 staging 빌드 검증 |
+1 -22
View File
@@ -29,28 +29,7 @@ export default tseslint.config(
'@typescript-eslint/no-explicit-any': 'off', '@typescript-eslint/no-explicit-any': 'off',
'@typescript-eslint/no-floating-promises': 'warn', '@typescript-eslint/no-floating-promises': 'warn',
'@typescript-eslint/no-unsafe-argument': 'warn', '@typescript-eslint/no-unsafe-argument': 'warn',
'prettier/prettier': ['error', { endOfLine: 'auto' }], "prettier/prettier": ["error", { endOfLine: "auto" }],
},
},
{
files: ['**/*.spec.ts', 'test/**/*.ts'],
rules: {
'@typescript-eslint/no-unsafe-assignment': 'off',
'@typescript-eslint/no-unsafe-call': 'off',
'@typescript-eslint/no-unsafe-member-access': 'off',
'@typescript-eslint/no-unsafe-return': 'off',
'@typescript-eslint/no-this-alias': 'off',
'@typescript-eslint/require-await': 'off',
'@typescript-eslint/unbound-method': 'off',
},
},
{
files: ['src/modules/global/database/migrations/**/*.ts'],
rules: {
'@typescript-eslint/no-unsafe-assignment': 'off',
'@typescript-eslint/no-unsafe-call': 'off',
'@typescript-eslint/no-unsafe-member-access': 'off',
'@typescript-eslint/no-unsafe-return': 'off',
}, },
}, },
); );
+9 -11
View File
@@ -22,8 +22,6 @@
"start:debug": "nest start --debug --watch", "start:debug": "nest start --debug --watch",
"lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix", "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
"test": "jest", "test": "jest",
"typecheck": "tsc --noEmit --incremental false",
"test:redis": "node test/run-redis-tests.mjs",
"test:watch": "jest --watch", "test:watch": "jest --watch",
"test:cov": "jest --coverage", "test:cov": "jest --coverage",
"test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand", "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
@@ -31,20 +29,20 @@
}, },
"dependencies": { "dependencies": {
"@lolympus/contracts": "workspace:*", "@lolympus/contracts": "workspace:*",
"@nestjs/common": "^11.1.28", "@nestjs/common": "^11.0.1",
"@nestjs/config": "^4.0.4", "@nestjs/config": "^4.0.4",
"@nestjs/core": "^11.1.28", "@nestjs/core": "^11.0.1",
"@nestjs/platform-express": "^11.1.28", "@nestjs/platform-express": "^11.0.1",
"@nestjs/platform-socket.io": "^11.1.28", "@nestjs/platform-socket.io": "^11.1.19",
"@nestjs/swagger": "^11.4.6", "@nestjs/swagger": "^11.2.7",
"@nestjs/websockets": "^11.1.28", "@nestjs/websockets": "^11.1.19",
"@socket.io/redis-adapter": "^8.3.0", "@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",
"mongoose": "9.4.1", "mongoose": "^9.4.1",
"nats": "^2.29.3", "nats": "^2.29.3",
"newrelic": "^14.3.3", "newrelic": "^14.1.2",
"redis": "^5.12.1", "redis": "^5.12.1",
"reflect-metadata": "^0.2.2", "reflect-metadata": "^0.2.2",
"rxjs": "^7.8.1", "rxjs": "^7.8.1",
@@ -59,7 +57,7 @@
"@nestjs/testing": "^11.0.1", "@nestjs/testing": "^11.0.1",
"@types/express": "^5.0.0", "@types/express": "^5.0.0",
"@types/jest": "^30.0.0", "@types/jest": "^30.0.0",
"@types/node": "^26.1.1", "@types/node": "^24.0.0",
"@types/supertest": "^7.0.0", "@types/supertest": "^7.0.0",
"eslint": "^9.18.0", "eslint": "^9.18.0",
"eslint-config-prettier": "^10.0.1", "eslint-config-prettier": "^10.0.1",
@@ -79,9 +79,7 @@ describe('AuctionDeadlineScheduler', () => {
.spyOn(scheduler, 'processDueBidRoundDeadlines') .spyOn(scheduler, 'processDueBidRoundDeadlines')
.mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 }); .mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 });
await ( await (scheduler as unknown as { safeTick: () => Promise<void> }).safeTick();
scheduler as unknown as { safeTick: () => Promise<void> }
).safeTick();
const leaderLockToken = redis.acquireTokenLock.mock.calls[0]?.[1]; const leaderLockToken = redis.acquireTokenLock.mock.calls[0]?.[1];
expect(redis.acquireTokenLock).toHaveBeenCalledWith( expect(redis.acquireTokenLock).toHaveBeenCalledWith(
@@ -102,9 +100,7 @@ describe('AuctionDeadlineScheduler', () => {
.spyOn(scheduler, 'processDueBidRoundDeadlines') .spyOn(scheduler, 'processDueBidRoundDeadlines')
.mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 }); .mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 });
await ( await (scheduler as unknown as { safeTick: () => Promise<void> }).safeTick();
scheduler as unknown as { safeTick: () => Promise<void> }
).safeTick();
expect(processDueBidRoundDeadlinesSpy).not.toHaveBeenCalled(); expect(processDueBidRoundDeadlinesSpy).not.toHaveBeenCalled();
expect(redis.releaseTokenLock).not.toHaveBeenCalled(); expect(redis.releaseTokenLock).not.toHaveBeenCalled();
@@ -133,12 +129,10 @@ describe('AuctionDeadlineScheduler', () => {
it('prepares and completes due auction deadlines', async () => { it('prepares and completes due auction deadlines', async () => {
const matchId = '665f2f01f1f1f1f1f1f1f1f1'; const matchId = '665f2f01f1f1f1f1f1f1f1f1';
const completedState = { phase: 'passed', revision: 3 }; const completedState = { phase: 'passed', revision: 3 };
const { auctionService, eventBus, redisCommand, scheduler } = makeScheduler( const { auctionService, eventBus, redisCommand, scheduler } = makeScheduler({
{ dueReply: [matchId],
dueReply: [matchId], completedState,
completedState, });
},
);
await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({ await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({
completed: 1, completed: 1,
@@ -155,10 +149,7 @@ describe('AuctionDeadlineScheduler', () => {
expect(auctionService.completePreparedExpiry).toHaveBeenCalledTimes(1); expect(auctionService.completePreparedExpiry).toHaveBeenCalledTimes(1);
// 만료 확정 결과는 즉시 1차 broadcast돼야 한다(클라가 입찰 라운드에 멈춰 // 만료 확정 결과는 즉시 1차 broadcast돼야 한다(클라가 입찰 라운드에 멈춰
// 후속 액션에서 CONFLICT가 반복되는 것을 막는 핵심 동작). // 후속 액션에서 CONFLICT가 반복되는 것을 막는 핵심 동작).
expect(eventBus.broadcastState).toHaveBeenCalledWith( expect(eventBus.broadcastState).toHaveBeenCalledWith(matchId, completedState);
matchId,
completedState,
);
}); });
it('skips noop expiry preparations', async () => { it('skips noop expiry preparations', async () => {
@@ -198,7 +189,10 @@ describe('AuctionDeadlineScheduler', () => {
}); });
it('continues processing later deadline items after one item fails', async () => { it('continues processing later deadline items after one item fails', async () => {
const matchIds = ['665f2f01f1f1f1f1f1f1f1f1', '665f2f02f1f1f1f1f1f1f1f1']; const matchIds = [
'665f2f01f1f1f1f1f1f1f1f1',
'665f2f02f1f1f1f1f1f1f1f1',
];
const { auctionService, redisCommand, scheduler } = makeScheduler({ const { auctionService, redisCommand, scheduler } = makeScheduler({
dueReply: matchIds, dueReply: matchIds,
}); });
@@ -101,17 +101,15 @@ export class AuctionDeadlineScheduler implements OnModuleInit, OnModuleDestroy {
currentRedisTimestampMS: number, currentRedisTimestampMS: number,
batchLimit: number, batchLimit: number,
): Promise<string[]> { ): Promise<string[]> {
const reply = await this.auctionRedisService const reply = await this.auctionRedisService.raw().sendCommand([
.raw() 'ZRANGEBYSCORE',
.sendCommand([ BID_ROUND_DEADLINE_QUEUE_KEY,
'ZRANGEBYSCORE', '-inf',
BID_ROUND_DEADLINE_QUEUE_KEY, String(currentRedisTimestampMS),
'-inf', 'LIMIT',
String(currentRedisTimestampMS), '0',
'LIMIT', String(batchLimit),
'0', ]);
String(batchLimit),
]);
return Array.isArray(reply) ? reply.map(String) : []; return Array.isArray(reply) ? reply.map(String) : [];
} }
@@ -179,11 +177,11 @@ export class AuctionDeadlineScheduler implements OnModuleInit, OnModuleDestroy {
return { completed, prepared, skipped }; return { completed, prepared, skipped };
} }
private async removeBidRoundDeadlineQueueEntry( private async removeBidRoundDeadlineQueueEntry(matchId: string): Promise<void> {
matchId: string, await this.auctionRedisService.raw().sendCommand([
): Promise<void> { 'ZREM',
await this.auctionRedisService BID_ROUND_DEADLINE_QUEUE_KEY,
.raw() matchId,
.sendCommand(['ZREM', BID_ROUND_DEADLINE_QUEUE_KEY, matchId]); ]);
} }
} }
@@ -20,8 +20,9 @@ export class AuctionEventBusService {
} }
public broadcastState(matchId: string, state: AuctionStateResponse): void { public broadcastState(matchId: string, state: AuctionStateResponse): void {
this.auctionNamespace this.auctionNamespace?.to(matchId).emit(
?.to(matchId) 'state',
.emit('state', serializeRealtimeAuction(state)); serializeRealtimeAuction(state),
);
} }
} }
@@ -74,11 +74,13 @@ function serializeRealtimeAuctionPlayer(
return player; return player;
} }
const lightweightPlayer = { ...player }; const {
delete lightweightPlayer.masteries; masteries: _masteries,
delete lightweightPlayer.puuid; puuid: _puuid,
delete lightweightPlayer.recentStatsSummary; recentStatsSummary: _recentStatsSummary,
delete lightweightPlayer.tierHistory; tierHistory: _tierHistory,
...lightweightPlayer
} = player;
return lightweightPlayer; return lightweightPlayer;
} }
@@ -5,15 +5,6 @@ import {
} from './auction-rejection'; } from './auction-rejection';
describe('resolveAuctionRejectionReason', () => { describe('resolveAuctionRejectionReason', () => {
it('reports roster validation failures without recommending a retry', () => {
const reason = resolveAuctionRejectionReason(
'AUCTION_ROSTER_INVALID',
'Auction roster validation failed.',
);
expect(reason).toBe('AUCTION_TRANSITION_REJECTED_BECAUSE_ROSTER_INVALID');
expect(isAuctionResyncRecommended(reason)).toBe(false);
});
it('maps the internal CONFLICT code to the descriptive transition reason', () => { it('maps the internal CONFLICT code to the descriptive transition reason', () => {
expect(resolveAuctionRejectionReason('CONFLICT')).toBe( expect(resolveAuctionRejectionReason('CONFLICT')).toBe(
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY, AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY,
@@ -31,10 +22,7 @@ describe('resolveAuctionRejectionReason', () => {
it('maps known BadRequest messages without a structured code', () => { it('maps known BadRequest messages without a structured code', () => {
expect( expect(
resolveAuctionRejectionReason( resolveAuctionRejectionReason(undefined, 'Cannot advance from current phase.'),
undefined,
'Cannot advance from current phase.',
),
).toBe( ).toBe(
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE, AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE,
); );
@@ -16,7 +16,7 @@
* resync 권장 여부: * resync 권장 여부:
* - `AUCTION_RESYNC_RECOMMENDED_REASONS`에 속한 reason은 "클라가 본 상태가 이미 * - `AUCTION_RESYNC_RECOMMENDED_REASONS`에 속한 reason은 "클라가 본 상태가 이미
* 바뀌었다(낙관적 동시성 충돌/만료/단계 전이)"는 신호다. 이 경우 클라는 최신 * 바뀌었다(낙관적 동시성 충돌/만료/단계 전이)"는 신호다. 이 경우 클라는 최신
* state로 rebaseline한다. 구조 액션 재시도는 원래 대상과 단계가 같을 때만 허용한다. * state로 rebaseline한 뒤 (구조 액션이라면) 1회 재시도하는 것이 안전하다.
* - 반대로 정원 초과/포인트 부족처럼 "상태를 새로고침해도 결과가 같은" 거부는 * - 반대로 정원 초과/포인트 부족처럼 "상태를 새로고침해도 결과가 같은" 거부는
* resync 권장 대상이 아니다(재시도해도 또 거부됨). * resync 권장 대상이 아니다(재시도해도 또 거부됨).
*/ */
@@ -29,12 +29,9 @@ export const AUCTION_REJECTION_REASON = {
/** 입찰 단계가 아닌데 입찰 단계 전환을 시도함(이미 sold/passed/presenting 등). */ /** 입찰 단계가 아닌데 입찰 단계 전환을 시도함(이미 sold/passed/presenting 등). */
AUCTION_TRANSITION_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE: AUCTION_TRANSITION_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE:
'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_PHASE_DOES_NOT_ALLOW_ADVANCE', 'AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE',
/** 원 참가자 명단과 실제 팀 배정이 일치하지 않아 완료할 수 없음. */
AUCTION_TRANSITION_REJECTED_BECAUSE_ROSTER_INVALID:
'AUCTION_TRANSITION_REJECTED_BECAUSE_ROSTER_INVALID',
/** 낙찰 처리할 유효한 최고 입찰이 없음(만료 처리로 이미 정리됐을 수 있음). */ /** 낙찰 처리할 유효한 최고 입찰이 없음(만료 처리로 이미 정리됐을 수 있음). */
AUCTION_TRANSITION_REJECTED_BECAUSE_NO_WINNING_BID_TO_MARK_SOLD: AUCTION_TRANSITION_REJECTED_BECAUSE_NO_WINNING_BID_TO_MARK_SOLD:
'AUCTION_TRANSITION_REJECTED_BECAUSE_NO_WINNING_BID_TO_MARK_SOLD', 'AUCTION_TRANSITION_REJECTED_BECAUSE_NO_WINNING_BID_TO_MARK_SOLD',
@@ -86,8 +83,6 @@ export type AuctionRejectionReason =
/** 내부 짧은 코드 → 설명적 reason. */ /** 내부 짧은 코드 → 설명적 reason. */
const INTERNAL_CODE_TO_REASON: Record<string, AuctionRejectionReason> = { const INTERNAL_CODE_TO_REASON: Record<string, AuctionRejectionReason> = {
AUCTION_ROSTER_INVALID:
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_ROSTER_INVALID,
CONFLICT: CONFLICT:
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY, AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY,
STALE_BID_ROUND: STALE_BID_ROUND:
@@ -41,24 +41,22 @@ export class AuctionSideEffectService {
matchSideEffectStatus: AuctionMatchSideEffectStatus; matchSideEffectStatus: AuctionMatchSideEffectStatus;
}): Promise<boolean> { }): Promise<boolean> {
const keys = buildAuctionRedisKeys(params.matchId); const keys = buildAuctionRedisKeys(params.matchId);
const result = await this.auctionRedisService const result = await this.auctionRedisService.raw().sendCommand([
.raw() 'EVAL',
.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')",
"if redis.call('HGET', KEYS[1], 'auctionLifecycleId') ~= ARGV[1] then return 0 end", 'local nextRevision = tonumber(ARGV[2])',
"local currentRevision = tonumber(redis.call('HGET', KEYS[1], 'matchSideEffectRevision') or '-1')", 'if currentRevision >= nextRevision then return 0 end',
'local nextRevision = tonumber(ARGV[2])', "redis.call('HSET', KEYS[1], 'matchSideEffectRevision', ARGV[2], 'matchSideEffectStatus', ARGV[3])",
'if currentRevision >= nextRevision then return 0 end', 'return 1',
"redis.call('HSET', KEYS[1], 'matchSideEffectRevision', ARGV[2], 'matchSideEffectStatus', ARGV[3])", ].join('\n'),
'return 1', '1',
].join('\n'), keys.liveStateKey,
'1', params.auctionLifecycleId,
keys.liveStateKey, String(params.matchSideEffectRevision),
params.auctionLifecycleId, params.matchSideEffectStatus,
String(params.matchSideEffectRevision), ]);
params.matchSideEffectStatus,
]);
return Number(result) === 1; return Number(result) === 1;
} }
} }
@@ -80,7 +78,8 @@ export function canAcquireSideEffectLease(
if (state.state === 'pending' || state.state === 'failed') return true; if (state.state === 'pending' || state.state === 'failed') return true;
if (state.state !== 'processing') return false; if (state.state !== 'processing') return false;
return ( return (
(state.processingLeaseExpiresAtTimestampMS ?? 0) <= currentRedisTimestampMS (state.processingLeaseExpiresAtTimestampMS ?? 0) <=
currentRedisTimestampMS
); );
} }
@@ -59,7 +59,8 @@ export class AuctionController {
initialTeamBidPointAmount: c.initialTeamBidPointAmount, initialTeamBidPointAmount: c.initialTeamBidPointAmount,
})), })),
initialTeamBidPointAmount: body.initialTeamBidPointAmount ?? 1000, initialTeamBidPointAmount: body.initialTeamBidPointAmount ?? 1000,
maximumBidRoundDurationSeconds: body.maximumBidRoundDurationSeconds ?? 30, maximumBidRoundDurationSeconds:
body.maximumBidRoundDurationSeconds ?? 30,
bidRoundExtensionSeconds: body.bidRoundExtensionSeconds ?? 5, bidRoundExtensionSeconds: body.bidRoundExtensionSeconds ?? 5,
topTierAuctionPriorityThreshold: topTierAuctionPriorityThreshold:
body.topTierAuctionPriorityThreshold ?? 'NONE', body.topTierAuctionPriorityThreshold ?? 'NONE',
+56 -96
View File
@@ -13,7 +13,7 @@ import {
} from '@nestjs/websockets'; } from '@nestjs/websockets';
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import type { JWTPayload } from 'jose'; import type { JWTPayload } from 'jose';
import type { DefaultEventsMap, Namespace, Socket } from 'socket.io'; import { Namespace, Socket } from 'socket.io';
import { AuthService } from '../auth/auth.service'; import { AuthService } from '../auth/auth.service';
import { IdentityService } from '../auth/identity.service'; import { IdentityService } from '../auth/identity.service';
import { JwtService } from '../auth/jwt.service'; import { JwtService } from '../auth/jwt.service';
@@ -78,20 +78,6 @@ interface BidRateLimitState {
windowStartedAtTimestampMS: number; windowStartedAtTimestampMS: number;
} }
interface AuctionSocketData {
auctionBidRateLimit?: BidRateLimitState;
identity?: IdentityDocument;
matchId?: string;
user?: UserDocument;
}
type AuctionSocket = Socket<
DefaultEventsMap,
DefaultEventsMap,
DefaultEventsMap,
AuctionSocketData
>;
const BID_RATE_LIMIT_WINDOW_MS = 1000; const BID_RATE_LIMIT_WINDOW_MS = 1000;
const BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW = 8; const BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW = 8;
const BID_RATE_LIMIT_REJECTION_CODE = 'BID_RATE_LIMITED'; const BID_RATE_LIMIT_REJECTION_CODE = 'BID_RATE_LIMITED';
@@ -106,7 +92,9 @@ const BID_RATE_LIMIT_REJECTION_MESSAGE =
allowedHeaders: ['Authorization', 'Content-Type', 'X-Auth-User-Id'], allowedHeaders: ['Authorization', 'Content-Type', 'X-Auth-User-Id'],
}, },
}) })
export class AuctionGateway implements OnGatewayConnection, OnGatewayInit { export class AuctionGateway
implements OnGatewayConnection, OnGatewayInit
{
@WebSocketServer() @WebSocketServer()
private server!: Namespace; private server!: Namespace;
@@ -126,14 +114,14 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
this.auctionEventBusService.attachAuctionNamespace(server); this.auctionEventBusService.attachAuctionNamespace(server);
} }
public async handleConnection(socket: AuctionSocket) { public async handleConnection(socket: Socket) {
try { try {
await this.authenticateSocket(socket); await this.authenticateSocket(socket);
this.logger.debug(`Auction client connected: ${socket.id}`); this.logger.debug(`Auction client connected: ${socket.id}`);
} catch (err) { } catch (err) {
this.logger.warn( this.logger.warn(
`Auction client authentication failed: ${ `Auction client authentication failed: ${
err instanceof Error ? err.message : String(err) err instanceof Error ? err.message : err
}`, }`,
); );
socket.disconnect(true); socket.disconnect(true);
@@ -142,7 +130,7 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
@SubscribeMessage('join') @SubscribeMessage('join')
public async handleJoin( public async handleJoin(
@ConnectedSocket() socket: AuctionSocket, @ConnectedSocket() socket: Socket,
@MessageBody() payload: JoinAuctionPayload, @MessageBody() payload: JoinAuctionPayload,
) { ) {
if (!payload?.matchId || !mongoose.isValidObjectId(payload.matchId)) { if (!payload?.matchId || !mongoose.isValidObjectId(payload.matchId)) {
@@ -170,7 +158,7 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
@SubscribeMessage('bid') @SubscribeMessage('bid')
public async handleBid( public async handleBid(
@ConnectedSocket() socket: AuctionSocket, @ConnectedSocket() socket: Socket,
@MessageBody() payload: BidPayload, @MessageBody() payload: BidPayload,
@Ack() ack?: (response: Record<string, unknown>) => void, @Ack() ack?: (response: Record<string, unknown>) => void,
) { ) {
@@ -217,9 +205,7 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
ack?.({ ack?.({
...(bidDelta ...(bidDelta
? {} ? {}
: { : { state: this.serializeAuction(bidResult as AuctionStateResponse) }),
state: this.serializeAuction(bidResult as AuctionStateResponse),
}),
ok: true, ok: true,
bidRequestId, bidRequestId,
bidDelta: broadcastBidDelta, bidDelta: broadcastBidDelta,
@@ -234,12 +220,7 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
error, error,
); );
const bidServerTiming = this.extractBidServerTiming(rejectionAckFields); const bidServerTiming = this.extractBidServerTiming(rejectionAckFields);
this.emitError( this.emitError(socket, String(rejectionAckFields.message ?? ''));
socket,
typeof rejectionAckFields.message === 'string'
? rejectionAckFields.message
: '',
);
ack?.({ ack?.({
...rejectionAckFields, ...rejectionAckFields,
bidRequestId, bidRequestId,
@@ -282,7 +263,7 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
@SubscribeMessage('open-bidding') @SubscribeMessage('open-bidding')
public async handleOpenBidding( public async handleOpenBidding(
@ConnectedSocket() socket: AuctionSocket, @ConnectedSocket() socket: Socket,
@MessageBody() payload: AuctionActionPayload, @MessageBody() payload: AuctionActionPayload,
@Ack() ack?: (response: Record<string, unknown>) => void, @Ack() ack?: (response: Record<string, unknown>) => void,
) { ) {
@@ -311,7 +292,7 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
@SubscribeMessage('sold') @SubscribeMessage('sold')
public async handleSold( public async handleSold(
@ConnectedSocket() socket: AuctionSocket, @ConnectedSocket() socket: Socket,
@MessageBody() payload: SoldPayload, @MessageBody() payload: SoldPayload,
@Ack() ack?: (response: Record<string, unknown>) => void, @Ack() ack?: (response: Record<string, unknown>) => void,
) { ) {
@@ -341,7 +322,7 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
@SubscribeMessage('next') @SubscribeMessage('next')
public async handleNext( public async handleNext(
@ConnectedSocket() socket: AuctionSocket, @ConnectedSocket() socket: Socket,
@MessageBody() payload: AuctionActionPayload, @MessageBody() payload: AuctionActionPayload,
@Ack() ack?: (response: Record<string, unknown>) => void, @Ack() ack?: (response: Record<string, unknown>) => void,
) { ) {
@@ -370,7 +351,7 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
@SubscribeMessage('passed') @SubscribeMessage('passed')
public async handlePassed( public async handlePassed(
@ConnectedSocket() socket: AuctionSocket, @ConnectedSocket() socket: Socket,
@MessageBody() payload: AuctionActionPayload, @MessageBody() payload: AuctionActionPayload,
@Ack() ack?: (response: Record<string, unknown>) => void, @Ack() ack?: (response: Record<string, unknown>) => void,
) { ) {
@@ -399,7 +380,7 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
@SubscribeMessage('chat-message') @SubscribeMessage('chat-message')
public async handleChatMessage( public async handleChatMessage(
@ConnectedSocket() socket: AuctionSocket, @ConnectedSocket() socket: Socket,
@MessageBody() payload: ChatMessagePayload, @MessageBody() payload: ChatMessagePayload,
) { ) {
const matchId = this.requireJoinedMatchId(socket); const matchId = this.requireJoinedMatchId(socket);
@@ -425,7 +406,7 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
} }
} }
private requireJoinedMatchId(socket: AuctionSocket): string | null { private requireJoinedMatchId(socket: Socket): string | null {
const matchId = this.getSocketMatchId(socket); const matchId = this.getSocketMatchId(socket);
if (!matchId) { if (!matchId) {
this.emitError(socket, 'Join a match room before sending events.'); this.emitError(socket, 'Join a match room before sending events.');
@@ -434,9 +415,10 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
return matchId; return matchId;
} }
private consumeBidRateLimit(socket: AuctionSocket): boolean { private consumeBidRateLimit(socket: Socket): boolean {
const currentTimestampMS = Date.now(); const currentTimestampMS = Date.now();
const previousState = socket.data.auctionBidRateLimit; const previousState = socket.data
.auctionBidRateLimit as BidRateLimitState | undefined;
if ( if (
!previousState || !previousState ||
currentTimestampMS - previousState.windowStartedAtTimestampMS >= currentTimestampMS - previousState.windowStartedAtTimestampMS >=
@@ -454,8 +436,10 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
return previousState.count <= BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW; return previousState.count <= BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW;
} }
private getSocketMatchId(socket: AuctionSocket): string | undefined { private getSocketMatchId(socket: Socket): string | undefined {
return socket.data.matchId; return typeof socket.data.matchId === 'string'
? socket.data.matchId
: undefined;
} }
private toAuctionActionRequest(payload?: AuctionActionPayload) { private toAuctionActionRequest(payload?: AuctionActionPayload) {
@@ -479,9 +463,8 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
}; };
} }
private readHandshakeUserId(socket: AuctionSocket): string | undefined { private readHandshakeUserId(socket: Socket): string | undefined {
const handshakeAuth = socket.handshake.auth as Record<string, unknown>; const authUserId = socket.handshake.auth['x-auth-user-id'];
const authUserId = handshakeAuth['x-auth-user-id'];
if (typeof authUserId === 'string') return authUserId; if (typeof authUserId === 'string') return authUserId;
const header = socket.handshake.headers['x-auth-user-id']; const header = socket.handshake.headers['x-auth-user-id'];
@@ -489,16 +472,16 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
} }
private resolveSocketUserId( private resolveSocketUserId(
socket: AuctionSocket, socket: Socket,
): mongoose.Types.ObjectId | undefined { ): mongoose.Types.ObjectId | undefined {
return socket.data.user?._id; return (socket.data.user as UserDocument | undefined)?._id;
} }
private resolveChatDisplayName( private resolveChatDisplayName(
socket: AuctionSocket, socket: Socket,
fallbackDisplayName?: string, fallbackDisplayName?: string,
): string { ): string {
const user = socket.data.user; const user = socket.data.user as UserDocument | undefined;
const primaryRiotAccount = const primaryRiotAccount =
user?.riotAccounts.find((entry) => entry.isPrimary) ?? user?.riotAccounts.find((entry) => entry.isPrimary) ??
user?.riotAccounts[0]; user?.riotAccounts[0];
@@ -511,14 +494,14 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
if (user?.kakaoTalkNickname) return user.kakaoTalkNickname; if (user?.kakaoTalkNickname) return user.kakaoTalkNickname;
if (user?.discordNickname) return user.discordNickname; if (user?.discordNickname) return user.discordNickname;
const identity = socket.data.identity; const identity = socket.data.identity as IdentityDocument | undefined;
if (identity?.displayName) return identity.displayName; if (identity?.displayName) return identity.displayName;
if (identity?.email) return identity.email; if (identity?.email) return identity.email;
return fallbackDisplayName ?? '관전자'; return fallbackDisplayName ?? '관전자';
} }
private async authenticateSocket(socket: AuctionSocket): Promise<void> { private async authenticateSocket(socket: Socket): Promise<void> {
const fallback = await this.authService.resolveDevUserById( const fallback = await this.authService.resolveDevUserById(
this.readHandshakeUserId(socket), this.readHandshakeUserId(socket),
); );
@@ -548,20 +531,14 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
}); });
} }
private readHandshakeToken(socket: AuctionSocket): string | undefined { private readHandshakeToken(socket: Socket): string | undefined {
const handshakeAuth = socket.handshake.auth as Record<string, unknown>; const authToken = socket.handshake.auth.token;
const authToken = handshakeAuth.token;
if (typeof authToken === 'string' && authToken.trim()) { if (typeof authToken === 'string' && authToken.trim()) {
return authToken.trim().replace(/^Bearer\s+/i, ''); return authToken.trim().replace(/^Bearer\s+/i, '');
} }
const header: unknown = socket.handshake.headers.authorization; const header = socket.handshake.headers.authorization;
const authorization = const authorization = Array.isArray(header) ? header[0] : header;
typeof header === 'string'
? header
: Array.isArray(header) && typeof header[0] === 'string'
? header[0]
: undefined;
if (authorization?.startsWith('Bearer ')) { if (authorization?.startsWith('Bearer ')) {
return authorization.slice('Bearer '.length).trim(); return authorization.slice('Bearer '.length).trim();
} }
@@ -569,11 +546,10 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
} }
private async resolveSocketUserForMatch( private async resolveSocketUserForMatch(
socket: AuctionSocket, socket: Socket,
matchId: string, matchId: string,
): Promise<void> { ): Promise<void> {
if (socket.data.user || !socket.data.identity) return; if (socket.data.user || !socket.data.identity) return;
const identity = socket.data.identity;
const MatchModel = await this.connectionService.getModel('match'); const MatchModel = await this.connectionService.getModel('match');
const match = await MatchModel.findById(matchId).select({ const match = await MatchModel.findById(matchId).select({
@@ -582,11 +558,10 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
if (!match) return; if (!match) return;
const UserModel = await this.connectionService.getModel('user'); const UserModel = await this.connectionService.getModel('user');
const user = await UserModel.findOne({ socket.data.user = await UserModel.findOne({
communityId: match.communityId, communityId: match.communityId,
identityId: identity._id, identityId: (socket.data.identity as IdentityDocument)._id,
}).exec(); }).exec();
socket.data.user = user ?? undefined;
} }
private requireStringClaim(payload: JWTPayload, key: string): string { private requireStringClaim(payload: JWTPayload, key: string): string {
@@ -620,7 +595,7 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
this.server.to(matchId).emit('match-side-effect', delta); this.server.to(matchId).emit('match-side-effect', delta);
} }
private emitChatHistory(socket: AuctionSocket, 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) =>
this.serializeChatMessage(message), this.serializeChatMessage(message),
@@ -628,21 +603,16 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
}); });
} }
private emitKnownError(socket: AuctionSocket, error: unknown) { private emitKnownError(socket: Socket, error: unknown) {
this.emitError(socket, this.resolveErrorPayload(error).message); this.emitError(socket, this.resolveErrorPayload(error).message);
} }
private emitError(socket: AuctionSocket, message: string) { private emitError(socket: Socket, message: string) {
socket.emit('error', { message }); socket.emit('error', { message });
} }
private serializeAuction( private serializeAuction(auction: AuctionStateResponse) {
auction: AuctionStateResponse, return JSON.parse(JSON.stringify(auction));
): Record<string, unknown> {
const serialized: unknown = JSON.parse(JSON.stringify(auction));
return typeof serialized === 'object' && serialized !== null
? (serialized as Record<string, unknown>)
: {};
} }
/** /**
@@ -663,9 +633,7 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
typeof errorPayload.code === 'string' ? errorPayload.code : undefined, typeof errorPayload.code === 'string' ? errorPayload.code : undefined,
errorPayload.message, errorPayload.message,
); );
const resyncRecommended = isAuctionResyncRecommended( const resyncRecommended = isAuctionResyncRecommended(auctionRejectionReason);
auctionRejectionReason,
);
const state = resyncRecommended const state = resyncRecommended
? await this.fetchSerializedAuctionState(matchId) ? await this.fetchSerializedAuctionState(matchId)
: undefined; : undefined;
@@ -720,9 +688,7 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
return { return {
code: error instanceof Error ? error.message : 'UNKNOWN', code: error instanceof Error ? error.message : 'UNKNOWN',
message: message:
error instanceof Error error instanceof Error ? error.message : 'Unexpected auction gateway error.',
? error.message
: 'Unexpected auction gateway error.',
}; };
} }
@@ -750,8 +716,7 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
bidDelta: Record<string, unknown> | null, bidDelta: Record<string, unknown> | null,
): Record<string, unknown> | null { ): Record<string, unknown> | null {
if (!bidDelta || !('bidServerTiming' in bidDelta)) return bidDelta; if (!bidDelta || !('bidServerTiming' in bidDelta)) return bidDelta;
const publicBidDelta = { ...bidDelta }; const { bidServerTiming: _bidServerTiming, ...publicBidDelta } = bidDelta;
delete publicBidDelta.bidServerTiming;
return publicBidDelta; return publicBidDelta;
} }
@@ -759,7 +724,7 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
auction: AuctionStateResponse, auction: AuctionStateResponse,
bidRequestId?: string, bidRequestId?: string,
): Record<string, unknown> | null { ): Record<string, unknown> | null {
const serialized = this.serializeAuction(auction); const serialized = this.serializeAuction(auction) as Record<string, unknown>;
const revision = Number(serialized.revision); const revision = Number(serialized.revision);
const currentHighestBidPointAmount = Number( const currentHighestBidPointAmount = Number(
serialized.currentHighestBidPointAmount ?? serialized.currentBid, serialized.currentHighestBidPointAmount ?? serialized.currentBid,
@@ -774,13 +739,11 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
? Date.parse(serialized.currentDeadline) ? Date.parse(serialized.currentDeadline)
: 0), : 0),
); );
const redisBidHistory: unknown[] = Array.isArray( const redisBidHistory = Array.isArray(serialized.auctionBidHistory)
serialized.auctionBidHistory, ? serialized.auctionBidHistory
)
? (serialized.auctionBidHistory as unknown[])
: []; : [];
const legacyBidHistory: unknown[] = Array.isArray(serialized.bids) const legacyBidHistory = Array.isArray(serialized.bids)
? (serialized.bids as unknown[]) ? serialized.bids
: []; : [];
const auctionBidHistoryEntry = const auctionBidHistoryEntry =
redisBidHistory[redisBidHistory.length - 1] ?? redisBidHistory[redisBidHistory.length - 1] ??
@@ -812,7 +775,9 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
}; };
} }
private isBidDeltaResponse(value: unknown): value is AuctionBidDeltaResponse { private isBidDeltaResponse(
value: unknown,
): value is AuctionBidDeltaResponse {
return ( return (
typeof value === 'object' && typeof value === 'object' &&
value !== null && value !== null &&
@@ -839,12 +804,7 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
}; };
} }
private serializeChatMessage( private serializeChatMessage(message: AuctionChatMessage) {
message: AuctionChatMessage, return JSON.parse(JSON.stringify(message));
): Record<string, unknown> {
const serialized: unknown = JSON.parse(JSON.stringify(message));
return typeof serialized === 'object' && serialized !== null
? (serialized as Record<string, unknown>)
: {};
} }
} }
@@ -2,30 +2,6 @@ import mongoose from 'mongoose';
import { AuctionService } from './auction.service'; import { AuctionService } from './auction.service';
describe('AuctionService', () => { describe('AuctionService', () => {
function requireRecord(
value: unknown,
label: string,
): Record<string, unknown> {
if (!value || typeof value !== 'object' || Array.isArray(value)) {
throw new Error(`${label} must be an object.`);
}
return value as Record<string, unknown>;
}
function requireArray(value: unknown, label: string): unknown[] {
if (!Array.isArray(value)) {
throw new Error(`${label} must be an array.`);
}
return value as unknown[];
}
function parseJsonRecord(value: unknown, label: string) {
if (typeof value !== 'string') {
throw new Error(`${label} must be a JSON string.`);
}
return requireRecord(JSON.parse(value) as unknown, label);
}
function createService(models: Record<string, unknown>) { function createService(models: Record<string, unknown>) {
const auctionHistoryModel = { const auctionHistoryModel = {
findOne: jest.fn().mockReturnValue({ findOne: jest.fn().mockReturnValue({
@@ -182,11 +158,12 @@ describe('AuctionService', () => {
it('rejects non-positive or fractional bid amounts before loading auction state', async () => { it('rejects non-positive or fractional bid amounts before loading auction state', async () => {
const matchId = new mongoose.Types.ObjectId(); const matchId = new mongoose.Types.ObjectId();
const auctionFindOne = jest.fn(); const auctionFindOne = jest.fn();
const { service, auctionRedisCommandService } = createService({ const { service, auctionRedisCommandService, auctionRedisService } =
auction: { createService({
findOne: auctionFindOne, auction: {
}, findOne: auctionFindOne,
}); },
});
await expect( await expect(
service.placeBid({ service.placeBid({
@@ -1031,12 +1008,7 @@ describe('AuctionService', () => {
); );
const transitionInput = const transitionInput =
auctionRedisCommandService.applyTransition.mock.calls[0][1]; auctionRedisCommandService.applyTransition.mock.calls[0][1];
expect( expect(JSON.parse(transitionInput.durabilityPayloadJson)).toMatchObject({
parseJsonRecord(
transitionInput.durabilityPayloadJson,
'durabilityPayloadJson',
),
).toMatchObject({
afterAuctionMongoProjection: expect.objectContaining({ afterAuctionMongoProjection: expect.objectContaining({
phase: 'bidding', phase: 'bidding',
revision: 2, revision: 2,
@@ -1207,40 +1179,17 @@ describe('AuctionService', () => {
const transitionInput = const transitionInput =
auctionRedisCommandService.applyTransition.mock.calls[0][1]; auctionRedisCommandService.applyTransition.mock.calls[0][1];
const durabilityPayload = parseJsonRecord( const durabilityPayload = JSON.parse(transitionInput.durabilityPayloadJson);
transitionInput.durabilityPayloadJson, expect(durabilityPayload.snapshotBefore).toMatchObject({
'durabilityPayloadJson',
);
const snapshotBefore = requireRecord(
durabilityPayload.snapshotBefore,
'snapshotBefore',
);
const snapshotBeforeTeams = requireArray(
snapshotBefore.auctionTeams,
'snapshotBefore.auctionTeams',
);
const snapshotBeforeTeam = requireRecord(
snapshotBeforeTeams[0],
'snapshotBefore.auctionTeams[0]',
);
const afterAuctionMongoProjection = requireRecord(
durabilityPayload.afterAuctionMongoProjection,
'afterAuctionMongoProjection',
);
const projectedTeams = requireArray(
afterAuctionMongoProjection.auctionTeams,
'afterAuctionMongoProjection.auctionTeams',
);
const projectedTeam = requireRecord(
projectedTeams[0],
'afterAuctionMongoProjection.auctionTeams[0]',
);
expect(snapshotBefore).toMatchObject({
phase: 'bidding', phase: 'bidding',
revision: 4, revision: 4,
}); });
expect(snapshotBeforeTeam.members).toEqual([]); expect(durabilityPayload.snapshotBefore.auctionTeams[0].members).toEqual(
expect(projectedTeam.members).toEqual([ [],
);
expect(
durabilityPayload.afterAuctionMongoProjection.auctionTeams[0].members,
).toEqual([
expect.objectContaining({ expect.objectContaining({
memberAcquisitionBidPointAmount: 120, memberAcquisitionBidPointAmount: 120,
userId: playerUserId.toString(), userId: playerUserId.toString(),
@@ -1365,267 +1314,6 @@ describe('AuctionService', () => {
} }
}); });
describe('redis next safety', () => {
function createFortyPlayerAuction() {
const matchId = new mongoose.Types.ObjectId();
const participantIds = Array.from(
{ length: 40 },
() => new mongoose.Types.ObjectId(),
);
const auction = {
_id: new mongoose.Types.ObjectId(),
matchId,
auctionEngineVersion: 'redis-v1',
auctionLifecycleId: 'life-1',
};
const state = {
auctionLifecycleId: 'life-1',
auctionTeams: participantIds
.slice(0, 8)
.map((captainUserId, index) => ({
teamIndex: index + 1,
captainUserId: captainUserId.toString(),
remainingBidPointAmount: 960,
members: participantIds
.slice(8 + index * 4, 12 + index * 4)
.map((userId) => ({
userId: userId.toString(),
assignedPosition: 'MID',
memberAcquisitionBidPointAmount: 10,
})),
})),
auctionPlayerOrder: participantIds.slice(8).map((userId) => ({
userId: userId.toString(),
preferredPositions: [{ position: 'MID', priority: 1 }],
passCount: 0,
})),
bidRoundExtensionSeconds: 5,
currentAuctionHistorySequence: 121,
currentAuctionPlayerOrderIndex: 31,
currentAuctionRound: 1,
initialTeamBidPointAmount: 1000,
maximumBidRoundDurationSeconds: 15,
passedAuctionPlayerQueue: [] as Array<{
userId: string;
preferredPositions: Array<{ position: string; priority: number }>;
passCount: number;
}>,
phase: 'sold',
revision: 479,
topTierAuctionPriorityThreshold: 'NONE',
};
const match = {
_id: matchId,
participants: participantIds.map((userId) => ({
userId,
excluded: false,
preferredPositions: [{ position: 'MID', priority: 1 }],
})),
status: 'team-built',
teams: [],
save: jest.fn().mockResolvedValue(undefined),
};
const dependencies = createService({
auction: { findOne: jest.fn().mockResolvedValue(auction) },
match: { findById: jest.fn().mockResolvedValue(match) },
});
dependencies.auctionRedisStateReaderService.readAuctionStateView.mockResolvedValue(
state,
);
dependencies.auctionRedisCommandService.applyTransition.mockImplementation(
async (_matchId: string, input: Record<string, unknown>) => {
Object.assign(
state,
parseJsonRecord(
input.afterAuctionStructureStateJson,
'afterAuctionStructureStateJson',
),
input.liveStatePatch,
{
revision: Number(input.expectedRevision) + 1,
currentAuctionHistorySequence: input.auctionHistorySequence,
},
);
return {
auctionStateTransitionId: String(input.auctionStateTransitionId),
currentServerTimestampMS: 1780000000000,
ok: true,
revision: state.revision,
};
},
);
return { ...dependencies, matchId, match, state, participantIds };
}
it.each([12, 31])(
'rejects next for a presenting player at index %i without skipping or completing',
async (index) => {
const { service, matchId, state, auctionRedisCommandService } =
createFortyPlayerAuction();
state.phase = 'presenting';
state.currentAuctionPlayerOrderIndex = index;
const before = structuredClone(state);
await expect(service.next(matchId)).rejects.toThrow(
'Cannot advance from current phase.',
);
expect(state).toEqual(before);
expect(
auctionRedisCommandService.reserveActionRequest,
).not.toHaveBeenCalled();
expect(
auctionRedisCommandService.applyTransition,
).not.toHaveBeenCalled();
},
);
it('rejects completion when only 39 of the 40 participants are assigned', async () => {
const { service, matchId, state, match, auctionRedisCommandService } =
createFortyPlayerAuction();
state.auctionTeams[6].members.pop();
const before = structuredClone(state);
await expect(service.next(matchId)).rejects.toThrow(
'Auction roster validation failed.',
);
expect(state).toEqual(before);
expect(auctionRedisCommandService.applyTransition).not.toHaveBeenCalled();
expect(match.save).not.toHaveBeenCalled();
});
it('checks original eligible participants even if a missing player also disappeared from the order', async () => {
const { service, matchId, state, auctionRedisCommandService } =
createFortyPlayerAuction();
const missingPlayer = state.auctionTeams[6].members.pop()!;
state.auctionPlayerOrder = state.auctionPlayerOrder.filter(
(player) => player.userId !== missingPlayer.userId,
);
state.currentAuctionPlayerOrderIndex =
state.auctionPlayerOrder.length - 1;
const before = structuredClone(state);
await expect(service.next(matchId)).rejects.toThrow(
'Auction roster validation failed.',
);
expect(state).toEqual(before);
expect(auctionRedisCommandService.applyTransition).not.toHaveBeenCalled();
});
it('rejects a duplicate assignment even when the assigned count still equals 40', async () => {
const { service, matchId, state, auctionRedisCommandService } =
createFortyPlayerAuction();
state.auctionTeams[0].members[0].userId =
state.auctionTeams[1].members[0].userId;
await expect(service.next(matchId)).rejects.toThrow(
'Auction roster validation failed.',
);
expect(state.phase).toBe('sold');
expect(auctionRedisCommandService.applyTransition).not.toHaveBeenCalled();
});
it('rejects duplicate captain membership even when every expected user is present', async () => {
const { service, matchId, state, auctionRedisCommandService } =
createFortyPlayerAuction();
state.auctionTeams[0].members.push({
userId: state.auctionTeams[0].captainUserId,
assignedPosition: 'MID',
memberAcquisitionBidPointAmount: 10,
});
await expect(service.next(matchId)).rejects.toThrow(
'Auction roster validation failed.',
);
expect(state.phase).toBe('sold');
expect(auctionRedisCommandService.applyTransition).not.toHaveBeenCalled();
});
it('rejects an unexpected assigned user even when all 40 assignments are unique', async () => {
const { service, matchId, state, auctionRedisCommandService } =
createFortyPlayerAuction();
state.auctionTeams[0].members[0].userId =
new mongoose.Types.ObjectId().toString();
await expect(service.next(matchId)).rejects.toThrow(
'Auction roster validation failed.',
);
expect(state.phase).toBe('sold');
expect(auctionRedisCommandService.applyTransition).not.toHaveBeenCalled();
});
it('completes all 40 eligible participants once, allowing repeat order entries after passes and excluding cut participants', async () => {
const { service, matchId, state, match, auctionRedisCommandService } =
createFortyPlayerAuction();
state.auctionPlayerOrder.push({
...state.auctionPlayerOrder[12],
passCount: 1,
});
state.currentAuctionPlayerOrderIndex =
state.auctionPlayerOrder.length - 1;
state.currentAuctionRound = 2;
match.participants.push({
userId: new mongoose.Types.ObjectId(),
excluded: true,
preferredPositions: [{ position: 'MID', priority: 1 }],
});
await expect(service.next(matchId)).resolves.toMatchObject({
phase: 'complete',
revision: 480,
});
expect(auctionRedisCommandService.applyTransition).toHaveBeenCalledTimes(
1,
);
expect(state.auctionTeams).toHaveLength(8);
expect(
state.auctionTeams.every((team) => team.members.length === 4),
).toBe(true);
expect(match.save).not.toHaveBeenCalled();
});
it.each(['sold', 'passed'])(
'advances a nonterminal %s player without demanding a completed roster',
async (phase) => {
const { service, matchId, state } = createFortyPlayerAuction();
state.phase = phase;
state.currentAuctionPlayerOrderIndex = 12;
state.auctionTeams.forEach((team) => {
team.members = [];
});
await expect(service.next(matchId)).resolves.toMatchObject({
phase: 'presenting',
currentAuctionPlayerOrderIndex: 13,
});
},
);
it('requeues passed players for another round without completing an incomplete roster', async () => {
const { service, matchId, state } = createFortyPlayerAuction();
state.phase = 'passed';
state.auctionTeams[7].members.pop();
state.passedAuctionPlayerQueue.push({
...state.auctionPlayerOrder[31],
passCount: 1,
});
await expect(service.next(matchId)).resolves.toMatchObject({
phase: 'presenting',
currentAuctionPlayerOrderIndex: 32,
currentAuctionRound: 2,
passedAuctionPlayerQueue: [],
});
expect(state.auctionPlayerOrder).toHaveLength(33);
});
});
it('syncs match teams when a redis-v1 auction completes', async () => { it('syncs match teams when a redis-v1 auction completes', async () => {
const matchId = new mongoose.Types.ObjectId(); const matchId = new mongoose.Types.ObjectId();
const captainUserId = new mongoose.Types.ObjectId(); const captainUserId = new mongoose.Types.ObjectId();
@@ -1709,12 +1397,7 @@ describe('AuctionService', () => {
}); });
const [, transitionInput] = const [, transitionInput] =
auctionRedisCommandService.applyTransition.mock.calls.at(-1) ?? []; auctionRedisCommandService.applyTransition.mock.calls.at(-1) ?? [];
expect( expect(JSON.parse(transitionInput.durabilityPayloadJson)).toMatchObject({
parseJsonRecord(
transitionInput.durabilityPayloadJson,
'durabilityPayloadJson',
),
).toMatchObject({
afterAuctionMongoProjection: { afterAuctionMongoProjection: {
matchSideEffectStatus: 'pending', matchSideEffectStatus: 'pending',
phase: 'complete', phase: 'complete',
@@ -2103,7 +1786,7 @@ describe('AuctionService', () => {
}); });
expect(auction.currentBid).toBe(970); expect(auction.currentBid).toBe(970);
expect(auction).toHaveProperty('currentBidderTeamIndex', 1); expect(auction.currentBidderTeamIndex).toBe(1);
expect(auction.bids).toEqual([ expect(auction.bids).toEqual([
expect.objectContaining({ expect.objectContaining({
teamIndex: 1, teamIndex: 1,
@@ -2397,7 +2080,7 @@ describe('AuctionService', () => {
await service.next(matchId); await service.next(matchId);
expect(auction.phase).toBe('complete'); expect(auction.phase).toBe('complete');
expect(auction).toHaveProperty('completedAt', expect.any(Date)); expect(auction.completedAt).toBeInstanceOf(Date);
expect(auction.save).toHaveBeenCalledTimes(1); expect(auction.save).toHaveBeenCalledTimes(1);
expect(match.save).toHaveBeenCalledTimes(2); expect(match.save).toHaveBeenCalledTimes(2);
expect(match.teams).toEqual([ expect(match.teams).toEqual([
@@ -2885,10 +2568,7 @@ describe('AuctionService', () => {
durationSeconds: 30, durationSeconds: 30,
mode: 'set-relative', mode: 'set-relative',
}); });
const durabilityPayload = parseJsonRecord( const durabilityPayload = JSON.parse(transitionInput.durabilityPayloadJson);
transitionInput.durabilityPayloadJson,
'durabilityPayloadJson',
);
expect(durabilityPayload).toMatchObject({ expect(durabilityPayload).toMatchObject({
auctionActionType: 'undo', auctionActionType: 'undo',
historyMutation: { historyMutation: {
+56 -64
View File
@@ -39,7 +39,6 @@ import {
stringifyAuctionRedisStructureState, stringifyAuctionRedisStructureState,
} from './redis/auction-redis-projection'; } from './redis/auction-redis-projection';
import { AuctionRedisService } from './redis/auction-redis.service'; import { AuctionRedisService } from './redis/auction-redis.service';
import { AUCTION_CLEANUP_DURABILITY_SCRIPT } from './redis/auction-redis.cleanup';
import { AuctionRedisStateReaderService } from './redis/auction-redis-state-reader.service'; import { AuctionRedisStateReaderService } from './redis/auction-redis-state-reader.service';
import { shouldHydrateRedisAuctionState } from './redis/auction-redis.state'; import { shouldHydrateRedisAuctionState } from './redis/auction-redis.state';
// [AUCTION-DEBUG] 경매 "중복 멤버" 조사용 임시 계측. 조사 종료 후 제거 대상. // [AUCTION-DEBUG] 경매 "중복 멤버" 조사용 임시 계측. 조사 종료 후 제거 대상.
@@ -1194,7 +1193,11 @@ export class AuctionService {
): Promise<AuctionStateResponse> { ): Promise<AuctionStateResponse> {
const matchId = auction.matchId.toString(); const matchId = auction.matchId.toString();
const state = await this.requireRedisAuctionState(matchId); const state = await this.requireRedisAuctionState(matchId);
if (state.phase !== 'sold' && state.phase !== 'passed') { if (
state.phase !== 'sold' &&
state.phase !== 'presenting' &&
state.phase !== 'passed'
) {
throw new BadRequestException('Cannot advance from current phase.'); throw new BadRequestException('Cannot advance from current phase.');
} }
@@ -1215,10 +1218,6 @@ export class AuctionService {
structureInput.currentAuctionRound += 1; structureInput.currentAuctionRound += 1;
structureInput.currentAuctionPlayerOrderIndex = nextIndex; structureInput.currentAuctionPlayerOrderIndex = nextIndex;
} else { } else {
await this.assertCompleteAuctionRoster(
auction.matchId,
structureInput.auctionTeams,
);
action = 'complete'; action = 'complete';
nextPhase = 'complete'; nextPhase = 'complete';
} }
@@ -1333,16 +1332,17 @@ export class AuctionService {
if (this.isRedisV1Auction(auction)) { if (this.isRedisV1Auction(auction)) {
return this.advanceRedisAuction(auction, actionRequest); return this.advanceRedisAuction(auction, actionRequest);
} }
if (auction.phase !== 'sold' && auction.phase !== 'passed') { if (
auction.phase !== 'sold' &&
auction.phase !== 'presenting' &&
auction.phase !== 'passed'
) {
throw new BadRequestException('Cannot advance from current phase.'); throw new BadRequestException('Cannot advance from current phase.');
} }
const nextIndex = auction.currentIndex + 1; const nextIndex = auction.currentIndex + 1;
const completesAuction = const completesAuction =
nextIndex >= auction.order.length && nextIndex >= auction.order.length &&
(auction.passedQueue?.length ?? 0) === 0; (auction.passedQueue?.length ?? 0) === 0;
if (completesAuction) {
await this.assertCompleteAuctionRoster(matchId, auction.teams);
}
await this.recordSnapshot(auction, completesAuction ? 'complete' : 'next'); await this.recordSnapshot(auction, completesAuction ? 'complete' : 'next');
if (nextIndex >= auction.order.length) { if (nextIndex >= auction.order.length) {
if ((auction.passedQueue?.length ?? 0) > 0) { if ((auction.passedQueue?.length ?? 0) > 0) {
@@ -2515,52 +2515,6 @@ export class AuctionService {
return ordered.slice(0, desiredAuctionCount); return ordered.slice(0, desiredAuctionCount);
} }
private async assertCompleteAuctionRoster(
matchId: mongoose.Types.ObjectId,
teams: Array<{
captainUserId: mongoose.Types.ObjectId;
members: Array<{ userId: mongoose.Types.ObjectId }>;
}>,
): Promise<void> {
const MatchModel = await this.connectionService.getModel('match');
const match = await MatchModel.findById(matchId);
if (!match) throw new NotFoundException('Match not found.');
// The queue can contain reauction entries or be corrupted; use the original roster.
const expectedIds = match.participants
.filter((participant) => !participant.excluded)
.map((participant) => participant.userId.toString());
const expected = new Set(expectedIds);
const assignedIds = teams.flatMap((team) => [
team.captainUserId.toString(),
...team.members.map((member) => member.userId.toString()),
]);
const assigned = new Set(assignedIds);
const missingUserIds = expectedIds.filter((id) => !assigned.has(id));
const unexpectedUserIds = [...assigned].filter((id) => !expected.has(id));
if (
expected.size === 0 ||
expected.size !== expectedIds.length ||
assigned.size !== assignedIds.length ||
missingUserIds.length > 0 ||
unexpectedUserIds.length > 0
) {
this.logger.error({
event: 'auction_roster_validation_failed',
matchId: matchId.toString(),
expectedCount: expectedIds.length,
assignedCount: assignedIds.length,
assignedUniqueCount: assigned.size,
missingUserIds,
unexpectedUserIds,
});
throw new BadRequestException({
code: 'AUCTION_ROSTER_INVALID',
message: 'Auction roster validation failed.',
});
}
}
private assertCaptainAssignments( private assertCaptainAssignments(
captains: StartAuctionParams['captains'], captains: StartAuctionParams['captains'],
activeParticipants: Array<{ userId: mongoose.Types.ObjectId }>, activeParticipants: Array<{ userId: mongoose.Types.ObjectId }>,
@@ -2971,18 +2925,56 @@ export class AuctionService {
const payloadKeys = Array.isArray(reply[1]) ? reply[1].map(String) : []; const payloadKeys = Array.isArray(reply[1]) ? reply[1].map(String) : [];
if (payloadKeys.length === 0) continue; if (payloadKeys.length === 0) continue;
await this.auctionRedisService.evalScript( const values = await this.auctionRedisService
AUCTION_CLEANUP_DURABILITY_SCRIPT, .raw()
[ .sendCommand(['MGET', ...payloadKeys]);
keys.durabilityRetryQueueKey, const payloadKeysToDelete = payloadKeys.filter((payloadKey, index) =>
keys.durabilityDeadLetterQueueKey, this.shouldDeleteRedisDurabilityPayload(
...payloadKeys, Array.isArray(values) ? values[index] : undefined,
], expectedAuctionLifecycleId,
[expectedAuctionLifecycleId ?? ''], payloadKey,
),
); );
if (payloadKeysToDelete.length === 0) continue;
await this.auctionRedisService
.raw()
.sendCommand([
'ZREM',
keys.durabilityRetryQueueKey,
...payloadKeysToDelete,
]);
await this.auctionRedisService
.raw()
.sendCommand([
'ZREM',
keys.durabilityDeadLetterQueueKey,
...payloadKeysToDelete,
]);
await this.auctionRedisService
.raw()
.sendCommand(['DEL', ...payloadKeysToDelete]);
} while (cursor !== '0'); } while (cursor !== '0');
} }
private shouldDeleteRedisDurabilityPayload(
payloadValue: unknown,
expectedAuctionLifecycleId: string | undefined,
payloadKey: string,
): boolean {
if (!expectedAuctionLifecycleId) return true;
if (typeof payloadValue !== 'string') return false;
try {
const payload = JSON.parse(payloadValue) as Record<string, unknown>;
return payload.auctionLifecycleId === expectedAuctionLifecycleId;
} catch {
this.logger.warn(
`Failed to parse auction durability payload ${payloadKey}.`,
);
return false;
}
}
private enqueueBackgroundOrderEnrichment(params: { private enqueueBackgroundOrderEnrichment(params: {
auctionId: mongoose.Types.ObjectId; auctionId: mongoose.Types.ObjectId;
targets: AuctionEnrichmentTarget[]; targets: AuctionEnrichmentTarget[];
@@ -210,25 +210,21 @@ describe('AuctionRedisCommandService', () => {
it('parses apply transition replay and rejected replies', async () => { it('parses apply transition replay and rejected replies', async () => {
await expect( await expect(
makeService([ makeService(['REPLAY', 'APPLIED', 'transition-1', '2100'])
'REPLAY', .service.applyTransition('match-1', {
'APPLIED', afterAuctionStructureStateJson: '{}',
'transition-1', auctionHistorySequence: 5,
'2100', auctionLifecycleId: 'life-1',
]).service.applyTransition('match-1', { auctionStateTransitionId: 'transition-1',
afterAuctionStructureStateJson: '{}', broadcastStateRevision: 11,
auctionHistorySequence: 5, deadline: { mode: 'none' },
auctionLifecycleId: 'life-1', durabilityPayloadJson: '{}',
auctionStateTransitionId: 'transition-1', expectedPhase: 'sold',
broadcastStateRevision: 11, expectedRevision: 10,
deadline: { mode: 'none' }, liveStatePatch: {},
durabilityPayloadJson: '{}', matchId: 'match-1',
expectedPhase: 'sold', shouldBroadcastState: false,
expectedRevision: 10, }),
liveStatePatch: {},
matchId: 'match-1',
shouldBroadcastState: false,
}),
).resolves.toEqual({ ).resolves.toEqual({
auctionStateTransitionId: 'transition-1', auctionStateTransitionId: 'transition-1',
currentServerTimestampMS: 2100, currentServerTimestampMS: 2100,
@@ -237,25 +233,21 @@ describe('AuctionRedisCommandService', () => {
}); });
await expect( await expect(
makeService([ makeService(['REJECTED', 'CONFLICT', 'transition-1', '2200'])
'REJECTED', .service.applyTransition('match-1', {
'CONFLICT', afterAuctionStructureStateJson: '{}',
'transition-1', auctionHistorySequence: 5,
'2200', auctionLifecycleId: 'life-1',
]).service.applyTransition('match-1', { auctionStateTransitionId: 'transition-1',
afterAuctionStructureStateJson: '{}', broadcastStateRevision: 11,
auctionHistorySequence: 5, deadline: { mode: 'none' },
auctionLifecycleId: 'life-1', durabilityPayloadJson: '{}',
auctionStateTransitionId: 'transition-1', expectedPhase: 'sold',
broadcastStateRevision: 11, expectedRevision: 10,
deadline: { mode: 'none' }, liveStatePatch: {},
durabilityPayloadJson: '{}', matchId: 'match-1',
expectedPhase: 'sold', shouldBroadcastState: false,
expectedRevision: 10, }),
liveStatePatch: {},
matchId: 'match-1',
shouldBroadcastState: false,
}),
).resolves.toEqual({ ).resolves.toEqual({
auctionStateTransitionId: 'transition-1', auctionStateTransitionId: 'transition-1',
code: 'CONFLICT', code: 'CONFLICT',
@@ -296,17 +288,12 @@ describe('AuctionRedisCommandService', () => {
it('parses expire prepare replay and noop replies', async () => { it('parses expire prepare replay and noop replies', async () => {
await expect( await expect(
makeService([ makeService(['REPLAY', 'passed', 'expire-1', '12', '3100'])
'REPLAY', .service.expirePrepare('match-1', {
'passed', auctionStateTransitionId: 'expire-1',
'expire-1', bidRoundExpiryRetryDelayMS: 3000,
'12', matchId: 'match-1',
'3100', }),
]).service.expirePrepare('match-1', {
auctionStateTransitionId: 'expire-1',
bidRoundExpiryRetryDelayMS: 3000,
matchId: 'match-1',
}),
).resolves.toMatchObject({ ).resolves.toMatchObject({
auctionStateTransitionId: 'expire-1', auctionStateTransitionId: 'expire-1',
bidRoundExpiryDecision: 'passed', bidRoundExpiryDecision: 'passed',
@@ -373,19 +360,16 @@ describe('AuctionRedisCommandService', () => {
}); });
await expect( await expect(
makeService([ makeService(['REJECTED', 'INVALID_PATCH_ARITY', '4200'])
'REJECTED', .service.hydrateState('match-1', {
'INVALID_PATCH_ARITY', auctionHistorySequence: 3,
'4200', auctionLifecycleId: 'life-1',
]).service.hydrateState('match-1', { maximumBidRoundDurationSeconds: 30,
auctionHistorySequence: 3, matchId: 'match-1',
auctionLifecycleId: 'life-1', phase: 'presenting',
maximumBidRoundDurationSeconds: 30, revision: 6,
matchId: 'match-1', structureStateJson: '{}',
phase: 'presenting', }),
revision: 6,
structureStateJson: '{}',
}),
).resolves.toEqual({ ).resolves.toEqual({
code: 'INVALID_PATCH_ARITY', code: 'INVALID_PATCH_ARITY',
currentServerTimestampMS: 4200, currentServerTimestampMS: 4200,
@@ -85,9 +85,7 @@ export function stringifyAuctionRedisStructureState(
return JSON.stringify(buildAuctionRedisStructureState(input)); return JSON.stringify(buildAuctionRedisStructureState(input));
} }
function countAuctionTeamMembersIncludingCaptain( function countAuctionTeamMembersIncludingCaptain(team: RedisAuctionTeam): number {
team: RedisAuctionTeam,
): number {
const userIds = new Set<string>([team.captainUserId.toString()]); const userIds = new Set<string>([team.captainUserId.toString()]);
for (const member of team.members) { for (const member of team.members) {
userIds.add(member.userId.toString()); userIds.add(member.userId.toString());
@@ -1,10 +1,7 @@
import { AuctionRedisService } from './auction-redis.service'; import { AuctionRedisService } from './auction-redis.service';
import { AuctionRedisStateReaderService } from './auction-redis-state-reader.service'; import { AuctionRedisStateReaderService } from './auction-redis-state-reader.service';
function makeService( function makeService(commandReplies: unknown[], currentServerTimestampMS = 1000) {
commandReplies: unknown[],
currentServerTimestampMS = 1000,
) {
const sendCommand = jest const sendCommand = jest
.fn() .fn()
.mockImplementation(() => Promise.resolve(commandReplies.shift())); .mockImplementation(() => Promise.resolve(commandReplies.shift()));
@@ -152,9 +149,7 @@ describe('AuctionRedisStateReaderService', () => {
[], [],
]); ]);
await expect( await expect(service.readAuctionStateView('match-1')).resolves.toMatchObject({
service.readAuctionStateView('match-1'),
).resolves.toMatchObject({
auctionLifecycleId: 'life-1', auctionLifecycleId: 'life-1',
auctionTeams: [], auctionTeams: [],
phase: 'presenting', phase: 'presenting',
@@ -186,6 +181,7 @@ describe('AuctionRedisStateReaderService', () => {
}); });
}); });
it('returns null when live or structure state is absent', async () => { it('returns null when live or structure state is absent', async () => {
await expect( await expect(
makeService([[], '{"auctionTeams":[]}', []]).service.readAuctionStateView( makeService([[], '{"auctionTeams":[]}', []]).service.readAuctionStateView(
@@ -42,14 +42,12 @@ export class AuctionRedisStateReaderService {
matchId: string, matchId: string,
): Promise<AuctionRedisLiveStateIdentity | null> { ): Promise<AuctionRedisLiveStateIdentity | null> {
const keys = buildAuctionRedisKeys(matchId); const keys = buildAuctionRedisKeys(matchId);
const reply = await this.auctionRedisService const reply = await this.auctionRedisService.raw().sendCommand([
.raw() 'HMGET',
.sendCommand([ keys.liveStateKey,
'HMGET', 'auctionLifecycleId',
keys.liveStateKey, 'revision',
'auctionLifecycleId', ]);
'revision',
]);
if (!Array.isArray(reply)) return null; if (!Array.isArray(reply)) return null;
const auctionLifecycleId = const auctionLifecycleId =
typeof reply[0] === 'string' && reply[0] ? reply[0] : undefined; typeof reply[0] === 'string' && reply[0] ? reply[0] : undefined;
@@ -70,16 +68,14 @@ export class AuctionRedisStateReaderService {
): Promise<AuctionRedisBidContext | null> { ): Promise<AuctionRedisBidContext | null> {
const keys = buildAuctionRedisKeys(matchId); const keys = buildAuctionRedisKeys(matchId);
const bidderTeamCaptainUserIdField = `team:${bidderTeamIndex}:captainUserId`; const bidderTeamCaptainUserIdField = `team:${bidderTeamIndex}:captainUserId`;
const liveReply = await this.auctionRedisService const liveReply = await this.auctionRedisService.raw().sendCommand([
.raw() 'HMGET',
.sendCommand([ keys.liveStateKey,
'HMGET', 'phase',
keys.liveStateKey, 'auctionLifecycleId',
'phase', 'currentBidRoundPlayerUserId',
'auctionLifecycleId', bidderTeamCaptainUserIdField,
'currentBidRoundPlayerUserId', ]);
bidderTeamCaptainUserIdField,
]);
if (!Array.isArray(liveReply)) return null; if (!Array.isArray(liveReply)) return null;
const phase = stringValue(liveReply[0]); const phase = stringValue(liveReply[0]);
@@ -106,23 +102,18 @@ export class AuctionRedisStateReaderService {
options: AuctionRedisStateViewReadOptions = {}, options: AuctionRedisStateViewReadOptions = {},
): Promise<Record<string, unknown> | null> { ): Promise<Record<string, unknown> | null> {
const keys = buildAuctionRedisKeys(matchId); const keys = buildAuctionRedisKeys(matchId);
const [ const [currentServerTimestampMS, liveReply, structureStateJson, bidEntries] =
currentServerTimestampMS, await Promise.all([
liveReply, this.auctionRedisService.getCurrentRedisTimestampMS(),
structureStateJson, this.auctionRedisService.raw().sendCommand(['HGETALL', keys.liveStateKey]),
bidEntries, this.auctionRedisService.raw().sendCommand(['GET', keys.structureStateKey]),
] = await Promise.all([ this.auctionRedisService.raw().sendCommand([
this.auctionRedisService.getCurrentRedisTimestampMS(), 'LRANGE',
this.auctionRedisService keys.bidHistoryKey,
.raw() '0',
.sendCommand(['HGETALL', keys.liveStateKey]), '-1',
this.auctionRedisService ]),
.raw() ]);
.sendCommand(['GET', keys.structureStateKey]),
this.auctionRedisService
.raw()
.sendCommand(['LRANGE', keys.bidHistoryKey, '0', '-1']),
]);
const liveState = parseHashReply(liveReply, { const liveState = parseHashReply(liveReply, {
includeInternalLiveStateFields: includeInternalLiveStateFields:
@@ -151,7 +142,7 @@ export class AuctionRedisStateReaderService {
revision: number; revision: number;
}, },
shouldForceAuctionStateResync: options.shouldForceAuctionStateResync, shouldForceAuctionStateResync: options.shouldForceAuctionStateResync,
structureState: parseJsonRecord(structureStateJson), structureState: JSON.parse(structureStateJson) as Record<string, unknown>,
}); });
view.matchId = matchId; view.matchId = matchId;
if (options.includeInternalLiveStateFields) { if (options.includeInternalLiveStateFields) {
@@ -170,9 +161,12 @@ export class AuctionRedisStateReaderService {
if (typeof structureStateJson !== 'string' || !structureStateJson) { if (typeof structureStateJson !== 'string' || !structureStateJson) {
return undefined; return undefined;
} }
const structureState = parseJsonRecord(structureStateJson); const structureState = JSON.parse(structureStateJson) as Record<
const auctionTeams: unknown[] = Array.isArray(structureState.auctionTeams) string,
? (structureState.auctionTeams as unknown[]) unknown
>;
const auctionTeams = Array.isArray(structureState.auctionTeams)
? structureState.auctionTeams
: []; : [];
const bidderTeam = auctionTeams.find((entry) => { const bidderTeam = auctionTeams.find((entry) => {
if (!entry || typeof entry !== 'object') return false; if (!entry || typeof entry !== 'object') return false;
@@ -189,13 +183,6 @@ function stringValue(value: unknown): string | undefined {
return typeof value === 'string' && value ? value : undefined; return typeof value === 'string' && value ? value : undefined;
} }
function parseJsonRecord(json: string): Record<string, unknown> {
const value: unknown = JSON.parse(json);
return typeof value === 'object' && value !== null
? (value as Record<string, unknown>)
: {};
}
function parseHashReply( function parseHashReply(
reply: unknown, reply: unknown,
options: { includeInternalLiveStateFields?: boolean } = {}, options: { includeInternalLiveStateFields?: boolean } = {},
@@ -223,10 +210,7 @@ function parseHashEntries(
): Record<string, unknown> { ): Record<string, unknown> {
const result: Record<string, unknown> = {}; const result: Record<string, unknown> = {};
for (const [field, rawValue] of entries) { for (const [field, rawValue] of entries) {
if ( if (!options.includeInternalLiveStateFields && isInternalLiveStateField(field)) {
!options.includeInternalLiveStateFields &&
isInternalLiveStateField(field)
) {
continue; continue;
} }
const value = String(rawValue); const value = String(rawValue);
@@ -91,7 +91,9 @@ describe('auction apply transition redis script contract', () => {
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain( expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
'shouldBroadcastState', 'shouldBroadcastState',
); );
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain("redis.call('SADD'"); expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
"redis.call('SADD'",
);
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain( expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
"redis.call('HINCRBY'", "redis.call('HINCRBY'",
); );
@@ -317,7 +317,7 @@ if actionRequestScopeKey ~= '' then
actionRequestPrefix .. 'responseServerTimestampMS', actionRequestPrefix .. 'responseServerTimestampMS',
tostring(currentRedisTimestampMS) tostring(currentRedisTimestampMS)
) )
-- The reservation already inserted this request into the order list. redis.call('RPUSH', auctionActionRequestResultOrderKey, actionRequestScopeKey)
end end
return {'OK', auctionStateTransitionId, tostring(newRevision), tostring(currentRedisTimestampMS)} return {'OK', auctionStateTransitionId, tostring(newRevision), tostring(currentRedisTimestampMS)}
@@ -64,7 +64,9 @@ describe('auction bid redis script contract', () => {
expect(AUCTION_BID_SCRIPT.lua).toContain("redis.call('TIME')"); expect(AUCTION_BID_SCRIPT.lua).toContain("redis.call('TIME')");
expect(AUCTION_BID_SCRIPT.lua).toContain("redis.call('HINCRBY'"); 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('BID_REQUEST_RESULT_LIMIT');
expect(AUCTION_BID_SCRIPT.lua).toContain('currentHighestBidPointAmount'); expect(AUCTION_BID_SCRIPT.lua).toContain(
'currentHighestBidPointAmount',
);
expect(AUCTION_BID_SCRIPT.lua).not.toContain('cjson.decode'); expect(AUCTION_BID_SCRIPT.lua).not.toContain('cjson.decode');
}); });
}); });
@@ -1,27 +0,0 @@
import { defineAuctionRedisScript } from './auction-redis.scripts';
// Compare the lifecycle and remove the payload and its indexes atomically.
export const AUCTION_CLEANUP_DURABILITY_SCRIPT = defineAuctionRedisScript(
'auction.cleanupDurability',
`
local deleted = 0
for i = 3, #KEYS do
local key = KEYS[i]
local keyType = redis.call('TYPE', key).ok
local matches = ARGV[1] == ''
if not matches and keyType == 'hash' then
matches = redis.call('HGET', key, 'auctionLifecycleId') == ARGV[1]
elseif not matches and keyType == 'string' then
-- Retain compatibility with payloads written before the Hash format.
local ok, payload = pcall(cjson.decode, redis.call('GET', key))
matches = ok and type(payload) == 'table' and payload.auctionLifecycleId == ARGV[1]
end
if matches then
redis.call('ZREM', KEYS[1], key)
redis.call('ZREM', KEYS[2], key)
deleted = deleted + redis.call('UNLINK', key)
end
end
return deleted
`,
);
@@ -3,11 +3,9 @@ import { buildAuctionRedisKeys } from './auction-redis.keys';
describe('auction redis keys', () => { describe('auction redis keys', () => {
it('builds lifecycle-safe key names from match id', () => { it('builds lifecycle-safe key names from match id', () => {
expect(buildAuctionRedisKeys('match-1')).toMatchObject({ expect(buildAuctionRedisKeys('match-1')).toMatchObject({
actionRequestResultOrderKey: actionRequestResultOrderKey: 'auction:match-1:auctionActionRequestResultOrder',
'auction:match-1:auctionActionRequestResultOrder',
actionRequestResultsKey: 'auction:match-1:auctionActionRequestResults', actionRequestResultsKey: 'auction:match-1:auctionActionRequestResults',
appliedTransitionIdsKey: appliedTransitionIdsKey: 'auction:match-1:appliedAuctionStateTransitionIds',
'auction:match-1:appliedAuctionStateTransitionIds',
bidHistoryKey: 'auction:match-1:auctionBidHistory', bidHistoryKey: 'auction:match-1:auctionBidHistory',
bidRequestResultOrderKey: 'auction:match-1:bidRequestResultOrder', bidRequestResultOrderKey: 'auction:match-1:bidRequestResultOrder',
bidRequestResultsKey: 'auction:match-1:bidRequestResults', bidRequestResultsKey: 'auction:match-1:bidRequestResults',
@@ -2,7 +2,10 @@ import { Logger, Module } from '@nestjs/common';
import { createClient } from 'redis'; import { createClient } from 'redis';
import { SecretModule } from '../../global/secret/secret.module'; import { SecretModule } from '../../global/secret/secret.module';
import { SecretService } from '../../global/secret/secret.service'; import { SecretService } from '../../global/secret/secret.service';
import { loadRedisClientOptions } from '../../global/redis/redis.config'; import {
assertDistinctRedisInstances,
resolveRedisClientOptions,
} from '../../global/redis/redis.config';
import { AUCTION_REDIS_CLIENT } from './auction-redis.constants'; import { AUCTION_REDIS_CLIENT } from './auction-redis.constants';
import { import {
AuctionRedisService, AuctionRedisService,
@@ -11,6 +14,18 @@ import {
import { AuctionRedisCommandService } from './auction-redis-command.service'; import { AuctionRedisCommandService } from './auction-redis-command.service';
import { AuctionRedisStateReaderService } from './auction-redis-state-reader.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({ @Module({
imports: [SecretModule], imports: [SecretModule],
providers: [ providers: [
@@ -20,15 +35,48 @@ import { AuctionRedisStateReaderService } from './auction-redis-state-reader.ser
useFactory: async ( useFactory: async (
secretService: SecretService, secretService: SecretService,
): Promise<AuctionRedisClient> => { ): 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 logger = new Logger('AuctionRedisClient');
const client = createClient( const client = createClient(auctionRedisOptions);
await loadRedisClientOptions(secretService), client.on('error', (error) => {
);
client.on('error', (error: unknown) => {
logger.error( logger.error(
`Auction Redis client error: ${ `Auction Redis client error: ${error?.message ?? error}`,
error instanceof Error ? error.message : String(error)
}`,
); );
}); });
@@ -15,9 +15,7 @@ function makeService(sendCommand: jest.Mock) {
describe('AuctionRedisService', () => { describe('AuctionRedisService', () => {
it('uses Redis TIME as the timestamp source', async () => { it('uses Redis TIME as the timestamp source', async () => {
const service = makeService( const service = makeService(jest.fn().mockResolvedValue(['1781700000', '123000']));
jest.fn().mockResolvedValue(['1781700000', '123000']),
);
await expect(service.getCurrentRedisTimestampMS()).resolves.toBe( await expect(service.getCurrentRedisTimestampMS()).resolves.toBe(
1_781_700_000_123, 1_781_700_000_123,
@@ -22,11 +22,7 @@ export class AuctionRedisNoscriptError extends Error {
function isNoscriptError(error: unknown): boolean { function isNoscriptError(error: unknown): boolean {
if (error instanceof AuctionRedisNoscriptError) return true; if (error instanceof AuctionRedisNoscriptError) return true;
const message = const message =
error instanceof Error error instanceof Error ? error.message : typeof error === 'string' ? error : '';
? error.message
: typeof error === 'string'
? error
: '';
return /\bNOSCRIPT\b/iu.test(message); return /\bNOSCRIPT\b/iu.test(message);
} }
@@ -85,15 +81,9 @@ export class AuctionRedisService implements OnModuleDestroy {
if (!isNoscriptError(error)) throw error; if (!isNoscriptError(error)) throw error;
} }
const loadedShaReply = await this.client.sendCommand([ const loadedSha = String(
'SCRIPT', await this.client.sendCommand(['SCRIPT', 'LOAD', params.script]),
'LOAD', );
params.script,
]);
if (typeof loadedShaReply !== 'string') {
throw new Error('Redis SCRIPT LOAD returned a non-string SHA.');
}
const loadedSha = loadedShaReply;
return (await this.client.sendCommand( return (await this.client.sendCommand(
buildEvalShaCommand(loadedSha, params.keys, params.values), buildEvalShaCommand(loadedSha, params.keys, params.values),
)) as T; )) as T;
@@ -117,7 +107,7 @@ export class AuctionRedisService implements OnModuleDestroy {
token: string, token: string,
ttlMS: number, ttlMS: number,
): Promise<boolean> { ): Promise<boolean> {
const result = await this.client.sendCommand<string | null>([ const result = await this.client.sendCommand([
'SET', 'SET',
key, key,
token, token,
@@ -125,11 +115,17 @@ export class AuctionRedisService implements OnModuleDestroy {
String(ttlMS), String(ttlMS),
'NX', 'NX',
]); ]);
return result === 'OK'; return String(result) === 'OK';
} }
public async releaseTokenLock(key: string, token: string): Promise<boolean> { public async releaseTokenLock(key: string, token: string): Promise<boolean> {
const result = await this.client.sendCommand(['DELEX', key, 'IFEQ', token]); 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; return Number(result) === 1;
} }
} }
@@ -100,7 +100,9 @@ describe('auction redis state assembly', () => {
'1000', '1000',
]); ]);
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain("redis.call('TIME')"); expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain("redis.call('TIME')");
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain('INVALID_PATCH_ARITY'); expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain(
'INVALID_PATCH_ARITY',
);
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain( expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain(
'mongoRevision > redisRevision', 'mongoRevision > redisRevision',
); );
@@ -78,7 +78,9 @@ export function assembleAuctionViewFromRedisState(
return { return {
...params.structureState, ...params.structureState,
...params.liveState, ...params.liveState,
auctionBidHistory: params.auctionBidHistoryEntries.map(parseJsonValue), auctionBidHistory: params.auctionBidHistoryEntries.map((entry) =>
JSON.parse(entry),
),
canPlaceBidInCurrentBidRound: !isExpiring, canPlaceBidInCurrentBidRound: !isExpiring,
currentServerTimestampMS: params.currentServerTimestampMS, currentServerTimestampMS: params.currentServerTimestampMS,
isAuctionStateTransitionInProgress: isExpiring, isAuctionStateTransitionInProgress: isExpiring,
@@ -88,11 +90,6 @@ export function assembleAuctionViewFromRedisState(
}; };
} }
function parseJsonValue(json: string): unknown {
const value: unknown = JSON.parse(json);
return value;
}
export function buildHydrateAuctionStateScriptInvocation( export function buildHydrateAuctionStateScriptInvocation(
keys: AuctionRedisKeys, keys: AuctionRedisKeys,
input: HydrateAuctionStateScriptInput, input: HydrateAuctionStateScriptInput,
+4 -1
View File
@@ -1,5 +1,8 @@
import type { JWTHeaderParameters, JWTPayload } from 'jose'; import type { JWTHeaderParameters, JWTPayload } from 'jose';
import type { IdentityDocument, UserDocument } from '../global/database/schema'; import type {
IdentityDocument,
UserDocument,
} from '../global/database/schema';
import type { IdentityProviderName } from './jwt.service'; import type { IdentityProviderName } from './jwt.service';
declare module 'express' { declare module 'express' {
+4 -1
View File
@@ -2,7 +2,10 @@ import { Injectable } from '@nestjs/common';
import type { Request } from 'express'; import type { Request } from 'express';
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service'; import { ConnectionService } from '../global/database/connection.service';
import { IdentityDocument, UserDocument } from '../global/database/schema'; import {
IdentityDocument,
UserDocument,
} from '../global/database/schema';
import { SecretService } from '../global/secret/secret.service'; import { SecretService } from '../global/secret/secret.service';
import './auth-request'; import './auth-request';
+4 -4
View File
@@ -26,7 +26,8 @@ export class JwtAuthGuard implements CanActivate {
METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED, METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED,
[context.getHandler(), context.getClass()], [context.getHandler(), context.getClass()],
); );
const authzHeader = request.get('authorization'); const authz = request.headers?.authorization;
const authzHeader = Array.isArray(authz) ? authz[0] : authz;
if (!authzHeader) { if (!authzHeader) {
const fallback = const fallback =
@@ -73,7 +74,7 @@ export class JwtAuthGuard implements CanActivate {
private pickIdPFromToken(token: string): IdentityProviderName { private pickIdPFromToken(token: string): IdentityProviderName {
try { try {
const { iss } = decodeJwt(token); const { iss } = decodeJwt(token) as { iss?: string };
if (!iss) { if (!iss) {
throw new Error('Token has no issuer (iss) claim'); throw new Error('Token has no issuer (iss) claim');
} }
@@ -83,8 +84,7 @@ export class JwtAuthGuard implements CanActivate {
} }
throw new Error(`Unknown issuer: ${iss}`); throw new Error(`Unknown issuer: ${iss}`);
} catch (err) { } catch (err) {
const message = const message = err instanceof Error ? err.message : 'Unable to decode token';
err instanceof Error ? err.message : 'Unable to decode token';
throw new UnauthorizedException(message); throw new UnauthorizedException(message);
} }
} }
+9 -32
View File
@@ -35,13 +35,11 @@ export class JwtService {
throw new Error('Empty token'); throw new Error('Empty token');
} }
const provider = if (identityProvider !== 'MICROSOFT_ENTRAID') {
identityProvider === 'MICROSOFT_ENTRAID' throw new Error(`Identity provider not configured: ${identityProvider}`);
? await this.getEntraConfig()
: undefined;
if (!provider) {
throw new Error('Identity provider not configured.');
} }
const provider = await this.getEntraConfig();
const result = await jwtVerify(token, provider.jwks, { const result = await jwtVerify(token, provider.jwks, {
issuer: provider.issuer, issuer: provider.issuer,
audience: provider.audience, audience: provider.audience,
@@ -50,22 +48,14 @@ export class JwtService {
}); });
const { payload, protectedHeader } = result; const { payload, protectedHeader } = result;
if (!provider.allowedAlgs.includes(protectedHeader.alg)) { if (!provider.allowedAlgs.includes(protectedHeader.alg as string)) {
throw new Error(`Unexpected alg: ${protectedHeader.alg}`); throw new Error(`Unexpected alg: ${protectedHeader.alg}`);
} }
if ( if (payload.ver && payload.ver !== '2.0') {
payload.ver !== undefined && throw new Error(`Unsupported Entra token version: ${payload.ver}`);
(typeof payload.ver !== 'string' || payload.ver !== '2.0')
) {
throw new Error(
`Unsupported Entra token version: ${formatClaimValue(payload.ver)}`,
);
} }
if ( if (payload.tid && payload.tid !== provider.tenantId) {
payload.tid !== undefined && throw new Error(`Unexpected tenant: ${payload.tid}`);
(typeof payload.tid !== 'string' || payload.tid !== provider.tenantId)
) {
throw new Error(`Unexpected tenant: ${formatClaimValue(payload.tid)}`);
} }
return result; return result;
@@ -108,16 +98,3 @@ export class JwtService {
return this.entraConfig; return this.entraConfig;
} }
} }
function formatClaimValue(value: unknown): string {
if (
typeof value === 'string' ||
typeof value === 'number' ||
typeof value === 'boolean' ||
typeof value === 'bigint'
) {
return String(value);
}
if (value === null) return 'null';
return JSON.stringify(value) ?? typeof value;
}
+2 -2
View File
@@ -7,7 +7,7 @@ import {
} from '@nestjs/common'; } from '@nestjs/common';
import { Reflector } from '@nestjs/core'; import { Reflector } from '@nestjs/core';
import type { Request } from 'express'; import type { Request } from 'express';
import type { CommunityRole } from '../global/database/schema'; import { CommunityRole, UserDocument } from '../global/database/schema';
import { ROLES_KEY } from './roles.decorator'; import { ROLES_KEY } from './roles.decorator';
import './auth-request'; import './auth-request';
@@ -23,7 +23,7 @@ export class RolesGuard implements CanActivate {
if (!requiredRoles || requiredRoles.length === 0) return true; if (!requiredRoles || requiredRoles.length === 0) return true;
const req = context.switchToHttp().getRequest<Request>(); const req = context.switchToHttp().getRequest<Request>();
const user = req.user; const user = req.user as UserDocument | undefined;
if (!user && req.identity) { if (!user && req.identity) {
throw new ForbiddenException('No membership in this community.'); throw new ForbiddenException('No membership in this community.');
} }
@@ -4,7 +4,6 @@ import { ConnectionService } from '../global/database/connection.service';
import { IdentityDocument, UserDocument } from '../global/database/schema'; import { IdentityDocument, UserDocument } from '../global/database/schema';
import { UserResolverGuard } from './user-resolver.guard'; import { UserResolverGuard } from './user-resolver.guard';
import './auth-request'; import './auth-request';
import type { Request } from 'express';
function createContext(request: Record<string, unknown>): ExecutionContext { function createContext(request: Record<string, unknown>): ExecutionContext {
return { return {
@@ -25,7 +24,7 @@ describe('UserResolverGuard', () => {
const connectionService = { const connectionService = {
getModel: jest.fn().mockResolvedValue({ findOne }), getModel: jest.fn().mockResolvedValue({ findOne }),
} as unknown as ConnectionService; } as unknown as ConnectionService;
const request: Pick<Request, 'params' | 'identity' | 'user'> = { const request = {
params: { communityId: communityId.toString() }, params: { communityId: communityId.toString() },
identity: { _id: identityId } as IdentityDocument, identity: { _id: identityId } as IdentityDocument,
}; };
@@ -7,10 +7,9 @@ import {
import mongoose from 'mongoose'; import mongoose from 'mongoose';
@Injectable() @Injectable()
export class ParseObjectIdPipe implements PipeTransform< export class ParseObjectIdPipe
string, implements PipeTransform<string, mongoose.Types.ObjectId>
mongoose.Types.ObjectId {
> {
public transform( public transform(
value: string, value: string,
metadata: ArgumentMetadata, metadata: ArgumentMetadata,
@@ -1,67 +1,8 @@
import { Injectable, Logger } from '@nestjs/common'; import { Injectable, Logger } from '@nestjs/common';
import { randomUUID } from 'crypto';
import { RedisService } from '../global/redis/redis.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;
const CACHE_SCOPES = [
'matches',
'leaderboard',
'teamInsights',
'matchDetail',
'userInternal',
] as const;
type CacheScope = (typeof CACHE_SCOPES)[number];
function communityPrefix(communityId: string): string {
return `riot:communitystats:v2:{${communityId}}`;
}
export class CommunityStatsCacheKey {
public readonly generationKey: string;
public readonly hashKey: string;
public generation?: string;
constructor(
communityId: string,
scope: CacheScope,
public readonly field: string,
) {
const prefix = communityPrefix(communityId);
this.generationKey = `${prefix}:generation`;
this.hashKey = `${prefix}:${scope}`;
}
public get identity(): string {
return JSON.stringify([this.hashKey, this.generation, this.field]);
}
}
const READ_CACHE_SCRIPT = `
local generation = redis.call('GET', KEYS[1])
if not generation then
generation = ARGV[1]
redis.call('SET', KEYS[1], generation)
end
return {generation, redis.call('HGET', KEYS[2], ARGV[2])}
`;
const WRITE_CACHE_SCRIPT = `
if redis.call('GET', KEYS[1]) ~= ARGV[1] then return 0 end
redis.call('HSETEX', KEYS[2], 'EX', ARGV[4], 'FIELDS', 1, ARGV[2], ARGV[3])
return 1
`;
const INVALIDATE_CACHE_SCRIPT = `
-- A fill started before invalidation cannot publish into the new generation.
redis.call('SET', KEYS[1], ARGV[1])
local deleted = 0
for i = 2, #KEYS do
deleted = deleted + redis.call('HLEN', KEYS[i])
redis.call('UNLINK', KEYS[i])
end
return deleted
`;
@Injectable() @Injectable()
export class CommunityStatsCacheService { export class CommunityStatsCacheService {
@@ -69,72 +10,48 @@ export class CommunityStatsCacheService {
constructor(private readonly redisService: RedisService) {} constructor(private readonly redisService: RedisService) {}
public async get<T>(key: CommunityStatsCacheKey): Promise<T | null> { public get<T>(key: string): Promise<T | null> {
const reply = await this.redisService return this.redisService.getJson<T>(key);
.raw()
.sendCommand<
[string, string | null]
>(['EVAL', READ_CACHE_SCRIPT, '2', key.generationKey, key.hashKey, randomUUID(), key.field]);
key.generation = reply[0];
if (!reply[1]) return null;
try {
return JSON.parse(reply[1]) as T;
} catch {
this.logger.warn(
`Failed to parse community stats cache field in ${key.hashKey}.`,
);
return null;
}
} }
public async set( public set(
key: CommunityStatsCacheKey, key: string,
value: unknown, value: unknown,
ttlSeconds = COMMUNITY_STATS_TTL_SECONDS, ttlSeconds = COMMUNITY_STATS_TTL_SECONDS,
): Promise<void> { ): Promise<void> {
if (!key.generation) return this.redisService.setJson(key, value, ttlSeconds);
throw new Error(
'Read the cache generation before starting a cache fill.',
);
if (!Number.isInteger(ttlSeconds) || ttlSeconds <= 0)
throw new Error('Cache TTL must be a positive integer.');
await this.redisService
.raw()
.sendCommand([
'EVAL',
WRITE_CACHE_SCRIPT,
'2',
key.generationKey,
key.hashKey,
key.generation,
key.field,
JSON.stringify(value),
String(ttlSeconds),
]);
} }
public setDetail(key: CommunityStatsCacheKey, value: unknown): Promise<void> { public setDetail(key: string, value: unknown): Promise<void> {
return this.set(key, value, COMMUNITY_STATS_DETAIL_TTL_SECONDS); return this.set(key, value, COMMUNITY_STATS_DETAIL_TTL_SECONDS);
} }
public async invalidateCommunity(communityId: string): Promise<number> { public async invalidateCommunity(communityId: string): Promise<number> {
const prefix = communityPrefix(communityId); const prefix = `riot:communitystats:`;
const deleted = Number( const match = `${prefix}*${communityId}*`;
await this.redisService const client = this.redisService.raw();
.raw() let cursor = '0';
.sendCommand([ let deleted = 0;
'EVAL',
INVALIDATE_CACHE_SCRIPT, do {
String(CACHE_SCOPES.length + 1), const reply = (await client.sendCommand([
`${prefix}:generation`, 'SCAN',
...CACHE_SCOPES.map((scope) => `${prefix}:${scope}`), cursor,
randomUUID(), 'MATCH',
]), match,
); 'COUNT',
'100',
])) as [string, string[]];
cursor = reply[0];
const keys = reply[1] ?? [];
if (keys.length > 0) {
deleted += await client.del(keys);
}
} while (cursor !== '0');
if (deleted > 0) { if (deleted > 0) {
this.logger.debug( this.logger.debug(
`Invalidated ${deleted} community stats cache entries for ${communityId}.`, `Invalidated ${deleted} community stats cache keys for ${communityId}.`,
); );
} }
return deleted; return deleted;
@@ -23,14 +23,7 @@ export class CommunityStatsController {
) { ) {
return this.communityStatsService.getMatches({ return this.communityStatsService.getMatches({
communityId, communityId,
filters: this.toFilters({ filters: this.toFilters({ seasonId, from, to, championId, cursor, limit }),
seasonId,
from,
to,
championId,
cursor,
limit,
}),
}); });
} }
@@ -92,14 +85,7 @@ export class CommunityStatsController {
return this.communityStatsService.getUserInternalHistory({ return this.communityStatsService.getUserInternalHistory({
communityId, communityId,
userId, userId,
filters: this.toFilters({ filters: this.toFilters({ seasonId, from, to, championId, cursor, limit }),
seasonId,
from,
to,
championId,
cursor,
limit,
}),
}); });
} }
@@ -1,9 +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 { import { CommunityStatsCacheService } from './community-stats-cache.service';
CommunityStatsCacheKey,
CommunityStatsCacheService,
} from './community-stats-cache.service';
import { CommunityStatsService } from './community-stats.service'; import { CommunityStatsService } from './community-stats.service';
import type { import type {
InternalMatchCardView, InternalMatchCardView,
@@ -284,7 +281,7 @@ describe('CommunityStatsService', () => {
expect(setDetail).toHaveBeenCalledTimes(2); expect(setDetail).toHaveBeenCalledTimes(2);
expect(setDetail).toHaveBeenNthCalledWith( expect(setDetail).toHaveBeenNthCalledWith(
2, 2,
expect.objectContaining({ field: expect.stringContaining(':r4:') }), expect.stringContaining(':r4:'),
invalidCheckpointResponse, invalidCheckpointResponse,
); );
}); });
@@ -341,7 +338,7 @@ describe('CommunityStatsService', () => {
const set = jest const set = jest
.fn() .fn()
.mockImplementation( .mockImplementation(
(_key: CommunityStatsCacheKey, value: InternalMatchDetailResponse) => { (_key: string, value: InternalMatchDetailResponse) => {
cachedResponse = value; cachedResponse = value;
return Promise.resolve(); return Promise.resolve();
}, },
@@ -349,7 +346,7 @@ describe('CommunityStatsService', () => {
const setDetail = jest const setDetail = jest
.fn() .fn()
.mockImplementation( .mockImplementation(
(_key: CommunityStatsCacheKey, value: InternalMatchDetailResponse) => { (_key: string, value: InternalMatchDetailResponse) => {
cachedResponse = value; cachedResponse = value;
return Promise.resolve(); return Promise.resolve();
}, },
@@ -380,7 +377,7 @@ describe('CommunityStatsService', () => {
expect(backedOff).toBe(fallback); expect(backedOff).toBe(fallback);
expect(buildAndUpsert).toHaveBeenCalledTimes(1); expect(buildAndUpsert).toHaveBeenCalledTimes(1);
expect(set).toHaveBeenCalledWith( expect(set).toHaveBeenCalledWith(
expect.objectContaining({ field: expect.stringContaining(':r4:') }), expect.stringContaining(':r4:'),
fallback, fallback,
60, 60,
); );
@@ -392,7 +389,7 @@ describe('CommunityStatsService', () => {
expect(buildAndUpsert).toHaveBeenCalledTimes(2); expect(buildAndUpsert).toHaveBeenCalledTimes(2);
expect(setDetail).toHaveBeenCalledTimes(1); expect(setDetail).toHaveBeenCalledTimes(1);
expect(setDetail).toHaveBeenCalledWith( expect(setDetail).toHaveBeenCalledWith(
expect.objectContaining({ field: expect.stringContaining(':r4:') }), expect.stringContaining(':r4:'),
recovered, recovered,
); );
}); });
@@ -550,9 +547,7 @@ describe('CommunityStatsService', () => {
).toEqual([matchId.toString()]); ).toEqual([matchId.toString()]);
expect(buildBaseDataset).not.toHaveBeenCalled(); expect(buildBaseDataset).not.toHaveBeenCalled();
expect(cacheService.set).toHaveBeenCalledWith( expect(cacheService.set).toHaveBeenCalledWith(
expect.objectContaining({ expect.stringContaining(`userInternal:v3:${userId.toString()}`),
field: expect.stringContaining(`userInternal:v3:${userId.toString()}`),
}),
response, response,
); );
}); });
@@ -11,10 +11,7 @@ import type {
HistorySeasonDto, HistorySeasonDto,
RecentMatchView, RecentMatchView,
} from '../match-history/match-history.types'; } from '../match-history/match-history.types';
import { import { CommunityStatsCacheService } from './community-stats-cache.service';
CommunityStatsCacheKey,
CommunityStatsCacheService,
} from './community-stats-cache.service';
import type { import type {
CommunityStatsFilters, CommunityStatsFilters,
InternalMatchCardView, InternalMatchCardView,
@@ -222,25 +219,21 @@ 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 = new CommunityStatsCacheKey( const key = `riot:communitystats:matchDetail:v${MATCH_STATS_BUILDER_VERSION}:r${MATCH_DETAIL_RESPONSE_CACHE_VERSION}:${params.communityId.toString()}:${params.matchId.toString()}`;
params.communityId.toString(),
'matchDetail',
`v${MATCH_STATS_BUILDER_VERSION}:r${MATCH_DETAIL_RESPONSE_CACHE_VERSION}:${params.matchId.toString()}`,
);
const cached = const cached =
await this.cacheService.get<InternalMatchDetailResponse>(key); await this.cacheService.get<InternalMatchDetailResponse>(key);
if (cached && isCompleteMatchDetailResponse(cached)) return cached; if (cached && isCompleteMatchDetailResponse(cached)) return cached;
const inFlight = this.matchDetailInFlight.get(key.identity); const inFlight = this.matchDetailInFlight.get(key);
if (inFlight) return inFlight; if (inFlight) return inFlight;
const promise = this.buildMatchDetailResponse(params, key); const promise = this.buildMatchDetailResponse(params, key);
this.matchDetailInFlight.set(key.identity, promise); this.matchDetailInFlight.set(key, promise);
try { try {
return await promise; return await promise;
} finally { } finally {
if (this.matchDetailInFlight.get(key.identity) === promise) { if (this.matchDetailInFlight.get(key) === promise) {
this.matchDetailInFlight.delete(key.identity); this.matchDetailInFlight.delete(key);
} }
} }
} }
@@ -250,7 +243,7 @@ export class CommunityStatsService {
communityId: mongoose.Types.ObjectId; communityId: mongoose.Types.ObjectId;
matchId: mongoose.Types.ObjectId; matchId: mongoose.Types.ObjectId;
}, },
key: CommunityStatsCacheKey, key: string,
): Promise<InternalMatchDetailResponse> { ): Promise<InternalMatchDetailResponse> {
const dataset = await this.buildBaseDataset(params.communityId, { const dataset = await this.buildBaseDataset(params.communityId, {
seasonId: 'all', seasonId: 'all',
@@ -353,16 +346,16 @@ export class CommunityStatsService {
// Auction viewers can all request the same next player's internal history // Auction viewers can all request the same next player's internal history
// at once. Coalesce local cache misses so one player change does one DB read. // at once. Coalesce local cache misses so one player change does one DB read.
const inFlight = this.userInternalHistoryInFlight.get(key.identity); const inFlight = this.userInternalHistoryInFlight.get(key);
if (inFlight) return inFlight; if (inFlight) return inFlight;
const promise = this.buildUserInternalHistoryResponse(params, key); const promise = this.buildUserInternalHistoryResponse(params, key);
this.userInternalHistoryInFlight.set(key.identity, promise); this.userInternalHistoryInFlight.set(key, promise);
try { try {
return await promise; return await promise;
} finally { } finally {
if (this.userInternalHistoryInFlight.get(key.identity) === promise) { if (this.userInternalHistoryInFlight.get(key) === promise) {
this.userInternalHistoryInFlight.delete(key.identity); this.userInternalHistoryInFlight.delete(key);
} }
} }
} }
@@ -435,7 +428,7 @@ export class CommunityStatsService {
userId: mongoose.Types.ObjectId; userId: mongoose.Types.ObjectId;
filters: CommunityStatsFilters; filters: CommunityStatsFilters;
}, },
cacheKey: CommunityStatsCacheKey, cacheKey: string,
): Promise<UserInternalHistoryResponse> { ): Promise<UserInternalHistoryResponse> {
const context = await this.resolveContext( const context = await this.resolveContext(
params.communityId, params.communityId,
@@ -1145,31 +1138,18 @@ export class CommunityStatsService {
scope: string, scope: string,
communityId: mongoose.Types.ObjectId, communityId: mongoose.Types.ObjectId,
filters: CommunityStatsFilters, filters: CommunityStatsFilters,
): CommunityStatsCacheKey { ): string {
const cacheScope = scope.startsWith('userInternal:') return [
? 'userInternal' 'riot:communitystats',
: scope; scope,
if (
cacheScope !== 'matches' &&
cacheScope !== 'leaderboard' &&
cacheScope !== 'teamInsights' &&
cacheScope !== 'userInternal'
) {
throw new Error(`Unsupported community stats cache scope: ${scope}`);
}
return new CommunityStatsCacheKey(
communityId.toString(), communityId.toString(),
cacheScope, filters.seasonId ?? 'current',
JSON.stringify([ filters.from ?? '',
scope, filters.to ?? '',
filters.seasonId ?? 'current', filters.championId ?? '',
filters.from ?? '', filters.cursor ?? '',
filters.to ?? '', filters.limit ?? '',
filters.championId ?? '', ].join(':');
filters.cursor ?? '',
filters.limit ?? '',
]),
);
} }
private clampLimit( private clampLimit(
@@ -7,10 +7,7 @@ import type {
RiotLane, RiotLane,
TeamSide, TeamSide,
} from '../global/database/schema'; } from '../global/database/schema';
import type { import type { RecentMatchView, HistorySeasonDto } from '../match-history/match-history.types';
RecentMatchView,
HistorySeasonDto,
} from '../match-history/match-history.types';
export interface CommunityStatsFilters { export interface CommunityStatsFilters {
seasonId?: string; seasonId?: string;
@@ -83,9 +80,7 @@ export interface LeaderboardRow {
avgCsPerMin: number; avgCsPerMin: number;
avgDamageShare: number; avgDamageShare: number;
avgVisionScore: number; avgVisionScore: number;
byLane: Partial< byLane: Partial<Record<RiotLane, { games: number; wins: number; kda: number }>>;
Record<RiotLane, { games: number; wins: number; kda: number }>
>;
topChampions: Array<{ championId: number; games: number; winRate: number }>; topChampions: Array<{ championId: number; games: number; winRate: number }>;
} }
@@ -106,8 +106,6 @@ describe('MatchStatsFragmentBuilder', () => {
puuid: 'puuid-2', puuid: 'puuid-2',
gameName: 'Opponent', gameName: 'Opponent',
profileIconId: 8, profileIconId: 8,
preferredPositions: [],
joinedAt: new Date('2026-05-03T00:00:00.000Z'),
}); });
match.teams[1].members.push({ userId: redUserId, assignedPosition: 'TOP' }); match.teams[1].members.push({ userId: redUserId, assignedPosition: 'TOP' });
match.result?.games[0].participants.push({ match.result?.games[0].participants.push({
@@ -271,7 +269,7 @@ describe('MatchStatsFragmentBuilder', () => {
teamId: 200, teamId: 200,
win: false, win: false,
}); });
const timeline: RiotMatchTimelineDto = { const timeline = {
metadata: { metadata: {
dataVersion: '2', dataVersion: '2',
matchId: 'KR_1', matchId: 'KR_1',
@@ -282,7 +280,6 @@ describe('MatchStatsFragmentBuilder', () => {
frames: [ frames: [
{ {
timestamp: 0, timestamp: 0,
events: [],
participantFrames: { participantFrames: {
'1': { '1': {
participantId: 1, participantId: 1,
@@ -510,7 +507,9 @@ describe('MatchStatsFragmentBuilder', () => {
const fragment = builder.buildFragment({ const fragment = builder.buildFragment({
match, match,
rawByRiotMatchId: new Map([['KR_1', raw as RiotMatchDto]]), rawByRiotMatchId: new Map([['KR_1', raw as RiotMatchDto]]),
timelineByRiotMatchId: new Map([['KR_1', timeline]]), timelineByRiotMatchId: new Map([
['KR_1', timeline as RiotMatchTimelineDto],
]),
}); });
expect(fragment.gameDetails[0]).toMatchObject({ expect(fragment.gameDetails[0]).toMatchObject({
@@ -795,7 +794,9 @@ describe('MatchStatsFragmentBuilder', () => {
} as RiotMatchDto, } as RiotMatchDto,
], ],
]), ]),
timelineByRiotMatchId: new Map([['KR_1', timeline]]), timelineByRiotMatchId: new Map([
['KR_1', timeline as RiotMatchTimelineDto],
]),
}); });
expect( expect(
shortFragment.records.every((record) => record.checkpoints === undefined), shortFragment.records.every((record) => record.checkpoints === undefined),
@@ -227,7 +227,9 @@ export class MatchStatsFragmentBuilder {
participant, participant,
rawParticipant, rawParticipant,
buildEvents: rawParticipant buildEvents: rawParticipant
? buildEventsByParticipantId.get(rawParticipant.participantId) ? buildEventsByParticipantId.get(
rawParticipant.participantId,
)
: undefined, : undefined,
checkpoints: rawParticipant checkpoints: rawParticipant
? checkpointsByParticipantId.get(rawParticipant.participantId) ? checkpointsByParticipantId.get(rawParticipant.participantId)
@@ -418,10 +420,7 @@ export class MatchStatsFragmentBuilder {
private toBuildEventsByParticipantId( private toBuildEventsByParticipantId(
timeline?: RiotMatchTimelineDto, timeline?: RiotMatchTimelineDto,
): Map<number, ParticipantBuildEvents> { ): Map<number, ParticipantBuildEvents> {
const buildEventsByParticipantId = new Map< const buildEventsByParticipantId = new Map<number, ParticipantBuildEvents>();
number,
ParticipantBuildEvents
>();
if (!timeline?.info.frames.length) return buildEventsByParticipantId; if (!timeline?.info.frames.length) return buildEventsByParticipantId;
const getEvents = (participantId: number): ParticipantBuildEvents => { const getEvents = (participantId: number): ParticipantBuildEvents => {
@@ -797,18 +796,15 @@ export class MatchStatsFragmentBuilder {
? timelineDragon ? timelineDragon
: (rawObjectives?.dragon?.kills ?? 0), : (rawObjectives?.dragon?.kills ?? 0),
inhibitor: rawObjectives?.inhibitor?.kills ?? 0, inhibitor: rawObjectives?.inhibitor?.kills ?? 0,
baron: baron: (timelineObjectives?.baron ?? 0) > 0
(timelineObjectives?.baron ?? 0) > 0 ? (timelineObjectives?.baron ?? 0)
? (timelineObjectives?.baron ?? 0) : (rawObjectives?.baron?.kills ?? 0),
: (rawObjectives?.baron?.kills ?? 0), riftHerald: (timelineObjectives?.riftHerald ?? 0) > 0
riftHerald: ? (timelineObjectives?.riftHerald ?? 0)
(timelineObjectives?.riftHerald ?? 0) > 0 : (rawObjectives?.riftHerald?.kills ?? 0),
? (timelineObjectives?.riftHerald ?? 0) voidGrub: (timelineObjectives?.voidGrub ?? 0) > 0
: (rawObjectives?.riftHerald?.kills ?? 0), ? (timelineObjectives?.voidGrub ?? 0)
voidGrub: : (rawObjectives?.horde?.kills ?? 0),
(timelineObjectives?.voidGrub ?? 0) > 0
? (timelineObjectives?.voidGrub ?? 0)
: (rawObjectives?.horde?.kills ?? 0),
elderDragon: hasProjectedDragon ? timelineElder : 0, elderDragon: hasProjectedDragon ? timelineElder : 0,
}; };
} }
@@ -125,8 +125,8 @@ describe('MatchStatsRepository', () => {
if ( if (
stored && stored &&
stored.sourceCompetitionId?.equals(fragment.sourceCompetitionId) && stored.sourceCompetitionId?.equals(fragment.sourceCompetitionId!) &&
stored.sourceRevision <= fragment.sourceRevision stored.sourceRevision! <= fragment.sourceRevision!
) { ) {
stored = fragment; stored = fragment;
return { matchedCount: 1, upsertedCount: 0 }; return { matchedCount: 1, upsertedCount: 0 };
@@ -281,26 +281,15 @@ describe('MatchStatsService', () => {
MatchStatsFragmentBuilder['buildFragment'] MatchStatsFragmentBuilder['buildFragment']
>[0]; >[0];
const buildCalls: BuildParams[] = []; const buildCalls: BuildParams[] = [];
const builtFragment: ReturnType< const builtFragment = {
MatchStatsFragmentBuilder['buildFragment'] matchCard: { matchId: matchId.toString() },
> = {
matchCard: {
matchId: matchId.toString(),
title: '내전',
scheduledAt: match.scheduledAt.toISOString(),
status: 'finished',
gameCount: 1,
games: [],
teams: [],
seriesResults: [],
},
records: [], records: [],
gameDetails: [], gameDetails: [],
userIds: [], userIds: [],
championIds: [], championIds: [],
gameCreationMin: 1_000, gameCreationMin: 1_000,
gameCreationMax: 2_000, gameCreationMax: 2_000,
}; } as ReturnType<MatchStatsFragmentBuilder['buildFragment']>;
const buildFragment = jest.fn((params: BuildParams) => { const buildFragment = jest.fn((params: BuildParams) => {
buildCalls.push(params); buildCalls.push(params);
return builtFragment; return builtFragment;
@@ -6,7 +6,10 @@ 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 { CommunityDocument, UserDocument } from '../global/database/schema'; import {
CommunityDocument,
UserDocument,
} from '../global/database/schema';
export interface CreateCommunityInput { export interface CreateCommunityInput {
name: string; name: string;
@@ -10,7 +10,7 @@ describe('CompetitionBootstrapService', () => {
it('creates a deterministic paired-Series Competition and immutable snapshots', async () => { it('creates a deterministic paired-Series Competition and immutable snapshots', async () => {
const firstHarness = createHarness(); const firstHarness = createHarness();
const firstService = new CompetitionBootstrapService( const firstService = new CompetitionBootstrapService(
firstHarness.connectionService, firstHarness.connectionService as ConnectionService,
); );
const match = matchSnapshot({ gameMode: 'pair', teamCount: 2 }); const match = matchSnapshot({ gameMode: 'pair', teamCount: 2 });
@@ -88,7 +88,7 @@ describe('CompetitionBootstrapService', () => {
const secondHarness = createHarness(); const secondHarness = createHarness();
const secondService = new CompetitionBootstrapService( const secondService = new CompetitionBootstrapService(
secondHarness.connectionService, secondHarness.connectionService as ConnectionService,
); );
await secondService.bootstrap({ await secondService.bootstrap({
...match, ...match,
@@ -106,7 +106,9 @@ describe('CompetitionBootstrapService', () => {
it('maps round-robin configuration and preserves a limited round count', async () => { it('maps round-robin configuration and preserves a limited round count', async () => {
const harness = createHarness(); const harness = createHarness();
const service = new CompetitionBootstrapService(harness.connectionService); const service = new CompetitionBootstrapService(
harness.connectionService as ConnectionService,
);
await service.bootstrap( await service.bootstrap(
matchSnapshot({ matchSnapshot({
@@ -130,7 +132,9 @@ describe('CompetitionBootstrapService', () => {
it('maps double elimination seeds and stage-specific Series rules', async () => { it('maps double elimination seeds and stage-specific Series rules', async () => {
const harness = createHarness(); const harness = createHarness();
const service = new CompetitionBootstrapService(harness.connectionService); const service = new CompetitionBootstrapService(
harness.connectionService as ConnectionService,
);
const match = matchSnapshot({ const match = matchSnapshot({
gameMode: 'double-elimination', gameMode: 'double-elimination',
teamCount: 4, teamCount: 4,
@@ -173,14 +177,14 @@ describe('CompetitionBootstrapService', () => {
{ legacyTeamIndex: 4, seedNumber: 3 }, { legacyTeamIndex: 4, seedNumber: 3 },
]); ]);
expect( expect(
inserted.seriesGraph.find(({ code }) => code === 'WB_R1_M1')?.rule, inserted.seriesGraph.find(({ code }) => code === 'WB_R1_M1').rule,
).toEqual({ type: 'first-to', winsRequired: 3, maxGames: 5 }); ).toEqual({ type: 'first-to', winsRequired: 3, maxGames: 5 });
expect( expect(
inserted.seriesGraph.find(({ code }) => code?.startsWith('LB_'))?.rule, inserted.seriesGraph.find(({ code }) => code?.startsWith('LB_')).rule,
).toEqual({ type: 'first-to', winsRequired: 1, maxGames: 1 });
expect(
inserted.seriesGraph.find(({ code }) => code === 'GF')?.rule,
).toEqual({ type: 'first-to', winsRequired: 1, maxGames: 1 }); ).toEqual({ type: 'first-to', winsRequired: 1, maxGames: 1 });
expect(inserted.seriesGraph.find(({ code }) => code === 'GF').rule).toEqual(
{ type: 'first-to', winsRequired: 1, maxGames: 1 },
);
expect( expect(
inserted.seriesGraph.find(({ code }) => code === 'GF_RESET'), inserted.seriesGraph.find(({ code }) => code === 'GF_RESET'),
).toMatchObject({ ).toMatchObject({
@@ -191,7 +195,9 @@ describe('CompetitionBootstrapService', () => {
it('rejects double elimination until authoritative seeds are persisted', async () => { it('rejects double elimination until authoritative seeds are persisted', async () => {
const harness = createHarness(); const harness = createHarness();
const service = new CompetitionBootstrapService(harness.connectionService); const service = new CompetitionBootstrapService(
harness.connectionService as ConnectionService,
);
await expect( await expect(
service.bootstrap( service.bootstrap(
@@ -247,7 +253,7 @@ describe('CompetitionBootstrapService', () => {
for (const [label, mutate] of cases) { for (const [label, mutate] of cases) {
const harness = createHarness(); const harness = createHarness();
const service = new CompetitionBootstrapService( const service = new CompetitionBootstrapService(
harness.connectionService, harness.connectionService as ConnectionService,
); );
const match = matchSnapshot({ gameMode: 'pair', teamCount: 2 }); const match = matchSnapshot({ gameMode: 'pair', teamCount: 2 });
mutate(match); mutate(match);
@@ -266,7 +272,7 @@ describe('CompetitionBootstrapService', () => {
it('rejects bracket mode live but explicitly maps it for legacy migration', async () => { it('rejects bracket mode live but explicitly maps it for legacy migration', async () => {
const liveHarness = createHarness(); const liveHarness = createHarness();
const liveService = new CompetitionBootstrapService( const liveService = new CompetitionBootstrapService(
liveHarness.connectionService, liveHarness.connectionService as ConnectionService,
); );
const match = matchSnapshot({ gameMode: 'bracket', teamCount: 2 }); const match = matchSnapshot({ gameMode: 'bracket', teamCount: 2 });
@@ -279,7 +285,7 @@ describe('CompetitionBootstrapService', () => {
const migrationHarness = createHarness(); const migrationHarness = createHarness();
const migrationService = new CompetitionBootstrapService( const migrationService = new CompetitionBootstrapService(
migrationHarness.connectionService, migrationHarness.connectionService as ConnectionService,
); );
await migrationService.bootstrap(match, { source: 'legacy-migration' }); await migrationService.bootstrap(match, { source: 'legacy-migration' });
@@ -290,7 +296,9 @@ describe('CompetitionBootstrapService', () => {
it('upserts once and links only an unlinked or already-linked Match in one transaction', async () => { it('upserts once and links only an unlinked or already-linked Match in one transaction', async () => {
const harness = createHarness(); const harness = createHarness();
const service = new CompetitionBootstrapService(harness.connectionService); const service = new CompetitionBootstrapService(
harness.connectionService as ConnectionService,
);
const competition = await service.bootstrap( const competition = await service.bootstrap(
matchSnapshot({ gameMode: 'pair', teamCount: 2 }), matchSnapshot({ gameMode: 'pair', teamCount: 2 }),
@@ -334,7 +342,9 @@ describe('CompetitionBootstrapService', () => {
revision: 4, revision: 4,
}; };
const harness = createHarness({ existingCompetition: existing }); const harness = createHarness({ existingCompetition: existing });
const service = new CompetitionBootstrapService(harness.connectionService); const service = new CompetitionBootstrapService(
harness.connectionService as ConnectionService,
);
const result = await service.bootstrap( const result = await service.bootstrap(
matchSnapshot({ gameMode: 'pair', teamCount: 2 }), matchSnapshot({ gameMode: 'pair', teamCount: 2 }),
@@ -362,7 +372,9 @@ describe('CompetitionBootstrapService', () => {
competitionResults: [duplicateKey, winner], competitionResults: [duplicateKey, winner],
sessionCount: 2, sessionCount: 2,
}); });
const service = new CompetitionBootstrapService(harness.connectionService); const service = new CompetitionBootstrapService(
harness.connectionService as ConnectionService,
);
const result = await service.bootstrap( const result = await service.bootstrap(
matchSnapshot({ gameMode: 'pair', teamCount: 2 }), matchSnapshot({ gameMode: 'pair', teamCount: 2 }),
@@ -379,7 +391,9 @@ describe('CompetitionBootstrapService', () => {
it('aborts when the Match is already linked to a different Competition', async () => { it('aborts when the Match is already linked to a different Competition', async () => {
const harness = createHarness({ matchUpdateResult: { matchedCount: 0 } }); const harness = createHarness({ matchUpdateResult: { matchedCount: 0 } });
const service = new CompetitionBootstrapService(harness.connectionService); const service = new CompetitionBootstrapService(
harness.connectionService as ConnectionService,
);
await expect( await expect(
service.bootstrap(matchSnapshot({ gameMode: 'pair', teamCount: 2 })), service.bootstrap(matchSnapshot({ gameMode: 'pair', teamCount: 2 })),
@@ -471,7 +485,11 @@ function createHarness(
let competitionCall = 0; let competitionCall = 0;
const competitionModel = { const competitionModel = {
findOneAndUpdate: jest.fn( findOneAndUpdate: jest.fn(
(_filter: unknown, update: { $setOnInsert: InsertPayload }) => { (
_filter: unknown,
update: { $setOnInsert: InsertPayload },
_queryOptions: unknown,
) => {
insertedPayloads.push(update.$setOnInsert); insertedPayloads.push(update.$setOnInsert);
const selected = options.competitionResults?.[competitionCall++]; const selected = options.competitionResults?.[competitionCall++];
if (selected instanceof Error) return rejectedQuery(selected); if (selected instanceof Error) return rejectedQuery(selected);
@@ -494,7 +512,7 @@ function createHarness(
const connectionService = { const connectionService = {
createSession: jest.fn(() => Promise.resolve(sessions[sessionIndex++])), createSession: jest.fn(() => Promise.resolve(sessions[sessionIndex++])),
getModel: jest.fn((name: string) => Promise.resolve(models[name])), getModel: jest.fn((name: string) => Promise.resolve(models[name])),
} as unknown as jest.Mocked<ConnectionService>; };
return { return {
sessions, sessions,
@@ -22,7 +22,9 @@ describe('CompetitionCommandService', () => {
it('rejects a stale expected revision and aborts without writing', async () => { it('rejects a stale expected revision and aborts without writing', async () => {
const harness = createHarness({ competitionRevision: 8 }); const harness = createHarness({ competitionRevision: 8 });
const service = new CompetitionCommandService(harness.connectionService); const service = new CompetitionCommandService(
harness.connectionService as ConnectionService,
);
await expect(service.acceptGame(acceptGameCommand())).rejects.toMatchObject( await expect(service.acceptGame(acceptGameCommand())).rejects.toMatchObject(
{ {
@@ -42,7 +44,9 @@ describe('CompetitionCommandService', () => {
it('uses the expected revision in the persistence CAS and aborts a lost race', async () => { it('uses the expected revision in the persistence CAS and aborts a lost race', async () => {
const harness = createHarness({ casResult: null }); const harness = createHarness({ casResult: null });
const service = new CompetitionCommandService(harness.connectionService); const service = new CompetitionCommandService(
harness.connectionService as ConnectionService,
);
await expect(service.acceptGame(acceptGameCommand())).rejects.toMatchObject( await expect(service.acceptGame(acceptGameCommand())).rejects.toMatchObject(
{ {
@@ -82,7 +86,9 @@ describe('CompetitionCommandService', () => {
return Promise.resolve([receipt]); return Promise.resolve([receipt]);
}, },
); );
const service = new CompetitionCommandService(harness.connectionService); const service = new CompetitionCommandService(
harness.connectionService as ConnectionService,
);
const command = acceptGameCommand(); const command = acceptGameCommand();
const first = await service.acceptGame(command); const first = await service.acceptGame(command);
@@ -127,7 +133,9 @@ describe('CompetitionCommandService', () => {
}); });
}, },
); );
const service = new CompetitionCommandService(harness.connectionService); const service = new CompetitionCommandService(
harness.connectionService as ConnectionService,
);
await expect( await expect(
service.acceptGame(acceptGameCommand()), service.acceptGame(acceptGameCommand()),
@@ -154,7 +162,9 @@ describe('CompetitionCommandService', () => {
revision: 8, revision: 8,
}), }),
); );
const service = new CompetitionCommandService(harness.connectionService); const service = new CompetitionCommandService(
harness.connectionService as ConnectionService,
);
await expect(service.acceptGame(acceptGameCommand())).rejects.toMatchObject( await expect(service.acceptGame(acceptGameCommand())).rejects.toMatchObject(
{ {
@@ -170,7 +180,9 @@ describe('CompetitionCommandService', () => {
it('atomically accepts a code-backed game, projects it, and enqueues an event', async () => { it('atomically accepts a code-backed game, projects it, and enqueues an event', async () => {
const harness = createHarness(); const harness = createHarness();
const service = new CompetitionCommandService(harness.connectionService); const service = new CompetitionCommandService(
harness.connectionService as ConnectionService,
);
const command = { const command = {
...acceptGameCommand(), ...acceptGameCommand(),
tournamentCode: { tournamentCode: {
@@ -267,7 +279,9 @@ describe('CompetitionCommandService', () => {
it('appends an administrative adjudication through the same command runner', async () => { it('appends an administrative adjudication through the same command runner', async () => {
const harness = createHarness(); const harness = createHarness();
const service = new CompetitionCommandService(harness.connectionService); const service = new CompetitionCommandService(
harness.connectionService as ConnectionService,
);
const result = await service.adjudicateSeries({ const result = await service.adjudicateSeries({
competitionId: COMPETITION_ID, competitionId: COMPETITION_ID,
@@ -302,7 +316,9 @@ describe('CompetitionCommandService', () => {
facts: reversal.facts, facts: reversal.facts,
assignments: reversal.assignments, assignments: reversal.assignments,
}); });
const service = new CompetitionCommandService(harness.connectionService); const service = new CompetitionCommandService(
harness.connectionService as ConnectionService,
);
const preview = await service.previewSeriesReversal({ const preview = await service.previewSeriesReversal({
competitionId: COMPETITION_ID, competitionId: COMPETITION_ID,
@@ -332,7 +348,9 @@ describe('CompetitionCommandService', () => {
it('rejects a reversal preview at a stale revision', async () => { it('rejects a reversal preview at a stale revision', async () => {
const reversal = reversalFixture(); const reversal = reversalFixture();
const harness = createHarness({ competition: reversal.competition }); const harness = createHarness({ competition: reversal.competition });
const service = new CompetitionCommandService(harness.connectionService); const service = new CompetitionCommandService(
harness.connectionService as ConnectionService,
);
await expect( await expect(
service.previewSeriesReversal({ service.previewSeriesReversal({
@@ -354,7 +372,9 @@ describe('CompetitionCommandService', () => {
facts: reversal.facts, facts: reversal.facts,
assignments: reversal.assignments, assignments: reversal.assignments,
}); });
const service = new CompetitionCommandService(harness.connectionService); const service = new CompetitionCommandService(
harness.connectionService as ConnectionService,
);
const preview = await service.previewSeriesReversal({ const preview = await service.previewSeriesReversal({
competitionId: COMPETITION_ID, competitionId: COMPETITION_ID,
expectedRevision: 7, expectedRevision: 7,
@@ -465,7 +485,9 @@ describe('CompetitionCommandService', () => {
}), }),
) )
.mockResolvedValueOnce([]); .mockResolvedValueOnce([]);
const service = new CompetitionCommandService(harness.connectionService); const service = new CompetitionCommandService(
harness.connectionService as ConnectionService,
);
const preview = await service.previewSeriesReversal({ const preview = await service.previewSeriesReversal({
competitionId: COMPETITION_ID, competitionId: COMPETITION_ID,
expectedRevision: 7, expectedRevision: 7,
@@ -613,7 +635,7 @@ function createHarness(
const connectionService = { const connectionService = {
createSession: jest.fn().mockResolvedValue(session), createSession: jest.fn().mockResolvedValue(session),
getModel: jest.fn((name: string) => Promise.resolve(models[name])), getModel: jest.fn((name: string) => Promise.resolve(models[name])),
} as unknown as jest.Mocked<ConnectionService>; };
return { return {
session, session,
@@ -160,7 +160,9 @@ const SERIES_ID = 'series-1';
const GAME_SLOT_ID = 'slot-1'; const GAME_SLOT_ID = 'slot-1';
function createService(harness: ReturnType<typeof createHarness>) { function createService(harness: ReturnType<typeof createHarness>) {
return new CompetitionQueryService(harness.connectionService); return new CompetitionQueryService(
harness.connectionService as ConnectionService,
);
} }
function createHarness(options: { competition?: unknown } = {}) { function createHarness(options: { competition?: unknown } = {}) {
@@ -242,7 +244,7 @@ function createHarness(options: { competition?: unknown } = {}) {
factModel, factModel,
connectionService: { connectionService: {
getModel: jest.fn((name: string) => Promise.resolve(models[name])), getModel: jest.fn((name: string) => Promise.resolve(models[name])),
} as unknown as jest.Mocked<ConnectionService>, },
}; };
} }
@@ -127,7 +127,7 @@ describe('Competition persistence schemas', () => {
function expectIndexes( function expectIndexes(
schema: { schema: {
indexes(): ReturnType<typeof CompetitionSchema.indexes>; indexes(): Array<[Record<string, number>, Record<string, unknown>]>;
}, },
expected: Array<{ expected: Array<{
keys: Record<string, number>; keys: Record<string, number>;
@@ -429,14 +429,8 @@ export function applyCompetitionDomainInvariantIndexes(
} }
} }
export type CompetitionModelName =
| 'competition'
| 'competitionFact'
| 'competitionOutbox'
| 'tournamentCodeAssignment';
export const competitionModelDefinitions: Array<{ export const competitionModelDefinitions: Array<{
name: CompetitionModelName; name: string;
schema: mongoose.Schema; schema: mongoose.Schema;
schemaName: string; schemaName: string;
}> = [ }> = [
@@ -1,8 +1,4 @@
import { projectCompetition } from './competition-projector'; import { projectCompetition } from './competition-projector';
import {
CompetitionDomainError,
type CompetitionDomainErrorCode,
} from './domain-error';
import { generateSeriesGraph } from './series-graph'; import { generateSeriesGraph } from './series-graph';
describe('projectCompetition', () => { describe('projectCompetition', () => {
@@ -327,18 +323,20 @@ describe('projectCompetition', () => {
'team-1', 'team-1',
); );
expectCompetitionDomainError( expect(() =>
() => projectCompetition({
projectCompetition({ competitionId,
competitionId, revision: 1,
revision: 1, projectorVersion: 1,
projectorVersion: 1, teams,
teams, format,
format, seriesGraph,
seriesGraph, facts: [{ ...accepted, seriesId: 'series-does-not-exist' }],
facts: [{ ...accepted, seriesId: 'series-does-not-exist' }], }),
}), ).toThrow(
'GAME_SERIES_MISMATCH', expect.objectContaining({
code: 'GAME_SERIES_MISMATCH',
}),
); );
}); });
@@ -358,18 +356,20 @@ describe('projectCompetition', () => {
'team-1', 'team-1',
); );
expectCompetitionDomainError( expect(() =>
() => projectCompetition({
projectCompetition({ competitionId,
competitionId, revision: 1,
revision: 1, projectorVersion: 1,
projectorVersion: 1, teams,
teams, format,
format, seriesGraph,
seriesGraph, facts: [{ ...accepted, gameSlotId: 'slot-does-not-exist' }],
facts: [{ ...accepted, gameSlotId: 'slot-does-not-exist' }], }),
}), ).toThrow(
'GAME_SLOT_INVALID', expect.objectContaining({
code: 'GAME_SLOT_INVALID',
}),
); );
}); });
@@ -382,34 +382,36 @@ describe('projectCompetition', () => {
}; };
const seriesGraph = generateSeriesGraph({ competitionId, teams, format }); const seriesGraph = generateSeriesGraph({ competitionId, teams, format });
expectCompetitionDomainError( expect(() =>
() => projectCompetition({
projectCompetition({ competitionId,
competitionId, revision: 1,
revision: 1, projectorVersion: 1,
projectorVersion: 1, teams,
teams, format,
format, seriesGraph,
seriesGraph, facts: [
facts: [ {
{ id: 'fact-unknown-adjudication-series',
id: 'fact-unknown-adjudication-series', type: 'series-adjudicated',
type: 'series-adjudicated', competitionId,
competitionId, revision: 1,
revision: 1, ordinalWithinRevision: 1,
ordinalWithinRevision: 1, commandId: 'command-unknown-adjudication-series',
commandId: 'command-unknown-adjudication-series', schemaVersion: 1,
schemaVersion: 1, actor: { type: 'user' },
actor: { type: 'user' }, occurredAt: new Date('2026-07-12T00:00:01.000Z'),
occurredAt: new Date('2026-07-12T00:00:01.000Z'), recordedAt: new Date('2026-07-12T00:00:02.000Z'),
recordedAt: new Date('2026-07-12T00:00:02.000Z'), seriesId: 'series-does-not-exist',
seriesId: 'series-does-not-exist', decision: { type: 'administrative', winnerTeamId: 'team-1' },
decision: { type: 'administrative', winnerTeamId: 'team-1' }, reason: 'Manual correction',
reason: 'Manual correction', },
}, ],
], }),
}), ).toThrow(
'ADJUDICATION_INVALID', expect.objectContaining({
code: 'ADJUDICATION_INVALID',
}),
); );
}); });
@@ -589,10 +591,9 @@ function acceptedGameFactory(competitionId: string) {
}; };
} }
function projectedSeries<T extends { code?: string; seriesId: string }>( function projectedSeries<
projection: { series: T[] }, T extends { series: Array<{ code?: string; seriesId: string }> },
code: string, >(projection: T, code: string) {
) {
const series = projection.series.find((candidate) => candidate.code === code); const series = projection.series.find((candidate) => candidate.code === code);
if (!series) throw new Error(`Missing projected series ${code}`); if (!series) throw new Error(`Missing projected series ${code}`);
return series; return series;
@@ -616,23 +617,3 @@ interface GameSlotLike {
id: string; id: string;
ordinal: number; ordinal: number;
} }
function expectCompetitionDomainError(
action: () => unknown,
expectedCode: CompetitionDomainErrorCode,
): void {
let thrown: unknown;
try {
action();
} catch (error: unknown) {
thrown = error;
}
expect(thrown).toBeInstanceOf(CompetitionDomainError);
if (!(thrown instanceof CompetitionDomainError)) {
throw new Error(
`Expected CompetitionDomainError, received ${String(thrown)}`,
);
}
expect(thrown.code).toBe(expectedCode);
}
@@ -1,7 +1,6 @@
import { import {
assertReversalPreview, assertReversalPreview,
buildReversalFacts, buildReversalFacts,
CompetitionReversalError,
previewSeriesReversal, previewSeriesReversal,
} from './competition-reversal'; } from './competition-reversal';
@@ -20,18 +19,18 @@ describe('Competition reversal planning', () => {
]; ];
it('rejects strict reversal when a descendant has result activity', () => { it('rejects strict reversal when a descendant has result activity', () => {
expectCompetitionReversalError( expect(() =>
() => previewSeriesReversal({
previewSeriesReversal({ competitionId: 'competition-1',
competitionId: 'competition-1', revision: 2,
revision: 2, seriesId: 'series-parent',
seriesId: 'series-parent', mode: 'strict',
mode: 'strict', graph,
graph, facts,
facts, assignments,
assignments, }),
}), ).toThrow(
'REVERSAL_DESCENDANT_ACTIVITY', expect.objectContaining({ code: 'REVERSAL_DESCENDANT_ACTIVITY' }),
); );
}); });
@@ -106,22 +105,20 @@ describe('Competition reversal planning', () => {
assignments, assignments,
}); });
expectCompetitionReversalError( expect(() =>
() => assertReversalPreview(
assertReversalPreview( {
{ competitionId: 'competition-1',
competitionId: 'competition-1', revision: 3,
revision: 3, seriesId: 'series-parent',
seriesId: 'series-parent', mode: 'cascade',
mode: 'cascade', graph,
graph, facts,
facts, assignments,
assignments, },
}, preview.impactHash,
preview.impactHash, ),
), ).toThrow(expect.objectContaining({ code: 'REVERSAL_PREVIEW_STALE' }));
'REVERSAL_PREVIEW_STALE',
);
}); });
it('emits one append-only reversal fact for every active result fact', () => { it('emits one append-only reversal fact for every active result fact', () => {
@@ -163,26 +160,6 @@ describe('Competition reversal planning', () => {
}); });
}); });
function expectCompetitionReversalError(
action: () => unknown,
expectedCode: CompetitionReversalError['code'],
): void {
let thrown: unknown;
try {
action();
} catch (error: unknown) {
thrown = error;
}
expect(thrown).toBeInstanceOf(CompetitionReversalError);
if (!(thrown instanceof CompetitionReversalError)) {
throw new Error(
`Expected CompetitionReversalError, received ${String(thrown)}`,
);
}
expect(thrown.code).toBe(expectedCode);
}
function series(id: string, sources: Array<Record<string, unknown>>) { function series(id: string, sources: Array<Record<string, unknown>>) {
return { return {
id, id,
@@ -9,8 +9,7 @@ import { DakaoOutboxService } from './dakao-outbox.service';
const SWEEP_INTERVAL_MS = 60 * 1000; const SWEEP_INTERVAL_MS = 60 * 1000;
const STALE_OUTBOX_MS = 5 * 60 * 1000; const STALE_OUTBOX_MS = 5 * 60 * 1000;
const SWEEP_LOCK_KEY = const SWEEP_LOCK_KEY = 'distributed-lock:dakao-outbox:sweep-stale-publish-leases';
'distributed-lock:dakao-outbox:sweep-stale-publish-leases';
const SWEEP_LOCK_EXPIRATION_DURATION_MILLISECONDS = 55_000; const SWEEP_LOCK_EXPIRATION_DURATION_MILLISECONDS = 55_000;
@Injectable() @Injectable()
@@ -78,29 +78,35 @@ export class DakaoOutboxService {
await this.natsService.publishJetStream(params.subject, params.envelope, { await this.natsService.publishJetStream(params.subject, params.envelope, {
messageId: params.eventId, messageId: params.eventId,
}); });
await OutboxModel.updateOne(updateFilter, { await OutboxModel.updateOne(
$set: { updateFilter,
state: 'published', {
publishedAt: new Date(), $set: {
state: 'published',
publishedAt: new Date(),
},
$inc: { publishAttempts: 1 },
$unset: {
lastPublishError: '',
publishLeaseOwnerIdentifier: '',
publishLeaseExpiresAt: '',
},
}, },
$inc: { publishAttempts: 1 }, ).exec();
$unset: {
lastPublishError: '',
publishLeaseOwnerIdentifier: '',
publishLeaseExpiresAt: '',
},
}).exec();
} catch (err) { } catch (err) {
await OutboxModel.updateOne(updateFilter, { await OutboxModel.updateOne(
$inc: { publishAttempts: 1 }, updateFilter,
$set: { {
lastPublishError: (err as Error)?.message ?? String(err), $inc: { publishAttempts: 1 },
$set: {
lastPublishError: (err as Error)?.message ?? String(err),
},
$unset: {
publishLeaseOwnerIdentifier: '',
publishLeaseExpiresAt: '',
},
}, },
$unset: { ).exec();
publishLeaseOwnerIdentifier: '',
publishLeaseExpiresAt: '',
},
}).exec();
this.logger.error( this.logger.error(
`Failed to publish Dakao outbox eventId=${params.eventId}: ${ `Failed to publish Dakao outbox eventId=${params.eventId}: ${
(err as Error)?.stack ?? err (err as Error)?.stack ?? err
@@ -1,122 +0,0 @@
import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service';
import { RiotAccountService } from '../riot/riot-account.service';
import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service';
import { DakaoUserService } from './dakao-user.service';
const communityId = new mongoose.Types.ObjectId();
const params = {
communityId,
kakaoTalkId: 'new-id',
previousNickname: '예전 닉',
};
function setup() {
const user = {
_id: new mongoose.Types.ObjectId(),
communityId,
kakaoTalkId: 'old-id',
kakaoTalkNickname: '예전 닉',
riotAccounts: [{ puuid: 'puuid', gameName: '소환사', tagLine: 'KR1' }],
role: 'member',
};
const find = jest.fn().mockReturnValue({
limit: jest
.fn()
.mockReturnValue({ exec: jest.fn().mockResolvedValue([user]) }),
});
const findOne = jest
.fn()
.mockReturnValue({ exec: jest.fn().mockResolvedValue(null) });
const update = jest
.fn()
.mockImplementation(async () => ({ ...user, kakaoTalkId: 'new-id' }));
const findOneAndUpdate = jest.fn().mockReturnValue({ exec: update });
const service = new DakaoUserService(
{
getModel: jest
.fn()
.mockResolvedValue({ find, findOne, findOneAndUpdate }),
} as unknown as ConnectionService,
{} as RiotAccountService,
{} as RiotAccountEnrichmentService,
);
return { service, user, find, findOne, findOneAndUpdate, update };
}
describe('DakaoUserService.transferKakaoTalkId', () => {
it('selects registered users by exact nickname in the current community and changes only the ID', async () => {
const { service, user, find, findOneAndUpdate } = setup();
expect(await service.transferKakaoTalkId(params)).toBe('transferred');
expect(find).toHaveBeenCalledWith({
communityId,
kakaoTalkNickname: '예전 닉',
'riotAccounts.0': { $exists: true },
});
expect(findOneAndUpdate).toHaveBeenCalledWith(
{
_id: user._id,
communityId,
kakaoTalkId: 'old-id',
kakaoTalkNickname: '예전 닉',
'riotAccounts.0': { $exists: true },
},
{ $set: { kakaoTalkId: 'new-id' } },
{ returnDocument: 'after' },
);
});
it.each([
['not-found', 0],
['ambiguous', 2],
] as const)('returns %s without mutation', async (status, count) => {
const { service, user, find, findOneAndUpdate } = setup();
find.mockReturnValue({
limit: () => ({
exec: async () => Array.from({ length: count }, () => user),
}),
});
expect(await service.transferKakaoTalkId(params)).toBe(status);
expect(findOneAndUpdate).not.toHaveBeenCalled();
});
it('does not mutate an already linked user', async () => {
const { service, user, findOneAndUpdate } = setup();
user.kakaoTalkId = 'new-id';
expect(await service.transferKakaoTalkId(params)).toBe('already-linked');
expect(findOneAndUpdate).not.toHaveBeenCalled();
});
it('refuses an ID occupied by another user', async () => {
const { service, findOne, findOneAndUpdate } = setup();
findOne.mockReturnValue({
exec: async () => ({ _id: new mongoose.Types.ObjectId() }),
});
expect(await service.transferKakaoTalkId(params)).toBe('id-conflict');
expect(findOne).toHaveBeenCalledWith({
communityId,
kakaoTalkId: 'new-id',
});
expect(findOneAndUpdate).not.toHaveBeenCalled();
});
it('reports a concurrent change instead of overwriting it', async () => {
const { service, update } = setup();
update.mockResolvedValue(null);
expect(await service.transferKakaoTalkId(params)).toBe('changed');
});
it('handles a concurrent ID collision', async () => {
const { service, update } = setup();
update.mockRejectedValue({ code: 11000 });
expect(await service.transferKakaoTalkId(params)).toBe('id-conflict');
});
it('propagates unexpected database failures for retry', async () => {
const { service, update } = setup();
update.mockRejectedValue(new Error('database unavailable'));
await expect(service.transferKakaoTalkId(params)).rejects.toThrow(
'database unavailable',
);
});
});
@@ -105,7 +105,7 @@ describe('DakaoUserService', () => {
tagLine: 'KR2', tagLine: 'KR2',
isPrimary: false, isPrimary: false,
}); });
expect(result.user.riotAccounts[0]).toMatchObject({ expect((result.user.riotAccounts as RiotAccount[])[0]).toMatchObject({
puuid: 'puuid-1', puuid: 'puuid-1',
isPrimary: true, isPrimary: true,
}); });
@@ -223,21 +223,11 @@ describe('DakaoUserService', () => {
puuid: 'puuid-1', puuid: 'puuid-1',
gameName: '기존소환사', gameName: '기존소환사',
tagLine: 'KR1', tagLine: 'KR1',
profileIconId: 1,
revisionDate: 0,
summonerLevel: 30,
tiers: [],
tierHistory: [],
matchIds: [],
championMasteries: [],
championRecords: {},
isPrimary: true, isPrimary: true,
createdAt: new Date('2026-05-03T00:00:00.000Z'),
updatedAt: new Date('2026-05-03T00:00:00.000Z'),
}, },
], ],
save, save,
} satisfies Partial<UserDocument>, } as Partial<UserDocument>,
}); });
await expect( await expect(
@@ -60,14 +60,6 @@ interface ResolvedRiotIdentity {
const DEFAULT_RIOT_PLATFORM: RiotPlatformRoute = 'kr'; const DEFAULT_RIOT_PLATFORM: RiotPlatformRoute = 'kr';
const DEFAULT_RIOT_REGION: RiotRegionalRoute = 'asia'; const DEFAULT_RIOT_REGION: RiotRegionalRoute = 'asia';
export type KakaoDataTransferResult =
| 'transferred'
| 'already-linked'
| 'not-found'
| 'ambiguous'
| 'id-conflict'
| 'changed';
@Injectable() @Injectable()
export class DakaoUserService { export class DakaoUserService {
private readonly logger = new Logger(DakaoUserService.name); private readonly logger = new Logger(DakaoUserService.name);
@@ -95,7 +87,7 @@ export class DakaoUserService {
if (!community) { if (!community) {
throw new DakaoUserError('community_not_found', dakaoProjectId); throw new DakaoUserError('community_not_found', dakaoProjectId);
} }
return community._id; return community._id as mongoose.Types.ObjectId;
} }
public async upsertUser(params: { public async upsertUser(params: {
@@ -135,44 +127,6 @@ export class DakaoUserService {
}).exec(); }).exec();
} }
public async transferKakaoTalkId(params: {
communityId: mongoose.Types.ObjectId;
kakaoTalkId: string;
previousNickname: string;
}): Promise<KakaoDataTransferResult> {
const UserModel = await this.connectionService.getModel('user');
const targetFilter = {
communityId: params.communityId,
kakaoTalkNickname: params.previousNickname,
'riotAccounts.0': { $exists: true },
};
const candidates = await UserModel.find(targetFilter).limit(2).exec();
if (candidates.length === 0) return 'not-found';
if (candidates.length > 1) return 'ambiguous';
const user = candidates[0];
if (user.kakaoTalkId === params.kakaoTalkId) return 'already-linked';
const occupied = await this.findUserByKakaoTalkId(params);
if (occupied) return 'id-conflict';
try {
// Compare the previous ID so concurrent transfers cannot overwrite one another.
const updated = await UserModel.findOneAndUpdate(
{
...targetFilter,
_id: user._id,
kakaoTalkId: user.kakaoTalkId ?? null,
},
{ $set: { kakaoTalkId: params.kakaoTalkId } },
{ returnDocument: 'after' },
).exec();
return updated ? 'transferred' : 'changed';
} catch (error) {
if ((error as { code?: number })?.code === 11000) return 'id-conflict';
throw error;
}
}
public async resolveRiotAccount( public async resolveRiotAccount(
context: ResolveContext, context: ResolveContext,
): Promise<ResolveResult> { ): Promise<ResolveResult> {
@@ -12,7 +12,6 @@ import { DakaoUserService } from './dakao-user.service';
import { DakaoSendResultSubscriber } from './dakao-send-result.subscriber'; import { DakaoSendResultSubscriber } from './dakao-send-result.subscriber';
import { DakaoUrlShortenerService } from './dakao-url-shortener.service'; import { DakaoUrlShortenerService } from './dakao-url-shortener.service';
import { AccountRegisterHandler } from './handlers/account-register.handler'; import { AccountRegisterHandler } from './handlers/account-register.handler';
import { DataTransferHandler } from './handlers/data-transfer.handler';
import { MatchCancelHandler } from './handlers/match-cancel.handler'; import { MatchCancelHandler } from './handlers/match-cancel.handler';
import { MatchJoinHandler } from './handlers/match-join.handler'; import { MatchJoinHandler } from './handlers/match-join.handler';
import { MatchListHandler } from './handlers/match-list.handler'; import { MatchListHandler } from './handlers/match-list.handler';
@@ -36,7 +35,6 @@ import { PrimaryAccountChangeHandler } from './handlers/primary-account-change.h
DakaoUserService, DakaoUserService,
DakaoUrlShortenerService, DakaoUrlShortenerService,
AccountRegisterHandler, AccountRegisterHandler,
DataTransferHandler,
MatchListHandler, MatchListHandler,
MatchJoinHandler, MatchJoinHandler,
MatchCancelHandler, MatchCancelHandler,
@@ -16,7 +16,6 @@ function makeSubscriber(): DakaoSubscriber {
{} as never, {} as never,
{} as never, {} as never,
{} as never, {} as never,
{} as never,
); );
} }
@@ -40,48 +39,6 @@ const event = {
} satisfies DakaoInboundEvent; } satisfies DakaoInboundEvent;
describe('DakaoSubscriber', () => { describe('DakaoSubscriber', () => {
it('routes data transfer with the current sender ID and publishes its reply', async () => {
const subscriber = makeSubscriber();
const segments = [{ kind: 'text', text: ' 데이터 이관 완료' }];
const handle = jest.fn().mockResolvedValue(segments);
const sendMessage = jest.fn();
const markProcessed = jest.fn();
Object.assign(subscriber, {
dakaoUserService: {
resolveCommunityIdByDakaoProjectId: async () => event.projectId,
},
dataTransferHandler: { handle },
publisher: { sendMessage },
inbox: { claim: async () => ({ status: 'claimed' }), markProcessed },
});
await (
subscriber as unknown as {
handleEvent: (input: DakaoInboundEvent) => Promise<void>;
}
).handleEvent({
...event,
origin: {
...event.origin,
chatLog: {
...event.origin.chatLog,
message: '!내전 데이터이관 예전 닉',
},
},
});
expect(handle).toHaveBeenCalledWith({
communityId: event.projectId,
senderUserId: '12345',
senderNickname: '프리리',
previousNickname: '예전 닉',
});
expect(sendMessage).toHaveBeenCalledWith({
chatroomId: 'chatroom-1',
segments,
correlationId: 'log-1',
});
expect(markProcessed).toHaveBeenCalled();
});
it('renders usage help with star emoticon command lines', () => { it('renders usage help with star emoticon command lines', () => {
const subscriber = makeSubscriber() as unknown as { const subscriber = makeSubscriber() as unknown as {
parseErrorReply: ( parseErrorReply: (
@@ -108,8 +65,6 @@ describe('DakaoSubscriber', () => {
text: ' !내전 신청 코드 소환사이름#태그 포지션1,포지션2\u3000\n', text: ' !내전 신청 코드 소환사이름#태그 포지션1,포지션2\u3000\n',
}, },
{ kind: 'emoticon', id: '1200281_035', altText: '스타' }, { kind: 'emoticon', id: '1200281_035', altText: '스타' },
{ kind: 'text', text: ' !내전 취소 코드\u3000\n' },
{ kind: 'emoticon', id: '1200281_035', altText: '스타' },
{ kind: 'text', text: ' !내전 계정등록 소환사이름#태그\u3000\n' }, { kind: 'text', text: ' !내전 계정등록 소환사이름#태그\u3000\n' },
{ kind: 'emoticon', id: '1200281_035', altText: '스타' }, { kind: 'emoticon', id: '1200281_035', altText: '스타' },
{ {
@@ -119,10 +74,8 @@ describe('DakaoSubscriber', () => {
{ kind: 'emoticon', id: '1200281_035', altText: '스타' }, { kind: 'emoticon', id: '1200281_035', altText: '스타' },
{ {
kind: 'text', kind: 'text',
text: ' !내전 대표계정변경 소환사이름#태그\u3000\n', text: ' !내전 대표계정변경 소환사이름#태그',
}, },
{ kind: 'emoticon', id: '1200281_035', altText: '스타' },
{ kind: 'text', text: ' !내전 데이터이관 이전카카오톡채팅방닉네임' },
]); ]);
}); });
+1 -13
View File
@@ -7,7 +7,6 @@ import { DakaoInboundEvent, DakaoLong, DakaoSegment } from './dakao.types';
import { DakaoPublisher } from './dakao.publisher'; import { DakaoPublisher } from './dakao.publisher';
import { DakaoUserError, DakaoUserService } from './dakao-user.service'; import { DakaoUserError, DakaoUserService } from './dakao-user.service';
import { AccountRegisterHandler } from './handlers/account-register.handler'; import { AccountRegisterHandler } from './handlers/account-register.handler';
import { DataTransferHandler } from './handlers/data-transfer.handler';
import { MatchCancelHandler } from './handlers/match-cancel.handler'; import { MatchCancelHandler } from './handlers/match-cancel.handler';
import { MatchJoinHandler } from './handlers/match-join.handler'; import { MatchJoinHandler } from './handlers/match-join.handler';
import { MatchListHandler } from './handlers/match-list.handler'; import { MatchListHandler } from './handlers/match-list.handler';
@@ -25,11 +24,9 @@ export class DakaoSubscriber implements OnModuleInit {
private readonly usageCommands = [ private readonly usageCommands = [
'!내전 일정', '!내전 일정',
'!내전 신청 코드 소환사이름#태그 포지션1,포지션2', '!내전 신청 코드 소환사이름#태그 포지션1,포지션2',
'!내전 취소 코드',
'!내전 계정등록 소환사이름#태그', '!내전 계정등록 소환사이름#태그',
'!내전 선호포지션등록 포지션1,포지션2', '!내전 선호포지션등록 포지션1,포지션2',
'!내전 대표계정변경 소환사이름#태그', '!내전 대표계정변경 소환사이름#태그',
'!내전 데이터이관 이전카카오톡채팅방닉네임',
]; ];
constructor( constructor(
@@ -45,7 +42,6 @@ export class DakaoSubscriber implements OnModuleInit {
private readonly matchCancelHandler: MatchCancelHandler, private readonly matchCancelHandler: MatchCancelHandler,
private readonly preferredPositionRegisterHandler: PreferredPositionRegisterHandler, private readonly preferredPositionRegisterHandler: PreferredPositionRegisterHandler,
private readonly primaryAccountChangeHandler: PrimaryAccountChangeHandler, private readonly primaryAccountChangeHandler: PrimaryAccountChangeHandler,
private readonly dataTransferHandler: DataTransferHandler,
) {} ) {}
async onModuleInit() { async onModuleInit() {
@@ -123,14 +119,6 @@ export class DakaoSubscriber implements OnModuleInit {
const command = parseCommand(event.origin.chatLog.message); const command = parseCommand(event.origin.chatLog.message);
switch (command.kind) { switch (command.kind) {
case 'data-transfer':
segments = await this.dataTransferHandler.handle({
communityId,
senderUserId: event.userId,
senderNickname,
previousNickname: command.previousNickname,
});
break;
case 'match-list': case 'match-list':
segments = await this.matchListHandler.handle({ segments = await this.matchListHandler.handle({
communityId, communityId,
@@ -313,7 +301,7 @@ export class DakaoSubscriber implements OnModuleInit {
text: text:
index === this.usageCommands.length - 1 index === this.usageCommands.length - 1
? ` ${command}` ? ` ${command}`
: ` ${command}\u3000\n`, : ` ${command} \n`,
} as const, } as const,
]); ]);
} }
@@ -1,49 +0,0 @@
import mongoose from 'mongoose';
import {
DakaoUserService,
KakaoDataTransferResult,
} from '../dakao-user.service';
import { DataTransferHandler } from './data-transfer.handler';
const params = {
communityId: new mongoose.Types.ObjectId(),
senderUserId: 'new-id',
senderNickname: '현재 닉',
previousNickname: '예전 닉',
};
describe('DataTransferHandler', () => {
it.each<[KakaoDataTransferResult, string]>([
['transferred', '데이터 이관 완료'],
['already-linked', '이미 현재 카카오톡 계정에 연결'],
['not-found', '찾을 수 없습니다'],
['ambiguous', '여러 명'],
['id-conflict', '이미 다른 사용자'],
['changed', '변경되었습니다'],
])('replies to the sender for %s', async (result, message) => {
const transferKakaoTalkId = jest.fn().mockResolvedValue(result);
const handler = new DataTransferHandler({
transferKakaoTalkId,
} as unknown as DakaoUserService);
expect(await handler.handle(params)).toEqual([
{ kind: 'mention', userId: 'new-id', displayText: '현재 닉' },
{ kind: 'text', text: expect.stringContaining(message) },
]);
expect(transferKakaoTalkId).toHaveBeenCalledWith({
communityId: params.communityId,
kakaoTalkId: 'new-id',
previousNickname: '예전 닉',
});
});
it('propagates unexpected failures', async () => {
const handler = new DataTransferHandler({
transferKakaoTalkId: jest
.fn()
.mockRejectedValue(new Error('database unavailable')),
} as unknown as DakaoUserService);
await expect(handler.handle(params)).rejects.toThrow(
'database unavailable',
);
});
});
@@ -1,46 +0,0 @@
import { Injectable } from '@nestjs/common';
import mongoose from 'mongoose';
import {
DakaoUserService,
KakaoDataTransferResult,
} from '../dakao-user.service';
import { DakaoSegment } from '../dakao.types';
const RESULT_MESSAGES: Record<KakaoDataTransferResult, string> = {
transferred:
'데이터 이관 완료. 기존 라이엇 계정과 내전 기록이 현재 카카오톡 계정에 연결되었습니다.',
'already-linked': '이미 현재 카카오톡 계정에 연결된 사용자입니다.',
'not-found':
'해당 예전 닉네임으로 라이엇 계정이 등록된 사용자를 찾을 수 없습니다.',
ambiguous:
'같은 예전 닉네임으로 등록된 사용자가 여러 명입니다. 운영자에게 문의해주세요.',
'id-conflict':
'현재 카카오톡 계정에 이미 다른 사용자가 등록되어 있습니다. 운영자에게 문의해주세요.',
changed: '이관 중 사용자 정보가 변경되었습니다. 다시 시도해주세요.',
};
@Injectable()
export class DataTransferHandler {
constructor(private readonly dakaoUserService: DakaoUserService) {}
public async handle(params: {
communityId: mongoose.Types.ObjectId;
senderUserId: string;
senderNickname: string;
previousNickname: string;
}): Promise<DakaoSegment[]> {
const result = await this.dakaoUserService.transferKakaoTalkId({
communityId: params.communityId,
kakaoTalkId: params.senderUserId,
previousNickname: params.previousNickname,
});
return [
{
kind: 'mention',
userId: params.senderUserId,
displayText: params.senderNickname,
},
{ kind: 'text', text: ` ${RESULT_MESSAGES[result]}` },
];
}
}
@@ -104,11 +104,9 @@ describe('MatchCancelHandler', () => {
const handler = makeHandler({ const handler = makeHandler({
matchService: { matchService: {
cancelJoin, cancelJoin,
list: jest list: jest.fn().mockResolvedValue([
.fn() { _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
.mockResolvedValue([ ]),
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
]),
} as Partial<MatchService>, } as Partial<MatchService>,
dakaoUserService: { dakaoUserService: {
findUserByKakaoTalkId, findUserByKakaoTalkId,
@@ -230,11 +230,9 @@ describe('MatchJoinHandler', () => {
const resolveRiotAccount = jest.fn(); const resolveRiotAccount = jest.fn();
const handler = makeHandler({ const handler = makeHandler({
matchService: { matchService: {
list: jest list: jest.fn().mockResolvedValue([
.fn() { _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
.mockResolvedValue([ ]),
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
]),
join, join,
} as Partial<MatchService>, } as Partial<MatchService>,
dakaoUserService: { dakaoUserService: {
@@ -284,11 +282,9 @@ describe('MatchJoinHandler', () => {
const join = jest.fn(); const join = jest.fn();
const handler = makeHandler({ const handler = makeHandler({
matchService: { matchService: {
list: jest list: jest.fn().mockResolvedValue([
.fn() { _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
.mockResolvedValue([ ]),
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
]),
join, join,
} as Partial<MatchService>, } as Partial<MatchService>,
dakaoUserService: { dakaoUserService: {
@@ -44,7 +44,9 @@ export class MatchJoinHandler {
return this.errorReply(params, joinTarget); return this.errorReply(params, joinTarget);
} }
let resolved: { user: UserDocument; riotAccount: RiotAccount } | string; let resolved:
| { user: UserDocument; riotAccount: RiotAccount }
| string;
try { try {
resolved = resolved =
joinTarget.gameName && joinTarget.tagLine joinTarget.gameName && joinTarget.tagLine
@@ -241,7 +243,10 @@ export class MatchJoinHandler {
const gameName = normalizeRiotIdPart(value.slice(splitAt + 1)); const gameName = normalizeRiotIdPart(value.slice(splitAt + 1));
if (!matchTitlePrefix || !gameName) continue; if (!matchTitlePrefix || !gameName) continue;
const result = resolveRecruitingMatchReference(matchTitlePrefix, matches); const result = resolveRecruitingMatchReference(
matchTitlePrefix,
matches,
);
if (result.kind === 'matched') { if (result.kind === 'matched') {
return { kind: 'matched', match: result.match, gameName }; return { kind: 'matched', match: result.match, gameName };
} }
@@ -22,33 +22,6 @@ function makeHandler(params: {
} }
describe('MatchListHandler', () => { describe('MatchListHandler', () => {
afterEach(() => {
jest.useRealTimers();
});
it('queries only matches scheduled at or after command processing time', async () => {
const now = new Date('2026-07-25T07:30:00.000Z');
jest.useFakeTimers().setSystemTime(now);
const communityId = objectId('111111111111111111111111');
const list = jest.fn().mockResolvedValue([]);
const handler = makeHandler({
matchService: { list },
});
await handler.handle({
communityId,
senderUserId: 'kakao-user-1',
senderNickname: '프리리',
});
expect(list).toHaveBeenCalledWith({
communityId,
status: 'recruiting',
scheduledFrom: now,
limit: 10,
});
});
it('prints short codes, compact KST dates, and short links', async () => { it('prints short codes, compact KST dates, and short links', async () => {
const match = { const match = {
_id: objectId('333333333333333333333333'), _id: objectId('333333333333333333333333'),
@@ -19,11 +19,9 @@ export class MatchListHandler {
senderUserId: string; senderUserId: string;
senderNickname: string; senderNickname: string;
}): Promise<DakaoSegment[]> { }): Promise<DakaoSegment[]> {
const scheduledFrom = new Date();
const matches = await this.matchService.list({ const matches = await this.matchService.list({
communityId: params.communityId, communityId: params.communityId,
status: 'recruiting', status: 'recruiting',
scheduledFrom,
limit: 10, limit: 10,
}); });
@@ -20,8 +20,8 @@ export class IdempotencyCache {
public remember(key: string): void { public remember(key: string): void {
this.evictExpired(); this.evictExpired();
if (this.entries.size >= MAX_ENTRIES) { if (this.entries.size >= MAX_ENTRIES) {
const oldestKey: unknown = this.entries.keys().next().value; const oldestKey = this.entries.keys().next().value;
if (typeof oldestKey === 'string') this.entries.delete(oldestKey); if (oldestKey !== undefined) this.entries.delete(oldestKey);
} }
this.entries.set(key, Date.now() + TTL_MS); this.entries.set(key, Date.now() + TTL_MS);
} }
@@ -1,19 +1,6 @@
import { CommandParseError, parseCommand } from './command.parser'; import { CommandParseError, parseCommand } from './command.parser';
describe('parseCommand', () => { describe('parseCommand', () => {
it('parses data transfer with the complete previous nickname', () => {
expect(parseCommand(' !내전 데이터이관 예전 닉.* ')).toEqual({
kind: 'data-transfer',
previousNickname: '예전 닉.*',
});
});
it('requires a previous nickname for data transfer', () => {
expect(() => parseCommand('!내전 데이터이관 ')).toThrow(
new CommandParseError('usage'),
);
});
it('parses match-list command (목록)', () => { it('parses match-list command (목록)', () => {
expect(parseCommand('!내전 목록')).toEqual({ kind: 'match-list' }); expect(parseCommand('!내전 목록')).toEqual({ kind: 'match-list' });
}); });
@@ -35,7 +22,7 @@ describe('parseCommand', () => {
matchAndRiotId: '69b63bc96da18dfdb218ee8c 프리리#KR1', matchAndRiotId: '69b63bc96da18dfdb218ee8c 프리리#KR1',
}); });
if (result.kind === 'match-join') { if (result.kind === 'match-join') {
expect(result.positions?.positions).toEqual(['MID', 'TOP']); expect(result.positions.positions).toEqual(['MID', 'TOP']);
} }
}); });
@@ -7,7 +7,6 @@ import { normalizeRiotIdPart } from '../riot-id.util';
export type DakaoCommand = export type DakaoCommand =
| { kind: 'match-list' } | { kind: 'match-list' }
| { kind: 'data-transfer'; previousNickname: string }
| { | {
kind: 'account-register'; kind: 'account-register';
gameName: string; gameName: string;
@@ -76,9 +75,6 @@ export function parseCommand(rawMessage: string): DakaoCommand {
return parseCancelArgs(args); return parseCancelArgs(args);
case '계정등록': case '계정등록':
return parseAccountRegisterArgs(args); return parseAccountRegisterArgs(args);
case '데이터이관':
if (!args) throw new CommandParseError('usage');
return { kind: 'data-transfer', previousNickname: args };
case '대표계정변경': case '대표계정변경':
return parsePrimaryAccountChangeArgs(args); return parsePrimaryAccountChangeArgs(args);
case '선호포지션등록': case '선호포지션등록':
@@ -144,7 +144,7 @@ export function buildDoubleEliminationBracket(
teamIndex, teamIndex,
})); }));
const bracket: DoubleEliminationBracket = { const bracket: DoubleEliminationBracket = {
teamCount: seededTeamIndexes.length, teamCount: seededTeamIndexes.length as 4 | 8,
resetFinalEnabled: options.resetFinalEnabled, resetFinalEnabled: options.resetFinalEnabled,
resetFinalCreated: false, resetFinalCreated: false,
seeds, seeds,
@@ -19,9 +19,7 @@ describe('auction Redis schema foundation', () => {
expect(AuctionSchema.path('revision')).toBeDefined(); expect(AuctionSchema.path('revision')).toBeDefined();
expect(AuctionSchema.path('auctionEngineVersion')).toBeDefined(); expect(AuctionSchema.path('auctionEngineVersion')).toBeDefined();
expect(AuctionSchema.path('auctionLifecycleId')).toBeDefined(); expect(AuctionSchema.path('auctionLifecycleId')).toBeDefined();
expect( expect(AuctionSchema.path('lastAppliedAuctionStateTransitionId')).toBeDefined();
AuctionSchema.path('lastAppliedAuctionStateTransitionId'),
).toBeDefined();
expect(AuctionSchema.path('currentAuctionHistorySequence')).toBeDefined(); expect(AuctionSchema.path('currentAuctionHistorySequence')).toBeDefined();
expect(AuctionSchema.path('startAuctionRequestId')).toBeDefined(); expect(AuctionSchema.path('startAuctionRequestId')).toBeDefined();
expect(AuctionSchema.path('startAuctionStateTransitionId')).toBeDefined(); expect(AuctionSchema.path('startAuctionStateTransitionId')).toBeDefined();
@@ -38,73 +36,46 @@ describe('auction Redis schema foundation', () => {
expect(AuctionSchema.path('auctionBidHistory')).toBeDefined(); expect(AuctionSchema.path('auctionBidHistory')).toBeDefined();
expect(AuctionSchema.path('currentHighestBidPointAmount')).toBeDefined(); expect(AuctionSchema.path('currentHighestBidPointAmount')).toBeDefined();
expect(AuctionSchema.path('currentHighestBidderTeamIndex')).toBeDefined(); expect(AuctionSchema.path('currentHighestBidderTeamIndex')).toBeDefined();
expect( expect(AuctionSchema.path('currentBidRoundDeadlineTimestampMS')).toBeDefined();
AuctionSchema.path('currentBidRoundDeadlineTimestampMS'),
).toBeDefined();
expect(AuctionSchema.path('maximumBidRoundDurationSeconds')).toBeDefined(); expect(AuctionSchema.path('maximumBidRoundDurationSeconds')).toBeDefined();
expect(AuctionSchema.path('bidRoundExtensionSeconds')).toBeDefined(); expect(AuctionSchema.path('bidRoundExtensionSeconds')).toBeDefined();
expect(AuctionSchema.path('initialTeamBidPointAmount')).toBeDefined(); expect(AuctionSchema.path('initialTeamBidPointAmount')).toBeDefined();
expect(AuctionSchema.path('topTierAuctionPriorityThreshold')).toBeDefined(); expect(AuctionSchema.path('topTierAuctionPriorityThreshold')).toBeDefined();
expect( expect(AuctionSchema.path('manualTopTierAuctionPriorityUserIds')).toBeDefined();
AuctionSchema.path('manualTopTierAuctionPriorityUserIds'),
).toBeDefined();
expect(AuctionSchema.path('auctionStartedAtTimestampMS')).toBeDefined(); expect(AuctionSchema.path('auctionStartedAtTimestampMS')).toBeDefined();
expect(AuctionSchema.path('auctionCompletedAtTimestampMS')).toBeDefined(); expect(AuctionSchema.path('auctionCompletedAtTimestampMS')).toBeDefined();
}); });
it('adds history transition fields and reset/undo action enum values', () => { it('adds history transition fields and reset/undo action enum values', () => {
expect( expect(AuctionHistoryEntrySchema.path('auctionStateTransitionId')).toBeDefined();
AuctionHistoryEntrySchema.path('auctionStateTransitionId'),
).toBeDefined();
expect(AuctionHistoryEntrySchema.path('auctionLifecycleId')).toBeDefined(); expect(AuctionHistoryEntrySchema.path('auctionLifecycleId')).toBeDefined();
expect(AuctionHistoryEntrySchema.path('revision')).toBeDefined(); expect(AuctionHistoryEntrySchema.path('revision')).toBeDefined();
expect(AuctionHistoryEntrySchema.path('historyMutation')).toBeDefined(); expect(AuctionHistoryEntrySchema.path('historyMutation')).toBeDefined();
expect(AuctionHistoryEntrySchema.path('matchSideEffectMutation')).toBeDefined();
expect( expect(
AuctionHistoryEntrySchema.path('matchSideEffectMutation'), AuctionHistoryEntrySchema.path<string>('action').options.enum,
).toBeDefined(); ).toEqual(
expect(AuctionHistoryEntrySchema.path('action').options.enum).toEqual( expect.arrayContaining(['start', 'open-bidding', 'bid', 'sold', 'passed', 'next', 'complete', 'reset', 'undo']),
expect.arrayContaining([
'start',
'open-bidding',
'bid',
'sold',
'passed',
'next',
'complete',
'reset',
'undo',
]),
); );
}); });
it('adds unique history indexes for sequence and transition idempotency', () => { it('adds unique history indexes for sequence and transition idempotency', () => {
const indexes = AuctionHistoryEntrySchema.indexes(); const indexes = AuctionHistoryEntrySchema.indexes();
expect( expect(indexWithKeys(indexes, { auctionId: 1, sequence: 1 })?.[1]).toMatchObject({
indexWithKeys(indexes, { auctionId: 1, sequence: 1 })?.[1],
).toMatchObject({
unique: true, unique: true,
}); });
expect( expect(
indexWithKeys(indexes, { indexWithKeys(indexes, { auctionId: 1, auctionStateTransitionId: 1 })?.[1],
auctionId: 1,
auctionStateTransitionId: 1,
})?.[1],
).toMatchObject({ unique: true, sparse: true }); ).toMatchObject({ unique: true, sparse: true });
}); });
it('registers auction side effect application model with lease fields and unique idempotency index', () => { it('registers auction side effect application model with lease fields and unique idempotency index', () => {
expect(AuctionSideEffectApplicationSchema.path('processingOwnerToken')).toBeDefined();
expect( expect(
AuctionSideEffectApplicationSchema.path('processingOwnerToken'), AuctionSideEffectApplicationSchema.path('processingLeaseExpiresAtTimestampMS'),
).toBeDefined();
expect(
AuctionSideEffectApplicationSchema.path(
'processingLeaseExpiresAtTimestampMS',
),
).toBeDefined();
expect(
AuctionSideEffectApplicationSchema.path('payloadChecksum'),
).toBeDefined(); ).toBeDefined();
expect(AuctionSideEffectApplicationSchema.path('payloadChecksum')).toBeDefined();
const indexes = AuctionSideEffectApplicationSchema.indexes(); const indexes = AuctionSideEffectApplicationSchema.indexes();
expect( expect(
@@ -2,10 +2,7 @@ import { Injectable, Logger, Scope, OnModuleInit } from '@nestjs/common';
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import { applyMongoosePerformancePlugin } from '../observability/mongoose-performance.plugin'; import { applyMongoosePerformancePlugin } from '../observability/mongoose-performance.plugin';
import { SecretService } from '../secret/secret.service'; import { SecretService } from '../secret/secret.service';
import { import { tournamentModelDefinitions, TournamentModelTypes } from './schema';
tournamentModelDefinitions,
type TournamentModelTypes,
} from './schema';
export function resolveMongoDbName(nodeEnv = process.env.NODE_ENV): string { export function resolveMongoDbName(nodeEnv = process.env.NODE_ENV): string {
if (nodeEnv === 'prod') return 'lolympus'; if (nodeEnv === 'prod') return 'lolympus';
@@ -45,8 +42,7 @@ export class ConnectionService implements OnModuleInit {
private connectionPromise: Promise<mongoose.Connection> | null = null; private connectionPromise: Promise<mongoose.Connection> | null = null;
constructor(private readonly secretService: SecretService) {} constructor(private readonly secretService: SecretService) {}
private tournamentModels: Map<keyof TournamentModelTypes, unknown> | null = private tournamentModels: Map<string, mongoose.Model<any>> | null = null;
null;
public async getConnection(): Promise<mongoose.Connection> { public async getConnection(): Promise<mongoose.Connection> {
if ( if (
@@ -93,18 +89,14 @@ export class ConnectionService implements OnModuleInit {
modelKey: K, modelKey: K,
): Promise<mongoose.Model<TournamentModelTypes[K]>> { ): Promise<mongoose.Model<TournamentModelTypes[K]>> {
const connection = await this.getConnection(); const connection = await this.getConnection();
if (this.tournamentModels) { if (this.tournamentModels)
return this.requireTournamentModel(this.tournamentModels, modelKey); return this.tournamentModels.get(modelKey) as mongoose.Model<
} TournamentModelTypes[K]
>;
const models = new Map<keyof TournamentModelTypes, unknown>(); const models = new Map<K, mongoose.Model<TournamentModelTypes[K]>>();
tournamentModelDefinitions.forEach((modelDefinition) => { tournamentModelDefinitions.forEach((modelDefinition) => {
if (!(modelDefinition.schema instanceof mongoose.Schema)) {
throw new Error(
`Invalid Mongoose schema for model ${modelDefinition.name}.`,
);
}
applyMongoosePerformancePlugin(modelDefinition.schema); applyMongoosePerformancePlugin(modelDefinition.schema);
// 이미 생성된 경우 컴파일 스킵. // 이미 생성된 경우 컴파일 스킵.
if ( if (
@@ -114,14 +106,14 @@ export class ConnectionService implements OnModuleInit {
) )
) { ) {
models.set( models.set(
modelDefinition.name, modelDefinition.name as K,
connection.models[modelDefinition.name], connection.models[modelDefinition.name],
); );
return; return;
} else { } else {
models.set( models.set(
modelDefinition.name, modelDefinition.name as K,
connection.model( connection.model<TournamentModelTypes[K]>(
modelDefinition.name, modelDefinition.name,
modelDefinition.schema, modelDefinition.schema,
modelDefinition.schemaName, modelDefinition.schemaName,
@@ -131,18 +123,7 @@ export class ConnectionService implements OnModuleInit {
}); });
this.tournamentModels = models; this.tournamentModels = models;
return this.requireTournamentModel(models, modelKey); return models.get(modelKey) as mongoose.Model<TournamentModelTypes[K]>;
}
private requireTournamentModel<K extends keyof TournamentModelTypes>(
models: ReadonlyMap<keyof TournamentModelTypes, unknown>,
modelKey: K,
): mongoose.Model<TournamentModelTypes[K]> {
const model = models.get(modelKey);
if (model === undefined) {
throw new Error(`Mongoose model ${modelKey} is not registered.`);
}
return model as mongoose.Model<TournamentModelTypes[K]>;
} }
public async createSession( public async createSession(
@@ -1,4 +1,4 @@
import { Module } from '@nestjs/common'; import { DynamicModule, Module } from '@nestjs/common';
import { ConnectionService } from './connection.service'; import { ConnectionService } from './connection.service';
@Module({ @Module({
@@ -45,10 +45,7 @@ export async function migrateAuctionPassHistory(
}; };
}> = []; }> = [];
for await (const doc of db for await (const doc of db.collection('auction').find({}).limit(options.limit ?? 0)) {
.collection('auction')
.find({})
.limit(options.limit ?? 0)) {
stats.scannedAuctions += 1; stats.scannedAuctions += 1;
const set: Record<string, unknown> = {}; const set: Record<string, unknown> = {};
let changed = false; let changed = false;
@@ -1,10 +1,8 @@
import { migrateTeamIndex } from './20260502-team-index'; import { migrateTeamIndex } from './20260502-team-index';
type MigrationDocument = Record<string, unknown> & { _id: unknown };
function createDb(params: { function createDb(params: {
auctions?: MigrationDocument[]; auctions?: Array<Record<string, unknown>>;
matches?: MigrationDocument[]; matches?: Array<Record<string, unknown>>;
}) { }) {
const collections = { const collections = {
auction: params.auctions ?? [], auction: params.auctions ?? [],
@@ -29,21 +27,17 @@ function createDb(params: {
}, },
}; };
}, },
async bulkWrite( async bulkWrite(writes: Array<{
writes: Array<{ updateOne: {
updateOne: { filter: { _id: unknown };
filter: { _id: unknown }; update: {
update: { $set: Record<string, unknown>;
$set: Record<string, unknown>; $unset: Record<string, ''>;
$unset: Record<string, ''>;
};
}; };
}>, };
) { }>) {
for (const write of writes) { for (const write of writes) {
const doc = docs.find( const doc = docs.find((item) => item._id === write.updateOne.filter._id);
(item) => item._id === write.updateOne.filter._id,
);
if (!doc) continue; if (!doc) continue;
Object.assign(doc, write.updateOne.update.$set); Object.assign(doc, write.updateOne.update.$set);
for (const key of Object.keys(write.updateOne.update.$unset)) { for (const key of Object.keys(write.updateOne.update.$unset)) {
@@ -63,10 +57,7 @@ describe('migrateTeamIndex', () => {
auctions: [ auctions: [
{ {
_id: 'auction-1', _id: 'auction-1',
teams: [ teams: [{ side: 'blue', groupIndex: 1 }, { side: 'red', groupIndex: 1 }],
{ side: 'blue', groupIndex: 1 },
{ side: 'red', groupIndex: 1 },
],
bids: [{ side: 'red', groupIndex: 1, amount: 100 }], bids: [{ side: 'red', groupIndex: 1, amount: 100 }],
currentBidder: 'red', currentBidder: 'red',
currentBidderGroupIndex: 1, currentBidderGroupIndex: 1,
@@ -75,10 +66,7 @@ describe('migrateTeamIndex', () => {
matches: [ matches: [
{ {
_id: 'match-1', _id: 'match-1',
teams: [ teams: [{ side: 'blue', groupIndex: 1 }, { side: 'red', groupIndex: 1 }],
{ side: 'blue', groupIndex: 1 },
{ side: 'red', groupIndex: 1 },
],
result: { result: {
winnerSide: 'blue', winnerSide: 'blue',
blueScore: 1, blueScore: 1,
@@ -124,10 +112,7 @@ describe('migrateTeamIndex', () => {
currentBidderTeamIndex: 2, currentBidderTeamIndex: 2,
}); });
expect(collections.match[0]).toMatchObject({ expect(collections.match[0]).toMatchObject({
teams: [ teams: [{ teamIndex: 1, name: '1팀' }, { teamIndex: 2, name: '2팀' }],
{ teamIndex: 1, name: '1팀' },
{ teamIndex: 2, name: '2팀' },
],
result: { result: {
winnerTeamIndex: 1, winnerTeamIndex: 1,
games: [ games: [
@@ -45,20 +45,8 @@ export async function migrateTeamIndex(
changedMatches: 0, changedMatches: 0,
}; };
await migrateCollection( await migrateCollection(db.collection('auction'), options.limit, dryRun, stats, 'auction');
db.collection('auction'), await migrateCollection(db.collection('match'), options.limit, dryRun, stats, 'match');
options.limit,
dryRun,
stats,
'auction',
);
await migrateCollection(
db.collection('match'),
options.limit,
dryRun,
stats,
'match',
);
return stats; return stats;
} }
@@ -72,7 +60,7 @@ async function migrateCollection(
) { ) {
const cursor = collection.find({}).limit(limit ?? 0); const cursor = collection.find({}).limit(limit ?? 0);
const writes: Array<{ const writes: Array<{
updateOne: { updateOne: {
filter: { _id: unknown }; filter: { _id: unknown };
update: { $set: Record<string, unknown>; $unset: Record<string, ''> }; update: { $set: Record<string, unknown>; $unset: Record<string, ''> };
}; };
@@ -155,8 +143,7 @@ function migrateMatch(doc: AnyDoc) {
const migrated = { ...team }; const migrated = { ...team };
const teamIndex = readTeamIndex(migrated); const teamIndex = readTeamIndex(migrated);
if (teamIndex !== undefined) migrated.teamIndex = teamIndex; if (teamIndex !== undefined) migrated.teamIndex = teamIndex;
if (!migrated.name && typeof teamIndex === 'number') if (!migrated.name && typeof teamIndex === 'number') migrated.name = `${teamIndex}팀`;
migrated.name = `${teamIndex}팀`;
if ('side' in migrated || 'groupIndex' in migrated) changed = true; if ('side' in migrated || 'groupIndex' in migrated) changed = true;
delete migrated.side; delete migrated.side;
delete migrated.groupIndex; delete migrated.groupIndex;
@@ -213,10 +200,7 @@ function migrateResult(result: Record<string, unknown>) {
migrated.games = games; migrated.games = games;
const seriesResults = asArray(result.seriesResults).map((series) => { const seriesResults = asArray(result.seriesResults).map((series) => {
if ( if (typeof series.teamAIndex === 'number' && typeof series.teamBIndex === 'number') {
typeof series.teamAIndex === 'number' &&
typeof series.teamBIndex === 'number'
) {
return series; return series;
} }
changed = true; changed = true;
@@ -232,9 +216,7 @@ function migrateResult(result: Record<string, unknown>) {
const teamBIndex = Math.max(legacyBlueTeamIndex, legacyRedTeamIndex); const teamBIndex = Math.max(legacyBlueTeamIndex, legacyRedTeamIndex);
const blueScore = numberOrDefault(series.blueScore, 0); const blueScore = numberOrDefault(series.blueScore, 0);
const redScore = numberOrDefault(series.redScore, 0); const redScore = numberOrDefault(series.redScore, 0);
const winnerSide = isSide(series.winnerSide) const winnerSide = isSide(series.winnerSide) ? series.winnerSide : undefined;
? series.winnerSide
: undefined;
const winnerTeamIndex = const winnerTeamIndex =
winnerSide === 'blue' winnerSide === 'blue'
? legacyBlueTeamIndex ? legacyBlueTeamIndex
@@ -249,11 +231,12 @@ function migrateResult(result: Record<string, unknown>) {
winnerTeamIndex, winnerTeamIndex,
}; };
}); });
migrated.seriesResults = migrated.seriesResults = seriesResults.length > 0 ? seriesResults : buildSeries(games);
seriesResults.length > 0 ? seriesResults : buildSeries(games);
if (typeof migrated.winnerTeamIndex !== 'number') { if (typeof migrated.winnerTeamIndex !== 'number') {
const migratedSeriesResults = asArray(migrated.seriesResults); const migratedSeriesResults = Array.isArray(migrated.seriesResults)
? migrated.seriesResults
: [];
migrated.winnerTeamIndex = migrated.winnerTeamIndex =
resolveWinnerTeamIndex(migratedSeriesResults) ?? resolveWinnerTeamIndex(migratedSeriesResults) ??
(isSide(migrated.winnerSide) (isSide(migrated.winnerSide)
@@ -261,11 +244,7 @@ function migrateResult(result: Record<string, unknown>) {
: undefined); : undefined);
} }
if ( if ('winnerSide' in migrated || 'blueScore' in migrated || 'redScore' in migrated) {
'winnerSide' in migrated ||
'blueScore' in migrated ||
'redScore' in migrated
) {
changed = true; changed = true;
} }
delete migrated.winnerSide; delete migrated.winnerSide;
@@ -293,12 +272,8 @@ function buildSeries(games: Record<string, unknown>[]) {
const teamAIndex = Math.min(blueTeamIndex, redTeamIndex); const teamAIndex = Math.min(blueTeamIndex, redTeamIndex);
const teamBIndex = Math.max(blueTeamIndex, redTeamIndex); const teamBIndex = Math.max(blueTeamIndex, redTeamIndex);
const key = `${teamAIndex}:${teamBIndex}`; const key = `${teamAIndex}:${teamBIndex}`;
const current = bySeries.get(key) ?? { const current =
teamAIndex, bySeries.get(key) ?? { teamAIndex, teamBIndex, teamAWins: 0, teamBWins: 0 };
teamBIndex,
teamAWins: 0,
teamBWins: 0,
};
if (winnerTeamIndex === teamAIndex) current.teamAWins += 1; if (winnerTeamIndex === teamAIndex) current.teamAWins += 1;
if (winnerTeamIndex === teamBIndex) current.teamBWins += 1; if (winnerTeamIndex === teamBIndex) current.teamBWins += 1;
current.winnerTeamIndex = current.winnerTeamIndex =
@@ -356,7 +331,5 @@ function numberOrDefault(value: unknown, fallback: number) {
} }
function numberOrUndefined(value: unknown) { function numberOrUndefined(value: unknown) {
return typeof value === 'number' && Number.isFinite(value) return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
? value
: undefined;
} }
@@ -30,26 +30,20 @@ function createDb(params: { auctions?: Doc[]; history?: Doc[] }) {
}, },
}; };
}, },
async bulkWrite( async bulkWrite(writes: Array<{
writes: Array<{ updateOne: {
updateOne: { filter: { _id: unknown };
filter: { _id: unknown }; update: {
update: { $set?: Record<string, unknown>;
$set?: Record<string, unknown>; $unset?: Record<string, ''>;
$unset?: Record<string, ''>;
};
}; };
}>, };
) { }>) {
for (const write of writes) { for (const write of writes) {
const doc = docs.find( const doc = docs.find((item) => item._id === write.updateOne.filter._id);
(item) => item._id === write.updateOne.filter._id,
);
if (!doc) continue; if (!doc) continue;
Object.assign(doc, write.updateOne.update.$set ?? {}); Object.assign(doc, write.updateOne.update.$set ?? {});
for (const key of Object.keys( for (const key of Object.keys(write.updateOne.update.$unset ?? {})) {
write.updateOne.update.$unset ?? {},
)) {
delete doc[key]; delete doc[key];
} }
} }
@@ -31,10 +31,7 @@ interface MigrationStats {
} }
type AnyDoc = Record<string, unknown> & { _id: unknown }; type AnyDoc = Record<string, unknown> & { _id: unknown };
type UpdateDoc = { type UpdateDoc = { $set?: Record<string, unknown>; $unset?: Record<string, ''> };
$set?: Record<string, unknown>;
$unset?: Record<string, ''>;
};
const AUCTION_FIELD_RENAMES: Array<{ const AUCTION_FIELD_RENAMES: Array<{
from: string; from: string;
@@ -46,11 +43,7 @@ const AUCTION_FIELD_RENAMES: Array<{
{ from: 'passedQueue', to: 'passedAuctionPlayerQueue' }, { from: 'passedQueue', to: 'passedAuctionPlayerQueue' },
{ from: 'auctionRound', to: 'currentAuctionRound' }, { from: 'auctionRound', to: 'currentAuctionRound' },
{ from: 'currentIndex', to: 'currentAuctionPlayerOrderIndex' }, { from: 'currentIndex', to: 'currentAuctionPlayerOrderIndex' },
{ { from: 'bids', to: 'auctionBidHistory', transform: transformAuctionBidHistory },
from: 'bids',
to: 'auctionBidHistory',
transform: transformAuctionBidHistory,
},
{ from: 'currentBid', to: 'currentHighestBidPointAmount' }, { from: 'currentBid', to: 'currentHighestBidPointAmount' },
{ from: 'currentBidderTeamIndex', to: 'currentHighestBidderTeamIndex' }, { from: 'currentBidderTeamIndex', to: 'currentHighestBidderTeamIndex' },
{ {
@@ -164,8 +157,7 @@ async function countDuplicateHistorySequences(
const duplicates = new Set<string>(); const duplicates = new Set<string>();
for await (const doc of collection.find({}).limit(limit ?? 0)) { for await (const doc of collection.find({}).limit(limit ?? 0)) {
const auctionId = stringifyId(doc.auctionId); const auctionId = stringifyId(doc.auctionId);
const sequence = const sequence = typeof doc.sequence === 'number' ? doc.sequence : undefined;
typeof doc.sequence === 'number' ? doc.sequence : undefined;
if (!auctionId || sequence === undefined) continue; if (!auctionId || sequence === undefined) continue;
const key = `${auctionId}:${sequence}`; const key = `${auctionId}:${sequence}`;
@@ -330,9 +322,6 @@ function legacyAuctionLifecycleId(value: unknown): string {
function stringifyId(value: unknown): string | undefined { function stringifyId(value: unknown): string | undefined {
if (value === undefined || value === null) return undefined; if (value === undefined || value === null) return undefined;
// MongoDB ObjectId and migration fixture IDs intentionally rely on their
// stable string representation.
// eslint-disable-next-line @typescript-eslint/no-base-to-string
return typeof value === 'string' ? value : String(value); return typeof value === 'string' ? value : String(value);
} }
@@ -117,9 +117,7 @@ function createDb(params: {
function matchesFilter(doc: Doc, filter: Record<string, unknown>): boolean { function matchesFilter(doc: Doc, filter: Record<string, unknown>): boolean {
const clauses = filter.$or; const clauses = filter.$or;
if (Array.isArray(clauses)) { if (Array.isArray(clauses)) {
return (clauses as unknown[]).some( return clauses.some((clause) => matchesFilter(doc, clause));
(clause) => isRecord(clause) && matchesFilter(doc, clause),
);
} }
return Object.entries(filter).every(([key, value]) => { return Object.entries(filter).every(([key, value]) => {
@@ -1,4 +1,11 @@
type TournamentCodeState = string; type TournamentCodeState =
| 'available'
| 'reserved'
| 'used'
| 'released'
| 'expired'
| 'voided'
| string;
type AnyDoc = Record<string, unknown> & { _id: unknown }; type AnyDoc = Record<string, unknown> & { _id: unknown };
type IndexKey = Record<string, 1 | -1>; type IndexKey = Record<string, 1 | -1>;
@@ -29,7 +36,7 @@ interface MigrationCollection {
$unset?: Record<string, ''>; $unset?: Record<string, ''>;
}, },
options?: { ordered?: boolean }, options?: { ordered?: boolean },
): Promise<unknown>; ): Promise<{ matchedCount?: number; modifiedCount?: number } | unknown>;
indexes?(): Promise<MigrationIndex[]>; indexes?(): Promise<MigrationIndex[]>;
dropIndex?(name: string): Promise<unknown>; dropIndex?(name: string): Promise<unknown>;
createIndex?( createIndex?(
@@ -509,17 +516,15 @@ function summarizeGroups(
function summarizeCode(doc: TournamentCodeDoc): TournamentCodeDuplicateSummary { function summarizeCode(doc: TournamentCodeDoc): TournamentCodeDuplicateSummary {
return { return {
bracketMatchId: bracketMatchId:
doc.bracketMatchId === undefined doc.bracketMatchId === undefined ? undefined : String(doc.bracketMatchId),
? undefined code: doc.code === undefined ? undefined : String(doc.code),
: stringifyId(doc.bracketMatchId),
code: doc.code === undefined ? undefined : stringifyId(doc.code),
gameNumber: gameNumber:
doc.gameNumber === undefined ? undefined : stringifyId(doc.gameNumber), doc.gameNumber === undefined ? undefined : String(doc.gameNumber),
id: stringifyId(doc._id) ?? '', id: stringifyId(doc._id) ?? '',
matchId: doc.matchId === undefined ? undefined : stringifyId(doc.matchId), matchId: doc.matchId === undefined ? undefined : stringifyId(doc.matchId),
riotMatchId: riotMatchId:
doc.riotMatchId === undefined ? undefined : stringifyId(doc.riotMatchId), doc.riotMatchId === undefined ? undefined : String(doc.riotMatchId),
state: doc.state, state: doc.state === undefined ? undefined : String(doc.state),
}; };
} }
@@ -744,19 +749,16 @@ function readModifiedCount(result: unknown): number {
} }
function hasField(doc: Record<string, unknown>, key: string): boolean { function hasField(doc: Record<string, unknown>, key: string): boolean {
return Object.hasOwn(doc, key); return Object.prototype.hasOwnProperty.call(doc, key);
} }
function stringifyKeyPart(value: unknown): string { function stringifyKeyPart(value: unknown): string {
if (value === null) return '<null>'; if (value === null) return '<null>';
if (value === undefined) return '<undefined>'; if (value === undefined) return '<undefined>';
return stringifyId(value) ?? '<unknown>'; return stringifyId(value) ?? String(value);
} }
function stringifyId(value: unknown): string | undefined { function stringifyId(value: unknown): string | undefined {
if (value === undefined || value === null) return undefined; if (value === undefined || value === null) return undefined;
// MongoDB ObjectId and migration fixture IDs intentionally rely on their
// stable string representation.
// eslint-disable-next-line @typescript-eslint/no-base-to-string
return typeof value === 'string' ? value : String(value); return typeof value === 'string' ? value : String(value);
} }
@@ -40,14 +40,6 @@ describe('repair-double-elimination-series-rules buildRepairPlan', () => {
{ {
gameNumber: 1, gameNumber: 1,
bracketMatchId: 'WB_R2_M1', bracketMatchId: 'WB_R2_M1',
riotMatchId: 'KR_1',
blueTeamIndex: 4,
redTeamIndex: 6,
winnerTeamIndex: 4,
winnerSide: 'blue',
gameCreation: Date.parse('2026-05-03T00:00:00.000Z'),
gameDuration: 1800,
participants: [],
}, },
], ],
seriesResults: [], seriesResults: [],
@@ -11,11 +11,7 @@ import {
} from '../../../double-elimination/double-elimination.util'; } from '../../../double-elimination/double-elimination.util';
import { TOURNAMENT_CODE_EXPIRY_MARGIN_MS } from '../../../tournament-code/tournament-code.constants'; import { TOURNAMENT_CODE_EXPIRY_MARGIN_MS } from '../../../tournament-code/tournament-code.constants';
import { ConnectionService } from '../connection.service'; import { ConnectionService } from '../connection.service';
import type { import type { MatchDocument, TournamentCodeDocument } from '../schema';
MatchDocument,
TournamentCode,
TournamentCodeDocument,
} from '../schema';
import { SecretModule } from '../../secret/secret.module'; import { SecretModule } from '../../secret/secret.module';
interface CliOptions { interface CliOptions {
@@ -338,7 +334,7 @@ function printPlan(plan: MatchRepairPlan) {
async function applyPlan( async function applyPlan(
match: MatchDocument, match: MatchDocument,
plan: MatchRepairPlan, plan: MatchRepairPlan,
TournamentCodeModel: mongoose.Model<TournamentCode>, TournamentCodeModel: mongoose.Model<any>,
session: mongoose.ClientSession, session: mongoose.ClientSession,
) { ) {
if (plan.skippedReason) return; if (plan.skippedReason) return;
@@ -5,7 +5,10 @@ import { NestFactory } from '@nestjs/core';
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import { readFile } from 'node:fs/promises'; import { readFile } from 'node:fs/promises';
import { resolve } from 'node:path'; import { resolve } from 'node:path';
import { ConnectionService, resolveMongoDbName } from '../connection.service'; import {
ConnectionService,
resolveMongoDbName,
} from '../connection.service';
import type { import type {
MatchDocument, MatchDocument,
MatchGameAssignment, MatchGameAssignment,
@@ -211,16 +214,12 @@ async function main() {
printPlan(options, match, codes, plan); printPlan(options, match, codes, plan);
if (options.dryRun) { if (options.dryRun) {
console.log( console.log('No writes were made. Re-run with --apply to update MongoDB.');
'No writes were made. Re-run with --apply to update MongoDB.',
);
return; return;
} }
const now = new Date(); const now = new Date();
const session = await ( const session = await (await connectionService.getConnection()).startSession();
await connectionService.getConnection()
).startSession();
try { try {
await session.withTransaction(async () => { await session.withTransaction(async () => {
await applyTournamentCodeUpdates(plan, now, session); await applyTournamentCodeUpdates(plan, now, session);
@@ -231,9 +230,9 @@ async function main() {
status: 'finished', status: 'finished',
roundRobinMaxRounds: options.maxRounds, roundRobinMaxRounds: options.maxRounds,
gameSchedule: plan.schedule, gameSchedule: plan.schedule,
tournamentCodeIds: [...plan.usedCodeByOldGameNumber.values()].map( tournamentCodeIds: [
(code) => code._id, ...plan.usedCodeByOldGameNumber.values(),
), ].map((code) => code._id),
resultPollState: { resultPollState: {
startedAt: match.resultPollState?.startedAt ?? now, startedAt: match.resultPollState?.startedAt ?? now,
lastPolledAt: now, lastPolledAt: now,
@@ -424,9 +423,7 @@ function partitionIntoRounds(
} }
if (!fillRound(0)) { if (!fillRound(0)) {
throw new Error( throw new Error('Could not partition result games into simultaneous rounds.');
'Could not partition result games into simultaneous rounds.',
);
} }
return rounds; return rounds;
@@ -589,7 +586,8 @@ function buildSeriesResults(games: MatchGameResult[]): MatchSeriesResult[] {
} }
return [...bySeries.values()].sort( return [...bySeries.values()].sort(
(left, right) => (left, right) =>
left.teamAIndex - right.teamAIndex || left.teamBIndex - right.teamBIndex, left.teamAIndex - right.teamAIndex ||
left.teamBIndex - right.teamBIndex,
); );
} }
@@ -219,9 +219,9 @@ async function listDuplicateHistorySequences(
.toArray(); .toArray();
} }
function printDuplicateHistorySequences( function printDuplicateHistorySequences(groups: Awaited<
groups: Awaited<ReturnType<typeof listDuplicateHistorySequences>>, ReturnType<typeof listDuplicateHistorySequences>
) { >) {
if (groups.length === 0) { if (groups.length === 0) {
console.log('No duplicate auctionHistory auctionId+sequence groups found.'); console.log('No duplicate auctionHistory auctionId+sequence groups found.');
return; return;
@@ -248,8 +248,7 @@ async function repairDuplicateHistorySequences(
): Promise<DuplicateSequenceRepairStats> { ): Promise<DuplicateSequenceRepairStats> {
const historyCollection = db.collection('auctionHistory'); const historyCollection = db.collection('auctionHistory');
const auctionCollection = db.collection('auction'); const auctionCollection = db.collection('auction');
const affectedAuctionIds = const affectedAuctionIds = await findAuctionIdsWithDuplicateHistorySequences(db);
await findAuctionIdsWithDuplicateHistorySequences(db);
const stats: DuplicateSequenceRepairStats = { const stats: DuplicateSequenceRepairStats = {
affectedAuctions: affectedAuctionIds.length, affectedAuctions: affectedAuctionIds.length,
changedAuctionSequenceFields: 0, changedAuctionSequenceFields: 0,
@@ -177,9 +177,7 @@ function parseArgs(argv: string[]): CliOptions {
function parseCommitQuorum(value: string | undefined, label: string) { function parseCommitQuorum(value: string | undefined, label: string) {
if (!value) { if (!value) {
throw new Error( throw new Error(`${label} requires a positive integer, majority, or votingMembers.`);
`${label} requires a positive integer, majority, or votingMembers.`,
);
} }
if (value === 'majority' || value === 'votingMembers') return value; if (value === 'majority' || value === 'votingMembers') return value;
return parsePositiveInteger(value, label); return parsePositiveInteger(value, label);
@@ -232,7 +230,9 @@ function printDuplicateGroups(groups: TournamentCodeDuplicateGroupSummary[]) {
kind: group.kind, kind: group.kind,
loserCodes: group.losers.map((loser) => loser.code ?? '').join(', '), loserCodes: group.losers.map((loser) => loser.code ?? '').join(', '),
loserIds: group.losers.map((loser) => loser.id).join(', '), loserIds: group.losers.map((loser) => loser.id).join(', '),
loserStates: group.losers.map((loser) => loser.state ?? '').join(', '), loserStates: group.losers
.map((loser) => loser.state ?? '')
.join(', '),
})), })),
); );
} }
@@ -2485,9 +2485,7 @@ MatchStatsSchema.index({ communityId: 1, userIds: 1 });
MatchStatsSchema.index({ communityId: 1, userIds: 1, scheduledAt: -1 }); MatchStatsSchema.index({ communityId: 1, userIds: 1, scheduledAt: -1 });
MatchStatsSchema.index({ communityId: 1, championIds: 1 }); MatchStatsSchema.index({ communityId: 1, championIds: 1 });
export const tournamentModelDefinitions: Array< export const tournamentModelDefinitions: ModelDefinition[] = [
ModelDefinition & { name: keyof TournamentModelTypes }
> = [
...competitionModelDefinitions, ...competitionModelDefinitions,
{ name: 'identity', schema: IdentitySchema, schemaName: 'identity' }, { name: 'identity', schema: IdentitySchema, schemaName: 'identity' },
{ name: 'community', schema: CommunitySchema, schemaName: 'community' }, { name: 'community', schema: CommunitySchema, schemaName: 'community' },
+1 -1
View File
@@ -1,5 +1,5 @@
export interface ModelDefinition { export interface ModelDefinition {
name: string; name: string;
schema: unknown; schema: mongoose.Schema<any>;
schemaName?: string; schemaName?: string;
} }
@@ -1,4 +1,5 @@
import { Module } from '@nestjs/common'; import { Module } from '@nestjs/common';
import fs from 'fs/promises';
import { connect } from 'nats'; import { connect } from 'nats';
import type { NatsConnection } from 'nats'; import type { NatsConnection } from 'nats';
import { SecretModule } from '../secret/secret.module'; import { SecretModule } from '../secret/secret.module';
@@ -34,32 +34,31 @@ type SchemaWithPerformanceMarker = mongoose.Schema & {
[PERFORMANCE_PLUGIN_APPLIED]?: boolean; [PERFORMANCE_PLUGIN_APPLIED]?: boolean;
}; };
export function applyMongoosePerformancePlugin(schemaValue: unknown): void { export function applyMongoosePerformancePlugin(schema: mongoose.Schema): void {
if (!(schemaValue instanceof mongoose.Schema)) { const markedSchema = schema as SchemaWithPerformanceMarker;
throw new TypeError('Mongoose performance plugin requires a Schema.'); if (markedSchema[PERFORMANCE_PLUGIN_APPLIED]) return;
} markedSchema[PERFORMANCE_PLUGIN_APPLIED] = true;
const schema = schemaValue as SchemaWithPerformanceMarker; const hookableSchema = schema as any;
if (schema[PERFORMANCE_PLUGIN_APPLIED]) return;
schema[PERFORMANCE_PLUGIN_APPLIED] = true;
schema.pre(QUERY_OPERATION_REGEX, function () { hookableSchema.pre(QUERY_OPERATION_REGEX, function () {
const query = this as QueryWithPerformanceState; const query = this as QueryWithPerformanceState;
query[QUERY_PERFORMANCE_START] = process.hrtime.bigint(); query[QUERY_PERFORMANCE_START] = process.hrtime.bigint();
query[QUERY_PERFORMANCE_RECORDED] = false; query[QUERY_PERFORMANCE_RECORDED] = false;
}); });
schema.post(QUERY_OPERATION_REGEX, function (result: unknown) { hookableSchema.post(
recordQueryPerformance(this as QueryWithPerformanceState, result);
});
schema.post(
QUERY_OPERATION_REGEX, QUERY_OPERATION_REGEX,
{ errorHandler: true }, function (result: unknown) {
function ( recordQueryPerformance(
error: Error, this as unknown as QueryWithPerformanceState,
_result: unknown, result,
next: (error?: mongoose.CallbackError) => void, );
) { },
);
hookableSchema.post(
QUERY_OPERATION_REGEX,
function (error: unknown, _result: unknown, next: (error: unknown) => void) {
recordQueryPerformance( recordQueryPerformance(
this as unknown as QueryWithPerformanceState, this as unknown as QueryWithPerformanceState,
undefined, undefined,
@@ -69,24 +68,19 @@ export function applyMongoosePerformancePlugin(schemaValue: unknown): void {
}, },
); );
schema.pre('aggregate', function () { hookableSchema.pre('aggregate', function () {
const aggregate = this as AggregateWithPerformanceState; const aggregate = this as AggregateWithPerformanceState;
aggregate[QUERY_PERFORMANCE_START] = process.hrtime.bigint(); aggregate[QUERY_PERFORMANCE_START] = process.hrtime.bigint();
aggregate[QUERY_PERFORMANCE_RECORDED] = false; aggregate[QUERY_PERFORMANCE_RECORDED] = false;
}); });
schema.post('aggregate', function (result: unknown) { hookableSchema.post('aggregate', function (result: unknown) {
recordAggregatePerformance(this as AggregateWithPerformanceState, result); recordAggregatePerformance(this as AggregateWithPerformanceState, result);
}); });
schema.post( hookableSchema.post(
'aggregate', 'aggregate',
{ errorHandler: true }, function (error: unknown, _result: unknown, next: (error: unknown) => void) {
function (
error: Error,
_result: unknown,
next: (error?: mongoose.CallbackError) => void,
) {
recordAggregatePerformance( recordAggregatePerformance(
this as AggregateWithPerformanceState, this as AggregateWithPerformanceState,
undefined, undefined,
@@ -170,8 +164,8 @@ export function countHydratedDocuments(result: unknown): number {
function isHydratedDocument(value: unknown): boolean { function isHydratedDocument(value: unknown): boolean {
return Boolean( return Boolean(
value && value &&
typeof value === 'object' && typeof value === 'object' &&
'$__' in (value as Record<string, unknown>), '$__' in (value as Record<string, unknown>),
); );
} }
@@ -11,7 +11,9 @@ interface NewRelicCustomEventApi {
eventType: string, eventType: string,
attributes: Record<string, NewRelicAttributeValue>, attributes: Record<string, NewRelicAttributeValue>,
): void; ): void;
addCustomAttributes(attributes: Record<string, NewRelicAttributeValue>): void; addCustomAttributes(
attributes: Record<string, NewRelicAttributeValue>,
): void;
setTransactionName(name: string): void; setTransactionName(name: string): void;
} }
const agent = newrelicAgent as unknown as NewRelicCustomEventApi; const agent = newrelicAgent as unknown as NewRelicCustomEventApi;
@@ -52,7 +52,8 @@ export interface ApiRequestPerformanceEvent {
leanQueryCount: number; leanQueryCount: number;
} }
export interface MongooseQueryPerformanceEvent extends MongooseQueryPerformance { export interface MongooseQueryPerformanceEvent
extends MongooseQueryPerformance {
type: 'mongoose-query'; type: 'mongoose-query';
timestamp: string; timestamp: string;
requestId?: string; requestId?: string;
@@ -91,7 +92,10 @@ export function resolveApiPerformanceConfig(
const enabled = readBoolean(env.API_PERF_OBSERVABILITY_ENABLED, false); const enabled = readBoolean(env.API_PERF_OBSERVABILITY_ENABLED, false);
return { return {
enabled, enabled,
localEventsEnabled: readBoolean(env.API_PERF_LOCAL_EVENTS_ENABLED, enabled), localEventsEnabled: readBoolean(
env.API_PERF_LOCAL_EVENTS_ENABLED,
enabled,
),
localEventFile: localEventFile:
env.API_PERF_LOCAL_EVENT_FILE || '/tmp/lolympus-api-performance.ndjson', env.API_PERF_LOCAL_EVENT_FILE || '/tmp/lolympus-api-performance.ndjson',
newRelicRequestEventsEnabled: readBoolean( newRelicRequestEventsEnabled: readBoolean(
@@ -59,15 +59,16 @@ describe('DistributedLockService', () => {
).resolves.toBe(true); ).resolves.toBe(true);
expect(sendCommand).toHaveBeenCalledWith([ expect(sendCommand).toHaveBeenCalledWith([
'DELEX', 'EVAL',
expect.stringContaining('redis.call("GET", KEYS[1]) == ARGV[1]'),
'1',
'distributed-lock:test', 'distributed-lock:test',
'IFEQ',
'owner-token', 'owner-token',
]); ]);
}); });
it('extends a lock only when the ownership token matches', async () => { it('extends a lock only when the ownership token matches', async () => {
const sendCommand = jest.fn().mockResolvedValue('OK'); const sendCommand = jest.fn().mockResolvedValue(1);
const service = createService(sendCommand); const service = createService(sendCommand);
await expect( await expect(
@@ -82,12 +83,11 @@ describe('DistributedLockService', () => {
).resolves.toBe(true); ).resolves.toBe(true);
expect(sendCommand).toHaveBeenCalledWith([ expect(sendCommand).toHaveBeenCalledWith([
'SET', 'EVAL',
expect.stringContaining('PEXPIRE'),
'1',
'distributed-lock:test', 'distributed-lock:test',
'owner-token', 'owner-token',
'IFEQ',
'owner-token',
'PX',
'45000', '45000',
]); ]);
}); });
@@ -2,6 +2,20 @@ import { Injectable, Logger } from '@nestjs/common';
import { randomUUID } from 'crypto'; import { randomUUID } from 'crypto';
import { RedisService } from './redis.service'; import { RedisService } from './redis.service';
const RELEASE_LOCK_IF_OWNED_SCRIPT = `
if redis.call("GET", KEYS[1]) == ARGV[1] then
return redis.call("DEL", KEYS[1])
end
return 0
`;
const EXTEND_LOCK_IF_OWNED_SCRIPT = `
if redis.call("GET", KEYS[1]) == ARGV[1] then
return redis.call("PEXPIRE", KEYS[1], ARGV[2])
end
return 0
`;
export interface DistributedLockOwnership { export interface DistributedLockOwnership {
lockKey: string; lockKey: string;
lockOwnershipToken: string; lockOwnershipToken: string;
@@ -21,7 +35,8 @@ export interface RunWithDistributedLockOptions {
lockRetryDelayMilliseconds?: number; lockRetryDelayMilliseconds?: number;
} }
export interface RunWithRenewedDistributedLockOptions extends RunWithDistributedLockOptions { export interface RunWithRenewedDistributedLockOptions
extends RunWithDistributedLockOptions {
lockRenewalIntervalMilliseconds: number; lockRenewalIntervalMilliseconds: number;
} }
@@ -40,13 +55,16 @@ export class DistributedLockService {
); );
const lockOwnershipToken = options.lockOwnershipToken ?? randomUUID(); const lockOwnershipToken = options.lockOwnershipToken ?? randomUUID();
const result = await this.redisService const result = await this.redisService.raw().sendCommand([
.raw() 'SET',
.sendCommand< options.lockKey,
string | null lockOwnershipToken,
>(['SET', options.lockKey, lockOwnershipToken, 'NX', 'PX', String(options.lockExpirationDurationMilliseconds)]); 'NX',
'PX',
String(options.lockExpirationDurationMilliseconds),
]);
if (result !== 'OK') return null; if (String(result) !== 'OK') return null;
return { return {
lockKey: options.lockKey, lockKey: options.lockKey,
lockOwnershipToken, lockOwnershipToken,
@@ -58,32 +76,35 @@ export class DistributedLockService {
public async releaseLockIfOwned( public async releaseLockIfOwned(
lockOwnership: DistributedLockOwnership, lockOwnership: DistributedLockOwnership,
): Promise<boolean> { ): Promise<boolean> {
const result = await this.redisService const result = await this.redisService.raw().sendCommand([
.raw() 'EVAL',
.sendCommand([ RELEASE_LOCK_IF_OWNED_SCRIPT,
'DELEX', '1',
lockOwnership.lockKey, lockOwnership.lockKey,
'IFEQ', lockOwnership.lockOwnershipToken,
lockOwnership.lockOwnershipToken, ]);
]);
return Number(result) === 1; return Number(result) === 1;
} }
public async extendLockIfOwned( public async extendLockIfOwned(
lockOwnership: DistributedLockOwnership, lockOwnership: DistributedLockOwnership,
lockExpirationDurationMilliseconds = lockOwnership.lockExpirationDurationMilliseconds, lockExpirationDurationMilliseconds =
lockOwnership.lockExpirationDurationMilliseconds,
): Promise<boolean> { ): Promise<boolean> {
this.assertPositiveDuration( this.assertPositiveDuration(
lockExpirationDurationMilliseconds, lockExpirationDurationMilliseconds,
'lockExpirationDurationMilliseconds', 'lockExpirationDurationMilliseconds',
); );
const result = await this.redisService const result = await this.redisService.raw().sendCommand([
.raw() 'EVAL',
.sendCommand< EXTEND_LOCK_IF_OWNED_SCRIPT,
string | null '1',
>(['SET', lockOwnership.lockKey, lockOwnership.lockOwnershipToken, 'IFEQ', lockOwnership.lockOwnershipToken, 'PX', String(lockExpirationDurationMilliseconds)]); lockOwnership.lockKey,
return result === 'OK'; lockOwnership.lockOwnershipToken,
String(lockExpirationDurationMilliseconds),
]);
return Number(result) === 1;
} }
public async runWithLock<TResult>( public async runWithLock<TResult>(
@@ -99,7 +120,7 @@ export class DistributedLockService {
await this.releaseLockIfOwned(lockOwnership).catch((error: unknown) => { await this.releaseLockIfOwned(lockOwnership).catch((error: unknown) => {
this.logger.warn( this.logger.warn(
`Failed to release distributed lock ${lockOwnership.lockKey}: ${ `Failed to release distributed lock ${lockOwnership.lockKey}: ${
error instanceof Error ? error.message : String(error) error instanceof Error ? error.message : error
}`, }`,
); );
}); });
@@ -118,7 +139,8 @@ export class DistributedLockService {
const lockOwnership = await this.acquireLockWithRetry(options); const lockOwnership = await this.acquireLockWithRetry(options);
if (!lockOwnership) return null; if (!lockOwnership) return null;
const lockRenewalTimer = setInterval(() => { let lockRenewalTimer: NodeJS.Timeout | undefined;
lockRenewalTimer = setInterval(() => {
void this.extendLockIfOwned(lockOwnership).then((wasExtended) => { void this.extendLockIfOwned(lockOwnership).then((wasExtended) => {
if (wasExtended) return; if (wasExtended) return;
this.logger.warn( this.logger.warn(
@@ -131,11 +153,11 @@ export class DistributedLockService {
try { try {
return await operation(lockOwnership); return await operation(lockOwnership);
} finally { } finally {
clearInterval(lockRenewalTimer); if (lockRenewalTimer) clearInterval(lockRenewalTimer);
await this.releaseLockIfOwned(lockOwnership).catch((error: unknown) => { await this.releaseLockIfOwned(lockOwnership).catch((error: unknown) => {
this.logger.warn( this.logger.warn(
`Failed to release distributed lock ${lockOwnership.lockKey}: ${ `Failed to release distributed lock ${lockOwnership.lockKey}: ${
error instanceof Error ? error.message : String(error) error instanceof Error ? error.message : error
}`, }`,
); );
}); });
@@ -1,8 +1,12 @@
import { normalizeRedisUrl, resolveRedisClientOptions } from './redis.config'; import {
assertDistinctRedisInstances,
normalizeRedisUrl,
resolveRedisClientOptions,
} from './redis.config';
describe('redis.config', () => { describe('redis.config', () => {
it('normalizes host:port endpoints into redis URLs', () => { it('normalizes host:port endpoints into redis URLs', () => {
expect(normalizeRedisUrl(' 127.0.0.1:6379 ')).toBe( expect(normalizeRedisUrl('127.0.0.1:6379', 'REDIS_ENDPOINT')).toBe(
'redis://127.0.0.1:6379', 'redis://127.0.0.1:6379',
); );
expect(normalizeRedisUrl('rediss://cache.example.com:6380')).toBe( expect(normalizeRedisUrl('rediss://cache.example.com:6380')).toBe(
@@ -11,8 +15,8 @@ describe('redis.config', () => {
}); });
it('throws a clear error for empty endpoints', () => { it('throws a clear error for empty endpoints', () => {
expect(() => normalizeRedisUrl(' ')).toThrow( expect(() => normalizeRedisUrl(' ', 'REDIS_ENDPOINT')).toThrow(
'GARNET_ENDPOINT cannot be empty', 'REDIS_ENDPOINT cannot be empty',
); );
}); });
@@ -22,32 +26,34 @@ describe('redis.config', () => {
endpoint: 'redis.internal:6379', endpoint: 'redis.internal:6379',
username: '', username: '',
password: undefined, password: undefined,
endpointEnvName: 'REDIS_ENDPOINT',
}), }),
).toEqual({ ).toEqual({
url: 'redis://redis.internal:6379', url: 'redis://redis.internal:6379',
}); });
}); });
it.each([undefined, '', ' '])( it('rejects auction Redis when it points at the same physical Redis instance', () => {
'rejects a missing or blank endpoint: %p', expect(() =>
(endpoint) => { assertDistinctRedisInstances(
expect(() => resolveRedisClientOptions({ endpoint })).toThrow( 'redis://cache.internal:6379/0',
'GARNET_ENDPOINT cannot be empty', 'redis://cache.internal:6379/1',
); ),
}, ).toThrow('AUCTION_REDIS must use a separate Redis instance');
); });
it('preserves TLS, database selection, and credentials', () => { it('allows different Redis hosts or ports', () => {
expect( expect(() =>
resolveRedisClientOptions({ assertDistinctRedisInstances(
endpoint: ' rediss://garnet.internal:6380/1 ', 'redis://cache.internal:6379',
username: ' garnet-user ', 'redis://auction.internal:6379',
password: ' garnet-password ', ),
}), ).not.toThrow();
).toEqual({ expect(() =>
url: 'rediss://garnet.internal:6380/1', assertDistinctRedisInstances(
username: 'garnet-user', 'redis://cache.internal:6379',
password: 'garnet-password', 'redis://cache.internal:6380',
}); ),
).not.toThrow();
}); });
}); });
@@ -1,5 +1,3 @@
import type { SecretService } from '../secret/secret.service';
export interface RedisClientOptions { export interface RedisClientOptions {
password?: string; password?: string;
url: string; url: string;
@@ -8,7 +6,10 @@ export interface RedisClientOptions {
export interface ResolveRedisClientOptionsParams { export interface ResolveRedisClientOptionsParams {
endpoint?: string; endpoint?: string;
endpointEnvName?: string;
password?: string; password?: string;
url?: string;
urlEnvName?: string;
username?: string; username?: string;
} }
@@ -17,10 +18,13 @@ function trimOptional(value: string | undefined): string | undefined {
return trimmed ? trimmed : undefined; return trimmed ? trimmed : undefined;
} }
export function normalizeRedisUrl(endpointOrUrl: string): string { export function normalizeRedisUrl(
endpointOrUrl: string,
envName = 'REDIS_URL',
): string {
const trimmed = endpointOrUrl.trim(); const trimmed = endpointOrUrl.trim();
if (!trimmed) { if (!trimmed) {
throw new Error('GARNET_ENDPOINT cannot be empty'); throw new Error(`${envName} cannot be empty`);
} }
if (/^redis(s)?:\/\//iu.test(trimmed)) { if (/^redis(s)?:\/\//iu.test(trimmed)) {
return trimmed; return trimmed;
@@ -31,8 +35,19 @@ export function normalizeRedisUrl(endpointOrUrl: string): string {
export function resolveRedisClientOptions( export function resolveRedisClientOptions(
params: ResolveRedisClientOptionsParams, params: ResolveRedisClientOptionsParams,
): RedisClientOptions { ): 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 = { const options: RedisClientOptions = {
url: normalizeRedisUrl(params.endpoint ?? ''), url: normalizeRedisUrl(selectedEndpoint, selectedEnvName),
}; };
const username = trimOptional(params.username); const username = trimOptional(params.username);
const password = trimOptional(params.password); const password = trimOptional(params.password);
@@ -41,20 +56,22 @@ export function resolveRedisClientOptions(
return options; return options;
} }
export async function loadRedisClientOptions( function parseRedisInstanceIdentity(redisUrl: string): string {
secretService: Pick<SecretService, 'get' | 'ready'>, const url = new URL(normalizeRedisUrl(redisUrl));
): Promise<RedisClientOptions> { const hostname = url.hostname.toLowerCase();
await secretService.ready(); const port = url.port || '6379';
const [endpoint, username, userId, password] = await Promise.all([ return `${hostname}:${port}`;
secretService.get<string>('GARNET_ENDPOINT', ''), }
secretService.get<string>('GARNET_USERNAME', ''),
secretService.get<string>('GARNET_USERID', ''),
secretService.get<string>('GARNET_PASSWORD', ''),
]);
return resolveRedisClientOptions({ export function assertDistinctRedisInstances(
endpoint, redisUrl: string,
password, auctionRedisUrl: string,
username: trimOptional(username) ?? userId, ): 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.',
);
}
} }
@@ -1,99 +0,0 @@
import { Test } from '@nestjs/testing';
import { createClient } from 'redis';
import { AuctionRedisModule } from '../../auction/redis/auction-redis.module';
import { AuctionRedisService } from '../../auction/redis/auction-redis.service';
import { SecretService } from '../secret/secret.service';
import { RedisModule } from './redis.module';
import { RedisService, type RedisClient } from './redis.service';
jest.mock('redis', () => ({ createClient: jest.fn() }));
describe('shared Garnet instance', () => {
it.each([
{
name: 'only GARNET_ENDPOINT is configured',
secrets: { GARNET_ENDPOINT: 'garnet.internal:6379' },
options: { url: 'redis://garnet.internal:6379' },
},
{
name: 'existing Garnet credentials are configured',
secrets: {
GARNET_ENDPOINT: ' rediss://garnet.internal:6380/1 ',
GARNET_USERID: 'garnet-user',
GARNET_PASSWORD: 'garnet-password',
},
options: {
url: 'rediss://garnet.internal:6380/1',
username: 'garnet-user',
password: 'garnet-password',
},
},
{
name: 'obsolete Redis settings are also configured',
secrets: {
GARNET_ENDPOINT: 'garnet.internal:6379',
GARNET_USERNAME: 'garnet-user',
GARNET_PASSWORD: 'garnet-password',
GARNET_URL: 'redis://obsolete-garnet.internal:6379',
REDIS_URL: 'redis://obsolete-common.internal:6379',
REDIS_ENDPOINT: 'obsolete-common.internal:6379',
REDIS_USERNAME: 'obsolete-common-user',
REDIS_PASSWORD: 'obsolete-common-password',
AUCTION_REDIS_URL: 'redis://obsolete-common.internal:6379',
AUCTION_REDIS_ENDPOINT: 'obsolete-common.internal:6379',
AUCTION_REDIS_USERNAME: 'obsolete-auction-user',
AUCTION_REDIS_PASSWORD: 'obsolete-auction-password',
},
options: {
url: 'redis://garnet.internal:6379',
username: 'garnet-user',
password: 'garnet-password',
},
},
])('boots both Redis modules when $name', async ({ secrets, options }) => {
const values: Record<string, string | undefined> = secrets;
const secretService = {
ready: jest.fn().mockResolvedValue(undefined),
get: jest.fn((key: string, fallback: string) =>
Promise.resolve(values[key] ?? fallback),
),
};
const clients = Array.from({ length: 2 }, () => ({
connect: jest.fn().mockResolvedValue(undefined),
on: jest.fn(),
quit: jest.fn().mockResolvedValue(undefined),
destroy: jest.fn(),
}));
const createClientMock = jest.mocked(createClient);
createClientMock.mockReset();
for (const client of clients) {
createClientMock.mockReturnValueOnce(client as unknown as RedisClient);
}
const module = await Test.createTestingModule({
imports: [RedisModule, AuctionRedisModule],
})
.overrideProvider(SecretService)
.useValue(secretService)
.compile();
try {
await module.init();
expect(createClientMock).toHaveBeenCalledTimes(2);
for (let index = 0; index < clients.length; index++) {
expect(createClientMock).toHaveBeenNthCalledWith(index + 1, options);
expect(clients[index].connect).toHaveBeenCalledTimes(1);
}
expect(clients).toContain(module.get(RedisService).raw());
expect(clients).toContain(module.get(AuctionRedisService).raw());
expect(module.get(RedisService).raw()).not.toBe(
module.get(AuctionRedisService).raw(),
);
} finally {
await module.close();
}
for (const client of clients) {
expect(client.quit).toHaveBeenCalledTimes(1);
}
});
});
Loaded 100 of 211 files, more files were not shown because too many files have changed in this diff. Show more