Compare commits

...
10 Commits
32 changed files with 1905 additions and 190 deletions

No files matched your search

+1 -1
View File
@@ -1 +1 @@
66
68
+9 -3
View File
@@ -103,6 +103,12 @@ git push origin main:release/66
pnpm deploy:web:staging
```
staging Pages 배포 스크립트는 `CF_PAGES_STAGING_BRANCH`가 있으면 그 값을
사용하고, 없으면 최신 `release/*` 브랜치를 자동으로 선택합니다. 최신 기준은
브랜치가 가리키는 커밋 시각이며, 동률이면 브랜치명 내림차순입니다.
staging/prod Pages 배포 스크립트는 명시 릴리즈 브랜치 환경변수가 있으면 그
값을 사용하고, 없으면 최신 `release/*` 브랜치를 자동으로 선택합니다. 최신
기준은 브랜치가 가리키는 커밋 시각이며, 동률이면 브랜치명 내림차순입니다.
staging은 선택된 릴리즈 브랜치로 preview 배포를 만들고, prod는 Cloudflare
Pages production branch로 업로드해 production 배포를 만듭니다.
명시 릴리즈 브랜치는 staging은 `CF_PAGES_STAGING_BRANCH`, prod는
`CF_PAGES_RELEASE_BRANCH`로 지정합니다. Cloudflare Pages production branch가
`main`이 아니면 `CF_PAGES_PRODUCTION_BRANCH`로 지정합니다.
+2 -2
View File
@@ -27,8 +27,8 @@
## Riot Background Refresh
Set `RIOT_BG_REFRESH_ENABLED=true` to refresh stale Riot accounts automatically
between KST 03:00 and 10:00. The scheduler picks active users whose
Stale Riot accounts refresh automatically between KST 03:00 and 10:00.
The scheduler picks active users whose
`lastRefreshRequestedAt` is older than 6 hours, oldest first, and uses a
background-only Riot token bucket capped at roughly 40% of the app rate limit.
@@ -164,6 +164,7 @@ export class AuctionController {
) {
this.assertSameCommunity(currentUser, communityId);
await this.auctionService.reset({ matchId, communityId });
this.auctionGateway.broadcastReset(matchId.toString());
}
private resolveBidder(
@@ -364,6 +364,11 @@ export class AuctionGateway
this.syncRoomTimer(matchId, auction);
}
public broadcastReset(matchId: string) {
this.clearRoomTimer(matchId);
this.server.to(matchId).emit('reset', { matchId });
}
private emitChatHistory(socket: Socket, auction: AuctionDocument) {
socket.emit('chat-history', {
messages: (auction.chatMessages ?? []).map((message) =>
@@ -1,9 +1,4 @@
import {
Inject,
Injectable,
Logger,
OnModuleDestroy,
} from '@nestjs/common';
import { Inject, Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
import type { createClient } from 'redis';
import { GARNET_CLIENT } from './garnet.constants';
@@ -203,6 +198,13 @@ export class GarnetService implements OnModuleDestroy {
return this.client.xAck(key, group, ids);
}
public async deleteStreamEntries(
key: string,
ids: string | string[],
): Promise<number> {
return this.client.xDel(key, ids);
}
public async streamLength(key: string): Promise<number> {
return this.client.xLen(key);
}
@@ -99,6 +99,18 @@ export class MatchHistoryService {
losses: tier.losses,
fetchedAt: tier.fetchedAt.toISOString(),
})),
tierHistory: [...context.account.tierHistory]
.sort((left, right) => left.recordedAt.getTime() - right.recordedAt.getTime())
.map((entry) => ({
queueType: entry.queueType,
tier: entry.tier,
rank: entry.rank,
leaguePoints: entry.leaguePoints,
wins: entry.wins,
losses: entry.losses,
recordedAt: entry.recordedAt.toISOString(),
season: entry.season,
})),
season: context.season,
seasons: this.resolveSeasons(context.community),
lastFetchedAt: lastFetchedAt?.toISOString() ?? null,
@@ -27,6 +27,16 @@ export interface UserHistoryProfileResponse {
losses: number;
fetchedAt: string;
}>;
tierHistory: Array<{
queueType: string;
tier: string;
rank?: string;
leaguePoints?: number;
wins?: number;
losses?: number;
recordedAt: string;
season?: string;
}>;
season: HistorySeasonDto;
seasons: HistorySeasonDto[];
lastFetchedAt: string | null;
@@ -1,4 +1,3 @@
import { ConfigService } from '@nestjs/config';
import mongoose from 'mongoose';
import { GarnetService } from '../global/garnet/garnet.service';
import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service';
@@ -30,7 +29,7 @@ function candidate(puuid: string): StaleAccountCandidate {
};
}
function makeScheduler(enabled = true) {
function makeScheduler() {
const rawClient = {
sendCommand: jest.fn().mockResolvedValue(1),
};
@@ -42,7 +41,7 @@ function makeScheduler(enabled = true) {
raw: jest.fn().mockReturnValue(rawClient),
} as unknown as jest.Mocked<GarnetService> & { raw: jest.Mock };
const rateLimiter = {
acquireBackground: jest.fn().mockResolvedValue(undefined),
isRefreshWindowOpen: jest.fn().mockResolvedValue(true),
} as unknown as jest.Mocked<RiotRateLimiterService>;
const enrichmentService = {
markRefreshRequested: jest.fn().mockResolvedValue(undefined),
@@ -51,16 +50,11 @@ function makeScheduler(enabled = true) {
const staleAccountRepository = {
findStaleAccounts: jest.fn().mockResolvedValue([]),
} as unknown as jest.Mocked<StaleAccountRepository>;
const config = {
get: jest.fn().mockReturnValue(enabled ? 'true' : 'false'),
} as unknown as ConfigService;
const scheduler = new BackgroundRefreshScheduler(
garnet,
rateLimiter,
enrichmentService,
staleAccountRepository,
config,
) as SchedulerInternals;
return {
@@ -79,19 +73,40 @@ describe('BackgroundRefreshScheduler', () => {
jest.restoreAllMocks();
});
it('does not schedule ticks when disabled', () => {
it('schedules ticks without requiring RIOT_BG_REFRESH_ENABLED', () => {
jest.useFakeTimers();
const setIntervalSpy = jest.spyOn(global, 'setInterval');
const { scheduler } = makeScheduler(false);
const { scheduler } = makeScheduler();
scheduler.onModuleInit();
expect(setIntervalSpy).not.toHaveBeenCalled();
expect(setIntervalSpy).toHaveBeenCalledTimes(2);
scheduler.onModuleDestroy();
});
it('does not query stale accounts outside the KST window', async () => {
it('uses the dawn refresh gate ratio inside the KST background window', async () => {
jest.useFakeTimers().setSystemTime(new Date('2026-05-02T18:00:00.000Z'));
const { scheduler, rateLimiter } = makeScheduler();
await scheduler.tick();
expect(rateLimiter.isRefreshWindowOpen).toHaveBeenCalledWith(0.8);
});
it('uses the opportunistic refresh gate ratio outside the KST background window', async () => {
jest.useFakeTimers().setSystemTime(new Date('2026-05-02T17:59:59.000Z'));
const { scheduler, staleAccountRepository } = makeScheduler();
const { scheduler, rateLimiter, staleAccountRepository } = makeScheduler();
await scheduler.tick();
expect(rateLimiter.isRefreshWindowOpen).toHaveBeenCalledWith(0.5);
expect(staleAccountRepository.findStaleAccounts).toHaveBeenCalledTimes(1);
});
it('does not query stale accounts when the refresh gate is closed', async () => {
jest.useFakeTimers().setSystemTime(new Date('2026-05-02T18:00:00.000Z'));
const { scheduler, rateLimiter, staleAccountRepository } = makeScheduler();
rateLimiter.isRefreshWindowOpen.mockResolvedValue(false);
await scheduler.tick();
@@ -108,21 +123,15 @@ describe('BackgroundRefreshScheduler', () => {
expect(staleAccountRepository.findStaleAccounts).not.toHaveBeenCalled();
});
it('marks and enriches each stale candidate with background rate tokens', async () => {
it('marks and enriches each stale candidate without background precharge', async () => {
jest.useFakeTimers().setSystemTime(new Date('2026-05-02T18:00:00.000Z'));
const {
scheduler,
rateLimiter,
enrichmentService,
staleAccountRepository,
} = makeScheduler();
const { scheduler, enrichmentService, staleAccountRepository } =
makeScheduler();
const candidates = [candidate('puuid-1'), candidate('puuid-2')];
staleAccountRepository.findStaleAccounts.mockResolvedValue(candidates);
await scheduler.tick();
expect(rateLimiter.acquireBackground).toHaveBeenCalledTimes(2);
expect(rateLimiter.acquireBackground).toHaveBeenCalledWith(8);
expect(enrichmentService.markRefreshRequested).toHaveBeenCalledTimes(2);
expect(enrichmentService.markRefreshRequested).toHaveBeenNthCalledWith(
1,
@@ -136,6 +145,28 @@ describe('BackgroundRefreshScheduler', () => {
});
});
it('stops the candidate loop when the refresh gate closes mid-tick', async () => {
jest.useFakeTimers().setSystemTime(new Date('2026-05-02T18:00:00.000Z'));
const {
scheduler,
rateLimiter,
enrichmentService,
staleAccountRepository,
} = makeScheduler();
staleAccountRepository.findStaleAccounts.mockResolvedValue([
candidate('puuid-1'),
candidate('puuid-2'),
]);
rateLimiter.isRefreshWindowOpen
.mockResolvedValueOnce(true)
.mockResolvedValueOnce(true)
.mockResolvedValueOnce(false);
await scheduler.tick();
expect(enrichmentService.enrichRiotAccount).toHaveBeenCalledTimes(1);
});
it('continues after a candidate throws and records a failure counter', async () => {
jest.useFakeTimers().setSystemTime(new Date('2026-05-02T18:00:00.000Z'));
const { scheduler, rawClient, enrichmentService, staleAccountRepository } =
@@ -162,13 +193,8 @@ describe('BackgroundRefreshScheduler', () => {
it('skips candidates already in failure backoff', async () => {
jest.useFakeTimers().setSystemTime(new Date('2026-05-02T18:00:00.000Z'));
const {
scheduler,
garnet,
rateLimiter,
enrichmentService,
staleAccountRepository,
} = makeScheduler();
const { scheduler, garnet, enrichmentService, staleAccountRepository } =
makeScheduler();
staleAccountRepository.findStaleAccounts.mockResolvedValue([
candidate('skip-me'),
]);
@@ -179,7 +205,6 @@ describe('BackgroundRefreshScheduler', () => {
await scheduler.tick();
expect(rateLimiter.acquireBackground).not.toHaveBeenCalled();
expect(enrichmentService.markRefreshRequested).not.toHaveBeenCalled();
expect(enrichmentService.enrichRiotAccount).not.toHaveBeenCalled();
});
@@ -4,7 +4,6 @@ import {
OnModuleDestroy,
OnModuleInit,
} from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import {
type EnrichResult,
RiotAccountEnrichmentService,
@@ -20,11 +19,17 @@ const LEADER_TTL_SECONDS = 90;
const LEADER_RENEW_INTERVAL_MS = 30_000;
const STALE_THRESHOLD_MS = 6 * 60 * 60 * 1000;
const PER_TICK_CANDIDATE_LIMIT = 20;
const ENRICH_COST_TOKENS = 8;
const DAWN_USAGE_RATIO = 0.8;
const OPPORTUNISTIC_USAGE_RATIO = 0.5;
const FAILURE_BACKOFF_KEY_PREFIX = 'riot:bg:fail';
const FAILURE_BACKOFF_THRESHOLD = 3;
const FAILURE_BACKOFF_TTL_SECONDS = 24 * 60 * 60;
interface RefreshGatePolicy {
mode: 'dawn' | 'opportunistic';
usageRatio: number;
}
@Injectable()
export class BackgroundRefreshScheduler
implements OnModuleInit, OnModuleDestroy
@@ -34,26 +39,15 @@ export class BackgroundRefreshScheduler
private leaderRenewTimer?: NodeJS.Timeout;
private tickInProgress = false;
private readonly consumer = `${process.pid}:${Math.random().toString(36).slice(2)}`;
private readonly enabled: boolean;
constructor(
private readonly garnet: GarnetService,
private readonly rateLimiter: RiotRateLimiterService,
private readonly enrichmentService: RiotAccountEnrichmentService,
private readonly staleAccountRepository: StaleAccountRepository,
config: ConfigService,
) {
this.enabled = config.get<string>('RIOT_BG_REFRESH_ENABLED') === 'true';
}
) {}
public onModuleInit(): void {
if (!this.enabled) {
this.logger.log(
'Background Riot refresh is disabled (RIOT_BG_REFRESH_ENABLED).',
);
return;
}
this.tickTimer = setInterval(() => void this.safeTick(), TICK_INTERVAL_MS);
this.leaderRenewTimer = setInterval(
() => void this.renewLeaderIfHeld(),
@@ -87,7 +81,11 @@ export class BackgroundRefreshScheduler
}
private async tick(): Promise<void> {
if (!isInKstBackgroundWindow()) return;
const initialGate = this.currentRefreshGatePolicy();
if (!(await this.rateLimiter.isRefreshWindowOpen(initialGate.usageRatio))) {
return;
}
const isLeader = await this.tryBecomeLeader();
if (!isLeader) return;
@@ -101,15 +99,20 @@ export class BackgroundRefreshScheduler
let processed = 0;
let failed = 0;
let skipped = 0;
let currentGate = initialGate;
for (const candidate of candidates) {
if (!isInKstBackgroundWindow()) break;
currentGate = this.currentRefreshGatePolicy();
if (
!(await this.rateLimiter.isRefreshWindowOpen(currentGate.usageRatio))
) {
break;
}
if (await this.isInFailureBackoff(candidate.puuid)) {
skipped += 1;
continue;
}
await this.rateLimiter.acquireBackground(ENRICH_COST_TOKENS);
await this.enrichmentService.markRefreshRequested(
candidate.userId,
candidate.puuid,
@@ -142,10 +145,18 @@ export class BackgroundRefreshScheduler
}
this.logger.debug(
`Background refresh tick: processed=${processed} failed=${failed} skipped=${skipped} candidates=${candidates.length}`,
`Background refresh tick: processed=${processed} failed=${failed} skipped=${skipped} candidates=${candidates.length} mode=${currentGate.mode} ratio=${currentGate.usageRatio}`,
);
}
private currentRefreshGatePolicy(): RefreshGatePolicy {
const isDawn = isInKstBackgroundWindow();
return {
mode: isDawn ? 'dawn' : 'opportunistic',
usageRatio: isDawn ? DAWN_USAGE_RATIO : OPPORTUNISTIC_USAGE_RATIO,
};
}
private async tryBecomeLeader(): Promise<boolean> {
const current = await this.garnet.getString(LEADER_KEY);
if (current === this.consumer) {
@@ -17,6 +17,7 @@ function execResult<T>(value: T) {
function makeWorker() {
const garnetService = {
acknowledgeStream: jest.fn().mockResolvedValue(undefined),
deleteStreamEntries: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<GarnetService>;
const jobQueueService = {
markProcessing: jest.fn().mockResolvedValue(undefined),
@@ -74,6 +75,32 @@ function makeWorker() {
}
describe('RiotJobWorkerService', () => {
it('acknowledges and deletes invalid stream entries', async () => {
const { worker, garnetService } = makeWorker();
await (
worker as unknown as {
processEntry: (
stream: string,
entry: { id: string; message: Record<string, string> },
) => Promise<void>;
}
).processEntry('riot:queue:high', {
id: 'bad-1',
message: { job: 'not-json' },
});
expect(garnetService.acknowledgeStream).toHaveBeenCalledWith(
'riot:queue:high',
RIOT_JOB_GROUP,
'bad-1',
);
expect(garnetService.deleteStreamEntries).toHaveBeenCalledWith(
'riot:queue:high',
'bad-1',
);
});
it('refreshes league entries while processing user history refresh jobs', async () => {
const { worker, enrichmentService, recentMatchesService, garnetService } =
makeWorker();
@@ -91,12 +118,14 @@ describe('RiotJobWorkerService', () => {
priority: 'high',
};
await (worker as unknown as {
await (
worker as unknown as {
processEntry: (
stream: string,
entry: { id: string; message: Record<string, string> },
) => Promise<void>;
}).processEntry('riot:queue:high', {
}
).processEntry('riot:queue:high', {
id: '1-0',
message: { job: JSON.stringify(job) },
});
@@ -112,5 +141,14 @@ describe('RiotJobWorkerService', () => {
RIOT_JOB_GROUP,
'1-0',
);
expect(garnetService.deleteStreamEntries).toHaveBeenCalledWith(
'riot:queue:high',
'1-0',
);
expect(
garnetService.acknowledgeStream.mock.invocationCallOrder[0],
).toBeLessThan(
garnetService.deleteStreamEntries.mock.invocationCallOrder[0],
);
});
});
@@ -79,10 +79,13 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
}
}
private async processEntry(stream: string, entry: StreamEntry): Promise<void> {
private async processEntry(
stream: string,
entry: StreamEntry,
): Promise<void> {
const job = this.parseJob(entry);
if (!job) {
await this.garnetService.acknowledgeStream(stream, RIOT_JOB_GROUP, entry.id);
await this.acknowledgeAndDelete(stream, entry.id);
return;
}
@@ -134,7 +137,30 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
}`,
);
} finally {
await this.garnetService.acknowledgeStream(stream, RIOT_JOB_GROUP, entry.id);
await this.acknowledgeAndDelete(stream, entry.id);
}
}
private async acknowledgeAndDelete(
stream: string,
id: string,
): Promise<void> {
await this.garnetService.acknowledgeStream(stream, RIOT_JOB_GROUP, id);
await this.deleteAcknowledgedEntry(stream, id);
}
private async deleteAcknowledgedEntry(
stream: string,
id: string,
): Promise<void> {
try {
await this.garnetService.deleteStreamEntries(stream, id);
} catch (error) {
this.logger.warn(
`Failed to delete acknowledged Riot job stream entry ${stream} ${id}: ${
error instanceof Error ? error.message : error
}`,
);
}
}
@@ -192,9 +218,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
return job.kind === 'poll-tournament-result';
}
private isLegacyImportJob(
job: RiotJobPayload,
): job is LegacyImportMemberJob {
private isLegacyImportJob(job: RiotJobPayload): job is LegacyImportMemberJob {
return job.kind === 'legacy-import-member';
}
@@ -219,7 +243,8 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
try {
await this.garnetService.createConsumerGroup(stream, RIOT_JOB_GROUP);
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
const message =
error instanceof Error ? error.message : String(error);
if (!message.includes('BUSYGROUP')) throw error;
}
}),
@@ -70,9 +70,11 @@ function makeAccount(overrides: Partial<FakeAccount> = {}): FakeAccount {
function makeUser(account: FakeAccount) {
const _id = new mongoose.Types.ObjectId();
const communityId = new mongoose.Types.ObjectId();
const save = jest.fn().mockResolvedValue(undefined);
return {
_id,
communityId,
riotAccounts: [account],
save,
};
@@ -86,6 +88,7 @@ function makeService(overrides?: {
mastery?: Partial<RiotChampionMasteryService>;
recentMatches?: Partial<RiotRecentMatchesService>;
recentStats?: Partial<RiotRecentStatsService>;
match?: any;
}) {
const user = overrides?.user;
const userFindById = jest.fn().mockReturnValue({
@@ -102,6 +105,11 @@ function makeService(overrides?: {
}),
}),
});
const matchUpdateManyExec = jest.fn().mockResolvedValue({ modifiedCount: 0 });
const matchModel = {
updateMany: jest.fn().mockReturnValue({ exec: matchUpdateManyExec }),
...overrides?.match,
};
const connectionService = {
getModel: jest.fn().mockImplementation(async (modelName: string) => {
if (modelName === 'user') {
@@ -110,6 +118,9 @@ function makeService(overrides?: {
if (modelName === 'community') {
return { findById: communityFindById };
}
if (modelName === 'match') {
return matchModel;
}
throw new Error(`Unexpected model: ${modelName}`);
}),
} as unknown as ConnectionService;
@@ -160,6 +171,8 @@ function makeService(overrides?: {
masteryService,
recentMatchesService,
recentStatsService,
matchModel,
matchUpdateManyExec,
};
}
@@ -437,6 +450,206 @@ describe('RiotAccountEnrichmentService', () => {
expect(user.save).toHaveBeenCalledTimes(1);
});
it('appends tier history when LP changes without tier or rank changes', async () => {
const recent = new Date(Date.now() - 60_000);
const account = makeAccount({
revisionDate: Date.now() - 60_000,
tiers: [
{
leagueId: 'L1',
queueType: 'RANKED_SOLO_5x5',
tier: 'GOLD',
rank: 'II',
puuid: 'puuid-1',
leaguePoints: 10,
wins: 20,
losses: 12,
fetchedAt: recent,
},
],
tierHistory: [
{
queueType: 'RANKED_SOLO_5x5',
tier: 'GOLD',
rank: 'II',
leaguePoints: 10,
wins: 20,
losses: 12,
recordedAt: recent,
},
],
recentStatsFetchedAt: recent,
recentStatsSummary: createEmptyRiotRecentStatsSummary(),
});
const user = makeUser(account);
const { service } = makeService({
user,
league: {
getEntriesByPuuid: jest.fn().mockResolvedValue([
{
leagueId: 'L1',
queueType: 'RANKED_SOLO_5x5',
tier: 'GOLD',
rank: 'II',
puuid: 'puuid-1',
leaguePoints: 44,
wins: 21,
losses: 12,
},
]),
} as Partial<RiotLeagueService>,
});
await service.refreshLeagueEntries({
userId: user._id,
puuid: 'puuid-1',
platform: 'kr',
});
expect(account.tierHistory).toHaveLength(2);
expect(account.tierHistory.at(-1)).toMatchObject({
queueType: 'RANKED_SOLO_5x5',
tier: 'GOLD',
rank: 'II',
leaguePoints: 44,
wins: 21,
losses: 12,
});
});
it('syncs refreshed league tier into active match participant snapshots', async () => {
const recent = new Date(Date.now() - 60_000);
const account = makeAccount({
revisionDate: Date.now() - 60_000,
tiers: [
{
leagueId: 'L1',
queueType: 'RANKED_SOLO_5x5',
tier: 'GOLD',
rank: 'II',
puuid: 'puuid-1',
leaguePoints: 1,
wins: 1,
losses: 1,
fetchedAt: recent,
},
],
recentStatsFetchedAt: recent,
recentStatsSummary: createEmptyRiotRecentStatsSummary(),
});
const user = makeUser(account);
const { service, matchModel } = makeService({
user,
league: {
getEntriesByPuuid: jest.fn().mockResolvedValue([
{
leagueId: 'L2',
queueType: 'RANKED_SOLO_5x5',
tier: 'PLATINUM',
rank: 'IV',
puuid: 'puuid-1',
leaguePoints: 20,
wins: 10,
losses: 8,
},
]),
} as Partial<RiotLeagueService>,
});
await service.refreshLeagueEntries({
userId: user._id,
puuid: 'puuid-1',
platform: 'kr',
});
expect(matchModel.updateMany).toHaveBeenCalledWith(
{
status: { $in: ['recruiting', 'team-built', 'in-progress'] },
participants: {
$elemMatch: {
userId: user._id,
puuid: 'puuid-1',
},
},
},
{
$set: {
'participants.$[participant].tier': expect.objectContaining({
leagueId: 'L2',
queueType: 'RANKED_SOLO_5x5',
tier: 'PLATINUM',
rank: 'IV',
leaguePoints: 20,
}),
},
},
{
arrayFilters: [
{
'participant.userId': user._id,
'participant.puuid': 'puuid-1',
},
],
},
);
});
it('clears active match participant tier when refreshed league entries are empty', async () => {
const recent = new Date(Date.now() - 60_000);
const account = makeAccount({
revisionDate: Date.now() - 60_000,
tiers: [
{
leagueId: 'L1',
queueType: 'RANKED_SOLO_5x5',
tier: 'GOLD',
rank: 'II',
puuid: 'puuid-1',
leaguePoints: 1,
wins: 1,
losses: 1,
fetchedAt: recent,
},
],
recentStatsFetchedAt: recent,
recentStatsSummary: createEmptyRiotRecentStatsSummary(),
});
const user = makeUser(account);
const { service, matchModel } = makeService({
user,
league: {
getEntriesByPuuid: jest.fn().mockResolvedValue([]),
} as Partial<RiotLeagueService>,
});
await service.refreshLeagueEntries({
userId: user._id,
puuid: 'puuid-1',
platform: 'kr',
});
expect(matchModel.updateMany).toHaveBeenCalledWith(
{
status: { $in: ['recruiting', 'team-built', 'in-progress'] },
participants: {
$elemMatch: {
userId: user._id,
puuid: 'puuid-1',
},
},
},
{ $unset: { 'participants.$[participant].tier': '' } },
{
arrayFilters: [
{
'participant.userId': user._id,
'participant.puuid': 'puuid-1',
},
],
},
);
});
it('records failed for individual failing fetches but updates the rest', async () => {
const account = makeAccount();
const user = makeUser(account);
@@ -3,6 +3,7 @@ import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service';
import {
ChampionMasteryEntry,
MatchStatus,
RiotAccount,
TierInfo,
} from '../global/database/schema';
@@ -33,6 +34,11 @@ const DEFAULT_SUMMONER_TTL_MS = 24 * 60 * 60 * 1000; // 24h
const DEFAULT_LEAGUE_TTL_MS = 60 * 60 * 1000; // 1h
const DEFAULT_MASTERY_TTL_MS = 6 * 60 * 60 * 1000; // 6h
const DEFAULT_RECENT_MATCHES_TTL_MS = 6 * 60 * 60 * 1000; // 6h
const ACTIVE_MATCH_STATUSES: MatchStatus[] = [
'recruiting',
'team-built',
'in-progress',
];
export interface EnrichOptions {
platform?: RiotPlatformRoute;
@@ -117,6 +123,11 @@ export class RiotAccountEnrichmentService {
this.applyLeagueEntries(account, outcome.dto);
await user.save();
await this.syncActiveMatchParticipantTier(
user._id,
params.puuid,
account.tiers,
);
return 'updated';
}
@@ -243,6 +254,13 @@ export class RiotAccountEnrichmentService {
) {
await user.save();
}
if (leagueOutcome.status === 'updated') {
await this.syncActiveMatchParticipantTier(
user._id,
params.puuid,
account.tiers,
);
}
return {
summoner: summonerOutcome.status,
@@ -425,7 +443,10 @@ export class RiotAccountEnrichmentService {
const changed =
!last ||
last.tier !== entry.tier ||
(last.rank ?? '') !== (entry.rank ?? '');
(last.rank ?? '') !== (entry.rank ?? '') ||
last.leaguePoints !== entry.leaguePoints ||
last.wins !== entry.wins ||
last.losses !== entry.losses;
if (!changed) continue;
account.tierHistory.push({
@@ -463,6 +484,62 @@ export class RiotAccountEnrichmentService {
account.matchIdsFetchedAt = fetchedAt;
}
private async syncActiveMatchParticipantTier(
userId: mongoose.Types.ObjectId,
puuid: string,
tiers: TierInfo[],
): Promise<void> {
const MatchModel = await this.connectionService.getModel('match');
const tier = this.selectParticipantTier(tiers);
const update = tier
? { $set: { 'participants.$[participant].tier': tier } }
: { $unset: { 'participants.$[participant].tier': '' } };
await MatchModel.updateMany(
{
status: { $in: ACTIVE_MATCH_STATUSES },
participants: {
$elemMatch: {
userId,
puuid,
},
},
},
update,
{
arrayFilters: [
{
'participant.userId': userId,
'participant.puuid': puuid,
},
],
},
).exec();
}
private selectParticipantTier(tiers: TierInfo[]): TierInfo | undefined {
const tier =
tiers.find((entry) => entry.queueType === 'RANKED_SOLO_5x5') ?? tiers[0];
if (!tier) return undefined;
return {
leagueId: tier.leagueId,
queueType: tier.queueType,
tier: tier.tier,
rank: tier.rank,
puuid: tier.puuid,
leaguePoints: tier.leaguePoints,
wins: tier.wins,
losses: tier.losses,
veteran: tier.veteran,
inactive: tier.inactive,
freshBlood: tier.freshBlood,
hotStreak: tier.hotStreak,
miniSeries: tier.miniSeries,
fetchedAt: tier.fetchedAt,
};
}
private tiersOldestAt(tiers: TierInfo[]): number {
if (tiers.length === 0) return 0;
let oldest = Infinity;
@@ -0,0 +1,47 @@
import { RiotClientService } from './riot.client.service';
import { RiotLeagueService } from './riot-league.service';
import type { RiotLeagueEntryDto, RiotResponseParser } from './riot.types';
describe('RiotLeagueService', () => {
it('accepts Riot league entries without optional leagueId', async () => {
const client = {
get: jest.fn(
async <T>(
_path: string,
_options: unknown,
parser?: RiotResponseParser<T>,
) =>
parser
? parser([
{
queueType: 'RANKED_SOLO_5x5',
tier: 'EMERALD',
rank: 'I',
puuid: 'puuid-1',
leaguePoints: 75,
wins: 160,
losses: 148,
},
])
: ([] as T),
),
} as unknown as RiotClientService;
const service = new RiotLeagueService(client);
const result = await service.getEntriesByPuuid('puuid-1', {
platform: 'kr',
});
expect(result).toEqual<RiotLeagueEntryDto[]>([
{
queueType: 'RANKED_SOLO_5x5',
tier: 'EMERALD',
rank: 'I',
puuid: 'puuid-1',
leaguePoints: 75,
wins: 160,
losses: 148,
},
]);
});
});
@@ -36,7 +36,10 @@ function parseEntry(value: unknown, index: number): RiotLeagueEntryDto {
throw new TypeError(`leagueEntries[${index}] must be an object.`);
}
return {
leagueId: requireString(value.leagueId, `leagueEntries[${index}].leagueId`),
leagueId: optionalString(
value.leagueId,
`leagueEntries[${index}].leagueId`,
),
queueType: requireString(
value.queueType,
`leagueEntries[${index}].queueType`,
@@ -71,6 +74,11 @@ function requireString(value: unknown, path: string): string {
return value;
}
function optionalString(value: unknown, path: string): string | undefined {
if (value === undefined || value === null) return undefined;
return requireString(value, path);
}
function requireNumber(value: unknown, path: string): number {
if (typeof value !== 'number' || !Number.isFinite(value)) {
throw new TypeError(`${path} must be a finite number.`);
@@ -3,63 +3,156 @@ import { RiotRateLimiterService } from './riot-rate-limiter.service';
function makeService(sendCommand = jest.fn().mockResolvedValue(0)) {
const garnet = {
getString: jest.fn().mockResolvedValue(null),
raw: jest.fn().mockReturnValue({ sendCommand }),
} as unknown as GarnetService;
setString: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<GarnetService>;
return {
service: new RiotRateLimiterService(garnet),
garnet,
sendCommand,
};
}
describe('RiotRateLimiterService background limiter', () => {
function observedState(params: {
count120: number;
limit120?: number;
observedAt: number;
windowStartAt: number;
}) {
return JSON.stringify({
count120: params.count120,
limit120: params.limit120 ?? 100,
observedAt: params.observedAt,
windowStartAt: params.windowStartAt,
});
}
describe('RiotRateLimiterService', () => {
afterEach(() => {
jest.restoreAllMocks();
});
it('uses the background key namespace and passes cost to the Lua script', async () => {
it('uses global app rate keys and passes cost to the Lua script', async () => {
jest.spyOn(Date, 'now').mockReturnValue(1_000);
const { service, sendCommand } = makeService();
await service.acquireBackground(8);
await service.acquire('asia', 3);
expect(sendCommand).toHaveBeenCalledTimes(1);
const command = sendCommand.mock.calls[0][0] as string[];
expect(command[0]).toBe('EVAL');
expect(command[2]).toBe('2');
expect(command[3]).toBe('riot:bg:rl:1000');
expect(command[4]).toBe('riot:bg:rl:120000');
expect(command[3]).toBe('riot:rl:app:1000');
expect(command[4]).toBe('riot:rl:app:120000');
expect(command[5]).toBe('1000');
expect(command[7]).toBe('8');
expect(command[7]).toBe('3');
});
it('reads cleaned background usage for both windows', async () => {
jest.spyOn(Date, 'now').mockReturnValue(200_000);
const sendCommand = jest
.fn()
.mockImplementation(async (command: string[]) => {
if (command[0] === 'ZREMRANGEBYSCORE') return 0;
if (command[1] === 'riot:bg:rl:1000') return 3;
if (command[1] === 'riot:bg:rl:120000') return 24;
return 0;
});
const { service } = makeService(sendCommand);
it('records the 120 second app rate observation from Riot headers', async () => {
jest.spyOn(Date, 'now').mockReturnValue(1_000_000);
const { service, garnet } = makeService();
await expect(service.getBackgroundUsage()).resolves.toEqual({
used1s: 3,
used2m: 24,
await service.recordAppRateLimitObservation('47:120,3:1', '100:120,20:1');
expect(garnet.setString).toHaveBeenCalledTimes(1);
const [key, raw, ttl] = garnet.setString.mock.calls[0];
expect(key).toBe('riot:app:rl:observed');
expect(ttl).toBe(300);
expect(JSON.parse(raw)).toEqual({
count120: 47,
limit120: 100,
observedAt: 1_000_000,
windowStartAt: 1_000_000,
});
});
expect(sendCommand).toHaveBeenCalledWith([
'ZREMRANGEBYSCORE',
'riot:bg:rl:1000',
'-inf',
'199000',
]);
expect(sendCommand).toHaveBeenCalledWith([
'ZREMRANGEBYSCORE',
'riot:bg:rl:120000',
'-inf',
'80000',
]);
it('resets the inferred window when Riot count decreases or observation is stale', async () => {
const { service, garnet } = makeService();
jest.spyOn(Date, 'now').mockReturnValue(1_060_000);
garnet.getString.mockResolvedValueOnce(
observedState({
count120: 80,
observedAt: 1_050_000,
windowStartAt: 1_000_000,
}),
);
await service.recordAppRateLimitObservation('2:120', null);
expect(JSON.parse(garnet.setString.mock.calls[0][1])).toMatchObject({
count120: 2,
windowStartAt: 1_060_000,
});
jest.spyOn(Date, 'now').mockReturnValue(1_240_000);
garnet.getString.mockResolvedValueOnce(
observedState({
count120: 20,
observedAt: 1_120_000,
windowStartAt: 1_000_000,
}),
);
await service.recordAppRateLimitObservation('25:120', null);
expect(JSON.parse(garnet.setString.mock.calls[1][1])).toMatchObject({
count120: 25,
windowStartAt: 1_240_000,
});
});
it('opens the refresh gate when there is no active observation', async () => {
const { service, garnet } = makeService();
await expect(service.isRefreshWindowOpen(0.5)).resolves.toBe(true);
garnet.getString.mockResolvedValueOnce(
observedState({
count120: 90,
observedAt: 1_000_000,
windowStartAt: 900_000,
}),
);
jest.spyOn(Date, 'now').mockReturnValue(1_120_000);
await expect(service.isRefreshWindowOpen(0.5)).resolves.toBe(true);
});
it.each([
{ ratio: 0.5, count120: 49, expected: true },
{ ratio: 0.5, count120: 50, expected: false },
{ ratio: 0.8, count120: 79, expected: true },
{ ratio: 0.8, count120: 80, expected: false },
])(
'checks tail headroom for refresh gate ratio=$ratio count=$count120',
async ({ ratio, count120, expected }) => {
jest.spyOn(Date, 'now').mockReturnValue(1_070_000);
const { service, garnet } = makeService();
garnet.getString.mockResolvedValue(
observedState({
count120,
observedAt: 1_069_000,
windowStartAt: 1_000_000,
}),
);
await expect(service.isRefreshWindowOpen(ratio)).resolves.toBe(expected);
},
);
it('keeps the refresh gate closed before the 120 second window tail', async () => {
jest.spyOn(Date, 'now').mockReturnValue(1_050_000);
const { service, garnet } = makeService();
garnet.getString.mockResolvedValue(
observedState({
count120: 10,
observedAt: 1_049_000,
windowStartAt: 1_000_000,
}),
);
await expect(service.isRefreshWindowOpen(0.8)).resolves.toBe(false);
});
});
@@ -7,11 +7,19 @@ const APP_LIMITS = [
{ windowMs: 120_000, max: 90 },
] as const;
const BACKGROUND_LIMITS = [
{ windowMs: 1_000, max: 6 },
{ windowMs: 120_000, max: 36 },
] as const;
const BACKGROUND_KEY_PREFIX = 'riot:bg:rl';
const APP_KEY_PREFIX = 'riot:rl:app';
const APP_WINDOW_MS = 120_000;
const TAIL_MS = 60_000;
const APP_OBSERVED_KEY = 'riot:app:rl:observed';
const APP_OBSERVED_TTL_SECONDS = 300;
const DEFAULT_APP_LIMIT_120 = 100;
interface AppRateObservation {
count120: number;
limit120: number;
observedAt: number;
windowStartAt: number;
}
const ACQUIRE_SCRIPT = `
local now = tonumber(ARGV[1])
@@ -81,85 +89,78 @@ export class RiotRateLimiterService {
public async acquire(
route: RiotRegionalRoute | RiotPlatformRoute,
cost = 1,
): Promise<void> {
for (;;) {
const now = Date.now();
const waitMs = await this.checkAndAdd(route, now, 1);
if (waitMs <= 0) return;
if (waitMs >= 100) {
this.logger.warn(
`Riot API throttle waiting ${waitMs}ms for route=${route}.`,
);
}
await sleep(waitMs);
}
}
public async acquireBackground(cost = 1): Promise<void> {
const normalizedCost = normalizeCost(cost);
for (;;) {
const now = Date.now();
const waitMs = await this.checkAndAddBackground(now, normalizedCost);
const waitMs = await this.checkAndAdd(now, normalizedCost);
if (waitMs <= 0) return;
if (waitMs >= 100) {
this.logger.warn(
`Background Riot throttle waiting ${waitMs}ms (cost=${normalizedCost}).`,
`Riot API throttle waiting ${waitMs}ms for route=${route} cost=${normalizedCost}.`,
);
}
await sleep(waitMs);
}
}
public async getBackgroundUsage(): Promise<{
used1s: number;
used2m: number;
}> {
const client = this.garnet.raw();
const now = Date.now();
const usages = await Promise.all(
BACKGROUND_LIMITS.map(async (limit) => {
const key = `${BACKGROUND_KEY_PREFIX}:${limit.windowMs}`;
await client.sendCommand([
'ZREMRANGEBYSCORE',
key,
'-inf',
String(now - limit.windowMs),
]);
const response = await client.sendCommand(['ZCARD', key]);
const count = Number(response ?? 0);
return Number.isFinite(count) && count > 0 ? count : 0;
}),
);
public async recordAppRateLimitObservation(
countHeader: string | null,
limitHeader?: string | null,
): Promise<void> {
const count120 = parseRateLimitHeader(countHeader, 120);
if (count120 === null) return;
return {
used1s: usages[0] ?? 0,
used2m: usages[1] ?? 0,
const limit120 =
parseRateLimitHeader(limitHeader ?? null, 120) ?? DEFAULT_APP_LIMIT_120;
const now = Date.now();
const previous = await this.getAppRateObservation();
const windowStartAt =
!previous ||
now - previous.observedAt >= APP_WINDOW_MS ||
count120 < previous.count120
? now
: previous.windowStartAt;
const observation: AppRateObservation = {
count120,
limit120,
observedAt: now,
windowStartAt,
};
// Concurrent responses can race here. This observation is advisory, so
// last-writer-wins is acceptable and self-corrects on the next Riot header.
await this.garnet.setString(
APP_OBSERVED_KEY,
JSON.stringify(observation),
APP_OBSERVED_TTL_SECONDS,
);
}
private async checkAndAdd(
route: RiotRegionalRoute | RiotPlatformRoute,
now: number,
cost: number,
): Promise<number> {
public async isRefreshWindowOpen(
usageRatio: number,
now = Date.now(),
): Promise<boolean> {
const observation = await this.getAppRateObservation();
if (!observation) return true;
if (now - observation.observedAt >= APP_WINDOW_MS) return true;
const ratio = Number.isFinite(usageRatio) ? usageRatio : 0;
const headroomOk = observation.count120 < observation.limit120 * ratio;
const inTail = now >= observation.windowStartAt + APP_WINDOW_MS - TAIL_MS;
return headroomOk && inTail;
}
private async checkAndAdd(now: number, cost: number): Promise<number> {
const keys = APP_LIMITS.map(
(limit) => `riot:rl:${route}:${limit.windowMs}`,
(limit) => `${APP_KEY_PREFIX}:${limit.windowMs}`,
);
return this.checkAndAddWithLimits(keys, APP_LIMITS, now, cost);
}
private async checkAndAddBackground(
now: number,
cost: number,
): Promise<number> {
const keys = BACKGROUND_LIMITS.map(
(limit) => `${BACKGROUND_KEY_PREFIX}:${limit.windowMs}`,
);
return this.checkAndAddWithLimits(keys, BACKGROUND_LIMITS, now, cost);
}
private async checkAndAddWithLimits(
keys: string[],
limits: ReadonlyArray<{ windowMs: number; max: number }>,
@@ -187,6 +188,32 @@ export class RiotRateLimiterService {
if (!Number.isFinite(waitMs) || waitMs < 0) return 0;
return waitMs;
}
private async getAppRateObservation(): Promise<AppRateObservation | null> {
const raw = await this.garnet.getString(APP_OBSERVED_KEY);
if (!raw) return null;
try {
const parsed = JSON.parse(raw) as Partial<AppRateObservation>;
if (
typeof parsed.count120 !== 'number' ||
typeof parsed.limit120 !== 'number' ||
typeof parsed.observedAt !== 'number' ||
typeof parsed.windowStartAt !== 'number'
) {
return null;
}
return {
count120: parsed.count120,
limit120: parsed.limit120,
observedAt: parsed.observedAt,
windowStartAt: parsed.windowStartAt,
};
} catch {
return null;
}
}
}
function normalizeCost(cost: number): number {
@@ -194,6 +221,24 @@ function normalizeCost(cost: number): number {
return Math.max(1, Math.floor(cost));
}
function parseRateLimitHeader(
header: string | null,
windowSeconds: number,
): number | null {
if (!header) return null;
for (const rawEntry of header.split(',')) {
const [rawCount, rawWindow] = rawEntry.trim().split(':');
const count = Number(rawCount);
const window = Number(rawWindow);
if (window === windowSeconds && Number.isFinite(count) && count >= 0) {
return count;
}
}
return null;
}
function sleep(ms: number): Promise<void> {
return new Promise((resolve) => setTimeout(resolve, ms));
}
@@ -0,0 +1,43 @@
import { SecretService } from '../global/secret/secret.service';
import { RiotClientService } from './riot.client.service';
import { RiotRateLimiterService } from './riot-rate-limiter.service';
describe('RiotClientService', () => {
const originalFetch = global.fetch;
afterEach(() => {
global.fetch = originalFetch;
jest.restoreAllMocks();
});
it('records Riot app rate limit headers after a response', async () => {
const secretService = {
get: jest.fn().mockResolvedValue('riot-key'),
} as unknown as jest.Mocked<SecretService>;
const rateLimiter = {
acquire: jest.fn().mockResolvedValue(undefined),
recordAppRateLimitObservation: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<RiotRateLimiterService>;
global.fetch = jest.fn().mockResolvedValue({
headers: {
get: jest.fn((name: string) => {
if (name === 'X-App-Rate-Limit-Count') return '47:120,3:1';
if (name === 'X-App-Rate-Limit') return '100:120,20:1';
return null;
}),
},
json: jest.fn().mockResolvedValue({ ok: true }),
ok: true,
status: 200,
} as unknown as Response);
const service = new RiotClientService(secretService, rateLimiter);
await service.get('/lol/status/v4/platform-data', { platform: 'kr' });
expect(rateLimiter.acquire).toHaveBeenCalledWith('kr');
expect(rateLimiter.recordAppRateLimitObservation).toHaveBeenCalledWith(
'47:120,3:1',
'100:120,20:1',
);
});
});
@@ -140,16 +140,18 @@ export class RiotClientService {
});
const appRateLimitCount = response.headers.get('X-App-Rate-Limit-Count');
const appRateLimit = response.headers.get('X-App-Rate-Limit');
void this.rateLimiter.recordAppRateLimitObservation(
appRateLimitCount,
appRateLimit,
);
if (appRateLimitCount && Math.random() < 0.05) {
this.logger.debug(`Riot rate usage ${routeKey}: ${appRateLimitCount}`);
}
if (!response.ok) {
const error = await this.createApiError(response, url);
if (
error.status === 429 &&
attempt === 0
) {
if (error.status === 429 && attempt === 0) {
await sleep((error.retryAfterSeconds ?? 1) * 1000);
return this.fetchWithRetry(
url,
+1 -1
View File
@@ -89,7 +89,7 @@ export interface RiotSummonerDto {
// League-V4 entries by-puuid 응답
export interface RiotLeagueEntryDto {
leagueId: string;
leagueId?: string;
queueType: string;
tier: string;
rank: string;
+1
View File
@@ -25,6 +25,7 @@
"react": "^19.2.4",
"react-dom": "^19.2.4",
"react-router": "^7.14.0",
"recharts": "^3.8.1",
"socket.io-client": "^4.8.3"
},
"devDependencies": {
+9
View File
@@ -171,6 +171,15 @@ export function useUndoAuction(communityId = DEFAULT_COMMUNITY_ID) {
});
}
export function useResetAuction(communityId = DEFAULT_COMMUNITY_ID) {
return useMutation({
mutationFn: ({ matchId }: { matchId: string }) =>
apiFetch<void>(`/communities/${communityId}/matches/${matchId}/auction`, {
method: 'DELETE',
}),
});
}
export function useCreateMatch(communityId = DEFAULT_COMMUNITY_ID) {
return useMutation({
mutationFn: (body: MatchMutationRequest) =>
+12
View File
@@ -460,11 +460,23 @@ export interface ApiUserHistoryProfile {
profileIconId: number;
summonerLevel: number;
tiers: ApiTierInfo[];
tierHistory: ApiTierHistoryEntry[];
season: ApiHistorySeason;
seasons: ApiHistorySeason[];
lastFetchedAt: string | null;
}
export interface ApiTierHistoryEntry {
queueType: string;
tier: string;
rank?: string;
leaguePoints?: number;
wins?: number;
losses?: number;
recordedAt: string;
season?: string;
}
export interface ApiChampionStatsRow {
championId: number;
games: number;
+14
View File
@@ -26,6 +26,10 @@ interface ChatHistoryPayload {
messages?: ApiAuctionChatMessage[];
}
interface ResetPayload {
matchId?: string;
}
const MAX_CHAT_MESSAGES = 200;
function mergeChatMessages(
@@ -47,6 +51,7 @@ export function useAuctionSocket(matchId: string | undefined) {
const socketRef = useRef<Socket | null>(null);
const [auction, setAuction] = useState<ApiAuction | null>(null);
const [chatMessages, setChatMessages] = useState<ApiAuctionChatMessage[]>([]);
const [resetAt, setResetAt] = useState<number | null>(null);
const [connectionStatus, setConnectionStatus] =
useState<ConnectionStatus>('idle');
const [error, setError] = useState<string | null>(null);
@@ -103,6 +108,14 @@ export function useAuctionSocket(matchId: string | undefined) {
setChatMessages((current) => mergeChatMessages(current, [message]));
});
socket.on('reset', (payload: ResetPayload) => {
if (payload.matchId && payload.matchId !== matchId) return;
setAuction(null);
setChatMessages([]);
setResetAt(Date.now());
setError('경매가 취소되었습니다.');
});
socket.on('error', (payload: { message?: string }) => {
setConnectionStatus('error');
setError(payload.message ?? '실시간 경매 연결 중 오류가 발생했습니다.');
@@ -144,6 +157,7 @@ export function useAuctionSocket(matchId: string | undefined) {
return {
auction: visibleAuction,
chatMessages: visibleAuction ? chatMessages : [],
resetAt,
connectionStatus: visibleConnectionStatus,
error,
placeBid(payload: BidPayload) {
@@ -0,0 +1,382 @@
import { useMemo, useState } from "react";
import {
CartesianGrid,
Line,
LineChart,
ReferenceLine,
ResponsiveContainer,
Tooltip,
XAxis,
YAxis,
} from "recharts";
import type { ApiTierHistoryEntry } from "../api/types";
const TIER_NAMES: Record<string, string> = {
IRON: "아이언",
BRONZE: "브론즈",
SILVER: "실버",
GOLD: "골드",
PLATINUM: "플래티넘",
EMERALD: "에메랄드",
DIAMOND: "다이아몬드",
MASTER: "마스터",
GRANDMASTER: "그랜드마스터",
CHALLENGER: "챌린저",
};
// 낮은 티어 → 높은 티어. 인덱스가 사다리값의 기준이 된다.
const TIER_ORDER = [
"IRON",
"BRONZE",
"SILVER",
"GOLD",
"PLATINUM",
"EMERALD",
"DIAMOND",
"MASTER",
"GRANDMASTER",
"CHALLENGER",
];
const APEX_TIERS = new Set(["MASTER", "GRANDMASTER", "CHALLENGER"]);
// 한 티어 = 400, 한 디비전(랭크) = 100, LP는 그대로 더한다.
const TIER_SPAN = 400;
const RANK_SPAN = 100;
const RANK_INDEX: Record<string, number> = { IV: 0, III: 1, II: 2, I: 3 };
const QUEUE_LABELS: Record<string, string> = {
RANKED_SOLO_5x5: "솔로랭크",
RANKED_FLEX_SR: "자유랭크",
};
type PeriodKey = "30" | "90" | "all";
const PERIOD_OPTIONS: { key: PeriodKey; label: string; days: number | null }[] =
[
{ key: "30", label: "최근 30일", days: 30 },
{ key: "90", label: "최근 90일", days: 90 },
{ key: "all", label: "전체", days: null },
];
function tierIndex(tier: string) {
const index = TIER_ORDER.indexOf(tier);
return index === -1 ? 0 : index;
}
// 티어/랭크/LP를 단일 연속 스칼라(사다리값)로 환산한다.
function ladderValue(entry: {
tier: string;
rank?: string;
leaguePoints?: number;
}) {
const base = tierIndex(entry.tier) * TIER_SPAN;
const lp = entry.leaguePoints ?? 0;
if (APEX_TIERS.has(entry.tier)) {
return base + lp;
}
const rankIdx = RANK_INDEX[entry.rank ?? "IV"] ?? 0;
return base + rankIdx * RANK_SPAN + lp;
}
function normalizeRank(rank: string | undefined) {
switch (rank) {
case "I":
return "1";
case "II":
return "2";
case "III":
return "3";
case "IV":
return "4";
default:
return rank ?? "";
}
}
function formatTierLabel(entry: {
tier: string;
rank?: string;
leaguePoints?: number;
}) {
const name = TIER_NAMES[entry.tier] ?? entry.tier;
if (APEX_TIERS.has(entry.tier)) {
return `${name} ${entry.leaguePoints ?? 0}LP`;
}
const rank = normalizeRank(entry.rank);
return `${name}${rank ? ` ${rank}` : ""} · ${entry.leaguePoints ?? 0}LP`;
}
function formatTierShort(tier: string) {
return TIER_NAMES[tier] ?? tier;
}
function formatDate(ms: number) {
return new Intl.DateTimeFormat("ko-KR", {
month: "numeric",
day: "numeric",
}).format(new Date(ms));
}
type ChartPoint = {
ts: number;
value: number;
tier: string;
rank?: string;
leaguePoints?: number;
wins?: number;
losses?: number;
};
function TierTooltip({
active,
payload,
}: {
active?: boolean;
payload?: Array<{ payload: ChartPoint }>;
}) {
if (!active || !payload?.length) return null;
const point = payload[0].payload;
const games =
point.wins !== undefined && point.losses !== undefined
? ` · ${point.wins}승 ${point.losses}패`
: "";
return (
<div className="border border-base-content/15 bg-base-100 px-3 py-2 text-[11px] shadow-lg">
<div className="font-bold text-base-content">{formatTierLabel(point)}</div>
<div className="mt-0.5 text-base-content/45">
{new Intl.DateTimeFormat("ko-KR", {
year: "numeric",
month: "long",
day: "numeric",
}).format(new Date(point.ts))}
{games}
</div>
</div>
);
}
export default function TierHistoryChart({
entries,
}: {
entries: ApiTierHistoryEntry[];
}) {
// 데이터에 존재하는 큐 목록 (솔로 우선)
const availableQueues = useMemo(() => {
const queues = new Set(entries.map((entry) => entry.queueType));
return ["RANKED_SOLO_5x5", "RANKED_FLEX_SR"].filter((queue) =>
queues.has(queue),
);
}, [entries]);
const [queue, setQueue] = useState(
availableQueues[0] ?? "RANKED_SOLO_5x5",
);
const [period, setPeriod] = useState<PeriodKey>("all");
const activeQueue = availableQueues.includes(queue)
? queue
: (availableQueues[0] ?? "RANKED_SOLO_5x5");
const points = useMemo<ChartPoint[]>(() => {
const periodDays =
PERIOD_OPTIONS.find((option) => option.key === period)?.days ?? null;
const cutoff =
periodDays === null ? 0 : Date.now() - periodDays * 24 * 60 * 60 * 1000;
return entries
.filter((entry) => entry.queueType === activeQueue)
.map((entry) => ({
ts: new Date(entry.recordedAt).getTime(),
value: ladderValue(entry),
tier: entry.tier,
rank: entry.rank,
leaguePoints: entry.leaguePoints,
wins: entry.wins,
losses: entry.losses,
}))
.filter((point) => point.ts >= cutoff)
.sort((left, right) => left.ts - right.ts);
}, [entries, activeQueue, period]);
// 티어 경계(가로 점선) 후보 — 데이터 범위 안에 드는 티어 floor만.
const tierLines = useMemo(() => {
if (points.length === 0) return [];
const min = Math.min(...points.map((point) => point.value));
const max = Math.max(...points.map((point) => point.value));
return TIER_ORDER.map((tier, index) => ({
tier,
value: index * TIER_SPAN,
})).filter((line) => line.value >= min - TIER_SPAN && line.value <= max);
}, [points]);
const summary = useMemo(() => {
if (points.length === 0) return null;
const first = points[0];
const last = points[points.length - 1];
const peak = points.reduce((best, point) =>
point.value > best.value ? point : best,
);
const direction =
last.value > first.value
? "up"
: last.value < first.value
? "down"
: "flat";
return { first, last, peak, direction };
}, [points]);
const header = (
<div className="flex flex-wrap items-center justify-between gap-2 border-b border-base-content/10 bg-base-200/40 px-4 py-2.5">
<h2 className="text-[11px] font-bold uppercase tracking-wider text-base-content/40">
티어 변동
</h2>
<div className="flex items-center gap-1.5">
{availableQueues.length > 1 &&
availableQueues.map((option) => (
<button
key={option}
type="button"
onClick={() => setQueue(option)}
className={`h-7 px-2 text-[11px] font-semibold border transition-colors ${
activeQueue === option
? "border-primary/30 bg-primary/5 text-primary"
: "border-base-content/10 text-base-content/40 hover:text-base-content/70"
}`}
>
{QUEUE_LABELS[option] ?? option}
</button>
))}
<select
className="h-7 border border-base-content/10 bg-base-100 px-2 text-[11px] text-base-content focus:border-primary/30 focus:outline-none"
value={period}
onChange={(event) => setPeriod(event.target.value as PeriodKey)}
>
{PERIOD_OPTIONS.map((option) => (
<option key={option.key} value={option.key}>
{option.label}
</option>
))}
</select>
</div>
</div>
);
return (
<section className="border border-base-content/10 bg-base-100 mb-5 overflow-hidden">
{header}
{points.length < 2 ? (
<div className="px-4 py-10 text-center text-xs text-base-content/35">
티어 변동 기록이 아직 부족해요.
<br />
정보를 갱신할수록 변화가 쌓여 그래프로 보여드릴게요.
</div>
) : (
<>
<div className="px-2 pt-4 pb-1">
<ResponsiveContainer width="100%" height={220}>
<LineChart
data={points}
margin={{ top: 8, right: 16, bottom: 4, left: 4 }}
>
<CartesianGrid
strokeDasharray="3 3"
stroke="currentColor"
className="text-base-content/5"
vertical={false}
/>
{tierLines.map((line) => (
<ReferenceLine
key={line.tier}
y={line.value}
stroke="currentColor"
className="text-base-content/15"
strokeDasharray="2 4"
label={{
value: formatTierShort(line.tier),
position: "insideLeft",
fill: "currentColor",
fontSize: 10,
className: "text-base-content/35",
}}
/>
))}
<XAxis
dataKey="ts"
type="number"
scale="time"
domain={["dataMin", "dataMax"]}
tickFormatter={formatDate}
tick={{ fontSize: 10, fill: "currentColor" }}
className="text-base-content/40"
stroke="currentColor"
minTickGap={28}
/>
<YAxis
type="number"
domain={["dataMin - 60", "dataMax + 60"]}
hide
/>
<Tooltip
content={<TierTooltip />}
cursor={{
stroke: "currentColor",
strokeDasharray: "3 3",
className: "text-base-content/20",
}}
/>
<Line
type="monotone"
dataKey="value"
stroke="currentColor"
className="text-primary"
strokeWidth={2}
dot={{ r: 2.5, className: "text-primary", fill: "currentColor" }}
activeDot={{ r: 4 }}
isAnimationActive={false}
/>
</LineChart>
</ResponsiveContainer>
</div>
{summary && (
<div className="flex flex-wrap items-center gap-x-5 gap-y-1 border-t border-base-content/8 px-4 py-2.5 text-[11px]">
<span className="text-base-content/45">
현재{" "}
<span className="font-bold text-base-content/75">
{formatTierLabel(summary.last)}
</span>
</span>
<span className="text-base-content/45">
최고{" "}
<span className="font-bold text-amber-400">
{formatTierLabel(summary.peak)}
</span>
</span>
<span className="text-base-content/45">
기간 변동{" "}
<span
className={`font-bold ${
summary.direction === "up"
? "text-green-500"
: summary.direction === "down"
? "text-red-400"
: "text-base-content/55"
}`}
>
{formatTierShort(summary.first.tier)}
{summary.direction === "up"
? " ▲ "
: summary.direction === "down"
? " ▼ "
: " · "}
{formatTierShort(summary.last.tier)}
</span>
</span>
</div>
)}
</>
)}
</section>
);
}
+153 -2
View File
@@ -7,14 +7,15 @@ import {
type KeyboardEvent,
} from 'react';
import { useQueryClient } from '@tanstack/react-query';
import { SendHorizontal } from 'lucide-react';
import { Link, useLocation, useParams } from 'react-router';
import { AlertTriangle, SendHorizontal } from 'lucide-react';
import { Link, useLocation, useNavigate, useParams } from 'react-router';
import {
useAuction,
useAuctionHistory,
useDdragonManifest,
useMatch,
useMe,
useResetAuction,
useUndoAuction,
} from '../api/hooks';
import {
@@ -728,6 +729,7 @@ function BidLog({ bids }: { bids: AuctionStateView['bids'] }) {
export default function AuctionPage() {
const { id } = useParams();
const location = useLocation();
const navigate = useNavigate();
const queryClient = useQueryClient();
const meQuery = useMe();
const currentUser =
@@ -747,17 +749,42 @@ export default function AuctionPage() {
refetchInterval: 3000,
});
const undoMutation = useUndoAuction(DEFAULT_COMMUNITY_ID);
const resetAuctionMutation = useResetAuction(DEFAULT_COMMUNITY_ID);
const socket = useAuctionSocket(id);
const captainTeamIndex = useDevCaptainTeamIndex();
const [now, setNow] = useState(() => Date.now());
const [assignedPosition, setAssignedPosition] = useState<Position>('MID');
const [showCancelModal, setShowCancelModal] = useState(false);
const [cancelConfirmText, setCancelConfirmText] = useState('');
const cancelConfirmInputRef = useRef<HTMLInputElement>(null);
const historyBackTo = `${location.pathname}${location.search}${location.hash}`;
const canConfirmAuctionCancel = cancelConfirmText.trim() === '예';
async function invalidateAuctionData() {
if (!id) return;
await Promise.all([
queryClient.invalidateQueries({
queryKey: ['auction', DEFAULT_COMMUNITY_ID, id],
}),
queryClient.invalidateQueries({
queryKey: ['auction-history', DEFAULT_COMMUNITY_ID, id],
}),
queryClient.invalidateQueries({
queryKey: ['match', DEFAULT_COMMUNITY_ID, id],
}),
]);
}
useEffect(() => {
const timer = window.setInterval(() => setNow(Date.now()), 1000);
return () => window.clearInterval(timer);
}, []);
useEffect(() => {
if (!showCancelModal) return;
cancelConfirmInputRef.current?.focus();
}, [showCancelModal]);
const liveAuction = pickLatestAuction(socket.auction, auctionQuery.data);
const auctionState =
liveAuction && matchQuery.data
@@ -788,6 +815,13 @@ export default function AuctionPage() {
}
}, [availableTeamIndexes, captainTeamIndex]);
useEffect(() => {
if (!socket.resetAt || !id) return;
void invalidateAuctionData().finally(() => {
navigate(`/match/${id}`, { replace: true });
});
}, [id, navigate, socket.resetAt]);
if (!DEFAULT_COMMUNITY_ID) {
return (
<main className="max-w-5xl mx-auto px-4 py-20 text-center">
@@ -862,6 +896,21 @@ export default function AuctionPage() {
);
}
function handleResetAuction() {
if (!id || !canConfirmAuctionCancel) return;
resetAuctionMutation.mutate(
{ matchId: id },
{
onSuccess: async () => {
setShowCancelModal(false);
setCancelConfirmText('');
await invalidateAuctionData();
navigate(`/match/${id}`, { replace: true });
},
},
);
}
const undoPanel = canManageAuction ? (
<div className="border border-base-content/10 bg-base-100 p-4 space-y-3">
<div className="text-[10px] font-bold uppercase tracking-wider text-base-content/35">
@@ -930,6 +979,12 @@ export default function AuctionPage() {
</div>
)}
{resetAuctionMutation.error instanceof Error && (
<div className="mb-4 border border-red-500/20 bg-red-500/10 px-4 py-3 text-sm text-red-500">
{resetAuctionMutation.error.message}
</div>
)}
<div className="mb-5 flex items-start justify-between flex-wrap gap-3">
<div>
<h1 className="text-xl font-bold text-base-content leading-tight">
@@ -1101,6 +1156,23 @@ export default function AuctionPage() {
다음 선수
</button>
)}
<div className="border-t border-base-content/10 pt-3">
<button
type="button"
className="btn btn-outline btn-error btn-sm inline-flex items-center gap-1.5 px-4 text-xs"
onClick={() => {
setCancelConfirmText('');
setShowCancelModal(true);
}}
disabled={resetAuctionMutation.isPending}
>
<AlertTriangle className="h-3.5 w-3.5" />
경매 진행 취소
</button>
<p className="mt-2 text-[11px] leading-relaxed text-base-content/35">
경매 데이터와 진행 기록을 삭제하고 내전을 모집 상태로 되돌립니다.
</p>
</div>
</div>
)}
{undoPanel}
@@ -1138,6 +1210,85 @@ export default function AuctionPage() {
className="h-[420px]"
/>
</div>
{showCancelModal && (
<div
className="fixed inset-0 z-50 flex items-center justify-center bg-black/55 px-4"
role="dialog"
aria-modal="true"
aria-labelledby="auction-cancel-title"
>
<div className="w-full max-w-md border border-red-500/25 bg-base-100 p-5 shadow-2xl">
<div className="flex items-start gap-3">
<span className="inline-flex h-9 w-9 shrink-0 items-center justify-center border border-red-500/25 bg-red-500/10 text-red-400">
<AlertTriangle className="h-4 w-4" />
</span>
<div className="min-w-0">
<h2
id="auction-cancel-title"
className="text-base font-bold text-base-content"
>
경매 진행 취소
</h2>
<p className="mt-2 text-sm leading-6 text-base-content/60">
정말 경매를 취소하고 모집 상태로 되돌리시겠습니까?
경매 데이터, 입찰 기록, 팀 배정 정보가 삭제됩니다.
</p>
</div>
</div>
<label
htmlFor="auction-cancel-confirm"
className="mt-5 block text-[11px] font-bold uppercase tracking-wider text-base-content/40"
>
계속하려면 예 입력
</label>
<input
id="auction-cancel-confirm"
ref={cancelConfirmInputRef}
value={cancelConfirmText}
onChange={(event) => setCancelConfirmText(event.target.value)}
onKeyDown={(event) => {
if (event.key === 'Escape') {
setShowCancelModal(false);
setCancelConfirmText('');
}
if (event.key === 'Enter' && canConfirmAuctionCancel) {
handleResetAuction();
}
}}
className="mt-2 h-10 w-full border border-base-content/15 bg-base-100 px-3 text-sm text-base-content outline-none transition-colors focus:border-red-400/60"
placeholder="예"
/>
<div className="mt-5 flex flex-wrap justify-end gap-2">
<button
type="button"
className="btn btn-ghost btn-sm px-4 text-xs"
onClick={() => {
setShowCancelModal(false);
setCancelConfirmText('');
}}
disabled={resetAuctionMutation.isPending}
>
닫기
</button>
<button
type="button"
className="btn btn-error btn-sm px-4 text-xs"
onClick={handleResetAuction}
disabled={
!canConfirmAuctionCancel || resetAuctionMutation.isPending
}
>
{resetAuctionMutation.isPending
? '취소 처리 중...'
: '경매 취소 진행'}
</button>
</div>
</div>
</div>
)}
</main>
);
}
+13 -1
View File
@@ -1,4 +1,4 @@
import { useState } from "react";
import { lazy, Suspense, useState } from "react";
import { useQueryClient } from "@tanstack/react-query";
import { ChevronDown, ChevronUp } from "lucide-react";
import { Link, useLocation, useParams, useSearchParams } from "react-router";
@@ -43,6 +43,8 @@ import {
QUEUE_GROUP_TABS,
RANK_FILTER_TABS,
} from "../lib/riot-history";
// recharts가 무거워 메인 번들에서 분리한다 (전적 페이지에서만 로드).
const TierHistoryChart = lazy(() => import("../components/TierHistoryChart"));
type ChampionSortKey = "games" | "winRate" | "kda" | "avgCsPerMin";
@@ -1294,6 +1296,16 @@ export default function UserHistoryPage() {
)}
</section>
{profile.tierHistory.length > 0 && (
<Suspense
fallback={
<div className="mb-5 h-[180px] border border-base-content/10 bg-base-100" />
}
>
<TierHistoryChart entries={profile.tierHistory} />
</Suspense>
)}
<section className="border border-base-content/10 bg-base-100 mb-5">
<div className="flex flex-wrap border-b border-base-content/8">
{QUEUE_GROUP_TABS.map((tab) => (
+60 -1
View File
@@ -1,10 +1,69 @@
import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
import tailwindcss from "@tailwindcss/vite";
import { createRequire } from "node:module";
import fs from "node:fs";
import path from "node:path";
const ES_TOOLKIT_COMPAT_RE = /^es-toolkit\/compat\/[A-Za-z0-9_$]+$/;
const VIRTUAL_ES_TOOLKIT_COMPAT_PREFIX = "\0es-toolkit-compat-esm:";
function esToolkitCompatEsm() {
return {
name: "es-toolkit-compat-esm",
enforce: "pre" as const,
resolveId(source: string, importer?: string) {
if (!importer || !ES_TOOLKIT_COMPAT_RE.test(source)) {
return null;
}
const requireFromImporter = createRequire(importer);
const wrapperPath = requireFromImporter.resolve(source);
const wrapperSource = fs.readFileSync(wrapperPath, "utf8");
const wrapperMatch = wrapperSource.match(
/require\(['"](\.\.\/dist\/compat\/[^'"]+)\.js['"]\)\.([A-Za-z0-9_$]+)/,
);
if (!wrapperMatch) {
return null;
}
const [, esmPathWithoutExtension, exportName] = wrapperMatch;
const esmPath = path.resolve(
path.dirname(wrapperPath),
`${esmPathWithoutExtension}.mjs`,
);
return `${VIRTUAL_ES_TOOLKIT_COMPAT_PREFIX}${encodeURIComponent(
exportName,
)}:${encodeURIComponent(esmPath)}`;
},
load(id: string) {
if (!id.startsWith(VIRTUAL_ES_TOOLKIT_COMPAT_PREFIX)) {
return null;
}
const [encodedExportName, encodedEsmPath] = id
.slice(VIRTUAL_ES_TOOLKIT_COMPAT_PREFIX.length)
.split(":");
const exportName = decodeURIComponent(encodedExportName);
const esmPath = decodeURIComponent(encodedEsmPath);
return `export { ${exportName} as default, ${exportName} } from ${JSON.stringify(
esmPath,
)};`;
},
};
}
// https://vite.dev/config/
export default defineConfig({
plugins: [react(), tailwindcss()],
plugins: [esToolkitCompatEsm(), react(), tailwindcss()],
optimizeDeps: {
rolldownOptions: {
plugins: [esToolkitCompatEsm()],
},
},
server: {
host: "0.0.0.0",
allowedHosts: ["126.dahyeon.us"],
+313
View File
@@ -159,6 +159,9 @@ importers:
react-router:
specifier: ^7.14.0
version: 7.14.0(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
recharts:
specifier: ^3.8.1
version: 3.8.1(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react-is@18.3.1)(react@19.2.5)(redux@5.0.1)
socket.io-client:
specifier: ^4.8.3
version: 4.8.3
@@ -1437,6 +1440,17 @@ packages:
peerDependencies:
'@redis/client': ^5.12.1
'@reduxjs/toolkit@2.12.0':
resolution: {integrity: sha512-KiT+RzZbp6mQET+Mg+h2c97+9j1sNflUxQkIHI7Yuzf6Peu+OYpmkn6nbHWmLLWj+1ZODUJFwGZ7gx3L9R9EOw==}
peerDependencies:
react: ^16.9.0 || ^17.0.0 || ^18 || ^19
react-redux: ^7.2.1 || ^8.1.3 || ^9.0.0
peerDependenciesMeta:
react:
optional: true
react-redux:
optional: true
'@rolldown/binding-android-arm64@1.0.0-rc.15':
resolution: {integrity: sha512-YYe6aWruPZDtHNpwu7+qAHEMbQ/yRl6atqb/AhznLTnD3UY99Q1jE7ihLSahNWkF4EqRPVC4SiR4O0UkLK02tA==}
engines: {node: ^20.19.0 || >=22.12.0}
@@ -1722,6 +1736,12 @@ packages:
'@speed-highlight/core@1.2.15':
resolution: {integrity: sha512-BMq1K3DsElxDWawkX6eLg9+CKJrTVGCBAWVuHXVUV2u0s2711qiChLSId6ikYPfxhdYocLNt3wWwSvDiTvFabw==}
'@standard-schema/spec@1.1.0':
resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
'@standard-schema/utils@0.3.0':
resolution: {integrity: sha512-e7Mew686owMaPJVNNLs55PUvgz371nKgwsc4vxE49zsODpJEnxgxRo2y/OKrqueavXgZNMDVj3DdHFlaSAeU8g==}
'@tailwindcss/node@4.2.2':
resolution: {integrity: sha512-pXS+wJ2gZpVXqFaUEjojq7jzMpTGf8rU6ipJz5ovJV6PUGmlJ+jvIwGrzdHdQ80Sg+wmQxUFuoW1UAAwHNEdFA==}
@@ -1866,6 +1886,33 @@ packages:
'@types/cors@2.8.19':
resolution: {integrity: sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==}
'@types/d3-array@3.2.2':
resolution: {integrity: sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==}
'@types/d3-color@3.1.3':
resolution: {integrity: sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==}
'@types/d3-ease@3.0.2':
resolution: {integrity: sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA==}
'@types/d3-interpolate@3.0.4':
resolution: {integrity: sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==}
'@types/d3-path@3.1.1':
resolution: {integrity: sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg==}
'@types/d3-scale@4.0.9':
resolution: {integrity: sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw==}
'@types/d3-shape@3.1.8':
resolution: {integrity: sha512-lae0iWfcDeR7qt7rA88BNiqdvPS5pFVPpo5OfjElwNaT2yyekbM0C9vK+yqBqEmHr6lDkRnYNoTBYlAgJa7a4w==}
'@types/d3-time@3.0.4':
resolution: {integrity: sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g==}
'@types/d3-timer@3.0.2':
resolution: {integrity: sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw==}
'@types/eslint-scope@3.7.7':
resolution: {integrity: sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg==}
@@ -1934,6 +1981,9 @@ packages:
'@types/supertest@7.2.0':
resolution: {integrity: sha512-uh2Lv57xvggst6lCqNdFAmDSvoMG7M/HDtX4iUCquxQ5EGPtaPM5PL5Hmi7LCvOG8db7YaCPNJEeoI8s/WzIQw==}
'@types/use-sync-external-store@0.0.6':
resolution: {integrity: sha512-zFDAD+tlpf2r4asuHEj0XH6pY6i0g5NeAHPn+15wk3BV6JA69eERFXC1gyGThDkVa1zCyKr5jox1+2LbV/AMLg==}
'@types/validator@13.15.10':
resolution: {integrity: sha512-T8L6i7wCuyoK8A/ZeLYt1+q0ty3Zb9+qbSSvrIVitzT3YjZqkTZ40IbRsPanlB4h1QB3JVL1SYCdR6ngtFYcuA==}
@@ -2473,6 +2523,10 @@ packages:
resolution: {integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==}
engines: {node: '>=0.8'}
clsx@2.1.1:
resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==}
engines: {node: '>=6'}
cluster-key-slot@1.1.2:
resolution: {integrity: sha512-RMr0FhtfXemyinomL4hrWcYJxmX6deFdCxpJzhDttxgO1+bcCnkk+9drydLVDmAMG7NE6aN/fl4F7ucU/90gAA==}
engines: {node: '>=0.10.0'}
@@ -2569,6 +2623,50 @@ packages:
csstype@3.2.3:
resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
d3-array@3.2.4:
resolution: {integrity: sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==}
engines: {node: '>=12'}
d3-color@3.1.0:
resolution: {integrity: sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==}
engines: {node: '>=12'}
d3-ease@3.0.1:
resolution: {integrity: sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==}
engines: {node: '>=12'}
d3-format@3.1.2:
resolution: {integrity: sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg==}
engines: {node: '>=12'}
d3-interpolate@3.0.1:
resolution: {integrity: sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==}
engines: {node: '>=12'}
d3-path@3.1.0:
resolution: {integrity: sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ==}
engines: {node: '>=12'}
d3-scale@4.0.2:
resolution: {integrity: sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==}
engines: {node: '>=12'}
d3-shape@3.2.0:
resolution: {integrity: sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==}
engines: {node: '>=12'}
d3-time-format@4.1.0:
resolution: {integrity: sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==}
engines: {node: '>=12'}
d3-time@3.1.0:
resolution: {integrity: sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==}
engines: {node: '>=12'}
d3-timer@3.0.1:
resolution: {integrity: sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==}
engines: {node: '>=12'}
daisyui@5.5.19:
resolution: {integrity: sha512-pbFAkl1VCEh/MPCeclKL61I/MqRIFFhNU7yiXoDDRapXN4/qNCoMxeCCswyxEEhqL5eiTTfwHvucFtOE71C9sA==}
@@ -2581,6 +2679,9 @@ packages:
supports-color:
optional: true
decimal.js-light@2.5.1:
resolution: {integrity: sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==}
dedent@1.7.2:
resolution: {integrity: sha512-WzMx3mW98SN+zn3hgemf4OzdmyNhhhKz5Ay0pUfQiMQ3e1g+xmTJWp/pKdwKVXhdSkAEGIIzqeuWrL3mV/AXbA==}
peerDependencies:
@@ -2701,6 +2802,9 @@ packages:
resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==}
engines: {node: '>= 0.4'}
es-toolkit@1.47.0:
resolution: {integrity: sha512-n1GuoD0WEQZMBk5tttoZSqwgyLx01oqa5XsBmCHwPyNe1S9jPBEmtR2pSgp2kJuWE3ciFZ6yRHmY4pM4C3OOkw==}
esbuild@0.27.3:
resolution: {integrity: sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==}
engines: {node: '>=18'}
@@ -2815,6 +2919,9 @@ packages:
resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==}
engines: {node: '>= 0.6'}
eventemitter3@5.0.4:
resolution: {integrity: sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==}
events@3.3.0:
resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==}
engines: {node: '>=0.8.x'}
@@ -3069,6 +3176,12 @@ packages:
resolution: {integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==}
engines: {node: '>= 4'}
immer@10.2.0:
resolution: {integrity: sha512-d/+XTN3zfODyjr89gM3mPq1WNX2B8pYsu7eORitdwyA2sBubnTl3laYlBk4sXY5FUa5qTZGBDPJICVbvqzjlbw==}
immer@11.1.8:
resolution: {integrity: sha512-/tbkHMW7y10Lx6i1crLjD4/OhNkRG+Fo7byZHtah0547nIeXYcpIXaUh0IAQY6gO5459qpGGYapcEOHtFXkIuA==}
import-fresh@3.3.1:
resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==}
engines: {node: '>=6'}
@@ -3089,6 +3202,10 @@ packages:
inherits@2.0.4:
resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
internmap@2.0.3:
resolution: {integrity: sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==}
engines: {node: '>=12'}
ipaddr.js@1.9.1:
resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==}
engines: {node: '>= 0.10'}
@@ -3867,6 +3984,18 @@ packages:
react-is@18.3.1:
resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==}
react-redux@9.3.0:
resolution: {integrity: sha512-KQopgqFo/p/fgmAs5qz6p5RWaNAzq40WAu7fJIXnQpYxFPbJYtsJPWvGeF2rOBaY/kEuV77AVsX8TsQzKm+A/g==}
peerDependencies:
'@types/react': ^18.2.25 || ^19
react: ^18.0 || ^19
redux: ^5.0.0
peerDependenciesMeta:
'@types/react':
optional: true
redux:
optional: true
react-router@7.14.0:
resolution: {integrity: sha512-m/xR9N4LQLmAS0ZhkY2nkPA1N7gQ5TUVa5n8TgANuDTARbn1gt+zLPXEm7W0XDTbrQ2AJSJKhoa6yx1D8BcpxQ==}
engines: {node: '>=20.0.0'}
@@ -3889,10 +4018,26 @@ packages:
resolution: {integrity: sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==}
engines: {node: '>= 14.18.0'}
recharts@3.8.1:
resolution: {integrity: sha512-mwzmO1s9sFL0TduUpwndxCUNoXsBw3u3E/0+A+cLcrSfQitSG62L32N69GhqUrrT5qKcAE3pCGVINC6pqkBBQg==}
engines: {node: '>=18'}
peerDependencies:
react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
react-dom: ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
react-is: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
redis@5.12.1:
resolution: {integrity: sha512-LDsoVvb/CpoV9EN3FXvgvSHNJWuCIzl9MiO3ppOevuGLpSGJhwfQjpEwfFJcQvNSddHADDdZaWx0HnmMxRXG7g==}
engines: {node: '>= 18.19.0'}
redux-thunk@3.1.0:
resolution: {integrity: sha512-NW2r5T6ksUKXCabzhL9z+h206HQw/NJkcLm1GPImRQ8IzfXwRGqjVhKJGauHirT0DAuyy6hjdnMZaRoAcy0Klw==}
peerDependencies:
redux: ^5.0.0
redux@5.0.1:
resolution: {integrity: sha512-M9/ELqF6fy8FwmkpnF0S3YKOqMyoWJ4+CS5Efg2ct3oY9daQvd/Pc71FpGZsVsbl3Cpb+IIcjBDUnnyBdQbq4w==}
reflect-metadata@0.2.2:
resolution: {integrity: sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==}
@@ -3904,6 +4049,9 @@ packages:
resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==}
engines: {node: '>=0.10.0'}
reselect@5.1.1:
resolution: {integrity: sha512-K/BG6eIky/SBpzfHZv/dd+9JBFiS4SWV7FIujVyJRux6e45+73RaUHXLmIR1f7WOMaQ0U1km6qwklRQxpJJY0w==}
resolve-cwd@3.0.0:
resolution: {integrity: sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==}
engines: {node: '>=8'}
@@ -4187,6 +4335,9 @@ packages:
resolution: {integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==}
engines: {node: '>=8'}
tiny-invariant@1.3.3:
resolution: {integrity: sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==}
tinyglobby@0.2.16:
resolution: {integrity: sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==}
engines: {node: '>=12.0.0'}
@@ -4365,6 +4516,11 @@ packages:
uri-js@4.4.1:
resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
use-sync-external-store@1.6.0:
resolution: {integrity: sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==}
peerDependencies:
react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
util-deprecate@1.0.2:
resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
@@ -4383,6 +4539,9 @@ packages:
resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==}
engines: {node: '>= 0.8'}
victory-vendor@37.3.6:
resolution: {integrity: sha512-SbPDPdDBYp+5MJHhBCAyI7wKM3d5ivekigc2Dk2s7pgbZ9wIgIBYGVw4zGHBml/qTFbexrofXW6Gu4noGxrOwQ==}
vite@8.0.8:
resolution: {integrity: sha512-dbU7/iLVa8KZALJyLOBOQ88nOXtNG8vxKuOT4I2mD+Ya70KPceF4IAmDsmU0h1Qsn5bPrvsY9HJstCRh3hG6Uw==}
engines: {node: ^20.19.0 || >=22.12.0}
@@ -6119,6 +6278,18 @@ snapshots:
dependencies:
'@redis/client': 5.12.1
'@reduxjs/toolkit@2.12.0(react-redux@9.3.0(@types/react@19.2.14)(react@19.2.5)(redux@5.0.1))(react@19.2.5)':
dependencies:
'@standard-schema/spec': 1.1.0
'@standard-schema/utils': 0.3.0
immer: 11.1.8
redux: 5.0.1
redux-thunk: 3.1.0(redux@5.0.1)
reselect: 5.1.1
optionalDependencies:
react: 19.2.5
react-redux: 9.3.0(@types/react@19.2.14)(react@19.2.5)(redux@5.0.1)
'@rolldown/binding-android-arm64@1.0.0-rc.15':
optional: true
@@ -6460,6 +6631,10 @@ snapshots:
'@speed-highlight/core@1.2.15': {}
'@standard-schema/spec@1.1.0': {}
'@standard-schema/utils@0.3.0': {}
'@tailwindcss/node@4.2.2':
dependencies:
'@jridgewell/remapping': 2.3.5
@@ -6593,6 +6768,30 @@ snapshots:
dependencies:
'@types/node': 24.12.2
'@types/d3-array@3.2.2': {}
'@types/d3-color@3.1.3': {}
'@types/d3-ease@3.0.2': {}
'@types/d3-interpolate@3.0.4':
dependencies:
'@types/d3-color': 3.1.3
'@types/d3-path@3.1.1': {}
'@types/d3-scale@4.0.9':
dependencies:
'@types/d3-time': 3.0.4
'@types/d3-shape@3.1.8':
dependencies:
'@types/d3-path': 3.1.1
'@types/d3-time@3.0.4': {}
'@types/d3-timer@3.0.2': {}
'@types/eslint-scope@3.7.7':
dependencies:
'@types/eslint': 9.6.1
@@ -6678,6 +6877,8 @@ snapshots:
'@types/methods': 1.1.4
'@types/superagent': 8.1.9
'@types/use-sync-external-store@0.0.6': {}
'@types/validator@13.15.10': {}
'@types/webidl-conversions@7.0.3': {}
@@ -7317,6 +7518,8 @@ snapshots:
clone@1.0.4: {}
clsx@2.1.1: {}
cluster-key-slot@1.1.2: {}
co@4.6.0: {}
@@ -7393,12 +7596,52 @@ snapshots:
csstype@3.2.3: {}
d3-array@3.2.4:
dependencies:
internmap: 2.0.3
d3-color@3.1.0: {}
d3-ease@3.0.1: {}
d3-format@3.1.2: {}
d3-interpolate@3.0.1:
dependencies:
d3-color: 3.1.0
d3-path@3.1.0: {}
d3-scale@4.0.2:
dependencies:
d3-array: 3.2.4
d3-format: 3.1.2
d3-interpolate: 3.0.1
d3-time: 3.1.0
d3-time-format: 4.1.0
d3-shape@3.2.0:
dependencies:
d3-path: 3.1.0
d3-time-format@4.1.0:
dependencies:
d3-time: 3.1.0
d3-time@3.1.0:
dependencies:
d3-array: 3.2.4
d3-timer@3.0.1: {}
daisyui@5.5.19: {}
debug@4.4.3:
dependencies:
ms: 2.1.3
decimal.js-light@2.5.1: {}
dedent@1.7.2: {}
deep-is@0.1.4: {}
@@ -7511,6 +7754,8 @@ snapshots:
has-tostringtag: 1.0.2
hasown: 2.0.2
es-toolkit@1.47.0: {}
esbuild@0.27.3:
optionalDependencies:
'@esbuild/aix-ppc64': 0.27.3
@@ -7658,6 +7903,8 @@ snapshots:
etag@1.8.1: {}
eventemitter3@5.0.4: {}
events@3.3.0: {}
execa@5.1.1:
@@ -7961,6 +8208,10 @@ snapshots:
ignore@7.0.5: {}
immer@10.2.0: {}
immer@11.1.8: {}
import-fresh@3.3.1:
dependencies:
parent-module: 1.0.1
@@ -7980,6 +8231,8 @@ snapshots:
inherits@2.0.4: {}
internmap@2.0.3: {}
ipaddr.js@1.9.1: {}
is-arrayish@0.2.1: {}
@@ -8831,6 +9084,15 @@ snapshots:
react-is@18.3.1: {}
react-redux@9.3.0(@types/react@19.2.14)(react@19.2.5)(redux@5.0.1):
dependencies:
'@types/use-sync-external-store': 0.0.6
react: 19.2.5
use-sync-external-store: 1.6.0(react@19.2.5)
optionalDependencies:
'@types/react': 19.2.14
redux: 5.0.1
react-router@7.14.0(react-dom@19.2.5(react@19.2.5))(react@19.2.5):
dependencies:
cookie: 1.1.1
@@ -8849,6 +9111,26 @@ snapshots:
readdirp@4.1.2: {}
recharts@3.8.1(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react-is@18.3.1)(react@19.2.5)(redux@5.0.1):
dependencies:
'@reduxjs/toolkit': 2.12.0(react-redux@9.3.0(@types/react@19.2.14)(react@19.2.5)(redux@5.0.1))(react@19.2.5)
clsx: 2.1.1
decimal.js-light: 2.5.1
es-toolkit: 1.47.0
eventemitter3: 5.0.4
immer: 10.2.0
react: 19.2.5
react-dom: 19.2.5(react@19.2.5)
react-is: 18.3.1
react-redux: 9.3.0(@types/react@19.2.14)(react@19.2.5)(redux@5.0.1)
reselect: 5.1.1
tiny-invariant: 1.3.3
use-sync-external-store: 1.6.0(react@19.2.5)
victory-vendor: 37.3.6
transitivePeerDependencies:
- '@types/react'
- redux
redis@5.12.1:
dependencies:
'@redis/bloom': 5.12.1(@redis/client@5.12.1)
@@ -8860,12 +9142,20 @@ snapshots:
- '@node-rs/xxhash'
- '@opentelemetry/api'
redux-thunk@3.1.0(redux@5.0.1):
dependencies:
redux: 5.0.1
redux@5.0.1: {}
reflect-metadata@0.2.2: {}
require-directory@2.1.1: {}
require-from-string@2.0.2: {}
reselect@5.1.1: {}
resolve-cwd@3.0.0:
dependencies:
resolve-from: 5.0.0
@@ -9232,6 +9522,8 @@ snapshots:
glob: 7.2.3
minimatch: 3.1.5
tiny-invariant@1.3.3: {}
tinyglobby@0.2.16:
dependencies:
fdir: 6.5.0(picomatch@4.0.4)
@@ -9432,6 +9724,10 @@ snapshots:
dependencies:
punycode: 2.3.1
use-sync-external-store@1.6.0(react@19.2.5):
dependencies:
react: 19.2.5
util-deprecate@1.0.2: {}
v8-compile-cache-lib@3.0.1: {}
@@ -9446,6 +9742,23 @@ snapshots:
vary@1.1.2: {}
victory-vendor@37.3.6:
dependencies:
'@types/d3-array': 3.2.2
'@types/d3-ease': 3.0.2
'@types/d3-interpolate': 3.0.4
'@types/d3-scale': 4.0.9
'@types/d3-shape': 3.1.8
'@types/d3-time': 3.0.4
'@types/d3-timer': 3.0.2
d3-array: 3.2.4
d3-ease: 3.0.1
d3-interpolate: 3.0.1
d3-scale: 4.0.2
d3-shape: 3.2.0
d3-time: 3.1.0
d3-timer: 3.0.1
vite@8.0.8(@types/node@24.12.2)(esbuild@0.27.3)(jiti@2.6.1)(terser@5.46.1):
dependencies:
lightningcss: 1.32.0
+52 -16
View File
@@ -26,12 +26,23 @@ export function main(args = process.argv.slice(2), env = process.env) {
env.CF_PAGES_PROJECT_NAME ??
env.CLOUDFLARE_PAGES_PROJECT_NAME ??
"lolympus";
const stagingBranch =
target === "staging" ? resolveStagingBranch(env) : undefined;
const deployPlan = resolveDeployPlan(target, env);
validateEnv(viteMode, env);
run("pnpm", ["--filter", "web", "run", `build:${target}`], repoRoot);
const deployArgs = createPagesDeployArgs(projectName, deployPlan.pagesBranch);
console.error(
[
`Deploying ${target} from ${deployPlan.sourceBranch}`,
`to Cloudflare Pages branch ${deployPlan.pagesBranch}`,
].join(" "),
);
run("pnpm", deployArgs, webDir);
}
export function createPagesDeployArgs(projectName, branch) {
const deployArgs = [
"exec",
"wrangler",
@@ -42,37 +53,62 @@ export function main(args = process.argv.slice(2), env = process.env) {
projectName,
];
if (target === "staging") {
deployArgs.push("--branch", stagingBranch);
console.error(
`Deploying staging to Cloudflare Pages branch ${stagingBranch}`,
);
}
run("pnpm", deployArgs, webDir);
if (branch) deployArgs.push("--branch", branch);
return deployArgs;
}
export function resolveStagingBranch(env = process.env) {
const configuredBranch = env.CF_PAGES_STAGING_BRANCH?.trim();
return resolveDeployPlan("staging", env).pagesBranch;
}
export function resolveDeployPlan(
target,
env = process.env,
releaseBranchRowsProvider = () => {
refreshRemoteReleaseBranches();
return listReleaseBranchRefs();
},
) {
const sourceBranch = resolveSourceBranch(
target,
env,
releaseBranchRowsProvider,
);
const pagesBranch =
target === "prod" ? resolveProductionBranch(env) : sourceBranch;
return { sourceBranch, pagesBranch };
}
function resolveSourceBranch(target, env, releaseBranchRowsProvider) {
const sourceEnvKey =
target === "prod" ? "CF_PAGES_RELEASE_BRANCH" : "CF_PAGES_STAGING_BRANCH";
const configuredBranch = env[sourceEnvKey]?.trim();
if (configuredBranch) return configuredBranch;
refreshRemoteReleaseBranches();
const latestReleaseBranch = selectLatestReleaseBranch(
listReleaseBranchRefs(),
releaseBranchRowsProvider(),
);
if (latestReleaseBranch) return latestReleaseBranch;
console.error(
[
"No release/* branch found for staging deploy.",
`No release/* branch found for ${target} deploy.`,
"Create a release branch, for example: git push origin main:release/66",
"Or set CF_PAGES_STAGING_BRANCH explicitly.",
`Or set ${sourceEnvKey} explicitly.`,
].join("\n"),
);
process.exit(1);
}
function resolveProductionBranch(env) {
return (
env.CF_PAGES_PRODUCTION_BRANCH?.trim() ||
env.CF_PAGES_PROD_BRANCH?.trim() ||
"main"
);
}
export function selectLatestReleaseBranch(refRows) {
const latestByBranch = new Map();
+63
View File
@@ -0,0 +1,63 @@
import assert from "node:assert/strict";
import { describe, it } from "node:test";
import {
createPagesDeployArgs,
resolveDeployPlan,
} from "./deploy-cloudflare-pages.mjs";
describe("deploy-cloudflare-pages", () => {
it("deploys prod to the production branch using the latest release branch as source", () => {
const plan = resolveDeployPlan("prod", {}, () => [
"1710000000\torigin/release/66",
"1720000000\torigin/release/67",
]);
assert.deepEqual(plan, {
sourceBranch: "release/67",
pagesBranch: "main",
});
assert.deepEqual(
createPagesDeployArgs("lolympus", plan.pagesBranch),
[
"exec",
"wrangler",
"pages",
"deploy",
"dist",
"--project-name",
"lolympus",
"--branch",
"main",
],
);
});
it("keeps explicit staging branch override behavior", () => {
const plan = resolveDeployPlan(
"staging",
{ CF_PAGES_STAGING_BRANCH: "release/manual" },
() => {
throw new Error("should not inspect git refs when branch is explicit");
},
);
assert.deepEqual(plan, {
sourceBranch: "release/manual",
pagesBranch: "release/manual",
});
});
it("allows overriding the Cloudflare Pages production branch", () => {
const plan = resolveDeployPlan(
"prod",
{ CF_PAGES_PRODUCTION_BRANCH: "production" },
() => ["1720000000\torigin/release/67"],
);
assert.deepEqual(plan, {
sourceBranch: "release/67",
pagesBranch: "production",
});
});
});