Compare commits

...
7 Commits
Author SHA1 Message Date
dahyeon 2bac89d3dc chore(deps): resolve high audit findings
Upgrade direct dependencies and pin patched transitive versions so the high-severity pnpm audit gate passes. Document the dev-only brace-expansion exception and the separate Mongoose type-migration follow-up.
2026-07-25 01:51:00 -07:00
dahyeon ca786fd80a fix(dakao): hide started matches from schedule 2026-07-25 01:01:57 -07:00
dahyeon a4215f86fb fix(web): satisfy React hook lint rules 2026-07-24 22:36:53 -07:00
dahyeon bb68be14fa fix(api): eliminate unsafe lint warnings 2026-07-24 22:16:53 -07:00
dahyeon fd1fa2366c fix(api): resolve lint errors 2026-07-24 21:52:35 -07:00
dahyeon 96fede9fe5 style(api): apply prettier formatting 2026-07-24 21:42:28 -07:00
dahyeon 80fef25af3 chore: upgrade runtime to Node.js 26 2026-07-18 05:21:49 +00:00
127 changed files with 3439 additions and 2611 deletions

No files matched your search

+1
View File
@@ -0,0 +1 @@
26
+2 -2
View File
@@ -1,11 +1,11 @@
# syntax=docker/dockerfile:1.7 # syntax=docker/dockerfile:1.7
FROM node:24-bookworm-slim AS pnpm-base FROM node:26-bookworm-slim AS pnpm-base
ENV PNPM_HOME=/pnpm ENV PNPM_HOME=/pnpm
ENV PATH="${PNPM_HOME}:${PATH}" ENV PATH="${PNPM_HOME}:${PATH}"
RUN corepack enable RUN npm install --global pnpm@10.4.1
WORKDIR /app WORKDIR /app
+22 -1
View File
@@ -29,7 +29,28 @@ export default tseslint.config(
'@typescript-eslint/no-explicit-any': 'off', '@typescript-eslint/no-explicit-any': 'off',
'@typescript-eslint/no-floating-promises': 'warn', '@typescript-eslint/no-floating-promises': 'warn',
'@typescript-eslint/no-unsafe-argument': 'warn', '@typescript-eslint/no-unsafe-argument': 'warn',
"prettier/prettier": ["error", { endOfLine: "auto" }], 'prettier/prettier': ['error', { endOfLine: 'auto' }],
},
},
{
files: ['**/*.spec.ts', 'test/**/*.ts'],
rules: {
'@typescript-eslint/no-unsafe-assignment': 'off',
'@typescript-eslint/no-unsafe-call': 'off',
'@typescript-eslint/no-unsafe-member-access': 'off',
'@typescript-eslint/no-unsafe-return': 'off',
'@typescript-eslint/no-this-alias': 'off',
'@typescript-eslint/require-await': 'off',
'@typescript-eslint/unbound-method': 'off',
},
},
{
files: ['src/modules/global/database/migrations/**/*.ts'],
rules: {
'@typescript-eslint/no-unsafe-assignment': 'off',
'@typescript-eslint/no-unsafe-call': 'off',
'@typescript-eslint/no-unsafe-member-access': 'off',
'@typescript-eslint/no-unsafe-return': 'off',
}, },
}, },
); );
+9 -9
View File
@@ -29,20 +29,20 @@
}, },
"dependencies": { "dependencies": {
"@lolympus/contracts": "workspace:*", "@lolympus/contracts": "workspace:*",
"@nestjs/common": "^11.0.1", "@nestjs/common": "^11.1.28",
"@nestjs/config": "^4.0.4", "@nestjs/config": "^4.0.4",
"@nestjs/core": "^11.0.1", "@nestjs/core": "^11.1.28",
"@nestjs/platform-express": "^11.0.1", "@nestjs/platform-express": "^11.1.28",
"@nestjs/platform-socket.io": "^11.1.19", "@nestjs/platform-socket.io": "^11.1.28",
"@nestjs/swagger": "^11.2.7", "@nestjs/swagger": "^11.4.6",
"@nestjs/websockets": "^11.1.19", "@nestjs/websockets": "^11.1.28",
"@socket.io/redis-adapter": "^8.3.0", "@socket.io/redis-adapter": "^8.3.0",
"class-transformer": "^0.5.1", "class-transformer": "^0.5.1",
"class-validator": "^0.15.1", "class-validator": "^0.15.1",
"jose": "^6.2.2", "jose": "^6.2.2",
"mongoose": "^9.4.1", "mongoose": "9.4.1",
"nats": "^2.29.3", "nats": "^2.29.3",
"newrelic": "^14.1.2", "newrelic": "^14.3.3",
"redis": "^5.12.1", "redis": "^5.12.1",
"reflect-metadata": "^0.2.2", "reflect-metadata": "^0.2.2",
"rxjs": "^7.8.1", "rxjs": "^7.8.1",
@@ -57,7 +57,7 @@
"@nestjs/testing": "^11.0.1", "@nestjs/testing": "^11.0.1",
"@types/express": "^5.0.0", "@types/express": "^5.0.0",
"@types/jest": "^30.0.0", "@types/jest": "^30.0.0",
"@types/node": "^24.0.0", "@types/node": "^26.1.1",
"@types/supertest": "^7.0.0", "@types/supertest": "^7.0.0",
"eslint": "^9.18.0", "eslint": "^9.18.0",
"eslint-config-prettier": "^10.0.1", "eslint-config-prettier": "^10.0.1",
@@ -79,7 +79,9 @@ describe('AuctionDeadlineScheduler', () => {
.spyOn(scheduler, 'processDueBidRoundDeadlines') .spyOn(scheduler, 'processDueBidRoundDeadlines')
.mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 }); .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]; const leaderLockToken = redis.acquireTokenLock.mock.calls[0]?.[1];
expect(redis.acquireTokenLock).toHaveBeenCalledWith( expect(redis.acquireTokenLock).toHaveBeenCalledWith(
@@ -100,7 +102,9 @@ describe('AuctionDeadlineScheduler', () => {
.spyOn(scheduler, 'processDueBidRoundDeadlines') .spyOn(scheduler, 'processDueBidRoundDeadlines')
.mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 }); .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(processDueBidRoundDeadlinesSpy).not.toHaveBeenCalled();
expect(redis.releaseTokenLock).not.toHaveBeenCalled(); expect(redis.releaseTokenLock).not.toHaveBeenCalled();
@@ -129,10 +133,12 @@ describe('AuctionDeadlineScheduler', () => {
it('prepares and completes due auction deadlines', async () => { it('prepares and completes due auction deadlines', async () => {
const matchId = '665f2f01f1f1f1f1f1f1f1f1'; const matchId = '665f2f01f1f1f1f1f1f1f1f1';
const completedState = { phase: 'passed', revision: 3 }; const completedState = { phase: 'passed', revision: 3 };
const { auctionService, eventBus, redisCommand, scheduler } = makeScheduler({ const { auctionService, eventBus, redisCommand, scheduler } = makeScheduler(
{
dueReply: [matchId], dueReply: [matchId],
completedState, completedState,
}); },
);
await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({ await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({
completed: 1, completed: 1,
@@ -149,7 +155,10 @@ describe('AuctionDeadlineScheduler', () => {
expect(auctionService.completePreparedExpiry).toHaveBeenCalledTimes(1); expect(auctionService.completePreparedExpiry).toHaveBeenCalledTimes(1);
// 만료 확정 결과는 즉시 1차 broadcast돼야 한다(클라가 입찰 라운드에 멈춰 // 만료 확정 결과는 즉시 1차 broadcast돼야 한다(클라가 입찰 라운드에 멈춰
// 후속 액션에서 CONFLICT가 반복되는 것을 막는 핵심 동작). // 후속 액션에서 CONFLICT가 반복되는 것을 막는 핵심 동작).
expect(eventBus.broadcastState).toHaveBeenCalledWith(matchId, completedState); expect(eventBus.broadcastState).toHaveBeenCalledWith(
matchId,
completedState,
);
}); });
it('skips noop expiry preparations', async () => { it('skips noop expiry preparations', async () => {
@@ -189,10 +198,7 @@ describe('AuctionDeadlineScheduler', () => {
}); });
it('continues processing later deadline items after one item fails', async () => { it('continues processing later deadline items after one item fails', async () => {
const matchIds = [ const matchIds = ['665f2f01f1f1f1f1f1f1f1f1', '665f2f02f1f1f1f1f1f1f1f1'];
'665f2f01f1f1f1f1f1f1f1f1',
'665f2f02f1f1f1f1f1f1f1f1',
];
const { auctionService, redisCommand, scheduler } = makeScheduler({ const { auctionService, redisCommand, scheduler } = makeScheduler({
dueReply: matchIds, dueReply: matchIds,
}); });
@@ -101,7 +101,9 @@ export class AuctionDeadlineScheduler implements OnModuleInit, OnModuleDestroy {
currentRedisTimestampMS: number, currentRedisTimestampMS: number,
batchLimit: number, batchLimit: number,
): Promise<string[]> { ): Promise<string[]> {
const reply = await this.auctionRedisService.raw().sendCommand([ const reply = await this.auctionRedisService
.raw()
.sendCommand([
'ZRANGEBYSCORE', 'ZRANGEBYSCORE',
BID_ROUND_DEADLINE_QUEUE_KEY, BID_ROUND_DEADLINE_QUEUE_KEY,
'-inf', '-inf',
@@ -177,11 +179,11 @@ export class AuctionDeadlineScheduler implements OnModuleInit, OnModuleDestroy {
return { completed, prepared, skipped }; return { completed, prepared, skipped };
} }
private async removeBidRoundDeadlineQueueEntry(matchId: string): Promise<void> { private async removeBidRoundDeadlineQueueEntry(
await this.auctionRedisService.raw().sendCommand([ matchId: string,
'ZREM', ): Promise<void> {
BID_ROUND_DEADLINE_QUEUE_KEY, await this.auctionRedisService
matchId, .raw()
]); .sendCommand(['ZREM', BID_ROUND_DEADLINE_QUEUE_KEY, matchId]);
} }
} }
@@ -20,9 +20,8 @@ export class AuctionEventBusService {
} }
public broadcastState(matchId: string, state: AuctionStateResponse): void { public broadcastState(matchId: string, state: AuctionStateResponse): void {
this.auctionNamespace?.to(matchId).emit( this.auctionNamespace
'state', ?.to(matchId)
serializeRealtimeAuction(state), .emit('state', serializeRealtimeAuction(state));
);
} }
} }
@@ -74,13 +74,11 @@ function serializeRealtimeAuctionPlayer(
return player; return player;
} }
const { const lightweightPlayer = { ...player };
masteries: _masteries, delete lightweightPlayer.masteries;
puuid: _puuid, delete lightweightPlayer.puuid;
recentStatsSummary: _recentStatsSummary, delete lightweightPlayer.recentStatsSummary;
tierHistory: _tierHistory, delete lightweightPlayer.tierHistory;
...lightweightPlayer
} = player;
return lightweightPlayer; return lightweightPlayer;
} }
@@ -22,7 +22,10 @@ describe('resolveAuctionRejectionReason', () => {
it('maps known BadRequest messages without a structured code', () => { it('maps known BadRequest messages without a structured code', () => {
expect( expect(
resolveAuctionRejectionReason(undefined, 'Cannot advance from current phase.'), resolveAuctionRejectionReason(
undefined,
'Cannot advance from current phase.',
),
).toBe( ).toBe(
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE, AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE,
); );
@@ -41,7 +41,9 @@ export class AuctionSideEffectService {
matchSideEffectStatus: AuctionMatchSideEffectStatus; matchSideEffectStatus: AuctionMatchSideEffectStatus;
}): Promise<boolean> { }): Promise<boolean> {
const keys = buildAuctionRedisKeys(params.matchId); const keys = buildAuctionRedisKeys(params.matchId);
const result = await this.auctionRedisService.raw().sendCommand([ const result = await this.auctionRedisService
.raw()
.sendCommand([
'EVAL', 'EVAL',
[ [
"if redis.call('HGET', KEYS[1], 'auctionLifecycleId') ~= ARGV[1] then return 0 end", "if redis.call('HGET', KEYS[1], 'auctionLifecycleId') ~= ARGV[1] then return 0 end",
@@ -78,8 +80,7 @@ export function canAcquireSideEffectLease(
if (state.state === 'pending' || state.state === 'failed') return true; if (state.state === 'pending' || state.state === 'failed') return true;
if (state.state !== 'processing') return false; if (state.state !== 'processing') return false;
return ( return (
(state.processingLeaseExpiresAtTimestampMS ?? 0) <= (state.processingLeaseExpiresAtTimestampMS ?? 0) <= currentRedisTimestampMS
currentRedisTimestampMS
); );
} }
@@ -59,8 +59,7 @@ export class AuctionController {
initialTeamBidPointAmount: c.initialTeamBidPointAmount, initialTeamBidPointAmount: c.initialTeamBidPointAmount,
})), })),
initialTeamBidPointAmount: body.initialTeamBidPointAmount ?? 1000, initialTeamBidPointAmount: body.initialTeamBidPointAmount ?? 1000,
maximumBidRoundDurationSeconds: maximumBidRoundDurationSeconds: body.maximumBidRoundDurationSeconds ?? 30,
body.maximumBidRoundDurationSeconds ?? 30,
bidRoundExtensionSeconds: body.bidRoundExtensionSeconds ?? 5, bidRoundExtensionSeconds: body.bidRoundExtensionSeconds ?? 5,
topTierAuctionPriorityThreshold: topTierAuctionPriorityThreshold:
body.topTierAuctionPriorityThreshold ?? 'NONE', body.topTierAuctionPriorityThreshold ?? 'NONE',
+96 -56
View File
@@ -13,7 +13,7 @@ import {
} from '@nestjs/websockets'; } from '@nestjs/websockets';
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import type { JWTPayload } from 'jose'; import type { JWTPayload } from 'jose';
import { Namespace, Socket } from 'socket.io'; import type { DefaultEventsMap, Namespace, Socket } from 'socket.io';
import { AuthService } from '../auth/auth.service'; import { AuthService } from '../auth/auth.service';
import { IdentityService } from '../auth/identity.service'; import { IdentityService } from '../auth/identity.service';
import { JwtService } from '../auth/jwt.service'; import { JwtService } from '../auth/jwt.service';
@@ -78,6 +78,20 @@ interface BidRateLimitState {
windowStartedAtTimestampMS: number; windowStartedAtTimestampMS: number;
} }
interface AuctionSocketData {
auctionBidRateLimit?: BidRateLimitState;
identity?: IdentityDocument;
matchId?: string;
user?: UserDocument;
}
type AuctionSocket = Socket<
DefaultEventsMap,
DefaultEventsMap,
DefaultEventsMap,
AuctionSocketData
>;
const BID_RATE_LIMIT_WINDOW_MS = 1000; const BID_RATE_LIMIT_WINDOW_MS = 1000;
const BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW = 8; const BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW = 8;
const BID_RATE_LIMIT_REJECTION_CODE = 'BID_RATE_LIMITED'; const BID_RATE_LIMIT_REJECTION_CODE = 'BID_RATE_LIMITED';
@@ -92,9 +106,7 @@ const BID_RATE_LIMIT_REJECTION_MESSAGE =
allowedHeaders: ['Authorization', 'Content-Type', 'X-Auth-User-Id'], allowedHeaders: ['Authorization', 'Content-Type', 'X-Auth-User-Id'],
}, },
}) })
export class AuctionGateway export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
implements OnGatewayConnection, OnGatewayInit
{
@WebSocketServer() @WebSocketServer()
private server!: Namespace; private server!: Namespace;
@@ -114,14 +126,14 @@ export class AuctionGateway
this.auctionEventBusService.attachAuctionNamespace(server); this.auctionEventBusService.attachAuctionNamespace(server);
} }
public async handleConnection(socket: Socket) { public async handleConnection(socket: AuctionSocket) {
try { try {
await this.authenticateSocket(socket); await this.authenticateSocket(socket);
this.logger.debug(`Auction client connected: ${socket.id}`); this.logger.debug(`Auction client connected: ${socket.id}`);
} catch (err) { } catch (err) {
this.logger.warn( this.logger.warn(
`Auction client authentication failed: ${ `Auction client authentication failed: ${
err instanceof Error ? err.message : err err instanceof Error ? err.message : String(err)
}`, }`,
); );
socket.disconnect(true); socket.disconnect(true);
@@ -130,7 +142,7 @@ export class AuctionGateway
@SubscribeMessage('join') @SubscribeMessage('join')
public async handleJoin( public async handleJoin(
@ConnectedSocket() socket: Socket, @ConnectedSocket() socket: AuctionSocket,
@MessageBody() payload: JoinAuctionPayload, @MessageBody() payload: JoinAuctionPayload,
) { ) {
if (!payload?.matchId || !mongoose.isValidObjectId(payload.matchId)) { if (!payload?.matchId || !mongoose.isValidObjectId(payload.matchId)) {
@@ -158,7 +170,7 @@ export class AuctionGateway
@SubscribeMessage('bid') @SubscribeMessage('bid')
public async handleBid( public async handleBid(
@ConnectedSocket() socket: Socket, @ConnectedSocket() socket: AuctionSocket,
@MessageBody() payload: BidPayload, @MessageBody() payload: BidPayload,
@Ack() ack?: (response: Record<string, unknown>) => void, @Ack() ack?: (response: Record<string, unknown>) => void,
) { ) {
@@ -205,7 +217,9 @@ export class AuctionGateway
ack?.({ ack?.({
...(bidDelta ...(bidDelta
? {} ? {}
: { state: this.serializeAuction(bidResult as AuctionStateResponse) }), : {
state: this.serializeAuction(bidResult as AuctionStateResponse),
}),
ok: true, ok: true,
bidRequestId, bidRequestId,
bidDelta: broadcastBidDelta, bidDelta: broadcastBidDelta,
@@ -220,7 +234,12 @@ export class AuctionGateway
error, error,
); );
const bidServerTiming = this.extractBidServerTiming(rejectionAckFields); const bidServerTiming = this.extractBidServerTiming(rejectionAckFields);
this.emitError(socket, String(rejectionAckFields.message ?? '')); this.emitError(
socket,
typeof rejectionAckFields.message === 'string'
? rejectionAckFields.message
: '',
);
ack?.({ ack?.({
...rejectionAckFields, ...rejectionAckFields,
bidRequestId, bidRequestId,
@@ -263,7 +282,7 @@ export class AuctionGateway
@SubscribeMessage('open-bidding') @SubscribeMessage('open-bidding')
public async handleOpenBidding( public async handleOpenBidding(
@ConnectedSocket() socket: Socket, @ConnectedSocket() socket: AuctionSocket,
@MessageBody() payload: AuctionActionPayload, @MessageBody() payload: AuctionActionPayload,
@Ack() ack?: (response: Record<string, unknown>) => void, @Ack() ack?: (response: Record<string, unknown>) => void,
) { ) {
@@ -292,7 +311,7 @@ export class AuctionGateway
@SubscribeMessage('sold') @SubscribeMessage('sold')
public async handleSold( public async handleSold(
@ConnectedSocket() socket: Socket, @ConnectedSocket() socket: AuctionSocket,
@MessageBody() payload: SoldPayload, @MessageBody() payload: SoldPayload,
@Ack() ack?: (response: Record<string, unknown>) => void, @Ack() ack?: (response: Record<string, unknown>) => void,
) { ) {
@@ -322,7 +341,7 @@ export class AuctionGateway
@SubscribeMessage('next') @SubscribeMessage('next')
public async handleNext( public async handleNext(
@ConnectedSocket() socket: Socket, @ConnectedSocket() socket: AuctionSocket,
@MessageBody() payload: AuctionActionPayload, @MessageBody() payload: AuctionActionPayload,
@Ack() ack?: (response: Record<string, unknown>) => void, @Ack() ack?: (response: Record<string, unknown>) => void,
) { ) {
@@ -351,7 +370,7 @@ export class AuctionGateway
@SubscribeMessage('passed') @SubscribeMessage('passed')
public async handlePassed( public async handlePassed(
@ConnectedSocket() socket: Socket, @ConnectedSocket() socket: AuctionSocket,
@MessageBody() payload: AuctionActionPayload, @MessageBody() payload: AuctionActionPayload,
@Ack() ack?: (response: Record<string, unknown>) => void, @Ack() ack?: (response: Record<string, unknown>) => void,
) { ) {
@@ -380,7 +399,7 @@ export class AuctionGateway
@SubscribeMessage('chat-message') @SubscribeMessage('chat-message')
public async handleChatMessage( public async handleChatMessage(
@ConnectedSocket() socket: Socket, @ConnectedSocket() socket: AuctionSocket,
@MessageBody() payload: ChatMessagePayload, @MessageBody() payload: ChatMessagePayload,
) { ) {
const matchId = this.requireJoinedMatchId(socket); const matchId = this.requireJoinedMatchId(socket);
@@ -406,7 +425,7 @@ export class AuctionGateway
} }
} }
private requireJoinedMatchId(socket: Socket): string | null { private requireJoinedMatchId(socket: AuctionSocket): string | null {
const matchId = this.getSocketMatchId(socket); const matchId = this.getSocketMatchId(socket);
if (!matchId) { if (!matchId) {
this.emitError(socket, 'Join a match room before sending events.'); this.emitError(socket, 'Join a match room before sending events.');
@@ -415,10 +434,9 @@ export class AuctionGateway
return matchId; return matchId;
} }
private consumeBidRateLimit(socket: Socket): boolean { private consumeBidRateLimit(socket: AuctionSocket): boolean {
const currentTimestampMS = Date.now(); const currentTimestampMS = Date.now();
const previousState = socket.data const previousState = socket.data.auctionBidRateLimit;
.auctionBidRateLimit as BidRateLimitState | undefined;
if ( if (
!previousState || !previousState ||
currentTimestampMS - previousState.windowStartedAtTimestampMS >= currentTimestampMS - previousState.windowStartedAtTimestampMS >=
@@ -436,10 +454,8 @@ export class AuctionGateway
return previousState.count <= BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW; return previousState.count <= BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW;
} }
private getSocketMatchId(socket: Socket): string | undefined { private getSocketMatchId(socket: AuctionSocket): string | undefined {
return typeof socket.data.matchId === 'string' return socket.data.matchId;
? socket.data.matchId
: undefined;
} }
private toAuctionActionRequest(payload?: AuctionActionPayload) { private toAuctionActionRequest(payload?: AuctionActionPayload) {
@@ -463,8 +479,9 @@ export class AuctionGateway
}; };
} }
private readHandshakeUserId(socket: Socket): string | undefined { private readHandshakeUserId(socket: AuctionSocket): string | undefined {
const authUserId = socket.handshake.auth['x-auth-user-id']; const handshakeAuth = socket.handshake.auth as Record<string, unknown>;
const authUserId = handshakeAuth['x-auth-user-id'];
if (typeof authUserId === 'string') return authUserId; if (typeof authUserId === 'string') return authUserId;
const header = socket.handshake.headers['x-auth-user-id']; const header = socket.handshake.headers['x-auth-user-id'];
@@ -472,16 +489,16 @@ export class AuctionGateway
} }
private resolveSocketUserId( private resolveSocketUserId(
socket: Socket, socket: AuctionSocket,
): mongoose.Types.ObjectId | undefined { ): mongoose.Types.ObjectId | undefined {
return (socket.data.user as UserDocument | undefined)?._id; return socket.data.user?._id;
} }
private resolveChatDisplayName( private resolveChatDisplayName(
socket: Socket, socket: AuctionSocket,
fallbackDisplayName?: string, fallbackDisplayName?: string,
): string { ): string {
const user = socket.data.user as UserDocument | undefined; const user = socket.data.user;
const primaryRiotAccount = const primaryRiotAccount =
user?.riotAccounts.find((entry) => entry.isPrimary) ?? user?.riotAccounts.find((entry) => entry.isPrimary) ??
user?.riotAccounts[0]; user?.riotAccounts[0];
@@ -494,14 +511,14 @@ export class AuctionGateway
if (user?.kakaoTalkNickname) return user.kakaoTalkNickname; if (user?.kakaoTalkNickname) return user.kakaoTalkNickname;
if (user?.discordNickname) return user.discordNickname; if (user?.discordNickname) return user.discordNickname;
const identity = socket.data.identity as IdentityDocument | undefined; const identity = socket.data.identity;
if (identity?.displayName) return identity.displayName; if (identity?.displayName) return identity.displayName;
if (identity?.email) return identity.email; if (identity?.email) return identity.email;
return fallbackDisplayName ?? '관전자'; return fallbackDisplayName ?? '관전자';
} }
private async authenticateSocket(socket: Socket): Promise<void> { private async authenticateSocket(socket: AuctionSocket): Promise<void> {
const fallback = await this.authService.resolveDevUserById( const fallback = await this.authService.resolveDevUserById(
this.readHandshakeUserId(socket), this.readHandshakeUserId(socket),
); );
@@ -531,14 +548,20 @@ export class AuctionGateway
}); });
} }
private readHandshakeToken(socket: Socket): string | undefined { private readHandshakeToken(socket: AuctionSocket): string | undefined {
const authToken = socket.handshake.auth.token; const handshakeAuth = socket.handshake.auth as Record<string, unknown>;
const authToken = handshakeAuth.token;
if (typeof authToken === 'string' && authToken.trim()) { if (typeof authToken === 'string' && authToken.trim()) {
return authToken.trim().replace(/^Bearer\s+/i, ''); return authToken.trim().replace(/^Bearer\s+/i, '');
} }
const header = socket.handshake.headers.authorization; const header: unknown = socket.handshake.headers.authorization;
const authorization = Array.isArray(header) ? header[0] : header; const authorization =
typeof header === 'string'
? header
: Array.isArray(header) && typeof header[0] === 'string'
? header[0]
: undefined;
if (authorization?.startsWith('Bearer ')) { if (authorization?.startsWith('Bearer ')) {
return authorization.slice('Bearer '.length).trim(); return authorization.slice('Bearer '.length).trim();
} }
@@ -546,10 +569,11 @@ export class AuctionGateway
} }
private async resolveSocketUserForMatch( private async resolveSocketUserForMatch(
socket: Socket, socket: AuctionSocket,
matchId: string, matchId: string,
): Promise<void> { ): Promise<void> {
if (socket.data.user || !socket.data.identity) return; if (socket.data.user || !socket.data.identity) return;
const identity = socket.data.identity;
const MatchModel = await this.connectionService.getModel('match'); const MatchModel = await this.connectionService.getModel('match');
const match = await MatchModel.findById(matchId).select({ const match = await MatchModel.findById(matchId).select({
@@ -558,10 +582,11 @@ export class AuctionGateway
if (!match) return; if (!match) return;
const UserModel = await this.connectionService.getModel('user'); const UserModel = await this.connectionService.getModel('user');
socket.data.user = await UserModel.findOne({ const user = await UserModel.findOne({
communityId: match.communityId, communityId: match.communityId,
identityId: (socket.data.identity as IdentityDocument)._id, identityId: identity._id,
}).exec(); }).exec();
socket.data.user = user ?? undefined;
} }
private requireStringClaim(payload: JWTPayload, key: string): string { private requireStringClaim(payload: JWTPayload, key: string): string {
@@ -595,7 +620,7 @@ export class AuctionGateway
this.server.to(matchId).emit('match-side-effect', delta); this.server.to(matchId).emit('match-side-effect', delta);
} }
private emitChatHistory(socket: Socket, auction: AuctionDocument) { private emitChatHistory(socket: AuctionSocket, auction: AuctionDocument) {
socket.emit('chat-history', { socket.emit('chat-history', {
messages: (auction.chatMessages ?? []).map((message) => messages: (auction.chatMessages ?? []).map((message) =>
this.serializeChatMessage(message), this.serializeChatMessage(message),
@@ -603,16 +628,21 @@ export class AuctionGateway
}); });
} }
private emitKnownError(socket: Socket, error: unknown) { private emitKnownError(socket: AuctionSocket, error: unknown) {
this.emitError(socket, this.resolveErrorPayload(error).message); this.emitError(socket, this.resolveErrorPayload(error).message);
} }
private emitError(socket: Socket, message: string) { private emitError(socket: AuctionSocket, message: string) {
socket.emit('error', { message }); socket.emit('error', { message });
} }
private serializeAuction(auction: AuctionStateResponse) { private serializeAuction(
return JSON.parse(JSON.stringify(auction)); auction: AuctionStateResponse,
): Record<string, unknown> {
const serialized: unknown = JSON.parse(JSON.stringify(auction));
return typeof serialized === 'object' && serialized !== null
? (serialized as Record<string, unknown>)
: {};
} }
/** /**
@@ -633,7 +663,9 @@ export class AuctionGateway
typeof errorPayload.code === 'string' ? errorPayload.code : undefined, typeof errorPayload.code === 'string' ? errorPayload.code : undefined,
errorPayload.message, errorPayload.message,
); );
const resyncRecommended = isAuctionResyncRecommended(auctionRejectionReason); const resyncRecommended = isAuctionResyncRecommended(
auctionRejectionReason,
);
const state = resyncRecommended const state = resyncRecommended
? await this.fetchSerializedAuctionState(matchId) ? await this.fetchSerializedAuctionState(matchId)
: undefined; : undefined;
@@ -688,7 +720,9 @@ export class AuctionGateway
return { return {
code: error instanceof Error ? error.message : 'UNKNOWN', code: error instanceof Error ? error.message : 'UNKNOWN',
message: message:
error instanceof Error ? error.message : 'Unexpected auction gateway error.', error instanceof Error
? error.message
: 'Unexpected auction gateway error.',
}; };
} }
@@ -716,7 +750,8 @@ export class AuctionGateway
bidDelta: Record<string, unknown> | null, bidDelta: Record<string, unknown> | null,
): Record<string, unknown> | null { ): Record<string, unknown> | null {
if (!bidDelta || !('bidServerTiming' in bidDelta)) return bidDelta; if (!bidDelta || !('bidServerTiming' in bidDelta)) return bidDelta;
const { bidServerTiming: _bidServerTiming, ...publicBidDelta } = bidDelta; const publicBidDelta = { ...bidDelta };
delete publicBidDelta.bidServerTiming;
return publicBidDelta; return publicBidDelta;
} }
@@ -724,7 +759,7 @@ export class AuctionGateway
auction: AuctionStateResponse, auction: AuctionStateResponse,
bidRequestId?: string, bidRequestId?: string,
): Record<string, unknown> | null { ): Record<string, unknown> | null {
const serialized = this.serializeAuction(auction) as Record<string, unknown>; const serialized = this.serializeAuction(auction);
const revision = Number(serialized.revision); const revision = Number(serialized.revision);
const currentHighestBidPointAmount = Number( const currentHighestBidPointAmount = Number(
serialized.currentHighestBidPointAmount ?? serialized.currentBid, serialized.currentHighestBidPointAmount ?? serialized.currentBid,
@@ -739,11 +774,13 @@ export class AuctionGateway
? Date.parse(serialized.currentDeadline) ? Date.parse(serialized.currentDeadline)
: 0), : 0),
); );
const redisBidHistory = Array.isArray(serialized.auctionBidHistory) const redisBidHistory: unknown[] = Array.isArray(
? serialized.auctionBidHistory serialized.auctionBidHistory,
)
? (serialized.auctionBidHistory as unknown[])
: []; : [];
const legacyBidHistory = Array.isArray(serialized.bids) const legacyBidHistory: unknown[] = Array.isArray(serialized.bids)
? serialized.bids ? (serialized.bids as unknown[])
: []; : [];
const auctionBidHistoryEntry = const auctionBidHistoryEntry =
redisBidHistory[redisBidHistory.length - 1] ?? redisBidHistory[redisBidHistory.length - 1] ??
@@ -775,9 +812,7 @@ export class AuctionGateway
}; };
} }
private isBidDeltaResponse( private isBidDeltaResponse(value: unknown): value is AuctionBidDeltaResponse {
value: unknown,
): value is AuctionBidDeltaResponse {
return ( return (
typeof value === 'object' && typeof value === 'object' &&
value !== null && value !== null &&
@@ -804,7 +839,12 @@ export class AuctionGateway
}; };
} }
private serializeChatMessage(message: AuctionChatMessage) { private serializeChatMessage(
return JSON.parse(JSON.stringify(message)); message: AuctionChatMessage,
): Record<string, unknown> {
const serialized: unknown = JSON.parse(JSON.stringify(message));
return typeof serialized === 'object' && serialized !== null
? (serialized as Record<string, unknown>)
: {};
} }
} }
@@ -2,6 +2,30 @@ import mongoose from 'mongoose';
import { AuctionService } from './auction.service'; import { AuctionService } from './auction.service';
describe('AuctionService', () => { describe('AuctionService', () => {
function requireRecord(
value: unknown,
label: string,
): Record<string, unknown> {
if (!value || typeof value !== 'object' || Array.isArray(value)) {
throw new Error(`${label} must be an object.`);
}
return value as Record<string, unknown>;
}
function requireArray(value: unknown, label: string): unknown[] {
if (!Array.isArray(value)) {
throw new Error(`${label} must be an array.`);
}
return value as unknown[];
}
function parseJsonRecord(value: unknown, label: string) {
if (typeof value !== 'string') {
throw new Error(`${label} must be a JSON string.`);
}
return requireRecord(JSON.parse(value) as unknown, label);
}
function createService(models: Record<string, unknown>) { function createService(models: Record<string, unknown>) {
const auctionHistoryModel = { const auctionHistoryModel = {
findOne: jest.fn().mockReturnValue({ findOne: jest.fn().mockReturnValue({
@@ -158,8 +182,7 @@ describe('AuctionService', () => {
it('rejects non-positive or fractional bid amounts before loading auction state', async () => { it('rejects non-positive or fractional bid amounts before loading auction state', async () => {
const matchId = new mongoose.Types.ObjectId(); const matchId = new mongoose.Types.ObjectId();
const auctionFindOne = jest.fn(); const auctionFindOne = jest.fn();
const { service, auctionRedisCommandService, auctionRedisService } = const { service, auctionRedisCommandService } = createService({
createService({
auction: { auction: {
findOne: auctionFindOne, findOne: auctionFindOne,
}, },
@@ -1008,7 +1031,12 @@ describe('AuctionService', () => {
); );
const transitionInput = const transitionInput =
auctionRedisCommandService.applyTransition.mock.calls[0][1]; auctionRedisCommandService.applyTransition.mock.calls[0][1];
expect(JSON.parse(transitionInput.durabilityPayloadJson)).toMatchObject({ expect(
parseJsonRecord(
transitionInput.durabilityPayloadJson,
'durabilityPayloadJson',
),
).toMatchObject({
afterAuctionMongoProjection: expect.objectContaining({ afterAuctionMongoProjection: expect.objectContaining({
phase: 'bidding', phase: 'bidding',
revision: 2, revision: 2,
@@ -1179,17 +1207,40 @@ describe('AuctionService', () => {
const transitionInput = const transitionInput =
auctionRedisCommandService.applyTransition.mock.calls[0][1]; auctionRedisCommandService.applyTransition.mock.calls[0][1];
const durabilityPayload = JSON.parse(transitionInput.durabilityPayloadJson); const durabilityPayload = parseJsonRecord(
expect(durabilityPayload.snapshotBefore).toMatchObject({ transitionInput.durabilityPayloadJson,
'durabilityPayloadJson',
);
const snapshotBefore = requireRecord(
durabilityPayload.snapshotBefore,
'snapshotBefore',
);
const snapshotBeforeTeams = requireArray(
snapshotBefore.auctionTeams,
'snapshotBefore.auctionTeams',
);
const snapshotBeforeTeam = requireRecord(
snapshotBeforeTeams[0],
'snapshotBefore.auctionTeams[0]',
);
const afterAuctionMongoProjection = requireRecord(
durabilityPayload.afterAuctionMongoProjection,
'afterAuctionMongoProjection',
);
const projectedTeams = requireArray(
afterAuctionMongoProjection.auctionTeams,
'afterAuctionMongoProjection.auctionTeams',
);
const projectedTeam = requireRecord(
projectedTeams[0],
'afterAuctionMongoProjection.auctionTeams[0]',
);
expect(snapshotBefore).toMatchObject({
phase: 'bidding', phase: 'bidding',
revision: 4, revision: 4,
}); });
expect(durabilityPayload.snapshotBefore.auctionTeams[0].members).toEqual( expect(snapshotBeforeTeam.members).toEqual([]);
[], expect(projectedTeam.members).toEqual([
);
expect(
durabilityPayload.afterAuctionMongoProjection.auctionTeams[0].members,
).toEqual([
expect.objectContaining({ expect.objectContaining({
memberAcquisitionBidPointAmount: 120, memberAcquisitionBidPointAmount: 120,
userId: playerUserId.toString(), userId: playerUserId.toString(),
@@ -1397,7 +1448,12 @@ describe('AuctionService', () => {
}); });
const [, transitionInput] = const [, transitionInput] =
auctionRedisCommandService.applyTransition.mock.calls.at(-1) ?? []; auctionRedisCommandService.applyTransition.mock.calls.at(-1) ?? [];
expect(JSON.parse(transitionInput.durabilityPayloadJson)).toMatchObject({ expect(
parseJsonRecord(
transitionInput.durabilityPayloadJson,
'durabilityPayloadJson',
),
).toMatchObject({
afterAuctionMongoProjection: { afterAuctionMongoProjection: {
matchSideEffectStatus: 'pending', matchSideEffectStatus: 'pending',
phase: 'complete', phase: 'complete',
@@ -2568,7 +2624,10 @@ describe('AuctionService', () => {
durationSeconds: 30, durationSeconds: 30,
mode: 'set-relative', mode: 'set-relative',
}); });
const durabilityPayload = JSON.parse(transitionInput.durabilityPayloadJson); const durabilityPayload = parseJsonRecord(
transitionInput.durabilityPayloadJson,
'durabilityPayloadJson',
);
expect(durabilityPayload).toMatchObject({ expect(durabilityPayload).toMatchObject({
auctionActionType: 'undo', auctionActionType: 'undo',
historyMutation: { historyMutation: {
@@ -210,8 +210,12 @@ describe('AuctionRedisCommandService', () => {
it('parses apply transition replay and rejected replies', async () => { it('parses apply transition replay and rejected replies', async () => {
await expect( await expect(
makeService(['REPLAY', 'APPLIED', 'transition-1', '2100']) makeService([
.service.applyTransition('match-1', { 'REPLAY',
'APPLIED',
'transition-1',
'2100',
]).service.applyTransition('match-1', {
afterAuctionStructureStateJson: '{}', afterAuctionStructureStateJson: '{}',
auctionHistorySequence: 5, auctionHistorySequence: 5,
auctionLifecycleId: 'life-1', auctionLifecycleId: 'life-1',
@@ -233,8 +237,12 @@ describe('AuctionRedisCommandService', () => {
}); });
await expect( await expect(
makeService(['REJECTED', 'CONFLICT', 'transition-1', '2200']) makeService([
.service.applyTransition('match-1', { 'REJECTED',
'CONFLICT',
'transition-1',
'2200',
]).service.applyTransition('match-1', {
afterAuctionStructureStateJson: '{}', afterAuctionStructureStateJson: '{}',
auctionHistorySequence: 5, auctionHistorySequence: 5,
auctionLifecycleId: 'life-1', auctionLifecycleId: 'life-1',
@@ -288,8 +296,13 @@ describe('AuctionRedisCommandService', () => {
it('parses expire prepare replay and noop replies', async () => { it('parses expire prepare replay and noop replies', async () => {
await expect( await expect(
makeService(['REPLAY', 'passed', 'expire-1', '12', '3100']) makeService([
.service.expirePrepare('match-1', { 'REPLAY',
'passed',
'expire-1',
'12',
'3100',
]).service.expirePrepare('match-1', {
auctionStateTransitionId: 'expire-1', auctionStateTransitionId: 'expire-1',
bidRoundExpiryRetryDelayMS: 3000, bidRoundExpiryRetryDelayMS: 3000,
matchId: 'match-1', matchId: 'match-1',
@@ -360,8 +373,11 @@ describe('AuctionRedisCommandService', () => {
}); });
await expect( await expect(
makeService(['REJECTED', 'INVALID_PATCH_ARITY', '4200']) makeService([
.service.hydrateState('match-1', { 'REJECTED',
'INVALID_PATCH_ARITY',
'4200',
]).service.hydrateState('match-1', {
auctionHistorySequence: 3, auctionHistorySequence: 3,
auctionLifecycleId: 'life-1', auctionLifecycleId: 'life-1',
maximumBidRoundDurationSeconds: 30, maximumBidRoundDurationSeconds: 30,
@@ -85,7 +85,9 @@ export function stringifyAuctionRedisStructureState(
return JSON.stringify(buildAuctionRedisStructureState(input)); return JSON.stringify(buildAuctionRedisStructureState(input));
} }
function countAuctionTeamMembersIncludingCaptain(team: RedisAuctionTeam): number { function countAuctionTeamMembersIncludingCaptain(
team: RedisAuctionTeam,
): number {
const userIds = new Set<string>([team.captainUserId.toString()]); const userIds = new Set<string>([team.captainUserId.toString()]);
for (const member of team.members) { for (const member of team.members) {
userIds.add(member.userId.toString()); userIds.add(member.userId.toString());
@@ -1,7 +1,10 @@
import { AuctionRedisService } from './auction-redis.service'; import { AuctionRedisService } from './auction-redis.service';
import { AuctionRedisStateReaderService } from './auction-redis-state-reader.service'; import { AuctionRedisStateReaderService } from './auction-redis-state-reader.service';
function makeService(commandReplies: unknown[], currentServerTimestampMS = 1000) { function makeService(
commandReplies: unknown[],
currentServerTimestampMS = 1000,
) {
const sendCommand = jest const sendCommand = jest
.fn() .fn()
.mockImplementation(() => Promise.resolve(commandReplies.shift())); .mockImplementation(() => Promise.resolve(commandReplies.shift()));
@@ -149,7 +152,9 @@ describe('AuctionRedisStateReaderService', () => {
[], [],
]); ]);
await expect(service.readAuctionStateView('match-1')).resolves.toMatchObject({ await expect(
service.readAuctionStateView('match-1'),
).resolves.toMatchObject({
auctionLifecycleId: 'life-1', auctionLifecycleId: 'life-1',
auctionTeams: [], auctionTeams: [],
phase: 'presenting', phase: 'presenting',
@@ -181,7 +186,6 @@ describe('AuctionRedisStateReaderService', () => {
}); });
}); });
it('returns null when live or structure state is absent', async () => { it('returns null when live or structure state is absent', async () => {
await expect( await expect(
makeService([[], '{"auctionTeams":[]}', []]).service.readAuctionStateView( makeService([[], '{"auctionTeams":[]}', []]).service.readAuctionStateView(
@@ -42,7 +42,9 @@ export class AuctionRedisStateReaderService {
matchId: string, matchId: string,
): Promise<AuctionRedisLiveStateIdentity | null> { ): Promise<AuctionRedisLiveStateIdentity | null> {
const keys = buildAuctionRedisKeys(matchId); const keys = buildAuctionRedisKeys(matchId);
const reply = await this.auctionRedisService.raw().sendCommand([ const reply = await this.auctionRedisService
.raw()
.sendCommand([
'HMGET', 'HMGET',
keys.liveStateKey, keys.liveStateKey,
'auctionLifecycleId', 'auctionLifecycleId',
@@ -68,7 +70,9 @@ export class AuctionRedisStateReaderService {
): Promise<AuctionRedisBidContext | null> { ): Promise<AuctionRedisBidContext | null> {
const keys = buildAuctionRedisKeys(matchId); const keys = buildAuctionRedisKeys(matchId);
const bidderTeamCaptainUserIdField = `team:${bidderTeamIndex}:captainUserId`; const bidderTeamCaptainUserIdField = `team:${bidderTeamIndex}:captainUserId`;
const liveReply = await this.auctionRedisService.raw().sendCommand([ const liveReply = await this.auctionRedisService
.raw()
.sendCommand([
'HMGET', 'HMGET',
keys.liveStateKey, keys.liveStateKey,
'phase', 'phase',
@@ -102,17 +106,22 @@ export class AuctionRedisStateReaderService {
options: AuctionRedisStateViewReadOptions = {}, options: AuctionRedisStateViewReadOptions = {},
): Promise<Record<string, unknown> | null> { ): Promise<Record<string, unknown> | null> {
const keys = buildAuctionRedisKeys(matchId); const keys = buildAuctionRedisKeys(matchId);
const [currentServerTimestampMS, liveReply, structureStateJson, bidEntries] = const [
await Promise.all([ currentServerTimestampMS,
liveReply,
structureStateJson,
bidEntries,
] = await Promise.all([
this.auctionRedisService.getCurrentRedisTimestampMS(), this.auctionRedisService.getCurrentRedisTimestampMS(),
this.auctionRedisService.raw().sendCommand(['HGETALL', keys.liveStateKey]), this.auctionRedisService
this.auctionRedisService.raw().sendCommand(['GET', keys.structureStateKey]), .raw()
this.auctionRedisService.raw().sendCommand([ .sendCommand(['HGETALL', keys.liveStateKey]),
'LRANGE', this.auctionRedisService
keys.bidHistoryKey, .raw()
'0', .sendCommand(['GET', keys.structureStateKey]),
'-1', this.auctionRedisService
]), .raw()
.sendCommand(['LRANGE', keys.bidHistoryKey, '0', '-1']),
]); ]);
const liveState = parseHashReply(liveReply, { const liveState = parseHashReply(liveReply, {
@@ -142,7 +151,7 @@ export class AuctionRedisStateReaderService {
revision: number; revision: number;
}, },
shouldForceAuctionStateResync: options.shouldForceAuctionStateResync, shouldForceAuctionStateResync: options.shouldForceAuctionStateResync,
structureState: JSON.parse(structureStateJson) as Record<string, unknown>, structureState: parseJsonRecord(structureStateJson),
}); });
view.matchId = matchId; view.matchId = matchId;
if (options.includeInternalLiveStateFields) { if (options.includeInternalLiveStateFields) {
@@ -161,12 +170,9 @@ export class AuctionRedisStateReaderService {
if (typeof structureStateJson !== 'string' || !structureStateJson) { if (typeof structureStateJson !== 'string' || !structureStateJson) {
return undefined; return undefined;
} }
const structureState = JSON.parse(structureStateJson) as Record< const structureState = parseJsonRecord(structureStateJson);
string, const auctionTeams: unknown[] = Array.isArray(structureState.auctionTeams)
unknown ? (structureState.auctionTeams as unknown[])
>;
const auctionTeams = Array.isArray(structureState.auctionTeams)
? structureState.auctionTeams
: []; : [];
const bidderTeam = auctionTeams.find((entry) => { const bidderTeam = auctionTeams.find((entry) => {
if (!entry || typeof entry !== 'object') return false; if (!entry || typeof entry !== 'object') return false;
@@ -183,6 +189,13 @@ function stringValue(value: unknown): string | undefined {
return typeof value === 'string' && value ? value : undefined; return typeof value === 'string' && value ? value : undefined;
} }
function parseJsonRecord(json: string): Record<string, unknown> {
const value: unknown = JSON.parse(json);
return typeof value === 'object' && value !== null
? (value as Record<string, unknown>)
: {};
}
function parseHashReply( function parseHashReply(
reply: unknown, reply: unknown,
options: { includeInternalLiveStateFields?: boolean } = {}, options: { includeInternalLiveStateFields?: boolean } = {},
@@ -210,7 +223,10 @@ function parseHashEntries(
): Record<string, unknown> { ): Record<string, unknown> {
const result: Record<string, unknown> = {}; const result: Record<string, unknown> = {};
for (const [field, rawValue] of entries) { for (const [field, rawValue] of entries) {
if (!options.includeInternalLiveStateFields && isInternalLiveStateField(field)) { if (
!options.includeInternalLiveStateFields &&
isInternalLiveStateField(field)
) {
continue; continue;
} }
const value = String(rawValue); const value = String(rawValue);
@@ -91,9 +91,7 @@ describe('auction apply transition redis script contract', () => {
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain( expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
'shouldBroadcastState', 'shouldBroadcastState',
); );
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain( expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain("redis.call('SADD'");
"redis.call('SADD'",
);
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain( expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
"redis.call('HINCRBY'", "redis.call('HINCRBY'",
); );
@@ -64,9 +64,7 @@ describe('auction bid redis script contract', () => {
expect(AUCTION_BID_SCRIPT.lua).toContain("redis.call('TIME')"); expect(AUCTION_BID_SCRIPT.lua).toContain("redis.call('TIME')");
expect(AUCTION_BID_SCRIPT.lua).toContain("redis.call('HINCRBY'"); expect(AUCTION_BID_SCRIPT.lua).toContain("redis.call('HINCRBY'");
expect(AUCTION_BID_SCRIPT.lua).toContain('BID_REQUEST_RESULT_LIMIT'); expect(AUCTION_BID_SCRIPT.lua).toContain('BID_REQUEST_RESULT_LIMIT');
expect(AUCTION_BID_SCRIPT.lua).toContain( expect(AUCTION_BID_SCRIPT.lua).toContain('currentHighestBidPointAmount');
'currentHighestBidPointAmount',
);
expect(AUCTION_BID_SCRIPT.lua).not.toContain('cjson.decode'); expect(AUCTION_BID_SCRIPT.lua).not.toContain('cjson.decode');
}); });
}); });
@@ -3,9 +3,11 @@ import { buildAuctionRedisKeys } from './auction-redis.keys';
describe('auction redis keys', () => { describe('auction redis keys', () => {
it('builds lifecycle-safe key names from match id', () => { it('builds lifecycle-safe key names from match id', () => {
expect(buildAuctionRedisKeys('match-1')).toMatchObject({ expect(buildAuctionRedisKeys('match-1')).toMatchObject({
actionRequestResultOrderKey: 'auction:match-1:auctionActionRequestResultOrder', actionRequestResultOrderKey:
'auction:match-1:auctionActionRequestResultOrder',
actionRequestResultsKey: 'auction:match-1:auctionActionRequestResults', actionRequestResultsKey: 'auction:match-1:auctionActionRequestResults',
appliedTransitionIdsKey: 'auction:match-1:appliedAuctionStateTransitionIds', appliedTransitionIdsKey:
'auction:match-1:appliedAuctionStateTransitionIds',
bidHistoryKey: 'auction:match-1:auctionBidHistory', bidHistoryKey: 'auction:match-1:auctionBidHistory',
bidRequestResultOrderKey: 'auction:match-1:bidRequestResultOrder', bidRequestResultOrderKey: 'auction:match-1:bidRequestResultOrder',
bidRequestResultsKey: 'auction:match-1:bidRequestResults', bidRequestResultsKey: 'auction:match-1:bidRequestResults',
@@ -74,9 +74,11 @@ async function readFirstSecret(
const logger = new Logger('AuctionRedisClient'); const logger = new Logger('AuctionRedisClient');
const client = createClient(auctionRedisOptions); const client = createClient(auctionRedisOptions);
client.on('error', (error) => { client.on('error', (error: unknown) => {
logger.error( logger.error(
`Auction Redis client error: ${error?.message ?? error}`, `Auction Redis client error: ${
error instanceof Error ? error.message : String(error)
}`,
); );
}); });
@@ -15,7 +15,9 @@ function makeService(sendCommand: jest.Mock) {
describe('AuctionRedisService', () => { describe('AuctionRedisService', () => {
it('uses Redis TIME as the timestamp source', async () => { 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( await expect(service.getCurrentRedisTimestampMS()).resolves.toBe(
1_781_700_000_123, 1_781_700_000_123,
@@ -22,7 +22,11 @@ export class AuctionRedisNoscriptError extends Error {
function isNoscriptError(error: unknown): boolean { function isNoscriptError(error: unknown): boolean {
if (error instanceof AuctionRedisNoscriptError) return true; if (error instanceof AuctionRedisNoscriptError) return true;
const message = const message =
error instanceof Error ? error.message : typeof error === 'string' ? error : ''; error instanceof Error
? error.message
: typeof error === 'string'
? error
: '';
return /\bNOSCRIPT\b/iu.test(message); return /\bNOSCRIPT\b/iu.test(message);
} }
@@ -81,9 +85,15 @@ export class AuctionRedisService implements OnModuleDestroy {
if (!isNoscriptError(error)) throw error; if (!isNoscriptError(error)) throw error;
} }
const loadedSha = String( const loadedShaReply = await this.client.sendCommand([
await this.client.sendCommand(['SCRIPT', 'LOAD', params.script]), 'SCRIPT',
); 'LOAD',
params.script,
]);
if (typeof loadedShaReply !== 'string') {
throw new Error('Redis SCRIPT LOAD returned a non-string SHA.');
}
const loadedSha = loadedShaReply;
return (await this.client.sendCommand( return (await this.client.sendCommand(
buildEvalShaCommand(loadedSha, params.keys, params.values), buildEvalShaCommand(loadedSha, params.keys, params.values),
)) as T; )) as T;
@@ -107,7 +117,7 @@ export class AuctionRedisService implements OnModuleDestroy {
token: string, token: string,
ttlMS: number, ttlMS: number,
): Promise<boolean> { ): Promise<boolean> {
const result = await this.client.sendCommand([ const result = await this.client.sendCommand<string | null>([
'SET', 'SET',
key, key,
token, token,
@@ -115,7 +125,7 @@ export class AuctionRedisService implements OnModuleDestroy {
String(ttlMS), String(ttlMS),
'NX', 'NX',
]); ]);
return String(result) === 'OK'; return result === 'OK';
} }
public async releaseTokenLock(key: string, token: string): Promise<boolean> { public async releaseTokenLock(key: string, token: string): Promise<boolean> {
@@ -100,9 +100,7 @@ describe('auction redis state assembly', () => {
'1000', '1000',
]); ]);
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain("redis.call('TIME')"); expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain("redis.call('TIME')");
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain( expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain('INVALID_PATCH_ARITY');
'INVALID_PATCH_ARITY',
);
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain( expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain(
'mongoRevision > redisRevision', 'mongoRevision > redisRevision',
); );
@@ -78,9 +78,7 @@ export function assembleAuctionViewFromRedisState(
return { return {
...params.structureState, ...params.structureState,
...params.liveState, ...params.liveState,
auctionBidHistory: params.auctionBidHistoryEntries.map((entry) => auctionBidHistory: params.auctionBidHistoryEntries.map(parseJsonValue),
JSON.parse(entry),
),
canPlaceBidInCurrentBidRound: !isExpiring, canPlaceBidInCurrentBidRound: !isExpiring,
currentServerTimestampMS: params.currentServerTimestampMS, currentServerTimestampMS: params.currentServerTimestampMS,
isAuctionStateTransitionInProgress: isExpiring, isAuctionStateTransitionInProgress: isExpiring,
@@ -90,6 +88,11 @@ export function assembleAuctionViewFromRedisState(
}; };
} }
function parseJsonValue(json: string): unknown {
const value: unknown = JSON.parse(json);
return value;
}
export function buildHydrateAuctionStateScriptInvocation( export function buildHydrateAuctionStateScriptInvocation(
keys: AuctionRedisKeys, keys: AuctionRedisKeys,
input: HydrateAuctionStateScriptInput, input: HydrateAuctionStateScriptInput,
+1 -4
View File
@@ -1,8 +1,5 @@
import type { JWTHeaderParameters, JWTPayload } from 'jose'; import type { JWTHeaderParameters, JWTPayload } from 'jose';
import type { import type { IdentityDocument, UserDocument } from '../global/database/schema';
IdentityDocument,
UserDocument,
} from '../global/database/schema';
import type { IdentityProviderName } from './jwt.service'; import type { IdentityProviderName } from './jwt.service';
declare module 'express' { declare module 'express' {
+1 -4
View File
@@ -2,10 +2,7 @@ import { Injectable } from '@nestjs/common';
import type { Request } from 'express'; import type { Request } from 'express';
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service'; import { ConnectionService } from '../global/database/connection.service';
import { import { IdentityDocument, UserDocument } from '../global/database/schema';
IdentityDocument,
UserDocument,
} from '../global/database/schema';
import { SecretService } from '../global/secret/secret.service'; import { SecretService } from '../global/secret/secret.service';
import './auth-request'; import './auth-request';
+4 -4
View File
@@ -26,8 +26,7 @@ export class JwtAuthGuard implements CanActivate {
METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED, METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED,
[context.getHandler(), context.getClass()], [context.getHandler(), context.getClass()],
); );
const authz = request.headers?.authorization; const authzHeader = request.get('authorization');
const authzHeader = Array.isArray(authz) ? authz[0] : authz;
if (!authzHeader) { if (!authzHeader) {
const fallback = const fallback =
@@ -74,7 +73,7 @@ export class JwtAuthGuard implements CanActivate {
private pickIdPFromToken(token: string): IdentityProviderName { private pickIdPFromToken(token: string): IdentityProviderName {
try { try {
const { iss } = decodeJwt(token) as { iss?: string }; const { iss } = decodeJwt(token);
if (!iss) { if (!iss) {
throw new Error('Token has no issuer (iss) claim'); throw new Error('Token has no issuer (iss) claim');
} }
@@ -84,7 +83,8 @@ export class JwtAuthGuard implements CanActivate {
} }
throw new Error(`Unknown issuer: ${iss}`); throw new Error(`Unknown issuer: ${iss}`);
} catch (err) { } 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); throw new UnauthorizedException(message);
} }
} }
+32 -9
View File
@@ -35,11 +35,13 @@ export class JwtService {
throw new Error('Empty token'); throw new Error('Empty token');
} }
if (identityProvider !== 'MICROSOFT_ENTRAID') { const provider =
throw new Error(`Identity provider not configured: ${identityProvider}`); identityProvider === 'MICROSOFT_ENTRAID'
? await this.getEntraConfig()
: undefined;
if (!provider) {
throw new Error('Identity provider not configured.');
} }
const provider = await this.getEntraConfig();
const result = await jwtVerify(token, provider.jwks, { const result = await jwtVerify(token, provider.jwks, {
issuer: provider.issuer, issuer: provider.issuer,
audience: provider.audience, audience: provider.audience,
@@ -48,14 +50,22 @@ export class JwtService {
}); });
const { payload, protectedHeader } = result; const { payload, protectedHeader } = result;
if (!provider.allowedAlgs.includes(protectedHeader.alg as string)) { if (!provider.allowedAlgs.includes(protectedHeader.alg)) {
throw new Error(`Unexpected alg: ${protectedHeader.alg}`); throw new Error(`Unexpected alg: ${protectedHeader.alg}`);
} }
if (payload.ver && payload.ver !== '2.0') { if (
throw new Error(`Unsupported Entra token version: ${payload.ver}`); payload.ver !== undefined &&
(typeof payload.ver !== 'string' || payload.ver !== '2.0')
) {
throw new Error(
`Unsupported Entra token version: ${formatClaimValue(payload.ver)}`,
);
} }
if (payload.tid && payload.tid !== provider.tenantId) { if (
throw new Error(`Unexpected tenant: ${payload.tid}`); payload.tid !== undefined &&
(typeof payload.tid !== 'string' || payload.tid !== provider.tenantId)
) {
throw new Error(`Unexpected tenant: ${formatClaimValue(payload.tid)}`);
} }
return result; return result;
@@ -98,3 +108,16 @@ export class JwtService {
return this.entraConfig; return this.entraConfig;
} }
} }
function formatClaimValue(value: unknown): string {
if (
typeof value === 'string' ||
typeof value === 'number' ||
typeof value === 'boolean' ||
typeof value === 'bigint'
) {
return String(value);
}
if (value === null) return 'null';
return JSON.stringify(value) ?? typeof value;
}
+2 -2
View File
@@ -7,7 +7,7 @@ import {
} from '@nestjs/common'; } from '@nestjs/common';
import { Reflector } from '@nestjs/core'; import { Reflector } from '@nestjs/core';
import type { Request } from 'express'; import type { Request } from 'express';
import { CommunityRole, UserDocument } from '../global/database/schema'; import type { CommunityRole } from '../global/database/schema';
import { ROLES_KEY } from './roles.decorator'; import { ROLES_KEY } from './roles.decorator';
import './auth-request'; import './auth-request';
@@ -23,7 +23,7 @@ export class RolesGuard implements CanActivate {
if (!requiredRoles || requiredRoles.length === 0) return true; if (!requiredRoles || requiredRoles.length === 0) return true;
const req = context.switchToHttp().getRequest<Request>(); const req = context.switchToHttp().getRequest<Request>();
const user = req.user as UserDocument | undefined; const user = req.user;
if (!user && req.identity) { if (!user && req.identity) {
throw new ForbiddenException('No membership in this community.'); throw new ForbiddenException('No membership in this community.');
} }
@@ -7,9 +7,10 @@ import {
import mongoose from 'mongoose'; import mongoose from 'mongoose';
@Injectable() @Injectable()
export class ParseObjectIdPipe export class ParseObjectIdPipe implements PipeTransform<
implements PipeTransform<string, mongoose.Types.ObjectId> string,
{ mongoose.Types.ObjectId
> {
public transform( public transform(
value: string, value: string,
metadata: ArgumentMetadata, metadata: ArgumentMetadata,
@@ -34,16 +34,29 @@ export class CommunityStatsCacheService {
let deleted = 0; let deleted = 0;
do { do {
const reply = (await client.sendCommand([ const reply = await client.sendCommand([
'SCAN', 'SCAN',
cursor, cursor,
'MATCH', 'MATCH',
match, match,
'COUNT', 'COUNT',
'100', '100',
])) as [string, string[]]; ]);
cursor = reply[0]; if (!Array.isArray(reply)) {
const keys = reply[1] ?? []; throw new Error('Redis SCAN returned an invalid response.');
}
const values = reply as unknown[];
const nextCursor = values[0];
const rawKeys = values[1];
if (typeof nextCursor !== 'string') {
throw new Error('Redis SCAN returned an invalid cursor.');
}
cursor = nextCursor;
const keys = Array.isArray(rawKeys)
? (rawKeys as unknown[]).filter(
(key): key is string => typeof key === 'string',
)
: [];
if (keys.length > 0) { if (keys.length > 0) {
deleted += await client.del(keys); deleted += await client.del(keys);
} }
@@ -23,7 +23,14 @@ export class CommunityStatsController {
) { ) {
return this.communityStatsService.getMatches({ return this.communityStatsService.getMatches({
communityId, communityId,
filters: this.toFilters({ seasonId, from, to, championId, cursor, limit }), filters: this.toFilters({
seasonId,
from,
to,
championId,
cursor,
limit,
}),
}); });
} }
@@ -85,7 +92,14 @@ export class CommunityStatsController {
return this.communityStatsService.getUserInternalHistory({ return this.communityStatsService.getUserInternalHistory({
communityId, communityId,
userId, userId,
filters: this.toFilters({ seasonId, from, to, championId, cursor, limit }), filters: this.toFilters({
seasonId,
from,
to,
championId,
cursor,
limit,
}),
}); });
} }
@@ -7,7 +7,10 @@ import type {
RiotLane, RiotLane,
TeamSide, TeamSide,
} from '../global/database/schema'; } from '../global/database/schema';
import type { RecentMatchView, HistorySeasonDto } from '../match-history/match-history.types'; import type {
RecentMatchView,
HistorySeasonDto,
} from '../match-history/match-history.types';
export interface CommunityStatsFilters { export interface CommunityStatsFilters {
seasonId?: string; seasonId?: string;
@@ -80,7 +83,9 @@ export interface LeaderboardRow {
avgCsPerMin: number; avgCsPerMin: number;
avgDamageShare: number; avgDamageShare: number;
avgVisionScore: 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 }>; topChampions: Array<{ championId: number; games: number; winRate: number }>;
} }
@@ -227,9 +227,7 @@ export class MatchStatsFragmentBuilder {
participant, participant,
rawParticipant, rawParticipant,
buildEvents: rawParticipant buildEvents: rawParticipant
? buildEventsByParticipantId.get( ? buildEventsByParticipantId.get(rawParticipant.participantId)
rawParticipant.participantId,
)
: undefined, : undefined,
checkpoints: rawParticipant checkpoints: rawParticipant
? checkpointsByParticipantId.get(rawParticipant.participantId) ? checkpointsByParticipantId.get(rawParticipant.participantId)
@@ -420,7 +418,10 @@ export class MatchStatsFragmentBuilder {
private toBuildEventsByParticipantId( private toBuildEventsByParticipantId(
timeline?: RiotMatchTimelineDto, timeline?: RiotMatchTimelineDto,
): Map<number, ParticipantBuildEvents> { ): Map<number, ParticipantBuildEvents> {
const buildEventsByParticipantId = new Map<number, ParticipantBuildEvents>(); const buildEventsByParticipantId = new Map<
number,
ParticipantBuildEvents
>();
if (!timeline?.info.frames.length) return buildEventsByParticipantId; if (!timeline?.info.frames.length) return buildEventsByParticipantId;
const getEvents = (participantId: number): ParticipantBuildEvents => { const getEvents = (participantId: number): ParticipantBuildEvents => {
@@ -796,13 +797,16 @@ export class MatchStatsFragmentBuilder {
? timelineDragon ? timelineDragon
: (rawObjectives?.dragon?.kills ?? 0), : (rawObjectives?.dragon?.kills ?? 0),
inhibitor: rawObjectives?.inhibitor?.kills ?? 0, inhibitor: rawObjectives?.inhibitor?.kills ?? 0,
baron: (timelineObjectives?.baron ?? 0) > 0 baron:
(timelineObjectives?.baron ?? 0) > 0
? (timelineObjectives?.baron ?? 0) ? (timelineObjectives?.baron ?? 0)
: (rawObjectives?.baron?.kills ?? 0), : (rawObjectives?.baron?.kills ?? 0),
riftHerald: (timelineObjectives?.riftHerald ?? 0) > 0 riftHerald:
(timelineObjectives?.riftHerald ?? 0) > 0
? (timelineObjectives?.riftHerald ?? 0) ? (timelineObjectives?.riftHerald ?? 0)
: (rawObjectives?.riftHerald?.kills ?? 0), : (rawObjectives?.riftHerald?.kills ?? 0),
voidGrub: (timelineObjectives?.voidGrub ?? 0) > 0 voidGrub:
(timelineObjectives?.voidGrub ?? 0) > 0
? (timelineObjectives?.voidGrub ?? 0) ? (timelineObjectives?.voidGrub ?? 0)
: (rawObjectives?.horde?.kills ?? 0), : (rawObjectives?.horde?.kills ?? 0),
elderDragon: hasProjectedDragon ? timelineElder : 0, elderDragon: hasProjectedDragon ? timelineElder : 0,
@@ -125,8 +125,8 @@ describe('MatchStatsRepository', () => {
if ( if (
stored && stored &&
stored.sourceCompetitionId?.equals(fragment.sourceCompetitionId!) && stored.sourceCompetitionId?.equals(fragment.sourceCompetitionId) &&
stored.sourceRevision! <= fragment.sourceRevision! stored.sourceRevision <= fragment.sourceRevision
) { ) {
stored = fragment; stored = fragment;
return { matchedCount: 1, upsertedCount: 0 }; return { matchedCount: 1, upsertedCount: 0 };
@@ -6,10 +6,7 @@ import {
} from '@nestjs/common'; } from '@nestjs/common';
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service'; import { ConnectionService } from '../global/database/connection.service';
import { import { CommunityDocument, UserDocument } from '../global/database/schema';
CommunityDocument,
UserDocument,
} from '../global/database/schema';
export interface CreateCommunityInput { export interface CreateCommunityInput {
name: string; name: string;
@@ -485,11 +485,7 @@ function createHarness(
let competitionCall = 0; let competitionCall = 0;
const competitionModel = { const competitionModel = {
findOneAndUpdate: jest.fn( findOneAndUpdate: jest.fn(
( (_filter: unknown, update: { $setOnInsert: InsertPayload }) => {
_filter: unknown,
update: { $setOnInsert: InsertPayload },
_queryOptions: unknown,
) => {
insertedPayloads.push(update.$setOnInsert); insertedPayloads.push(update.$setOnInsert);
const selected = options.competitionResults?.[competitionCall++]; const selected = options.competitionResults?.[competitionCall++];
if (selected instanceof Error) return rejectedQuery(selected); if (selected instanceof Error) return rejectedQuery(selected);
@@ -429,8 +429,14 @@ export function applyCompetitionDomainInvariantIndexes(
} }
} }
export type CompetitionModelName =
| 'competition'
| 'competitionFact'
| 'competitionOutbox'
| 'tournamentCodeAssignment';
export const competitionModelDefinitions: Array<{ export const competitionModelDefinitions: Array<{
name: string; name: CompetitionModelName;
schema: mongoose.Schema; schema: mongoose.Schema;
schemaName: string; schemaName: string;
}> = [ }> = [
@@ -1,4 +1,8 @@
import { projectCompetition } from './competition-projector'; import { projectCompetition } from './competition-projector';
import {
CompetitionDomainError,
type CompetitionDomainErrorCode,
} from './domain-error';
import { generateSeriesGraph } from './series-graph'; import { generateSeriesGraph } from './series-graph';
describe('projectCompetition', () => { describe('projectCompetition', () => {
@@ -323,7 +327,8 @@ describe('projectCompetition', () => {
'team-1', 'team-1',
); );
expect(() => expectCompetitionDomainError(
() =>
projectCompetition({ projectCompetition({
competitionId, competitionId,
revision: 1, revision: 1,
@@ -333,10 +338,7 @@ describe('projectCompetition', () => {
seriesGraph, seriesGraph,
facts: [{ ...accepted, seriesId: 'series-does-not-exist' }], facts: [{ ...accepted, seriesId: 'series-does-not-exist' }],
}), }),
).toThrow( 'GAME_SERIES_MISMATCH',
expect.objectContaining({
code: 'GAME_SERIES_MISMATCH',
}),
); );
}); });
@@ -356,7 +358,8 @@ describe('projectCompetition', () => {
'team-1', 'team-1',
); );
expect(() => expectCompetitionDomainError(
() =>
projectCompetition({ projectCompetition({
competitionId, competitionId,
revision: 1, revision: 1,
@@ -366,10 +369,7 @@ describe('projectCompetition', () => {
seriesGraph, seriesGraph,
facts: [{ ...accepted, gameSlotId: 'slot-does-not-exist' }], facts: [{ ...accepted, gameSlotId: 'slot-does-not-exist' }],
}), }),
).toThrow( 'GAME_SLOT_INVALID',
expect.objectContaining({
code: 'GAME_SLOT_INVALID',
}),
); );
}); });
@@ -382,7 +382,8 @@ describe('projectCompetition', () => {
}; };
const seriesGraph = generateSeriesGraph({ competitionId, teams, format }); const seriesGraph = generateSeriesGraph({ competitionId, teams, format });
expect(() => expectCompetitionDomainError(
() =>
projectCompetition({ projectCompetition({
competitionId, competitionId,
revision: 1, revision: 1,
@@ -408,10 +409,7 @@ describe('projectCompetition', () => {
}, },
], ],
}), }),
).toThrow( 'ADJUDICATION_INVALID',
expect.objectContaining({
code: 'ADJUDICATION_INVALID',
}),
); );
}); });
@@ -617,3 +615,23 @@ interface GameSlotLike {
id: string; id: string;
ordinal: number; ordinal: number;
} }
function expectCompetitionDomainError(
action: () => unknown,
expectedCode: CompetitionDomainErrorCode,
): void {
let thrown: unknown;
try {
action();
} catch (error: unknown) {
thrown = error;
}
expect(thrown).toBeInstanceOf(CompetitionDomainError);
if (!(thrown instanceof CompetitionDomainError)) {
throw new Error(
`Expected CompetitionDomainError, received ${String(thrown)}`,
);
}
expect(thrown.code).toBe(expectedCode);
}
@@ -1,6 +1,7 @@
import { import {
assertReversalPreview, assertReversalPreview,
buildReversalFacts, buildReversalFacts,
CompetitionReversalError,
previewSeriesReversal, previewSeriesReversal,
} from './competition-reversal'; } from './competition-reversal';
@@ -19,7 +20,8 @@ describe('Competition reversal planning', () => {
]; ];
it('rejects strict reversal when a descendant has result activity', () => { it('rejects strict reversal when a descendant has result activity', () => {
expect(() => expectCompetitionReversalError(
() =>
previewSeriesReversal({ previewSeriesReversal({
competitionId: 'competition-1', competitionId: 'competition-1',
revision: 2, revision: 2,
@@ -29,8 +31,7 @@ describe('Competition reversal planning', () => {
facts, facts,
assignments, assignments,
}), }),
).toThrow( 'REVERSAL_DESCENDANT_ACTIVITY',
expect.objectContaining({ code: 'REVERSAL_DESCENDANT_ACTIVITY' }),
); );
}); });
@@ -105,7 +106,8 @@ describe('Competition reversal planning', () => {
assignments, assignments,
}); });
expect(() => expectCompetitionReversalError(
() =>
assertReversalPreview( assertReversalPreview(
{ {
competitionId: 'competition-1', competitionId: 'competition-1',
@@ -118,7 +120,8 @@ describe('Competition reversal planning', () => {
}, },
preview.impactHash, preview.impactHash,
), ),
).toThrow(expect.objectContaining({ code: 'REVERSAL_PREVIEW_STALE' })); 'REVERSAL_PREVIEW_STALE',
);
}); });
it('emits one append-only reversal fact for every active result fact', () => { it('emits one append-only reversal fact for every active result fact', () => {
@@ -160,6 +163,26 @@ describe('Competition reversal planning', () => {
}); });
}); });
function expectCompetitionReversalError(
action: () => unknown,
expectedCode: CompetitionReversalError['code'],
): void {
let thrown: unknown;
try {
action();
} catch (error: unknown) {
thrown = error;
}
expect(thrown).toBeInstanceOf(CompetitionReversalError);
if (!(thrown instanceof CompetitionReversalError)) {
throw new Error(
`Expected CompetitionReversalError, received ${String(thrown)}`,
);
}
expect(thrown.code).toBe(expectedCode);
}
function series(id: string, sources: Array<Record<string, unknown>>) { function series(id: string, sources: Array<Record<string, unknown>>) {
return { return {
id, id,
@@ -9,7 +9,8 @@ import { DakaoOutboxService } from './dakao-outbox.service';
const SWEEP_INTERVAL_MS = 60 * 1000; const SWEEP_INTERVAL_MS = 60 * 1000;
const STALE_OUTBOX_MS = 5 * 60 * 1000; const STALE_OUTBOX_MS = 5 * 60 * 1000;
const SWEEP_LOCK_KEY = '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; const SWEEP_LOCK_EXPIRATION_DURATION_MILLISECONDS = 55_000;
@Injectable() @Injectable()
@@ -78,9 +78,7 @@ export class DakaoOutboxService {
await this.natsService.publishJetStream(params.subject, params.envelope, { await this.natsService.publishJetStream(params.subject, params.envelope, {
messageId: params.eventId, messageId: params.eventId,
}); });
await OutboxModel.updateOne( await OutboxModel.updateOne(updateFilter, {
updateFilter,
{
$set: { $set: {
state: 'published', state: 'published',
publishedAt: new Date(), publishedAt: new Date(),
@@ -91,12 +89,9 @@ export class DakaoOutboxService {
publishLeaseOwnerIdentifier: '', publishLeaseOwnerIdentifier: '',
publishLeaseExpiresAt: '', publishLeaseExpiresAt: '',
}, },
}, }).exec();
).exec();
} catch (err) { } catch (err) {
await OutboxModel.updateOne( await OutboxModel.updateOne(updateFilter, {
updateFilter,
{
$inc: { publishAttempts: 1 }, $inc: { publishAttempts: 1 },
$set: { $set: {
lastPublishError: (err as Error)?.message ?? String(err), lastPublishError: (err as Error)?.message ?? String(err),
@@ -105,8 +100,7 @@ export class DakaoOutboxService {
publishLeaseOwnerIdentifier: '', publishLeaseOwnerIdentifier: '',
publishLeaseExpiresAt: '', publishLeaseExpiresAt: '',
}, },
}, }).exec();
).exec();
this.logger.error( this.logger.error(
`Failed to publish Dakao outbox eventId=${params.eventId}: ${ `Failed to publish Dakao outbox eventId=${params.eventId}: ${
(err as Error)?.stack ?? err (err as Error)?.stack ?? err
@@ -105,7 +105,7 @@ describe('DakaoUserService', () => {
tagLine: 'KR2', tagLine: 'KR2',
isPrimary: false, isPrimary: false,
}); });
expect((result.user.riotAccounts as RiotAccount[])[0]).toMatchObject({ expect(result.user.riotAccounts[0]).toMatchObject({
puuid: 'puuid-1', puuid: 'puuid-1',
isPrimary: true, isPrimary: true,
}); });
@@ -87,7 +87,7 @@ export class DakaoUserService {
if (!community) { if (!community) {
throw new DakaoUserError('community_not_found', dakaoProjectId); throw new DakaoUserError('community_not_found', dakaoProjectId);
} }
return community._id as mongoose.Types.ObjectId; return community._id;
} }
public async upsertUser(params: { public async upsertUser(params: {
@@ -301,7 +301,7 @@ export class DakaoSubscriber implements OnModuleInit {
text: text:
index === this.usageCommands.length - 1 index === this.usageCommands.length - 1
? ` ${command}` ? ` ${command}`
: ` ${command} \n`, : ` ${command}\u3000\n`,
} as const, } as const,
]); ]);
} }
@@ -104,7 +104,9 @@ describe('MatchCancelHandler', () => {
const handler = makeHandler({ const handler = makeHandler({
matchService: { matchService: {
cancelJoin, cancelJoin,
list: jest.fn().mockResolvedValue([ list: jest
.fn()
.mockResolvedValue([
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' }, { _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
]), ]),
} as Partial<MatchService>, } as Partial<MatchService>,
@@ -230,7 +230,9 @@ describe('MatchJoinHandler', () => {
const resolveRiotAccount = jest.fn(); const resolveRiotAccount = jest.fn();
const handler = makeHandler({ const handler = makeHandler({
matchService: { matchService: {
list: jest.fn().mockResolvedValue([ list: jest
.fn()
.mockResolvedValue([
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' }, { _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
]), ]),
join, join,
@@ -282,7 +284,9 @@ describe('MatchJoinHandler', () => {
const join = jest.fn(); const join = jest.fn();
const handler = makeHandler({ const handler = makeHandler({
matchService: { matchService: {
list: jest.fn().mockResolvedValue([ list: jest
.fn()
.mockResolvedValue([
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' }, { _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
]), ]),
join, join,
@@ -44,9 +44,7 @@ export class MatchJoinHandler {
return this.errorReply(params, joinTarget); return this.errorReply(params, joinTarget);
} }
let resolved: let resolved: { user: UserDocument; riotAccount: RiotAccount } | string;
| { user: UserDocument; riotAccount: RiotAccount }
| string;
try { try {
resolved = resolved =
joinTarget.gameName && joinTarget.tagLine joinTarget.gameName && joinTarget.tagLine
@@ -243,10 +241,7 @@ export class MatchJoinHandler {
const gameName = normalizeRiotIdPart(value.slice(splitAt + 1)); const gameName = normalizeRiotIdPart(value.slice(splitAt + 1));
if (!matchTitlePrefix || !gameName) continue; if (!matchTitlePrefix || !gameName) continue;
const result = resolveRecruitingMatchReference( const result = resolveRecruitingMatchReference(matchTitlePrefix, matches);
matchTitlePrefix,
matches,
);
if (result.kind === 'matched') { if (result.kind === 'matched') {
return { kind: 'matched', match: result.match, gameName }; return { kind: 'matched', match: result.match, gameName };
} }
@@ -22,6 +22,33 @@ function makeHandler(params: {
} }
describe('MatchListHandler', () => { describe('MatchListHandler', () => {
afterEach(() => {
jest.useRealTimers();
});
it('queries only matches scheduled at or after command processing time', async () => {
const now = new Date('2026-07-25T07:30:00.000Z');
jest.useFakeTimers().setSystemTime(now);
const communityId = objectId('111111111111111111111111');
const list = jest.fn().mockResolvedValue([]);
const handler = makeHandler({
matchService: { list },
});
await handler.handle({
communityId,
senderUserId: 'kakao-user-1',
senderNickname: '프리리',
});
expect(list).toHaveBeenCalledWith({
communityId,
status: 'recruiting',
scheduledFrom: now,
limit: 10,
});
});
it('prints short codes, compact KST dates, and short links', async () => { it('prints short codes, compact KST dates, and short links', async () => {
const match = { const match = {
_id: objectId('333333333333333333333333'), _id: objectId('333333333333333333333333'),
@@ -19,9 +19,11 @@ export class MatchListHandler {
senderUserId: string; senderUserId: string;
senderNickname: string; senderNickname: string;
}): Promise<DakaoSegment[]> { }): Promise<DakaoSegment[]> {
const scheduledFrom = new Date();
const matches = await this.matchService.list({ const matches = await this.matchService.list({
communityId: params.communityId, communityId: params.communityId,
status: 'recruiting', status: 'recruiting',
scheduledFrom,
limit: 10, limit: 10,
}); });
@@ -20,8 +20,8 @@ export class IdempotencyCache {
public remember(key: string): void { public remember(key: string): void {
this.evictExpired(); this.evictExpired();
if (this.entries.size >= MAX_ENTRIES) { if (this.entries.size >= MAX_ENTRIES) {
const oldestKey = this.entries.keys().next().value; const oldestKey: unknown = this.entries.keys().next().value;
if (oldestKey !== undefined) this.entries.delete(oldestKey); if (typeof oldestKey === 'string') this.entries.delete(oldestKey);
} }
this.entries.set(key, Date.now() + TTL_MS); this.entries.set(key, Date.now() + TTL_MS);
} }
@@ -144,7 +144,7 @@ export function buildDoubleEliminationBracket(
teamIndex, teamIndex,
})); }));
const bracket: DoubleEliminationBracket = { const bracket: DoubleEliminationBracket = {
teamCount: seededTeamIndexes.length as 4 | 8, teamCount: seededTeamIndexes.length,
resetFinalEnabled: options.resetFinalEnabled, resetFinalEnabled: options.resetFinalEnabled,
resetFinalCreated: false, resetFinalCreated: false,
seeds, seeds,
@@ -19,7 +19,9 @@ describe('auction Redis schema foundation', () => {
expect(AuctionSchema.path('revision')).toBeDefined(); expect(AuctionSchema.path('revision')).toBeDefined();
expect(AuctionSchema.path('auctionEngineVersion')).toBeDefined(); expect(AuctionSchema.path('auctionEngineVersion')).toBeDefined();
expect(AuctionSchema.path('auctionLifecycleId')).toBeDefined(); expect(AuctionSchema.path('auctionLifecycleId')).toBeDefined();
expect(AuctionSchema.path('lastAppliedAuctionStateTransitionId')).toBeDefined(); expect(
AuctionSchema.path('lastAppliedAuctionStateTransitionId'),
).toBeDefined();
expect(AuctionSchema.path('currentAuctionHistorySequence')).toBeDefined(); expect(AuctionSchema.path('currentAuctionHistorySequence')).toBeDefined();
expect(AuctionSchema.path('startAuctionRequestId')).toBeDefined(); expect(AuctionSchema.path('startAuctionRequestId')).toBeDefined();
expect(AuctionSchema.path('startAuctionStateTransitionId')).toBeDefined(); expect(AuctionSchema.path('startAuctionStateTransitionId')).toBeDefined();
@@ -36,46 +38,75 @@ describe('auction Redis schema foundation', () => {
expect(AuctionSchema.path('auctionBidHistory')).toBeDefined(); expect(AuctionSchema.path('auctionBidHistory')).toBeDefined();
expect(AuctionSchema.path('currentHighestBidPointAmount')).toBeDefined(); expect(AuctionSchema.path('currentHighestBidPointAmount')).toBeDefined();
expect(AuctionSchema.path('currentHighestBidderTeamIndex')).toBeDefined(); expect(AuctionSchema.path('currentHighestBidderTeamIndex')).toBeDefined();
expect(AuctionSchema.path('currentBidRoundDeadlineTimestampMS')).toBeDefined(); expect(
AuctionSchema.path('currentBidRoundDeadlineTimestampMS'),
).toBeDefined();
expect(AuctionSchema.path('maximumBidRoundDurationSeconds')).toBeDefined(); expect(AuctionSchema.path('maximumBidRoundDurationSeconds')).toBeDefined();
expect(AuctionSchema.path('bidRoundExtensionSeconds')).toBeDefined(); expect(AuctionSchema.path('bidRoundExtensionSeconds')).toBeDefined();
expect(AuctionSchema.path('initialTeamBidPointAmount')).toBeDefined(); expect(AuctionSchema.path('initialTeamBidPointAmount')).toBeDefined();
expect(AuctionSchema.path('topTierAuctionPriorityThreshold')).toBeDefined(); expect(AuctionSchema.path('topTierAuctionPriorityThreshold')).toBeDefined();
expect(AuctionSchema.path('manualTopTierAuctionPriorityUserIds')).toBeDefined(); expect(
AuctionSchema.path('manualTopTierAuctionPriorityUserIds'),
).toBeDefined();
expect(AuctionSchema.path('auctionStartedAtTimestampMS')).toBeDefined(); expect(AuctionSchema.path('auctionStartedAtTimestampMS')).toBeDefined();
expect(AuctionSchema.path('auctionCompletedAtTimestampMS')).toBeDefined(); expect(AuctionSchema.path('auctionCompletedAtTimestampMS')).toBeDefined();
}); });
it('adds history transition fields and reset/undo action enum values', () => { it('adds history transition fields and reset/undo action enum values', () => {
expect(AuctionHistoryEntrySchema.path('auctionStateTransitionId')).toBeDefined(); expect(
AuctionHistoryEntrySchema.path('auctionStateTransitionId'),
).toBeDefined();
expect(AuctionHistoryEntrySchema.path('auctionLifecycleId')).toBeDefined(); expect(AuctionHistoryEntrySchema.path('auctionLifecycleId')).toBeDefined();
expect(AuctionHistoryEntrySchema.path('revision')).toBeDefined(); expect(AuctionHistoryEntrySchema.path('revision')).toBeDefined();
expect(AuctionHistoryEntrySchema.path('historyMutation')).toBeDefined(); expect(AuctionHistoryEntrySchema.path('historyMutation')).toBeDefined();
expect(AuctionHistoryEntrySchema.path('matchSideEffectMutation')).toBeDefined(); expect(
AuctionHistoryEntrySchema.path('matchSideEffectMutation'),
).toBeDefined();
expect( expect(
AuctionHistoryEntrySchema.path<string>('action').options.enum, AuctionHistoryEntrySchema.path<string>('action').options.enum,
).toEqual( ).toEqual(
expect.arrayContaining(['start', 'open-bidding', 'bid', 'sold', 'passed', 'next', 'complete', 'reset', 'undo']), expect.arrayContaining([
'start',
'open-bidding',
'bid',
'sold',
'passed',
'next',
'complete',
'reset',
'undo',
]),
); );
}); });
it('adds unique history indexes for sequence and transition idempotency', () => { it('adds unique history indexes for sequence and transition idempotency', () => {
const indexes = AuctionHistoryEntrySchema.indexes(); const indexes = AuctionHistoryEntrySchema.indexes();
expect(indexWithKeys(indexes, { auctionId: 1, sequence: 1 })?.[1]).toMatchObject({ expect(
indexWithKeys(indexes, { auctionId: 1, sequence: 1 })?.[1],
).toMatchObject({
unique: true, unique: true,
}); });
expect( expect(
indexWithKeys(indexes, { auctionId: 1, auctionStateTransitionId: 1 })?.[1], indexWithKeys(indexes, {
auctionId: 1,
auctionStateTransitionId: 1,
})?.[1],
).toMatchObject({ unique: true, sparse: true }); ).toMatchObject({ unique: true, sparse: true });
}); });
it('registers auction side effect application model with lease fields and unique idempotency index', () => { it('registers auction side effect application model with lease fields and unique idempotency index', () => {
expect(AuctionSideEffectApplicationSchema.path('processingOwnerToken')).toBeDefined();
expect( expect(
AuctionSideEffectApplicationSchema.path('processingLeaseExpiresAtTimestampMS'), AuctionSideEffectApplicationSchema.path('processingOwnerToken'),
).toBeDefined();
expect(
AuctionSideEffectApplicationSchema.path(
'processingLeaseExpiresAtTimestampMS',
),
).toBeDefined();
expect(
AuctionSideEffectApplicationSchema.path('payloadChecksum'),
).toBeDefined(); ).toBeDefined();
expect(AuctionSideEffectApplicationSchema.path('payloadChecksum')).toBeDefined();
const indexes = AuctionSideEffectApplicationSchema.indexes(); const indexes = AuctionSideEffectApplicationSchema.indexes();
expect( expect(
@@ -2,7 +2,10 @@ import { Injectable, Logger, Scope, OnModuleInit } from '@nestjs/common';
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import { applyMongoosePerformancePlugin } from '../observability/mongoose-performance.plugin'; import { applyMongoosePerformancePlugin } from '../observability/mongoose-performance.plugin';
import { SecretService } from '../secret/secret.service'; import { SecretService } from '../secret/secret.service';
import { tournamentModelDefinitions, TournamentModelTypes } from './schema'; import {
tournamentModelDefinitions,
type TournamentModelTypes,
} from './schema';
export function resolveMongoDbName(nodeEnv = process.env.NODE_ENV): string { export function resolveMongoDbName(nodeEnv = process.env.NODE_ENV): string {
if (nodeEnv === 'prod') return 'lolympus'; if (nodeEnv === 'prod') return 'lolympus';
@@ -42,7 +45,8 @@ export class ConnectionService implements OnModuleInit {
private connectionPromise: Promise<mongoose.Connection> | null = null; private connectionPromise: Promise<mongoose.Connection> | null = null;
constructor(private readonly secretService: SecretService) {} constructor(private readonly secretService: SecretService) {}
private tournamentModels: Map<string, mongoose.Model<any>> | null = null; private tournamentModels: Map<keyof TournamentModelTypes, unknown> | null =
null;
public async getConnection(): Promise<mongoose.Connection> { public async getConnection(): Promise<mongoose.Connection> {
if ( if (
@@ -89,14 +93,18 @@ export class ConnectionService implements OnModuleInit {
modelKey: K, modelKey: K,
): Promise<mongoose.Model<TournamentModelTypes[K]>> { ): Promise<mongoose.Model<TournamentModelTypes[K]>> {
const connection = await this.getConnection(); const connection = await this.getConnection();
if (this.tournamentModels) if (this.tournamentModels) {
return this.tournamentModels.get(modelKey) as mongoose.Model< return this.requireTournamentModel(this.tournamentModels, modelKey);
TournamentModelTypes[K] }
>;
const models = new Map<K, mongoose.Model<TournamentModelTypes[K]>>(); const models = new Map<keyof TournamentModelTypes, unknown>();
tournamentModelDefinitions.forEach((modelDefinition) => { tournamentModelDefinitions.forEach((modelDefinition) => {
if (!(modelDefinition.schema instanceof mongoose.Schema)) {
throw new Error(
`Invalid Mongoose schema for model ${modelDefinition.name}.`,
);
}
applyMongoosePerformancePlugin(modelDefinition.schema); applyMongoosePerformancePlugin(modelDefinition.schema);
// 이미 생성된 경우 컴파일 스킵. // 이미 생성된 경우 컴파일 스킵.
if ( if (
@@ -106,14 +114,14 @@ export class ConnectionService implements OnModuleInit {
) )
) { ) {
models.set( models.set(
modelDefinition.name as K, modelDefinition.name,
connection.models[modelDefinition.name], connection.models[modelDefinition.name],
); );
return; return;
} else { } else {
models.set( models.set(
modelDefinition.name as K, modelDefinition.name,
connection.model<TournamentModelTypes[K]>( connection.model(
modelDefinition.name, modelDefinition.name,
modelDefinition.schema, modelDefinition.schema,
modelDefinition.schemaName, modelDefinition.schemaName,
@@ -123,7 +131,18 @@ export class ConnectionService implements OnModuleInit {
}); });
this.tournamentModels = models; this.tournamentModels = models;
return models.get(modelKey) as mongoose.Model<TournamentModelTypes[K]>; 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]>;
} }
public async createSession( public async createSession(
@@ -1,4 +1,4 @@
import { DynamicModule, Module } from '@nestjs/common'; import { Module } from '@nestjs/common';
import { ConnectionService } from './connection.service'; import { ConnectionService } from './connection.service';
@Module({ @Module({
@@ -45,7 +45,10 @@ 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; stats.scannedAuctions += 1;
const set: Record<string, unknown> = {}; const set: Record<string, unknown> = {};
let changed = false; let changed = false;
@@ -27,7 +27,8 @@ function createDb(params: {
}, },
}; };
}, },
async bulkWrite(writes: Array<{ async bulkWrite(
writes: Array<{
updateOne: { updateOne: {
filter: { _id: unknown }; filter: { _id: unknown };
update: { update: {
@@ -35,9 +36,12 @@ function createDb(params: {
$unset: Record<string, ''>; $unset: Record<string, ''>;
}; };
}; };
}>) { }>,
) {
for (const write of writes) { 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; if (!doc) continue;
Object.assign(doc, write.updateOne.update.$set); Object.assign(doc, write.updateOne.update.$set);
for (const key of Object.keys(write.updateOne.update.$unset)) { for (const key of Object.keys(write.updateOne.update.$unset)) {
@@ -57,7 +61,10 @@ describe('migrateTeamIndex', () => {
auctions: [ auctions: [
{ {
_id: 'auction-1', _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 }], bids: [{ side: 'red', groupIndex: 1, amount: 100 }],
currentBidder: 'red', currentBidder: 'red',
currentBidderGroupIndex: 1, currentBidderGroupIndex: 1,
@@ -66,7 +73,10 @@ describe('migrateTeamIndex', () => {
matches: [ matches: [
{ {
_id: 'match-1', _id: 'match-1',
teams: [{ side: 'blue', groupIndex: 1 }, { side: 'red', groupIndex: 1 }], teams: [
{ side: 'blue', groupIndex: 1 },
{ side: 'red', groupIndex: 1 },
],
result: { result: {
winnerSide: 'blue', winnerSide: 'blue',
blueScore: 1, blueScore: 1,
@@ -112,7 +122,10 @@ describe('migrateTeamIndex', () => {
currentBidderTeamIndex: 2, currentBidderTeamIndex: 2,
}); });
expect(collections.match[0]).toMatchObject({ expect(collections.match[0]).toMatchObject({
teams: [{ teamIndex: 1, name: '1팀' }, { teamIndex: 2, name: '2팀' }], teams: [
{ teamIndex: 1, name: '1팀' },
{ teamIndex: 2, name: '2팀' },
],
result: { result: {
winnerTeamIndex: 1, winnerTeamIndex: 1,
games: [ games: [
@@ -45,8 +45,20 @@ export async function migrateTeamIndex(
changedMatches: 0, changedMatches: 0,
}; };
await migrateCollection(db.collection('auction'), options.limit, dryRun, stats, 'auction'); await migrateCollection(
await migrateCollection(db.collection('match'), options.limit, dryRun, stats, 'match'); db.collection('auction'),
options.limit,
dryRun,
stats,
'auction',
);
await migrateCollection(
db.collection('match'),
options.limit,
dryRun,
stats,
'match',
);
return stats; return stats;
} }
@@ -143,7 +155,8 @@ function migrateMatch(doc: AnyDoc) {
const migrated = { ...team }; const migrated = { ...team };
const teamIndex = readTeamIndex(migrated); const teamIndex = readTeamIndex(migrated);
if (teamIndex !== undefined) migrated.teamIndex = teamIndex; if (teamIndex !== undefined) migrated.teamIndex = teamIndex;
if (!migrated.name && typeof teamIndex === 'number') migrated.name = `${teamIndex}팀`; if (!migrated.name && typeof teamIndex === 'number')
migrated.name = `${teamIndex}팀`;
if ('side' in migrated || 'groupIndex' in migrated) changed = true; if ('side' in migrated || 'groupIndex' in migrated) changed = true;
delete migrated.side; delete migrated.side;
delete migrated.groupIndex; delete migrated.groupIndex;
@@ -200,7 +213,10 @@ function migrateResult(result: Record<string, unknown>) {
migrated.games = games; migrated.games = games;
const seriesResults = asArray(result.seriesResults).map((series) => { const seriesResults = asArray(result.seriesResults).map((series) => {
if (typeof series.teamAIndex === 'number' && typeof series.teamBIndex === 'number') { if (
typeof series.teamAIndex === 'number' &&
typeof series.teamBIndex === 'number'
) {
return series; return series;
} }
changed = true; changed = true;
@@ -216,7 +232,9 @@ function migrateResult(result: Record<string, unknown>) {
const teamBIndex = Math.max(legacyBlueTeamIndex, legacyRedTeamIndex); const teamBIndex = Math.max(legacyBlueTeamIndex, legacyRedTeamIndex);
const blueScore = numberOrDefault(series.blueScore, 0); const blueScore = numberOrDefault(series.blueScore, 0);
const redScore = numberOrDefault(series.redScore, 0); const redScore = numberOrDefault(series.redScore, 0);
const winnerSide = isSide(series.winnerSide) ? series.winnerSide : undefined; const winnerSide = isSide(series.winnerSide)
? series.winnerSide
: undefined;
const winnerTeamIndex = const winnerTeamIndex =
winnerSide === 'blue' winnerSide === 'blue'
? legacyBlueTeamIndex ? legacyBlueTeamIndex
@@ -231,12 +249,11 @@ function migrateResult(result: Record<string, unknown>) {
winnerTeamIndex, winnerTeamIndex,
}; };
}); });
migrated.seriesResults = seriesResults.length > 0 ? seriesResults : buildSeries(games); migrated.seriesResults =
seriesResults.length > 0 ? seriesResults : buildSeries(games);
if (typeof migrated.winnerTeamIndex !== 'number') { if (typeof migrated.winnerTeamIndex !== 'number') {
const migratedSeriesResults = Array.isArray(migrated.seriesResults) const migratedSeriesResults = asArray(migrated.seriesResults);
? migrated.seriesResults
: [];
migrated.winnerTeamIndex = migrated.winnerTeamIndex =
resolveWinnerTeamIndex(migratedSeriesResults) ?? resolveWinnerTeamIndex(migratedSeriesResults) ??
(isSide(migrated.winnerSide) (isSide(migrated.winnerSide)
@@ -244,7 +261,11 @@ function migrateResult(result: Record<string, unknown>) {
: undefined); : undefined);
} }
if ('winnerSide' in migrated || 'blueScore' in migrated || 'redScore' in migrated) { if (
'winnerSide' in migrated ||
'blueScore' in migrated ||
'redScore' in migrated
) {
changed = true; changed = true;
} }
delete migrated.winnerSide; delete migrated.winnerSide;
@@ -272,8 +293,12 @@ function buildSeries(games: Record<string, unknown>[]) {
const teamAIndex = Math.min(blueTeamIndex, redTeamIndex); const teamAIndex = Math.min(blueTeamIndex, redTeamIndex);
const teamBIndex = Math.max(blueTeamIndex, redTeamIndex); const teamBIndex = Math.max(blueTeamIndex, redTeamIndex);
const key = `${teamAIndex}:${teamBIndex}`; const key = `${teamAIndex}:${teamBIndex}`;
const current = const current = bySeries.get(key) ?? {
bySeries.get(key) ?? { teamAIndex, teamBIndex, teamAWins: 0, teamBWins: 0 }; teamAIndex,
teamBIndex,
teamAWins: 0,
teamBWins: 0,
};
if (winnerTeamIndex === teamAIndex) current.teamAWins += 1; if (winnerTeamIndex === teamAIndex) current.teamAWins += 1;
if (winnerTeamIndex === teamBIndex) current.teamBWins += 1; if (winnerTeamIndex === teamBIndex) current.teamBWins += 1;
current.winnerTeamIndex = current.winnerTeamIndex =
@@ -331,5 +356,7 @@ function numberOrDefault(value: unknown, fallback: number) {
} }
function numberOrUndefined(value: unknown) { function numberOrUndefined(value: unknown) {
return typeof value === 'number' && Number.isFinite(value) ? value : undefined; return typeof value === 'number' && Number.isFinite(value)
? value
: undefined;
} }
@@ -30,7 +30,8 @@ function createDb(params: { auctions?: Doc[]; history?: Doc[] }) {
}, },
}; };
}, },
async bulkWrite(writes: Array<{ async bulkWrite(
writes: Array<{
updateOne: { updateOne: {
filter: { _id: unknown }; filter: { _id: unknown };
update: { update: {
@@ -38,12 +39,17 @@ function createDb(params: { auctions?: Doc[]; history?: Doc[] }) {
$unset?: Record<string, ''>; $unset?: Record<string, ''>;
}; };
}; };
}>) { }>,
) {
for (const write of writes) { 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; if (!doc) continue;
Object.assign(doc, write.updateOne.update.$set ?? {}); Object.assign(doc, write.updateOne.update.$set ?? {});
for (const key of Object.keys(write.updateOne.update.$unset ?? {})) { for (const key of Object.keys(
write.updateOne.update.$unset ?? {},
)) {
delete doc[key]; delete doc[key];
} }
} }
@@ -31,7 +31,10 @@ interface MigrationStats {
} }
type AnyDoc = Record<string, unknown> & { _id: unknown }; 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<{ const AUCTION_FIELD_RENAMES: Array<{
from: string; from: string;
@@ -43,7 +46,11 @@ const AUCTION_FIELD_RENAMES: Array<{
{ from: 'passedQueue', to: 'passedAuctionPlayerQueue' }, { from: 'passedQueue', to: 'passedAuctionPlayerQueue' },
{ from: 'auctionRound', to: 'currentAuctionRound' }, { from: 'auctionRound', to: 'currentAuctionRound' },
{ from: 'currentIndex', to: 'currentAuctionPlayerOrderIndex' }, { from: 'currentIndex', to: 'currentAuctionPlayerOrderIndex' },
{ from: 'bids', to: 'auctionBidHistory', transform: transformAuctionBidHistory }, {
from: 'bids',
to: 'auctionBidHistory',
transform: transformAuctionBidHistory,
},
{ from: 'currentBid', to: 'currentHighestBidPointAmount' }, { from: 'currentBid', to: 'currentHighestBidPointAmount' },
{ from: 'currentBidderTeamIndex', to: 'currentHighestBidderTeamIndex' }, { from: 'currentBidderTeamIndex', to: 'currentHighestBidderTeamIndex' },
{ {
@@ -157,7 +164,8 @@ async function countDuplicateHistorySequences(
const duplicates = new Set<string>(); const duplicates = new Set<string>();
for await (const doc of collection.find({}).limit(limit ?? 0)) { for await (const doc of collection.find({}).limit(limit ?? 0)) {
const auctionId = stringifyId(doc.auctionId); const auctionId = stringifyId(doc.auctionId);
const sequence = typeof doc.sequence === 'number' ? doc.sequence : undefined; const sequence =
typeof doc.sequence === 'number' ? doc.sequence : undefined;
if (!auctionId || sequence === undefined) continue; if (!auctionId || sequence === undefined) continue;
const key = `${auctionId}:${sequence}`; const key = `${auctionId}:${sequence}`;
@@ -322,6 +330,9 @@ function legacyAuctionLifecycleId(value: unknown): string {
function stringifyId(value: unknown): string | undefined { function stringifyId(value: unknown): string | undefined {
if (value === undefined || value === null) return undefined; if (value === undefined || value === null) return undefined;
// MongoDB ObjectId and migration fixture IDs intentionally rely on their
// stable string representation.
// eslint-disable-next-line @typescript-eslint/no-base-to-string
return typeof value === 'string' ? value : String(value); return typeof value === 'string' ? value : String(value);
} }
@@ -117,7 +117,9 @@ function createDb(params: {
function matchesFilter(doc: Doc, filter: Record<string, unknown>): boolean { function matchesFilter(doc: Doc, filter: Record<string, unknown>): boolean {
const clauses = filter.$or; const clauses = filter.$or;
if (Array.isArray(clauses)) { if (Array.isArray(clauses)) {
return clauses.some((clause) => matchesFilter(doc, clause)); return (clauses as unknown[]).some(
(clause) => isRecord(clause) && matchesFilter(doc, clause),
);
} }
return Object.entries(filter).every(([key, value]) => { return Object.entries(filter).every(([key, value]) => {
@@ -1,11 +1,4 @@
type TournamentCodeState = type TournamentCodeState = string;
| 'available'
| 'reserved'
| 'used'
| 'released'
| 'expired'
| 'voided'
| string;
type AnyDoc = Record<string, unknown> & { _id: unknown }; type AnyDoc = Record<string, unknown> & { _id: unknown };
type IndexKey = Record<string, 1 | -1>; type IndexKey = Record<string, 1 | -1>;
@@ -36,7 +29,7 @@ interface MigrationCollection {
$unset?: Record<string, ''>; $unset?: Record<string, ''>;
}, },
options?: { ordered?: boolean }, options?: { ordered?: boolean },
): Promise<{ matchedCount?: number; modifiedCount?: number } | unknown>; ): Promise<unknown>;
indexes?(): Promise<MigrationIndex[]>; indexes?(): Promise<MigrationIndex[]>;
dropIndex?(name: string): Promise<unknown>; dropIndex?(name: string): Promise<unknown>;
createIndex?( createIndex?(
@@ -516,15 +509,17 @@ function summarizeGroups(
function summarizeCode(doc: TournamentCodeDoc): TournamentCodeDuplicateSummary { function summarizeCode(doc: TournamentCodeDoc): TournamentCodeDuplicateSummary {
return { return {
bracketMatchId: bracketMatchId:
doc.bracketMatchId === undefined ? undefined : String(doc.bracketMatchId), doc.bracketMatchId === undefined
code: doc.code === undefined ? undefined : String(doc.code), ? undefined
: stringifyId(doc.bracketMatchId),
code: doc.code === undefined ? undefined : stringifyId(doc.code),
gameNumber: gameNumber:
doc.gameNumber === undefined ? undefined : String(doc.gameNumber), doc.gameNumber === undefined ? undefined : stringifyId(doc.gameNumber),
id: stringifyId(doc._id) ?? '', id: stringifyId(doc._id) ?? '',
matchId: doc.matchId === undefined ? undefined : stringifyId(doc.matchId), matchId: doc.matchId === undefined ? undefined : stringifyId(doc.matchId),
riotMatchId: riotMatchId:
doc.riotMatchId === undefined ? undefined : String(doc.riotMatchId), doc.riotMatchId === undefined ? undefined : stringifyId(doc.riotMatchId),
state: doc.state === undefined ? undefined : String(doc.state), state: doc.state,
}; };
} }
@@ -749,16 +744,19 @@ function readModifiedCount(result: unknown): number {
} }
function hasField(doc: Record<string, unknown>, key: string): boolean { function hasField(doc: Record<string, unknown>, key: string): boolean {
return Object.prototype.hasOwnProperty.call(doc, key); return Object.hasOwn(doc, key);
} }
function stringifyKeyPart(value: unknown): string { function stringifyKeyPart(value: unknown): string {
if (value === null) return '<null>'; if (value === null) return '<null>';
if (value === undefined) return '<undefined>'; if (value === undefined) return '<undefined>';
return stringifyId(value) ?? String(value); return stringifyId(value) ?? '<unknown>';
} }
function stringifyId(value: unknown): string | undefined { function stringifyId(value: unknown): string | undefined {
if (value === undefined || value === null) return undefined; if (value === undefined || value === null) return undefined;
// MongoDB ObjectId and migration fixture IDs intentionally rely on their
// stable string representation.
// eslint-disable-next-line @typescript-eslint/no-base-to-string
return typeof value === 'string' ? value : String(value); return typeof value === 'string' ? value : String(value);
} }
@@ -11,7 +11,11 @@ import {
} from '../../../double-elimination/double-elimination.util'; } from '../../../double-elimination/double-elimination.util';
import { TOURNAMENT_CODE_EXPIRY_MARGIN_MS } from '../../../tournament-code/tournament-code.constants'; import { TOURNAMENT_CODE_EXPIRY_MARGIN_MS } from '../../../tournament-code/tournament-code.constants';
import { ConnectionService } from '../connection.service'; import { ConnectionService } from '../connection.service';
import type { MatchDocument, TournamentCodeDocument } from '../schema'; import type {
MatchDocument,
TournamentCode,
TournamentCodeDocument,
} from '../schema';
import { SecretModule } from '../../secret/secret.module'; import { SecretModule } from '../../secret/secret.module';
interface CliOptions { interface CliOptions {
@@ -334,7 +338,7 @@ function printPlan(plan: MatchRepairPlan) {
async function applyPlan( async function applyPlan(
match: MatchDocument, match: MatchDocument,
plan: MatchRepairPlan, plan: MatchRepairPlan,
TournamentCodeModel: mongoose.Model<any>, TournamentCodeModel: mongoose.Model<TournamentCode>,
session: mongoose.ClientSession, session: mongoose.ClientSession,
) { ) {
if (plan.skippedReason) return; if (plan.skippedReason) return;
@@ -5,10 +5,7 @@ import { NestFactory } from '@nestjs/core';
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import { readFile } from 'node:fs/promises'; import { readFile } from 'node:fs/promises';
import { resolve } from 'node:path'; import { resolve } from 'node:path';
import { import { ConnectionService, resolveMongoDbName } from '../connection.service';
ConnectionService,
resolveMongoDbName,
} from '../connection.service';
import type { import type {
MatchDocument, MatchDocument,
MatchGameAssignment, MatchGameAssignment,
@@ -214,12 +211,16 @@ async function main() {
printPlan(options, match, codes, plan); printPlan(options, match, codes, plan);
if (options.dryRun) { 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; return;
} }
const now = new Date(); const now = new Date();
const session = await (await connectionService.getConnection()).startSession(); const session = await (
await connectionService.getConnection()
).startSession();
try { try {
await session.withTransaction(async () => { await session.withTransaction(async () => {
await applyTournamentCodeUpdates(plan, now, session); await applyTournamentCodeUpdates(plan, now, session);
@@ -230,9 +231,9 @@ async function main() {
status: 'finished', status: 'finished',
roundRobinMaxRounds: options.maxRounds, roundRobinMaxRounds: options.maxRounds,
gameSchedule: plan.schedule, gameSchedule: plan.schedule,
tournamentCodeIds: [ tournamentCodeIds: [...plan.usedCodeByOldGameNumber.values()].map(
...plan.usedCodeByOldGameNumber.values(), (code) => code._id,
].map((code) => code._id), ),
resultPollState: { resultPollState: {
startedAt: match.resultPollState?.startedAt ?? now, startedAt: match.resultPollState?.startedAt ?? now,
lastPolledAt: now, lastPolledAt: now,
@@ -423,7 +424,9 @@ function partitionIntoRounds(
} }
if (!fillRound(0)) { 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; return rounds;
@@ -586,8 +589,7 @@ function buildSeriesResults(games: MatchGameResult[]): MatchSeriesResult[] {
} }
return [...bySeries.values()].sort( return [...bySeries.values()].sort(
(left, right) => (left, right) =>
left.teamAIndex - right.teamAIndex || left.teamAIndex - right.teamAIndex || left.teamBIndex - right.teamBIndex,
left.teamBIndex - right.teamBIndex,
); );
} }
@@ -219,9 +219,9 @@ async function listDuplicateHistorySequences(
.toArray(); .toArray();
} }
function printDuplicateHistorySequences(groups: Awaited< function printDuplicateHistorySequences(
ReturnType<typeof listDuplicateHistorySequences> groups: Awaited<ReturnType<typeof listDuplicateHistorySequences>>,
>) { ) {
if (groups.length === 0) { if (groups.length === 0) {
console.log('No duplicate auctionHistory auctionId+sequence groups found.'); console.log('No duplicate auctionHistory auctionId+sequence groups found.');
return; return;
@@ -248,7 +248,8 @@ async function repairDuplicateHistorySequences(
): Promise<DuplicateSequenceRepairStats> { ): Promise<DuplicateSequenceRepairStats> {
const historyCollection = db.collection('auctionHistory'); const historyCollection = db.collection('auctionHistory');
const auctionCollection = db.collection('auction'); const auctionCollection = db.collection('auction');
const affectedAuctionIds = await findAuctionIdsWithDuplicateHistorySequences(db); const affectedAuctionIds =
await findAuctionIdsWithDuplicateHistorySequences(db);
const stats: DuplicateSequenceRepairStats = { const stats: DuplicateSequenceRepairStats = {
affectedAuctions: affectedAuctionIds.length, affectedAuctions: affectedAuctionIds.length,
changedAuctionSequenceFields: 0, changedAuctionSequenceFields: 0,
@@ -177,7 +177,9 @@ function parseArgs(argv: string[]): CliOptions {
function parseCommitQuorum(value: string | undefined, label: string) { function parseCommitQuorum(value: string | undefined, label: string) {
if (!value) { if (!value) {
throw new Error(`${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; if (value === 'majority' || value === 'votingMembers') return value;
return parsePositiveInteger(value, label); return parsePositiveInteger(value, label);
@@ -230,9 +232,7 @@ function printDuplicateGroups(groups: TournamentCodeDuplicateGroupSummary[]) {
kind: group.kind, kind: group.kind,
loserCodes: group.losers.map((loser) => loser.code ?? '').join(', '), loserCodes: group.losers.map((loser) => loser.code ?? '').join(', '),
loserIds: group.losers.map((loser) => loser.id).join(', '), loserIds: group.losers.map((loser) => loser.id).join(', '),
loserStates: group.losers loserStates: group.losers.map((loser) => loser.state ?? '').join(', '),
.map((loser) => loser.state ?? '')
.join(', '),
})), })),
); );
} }
@@ -2485,7 +2485,9 @@ MatchStatsSchema.index({ communityId: 1, userIds: 1 });
MatchStatsSchema.index({ communityId: 1, userIds: 1, scheduledAt: -1 }); MatchStatsSchema.index({ communityId: 1, userIds: 1, scheduledAt: -1 });
MatchStatsSchema.index({ communityId: 1, championIds: 1 }); MatchStatsSchema.index({ communityId: 1, championIds: 1 });
export const tournamentModelDefinitions: ModelDefinition[] = [ export const tournamentModelDefinitions: Array<
ModelDefinition & { name: keyof TournamentModelTypes }
> = [
...competitionModelDefinitions, ...competitionModelDefinitions,
{ name: 'identity', schema: IdentitySchema, schemaName: 'identity' }, { name: 'identity', schema: IdentitySchema, schemaName: 'identity' },
{ name: 'community', schema: CommunitySchema, schemaName: 'community' }, { name: 'community', schema: CommunitySchema, schemaName: 'community' },
+1 -1
View File
@@ -1,5 +1,5 @@
export interface ModelDefinition { export interface ModelDefinition {
name: string; name: string;
schema: mongoose.Schema<any>; schema: unknown;
schemaName?: string; schemaName?: string;
} }
@@ -1,5 +1,4 @@
import { Module } from '@nestjs/common'; import { Module } from '@nestjs/common';
import fs from 'fs/promises';
import { connect } from 'nats'; import { connect } from 'nats';
import type { NatsConnection } from 'nats'; import type { NatsConnection } from 'nats';
import { SecretModule } from '../secret/secret.module'; import { SecretModule } from '../secret/secret.module';
@@ -34,31 +34,32 @@ type SchemaWithPerformanceMarker = mongoose.Schema & {
[PERFORMANCE_PLUGIN_APPLIED]?: boolean; [PERFORMANCE_PLUGIN_APPLIED]?: boolean;
}; };
export function applyMongoosePerformancePlugin(schema: mongoose.Schema): void { export function applyMongoosePerformancePlugin(schemaValue: unknown): void {
const markedSchema = schema as SchemaWithPerformanceMarker; if (!(schemaValue instanceof mongoose.Schema)) {
if (markedSchema[PERFORMANCE_PLUGIN_APPLIED]) return; throw new TypeError('Mongoose performance plugin requires a Schema.');
markedSchema[PERFORMANCE_PLUGIN_APPLIED] = true; }
const hookableSchema = schema as any; const schema = schemaValue as SchemaWithPerformanceMarker;
if (schema[PERFORMANCE_PLUGIN_APPLIED]) return;
schema[PERFORMANCE_PLUGIN_APPLIED] = true;
hookableSchema.pre(QUERY_OPERATION_REGEX, function () { schema.pre(QUERY_OPERATION_REGEX, function () {
const query = this as QueryWithPerformanceState; const query = this as QueryWithPerformanceState;
query[QUERY_PERFORMANCE_START] = process.hrtime.bigint(); query[QUERY_PERFORMANCE_START] = process.hrtime.bigint();
query[QUERY_PERFORMANCE_RECORDED] = false; query[QUERY_PERFORMANCE_RECORDED] = false;
}); });
hookableSchema.post( schema.post(QUERY_OPERATION_REGEX, function (result: unknown) {
QUERY_OPERATION_REGEX, recordQueryPerformance(this as QueryWithPerformanceState, result);
function (result: unknown) { });
recordQueryPerformance(
this as unknown as QueryWithPerformanceState,
result,
);
},
);
hookableSchema.post( schema.post(
QUERY_OPERATION_REGEX, QUERY_OPERATION_REGEX,
function (error: unknown, _result: unknown, next: (error: unknown) => void) { { errorHandler: true },
function (
error: Error,
_result: unknown,
next: (error?: mongoose.CallbackError) => void,
) {
recordQueryPerformance( recordQueryPerformance(
this as unknown as QueryWithPerformanceState, this as unknown as QueryWithPerformanceState,
undefined, undefined,
@@ -68,19 +69,24 @@ export function applyMongoosePerformancePlugin(schema: mongoose.Schema): void {
}, },
); );
hookableSchema.pre('aggregate', function () { schema.pre('aggregate', function () {
const aggregate = this as AggregateWithPerformanceState; const aggregate = this as AggregateWithPerformanceState;
aggregate[QUERY_PERFORMANCE_START] = process.hrtime.bigint(); aggregate[QUERY_PERFORMANCE_START] = process.hrtime.bigint();
aggregate[QUERY_PERFORMANCE_RECORDED] = false; aggregate[QUERY_PERFORMANCE_RECORDED] = false;
}); });
hookableSchema.post('aggregate', function (result: unknown) { schema.post('aggregate', function (result: unknown) {
recordAggregatePerformance(this as AggregateWithPerformanceState, result); recordAggregatePerformance(this as AggregateWithPerformanceState, result);
}); });
hookableSchema.post( schema.post(
'aggregate', 'aggregate',
function (error: unknown, _result: unknown, next: (error: unknown) => void) { { errorHandler: true },
function (
error: Error,
_result: unknown,
next: (error?: mongoose.CallbackError) => void,
) {
recordAggregatePerformance( recordAggregatePerformance(
this as AggregateWithPerformanceState, this as AggregateWithPerformanceState,
undefined, undefined,
@@ -11,9 +11,7 @@ interface NewRelicCustomEventApi {
eventType: string, eventType: string,
attributes: Record<string, NewRelicAttributeValue>, attributes: Record<string, NewRelicAttributeValue>,
): void; ): void;
addCustomAttributes( addCustomAttributes(attributes: Record<string, NewRelicAttributeValue>): void;
attributes: Record<string, NewRelicAttributeValue>,
): void;
setTransactionName(name: string): void; setTransactionName(name: string): void;
} }
const agent = newrelicAgent as unknown as NewRelicCustomEventApi; const agent = newrelicAgent as unknown as NewRelicCustomEventApi;
@@ -52,8 +52,7 @@ export interface ApiRequestPerformanceEvent {
leanQueryCount: number; leanQueryCount: number;
} }
export interface MongooseQueryPerformanceEvent export interface MongooseQueryPerformanceEvent extends MongooseQueryPerformance {
extends MongooseQueryPerformance {
type: 'mongoose-query'; type: 'mongoose-query';
timestamp: string; timestamp: string;
requestId?: string; requestId?: string;
@@ -92,10 +91,7 @@ export function resolveApiPerformanceConfig(
const enabled = readBoolean(env.API_PERF_OBSERVABILITY_ENABLED, false); const enabled = readBoolean(env.API_PERF_OBSERVABILITY_ENABLED, false);
return { return {
enabled, enabled,
localEventsEnabled: readBoolean( localEventsEnabled: readBoolean(env.API_PERF_LOCAL_EVENTS_ENABLED, enabled),
env.API_PERF_LOCAL_EVENTS_ENABLED,
enabled,
),
localEventFile: localEventFile:
env.API_PERF_LOCAL_EVENT_FILE || '/tmp/lolympus-api-performance.ndjson', env.API_PERF_LOCAL_EVENT_FILE || '/tmp/lolympus-api-performance.ndjson',
newRelicRequestEventsEnabled: readBoolean( newRelicRequestEventsEnabled: readBoolean(
@@ -35,8 +35,7 @@ export interface RunWithDistributedLockOptions {
lockRetryDelayMilliseconds?: number; lockRetryDelayMilliseconds?: number;
} }
export interface RunWithRenewedDistributedLockOptions export interface RunWithRenewedDistributedLockOptions extends RunWithDistributedLockOptions {
extends RunWithDistributedLockOptions {
lockRenewalIntervalMilliseconds: number; lockRenewalIntervalMilliseconds: number;
} }
@@ -55,16 +54,13 @@ export class DistributedLockService {
); );
const lockOwnershipToken = options.lockOwnershipToken ?? randomUUID(); const lockOwnershipToken = options.lockOwnershipToken ?? randomUUID();
const result = await this.redisService.raw().sendCommand([ const result = await this.redisService
'SET', .raw()
options.lockKey, .sendCommand<
lockOwnershipToken, string | null
'NX', >(['SET', options.lockKey, lockOwnershipToken, 'NX', 'PX', String(options.lockExpirationDurationMilliseconds)]);
'PX',
String(options.lockExpirationDurationMilliseconds),
]);
if (String(result) !== 'OK') return null; if (result !== 'OK') return null;
return { return {
lockKey: options.lockKey, lockKey: options.lockKey,
lockOwnershipToken, lockOwnershipToken,
@@ -76,7 +72,9 @@ export class DistributedLockService {
public async releaseLockIfOwned( public async releaseLockIfOwned(
lockOwnership: DistributedLockOwnership, lockOwnership: DistributedLockOwnership,
): Promise<boolean> { ): Promise<boolean> {
const result = await this.redisService.raw().sendCommand([ const result = await this.redisService
.raw()
.sendCommand([
'EVAL', 'EVAL',
RELEASE_LOCK_IF_OWNED_SCRIPT, RELEASE_LOCK_IF_OWNED_SCRIPT,
'1', '1',
@@ -88,15 +86,16 @@ export class DistributedLockService {
public async extendLockIfOwned( public async extendLockIfOwned(
lockOwnership: DistributedLockOwnership, lockOwnership: DistributedLockOwnership,
lockExpirationDurationMilliseconds = lockExpirationDurationMilliseconds = lockOwnership.lockExpirationDurationMilliseconds,
lockOwnership.lockExpirationDurationMilliseconds,
): Promise<boolean> { ): Promise<boolean> {
this.assertPositiveDuration( this.assertPositiveDuration(
lockExpirationDurationMilliseconds, lockExpirationDurationMilliseconds,
'lockExpirationDurationMilliseconds', 'lockExpirationDurationMilliseconds',
); );
const result = await this.redisService.raw().sendCommand([ const result = await this.redisService
.raw()
.sendCommand([
'EVAL', 'EVAL',
EXTEND_LOCK_IF_OWNED_SCRIPT, EXTEND_LOCK_IF_OWNED_SCRIPT,
'1', '1',
@@ -120,7 +119,7 @@ export class DistributedLockService {
await this.releaseLockIfOwned(lockOwnership).catch((error: unknown) => { await this.releaseLockIfOwned(lockOwnership).catch((error: unknown) => {
this.logger.warn( this.logger.warn(
`Failed to release distributed lock ${lockOwnership.lockKey}: ${ `Failed to release distributed lock ${lockOwnership.lockKey}: ${
error instanceof Error ? error.message : error error instanceof Error ? error.message : String(error)
}`, }`,
); );
}); });
@@ -139,8 +138,7 @@ export class DistributedLockService {
const lockOwnership = await this.acquireLockWithRetry(options); const lockOwnership = await this.acquireLockWithRetry(options);
if (!lockOwnership) return null; if (!lockOwnership) return null;
let lockRenewalTimer: NodeJS.Timeout | undefined; const lockRenewalTimer = setInterval(() => {
lockRenewalTimer = setInterval(() => {
void this.extendLockIfOwned(lockOwnership).then((wasExtended) => { void this.extendLockIfOwned(lockOwnership).then((wasExtended) => {
if (wasExtended) return; if (wasExtended) return;
this.logger.warn( this.logger.warn(
@@ -153,11 +151,11 @@ export class DistributedLockService {
try { try {
return await operation(lockOwnership); return await operation(lockOwnership);
} finally { } finally {
if (lockRenewalTimer) clearInterval(lockRenewalTimer); clearInterval(lockRenewalTimer);
await this.releaseLockIfOwned(lockOwnership).catch((error: unknown) => { await this.releaseLockIfOwned(lockOwnership).catch((error: unknown) => {
this.logger.warn( this.logger.warn(
`Failed to release distributed lock ${lockOwnership.lockKey}: ${ `Failed to release distributed lock ${lockOwnership.lockKey}: ${
error instanceof Error ? error.message : error error instanceof Error ? error.message : String(error)
}`, }`,
); );
}); });
@@ -25,7 +25,9 @@ async function readFirstSecret(
{ {
provide: REDIS_CLIENT, provide: REDIS_CLIENT,
inject: [SecretService], inject: [SecretService],
useFactory: async (secretService: SecretService): Promise<RedisClient> => { useFactory: async (
secretService: SecretService,
): Promise<RedisClient> => {
await secretService.ready(); await secretService.ready();
const [url, endpoint, username, password] = await Promise.all([ const [url, endpoint, username, password] = await Promise.all([
@@ -52,8 +54,12 @@ async function readFirstSecret(
}), }),
); );
client.on('error', (error) => { client.on('error', (error: unknown) => {
logger.error(`Redis client error: ${error?.message ?? error}`); logger.error(
`Redis client error: ${
error instanceof Error ? error.message : String(error)
}`,
);
}); });
await client.connect(); await client.connect();
@@ -6,7 +6,9 @@ function createRedisService(client: Record<string, unknown>) {
describe('RedisService stream pending recovery', () => { describe('RedisService stream pending recovery', () => {
it('normalizes XAUTOCLAIM array replies into stream entries', async () => { it('normalizes XAUTOCLAIM array replies into stream entries', async () => {
const sendCommand = jest.fn().mockResolvedValue([ const sendCommand = jest
.fn()
.mockResolvedValue([
'0-0', '0-0',
[ [
[ [
@@ -35,11 +35,14 @@ interface RawStreamReadResult {
function normalizeStreamFields(fields: unknown): Record<string, string> { function normalizeStreamFields(fields: unknown): Record<string, string> {
if (Array.isArray(fields)) { if (Array.isArray(fields)) {
const values = fields as unknown[];
const normalized: Record<string, string> = {}; const normalized: Record<string, string> = {};
for (let index = 0; index < fields.length; index += 2) { for (let index = 0; index < values.length; index += 2) {
const key = fields[index]; const key = values[index];
if (key === undefined) continue; if (key === undefined) continue;
normalized[String(key)] = String(fields[index + 1] ?? ''); normalized[redisValueToString(key)] = redisValueToString(
values[index + 1],
);
} }
return normalized; return normalized;
} }
@@ -223,9 +226,7 @@ export class RedisService implements OnModuleDestroy {
])) as unknown; ])) as unknown;
const responseItems = Array.isArray(response) ? response : []; const responseItems = Array.isArray(response) ? response : [];
const rawMessages = Array.isArray(responseItems[1]) const rawMessages = Array.isArray(responseItems[1]) ? responseItems[1] : [];
? responseItems[1]
: [];
return { return {
nextStartId: String(responseItems[0] ?? '0-0'), nextStartId: String(responseItems[0] ?? '0-0'),
@@ -258,12 +259,14 @@ export class RedisService implements OnModuleDestroy {
return this.client.publish(channel, message); return this.client.publish(channel, message);
} }
private normalizeClaimedStreamMessage(rawMessage: unknown): StreamEntry | null { private normalizeClaimedStreamMessage(
rawMessage: unknown,
): StreamEntry | null {
if (Array.isArray(rawMessage)) { if (Array.isArray(rawMessage)) {
const [id, fields] = rawMessage; const [id, fields] = rawMessage as unknown[];
if (id === undefined) return null; if (id === undefined) return null;
return { return {
id: String(id), id: redisValueToString(id),
message: normalizeStreamFields(fields), message: normalizeStreamFields(fields),
}; };
} }
@@ -291,3 +294,17 @@ export class RedisService implements OnModuleDestroy {
return null; return null;
} }
} }
function redisValueToString(value: unknown): string {
if (typeof value === 'string') return value;
if (
typeof value === 'number' ||
typeof value === 'boolean' ||
typeof value === 'bigint'
) {
return String(value);
}
if (Buffer.isBuffer(value)) return value.toString('utf8');
if (value === undefined || value === null) return '';
return JSON.stringify(value) ?? '';
}
@@ -1,4 +1,3 @@
/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/require-await, @typescript-eslint/unbound-method */
import { readFileSync } from 'node:fs'; import { readFileSync } from 'node:fs';
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import type { CompetitionBootstrapService } from '../competition/competition-bootstrap.service'; import type { CompetitionBootstrapService } from '../competition/competition-bootstrap.service';
@@ -46,11 +46,13 @@ export function countKnownParticipants(
): { team100: number; team200: number; total: number } { ): { team100: number; team200: number; total: number } {
const team100 = detail.info.participants.filter( const team100 = detail.info.participants.filter(
(participant) => (participant) =>
participant.teamId === RIOT_BLUE_TEAM_ID && userByPuuid.has(participant.puuid), participant.teamId === RIOT_BLUE_TEAM_ID &&
userByPuuid.has(participant.puuid),
).length; ).length;
const team200 = detail.info.participants.filter( const team200 = detail.info.participants.filter(
(participant) => (participant) =>
participant.teamId === RIOT_RED_TEAM_ID && userByPuuid.has(participant.puuid), participant.teamId === RIOT_RED_TEAM_ID &&
userByPuuid.has(participant.puuid),
).length; ).length;
return { team100, team200, total: team100 + team200 }; return { team100, team200, total: team100 + team200 };
} }
@@ -78,13 +80,16 @@ export function buildParticipantsSnapshot(
tagLine: user.account.tagLine || participant.riotIdTagLine, tagLine: user.account.tagLine || participant.riotIdTagLine,
profileIconId: user.account.profileIconId, profileIconId: user.account.profileIconId,
tier: tier:
user.account.tiers.find((tier) => tier.queueType === 'RANKED_SOLO_5x5') ?? user.account.tiers.find(
user.account.tiers[0], (tier) => tier.queueType === 'RANKED_SOLO_5x5',
) ?? user.account.tiers[0],
preferredPositions: user.preferredPositions, preferredPositions: user.preferredPositions,
joinedAt: new Date(detail.info.gameCreation), joinedAt: new Date(detail.info.gameCreation),
}; };
}) })
.filter((participant): participant is MatchParticipant => Boolean(participant)); .filter((participant): participant is MatchParticipant =>
Boolean(participant),
);
} }
export function buildTeams( export function buildTeams(
@@ -105,7 +110,9 @@ export function buildTeams(
assignedPosition: resolveAssignedPosition(participant, user), assignedPosition: resolveAssignedPosition(participant, user),
}; };
}) })
.filter((member): member is NonNullable<typeof member> => Boolean(member)); .filter((member): member is NonNullable<typeof member> =>
Boolean(member),
);
return { return {
teamIndex, teamIndex,
name: `${teamIndex}팀`, name: `${teamIndex}팀`,
@@ -3,9 +3,7 @@ import mongoose from 'mongoose';
import { AllowPublicAccess } from '../auth/allow-public-access.decorator'; import { AllowPublicAccess } from '../auth/allow-public-access.decorator';
import { ParseObjectIdPipe } from '../common/parse-object-id.pipe'; import { ParseObjectIdPipe } from '../common/parse-object-id.pipe';
import { RiotJobQueueService } from '../riot-job-queue/riot-job-queue.service'; import { RiotJobQueueService } from '../riot-job-queue/riot-job-queue.service';
import type { import type { RiotJobPriority } from '../riot-job-queue/riot-job-queue.types';
RiotJobPriority,
} from '../riot-job-queue/riot-job-queue.types';
import { MatchHistoryService } from './match-history.service'; import { MatchHistoryService } from './match-history.service';
interface RefreshBody { interface RefreshBody {
@@ -1,4 +1,8 @@
import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common'; import {
BadRequestException,
Injectable,
NotFoundException,
} from '@nestjs/common';
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service'; import { ConnectionService } from '../global/database/connection.service';
import type { import type {
@@ -16,10 +20,7 @@ import {
type RiotQueueGroup, type RiotQueueGroup,
type RiotRankFilter, type RiotRankFilter,
} from '../riot/riot-queue.constants'; } from '../riot/riot-queue.constants';
import type { import type { RiotMatchDto, RiotMatchParticipantDto } from '../riot/riot.types';
RiotMatchDto,
RiotMatchParticipantDto,
} from '../riot/riot.types';
import type { import type {
ChampionStatsResponse, ChampionStatsResponse,
ChampionStatsRow, ChampionStatsRow,
@@ -104,7 +105,10 @@ export class MatchHistoryService {
fetchedAt: tier.fetchedAt.toISOString(), fetchedAt: tier.fetchedAt.toISOString(),
})), })),
tierHistory: [...context.account.tierHistory] tierHistory: [...context.account.tierHistory]
.sort((left, right) => left.recordedAt.getTime() - right.recordedAt.getTime()) .sort(
(left, right) =>
left.recordedAt.getTime() - right.recordedAt.getTime(),
)
.map((entry) => ({ .map((entry) => ({
queueType: entry.queueType, queueType: entry.queueType,
tier: entry.tier, tier: entry.tier,
@@ -170,7 +174,11 @@ export class MatchHistoryService {
seasonId: params.filters.seasonId, seasonId: params.filters.seasonId,
}); });
const { queueIds } = this.resolveQueueFilters(params.filters); const { queueIds } = this.resolveQueueFilters(params.filters);
const limit = this.clampLimit(params.filters.limit, DEFAULT_SUMMARY_LIMIT, 50); const limit = this.clampLimit(
params.filters.limit,
DEFAULT_SUMMARY_LIMIT,
50,
);
const docs = await this.findStoredMatches({ const docs = await this.findStoredMatches({
context, context,
queueIds, queueIds,
@@ -196,7 +204,11 @@ export class MatchHistoryService {
seasonId: params.filters.seasonId, seasonId: params.filters.seasonId,
}); });
const { queueIds } = this.resolveQueueFilters(params.filters); const { queueIds } = this.resolveQueueFilters(params.filters);
const limit = this.clampLimit(params.filters.limit, DEFAULT_RECENT_LIMIT, 30); const limit = this.clampLimit(
params.filters.limit,
DEFAULT_RECENT_LIMIT,
30,
);
const docs = await this.findStoredMatches({ const docs = await this.findStoredMatches({
context, context,
queueIds, queueIds,
@@ -212,7 +224,10 @@ export class MatchHistoryService {
return { return {
matches: page, matches: page,
nextCursor: views.length > limit ? page[page.length - 1]?.gameCreation ?? null : null, nextCursor:
views.length > limit
? (page[page.length - 1]?.gameCreation ?? null)
: null,
lastFetchedAt: this.resolveLastFetchedAt(docs, context), lastFetchedAt: this.resolveLastFetchedAt(docs, context),
season: context.season, season: context.season,
}; };
@@ -455,8 +470,9 @@ export class MatchHistoryService {
puuid: string, puuid: string,
): RiotMatchParticipantDto | null { ): RiotMatchParticipantDto | null {
return ( return (
match.info.participants.find((participant) => participant.puuid === puuid) ?? match.info.participants.find(
null (participant) => participant.puuid === puuid,
) ?? null
); );
} }
@@ -570,7 +586,8 @@ export class MatchHistoryService {
return { return {
matchId: dto.metadata.matchId, matchId: dto.metadata.matchId,
queueId: dto.info.queueId, queueId: dto.info.queueId,
queueLabel: RIOT_QUEUE_LABELS[dto.info.queueId] ?? `큐 ${dto.info.queueId}`, queueLabel:
RIOT_QUEUE_LABELS[dto.info.queueId] ?? `큐 ${dto.info.queueId}`,
gameCreation: dto.info.gameCreation, gameCreation: dto.info.gameCreation,
gameDuration: dto.info.gameDuration, gameDuration: dto.info.gameDuration,
win: participant.win, win: participant.win,
@@ -684,11 +701,15 @@ export class MatchHistoryService {
return { return {
puuid: participant.puuid, puuid: participant.puuid,
gameName: participant.riotIdGameName || participant.summonerName || 'Unknown', gameName:
participant.riotIdGameName ||
participant.summonerName ||
'Unknown',
tagLine: participant.riotIdTagLine || '', tagLine: participant.riotIdTagLine || '',
championId: participant.championId, championId: participant.championId,
championLevel: participant.champLevel, championLevel: participant.champLevel,
teamPosition: participant.teamPosition || participant.individualPosition, teamPosition:
participant.teamPosition || participant.individualPosition,
kills: participant.kills, kills: participant.kills,
deaths: participant.deaths, deaths: participant.deaths,
assists: participant.assists, assists: participant.assists,
@@ -720,7 +741,9 @@ export class MatchHistoryService {
})); }));
} }
private resolvePerks(participant: RiotMatchParticipantDto): RecentMatchView['perks'] { private resolvePerks(
participant: RiotMatchParticipantDto,
): RecentMatchView['perks'] {
const primary = participant.perks.styles.find( const primary = participant.perks.styles.find(
(style) => style.description === 'primaryStyle', (style) => style.description === 'primaryStyle',
); );
@@ -750,11 +773,19 @@ export class MatchHistoryService {
) as Partial<Record<RiotLane, number>>; ) as Partial<Record<RiotLane, number>>;
} }
private resolveTopChampions(views: RecentMatchView[]): RecentSummaryResponse['topChampions'] { private resolveTopChampions(
const byChampion = new Map<number, { games: number; wins: number; rating: number }>(); views: RecentMatchView[],
): RecentSummaryResponse['topChampions'] {
const byChampion = new Map<
number,
{ games: number; wins: number; rating: number }
>();
for (const view of views) { for (const view of views) {
const stat = const stat = byChampion.get(view.championId) ?? {
byChampion.get(view.championId) ?? { games: 0, wins: 0, rating: 0 }; games: 0,
wins: 0,
rating: 0,
};
stat.games += 1; stat.games += 1;
stat.wins += view.win ? 1 : 0; stat.wins += view.win ? 1 : 0;
stat.rating += view.rating; stat.rating += view.rating;
@@ -797,7 +828,8 @@ export class MatchHistoryService {
participant.deaths, participant.deaths,
participant.assists, participant.assists,
); );
const kp = teamKills > 0 ? (participant.kills + participant.assists) / teamKills : 0; const kp =
teamKills > 0 ? (participant.kills + participant.assists) / teamKills : 0;
const csPerMin = this.resolveTotalCs(participant) / Math.max(minutes, 1); const csPerMin = this.resolveTotalCs(participant) / Math.max(minutes, 1);
const visionPerMin = participant.visionScore / Math.max(minutes, 1); const visionPerMin = participant.visionScore / Math.max(minutes, 1);
const score = const score =
@@ -815,8 +847,13 @@ export class MatchHistoryService {
): number { ): number {
const teamDamage = match.info.participants const teamDamage = match.info.participants
.filter((candidate) => candidate.teamId === participant.teamId) .filter((candidate) => candidate.teamId === participant.teamId)
.reduce((sum, candidate) => sum + candidate.totalDamageDealtToChampions, 0); .reduce(
return teamDamage > 0 ? participant.totalDamageDealtToChampions / teamDamage : 0; (sum, candidate) => sum + candidate.totalDamageDealtToChampions,
0,
);
return teamDamage > 0
? participant.totalDamageDealtToChampions / teamDamage
: 0;
} }
private resolveTotalCs(participant: RiotMatchParticipantDto): number { private resolveTotalCs(participant: RiotMatchParticipantDto): number {
@@ -827,11 +864,16 @@ export class MatchHistoryService {
match: RiotMatchDto, match: RiotMatchDto,
participant: RiotMatchParticipantDto, participant: RiotMatchParticipantDto,
): number { ): number {
return Math.max((participant.timePlayed || match.info.gameDuration) / 60, 1); return Math.max(
(participant.timePlayed || match.info.gameDuration) / 60,
1,
);
} }
private resolveKda(kills: number, deaths: number, assists: number): number { private resolveKda(kills: number, deaths: number, assists: number): number {
return deaths === 0 ? kills + assists : this.round((kills + assists) / deaths); return deaths === 0
? kills + assists
: this.round((kills + assists) / deaths);
} }
private resolveLastFetchedAt( private resolveLastFetchedAt(
@@ -841,9 +883,11 @@ export class MatchHistoryService {
if (docs.length === 0) { if (docs.length === 0) {
return context.account.recentStatsFetchedAt?.toISOString() ?? null; return context.account.recentStatsFetchedAt?.toISOString() ?? null;
} }
const oldest = docs.reduce((acc, doc) => const oldest = docs.reduce(
(acc, doc) =>
doc.fetchedAt.getTime() < acc.getTime() ? doc.fetchedAt : acc, doc.fetchedAt.getTime() < acc.getTime() ? doc.fetchedAt : acc,
docs[0].fetchedAt); docs[0].fetchedAt,
);
return oldest.toISOString(); return oldest.toISOString();
} }
@@ -858,14 +902,17 @@ export class MatchHistoryService {
.map((row) => row.lastFetchedAt) .map((row) => row.lastFetchedAt)
.filter((value): value is Date => value instanceof Date) .filter((value): value is Date => value instanceof Date)
.reduce<Date | null>( .reduce<Date | null>(
(acc, value) => (acc, value) => (!acc || value.getTime() < acc.getTime() ? value : acc),
!acc || value.getTime() < acc.getTime() ? value : acc,
null, null,
); );
return oldest?.toISOString() ?? null; return oldest?.toISOString() ?? null;
} }
private clampLimit(value: number | undefined, fallback: number, max: number): number { private clampLimit(
value: number | undefined,
fallback: number,
max: number,
): number {
if (!value || !Number.isFinite(value)) return fallback; if (!value || !Number.isFinite(value)) return fallback;
return Math.max(1, Math.min(Math.floor(value), max)); return Math.max(1, Math.min(Math.floor(value), max));
} }
@@ -882,18 +929,12 @@ export class MatchHistoryService {
return Math.round(value * 10) / 10; return Math.round(value * 10) / 10;
} }
private numberField( private numberField(value: RiotMatchParticipantDto, key: string): number {
value: RiotMatchParticipantDto,
key: string,
): number {
const field = value[key]; const field = value[key];
return typeof field === 'number' && Number.isFinite(field) ? field : 0; return typeof field === 'number' && Number.isFinite(field) ? field : 0;
} }
private booleanField( private booleanField(value: RiotMatchParticipantDto, key: string): boolean {
value: RiotMatchParticipantDto,
key: string,
): boolean {
return value[key] === true; return value[key] === true;
} }
} }
@@ -34,7 +34,7 @@ describe('MatchController participant access', () => {
it('requires an authenticated community member for the self-join route', () => { it('requires an authenticated community member for the self-join route', () => {
// Metadata must be read from the unbound prototype method itself. // Metadata must be read from the unbound prototype method itself.
// eslint-disable-next-line @typescript-eslint/unbound-method
const handler = MatchController.prototype.joinMatch; const handler = MatchController.prototype.joinMatch;
const roles = Reflect.getMetadata(ROLES_KEY, handler) as const roles = Reflect.getMetadata(ROLES_KEY, handler) as
| string[] | string[]
@@ -5,7 +5,9 @@ describe('MatchService', () => {
function createServiceWithCreateModels() { function createServiceWithCreateModels() {
const createdPayloads: Record<string, unknown>[] = []; const createdPayloads: Record<string, unknown>[] = [];
const MatchModel = { const MatchModel = {
create: jest.fn().mockImplementation(async (payload) => { create: jest
.fn()
.mockImplementation(async (payload: Record<string, unknown>) => {
createdPayloads.push(payload); createdPayloads.push(payload);
return payload; return payload;
}), }),
@@ -73,7 +73,7 @@ export class BackgroundRefreshScheduler
.catch((err: unknown) => { .catch((err: unknown) => {
this.logger.warn( this.logger.warn(
`Background refresh leader release failed: ${ `Background refresh leader release failed: ${
err instanceof Error ? err.message : err err instanceof Error ? err.message : String(err)
}`, }`,
); );
}); });
@@ -8,7 +8,11 @@ import { RiotJobWorkerService } from './riot-job-worker.service';
import { RiotRefreshGateway } from './riot-refresh.gateway'; import { RiotRefreshGateway } from './riot-refresh.gateway';
@Module({ @Module({
imports: [RiotModule, LegacyImportModule, forwardRef(() => TournamentResultModule)], imports: [
RiotModule,
LegacyImportModule,
forwardRef(() => TournamentResultModule),
],
controllers: [RiotJobQueueController], controllers: [RiotJobQueueController],
providers: [RiotJobQueueService, RiotJobWorkerService, RiotRefreshGateway], providers: [RiotJobQueueService, RiotJobWorkerService, RiotRefreshGateway],
exports: [RiotJobQueueService], exports: [RiotJobQueueService],
@@ -95,7 +95,8 @@ export class RiotJobQueueService {
jobId: existingJobId, jobId: existingJobId,
queueGroup, queueGroup,
alreadyQueued: true, alreadyQueued: true,
etaSeconds: existingStatus?.etaSeconds ?? queuePosition * RIOT_JOB_AVG_SECONDS, etaSeconds:
existingStatus?.etaSeconds ?? queuePosition * RIOT_JOB_AVG_SECONDS,
queuePosition: existingStatus?.queuePosition ?? queuePosition, queuePosition: existingStatus?.queuePosition ?? queuePosition,
}); });
continue; continue;
@@ -127,7 +128,8 @@ export class RiotJobQueueService {
jobId, jobId,
queueGroup, queueGroup,
alreadyQueued: true, alreadyQueued: true,
etaSeconds: status?.etaSeconds ?? queuePosition * RIOT_JOB_AVG_SECONDS, etaSeconds:
status?.etaSeconds ?? queuePosition * RIOT_JOB_AVG_SECONDS,
queuePosition: status?.queuePosition ?? queuePosition, queuePosition: status?.queuePosition ?? queuePosition,
}); });
continue; continue;
@@ -164,7 +166,10 @@ export class RiotJobQueueService {
}); });
} }
await this.setParent(parentJobId, subJobs.map((job) => job.jobId)); await this.setParent(
parentJobId,
subJobs.map((job) => job.jobId),
);
if (params.priority === 'high' && needsNewJob) { if (params.priority === 'high' && needsNewJob) {
await this.markRefreshRequested(context.user._id, context.account.puuid); await this.markRefreshRequested(context.user._id, context.account.puuid);
} }
@@ -210,7 +215,7 @@ export class RiotJobQueueService {
public async promoteDueScheduledJobs(limit = 100): Promise<number> { public async promoteDueScheduledJobs(limit = 100): Promise<number> {
const client = this.redisService.raw(); const client = this.redisService.raw();
const raw = (await client.sendCommand([ const entries = await client.sendCommand<string[]>([
'ZRANGEBYSCORE', 'ZRANGEBYSCORE',
RIOT_JOB_SCHEDULED_ZSET, RIOT_JOB_SCHEDULED_ZSET,
'-inf', '-inf',
@@ -218,16 +223,15 @@ export class RiotJobQueueService {
'LIMIT', 'LIMIT',
'0', '0',
String(limit), String(limit),
])) as string[] | null; ]);
const entries = raw ?? [];
let promoted = 0; let promoted = 0;
for (const entry of entries) { for (const entry of entries) {
const removed = (await client.sendCommand([ const removed = await client.sendCommand<number>([
'ZREM', 'ZREM',
RIOT_JOB_SCHEDULED_ZSET, RIOT_JOB_SCHEDULED_ZSET,
entry, entry,
])) as number; ]);
if (removed !== 1) continue; if (removed !== 1) continue;
const job = this.parseScheduledJob(entry); const job = this.parseScheduledJob(entry);
if (!job) continue; if (!job) continue;
@@ -253,8 +257,8 @@ export class RiotJobQueueService {
const subJobs = ( const subJobs = (
await Promise.all(jobIds.map((jobId) => this.getStatus(jobId))) await Promise.all(jobIds.map((jobId) => this.getStatus(jobId)))
).filter((status): status is RiotJobStatus => Boolean(status)); ).filter((status): status is RiotJobStatus => Boolean(status));
const done = subJobs.filter((job) => const done = subJobs.filter(
job.state === 'completed' || job.state === 'failed', (job) => job.state === 'completed' || job.state === 'failed',
).length; ).length;
const state = this.resolveParentState(subJobs); const state = this.resolveParentState(subJobs);
@@ -411,7 +415,9 @@ export class RiotJobQueueService {
job: PollTournamentResultJob, job: PollTournamentResultJob,
deferUntilMs: number, deferUntilMs: number,
): Promise<void> { ): Promise<void> {
await this.redisService.raw().sendCommand([ await this.redisService
.raw()
.sendCommand([
'ZADD', 'ZADD',
RIOT_JOB_SCHEDULED_ZSET, RIOT_JOB_SCHEDULED_ZSET,
String(deferUntilMs), String(deferUntilMs),
@@ -449,7 +455,10 @@ export class RiotJobQueueService {
); );
} }
private async setParent(parentJobId: string, jobIds: string[]): Promise<void> { private async setParent(
parentJobId: string,
jobIds: string[],
): Promise<void> {
await this.redisService.setJson( await this.redisService.setJson(
this.parentKey(parentJobId), this.parentKey(parentJobId),
jobIds, jobIds,
@@ -1,7 +1,4 @@
import type { import type { RiotPlatformRoute, RiotRegionalRoute } from '../riot/riot.types';
RiotPlatformRoute,
RiotRegionalRoute,
} from '../riot/riot.types';
import type { RiotQueueGroup } from '../riot/riot-queue.constants'; import type { RiotQueueGroup } from '../riot/riot-queue.constants';
import type { PollTournamentResultJob } from '../tournament-result/tournament-result.types'; import type { PollTournamentResultJob } from '../tournament-result/tournament-result.types';
import type { LegacyImportMemberJob } from '../legacy-import/legacy-import.types'; import type { LegacyImportMemberJob } from '../legacy-import/legacy-import.types';
@@ -21,7 +21,9 @@ function makeWorker() {
deleteStreamEntries: jest.fn().mockResolvedValue(undefined), deleteStreamEntries: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<RedisService>; } as unknown as jest.Mocked<RedisService>;
const distributedLockService = { const distributedLockService = {
runWithRenewedLock: jest.fn().mockImplementation(async (options, operation) => runWithRenewedLock: jest
.fn()
.mockImplementation(async (options, operation) =>
operation({ operation({
lockKey: options.lockKey, lockKey: options.lockKey,
lockOwnershipToken: 'lock-owner', lockOwnershipToken: 'lock-owner',
@@ -67,7 +67,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
.catch((error: unknown) => { .catch((error: unknown) => {
this.logger.warn( this.logger.warn(
`Failed to release Riot job worker leader lock: ${ `Failed to release Riot job worker leader lock: ${
error instanceof Error ? error.message : error error instanceof Error ? error.message : String(error)
}`, }`,
); );
}); });
@@ -31,10 +31,10 @@ export class RiotRefreshGateway {
private readonly logger = new Logger(RiotRefreshGateway.name); private readonly logger = new Logger(RiotRefreshGateway.name);
@SubscribeMessage('subscribe') @SubscribeMessage('subscribe')
public async handleSubscribe( public handleSubscribe(
@ConnectedSocket() socket: Socket, @ConnectedSocket() socket: Socket,
@MessageBody() payload: SubscribePayload, @MessageBody() payload: SubscribePayload,
) { ): void {
const rooms = this.resolveRooms(payload); const rooms = this.resolveRooms(payload);
if (rooms.length === 0) { if (rooms.length === 0) {
socket.emit('error', { message: 'Invalid riot refresh subscription.' }); socket.emit('error', { message: 'Invalid riot refresh subscription.' });
@@ -47,7 +47,7 @@ export class RiotRefreshGateway {
return; return;
} }
await Promise.all(rooms.map((room) => socket.join(room))); void socket.join(rooms);
socket.emit('subscribed', { rooms }); socket.emit('subscribed', { rooms });
} }
@@ -70,7 +70,10 @@ export class RiotRefreshGateway {
if (typeof payload?.puuid === 'string' && payload.puuid.trim()) { if (typeof payload?.puuid === 'string' && payload.puuid.trim()) {
rooms.push(`puuid:${payload.puuid.trim()}`); rooms.push(`puuid:${payload.puuid.trim()}`);
} }
if (typeof payload?.parentJobId === 'string' && payload.parentJobId.trim()) { if (
typeof payload?.parentJobId === 'string' &&
payload.parentJobId.trim()
) {
rooms.push(`parent:${payload.parentJobId.trim()}`); rooms.push(`parent:${payload.parentJobId.trim()}`);
} }
return rooms; return rooms;
@@ -198,8 +198,7 @@ describe('RiotAccountEnrichmentService', () => {
masteryService, masteryService,
recentMatchesService, recentMatchesService,
recentStatsService, recentStatsService,
} = } = makeService({
makeService({
user, user,
summoner: { summoner: {
getByPuuid: jest.fn().mockResolvedValue({ getByPuuid: jest.fn().mockResolvedValue({
@@ -148,14 +148,18 @@ describe('RiotDdragonService', () => {
'ddragon:manifest:v5:ko_KR', 'ddragon:manifest:v5:ko_KR',
expect.objectContaining({ expect.objectContaining({
summonerSpells: expect.objectContaining({ summonerSpells: expect.objectContaining({
'4': expect.objectContaining({ description: '커서 방향으로 순간이동합니다.' }), '4': expect.objectContaining({
description: '커서 방향으로 순간이동합니다.',
}),
}), }),
runesReforged: expect.arrayContaining([ runesReforged: expect.arrayContaining([
expect.objectContaining({ expect.objectContaining({
slots: expect.arrayContaining([ slots: expect.arrayContaining([
expect.objectContaining({ expect.objectContaining({
runes: expect.arrayContaining([ runes: expect.arrayContaining([
expect.objectContaining({ longDesc: expect.stringContaining('기본 공격') }), expect.objectContaining({
longDesc: expect.stringContaining('기본 공격'),
}),
]), ]),
}), }),
]), ]),
@@ -114,7 +114,9 @@ export class RiotDdragonService {
constructor(private readonly redisService: RedisService) {} constructor(private readonly redisService: RedisService) {}
public async getManifest(locale: string = DEFAULT_LOCALE): Promise<DdragonManifest> { public async getManifest(
locale: string = DEFAULT_LOCALE,
): Promise<DdragonManifest> {
const normalizedLocale = normalizeLocale(locale); const normalizedLocale = normalizeLocale(locale);
const cacheKey = manifestCacheKey(normalizedLocale); const cacheKey = manifestCacheKey(normalizedLocale);
@@ -139,12 +141,14 @@ export class RiotDdragonService {
private async buildManifest(locale: string): Promise<DdragonManifest> { private async buildManifest(locale: string): Promise<DdragonManifest> {
const version = await this.fetchLatestVersion(); const version = await this.fetchLatestVersion();
const [champions, summonerSpells, runesReforged, items] = await Promise.all([ const [champions, summonerSpells, runesReforged, items] = await Promise.all(
[
this.fetchChampionMap(version, locale), this.fetchChampionMap(version, locale),
this.fetchSummonerSpellMap(version, locale), this.fetchSummonerSpellMap(version, locale),
this.fetchRuneStyles(version, locale), this.fetchRuneStyles(version, locale),
this.fetchItemMap(version, locale), this.fetchItemMap(version, locale),
]); ],
);
return { return {
version, version,
cdn: DDRAGON_CDN, cdn: DDRAGON_CDN,
@@ -158,7 +162,9 @@ export class RiotDdragonService {
} }
private async fetchLatestVersion(): Promise<string> { private async fetchLatestVersion(): Promise<string> {
const versions = await this.fetchJson<unknown>(`${DDRAGON_BASE}/api/versions.json`); const versions = await this.fetchJson<unknown>(
`${DDRAGON_BASE}/api/versions.json`,
);
if (!Array.isArray(versions) || typeof versions[0] !== 'string') { if (!Array.isArray(versions) || typeof versions[0] !== 'string') {
throw new Error('ddragon versions.json response is malformed.'); throw new Error('ddragon versions.json response is malformed.');
} }
@@ -219,7 +225,9 @@ export class RiotDdragonService {
const url = `${DDRAGON_CDN}/${version}/data/${locale}/runesReforged.json`; const url = `${DDRAGON_CDN}/${version}/data/${locale}/runesReforged.json`;
const payload = await this.fetchJson<unknown>(url); const payload = await this.fetchJson<unknown>(url);
if (!Array.isArray(payload)) { if (!Array.isArray(payload)) {
throw new Error(`ddragon runesReforged.json response is malformed (${url}).`); throw new Error(
`ddragon runesReforged.json response is malformed (${url}).`,
);
} }
return payload return payload
@@ -229,8 +237,7 @@ export class RiotDdragonService {
key: style.key, key: style.key,
icon: style.icon, icon: style.icon,
name: style.name, name: style.name,
shortDesc: shortDesc: typeof style.shortDesc === 'string' ? style.shortDesc : '',
typeof style.shortDesc === 'string' ? style.shortDesc : '',
longDesc: typeof style.longDesc === 'string' ? style.longDesc : '', longDesc: typeof style.longDesc === 'string' ? style.longDesc : '',
slots: (style.slots ?? []).map((slot) => ({ slots: (style.slots ?? []).map((slot) => ({
runes: (slot.runes ?? []) runes: (slot.runes ?? [])
@@ -290,9 +297,7 @@ export class RiotDdragonService {
signal: controller.signal, signal: controller.signal,
}); });
if (!response.ok) { if (!response.ok) {
throw new Error( throw new Error(`ddragon request failed (${response.status}): ${url}`);
`ddragon request failed (${response.status}): ${url}`,
);
} }
return (await response.json()) as T; return (await response.json()) as T;
} catch (err) { } catch (err) {
@@ -1,9 +1,6 @@
import { Injectable } from '@nestjs/common'; import { Injectable } from '@nestjs/common';
import { RiotClientService } from './riot.client.service'; import { RiotClientService } from './riot.client.service';
import { import { RiotLeagueEntryDto, RiotPlatformLookupOptions } from './riot.types';
RiotLeagueEntryDto,
RiotPlatformLookupOptions,
} from './riot.types';
@Injectable() @Injectable()
export class RiotLeagueService { export class RiotLeagueService {
@@ -98,9 +98,7 @@ function validateMatchIdsLookupOptions(
assertOptionalNonNegativeInteger(options.endTime, 'endTime'); assertOptionalNonNegativeInteger(options.endTime, 'endTime');
if (options.type !== undefined && !RIOT_MATCH_TYPES.includes(options.type)) { if (options.type !== undefined && !RIOT_MATCH_TYPES.includes(options.type)) {
throw new RangeError( throw new RangeError(`type must be one of: ${RIOT_MATCH_TYPES.join(', ')}`);
`type must be one of: ${RIOT_MATCH_TYPES.join(', ')}`,
);
} }
if ( if (
@@ -278,7 +276,9 @@ function parseTimelineParticipant(
index: number, index: number,
): RiotMatchTimelineParticipantDto { ): RiotMatchTimelineParticipantDto {
if (!isRecord(value)) { if (!isRecord(value)) {
throw new TypeError(`timeline.info.participants[${index}] must be an object.`); throw new TypeError(
`timeline.info.participants[${index}] must be an object.`,
);
} }
return { return {
@@ -287,7 +287,10 @@ function parseTimelineParticipant(
value.participantId, value.participantId,
`timeline.info.participants[${index}].participantId`, `timeline.info.participants[${index}].participantId`,
), ),
puuid: requireString(value.puuid, `timeline.info.participants[${index}].puuid`), puuid: requireString(
value.puuid,
`timeline.info.participants[${index}].puuid`,
),
}; };
} }
@@ -589,7 +592,10 @@ function parseParticipant(
}; };
} }
function parsePerks(value: unknown, participantIndex: number): RiotMatchPerksDto { function parsePerks(
value: unknown,
participantIndex: number,
): RiotMatchPerksDto {
if (!isRecord(value)) { if (!isRecord(value)) {
throw new TypeError( throw new TypeError(
`participants[${participantIndex}].perks must be an object.`, `participants[${participantIndex}].perks must be an object.`,
@@ -732,7 +738,9 @@ function parseBan(
banIndex: number, banIndex: number,
): RiotMatchBanDto { ): RiotMatchBanDto {
if (!isRecord(value)) { if (!isRecord(value)) {
throw new TypeError(`teams[${teamIndex}].bans[${banIndex}] must be an object.`); throw new TypeError(
`teams[${teamIndex}].bans[${banIndex}] must be an object.`,
);
} }
return { return {
@@ -781,7 +789,9 @@ function parseObjective(
key: keyof RiotMatchObjectivesDto, key: keyof RiotMatchObjectivesDto,
): RiotMatchObjectiveDto { ): RiotMatchObjectiveDto {
if (!isRecord(value)) { if (!isRecord(value)) {
throw new TypeError(`teams[${teamIndex}].objectives.${key} must be an object.`); throw new TypeError(
`teams[${teamIndex}].objectives.${key} must be an object.`,
);
} }
return { return {
@@ -84,5 +84,10 @@ export function isRiotQueueGroup(value: string): value is RiotQueueGroup {
} }
export function isRiotRankFilter(value: string): value is RiotRankFilter { export function isRiotRankFilter(value: string): value is RiotRankFilter {
return value === 'all' || value === 'solo' || value === 'flex' || value === 'normal'; return (
value === 'all' ||
value === 'solo' ||
value === 'flex' ||
value === 'normal'
);
} }
@@ -100,7 +100,7 @@ export class RiotRecentMatchesService {
} catch (error: unknown) { } catch (error: unknown) {
this.logger.warn( this.logger.warn(
`Skipping Riot match ${matchId} while syncing ${params.puuid}: ${ `Skipping Riot match ${matchId} while syncing ${params.puuid}: ${
error instanceof Error ? error.message : error error instanceof Error ? error.message : String(error)
}`, }`,
); );
} }
@@ -150,13 +150,16 @@ async function runWithConcurrency<T>(
if (items.length === 0) return; if (items.length === 0) return;
const queue = [...items]; const queue = [...items];
const runners = Array.from({ length: Math.min(concurrency, queue.length) }, async () => { const runners = Array.from(
{ length: Math.min(concurrency, queue.length) },
async () => {
while (queue.length > 0) { while (queue.length > 0) {
const item = queue.shift(); const item = queue.shift();
if (item === undefined) return; if (item === undefined) return;
await worker(item); await worker(item);
} }
}); },
);
await Promise.all(runners); await Promise.all(runners);
} }
@@ -44,17 +44,29 @@ export class RiotRecentStatsService {
); );
for (const match of filteredMatches) { for (const match of filteredMatches) {
const participant = match.info.participants.find((entry) => entry.puuid === puuid); const participant = match.info.participants.find(
(entry) => entry.puuid === puuid,
);
if (!participant) continue; if (!participant) continue;
accumulateAggregate(overall, participant, match.info.gameCreation, match.info.gameDuration); accumulateAggregate(
overall,
participant,
match.info.gameCreation,
match.info.gameDuration,
);
const lane = resolveLane(participant); const lane = resolveLane(participant);
if (!lane) continue; if (!lane) continue;
const aggregate = laneAggregates.get(lane); const aggregate = laneAggregates.get(lane);
if (!aggregate) continue; if (!aggregate) continue;
accumulateAggregate(aggregate, participant, match.info.gameCreation, match.info.gameDuration); accumulateAggregate(
aggregate,
participant,
match.info.gameCreation,
match.info.gameDuration,
);
} }
if (overall.games === 0) { if (overall.games === 0) {
@@ -133,7 +145,8 @@ function finalizeAggregate(aggregate: Aggregate): RiotLaneStats {
const mostPlayedChampionIds = [...aggregate.championCounts.entries()] const mostPlayedChampionIds = [...aggregate.championCounts.entries()]
.sort((left, right) => { .sort((left, right) => {
if (right[1] !== left[1]) return right[1] - left[1]; if (right[1] !== left[1]) return right[1] - left[1];
const rightLastPlayed = aggregate.lastPlayedAtByChampion.get(right[0]) ?? 0; const rightLastPlayed =
aggregate.lastPlayedAtByChampion.get(right[0]) ?? 0;
const leftLastPlayed = aggregate.lastPlayedAtByChampion.get(left[0]) ?? 0; const leftLastPlayed = aggregate.lastPlayedAtByChampion.get(left[0]) ?? 0;
if (rightLastPlayed !== leftLastPlayed) { if (rightLastPlayed !== leftLastPlayed) {
return rightLastPlayed - leftLastPlayed; return rightLastPlayed - leftLastPlayed;
@@ -1,9 +1,6 @@
import { Injectable } from '@nestjs/common'; import { Injectable } from '@nestjs/common';
import { RiotClientService } from './riot.client.service'; import { RiotClientService } from './riot.client.service';
import { import { RiotPlatformLookupOptions, RiotSummonerDto } from './riot.types';
RiotPlatformLookupOptions,
RiotSummonerDto,
} from './riot.types';
@Injectable() @Injectable()
export class RiotSummonerService { export class RiotSummonerService {
@@ -17,8 +17,12 @@ describe('RiotWebhookController', () => {
}); });
it('logs the incoming webhook payload and returns an acknowledgement', () => { it('logs the incoming webhook payload and returns an acknowledgement', () => {
const logSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined); const logSpy = jest
const dirSpy = jest.spyOn(console, 'dir').mockImplementation(() => undefined); .spyOn(console, 'log')
.mockImplementation(() => undefined);
const dirSpy = jest
.spyOn(console, 'dir')
.mockImplementation(() => undefined);
const request = { const request = {
method: 'POST', method: 'POST',
originalUrl: '/riot/webhooks/tournament', originalUrl: '/riot/webhooks/tournament',
Loaded 100 of 127 files, more files were not shown because too many files have changed in this diff. Show more