From 1022cd00445439f9beb5f1f9a87dd96b2765ca3d 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: Mon, 27 Apr 2026 03:51:00 +0900 Subject: [PATCH] chore: add deployment and maintenance tooling --- Dockerfile | 50 + apps/api/docker-entrypoint.js | 72 ++ apps/api/start.ps1 | 68 ++ apps/project.env | 4 + scripts/add-manual-dakao-riot-user.js | 406 ++++++++ scripts/apply-saved-dakao-riot-users.js | 424 ++++++++ scripts/dakao-user-bootstrap.nodeshell.js | 1063 +++++++++++++++++++++ scripts/deploy-cloudflare-pages.mjs | 109 +++ 8 files changed, 2196 insertions(+) create mode 100644 Dockerfile create mode 100644 apps/api/docker-entrypoint.js create mode 100644 apps/api/start.ps1 create mode 100644 apps/project.env create mode 100644 scripts/add-manual-dakao-riot-user.js create mode 100644 scripts/apply-saved-dakao-riot-users.js create mode 100644 scripts/dakao-user-bootstrap.nodeshell.js create mode 100644 scripts/deploy-cloudflare-pages.mjs diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..cb7fab03 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,50 @@ +# syntax=docker/dockerfile:1.7 + +FROM node:24-bookworm-slim AS pnpm-base + +ENV PNPM_HOME=/pnpm +ENV PATH="${PNPM_HOME}:${PATH}" + +RUN corepack enable + +WORKDIR /app + +FROM pnpm-base AS deps + +COPY package.json pnpm-lock.yaml pnpm-workspace.yaml ./ +COPY apps/api/package.json apps/api/package.json +COPY apps/web/package.json apps/web/package.json + +RUN pnpm install --frozen-lockfile --filter api... --filter lolympus-tournament-support + +FROM deps AS build + +COPY apps/api apps/api + +RUN pnpm --filter api build + +FROM pnpm-base AS prod-deps + +COPY package.json pnpm-lock.yaml pnpm-workspace.yaml ./ +COPY apps/api/package.json apps/api/package.json +COPY apps/web/package.json apps/web/package.json + +RUN pnpm install --prod --frozen-lockfile --filter api... --filter lolympus-tournament-support + +FROM gcr.io/distroless/nodejs24-debian13:nonroot AS runtime + +WORKDIR /app + +ENV NODE_ENV=prod + +COPY --from=prod-deps --chown=nonroot:nonroot /app/package.json ./package.json +COPY --from=prod-deps --chown=nonroot:nonroot /app/node_modules ./node_modules +COPY --from=prod-deps --chown=nonroot:nonroot /app/apps/api/package.json ./apps/api/package.json +COPY --from=prod-deps --chown=nonroot:nonroot /app/apps/api/node_modules ./apps/api/node_modules +COPY --from=build --chown=nonroot:nonroot /app/apps/api/dist ./apps/api/dist +COPY --chown=nonroot:nonroot apps/project.env ./project.env +COPY --chown=nonroot:nonroot apps/api/docker-entrypoint.js ./apps/api/docker-entrypoint.js + +EXPOSE 10712 + +CMD ["apps/api/docker-entrypoint.js"] diff --git a/apps/api/docker-entrypoint.js b/apps/api/docker-entrypoint.js new file mode 100644 index 00000000..267e7b42 --- /dev/null +++ b/apps/api/docker-entrypoint.js @@ -0,0 +1,72 @@ +'use strict'; + +const fs = require('node:fs'); +const path = require('node:path'); + +const MACHINE_ENV_PATHS = [ + process.env.MachineEnvFile, + process.env.MACHINE_ENV_FILE, + '/source/global-env-vars.txt', + process.env.HOME + ? path.join(process.env.HOME, 'source/global-env-vars.txt') + : '', +].filter(Boolean); + +const PROJECT_ENV_PATHS = [ + 'project.env', + '/app/project.env', + 'apps/project.env', +]; + +function stripQuotes(value) { + const trimmed = value.trim(); + if ( + (trimmed.startsWith('"') && trimmed.endsWith('"')) || + (trimmed.startsWith("'") && trimmed.endsWith("'")) + ) { + return trimmed.slice(1, -1); + } + return trimmed; +} + +function loadEnvFile(filePath, options = {}) { + const { override = false } = options; + const content = fs.readFileSync(filePath, 'utf8'); + for (const line of content.split(/\r?\n/u)) { + if (!line.trim() || /^\s*#/u.test(line)) continue; + + const match = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$/u); + if (!match) continue; + + if (!override && process.env[match[1]] !== undefined) continue; + process.env[match[1]] = stripQuotes(match[2]); + } +} + +const machineEnvFile = MACHINE_ENV_PATHS.find((candidate) => + fs.existsSync(candidate), +); +if (machineEnvFile) { + loadEnvFile(machineEnvFile, { override: true }); +} + +for (const projectEnvFile of PROJECT_ENV_PATHS) { + if (fs.existsSync(projectEnvFile)) { + loadEnvFile(projectEnvFile); + } +} + +const missing = [ + 'INFISICAL_CLIENT_ID', + 'INFISICAL_CLIENT_SECRET', + 'INFISICAL_PROJECT_ID', +].filter((key) => !process.env[key]); + +if (missing.length > 0) { + console.error( + `Missing required environment variables: ${missing.join(', ')}`, + ); + process.exit(1); +} + +require('./dist/main.js'); diff --git a/apps/api/start.ps1 b/apps/api/start.ps1 new file mode 100644 index 00000000..20e3329c --- /dev/null +++ b/apps/api/start.ps1 @@ -0,0 +1,68 @@ +param( + [switch]$UsePm2, + [string]$Pm2Name = "lolympus-tournament-support" +) + +if (-not $env:NODE_ENV) { + $env:NODE_ENV = "dev" +} + +$MainScript = Join-Path $PSScriptRoot "dist/main.js" + +if ($isMacOS -or $isLinux) { + $env:MachineEnvFile = "$env:HOME/source/global-env-vars.txt" +} elseif ($isWindows) { + $env:MachineEnvFile = "$env:USERPROFILE/source/global-env-vars.txt" +} + +function Set-EnvFromFile { + param([string]$Path) + + if (-not (Test-Path $Path)) { + throw "File not found: $Path" + } + + foreach ($line in Get-Content $Path) { + if ([string]::IsNullOrWhiteSpace($line)) { continue } + if ($line -match '^\s*#') { continue } + + if ($line -match '^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$') { + $key = $matches[1] + $value = $matches[2].Trim() + + if ( + ($value.StartsWith('"') -and $value.EndsWith('"')) -or + ($value.StartsWith("'") -and $value.EndsWith("'")) + ) { + $value = $value.Substring(1, $value.Length - 2) + } + + [System.Environment]::SetEnvironmentVariable($key, $value) + } + } +} + +if (Test-Path $env:MachineEnvFile) { + Set-EnvFromFile $env:MachineEnvFile +} + +if (-not $env:INFISICAL_CLIENT_ID) { + Write-Error "INFISICAL_CLIENT_ID is not set." + exit 1 +} + +if (-not $env:INFISICAL_CLIENT_SECRET) { + Write-Error "INFISICAL_CLIENT_SECRET is not set." + exit 1 +} + +if (-not $env:INFISICAL_PROJECT_ID) { + Write-Error "INFISICAL_PROJECT_ID is not set." + exit 1 +} + +if ($UsePm2) { + pm2 start $MainScript --name $Pm2Name --update-env +} else { + node $MainScript +} diff --git a/apps/project.env b/apps/project.env new file mode 100644 index 00000000..76b8b5d6 --- /dev/null +++ b/apps/project.env @@ -0,0 +1,4 @@ +INFISICAL_PROJECT_ID=26a80d59-a424-4e33-adfc-2b6e84d6e25f + +SERVICE_NAME=lolympus-tournament-support +VERSION=0.1 \ No newline at end of file diff --git a/scripts/add-manual-dakao-riot-user.js b/scripts/add-manual-dakao-riot-user.js new file mode 100644 index 00000000..df6c916a --- /dev/null +++ b/scripts/add-manual-dakao-riot-user.js @@ -0,0 +1,406 @@ +/** + * Add or update one lolympus user manually from Kakao + Riot identity. + * + * This is for the last few users that need manual handling. + * + * Install: + * npm install mongodb + * + * Dry-run with Riot API enrichment: + * MONGODB_URI="mongodb://..." \ + * RIOT_API_KEY="RGAPI-..." \ + * KAKAO_TALK_ID="7448687768283723562" \ + * KAKAO_TALK_NICKNAME="탑은죄악이다/95/남/G" \ + * RIOT_ID="탑은죄악이다#망나니" \ + * PREFERRED_POSITIONS="TOP,JGL" \ + * node add-manual-dakao-riot-user.js + * + * Write: + * DRY_RUN=false MONGODB_URI="..." RIOT_API_KEY="..." ... node add-manual-dakao-riot-user.js + * + * Fallback without Riot API: + * PUUID="..." RIOT_ID="..." node add-manual-dakao-riot-user.js + */ + +"use strict"; + +const { MongoClient, ObjectId } = require("mongodb"); + +const CONFIG = { + MONGODB_URI: process.env.MONGODB_URI ?? "mongodb://127.0.0.1:27017", + LOLYMPUS_DB_NAME: process.env.LOLYMPUS_DB_NAME ?? "lolympus-test", + COMMUNITY_ID: new ObjectId( + process.env.COMMUNITY_ID ?? "69ebe0adf627c11be2f020a1", + ), + RIOT_API_KEY: process.env.RIOT_API_KEY ?? "", + RIOT_REGION: process.env.RIOT_REGION ?? "asia", + RIOT_PLATFORM: process.env.RIOT_PLATFORM ?? "kr", + MASTERY_COUNT: Number(process.env.MASTERY_COUNT ?? 10), + RECENT_MATCH_COUNT: Number(process.env.RECENT_MATCH_COUNT ?? 20), + FETCH_RECENT_MATCH_IDS: process.env.FETCH_RECENT_MATCH_IDS !== "false", + DRY_RUN: process.env.DRY_RUN !== "false", + FAIL_ON_CONFLICT: process.env.FAIL_ON_CONFLICT !== "false", +}; + +const INPUT = { + kakaoTalkId: process.env.KAKAO_TALK_ID ?? "", + kakaoTalkNickname: process.env.KAKAO_TALK_NICKNAME ?? "", + riotId: process.env.RIOT_ID ?? "", + puuid: process.env.PUUID ?? "", + preferredPositions: process.env.PREFERRED_POSITIONS ?? "", + role: process.env.ROLE ?? "member", + isActivated: process.env.IS_ACTIVATED !== "false", +}; + +function normalizeString(value) { + return typeof value === "string" ? value.trim() : ""; +} + +function splitRiotId(riotId) { + const value = normalizeString(riotId); + const hashIndex = value.lastIndexOf("#"); + if (hashIndex <= 0 || hashIndex === value.length - 1) { + throw new Error(`Invalid RIOT_ID. Expected "gameName#tagLine": ${riotId}`); + } + return { + gameName: value.slice(0, hashIndex).trim(), + tagLine: value.slice(hashIndex + 1).trim(), + }; +} + +function normalizePositions(value) { + const allowed = new Set(["TOP", "JGL", "MID", "ADC", "SUP"]); + return normalizeString(value) + .split(",") + .map((position) => normalizeString(position).toUpperCase()) + .filter((position) => allowed.has(position)) + .map((position, index) => ({ position, priority: index + 1 })); +} + +function removeUndefined(value) { + if (Array.isArray(value)) return value.map(removeUndefined); + if ( + value && + typeof value === "object" && + !(value instanceof Date) && + !(value instanceof ObjectId) + ) { + return Object.fromEntries( + Object.entries(value) + .filter(([, entryValue]) => entryValue !== undefined) + .map(([key, entryValue]) => [key, removeUndefined(entryValue)]), + ); + } + return value; +} + +function sleep(ms) { + return new Promise((resolve) => setTimeout(resolve, ms)); +} + +function maskConfig() { + return { + ...CONFIG, + MONGODB_URI: CONFIG.MONGODB_URI.replace(/\/\/.*@/u, "//***@"), + RIOT_API_KEY: CONFIG.RIOT_API_KEY ? "***" : "", + }; +} + +function requireInput() { + const missing = []; + if (!normalizeString(INPUT.kakaoTalkId)) missing.push("KAKAO_TALK_ID"); + if (!normalizeString(INPUT.kakaoTalkNickname)) { + missing.push("KAKAO_TALK_NICKNAME"); + } + if (!normalizeString(INPUT.riotId)) missing.push("RIOT_ID"); + if (!CONFIG.RIOT_API_KEY && !normalizeString(INPUT.puuid)) { + missing.push("RIOT_API_KEY or PUUID"); + } + if (missing.length > 0) { + throw new Error(`Missing required env: ${missing.join(", ")}`); + } +} + +async function fetchRiotJson({ host, path, query }) { + if (!CONFIG.RIOT_API_KEY) return null; + + const url = new URL(`https://${host}${path}`); + for (const [key, value] of Object.entries(query ?? {})) { + if (value !== undefined && value !== null) { + url.searchParams.set(key, String(value)); + } + } + + for (;;) { + const response = await fetch(url, { + headers: { "X-Riot-Token": CONFIG.RIOT_API_KEY }, + }); + + if (response.status === 429) { + const retryAfterSeconds = Number(response.headers.get("retry-after") ?? 1); + await sleep(Math.max(1, retryAfterSeconds) * 1000); + continue; + } + if (response.status === 404) return null; + if (!response.ok) { + const body = await response.text().catch(() => ""); + throw new Error(`Riot API failed ${response.status} ${url.pathname}: ${body}`); + } + return response.json(); + } +} + +async function fetchAccountByRiotId({ gameName, tagLine }) { + return fetchRiotJson({ + host: `${CONFIG.RIOT_REGION}.api.riotgames.com`, + path: `/riot/account/v1/accounts/by-riot-id/${encodeURIComponent(gameName)}/${encodeURIComponent(tagLine)}`, + }); +} + +async function fetchSummonerByPuuid(puuid) { + return fetchRiotJson({ + host: `${CONFIG.RIOT_PLATFORM}.api.riotgames.com`, + path: `/lol/summoner/v4/summoners/by-puuid/${encodeURIComponent(puuid)}`, + }); +} + +async function fetchLeagueEntriesByPuuid(puuid) { + return fetchRiotJson({ + host: `${CONFIG.RIOT_PLATFORM}.api.riotgames.com`, + path: `/lol/league/v4/entries/by-puuid/${encodeURIComponent(puuid)}`, + }); +} + +async function fetchChampionMasteriesByPuuid(puuid) { + return fetchRiotJson({ + host: `${CONFIG.RIOT_PLATFORM}.api.riotgames.com`, + path: `/lol/champion-mastery/v4/champion-masteries/by-puuid/${encodeURIComponent(puuid)}/top`, + query: { count: CONFIG.MASTERY_COUNT }, + }); +} + +async function fetchRecentMatchIdsByPuuid(puuid) { + if (!CONFIG.FETCH_RECENT_MATCH_IDS) return []; + return fetchRiotJson({ + host: `${CONFIG.RIOT_REGION}.api.riotgames.com`, + path: `/lol/match/v5/matches/by-puuid/${encodeURIComponent(puuid)}/ids`, + query: { start: 0, count: CONFIG.RECENT_MATCH_COUNT }, + }); +} + +async function fetchRiotData({ riotId }) { + const fallback = splitRiotId(riotId); + const account = + (await fetchAccountByRiotId(fallback)) ?? { + ...fallback, + puuid: normalizeString(INPUT.puuid), + }; + if (!account?.puuid) { + throw new Error(`Riot account not found and PUUID was not provided: ${riotId}`); + } + + const [summoner, leagueEntries, championMasteries, matchIds] = + await Promise.all([ + fetchSummonerByPuuid(account.puuid).catch(() => null), + fetchLeagueEntriesByPuuid(account.puuid).catch(() => []), + fetchChampionMasteriesByPuuid(account.puuid).catch(() => []), + fetchRecentMatchIdsByPuuid(account.puuid).catch(() => []), + ]); + + return { + account: { + puuid: account.puuid, + gameName: normalizeString(account.gameName) || fallback.gameName, + tagLine: normalizeString(account.tagLine) || fallback.tagLine, + }, + summoner, + leagueEntries: Array.isArray(leagueEntries) ? leagueEntries : [], + championMasteries: Array.isArray(championMasteries) + ? championMasteries + : [], + matchIds: Array.isArray(matchIds) ? matchIds : [], + }; +} + +function toTierInfo(entry, fetchedAt) { + return { + leagueId: entry.leagueId, + queueType: entry.queueType, + tier: entry.tier, + rank: entry.rank, + puuid: entry.puuid, + leaguePoints: entry.leaguePoints ?? 0, + wins: entry.wins ?? 0, + losses: entry.losses ?? 0, + veteran: entry.veteran, + inactive: entry.inactive, + freshBlood: entry.freshBlood, + hotStreak: entry.hotStreak, + miniSeries: entry.miniSeries, + fetchedAt, + }; +} + +function toTierHistory(entry, recordedAt) { + return { + queueType: entry.queueType, + tier: entry.tier, + rank: entry.rank, + leaguePoints: entry.leaguePoints ?? 0, + wins: entry.wins ?? 0, + losses: entry.losses ?? 0, + recordedAt, + }; +} + +function toChampionMastery(entry) { + return { + puuid: entry.puuid, + championId: entry.championId, + championLevel: entry.championLevel, + championPoints: entry.championPoints, + lastPlayTime: entry.lastPlayTime, + championPointsSinceLastLevel: entry.championPointsSinceLastLevel, + championPointsUntilNextLevel: entry.championPointsUntilNextLevel, + markRequiredForNextLevel: entry.markRequiredForNextLevel, + tokensEarned: entry.tokensEarned, + championSeasonMilestone: entry.championSeasonMilestone, + milestoneGrades: entry.milestoneGrades, + nextSeasonMilestone: entry.nextSeasonMilestone, + }; +} + +function buildRiotAccount(riotData, now) { + return removeUndefined({ + puuid: riotData.account.puuid, + gameName: riotData.account.gameName, + tagLine: riotData.account.tagLine, + profileIconId: riotData.summoner?.profileIconId ?? 0, + revisionDate: riotData.summoner?.revisionDate ?? 0, + summonerLevel: riotData.summoner?.summonerLevel ?? 0, + isPrimary: true, + tiers: riotData.leagueEntries.map((entry) => toTierInfo(entry, now)), + tierHistory: riotData.leagueEntries.map((entry) => toTierHistory(entry, now)), + matchIds: riotData.matchIds, + matchIdsFetchedAt: riotData.matchIds.length > 0 ? now : undefined, + championMasteries: riotData.championMasteries + .slice(0, CONFIG.MASTERY_COUNT) + .map(toChampionMastery), + championMasteriesFetchedAt: + riotData.championMasteries.length > 0 ? now : undefined, + championRecords: {}, + createdAt: now, + updatedAt: now, + }); +} + +function mergeRiotAccount(existingAccounts, nextAccount) { + const merged = (existingAccounts ?? []) + .filter( + (account) => + account.puuid !== nextAccount.puuid && + !( + normalizeString(account.gameName).toLowerCase() === + normalizeString(nextAccount.gameName).toLowerCase() && + normalizeString(account.tagLine).toLowerCase() === + normalizeString(nextAccount.tagLine).toLowerCase() + ), + ) + .map((account) => ({ ...account, isPrimary: false })); + return [nextAccount, ...merged]; +} + +async function buildPlan(User) { + const now = new Date(); + const riotData = await fetchRiotData({ riotId: INPUT.riotId }); + const account = buildRiotAccount(riotData, now); + + const conflict = await User.findOne({ + communityId: CONFIG.COMMUNITY_ID, + kakaoTalkId: { $ne: INPUT.kakaoTalkId }, + "riotAccounts.puuid": account.puuid, + }); + if (conflict && CONFIG.FAIL_ON_CONFLICT) { + throw new Error( + `Riot puuid conflict. existingUserId=${conflict._id.toString()} existingKakaoTalkId=${conflict.kakaoTalkId}`, + ); + } + + const filter = { + communityId: CONFIG.COMMUNITY_ID, + kakaoTalkId: INPUT.kakaoTalkId, + }; + const existing = await User.findOne(filter); + const doc = removeUndefined({ + _id: existing?._id ?? new ObjectId(), + communityId: CONFIG.COMMUNITY_ID, + role: INPUT.role, + kakaoTalkId: INPUT.kakaoTalkId, + kakaoTalkNickname: INPUT.kakaoTalkNickname, + riotAccounts: mergeRiotAccount(existing?.riotAccounts, account), + preferredPositions: normalizePositions(INPUT.preferredPositions), + isActivated: INPUT.isActivated, + createdAt: existing?.createdAt ?? now, + updatedAt: now, + }); + + return { + mode: existing ? "update" : "insert", + filter, + doc, + conflict: conflict + ? { + existingUserId: conflict._id, + existingKakaoTalkId: conflict.kakaoTalkId, + } + : null, + }; +} + +async function applyPlan(User, plan) { + if (CONFIG.DRY_RUN) return { dryRun: true, plan }; + + if (plan.mode === "update") { + const { _id, createdAt, ...setDoc } = plan.doc; + await User.updateOne({ _id: plan.doc._id }, { $set: setDoc }); + return { updated: 1, inserted: 0, userId: plan.doc._id }; + } + + await User.insertOne(plan.doc); + return { updated: 0, inserted: 1, userId: plan.doc._id }; +} + +async function run() { + requireInput(); + const client = new MongoClient(CONFIG.MONGODB_URI); + await client.connect(); + + try { + const db = client.db(CONFIG.LOLYMPUS_DB_NAME); + const User = db.collection("user"); + const plan = await buildPlan(User); + const result = await applyPlan(User, plan); + + return { + config: maskConfig(), + input: { + ...INPUT, + puuid: INPUT.puuid ? "***provided***" : "", + }, + result, + }; + } finally { + await client.close(); + } +} + +if (require.main === module) { + run() + .then((result) => { + console.log(JSON.stringify(result, null, 2)); + }) + .catch((error) => { + console.error(error); + process.exitCode = 1; + }); +} diff --git a/scripts/apply-saved-dakao-riot-users.js b/scripts/apply-saved-dakao-riot-users.js new file mode 100644 index 00000000..a9a4d4c5 --- /dev/null +++ b/scripts/apply-saved-dakao-riot-users.js @@ -0,0 +1,424 @@ +/** + * Apply already-saved Dakao user bootstrap data into lolympus-test.user. + * + * This script does NOT call Riot API. + * + * It reads saved documents from one of: + * 1. lolympus-test.DakaoUserBootstrapRun + * 2. lolympus-test.DakaoUserBootstrapCandidate + * + * It only applies users that already have a valid Riot identity: + * - dryRunUsers[].doc.riotAccounts[0].puuid, or + * - candidate.riotApiResult.puuid, or + * - candidate.matchedRiotAccount.puuid + * + * Install: + * npm install mongodb + * + * Dry-run latest saved run: + * MONGODB_URI="mongodb://..." node apply-saved-dakao-riot-users.js + * + * Dry-run specific saved run: + * MONGODB_URI="mongodb://..." SOURCE=run RUN_ID="..." node apply-saved-dakao-riot-users.js + * + * Dry-run from candidate collection: + * MONGODB_URI="mongodb://..." SOURCE=candidate node apply-saved-dakao-riot-users.js + * + * Write: + * DRY_RUN=false MONGODB_URI="mongodb://..." node apply-saved-dakao-riot-users.js + */ + +"use strict"; + +const { MongoClient, ObjectId } = require("mongodb"); + +const CONFIG = { + MONGODB_URI: process.env.MONGODB_URI ?? "mongodb://127.0.0.1:27017", + LOLYMPUS_DB_NAME: process.env.LOLYMPUS_DB_NAME ?? "lolympus-test", + COMMUNITY_ID: new ObjectId( + process.env.COMMUNITY_ID ?? "69ebe0adf627c11be2f020a1", + ), + RUNS_COLLECTION_NAME: + process.env.RUNS_COLLECTION_NAME ?? "DakaoUserBootstrapRun", + CANDIDATES_COLLECTION_NAME: + process.env.CANDIDATES_COLLECTION_NAME ?? "DakaoUserBootstrapCandidate", + SOURCE: process.env.SOURCE ?? "run", // run | candidate + RUN_ID: process.env.RUN_ID ?? "", + DRY_RUN: process.env.DRY_RUN !== "false", + FORCE_REAPPLY_RUN: process.env.FORCE_REAPPLY_RUN === "true", +}; + +function normalizeString(value) { + return typeof value === "string" ? value.trim() : ""; +} + +function toObjectId(value, fieldName) { + if (value instanceof ObjectId) return value; + if (typeof value === "string" && ObjectId.isValid(value)) { + return new ObjectId(value); + } + throw new Error(`Invalid ObjectId for ${fieldName}: ${value}`); +} + +function removeUndefined(value) { + if (Array.isArray(value)) { + return value.map(removeUndefined); + } + if ( + value && + typeof value === "object" && + !(value instanceof Date) && + !(value instanceof ObjectId) + ) { + return Object.fromEntries( + Object.entries(value) + .filter(([, entryValue]) => entryValue !== undefined) + .map(([key, entryValue]) => [key, removeUndefined(entryValue)]), + ); + } + return value; +} + +function maskConfig() { + return { + ...CONFIG, + MONGODB_URI: CONFIG.MONGODB_URI.replace(/\/\/.*@/u, "//***@"), + }; +} + +function hasValidRiotAccount(account) { + return Boolean( + normalizeString(account?.puuid) && + normalizeString(account?.gameName) && + normalizeString(account?.tagLine), + ); +} + +function ensureRiotAccountShape(account, now) { + return removeUndefined({ + puuid: normalizeString(account.puuid), + gameName: normalizeString(account.gameName), + tagLine: normalizeString(account.tagLine), + profileIconId: account.profileIconId ?? 0, + revisionDate: account.revisionDate ?? 0, + summonerLevel: account.summonerLevel ?? 0, + isPrimary: true, + tiers: Array.isArray(account.tiers) ? account.tiers : [], + tierHistory: Array.isArray(account.tierHistory) ? account.tierHistory : [], + matchIds: Array.isArray(account.matchIds) ? account.matchIds : [], + matchIdsFetchedAt: account.matchIdsFetchedAt, + lastRefreshRequestedAt: account.lastRefreshRequestedAt, + recentStatsSummary: account.recentStatsSummary, + recentStatsFetchedAt: account.recentStatsFetchedAt, + championMasteries: Array.isArray(account.championMasteries) + ? account.championMasteries + : [], + championMasteriesFetchedAt: account.championMasteriesFetchedAt, + championRecords: account.championRecords ?? {}, + championRecordsFetchedAt: account.championRecordsFetchedAt, + createdAt: account.createdAt ?? now, + updatedAt: now, + }); +} + +function mergeRiotAccount(existingAccounts, nextAccount) { + const merged = (existingAccounts ?? []) + .filter( + (account) => + account.puuid !== nextAccount.puuid && + !( + normalizeString(account.gameName).toLowerCase() === + normalizeString(nextAccount.gameName).toLowerCase() && + normalizeString(account.tagLine).toLowerCase() === + normalizeString(nextAccount.tagLine).toLowerCase() + ), + ) + .map((account) => ({ ...account, isPrimary: false })); + + return [nextAccount, ...merged]; +} + +function buildPlanFromDryRunUser(planned, now) { + const doc = planned.doc ?? {}; + const primary = doc.riotAccounts?.[0]; + if (!hasValidRiotAccount(primary)) return null; + + return { + source: "dryRunUsers", + originalMode: planned.mode, + filter: { + communityId: toObjectId( + planned.filter?.communityId ?? doc.communityId ?? CONFIG.COMMUNITY_ID, + "planned.communityId", + ), + kakaoTalkId: normalizeString(planned.filter?.kakaoTalkId ?? doc.kakaoTalkId), + }, + doc: removeUndefined({ + _id: + doc._id && ObjectId.isValid(String(doc._id)) + ? toObjectId(doc._id, "planned.doc._id") + : new ObjectId(), + communityId: toObjectId(doc.communityId ?? CONFIG.COMMUNITY_ID, "doc.communityId"), + role: doc.role ?? "member", + kakaoTalkId: normalizeString(doc.kakaoTalkId), + kakaoTalkNickname: normalizeString(doc.kakaoTalkNickname), + riotAccounts: [ensureRiotAccountShape(primary, now)], + preferredPositions: Array.isArray(doc.preferredPositions) + ? doc.preferredPositions + : [], + isActivated: doc.isActivated ?? true, + createdAt: doc.createdAt ?? now, + updatedAt: now, + }), + }; +} + +function buildPlanFromCandidate(candidate, now) { + const api = candidate.riotApiResult; + const matched = candidate.matchedRiotAccount; + const accountSource = hasValidRiotAccount(api) ? api : matched; + if (!hasValidRiotAccount(accountSource)) return null; + + const account = ensureRiotAccountShape( + { + ...matched, + ...api, + profileIconId: candidate.riotEnrichment?.summoner?.profileIconId ?? 0, + revisionDate: candidate.riotEnrichment?.summoner?.revisionDate ?? 0, + summonerLevel: candidate.riotEnrichment?.summoner?.summonerLevel ?? 0, + tiers: (candidate.riotEnrichment?.leagueEntries ?? []).map((entry) => ({ + leagueId: entry.leagueId, + queueType: entry.queueType, + tier: entry.tier, + rank: entry.rank, + puuid: entry.puuid, + leaguePoints: entry.leaguePoints ?? 0, + wins: entry.wins ?? 0, + losses: entry.losses ?? 0, + veteran: entry.veteran, + inactive: entry.inactive, + freshBlood: entry.freshBlood, + hotStreak: entry.hotStreak, + miniSeries: entry.miniSeries, + fetchedAt: now, + })), + tierHistory: (candidate.riotEnrichment?.leagueEntries ?? []).map( + (entry) => ({ + queueType: entry.queueType, + tier: entry.tier, + rank: entry.rank, + leaguePoints: entry.leaguePoints ?? 0, + wins: entry.wins ?? 0, + losses: entry.losses ?? 0, + recordedAt: now, + }), + ), + matchIds: candidate.riotEnrichment?.matchIds ?? [], + matchIdsFetchedAt: + candidate.riotEnrichment?.matchIds?.length > 0 ? now : undefined, + championMasteries: candidate.riotEnrichment?.championMasteries ?? [], + championMasteriesFetchedAt: + candidate.riotEnrichment?.championMasteries?.length > 0 + ? now + : undefined, + }, + now, + ); + + return { + source: "candidate", + filter: { + communityId: toObjectId(candidate.communityId ?? CONFIG.COMMUNITY_ID, "candidate.communityId"), + kakaoTalkId: normalizeString(candidate.kakaoTalkId), + }, + doc: removeUndefined({ + _id: new ObjectId(), + communityId: toObjectId(candidate.communityId ?? CONFIG.COMMUNITY_ID, "candidate.communityId"), + role: candidate.role ?? "member", + kakaoTalkId: normalizeString(candidate.kakaoTalkId), + kakaoTalkNickname: normalizeString( + candidate.targetKakaoTalkNickname || candidate.kakaoTalkNickname, + ), + riotAccounts: [account], + preferredPositions: Array.isArray(candidate.preferredPositions) + ? candidate.preferredPositions + : [], + isActivated: candidate.isActivated ?? true, + createdAt: now, + updatedAt: now, + }), + }; +} + +function dedupePlans(plans) { + const byKakaoTalkId = new Map(); + for (const plan of plans) { + if (!plan?.filter?.kakaoTalkId) continue; + byKakaoTalkId.set(plan.filter.kakaoTalkId, plan); + } + return [...byKakaoTalkId.values()]; +} + +async function loadLatestRun(Runs) { + if (CONFIG.RUN_ID) { + return Runs.findOne({ _id: toObjectId(CONFIG.RUN_ID, "RUN_ID") }); + } + return Runs.findOne( + { communityId: CONFIG.COMMUNITY_ID }, + { sort: { createdAt: -1 } }, + ); +} + +async function loadPlansFromRun(lolympusDb, now) { + const Runs = lolympusDb.collection(CONFIG.RUNS_COLLECTION_NAME); + const run = await loadLatestRun(Runs); + if (!run) { + throw new Error("No saved DakaoUserBootstrapRun found."); + } + if (run.state === "applied" && !CONFIG.FORCE_REAPPLY_RUN) { + throw new Error( + `Run ${run._id.toString()} is already applied. Set FORCE_REAPPLY_RUN=true to re-apply.`, + ); + } + + const fromDryRunUsers = (run.upsertResult?.dryRunUsers ?? []) + .map((planned) => buildPlanFromDryRunUser(planned, now)) + .filter(Boolean); + const fromCandidates = (run.candidates ?? []) + .map((candidate) => buildPlanFromCandidate(candidate, now)) + .filter(Boolean); + const plans = dedupePlans( + fromDryRunUsers.length > 0 ? fromDryRunUsers : fromCandidates, + ); + + return { sourceRun: run, plans }; +} + +async function loadPlansFromCandidates(lolympusDb, now) { + const Candidate = lolympusDb.collection(CONFIG.CANDIDATES_COLLECTION_NAME); + const candidates = await Candidate.find({ + communityId: CONFIG.COMMUNITY_ID, + }).toArray(); + const plans = dedupePlans( + candidates.map((candidate) => buildPlanFromCandidate(candidate, now)).filter(Boolean), + ); + return { sourceRun: null, plans }; +} + +async function applyPlans(lolympusDb, plans) { + const User = lolympusDb.collection("user"); + const result = { + inserted: 0, + updated: 0, + skippedConflict: [], + errors: [], + dryRunUsers: [], + }; + + for (const plan of plans) { + try { + const primary = plan.doc.riotAccounts?.[0]; + const conflict = await User.findOne({ + communityId: plan.doc.communityId, + kakaoTalkId: { $ne: plan.doc.kakaoTalkId }, + "riotAccounts.puuid": primary.puuid, + }); + if (conflict) { + result.skippedConflict.push({ + kakaoTalkId: plan.doc.kakaoTalkId, + riotId: `${primary.gameName}#${primary.tagLine}`, + puuid: primary.puuid, + existingUserId: conflict._id, + existingKakaoTalkId: conflict.kakaoTalkId, + }); + continue; + } + + const existing = await User.findOne(plan.filter); + const nextDoc = removeUndefined({ + ...plan.doc, + _id: existing?._id ?? plan.doc._id, + createdAt: existing?.createdAt ?? plan.doc.createdAt, + riotAccounts: mergeRiotAccount(existing?.riotAccounts, primary), + }); + + if (CONFIG.DRY_RUN) { + result.dryRunUsers.push({ + mode: existing ? "update" : "insert", + filter: plan.filter, + doc: nextDoc, + }); + continue; + } + + if (existing) { + const { _id, createdAt, ...setDoc } = nextDoc; + await User.updateOne({ _id: existing._id }, { $set: setDoc }); + result.updated += 1; + } else { + await User.insertOne(nextDoc); + result.inserted += 1; + } + } catch (error) { + result.errors.push({ + kakaoTalkId: plan?.doc?.kakaoTalkId, + message: error instanceof Error ? error.message : String(error), + }); + } + } + + return result; +} + +async function markRunApplied(lolympusDb, sourceRun, applyResult) { + if (!sourceRun || CONFIG.DRY_RUN) return; + const Runs = lolympusDb.collection(CONFIG.RUNS_COLLECTION_NAME); + await Runs.updateOne( + { _id: sourceRun._id }, + { + $set: { + state: applyResult.errors.length > 0 ? "apply-partial" : "applied", + appliedAt: new Date(), + updatedAt: new Date(), + applyResult, + }, + }, + ); +} + +async function run() { + const client = new MongoClient(CONFIG.MONGODB_URI); + await client.connect(); + + try { + const lolympusDb = client.db(CONFIG.LOLYMPUS_DB_NAME); + const now = new Date(); + const { sourceRun, plans } = + CONFIG.SOURCE === "candidate" + ? await loadPlansFromCandidates(lolympusDb, now) + : await loadPlansFromRun(lolympusDb, now); + const applyResult = await applyPlans(lolympusDb, plans); + await markRunApplied(lolympusDb, sourceRun, applyResult); + + return { + config: maskConfig(), + source: CONFIG.SOURCE, + sourceRunId: sourceRun?._id ?? null, + planCount: plans.length, + applyResult, + }; + } finally { + await client.close(); + } +} + +if (require.main === module) { + run() + .then((result) => { + console.log(JSON.stringify(result, null, 2)); + }) + .catch((error) => { + console.error(error); + process.exitCode = 1; + }); +} diff --git a/scripts/dakao-user-bootstrap.nodeshell.js b/scripts/dakao-user-bootstrap.nodeshell.js new file mode 100644 index 00000000..41b74942 --- /dev/null +++ b/scripts/dakao-user-bootstrap.nodeshell.js @@ -0,0 +1,1063 @@ +/** + * Standalone Node.js script using the official MongoDB driver. + * + * Install: + * npm install mongodb + * + * Run dry-run: + * MONGODB_URI="mongodb://..." RIOT_API_KEY="RGAPI-..." node dakao-user-bootstrap.nodeshell.js + * + * Run write: + * DRY_RUN=false MONGODB_URI="mongodb://..." RIOT_API_KEY="RGAPI-..." node dakao-user-bootstrap.nodeshell.js + * + * Apply saved dry-run without re-calling Riot API: + * APPLY_RUN_ID="" MONGODB_URI="mongodb://..." node dakao-user-bootstrap.nodeshell.js + * + * Flow: + * dakao.OpenChatMemberProfile + dakao.LOCOEvent + * -> extract Kakao userId/nickname + * -> join nickname base with RiotAccount.gameName + * -> verify/fetch puuid from Riot Account API + * -> fetch summoner / league / mastery / recent match ids from Riot API + * -> upsert lolympus-test.user + */ + +"use strict"; + +const { MongoClient, ObjectId } = require("mongodb"); + +const CONFIG = { + // Do not hardcode credentials/API keys in source. Pass them by env. + MONGODB_URI: process.env.MONGODB_URI ?? "mongodb://127.0.0.1:27017", + RIOT_API_KEY: process.env.RIOT_API_KEY ?? "", + + DAKAO_DB_NAME: "dakao", + LOLYMPUS_DB_NAME: "lolympus-test", + RIOT_ACCOUNT_DB_NAME: process.env.RIOT_ACCOUNT_DB_NAME ?? "dakao", + RIOT_ACCOUNT_COLLECTION_NAME: + process.env.RIOT_ACCOUNT_COLLECTION_NAME ?? "RiotAccount", + RUNS_COLLECTION_NAME: + process.env.RUNS_COLLECTION_NAME ?? "DakaoUserBootstrapRun", + + DAKAO_PROJECT_ID: new ObjectId("69985467365c75936c355318"), + CHATROOM_ID: "18449690440646330", + COMMUNITY_ID: new ObjectId("69ebe0adf627c11be2f020a1"), + + RECENT_DAYS: Number(process.env.RECENT_DAYS ?? 31), + RIOT_REGION: process.env.RIOT_REGION ?? "asia", + RIOT_PLATFORM: process.env.RIOT_PLATFORM ?? "kr", + MASTERY_COUNT: Number(process.env.MASTERY_COUNT ?? 10), + RECENT_MATCH_COUNT: Number(process.env.RECENT_MATCH_COUNT ?? 20), + FETCH_RECENT_MATCH_IDS: process.env.FETCH_RECENT_MATCH_IDS !== "false", + + // Safe default. Set DRY_RUN=false to write into lolympus-test.user. + DRY_RUN: process.env.DRY_RUN !== "false", + SAVE_DRY_RUN_RESULT: process.env.SAVE_DRY_RUN_RESULT !== "false", + OUTPUT_ONLY_RIOT_MATCHED: process.env.OUTPUT_ONLY_RIOT_MATCHED !== "false", + APPLY_RUN_ID: process.env.APPLY_RUN_ID ?? "", + FORCE_APPLY_SAVED_RUN: process.env.FORCE_APPLY_SAVED_RUN === "true", + RUN_LABEL: process.env.RUN_LABEL ?? "", + WRITE_CANDIDATES_COLLECTION: + process.env.WRITE_CANDIDATES_COLLECTION !== "false", + + // Optional comma-separated Kakao user ids to ignore. + EXCLUDE_KAKAO_IDS: (process.env.EXCLUDE_KAKAO_IDS ?? "") + .split(",") + .map((value) => value.trim()) + .filter(Boolean), + + // Small delay between Riot API requests. 0 is usually okay, but this keeps + // one-off migration scripts polite. + RIOT_REQUEST_DELAY_MS: Number(process.env.RIOT_REQUEST_DELAY_MS ?? 250), +}; + +/** + * Optional corrections for weird Kakao nicknames or Riot IDs. + * + * Key: Kakao userId / LOCOEvent senderId + * + * Use this only when nickname -> RiotAccount.gameName matching is impossible + * or ambiguous. + */ +const MANUAL_OVERRIDES = { + /* + "5004764920338338307": { + riotId: "도구왕#KR1", + nickname: "도구왕/86/남/E", + preferredPositions: ["SUP"], + role: "member", + isActivated: true + }, + */ +}; + +function normalizeString(value) { + return typeof value === "string" ? value.trim() : ""; +} + +function normalizeJoinKey(value) { + return normalizeString(value).toLocaleLowerCase("ko-KR"); +} + +function normalizeCompactJoinKey(value) { + return normalizeJoinKey(value).replace(/\s+/gu, ""); +} + +function extractNicknameBase(nickname) { + const value = normalizeString(nickname); + if (!value) return ""; + return normalizeString(value.split("/")[0]); +} + +function splitRiotId(riotId) { + const value = normalizeString(riotId); + const hashIndex = value.lastIndexOf("#"); + if (hashIndex <= 0 || hashIndex === value.length - 1) { + throw new Error(`Invalid riotId: ${riotId}`); + } + return { + gameName: value.slice(0, hashIndex).trim(), + tagLine: value.slice(hashIndex + 1).trim(), + }; +} + +function normalizePositions(values) { + const allowed = new Set(["TOP", "JGL", "MID", "ADC", "SUP"]); + return (values ?? []) + .map((position) => normalizeString(position).toUpperCase()) + .filter((position) => allowed.has(position)) + .map((position, index) => ({ position, priority: index + 1 })); +} + +function sleep(ms) { + return new Promise((resolve) => setTimeout(resolve, ms)); +} + +function removeUndefined(value) { + if (Array.isArray(value)) { + return value.map(removeUndefined); + } + if ( + value && + typeof value === "object" && + !(value instanceof Date) && + !(value instanceof ObjectId) + ) { + return Object.fromEntries( + Object.entries(value) + .filter(([, entryValue]) => entryValue !== undefined) + .map(([key, entryValue]) => [key, removeUndefined(entryValue)]), + ); + } + return value; +} + +function maskConfigForStorage() { + return { + ...CONFIG, + MONGODB_URI: CONFIG.MONGODB_URI.replace(/\/\/.*@/u, "//***@"), + RIOT_API_KEY: CONFIG.RIOT_API_KEY ? "***" : "", + }; +} + +function isRiotMatchedCandidate(candidate) { + return Boolean( + candidate.matchedRiotAccount && + candidate.ambiguousRiotAccounts?.length === 0 && + candidate.riotApiResult && + !candidate.riotApiError && + !candidate.riotEnrichmentError, + ); +} + +function filterOutputCandidates(candidates) { + if (!CONFIG.OUTPUT_ONLY_RIOT_MATCHED) return candidates; + return candidates.filter(isRiotMatchedCandidate); +} + +function filterOutputUpsertResult(result) { + if (!CONFIG.OUTPUT_ONLY_RIOT_MATCHED) return result; + return { + ...result, + skippedNoRiotMatchCount: result.skippedNoRiotMatch?.length ?? 0, + skippedAmbiguousCount: result.skippedAmbiguous?.length ?? 0, + skippedRiotApiErrorCount: result.skippedRiotApiError?.length ?? 0, + skippedRiotEnrichmentErrorCount: + result.skippedRiotEnrichmentError?.length ?? 0, + skippedRiotApiNotFoundCount: result.skippedRiotApiNotFound?.length ?? 0, + skippedNoRiotMatch: [], + skippedAmbiguous: [], + skippedRiotApiError: [], + skippedRiotEnrichmentError: [], + skippedRiotApiNotFound: [], + }; +} + +function remember(map, kakaoTalkId, patch) { + if (!kakaoTalkId) return; + + const current = map.get(kakaoTalkId) ?? { + kakaoTalkId, + kakaoTalkNickname: "", + nicknameBase: "", + isPresent: false, + sources: [], + firstJoinedAt: null, + lastSeenAt: null, + joinCount: 0, + leaveCount: 0, + profileImageUrl: null, + fullProfileImageUrl: null, + recentMessageCount: 0, + }; + + const nickname = + normalizeString(patch.kakaoTalkNickname) || + normalizeString(current.kakaoTalkNickname); + const sources = new Set([...(current.sources ?? []), ...(patch.sources ?? [])]); + const lastSeenCandidates = [current.lastSeenAt, patch.lastSeenAt] + .filter(Boolean) + .map((value) => new Date(value)); + + map.set(kakaoTalkId, { + ...current, + ...patch, + kakaoTalkId, + kakaoTalkNickname: nickname, + nicknameBase: extractNicknameBase(nickname), + isPresent: Boolean(current.isPresent || patch.isPresent), + sources: [...sources], + lastSeenAt: + lastSeenCandidates.length > 0 + ? new Date(Math.max(...lastSeenCandidates.map((date) => date.getTime()))) + : null, + recentMessageCount: + (current.recentMessageCount ?? 0) + (patch.recentMessageCount ?? 0), + }); +} + +async function collectCandidates({ dakaoDb }) { + const OpenChatMemberProfile = dakaoDb.collection("OpenChatMemberProfile"); + const LOCOEvent = dakaoDb.collection("LOCOEvent"); + const since = new Date(Date.now() - CONFIG.RECENT_DAYS * 24 * 60 * 60 * 1000); + const excluded = CONFIG.EXCLUDE_KAKAO_IDS; + const map = new Map(); + + const presentProfiles = await OpenChatMemberProfile.find({ + chatroomId: CONFIG.CHATROOM_ID, + isPresent: true, + userId: { $nin: excluded }, + }) + .project({ + userId: 1, + nickname: 1, + firstJoinedAt: 1, + lastSeenAt: 1, + joinCount: 1, + leaveCount: 1, + profileImageUrl: 1, + fullProfileImageUrl: 1, + }) + .toArray(); + + for (const profile of presentProfiles) { + remember(map, normalizeString(profile.userId), { + kakaoTalkNickname: profile.nickname, + isPresent: true, + sources: ["present-profile"], + firstJoinedAt: profile.firstJoinedAt ?? null, + lastSeenAt: profile.lastSeenAt ?? null, + joinCount: profile.joinCount ?? 0, + leaveCount: profile.leaveCount ?? 0, + profileImageUrl: profile.profileImageUrl ?? null, + fullProfileImageUrl: profile.fullProfileImageUrl ?? null, + }); + } + + const recentSenders = await LOCOEvent.aggregate([ + { + $match: { + projectId: CONFIG.DAKAO_PROJECT_ID, + chatroomId: CONFIG.CHATROOM_ID, + eventType: "message.received", + direction: "inbound", + timestamp: { $gte: since }, + senderId: { $nin: excluded }, + }, + }, + { $sort: { timestamp: -1 } }, + { + $group: { + _id: "$senderId", + lastSeenAt: { $first: "$timestamp" }, + kakaoTalkNickname: { $first: "$data.body.authorNickname" }, + recentMessageCount: { $sum: 1 }, + }, + }, + ]).toArray(); + + for (const sender of recentSenders) { + remember(map, normalizeString(sender._id), { + kakaoTalkNickname: sender.kakaoTalkNickname, + sources: ["recent-loco-message"], + lastSeenAt: sender.lastSeenAt ?? null, + recentMessageCount: sender.recentMessageCount ?? 0, + }); + } + + return [...map.values()].sort((left, right) => + normalizeString(left.kakaoTalkNickname).localeCompare( + normalizeString(right.kakaoTalkNickname), + ), + ); +} + +async function loadRiotAccountIndex({ riotAccountDb }) { + const RiotAccount = riotAccountDb.collection( + CONFIG.RIOT_ACCOUNT_COLLECTION_NAME, + ); + const accounts = await RiotAccount.find({}) + .project({ + puuid: 1, + gameName: 1, + tagLine: 1, + region: 1, + updatedAt: 1, + createdAt: 1, + }) + .toArray(); + + const exact = new Map(); + const compact = new Map(); + + for (const account of accounts) { + const exactKey = normalizeJoinKey(account.gameName); + const compactKey = normalizeCompactJoinKey(account.gameName); + if (!exact.has(exactKey)) exact.set(exactKey, []); + if (!compact.has(compactKey)) compact.set(compactKey, []); + exact.get(exactKey).push(account); + compact.get(compactKey).push(account); + } + + return { accounts, exact, compact }; +} + +function pickRiotAccountForCandidate(candidate, index) { + const override = MANUAL_OVERRIDES[candidate.kakaoTalkId]; + if (override?.riotId) { + const { gameName, tagLine } = splitRiotId(override.riotId); + return { + source: "manual-override", + account: { + gameName, + tagLine, + puuid: override.puuid, + region: CONFIG.RIOT_REGION, + }, + override, + ambiguous: [], + }; + } + + const nicknameBase = candidate.nicknameBase; + if (!nicknameBase) { + return { source: "no-nickname-base", account: null, override, ambiguous: [] }; + } + + const exactMatches = index.exact.get(normalizeJoinKey(nicknameBase)) ?? []; + if (exactMatches.length === 1) { + return { + source: "riot-account-exact-gameName", + account: exactMatches[0], + override, + ambiguous: [], + }; + } + if (exactMatches.length > 1) { + return { + source: "ambiguous-exact-gameName", + account: null, + override, + ambiguous: exactMatches, + }; + } + + const compactMatches = + index.compact.get(normalizeCompactJoinKey(nicknameBase)) ?? []; + if (compactMatches.length === 1) { + return { + source: "riot-account-compact-gameName", + account: compactMatches[0], + override, + ambiguous: [], + }; + } + if (compactMatches.length > 1) { + return { + source: "ambiguous-compact-gameName", + account: null, + override, + ambiguous: compactMatches, + }; + } + + return { source: "not-matched", account: null, override, ambiguous: [] }; +} + +async function fetchRiotJson({ host, path, query }) { + if (!CONFIG.RIOT_API_KEY) { + throw new Error("Set RIOT_API_KEY env before calling Riot API."); + } + + const url = new URL(`https://${host}${path}`); + for (const [key, value] of Object.entries(query ?? {})) { + if (value !== undefined && value !== null) { + url.searchParams.set(key, String(value)); + } + } + + for (;;) { + const response = await fetch(url, { + headers: { "X-Riot-Token": CONFIG.RIOT_API_KEY }, + }); + + if (response.status === 429) { + const retryAfterSeconds = Number(response.headers.get("retry-after") ?? 1); + await sleep(Math.max(1, retryAfterSeconds) * 1000); + continue; + } + + if (response.status === 404) return null; + + if (!response.ok) { + const body = await response.text().catch(() => ""); + throw new Error(`Riot API failed ${response.status} ${url.pathname}: ${body}`); + } + + return response.json(); + } +} + +async function fetchRiotAccountByRiotId({ gameName, tagLine }) { + const encodedGameName = encodeURIComponent(gameName); + const encodedTagLine = encodeURIComponent(tagLine); + return fetchRiotJson({ + host: `${CONFIG.RIOT_REGION}.api.riotgames.com`, + path: `/riot/account/v1/accounts/by-riot-id/${encodedGameName}/${encodedTagLine}`, + }); +} + +async function fetchSummonerByPuuid(puuid) { + return fetchRiotJson({ + host: `${CONFIG.RIOT_PLATFORM}.api.riotgames.com`, + path: `/lol/summoner/v4/summoners/by-puuid/${encodeURIComponent(puuid)}`, + }); +} + +async function fetchLeagueEntriesByPuuid(puuid) { + return fetchRiotJson({ + host: `${CONFIG.RIOT_PLATFORM}.api.riotgames.com`, + path: `/lol/league/v4/entries/by-puuid/${encodeURIComponent(puuid)}`, + }); +} + +async function fetchChampionMasteriesByPuuid(puuid) { + return fetchRiotJson({ + host: `${CONFIG.RIOT_PLATFORM}.api.riotgames.com`, + path: `/lol/champion-mastery/v4/champion-masteries/by-puuid/${encodeURIComponent(puuid)}/top`, + query: { count: CONFIG.MASTERY_COUNT }, + }); +} + +async function fetchRecentMatchIdsByPuuid(puuid) { + if (!CONFIG.FETCH_RECENT_MATCH_IDS) return []; + return fetchRiotJson({ + host: `${CONFIG.RIOT_REGION}.api.riotgames.com`, + path: `/lol/match/v5/matches/by-puuid/${encodeURIComponent(puuid)}/ids`, + query: { start: 0, count: CONFIG.RECENT_MATCH_COUNT }, + }); +} + +async function fetchRiotEnrichment(puuid) { + const errors = {}; + + const summoner = await fetchSummonerByPuuid(puuid); + if (!summoner) { + throw new Error(`Summoner not found by puuid: ${puuid}`); + } + + const [leagueEntries, championMasteries, matchIds] = await Promise.all([ + fetchLeagueEntriesByPuuid(puuid).catch((error) => { + errors.league = error instanceof Error ? error.message : String(error); + return []; + }), + fetchChampionMasteriesByPuuid(puuid).catch((error) => { + errors.masteries = error instanceof Error ? error.message : String(error); + return []; + }), + fetchRecentMatchIdsByPuuid(puuid).catch((error) => { + errors.matchIds = error instanceof Error ? error.message : String(error); + return []; + }), + ]); + + return { + summoner, + leagueEntries: Array.isArray(leagueEntries) ? leagueEntries : [], + championMasteries: Array.isArray(championMasteries) + ? championMasteries + : [], + matchIds: Array.isArray(matchIds) ? matchIds : [], + errors, + }; +} + +function toTierInfo(entry, fetchedAt) { + return { + leagueId: entry.leagueId, + queueType: entry.queueType, + tier: entry.tier, + rank: entry.rank, + puuid: entry.puuid, + leaguePoints: entry.leaguePoints ?? 0, + wins: entry.wins ?? 0, + losses: entry.losses ?? 0, + veteran: entry.veteran, + inactive: entry.inactive, + freshBlood: entry.freshBlood, + hotStreak: entry.hotStreak, + miniSeries: entry.miniSeries, + fetchedAt, + }; +} + +function toTierHistory(entry, recordedAt) { + return { + queueType: entry.queueType, + tier: entry.tier, + rank: entry.rank, + leaguePoints: entry.leaguePoints ?? 0, + wins: entry.wins ?? 0, + losses: entry.losses ?? 0, + recordedAt, + }; +} + +function toChampionMastery(entry) { + return { + puuid: entry.puuid, + championId: entry.championId, + championLevel: entry.championLevel, + championPoints: entry.championPoints, + lastPlayTime: entry.lastPlayTime, + championPointsSinceLastLevel: entry.championPointsSinceLastLevel, + championPointsUntilNextLevel: entry.championPointsUntilNextLevel, + markRequiredForNextLevel: entry.markRequiredForNextLevel, + tokensEarned: entry.tokensEarned, + championSeasonMilestone: entry.championSeasonMilestone, + milestoneGrades: entry.milestoneGrades, + nextSeasonMilestone: entry.nextSeasonMilestone, + }; +} + +function buildUserRiotAccount({ + riotAccountApiResult, + riotEnrichment, + fallbackAccount, + now, +}) { + const gameName = + normalizeString(riotAccountApiResult?.gameName) || + normalizeString(fallbackAccount.gameName); + const tagLine = + normalizeString(riotAccountApiResult?.tagLine) || + normalizeString(fallbackAccount.tagLine); + const puuid = + normalizeString(riotAccountApiResult?.puuid) || + normalizeString(fallbackAccount.puuid); + + if (!puuid || !gameName || !tagLine) return null; + const summoner = riotEnrichment?.summoner ?? {}; + const leagueEntries = riotEnrichment?.leagueEntries ?? []; + const championMasteries = riotEnrichment?.championMasteries ?? []; + const matchIds = riotEnrichment?.matchIds ?? []; + + return { + puuid, + gameName, + tagLine, + profileIconId: summoner.profileIconId ?? 0, + revisionDate: summoner.revisionDate ?? 0, + summonerLevel: summoner.summonerLevel ?? 0, + isPrimary: true, + tiers: leagueEntries.map((entry) => toTierInfo(entry, now)), + tierHistory: leagueEntries.map((entry) => toTierHistory(entry, now)), + matchIds, + matchIdsFetchedAt: matchIds.length > 0 ? now : undefined, + championMasteries: championMasteries + .slice(0, CONFIG.MASTERY_COUNT) + .map(toChampionMastery), + championMasteriesFetchedAt: championMasteries.length > 0 ? now : undefined, + championRecords: {}, + createdAt: now, + updatedAt: now, + }; +} + +function mergeRiotAccount(existingAccounts, nextAccount) { + if (!nextAccount) return existingAccounts ?? []; + + const merged = (existingAccounts ?? []) + .filter( + (account) => + account.puuid !== nextAccount.puuid && + !( + normalizeString(account.gameName).toLowerCase() === + normalizeString(nextAccount.gameName).toLowerCase() && + normalizeString(account.tagLine).toLowerCase() === + normalizeString(nextAccount.tagLine).toLowerCase() + ), + ) + .map((account) => ({ ...account, isPrimary: false })); + + return [nextAccount, ...merged]; +} + +async function enrichCandidatesWithRiot({ candidates, riotAccountIndex }) { + const enriched = []; + + for (const candidate of candidates) { + const match = pickRiotAccountForCandidate(candidate, riotAccountIndex); + const fallbackAccount = match.account; + let riotApiResult = null; + let riotApiError = null; + let riotEnrichment = null; + let riotEnrichmentError = null; + + if (fallbackAccount?.gameName && fallbackAccount?.tagLine) { + try { + riotApiResult = await fetchRiotAccountByRiotId({ + gameName: fallbackAccount.gameName, + tagLine: fallbackAccount.tagLine, + }); + if (CONFIG.RIOT_REQUEST_DELAY_MS > 0) { + await sleep(CONFIG.RIOT_REQUEST_DELAY_MS); + } + } catch (error) { + riotApiError = error instanceof Error ? error.message : String(error); + } + + if (riotApiResult?.puuid) { + try { + riotEnrichment = await fetchRiotEnrichment(riotApiResult.puuid); + if (CONFIG.RIOT_REQUEST_DELAY_MS > 0) { + await sleep(CONFIG.RIOT_REQUEST_DELAY_MS); + } + } catch (error) { + riotEnrichmentError = + error instanceof Error ? error.message : String(error); + } + } + } + + enriched.push({ + ...candidate, + manualOverride: match.override ?? null, + riotMatchSource: match.source, + matchedRiotAccount: fallbackAccount ?? null, + ambiguousRiotAccounts: match.ambiguous ?? [], + riotApiResult, + riotApiError, + riotEnrichment, + riotEnrichmentError, + preferredPositions: normalizePositions(match.override?.preferredPositions), + role: match.override?.role ?? "member", + isActivated: match.override?.isActivated ?? true, + targetKakaoTalkNickname: + normalizeString(match.override?.nickname) || candidate.kakaoTalkNickname, + }); + } + + return enriched; +} + +async function writeCandidates({ lolympusDb, candidates }) { + if (!CONFIG.WRITE_CANDIDATES_COLLECTION) return; + + const Candidate = lolympusDb.collection("DakaoUserBootstrapCandidate"); + const now = new Date(); + const outputCandidates = filterOutputCandidates(candidates); + const operations = outputCandidates.map((candidate) => ({ + updateOne: { + filter: { + communityId: CONFIG.COMMUNITY_ID, + kakaoTalkId: candidate.kakaoTalkId, + }, + update: { + $set: { + ...candidate, + communityId: CONFIG.COMMUNITY_ID, + updatedAt: now, + }, + $setOnInsert: { createdAt: now }, + }, + upsert: true, + }, + })); + + if (operations.length > 0) { + await Candidate.bulkWrite(operations, { ordered: false }); + } +} + +async function findRiotPuuidConflict({ User, candidate, account }) { + if (!account?.puuid) return null; + return User.findOne({ + communityId: CONFIG.COMMUNITY_ID, + kakaoTalkId: { $ne: candidate.kakaoTalkId }, + "riotAccounts.puuid": account.puuid, + }); +} + +async function upsertUsers({ lolympusDb, candidates }) { + const User = lolympusDb.collection("user"); + const now = new Date(); + const result = { + inserted: 0, + updated: 0, + skippedNoRiotMatch: [], + skippedAmbiguous: [], + skippedRiotApiError: [], + skippedRiotEnrichmentError: [], + skippedRiotApiNotFound: [], + conflicts: [], + dryRunUsers: [], + }; + + for (const candidate of candidates) { + if (candidate.ambiguousRiotAccounts?.length > 0) { + result.skippedAmbiguous.push(candidate); + continue; + } + if (!candidate.matchedRiotAccount) { + result.skippedNoRiotMatch.push(candidate); + continue; + } + if (candidate.riotApiError) { + result.skippedRiotApiError.push(candidate); + continue; + } + if (candidate.riotEnrichmentError) { + result.skippedRiotEnrichmentError.push(candidate); + continue; + } + if (!candidate.riotApiResult) { + result.skippedRiotApiNotFound.push(candidate); + continue; + } + + const account = buildUserRiotAccount({ + riotAccountApiResult: candidate.riotApiResult, + riotEnrichment: candidate.riotEnrichment, + fallbackAccount: candidate.matchedRiotAccount, + now, + }); + if (!account) { + result.skippedRiotApiNotFound.push(candidate); + continue; + } + + const conflict = await findRiotPuuidConflict({ + User, + candidate, + account, + }); + if (conflict) { + result.conflicts.push({ + kakaoTalkId: candidate.kakaoTalkId, + kakaoTalkNickname: candidate.kakaoTalkNickname, + riotId: `${account.gameName}#${account.tagLine}`, + puuid: account.puuid, + existingUserId: conflict._id, + existingKakaoTalkId: conflict.kakaoTalkId, + }); + continue; + } + + const existing = await User.findOne({ + communityId: CONFIG.COMMUNITY_ID, + kakaoTalkId: candidate.kakaoTalkId, + }); + + const userDoc = { + communityId: CONFIG.COMMUNITY_ID, + role: candidate.role ?? existing?.role ?? "member", + kakaoTalkId: candidate.kakaoTalkId, + kakaoTalkNickname: candidate.targetKakaoTalkNickname, + riotAccounts: mergeRiotAccount(existing?.riotAccounts, account), + preferredPositions: + candidate.preferredPositions?.length > 0 + ? candidate.preferredPositions + : existing?.preferredPositions ?? [], + isActivated: candidate.isActivated ?? true, + updatedAt: now, + }; + + if (CONFIG.DRY_RUN) { + result.dryRunUsers.push({ + mode: existing ? "update" : "insert", + filter: { + communityId: CONFIG.COMMUNITY_ID, + kakaoTalkId: candidate.kakaoTalkId, + }, + doc: { + ...userDoc, + _id: existing?._id ?? new ObjectId(), + createdAt: existing?.createdAt ?? now, + }, + }); + continue; + } + + if (existing) { + await User.updateOne({ _id: existing._id }, { $set: userDoc }); + result.updated += 1; + } else { + await User.insertOne({ + _id: new ObjectId(), + ...userDoc, + createdAt: now, + }); + result.inserted += 1; + } + } + + return result; +} + +function objectIdFromMaybeString(value, fieldName) { + if (value instanceof ObjectId) return value; + if (typeof value === "string" && ObjectId.isValid(value)) { + return new ObjectId(value); + } + throw new Error(`Invalid ObjectId for ${fieldName}: ${value}`); +} + +function buildSetDocFromPlannedDoc(plannedDoc, existing) { + const { _id, createdAt, ...rest } = plannedDoc; + return removeUndefined({ + ...rest, + // Preserve existing createdAt on update. Insert uses the planned createdAt. + updatedAt: new Date(), + }); +} + +async function applyPlannedUsers({ lolympusDb, dryRunUsers }) { + const User = lolympusDb.collection("user"); + const result = { + inserted: 0, + updated: 0, + skippedConflict: [], + errors: [], + }; + + for (const planned of dryRunUsers) { + try { + const filter = removeUndefined({ + ...planned.filter, + communityId: objectIdFromMaybeString( + planned.filter.communityId, + "planned.filter.communityId", + ), + }); + const plannedDoc = removeUndefined({ + ...planned.doc, + _id: objectIdFromMaybeString(planned.doc._id, "planned.doc._id"), + communityId: objectIdFromMaybeString( + planned.doc.communityId, + "planned.doc.communityId", + ), + }); + const primaryPuuid = plannedDoc.riotAccounts?.[0]?.puuid; + + if (primaryPuuid) { + const conflict = await User.findOne({ + communityId: plannedDoc.communityId, + kakaoTalkId: { $ne: plannedDoc.kakaoTalkId }, + "riotAccounts.puuid": primaryPuuid, + }); + if (conflict) { + result.skippedConflict.push({ + kakaoTalkId: plannedDoc.kakaoTalkId, + riotId: `${plannedDoc.riotAccounts[0].gameName}#${plannedDoc.riotAccounts[0].tagLine}`, + puuid: primaryPuuid, + existingUserId: conflict._id, + existingKakaoTalkId: conflict.kakaoTalkId, + }); + continue; + } + } + + const existing = await User.findOne(filter); + if (existing) { + await User.updateOne( + { _id: existing._id }, + { $set: buildSetDocFromPlannedDoc(plannedDoc, existing) }, + ); + result.updated += 1; + } else { + await User.insertOne(plannedDoc); + result.inserted += 1; + } + } catch (error) { + result.errors.push({ + planned, + message: error instanceof Error ? error.message : String(error), + }); + } + } + + return result; +} + +async function saveDryRunResult({ lolympusDb, payload }) { + if (!CONFIG.DRY_RUN || !CONFIG.SAVE_DRY_RUN_RESULT) return null; + + const Runs = lolympusDb.collection(CONFIG.RUNS_COLLECTION_NAME); + const now = new Date(); + const doc = removeUndefined({ + label: CONFIG.RUN_LABEL || null, + state: "planned", + communityId: CONFIG.COMMUNITY_ID, + createdAt: now, + updatedAt: now, + config: maskConfigForStorage(), + summary: { + riotAccountCount: payload.riotAccountCount, + candidateCount: payload.candidateCount, + matchedCandidateCount: payload.matchedCandidateCount, + ambiguousCount: payload.ambiguousCount, + dryRunUserCount: payload.upsertResult?.dryRunUsers?.length ?? 0, + }, + candidates: filterOutputCandidates(payload.candidates), + upsertResult: payload.upsertResult, + }); + + const inserted = await Runs.insertOne(doc); + return inserted.insertedId; +} + +async function applySavedRun({ lolympusDb, runId }) { + const Runs = lolympusDb.collection(CONFIG.RUNS_COLLECTION_NAME); + const _id = objectIdFromMaybeString(runId, "APPLY_RUN_ID"); + const saved = await Runs.findOne({ _id }); + if (!saved) { + throw new Error(`Saved dry-run not found: ${runId}`); + } + if (saved.state === "applied" && !CONFIG.FORCE_APPLY_SAVED_RUN) { + throw new Error( + `Saved dry-run ${runId} is already applied. Set FORCE_APPLY_SAVED_RUN=true to re-apply.`, + ); + } + + const dryRunUsers = saved.upsertResult?.dryRunUsers ?? []; + if (!Array.isArray(dryRunUsers) || dryRunUsers.length === 0) { + throw new Error(`Saved dry-run ${runId} has no dryRunUsers to apply.`); + } + + const applyResult = await applyPlannedUsers({ lolympusDb, dryRunUsers }); + await Runs.updateOne( + { _id }, + { + $set: { + state: applyResult.errors.length > 0 ? "apply-partial" : "applied", + appliedAt: new Date(), + updatedAt: new Date(), + applyResult, + }, + }, + ); + + return { + appliedRunId: _id, + savedSummary: saved.summary, + applyResult, + }; +} + +async function run() { + const client = new MongoClient(CONFIG.MONGODB_URI); + await client.connect(); + + try { + const lolympusDb = client.db(CONFIG.LOLYMPUS_DB_NAME); + if (CONFIG.APPLY_RUN_ID) { + return applySavedRun({ + lolympusDb, + runId: CONFIG.APPLY_RUN_ID, + }); + } + + if (!CONFIG.RIOT_API_KEY) { + throw new Error("Set RIOT_API_KEY env before running this script."); + } + + const dakaoDb = client.db(CONFIG.DAKAO_DB_NAME); + const riotAccountDb = client.db(CONFIG.RIOT_ACCOUNT_DB_NAME); + + const candidates = await collectCandidates({ dakaoDb }); + const riotAccountIndex = await loadRiotAccountIndex({ riotAccountDb }); + const enrichedCandidates = await enrichCandidatesWithRiot({ + candidates, + riotAccountIndex, + }); + + await writeCandidates({ + lolympusDb, + candidates: enrichedCandidates, + }); + + const upsertResult = await upsertUsers({ + lolympusDb, + candidates: enrichedCandidates, + }); + + const outputCandidates = filterOutputCandidates(enrichedCandidates); + const outputUpsertResult = filterOutputUpsertResult(upsertResult); + const payload = { + config: maskConfigForStorage(), + riotAccountCount: riotAccountIndex.accounts.length, + candidateCount: candidates.length, + matchedCandidateCount: enrichedCandidates.filter( + (candidate) => candidate.matchedRiotAccount && candidate.riotApiResult, + ).length, + ambiguousCount: enrichedCandidates.filter( + (candidate) => candidate.ambiguousRiotAccounts?.length > 0, + ).length, + outputCandidateCount: outputCandidates.length, + candidates: outputCandidates, + upsertResult: outputUpsertResult, + }; + + const savedRunId = await saveDryRunResult({ lolympusDb, payload }); + return { + ...payload, + savedRunId, + }; + } finally { + await client.close(); + } +} + +if (require.main === module) { + run() + .then((result) => { + console.log(JSON.stringify(result, null, 2)); + }) + .catch((error) => { + console.error(error); + process.exitCode = 1; + }); +} + +module.exports = { run, CONFIG, MANUAL_OVERRIDES }; diff --git a/scripts/deploy-cloudflare-pages.mjs b/scripts/deploy-cloudflare-pages.mjs new file mode 100644 index 00000000..4a19309a --- /dev/null +++ b/scripts/deploy-cloudflare-pages.mjs @@ -0,0 +1,109 @@ +import { spawnSync } from 'node:child_process'; +import { existsSync, readFileSync } from 'node:fs'; +import { dirname, resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; + +const __dirname = dirname(fileURLToPath(import.meta.url)); +const repoRoot = resolve(__dirname, '..'); +const webDir = resolve(repoRoot, 'apps/web'); + +const target = process.argv[2]; +if (target !== 'test' && target !== 'prod') { + console.error('Usage: node scripts/deploy-cloudflare-pages.mjs '); + process.exit(1); +} + +const viteMode = target === 'prod' ? 'production' : 'test'; +const projectName = + process.env.CF_PAGES_PROJECT_NAME ?? + process.env.CLOUDFLARE_PAGES_PROJECT_NAME ?? + 'lolympus'; +const testBranch = process.env.CF_PAGES_TEST_BRANCH ?? 'test'; + +validateEnv(viteMode); +run('pnpm', ['--filter', 'web', 'run', `build:${target}`], repoRoot); + +const deployArgs = [ + 'exec', + 'wrangler', + 'pages', + 'deploy', + 'dist', + '--project-name', + projectName, +]; + +if (target === 'test') { + deployArgs.push('--branch', testBranch); +} + +run('pnpm', deployArgs, webDir); + +function run(command, args, cwd) { + const result = spawnSync(command, args, { + cwd, + stdio: 'inherit', + shell: process.platform === 'win32', + }); + if (result.status !== 0) { + process.exit(result.status ?? 1); + } +} + +function validateEnv(mode) { + const fileEnv = [ + '.env', + '.env.local', + `.env.${mode}`, + `.env.${mode}.local`, + ].reduce((acc, fileName) => { + const envFile = resolve(webDir, fileName); + if (!existsSync(envFile)) return acc; + return { ...acc, ...parseEnvFile(envFile) }; + }, {}); + const requiredKeys = [ + 'VITE_API_BASE_URL', + 'VITE_DEFAULT_COMMUNITY_ID', + 'VITE_MSAL_CLIENT_ID', + 'VITE_MSAL_AUTHORITY', + 'VITE_MSAL_API_SCOPE', + 'VITE_MSAL_REDIRECT_URI', + ]; + const missing = requiredKeys.filter((key) => { + const value = process.env[key] ?? fileEnv[key]; + return !value || value.includes('<'); + }); + + if (missing.length === 0) return; + + console.error( + [ + `Missing Cloudflare Pages ${mode} build env: ${missing.join(', ')}`, + `Create apps/web/.env.${mode}, apps/web/.env.${mode}.local, or export these variables before deploy.`, + `Use apps/web/.env.${mode}.example as a template.`, + ].join('\n'), + ); + process.exit(1); +} + +function parseEnvFile(path) { + return Object.fromEntries( + readFileSync(path, 'utf8') + .split(/\r?\n/) + .map((line) => line.trim()) + .filter((line) => line && !line.startsWith('#')) + .map((line) => { + const separatorIndex = line.indexOf('='); + if (separatorIndex === -1) return [line, '']; + const key = line.slice(0, separatorIndex).trim(); + let value = line.slice(separatorIndex + 1).trim(); + if ( + (value.startsWith('"') && value.endsWith('"')) || + (value.startsWith("'") && value.endsWith("'")) + ) { + value = value.slice(1, -1); + } + return [key, value]; + }), + ); +}