style(api): apply prettier formatting

This commit is contained in:
dahyeon committed 2026-07-24 21:42:28 -07:00
1 parent 80fef25af3
commit 96fede9fe5
75 files changed
+955 -674

No files matched your search

@@ -79,7 +79,9 @@ describe('AuctionDeadlineScheduler', () => {
.spyOn(scheduler, 'processDueBidRoundDeadlines')
.mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 });
await (scheduler as unknown as { safeTick: () => Promise<void> }).safeTick();
await (
scheduler as unknown as { safeTick: () => Promise<void> }
).safeTick();
const leaderLockToken = redis.acquireTokenLock.mock.calls[0]?.[1];
expect(redis.acquireTokenLock).toHaveBeenCalledWith(
@@ -100,7 +102,9 @@ describe('AuctionDeadlineScheduler', () => {
.spyOn(scheduler, 'processDueBidRoundDeadlines')
.mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 });
await (scheduler as unknown as { safeTick: () => Promise<void> }).safeTick();
await (
scheduler as unknown as { safeTick: () => Promise<void> }
).safeTick();
expect(processDueBidRoundDeadlinesSpy).not.toHaveBeenCalled();
expect(redis.releaseTokenLock).not.toHaveBeenCalled();
@@ -129,10 +133,12 @@ describe('AuctionDeadlineScheduler', () => {
it('prepares and completes due auction deadlines', async () => {
const matchId = '665f2f01f1f1f1f1f1f1f1f1';
const completedState = { phase: 'passed', revision: 3 };
const { auctionService, eventBus, redisCommand, scheduler } = makeScheduler({
dueReply: [matchId],
completedState,
});
const { auctionService, eventBus, redisCommand, scheduler } = makeScheduler(
{
dueReply: [matchId],
completedState,
},
);
await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({
completed: 1,
@@ -149,7 +155,10 @@ describe('AuctionDeadlineScheduler', () => {
expect(auctionService.completePreparedExpiry).toHaveBeenCalledTimes(1);
// 만료 확정 결과는 즉시 1차 broadcast돼야 한다(클라가 입찰 라운드에 멈춰
// 후속 액션에서 CONFLICT가 반복되는 것을 막는 핵심 동작).
expect(eventBus.broadcastState).toHaveBeenCalledWith(matchId, completedState);
expect(eventBus.broadcastState).toHaveBeenCalledWith(
matchId,
completedState,
);
});
it('skips noop expiry preparations', async () => {
@@ -189,10 +198,7 @@ describe('AuctionDeadlineScheduler', () => {
});
it('continues processing later deadline items after one item fails', async () => {
const matchIds = [
'665f2f01f1f1f1f1f1f1f1f1',
'665f2f02f1f1f1f1f1f1f1f1',
];
const matchIds = ['665f2f01f1f1f1f1f1f1f1f1', '665f2f02f1f1f1f1f1f1f1f1'];
const { auctionService, redisCommand, scheduler } = makeScheduler({
dueReply: matchIds,
});
@@ -101,15 +101,17 @@ export class AuctionDeadlineScheduler implements OnModuleInit, OnModuleDestroy {
currentRedisTimestampMS: number,
batchLimit: number,
): Promise<string[]> {
const reply = await this.auctionRedisService.raw().sendCommand([
'ZRANGEBYSCORE',
BID_ROUND_DEADLINE_QUEUE_KEY,
'-inf',
String(currentRedisTimestampMS),
'LIMIT',
'0',
String(batchLimit),
]);
const reply = await this.auctionRedisService
.raw()
.sendCommand([
'ZRANGEBYSCORE',
BID_ROUND_DEADLINE_QUEUE_KEY,
'-inf',
String(currentRedisTimestampMS),
'LIMIT',
'0',
String(batchLimit),
]);
return Array.isArray(reply) ? reply.map(String) : [];
}
@@ -177,11 +179,11 @@ export class AuctionDeadlineScheduler implements OnModuleInit, OnModuleDestroy {
return { completed, prepared, skipped };
}
private async removeBidRoundDeadlineQueueEntry(matchId: string): Promise<void> {
await this.auctionRedisService.raw().sendCommand([
'ZREM',
BID_ROUND_DEADLINE_QUEUE_KEY,
matchId,
]);
private async removeBidRoundDeadlineQueueEntry(
matchId: string,
): Promise<void> {
await this.auctionRedisService
.raw()
.sendCommand(['ZREM', BID_ROUND_DEADLINE_QUEUE_KEY, matchId]);
}
}
@@ -20,9 +20,8 @@ export class AuctionEventBusService {
}
public broadcastState(matchId: string, state: AuctionStateResponse): void {
this.auctionNamespace?.to(matchId).emit(
'state',
serializeRealtimeAuction(state),
);
this.auctionNamespace
?.to(matchId)
.emit('state', serializeRealtimeAuction(state));
}
}
@@ -22,7 +22,10 @@ describe('resolveAuctionRejectionReason', () => {
it('maps known BadRequest messages without a structured code', () => {
expect(
resolveAuctionRejectionReason(undefined, 'Cannot advance from current phase.'),
resolveAuctionRejectionReason(
undefined,
'Cannot advance from current phase.',
),
).toBe(
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE,
);
@@ -41,22 +41,24 @@ export class AuctionSideEffectService {
matchSideEffectStatus: AuctionMatchSideEffectStatus;
}): Promise<boolean> {
const keys = buildAuctionRedisKeys(params.matchId);
const result = await this.auctionRedisService.raw().sendCommand([
'EVAL',
[
"if redis.call('HGET', KEYS[1], 'auctionLifecycleId') ~= ARGV[1] then return 0 end",
"local currentRevision = tonumber(redis.call('HGET', KEYS[1], 'matchSideEffectRevision') or '-1')",
'local nextRevision = tonumber(ARGV[2])',
'if currentRevision >= nextRevision then return 0 end',
"redis.call('HSET', KEYS[1], 'matchSideEffectRevision', ARGV[2], 'matchSideEffectStatus', ARGV[3])",
'return 1',
].join('\n'),
'1',
keys.liveStateKey,
params.auctionLifecycleId,
String(params.matchSideEffectRevision),
params.matchSideEffectStatus,
]);
const result = await this.auctionRedisService
.raw()
.sendCommand([
'EVAL',
[
"if redis.call('HGET', KEYS[1], 'auctionLifecycleId') ~= ARGV[1] then return 0 end",
"local currentRevision = tonumber(redis.call('HGET', KEYS[1], 'matchSideEffectRevision') or '-1')",
'local nextRevision = tonumber(ARGV[2])',
'if currentRevision >= nextRevision then return 0 end',
"redis.call('HSET', KEYS[1], 'matchSideEffectRevision', ARGV[2], 'matchSideEffectStatus', ARGV[3])",
'return 1',
].join('\n'),
'1',
keys.liveStateKey,
params.auctionLifecycleId,
String(params.matchSideEffectRevision),
params.matchSideEffectStatus,
]);
return Number(result) === 1;
}
}
@@ -78,8 +80,7 @@ export function canAcquireSideEffectLease(
if (state.state === 'pending' || state.state === 'failed') return true;
if (state.state !== 'processing') return false;
return (
(state.processingLeaseExpiresAtTimestampMS ?? 0) <=
currentRedisTimestampMS
(state.processingLeaseExpiresAtTimestampMS ?? 0) <= currentRedisTimestampMS
);
}
@@ -59,8 +59,7 @@ export class AuctionController {
initialTeamBidPointAmount: c.initialTeamBidPointAmount,
})),
initialTeamBidPointAmount: body.initialTeamBidPointAmount ?? 1000,
maximumBidRoundDurationSeconds:
body.maximumBidRoundDurationSeconds ?? 30,
maximumBidRoundDurationSeconds: body.maximumBidRoundDurationSeconds ?? 30,
bidRoundExtensionSeconds: body.bidRoundExtensionSeconds ?? 5,
topTierAuctionPriorityThreshold:
body.topTierAuctionPriorityThreshold ?? 'NONE',
+18 -12
View File
@@ -92,9 +92,7 @@ const BID_RATE_LIMIT_REJECTION_MESSAGE =
allowedHeaders: ['Authorization', 'Content-Type', 'X-Auth-User-Id'],
},
})
export class AuctionGateway
implements OnGatewayConnection, OnGatewayInit
{
export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
@WebSocketServer()
private server!: Namespace;
@@ -205,7 +203,9 @@ export class AuctionGateway
ack?.({
...(bidDelta
? {}
: { state: this.serializeAuction(bidResult as AuctionStateResponse) }),
: {
state: this.serializeAuction(bidResult as AuctionStateResponse),
}),
ok: true,
bidRequestId,
bidDelta: broadcastBidDelta,
@@ -417,8 +417,9 @@ export class AuctionGateway
private consumeBidRateLimit(socket: Socket): boolean {
const currentTimestampMS = Date.now();
const previousState = socket.data
.auctionBidRateLimit as BidRateLimitState | undefined;
const previousState = socket.data.auctionBidRateLimit as
| BidRateLimitState
| undefined;
if (
!previousState ||
currentTimestampMS - previousState.windowStartedAtTimestampMS >=
@@ -633,7 +634,9 @@ export class AuctionGateway
typeof errorPayload.code === 'string' ? errorPayload.code : undefined,
errorPayload.message,
);
const resyncRecommended = isAuctionResyncRecommended(auctionRejectionReason);
const resyncRecommended = isAuctionResyncRecommended(
auctionRejectionReason,
);
const state = resyncRecommended
? await this.fetchSerializedAuctionState(matchId)
: undefined;
@@ -688,7 +691,9 @@ export class AuctionGateway
return {
code: error instanceof Error ? error.message : 'UNKNOWN',
message:
error instanceof Error ? error.message : 'Unexpected auction gateway error.',
error instanceof Error
? error.message
: 'Unexpected auction gateway error.',
};
}
@@ -724,7 +729,10 @@ export class AuctionGateway
auction: AuctionStateResponse,
bidRequestId?: string,
): Record<string, unknown> | null {
const serialized = this.serializeAuction(auction) as Record<string, unknown>;
const serialized = this.serializeAuction(auction) as Record<
string,
unknown
>;
const revision = Number(serialized.revision);
const currentHighestBidPointAmount = Number(
serialized.currentHighestBidPointAmount ?? serialized.currentBid,
@@ -775,9 +783,7 @@ export class AuctionGateway
};
}
private isBidDeltaResponse(
value: unknown,
): value is AuctionBidDeltaResponse {
private isBidDeltaResponse(value: unknown): value is AuctionBidDeltaResponse {
return (
typeof value === 'object' &&
value !== null &&
@@ -210,21 +210,25 @@ describe('AuctionRedisCommandService', () => {
it('parses apply transition replay and rejected replies', async () => {
await expect(
makeService(['REPLAY', 'APPLIED', 'transition-1', '2100'])
.service.applyTransition('match-1', {
afterAuctionStructureStateJson: '{}',
auctionHistorySequence: 5,
auctionLifecycleId: 'life-1',
auctionStateTransitionId: 'transition-1',
broadcastStateRevision: 11,
deadline: { mode: 'none' },
durabilityPayloadJson: '{}',
expectedPhase: 'sold',
expectedRevision: 10,
liveStatePatch: {},
matchId: 'match-1',
shouldBroadcastState: false,
}),
makeService([
'REPLAY',
'APPLIED',
'transition-1',
'2100',
]).service.applyTransition('match-1', {
afterAuctionStructureStateJson: '{}',
auctionHistorySequence: 5,
auctionLifecycleId: 'life-1',
auctionStateTransitionId: 'transition-1',
broadcastStateRevision: 11,
deadline: { mode: 'none' },
durabilityPayloadJson: '{}',
expectedPhase: 'sold',
expectedRevision: 10,
liveStatePatch: {},
matchId: 'match-1',
shouldBroadcastState: false,
}),
).resolves.toEqual({
auctionStateTransitionId: 'transition-1',
currentServerTimestampMS: 2100,
@@ -233,21 +237,25 @@ describe('AuctionRedisCommandService', () => {
});
await expect(
makeService(['REJECTED', 'CONFLICT', 'transition-1', '2200'])
.service.applyTransition('match-1', {
afterAuctionStructureStateJson: '{}',
auctionHistorySequence: 5,
auctionLifecycleId: 'life-1',
auctionStateTransitionId: 'transition-1',
broadcastStateRevision: 11,
deadline: { mode: 'none' },
durabilityPayloadJson: '{}',
expectedPhase: 'sold',
expectedRevision: 10,
liveStatePatch: {},
matchId: 'match-1',
shouldBroadcastState: false,
}),
makeService([
'REJECTED',
'CONFLICT',
'transition-1',
'2200',
]).service.applyTransition('match-1', {
afterAuctionStructureStateJson: '{}',
auctionHistorySequence: 5,
auctionLifecycleId: 'life-1',
auctionStateTransitionId: 'transition-1',
broadcastStateRevision: 11,
deadline: { mode: 'none' },
durabilityPayloadJson: '{}',
expectedPhase: 'sold',
expectedRevision: 10,
liveStatePatch: {},
matchId: 'match-1',
shouldBroadcastState: false,
}),
).resolves.toEqual({
auctionStateTransitionId: 'transition-1',
code: 'CONFLICT',
@@ -288,12 +296,17 @@ describe('AuctionRedisCommandService', () => {
it('parses expire prepare replay and noop replies', async () => {
await expect(
makeService(['REPLAY', 'passed', 'expire-1', '12', '3100'])
.service.expirePrepare('match-1', {
auctionStateTransitionId: 'expire-1',
bidRoundExpiryRetryDelayMS: 3000,
matchId: 'match-1',
}),
makeService([
'REPLAY',
'passed',
'expire-1',
'12',
'3100',
]).service.expirePrepare('match-1', {
auctionStateTransitionId: 'expire-1',
bidRoundExpiryRetryDelayMS: 3000,
matchId: 'match-1',
}),
).resolves.toMatchObject({
auctionStateTransitionId: 'expire-1',
bidRoundExpiryDecision: 'passed',
@@ -360,16 +373,19 @@ describe('AuctionRedisCommandService', () => {
});
await expect(
makeService(['REJECTED', 'INVALID_PATCH_ARITY', '4200'])
.service.hydrateState('match-1', {
auctionHistorySequence: 3,
auctionLifecycleId: 'life-1',
maximumBidRoundDurationSeconds: 30,
matchId: 'match-1',
phase: 'presenting',
revision: 6,
structureStateJson: '{}',
}),
makeService([
'REJECTED',
'INVALID_PATCH_ARITY',
'4200',
]).service.hydrateState('match-1', {
auctionHistorySequence: 3,
auctionLifecycleId: 'life-1',
maximumBidRoundDurationSeconds: 30,
matchId: 'match-1',
phase: 'presenting',
revision: 6,
structureStateJson: '{}',
}),
).resolves.toEqual({
code: 'INVALID_PATCH_ARITY',
currentServerTimestampMS: 4200,
@@ -85,7 +85,9 @@ export function stringifyAuctionRedisStructureState(
return JSON.stringify(buildAuctionRedisStructureState(input));
}
function countAuctionTeamMembersIncludingCaptain(team: RedisAuctionTeam): number {
function countAuctionTeamMembersIncludingCaptain(
team: RedisAuctionTeam,
): number {
const userIds = new Set<string>([team.captainUserId.toString()]);
for (const member of team.members) {
userIds.add(member.userId.toString());
@@ -1,7 +1,10 @@
import { AuctionRedisService } from './auction-redis.service';
import { AuctionRedisStateReaderService } from './auction-redis-state-reader.service';
function makeService(commandReplies: unknown[], currentServerTimestampMS = 1000) {
function makeService(
commandReplies: unknown[],
currentServerTimestampMS = 1000,
) {
const sendCommand = jest
.fn()
.mockImplementation(() => Promise.resolve(commandReplies.shift()));
@@ -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',
auctionTeams: [],
phase: 'presenting',
@@ -181,7 +186,6 @@ describe('AuctionRedisStateReaderService', () => {
});
});
it('returns null when live or structure state is absent', async () => {
await expect(
makeService([[], '{"auctionTeams":[]}', []]).service.readAuctionStateView(
@@ -42,12 +42,14 @@ export class AuctionRedisStateReaderService {
matchId: string,
): Promise<AuctionRedisLiveStateIdentity | null> {
const keys = buildAuctionRedisKeys(matchId);
const reply = await this.auctionRedisService.raw().sendCommand([
'HMGET',
keys.liveStateKey,
'auctionLifecycleId',
'revision',
]);
const reply = await this.auctionRedisService
.raw()
.sendCommand([
'HMGET',
keys.liveStateKey,
'auctionLifecycleId',
'revision',
]);
if (!Array.isArray(reply)) return null;
const auctionLifecycleId =
typeof reply[0] === 'string' && reply[0] ? reply[0] : undefined;
@@ -68,14 +70,16 @@ export class AuctionRedisStateReaderService {
): Promise<AuctionRedisBidContext | null> {
const keys = buildAuctionRedisKeys(matchId);
const bidderTeamCaptainUserIdField = `team:${bidderTeamIndex}:captainUserId`;
const liveReply = await this.auctionRedisService.raw().sendCommand([
'HMGET',
keys.liveStateKey,
'phase',
'auctionLifecycleId',
'currentBidRoundPlayerUserId',
bidderTeamCaptainUserIdField,
]);
const liveReply = await this.auctionRedisService
.raw()
.sendCommand([
'HMGET',
keys.liveStateKey,
'phase',
'auctionLifecycleId',
'currentBidRoundPlayerUserId',
bidderTeamCaptainUserIdField,
]);
if (!Array.isArray(liveReply)) return null;
const phase = stringValue(liveReply[0]);
@@ -102,18 +106,23 @@ export class AuctionRedisStateReaderService {
options: AuctionRedisStateViewReadOptions = {},
): Promise<Record<string, unknown> | null> {
const keys = buildAuctionRedisKeys(matchId);
const [currentServerTimestampMS, liveReply, structureStateJson, bidEntries] =
await Promise.all([
this.auctionRedisService.getCurrentRedisTimestampMS(),
this.auctionRedisService.raw().sendCommand(['HGETALL', keys.liveStateKey]),
this.auctionRedisService.raw().sendCommand(['GET', keys.structureStateKey]),
this.auctionRedisService.raw().sendCommand([
'LRANGE',
keys.bidHistoryKey,
'0',
'-1',
]),
]);
const [
currentServerTimestampMS,
liveReply,
structureStateJson,
bidEntries,
] = await Promise.all([
this.auctionRedisService.getCurrentRedisTimestampMS(),
this.auctionRedisService
.raw()
.sendCommand(['HGETALL', keys.liveStateKey]),
this.auctionRedisService
.raw()
.sendCommand(['GET', keys.structureStateKey]),
this.auctionRedisService
.raw()
.sendCommand(['LRANGE', keys.bidHistoryKey, '0', '-1']),
]);
const liveState = parseHashReply(liveReply, {
includeInternalLiveStateFields:
@@ -210,7 +219,10 @@ function parseHashEntries(
): Record<string, unknown> {
const result: Record<string, unknown> = {};
for (const [field, rawValue] of entries) {
if (!options.includeInternalLiveStateFields && isInternalLiveStateField(field)) {
if (
!options.includeInternalLiveStateFields &&
isInternalLiveStateField(field)
) {
continue;
}
const value = String(rawValue);
@@ -91,9 +91,7 @@ describe('auction apply transition redis script contract', () => {
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
'shouldBroadcastState',
);
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
"redis.call('SADD'",
);
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain("redis.call('SADD'");
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
"redis.call('HINCRBY'",
);
@@ -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('HINCRBY'");
expect(AUCTION_BID_SCRIPT.lua).toContain('BID_REQUEST_RESULT_LIMIT');
expect(AUCTION_BID_SCRIPT.lua).toContain(
'currentHighestBidPointAmount',
);
expect(AUCTION_BID_SCRIPT.lua).toContain('currentHighestBidPointAmount');
expect(AUCTION_BID_SCRIPT.lua).not.toContain('cjson.decode');
});
});
@@ -3,9 +3,11 @@ import { buildAuctionRedisKeys } from './auction-redis.keys';
describe('auction redis keys', () => {
it('builds lifecycle-safe key names from match id', () => {
expect(buildAuctionRedisKeys('match-1')).toMatchObject({
actionRequestResultOrderKey: 'auction:match-1:auctionActionRequestResultOrder',
actionRequestResultOrderKey:
'auction:match-1:auctionActionRequestResultOrder',
actionRequestResultsKey: 'auction:match-1:auctionActionRequestResults',
appliedTransitionIdsKey: 'auction:match-1:appliedAuctionStateTransitionIds',
appliedTransitionIdsKey:
'auction:match-1:appliedAuctionStateTransitionIds',
bidHistoryKey: 'auction:match-1:auctionBidHistory',
bidRequestResultOrderKey: 'auction:match-1:bidRequestResultOrder',
bidRequestResultsKey: 'auction:match-1:bidRequestResults',
@@ -15,7 +15,9 @@ function makeService(sendCommand: jest.Mock) {
describe('AuctionRedisService', () => {
it('uses Redis TIME as the timestamp source', async () => {
const service = makeService(jest.fn().mockResolvedValue(['1781700000', '123000']));
const service = makeService(
jest.fn().mockResolvedValue(['1781700000', '123000']),
);
await expect(service.getCurrentRedisTimestampMS()).resolves.toBe(
1_781_700_000_123,
@@ -22,7 +22,11 @@ export class AuctionRedisNoscriptError extends Error {
function isNoscriptError(error: unknown): boolean {
if (error instanceof AuctionRedisNoscriptError) return true;
const message =
error instanceof Error ? error.message : typeof error === 'string' ? error : '';
error instanceof Error
? error.message
: typeof error === 'string'
? error
: '';
return /\bNOSCRIPT\b/iu.test(message);
}
@@ -100,9 +100,7 @@ describe('auction redis state assembly', () => {
'1000',
]);
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain("redis.call('TIME')");
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain(
'INVALID_PATCH_ARITY',
);
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain('INVALID_PATCH_ARITY');
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain(
'mongoRevision > redisRevision',
);
+1 -4
View File
@@ -1,8 +1,5 @@
import type { JWTHeaderParameters, JWTPayload } from 'jose';
import type {
IdentityDocument,
UserDocument,
} from '../global/database/schema';
import type { IdentityDocument, UserDocument } from '../global/database/schema';
import type { IdentityProviderName } from './jwt.service';
declare module 'express' {
+1 -4
View File
@@ -2,10 +2,7 @@ import { Injectable } from '@nestjs/common';
import type { Request } from 'express';
import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service';
import {
IdentityDocument,
UserDocument,
} from '../global/database/schema';
import { IdentityDocument, UserDocument } from '../global/database/schema';
import { SecretService } from '../global/secret/secret.service';
import './auth-request';
+2 -1
View File
@@ -84,7 +84,8 @@ export class JwtAuthGuard implements CanActivate {
}
throw new Error(`Unknown issuer: ${iss}`);
} catch (err) {
const message = err instanceof Error ? err.message : 'Unable to decode token';
const message =
err instanceof Error ? err.message : 'Unable to decode token';
throw new UnauthorizedException(message);
}
}
@@ -7,9 +7,10 @@ import {
import mongoose from 'mongoose';
@Injectable()
export class ParseObjectIdPipe
implements PipeTransform<string, mongoose.Types.ObjectId>
{
export class ParseObjectIdPipe implements PipeTransform<
string,
mongoose.Types.ObjectId
> {
public transform(
value: string,
metadata: ArgumentMetadata,
@@ -23,7 +23,14 @@ export class CommunityStatsController {
) {
return this.communityStatsService.getMatches({
communityId,
filters: this.toFilters({ seasonId, from, to, championId, cursor, limit }),
filters: this.toFilters({
seasonId,
from,
to,
championId,
cursor,
limit,
}),
});
}
@@ -85,7 +92,14 @@ export class CommunityStatsController {
return this.communityStatsService.getUserInternalHistory({
communityId,
userId,
filters: this.toFilters({ seasonId, from, to, championId, cursor, limit }),
filters: this.toFilters({
seasonId,
from,
to,
championId,
cursor,
limit,
}),
});
}
@@ -7,7 +7,10 @@ import type {
RiotLane,
TeamSide,
} from '../global/database/schema';
import type { RecentMatchView, HistorySeasonDto } from '../match-history/match-history.types';
import type {
RecentMatchView,
HistorySeasonDto,
} from '../match-history/match-history.types';
export interface CommunityStatsFilters {
seasonId?: string;
@@ -80,7 +83,9 @@ export interface LeaderboardRow {
avgCsPerMin: number;
avgDamageShare: number;
avgVisionScore: number;
byLane: Partial<Record<RiotLane, { games: number; wins: number; kda: number }>>;
byLane: Partial<
Record<RiotLane, { games: number; wins: number; kda: number }>
>;
topChampions: Array<{ championId: number; games: number; winRate: number }>;
}
@@ -227,9 +227,7 @@ export class MatchStatsFragmentBuilder {
participant,
rawParticipant,
buildEvents: rawParticipant
? buildEventsByParticipantId.get(
rawParticipant.participantId,
)
? buildEventsByParticipantId.get(rawParticipant.participantId)
: undefined,
checkpoints: rawParticipant
? checkpointsByParticipantId.get(rawParticipant.participantId)
@@ -420,7 +418,10 @@ export class MatchStatsFragmentBuilder {
private toBuildEventsByParticipantId(
timeline?: RiotMatchTimelineDto,
): Map<number, ParticipantBuildEvents> {
const buildEventsByParticipantId = new Map<number, ParticipantBuildEvents>();
const buildEventsByParticipantId = new Map<
number,
ParticipantBuildEvents
>();
if (!timeline?.info.frames.length) return buildEventsByParticipantId;
const getEvents = (participantId: number): ParticipantBuildEvents => {
@@ -796,15 +797,18 @@ export class MatchStatsFragmentBuilder {
? timelineDragon
: (rawObjectives?.dragon?.kills ?? 0),
inhibitor: rawObjectives?.inhibitor?.kills ?? 0,
baron: (timelineObjectives?.baron ?? 0) > 0
? (timelineObjectives?.baron ?? 0)
: (rawObjectives?.baron?.kills ?? 0),
riftHerald: (timelineObjectives?.riftHerald ?? 0) > 0
? (timelineObjectives?.riftHerald ?? 0)
: (rawObjectives?.riftHerald?.kills ?? 0),
voidGrub: (timelineObjectives?.voidGrub ?? 0) > 0
? (timelineObjectives?.voidGrub ?? 0)
: (rawObjectives?.horde?.kills ?? 0),
baron:
(timelineObjectives?.baron ?? 0) > 0
? (timelineObjectives?.baron ?? 0)
: (rawObjectives?.baron?.kills ?? 0),
riftHerald:
(timelineObjectives?.riftHerald ?? 0) > 0
? (timelineObjectives?.riftHerald ?? 0)
: (rawObjectives?.riftHerald?.kills ?? 0),
voidGrub:
(timelineObjectives?.voidGrub ?? 0) > 0
? (timelineObjectives?.voidGrub ?? 0)
: (rawObjectives?.horde?.kills ?? 0),
elderDragon: hasProjectedDragon ? timelineElder : 0,
};
}
@@ -6,10 +6,7 @@ import {
} from '@nestjs/common';
import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service';
import {
CommunityDocument,
UserDocument,
} from '../global/database/schema';
import { CommunityDocument, UserDocument } from '../global/database/schema';
export interface CreateCommunityInput {
name: string;
@@ -9,7 +9,8 @@ import { DakaoOutboxService } from './dakao-outbox.service';
const SWEEP_INTERVAL_MS = 60 * 1000;
const STALE_OUTBOX_MS = 5 * 60 * 1000;
const SWEEP_LOCK_KEY = 'distributed-lock:dakao-outbox:sweep-stale-publish-leases';
const SWEEP_LOCK_KEY =
'distributed-lock:dakao-outbox:sweep-stale-publish-leases';
const SWEEP_LOCK_EXPIRATION_DURATION_MILLISECONDS = 55_000;
@Injectable()
@@ -78,35 +78,29 @@ export class DakaoOutboxService {
await this.natsService.publishJetStream(params.subject, params.envelope, {
messageId: params.eventId,
});
await OutboxModel.updateOne(
updateFilter,
{
$set: {
state: 'published',
publishedAt: new Date(),
},
$inc: { publishAttempts: 1 },
$unset: {
lastPublishError: '',
publishLeaseOwnerIdentifier: '',
publishLeaseExpiresAt: '',
},
await OutboxModel.updateOne(updateFilter, {
$set: {
state: 'published',
publishedAt: new Date(),
},
).exec();
$inc: { publishAttempts: 1 },
$unset: {
lastPublishError: '',
publishLeaseOwnerIdentifier: '',
publishLeaseExpiresAt: '',
},
}).exec();
} catch (err) {
await OutboxModel.updateOne(
updateFilter,
{
$inc: { publishAttempts: 1 },
$set: {
lastPublishError: (err as Error)?.message ?? String(err),
},
$unset: {
publishLeaseOwnerIdentifier: '',
publishLeaseExpiresAt: '',
},
await OutboxModel.updateOne(updateFilter, {
$inc: { publishAttempts: 1 },
$set: {
lastPublishError: (err as Error)?.message ?? String(err),
},
).exec();
$unset: {
publishLeaseOwnerIdentifier: '',
publishLeaseExpiresAt: '',
},
}).exec();
this.logger.error(
`Failed to publish Dakao outbox eventId=${params.eventId}: ${
(err as Error)?.stack ?? err
@@ -104,9 +104,11 @@ describe('MatchCancelHandler', () => {
const handler = makeHandler({
matchService: {
cancelJoin,
list: jest.fn().mockResolvedValue([
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
]),
list: jest
.fn()
.mockResolvedValue([
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
]),
} as Partial<MatchService>,
dakaoUserService: {
findUserByKakaoTalkId,
@@ -230,9 +230,11 @@ describe('MatchJoinHandler', () => {
const resolveRiotAccount = jest.fn();
const handler = makeHandler({
matchService: {
list: jest.fn().mockResolvedValue([
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
]),
list: jest
.fn()
.mockResolvedValue([
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
]),
join,
} as Partial<MatchService>,
dakaoUserService: {
@@ -282,9 +284,11 @@ describe('MatchJoinHandler', () => {
const join = jest.fn();
const handler = makeHandler({
matchService: {
list: jest.fn().mockResolvedValue([
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
]),
list: jest
.fn()
.mockResolvedValue([
{ _id: matchId, title: '저녁 내전', shortCode: 'AB12' },
]),
join,
} as Partial<MatchService>,
dakaoUserService: {
@@ -44,9 +44,7 @@ export class MatchJoinHandler {
return this.errorReply(params, joinTarget);
}
let resolved:
| { user: UserDocument; riotAccount: RiotAccount }
| string;
let resolved: { user: UserDocument; riotAccount: RiotAccount } | string;
try {
resolved =
joinTarget.gameName && joinTarget.tagLine
@@ -243,10 +241,7 @@ export class MatchJoinHandler {
const gameName = normalizeRiotIdPart(value.slice(splitAt + 1));
if (!matchTitlePrefix || !gameName) continue;
const result = resolveRecruitingMatchReference(
matchTitlePrefix,
matches,
);
const result = resolveRecruitingMatchReference(matchTitlePrefix, matches);
if (result.kind === 'matched') {
return { kind: 'matched', match: result.match, gameName };
}
@@ -19,7 +19,9 @@ describe('auction Redis schema foundation', () => {
expect(AuctionSchema.path('revision')).toBeDefined();
expect(AuctionSchema.path('auctionEngineVersion')).toBeDefined();
expect(AuctionSchema.path('auctionLifecycleId')).toBeDefined();
expect(AuctionSchema.path('lastAppliedAuctionStateTransitionId')).toBeDefined();
expect(
AuctionSchema.path('lastAppliedAuctionStateTransitionId'),
).toBeDefined();
expect(AuctionSchema.path('currentAuctionHistorySequence')).toBeDefined();
expect(AuctionSchema.path('startAuctionRequestId')).toBeDefined();
expect(AuctionSchema.path('startAuctionStateTransitionId')).toBeDefined();
@@ -36,46 +38,75 @@ describe('auction Redis schema foundation', () => {
expect(AuctionSchema.path('auctionBidHistory')).toBeDefined();
expect(AuctionSchema.path('currentHighestBidPointAmount')).toBeDefined();
expect(AuctionSchema.path('currentHighestBidderTeamIndex')).toBeDefined();
expect(AuctionSchema.path('currentBidRoundDeadlineTimestampMS')).toBeDefined();
expect(
AuctionSchema.path('currentBidRoundDeadlineTimestampMS'),
).toBeDefined();
expect(AuctionSchema.path('maximumBidRoundDurationSeconds')).toBeDefined();
expect(AuctionSchema.path('bidRoundExtensionSeconds')).toBeDefined();
expect(AuctionSchema.path('initialTeamBidPointAmount')).toBeDefined();
expect(AuctionSchema.path('topTierAuctionPriorityThreshold')).toBeDefined();
expect(AuctionSchema.path('manualTopTierAuctionPriorityUserIds')).toBeDefined();
expect(
AuctionSchema.path('manualTopTierAuctionPriorityUserIds'),
).toBeDefined();
expect(AuctionSchema.path('auctionStartedAtTimestampMS')).toBeDefined();
expect(AuctionSchema.path('auctionCompletedAtTimestampMS')).toBeDefined();
});
it('adds history transition fields and reset/undo action enum values', () => {
expect(AuctionHistoryEntrySchema.path('auctionStateTransitionId')).toBeDefined();
expect(
AuctionHistoryEntrySchema.path('auctionStateTransitionId'),
).toBeDefined();
expect(AuctionHistoryEntrySchema.path('auctionLifecycleId')).toBeDefined();
expect(AuctionHistoryEntrySchema.path('revision')).toBeDefined();
expect(AuctionHistoryEntrySchema.path('historyMutation')).toBeDefined();
expect(AuctionHistoryEntrySchema.path('matchSideEffectMutation')).toBeDefined();
expect(
AuctionHistoryEntrySchema.path('matchSideEffectMutation'),
).toBeDefined();
expect(
AuctionHistoryEntrySchema.path<string>('action').options.enum,
).toEqual(
expect.arrayContaining(['start', 'open-bidding', 'bid', 'sold', 'passed', 'next', 'complete', 'reset', 'undo']),
expect.arrayContaining([
'start',
'open-bidding',
'bid',
'sold',
'passed',
'next',
'complete',
'reset',
'undo',
]),
);
});
it('adds unique history indexes for sequence and transition idempotency', () => {
const indexes = AuctionHistoryEntrySchema.indexes();
expect(indexWithKeys(indexes, { auctionId: 1, sequence: 1 })?.[1]).toMatchObject({
expect(
indexWithKeys(indexes, { auctionId: 1, sequence: 1 })?.[1],
).toMatchObject({
unique: true,
});
expect(
indexWithKeys(indexes, { auctionId: 1, auctionStateTransitionId: 1 })?.[1],
indexWithKeys(indexes, {
auctionId: 1,
auctionStateTransitionId: 1,
})?.[1],
).toMatchObject({ unique: true, sparse: true });
});
it('registers auction side effect application model with lease fields and unique idempotency index', () => {
expect(AuctionSideEffectApplicationSchema.path('processingOwnerToken')).toBeDefined();
expect(
AuctionSideEffectApplicationSchema.path('processingLeaseExpiresAtTimestampMS'),
AuctionSideEffectApplicationSchema.path('processingOwnerToken'),
).toBeDefined();
expect(
AuctionSideEffectApplicationSchema.path(
'processingLeaseExpiresAtTimestampMS',
),
).toBeDefined();
expect(
AuctionSideEffectApplicationSchema.path('payloadChecksum'),
).toBeDefined();
expect(AuctionSideEffectApplicationSchema.path('payloadChecksum')).toBeDefined();
const indexes = AuctionSideEffectApplicationSchema.indexes();
expect(
@@ -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;
const set: Record<string, unknown> = {};
let changed = false;
@@ -27,17 +27,21 @@ function createDb(params: {
},
};
},
async bulkWrite(writes: Array<{
updateOne: {
filter: { _id: unknown };
update: {
$set: Record<string, unknown>;
$unset: Record<string, ''>;
async bulkWrite(
writes: Array<{
updateOne: {
filter: { _id: unknown };
update: {
$set: Record<string, unknown>;
$unset: Record<string, ''>;
};
};
};
}>) {
}>,
) {
for (const write of writes) {
const doc = docs.find((item) => item._id === write.updateOne.filter._id);
const doc = docs.find(
(item) => item._id === write.updateOne.filter._id,
);
if (!doc) continue;
Object.assign(doc, write.updateOne.update.$set);
for (const key of Object.keys(write.updateOne.update.$unset)) {
@@ -57,7 +61,10 @@ describe('migrateTeamIndex', () => {
auctions: [
{
_id: 'auction-1',
teams: [{ side: 'blue', groupIndex: 1 }, { side: 'red', groupIndex: 1 }],
teams: [
{ side: 'blue', groupIndex: 1 },
{ side: 'red', groupIndex: 1 },
],
bids: [{ side: 'red', groupIndex: 1, amount: 100 }],
currentBidder: 'red',
currentBidderGroupIndex: 1,
@@ -66,7 +73,10 @@ describe('migrateTeamIndex', () => {
matches: [
{
_id: 'match-1',
teams: [{ side: 'blue', groupIndex: 1 }, { side: 'red', groupIndex: 1 }],
teams: [
{ side: 'blue', groupIndex: 1 },
{ side: 'red', groupIndex: 1 },
],
result: {
winnerSide: 'blue',
blueScore: 1,
@@ -112,7 +122,10 @@ describe('migrateTeamIndex', () => {
currentBidderTeamIndex: 2,
});
expect(collections.match[0]).toMatchObject({
teams: [{ teamIndex: 1, name: '1팀' }, { teamIndex: 2, name: '2팀' }],
teams: [
{ teamIndex: 1, name: '1팀' },
{ teamIndex: 2, name: '2팀' },
],
result: {
winnerTeamIndex: 1,
games: [
@@ -45,8 +45,20 @@ export async function migrateTeamIndex(
changedMatches: 0,
};
await migrateCollection(db.collection('auction'), options.limit, dryRun, stats, 'auction');
await migrateCollection(db.collection('match'), options.limit, dryRun, stats, 'match');
await migrateCollection(
db.collection('auction'),
options.limit,
dryRun,
stats,
'auction',
);
await migrateCollection(
db.collection('match'),
options.limit,
dryRun,
stats,
'match',
);
return stats;
}
@@ -60,7 +72,7 @@ async function migrateCollection(
) {
const cursor = collection.find({}).limit(limit ?? 0);
const writes: Array<{
updateOne: {
updateOne: {
filter: { _id: unknown };
update: { $set: Record<string, unknown>; $unset: Record<string, ''> };
};
@@ -143,7 +155,8 @@ function migrateMatch(doc: AnyDoc) {
const migrated = { ...team };
const teamIndex = readTeamIndex(migrated);
if (teamIndex !== undefined) migrated.teamIndex = teamIndex;
if (!migrated.name && typeof teamIndex === 'number') migrated.name = `${teamIndex}팀`;
if (!migrated.name && typeof teamIndex === 'number')
migrated.name = `${teamIndex}팀`;
if ('side' in migrated || 'groupIndex' in migrated) changed = true;
delete migrated.side;
delete migrated.groupIndex;
@@ -200,7 +213,10 @@ function migrateResult(result: Record<string, unknown>) {
migrated.games = games;
const seriesResults = asArray(result.seriesResults).map((series) => {
if (typeof series.teamAIndex === 'number' && typeof series.teamBIndex === 'number') {
if (
typeof series.teamAIndex === 'number' &&
typeof series.teamBIndex === 'number'
) {
return series;
}
changed = true;
@@ -216,7 +232,9 @@ function migrateResult(result: Record<string, unknown>) {
const teamBIndex = Math.max(legacyBlueTeamIndex, legacyRedTeamIndex);
const blueScore = numberOrDefault(series.blueScore, 0);
const redScore = numberOrDefault(series.redScore, 0);
const winnerSide = isSide(series.winnerSide) ? series.winnerSide : undefined;
const winnerSide = isSide(series.winnerSide)
? series.winnerSide
: undefined;
const winnerTeamIndex =
winnerSide === 'blue'
? legacyBlueTeamIndex
@@ -231,7 +249,8 @@ function migrateResult(result: Record<string, unknown>) {
winnerTeamIndex,
};
});
migrated.seriesResults = seriesResults.length > 0 ? seriesResults : buildSeries(games);
migrated.seriesResults =
seriesResults.length > 0 ? seriesResults : buildSeries(games);
if (typeof migrated.winnerTeamIndex !== 'number') {
const migratedSeriesResults = Array.isArray(migrated.seriesResults)
@@ -244,7 +263,11 @@ function migrateResult(result: Record<string, unknown>) {
: undefined);
}
if ('winnerSide' in migrated || 'blueScore' in migrated || 'redScore' in migrated) {
if (
'winnerSide' in migrated ||
'blueScore' in migrated ||
'redScore' in migrated
) {
changed = true;
}
delete migrated.winnerSide;
@@ -272,8 +295,12 @@ function buildSeries(games: Record<string, unknown>[]) {
const teamAIndex = Math.min(blueTeamIndex, redTeamIndex);
const teamBIndex = Math.max(blueTeamIndex, redTeamIndex);
const key = `${teamAIndex}:${teamBIndex}`;
const current =
bySeries.get(key) ?? { teamAIndex, teamBIndex, teamAWins: 0, teamBWins: 0 };
const current = bySeries.get(key) ?? {
teamAIndex,
teamBIndex,
teamAWins: 0,
teamBWins: 0,
};
if (winnerTeamIndex === teamAIndex) current.teamAWins += 1;
if (winnerTeamIndex === teamBIndex) current.teamBWins += 1;
current.winnerTeamIndex =
@@ -331,5 +358,7 @@ function numberOrDefault(value: unknown, fallback: number) {
}
function numberOrUndefined(value: unknown) {
return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
return typeof value === 'number' && Number.isFinite(value)
? value
: undefined;
}
@@ -30,20 +30,26 @@ function createDb(params: { auctions?: Doc[]; history?: Doc[] }) {
},
};
},
async bulkWrite(writes: Array<{
updateOne: {
filter: { _id: unknown };
update: {
$set?: Record<string, unknown>;
$unset?: Record<string, ''>;
async bulkWrite(
writes: Array<{
updateOne: {
filter: { _id: unknown };
update: {
$set?: Record<string, unknown>;
$unset?: Record<string, ''>;
};
};
};
}>) {
}>,
) {
for (const write of writes) {
const doc = docs.find((item) => item._id === write.updateOne.filter._id);
const doc = docs.find(
(item) => item._id === write.updateOne.filter._id,
);
if (!doc) continue;
Object.assign(doc, write.updateOne.update.$set ?? {});
for (const key of Object.keys(write.updateOne.update.$unset ?? {})) {
for (const key of Object.keys(
write.updateOne.update.$unset ?? {},
)) {
delete doc[key];
}
}
@@ -31,7 +31,10 @@ interface MigrationStats {
}
type AnyDoc = Record<string, unknown> & { _id: unknown };
type UpdateDoc = { $set?: Record<string, unknown>; $unset?: Record<string, ''> };
type UpdateDoc = {
$set?: Record<string, unknown>;
$unset?: Record<string, ''>;
};
const AUCTION_FIELD_RENAMES: Array<{
from: string;
@@ -43,7 +46,11 @@ const AUCTION_FIELD_RENAMES: Array<{
{ from: 'passedQueue', to: 'passedAuctionPlayerQueue' },
{ from: 'auctionRound', to: 'currentAuctionRound' },
{ from: 'currentIndex', to: 'currentAuctionPlayerOrderIndex' },
{ from: 'bids', to: 'auctionBidHistory', transform: transformAuctionBidHistory },
{
from: 'bids',
to: 'auctionBidHistory',
transform: transformAuctionBidHistory,
},
{ from: 'currentBid', to: 'currentHighestBidPointAmount' },
{ from: 'currentBidderTeamIndex', to: 'currentHighestBidderTeamIndex' },
{
@@ -157,7 +164,8 @@ async function countDuplicateHistorySequences(
const duplicates = new Set<string>();
for await (const doc of collection.find({}).limit(limit ?? 0)) {
const auctionId = stringifyId(doc.auctionId);
const sequence = typeof doc.sequence === 'number' ? doc.sequence : undefined;
const sequence =
typeof doc.sequence === 'number' ? doc.sequence : undefined;
if (!auctionId || sequence === undefined) continue;
const key = `${auctionId}:${sequence}`;
@@ -5,10 +5,7 @@ import { NestFactory } from '@nestjs/core';
import mongoose from 'mongoose';
import { readFile } from 'node:fs/promises';
import { resolve } from 'node:path';
import {
ConnectionService,
resolveMongoDbName,
} from '../connection.service';
import { ConnectionService, resolveMongoDbName } from '../connection.service';
import type {
MatchDocument,
MatchGameAssignment,
@@ -214,12 +211,16 @@ async function main() {
printPlan(options, match, codes, plan);
if (options.dryRun) {
console.log('No writes were made. Re-run with --apply to update MongoDB.');
console.log(
'No writes were made. Re-run with --apply to update MongoDB.',
);
return;
}
const now = new Date();
const session = await (await connectionService.getConnection()).startSession();
const session = await (
await connectionService.getConnection()
).startSession();
try {
await session.withTransaction(async () => {
await applyTournamentCodeUpdates(plan, now, session);
@@ -230,9 +231,9 @@ async function main() {
status: 'finished',
roundRobinMaxRounds: options.maxRounds,
gameSchedule: plan.schedule,
tournamentCodeIds: [
...plan.usedCodeByOldGameNumber.values(),
].map((code) => code._id),
tournamentCodeIds: [...plan.usedCodeByOldGameNumber.values()].map(
(code) => code._id,
),
resultPollState: {
startedAt: match.resultPollState?.startedAt ?? now,
lastPolledAt: now,
@@ -423,7 +424,9 @@ function partitionIntoRounds(
}
if (!fillRound(0)) {
throw new Error('Could not partition result games into simultaneous rounds.');
throw new Error(
'Could not partition result games into simultaneous rounds.',
);
}
return rounds;
@@ -586,8 +589,7 @@ function buildSeriesResults(games: MatchGameResult[]): MatchSeriesResult[] {
}
return [...bySeries.values()].sort(
(left, right) =>
left.teamAIndex - right.teamAIndex ||
left.teamBIndex - right.teamBIndex,
left.teamAIndex - right.teamAIndex || left.teamBIndex - right.teamBIndex,
);
}
@@ -219,9 +219,9 @@ async function listDuplicateHistorySequences(
.toArray();
}
function printDuplicateHistorySequences(groups: Awaited<
ReturnType<typeof listDuplicateHistorySequences>
>) {
function printDuplicateHistorySequences(
groups: Awaited<ReturnType<typeof listDuplicateHistorySequences>>,
) {
if (groups.length === 0) {
console.log('No duplicate auctionHistory auctionId+sequence groups found.');
return;
@@ -248,7 +248,8 @@ async function repairDuplicateHistorySequences(
): Promise<DuplicateSequenceRepairStats> {
const historyCollection = db.collection('auctionHistory');
const auctionCollection = db.collection('auction');
const affectedAuctionIds = await findAuctionIdsWithDuplicateHistorySequences(db);
const affectedAuctionIds =
await findAuctionIdsWithDuplicateHistorySequences(db);
const stats: DuplicateSequenceRepairStats = {
affectedAuctions: affectedAuctionIds.length,
changedAuctionSequenceFields: 0,
@@ -177,7 +177,9 @@ function parseArgs(argv: string[]): CliOptions {
function parseCommitQuorum(value: string | undefined, label: string) {
if (!value) {
throw new Error(`${label} requires a positive integer, majority, or votingMembers.`);
throw new Error(
`${label} requires a positive integer, majority, or votingMembers.`,
);
}
if (value === 'majority' || value === 'votingMembers') return value;
return parsePositiveInteger(value, label);
@@ -230,9 +232,7 @@ function printDuplicateGroups(groups: TournamentCodeDuplicateGroupSummary[]) {
kind: group.kind,
loserCodes: group.losers.map((loser) => loser.code ?? '').join(', '),
loserIds: group.losers.map((loser) => loser.id).join(', '),
loserStates: group.losers
.map((loser) => loser.state ?? '')
.join(', '),
loserStates: group.losers.map((loser) => loser.state ?? '').join(', '),
})),
);
}
@@ -46,19 +46,20 @@ export function applyMongoosePerformancePlugin(schema: mongoose.Schema): void {
query[QUERY_PERFORMANCE_RECORDED] = false;
});
hookableSchema.post(
QUERY_OPERATION_REGEX,
function (result: unknown) {
recordQueryPerformance(
this as unknown as QueryWithPerformanceState,
result,
);
},
);
hookableSchema.post(QUERY_OPERATION_REGEX, function (result: unknown) {
recordQueryPerformance(
this as unknown as QueryWithPerformanceState,
result,
);
});
hookableSchema.post(
QUERY_OPERATION_REGEX,
function (error: unknown, _result: unknown, next: (error: unknown) => void) {
function (
error: unknown,
_result: unknown,
next: (error: unknown) => void,
) {
recordQueryPerformance(
this as unknown as QueryWithPerformanceState,
undefined,
@@ -80,7 +81,11 @@ export function applyMongoosePerformancePlugin(schema: mongoose.Schema): void {
hookableSchema.post(
'aggregate',
function (error: unknown, _result: unknown, next: (error: unknown) => void) {
function (
error: unknown,
_result: unknown,
next: (error: unknown) => void,
) {
recordAggregatePerformance(
this as AggregateWithPerformanceState,
undefined,
@@ -164,8 +169,8 @@ export function countHydratedDocuments(result: unknown): number {
function isHydratedDocument(value: unknown): boolean {
return Boolean(
value &&
typeof value === 'object' &&
'$__' in (value as Record<string, unknown>),
typeof value === 'object' &&
'$__' in (value as Record<string, unknown>),
);
}
@@ -11,9 +11,7 @@ interface NewRelicCustomEventApi {
eventType: string,
attributes: Record<string, NewRelicAttributeValue>,
): void;
addCustomAttributes(
attributes: Record<string, NewRelicAttributeValue>,
): void;
addCustomAttributes(attributes: Record<string, NewRelicAttributeValue>): void;
setTransactionName(name: string): void;
}
const agent = newrelicAgent as unknown as NewRelicCustomEventApi;
@@ -52,8 +52,7 @@ export interface ApiRequestPerformanceEvent {
leanQueryCount: number;
}
export interface MongooseQueryPerformanceEvent
extends MongooseQueryPerformance {
export interface MongooseQueryPerformanceEvent extends MongooseQueryPerformance {
type: 'mongoose-query';
timestamp: string;
requestId?: string;
@@ -92,10 +91,7 @@ export function resolveApiPerformanceConfig(
const enabled = readBoolean(env.API_PERF_OBSERVABILITY_ENABLED, false);
return {
enabled,
localEventsEnabled: readBoolean(
env.API_PERF_LOCAL_EVENTS_ENABLED,
enabled,
),
localEventsEnabled: readBoolean(env.API_PERF_LOCAL_EVENTS_ENABLED, enabled),
localEventFile:
env.API_PERF_LOCAL_EVENT_FILE || '/tmp/lolympus-api-performance.ndjson',
newRelicRequestEventsEnabled: readBoolean(
@@ -35,8 +35,7 @@ export interface RunWithDistributedLockOptions {
lockRetryDelayMilliseconds?: number;
}
export interface RunWithRenewedDistributedLockOptions
extends RunWithDistributedLockOptions {
export interface RunWithRenewedDistributedLockOptions extends RunWithDistributedLockOptions {
lockRenewalIntervalMilliseconds: number;
}
@@ -55,14 +54,16 @@ export class DistributedLockService {
);
const lockOwnershipToken = options.lockOwnershipToken ?? randomUUID();
const result = await this.redisService.raw().sendCommand([
'SET',
options.lockKey,
lockOwnershipToken,
'NX',
'PX',
String(options.lockExpirationDurationMilliseconds),
]);
const result = await this.redisService
.raw()
.sendCommand([
'SET',
options.lockKey,
lockOwnershipToken,
'NX',
'PX',
String(options.lockExpirationDurationMilliseconds),
]);
if (String(result) !== 'OK') return null;
return {
@@ -76,34 +77,37 @@ export class DistributedLockService {
public async releaseLockIfOwned(
lockOwnership: DistributedLockOwnership,
): Promise<boolean> {
const result = await this.redisService.raw().sendCommand([
'EVAL',
RELEASE_LOCK_IF_OWNED_SCRIPT,
'1',
lockOwnership.lockKey,
lockOwnership.lockOwnershipToken,
]);
const result = await this.redisService
.raw()
.sendCommand([
'EVAL',
RELEASE_LOCK_IF_OWNED_SCRIPT,
'1',
lockOwnership.lockKey,
lockOwnership.lockOwnershipToken,
]);
return Number(result) === 1;
}
public async extendLockIfOwned(
lockOwnership: DistributedLockOwnership,
lockExpirationDurationMilliseconds =
lockOwnership.lockExpirationDurationMilliseconds,
lockExpirationDurationMilliseconds = lockOwnership.lockExpirationDurationMilliseconds,
): Promise<boolean> {
this.assertPositiveDuration(
lockExpirationDurationMilliseconds,
'lockExpirationDurationMilliseconds',
);
const result = await this.redisService.raw().sendCommand([
'EVAL',
EXTEND_LOCK_IF_OWNED_SCRIPT,
'1',
lockOwnership.lockKey,
lockOwnership.lockOwnershipToken,
String(lockExpirationDurationMilliseconds),
]);
const result = await this.redisService
.raw()
.sendCommand([
'EVAL',
EXTEND_LOCK_IF_OWNED_SCRIPT,
'1',
lockOwnership.lockKey,
lockOwnership.lockOwnershipToken,
String(lockExpirationDurationMilliseconds),
]);
return Number(result) === 1;
}
@@ -25,7 +25,9 @@ async function readFirstSecret(
{
provide: REDIS_CLIENT,
inject: [SecretService],
useFactory: async (secretService: SecretService): Promise<RedisClient> => {
useFactory: async (
secretService: SecretService,
): Promise<RedisClient> => {
await secretService.ready();
const [url, endpoint, username, password] = await Promise.all([
@@ -6,15 +6,17 @@ function createRedisService(client: Record<string, unknown>) {
describe('RedisService stream pending recovery', () => {
it('normalizes XAUTOCLAIM array replies into stream entries', async () => {
const sendCommand = jest.fn().mockResolvedValue([
'0-0',
[
const sendCommand = jest
.fn()
.mockResolvedValue([
'0-0',
[
'1700000000000-0',
['job', '{"kind":"poll-tournament-result"}', 'source', 'test'],
[
'1700000000000-0',
['job', '{"kind":"poll-tournament-result"}', 'source', 'test'],
],
],
],
]);
]);
const service = createRedisService({ sendCommand });
await expect(
@@ -223,9 +223,7 @@ export class RedisService implements OnModuleDestroy {
])) as unknown;
const responseItems = Array.isArray(response) ? response : [];
const rawMessages = Array.isArray(responseItems[1])
? responseItems[1]
: [];
const rawMessages = Array.isArray(responseItems[1]) ? responseItems[1] : [];
return {
nextStartId: String(responseItems[0] ?? '0-0'),
@@ -258,7 +256,9 @@ export class RedisService implements OnModuleDestroy {
return this.client.publish(channel, message);
}
private normalizeClaimedStreamMessage(rawMessage: unknown): StreamEntry | null {
private normalizeClaimedStreamMessage(
rawMessage: unknown,
): StreamEntry | null {
if (Array.isArray(rawMessage)) {
const [id, fields] = rawMessage;
if (id === undefined) return null;
@@ -46,11 +46,13 @@ export function countKnownParticipants(
): { team100: number; team200: number; total: number } {
const team100 = detail.info.participants.filter(
(participant) =>
participant.teamId === RIOT_BLUE_TEAM_ID && userByPuuid.has(participant.puuid),
participant.teamId === RIOT_BLUE_TEAM_ID &&
userByPuuid.has(participant.puuid),
).length;
const team200 = detail.info.participants.filter(
(participant) =>
participant.teamId === RIOT_RED_TEAM_ID && userByPuuid.has(participant.puuid),
participant.teamId === RIOT_RED_TEAM_ID &&
userByPuuid.has(participant.puuid),
).length;
return { team100, team200, total: team100 + team200 };
}
@@ -78,13 +80,16 @@ export function buildParticipantsSnapshot(
tagLine: user.account.tagLine || participant.riotIdTagLine,
profileIconId: user.account.profileIconId,
tier:
user.account.tiers.find((tier) => tier.queueType === 'RANKED_SOLO_5x5') ??
user.account.tiers[0],
user.account.tiers.find(
(tier) => tier.queueType === 'RANKED_SOLO_5x5',
) ?? user.account.tiers[0],
preferredPositions: user.preferredPositions,
joinedAt: new Date(detail.info.gameCreation),
};
})
.filter((participant): participant is MatchParticipant => Boolean(participant));
.filter((participant): participant is MatchParticipant =>
Boolean(participant),
);
}
export function buildTeams(
@@ -105,7 +110,9 @@ export function buildTeams(
assignedPosition: resolveAssignedPosition(participant, user),
};
})
.filter((member): member is NonNullable<typeof member> => Boolean(member));
.filter((member): member is NonNullable<typeof member> =>
Boolean(member),
);
return {
teamIndex,
name: `${teamIndex}팀`,
@@ -3,9 +3,7 @@ import mongoose from 'mongoose';
import { AllowPublicAccess } from '../auth/allow-public-access.decorator';
import { ParseObjectIdPipe } from '../common/parse-object-id.pipe';
import { RiotJobQueueService } from '../riot-job-queue/riot-job-queue.service';
import type {
RiotJobPriority,
} from '../riot-job-queue/riot-job-queue.types';
import type { RiotJobPriority } from '../riot-job-queue/riot-job-queue.types';
import { MatchHistoryService } from './match-history.service';
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 { ConnectionService } from '../global/database/connection.service';
import type {
@@ -16,10 +20,7 @@ import {
type RiotQueueGroup,
type RiotRankFilter,
} from '../riot/riot-queue.constants';
import type {
RiotMatchDto,
RiotMatchParticipantDto,
} from '../riot/riot.types';
import type { RiotMatchDto, RiotMatchParticipantDto } from '../riot/riot.types';
import type {
ChampionStatsResponse,
ChampionStatsRow,
@@ -104,7 +105,10 @@ export class MatchHistoryService {
fetchedAt: tier.fetchedAt.toISOString(),
})),
tierHistory: [...context.account.tierHistory]
.sort((left, right) => left.recordedAt.getTime() - right.recordedAt.getTime())
.sort(
(left, right) =>
left.recordedAt.getTime() - right.recordedAt.getTime(),
)
.map((entry) => ({
queueType: entry.queueType,
tier: entry.tier,
@@ -170,7 +174,11 @@ export class MatchHistoryService {
seasonId: params.filters.seasonId,
});
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({
context,
queueIds,
@@ -196,7 +204,11 @@ export class MatchHistoryService {
seasonId: params.filters.seasonId,
});
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({
context,
queueIds,
@@ -212,7 +224,10 @@ export class MatchHistoryService {
return {
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),
season: context.season,
};
@@ -455,8 +470,9 @@ export class MatchHistoryService {
puuid: string,
): RiotMatchParticipantDto | null {
return (
match.info.participants.find((participant) => participant.puuid === puuid) ??
null
match.info.participants.find(
(participant) => participant.puuid === puuid,
) ?? null
);
}
@@ -570,7 +586,8 @@ export class MatchHistoryService {
return {
matchId: dto.metadata.matchId,
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,
gameDuration: dto.info.gameDuration,
win: participant.win,
@@ -684,11 +701,15 @@ export class MatchHistoryService {
return {
puuid: participant.puuid,
gameName: participant.riotIdGameName || participant.summonerName || 'Unknown',
gameName:
participant.riotIdGameName ||
participant.summonerName ||
'Unknown',
tagLine: participant.riotIdTagLine || '',
championId: participant.championId,
championLevel: participant.champLevel,
teamPosition: participant.teamPosition || participant.individualPosition,
teamPosition:
participant.teamPosition || participant.individualPosition,
kills: participant.kills,
deaths: participant.deaths,
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(
(style) => style.description === 'primaryStyle',
);
@@ -750,11 +773,19 @@ export class MatchHistoryService {
) as Partial<Record<RiotLane, number>>;
}
private resolveTopChampions(views: RecentMatchView[]): RecentSummaryResponse['topChampions'] {
const byChampion = new Map<number, { games: number; wins: number; rating: number }>();
private resolveTopChampions(
views: RecentMatchView[],
): RecentSummaryResponse['topChampions'] {
const byChampion = new Map<
number,
{ games: number; wins: number; rating: number }
>();
for (const view of views) {
const stat =
byChampion.get(view.championId) ?? { games: 0, wins: 0, rating: 0 };
const stat = byChampion.get(view.championId) ?? {
games: 0,
wins: 0,
rating: 0,
};
stat.games += 1;
stat.wins += view.win ? 1 : 0;
stat.rating += view.rating;
@@ -797,7 +828,8 @@ export class MatchHistoryService {
participant.deaths,
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 visionPerMin = participant.visionScore / Math.max(minutes, 1);
const score =
@@ -815,8 +847,13 @@ export class MatchHistoryService {
): number {
const teamDamage = match.info.participants
.filter((candidate) => candidate.teamId === participant.teamId)
.reduce((sum, candidate) => sum + candidate.totalDamageDealtToChampions, 0);
return teamDamage > 0 ? participant.totalDamageDealtToChampions / teamDamage : 0;
.reduce(
(sum, candidate) => sum + candidate.totalDamageDealtToChampions,
0,
);
return teamDamage > 0
? participant.totalDamageDealtToChampions / teamDamage
: 0;
}
private resolveTotalCs(participant: RiotMatchParticipantDto): number {
@@ -827,11 +864,16 @@ export class MatchHistoryService {
match: RiotMatchDto,
participant: RiotMatchParticipantDto,
): 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 {
return deaths === 0 ? kills + assists : this.round((kills + assists) / deaths);
return deaths === 0
? kills + assists
: this.round((kills + assists) / deaths);
}
private resolveLastFetchedAt(
@@ -841,9 +883,11 @@ export class MatchHistoryService {
if (docs.length === 0) {
return context.account.recentStatsFetchedAt?.toISOString() ?? null;
}
const oldest = docs.reduce((acc, doc) =>
doc.fetchedAt.getTime() < acc.getTime() ? doc.fetchedAt : acc,
docs[0].fetchedAt);
const oldest = docs.reduce(
(acc, doc) =>
doc.fetchedAt.getTime() < acc.getTime() ? doc.fetchedAt : acc,
docs[0].fetchedAt,
);
return oldest.toISOString();
}
@@ -858,14 +902,17 @@ export class MatchHistoryService {
.map((row) => row.lastFetchedAt)
.filter((value): value is Date => value instanceof Date)
.reduce<Date | null>(
(acc, value) =>
!acc || value.getTime() < acc.getTime() ? value : acc,
(acc, value) => (!acc || value.getTime() < acc.getTime() ? value : acc),
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;
return Math.max(1, Math.min(Math.floor(value), max));
}
@@ -882,18 +929,12 @@ export class MatchHistoryService {
return Math.round(value * 10) / 10;
}
private numberField(
value: RiotMatchParticipantDto,
key: string,
): number {
private numberField(value: RiotMatchParticipantDto, key: string): number {
const field = value[key];
return typeof field === 'number' && Number.isFinite(field) ? field : 0;
}
private booleanField(
value: RiotMatchParticipantDto,
key: string,
): boolean {
private booleanField(value: RiotMatchParticipantDto, key: string): boolean {
return value[key] === true;
}
}
@@ -8,7 +8,11 @@ import { RiotJobWorkerService } from './riot-job-worker.service';
import { RiotRefreshGateway } from './riot-refresh.gateway';
@Module({
imports: [RiotModule, LegacyImportModule, forwardRef(() => TournamentResultModule)],
imports: [
RiotModule,
LegacyImportModule,
forwardRef(() => TournamentResultModule),
],
controllers: [RiotJobQueueController],
providers: [RiotJobQueueService, RiotJobWorkerService, RiotRefreshGateway],
exports: [RiotJobQueueService],
@@ -95,7 +95,8 @@ export class RiotJobQueueService {
jobId: existingJobId,
queueGroup,
alreadyQueued: true,
etaSeconds: existingStatus?.etaSeconds ?? queuePosition * RIOT_JOB_AVG_SECONDS,
etaSeconds:
existingStatus?.etaSeconds ?? queuePosition * RIOT_JOB_AVG_SECONDS,
queuePosition: existingStatus?.queuePosition ?? queuePosition,
});
continue;
@@ -127,7 +128,8 @@ export class RiotJobQueueService {
jobId,
queueGroup,
alreadyQueued: true,
etaSeconds: status?.etaSeconds ?? queuePosition * RIOT_JOB_AVG_SECONDS,
etaSeconds:
status?.etaSeconds ?? queuePosition * RIOT_JOB_AVG_SECONDS,
queuePosition: status?.queuePosition ?? queuePosition,
});
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) {
await this.markRefreshRequested(context.user._id, context.account.puuid);
}
@@ -253,8 +258,8 @@ export class RiotJobQueueService {
const subJobs = (
await Promise.all(jobIds.map((jobId) => this.getStatus(jobId)))
).filter((status): status is RiotJobStatus => Boolean(status));
const done = subJobs.filter((job) =>
job.state === 'completed' || job.state === 'failed',
const done = subJobs.filter(
(job) => job.state === 'completed' || job.state === 'failed',
).length;
const state = this.resolveParentState(subJobs);
@@ -411,12 +416,14 @@ export class RiotJobQueueService {
job: PollTournamentResultJob,
deferUntilMs: number,
): Promise<void> {
await this.redisService.raw().sendCommand([
'ZADD',
RIOT_JOB_SCHEDULED_ZSET,
String(deferUntilMs),
JSON.stringify(job),
]);
await this.redisService
.raw()
.sendCommand([
'ZADD',
RIOT_JOB_SCHEDULED_ZSET,
String(deferUntilMs),
JSON.stringify(job),
]);
}
private parseScheduledJob(value: string): PollTournamentResultJob | null {
@@ -449,7 +456,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(
this.parentKey(parentJobId),
jobIds,
@@ -1,7 +1,4 @@
import type {
RiotPlatformRoute,
RiotRegionalRoute,
} from '../riot/riot.types';
import type { RiotPlatformRoute, RiotRegionalRoute } from '../riot/riot.types';
import type { RiotQueueGroup } from '../riot/riot-queue.constants';
import type { PollTournamentResultJob } from '../tournament-result/tournament-result.types';
import type { LegacyImportMemberJob } from '../legacy-import/legacy-import.types';
@@ -21,14 +21,16 @@ function makeWorker() {
deleteStreamEntries: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<RedisService>;
const distributedLockService = {
runWithRenewedLock: jest.fn().mockImplementation(async (options, operation) =>
operation({
lockKey: options.lockKey,
lockOwnershipToken: 'lock-owner',
lockExpirationDurationMilliseconds:
options.lockExpirationDurationMilliseconds,
}),
),
runWithRenewedLock: jest
.fn()
.mockImplementation(async (options, operation) =>
operation({
lockKey: options.lockKey,
lockOwnershipToken: 'lock-owner',
lockExpirationDurationMilliseconds:
options.lockExpirationDurationMilliseconds,
}),
),
} as unknown as jest.Mocked<DistributedLockService>;
const jobQueueService = {
markProcessing: jest.fn().mockResolvedValue(undefined),
@@ -275,10 +275,10 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
): Promise<{ stream: string; message: StreamEntry } | null> {
const result = await this.redisService.readGroup(
stream,
RIOT_JOB_GROUP,
this.consumerIdentifier,
'>',
{ count: 1, blockMs },
RIOT_JOB_GROUP,
this.consumerIdentifier,
'>',
{ count: 1, blockMs },
);
const message = result?.[0]?.messages[0];
return message ? { stream, message } : null;
@@ -70,7 +70,10 @@ export class RiotRefreshGateway {
if (typeof payload?.puuid === 'string' && 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()}`);
}
return rooms;
@@ -101,7 +101,7 @@ function makeService(overrides?: {
Promise.resolve({
riotPlatform: 'kr',
riotRegion: 'asia',
}),
}),
}),
}),
});
@@ -198,65 +198,64 @@ describe('RiotAccountEnrichmentService', () => {
masteryService,
recentMatchesService,
recentStatsService,
} =
makeService({
user,
summoner: {
getByPuuid: jest.fn().mockResolvedValue({
} = makeService({
user,
summoner: {
getByPuuid: jest.fn().mockResolvedValue({
puuid: 'puuid-1',
profileIconId: 588,
revisionDate: 1776977597000,
summonerLevel: 529,
}),
} as Partial<RiotSummonerService>,
league: {
getEntriesByPuuid: jest.fn().mockResolvedValue([
{
leagueId: 'L1',
queueType: 'RANKED_SOLO_5x5',
tier: 'EMERALD',
rank: 'I',
puuid: 'puuid-1',
profileIconId: 588,
revisionDate: 1776977597000,
summonerLevel: 529,
}),
} as Partial<RiotSummonerService>,
league: {
getEntriesByPuuid: jest.fn().mockResolvedValue([
{
leagueId: 'L1',
queueType: 'RANKED_SOLO_5x5',
tier: 'EMERALD',
rank: 'I',
puuid: 'puuid-1',
leaguePoints: 75,
wins: 160,
losses: 148,
},
]),
} as Partial<RiotLeagueService>,
mastery: {
getTopByPuuid: jest.fn().mockResolvedValue([
{
puuid: 'puuid-1',
championId: 7,
championLevel: 70,
championPoints: 742560,
},
]),
} as Partial<RiotChampionMasteryService>,
recentMatches: {
syncRecentMatches: jest.fn().mockResolvedValue([]),
loadFromDb: jest.fn().mockResolvedValue([
{ matchId: 'KR_1', raw: {} },
{ matchId: 'KR_2', raw: {} },
]),
} as Partial<RiotRecentMatchesService>,
recentStats: {
computeSummary: jest.fn().mockReturnValue({
overall: {
games: 2,
wins: 1,
losses: 1,
avgKills: 5.5,
avgDeaths: 2.5,
avgAssists: 7,
avgCs: 175,
avgCsPerMin: 6.4,
mostPlayedChampionIds: [7, 103],
},
byLane: {},
}),
} as Partial<RiotRecentStatsService>,
});
leaguePoints: 75,
wins: 160,
losses: 148,
},
]),
} as Partial<RiotLeagueService>,
mastery: {
getTopByPuuid: jest.fn().mockResolvedValue([
{
puuid: 'puuid-1',
championId: 7,
championLevel: 70,
championPoints: 742560,
},
]),
} as Partial<RiotChampionMasteryService>,
recentMatches: {
syncRecentMatches: jest.fn().mockResolvedValue([]),
loadFromDb: jest.fn().mockResolvedValue([
{ matchId: 'KR_1', raw: {} },
{ matchId: 'KR_2', raw: {} },
]),
} as Partial<RiotRecentMatchesService>,
recentStats: {
computeSummary: jest.fn().mockReturnValue({
overall: {
games: 2,
wins: 1,
losses: 1,
avgKills: 5.5,
avgDeaths: 2.5,
avgAssists: 7,
avgCs: 175,
avgCsPerMin: 6.4,
mostPlayedChampionIds: [7, 103],
},
byLane: {},
}),
} as Partial<RiotRecentStatsService>,
});
const result = await service.enrichRiotAccount({
userId: user._id,
@@ -148,14 +148,18 @@ describe('RiotDdragonService', () => {
'ddragon:manifest:v5:ko_KR',
expect.objectContaining({
summonerSpells: expect.objectContaining({
'4': expect.objectContaining({ description: '커서 방향으로 순간이동합니다.' }),
'4': expect.objectContaining({
description: '커서 방향으로 순간이동합니다.',
}),
}),
runesReforged: expect.arrayContaining([
expect.objectContaining({
slots: expect.arrayContaining([
expect.objectContaining({
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) {}
public async getManifest(locale: string = DEFAULT_LOCALE): Promise<DdragonManifest> {
public async getManifest(
locale: string = DEFAULT_LOCALE,
): Promise<DdragonManifest> {
const normalizedLocale = normalizeLocale(locale);
const cacheKey = manifestCacheKey(normalizedLocale);
@@ -139,12 +141,14 @@ export class RiotDdragonService {
private async buildManifest(locale: string): Promise<DdragonManifest> {
const version = await this.fetchLatestVersion();
const [champions, summonerSpells, runesReforged, items] = await Promise.all([
this.fetchChampionMap(version, locale),
this.fetchSummonerSpellMap(version, locale),
this.fetchRuneStyles(version, locale),
this.fetchItemMap(version, locale),
]);
const [champions, summonerSpells, runesReforged, items] = await Promise.all(
[
this.fetchChampionMap(version, locale),
this.fetchSummonerSpellMap(version, locale),
this.fetchRuneStyles(version, locale),
this.fetchItemMap(version, locale),
],
);
return {
version,
cdn: DDRAGON_CDN,
@@ -158,7 +162,9 @@ export class RiotDdragonService {
}
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') {
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 payload = await this.fetchJson<unknown>(url);
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
@@ -229,8 +237,7 @@ export class RiotDdragonService {
key: style.key,
icon: style.icon,
name: style.name,
shortDesc:
typeof style.shortDesc === 'string' ? style.shortDesc : '',
shortDesc: typeof style.shortDesc === 'string' ? style.shortDesc : '',
longDesc: typeof style.longDesc === 'string' ? style.longDesc : '',
slots: (style.slots ?? []).map((slot) => ({
runes: (slot.runes ?? [])
@@ -290,9 +297,7 @@ export class RiotDdragonService {
signal: controller.signal,
});
if (!response.ok) {
throw new Error(
`ddragon request failed (${response.status}): ${url}`,
);
throw new Error(`ddragon request failed (${response.status}): ${url}`);
}
return (await response.json()) as T;
} catch (err) {
@@ -1,9 +1,6 @@
import { Injectable } from '@nestjs/common';
import { RiotClientService } from './riot.client.service';
import {
RiotLeagueEntryDto,
RiotPlatformLookupOptions,
} from './riot.types';
import { RiotLeagueEntryDto, RiotPlatformLookupOptions } from './riot.types';
@Injectable()
export class RiotLeagueService {
@@ -98,9 +98,7 @@ function validateMatchIdsLookupOptions(
assertOptionalNonNegativeInteger(options.endTime, 'endTime');
if (options.type !== undefined && !RIOT_MATCH_TYPES.includes(options.type)) {
throw new RangeError(
`type must be one of: ${RIOT_MATCH_TYPES.join(', ')}`,
);
throw new RangeError(`type must be one of: ${RIOT_MATCH_TYPES.join(', ')}`);
}
if (
@@ -278,7 +276,9 @@ function parseTimelineParticipant(
index: number,
): RiotMatchTimelineParticipantDto {
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 {
@@ -287,7 +287,10 @@ function parseTimelineParticipant(
value.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)) {
throw new TypeError(
`participants[${participantIndex}].perks must be an object.`,
@@ -732,7 +738,9 @@ function parseBan(
banIndex: number,
): RiotMatchBanDto {
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 {
@@ -781,7 +789,9 @@ function parseObjective(
key: keyof RiotMatchObjectivesDto,
): RiotMatchObjectiveDto {
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 {
@@ -84,5 +84,10 @@ export function isRiotQueueGroup(value: string): value is RiotQueueGroup {
}
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'
);
}
@@ -150,13 +150,16 @@ async function runWithConcurrency<T>(
if (items.length === 0) return;
const queue = [...items];
const runners = Array.from({ length: Math.min(concurrency, queue.length) }, async () => {
while (queue.length > 0) {
const item = queue.shift();
if (item === undefined) return;
await worker(item);
}
});
const runners = Array.from(
{ length: Math.min(concurrency, queue.length) },
async () => {
while (queue.length > 0) {
const item = queue.shift();
if (item === undefined) return;
await worker(item);
}
},
);
await Promise.all(runners);
}
@@ -44,17 +44,29 @@ export class RiotRecentStatsService {
);
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;
accumulateAggregate(overall, participant, match.info.gameCreation, match.info.gameDuration);
accumulateAggregate(
overall,
participant,
match.info.gameCreation,
match.info.gameDuration,
);
const lane = resolveLane(participant);
if (!lane) continue;
const aggregate = laneAggregates.get(lane);
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) {
@@ -133,7 +145,8 @@ function finalizeAggregate(aggregate: Aggregate): RiotLaneStats {
const mostPlayedChampionIds = [...aggregate.championCounts.entries()]
.sort((left, right) => {
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;
if (rightLastPlayed !== leftLastPlayed) {
return rightLastPlayed - leftLastPlayed;
@@ -1,9 +1,6 @@
import { Injectable } from '@nestjs/common';
import { RiotClientService } from './riot.client.service';
import {
RiotPlatformLookupOptions,
RiotSummonerDto,
} from './riot.types';
import { RiotPlatformLookupOptions, RiotSummonerDto } from './riot.types';
@Injectable()
export class RiotSummonerService {
@@ -17,8 +17,12 @@ describe('RiotWebhookController', () => {
});
it('logs the incoming webhook payload and returns an acknowledgement', () => {
const logSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
const dirSpy = jest.spyOn(console, 'dir').mockImplementation(() => undefined);
const logSpy = jest
.spyOn(console, 'log')
.mockImplementation(() => undefined);
const dirSpy = jest
.spyOn(console, 'dir')
.mockImplementation(() => undefined);
const request = {
method: 'POST',
originalUrl: '/riot/webhooks/tournament',
@@ -1,10 +1,4 @@
import {
All,
Controller,
HttpCode,
HttpStatus,
Req,
} from '@nestjs/common';
import { All, Controller, HttpCode, HttpStatus, Req } from '@nestjs/common';
import type { Request } from 'express';
import { AllowPublicAccess } from '../auth/allow-public-access.decorator';
+8 -3
View File
@@ -263,7 +263,10 @@ export interface RiotMatchTimelineInfoDto extends Record<string, unknown> {
participants?: RiotMatchTimelineParticipantDto[];
}
export interface RiotMatchTimelineParticipantDto extends Record<string, unknown> {
export interface RiotMatchTimelineParticipantDto extends Record<
string,
unknown
> {
participantId: number;
puuid: string;
}
@@ -294,8 +297,10 @@ export interface RiotMatchTimelineEventDto extends Record<string, unknown> {
victimId?: number;
}
export interface RiotMatchTimelineParticipantFrameDto
extends Record<string, unknown> {
export interface RiotMatchTimelineParticipantFrameDto extends Record<
string,
unknown
> {
participantId: number;
totalGold: number;
xp: number;
@@ -8,9 +8,7 @@ import {
describe('round-robin util', () => {
it('builds every team pair in lexicographic order', () => {
expect(roundRobinPairs(2)).toEqual([
{ teamAIndex: 1, teamBIndex: 2 },
]);
expect(roundRobinPairs(2)).toEqual([{ teamAIndex: 1, teamBIndex: 2 }]);
expect(roundRobinPairs(4)).toEqual([
{ teamAIndex: 1, teamBIndex: 2 },
{ teamAIndex: 1, teamBIndex: 3 },
@@ -33,8 +31,9 @@ describe('round-robin util', () => {
for (const roundNumber of [1, 2, 3, 4, 5]) {
const round = schedule.filter((game) => game.roundNumber === roundNumber);
expect(round).toHaveLength(3);
expect(new Set(round.flatMap((game) => [game.teamAIndex, game.teamBIndex])))
.toHaveProperty('size', 6);
expect(
new Set(round.flatMap((game) => [game.teamAIndex, game.teamBIndex])),
).toHaveProperty('size', 6);
}
});
@@ -59,10 +59,7 @@ export function roundRobinGameSchedule(
typeof options.maxRounds === 'number' && Number.isFinite(options.maxRounds)
? Math.floor(options.maxRounds)
: fullRoundCount;
const roundLimit = Math.max(
0,
Math.min(fullRoundCount, requestedRoundCount),
);
const roundLimit = Math.max(0, Math.min(fullRoundCount, requestedRoundCount));
if (roundLimit === 0) return [];
const bye = 0;
@@ -46,9 +46,7 @@ describe('TournamentCodeVendorService', () => {
ok: true,
status: 200,
json: jest.fn().mockResolvedValue({
tournament_code_list: [
'KR05090-85d64e26-0a7d-438b-9ada-11784e46add3',
],
tournament_code_list: ['KR05090-85d64e26-0a7d-438b-9ada-11784e46add3'],
}),
});
const service = new TournamentCodeVendorService();
+5 -5
View File
@@ -13,10 +13,7 @@ import { AllowPublicAccess } from '../auth/allow-public-access.decorator';
import '../auth/auth-request';
import { CurrentUser } from '../auth/current-user.decorator';
import { ConnectionService } from '../global/database/connection.service';
import type {
IdentityDocument,
UserDocument,
} from '../global/database/schema';
import type { IdentityDocument, UserDocument } from '../global/database/schema';
import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service';
import type { MeResponseDto } from './dto/me-response.dto';
import { RefreshRiotAccountDto } from './dto/refresh-riot-account.dto';
@@ -56,7 +53,10 @@ export class UserController {
@Body() body: RefreshRiotAccountDto,
) {
const resolvedUser =
user ?? (req.identity ? await this.findUserByIdentityAndPuuid(req.identity, puuid) : null);
user ??
(req.identity
? await this.findUserByIdentityAndPuuid(req.identity, puuid)
: null);
if (!resolvedUser) {
throw new UnauthorizedException('Authentication required.');
}