Files
lolympus-tournament-support/scripts/dakao-user-bootstrap.nodeshell.js
T

1064 lines
31 KiB
JavaScript

/**
* 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="<DakaoUserBootstrapRun _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 };