buildpath/patch_detector/index.ts

import { MongoClient } from 'mongodb'
import { writeFile, mkdir } from 'fs/promises'
import { existsSync } from 'fs'
import { join } from 'path'

// CDragon base URL for specific patch
const CDRAGON_BASE = 'https://raw.communitydragon.org/'

// Assets to cache for each patch
const CDRAGON_ASSETS = [
  {
    name: 'items.json',
    path: 'plugins/rcp-be-lol-game-data/global/default/v1/items.json'
  },
  {
    name: 'perks.json',
    path: 'plugins/rcp-be-lol-game-data/global/default/v1/perks.json'
  },
  {
    name: 'perkstyles.json',
    path: 'plugins/rcp-be-lol-game-data/global/default/v1/perkstyles.json'
  },
  {
    name: 'summoner-spells.json',
    path: 'plugins/rcp-be-lol-game-data/global/default/v1/summoner-spells.json'
  },
  {
    name: 'champion-summary.json',
    path: 'plugins/rcp-be-lol-game-data/global/default/v1/champion-summary.json'
  }
]

main()

async function main() {
  const client = await connectToDatabase()
  const dbPatch = await getLatestPatchFromDatabase(client)

  // In dev mode, get patch from database (the one we have match data for)
  if (process.env.NODE_ENV === 'development') {
    console.log('Development mode: downloading cache for database patch')
    await client.close()

    if (dbPatch) {
      console.log('Latest patch in database: ' + dbPatch)
      await downloadAssets(dbPatch)
    } else {
      console.log('No patch found in database!')
    }
    return
  }

  // Production mode: check database and update if new patch
  const newPatch = await fetchLatestPatch()
  console.log('Latest patch is: ' + newPatch)
  const newDate = new Date()

  if (!(await compareLatestSavedPatch(client, newPatch, newDate))) {
    await downloadAssets(newPatch)
  }

  await client.close()
}

async function fetchLatestPatch() {
  const url = 'https://ddragon.leagueoflegends.com/api/versions.json'
  const patchDataResponse = await fetch(url)
  const patchData = await patchDataResponse.json()
  const patch: string = patchData[0]
  return patch
}

async function connectToDatabase() {
  // Create a MongoClient with a MongoClientOptions object to set the Stable API version
  let uri = `mongodb://${process.env.MONGO_USER}:${process.env.MONGO_PASS}@${process.env.MONGO_HOST}`
  if (
    process.env.MONGO_URI != undefined &&
    process.env.MONGO_URI != null &&
    process.env.MONGO_URI != ''
  ) {
    uri = process.env.MONGO_URI
  }
  const client = new MongoClient(uri)
  await client.connect()
  return client
}

async function compareLatestSavedPatch(client: MongoClient, newPatch: string, newDate: Date) {
  const database = client.db('patches')
  const patches = database.collection('patches')
  const latestPatch = await patches.find().limit(1).sort({ date: -1 }).next()

  if (latestPatch == null) {
    console.log('No previous patch recorded in database.')
  } else {
    console.log('Latest patch in database is: ' + latestPatch.patch)
  }

  if (latestPatch == null || latestPatch.patch != newPatch) {
    await patches.insertOne({ patch: newPatch, date: newDate })
    return false
  }

  return true
}

async function getLatestPatchFromDatabase(client: MongoClient): Promise<string | null> {
  const database = client.db('patches')
  const patches = database.collection('patches')
  const latestPatch = await patches.find().limit(1).sort({ date: -1 }).next()

  if (latestPatch == null) {
    return null
  }

  return latestPatch.patch
}

async function downloadAssets(patch: string) {
  // Convert patch format for CDragon: "16.4.1" -> "16.4"
  // CDragon uses patch format without the last minor version
  const cdragonPatch = patch.split('.').slice(0, 2).join('.')
  console.log(`Downloading CDragon assets for patch ${cdragonPatch} (from ${patch})...`)

  // Get cache directory from environment or use default
  const cacheDir = process.env.CDRAGON_CACHE_DIR || '/cdragon'
  const patchDir = join(cacheDir, cdragonPatch)

  // Create patch directory if it doesn't exist
  if (!existsSync(patchDir)) {
    await mkdir(patchDir, { recursive: true })
    console.log(`Created directory: ${patchDir}`)
  }

  // Download each asset
  for (const asset of CDRAGON_ASSETS) {
    const url = `${CDRAGON_BASE}${cdragonPatch}/${asset.path}`
    const filePath = join(patchDir, asset.name)

    try {
      console.log(`Downloading ${asset.name}...`)
      const response = await fetch(url)

      if (!response.ok) {
        console.error(`Failed to download ${asset.name}: ${response.status} ${response.statusText}`)
        continue
      }

      const data = await response.json()
      await writeFile(filePath, JSON.stringify(data, null, 2))
      console.log(`Saved ${asset.name} to ${filePath}`)
    } catch (error) {
      console.error(`Error downloading ${asset.name}:`, error)
    }
  }

  // Create a symlink or copy to 'latest' directory for easy access
  const latestDir = join(cacheDir, 'latest')
  const latestFile = join(latestDir, 'patch.txt')

  if (!existsSync(latestDir)) {
    await mkdir(latestDir, { recursive: true })
  }

  await writeFile(latestFile, patch)
  console.log(`Updated latest patch reference to ${patch}`)

  console.log('CDragon assets download complete!')
}