From 41e7c86b50a4eb6fe294bc5f7a5a3200789282ed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EB=B0=95=EB=8B=A4=ED=98=84=20=28Dahyeon=20Park=29?= Date: Wed, 15 Apr 2026 01:30:18 +0900 Subject: [PATCH] feat(api): implement Riot Match Service feat(api): integrate RiotModule and ConfigModule --- apps/api/src/app.module.ts | 12 +- .../src/modules/riot/riot-match.service.ts | 622 ++++++++++++++++++ 2 files changed, 633 insertions(+), 1 deletion(-) create mode 100644 apps/api/src/modules/riot/riot-match.service.ts diff --git a/apps/api/src/app.module.ts b/apps/api/src/app.module.ts index 86628031..45a79906 100644 --- a/apps/api/src/app.module.ts +++ b/apps/api/src/app.module.ts @@ -1,9 +1,19 @@ import { Module } from '@nestjs/common'; +import { ConfigModule } from '@nestjs/config'; import { AppController } from './app.controller'; import { AppService } from './app.service'; +import { GlobalModule } from './modules/global/global.module'; +import { RiotModule } from './modules/riot/riot.module'; @Module({ - imports: [], + imports: [ + ConfigModule.forRoot({ + isGlobal: true, + envFilePath: ['../project.env', 'project.env'], + }), + GlobalModule, + RiotModule, + ], controllers: [AppController], providers: [AppService], }) 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..c4ba1cca --- /dev/null +++ b/apps/api/src/modules/riot/riot-match.service.ts @@ -0,0 +1,622 @@ +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: requireString( + 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: requireString( + value.summonerName, + `participants[${index}].summonerName`, + ), + teamId: requireNumber(value.teamId, `participants[${index}].teamId`), + teamPosition: requireString( + 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 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; +}