Allow collecting data from EUNE, NA, KR on top of EUW

- match_collector: query API and build collections for each platform
- match_collector: aggregate champion stats of each platform in one collection with platform annotations
- frontend: replace stats to count matches in platform-specific collections
- frontend: replace "EUW Challengers" with all supported platforms
- dev: adapted scripts to count match in platforms

match_collector/index.ts

@@ -1,4 +1,3 @@
-const base = 'https://euw1.api.riotgames.com'
 const api_key = process.env.RIOT_API_KEY
 const sleep_minutes = 12
 
@@ -7,6 +6,22 @@ import { MongoClient } from 'mongodb'
 import champion_stat from './champion_stat'
 import { Match } from './api'
 
+// Region configuration: platform -> regional routing value
+const PLATFORMS: Record<string, string> = {
+  EUW1: 'EUROPE',
+  EUN1: 'EUROPE',
+  NA1: 'AMERICAS',
+  KR: 'ASIA'
+}
+
+function getPlatformBaseUrl(platform: string): string {
+  return `https://${platform.toLowerCase()}.api.riotgames.com`
+}
+
+function getRegionalBaseUrl(region: string): string {
+  return `https://${region.toLowerCase()}.api.riotgames.com`
+}
+
 main()
 
 async function main() {
@@ -25,42 +40,51 @@ async function main() {
     'Connected to database, latest patch ' + latestPatch + ' was epoch: ' + latestPatchTime
   )
 
-  const alreadySeenGameList = await alreadySeenGames(client, latestPatch)
-  console.log('We already have ' + alreadySeenGameList.length + ' matches for this patch !')
-
   console.log('Using RIOT_API_KEY: ' + api_key)
   if (api_key != null && api_key != undefined && api_key != '') {
-    const challengerLeague = await fetchChallengerLeague()
-    console.log('ChallengerLeague: got ' + challengerLeague.entries.length + ' entries')
+    // Iterate through all platforms
+    for (const [platform, region] of Object.entries(PLATFORMS)) {
+      console.log(`\n=== Processing platform: ${platform} (region: ${region}) ===`)
 
-    const gameList : string[] = []
-    let i = 0
-    for (const challenger of challengerLeague.entries) {
-      console.log('Entry ' + i + '/' + challengerLeague.entries.length + ' ...')
-      const puuid = challenger.puuid
-      const challengerGameList = await summonerGameList(puuid, latestPatchTime)
-      for (const game of challengerGameList) {
-        if (!gameList.includes(game) && !alreadySeenGameList.includes(game)) {
-          gameList.push(game)
+      const alreadySeenGameList = await alreadySeenGames(client, latestPatch, platform)
+      console.log(
+        'We already have ' + alreadySeenGameList.length + ' matches for this patch/platform !'
+      )
+
+      const challengerLeague = await fetchChallengerLeague(platform)
+      console.log('ChallengerLeague: got ' + challengerLeague.entries.length + ' entries')
+
+      const gameList: string[] = []
+      let i = 0
+      for (const challenger of challengerLeague.entries) {
+        console.log('Entry ' + i + '/' + challengerLeague.entries.length + ' ...')
+        const puuid = challenger.puuid
+        const challengerGameList = await summonerGameList(puuid, latestPatchTime, region)
+        for (const game of challengerGameList) {
+          if (!gameList.includes(game) && !alreadySeenGameList.includes(game)) {
+            gameList.push(game)
+          }
         }
+        i++
       }
-      i++
-    }
 
-    console.log('Games: got ' + gameList.length + ' entries')
-    i = 0
-    for (const game of gameList) {
-      console.log('Entry ' + i + '/' + gameList.length + ' ...')
-      const gameMatch = await match(game)
-      const gameTimeline = await matchTimeline(game)
-      gameMatch.timeline = gameTimeline
-      await saveMatch(client, gameMatch, latestPatch)
-      i++
+      console.log('Games: got ' + gameList.length + ' entries for ' + platform)
+      i = 0
+      for (const game of gameList) {
+        console.log('Entry ' + i + '/' + gameList.length + ' ...')
+        // Determine region from matchId (format: REGION_matchId)
+        const matchRegion = game.split('_')[0]
+        const gameMatch = await match(game, matchRegion)
+        const gameTimeline = await matchTimeline(game, matchRegion)
+        gameMatch.timeline = gameTimeline
+        await saveMatch(client, gameMatch, latestPatch, platform)
+        i++
+      }
     }
   }
 
   console.log('Generating stats...')
-  await champion_stat.makeChampionsStats(client, latestPatch)
+  await champion_stat.makeChampionsStats(client, latestPatch, Object.keys(PLATFORMS))
 
   console.log('All done. Closing client.')
   await client.close()
@@ -113,10 +137,11 @@ async function fetchLatestPatchDate(client: MongoClient) {
   return [latestPatch!.patch, Math.floor(latestPatch!.date.valueOf() / 1000)]
 }
 
-async function fetchChallengerLeague() {
+async function fetchChallengerLeague(platform: string) {
   const queue = 'RANKED_SOLO_5x5'
   const endpoint = `/lol/league/v4/challengerleagues/by-queue/${queue}`
-  const url = `${base}${endpoint}?api_key=${api_key}`
+  const baseUrl = getPlatformBaseUrl(platform)
+  const url = `${baseUrl}${endpoint}?api_key=${api_key}`
 
   const challengerLeagueResponse = await handleRateLimit(new URL(url))
 
@@ -126,10 +151,10 @@ async function fetchChallengerLeague() {
   return challengerLeague
 }
 
-async function summonerGameList(puuid: string, startTime: string) {
-  const base = 'https://europe.api.riotgames.com'
+async function summonerGameList(puuid: string, startTime: string, region: string) {
+  const baseUrl = getRegionalBaseUrl(region)
   const endpoint = `/lol/match/v5/matches/by-puuid/${puuid}/ids`
-  const url = `${base}${endpoint}?queue=420&type=ranked&startTime=${startTime}&api_key=${api_key}`
+  const url = `${baseUrl}${endpoint}?queue=420&type=ranked&startTime=${startTime}&api_key=${api_key}`
 
   const gameListResponse = await handleRateLimit(new URL(url))
   handleError(gameListResponse)
@@ -138,10 +163,10 @@ async function summonerGameList(puuid: string, startTime: string) {
   return gameList
 }
 
-async function match(matchId: string) {
-  const base = 'https://europe.api.riotgames.com'
+async function match(matchId: string, region: string) {
+  const baseUrl = getRegionalBaseUrl(region)
   const endpoint = `/lol/match/v5/matches/${matchId}`
-  const url = `${base}${endpoint}?api_key=${api_key}`
+  const url = `${baseUrl}${endpoint}?api_key=${api_key}`
 
   const matchResponse = await handleRateLimit(new URL(url))
   handleError(matchResponse)
@@ -150,10 +175,10 @@ async function match(matchId: string) {
   return match
 }
 
-async function matchTimeline(matchId: string) {
-  const base = 'https://europe.api.riotgames.com'
+async function matchTimeline(matchId: string, region: string) {
+  const baseUrl = getRegionalBaseUrl(region)
   const endpoint = `/lol/match/v5/matches/${matchId}/timeline`
-  const url = `${base}${endpoint}?api_key=${api_key}`
+  const url = `${baseUrl}${endpoint}?api_key=${api_key}`
 
   const timelineResponse = await handleRateLimit(new URL(url))
   handleError(timelineResponse)
@@ -162,17 +187,19 @@ async function matchTimeline(matchId: string) {
   return timeline
 }
 
-async function alreadySeenGames(client: MongoClient, latestPatch: string) {
+async function alreadySeenGames(client: MongoClient, latestPatch: string, platform: string) {
   const database = client.db('matches')
-  const matches = database.collection(latestPatch)
+  const collectionName = `${latestPatch}_${platform}`
+  const matches = database.collection(collectionName)
 
   const alreadySeen = await matches.distinct('metadata.matchId')
   return alreadySeen
 }
 
-async function saveMatch(client: MongoClient, match: Match, latestPatch: string) {
+async function saveMatch(client: MongoClient, match: Match, latestPatch: string, platform: string) {
   const database = client.db('matches')
-  const matches = database.collection(latestPatch)
+  const collectionName = `${latestPatch}_${platform}`
+  const matches = database.collection(collectionName)
   await matches.insertOne(match)
 }
 
@@ -187,10 +214,15 @@ async function runWithPreloadedData() {
     const [latestPatch] = await fetchLatestPatchDate(client)
     console.log(`Latest patch: ${latestPatch}`)
 
-    // Check if we have matches for this patch
+    // Check if we have matches for this patch (including platform-specific collections)
     const matchesDb = client.db('matches')
     const collections = await matchesDb.listCollections().toArray()
-    const patchCollections = collections.map(c => c.name).filter(name => name === latestPatch)
+    const collectionNames = collections.map(c => c.name)
+
+    // Find collections for this patch (both global and platform-specific)
+    const patchCollections = collectionNames.filter(
+      name => name === latestPatch || name.startsWith(`${latestPatch}_`)
+    )
 
     if (patchCollections.length === 0) {
       console.error(`❌ No match data found for patch ${latestPatch}`)
@@ -199,13 +231,21 @@ async function runWithPreloadedData() {
       return
     }
 
-    console.log(`Found ${patchCollections.length} match collection(s)`)
+    console.log(
+      `Found ${patchCollections.length} match collection(s): ${patchCollections.join(', ')}`
+    )
 
-    // Generate stats for each patch with data
-    for (const patch of patchCollections) {
-      console.log(`Generating stats for patch ${patch}...`)
-      await champion_stat.makeChampionsStats(client, patch)
-      console.log(`Stats generated for patch ${patch}`)
+    // Extract platforms from collection names (e.g., "15.1_EUW1" -> "EUW1")
+    const platforms = patchCollections
+      .filter(name => name.startsWith(`${latestPatch}_`))
+      .map(name => name.replace(`${latestPatch}_`, ''))
+
+    // Generate stats for each platform
+    if (platforms.length > 0) {
+      await champion_stat.makeChampionsStats(client, latestPatch, platforms)
+    } else {
+      // Fallback for old-style collections without platform suffix
+      await champion_stat.makeChampionsStats(client, latestPatch)
     }
 
     console.log('🎉 All stats generated successfully!')