diff --git a/apps/api/src/modules/riot/riot-ddragon.controller.ts b/apps/api/src/modules/riot/riot-ddragon.controller.ts new file mode 100644 index 00000000..4dbd58a0 --- /dev/null +++ b/apps/api/src/modules/riot/riot-ddragon.controller.ts @@ -0,0 +1,19 @@ +import { Controller, Get, Query } from '@nestjs/common'; +import { AllowPublicAccess } from '../auth/allow-public-access.decorator'; +import { + RiotDdragonService, + type DdragonManifest, +} from './riot-ddragon.service'; + +@Controller('riot/ddragon') +export class RiotDdragonController { + constructor(private readonly ddragonService: RiotDdragonService) {} + + @Get('manifest') + @AllowPublicAccess() + public async getManifest( + @Query('locale') locale?: string, + ): Promise { + return this.ddragonService.getManifest(locale ?? 'ko_KR'); + } +} diff --git a/apps/api/src/modules/riot/riot-ddragon.service.ts b/apps/api/src/modules/riot/riot-ddragon.service.ts new file mode 100644 index 00000000..a66d65fb --- /dev/null +++ b/apps/api/src/modules/riot/riot-ddragon.service.ts @@ -0,0 +1,250 @@ +import { Injectable, Logger } from '@nestjs/common'; +import { GarnetService } from '../global/garnet/garnet.service'; + +const DDRAGON_BASE = 'https://ddragon.leagueoflegends.com'; +const DDRAGON_CDN = `${DDRAGON_BASE}/cdn`; +const DEFAULT_LOCALE = 'ko_KR'; +const CACHE_TTL_SECONDS = 24 * 60 * 60; +const CACHE_VERSION = 'v3'; +const FETCH_TIMEOUT_MS = 10_000; + +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; +} + +interface ChampionDataEntry { + key: string; + id: string; + name: string; +} + +interface ChampionDataResponse { + data: Record; +} + +interface SummonerSpellDataEntry { + key: string; + id: string; + name: string; +} + +interface SummonerSpellDataResponse { + data: Record; +} + +interface RuneDataEntry { + id: number; + key: string; + icon: string; + name: string; +} + +interface RuneStyleDataEntry extends RuneDataEntry { + slots?: Array<{ runes?: RuneDataEntry[] }>; +} + +@Injectable() +export class RiotDdragonService { + private readonly logger = new Logger(RiotDdragonService.name); + private inflight = new Map>(); + + constructor(private readonly garnetService: GarnetService) {} + + public async getManifest(locale: string = DEFAULT_LOCALE): Promise { + const normalizedLocale = normalizeLocale(locale); + const cacheKey = manifestCacheKey(normalizedLocale); + + const cached = await this.garnetService.getJson(cacheKey); + if (cached) return cached; + + const pending = this.inflight.get(cacheKey); + if (pending) return pending; + + const promise = this.buildManifest(normalizedLocale) + .then(async (manifest) => { + await this.garnetService.setJson(cacheKey, manifest, CACHE_TTL_SECONDS); + return manifest; + }) + .finally(() => { + this.inflight.delete(cacheKey); + }); + + this.inflight.set(cacheKey, promise); + return promise; + } + + private async buildManifest(locale: string): Promise { + const version = await this.fetchLatestVersion(); + const [champions, summonerSpells, runesReforged] = await Promise.all([ + this.fetchChampionMap(version, locale), + this.fetchSummonerSpellMap(version, locale), + this.fetchRuneStyles(version, locale), + ]); + return { + version, + cdn: DDRAGON_CDN, + locale, + champions, + summonerSpells, + runesReforged, + fetchedAt: new Date().toISOString(), + }; + } + + private async fetchLatestVersion(): Promise { + const versions = await this.fetchJson(`${DDRAGON_BASE}/api/versions.json`); + if (!Array.isArray(versions) || typeof versions[0] !== 'string') { + throw new Error('ddragon versions.json response is malformed.'); + } + return versions[0]; + } + + private async fetchChampionMap( + version: string, + locale: string, + ): Promise> { + const url = `${DDRAGON_CDN}/${version}/data/${locale}/champion.json`; + const payload = await this.fetchJson(url); + if (!payload || typeof payload !== 'object' || !payload.data) { + throw new Error(`ddragon champion.json response is malformed (${url}).`); + } + + const map: Record = {}; + for (const entry of Object.values(payload.data)) { + if (entry?.key && entry.id) { + map[entry.key] = { + key: entry.id, + name: typeof entry.name === 'string' ? entry.name : entry.id, + }; + } + } + return map; + } + + private async fetchSummonerSpellMap( + version: string, + locale: string, + ): Promise> { + const url = `${DDRAGON_CDN}/${version}/data/${locale}/summoner.json`; + const payload = await this.fetchJson(url); + if (!payload || typeof payload !== 'object' || !payload.data) { + throw new Error(`ddragon summoner.json response is malformed (${url}).`); + } + + const map: Record = {}; + for (const entry of Object.values(payload.data)) { + if (entry?.key && entry.id) { + map[entry.key] = { + key: entry.id, + name: typeof entry.name === 'string' ? entry.name : entry.id, + }; + } + } + return map; + } + + private async fetchRuneStyles( + version: string, + locale: string, + ): Promise { + const url = `${DDRAGON_CDN}/${version}/data/${locale}/runesReforged.json`; + const payload = await this.fetchJson(url); + if (!Array.isArray(payload)) { + throw new Error(`ddragon runesReforged.json response is malformed (${url}).`); + } + + return payload + .filter((style): style is RuneStyleDataEntry => isRuneEntry(style)) + .map((style) => ({ + id: style.id, + key: style.key, + icon: style.icon, + name: style.name, + slots: (style.slots ?? []).map((slot) => ({ + runes: (slot.runes ?? []) + .filter((rune): rune is RuneDataEntry => isRuneEntry(rune)) + .map((rune) => ({ + id: rune.id, + key: rune.key, + icon: rune.icon, + name: rune.name, + })), + })), + })); + } + + private async fetchJson(url: string): Promise { + const controller = new AbortController(); + const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS); + try { + const response = await fetch(url, { + method: 'GET', + headers: { Accept: 'application/json' }, + signal: controller.signal, + }); + if (!response.ok) { + throw new Error( + `ddragon request failed (${response.status}): ${url}`, + ); + } + return (await response.json()) as T; + } catch (err) { + this.logger.error( + `ddragon fetch error for ${url}: ${(err as Error)?.message ?? err}`, + ); + throw err; + } finally { + clearTimeout(timeout); + } + } +} + +function normalizeLocale(locale: string): string { + const trimmed = locale.trim(); + if (!/^[a-zA-Z]{2}_[a-zA-Z]{2}$/.test(trimmed)) { + return DEFAULT_LOCALE; + } + return `${trimmed.slice(0, 2).toLowerCase()}_${trimmed.slice(3).toUpperCase()}`; +} + +function isRuneEntry(value: unknown): value is RuneDataEntry { + if (!value || typeof value !== 'object') return false; + const entry = value as Partial; + return ( + typeof entry.id === 'number' && + typeof entry.key === 'string' && + typeof entry.icon === 'string' && + typeof entry.name === 'string' + ); +} + +function manifestCacheKey(locale: string): string { + return `ddragon:manifest:${CACHE_VERSION}:${locale}`; +} diff --git a/apps/api/src/modules/riot/riot-match.service.spec.ts b/apps/api/src/modules/riot/riot-match.service.spec.ts new file mode 100644 index 00000000..6aef710b --- /dev/null +++ b/apps/api/src/modules/riot/riot-match.service.spec.ts @@ -0,0 +1,109 @@ +import { RiotClientService } from './riot.client.service'; +import { RiotMatchService } from './riot-match.service'; +import type { RiotResponseParser } from './riot.types'; + +function createMatchPayload() { + const participant = { + assists: 7, + champExperience: 12000, + champLevel: 16, + championId: 103, + championName: 'Ahri', + deaths: 2, + goldEarned: 12000, + goldSpent: 11000, + individualPosition: '', + item0: 0, + item1: 0, + item2: 0, + item3: 0, + item4: 0, + item5: 0, + item6: 0, + kills: 8, + neutralMinionsKilled: 12, + participantId: 1, + perks: { + statPerks: { defense: 0, flex: 0, offense: 0 }, + styles: [], + }, + puuid: 'puuid-1', + riotIdGameName: '테스터', + riotIdTagLine: 'KR1', + summoner1Id: 4, + summoner2Id: 14, + summonerId: 'summoner-id-1', + summonerLevel: 100, + summonerName: '', + teamId: 100, + teamPosition: '', + timePlayed: 1800, + totalDamageDealtToChampions: 22000, + totalDamageTaken: 11000, + totalMinionsKilled: 180, + visionScore: 20, + wardsKilled: 2, + wardsPlaced: 10, + win: true, + }; + + return { + metadata: { + dataVersion: '2', + matchId: 'KR_8188913502', + participants: ['puuid-1'], + }, + info: { + gameCreation: 1777000000000, + gameDuration: 1800, + gameEndTimestamp: 1777001800000, + gameId: 8188913502, + gameMode: 'CLASSIC', + gameName: 'teambuilder-match-8188913502', + gameStartTimestamp: 1777000000000, + gameType: 'MATCHED_GAME', + gameVersion: '15.8.1', + mapId: 11, + participants: [participant], + platformId: 'KR', + queueId: 420, + teams: [ + { + bans: [], + objectives: { + baron: { first: false, kills: 0 }, + champion: { first: true, kills: 25 }, + dragon: { first: true, kills: 3 }, + inhibitor: { first: false, kills: 1 }, + riftHerald: { first: true, kills: 1 }, + tower: { first: true, kills: 8 }, + }, + teamId: 100, + win: true, + }, + ], + }, + }; +} + +describe('RiotMatchService', () => { + it('accepts empty Riot display fields in match participants', async () => { + const payload = createMatchPayload(); + const riotClientService = { + get: jest.fn( + async ( + _path: string, + _options: unknown, + parser?: RiotResponseParser, + ) => (parser ? parser(payload) : (payload as T)), + ), + } as unknown as RiotClientService; + const service = new RiotMatchService(riotClientService); + + const match = await service.getMatch('KR_8188913502', { region: 'asia' }); + + expect(match.info.participants[0].summonerName).toBe(''); + expect(match.info.participants[0].teamPosition).toBe(''); + expect(match.info.participants[0].individualPosition).toBe(''); + }); +}); diff --git a/apps/api/src/modules/riot/riot-match.service.ts b/apps/api/src/modules/riot/riot-match.service.ts new file mode 100644 index 00000000..33aaeb86 --- /dev/null +++ b/apps/api/src/modules/riot/riot-match.service.ts @@ -0,0 +1,630 @@ +import { Injectable } from '@nestjs/common'; +import { RiotClientService } from './riot.client.service'; +import { + RiotMatchBanDto, + RiotMatchDto, + RiotMatchIdsLookupOptions, + RiotMatchInfoDto, + RiotMatchLookupOptions, + RiotMatchMetadataDto, + RiotMatchObjectiveDto, + RiotMatchObjectivesDto, + RiotMatchParticipantDto, + RiotMatchPerksDto, + RiotMatchPerkStyleDto, + RiotMatchPerkStyleSelectionDto, + RiotMatchStatPerksDto, + RiotMatchTeamDto, + RiotMatchType, +} from './riot.types'; + +const RIOT_MATCH_TYPES: RiotMatchType[] = [ + 'ranked', + 'normal', + 'tourney', + 'tutorial', +]; + +@Injectable() +export class RiotMatchService { + constructor(private readonly riotClientService: RiotClientService) {} + + public async getMatchIdsByPuuid( + puuid: string, + options: RiotMatchIdsLookupOptions = {}, + ): Promise { + validateMatchIdsLookupOptions(options); + + return this.riotClientService.get( + `/lol/match/v5/matches/by-puuid/${encodeURIComponent(puuid)}/ids`, + { + region: options.region, + signal: options.signal, + query: { + start: options.start, + count: options.count, + queue: options.queue, + type: options.type, + startTime: options.startTime, + endTime: options.endTime, + }, + }, + parseMatchIdsResponse, + ); + } + + public async getMatch( + matchId: string, + options: RiotMatchLookupOptions = {}, + ): Promise { + return this.riotClientService.get( + `/lol/match/v5/matches/${encodeURIComponent(matchId)}`, + { + region: options.region, + signal: options.signal, + }, + parseMatchResponse, + ); + } +} + +function validateMatchIdsLookupOptions( + options: RiotMatchIdsLookupOptions, +): void { + assertOptionalNonNegativeInteger(options.start, 'start'); + assertOptionalRange(options.count, 'count', 0, 100); + assertOptionalNonNegativeInteger(options.queue, 'queue'); + assertOptionalNonNegativeInteger(options.startTime, 'startTime'); + assertOptionalNonNegativeInteger(options.endTime, 'endTime'); + + if (options.type !== undefined && !RIOT_MATCH_TYPES.includes(options.type)) { + throw new RangeError( + `type must be one of: ${RIOT_MATCH_TYPES.join(', ')}`, + ); + } + + if ( + options.startTime !== undefined && + options.endTime !== undefined && + options.startTime > options.endTime + ) { + throw new RangeError('startTime must be less than or equal to endTime.'); + } +} + +function parseMatchIdsResponse(value: unknown): string[] { + if (!Array.isArray(value)) { + throw new TypeError('Riot match ids response must be an array.'); + } + + if (!value.every(isNonEmptyString)) { + throw new TypeError('Riot match ids response must contain only strings.'); + } + + return value; +} + +function parseMatchResponse(value: unknown): RiotMatchDto { + if (!isRecord(value)) { + throw new TypeError('Riot match response must be an object.'); + } + + return { + metadata: parseMatchMetadata(value.metadata), + info: parseMatchInfo(value.info), + }; +} + +function parseMatchMetadata(value: unknown): RiotMatchMetadataDto { + if (!isRecord(value)) { + throw new TypeError('Riot match metadata must be an object.'); + } + + const dataVersion = value.dataVersion; + const matchId = value.matchId; + const participants = value.participants; + + if (!isNonEmptyString(dataVersion)) { + throw new TypeError('Riot match metadata.dataVersion must be a string.'); + } + + if (!isNonEmptyString(matchId)) { + throw new TypeError('Riot match metadata.matchId must be a string.'); + } + + if (!Array.isArray(participants) || !participants.every(isNonEmptyString)) { + throw new TypeError( + 'Riot match metadata.participants must be an array of strings.', + ); + } + + return { + dataVersion, + matchId, + participants, + }; +} + +function parseMatchInfo(value: unknown): RiotMatchInfoDto { + if (!isRecord(value)) { + throw new TypeError('Riot match info must be an object.'); + } + + const participants = value.participants; + const teams = value.teams; + + if (!Array.isArray(participants)) { + throw new TypeError('Riot match info.participants must be an array.'); + } + + if (!Array.isArray(teams)) { + throw new TypeError('Riot match info.teams must be an array.'); + } + + const gameCreation = requireNumber(value.gameCreation, 'info.gameCreation'); + const gameDuration = requireNumber(value.gameDuration, 'info.gameDuration'); + const gameId = requireNumber(value.gameId, 'info.gameId'); + const gameMode = requireString(value.gameMode, 'info.gameMode'); + const gameName = requireString(value.gameName, 'info.gameName'); + const gameStartTimestamp = requireNumber( + value.gameStartTimestamp, + 'info.gameStartTimestamp', + ); + const gameType = requireString(value.gameType, 'info.gameType'); + const gameVersion = requireString(value.gameVersion, 'info.gameVersion'); + const mapId = requireNumber(value.mapId, 'info.mapId'); + const platformId = requireString(value.platformId, 'info.platformId'); + const queueId = requireNumber(value.queueId, 'info.queueId'); + const gameEndTimestamp = optionalNumber( + value.gameEndTimestamp, + 'info.gameEndTimestamp', + ); + const tournamentCode = optionalString( + value.tournamentCode, + 'info.tournamentCode', + ); + const endOfGameResult = optionalString( + value.endOfGameResult, + 'info.endOfGameResult', + ); + + return { + ...value, + endOfGameResult, + gameCreation, + gameDuration, + gameEndTimestamp, + gameId, + gameMode, + gameName, + gameStartTimestamp, + gameType, + gameVersion, + mapId, + participants: participants.map((participant, index) => + parseParticipant(participant, index), + ), + platformId, + queueId, + teams: teams.map((team, index) => parseTeam(team, index)), + tournamentCode, + }; +} + +function parseParticipant( + value: unknown, + index: number, +): RiotMatchParticipantDto { + if (!isRecord(value)) { + throw new TypeError(`participants[${index}] must be an object.`); + } + + return { + ...value, + assists: requireNumber(value.assists, `participants[${index}].assists`), + champExperience: requireNumber( + value.champExperience, + `participants[${index}].champExperience`, + ), + champLevel: requireNumber( + value.champLevel, + `participants[${index}].champLevel`, + ), + championId: requireNumber( + value.championId, + `participants[${index}].championId`, + ), + championName: requireString( + value.championName, + `participants[${index}].championName`, + ), + deaths: requireNumber(value.deaths, `participants[${index}].deaths`), + goldEarned: requireNumber( + value.goldEarned, + `participants[${index}].goldEarned`, + ), + goldSpent: requireNumber( + value.goldSpent, + `participants[${index}].goldSpent`, + ), + individualPosition: requireStringAllowEmpty( + value.individualPosition, + `participants[${index}].individualPosition`, + ), + item0: requireNumber(value.item0, `participants[${index}].item0`), + item1: requireNumber(value.item1, `participants[${index}].item1`), + item2: requireNumber(value.item2, `participants[${index}].item2`), + item3: requireNumber(value.item3, `participants[${index}].item3`), + item4: requireNumber(value.item4, `participants[${index}].item4`), + item5: requireNumber(value.item5, `participants[${index}].item5`), + item6: requireNumber(value.item6, `participants[${index}].item6`), + kills: requireNumber(value.kills, `participants[${index}].kills`), + neutralMinionsKilled: requireNumber( + value.neutralMinionsKilled, + `participants[${index}].neutralMinionsKilled`, + ), + participantId: requireNumber( + value.participantId, + `participants[${index}].participantId`, + ), + perks: parsePerks(value.perks, index), + puuid: requireString(value.puuid, `participants[${index}].puuid`), + riotIdGameName: optionalString( + value.riotIdGameName, + `participants[${index}].riotIdGameName`, + ), + riotIdTagLine: optionalString( + value.riotIdTagLine, + `participants[${index}].riotIdTagLine`, + ), + summoner1Id: requireNumber( + value.summoner1Id, + `participants[${index}].summoner1Id`, + ), + summoner2Id: requireNumber( + value.summoner2Id, + `participants[${index}].summoner2Id`, + ), + summonerId: requireString( + value.summonerId, + `participants[${index}].summonerId`, + ), + summonerLevel: requireNumber( + value.summonerLevel, + `participants[${index}].summonerLevel`, + ), + summonerName: requireStringAllowEmpty( + value.summonerName, + `participants[${index}].summonerName`, + ), + teamId: requireNumber(value.teamId, `participants[${index}].teamId`), + teamPosition: requireStringAllowEmpty( + value.teamPosition, + `participants[${index}].teamPosition`, + ), + timePlayed: requireNumber( + value.timePlayed, + `participants[${index}].timePlayed`, + ), + totalDamageDealtToChampions: requireNumber( + value.totalDamageDealtToChampions, + `participants[${index}].totalDamageDealtToChampions`, + ), + totalDamageTaken: requireNumber( + value.totalDamageTaken, + `participants[${index}].totalDamageTaken`, + ), + totalMinionsKilled: requireNumber( + value.totalMinionsKilled, + `participants[${index}].totalMinionsKilled`, + ), + visionScore: requireNumber( + value.visionScore, + `participants[${index}].visionScore`, + ), + wardsKilled: requireNumber( + value.wardsKilled, + `participants[${index}].wardsKilled`, + ), + wardsPlaced: requireNumber( + value.wardsPlaced, + `participants[${index}].wardsPlaced`, + ), + win: requireBoolean(value.win, `participants[${index}].win`), + }; +} + +function parsePerks(value: unknown, participantIndex: number): RiotMatchPerksDto { + if (!isRecord(value)) { + throw new TypeError( + `participants[${participantIndex}].perks must be an object.`, + ); + } + + const styles = value.styles; + if (!Array.isArray(styles)) { + throw new TypeError( + `participants[${participantIndex}].perks.styles must be an array.`, + ); + } + + return { + statPerks: parseStatPerks(value.statPerks, participantIndex), + styles: styles.map((style, styleIndex) => + parsePerkStyle(style, participantIndex, styleIndex), + ), + }; +} + +function parseStatPerks( + value: unknown, + participantIndex: number, +): RiotMatchStatPerksDto { + if (!isRecord(value)) { + throw new TypeError( + `participants[${participantIndex}].perks.statPerks must be an object.`, + ); + } + + return { + defense: requireNumber( + value.defense, + `participants[${participantIndex}].perks.statPerks.defense`, + ), + flex: requireNumber( + value.flex, + `participants[${participantIndex}].perks.statPerks.flex`, + ), + offense: requireNumber( + value.offense, + `participants[${participantIndex}].perks.statPerks.offense`, + ), + }; +} + +function parsePerkStyle( + value: unknown, + participantIndex: number, + styleIndex: number, +): RiotMatchPerkStyleDto { + if (!isRecord(value)) { + throw new TypeError( + `participants[${participantIndex}].perks.styles[${styleIndex}] must be an object.`, + ); + } + + const selections = value.selections; + if (!Array.isArray(selections)) { + throw new TypeError( + `participants[${participantIndex}].perks.styles[${styleIndex}].selections must be an array.`, + ); + } + + return { + description: requireString( + value.description, + `participants[${participantIndex}].perks.styles[${styleIndex}].description`, + ), + selections: selections.map((selection, selectionIndex) => + parsePerkSelection( + selection, + participantIndex, + styleIndex, + selectionIndex, + ), + ), + style: requireNumber( + value.style, + `participants[${participantIndex}].perks.styles[${styleIndex}].style`, + ), + }; +} + +function parsePerkSelection( + value: unknown, + participantIndex: number, + styleIndex: number, + selectionIndex: number, +): RiotMatchPerkStyleSelectionDto { + if (!isRecord(value)) { + throw new TypeError( + `participants[${participantIndex}].perks.styles[${styleIndex}].selections[${selectionIndex}] must be an object.`, + ); + } + + return { + perk: requireNumber( + value.perk, + `participants[${participantIndex}].perks.styles[${styleIndex}].selections[${selectionIndex}].perk`, + ), + var1: requireNumber( + value.var1, + `participants[${participantIndex}].perks.styles[${styleIndex}].selections[${selectionIndex}].var1`, + ), + var2: requireNumber( + value.var2, + `participants[${participantIndex}].perks.styles[${styleIndex}].selections[${selectionIndex}].var2`, + ), + var3: requireNumber( + value.var3, + `participants[${participantIndex}].perks.styles[${styleIndex}].selections[${selectionIndex}].var3`, + ), + }; +} + +function parseTeam(value: unknown, index: number): RiotMatchTeamDto { + if (!isRecord(value)) { + throw new TypeError(`teams[${index}] must be an object.`); + } + + const bans = value.bans; + if (!Array.isArray(bans)) { + throw new TypeError(`teams[${index}].bans must be an array.`); + } + + return { + ...value, + bans: bans.map((ban, banIndex) => parseBan(ban, index, banIndex)), + objectives: parseObjectives(value.objectives, index), + teamId: requireNumber(value.teamId, `teams[${index}].teamId`), + win: requireBoolean(value.win, `teams[${index}].win`), + }; +} + +function parseBan( + value: unknown, + teamIndex: number, + banIndex: number, +): RiotMatchBanDto { + if (!isRecord(value)) { + throw new TypeError(`teams[${teamIndex}].bans[${banIndex}] must be an object.`); + } + + return { + championId: requireNumber( + value.championId, + `teams[${teamIndex}].bans[${banIndex}].championId`, + ), + pickTurn: requireNumber( + value.pickTurn, + `teams[${teamIndex}].bans[${banIndex}].pickTurn`, + ), + }; +} + +function parseObjectives( + value: unknown, + teamIndex: number, +): RiotMatchObjectivesDto { + if (!isRecord(value)) { + throw new TypeError(`teams[${teamIndex}].objectives must be an object.`); + } + + return { + baron: parseObjective(value.baron, teamIndex, 'baron'), + champion: parseObjective(value.champion, teamIndex, 'champion'), + dragon: parseObjective(value.dragon, teamIndex, 'dragon'), + inhibitor: parseObjective(value.inhibitor, teamIndex, 'inhibitor'), + riftHerald: parseObjective(value.riftHerald, teamIndex, 'riftHerald'), + tower: parseObjective(value.tower, teamIndex, 'tower'), + }; +} + +function parseObjective( + value: unknown, + teamIndex: number, + key: keyof RiotMatchObjectivesDto, +): RiotMatchObjectiveDto { + if (!isRecord(value)) { + throw new TypeError(`teams[${teamIndex}].objectives.${key} must be an object.`); + } + + return { + first: requireBoolean( + value.first, + `teams[${teamIndex}].objectives.${key}.first`, + ), + kills: requireNumber( + value.kills, + `teams[${teamIndex}].objectives.${key}.kills`, + ), + }; +} + +function requireString(value: unknown, path: string): string { + if (!isNonEmptyString(value)) { + throw new TypeError(`${path} must be a non-empty string.`); + } + + return value; +} + +function requireStringAllowEmpty(value: unknown, path: string): string { + if (typeof value !== 'string') { + throw new TypeError(`${path} must be a string.`); + } + + return value; +} + +function optionalString(value: unknown, path: string): string | undefined { + if (value === undefined || value === null) { + return undefined; + } + + if (typeof value !== 'string') { + throw new TypeError(`${path} must be a string when present.`); + } + + return value; +} + +function requireNumber(value: unknown, path: string): number { + if (!isFiniteNumber(value)) { + throw new TypeError(`${path} must be a finite number.`); + } + + return value; +} + +function optionalNumber(value: unknown, path: string): number | undefined { + if (value === undefined || value === null) { + return undefined; + } + + if (!isFiniteNumber(value)) { + throw new TypeError(`${path} must be a finite number when present.`); + } + + return value; +} + +function requireBoolean(value: unknown, path: string): boolean { + if (typeof value !== 'boolean') { + throw new TypeError(`${path} must be a boolean.`); + } + + return value; +} + +function assertOptionalNonNegativeInteger( + value: number | undefined, + fieldName: string, +): void { + if (value === undefined) { + return; + } + + if (!Number.isInteger(value) || value < 0) { + throw new RangeError(`${fieldName} must be a non-negative integer.`); + } +} + +function assertOptionalRange( + value: number | undefined, + fieldName: string, + min: number, + max: number, +): void { + if (value === undefined) { + return; + } + + if (!Number.isInteger(value) || value < min || value > max) { + throw new RangeError( + `${fieldName} must be an integer between ${min} and ${max}.`, + ); + } +} + +function isRecord(value: unknown): value is Record { + return typeof value === 'object' && value !== null; +} + +function isFiniteNumber(value: unknown): value is number { + return typeof value === 'number' && Number.isFinite(value); +} + +function isNonEmptyString(value: unknown): value is string { + return typeof value === 'string' && value.length > 0; +}