/** * 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-staging.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-staging", 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-staging.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 };