1064 lines
31 KiB
JavaScript
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 };
|