import { BadRequestException, ConflictException, Injectable, InternalServerErrorException, Logger, NotFoundException, } from '@nestjs/common'; import { createHash, randomUUID } from 'node:crypto'; import mongoose from 'mongoose'; import { CompetitionBootstrapService, type CompetitionBootstrapMatch, } from '../competition/competition-bootstrap.service'; import { CompetitionCommandService, type CompetitionCommandActor, } from '../competition/competition-command.service'; import { MatchStatsService } from '../community-stats/match-stats.service'; import { CommunityStatsService } from '../community-stats/community-stats.service'; import { ConnectionService } from '../global/database/connection.service'; import { type DistributedLockOwnership, DistributedLockService, } from '../global/redis/distributed-lock.service'; import type { LegacyImportJobDocument, Match, MatchDocument, RiotMatch as StoredRiotMatch, UserDocument, } from '../global/database/schema'; import { RedisService } from '../global/redis/redis.service'; import { RIOT_JOB_LOW_STREAM } from '../riot-job-queue/riot-job-queue.types'; import { RiotMatchService } from '../riot/riot-match.service'; import type { RiotMatchDto, RiotRegionalRoute } from '../riot/riot.types'; import { resolveReadyCompetitionSlot, type CompetitionResultSnapshot, } from '../tournament-result/competition-result.adapter'; import type { MatchPuuidLookup } from '../tournament-result/team-mapping.util'; import { buildParticipantsSnapshot, buildTeams, buildUserByPuuidMap, countKnownParticipants, resolveExternalCount, type UserByPuuidMap, } from './match-builder.util'; import { LEGACY_IMPORT_DEFAULT_START_ISO, LEGACY_IMPORT_LOCK_TTL_SECONDS, LEGACY_IMPORT_MEMBER_AVG_SECONDS, type BulkDeleteLegacyMatchesRequest, type LegacyImportMemberJob, type LegacyImportMemberWindowView, type LegacyMatchListResponse, type RebuildLegacyMatchesResponse, type StartLegacyImportRequest, type StartLegacyImportResponse, } from './legacy-import.types'; const MATCH_IMPORT_LOCK_TTL_SECONDS = 60; const MATCH_ID_PAGE_SIZE = 100; type ImportOutcome = 'imported' | 'duplicate' | 'skipped' | 'error'; type ResultlessMatchPatch = Omit< Partial, 'result' | 'doubleElimination' >; @Injectable() export class LegacyImportService { private readonly logger = new Logger(LegacyImportService.name); constructor( private readonly connectionService: ConnectionService, private readonly redisService: RedisService, private readonly riotMatchService: RiotMatchService, private readonly communityStatsService: CommunityStatsService, private readonly matchStatsService: MatchStatsService, private readonly distributedLockService: DistributedLockService, private readonly competitionBootstrapService: CompetitionBootstrapService, private readonly competitionCommandService: CompetitionCommandService, ) {} public async previewMembers(params: { communityId: mongoose.Types.ObjectId; windowStart?: string; windowEnd?: string; }): Promise<{ members: LegacyImportMemberWindowView[] }> { const { windowStart, windowEnd } = this.resolveWindow(params); const users = await this.findImportableUsers(params.communityId); return { members: users.map((user) => this.toMemberWindowView(user, windowStart, windowEnd), ), }; } public async start(params: { communityId: mongoose.Types.ObjectId; triggeredBy: mongoose.Types.ObjectId; body: StartLegacyImportRequest; }): Promise { const lockKey = this.communityLockKey(params.communityId); const jobId = randomUUID(); const communityImportLockOwnership = await this.distributedLockService.acquireLock({ lockKey, lockOwnershipToken: jobId, lockExpirationDurationMilliseconds: LEGACY_IMPORT_LOCK_TTL_SECONDS * 1000, }); if (!communityImportLockOwnership) { throw new ConflictException('Legacy import is already running.'); } try { const CommunityModel = await this.connectionService.getModel('community'); const community = await CommunityModel.findById(params.communityId) .select({ riotRegion: 1 }) .lean() .exec(); if (!community) throw new NotFoundException('Community not found.'); const { windowStart, windowEnd } = this.resolveWindow({ windowStart: params.body.windowStart, windowEnd: params.body.windowEnd, }); const users = await this.findImportableUsers(params.communityId); const overrides = new Map( (params.body.memberOverrides ?? []).map((override) => [ override.userId, override, ]), ); const windows = users .map((user) => this.resolveMemberWindow(user, windowStart, windowEnd, overrides), ) .filter( (window) => window.startTime.getTime() <= window.endTime.getTime(), ); const LegacyImportJobModel = await this.connectionService.getModel('legacyImportJob'); await LegacyImportJobModel.create({ jobId, communityId: params.communityId, triggeredBy: params.triggeredBy, startedAt: new Date(), state: 'running', windowStart, windowEnd, memberOverrides: windows, totalMembers: windows.length, processedMembers: 0, totalDiscoveredMatchIds: 0, totalImportedMatches: 0, totalSkippedDuplicate: 0, totalErrors: 0, averageMemberSeconds: LEGACY_IMPORT_MEMBER_AVG_SECONDS, completedMemberJobIds: [], }); for (const window of windows) { const job: LegacyImportMemberJob = { kind: 'legacy-import-member', jobId: randomUUID(), parentJobId: jobId, communityId: params.communityId.toString(), userId: window.userId.toString(), puuid: window.puuid, startTime: Math.floor(window.startTime.getTime() / 1000), endTime: Math.floor(window.endTime.getTime() / 1000), triggeredBy: params.triggeredBy.toString(), region: community.riotRegion ?? 'asia', }; await this.redisService.appendStream( RIOT_JOB_LOW_STREAM, { job: JSON.stringify(job) }, { maxLen: 10_000 }, ); } if (windows.length === 0) { await LegacyImportJobModel.updateOne( { jobId }, { $set: { state: 'completed', completedAt: new Date() } }, ).exec(); await this.releaseDistributedLockSafely(communityImportLockOwnership); } return { jobId, totalMembers: windows.length, etaSeconds: windows.length * LEGACY_IMPORT_MEMBER_AVG_SECONDS, }; } catch (error) { await this.releaseDistributedLockSafely(communityImportLockOwnership); throw error; } } public async listJobs(params: { communityId: mongoose.Types.ObjectId; limit?: number; }): Promise<{ jobs: LegacyImportJobDocument[] }> { const LegacyImportJobModel = await this.connectionService.getModel('legacyImportJob'); const jobs = await LegacyImportJobModel.find({ communityId: params.communityId, }) .sort({ startedAt: -1 }) .limit(Math.min(params.limit ?? 10, 50)) .exec(); return { jobs }; } public async getJob(params: { communityId: mongoose.Types.ObjectId; jobId: string; }): Promise { const LegacyImportJobModel = await this.connectionService.getModel('legacyImportJob'); const job = await LegacyImportJobModel.findOne({ communityId: params.communityId, jobId: params.jobId, }).exec(); if (!job) throw new NotFoundException('Legacy import job not found.'); return job; } public async cancel(params: { communityId: mongoose.Types.ObjectId; jobId: string; }): Promise { const LegacyImportJobModel = await this.connectionService.getModel('legacyImportJob'); const job = await LegacyImportJobModel.findOneAndUpdate( { communityId: params.communityId, jobId: params.jobId, state: { $in: ['pending', 'running'] }, }, { $set: { state: 'cancelled', completedAt: new Date() } }, { returnDocument: 'after' }, ).exec(); if (!job) throw new NotFoundException('Running legacy import job not found.'); await this.distributedLockService.releaseLockIfOwned({ lockKey: this.communityLockKey(params.communityId), lockOwnershipToken: job.jobId, lockExpirationDurationMilliseconds: LEGACY_IMPORT_LOCK_TTL_SECONDS * 1000, }); return job; } public async processMemberJob(job: LegacyImportMemberJob): Promise { const started = Date.now(); const legacyJob = await this.getRunnableJob(job); if (!legacyJob) return; if (legacyJob.completedMemberJobIds?.includes(job.jobId)) return; let discovered = 0; let imported = 0; let duplicates = 0; let errors = 0; try { const userByPuuid = await this.buildUserByPuuidMap( new mongoose.Types.ObjectId(job.communityId), ); const matchIds = await this.collectMatchIds(job); discovered = matchIds.size; for (const matchId of matchIds) { if (await this.isCancelled(job.parentJobId)) break; const outcome = await this.importSingleMatch(matchId, job, userByPuuid); if (outcome === 'imported') imported += 1; if (outcome === 'duplicate') duplicates += 1; if (outcome === 'error') errors += 1; } } catch (error) { errors += 1; await this.recordError(job.parentJobId, { puuid: job.puuid, reason: error instanceof Error ? error.message : String(error), }); this.logger.warn( `Legacy import member job failed ${job.jobId}: ${ error instanceof Error ? error.message : error }`, ); } finally { await this.finishMemberJob(job, { discovered, imported, duplicates, errors, elapsedSeconds: Math.max(1, Math.round((Date.now() - started) / 1000)), }); } } public async listLegacyMatches(params: { communityId: mongoose.Types.ObjectId; cursor?: number; limit?: number; }): Promise { const MatchModel = await this.connectionService.getModel('match'); const limit = Math.max(1, Math.min(params.limit ?? 30, 100)); const filter: Record = { communityId: params.communityId, legacyImported: true, }; if (params.cursor) { filter.scheduledAt = { $lt: new Date(params.cursor) }; } const matches = await MatchModel.find(filter) .sort({ scheduledAt: -1 }) .limit(limit + 1) .exec(); const visible = matches.slice(0, limit); const competitionByMatchId = await this.loadCompetitionByMatchId( visible.map(({ _id }) => _id), ); const summaryByMatchId = new Map( visible.map((match) => [ match._id.toString(), summarizeCompetitionResult( competitionByMatchId.get(match._id.toString()), ) ?? summarizeLegacyMatchResult(match), ]), ); const riotMatchIds = [...summaryByMatchId.values()] .map(({ riotMatchId }) => riotMatchId) .filter((matchId): matchId is string => Boolean(matchId)); const RiotMatchModel = await this.connectionService.getModel('riotMatch'); const rawDocs = await RiotMatchModel.find({ matchId: { $in: riotMatchIds }, }) .lean() .exec(); const rawById = new Map( rawDocs.map((doc) => [doc.matchId, doc.raw as unknown as RiotMatchDto]), ); const userByPuuid = await this.buildUserByPuuidMap(params.communityId); return { matches: visible.map((match) => { const summary = summaryByMatchId.get(match._id.toString())!; const riotMatchId = summary.riotMatchId; const raw = riotMatchId ? rawById.get(riotMatchId) : undefined; return { matchId: match._id.toString(), title: match.title, scheduledAt: match.scheduledAt.toISOString(), riotMatchId, memberCount: summary.memberCount, externalCount: raw ? resolveExternalCount(raw, userByPuuid) : Math.max(0, 10 - summary.memberCount), teamAIndex: summary.teamAIndex, teamBIndex: summary.teamBIndex, teamAWins: summary.teamAWins, teamBWins: summary.teamBWins, winnerTeamIndex: summary.winnerTeamIndex, }; }), nextCursor: matches.length > limit ? (visible[visible.length - 1]?.scheduledAt.getTime() ?? null) : null, }; } public async bulkDeleteLegacyMatches(params: { communityId: mongoose.Types.ObjectId; body: BulkDeleteLegacyMatchesRequest; }): Promise<{ deleted: number }> { const ids = (params.body.matchIds ?? []) .filter((id) => mongoose.isValidObjectId(id)) .map((id) => new mongoose.Types.ObjectId(id)); if (ids.length === 0) return { deleted: 0 }; const [ MatchModel, CompetitionModel, CompetitionFactModel, CompetitionOutboxModel, AssignmentModel, TournamentCodeModel, MatchStatsModel, connection, ] = await Promise.all([ this.connectionService.getModel('match'), this.connectionService.getModel('competition'), this.connectionService.getModel('competitionFact'), this.connectionService.getModel('competitionOutbox'), this.connectionService.getModel('tournamentCodeAssignment'), this.connectionService.getModel('tournamentCode'), this.connectionService.getModel('matchStats'), this.connectionService.getConnection(), ]); const session = await this.connectionService.createSession(); if (!session) { throw new InternalServerErrorException( 'A MongoDB transaction is required to delete legacy Matches.', ); } let deleted = 0; try { session.startTransaction(); const targets = await MatchModel.find({ _id: { $in: ids }, communityId: params.communityId, legacyImported: true, }) .select({ _id: 1 }) .session(session) .exec(); const targetIds = targets.map((match) => match._id); if (targetIds.length === 0) { await session.commitTransaction(); } else { const competitions = await CompetitionModel.find({ matchId: { $in: targetIds }, }) .select({ _id: 1 }) .session(session) .lean() .exec(); const competitionIds = competitions.map(({ _id }) => _id); if (competitionIds.length > 0) { const assignments = await AssignmentModel.find({ competitionId: { $in: competitionIds }, state: { $in: ['reserved', 'used'] }, }) .select({ tournamentCodeId: 1, state: 1 }) .session(session) .lean() .exec(); const assignmentCodeIds = assignments.map( ({ tournamentCodeId }) => tournamentCodeId, ); const uniqueAssignmentCodeIds = new Set( assignmentCodeIds.map((id) => id.toString()), ); if (uniqueAssignmentCodeIds.size !== assignmentCodeIds.length) { throw new ConflictException( 'Tournament Code assignments contain a duplicate active code identity.', ); } const tournamentCodes = assignmentCodeIds.length === 0 ? [] : await TournamentCodeModel.find({ _id: { $in: assignmentCodeIds }, }) .select({ _id: 1, state: 1, matchId: 1 }) .session(session) .lean() .exec(); const tournamentCodeById = new Map( tournamentCodes.map((code) => [code._id.toString(), code]), ); const targetIdSet = new Set(targetIds.map((id) => id.toString())); for (const assignment of assignments) { const code = tournamentCodeById.get( assignment.tournamentCodeId.toString(), ); if ( !code || code.state !== assignment.state || !code.matchId || !targetIdSet.has(code.matchId.toString()) ) { throw new ConflictException( 'Tournament Code assignment ownership or state does not match the target legacy Match.', ); } } const releasedCodeIds = assignments .filter(({ state }) => state === 'reserved') .map(({ tournamentCodeId }) => tournamentCodeId); const voidedCodeIds = assignments .filter(({ state }) => state === 'used') .map(({ tournamentCodeId }) => tournamentCodeId); const terminalAt = new Date(); if (releasedCodeIds.length > 0) { const released = await TournamentCodeModel.updateMany( { _id: { $in: releasedCodeIds }, matchId: { $in: targetIds }, state: 'reserved', }, { $set: { state: 'released', releasedAt: terminalAt }, $unset: legacyTournamentCodeBindingUnset(), }, ) .session(session) .exec(); assertExactTournamentCodeTransition( released, releasedCodeIds.length, ); } if (voidedCodeIds.length > 0) { const voided = await TournamentCodeModel.updateMany( { _id: { $in: voidedCodeIds }, matchId: { $in: targetIds }, state: 'used', }, { $set: { state: 'voided', voidedAt: terminalAt }, $unset: legacyTournamentCodeBindingUnset(), }, ) .session(session) .exec(); assertExactTournamentCodeTransition(voided, voidedCodeIds.length); } await CompetitionFactModel.deleteMany({ competitionId: { $in: competitionIds }, }) .session(session) .exec(); await CompetitionOutboxModel.deleteMany({ competitionId: { $in: competitionIds }, }) .session(session) .exec(); await AssignmentModel.deleteMany({ competitionId: { $in: competitionIds }, }) .session(session) .exec(); await CompetitionModel.deleteMany({ _id: { $in: competitionIds }, }) .session(session) .exec(); } await connection .collection('competition_migration_quarantine') .deleteMany({ _id: { $in: targetIds } }, { session }); const result = await MatchModel.deleteMany({ _id: { $in: targetIds }, communityId: params.communityId, legacyImported: true, }) .session(session) .exec(); await MatchStatsModel.deleteMany({ matchId: { $in: targetIds } }) .session(session) .exec(); deleted = result.deletedCount ?? 0; await session.commitTransaction(); } } catch (error) { await session.abortTransaction().catch(() => undefined); throw error; } finally { await session.endSession().catch(() => undefined); } await this.communityStatsService.invalidateCommunity(params.communityId); return { deleted }; } public async rebuildLegacyMatches(params: { communityId: mongoose.Types.ObjectId; }): Promise { const MatchModel = await this.connectionService.getModel('match'); const matches = await MatchModel.find({ communityId: params.communityId, legacyImported: true, }).exec(); const competitionByMatchId = await this.loadCompetitionByMatchId( matches.map(({ _id }) => _id), ); const summaryByMatchId = new Map( matches.map((match) => [ match._id.toString(), summarizeCompetitionResult( competitionByMatchId.get(match._id.toString()), ) ?? summarizeLegacyMatchResult(match), ]), ); const riotMatchIds = [...summaryByMatchId.values()] .map(({ riotMatchId }) => riotMatchId) .filter((matchId): matchId is string => Boolean(matchId)); const RiotMatchModel = await this.connectionService.getModel('riotMatch'); const rawDocs = await RiotMatchModel.find({ matchId: { $in: riotMatchIds }, }) .lean() .exec(); const rawById = new Map(); for (const doc of rawDocs) { if (isRiotMatchDto(doc.raw)) rawById.set(doc.matchId, doc.raw); } const userByPuuid = await this.buildUserByPuuidMap(params.communityId); const result: RebuildLegacyMatchesResponse = { scanned: matches.length, rebuilt: 0, normalizedTitles: 0, skippedMissingRaw: 0, skippedNoKnownParticipants: 0, }; for (const match of matches) { const existingCompetition = competitionByMatchId.get( match._id.toString(), ); const summary = summaryByMatchId.get(match._id.toString())!; const riotMatchId = summary.riotMatchId; const raw = riotMatchId ? rawById.get(riotMatchId) : undefined; const title = this.normalizeLegacyTitle( match.title, raw?.info.gameCreation ?? match.scheduledAt.getTime(), ); const update: ResultlessMatchPatch = {}; if (title !== match.title) { update.title = title; result.normalizedTitles += 1; } if (!raw || !riotMatchId) { result.skippedMissingRaw += 1; if (Object.keys(update).length > 0) { await MatchModel.updateOne( { _id: match._id }, { $set: update }, ).exec(); await this.rebuildMatchStats( match._id, competitionRevision(existingCompetition), ); } continue; } const participants = buildParticipantsSnapshot(raw, userByPuuid); const teams = buildTeams(raw, userByPuuid); const counts = countKnownParticipants(raw, userByPuuid); if ( !hasDecisiveRiotWinner(raw) || !hasTrustedCompetitionRoster(counts, participants, teams) ) { result.skippedNoKnownParticipants += 1; if (Object.keys(update).length > 0) { await MatchModel.updateOne( { _id: match._id }, { $set: update }, ).exec(); await this.rebuildMatchStats( match._id, competitionRevision(existingCompetition), ); } continue; } update.mapId = raw.info.mapId ?? match.mapId; update.participants = participants; update.teams = teams; update.gameMode = 'pair'; update.gameCount = 1; update.teamBuiltAt = match.teamBuiltAt ?? new Date(raw.info.gameCreation); await MatchModel.updateOne( { _id: match._id, communityId: params.communityId, legacyImported: true, }, { $set: update }, ).exec(); let sourceRevision = competitionRevision(existingCompetition); if (!summarizeCompetitionResult(existingCompetition)) { const updatedMatch = { ...toPlainRecord(match), ...update, _id: match._id, communityId: match.communityId, } as unknown as MatchDocument; sourceRevision = (await this.acceptRiotCompetitionFact({ match: updatedMatch, detail: raw, actor: { type: 'system' }, })) ?? undefined; } if (sourceRevision === undefined) { result.skippedNoKnownParticipants += 1; continue; } await MatchModel.updateOne( { _id: match._id }, { $set: { status: 'finished' } }, ).exec(); await this.rebuildMatchStats(match._id, sourceRevision); result.rebuilt += 1; } if (result.rebuilt > 0 || result.normalizedTitles > 0) { await this.communityStatsService.invalidateCommunity(params.communityId); } return result; } private async loadCompetitionByMatchId( matchIds: mongoose.Types.ObjectId[], ): Promise> { if (matchIds.length === 0) return new Map(); const CompetitionModel = await this.connectionService.getModel('competition'); const competitions = await CompetitionModel.find({ matchId: { $in: matchIds }, }) .lean() .exec(); return new Map( competitions.map((competition) => [ competition.matchId.toString(), competition, ]), ); } private rebuildMatchStats( matchId: mongoose.Types.ObjectId, sourceRevision?: number, ): Promise { return this.matchStatsService .buildAndUpsert(matchId, { ...(sourceRevision === undefined ? {} : { sourceRevision }), }) .catch((error: unknown) => { this.logger.warn( `Failed to rebuild legacy Match stats ${matchId.toString()}${ sourceRevision === undefined ? '' : ` at Competition revision ${sourceRevision}` }: ${error instanceof Error ? error.message : String(error)}`, ); }); } private async collectMatchIds( job: LegacyImportMemberJob, ): Promise> { const matchIds = new Set(); let start = 0; while (true) { const ids = await this.riotMatchService.getMatchIdsByPuuid(job.puuid, { region: job.region, type: 'tourney', startTime: job.startTime, endTime: job.endTime, start, count: MATCH_ID_PAGE_SIZE, }); ids.forEach((matchId) => matchIds.add(matchId)); if (ids.length < MATCH_ID_PAGE_SIZE) break; start += MATCH_ID_PAGE_SIZE; } return matchIds; } private async importSingleMatch( riotMatchId: string, job: LegacyImportMemberJob, userByPuuid: UserByPuuidMap, ): Promise { const lockKey = `legacy-import:match:${riotMatchId}`; try { const importOutcome = await this.distributedLockService.runWithLock( { lockKey, lockExpirationDurationMilliseconds: MATCH_IMPORT_LOCK_TTL_SECONDS * 1000, }, async () => { const CompetitionFactModel = await this.connectionService.getModel('competitionFact'); const existing = await CompetitionFactModel.exists({ type: 'game-accepted', 'evidence.type': 'riot', 'evidence.riotMatchId': riotMatchId, }); if (existing) return 'duplicate'; const detail = await this.ensureRiotMatchPersisted( riotMatchId, job.region, ); if (!detail.info.tournamentCode) return 'skipped'; const counts = countKnownParticipants(detail, userByPuuid); const participants = buildParticipantsSnapshot(detail, userByPuuid); const teams = buildTeams(detail, userByPuuid); if ( !hasDecisiveRiotWinner(detail) || !hasTrustedCompetitionRoster(counts, participants, teams) ) { return 'skipped'; } const matchPayload: ResultlessMatchPatch = { communityId: new mongoose.Types.ObjectId(job.communityId), title: this.formatLegacyDate(detail.info.gameCreation), description: 'Legacy import (자동 생성)', mapId: detail.info.mapId ?? 11, status: 'team-built', scheduledAt: new Date(detail.info.gameCreation), maxParticipants: 10, gameCount: 1, gameMode: 'pair', tournamentCodeIds: [], gameSchedule: [], teamBuiltAt: new Date(detail.info.gameCreation), hostUserId: new mongoose.Types.ObjectId(job.triggeredBy), participants, teams, legacyImported: true, legacyImportSource: { importedAt: new Date(), importedBy: new mongoose.Types.ObjectId(job.triggeredBy), triggeringPuuid: job.puuid, jobId: job.parentJobId, }, prizes: [], notices: [], schedule: [], }; const MatchModel = await this.connectionService.getModel('match'); const match = await MatchModel.findOneAndUpdate( { _id: deterministicObjectId(`legacy-import:match:${riotMatchId}`), }, { $setOnInsert: matchPayload }, { upsert: true, returnDocument: 'after', setDefaultsOnInsert: true, runValidators: true, }, ).exec(); if (!match) throw new Error('Legacy Match upsert returned no document.'); const sourceRevision = await this.acceptRiotCompetitionFact({ match, detail, actor: { type: 'migration', migrationRunId: job.parentJobId, }, }); if (sourceRevision === null) return 'skipped'; await MatchModel.updateOne( { _id: match._id }, { $set: { status: 'finished' } }, ).exec(); await this.rebuildMatchStats(match._id, sourceRevision); return 'imported'; }, ); if (importOutcome === null) return 'duplicate'; return importOutcome; } catch (error) { await this.recordError(job.parentJobId, { puuid: job.puuid, matchId: riotMatchId, reason: error instanceof Error ? error.message : String(error), }); return 'error'; } } private async acceptRiotCompetitionFact(params: { match: MatchDocument; detail: RiotMatchDto; actor: CompetitionCommandActor; }): Promise { const competitionDocument = await this.competitionBootstrapService.bootstrap( params.match as unknown as CompetitionBootstrapMatch, ); const competition = toCompetitionResultSnapshot(competitionDocument); const mapped = resolveReadyCompetitionSlot({ competition, detail: params.detail, lookup: buildMatchPuuidLookup(params.match), }); if (!mapped) return null; const accepted = await this.competitionCommandService.acceptGame({ competitionId: competition.competitionId, expectedRevision: competition.revision, idempotencyKey: `legacy-import:riot:${params.detail.metadata.matchId}`, actor: params.actor, occurredAt: mapped.occurredAt, gameId: mapped.gameId, seriesId: mapped.seriesId, gameSlotId: mapped.gameSlotId, ordinal: mapped.ordinal, evidence: mapped.evidence, mapping: mapped.mapping, startedAt: mapped.startedAt, durationSeconds: mapped.durationSeconds, participants: mapped.normalizedParticipants, }); return accepted.revision; } private async ensureRiotMatchPersisted( riotMatchId: string, region: RiotRegionalRoute, ): Promise { const RiotMatchModel = await this.connectionService.getModel('riotMatch'); const stored = await RiotMatchModel.findOne({ matchId: riotMatchId, }).exec(); if (isRiotMatchDto(stored?.raw)) return stored.raw; const dto = await this.riotMatchService.getMatch(riotMatchId, { region }); const payload: Partial = { matchId: dto.metadata.matchId, gameCreation: dto.info.gameCreation, gameDuration: dto.info.gameDuration, gameVersion: dto.info.gameVersion, queueId: dto.info.queueId, participantPuuids: dto.metadata.participants, raw: dto as unknown as Record, fetchedAt: new Date(), }; await RiotMatchModel.updateOne( { matchId: dto.metadata.matchId }, { $set: payload }, { upsert: true }, ).exec(); return dto; } private async finishMemberJob( job: LegacyImportMemberJob, stats: { discovered: number; imported: number; duplicates: number; errors: number; elapsedSeconds: number; }, ): Promise { const LegacyImportJobModel = await this.connectionService.getModel('legacyImportJob'); const current = await LegacyImportJobModel.findOne({ jobId: job.parentJobId, }).exec(); if (!current || current.state === 'cancelled') return; if (current.completedMemberJobIds?.includes(job.jobId)) return; const average = current.averageMemberSeconds === undefined ? stats.elapsedSeconds : Math.round( current.averageMemberSeconds * 0.7 + stats.elapsedSeconds * 0.3, ); const updateResult = await LegacyImportJobModel.updateOne( { jobId: job.parentJobId, completedMemberJobIds: { $ne: job.jobId }, state: { $ne: 'cancelled' }, }, { $set: { averageMemberSeconds: average, }, $inc: { processedMembers: 1, totalDiscoveredMatchIds: stats.discovered, totalImportedMatches: stats.imported, totalSkippedDuplicate: stats.duplicates, totalErrors: stats.errors, }, $addToSet: { completedMemberJobIds: job.jobId, }, }, ).exec(); if (updateResult.modifiedCount === 0) return; const updated = await LegacyImportJobModel.findOne({ jobId: job.parentJobId, }) .select({ processedMembers: 1, totalMembers: 1, state: 1, completedAt: 1, }) .lean() .exec(); const completed = Boolean( updated && updated.state !== 'cancelled' && updated.processedMembers >= updated.totalMembers, ); if (completed) { await LegacyImportJobModel.updateOne( { jobId: job.parentJobId, state: { $ne: 'cancelled' }, }, { $set: { state: 'completed', completedAt: updated?.completedAt ?? new Date(), }, }, ).exec(); } if (completed) { await Promise.all([ this.distributedLockService.releaseLockIfOwned({ lockKey: this.communityLockKey( new mongoose.Types.ObjectId(job.communityId), ), lockOwnershipToken: job.parentJobId, lockExpirationDurationMilliseconds: LEGACY_IMPORT_LOCK_TTL_SECONDS * 1000, }), this.communityStatsService.invalidateCommunity( new mongoose.Types.ObjectId(job.communityId), ), ]); } } private async getRunnableJob( job: LegacyImportMemberJob, ): Promise { const LegacyImportJobModel = await this.connectionService.getModel('legacyImportJob'); const legacyJob = await LegacyImportJobModel.findOne({ jobId: job.parentJobId, }).exec(); if (!legacyJob || legacyJob.state === 'cancelled') return null; if (legacyJob.state === 'completed' || legacyJob.state === 'failed') return null; return legacyJob; } private async releaseDistributedLockSafely( lockOwnership: DistributedLockOwnership, ): Promise { await this.distributedLockService .releaseLockIfOwned(lockOwnership) .catch((error: unknown) => { this.logger.warn( `Failed to release legacy import lock ${lockOwnership.lockKey}: ${ error instanceof Error ? error.message : String(error) }`, ); }); } private async isCancelled(parentJobId: string): Promise { const LegacyImportJobModel = await this.connectionService.getModel('legacyImportJob'); const job = await LegacyImportJobModel.findOne({ jobId: parentJobId }) .select({ state: 1 }) .lean() .exec(); return job?.state === 'cancelled'; } private async recordError( jobId: string, error: { puuid?: string; matchId?: string; reason: string }, ): Promise { const LegacyImportJobModel = await this.connectionService.getModel('legacyImportJob'); await LegacyImportJobModel.updateOne( { jobId }, { $push: { errors: { ...error, at: new Date(), }, }, }, ).exec(); } private async buildUserByPuuidMap( communityId: mongoose.Types.ObjectId, ): Promise { const users = await this.findImportableUsers(communityId); return buildUserByPuuidMap(users); } private async findImportableUsers( communityId: mongoose.Types.ObjectId, ): Promise { const UserModel = await this.connectionService.getModel('user'); return UserModel.find({ communityId, 'riotAccounts.0': { $exists: true }, }).exec(); } private toMemberWindowView( user: UserDocument, windowStart: Date, windowEnd: Date, ): LegacyImportMemberWindowView { const resolved = this.resolveMemberWindow( user, windowStart, windowEnd, new Map(), ); const account = user.riotAccounts.find((riotAccount) => riotAccount.isPrimary) ?? user.riotAccounts[0]; return { userId: user._id.toString(), puuid: account.puuid, displayName: user.kakaoTalkNickname ?? user.discordNickname ?? account.gameName ?? user._id.toString(), gameName: account.gameName, tagLine: account.tagLine, profileIconId: account.profileIconId, isActivated: user.isActivated, startTime: resolved.startTime.toISOString(), endTime: resolved.endTime.toISOString(), }; } private resolveMemberWindow( user: UserDocument, windowStart: Date, windowEnd: Date, overrides: Map, ) { const account = user.riotAccounts.find((riotAccount) => riotAccount.isPrimary) ?? user.riotAccounts[0]; if (!account) throw new BadRequestException('Riot account not found.'); const override = overrides.get(user._id.toString()); const overrideStart = this.parseOptionalDate(override?.startTime); const overrideEnd = this.parseOptionalDate(override?.endTime); const activeEnd = user.isActivated ? windowEnd : user.updatedAt; const startTime = overrideStart ?? windowStart; const endTime = this.minDate(windowEnd, activeEnd, overrideEnd); return { userId: user._id, puuid: account.puuid, startTime, endTime, }; } private resolveWindow(params: { windowStart?: string; windowEnd?: string }) { const windowStart = this.parseOptionalDate(params.windowStart) ?? new Date(LEGACY_IMPORT_DEFAULT_START_ISO); const windowEnd = this.parseOptionalDate(params.windowEnd) ?? new Date(); if (windowStart.getTime() > windowEnd.getTime()) { throw new BadRequestException('windowStart must be before windowEnd.'); } return { windowStart, windowEnd }; } private parseOptionalDate(value: string | undefined): Date | undefined { if (!value) return undefined; const parsed = new Date(value); if (Number.isNaN(parsed.getTime())) { throw new BadRequestException('Invalid date.'); } return parsed; } private minDate(...values: Array): Date { return new Date( Math.min(...values.filter(Boolean).map((date) => date!.getTime())), ); } private normalizeLegacyTitle(title: string, gameCreation: number): string { const stripped = title.replace(/^\[(?:legacy|lagacy)\]\s*/i, '').trim(); return stripped || this.formatLegacyDate(gameCreation); } private formatLegacyDate(gameCreation: number): string { return new Intl.DateTimeFormat('ko-KR', { timeZone: 'Asia/Seoul', year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', }).format(new Date(gameCreation)); } private communityLockKey(communityId: mongoose.Types.ObjectId): string { return `legacy-import:lock:${communityId.toString()}`; } } function isRiotMatchDto(value: unknown): value is RiotMatchDto { return Boolean( value && typeof value === 'object' && 'metadata' in value && 'info' in value, ); } interface LegacyResultSummary { riotMatchId: string | null; memberCount: number; teamAIndex: number; teamBIndex: number; teamAWins: number; teamBWins: number; winnerTeamIndex?: number; } function summarizeCompetitionResult( value: unknown, ): LegacyResultSummary | null { if (!value) return null; const competition = toPlainRecord(value); const projection = toRecord(competition.projection); const games = toArray(projection.games).map(toRecord); const game = games.find((candidate) => { const evidence = toRecord(candidate.evidence); return evidence.type === 'riot' && typeof evidence.riotMatchId === 'string'; }); if (!game) return null; const evidence = toRecord(game.evidence); const series = toArray(projection.series) .map(toRecord) .find( (candidate) => idString(candidate.seriesId) === idString(game.seriesId), ); const entries = toArray(series?.entries).map(toRecord); const teamIndexById = new Map( toArray(competition.teams).map((teamValue) => { const team = toRecord(teamValue); return [ idString(team.teamId), optionalNumber(team.legacyTeamIndex) ?? numberValue(team.displayOrder), ]; }), ); const teamA = entries.find((entry) => entry.slot === 'A'); const teamB = entries.find((entry) => entry.slot === 'B'); const teamAId = idString(teamA?.teamId); const teamBId = idString(teamB?.teamId); const winnerTeamId = idString(toRecord(series?.outcome).winnerTeamId) || idString(game.winnerTeamId); return { riotMatchId: String(evidence.riotMatchId), memberCount: toArray(game.participants).filter( (participant) => idString(toRecord(participant).userId).length > 0, ).length, teamAIndex: teamIndexById.get(teamAId) ?? 1, teamBIndex: teamIndexById.get(teamBId) ?? 2, teamAWins: numberValue(teamA?.gameWins), teamBWins: numberValue(teamB?.gameWins), ...(teamIndexById.has(winnerTeamId) ? { winnerTeamIndex: teamIndexById.get(winnerTeamId) } : {}), }; } function summarizeLegacyMatchResult(match: MatchDocument): LegacyResultSummary { const series = match.result?.seriesResults?.[0]; const game = match.result?.games?.[0]; return { riotMatchId: game?.riotMatchId ?? match.result?.riotMatchIds?.[0] ?? null, memberCount: game?.participants.length ?? 0, teamAIndex: series?.teamAIndex ?? 1, teamBIndex: series?.teamBIndex ?? 2, teamAWins: series?.teamAWins ?? 0, teamBWins: series?.teamBWins ?? 0, ...(match.result?.winnerTeamIndex === undefined ? {} : { winnerTeamIndex: match.result.winnerTeamIndex }), }; } function competitionRevision(value: unknown): number | undefined { return value ? optionalNumber(toPlainRecord(value).revision) : undefined; } function hasDecisiveRiotWinner(detail: RiotMatchDto): boolean { return ( detail.info.teams.filter( ({ teamId, win }) => win && (teamId === 100 || teamId === 200), ).length === 1 ); } function hasTrustedCompetitionRoster( counts: { team100: number; team200: number; total: number }, participants: Match['participants'], teams: Match['teams'], ): boolean { if ( counts.total < 6 || counts.team100 !== counts.team200 || counts.team100 === 0 || teams.length !== 2 || teams.some((team) => team.members.length !== counts.team100) ) { return false; } const userIds = participants.map(({ userId }) => userId.toString()); return ( userIds.length === counts.total && new Set(userIds).size === userIds.length ); } function buildMatchPuuidLookup(match: MatchDocument): MatchPuuidLookup { const puuidByUserId = new Map(); const userIdByPuuid = new Map(); for (const participant of match.participants) { if (!participant.puuid) continue; puuidByUserId.set(participant.userId.toString(), participant.puuid); userIdByPuuid.set(participant.puuid, participant.userId); } return { puuidByUserId, userIdByPuuid }; } function toCompetitionResultSnapshot( value: unknown, ): CompetitionResultSnapshot { const raw = toPlainRecord(value); const projection = toRecord(raw.projection); return { competitionId: idString(raw._id), revision: numberValue(raw.revision), phase: String(raw.phase) as CompetitionResultSnapshot['phase'], teams: toArray(raw.teams).map((teamValue) => { const team = toRecord(teamValue); return { teamId: idString(team.teamId), members: toArray(team.members).map((memberValue) => ({ userId: idString(toRecord(memberValue).userId), })), }; }), projection: { phase: String( projection.phase, ) as CompetitionResultSnapshot['projection']['phase'], series: toArray(projection.series).map((seriesValue) => { const series = toRecord(seriesValue); return { seriesId: idString(series.seriesId), status: String( series.status, ) as CompetitionResultSnapshot['projection']['series'][number]['status'], entries: toArray(series.entries).map((entryValue) => { const entry = toRecord(entryValue); return { slot: String(entry.slot) as 'A' | 'B', teamId: entry.teamId == null ? null : idString(entry.teamId), gameWins: numberValue(entry.gameWins), }; }), }; }), gameSlots: toArray(projection.gameSlots).map((slotValue) => { const slot = toRecord(slotValue); return { id: idString(slot.id), seriesId: idString(slot.seriesId), ordinal: numberValue(slot.ordinal), displayNumber: numberValue(slot.displayNumber), status: String( slot.status, ) as CompetitionResultSnapshot['projection']['gameSlots'][number]['status'], }; }), games: toArray(projection.games).map((gameValue) => { const evidence = toRecord(toRecord(gameValue).evidence); return { evidence: { type: typeof evidence.type === 'string' ? evidence.type : undefined, riotMatchId: typeof evidence.riotMatchId === 'string' ? evidence.riotMatchId : undefined, }, }; }), }, }; } function toPlainRecord(value: unknown): Record { if ( value && typeof value === 'object' && 'toObject' in value && typeof value.toObject === 'function' ) { const document = value as { toObject: () => unknown }; return toRecord(document.toObject()); } return toRecord(value); } function toRecord(value: unknown): Record { return value !== null && typeof value === 'object' && !Array.isArray(value) ? (value as Record) : {}; } function toArray(value: unknown): unknown[] { return Array.isArray(value) ? value : []; } function idString(value: unknown): string { if (value instanceof mongoose.Types.ObjectId) return value.toString(); return typeof value === 'string' ? value : ''; } function numberValue(value: unknown): number { return typeof value === 'number' && Number.isFinite(value) ? value : 0; } function optionalNumber(value: unknown): number | undefined { return typeof value === 'number' && Number.isFinite(value) ? value : undefined; } function legacyTournamentCodeBindingUnset(): Record { return { matchId: 1, gameNumber: 1, bracketMatchId: 1, reservedAt: 1, }; } function assertExactTournamentCodeTransition( result: { matchedCount?: number; modifiedCount?: number }, expectedCount: number, ): void { if ( result.matchedCount !== expectedCount || result.modifiedCount !== expectedCount ) { throw new ConflictException( 'Tournament Code transition did not update every validated assignment.', ); } } function deterministicObjectId(key: string): mongoose.Types.ObjectId { return new mongoose.Types.ObjectId( createHash('sha256').update(key).digest('hex').slice(0, 24), ); }