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