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; }