type LegacySide = 'blue' | 'red'; interface MigrationCollection { find(filter: Record): { limit(limit: number): AsyncIterable; }; bulkWrite( writes: Array<{ updateOne: { filter: { _id: unknown }; update: { $set: Record; $unset: Record }; }; }>, options: { ordered: boolean }, ): Promise; } 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 & { _id: unknown }; export async function migrateTeamIndex( db: MigrationDb, options: MigrationOptions = {}, ): Promise { 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; $unset: Record }; }; }> = []; 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 = {}; const unset: Record = {}; 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 = {}; const unset: Record = {}; 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) { 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 = asArray(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[]) { 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>, ): number | undefined { const wins = new Map(); 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): 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[] { return Array.isArray(value) ? value.filter(isRecord).map((item) => ({ ...item })) : []; } function isRecord(value: unknown): value is Record { 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; }