release/86 #2

Merged
dahyeon merged 108 commits from release/86 into main 2026-07-15 08:56:05 +00:00
Showing only changes of commit 1272c81fa9 - Show all commits
@@ -0,0 +1,680 @@
import 'reflect-metadata';
import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { NestFactory } from '@nestjs/core';
import mongoose from 'mongoose';
import { readFile } from 'node:fs/promises';
import { resolve } from 'node:path';
import {
ConnectionService,
resolveMongoDbName,
} from '../connection.service';
import type {
MatchDocument,
MatchGameAssignment,
MatchGameResult,
MatchSeriesResult,
TournamentCodeDocument,
} from '../schema';
import { SecretModule } from '../../secret/secret.module';
import { MatchStatsFragmentBuilder } from '../../../community-stats/match-stats-fragment.builder';
import { MatchStatsRepository } from '../../../community-stats/match-stats.repository';
import { MatchStatsService } from '../../../community-stats/match-stats.service';
interface CliOptions {
dryRun: boolean;
matchId: mongoose.Types.ObjectId;
maxRounds: number;
nodeEnv: string;
}
interface ResultGamePlan {
oldGameNumber: number;
newGameNumber: number;
roundNumber: number;
teamAIndex: number;
teamBIndex: number;
game: MatchGameResult;
}
interface RepairPlan {
schedule: MatchGameAssignment[];
gamePlans: ResultGamePlan[];
seriesResults: MatchSeriesResult[];
winnerTeamIndex?: number;
usedCodeByOldGameNumber: Map<number, TournamentCodeDocument>;
releasedCodes: TournamentCodeDocument[];
}
@Module({
imports: [
ConfigModule.forRoot({
isGlobal: true,
envFilePath: [
resolve(__dirname, '../../../../../../project.env'),
resolve(process.cwd(), '../project.env'),
resolve(process.cwd(), 'apps/project.env'),
resolve(process.cwd(), 'project.env'),
],
}),
SecretModule,
],
providers: [
ConnectionService,
MatchStatsFragmentBuilder,
MatchStatsRepository,
MatchStatsService,
],
})
class RepairModule {}
async function loadMachineEnvFile() {
const homeDir = process.env.HOME ?? process.env.USERPROFILE;
if (!homeDir) return;
const machineEnvFile = resolve(homeDir, 'source/global-env-vars.txt');
try {
const file = await readFile(machineEnvFile, 'utf8');
for (const rawLine of file.split(/\r?\n/)) {
const line = rawLine.trim();
if (!line || line.startsWith('#')) continue;
const matched = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
if (!matched) continue;
const [, key, rawValue] = matched;
process.env[key] = rawValue.replace(/^["']|["']$/g, '');
}
} catch {
// 로컬 machine env 파일이 없으면 그냥 지나간다.
}
}
function parseArgs(argv: string[]): CliOptions {
let dryRun = true;
let matchId: mongoose.Types.ObjectId | undefined;
let maxRounds = 3;
let nodeEnv = process.env.NODE_ENV ?? 'dev';
for (let index = 0; index < argv.length; index += 1) {
const arg = argv[index];
if (arg === '--apply') {
dryRun = false;
continue;
}
if (arg === '--dry-run') {
dryRun = true;
continue;
}
if (arg === '--match-id') {
const value = argv[index + 1];
if (!value || !mongoose.isValidObjectId(value)) {
throw new Error('--match-id requires a valid ObjectId.');
}
matchId = new mongoose.Types.ObjectId(value);
index += 1;
continue;
}
if (arg.startsWith('--match-id=')) {
const value = arg.slice('--match-id='.length);
if (!mongoose.isValidObjectId(value)) {
throw new Error('--match-id requires a valid ObjectId.');
}
matchId = new mongoose.Types.ObjectId(value);
continue;
}
if (arg === '--max-rounds') {
maxRounds = parsePositiveInteger(argv[index + 1], '--max-rounds');
index += 1;
continue;
}
if (arg.startsWith('--max-rounds=')) {
maxRounds = parsePositiveInteger(
arg.slice('--max-rounds='.length),
'--max-rounds',
);
continue;
}
if (arg === '--env') {
const value = argv[index + 1];
if (!value) throw new Error('--env requires dev, staging, or prod.');
nodeEnv = value;
index += 1;
continue;
}
if (arg.startsWith('--env=')) {
nodeEnv = arg.slice('--env='.length);
continue;
}
if (arg === '--help' || arg === '-h') {
printHelp();
process.exit(0);
}
throw new Error(`Unknown argument: ${arg}`);
}
if (!matchId) throw new Error('--match-id is required.');
if (!['dev', 'staging', 'prod'].includes(nodeEnv)) {
throw new Error('--env must be dev, staging, or prod.');
}
return { dryRun, matchId, maxRounds, nodeEnv };
}
function parsePositiveInteger(value: string | undefined, label: string) {
const parsed = Number(value);
if (!Number.isInteger(parsed) || parsed < 1) {
throw new Error(`${label} requires a positive integer.`);
}
return parsed;
}
function printHelp() {
console.log(`Usage:
pnpm --filter api exec ts-node src/modules/global/database/migrations/repair-limited-round-robin-finished-match.ts --match-id <id> --max-rounds 3 --dry-run
pnpm --filter api exec ts-node src/modules/global/database/migrations/repair-limited-round-robin-finished-match.ts --match-id <id> --max-rounds 3 --env prod --apply
Options:
--match-id <id> Match ObjectId to repair.
--max-rounds <n> Number of round-robin rounds to keep. Default: 3.
--dry-run Print the repair plan without writing. Default.
--apply Apply match, tournament code, and stats updates.
--env <env> dev | staging | prod. Default: NODE_ENV or dev.
`);
}
async function main() {
const options = parseArgs(process.argv.slice(2));
process.env.NODE_ENV = options.nodeEnv;
await loadMachineEnvFile();
const app = await NestFactory.createApplicationContext(RepairModule, {
logger: ['log', 'warn', 'error'],
});
try {
const connectionService = app.get(ConnectionService);
const matchStatsService = app.get(MatchStatsService);
const MatchModel = await connectionService.getModel('match');
const TournamentCodeModel =
await connectionService.getModel('tournamentCode');
const match = await MatchModel.findById(options.matchId).exec();
if (!match) {
throw new Error(`Match not found: ${options.matchId.toString()}`);
}
const codes = await TournamentCodeModel.find({
_id: { $in: match.tournamentCodeIds ?? [] },
})
.sort({ gameNumber: 1, reservedAt: 1, _id: 1 })
.exec();
const plan = buildRepairPlan(match, codes, options.maxRounds);
printPlan(options, match, codes, plan);
if (options.dryRun) {
console.log('No writes were made. Re-run with --apply to update MongoDB.');
return;
}
const now = new Date();
const session = await (await connectionService.getConnection()).startSession();
try {
await session.withTransaction(async () => {
await applyTournamentCodeUpdates(plan, now, session);
await MatchModel.updateOne(
{ _id: match._id },
{
$set: {
status: 'finished',
roundRobinMaxRounds: options.maxRounds,
gameSchedule: plan.schedule,
tournamentCodeIds: [
...plan.usedCodeByOldGameNumber.values(),
].map((code) => code._id),
resultPollState: {
startedAt: match.resultPollState?.startedAt ?? now,
lastPolledAt: now,
lastPollOutcome: 'matched',
matchedCount: plan.gamePlans.length,
expandedToAllPuuids: true,
state: 'complete',
},
result: {
winnerTeamIndex: plan.winnerTeamIndex,
mvpUserId: match.result?.mvpUserId,
riotMatchIds: plan.gamePlans.map(
(gamePlan) => gamePlan.game.riotMatchId,
),
games: plan.gamePlans.map((gamePlan) => ({
...toPlainGame(gamePlan.game),
gameNumber: gamePlan.newGameNumber,
})),
seriesResults: plan.seriesResults,
},
},
},
{ session },
).exec();
});
} finally {
await session.endSession();
}
await matchStatsService.buildAndUpsert(match._id);
console.log('Repair applied and match stats rebuilt.');
} finally {
await app.close();
await mongoose.disconnect();
}
}
function buildRepairPlan(
match: MatchDocument,
codes: TournamentCodeDocument[],
maxRounds: number,
): RepairPlan {
if (match.gameMode !== 'round-robin') {
throw new Error(`Expected round-robin match, got ${match.gameMode}.`);
}
const games = [...(match.result?.games ?? [])]
.map(toPlainGame)
.sort((left, right) => left.gameNumber - right.gameNumber);
if (games.length === 0) {
throw new Error('Match has no result games to preserve.');
}
const teamIndexes = [...new Set(match.teams.map((team) => team.teamIndex))]
.filter((teamIndex) => Number.isInteger(teamIndex) && teamIndex > 0)
.sort((left, right) => left - right);
if (teamIndexes.length < 2) {
throw new Error('Match needs at least two teams.');
}
if (teamIndexes.length % 2 !== 0) {
throw new Error('This repair script currently expects an even team count.');
}
const gamesPerRound = teamIndexes.length / 2;
const requiredGames = gamesPerRound * maxRounds;
if (games.length !== requiredGames) {
throw new Error(
`Expected ${requiredGames} result games for ${maxRounds} rounds and ${teamIndexes.length} teams, got ${games.length}.`,
);
}
validateResultGames(games, teamIndexes);
const rounds = partitionIntoRounds(games, teamIndexes, maxRounds);
const gamePlans = rounds.flatMap((roundGames, roundIndex) =>
sortRoundGames(roundGames).map((game, gameIndex) => ({
oldGameNumber: game.gameNumber,
newGameNumber: roundIndex * gamesPerRound + gameIndex + 1,
roundNumber: roundIndex + 1,
teamAIndex: Math.min(game.blueTeamIndex, game.redTeamIndex),
teamBIndex: Math.max(game.blueTeamIndex, game.redTeamIndex),
game,
})),
);
const schedule = gamePlans.map(
({ newGameNumber, roundNumber, teamAIndex, teamBIndex }) => ({
gameNumber: newGameNumber,
roundNumber,
teamAIndex,
teamBIndex,
}),
);
const usedOldGameNumbers = new Set(
gamePlans.map((gamePlan) => gamePlan.oldGameNumber),
);
const usedCodeByOldGameNumber = resolveUsedCodesByOldGameNumber(
codes,
gamePlans,
);
const releasedCodes = codes.filter(
(code) => !usedOldGameNumbers.has(code.gameNumber ?? 0),
);
const unsafeReleased = releasedCodes.filter((code) => code.state === 'used');
if (unsafeReleased.length > 0) {
throw new Error(
`Refusing to release used tournament codes without matching result games: ${unsafeReleased
.map((code) => formatCode(code))
.join(', ')}`,
);
}
const updatedGames = gamePlans.map((gamePlan) => ({
...toPlainGame(gamePlan.game),
gameNumber: gamePlan.newGameNumber,
}));
const seriesResults = buildSeriesResults(updatedGames);
return {
schedule,
gamePlans,
seriesResults,
winnerTeamIndex: resolveMatchWinnerTeamIndex(seriesResults),
usedCodeByOldGameNumber,
releasedCodes,
};
}
function validateResultGames(games: MatchGameResult[], teamIndexes: number[]) {
const validTeamIndexes = new Set(teamIndexes);
const pairKeys = new Set<string>();
const gameNumbers = new Set<number>();
for (const game of games) {
if (gameNumbers.has(game.gameNumber)) {
throw new Error(`Duplicate result gameNumber: ${game.gameNumber}.`);
}
gameNumbers.add(game.gameNumber);
if (!validTeamIndexes.has(game.blueTeamIndex)) {
throw new Error(`Invalid blueTeamIndex ${game.blueTeamIndex}.`);
}
if (!validTeamIndexes.has(game.redTeamIndex)) {
throw new Error(`Invalid redTeamIndex ${game.redTeamIndex}.`);
}
if (game.blueTeamIndex === game.redTeamIndex) {
throw new Error(`Game ${game.gameNumber} has the same team twice.`);
}
const key = pairKey(game);
if (pairKeys.has(key)) {
throw new Error(`Duplicate team pair in results: ${key}.`);
}
pairKeys.add(key);
}
}
function partitionIntoRounds(
games: MatchGameResult[],
teamIndexes: number[],
maxRounds: number,
): MatchGameResult[][] {
const targetPerRound = teamIndexes.length / 2;
const unused = new Set(games.map((game) => game.gameNumber));
const byGameNumber = new Map(games.map((game) => [game.gameNumber, game]));
const rounds: MatchGameResult[][] = [];
function fillRound(roundIndex: number): boolean {
if (roundIndex === maxRounds) return unused.size === 0;
const candidates = enumerateRoundCandidates(
[...unused]
.map((gameNumber) => byGameNumber.get(gameNumber))
.filter((game): game is MatchGameResult => Boolean(game)),
teamIndexes,
targetPerRound,
);
for (const candidate of candidates) {
for (const game of candidate) unused.delete(game.gameNumber);
rounds[roundIndex] = candidate;
if (fillRound(roundIndex + 1)) return true;
for (const game of candidate) unused.add(game.gameNumber);
}
rounds.length = roundIndex;
return false;
}
if (!fillRound(0)) {
throw new Error('Could not partition result games into simultaneous rounds.');
}
return rounds;
}
function enumerateRoundCandidates(
availableGames: MatchGameResult[],
teamIndexes: number[],
targetPerRound: number,
): MatchGameResult[][] {
const candidates: MatchGameResult[][] = [];
function visit(usedTeams: Set<number>, chosen: MatchGameResult[]) {
if (chosen.length === targetPerRound) {
candidates.push([...chosen]);
return;
}
const nextTeam = teamIndexes.find((teamIndex) => !usedTeams.has(teamIndex));
if (!nextTeam) return;
const nextGames = availableGames
.filter((game) => {
if (!includesTeam(game, nextTeam)) return false;
return (
!usedTeams.has(game.blueTeamIndex) &&
!usedTeams.has(game.redTeamIndex)
);
})
.sort((left, right) => left.gameNumber - right.gameNumber);
for (const game of nextGames) {
chosen.push(game);
usedTeams.add(game.blueTeamIndex);
usedTeams.add(game.redTeamIndex);
visit(usedTeams, chosen);
usedTeams.delete(game.blueTeamIndex);
usedTeams.delete(game.redTeamIndex);
chosen.pop();
}
}
visit(new Set<number>(), []);
return candidates;
}
function sortRoundGames(games: MatchGameResult[]) {
return [...games].sort(
(left, right) =>
Math.min(left.blueTeamIndex, left.redTeamIndex) -
Math.min(right.blueTeamIndex, right.redTeamIndex) ||
Math.max(left.blueTeamIndex, left.redTeamIndex) -
Math.max(right.blueTeamIndex, right.redTeamIndex),
);
}
function resolveUsedCodesByOldGameNumber(
codes: TournamentCodeDocument[],
gamePlans: ResultGamePlan[],
): Map<number, TournamentCodeDocument> {
const byGameNumber = new Map<number, TournamentCodeDocument[]>();
for (const code of codes) {
if (!code.gameNumber) continue;
const existing = byGameNumber.get(code.gameNumber) ?? [];
existing.push(code);
byGameNumber.set(code.gameNumber, existing);
}
const result = new Map<number, TournamentCodeDocument>();
for (const gamePlan of gamePlans) {
const candidates = byGameNumber.get(gamePlan.oldGameNumber) ?? [];
if (candidates.length !== 1) {
throw new Error(
`Expected exactly one tournament code for old game ${gamePlan.oldGameNumber}, got ${candidates.length}.`,
);
}
const [code] = candidates;
if (code.riotMatchId && code.riotMatchId !== gamePlan.game.riotMatchId) {
throw new Error(
`Tournament code ${formatCode(code)} has riotMatchId ${code.riotMatchId}, expected ${gamePlan.game.riotMatchId}.`,
);
}
result.set(gamePlan.oldGameNumber, code);
}
return result;
}
async function applyTournamentCodeUpdates(
plan: RepairPlan,
now: Date,
session: mongoose.ClientSession,
) {
const usedOperations = plan.gamePlans.map((gamePlan) => {
const code = plan.usedCodeByOldGameNumber.get(gamePlan.oldGameNumber);
if (!code) {
throw new Error(`Missing tournament code for ${gamePlan.oldGameNumber}.`);
}
return code.updateOne(
{
$set: {
state: 'used',
gameNumber: gamePlan.newGameNumber,
riotMatchId: gamePlan.game.riotMatchId,
usedAt: resolveGameEndedAt(gamePlan.game),
},
$unset: {
releasedAt: '',
},
},
{ session },
);
});
const releasedOperations = plan.releasedCodes.map((code) =>
code.updateOne(
{
$set: {
state: 'released',
releasedAt: now,
},
$unset: {
matchId: '',
gameNumber: '',
reservedAt: '',
usedAt: '',
riotMatchId: '',
},
},
{ session },
),
);
await Promise.all([...usedOperations, ...releasedOperations]);
}
function buildSeriesResults(games: MatchGameResult[]): MatchSeriesResult[] {
const bySeries = new Map<string, MatchSeriesResult>();
for (const game of games) {
const teamAIndex = Math.min(game.blueTeamIndex, game.redTeamIndex);
const teamBIndex = Math.max(game.blueTeamIndex, game.redTeamIndex);
const key = `${teamAIndex}:${teamBIndex}`;
const current =
bySeries.get(key) ??
({
teamAIndex,
teamBIndex,
teamAWins: 0,
teamBWins: 0,
} satisfies MatchSeriesResult);
if (game.winnerTeamIndex === teamAIndex) current.teamAWins += 1;
if (game.winnerTeamIndex === teamBIndex) current.teamBWins += 1;
current.winnerTeamIndex =
current.teamAWins > current.teamBWins
? teamAIndex
: current.teamBWins > current.teamAWins
? teamBIndex
: undefined;
bySeries.set(key, current);
}
return [...bySeries.values()].sort(
(left, right) =>
left.teamAIndex - right.teamAIndex ||
left.teamBIndex - right.teamBIndex,
);
}
function resolveMatchWinnerTeamIndex(seriesResults: MatchSeriesResult[]) {
const winsByTeam = new Map<number, number>();
for (const series of seriesResults) {
if (!series.winnerTeamIndex) continue;
winsByTeam.set(
series.winnerTeamIndex,
(winsByTeam.get(series.winnerTeamIndex) ?? 0) + 1,
);
}
const sorted = [...winsByTeam.entries()].sort(
(left, right) => right[1] - left[1],
);
if (sorted.length === 0) return undefined;
if (sorted.length > 1 && sorted[0][1] === sorted[1][1]) return undefined;
return sorted[0][0];
}
function printPlan(
options: CliOptions,
match: MatchDocument,
codes: TournamentCodeDocument[],
plan: RepairPlan,
) {
console.log(
`[limited round-robin repair] mode=${options.dryRun ? 'dry-run' : 'apply'} env=${options.nodeEnv} db=${resolveMongoDbName(options.nodeEnv)}`,
);
console.log(
`[limited round-robin repair] match=${match._id.toString()} title="${match.title}"`,
);
console.log(
`[limited round-robin repair] status ${match.status} -> finished, maxRounds=${options.maxRounds}`,
);
console.log(
`[limited round-robin repair] resultGames=${plan.gamePlans.length} codes kept=${plan.usedCodeByOldGameNumber.size} codes released=${plan.releasedCodes.length} previousCodeIds=${codes.length}`,
);
console.log(
`[limited round-robin repair] winnerTeamIndex=${plan.winnerTeamIndex ?? '(tie)'}`,
);
for (const gamePlan of plan.gamePlans) {
console.log(
` R${gamePlan.roundNumber} G${gamePlan.newGameNumber}: ${gamePlan.teamAIndex}팀 vs ${gamePlan.teamBIndex}팀 (old G${gamePlan.oldGameNumber}, riot=${gamePlan.game.riotMatchId})`,
);
}
}
function toPlainGame(game: MatchGameResult): MatchGameResult {
const maybeSubdocument = game as unknown as {
toObject?: () => MatchGameResult;
};
const objectValue =
typeof maybeSubdocument.toObject === 'function'
? maybeSubdocument.toObject()
: game;
return {
...objectValue,
participants: [...(objectValue.participants ?? [])],
};
}
function includesTeam(game: MatchGameResult, teamIndex: number) {
return game.blueTeamIndex === teamIndex || game.redTeamIndex === teamIndex;
}
function pairKey(game: MatchGameResult) {
const teamAIndex = Math.min(game.blueTeamIndex, game.redTeamIndex);
const teamBIndex = Math.max(game.blueTeamIndex, game.redTeamIndex);
return `${teamAIndex}:${teamBIndex}`;
}
function resolveGameEndedAt(game: MatchGameResult) {
return new Date(game.gameCreation + game.gameDuration * 1000);
}
function formatCode(code: TournamentCodeDocument) {
return `${code._id.toString()}(gameNumber=${code.gameNumber ?? 'none'}, state=${code.state})`;
}
void main()
.then(() => {
process.exit(0);
})
.catch((error: unknown) => {
console.error(error instanceof Error ? error.message : error);
process.exit(1);
});