diff --git a/apps/web/src/api/hooks.ts b/apps/web/src/api/hooks.ts new file mode 100644 index 00000000..8546bf22 --- /dev/null +++ b/apps/web/src/api/hooks.ts @@ -0,0 +1,762 @@ +import { InteractionStatus } from '@azure/msal-browser'; +import { useMsal } from '@azure/msal-react'; +import { useInfiniteQuery, useMutation, useQuery } from '@tanstack/react-query'; +import { DEFAULT_COMMUNITY_ID, useAuthUserId } from '../config'; +import { apiFetch } from '../lib/api'; +import { + isMsalConfigured, + MSAL_API_SCOPE, + MSAL_SILENT_REDIRECT_URI, +} from '../lib/auth/msal.config'; +import type { + ApiAuction, + ApiAuctionHistoryEntry, + ApiChampionStatsResponse, + ApiCommunity, + ApiEnqueueRefreshResult, + ApiInternalMatchDetailResponse, + ApiInternalMatchListResponse, + ApiLeaderboardResponse, + LegacyImportJobsResponse, + LegacyImportMembersResponse, + LegacyMatchListResponse, + ApiMatch, + ApiRecentMatchesResponse, + ApiRecentSummaryResponse, + ApiTeamInsightsResponse, + ApiTournamentCode, + ApiUserInternalHistoryResponse, + ApiUserHistoryProfile, + DdragonManifest, + StartLegacyImportRequest, + StartLegacyImportResponse, + MatchStatus, + MatchMutationRequest, + MatchesResponse, + ManualTournamentResultCollectResponse, + MeResponse, + RiotQueueGroup, + RiotRankFilter, + RebuildLegacyMatchesResponse, + TournamentCodeBulkUploadResponse, + TournamentCodeListResponse, + TournamentCodeState, + TournamentCodeStatsResponse, + TournamentCodeUploadItem, +} from './types'; + +const DDRAGON_MANIFEST_STALE_MS = 24 * 60 * 60 * 1000; + +interface MatchesQueryOptions { + status?: MatchStatus; + limit?: number; +} + +export interface UserHistoryFilters { + queueGroup?: RiotQueueGroup; + rank?: RiotRankFilter; + seasonId?: string; + championId?: number; +} + +export interface CommunityInternalStatsFilters { + seasonId?: string; + from?: string; + to?: string; + championId?: number; + limit?: number; +} + +function createMatchesPath( + communityId: string, + options: MatchesQueryOptions = {}, +) { + const searchParams = new URLSearchParams(); + if (options.status) searchParams.set('status', options.status); + if (options.limit) searchParams.set('limit', String(options.limit)); + + const queryString = searchParams.toString(); + return `/communities/${communityId}/matches${queryString ? `?${queryString}` : ''}`; +} + +export function useCommunity(communityId = DEFAULT_COMMUNITY_ID) { + return useQuery({ + queryKey: ['community', communityId], + queryFn: () => + apiFetch(`/communities/${communityId}`, { auth: 'none' }), + enabled: Boolean(communityId), + }); +} + +export function useMatches( + options: MatchesQueryOptions, + communityId = DEFAULT_COMMUNITY_ID, +) { + return useQuery({ + queryKey: ['matches', communityId, options.status ?? null, options.limit ?? null], + queryFn: async () => { + const response = await apiFetch( + createMatchesPath(communityId, options), + { auth: 'none' }, + ); + return response.matches; + }, + enabled: Boolean(communityId), + }); +} + +export function useMatch(matchId: string | undefined, communityId = DEFAULT_COMMUNITY_ID) { + return useQuery({ + queryKey: ['match', communityId, matchId ?? null], + queryFn: () => + apiFetch(`/communities/${communityId}/matches/${matchId}`, { + auth: 'none', + }), + enabled: Boolean(communityId && matchId), + retry: false, + }); +} + +export function useAuction( + matchId: string | undefined, + communityId = DEFAULT_COMMUNITY_ID, + options: { refetchInterval?: number | false } = {}, +) { + return useQuery({ + queryKey: ['auction', communityId, matchId ?? null], + queryFn: () => + apiFetch( + `/communities/${communityId}/matches/${matchId}/auction`, + { auth: 'none' }, + ), + enabled: Boolean(communityId && matchId), + retry: false, + refetchInterval: options.refetchInterval, + }); +} + +export function useAuctionHistory( + matchId: string | undefined, + communityId = DEFAULT_COMMUNITY_ID, + options: { enabled?: boolean; refetchInterval?: number | false } = {}, +) { + return useQuery({ + queryKey: ['auction-history', communityId, matchId ?? null], + queryFn: () => + apiFetch( + `/communities/${communityId}/matches/${matchId}/auction/history`, + ), + enabled: Boolean(communityId && matchId && (options.enabled ?? true)), + retry: false, + refetchInterval: options.refetchInterval, + }); +} + +export function useUndoAuction(communityId = DEFAULT_COMMUNITY_ID) { + return useMutation({ + mutationFn: ({ + matchId, + sequence, + }: { + matchId: string; + sequence: number; + }) => + apiFetch( + `/communities/${communityId}/matches/${matchId}/auction/undo`, + { + method: 'POST', + body: JSON.stringify({ sequence }), + }, + ), + }); +} + +export function useCreateMatch(communityId = DEFAULT_COMMUNITY_ID) { + return useMutation({ + mutationFn: (body: MatchMutationRequest) => + apiFetch(`/communities/${communityId}/matches`, { + method: 'POST', + body: JSON.stringify(body), + }), + }); +} + +export function useUpdateMatch(communityId = DEFAULT_COMMUNITY_ID) { + return useMutation({ + mutationFn: ({ matchId, body }: { matchId: string; body: Partial }) => + apiFetch(`/communities/${communityId}/matches/${matchId}`, { + method: 'PATCH', + body: JSON.stringify(body), + }), + }); +} + +function createUserHistoryPath( + communityId: string, + userId: string, + resource: string, + filters: UserHistoryFilters = {}, + extra: Record = {}, +) { + const searchParams = new URLSearchParams(); + if (filters.queueGroup) searchParams.set('queueGroup', filters.queueGroup); + if (filters.rank) searchParams.set('rank', filters.rank); + if (filters.seasonId) searchParams.set('seasonId', filters.seasonId); + if (filters.championId) searchParams.set('championId', String(filters.championId)); + for (const [key, value] of Object.entries(extra)) { + if (value !== null && value !== undefined && value !== '') { + searchParams.set(key, String(value)); + } + } + + const queryString = searchParams.toString(); + return `/communities/${communityId}/users/${userId}/${resource}${queryString ? `?${queryString}` : ''}`; +} + +export function useUserHistoryProfile( + userId: string | undefined, + communityId = DEFAULT_COMMUNITY_ID, +) { + return useQuery({ + queryKey: ['user-history-profile', communityId, userId ?? null], + queryFn: () => + apiFetch( + `/communities/${communityId}/users/${userId}/history-profile`, + { auth: 'none' }, + ), + enabled: Boolean(communityId && userId), + retry: false, + }); +} + +export function useChampionStats( + userId: string | undefined, + filters: UserHistoryFilters, + communityId = DEFAULT_COMMUNITY_ID, + enabled = true, +) { + return useQuery({ + queryKey: [ + 'user-champion-stats', + communityId, + userId ?? null, + filters.queueGroup ?? null, + filters.rank ?? null, + filters.seasonId ?? null, + ], + queryFn: () => + apiFetch( + createUserHistoryPath(communityId, userId ?? '', 'champion-stats', filters), + { auth: 'none' }, + ), + enabled: Boolean(communityId && userId && enabled), + }); +} + +export function useRecentSummary( + userId: string | undefined, + filters: UserHistoryFilters, + communityId = DEFAULT_COMMUNITY_ID, + enabled = true, +) { + return useQuery({ + queryKey: [ + 'user-recent-summary', + communityId, + userId ?? null, + filters.queueGroup ?? null, + filters.rank ?? null, + filters.seasonId ?? null, + filters.championId ?? null, + ], + queryFn: () => + apiFetch( + createUserHistoryPath(communityId, userId ?? '', 'recent-summary', filters), + { auth: 'none' }, + ), + enabled: Boolean(communityId && userId && enabled), + }); +} + +export function useRecentMatches( + userId: string | undefined, + filters: UserHistoryFilters, + communityId = DEFAULT_COMMUNITY_ID, + enabled = true, +) { + return useInfiniteQuery({ + queryKey: [ + 'user-recent-matches', + communityId, + userId ?? null, + filters.queueGroup ?? null, + filters.rank ?? null, + filters.seasonId ?? null, + filters.championId ?? null, + ], + queryFn: ({ pageParam }) => + apiFetch( + createUserHistoryPath(communityId, userId ?? '', 'recent-matches', filters, { + cursor: pageParam, + limit: 10, + }), + { auth: 'none' }, + ), + initialPageParam: null as number | null, + getNextPageParam: (lastPage) => lastPage.nextCursor, + enabled: Boolean(communityId && userId && enabled), + }); +} + +function createCommunityInternalStatsPath( + communityId: string, + resource: string, + filters: CommunityInternalStatsFilters = {}, + extra: Record = {}, +) { + const searchParams = new URLSearchParams(); + if (filters.seasonId) searchParams.set('seasonId', filters.seasonId); + if (filters.from) searchParams.set('from', filters.from); + if (filters.to) searchParams.set('to', filters.to); + if (filters.championId) searchParams.set('championId', String(filters.championId)); + if (filters.limit) searchParams.set('limit', String(filters.limit)); + for (const [key, value] of Object.entries(extra)) { + if (value !== null && value !== undefined && value !== '') { + searchParams.set(key, String(value)); + } + } + + const queryString = searchParams.toString(); + return `/communities/${communityId}/internal-stats/${resource}${queryString ? `?${queryString}` : ''}`; +} + +export function useCommunityInternalStatsMatches( + filters: CommunityInternalStatsFilters, + communityId = DEFAULT_COMMUNITY_ID, + enabled = true, +) { + return useInfiniteQuery({ + queryKey: [ + 'community-internal-stats-matches', + communityId, + filters.seasonId ?? null, + filters.from ?? null, + filters.to ?? null, + filters.championId ?? null, + filters.limit ?? null, + ], + queryFn: ({ pageParam }) => + apiFetch( + createCommunityInternalStatsPath(communityId, 'matches', filters, { + cursor: pageParam, + }), + { auth: 'none' }, + ), + initialPageParam: null as number | null, + getNextPageParam: (lastPage) => lastPage.nextCursor, + enabled: Boolean(communityId && enabled), + }); +} + +export function useCommunityLeaderboard( + filters: CommunityInternalStatsFilters, + communityId = DEFAULT_COMMUNITY_ID, + enabled = true, +) { + return useQuery({ + queryKey: [ + 'community-internal-stats-leaderboard', + communityId, + filters.seasonId ?? null, + filters.from ?? null, + filters.to ?? null, + filters.championId ?? null, + ], + queryFn: () => + apiFetch( + createCommunityInternalStatsPath(communityId, 'leaderboard', filters), + { auth: 'none' }, + ), + enabled: Boolean(communityId && enabled), + }); +} + +export function useTeamInsights( + filters: CommunityInternalStatsFilters, + communityId = DEFAULT_COMMUNITY_ID, + enabled = true, +) { + return useQuery({ + queryKey: [ + 'community-internal-stats-team-insights', + communityId, + filters.seasonId ?? null, + filters.from ?? null, + filters.to ?? null, + filters.championId ?? null, + ], + queryFn: () => + apiFetch( + createCommunityInternalStatsPath(communityId, 'team-insights', filters), + { auth: 'none' }, + ), + enabled: Boolean(communityId && enabled), + }); +} + +export function useInternalMatchDetail( + matchId: string | undefined, + communityId = DEFAULT_COMMUNITY_ID, +) { + return useQuery({ + queryKey: ['community-internal-stats-match', communityId, matchId ?? null], + queryFn: () => + apiFetch( + `/communities/${communityId}/internal-stats/match/${matchId}`, + { auth: 'none' }, + ), + enabled: Boolean(communityId && matchId), + retry: false, + }); +} + +export function useUserInternalHistory( + userId: string | undefined, + filters: UserHistoryFilters, + communityId = DEFAULT_COMMUNITY_ID, + enabled = true, +) { + return useInfiniteQuery({ + queryKey: [ + 'user-internal-history', + communityId, + userId ?? null, + filters.seasonId ?? null, + filters.championId ?? null, + ], + queryFn: ({ pageParam }) => + apiFetch( + createUserHistoryPath(communityId, userId ?? '', 'internal-history', filters, { + cursor: pageParam, + limit: 10, + }), + { auth: 'none' }, + ), + initialPageParam: null as number | null, + getNextPageParam: (lastPage) => lastPage.nextCursor, + enabled: Boolean(communityId && userId && enabled), + }); +} + +export function useRefreshUserHistory( + userId: string | undefined, + communityId = DEFAULT_COMMUNITY_ID, +) { + return useMutation({ + mutationFn: (body: { + queueGroups: RiotQueueGroup[]; + priority: 'high' | 'low'; + }) => + apiFetch( + `/communities/${communityId}/users/${userId}/refresh`, + { + method: 'POST', + body: JSON.stringify(body), + }, + ), + }); +} + +export function useDdragonManifest(locale = 'ko_KR') { + return useQuery({ + queryKey: ['ddragon-manifest', locale], + queryFn: () => + apiFetch( + `/riot/ddragon/manifest?locale=${encodeURIComponent(locale)}`, + { auth: 'none' }, + ), + staleTime: DDRAGON_MANIFEST_STALE_MS, + gcTime: DDRAGON_MANIFEST_STALE_MS, + refetchOnMount: false, + refetchOnReconnect: false, + }); +} + +export function useTournamentCodeStats( + communityId = DEFAULT_COMMUNITY_ID, + enabled = true, +) { + return useQuery({ + queryKey: ['tournament-code-stats', communityId], + queryFn: () => + apiFetch( + `/communities/${communityId}/tournament-codes/stats`, + ), + enabled: Boolean(communityId && enabled), + refetchInterval: enabled ? 30_000 : false, + retry: false, + }); +} + +export function useTournamentCodes( + options: { state?: TournamentCodeState; limit?: number }, + communityId = DEFAULT_COMMUNITY_ID, + enabled = true, +) { + return useQuery({ + queryKey: [ + 'tournament-codes', + communityId, + options.state ?? null, + options.limit ?? null, + ], + queryFn: () => { + const searchParams = new URLSearchParams(); + if (options.state) searchParams.set('state', options.state); + if (options.limit) searchParams.set('limit', String(options.limit)); + const queryString = searchParams.toString(); + return apiFetch( + `/communities/${communityId}/tournament-codes${queryString ? `?${queryString}` : ''}`, + ); + }, + enabled: Boolean(communityId && enabled), + refetchInterval: enabled ? 30_000 : false, + retry: false, + }); +} + +export function useBulkUploadTournamentCodes(communityId = DEFAULT_COMMUNITY_ID) { + return useMutation({ + mutationFn: (codes: TournamentCodeUploadItem[]) => + apiFetch( + `/communities/${communityId}/tournament-codes`, + { + method: 'POST', + body: JSON.stringify({ codes }), + }, + ), + }); +} + +export function useRestoreTournamentCode(communityId = DEFAULT_COMMUNITY_ID) { + return useMutation({ + mutationFn: (codeId: string) => + apiFetch( + `/communities/${communityId}/tournament-codes/${codeId}/release`, + { method: 'POST' }, + ), + }); +} + +export function useDeleteTournamentCode(communityId = DEFAULT_COMMUNITY_ID) { + return useMutation({ + mutationFn: (codeId: string) => + apiFetch(`/communities/${communityId}/tournament-codes/${codeId}`, { + method: 'DELETE', + }), + }); +} + +export function usePollTournamentResult(communityId = DEFAULT_COMMUNITY_ID) { + return useMutation({ + mutationFn: (matchId: string) => + apiFetch<{ + jobId: string; + matchId: string; + priority: 'high' | 'low'; + attempt: number; + expandedToAllPuuids: boolean; + }>(`/communities/${communityId}/matches/${matchId}/poll-tournament-result`, { + method: 'POST', + }), + }); +} + +export function useCollectTournamentResultByWindow( + communityId = DEFAULT_COMMUNITY_ID, +) { + return useMutation({ + mutationFn: (params: { + matchId: string; + startTime: string; + endTime: string; + }) => + apiFetch( + `/communities/${communityId}/matches/${params.matchId}/poll-tournament-result/collect-by-window`, + { + method: 'POST', + body: JSON.stringify({ + startTime: params.startTime, + endTime: params.endTime, + }), + }, + ), + }); +} + +export function useCollectTournamentResultByRiotMatch( + communityId = DEFAULT_COMMUNITY_ID, +) { + return useMutation({ + mutationFn: (params: { matchId: string; riotMatchId: string }) => + apiFetch( + `/communities/${communityId}/matches/${params.matchId}/poll-tournament-result/collect-by-riot-match`, + { + method: 'POST', + body: JSON.stringify({ riotMatchId: params.riotMatchId }), + }, + ), + }); +} + +export function useLegacyImportMembers( + options: { windowStart?: string; windowEnd?: string }, + communityId = DEFAULT_COMMUNITY_ID, + enabled = true, +) { + return useQuery({ + queryKey: [ + 'legacy-import-members', + communityId, + options.windowStart ?? null, + options.windowEnd ?? null, + ], + queryFn: () => { + const searchParams = new URLSearchParams(); + if (options.windowStart) searchParams.set('windowStart', options.windowStart); + if (options.windowEnd) searchParams.set('windowEnd', options.windowEnd); + const queryString = searchParams.toString(); + return apiFetch( + `/communities/${communityId}/legacy-import/members${queryString ? `?${queryString}` : ''}`, + ); + }, + enabled: Boolean(communityId && enabled), + }); +} + +export function useLegacyImportJobs( + communityId = DEFAULT_COMMUNITY_ID, + enabled = true, +) { + return useQuery({ + queryKey: ['legacy-import-jobs', communityId], + queryFn: () => + apiFetch( + `/communities/${communityId}/legacy-import-jobs?limit=10`, + ), + enabled: Boolean(communityId && enabled), + refetchInterval: (query) => + query.state.data?.jobs.some( + (job) => job.state === 'pending' || job.state === 'running', + ) + ? 5_000 + : false, + }); +} + +export function useStartLegacyImport(communityId = DEFAULT_COMMUNITY_ID) { + return useMutation({ + mutationFn: (body: StartLegacyImportRequest) => + apiFetch( + `/communities/${communityId}/legacy-import`, + { + method: 'POST', + body: JSON.stringify(body), + }, + ), + }); +} + +export function useCancelLegacyImport(communityId = DEFAULT_COMMUNITY_ID) { + return useMutation({ + mutationFn: (jobId: string) => + apiFetch( + `/communities/${communityId}/legacy-import-jobs/${jobId}/cancel`, + { method: 'POST' }, + ), + }); +} + +export function useLegacyMatches( + communityId = DEFAULT_COMMUNITY_ID, + enabled = true, +) { + return useInfiniteQuery({ + queryKey: ['legacy-matches', communityId], + queryFn: ({ pageParam }) => { + const searchParams = new URLSearchParams({ limit: '50' }); + if (pageParam) searchParams.set('cursor', String(pageParam)); + return apiFetch( + `/communities/${communityId}/legacy-matches?${searchParams.toString()}`, + ); + }, + initialPageParam: null as number | null, + getNextPageParam: (lastPage) => lastPage.nextCursor, + enabled: Boolean(communityId && enabled), + }); +} + +export function useDeleteMatch(communityId = DEFAULT_COMMUNITY_ID) { + return useMutation({ + mutationFn: (matchId: string) => + apiFetch(`/communities/${communityId}/matches/${matchId}`, { + method: 'DELETE', + }), + }); +} + +export function useBulkDeleteLegacyMatches(communityId = DEFAULT_COMMUNITY_ID) { + return useMutation({ + mutationFn: (matchIds: string[]) => + apiFetch<{ deleted: number }>( + `/communities/${communityId}/legacy-matches/bulk-delete`, + { + method: 'POST', + body: JSON.stringify({ matchIds }), + }, + ), + }); +} + +export function useRebuildLegacyMatches(communityId = DEFAULT_COMMUNITY_ID) { + return useMutation({ + mutationFn: () => + apiFetch( + `/communities/${communityId}/legacy-matches/rebuild`, + { method: 'POST' }, + ), + }); +} + +export function useMe() { + const authUserId = useAuthUserId(); + const { accounts, inProgress, instance } = useMsal(); + const account = isMsalConfigured + ? (instance.getActiveAccount() ?? accounts[0] ?? null) + : null; + const accountKey = account?.homeAccountId ?? null; + const isMsalReady = + !isMsalConfigured || inProgress === InteractionStatus.None; + + return useQuery({ + queryKey: ['me', authUserId, accountKey], + queryFn: async () => { + if (!account) { + return apiFetch('/me'); + } + + const response = await instance.acquireTokenSilent({ + account, + scopes: [MSAL_API_SCOPE], + redirectUri: MSAL_SILENT_REDIRECT_URI, + }); + return apiFetch('/me', { + headers: { + Authorization: `Bearer ${response.accessToken}`, + }, + }); + }, + enabled: Boolean(authUserId || isMsalReady), + retry: false, + }); +} diff --git a/apps/web/src/api/mappers.ts b/apps/web/src/api/mappers.ts new file mode 100644 index 00000000..3cb9c491 --- /dev/null +++ b/apps/web/src/api/mappers.ts @@ -0,0 +1,528 @@ +import type { + ApiAuction, + ApiAuctionPlayerSnapshot, + ApiAuctionTeam, + ApiMatch, + ApiMatchParticipant, + ApiPositionPreference, + ApiRiotLaneStats, + ApiRiotRecentStatsSummary, + ApiTierInfo, + MatchStatus, + Position, + RiotLane, + TournamentCodeSlotView, +} from "./types"; +import { POSITION_ORDER, teamIndexLabel } from "../lib/league"; + +export interface ParticipantView { + id: string; + userId: string; + summonerName: string; + tag: string; + tier?: ApiTierInfo; + mainPosition: Position; + subPosition: Position; + profileIconId: number; + excluded?: boolean; +} + +export interface TeamParticipantView extends ParticipantView { + assignedPosition: Position; + cost?: number; +} + +export interface TeamView { + teamIndex: number; + name: string; + participants: TeamParticipantView[]; +} + +export interface MatchDetailView { + id: string; + title: string; + date: string; + time: string; + status: MatchStatus; + description: string; + map: string; + maxParticipants: number; + gameCount: number; + gameMode: ApiMatch["gameMode"]; + tournamentCodes: TournamentCodeSlotView[]; + joined: boolean; + participants: ParticipantView[]; + teams: TeamView[]; + result?: { + winner?: string; + winnerTeamIndex?: number; + riotMatchIds: string[]; + games: Array<{ + gameNumber: number; + riotMatchId: string; + blueTeamIndex: number; + redTeamIndex: number; + winnerTeamIndex: number; + winnerSide: "blue" | "red"; + gameCreation: number; + gameDuration: number; + participants: Array<{ + userId: string; + teamIndex: number; + side: "blue" | "red"; + championId: number; + kills: number; + deaths: number; + assists: number; + win: boolean; + }>; + }>; + seriesResults: NonNullable["seriesResults"]; + }; + prizes: string[]; + notices: string[]; + schedule: { time: string; label: string }[]; +} + +export interface AuctionPlayerView extends ParticipantView { + passCount: number; + masteries: { + championId: number; + level: number; + points: number; + }[]; + recentStats: { + overall: ApiRiotLaneStats; + byLane: Partial>; + primary: ApiRiotLaneStats | null; + primarySource: "lane" | "overall" | "none"; + }; +} + +export interface AuctionTeamView { + teamIndex: number; + name: string; + captainUserId: string; + captainName: string; + points: number; + members: (AuctionPlayerView & { + assignedPosition: Position; + cost: number; + })[]; +} + +export interface AuctionStateView { + matchId: string; + phase: ApiAuction["phase"]; + teams: AuctionTeamView[]; + currentPlayer: AuctionPlayerView | null; + currentPlayerIndex: number; + totalPlayers: number; + auctionOrder: AuctionPlayerView[]; + passedQueue: AuctionPlayerView[]; + auctionRound: number; + bids: { + teamIndex: number; + amount: number; + timestamp: string; + }[]; + currentBid: number; + currentBidder: { teamIndex: number } | null; + timer: number; + maxTimer: number; + bidExtensionSeconds: number; + deadline?: string; +} + +const MAP_LABELS: Record = { + 11: "소환사의 협곡", + 12: "칼바람 나락", + 21: "소환사의 협곡", + 22: "전략적 팀 전투", +}; + +const TIER_NAMES: Record = { + IRON: "아이언", + BRONZE: "브론즈", + SILVER: "실버", + GOLD: "골드", + PLATINUM: "플래티넘", + EMERALD: "에메랄드", + DIAMOND: "다이아", + MASTER: "마스터", + GRANDMASTER: "그랜드마스터", + CHALLENGER: "챌린저", +}; + +const POSITION_TO_RIOT_LANE: Record = { + TOP: "TOP", + JGL: "JUNGLE", + MID: "MIDDLE", + ADC: "BOTTOM", + SUP: "UTILITY", +}; + +function createEmptyLaneStats(): ApiRiotLaneStats { + return { + games: 0, + wins: 0, + losses: 0, + avgKills: 0, + avgDeaths: 0, + avgAssists: 0, + avgCs: 0, + avgCsPerMin: 0, + mostPlayedChampionIds: [], + }; +} + +function createEmptyRecentStatsView(): AuctionPlayerView["recentStats"] { + return { + overall: createEmptyLaneStats(), + byLane: {}, + primary: null, + primarySource: "none", + }; +} + +function sortPreferredPositions(preferredPositions: ApiPositionPreference[]) { + return [...preferredPositions].sort( + (left, right) => left.priority - right.priority, + ); +} + +function resolveMainAndSubPosition( + preferredPositions: ApiPositionPreference[], +) { + const sorted = sortPreferredPositions(preferredPositions); + return { + mainPosition: sorted[0]?.position ?? "MID", + subPosition: sorted[1]?.position ?? sorted[0]?.position ?? "MID", + }; +} + +function mapMatchParticipantToView( + participant: ApiMatchParticipant, +): ParticipantView { + const { mainPosition, subPosition } = resolveMainAndSubPosition( + participant.preferredPositions, + ); + + return { + id: participant.userId, + userId: participant.userId, + summonerName: participant.gameName ?? "알 수 없음", + tag: participant.tagLine ?? "----", + tier: participant.tier, + mainPosition, + subPosition, + profileIconId: participant.profileIconId ?? 0, + excluded: participant.excluded ?? false, + }; +} + +function mapAuctionPlayerToView( + player: ApiAuctionPlayerSnapshot, +): AuctionPlayerView { + const { mainPosition, subPosition } = resolveMainAndSubPosition( + player.preferredPositions, + ); + const summary = player.recentStatsSummary; + const primary = pickPrimary(summary, mainPosition); + + return { + id: player.userId, + userId: player.userId, + summonerName: player.gameName, + tag: player.tagLine, + tier: selectPrimaryTier(player.tiers), + mainPosition, + subPosition, + profileIconId: player.profileIconId, + passCount: player.passCount ?? 0, + masteries: player.masteries.slice(0, 5).map((mastery) => ({ + championId: mastery.championId, + level: mastery.championLevel, + points: mastery.championPoints, + })), + recentStats: { + overall: summary?.overall ?? createEmptyLaneStats(), + byLane: summary?.byLane ?? {}, + primary: primary.stats, + primarySource: primary.source, + }, + }; +} + +function createFallbackParticipant(userId: string): ParticipantView { + return { + id: userId, + userId, + summonerName: `User ${userId.slice(-4)}`, + tag: "----", + mainPosition: "MID", + subPosition: "MID", + profileIconId: 0, + }; +} + +function mapAuctionTeamToView( + team: ApiAuctionTeam, + playerLookup: Map, + participantLookup: Map, +): AuctionTeamView { + return { + teamIndex: team.teamIndex, + name: teamIndexLabel(team.teamIndex), + captainUserId: team.captainUserId, + captainName: + participantLookup.get(team.captainUserId)?.summonerName ?? + `User ${team.captainUserId.slice(-4)}`, + points: team.points, + members: team.members.map((member) => { + const participant = participantLookup.get(member.userId); + const player = + playerLookup.get(member.userId) ?? + (participant + ? { + ...participant, + passCount: 0, + masteries: [], + recentStats: createEmptyRecentStatsView(), + } + : { + ...createFallbackParticipant(member.userId), + passCount: 0, + masteries: [], + recentStats: createEmptyRecentStatsView(), + }); + + return { + ...player, + assignedPosition: member.assignedPosition, + cost: member.cost, + }; + }), + }; +} + +export function mapIdToLabel(mapId: number) { + return MAP_LABELS[mapId] ?? `맵 #${mapId}`; +} + +export function formatKoreanDate(dateLike: string | Date) { + const date = new Date(dateLike); + + return { + date: new Intl.DateTimeFormat("ko-KR", { + year: "numeric", + month: "long", + day: "numeric", + weekday: "short", + }).format(date), + time: new Intl.DateTimeFormat("ko-KR", { + hour: "numeric", + minute: "2-digit", + }).format(date), + }; +} + +function pickPrimary( + summary: ApiRiotRecentStatsSummary | undefined, + mainPosition: Position, +): { + stats: ApiRiotLaneStats | null; + source: "lane" | "overall" | "none"; +} { + if (!summary) { + return { stats: null, source: "none" }; + } + + const laneStats = summary.byLane[POSITION_TO_RIOT_LANE[mainPosition]]; + if (laneStats && laneStats.games > 0) { + return { stats: laneStats, source: "lane" }; + } + + if (summary.overall.games > 0) { + return { stats: summary.overall, source: "overall" }; + } + + return { stats: null, source: "none" }; +} + +export function selectPrimaryTier(tiers: ApiTierInfo[]) { + return tiers.find((tier) => tier.queueType === "RANKED_SOLO_5x5") ?? tiers[0]; +} + +export function formatTierLabel(tier?: ApiTierInfo) { + if (!tier) return "미등록"; + + const tierName = TIER_NAMES[tier.tier] ?? tier.tier; + const highTier = ["MASTER", "GRANDMASTER", "CHALLENGER"].includes(tier.tier); + + if (highTier && tier.leaguePoints > 0) { + return `${tierName} ${tier.leaguePoints}LP`; + } + + return tier.rank ? `${tierName} ${tier.rank}` : tierName; +} + +export function getTierColorToken(tier?: ApiTierInfo) { + switch (tier?.tier) { + case "CHALLENGER": + return "text-amber-400"; + case "GRANDMASTER": + return "text-red-400"; + case "MASTER": + return "text-fuchsia-400"; + case "DIAMOND": + return "text-cyan-400"; + case "EMERALD": + return "text-emerald-400"; + case "PLATINUM": + return "text-teal-300"; + case "GOLD": + return "text-yellow-400"; + case "SILVER": + return "text-gray-300"; + case "BRONZE": + return "text-amber-700"; + case "IRON": + return "text-stone-400"; + default: + return "text-base-content/50"; + } +} + +export function buildDefaultPreferredPositions() { + return POSITION_ORDER.map((position, index) => ({ + position, + priority: index + 1, + })); +} + +export function mapApiMatchToMatchDetail(match: ApiMatch): MatchDetailView { + const formattedDate = formatKoreanDate(match.scheduledAt); + const participants = match.participants.map(mapMatchParticipantToView); + const participantLookup = new Map( + participants.map((participant) => [participant.userId, participant]), + ); + + const teams = match.teams.map((team) => ({ + teamIndex: team.teamIndex, + name: teamIndexLabel(team.teamIndex, team.name), + participants: team.members.map((member) => { + const participant = + participantLookup.get(member.userId) ?? + createFallbackParticipant(member.userId); + + return { + ...participant, + assignedPosition: member.assignedPosition, + cost: member.cost, + }; + }), + })); + + const winnerTeam = match.result?.winnerTeamIndex + ? teams.find((team) => team.teamIndex === match.result?.winnerTeamIndex) + : undefined; + + return { + id: match._id, + title: match.title, + date: formattedDate.date, + time: formattedDate.time, + status: match.status, + description: match.description, + map: mapIdToLabel(match.mapId), + maxParticipants: match.maxParticipants, + gameCount: match.gameCount ?? 3, + gameMode: match.gameMode ?? "pair", + tournamentCodes: match.tournamentCodes ?? [], + joined: Boolean(match.joined), + participants, + teams, + result: match.result + ? { + winner: match.result.winnerTeamIndex ? winnerTeam?.name : undefined, + winnerTeamIndex: match.result.winnerTeamIndex, + riotMatchIds: match.result.riotMatchIds, + games: [...(match.result.games ?? [])].sort( + (left, right) => left.gameNumber - right.gameNumber, + ), + seriesResults: match.result.seriesResults ?? [], + } + : undefined, + prizes: match.prizes, + notices: match.notices, + schedule: match.schedule, + }; +} + +export function mapApiAuctionToAuctionState( + auction: ApiAuction, + match: ApiMatch, + now = new Date(), +): AuctionStateView { + const participantLookup = new Map( + match.participants + .map(mapMatchParticipantToView) + .map((participant) => [participant.userId, participant]), + ); + const auctionOrder = auction.order.map(mapAuctionPlayerToView); + const passedQueue = (auction.passedQueue ?? []).map(mapAuctionPlayerToView); + const auctionPlayerLookup = new Map( + auctionOrder.map((player) => [player.userId, player]), + ); + const teams = [...auction.teams].sort( + (left, right) => left.teamIndex - right.teamIndex, + ); + + const totalPlayers = auctionOrder.length; + const currentPlayer = + auction.phase === "complete" + ? null + : (auctionPlayerLookup.get( + auction.order[auction.currentIndex]?.userId ?? "", + ) ?? null); + const currentPlayerIndex = + auction.phase === "complete" ? totalPlayers : auction.currentIndex; + const timer = auction.currentDeadline + ? Math.max( + 0, + Math.ceil( + (new Date(auction.currentDeadline).getTime() - now.getTime()) / 1000, + ), + ) + : 0; + + return { + matchId: auction.matchId, + phase: auction.phase, + teams: teams.map((team) => + mapAuctionTeamToView(team, auctionPlayerLookup, participantLookup), + ), + currentPlayer, + currentPlayerIndex, + totalPlayers, + auctionOrder, + passedQueue, + auctionRound: auction.auctionRound ?? 1, + bids: auction.bids.map((bid) => ({ + teamIndex: bid.teamIndex, + amount: bid.amount, + timestamp: bid.timestamp, + })), + currentBid: auction.currentBid, + currentBidder: auction.currentBidderTeamIndex + ? { + teamIndex: auction.currentBidderTeamIndex, + } + : null, + timer, + maxTimer: auction.maxTimerSeconds, + bidExtensionSeconds: auction.bidExtensionSeconds ?? 5, + deadline: auction.currentDeadline, + }; +} diff --git a/apps/web/src/api/types.ts b/apps/web/src/api/types.ts new file mode 100644 index 00000000..e349c1c9 --- /dev/null +++ b/apps/web/src/api/types.ts @@ -0,0 +1,853 @@ +export type Position = 'TOP' | 'JGL' | 'MID' | 'ADC' | 'SUP'; +export type RiotLane = 'TOP' | 'JUNGLE' | 'MIDDLE' | 'BOTTOM' | 'UTILITY'; +export type TeamSide = 'blue' | 'red'; +export type MatchGameMode = 'pair' | 'bracket' | 'round-robin'; +export type MatchStatus = + | 'recruiting' + | 'team-built' + | 'in-progress' + | 'finished'; +export type AuctionPhase = + | 'waiting' + | 'presenting' + | 'bidding' + | 'sold' + | 'passed' + | 'complete'; +export type AuctionTopTierThreshold = + | 'NONE' + | 'EMERALD' + | 'DIAMOND' + | 'MASTER' + | 'MANUAL'; +export type CommunityRole = 'owner' | 'admin' | 'member'; + +export interface ApiPositionPreference { + position: Position; + priority: number; +} + +export interface ApiTierInfo { + queueType: string; + tier: string; + rank: string; + leaguePoints: number; + wins: number; + losses: number; + fetchedAt: string; +} + +export interface ApiChampionMasteryEntry { + puuid?: string; + championId: number; + championLevel: number; + championPoints: number; + lastPlayTime?: number; + championPointsSinceLastLevel?: number; + championPointsUntilNextLevel?: number; + markRequiredForNextLevel?: number; + tokensEarned?: number; + championSeasonMilestone?: number; + milestoneGrades?: string[]; + nextSeasonMilestone?: Record; +} + +export interface ApiRiotLaneStats { + games: number; + wins: number; + losses: number; + avgKills: number; + avgDeaths: number; + avgAssists: number; + avgCs: number; + avgCsPerMin: number; + mostPlayedChampionIds: number[]; +} + +export interface ApiRiotRecentStatsSummary { + overall: ApiRiotLaneStats; + byLane: Partial>; +} + +export interface ApiRiotAccount { + puuid: string; + gameName: string; + tagLine: string; + profileIconId: number; + revisionDate: number; + summonerLevel: number; + isPrimary: boolean; + tiers: ApiTierInfo[]; + tierHistory: unknown[]; + matchIds: string[]; + championMasteries: ApiChampionMasteryEntry[]; + championRecords: Record>; + recentStatsSummary?: ApiRiotRecentStatsSummary; + createdAt: string; + updatedAt: string; +} + +export interface ApiUser { + _id: string; + communityId: string; + identityId?: string; + role: CommunityRole; + kakaoTalkId?: string; + kakaoTalkNickname?: string; + discordId?: string; + discordNickname?: string; + riotAccounts: ApiRiotAccount[]; + preferredPositions: ApiPositionPreference[]; + isActivated: boolean; + createdAt: string; + updatedAt: string; +} + +export interface ApiCommunity { + _id: string; + name: string; + description: string; + ownerUserId: string; + matchGameCount?: number; + createdAt: string; + updatedAt: string; +} + +export type TournamentCodeState = + | 'available' + | 'reserved' + | 'used' + | 'expired' + | 'released'; + +export type TournamentCodeSlotState = TournamentCodeState | 'pending'; + +export interface TournamentCodeSlotView { + gameNumber: number; + teamAIndex: number; + teamBIndex: number; + code: string | null; + expiresAt: string | null; + state: TournamentCodeSlotState; + riotMatchId: string | null; +} + +export interface ApiMatchParticipant { + userId: string; + puuid?: string; + gameName?: string; + tagLine?: string; + profileIconId?: number; + tier?: ApiTierInfo; + preferredPositions: ApiPositionPreference[]; + joinedAt: string; + excluded?: boolean; +} + +export interface ApiMatchTeamMember { + userId: string; + assignedPosition: Position; + cost?: number; +} + +export interface ApiMatchTeam { + teamIndex: number; + name: string; + captainUserId?: string; + members: ApiMatchTeamMember[]; +} + +export interface ApiMatchGameResultParticipant { + userId: string; + teamIndex: number; + side: TeamSide; + championId: number; + kills: number; + deaths: number; + assists: number; + win: boolean; +} + +export interface ApiMatchGameResult { + gameNumber: number; + riotMatchId: string; + blueTeamIndex: number; + redTeamIndex: number; + winnerTeamIndex: number; + winnerSide: TeamSide; + gameCreation: number; + gameDuration: number; + participants: ApiMatchGameResultParticipant[]; +} + +export interface ApiMatchResult { + winnerTeamIndex?: number; + mvpUserId?: string; + riotMatchIds: string[]; + games: ApiMatchGameResult[]; + seriesResults?: Array<{ + teamAIndex: number; + teamBIndex: number; + teamAWins: number; + teamBWins: number; + winnerTeamIndex?: number; + }>; +} + +export interface ApiMatchScheduleItem { + time: string; + label: string; +} + +export interface ApiMatchGameAssignment { + gameNumber: number; + teamAIndex: number; + teamBIndex: number; +} + +export interface ManualTournamentResultCollectResponse { + scanned: number; + matched: number; + skipped: number; + riotMatchIds: string[]; + gameNumbers: number[]; +} + +export interface ApiMatch { + _id: string; + communityId: string; + shortCode?: string; + title: string; + description: string; + mapId: number; + status: MatchStatus; + scheduledAt: string; + maxParticipants: number; + gameCount: number; + gameMode: MatchGameMode; + gameSchedule?: ApiMatchGameAssignment[]; + tournamentCodes?: TournamentCodeSlotView[]; + hostUserId?: string; + participants: ApiMatchParticipant[]; + teams: ApiMatchTeam[]; + result?: ApiMatchResult; + prizes: string[]; + notices: string[]; + schedule: ApiMatchScheduleItem[]; + joined?: boolean; + createdAt: string; + updatedAt: string; +} + +export interface ApiAuctionPlayerSnapshot { + userId: string; + puuid: string; + gameName: string; + tagLine: string; + profileIconId: number; + preferredPositions: ApiPositionPreference[]; + tiers: ApiTierInfo[]; + masteries: ApiChampionMasteryEntry[]; + recentStatsSummary?: ApiRiotRecentStatsSummary; + passCount: number; +} + +export interface ApiAuctionTeamMember { + userId: string; + assignedPosition: Position; + cost: number; +} + +export interface ApiAuctionTeam { + teamIndex: number; + captainUserId: string; + points: number; + members: ApiAuctionTeamMember[]; +} + +export interface ApiAuctionBid { + teamIndex: number; + amount: number; + bidderUserId: string; + timestamp: string; +} + +export interface ApiAuction { + _id: string; + matchId: string; + phase: AuctionPhase; + teams: ApiAuctionTeam[]; + order: ApiAuctionPlayerSnapshot[]; + passedQueue: ApiAuctionPlayerSnapshot[]; + auctionRound: number; + currentIndex: number; + bids: ApiAuctionBid[]; + currentBid: number; + currentBidderTeamIndex?: number; + maxTimerSeconds: number; + bidExtensionSeconds: number; + currentDeadline?: string; + initialPoints: number; + topTierThreshold: AuctionTopTierThreshold; + manualTopTierUserIds: string[]; + startedAt?: string; + completedAt?: string; + createdAt: string; + updatedAt: string; +} + +export interface ApiAuctionHistoryEntry { + sequence: number; + action: + | 'start' + | 'open-bidding' + | 'bid' + | 'sold' + | 'passed' + | 'next' + | 'complete'; + actionLabel: string; + takenAt: string; +} + +export interface ApiIdentity { + id: string; + entraOid: string; + tenantId?: string; + email?: string; + displayName?: string; +} + +export interface ApiMembership { + user: ApiUser; + community: ApiCommunity | null; +} + +export interface MeResponse { + identity: ApiIdentity | null; + memberships: ApiMembership[]; +} + +export interface MatchesResponse { + matches: ApiMatch[]; +} + +export interface MatchMutationRequest { + title: string; + description?: string; + mapId?: number; + scheduledAt: string; + maxParticipants?: number; + gameCount?: number; + gameMode?: MatchGameMode; + prizes?: string[]; + notices?: string[]; + schedule?: ApiMatchScheduleItem[]; +} + +export interface DdragonChampionEntry { + key: string; + name: string; +} + +export interface DdragonSummonerSpellEntry { + key: string; + name: string; +} + +export interface DdragonRuneEntry { + id: number; + key: string; + icon: string; + name: string; +} + +export interface DdragonRuneStyleEntry extends DdragonRuneEntry { + slots: Array<{ runes: DdragonRuneEntry[] }>; +} + +export interface DdragonManifest { + version: string; + cdn: string; + locale: string; + champions: Record; + summonerSpells: Record; + runesReforged: DdragonRuneStyleEntry[]; + fetchedAt: string; +} + +export type TournamentSpectatorType = 'NONE' | 'LOBBYONLY' | 'ALL'; + +export interface ApiTournamentCode { + _id: string; + code: string; + region: string; + mapType: 'SUMMONERS_RIFT'; + teamSize: number; + spectatorType: TournamentSpectatorType; + metadata?: Record; + expiresAt: string; + state: TournamentCodeState; + matchId?: string; + gameNumber?: number; + reservedAt?: string; + usedAt?: string; + releasedAt?: string; + riotMatchId?: string; + uploadedBy: string; + uploadedAt: string; + source?: string; + notes?: string; + createdAt: string; + updatedAt: string; +} + +export interface TournamentCodeStatsResponse { + byState: Record; + expiringSoon: number; + available: number; +} + +export interface TournamentCodeListResponse { + codes: ApiTournamentCode[]; +} + +export interface TournamentCodeUploadItem { + code: string; + expiresAt: string; + spectatorType?: TournamentSpectatorType; + metadata?: Record; + source?: string; + notes?: string; +} + +export interface TournamentCodeBulkUploadResponse { + inserted: number; + duplicates: string[]; + invalid: Array<{ code: string; reason: string }>; +} + +export type RiotQueueGroup = + | 'all' + | 'summoners-rift' + | 'aram' + | 'urf' + | 'arena' + | 'internal'; +export type RiotRankFilter = 'all' | 'solo' | 'flex' | 'normal'; + +export interface ApiHistorySeason { + id: string; + label: string; + startedAt: string | null; + endedAt: string | null; +} + +export interface ApiUserHistoryProfile { + userId: string; + puuid: string; + gameName: string; + tagLine: string; + profileIconId: number; + summonerLevel: number; + tiers: ApiTierInfo[]; + season: ApiHistorySeason; + seasons: ApiHistorySeason[]; + lastFetchedAt: string | null; +} + +export interface ApiChampionStatsRow { + championId: number; + games: number; + wins: number; + losses: number; + winRate: number; + avgKills: number; + avgDeaths: number; + avgAssists: number; + kda: number; + totalKills: number; + totalDeaths: number; + totalAssists: number; + doubleKills: number; + tripleKills: number; + quadraKills: number; + pentaKills: number; + avgCs: number; + avgCsPerMin: number; +} + +export interface ApiChampionStatsResponse { + queueGroup: RiotQueueGroup; + rank: RiotRankFilter; + queueIds: number[]; + season: ApiHistorySeason; + lastFetchedAt: string | null; + champions: ApiChampionStatsRow[]; + totals: ApiChampionStatsRow; +} + +export interface ApiRecentSummaryResponse { + windowSize: number; + winRate: number; + wins: number; + losses: number; + streak: { type: 'win' | 'loss'; count: number } | null; + kda: number; + avgKills: number; + avgDeaths: number; + avgAssists: number; + bestRating: { + rating: number | 'Perfect'; + kills: number; + deaths: number; + assists: number; + matchId: string; + } | null; + positionRates: Partial>; + topChampions: Array<{ + championId: number; + games: number; + winRate: number; + pickRate: number; + avgRating: number; + }>; + lastFetchedAt: string | null; +} + +export interface ApiRecentMatchTeamParticipant { + puuid: string; + gameName: string; + tagLine: string; + championId: number; + championLevel: number; + teamPosition: string; + kills: number; + deaths: number; + assists: number; + items: number[]; + trinket: number; + summonerSpells: [number, number]; + perks: { primaryStyle?: number; subStyle?: number; keystone?: number }; + totalCs: number; + csPerMin: number; + goldEarned: number; + damageDealtToChampions: number; + damageTaken: number; + visionScore: number; + wardsPlaced: number; + wardsKilled: number; + controlWardsBought: number; +} + +export interface ApiRecentMatchTeam { + side: 100 | 200; + win: boolean; + objectives?: { baron?: number; dragon?: number; tower?: number }; + participants: ApiRecentMatchTeamParticipant[]; +} + +export interface ApiRecentMatchView { + matchId: string; + queueId: number; + queueLabel: string; + gameCreation: number; + gameDuration: number; + win: boolean; + remake: boolean; + championId: number; + championLevel: number; + teamPosition: string; + kills: number; + deaths: number; + assists: number; + kda: number; + rating: number; + totalCs: number; + csPerMin: number; + killParticipation: number; + visionScore: number; + controlWardsBought: number; + wardsPlaced: number; + wardsKilled: number; + damageDealtToChampions: number; + damageTaken: number; + goldEarned: number; + items: number[]; + trinket: number; + summonerSpells: [number, number]; + perks: { primaryStyle?: number; subStyle?: number; keystone?: number }; + teams: ApiRecentMatchTeam[]; +} + +export interface ApiRecentMatchesResponse { + matches: ApiRecentMatchView[]; + nextCursor: number | null; + lastFetchedAt: string | null; + season: ApiHistorySeason; +} + +export interface ApiInternalMatchCard { + matchId: string; + title: string; + scheduledAt: string; + status: 'finished' | 'in-progress'; + gameCount: number; + winnerTeamIndex?: number; + seriesResults: Array<{ + teamAIndex: number; + teamBIndex: number; + teamAWins: number; + teamBWins: number; + winnerTeamIndex?: number; + }>; + games: Array<{ + gameNumber: number; + riotMatchId: string | null; + blueTeamIndex: number; + redTeamIndex: number; + winnerTeamIndex: number | null; + winnerSide: TeamSide | null; + gameDuration: number; + }>; + teams: Array<{ + teamIndex: number; + name: string; + members: Array<{ + userId: string; + summonerName: string; + profileIconId: number; + }>; + }>; +} + +export interface ApiInternalMatchListResponse { + matches: ApiInternalMatchCard[]; + nextCursor: number | null; + season: ApiHistorySeason; +} + +export interface ApiLeaderboardRow { + userId: string; + summonerName: string; + profileIconId: number; + games: number; + wins: number; + losses: number; + winRate: number; + totalKills: number; + totalDeaths: number; + totalAssists: number; + kda: number; + avgGoldPerMin: number; + avgKillParticipation: number; + avgCsPerMin: number; + avgDamageShare: number; + avgVisionScore: number; + byLane: Partial>; + topChampions: Array<{ championId: number; games: number; winRate: number }>; +} + +export interface ApiLeaderboardResponse { + rows: ApiLeaderboardRow[]; + season: ApiHistorySeason; +} + +export interface ApiLeaderHighlight { + metric: number; + userId: string; + summonerName: string; + championId?: number; + matchId?: string; + isSingleGame: boolean; +} + +export interface ApiTeamInsightsResponse { + season: ApiHistorySeason; + sideWinRate: { + blue: number; + red: number; + bluePicks: number; + redPicks: number; + }; + topKda: ApiLeaderHighlight | null; + mostKills: ApiLeaderHighlight | null; + topTeamGpm: ApiLeaderHighlight | null; + topKillParticipation: ApiLeaderHighlight | null; + bestFarm: ApiLeaderHighlight | null; + minGamesThreshold: number; +} + +export interface ApiInternalMatchDetailResponse { + match: ApiInternalMatchCard; + games: Array<{ + gameNumber: number; + riotMatchId: string; + gameCreation: number; + gameDuration: number; + teams: Array<{ + teamIndex: number; + side: TeamSide; + win: boolean; + objectives: { baron: number; dragon: number; tower: number }; + participants: Array<{ + userId: string | null; + summonerName: string; + teamIndex: number; + side: TeamSide; + teamPosition: string; + championId: number; + kills: number; + deaths: number; + assists: number; + cs: number; + csPerMin: number; + gold: number; + gpm: number; + damageDealtToChampions: number; + damageShare: number; + killParticipation: number; + visionScore: number; + items: number[]; + trinket: number; + summonerSpells: [number, number]; + perks: { primaryStyle?: number; subStyle?: number; keystone?: number }; + win: boolean; + }>; + }>; + }>; +} + +export interface ApiUserInternalHistoryResponse { + season: ApiHistorySeason; + championStats: ApiChampionStatsResponse; + summary: ApiRecentSummaryResponse; + matches: ApiRecentMatchView[]; + nextCursor: number | null; + lastFetchedAt: string | null; +} + +export type LegacyImportJobState = + | 'pending' + | 'running' + | 'completed' + | 'failed' + | 'cancelled'; + +export interface LegacyImportMemberWindow { + userId: string; + puuid: string; + displayName: string; + gameName: string; + tagLine: string; + profileIconId: number; + isActivated: boolean; + startTime: string; + endTime: string; +} + +export interface LegacyImportMembersResponse { + members: LegacyImportMemberWindow[]; +} + +export interface StartLegacyImportRequest { + windowStart?: string; + windowEnd?: string; + memberOverrides?: Array<{ + userId: string; + startTime?: string; + endTime?: string; + }>; +} + +export interface StartLegacyImportResponse { + jobId: string; + totalMembers: number; + etaSeconds: number; +} + +export interface LegacyImportJob { + _id: string; + jobId: string; + communityId: string; + triggeredBy: string; + startedAt: string; + completedAt?: string; + state: LegacyImportJobState; + windowStart: string; + windowEnd: string; + memberOverrides: Array<{ + userId: string; + puuid: string; + startTime: string; + endTime: string; + }>; + totalMembers: number; + processedMembers: number; + totalDiscoveredMatchIds: number; + totalImportedMatches: number; + totalSkippedDuplicate: number; + totalErrors: number; + averageMemberSeconds?: number; + errors?: Array<{ + puuid?: string; + matchId?: string; + reason: string; + at: string; + }>; +} + +export interface LegacyImportJobsResponse { + jobs: LegacyImportJob[]; +} + +export interface LegacyMatchListItem { + matchId: string; + title: string; + scheduledAt: string; + riotMatchId: string | null; + memberCount: number; + externalCount: number; + teamAIndex: number; + teamBIndex: number; + teamAWins: number; + teamBWins: number; + winnerTeamIndex?: number; +} + +export interface LegacyMatchListResponse { + matches: LegacyMatchListItem[]; + nextCursor: number | null; +} + +export interface RebuildLegacyMatchesResponse { + scanned: number; + rebuilt: number; + normalizedTitles: number; + skippedMissingRaw: number; + skippedNoKnownParticipants: number; +} + +export type ApiRiotJobPriority = 'high' | 'low'; +export type ApiRiotJobState = 'queued' | 'processing' | 'completed' | 'failed'; + +export interface ApiEnqueueRefreshResult { + parentJobId: string; + subJobs: Array<{ + jobId: string; + queueGroup: RiotQueueGroup; + alreadyQueued: boolean; + etaSeconds: number; + queuePosition: number; + }>; + totalEtaSeconds: number; +} + +export interface ApiRiotRefreshEvent { + parentJobId: string; + jobId: string; + queueGroup: RiotQueueGroup; + puuid: string; + state: ApiRiotJobState; + error?: string; +} diff --git a/apps/web/src/api/useAuctionSocket.ts b/apps/web/src/api/useAuctionSocket.ts new file mode 100644 index 00000000..49cef7ed --- /dev/null +++ b/apps/web/src/api/useAuctionSocket.ts @@ -0,0 +1,121 @@ +import { useEffect, useRef, useState } from 'react'; +import { io, type Socket } from 'socket.io-client'; +import { API_BASE_URL, useAuthUserId } from '../config'; +import { acquireAccessToken } from '../lib/auth/token-provider'; +import type { ApiAuction, Position } from './types'; + +type ConnectionStatus = + | 'idle' + | 'connecting' + | 'connected' + | 'disconnected' + | 'error'; + +interface BidPayload { + teamIndex: number; + amount: number; + bidderUserId?: string; +} + +export function useAuctionSocket(matchId: string | undefined) { + const authUserId = useAuthUserId(); + const socketRef = useRef(null); + const [auction, setAuction] = useState(null); + const [connectionStatus, setConnectionStatus] = + useState('idle'); + const [error, setError] = useState(null); + + useEffect(() => { + if (!matchId) { + setAuction(null); + setConnectionStatus('idle'); + return; + } + + let disposed = false; + setConnectionStatus('connecting'); + setError(null); + + void (async () => { + const accessToken = await acquireAccessToken().catch((error) => { + console.warn('Failed to acquire socket access token:', error); + return null; + }); + if (disposed) return; + + const socket = io(`${API_BASE_URL}/auction`, { + transports: ['websocket'], + auth: accessToken + ? { token: accessToken } + : authUserId + ? { 'x-auth-user-id': authUserId } + : {}, + }); + + socketRef.current = socket; + + socket.on('connect', () => { + setConnectionStatus('connected'); + socket.emit('join', { matchId }); + }); + + socket.on('disconnect', () => { + setConnectionStatus('disconnected'); + }); + + socket.on('state', (nextAuction: ApiAuction) => { + setAuction(nextAuction); + setError(null); + }); + + socket.on('error', (payload: { message?: string }) => { + setConnectionStatus('error'); + setError(payload.message ?? '실시간 경매 연결 중 오류가 발생했습니다.'); + }); + })(); + + return () => { + disposed = true; + const socket = socketRef.current; + socket?.removeAllListeners(); + socket?.disconnect(); + socketRef.current = null; + setConnectionStatus('idle'); + }; + }, [authUserId, matchId]); + + function emit(eventName: string, payload?: unknown) { + const socket = socketRef.current; + if (!socket || !socket.connected) { + setError('소켓이 아직 연결되지 않았습니다.'); + return; + } + + setError(null); + + if (payload === undefined) { + socket.emit(eventName); + return; + } + + socket.emit(eventName, payload); + } + + return { + auction, + connectionStatus, + error, + placeBid(payload: BidPayload) { + emit('bid', payload); + }, + openBidding() { + emit('open-bidding', {}); + }, + markSold(assignedPosition?: Position) { + emit('sold', assignedPosition ? { assignedPosition } : {}); + }, + next() { + emit('next', {}); + }, + }; +} diff --git a/apps/web/src/api/useRiotRefreshSocket.ts b/apps/web/src/api/useRiotRefreshSocket.ts new file mode 100644 index 00000000..c53aa443 --- /dev/null +++ b/apps/web/src/api/useRiotRefreshSocket.ts @@ -0,0 +1,73 @@ +import { useEffect, useRef, useState } from 'react'; +import { io, type Socket } from 'socket.io-client'; +import { API_BASE_URL } from '../config'; +import type { ApiRiotRefreshEvent } from './types'; + +type ConnectionStatus = + | 'idle' + | 'connecting' + | 'connected' + | 'disconnected' + | 'error'; + +export function useRiotRefreshSocket({ + puuid, + parentJobId, + onEvent, +}: { + puuid?: string; + parentJobId?: string; + onEvent: (event: ApiRiotRefreshEvent) => void; +}) { + const socketRef = useRef(null); + const onEventRef = useRef(onEvent); + const [connectionStatus, setConnectionStatus] = + useState('idle'); + const [error, setError] = useState(null); + + useEffect(() => { + onEventRef.current = onEvent; + }, [onEvent]); + + useEffect(() => { + if (!puuid && !parentJobId) { + setConnectionStatus('idle'); + return; + } + + setConnectionStatus('connecting'); + setError(null); + + const socket = io(`${API_BASE_URL}/riot-refresh`, { + transports: ['websocket'], + }); + socketRef.current = socket; + + socket.on('connect', () => { + setConnectionStatus('connected'); + socket.emit('subscribe', { puuid, parentJobId }); + }); + + socket.on('disconnect', () => { + setConnectionStatus('disconnected'); + }); + + socket.on('riot-refresh', (event: ApiRiotRefreshEvent) => { + onEventRef.current(event); + }); + + socket.on('error', (payload: { message?: string }) => { + setConnectionStatus('error'); + setError(payload.message ?? '전적 갱신 소켓 연결 중 오류가 발생했습니다.'); + }); + + return () => { + socket.removeAllListeners(); + socket.disconnect(); + socketRef.current = null; + setConnectionStatus('idle'); + }; + }, [parentJobId, puuid]); + + return { connectionStatus, error }; +}