diff --git a/apps/api/src/modules/global/database/dev-seeds/backfill-match-stats.ts b/apps/api/src/modules/global/database/dev-seeds/backfill-match-stats.ts new file mode 100644 index 00000000..f186f2fa --- /dev/null +++ b/apps/api/src/modules/global/database/dev-seeds/backfill-match-stats.ts @@ -0,0 +1,102 @@ +import { NestFactory } from '@nestjs/core'; +import mongoose from 'mongoose'; +import { AppModule } from '../../../../app.module'; +import { ConnectionService } from '../connection.service'; +import { MatchStatsService } from '../../../community-stats/match-stats.service'; + +interface Options { + communityId?: mongoose.Types.ObjectId; + dryRun: boolean; + force: boolean; +} + +async function main() { + const options = parseArgs(process.argv.slice(2)); + const app = await NestFactory.createApplicationContext(AppModule, { + logger: ['log', 'warn', 'error'], + }); + + try { + const connectionService = app.get(ConnectionService); + const matchStatsService = app.get(MatchStatsService); + const MatchModel = await connectionService.getModel('match'); + const MatchStatsModel = await connectionService.getModel('matchStats'); + + const filter: Record = { + status: { $in: ['finished', 'in-progress'] }, + 'result.games.0': { $exists: true }, + }; + if (options.communityId) filter.communityId = options.communityId; + + const matches = await MatchModel.find(filter) + .sort({ scheduledAt: -1 }) + .select({ _id: 1 }) + .exec(); + console.log(`match_stats backfill target=${matches.length}`); + + let processed = 0; + let skipped = 0; + let failed = 0; + + for (const match of matches) { + if (!options.force) { + const existing = await MatchStatsModel.exists({ matchId: match._id }); + if (existing) { + skipped += 1; + continue; + } + } + if (options.dryRun) { + processed += 1; + continue; + } + + try { + await matchStatsService.buildAndUpsert(match._id); + processed += 1; + } catch (error) { + failed += 1; + console.warn( + `failed ${match._id.toString()}: ${ + error instanceof Error ? error.message : error + }`, + ); + } + + if ((processed + skipped + failed) % 50 === 0) { + console.log( + `progress processed=${processed} skipped=${skipped} failed=${failed}`, + ); + } + } + + console.log( + `done processed=${processed} skipped=${skipped} failed=${failed}`, + ); + } finally { + await app.close(); + } +} + +function parseArgs(args: string[]): Options { + const options: Options = { dryRun: false, force: false }; + for (let index = 0; index < args.length; index += 1) { + const arg = args[index]; + if (arg === '--dry-run') options.dryRun = true; + if (arg === '--force') options.force = true; + if (arg === '--community-id') { + const value = args[index + 1]; + if (!value || !mongoose.isValidObjectId(value)) { + throw new Error('--community-id requires a valid ObjectId'); + } + options.communityId = new mongoose.Types.ObjectId(value); + index += 1; + } + } + return options; +} + +void main().catch((error) => { + console.error(error); + process.exit(1); +}); diff --git a/apps/api/src/modules/global/database/dev-seeds/create-temp-finished-match.ts b/apps/api/src/modules/global/database/dev-seeds/create-temp-finished-match.ts new file mode 100644 index 00000000..79f9dc54 --- /dev/null +++ b/apps/api/src/modules/global/database/dev-seeds/create-temp-finished-match.ts @@ -0,0 +1,574 @@ +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 { + MatchGameResult, + MatchParticipant, + MatchSeriesResult, + MatchTeam, + Position, + PositionPreference, + TeamSide, + TierInfo, +} from '../schema'; +import { SecretModule } from '../../secret/secret.module'; + +const TEMP_JOB_ID = 'temp-finished-30-players-6-teams'; +const TEAM_COUNT = 6; +const TEAM_SIZE = 5; +const TOTAL_PLAYERS = TEAM_COUNT * TEAM_SIZE; +const GAME_COUNT_PER_SERIES_GROUP = 5; +const POSITIONS: Position[] = ['TOP', 'JGL', 'MID', 'ADC', 'SUP']; +const CHAMPION_IDS = [ + 266, 64, 103, 222, 412, 24, 421, 134, 145, 497, 58, 121, 777, 202, 111, 39, + 120, 7, 81, 89, 114, 104, 157, 51, 432, 92, 234, 61, 21, 53, +]; + +interface CliOptions { + communityId?: string; + dryRun: boolean; + nodeEnv: string; + replace: boolean; + scheduledAt: Date; + title: string; +} + +interface TempPlayer { + userId: mongoose.Types.ObjectId; + puuid: string; + gameName: string; + tagLine: string; + profileIconId: number; + tier: TierInfo; + preferredPositions: PositionPreference[]; +} + +interface CommunityLean { + _id: mongoose.Types.ObjectId; + name?: string; +} + +@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], +}) +class TempSeedModule {} + +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 communityId = + process.env.VITE_DEFAULT_COMMUNITY_ID ?? process.env.DEFAULT_COMMUNITY_ID; + let dryRun = false; + let nodeEnv = process.env.NODE_ENV ?? 'dev'; + let replace = false; + let scheduledAt = new Date(Date.now() - 24 * 60 * 60 * 1000); + let title = `결과 검증 임시 내전 30인 6팀 ${formatStamp(new Date())}`; + + for (let index = 0; index < argv.length; index += 1) { + const arg = argv[index]; + if (arg === '--community-id') { + const value = argv[index + 1]; + if (!value) throw new Error('--community-id requires an ObjectId.'); + communityId = value; + index += 1; + continue; + } + if (arg.startsWith('--community-id=')) { + communityId = arg.slice('--community-id='.length); + continue; + } + if (arg === '--dry-run') { + dryRun = true; + continue; + } + if (arg === '--env') { + const value = argv[index + 1]; + if (!value) throw new Error('--env requires dev, test, or prod.'); + nodeEnv = value; + index += 1; + continue; + } + if (arg.startsWith('--env=')) { + nodeEnv = arg.slice('--env='.length); + continue; + } + if (arg === '--replace') { + replace = true; + continue; + } + if (arg === '--scheduled-at') { + scheduledAt = parseDateArg(argv[index + 1], '--scheduled-at'); + index += 1; + continue; + } + if (arg.startsWith('--scheduled-at=')) { + scheduledAt = parseDateArg( + arg.slice('--scheduled-at='.length), + '--scheduled-at', + ); + continue; + } + if (arg === '--title') { + const value = argv[index + 1]; + if (!value) throw new Error('--title requires a value.'); + title = value; + index += 1; + continue; + } + if (arg.startsWith('--title=')) { + title = arg.slice('--title='.length); + continue; + } + if (arg === '--help' || arg === '-h') { + printHelp(); + process.exit(0); + } + throw new Error(`Unknown argument: ${arg}`); + } + + if (!['dev', 'test', 'prod'].includes(nodeEnv)) { + throw new Error('--env must be dev, test, or prod.'); + } + if (communityId && !mongoose.isValidObjectId(communityId)) { + throw new Error('--community-id must be a valid ObjectId.'); + } + + return { + communityId: communityId?.trim() || undefined, + dryRun, + nodeEnv, + replace, + scheduledAt, + title, + }; +} + +function parseDateArg(value: string | undefined, label: string): Date { + if (!value) throw new Error(`${label} requires an ISO date value.`); + const parsed = new Date(value); + if (Number.isNaN(parsed.getTime())) { + throw new Error(`${label} must be a valid ISO date value.`); + } + return parsed; +} + +function printHelp() { + console.log(`Usage: + pnpm --filter api exec ts-node src/modules/global/database/dev-seeds/create-temp-finished-match.ts + pnpm --filter api exec ts-node src/modules/global/database/dev-seeds/create-temp-finished-match.ts --replace + +Options: + --community-id Community ObjectId. Defaults to env or first community. + --dry-run Print the payload summary without writing. + --env dev | test | prod. Default: NODE_ENV or dev. + --replace Delete previous temp matches created by this script first. + --scheduled-at Scheduled date. Default: yesterday. + --title Match title. Default: timestamped temp title. +`); +} + +async function main() { + const options = parseArgs(process.argv.slice(2)); + process.env.NODE_ENV = options.nodeEnv; + await loadMachineEnvFile(); + + const app = await NestFactory.createApplicationContext(TempSeedModule, { + logger: ['log', 'warn', 'error'], + }); + + try { + const connectionService = app.get(ConnectionService); + const CommunityModel = await connectionService.getModel('community'); + const MatchModel = await connectionService.getModel('match'); + const community = await resolveCommunity( + CommunityModel, + options.communityId, + ); + + const payload = buildMatchPayload(community._id, options); + + console.log( + `[temp result seed] mode=${options.dryRun ? 'dry-run' : 'apply'} env=${options.nodeEnv} db=${resolveMongoDbName(options.nodeEnv)}`, + ); + console.log( + `[temp result seed] community=${community.name ?? '(unnamed)'} (${community._id.toString()})`, + ); + console.log( + `[temp result seed] title="${options.title}" participants=${payload.participants.length} teams=${payload.teams.length} games=${payload.result.games.length}`, + ); + + if (options.dryRun) { + console.log('[temp result seed] No writes were made.'); + return; + } + + if (options.replace) { + const deleteResult = await MatchModel.deleteMany({ + communityId: community._id, + 'legacyImportSource.jobId': TEMP_JOB_ID, + }).exec(); + console.log( + `[temp result seed] deleted=${deleteResult.deletedCount ?? 0}`, + ); + } + + const match = await MatchModel.create(payload); + console.log(`[temp result seed] created=${match._id.toString()}`); + console.log(`[temp result seed] route=/match/${match._id.toString()}`); + } finally { + await app.close(); + } +} + +async function resolveCommunity( + CommunityModel: mongoose.Model<unknown>, + communityId?: string, +): Promise<CommunityLean> { + const community = communityId + ? await CommunityModel.findById(communityId) + .select({ name: 1 }) + .lean<CommunityLean>() + .exec() + : await CommunityModel.findOne() + .sort({ createdAt: 1 }) + .select({ name: 1 }) + .lean<CommunityLean>() + .exec(); + + if (!community) { + throw new Error( + communityId + ? `Community not found: ${communityId}` + : 'No community found. Pass --community-id.', + ); + } + + return community; +} + +function buildMatchPayload( + communityId: mongoose.Types.ObjectId, + options: CliOptions, +) { + const now = new Date(); + const players = buildPlayers(now); + const participants = players.map( + (player, index): MatchParticipant => ({ + userId: player.userId, + puuid: player.puuid, + gameName: player.gameName, + tagLine: player.tagLine, + profileIconId: player.profileIconId, + tier: player.tier, + preferredPositions: player.preferredPositions, + joinedAt: new Date( + options.scheduledAt.getTime() - (TOTAL_PLAYERS - index) * 60000, + ), + excluded: false, + }), + ); + const teams = buildTeams(players); + const games = buildGames(players, options.scheduledAt); + const seriesResults = buildSeriesResults(games); + const winnerTeamIndex = resolveOverallWinner(seriesResults); + + return { + communityId, + title: options.title, + description: + '결과 페이지 검증용으로 생성된 30명, 6팀, 15경기 완료 임시 데이터입니다.', + mapId: 11, + status: 'finished', + scheduledAt: options.scheduledAt, + maxParticipants: TOTAL_PLAYERS, + gameCount: GAME_COUNT_PER_SERIES_GROUP, + gameMode: 'round-robin', + tournamentCodeIds: [], + teamBuiltAt: new Date(options.scheduledAt.getTime() - 30 * 60000), + participants, + teams, + result: { + winnerTeamIndex, + mvpUserId: players[0].userId, + riotMatchIds: games.map((game) => game.riotMatchId), + games, + seriesResults, + }, + resultPollState: { + startedAt: new Date(options.scheduledAt.getTime() + 2 * 60 * 60 * 1000), + lastPolledAt: now, + lastPollOutcome: 'matched', + matchedCount: games.length, + expandedToAllPuuids: true, + state: 'complete', + }, + legacyImported: true, + legacyImportSource: { + importedAt: now, + importedBy: players[0].userId, + triggeringPuuid: players[0].puuid, + jobId: TEMP_JOB_ID, + }, + prizes: ['1등 팀: 결과 화면 검증용 임시 상품', 'MVP: Temp01'], + notices: ['이 매치는 UI 검증용 임시 데이터입니다.'], + schedule: [ + { time: '20:00', label: '로비 오픈' }, + { time: '20:10', label: '1경기 시작' }, + { time: '23:30', label: '풀리그 종료' }, + ], + }; +} + +function buildPlayers(now: Date): TempPlayer[] { + return Array.from({ length: TOTAL_PLAYERS }, (_, index) => { + const playerNumber = index + 1; + const primaryPosition = POSITIONS[index % POSITIONS.length]; + + return { + userId: new mongoose.Types.ObjectId(), + puuid: `temp-result-puuid-${playerNumber.toString().padStart(2, '0')}`, + gameName: `Temp${playerNumber.toString().padStart(2, '0')}`, + tagLine: `T${playerNumber.toString().padStart(3, '0')}`, + profileIconId: 20 + playerNumber, + tier: buildTier(playerNumber, now), + preferredPositions: buildPreferredPositions(primaryPosition), + }; + }); +} + +function buildPreferredPositions( + primaryPosition: Position, +): PositionPreference[] { + const ordered = [ + primaryPosition, + ...POSITIONS.filter((position) => position !== primaryPosition), + ]; + return ordered.map((position, index) => ({ + position, + priority: index + 1, + })); +} + +function buildTier(playerNumber: number, fetchedAt: Date): TierInfo { + const tiers = [ + ['CHALLENGER', 'I'], + ['GRANDMASTER', 'I'], + ['MASTER', 'I'], + ['DIAMOND', 'I'], + ['DIAMOND', 'II'], + ['EMERALD', 'I'], + ['EMERALD', 'II'], + ['PLATINUM', 'I'], + ['PLATINUM', 'II'], + ['GOLD', 'I'], + ] as const; + const [tier, rank] = tiers[(playerNumber - 1) % tiers.length]; + + return { + queueType: 'RANKED_SOLO_5x5', + tier, + rank, + leaguePoints: (playerNumber * 17) % 100, + wins: 40 + playerNumber, + losses: 22 + (playerNumber % 13), + fetchedAt, + }; +} + +function buildTeams(players: TempPlayer[]): MatchTeam[] { + return Array.from({ length: TEAM_COUNT }, (_, teamOffset) => { + const teamIndex = teamOffset + 1; + const members = players + .slice(teamOffset * TEAM_SIZE, (teamOffset + 1) * TEAM_SIZE) + .map((player, memberOffset) => ({ + userId: player.userId, + assignedPosition: POSITIONS[memberOffset], + cost: memberOffset === 0 ? 0 : 80 + teamIndex * 15 + memberOffset * 20, + })); + + return { + teamIndex, + name: `${teamIndex}팀`, + captainUserId: members[0]?.userId, + members, + }; + }); +} + +function buildGames( + players: TempPlayer[], + scheduledAt: Date, +): MatchGameResult[] { + const games: MatchGameResult[] = []; + const playersByTeam = new Map<number, TempPlayer[]>(); + + for (let teamIndex = 1; teamIndex <= TEAM_COUNT; teamIndex += 1) { + playersByTeam.set( + teamIndex, + players.slice((teamIndex - 1) * TEAM_SIZE, teamIndex * TEAM_SIZE), + ); + } + + for (let teamAIndex = 1; teamAIndex <= TEAM_COUNT; teamAIndex += 1) { + for ( + let teamBIndex = teamAIndex + 1; + teamBIndex <= TEAM_COUNT; + teamBIndex += 1 + ) { + const gameNumber = games.length + 1; + const lowerTeamStartsBlue = gameNumber % 2 === 1; + const blueTeamIndex = lowerTeamStartsBlue ? teamAIndex : teamBIndex; + const redTeamIndex = lowerTeamStartsBlue ? teamBIndex : teamAIndex; + const winnerTeamIndex = teamAIndex; + const winnerSide: TeamSide = + winnerTeamIndex === blueTeamIndex ? 'blue' : 'red'; + const gameCreation = scheduledAt.getTime() + gameNumber * 20 * 60 * 1000; + const riotMatchId = `KR_TEMP_30X6_${formatStamp(scheduledAt)}_${gameNumber + .toString() + .padStart(2, '0')}`; + + games.push({ + gameNumber, + riotMatchId, + blueTeamIndex, + redTeamIndex, + winnerTeamIndex, + winnerSide, + gameCreation, + gameDuration: 1650 + gameNumber * 23, + participants: [ + ...buildGameParticipants({ + players: playersByTeam.get(blueTeamIndex) ?? [], + teamIndex: blueTeamIndex, + side: 'blue', + winnerTeamIndex, + gameNumber, + }), + ...buildGameParticipants({ + players: playersByTeam.get(redTeamIndex) ?? [], + teamIndex: redTeamIndex, + side: 'red', + winnerTeamIndex, + gameNumber, + }), + ], + }); + } + } + + return games; +} + +function buildGameParticipants(params: { + players: TempPlayer[]; + teamIndex: number; + side: TeamSide; + winnerTeamIndex: number; + gameNumber: number; +}): MatchGameResult['participants'] { + const didWin = params.teamIndex === params.winnerTeamIndex; + + return params.players.map((player, index) => { + const championIndex = + (params.gameNumber + params.teamIndex + index) % CHAMPION_IDS.length; + return { + userId: player.userId, + teamIndex: params.teamIndex, + side: params.side, + championId: CHAMPION_IDS[championIndex], + kills: didWin + ? 4 + ((params.gameNumber + index) % 8) + : 1 + ((params.gameNumber + index) % 5), + deaths: didWin ? 1 + (index % 4) : 4 + ((params.gameNumber + index) % 7), + assists: didWin + ? 7 + ((params.gameNumber + index) % 12) + : 3 + ((params.gameNumber + index) % 8), + win: didWin, + }; + }); +} + +function buildSeriesResults(games: MatchGameResult[]): MatchSeriesResult[] { + return games.map((game) => { + const teamAIndex = Math.min(game.blueTeamIndex, game.redTeamIndex); + const teamBIndex = Math.max(game.blueTeamIndex, game.redTeamIndex); + + return { + teamAIndex, + teamBIndex, + teamAWins: game.winnerTeamIndex === teamAIndex ? 1 : 0, + teamBWins: game.winnerTeamIndex === teamBIndex ? 1 : 0, + winnerTeamIndex: game.winnerTeamIndex, + }; + }); +} + +function resolveOverallWinner( + seriesResults: MatchSeriesResult[], +): number | undefined { + 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, + ); + } + + return [...winsByTeam.entries()].sort( + (left, right) => right[1] - left[1], + )[0]?.[0]; +} + +function formatStamp(date: Date): string { + const year = date.getFullYear(); + const month = `${date.getMonth() + 1}`.padStart(2, '0'); + const day = `${date.getDate()}`.padStart(2, '0'); + const hours = `${date.getHours()}`.padStart(2, '0'); + const minutes = `${date.getMinutes()}`.padStart(2, '0'); + const seconds = `${date.getSeconds()}`.padStart(2, '0'); + return `${year}${month}${day}-${hours}${minutes}${seconds}`; +} + +void main().catch((error: unknown) => { + console.error(error instanceof Error ? error.message : error); + process.exitCode = 1; +}); diff --git a/apps/api/src/modules/global/database/migrations/20260502-auction-pass-history.ts b/apps/api/src/modules/global/database/migrations/20260502-auction-pass-history.ts new file mode 100644 index 00000000..95f0bbce --- /dev/null +++ b/apps/api/src/modules/global/database/migrations/20260502-auction-pass-history.ts @@ -0,0 +1,100 @@ +interface MigrationCollection { + find(filter: Record<string, unknown>): { + limit(limit: number): AsyncIterable<AnyDoc>; + }; + bulkWrite( + writes: Array<{ + updateOne: { + filter: { _id: unknown }; + update: { $set: Record<string, unknown> }; + }; + }>, + options: { ordered: boolean }, + ): Promise<unknown>; +} + +interface MigrationDb { + collection(name: string): MigrationCollection; +} + +interface MigrationOptions { + dryRun?: boolean; + limit?: number; +} + +interface MigrationStats { + scannedAuctions: number; + changedAuctions: number; +} + +type AnyDoc = Record<string, unknown> & { _id: unknown }; + +export async function migrateAuctionPassHistory( + db: MigrationDb, + options: MigrationOptions = {}, +): Promise<MigrationStats> { + const dryRun = options.dryRun ?? true; + const stats: MigrationStats = { + scannedAuctions: 0, + changedAuctions: 0, + }; + const writes: Array<{ + updateOne: { + filter: { _id: unknown }; + update: { $set: Record<string, unknown> }; + }; + }> = []; + + for await (const doc of db.collection('auction').find({}).limit(options.limit ?? 0)) { + stats.scannedAuctions += 1; + const set: Record<string, unknown> = {}; + let changed = false; + + if (!Array.isArray(doc.passedQueue)) { + set.passedQueue = []; + changed = true; + } + if (typeof doc.auctionRound !== 'number') { + set.auctionRound = 1; + changed = true; + } + if (typeof doc.topTierThreshold !== 'string') { + set.topTierThreshold = 'NONE'; + changed = true; + } + if (!Array.isArray(doc.manualTopTierUserIds)) { + set.manualTopTierUserIds = []; + changed = true; + } + + const order = Array.isArray(doc.order) + ? doc.order.map((player) => { + if (!isRecord(player) || typeof player.passCount === 'number') { + return player; + } + changed = true; + return { ...player, passCount: 0 }; + }) + : []; + if (changed && order.length > 0) set.order = order; + if (!changed) continue; + + stats.changedAuctions += 1; + writes.push({ + updateOne: { + filter: { _id: doc._id }, + update: { $set: set }, + }, + }); + } + + if (!dryRun && writes.length > 0) { + await db.collection('auction').bulkWrite(writes, { ordered: false }); + } + + return stats; +} + +function isRecord(value: unknown): value is Record<string, unknown> { + return Boolean(value && typeof value === 'object' && !Array.isArray(value)); +} diff --git a/apps/api/src/modules/global/database/migrations/20260502-team-index.spec.ts b/apps/api/src/modules/global/database/migrations/20260502-team-index.spec.ts new file mode 100644 index 00000000..deb3168f --- /dev/null +++ b/apps/api/src/modules/global/database/migrations/20260502-team-index.spec.ts @@ -0,0 +1,160 @@ +import { migrateTeamIndex } from './20260502-team-index'; + +function createDb(params: { + auctions?: Array<Record<string, unknown>>; + matches?: Array<Record<string, unknown>>; +}) { + const collections = { + auction: params.auctions ?? [], + match: params.matches ?? [], + }; + + return { + collections, + db: { + collection(name: string) { + const key = name === 'auction' ? 'auction' : 'match'; + const docs = collections[key]; + return { + find() { + return { + limit() { + return { + async *[Symbol.asyncIterator]() { + for (const doc of docs) yield doc; + }, + }; + }, + }; + }, + async bulkWrite(writes: Array<{ + updateOne: { + filter: { _id: unknown }; + update: { + $set: Record<string, unknown>; + $unset: Record<string, ''>; + }; + }; + }>) { + for (const write of writes) { + const doc = docs.find((item) => item._id === write.updateOne.filter._id); + if (!doc) continue; + Object.assign(doc, write.updateOne.update.$set); + for (const key of Object.keys(write.updateOne.update.$unset)) { + delete doc[key]; + } + } + }, + }; + }, + }, + }; +} + +describe('migrateTeamIndex', () => { + it('migrates auction and match team identity fields', async () => { + const { db, collections } = createDb({ + auctions: [ + { + _id: 'auction-1', + teams: [{ side: 'blue', groupIndex: 1 }, { side: 'red', groupIndex: 1 }], + bids: [{ side: 'red', groupIndex: 1, amount: 100 }], + currentBidder: 'red', + currentBidderGroupIndex: 1, + }, + ], + matches: [ + { + _id: 'match-1', + teams: [{ side: 'blue', groupIndex: 1 }, { side: 'red', groupIndex: 1 }], + result: { + winnerSide: 'blue', + blueScore: 1, + redScore: 0, + games: [ + { + gameNumber: 1, + riotMatchId: 'KR_1', + winnerSide: 'blue', + blueGroupIndex: 1, + redGroupIndex: 1, + participants: [ + { userId: 'u1', side: 'blue' }, + { userId: 'u2', side: 'red' }, + ], + }, + ], + seriesResults: [ + { + blueGroupIndex: 1, + redGroupIndex: 1, + blueScore: 1, + redScore: 0, + winnerSide: 'blue', + }, + ], + }, + }, + ], + }); + + const stats = await migrateTeamIndex(db, { dryRun: false }); + + expect(stats).toEqual({ + scannedAuctions: 1, + changedAuctions: 1, + scannedMatches: 1, + changedMatches: 1, + }); + expect(collections.auction[0]).toMatchObject({ + teams: [{ teamIndex: 1 }, { teamIndex: 2 }], + bids: [{ teamIndex: 2, amount: 100 }], + currentBidderTeamIndex: 2, + }); + expect(collections.match[0]).toMatchObject({ + teams: [{ teamIndex: 1, name: '1팀' }, { teamIndex: 2, name: '2팀' }], + result: { + winnerTeamIndex: 1, + games: [ + { + blueTeamIndex: 1, + redTeamIndex: 2, + winnerTeamIndex: 1, + participants: [ + { teamIndex: 1, side: 'blue' }, + { teamIndex: 2, side: 'red' }, + ], + }, + ], + seriesResults: [ + { + teamAIndex: 1, + teamBIndex: 2, + teamAWins: 1, + teamBWins: 0, + winnerTeamIndex: 1, + }, + ], + }, + }); + expect(collections.auction[0]).not.toHaveProperty('currentBidder'); + expect(collections.match[0].result).not.toHaveProperty('blueScore'); + }); + + it('is idempotent after applying updates', async () => { + const { db } = createDb({ + matches: [ + { + _id: 'match-1', + teams: [{ side: 'blue', groupIndex: 1 }], + }, + ], + }); + + await migrateTeamIndex(db, { dryRun: false }); + const stats = await migrateTeamIndex(db, { dryRun: false }); + + expect(stats.changedMatches).toBe(0); + expect(stats.changedAuctions).toBe(0); + }); +}); diff --git a/apps/api/src/modules/global/database/migrations/20260502-team-index.ts b/apps/api/src/modules/global/database/migrations/20260502-team-index.ts new file mode 100644 index 00000000..cbbf21c2 --- /dev/null +++ b/apps/api/src/modules/global/database/migrations/20260502-team-index.ts @@ -0,0 +1,335 @@ +type LegacySide = 'blue' | 'red'; + +interface MigrationCollection { + find(filter: Record<string, unknown>): { + limit(limit: number): AsyncIterable<AnyDoc>; + }; + bulkWrite( + writes: Array<{ + updateOne: { + filter: { _id: unknown }; + update: { $set: Record<string, unknown>; $unset: Record<string, ''> }; + }; + }>, + options: { ordered: boolean }, + ): Promise<unknown>; +} + +interface MigrationDb { + collection(name: string): MigrationCollection; +} + +interface MigrationOptions { + dryRun?: boolean; + limit?: number; +} + +interface MigrationStats { + scannedAuctions: number; + changedAuctions: number; + scannedMatches: number; + changedMatches: number; +} + +type AnyDoc = Record<string, unknown> & { _id: unknown }; + +export async function migrateTeamIndex( + db: MigrationDb, + options: MigrationOptions = {}, +): Promise<MigrationStats> { + const dryRun = options.dryRun ?? true; + const stats: MigrationStats = { + scannedAuctions: 0, + changedAuctions: 0, + scannedMatches: 0, + changedMatches: 0, + }; + + await migrateCollection(db.collection('auction'), options.limit, dryRun, stats, 'auction'); + await migrateCollection(db.collection('match'), options.limit, dryRun, stats, 'match'); + + return stats; +} + +async function migrateCollection( + collection: MigrationCollection, + limit: number | undefined, + dryRun: boolean, + stats: MigrationStats, + kind: 'auction' | 'match', +) { + const cursor = collection.find({}).limit(limit ?? 0); + const writes: Array<{ + updateOne: { + filter: { _id: unknown }; + update: { $set: Record<string, unknown>; $unset: Record<string, ''> }; + }; + }> = []; + + for await (const doc of cursor) { + if (kind === 'auction') stats.scannedAuctions += 1; + if (kind === 'match') stats.scannedMatches += 1; + + const update = kind === 'auction' ? migrateAuction(doc) : migrateMatch(doc); + if (!update) continue; + + if (kind === 'auction') stats.changedAuctions += 1; + if (kind === 'match') stats.changedMatches += 1; + writes.push({ + updateOne: { + filter: { _id: doc._id }, + update, + }, + }); + } + + if (!dryRun && writes.length > 0) { + await collection.bulkWrite(writes, { ordered: false }); + } +} + +function migrateAuction(doc: AnyDoc) { + const set: Record<string, unknown> = {}; + const unset: Record<string, ''> = {}; + let changed = false; + + const teams = asArray(doc.teams).map((team) => { + const migrated = { ...team }; + const teamIndex = readTeamIndex(migrated); + if (teamIndex !== undefined) migrated.teamIndex = teamIndex; + if ('side' in migrated || 'groupIndex' in migrated) changed = true; + delete migrated.side; + delete migrated.groupIndex; + return migrated; + }); + if (changed) set.teams = teams; + + const bids = asArray(doc.bids).map((bid) => { + const migrated = { ...bid }; + const teamIndex = readTeamIndex(migrated); + if (teamIndex !== undefined) migrated.teamIndex = teamIndex; + if ('side' in migrated || 'groupIndex' in migrated) changed = true; + delete migrated.side; + delete migrated.groupIndex; + return migrated; + }); + if (changed) set.bids = bids; + + if ( + typeof doc.currentBidderTeamIndex !== 'number' && + isSide(doc.currentBidder) + ) { + set.currentBidderTeamIndex = sideGroupToTeamIndex( + doc.currentBidder, + numberOrDefault(doc.currentBidderGroupIndex, 1), + ); + changed = true; + } + if ('currentBidder' in doc || 'currentBidderGroupIndex' in doc) { + unset.currentBidder = ''; + unset.currentBidderGroupIndex = ''; + changed = true; + } + + return changed ? { $set: set, $unset: unset } : null; +} + +function migrateMatch(doc: AnyDoc) { + const set: Record<string, unknown> = {}; + const unset: Record<string, ''> = {}; + let changed = false; + + const teams = asArray(doc.teams).map((team) => { + const migrated = { ...team }; + const teamIndex = readTeamIndex(migrated); + if (teamIndex !== undefined) migrated.teamIndex = teamIndex; + if (!migrated.name && typeof teamIndex === 'number') migrated.name = `${teamIndex}팀`; + if ('side' in migrated || 'groupIndex' in migrated) changed = true; + delete migrated.side; + delete migrated.groupIndex; + return migrated; + }); + if (changed) set.teams = teams; + + const result = isRecord(doc.result) ? migrateResult(doc.result) : null; + if (result) { + set.result = result; + changed = true; + } + + return changed ? { $set: set, $unset: unset } : null; +} + +function migrateResult(result: Record<string, unknown>) { + let changed = false; + const migrated = { ...result }; + + const games = asArray(result.games).map((game) => { + const next = { ...game }; + const blueTeamIndex = + numberOrUndefined(next.blueTeamIndex) ?? + sideGroupToTeamIndex('blue', numberOrDefault(next.blueGroupIndex, 1)); + const redTeamIndex = + numberOrUndefined(next.redTeamIndex) ?? + sideGroupToTeamIndex('red', numberOrDefault(next.redGroupIndex, 1)); + const winnerSide = isSide(next.winnerSide) ? next.winnerSide : undefined; + const winnerTeamIndex = + numberOrUndefined(next.winnerTeamIndex) ?? + (winnerSide === 'blue' + ? blueTeamIndex + : winnerSide === 'red' + ? redTeamIndex + : undefined); + + next.blueTeamIndex = blueTeamIndex; + next.redTeamIndex = redTeamIndex; + if (winnerTeamIndex !== undefined) next.winnerTeamIndex = winnerTeamIndex; + next.participants = asArray(next.participants).map((participant) => { + const migratedParticipant = { ...participant }; + if (typeof migratedParticipant.teamIndex !== 'number') { + migratedParticipant.teamIndex = + migratedParticipant.side === 'blue' ? blueTeamIndex : redTeamIndex; + } + return migratedParticipant; + }); + if ('blueGroupIndex' in next || 'redGroupIndex' in next) changed = true; + delete next.blueGroupIndex; + delete next.redGroupIndex; + return next; + }); + migrated.games = games; + + const seriesResults = asArray(result.seriesResults).map((series) => { + if (typeof series.teamAIndex === 'number' && typeof series.teamBIndex === 'number') { + return series; + } + changed = true; + const legacyBlueTeamIndex = sideGroupToTeamIndex( + 'blue', + numberOrDefault(series.blueGroupIndex, 1), + ); + const legacyRedTeamIndex = sideGroupToTeamIndex( + 'red', + numberOrDefault(series.redGroupIndex, 1), + ); + const teamAIndex = Math.min(legacyBlueTeamIndex, legacyRedTeamIndex); + const teamBIndex = Math.max(legacyBlueTeamIndex, legacyRedTeamIndex); + const blueScore = numberOrDefault(series.blueScore, 0); + const redScore = numberOrDefault(series.redScore, 0); + const winnerSide = isSide(series.winnerSide) ? series.winnerSide : undefined; + const winnerTeamIndex = + winnerSide === 'blue' + ? legacyBlueTeamIndex + : winnerSide === 'red' + ? legacyRedTeamIndex + : undefined; + return { + teamAIndex, + teamBIndex, + teamAWins: teamAIndex === legacyBlueTeamIndex ? blueScore : redScore, + teamBWins: teamBIndex === legacyBlueTeamIndex ? blueScore : redScore, + winnerTeamIndex, + }; + }); + migrated.seriesResults = seriesResults.length > 0 ? seriesResults : buildSeries(games); + + if (typeof migrated.winnerTeamIndex !== 'number') { + const migratedSeriesResults = Array.isArray(migrated.seriesResults) + ? migrated.seriesResults + : []; + migrated.winnerTeamIndex = + resolveWinnerTeamIndex(migratedSeriesResults) ?? + (isSide(migrated.winnerSide) + ? sideGroupToTeamIndex(migrated.winnerSide, 1) + : undefined); + } + + if ('winnerSide' in migrated || 'blueScore' in migrated || 'redScore' in migrated) { + changed = true; + } + delete migrated.winnerSide; + delete migrated.blueScore; + delete migrated.redScore; + + return changed ? migrated : null; +} + +function buildSeries(games: Record<string, unknown>[]) { + const bySeries = new Map< + string, + { + teamAIndex: number; + teamBIndex: number; + teamAWins: number; + teamBWins: number; + winnerTeamIndex?: number; + } + >(); + for (const game of games) { + const blueTeamIndex = numberOrDefault(game.blueTeamIndex, 1); + const redTeamIndex = numberOrDefault(game.redTeamIndex, 2); + const winnerTeamIndex = numberOrUndefined(game.winnerTeamIndex); + const teamAIndex = Math.min(blueTeamIndex, redTeamIndex); + const teamBIndex = Math.max(blueTeamIndex, redTeamIndex); + const key = `${teamAIndex}:${teamBIndex}`; + const current = + bySeries.get(key) ?? { teamAIndex, teamBIndex, teamAWins: 0, teamBWins: 0 }; + if (winnerTeamIndex === teamAIndex) current.teamAWins += 1; + if (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()]; +} + +function resolveWinnerTeamIndex( + seriesResults: Array<Record<string, unknown>>, +): number | undefined { + const wins = new Map<number, number>(); + for (const series of seriesResults) { + const winnerTeamIndex = numberOrUndefined(series.winnerTeamIndex); + if (!winnerTeamIndex) continue; + wins.set(winnerTeamIndex, (wins.get(winnerTeamIndex) ?? 0) + 1); + } + const sorted = [...wins.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 readTeamIndex(value: Record<string, unknown>): number | undefined { + if (typeof value.teamIndex === 'number') return value.teamIndex; + if (!isSide(value.side)) return undefined; + return sideGroupToTeamIndex(value.side, numberOrDefault(value.groupIndex, 1)); +} + +function sideGroupToTeamIndex(side: LegacySide, groupIndex: number) { + return (Math.max(1, groupIndex) - 1) * 2 + (side === 'blue' ? 1 : 2); +} + +function asArray(value: unknown): Record<string, unknown>[] { + return Array.isArray(value) + ? value.filter(isRecord).map((item) => ({ ...item })) + : []; +} + +function isRecord(value: unknown): value is Record<string, unknown> { + return Boolean(value && typeof value === 'object' && !Array.isArray(value)); +} + +function isSide(value: unknown): value is LegacySide { + return value === 'blue' || value === 'red'; +} + +function numberOrDefault(value: unknown, fallback: number) { + return typeof value === 'number' && Number.isFinite(value) ? value : fallback; +} + +function numberOrUndefined(value: unknown) { + return typeof value === 'number' && Number.isFinite(value) ? value : undefined; +} diff --git a/apps/api/src/modules/global/database/migrations/run-team-index.ts b/apps/api/src/modules/global/database/migrations/run-team-index.ts new file mode 100644 index 00000000..1b871ce8 --- /dev/null +++ b/apps/api/src/modules/global/database/migrations/run-team-index.ts @@ -0,0 +1,167 @@ +import 'reflect-metadata'; +import { Module } from '@nestjs/common'; +import { ConfigModule } from '@nestjs/config'; +import { NestFactory } from '@nestjs/core'; +import { readFile } from 'node:fs/promises'; +import { resolve } from 'node:path'; +import { ConnectionService, resolveMongoDbName } from '../connection.service'; +import { SecretModule } from '../../secret/secret.module'; +import { migrateTeamIndex } from './20260502-team-index'; + +interface CliOptions { + dryRun: boolean; + limit?: number; + nodeEnv: string; +} + +@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], +}) +class MigrationModule {} + +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 limit: number | undefined; + 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 === '--env') { + const value = argv[index + 1]; + if (!value) throw new Error('--env requires dev, test, or prod.'); + nodeEnv = value; + index += 1; + continue; + } + if (arg.startsWith('--env=')) { + nodeEnv = arg.slice('--env='.length); + continue; + } + if (arg === '--limit') { + const value = Number(argv[index + 1]); + if (!Number.isInteger(value) || value < 1) { + throw new Error('--limit requires a positive integer.'); + } + limit = value; + index += 1; + continue; + } + if (arg.startsWith('--limit=')) { + const value = Number(arg.slice('--limit='.length)); + if (!Number.isInteger(value) || value < 1) { + throw new Error('--limit requires a positive integer.'); + } + limit = value; + continue; + } + if (arg === '--help' || arg === '-h') { + printHelp(); + process.exit(0); + } + throw new Error(`Unknown argument: ${arg}`); + } + + if (!['dev', 'test', 'prod'].includes(nodeEnv)) { + throw new Error('--env must be dev, test, or prod.'); + } + + return { dryRun, limit, nodeEnv }; +} + +function printHelp() { + console.log(`Usage: + pnpm --filter api exec ts-node src/modules/global/database/migrations/run-team-index.ts [--dry-run] + pnpm --filter api exec ts-node src/modules/global/database/migrations/run-team-index.ts --apply + +Options: + --dry-run Print affected counts without writing. Default. + --apply Apply updates to MongoDB. + --env <env> dev | test | prod. Default: NODE_ENV or dev. + --limit <n> Only scan first n documents per collection. +`); +} + +async function main() { + const options = parseArgs(process.argv.slice(2)); + process.env.NODE_ENV = options.nodeEnv; + await loadMachineEnvFile(); + + const app = await NestFactory.createApplicationContext(MigrationModule, { + logger: options.dryRun ? ['log', 'warn', 'error'] : ['log', 'warn', 'error'], + }); + + try { + const connectionService = app.get(ConnectionService); + const connection = await connectionService.getConnection(); + if (!connection.db) { + throw new Error('MongoDB connection has no db handle.'); + } + + const dbName = resolveMongoDbName(options.nodeEnv); + console.log( + `[team-index migration] mode=${options.dryRun ? 'dry-run' : 'apply'} env=${options.nodeEnv} db=${dbName}`, + ); + + const stats = await migrateTeamIndex(connection.db as Parameters<typeof migrateTeamIndex>[0], { + dryRun: options.dryRun, + limit: options.limit, + }); + + console.table(stats); + if (options.dryRun) { + console.log('No writes were made. Re-run with --apply to update documents.'); + } else { + console.log('Migration applied.'); + } + } finally { + await app.close(); + } +} + +void main().catch((error: unknown) => { + console.error(error instanceof Error ? error.message : error); + process.exitCode = 1; +});