import { BadRequestException, Injectable, InternalServerErrorException, Logger, NotFoundException, } from '@nestjs/common'; import { randomUUID } from 'crypto'; import { performance } from 'perf_hooks'; import mongoose from 'mongoose'; import { ConnectionService } from '../global/database/connection.service'; import { AuctionActionType, AuctionChatMessage, AuctionDocument, AuctionPlayerSnapshot, AuctionTeam, AuctionTopTierThreshold, MatchDocument, MatchParticipant, MatchTeamMember, Position, RiotAccount, } from '../global/database/schema'; import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service'; import type { RiotPlatformRoute, RiotRegionalRoute } from '../riot/riot.types'; import { TournamentCodeService } from '../tournament-code/tournament-code.service'; import { TournamentResultService } from '../tournament-result/tournament-result.service'; import { AuctionRedisCommandService, type AuctionBidCommandResult, } from './redis/auction-redis-command.service'; import { buildAuctionRedisKeys } from './redis/auction-redis.keys'; import { buildAuctionRedisLiveStatePatchFromStructure, buildAuctionRedisStructureState, convertLegacyAuctionTeamsToRedisTeams, stringifyAuctionRedisStructureState, } from './redis/auction-redis-projection'; import { AuctionRedisService } from './redis/auction-redis.service'; import { AuctionRedisStateReaderService } from './redis/auction-redis-state-reader.service'; import { shouldHydrateRedisAuctionState } from './redis/auction-redis.state'; // [AUCTION-DEBUG] 경매 "중복 멤버" 조사용 임시 계측. 조사 종료 후 제거 대상. import { recordNewRelicCustomEvent } from '../global/observability/new-relic'; const AUCTION_MAX_TEAM_SIZE = 5; const AUCTION_MIN_BID_POINTS = 10; const AUCTION_BACKGROUND_ENRICHMENT_CONCURRENCY = 1; const AUCTION_ENRICHMENT_COOLDOWN_MS = 3 * 60 * 60 * 1000; const AUCTION_CHAT_MAX_MESSAGES = 200; const AUCTION_CHAT_MAX_MESSAGE_LENGTH = 300; const AUCTION_CHAT_MAX_DISPLAY_NAME_LENGTH = 24; const AUCTION_MAX_STORED_BID_HISTORY_COUNT = 1000; const AUCTION_MAX_STORED_BID_REQUEST_RESULT_COUNT = 500; const AUCTION_BID_REQUEST_REPLAY_WINDOW_MS = 5 * 60 * 1000; const AUCTION_MAX_STORED_ACTION_REQUEST_RESULT_COUNT = 500; const AUCTION_ACTION_REQUEST_REPLAY_WINDOW_MS = 5 * 60 * 1000; const AUCTION_ACTION_REQUEST_LEASE_DURATION_MS = 15 * 1000; const AUCTION_REHYDRATE_LOCK_TTL_MS = 5 * 1000; const AUCTION_REHYDRATE_LOCK_WAIT_MS = 50; const AUCTION_HISTORY_LIST_LIMIT = 100; const AUCTION_HISTORY_LIST_CACHE_TTL_MS = 2 * 1000; const AUCTION_HISTORY_LIST_CACHE_MAX_ENTRIES = 256; interface StartAuctionParams { matchId: mongoose.Types.ObjectId; communityId: mongoose.Types.ObjectId; startAuctionRequestId: string; actorUserId?: mongoose.Types.ObjectId; captains: { teamIndex: number; userId: mongoose.Types.ObjectId; initialTeamBidPointAmount?: number; }[]; initialTeamBidPointAmount: number; maximumBidRoundDurationSeconds: number; bidRoundExtensionSeconds: number; topTierAuctionPriorityThreshold: AuctionTopTierThreshold; manualTopTierAuctionPriorityUserIds: mongoose.Types.ObjectId[]; } interface PlaceBidParams { matchId: mongoose.Types.ObjectId; teamIndex: number; amount: number; bidRequestId?: string; bidderUserId?: mongoose.Types.ObjectId; clientObservedAuctionLifecycleId?: string; clientObservedCurrentBidRoundPlayerUserId?: string; } interface AuctionStructureActionRequestParams { auctionActionRequestId?: string; clientObservedAuctionLifecycleId?: string; clientObservedCurrentAuctionPlayerOrderIndex?: number; clientObservedCurrentBidRoundPlayerUserId?: string; clientObservedPhase?: string; clientObservedRevision?: number; shouldBroadcastStateAfterDurability?: boolean; } interface MarkSoldParams extends AuctionStructureActionRequestParams { matchId: mongoose.Types.ObjectId; assignedPosition?: Position; } interface ReservedRedisActionRequestContext { actionRequest: { observedProcessingLeaseVersion: number; processingOwnerToken: string; scopeKey: string; }; auctionStateTransitionId: string; expectedAuctionLifecycleId: string; expectedCurrentAuctionPlayerOrderIndex?: number; expectedCurrentBidRoundPlayerUserId?: string; expectedPhase: string; expectedRevision: number; } interface ReplayedRedisActionRequestContext { currentServerTimestampMS: number; replay: true; requiresRefetch: boolean; responseJson?: string; revision?: number; } type RedisActionRequestContext = | ReservedRedisActionRequestContext | ReplayedRedisActionRequestContext; interface AppendChatMessageParams { matchId: mongoose.Types.ObjectId; userId?: mongoose.Types.ObjectId; displayName?: string; message: string; } export interface AuctionHistoryView { sequence: number; action: AuctionActionType; actionLabel: string; takenAt: Date; } interface AuctionHistorySummaryRecord { sequence: number; action: AuctionActionType; takenAt: Date; } interface AuctionHistoryListCacheEntry { entries: AuctionHistoryView[]; expiresAtTimestampMS: number; } export type AuctionStateResponse = AuctionDocument | Record; export interface AuctionBidDeltaResponse { auctionBidHistoryEntry: Record; auctionLifecycleId?: string; bidServerTiming?: AuctionBidServerTiming; bidRequestId: string; currentBidRoundDeadlineTimestampMS: number; currentHighestBidderTeamIndex: number; currentHighestBidPointAmount: number; currentServerTimestampMS: number; revision: number; } export interface AuctionBidServerTiming { fallbackFullStatePath?: boolean; redisBidCommandDurationMS?: number; redisBidContextReadDurationMS?: number; serviceTotalDurationMS?: number; } export interface AuctionBidRejectDiagnostics { currentBidRoundDeadlineTimestampMS?: number; currentServerTimestampMS?: number; } interface AuctionEnrichmentTarget { userId: mongoose.Types.ObjectId; puuid: string; } function isMongoDuplicateKeyError(error: unknown): boolean { return ( typeof error === 'object' && error !== null && Number((error as { code?: unknown }).code) === 11000 ); } @Injectable() export class AuctionService { private readonly logger = new Logger(AuctionService.name); private readonly auctionHistoryListCache = new Map< string, AuctionHistoryListCacheEntry >(); constructor( private readonly connectionService: ConnectionService, private readonly enrichmentService: RiotAccountEnrichmentService, private readonly tournamentCodeService: TournamentCodeService, private readonly tournamentResultService: TournamentResultService, private readonly auctionRedisService: AuctionRedisService, private readonly auctionRedisCommandService: AuctionRedisCommandService, private readonly auctionRedisStateReaderService: AuctionRedisStateReaderService, ) {} public async start(params: StartAuctionParams): Promise { const MatchModel = await this.connectionService.getModel('match'); const UserModel = await this.connectionService.getModel('user'); const AuctionModel = await this.connectionService.getModel('auction'); const AuctionHistoryModel = await this.connectionService.getModel('auctionHistory'); const CommunityModel = await this.connectionService.getModel('community'); const match = await MatchModel.findById(params.matchId); if (!match) throw new NotFoundException('Match not found.'); if (!match.communityId.equals(params.communityId)) { throw new BadRequestException('Match does not belong to this community.'); } const existing = await AuctionModel.findOne({ matchId: params.matchId }); if (existing) { if (existing.startAuctionRequestId === params.startAuctionRequestId) { return existing; } if (this.isRestartableResetRedisAuction(existing)) { await this.clearRedisAuctionRuntimeForLifecycle( params.matchId.toString(), existing.auctionLifecycleId, ); await AuctionHistoryModel.deleteMany({ auctionId: existing._id }); await AuctionModel.deleteOne({ _id: existing._id }); } else if (this.isRedisResetStillApplying(existing)) { throw new BadRequestException( 'Auction reset is still being applied. Please try again shortly.', ); } else { throw new BadRequestException('Auction already exists for this match.'); } } const activeParticipants = this.applyAuctionCut(match); const desiredAuctionCount = activeParticipants.length; if (desiredAuctionCount < 10) { throw new BadRequestException( 'Not enough participants (need at least 10).', ); } const expectedCaptainCount = desiredAuctionCount / AUCTION_MAX_TEAM_SIZE; if (params.captains.length !== expectedCaptainCount) { throw new BadRequestException( `Expected ${expectedCaptainCount} captains for ${desiredAuctionCount} participants.`, ); } this.assertCaptainAssignments( params.captains, activeParticipants, expectedCaptainCount, ); const captainUserIds = params.captains.map((c) => c.userId); const basePlayerUsers = await UserModel.find({ _id: { $in: activeParticipants .filter((p) => !captainUserIds.some((cid) => cid.equals(p.userId))) .map((p) => p.userId), }, }); const community = await CommunityModel.findById(match.communityId) .select({ riotPlatform: 1, riotRegion: 1 }) .lean() .exec(); const platform = community?.riotPlatform ?? 'kr'; const region = community?.riotRegion ?? 'asia'; const enrichCooldownCutoff = Date.now() - AUCTION_ENRICHMENT_COOLDOWN_MS; const enrichTargets = basePlayerUsers.flatMap((user) => { const account = user.riotAccounts.find((entry) => entry.isPrimary) ?? user.riotAccounts[0]; if (!account?.puuid) return []; if (this.wasRecentlyRefreshed(account, enrichCooldownCutoff)) return []; return [{ userId: user._id, puuid: account.puuid }]; }); const userById = new Map(basePlayerUsers.map((u) => [u._id.toString(), u])); const nonCaptainPuuids = new Set(); const order: AuctionPlayerSnapshot[] = []; for (const participant of activeParticipants) { if (captainUserIds.some((cid) => cid.equals(participant.userId))) { continue; } const user = userById.get(participant.userId.toString()); if (!user) continue; const primary = user.riotAccounts.find((a) => a.isPrimary) ?? user.riotAccounts[0]; if (!primary) { throw new BadRequestException( `Participant ${user._id.toString()} has no Riot account.`, ); } if (nonCaptainPuuids.has(primary.puuid)) continue; nonCaptainPuuids.add(primary.puuid); order.push({ userId: user._id, puuid: primary.puuid, gameName: primary.gameName, tagLine: primary.tagLine, profileIconId: primary.profileIconId, preferredPositions: participant.preferredPositions, tiers: primary.tiers, tierHistory: primary.tierHistory ?? [], masteries: primary.championMasteries, recentStatsSummary: primary.recentStatsSummary, passCount: 0, }); } const shuffledOrder = this.shuffleAuctionPlayerOrder(order); const prioritizedOrder = this.applyTopTierPriority( shuffledOrder, params.topTierAuctionPriorityThreshold, params.manualTopTierAuctionPriorityUserIds, ); const auctionId = new mongoose.Types.ObjectId(); const auctionStartedAtTimestampMS = await this.auctionRedisService.getCurrentRedisTimestampMS(); const startAuctionStateTransitionId = `start:${auctionId.toString()}:${params.startAuctionRequestId}`; const auctionLifecycleId = `auction:${auctionId.toString()}:${params.startAuctionRequestId}`; const legacyTeams = params.captains.map((c) => ({ teamIndex: c.teamIndex, captainUserId: c.userId, points: c.initialTeamBidPointAmount ?? params.initialTeamBidPointAmount, members: [], })); const auctionTeams = convertLegacyAuctionTeamsToRedisTeams(legacyTeams); const redisStructureInput = { auctionPlayerOrder: prioritizedOrder, auctionTeams, bidRoundExtensionSeconds: params.bidRoundExtensionSeconds, currentAuctionPlayerOrderIndex: 0, currentAuctionRound: 1, initialTeamBidPointAmount: params.initialTeamBidPointAmount, manualTopTierAuctionPriorityUserIds: params.topTierAuctionPriorityThreshold === 'MANUAL' ? params.manualTopTierAuctionPriorityUserIds : [], maximumBidRoundDurationSeconds: params.maximumBidRoundDurationSeconds, passedAuctionPlayerQueue: [], topTierAuctionPriorityThreshold: params.topTierAuctionPriorityThreshold, }; const structureStateJson = stringifyAuctionRedisStructureState(redisStructureInput); const liveStatePatch = buildAuctionRedisLiveStatePatchFromStructure(redisStructureInput); let auction: AuctionDocument; try { auction = await AuctionModel.create({ _id: auctionId, matchId: params.matchId, phase: 'presenting', revision: 1, auctionEngineVersion: 'redis-v1', auctionLifecycleId, lastAppliedAuctionStateTransitionId: startAuctionStateTransitionId, currentAuctionHistorySequence: 1, startAuctionRequestId: params.startAuctionRequestId, startAuctionStateTransitionId, auctionStartedAtTimestampMS, auctionStartedByUserId: params.actorUserId, matchSideEffectStatus: 'none', matchSideEffectRevision: 0, teams: legacyTeams, order: prioritizedOrder, passedQueue: [], auctionRound: 1, currentIndex: 0, bids: [], currentBid: 0, maxTimerSeconds: params.maximumBidRoundDurationSeconds, bidExtensionSeconds: params.bidRoundExtensionSeconds, initialPoints: params.initialTeamBidPointAmount, topTierThreshold: params.topTierAuctionPriorityThreshold, manualTopTierUserIds: params.topTierAuctionPriorityThreshold === 'MANUAL' ? params.manualTopTierAuctionPriorityUserIds : [], startedAt: new Date(auctionStartedAtTimestampMS), auctionTeams, auctionPlayerOrder: prioritizedOrder, passedAuctionPlayerQueue: [], currentAuctionRound: 1, currentAuctionPlayerOrderIndex: 0, auctionBidHistory: [], currentHighestBidPointAmount: 0, maximumBidRoundDurationSeconds: params.maximumBidRoundDurationSeconds, bidRoundExtensionSeconds: params.bidRoundExtensionSeconds, initialTeamBidPointAmount: params.initialTeamBidPointAmount, topTierAuctionPriorityThreshold: params.topTierAuctionPriorityThreshold, manualTopTierAuctionPriorityUserIds: params.topTierAuctionPriorityThreshold === 'MANUAL' ? params.manualTopTierAuctionPriorityUserIds : [], }); } catch (error) { if (!isMongoDuplicateKeyError(error)) throw error; const raceWinner = await AuctionModel.findOne({ matchId: params.matchId, }); if (raceWinner?.startAuctionRequestId === params.startAuctionRequestId) { return raceWinner; } throw new BadRequestException('Auction already exists for this match.'); } await this.recordSnapshot(auction, 'start'); await this.auctionRedisCommandService.hydrateState( params.matchId.toString(), { auctionHistorySequence: 1, auctionLifecycleId, maximumBidRoundDurationSeconds: params.maximumBidRoundDurationSeconds, liveStatePatch, matchId: params.matchId.toString(), phase: 'presenting', revision: 0, structureStateJson, }, ); match.status = 'team-built'; await match.save(); this.enqueueBackgroundOrderEnrichment({ auctionId: auction._id, targets: enrichTargets, platform, region, }); return auction; } public async getByMatchId( matchId: mongoose.Types.ObjectId, ): Promise { const AuctionModel = await this.connectionService.getModel('auction'); const auction = await AuctionModel.findOne({ matchId }); if (!auction) throw new NotFoundException('Auction not found.'); return auction; } public async getStateByMatchId( matchId: mongoose.Types.ObjectId, ): Promise { const auction = await this.getByMatchId(matchId); if (!this.isRedisV1Auction(auction)) return auction; const redisState = await this.readRedisAuctionStateOrRehydrate(auction); if (!redisState) return auction; const mongoState = typeof auction.toObject === 'function' ? auction.toObject({ depopulate: true }) : auction; return { ...JSON.parse(JSON.stringify(mongoState)), ...redisState, chatMessages: auction.chatMessages ?? [], }; } private async readRedisAuctionStateOrRehydrate( auction: AuctionDocument, ): Promise | null> { const matchId = auction.matchId.toString(); const mongoRevision = auction.revision ?? 0; const mongoAuctionLifecycleId = auction.auctionLifecycleId; if (!mongoAuctionLifecycleId || auction.phase === 'complete') { return this.auctionRedisStateReaderService.readAuctionStateView(matchId); } const liveIdentity = await this.auctionRedisStateReaderService.readLiveStateIdentity(matchId); const shouldHydrate = shouldHydrateRedisAuctionState({ live: liveIdentity, mongo: { auctionLifecycleId: mongoAuctionLifecycleId, revision: mongoRevision, }, }); if (!shouldHydrate) { return this.auctionRedisStateReaderService.readAuctionStateView(matchId); } const keys = buildAuctionRedisKeys(matchId); const lockToken = randomUUID(); const lockAcquired = await this.auctionRedisService.acquireTokenLock( keys.rehydrateLockKey, lockToken, AUCTION_REHYDRATE_LOCK_TTL_MS, ); if (lockAcquired) { try { await this.hydrateRedisStateFromAuctionDocument(auction); } finally { await this.auctionRedisService.releaseTokenLock( keys.rehydrateLockKey, lockToken, ); } } else { await new Promise((resolve) => setTimeout(resolve, AUCTION_REHYDRATE_LOCK_WAIT_MS), ); } return this.auctionRedisStateReaderService.readAuctionStateView(matchId, { shouldForceAuctionStateResync: true, }); } public async appendChatMessage(params: AppendChatMessageParams): Promise<{ auction: AuctionDocument; message: AuctionChatMessage; }> { const auction = await this.getByMatchId(params.matchId); const messageText = this.normalizeChatMessage(params.message); const message: AuctionChatMessage = { id: randomUUID(), userId: params.userId, displayName: this.normalizeChatDisplayName(params.displayName), message: messageText, sentAt: new Date(), }; auction.chatMessages ??= []; auction.chatMessages.push(message); const overflow = auction.chatMessages.length - AUCTION_CHAT_MAX_MESSAGES; if (overflow > 0) { auction.chatMessages.splice(0, overflow); } await auction.save(); return { auction, message }; } public async listHistory(params: { matchId: mongoose.Types.ObjectId; communityId: mongoose.Types.ObjectId; }): Promise { const MatchModel = await this.connectionService.getModel('match'); const AuctionHistoryModel = await this.connectionService.getModel('auctionHistory'); const match = await MatchModel.findById(params.matchId).select({ communityId: 1, }); if (!match) throw new NotFoundException('Match not found.'); if (!match.communityId.equals(params.communityId)) { throw new BadRequestException('Match does not belong to this community.'); } const cacheKey = this.buildAuctionHistoryListCacheKey(params); const cachedHistory = this.getCachedAuctionHistoryList(cacheKey); if (cachedHistory) return cachedHistory; const entries = (await AuctionHistoryModel.find({ matchId: params.matchId }) .select({ _id: 0, action: 1, sequence: 1, takenAt: 1 }) .sort({ sequence: -1 }) .limit(AUCTION_HISTORY_LIST_LIMIT) .lean() .exec()) as AuctionHistorySummaryRecord[]; const history = entries.map((entry) => ({ sequence: entry.sequence, action: entry.action, actionLabel: this.formatHistoryActionLabel(entry.action), takenAt: entry.takenAt, })); this.setCachedAuctionHistoryList(cacheKey, history); return history; } private buildAuctionHistoryListCacheKey(params: { matchId: mongoose.Types.ObjectId; communityId: mongoose.Types.ObjectId; }): string { return `${params.communityId.toString()}:${params.matchId.toString()}`; } private getCachedAuctionHistoryList( cacheKey: string, ): AuctionHistoryView[] | null { const cached = this.auctionHistoryListCache.get(cacheKey); if (!cached) return null; if (cached.expiresAtTimestampMS <= Date.now()) { this.auctionHistoryListCache.delete(cacheKey); return null; } return cached.entries; } private setCachedAuctionHistoryList( cacheKey: string, entries: AuctionHistoryView[], ): void { if ( !this.auctionHistoryListCache.has(cacheKey) && this.auctionHistoryListCache.size >= AUCTION_HISTORY_LIST_CACHE_MAX_ENTRIES ) { const oldestKey = this.auctionHistoryListCache.keys().next().value as | string | undefined; if (oldestKey) this.auctionHistoryListCache.delete(oldestKey); } this.auctionHistoryListCache.set(cacheKey, { entries, expiresAtTimestampMS: Date.now() + AUCTION_HISTORY_LIST_CACHE_TTL_MS, }); } public async openBidding( matchId: mongoose.Types.ObjectId, actionRequest: AuctionStructureActionRequestParams = {}, ): Promise { const auction = await this.getByMatchId(matchId); this.assertLiveAuctionOperationSupported(auction); if (this.isRedisV1Auction(auction)) { return this.openRedisBidding(auction, actionRequest); } if (auction.phase !== 'presenting') { throw new BadRequestException('Auction is not in presenting phase.'); } await this.recordSnapshot(auction, 'open-bidding'); auction.phase = 'bidding'; auction.currentBid = 0; auction.currentBidderTeamIndex = undefined; auction.currentDeadline = this.createDeadline(auction.maxTimerSeconds); await auction.save(); return auction; } public async placeBid(params: PlaceBidParams): Promise { this.assertValidBidPointAmount(params.amount); const auction = await this.getByMatchId(params.matchId); this.assertLiveAuctionOperationSupported(auction); if (this.isRedisV1Auction(auction)) { return this.placeRedisBid(auction, params); } if (auction.phase !== 'bidding') { throw new BadRequestException('Auction is not in bidding phase.'); } const team = this.findAuctionTeamByIndex(auction, params.teamIndex); if (!team) throw new BadRequestException('Unknown team.'); if (params.amount <= auction.currentBid) { throw new BadRequestException('Bid must exceed current bid.'); } if (params.amount > team.points) { throw new BadRequestException('Bid exceeds team points.'); } this.assertTeamHasSlot(team); if (params.amount > this.calculateMaxBidForTeam(team)) { throw new BadRequestException( 'Bid must reserve minimum points for remaining slots.', ); } // 임시 운영용: 클라이언트에서 선택한 팀장 모드를 신뢰하고 실제 로그인 사용자 검증은 건너뛴다. await this.recordSnapshot(auction, 'bid', params.bidderUserId); auction.currentBid = params.amount; auction.currentBidderTeamIndex = params.teamIndex; auction.currentDeadline = this.createDeadline( this.resolveBidExtensionSeconds(auction), ); auction.bids.push({ teamIndex: params.teamIndex, amount: params.amount, bidderUserId: team.captainUserId, timestamp: new Date(), }); await auction.save(); return auction; } public async placeBidDelta( params: PlaceBidParams, ): Promise { this.assertValidBidPointAmount(params.amount); const redisBidDelta = await this.tryPlaceRedisBidDeltaFromRealtimeState(params); if (redisBidDelta) return redisBidDelta; const auction = await this.getByMatchId(params.matchId); this.assertLiveAuctionOperationSupported(auction); if (this.isRedisV1Auction(auction)) { return this.placeRedisBidDelta(auction, params); } return this.placeBid(params); } private async openRedisBidding( auction: AuctionDocument, actionRequestParams: AuctionStructureActionRequestParams, ): Promise { const matchId = auction.matchId.toString(); const state = await this.requireRedisAuctionState(matchId); if (state.phase !== 'presenting') { throw new BadRequestException('Auction is not in presenting phase.'); } const actionRequest = await this.reserveRedisStructureActionRequest({ action: 'open-bidding', matchId, params: actionRequestParams, state, }); if (this.isReplayedRedisActionRequestContext(actionRequest)) { return this.resolveReplayedRedisActionRequest(matchId, actionRequest); } const structureInput = this.buildRedisStructureInputFromState(state); const liveStatePatch = { ...buildAuctionRedisLiveStatePatchFromStructure(structureInput), currentHighestBidPointAmount: 0, currentHighestBidderTeamIndex: -1, phase: 'bidding', }; return this.applyRedisStructureTransition({ action: 'open-bidding', actionRequest, auction, deadline: { durationSeconds: structureInput.maximumBidRoundDurationSeconds, mode: 'set-relative', }, expectedPhase: 'presenting', liveStatePatch, shouldBroadcastStateAfterDurability: actionRequestParams.shouldBroadcastStateAfterDurability, state, structureInput, }); } private async placeRedisBid( auction: AuctionDocument, params: PlaceBidParams, ): Promise { const matchId = auction.matchId.toString(); await this.executeRedisBid(auction, params); return this.requireRedisAuctionState(matchId); } private async placeRedisBidDelta( auction: AuctionDocument, params: PlaceBidParams, ): Promise { const serviceStartedAtMS = performance.now(); const { redisBidCommandDurationMS, result, state } = await this.executeRedisBid(auction, params); const bidDelta = this.buildBidDeltaFromRedisBidResult(state, result); bidDelta.bidServerTiming = this.roundBidServerTiming({ fallbackFullStatePath: true, redisBidCommandDurationMS, serviceTotalDurationMS: performance.now() - serviceStartedAtMS, }); this.logSlowBidTiming(auction.matchId.toString(), bidDelta.bidServerTiming); return bidDelta; } private async tryPlaceRedisBidDeltaFromRealtimeState( params: PlaceBidParams, ): Promise { const serviceStartedAtMS = performance.now(); const matchId = params.matchId.toString(); const bidContextReadStartedAtMS = performance.now(); const bidContext = await this.auctionRedisStateReaderService.readBidContext( matchId, params.teamIndex, ); const redisBidContextReadDurationMS = performance.now() - bidContextReadStartedAtMS; if (!bidContext) return null; if (bidContext.phase !== 'bidding') { throw new BadRequestException('Auction is not in bidding phase.'); } if (!bidContext.bidderTeamCaptainUserId) { throw new BadRequestException('Unknown team.'); } const auctionLifecycleId = params.clientObservedAuctionLifecycleId ?? bidContext.auctionLifecycleId; const currentBidRoundPlayerUserId = params.clientObservedCurrentBidRoundPlayerUserId ?? bidContext.currentBidRoundPlayerUserId; if (!auctionLifecycleId || !currentBidRoundPlayerUserId) { throw new BadRequestException('Current bid round is not available.'); } const redisBidCommandStartedAtMS = performance.now(); const result = await this.auctionRedisCommandService.placeBid(matchId, { bidPointAmount: params.amount, bidderTeamIndex: params.teamIndex, bidderUserId: bidContext.bidderTeamCaptainUserId, bidRequestId: params.bidRequestId ?? randomUUID(), clientObservedAuctionLifecycleId: auctionLifecycleId, clientObservedCurrentBidRoundPlayerUserId: currentBidRoundPlayerUserId, matchId, maximumAuctionTeamMemberCount: AUCTION_MAX_TEAM_SIZE, maximumStoredAuctionBidHistoryCount: AUCTION_MAX_STORED_BID_HISTORY_COUNT, maximumStoredBidRequestResultCount: AUCTION_MAX_STORED_BID_REQUEST_RESULT_COUNT, minimumBidPointReservePerRemainingAuctionTeamMemberSlot: AUCTION_MIN_BID_POINTS, minimumBidRequestResultReplayWindowMS: AUCTION_BID_REQUEST_REPLAY_WINDOW_MS, }); const redisBidCommandDurationMS = performance.now() - redisBidCommandStartedAtMS; if ('rejected' in result) { const bidServerTiming = this.roundBidServerTiming({ redisBidCommandDurationMS, redisBidContextReadDurationMS, serviceTotalDurationMS: performance.now() - serviceStartedAtMS, }); this.logSlowBidTiming(matchId, bidServerTiming); throw this.createRedisBidRejectedException(result, bidServerTiming); } const bidDelta = this.buildBidDeltaFromRedisBidResult( { auctionLifecycleId: bidContext.auctionLifecycleId }, result, ); bidDelta.bidServerTiming = this.roundBidServerTiming({ redisBidCommandDurationMS, redisBidContextReadDurationMS, serviceTotalDurationMS: performance.now() - serviceStartedAtMS, }); this.logSlowBidTiming(matchId, bidDelta.bidServerTiming); return bidDelta; } private async executeRedisBid( auction: AuctionDocument, params: PlaceBidParams, ): Promise<{ redisBidCommandDurationMS: number; result: Extract; state: Record; }> { const serviceStartedAtMS = performance.now(); const matchId = auction.matchId.toString(); const state = await this.requireRedisAuctionState(matchId); if (state.phase !== 'bidding') { throw new BadRequestException('Auction is not in bidding phase.'); } const auctionTeams = this.arrayFromState>( state.auctionTeams, ); const team = auctionTeams.find( (entry) => Number(entry.teamIndex) === params.teamIndex, ); if (!team) throw new BadRequestException('Unknown team.'); const auctionLifecycleId = params.clientObservedAuctionLifecycleId ?? this.stringFromState(state.auctionLifecycleId); const currentBidRoundPlayerUserId = params.clientObservedCurrentBidRoundPlayerUserId ?? this.stringFromState(state.currentBidRoundPlayerUserId); if (!auctionLifecycleId || !currentBidRoundPlayerUserId) { throw new BadRequestException('Current bid round is not available.'); } const redisBidCommandStartedAtMS = performance.now(); const result = await this.auctionRedisCommandService.placeBid(matchId, { bidPointAmount: params.amount, bidderTeamIndex: params.teamIndex, bidderUserId: this.stringFromState(team.captainUserId), bidRequestId: params.bidRequestId ?? randomUUID(), clientObservedAuctionLifecycleId: auctionLifecycleId, clientObservedCurrentBidRoundPlayerUserId: currentBidRoundPlayerUserId, matchId, maximumAuctionTeamMemberCount: AUCTION_MAX_TEAM_SIZE, maximumStoredAuctionBidHistoryCount: AUCTION_MAX_STORED_BID_HISTORY_COUNT, maximumStoredBidRequestResultCount: AUCTION_MAX_STORED_BID_REQUEST_RESULT_COUNT, minimumBidPointReservePerRemainingAuctionTeamMemberSlot: AUCTION_MIN_BID_POINTS, minimumBidRequestResultReplayWindowMS: AUCTION_BID_REQUEST_REPLAY_WINDOW_MS, }); const redisBidCommandDurationMS = performance.now() - redisBidCommandStartedAtMS; if ('rejected' in result) { const bidServerTiming = this.roundBidServerTiming({ fallbackFullStatePath: true, redisBidCommandDurationMS, serviceTotalDurationMS: performance.now() - serviceStartedAtMS, }); this.logSlowBidTiming(matchId, bidServerTiming); throw this.createRedisBidRejectedException(result, bidServerTiming); } return { redisBidCommandDurationMS, result, state }; } private buildBidDeltaFromRedisBidResult( state: Record, result: Extract, ): AuctionBidDeltaResponse { return { auctionBidHistoryEntry: result.auctionBidHistoryEntry, auctionLifecycleId: this.stringFromState(state.auctionLifecycleId), bidRequestId: result.bidRequestId, currentBidRoundDeadlineTimestampMS: result.currentBidRoundDeadlineTimestampMS, currentHighestBidderTeamIndex: result.currentHighestBidderTeamIndex, currentHighestBidPointAmount: result.currentHighestBidPointAmount, currentServerTimestampMS: result.currentServerTimestampMS, revision: result.revision, }; } private async markRedisSold( auction: AuctionDocument, params: MarkSoldParams, ): Promise { const matchId = auction.matchId.toString(); const state = await this.requireRedisAuctionState(matchId); if (state.phase !== 'bidding') { throw new BadRequestException('Auction is not in bidding phase.'); } const currentBidPointAmount = this.numberFromState( state.currentHighestBidPointAmount, ); const winningTeamIndex = this.numberFromState( state.currentHighestBidderTeamIndex, -1, ); if (winningTeamIndex < 1 || currentBidPointAmount <= 0) { throw new BadRequestException('No bid to mark sold.'); } const structureInput = this.buildRedisStructureInputFromState(state); const currentPlayer = structureInput.auctionPlayerOrder[ structureInput.currentAuctionPlayerOrderIndex ]; if (!currentPlayer) throw new BadRequestException('No current player.'); const team = structureInput.auctionTeams.find( (entry) => Number(entry.teamIndex) === winningTeamIndex, ); if (!team) throw new BadRequestException('Winning team not found.'); const actionRequest = await this.reserveRedisStructureActionRequest({ action: 'sold', matchId, params, state, }); if (this.isReplayedRedisActionRequestContext(actionRequest)) { return this.resolveReplayedRedisActionRequest(matchId, actionRequest); } // [AUCTION-DEBUG] 중복 멤버 버그 스모킹건: 낙찰 직전, 이 선수가 이미 어느 팀에 // 들어있는지. (markRedisSold는 검사 없이 append하므로 true면 그대로 중복) — 제거 대상 const soldUserId = String(currentPlayer.userId); const existingTeamIndex = structureInput.auctionTeams.find((entry) => (entry.members ?? []).some( (member) => String(member.userId) === soldUserId, ), )?.teamIndex; recordNewRelicCustomEvent('AuctionServerSold', { matchId, auctionActionRequestId: params.auctionActionRequestId ?? null, auctionLifecycleId: this.stringFromState(state.auctionLifecycleId), revision: this.numberFromState(state.revision), currentAuctionPlayerOrderIndex: structureInput.currentAuctionPlayerOrderIndex, soldUserId, winningTeamIndex, currentBidPointAmount, playerAlreadyInTeam: existingTeamIndex !== undefined, existingTeamIndex: existingTeamIndex !== undefined ? Number(existingTeamIndex) : -1, totalAssignedMemberCount: structureInput.auctionTeams.reduce( (sum, entry) => sum + (entry.members?.length ?? 0), 0, ), }); const preferredPrimary = currentPlayer.preferredPositions?.[0]?.position; team.members = [ ...(team.members ?? []), { userId: currentPlayer.userId, assignedPosition: params.assignedPosition ?? preferredPrimary ?? 'MID', memberAcquisitionBidPointAmount: currentBidPointAmount, }, ]; team.remainingBidPointAmount = Number(team.remainingBidPointAmount ?? 0) - currentBidPointAmount; return this.applyRedisStructureTransition({ action: 'sold', actionRequest, auction, deadline: { mode: 'remove' }, expectedPhase: 'bidding', liveStatePatch: { ...buildAuctionRedisLiveStatePatchFromStructure(structureInput), phase: 'sold', }, shouldBroadcastStateAfterDurability: params.shouldBroadcastStateAfterDurability, state, structureInput, }); } private async markRedisPassed( auction: AuctionDocument, actionRequestParams: AuctionStructureActionRequestParams, ): Promise { const matchId = auction.matchId.toString(); const state = await this.requireRedisAuctionState(matchId); if (state.phase !== 'bidding') { throw new BadRequestException('Auction is not in bidding phase.'); } if (this.numberFromState(state.currentHighestBidPointAmount) > 0) { throw new BadRequestException('Cannot pass a player with an active bid.'); } const structureInput = this.buildRedisStructureInputFromState(state); const currentPlayer = structureInput.auctionPlayerOrder[ structureInput.currentAuctionPlayerOrderIndex ]; if (!currentPlayer) throw new BadRequestException('No current player.'); const actionRequest = await this.reserveRedisStructureActionRequest({ action: 'passed', matchId, params: actionRequestParams, state, }); if (this.isReplayedRedisActionRequestContext(actionRequest)) { return this.resolveReplayedRedisActionRequest(matchId, actionRequest); } const passedPlayer = { ...JSON.parse(JSON.stringify(currentPlayer)), passCount: this.numberFromState(currentPlayer.passCount) + 1, }; structureInput.auctionPlayerOrder[ structureInput.currentAuctionPlayerOrderIndex ] = passedPlayer; structureInput.passedAuctionPlayerQueue = [ ...structureInput.passedAuctionPlayerQueue, passedPlayer, ]; return this.applyRedisStructureTransition({ action: 'passed', actionRequest, auction, deadline: { mode: 'remove' }, expectedPhase: 'bidding', liveStatePatch: { ...buildAuctionRedisLiveStatePatchFromStructure(structureInput), phase: 'passed', }, shouldBroadcastStateAfterDurability: actionRequestParams.shouldBroadcastStateAfterDurability, state, structureInput, }); } private async completeRedisExpirySold( auction: AuctionDocument, state: Record, ): Promise { const currentBidPointAmount = this.numberFromState( state.bidRoundExpiryWinningBidPointAmount, ); const winningTeamIndex = this.numberFromState( state.bidRoundExpiryWinningBidderTeamIndex, -1, ); if (winningTeamIndex < 1 || currentBidPointAmount <= 0) { throw new BadRequestException('Prepared expiry has no winning bid.'); } const structureInput = this.buildRedisStructureInputFromState(state); const currentPlayer = structureInput.auctionPlayerOrder[ structureInput.currentAuctionPlayerOrderIndex ]; if (!currentPlayer) throw new BadRequestException('No current player.'); const team = structureInput.auctionTeams.find( (entry) => Number(entry.teamIndex) === winningTeamIndex, ); if (!team) throw new BadRequestException('Winning team not found.'); const preferredPrimary = currentPlayer.preferredPositions?.[0]?.position; team.members = [ ...(team.members ?? []), { userId: currentPlayer.userId, assignedPosition: preferredPrimary ?? 'MID', memberAcquisitionBidPointAmount: currentBidPointAmount, }, ]; team.remainingBidPointAmount = Number(team.remainingBidPointAmount ?? 0) - currentBidPointAmount; return this.applyRedisStructureTransition({ action: 'sold', auction, auctionStateTransitionId: this.stringFromState( state.bidRoundExpiryAuctionStateTransitionId, ), deadline: { mode: 'remove' }, expectedPhase: 'expiring', liveStatePatch: { ...buildAuctionRedisLiveStatePatchFromStructure(structureInput), phase: 'sold', }, state, structureInput, }); } private async completeRedisExpiryPassed( auction: AuctionDocument, state: Record, ): Promise { const structureInput = this.buildRedisStructureInputFromState(state); const currentPlayer = structureInput.auctionPlayerOrder[ structureInput.currentAuctionPlayerOrderIndex ]; if (!currentPlayer) throw new BadRequestException('No current player.'); const passedPlayer = { ...JSON.parse(JSON.stringify(currentPlayer)), passCount: this.numberFromState(currentPlayer.passCount) + 1, }; structureInput.auctionPlayerOrder[ structureInput.currentAuctionPlayerOrderIndex ] = passedPlayer; structureInput.passedAuctionPlayerQueue = [ ...structureInput.passedAuctionPlayerQueue, passedPlayer, ]; return this.applyRedisStructureTransition({ action: 'passed', auction, auctionStateTransitionId: this.stringFromState( state.bidRoundExpiryAuctionStateTransitionId, ), deadline: { mode: 'remove' }, expectedPhase: 'expiring', liveStatePatch: { ...buildAuctionRedisLiveStatePatchFromStructure(structureInput), phase: 'passed', }, state, structureInput, }); } private async advanceRedisAuction( auction: AuctionDocument, actionRequestParams: AuctionStructureActionRequestParams, ): Promise { const matchId = auction.matchId.toString(); const state = await this.requireRedisAuctionState(matchId); if ( state.phase !== 'sold' && state.phase !== 'presenting' && state.phase !== 'passed' ) { throw new BadRequestException('Cannot advance from current phase.'); } const structureInput = this.buildRedisStructureInputFromState(state); const nextIndex = structureInput.currentAuctionPlayerOrderIndex + 1; let action: AuctionActionType = 'next'; let nextPhase = 'presenting'; if (nextIndex >= structureInput.auctionPlayerOrder.length) { if (structureInput.passedAuctionPlayerQueue.length > 0) { structureInput.auctionPlayerOrder = [ ...structureInput.auctionPlayerOrder, ...structureInput.passedAuctionPlayerQueue.map((player) => JSON.parse(JSON.stringify(player)), ), ]; structureInput.passedAuctionPlayerQueue = []; structureInput.currentAuctionRound += 1; structureInput.currentAuctionPlayerOrderIndex = nextIndex; } else { action = 'complete'; nextPhase = 'complete'; } } else { structureInput.currentAuctionPlayerOrderIndex = nextIndex; } const actionRequest = await this.reserveRedisStructureActionRequest({ action, matchId, params: actionRequestParams, state, }); if (this.isReplayedRedisActionRequestContext(actionRequest)) { return this.resolveReplayedRedisActionRequest(matchId, actionRequest); } const completionTimestampMS = action === 'complete' ? await this.auctionRedisService.getCurrentRedisTimestampMS() : undefined; return this.applyRedisStructureTransition({ action, actionRequest, auction, deadline: { mode: 'remove' }, expectedPhase: String(state.phase), liveStatePatch: { ...buildAuctionRedisLiveStatePatchFromStructure(structureInput), auctionCompletedAtTimestampMS: completionTimestampMS, currentHighestBidPointAmount: 0, currentHighestBidderTeamIndex: -1, phase: nextPhase, }, shouldBroadcastStateAfterDurability: actionRequestParams.shouldBroadcastStateAfterDurability, state, structureInput, }); } public async markSold(params: MarkSoldParams): Promise { const auction = await this.getByMatchId(params.matchId); this.assertLiveAuctionOperationSupported(auction); if (this.isRedisV1Auction(auction)) { return this.markRedisSold(auction, params); } if (auction.phase !== 'bidding') { throw new BadRequestException('Auction is not in bidding phase.'); } if (!auction.currentBidderTeamIndex || auction.currentBid <= 0) { throw new BadRequestException('No bid to mark sold.'); } const team = this.findAuctionTeamByIndex( auction, auction.currentBidderTeamIndex, ); if (!team) throw new BadRequestException('Winning team not found.'); this.assertTeamHasSlot(team); const current = auction.order[auction.currentIndex]; if (!current) throw new BadRequestException('No current player.'); await this.recordSnapshot(auction, 'sold'); const preferredPrimary = current.preferredPositions[0]?.position; team.members.push({ userId: current.userId, assignedPosition: params.assignedPosition ?? preferredPrimary ?? 'MID', cost: auction.currentBid, }); team.points -= auction.currentBid; auction.phase = 'sold'; auction.currentDeadline = undefined; await auction.save(); return auction; } public async markPassed( matchId: mongoose.Types.ObjectId, actionRequest: AuctionStructureActionRequestParams = {}, ): Promise { const auction = await this.getByMatchId(matchId); this.assertLiveAuctionOperationSupported(auction); if (this.isRedisV1Auction(auction)) { return this.markRedisPassed(auction, actionRequest); } if (auction.phase !== 'bidding') { throw new BadRequestException('Auction is not in bidding phase.'); } if (auction.currentBid > 0) { throw new BadRequestException('Cannot pass a player with an active bid.'); } const current = auction.order[auction.currentIndex]; if (!current) throw new BadRequestException('No current player.'); await this.recordSnapshot(auction, 'passed'); current.passCount = (current.passCount ?? 0) + 1; auction.passedQueue ??= []; auction.passedQueue.push(this.cloneAuctionPlayerSnapshot(current)); auction.phase = 'passed'; auction.currentDeadline = undefined; await auction.save(); return auction; } public async next( matchId: mongoose.Types.ObjectId, actionRequest: AuctionStructureActionRequestParams = {}, ): Promise { const auction = await this.getByMatchId(matchId); this.assertLiveAuctionOperationSupported(auction); if (this.isRedisV1Auction(auction)) { return this.advanceRedisAuction(auction, actionRequest); } if ( auction.phase !== 'sold' && auction.phase !== 'presenting' && auction.phase !== 'passed' ) { throw new BadRequestException('Cannot advance from current phase.'); } const nextIndex = auction.currentIndex + 1; const completesAuction = nextIndex >= auction.order.length && (auction.passedQueue?.length ?? 0) === 0; await this.recordSnapshot(auction, completesAuction ? 'complete' : 'next'); if (nextIndex >= auction.order.length) { if ((auction.passedQueue?.length ?? 0) > 0) { auction.order.push( ...auction.passedQueue.map((player) => this.cloneAuctionPlayerSnapshot(player), ), ); auction.passedQueue = []; auction.auctionRound = (auction.auctionRound ?? 1) + 1; auction.currentIndex = nextIndex; auction.phase = 'presenting'; auction.currentBid = 0; auction.currentBidderTeamIndex = undefined; } else { auction.phase = 'complete'; auction.completedAt = new Date(); } } else { auction.currentIndex = nextIndex; auction.phase = 'presenting'; auction.currentBid = 0; auction.currentBidderTeamIndex = undefined; } auction.currentDeadline = undefined; await auction.save(); if (auction.phase === 'complete') { await this.syncMatchTeamsFromAuction(auction); } return auction; } public async completePreparedExpiry( matchId: mongoose.Types.ObjectId, ): Promise { const auction = await this.getByMatchId(matchId); if (!this.isRedisV1Auction(auction)) return null; const state = await this.auctionRedisStateReaderService.readAuctionStateView( matchId.toString(), { includeInternalLiveStateFields: true }, ); if (!state || state.redisInternalPhase !== 'expiring') return null; const decision = this.stringFromState(state.bidRoundExpiryDecision); if (decision === 'sold') { return this.completeRedisExpirySold(auction, state); } if (decision === 'passed') { return this.completeRedisExpiryPassed(auction, state); } return null; } public async reset(params: { auctionActionRequestId?: string; clientObservedAuctionLifecycleId?: string; clientObservedCurrentAuctionPlayerOrderIndex?: number; clientObservedCurrentBidRoundPlayerUserId?: string; clientObservedPhase?: string; clientObservedRevision?: number; matchId: mongoose.Types.ObjectId; communityId: mongoose.Types.ObjectId; }): Promise { const AuctionModel = await this.connectionService.getModel('auction'); const AuctionHistoryModel = await this.connectionService.getModel('auctionHistory'); const AuctionSideEffectApplicationModel = await this.connectionService.getModel('auctionSideEffectApplication'); const MatchModel = await this.connectionService.getModel('match'); const session = await this.connectionService.createSession(); if (!session) { throw new InternalServerErrorException('Failed to start DB session.'); } let redisRuntimeToClear: { auctionLifecycleId?: string; matchId: string; } | null = null; try { session.startTransaction(); const auction = await AuctionModel.findOne({ matchId: params.matchId, }).session(session); if (!auction) throw new NotFoundException('Auction not found.'); const match = await MatchModel.findById(params.matchId).session(session); if (!match) throw new NotFoundException('Match not found.'); if (!match.communityId.equals(params.communityId)) { throw new BadRequestException('Community mismatch.'); } if (this.isRedisV1Auction(auction)) { redisRuntimeToClear = { auctionLifecycleId: auction.auctionLifecycleId, matchId: params.matchId.toString(), }; await this.resetMatchAfterAuctionCancellation(match, session); await AuctionSideEffectApplicationModel.deleteMany({ auctionId: auction._id, }).session(session); await AuctionHistoryModel.deleteMany({ auctionId: auction._id, }).session(session); await auction.deleteOne({ session }); } else { await auction.deleteOne({ session }); await AuctionHistoryModel.deleteMany({ auctionId: auction._id, }).session(session); if (match.status === 'team-built') { await this.tournamentCodeService.releaseFromMatch(match); match.status = 'recruiting'; match.teams = []; match.tournamentCodeIds = []; match.gameSchedule = []; match.participants.forEach((participant) => { participant.excluded = false; }); match.teamBuiltAt = undefined; match.result = undefined; match.resultPollState = undefined; await match.save({ session }); } } await session.commitTransaction(); } catch (err) { await session.abortTransaction(); throw err; } finally { await session.endSession(); } if (redisRuntimeToClear) { await this.clearRedisAuctionRuntimeForLifecycle( redisRuntimeToClear.matchId, redisRuntimeToClear.auctionLifecycleId, ); } } public async undoTo(params: { auctionActionRequestId?: string; clientObservedAuctionLifecycleId?: string; clientObservedCurrentAuctionPlayerOrderIndex?: number; clientObservedCurrentBidRoundPlayerUserId?: string; clientObservedPhase?: string; clientObservedRevision?: number; matchId: mongoose.Types.ObjectId; communityId: mongoose.Types.ObjectId; sequence: number; }): Promise { const AuctionModel = await this.connectionService.getModel('auction'); const AuctionHistoryModel = await this.connectionService.getModel('auctionHistory'); const MatchModel = await this.connectionService.getModel('match'); const session = await this.connectionService.createSession(); if (!session) { throw new InternalServerErrorException('Failed to start DB session.'); } let redisUndoContext: { actionRequestParams?: AuctionStructureActionRequestParams; auction: AuctionDocument; snapshot: Record; targetHistorySequence: number; undoingCompletedAuction: boolean; } | null = null; let restored: AuctionDocument | null = null; try { session.startTransaction(); const auction = await AuctionModel.findOne({ matchId: params.matchId, }).session(session); if (!auction) throw new NotFoundException('Auction not found.'); const match = await MatchModel.findById(params.matchId).session(session); if (!match) throw new NotFoundException('Match not found.'); if (!match.communityId.equals(params.communityId)) { throw new BadRequestException('Community mismatch.'); } const history = await AuctionHistoryModel.findOne({ auctionId: auction._id, sequence: params.sequence, }) .session(session) .lean() .exec(); if (!history) throw new NotFoundException('Auction history not found.'); const snapshot = history.snapshotBefore; if (!snapshot || typeof snapshot !== 'object') { throw new BadRequestException('Auction history snapshot is invalid.'); } const undoingCompletedAuction = Boolean(auction.completedAt) && !('completedAt' in snapshot); if (this.isRedisV1Auction(auction)) { redisUndoContext = { auction, actionRequestParams: params, snapshot: snapshot as Record, targetHistorySequence: params.sequence, undoingCompletedAuction, }; await session.commitTransaction(); } else { if (undoingCompletedAuction) { await this.tournamentCodeService.releaseFromMatch(match); await this.tournamentResultService.cancelPolling(match); match.status = 'team-built'; match.result = undefined; await match.save({ session }); } await AuctionModel.replaceOne({ _id: auction._id }, snapshot, { session, }).exec(); await AuctionHistoryModel.deleteMany({ auctionId: auction._id, sequence: { $gt: params.sequence }, }) .session(session) .exec(); await session.commitTransaction(); restored = await AuctionModel.findById(auction._id); if (!restored) throw new NotFoundException('Auction not found.'); } } catch (err) { await session.abortTransaction(); throw err; } finally { await session.endSession(); } if (redisUndoContext) { return this.undoRedisAuction(redisUndoContext); } if (!restored) throw new NotFoundException('Auction not found.'); return restored; } private async requireRedisAuctionState( matchId: string, ): Promise> { const state = await this.auctionRedisStateReaderService.readAuctionStateView(matchId); if (!state) { throw new BadRequestException('Auction realtime state is not available.'); } return state; } private async reserveRedisStructureActionRequest(params: { action: AuctionActionType; matchId: string; params: AuctionStructureActionRequestParams; state: Record; }): Promise { const auctionActionRequestId = params.params.auctionActionRequestId ?? randomUUID(); const expectedAuctionLifecycleId = params.params.clientObservedAuctionLifecycleId ?? this.stringFromState(params.state.auctionLifecycleId); const expectedRevision = params.params.clientObservedRevision ?? this.numberFromState(params.state.revision); const expectedPhase = params.params.clientObservedPhase ?? this.stringFromState(params.state.phase); const expectedCurrentBidRoundPlayerUserId = params.params.clientObservedCurrentBidRoundPlayerUserId ?? this.stringFromState(params.state.currentBidRoundPlayerUserId) ?? undefined; const expectedCurrentAuctionPlayerOrderIndex = params.params.clientObservedCurrentAuctionPlayerOrderIndex ?? this.numberFromState(params.state.currentAuctionPlayerOrderIndex); const processingOwnerToken = randomUUID(); const auctionStateTransitionId = `${params.action}:${expectedAuctionLifecycleId}:${auctionActionRequestId}`; const reserved = await this.auctionRedisCommandService.reserveActionRequest( params.matchId, { auctionActionRequestId, auctionActionType: params.action, auctionStateTransitionId, clientObservedAuctionLifecycleId: expectedAuctionLifecycleId, clientObservedCurrentAuctionPlayerOrderIndex: expectedCurrentAuctionPlayerOrderIndex, clientObservedCurrentBidRoundPlayerUserId: expectedCurrentBidRoundPlayerUserId, clientObservedPhase: expectedPhase, clientObservedRevision: expectedRevision, leaseDurationMS: AUCTION_ACTION_REQUEST_LEASE_DURATION_MS, maximumStoredAuctionActionRequestResultCount: AUCTION_MAX_STORED_ACTION_REQUEST_RESULT_COUNT, minimumAuctionActionRequestResultReplayWindowMS: AUCTION_ACTION_REQUEST_REPLAY_WINDOW_MS, processingOwnerToken, }, ); if ('rejected' in reserved) { throw new BadRequestException( `Auction action request was rejected: ${reserved.code}.`, ); } if ('isReplay' in reserved) { if (reserved.replayStatus === 'applied') { return { currentServerTimestampMS: reserved.currentServerTimestampMS, replay: true, requiresRefetch: reserved.requiresRefetch ?? true, responseJson: reserved.responseJson, revision: reserved.revision, }; } throw new BadRequestException( `Auction action request was replayed as ${reserved.replayStatus}.`, ); } return { actionRequest: { observedProcessingLeaseVersion: reserved.observedProcessingLeaseVersion, processingOwnerToken, scopeKey: reserved.actionRequestScopeKey, }, auctionStateTransitionId: reserved.auctionStateTransitionId, expectedAuctionLifecycleId, expectedCurrentAuctionPlayerOrderIndex, expectedCurrentBidRoundPlayerUserId, expectedPhase, expectedRevision, }; } private isReplayedRedisActionRequestContext( actionRequest: RedisActionRequestContext, ): actionRequest is ReplayedRedisActionRequestContext { return 'replay' in actionRequest; } private async resolveReplayedRedisActionRequest( matchId: string, actionRequest: ReplayedRedisActionRequestContext, ): Promise { if (actionRequest.responseJson && !actionRequest.requiresRefetch) { try { return JSON.parse(actionRequest.responseJson) as Record< string, unknown >; } catch { // Fall through to a full Redis read if a stored response is malformed. } } return this.requireRedisAuctionState(matchId); } private async applyRedisStructureTransition(params: { action: AuctionActionType; auction: AuctionDocument; actionRequest?: ReservedRedisActionRequestContext; auctionStateTransitionId?: string; deadline: | { mode: 'none' } | { mode: 'remove' } | { durationSeconds: number; mode: 'set-relative' }; expectedPhase: string; historyMutation?: Record; liveStatePatch: Record< string, string | number | boolean | null | undefined >; matchSideEffectMutation?: Record; shouldBroadcastStateAfterDurability?: boolean; shouldResetBidRuntime?: boolean; state: Record; structureInput: Parameters[0]; }): Promise { const matchId = params.auction.matchId.toString(); const auctionLifecycleId = this.stringFromState( params.state.auctionLifecycleId, ); const expectedRevision = params.actionRequest?.expectedRevision ?? this.numberFromState(params.state.revision); const expectedAuctionHistorySequence = this.numberFromState( params.state.currentAuctionHistorySequence, ); const auctionHistorySequence = expectedAuctionHistorySequence + 1; const auctionStateTransitionId = params.actionRequest?.auctionStateTransitionId || params.auctionStateTransitionId || `${params.action}:${auctionLifecycleId}:${randomUUID()}`; const afterState = { ...params.state, ...buildAuctionRedisStructureState(params.structureInput), ...params.liveStatePatch, currentAuctionHistorySequence: auctionHistorySequence, lastAppliedAuctionStateTransitionId: auctionStateTransitionId, revision: expectedRevision + 1, }; const afterAuctionMongoProjection = this.buildAuctionMongoProjectionFromState(params.auction, afterState); const matchSideEffectMutation = params.matchSideEffectMutation ?? (params.action === 'complete' ? { type: 'syncMatchTeamsAfterComplete' } : { type: 'none' }); if (matchSideEffectMutation.type !== 'none') { afterAuctionMongoProjection.matchSideEffectStatus = 'pending'; afterAuctionMongoProjection.matchSideEffectRevision = (params.auction.matchSideEffectRevision ?? 0) + 1; afterAuctionMongoProjection.matchSideEffectError = undefined; } const durabilityPayload = { afterAuctionMongoProjection, auctionActionType: params.action, auctionHistorySequence, auctionId: params.auction._id.toString(), auctionLifecycleId, auctionStateTransitionId, historyMutation: params.historyMutation ?? { type: 'append' }, matchId, matchSideEffectMutation, revision: expectedRevision + 1, snapshotBefore: this.buildAuctionSnapshotFromRedisState( params.auction, params.state, ), }; const result = await this.auctionRedisCommandService.applyTransition( matchId, { afterAuctionStructureStateJson: stringifyAuctionRedisStructureState( params.structureInput, ), auctionHistorySequence, auctionLifecycleId: params.actionRequest?.expectedAuctionLifecycleId ?? auctionLifecycleId, auctionStateTransitionId, broadcastStateRevision: expectedRevision + 1, deadline: params.deadline, durabilityPayloadJson: JSON.stringify(durabilityPayload), expectedCurrentAuctionPlayerOrderIndex: params.actionRequest?.expectedCurrentAuctionPlayerOrderIndex ?? params.structureInput.currentAuctionPlayerOrderIndex, expectedCurrentBidRoundPlayerUserId: params.actionRequest?.expectedCurrentBidRoundPlayerUserId ?? (params.expectedPhase === 'bidding' ? this.stringFromState(params.state.currentBidRoundPlayerUserId) : undefined), expectedAuctionHistorySequence, expectedPhase: params.actionRequest?.expectedPhase ?? params.expectedPhase, expectedRevision, liveStatePatch: params.liveStatePatch, matchId, shouldBroadcastState: params.shouldBroadcastStateAfterDurability ?? true, shouldResetBidRuntime: params.shouldResetBidRuntime, actionRequest: params.actionRequest?.actionRequest, }, ); // [AUCTION-DEBUG] 제거 대상. 모든 redis 전환(sold/undo/next/open-bidding/complete)의 백본 타임라인. // auctionStateTransitionId = `${action}:${lifecycleId}:${auctionActionRequestId}` // 라서 클라의 auctionActionRequestId와 조인된다. recordNewRelicCustomEvent('AuctionServerTransition', { matchId, action: params.action, auctionStateTransitionId, auctionLifecycleId, expectedRevision, newRevision: 'rejected' in result ? -1 : expectedRevision + 1, auctionHistorySequence, currentAuctionPlayerOrderIndex: params.structureInput.currentAuctionPlayerOrderIndex, totalAssignedMemberCount: params.structureInput.auctionTeams.reduce( (sum, entry) => sum + (entry.members?.length ?? 0), 0, ), rejected: 'rejected' in result, rejectionCode: 'rejected' in result ? result.code : null, }); if ('rejected' in result) { // 게이트웨이가 설명적 거부코드로 변환할 수 있도록 내부 code(예: CONFLICT)를 // 구조화해 던진다(message만 던지면 code 자리에 풀 문장이 들어가 매핑이 어렵다). throw new BadRequestException({ code: result.code, message: `Auction transition was rejected: ${result.code}.`, }); } return this.requireRedisAuctionState(matchId); } private async resetRedisAuction(params: { actionRequestParams?: AuctionStructureActionRequestParams; auction: AuctionDocument; }): Promise { const matchId = params.auction.matchId.toString(); const state = await this.requireRedisAuctionState(matchId); const actionRequest = await this.reserveRedisStructureActionRequest({ action: 'reset', matchId, params: params.actionRequestParams ?? {}, state, }); if (this.isReplayedRedisActionRequestContext(actionRequest)) { return this.resolveReplayedRedisActionRequest(matchId, actionRequest); } const currentStructureInput = this.buildRedisStructureInputFromState(state); const resetStructureInput = { ...currentStructureInput, auctionPlayerOrder: [], auctionTeams: [], currentAuctionPlayerOrderIndex: 0, currentAuctionRound: 1, passedAuctionPlayerQueue: [], }; const clearedTeamLiveStatePatch: Record = {}; for (const team of this.arrayFromState>( state.auctionTeams, )) { const teamIndex = this.numberFromState(team.teamIndex); if (teamIndex < 1) continue; clearedTeamLiveStatePatch[`team:${teamIndex}:remainingBidPointAmount`] = 0; clearedTeamLiveStatePatch[ `team:${teamIndex}:assignedAuctionTeamMemberCount` ] = 0; } return this.applyRedisStructureTransition({ action: 'reset', actionRequest, auction: params.auction, deadline: { mode: 'remove' }, expectedPhase: String(state.phase), historyMutation: { resetMode: 'clear-history', type: 'reset', }, liveStatePatch: { ...buildAuctionRedisLiveStatePatchFromStructure(resetStructureInput), ...clearedTeamLiveStatePatch, auctionCompletedAtTimestampMS: 0, currentBidRoundDeadlineTimestampMS: 0, currentBidRoundPlayerUserId: '', currentHighestBidPointAmount: 0, currentHighestBidderTeamIndex: -1, matchSideEffectRevision: Number(params.auction.matchSideEffectRevision ?? 0) + 1, matchSideEffectStatus: 'pending', phase: 'waiting', }, matchSideEffectMutation: { type: 'resetMatchAfterAuctionReset' }, shouldResetBidRuntime: true, state, structureInput: resetStructureInput, }); } private async undoRedisAuction(params: { actionRequestParams?: AuctionStructureActionRequestParams; auction: AuctionDocument; snapshot: Record; targetHistorySequence: number; undoingCompletedAuction: boolean; }): Promise { const matchId = params.auction.matchId.toString(); const state = await this.requireRedisAuctionState(matchId); const actionRequest = await this.reserveRedisStructureActionRequest({ action: 'undo', matchId, params: params.actionRequestParams ?? {}, state, }); if (this.isReplayedRedisActionRequestContext(actionRequest)) { return this.resolveReplayedRedisActionRequest(matchId, actionRequest); } const structureInput = this.buildRedisStructureInputFromAuctionSnapshot( params.snapshot, ); const phase = this.stringFromState(params.snapshot.phase) || 'presenting'; const currentHighestBidderTeamIndex = this.numberFromState( params.snapshot.currentHighestBidderTeamIndex ?? params.snapshot.currentBidderTeamIndex, -1, ); const currentHighestBidPointAmount = this.numberFromState( params.snapshot.currentHighestBidPointAmount ?? params.snapshot.currentBid, 0, ); // [AUCTION-DEBUG] 제거 대상. undo가 "어느 시점으로" 복원하는지 + 복원된 팀 구성. 라이브 revision과 // 복원 스냅샷 revision의 간격(restoredRevisionLag)이 사용자가 본 "2~3 뒤처짐". // 이 이벤트 직후의 AuctionServerSold가 playerAlreadyInTeam:true면 "undo가 선수를 // 안 지운 채 재낙찰 → 중복"이 한 타임라인으로 증명된다. const liveRevisionBeforeUndo = this.numberFromState(state.revision); const restoredRevision = this.numberFromState(params.snapshot.revision); const restoredMemberUserIds = structureInput.auctionTeams.flatMap((entry) => (entry.members ?? []).map((member) => String(member.userId)), ); recordNewRelicCustomEvent('AuctionServerUndo', { matchId, auctionActionRequestId: params.actionRequestParams?.auctionActionRequestId ?? null, auctionLifecycleId: this.stringFromState(state.auctionLifecycleId), targetHistorySequence: params.targetHistorySequence, liveRevisionBeforeUndo, restoredRevision, restoredRevisionLag: liveRevisionBeforeUndo - restoredRevision, restoredHistorySequence: this.numberFromState( params.snapshot.currentAuctionHistorySequence, ), restoredPhase: phase, restoredOrderIndex: structureInput.currentAuctionPlayerOrderIndex, restoredAssignedMemberCount: restoredMemberUserIds.length, restoredHasDuplicateMember: restoredMemberUserIds.length !== new Set(restoredMemberUserIds).size, undoingCompletedAuction: params.undoingCompletedAuction, }); return this.applyRedisStructureTransition({ action: 'undo', actionRequest, auction: params.auction, deadline: phase === 'bidding' ? { durationSeconds: structureInput.maximumBidRoundDurationSeconds, mode: 'set-relative', } : { mode: 'remove' }, expectedPhase: String(state.phase), historyMutation: { targetHistorySequence: params.targetHistorySequence, type: 'deleteAfterSequenceAndAppendUndo', }, liveStatePatch: { ...buildAuctionRedisLiveStatePatchFromStructure(structureInput), auctionCompletedAtTimestampMS: phase === 'complete' ? this.numberFromState( params.snapshot.auctionCompletedAtTimestampMS ?? params.snapshot.completedAt, ) : 0, currentHighestBidPointAmount, currentHighestBidderTeamIndex, phase, }, matchSideEffectMutation: params.undoingCompletedAuction ? { type: 'undoCompletedAuctionSideEffects' } : { type: 'none' }, state, structureInput, }); } private buildRedisStructureInputFromState( state: Record, ): Parameters[0] { return { auctionPlayerOrder: this.cloneRedisStructureArray( state.auctionPlayerOrder, ), auctionTeams: this.cloneRedisStructureArray(state.auctionTeams), bidRoundExtensionSeconds: this.numberFromState( state.bidRoundExtensionSeconds, 5, ), currentAuctionPlayerOrderIndex: this.numberFromState( state.currentAuctionPlayerOrderIndex, ), currentAuctionRound: this.numberFromState(state.currentAuctionRound, 1), initialTeamBidPointAmount: this.numberFromState( state.initialTeamBidPointAmount, 1000, ), manualTopTierAuctionPriorityUserIds: this.cloneRedisStructureArray( state.manualTopTierAuctionPriorityUserIds, ), maximumBidRoundDurationSeconds: this.numberFromState( state.maximumBidRoundDurationSeconds, 30, ), passedAuctionPlayerQueue: this.cloneRedisStructureArray( state.passedAuctionPlayerQueue, ), topTierAuctionPriorityThreshold: this.isAuctionTopTierThreshold( state.topTierAuctionPriorityThreshold, ) ? state.topTierAuctionPriorityThreshold : 'NONE', }; } private buildRedisStructureInputFromAuctionSnapshot( snapshot: Record, ): Parameters[0] { const legacyTeams = this.cloneRedisStructureArray(snapshot.teams); const auctionTeams = this.cloneRedisStructureArray(snapshot.auctionTeams); return { auctionPlayerOrder: this.cloneRedisStructureArray( snapshot.auctionPlayerOrder ?? snapshot.order, ), auctionTeams: auctionTeams.length > 0 ? auctionTeams : convertLegacyAuctionTeamsToRedisTeams(legacyTeams as never), bidRoundExtensionSeconds: this.numberFromState( snapshot.bidRoundExtensionSeconds ?? snapshot.bidExtensionSeconds, 5, ), currentAuctionPlayerOrderIndex: this.numberFromState( snapshot.currentAuctionPlayerOrderIndex ?? snapshot.currentIndex, ), currentAuctionRound: this.numberFromState( snapshot.currentAuctionRound ?? snapshot.auctionRound, 1, ), initialTeamBidPointAmount: this.numberFromState( snapshot.initialTeamBidPointAmount ?? snapshot.initialPoints, 1000, ), manualTopTierAuctionPriorityUserIds: this.cloneRedisStructureArray( snapshot.manualTopTierAuctionPriorityUserIds ?? snapshot.manualTopTierUserIds, ), maximumBidRoundDurationSeconds: this.numberFromState( snapshot.maximumBidRoundDurationSeconds ?? snapshot.maxTimerSeconds, 30, ), passedAuctionPlayerQueue: this.cloneRedisStructureArray( snapshot.passedAuctionPlayerQueue ?? snapshot.passedQueue, ), topTierAuctionPriorityThreshold: this.isAuctionTopTierThreshold( snapshot.topTierAuctionPriorityThreshold ?? snapshot.topTierThreshold, ) ? ((snapshot.topTierAuctionPriorityThreshold ?? snapshot.topTierThreshold) as never) : 'NONE', }; } private buildAuctionSnapshotFromRedisState( auction: AuctionDocument, state: Record, ): Record { const base = typeof auction.toObject === 'function' ? (auction.toObject({ depopulate: true }) as Record) : (auction as unknown as Record); return { ...JSON.parse(JSON.stringify(base)), ...this.buildAuctionMongoProjectionFromState(auction, state), _id: auction._id, matchId: auction.matchId, chatMessages: auction.chatMessages ?? [], }; } private buildAuctionMongoProjectionFromState( auction: AuctionDocument, state: Record, ): Record { const structureInput = this.buildRedisStructureInputFromState(state); const currentHighestBidderTeamIndex = this.numberFromState( state.currentHighestBidderTeamIndex, -1, ); const currentBidRoundDeadlineTimestampMS = this.numberFromState( state.currentBidRoundDeadlineTimestampMS, 0, ); const auctionBidHistory = this.arrayFromState>( state.auctionBidHistory, ); const phase = this.stringFromState(state.phase) || 'presenting'; const projection: Record = { auctionBidHistory, auctionCompletedAtTimestampMS: phase === 'complete' && this.numberFromState(state.auctionCompletedAtTimestampMS) > 0 ? this.numberFromState(state.auctionCompletedAtTimestampMS) : undefined, auctionEngineVersion: 'redis-v1', auctionLifecycleId: this.stringFromState(state.auctionLifecycleId), auctionPlayerOrder: structureInput.auctionPlayerOrder, auctionRound: structureInput.currentAuctionRound, auctionTeams: structureInput.auctionTeams, bidExtensionSeconds: structureInput.bidRoundExtensionSeconds, bidRoundExtensionSeconds: structureInput.bidRoundExtensionSeconds, bids: auctionBidHistory.map((bid) => ({ amount: this.numberFromState(bid.bidPointAmount), bidderUserId: bid.bidderUserId, teamIndex: this.numberFromState(bid.bidderTeamIndex), timestamp: new Date(this.numberFromState(bid.bidPlacedAtTimestampMS)), })), completedAt: phase === 'complete' && this.numberFromState(state.auctionCompletedAtTimestampMS) > 0 ? new Date(this.numberFromState(state.auctionCompletedAtTimestampMS)) : undefined, currentAuctionHistorySequence: this.numberFromState( state.currentAuctionHistorySequence, ), currentAuctionPlayerOrderIndex: structureInput.currentAuctionPlayerOrderIndex, currentAuctionRound: structureInput.currentAuctionRound, currentBid: this.numberFromState(state.currentHighestBidPointAmount), currentBidRoundDeadlineTimestampMS: currentBidRoundDeadlineTimestampMS > 0 ? currentBidRoundDeadlineTimestampMS : undefined, currentBidderTeamIndex: currentHighestBidderTeamIndex > 0 ? currentHighestBidderTeamIndex : undefined, currentDeadline: currentBidRoundDeadlineTimestampMS > 0 ? new Date(currentBidRoundDeadlineTimestampMS) : undefined, currentHighestBidPointAmount: this.numberFromState( state.currentHighestBidPointAmount, ), currentHighestBidderTeamIndex: currentHighestBidderTeamIndex > 0 ? currentHighestBidderTeamIndex : undefined, currentIndex: structureInput.currentAuctionPlayerOrderIndex, initialPoints: structureInput.initialTeamBidPointAmount, initialTeamBidPointAmount: structureInput.initialTeamBidPointAmount, lastAppliedAuctionStateTransitionId: this.stringFromState( state.lastAppliedAuctionStateTransitionId, ), manualTopTierAuctionPriorityUserIds: structureInput.manualTopTierAuctionPriorityUserIds, manualTopTierUserIds: structureInput.manualTopTierAuctionPriorityUserIds, matchId: auction.matchId, maxTimerSeconds: structureInput.maximumBidRoundDurationSeconds, maximumBidRoundDurationSeconds: structureInput.maximumBidRoundDurationSeconds, order: structureInput.auctionPlayerOrder, passedAuctionPlayerQueue: structureInput.passedAuctionPlayerQueue, passedQueue: structureInput.passedAuctionPlayerQueue, phase, revision: this.numberFromState(state.revision), teams: this.convertRedisTeamsToLegacyTeams(structureInput.auctionTeams), topTierAuctionPriorityThreshold: structureInput.topTierAuctionPriorityThreshold, topTierThreshold: structureInput.topTierAuctionPriorityThreshold, }; return this.dropUndefinedProjectionFields(projection); } private convertRedisTeamsToLegacyTeams( auctionTeams: Parameters< typeof stringifyAuctionRedisStructureState >[0]['auctionTeams'], ): AuctionTeam[] { return auctionTeams.map((team) => ({ captainUserId: team.captainUserId as mongoose.Types.ObjectId, members: (team.members ?? []).map((member) => ({ assignedPosition: member.assignedPosition, cost: member.memberAcquisitionBidPointAmount, userId: member.userId as mongoose.Types.ObjectId, })), points: team.remainingBidPointAmount, teamIndex: team.teamIndex, })); } private dropUndefinedProjectionFields( projection: Record, ): Record { return Object.fromEntries( Object.entries(projection).filter(([, value]) => value !== undefined), ); } private arrayFromState(value: unknown): T[] { return Array.isArray(value) ? (value as T[]) : []; } private cloneRedisStructureArray(value: unknown): T[] { // 구조 전환 핸들러가 이 작업본을 변이하므로 snapshotBefore 원본과 참조를 공유하면 안 된다. // structuredClone은 ObjectId를 [object Object]로 망가뜨리므로, 코드베이스 관행대로 // JSON 클론으로 깊은 복사 + ObjectId/Date 정규화를 함께 수행한다. return JSON.parse(JSON.stringify(this.arrayFromState(value))) as T[]; } private numberFromState(value: unknown, fallback = 0): number { const parsed = Number(value); return Number.isFinite(parsed) ? parsed : fallback; } private stringFromState(value: unknown): string { return typeof value === 'string' ? value : (value?.toString() ?? ''); } private isAuctionTopTierThreshold( value: unknown, ): value is AuctionTopTierThreshold { return ( value === 'NONE' || value === 'EMERALD' || value === 'DIAMOND' || value === 'MASTER' || value === 'MANUAL' ); } private formatRedisBidRejectCode(code: string): string { switch (code) { case 'PHASE': return 'Auction is not in bidding phase.'; case 'STALE_BID_ROUND': return 'Bid round has already changed.'; case 'EXPIRED': return 'Bid deadline has already expired.'; case 'TOO_LOW': return 'Bid must exceed current bid.'; case 'UNKNOWN_TEAM': return 'Unknown team.'; case 'FULL': return 'Team already has maximum members.'; case 'INSUFFICIENT': return 'Bid must reserve minimum points for remaining slots.'; case 'DUPLICATE_REQUEST_CONFLICT': return 'Bid request conflicts with an earlier request.'; default: return `Bid was rejected: ${code}.`; } } private createRedisBidRejectedException( result: Extract, bidServerTiming?: AuctionBidServerTiming, ): BadRequestException { const message = this.formatRedisBidRejectCode(result.code); const bidDiagnostics: AuctionBidRejectDiagnostics = { currentBidRoundDeadlineTimestampMS: result.currentBidRoundDeadlineTimestampMS, currentServerTimestampMS: result.currentServerTimestampMS, }; return new BadRequestException({ bidDiagnostics, ...(bidServerTiming ? { bidServerTiming } : {}), code: result.code, message, }); } private roundBidServerTiming( timing: AuctionBidServerTiming, ): AuctionBidServerTiming { return Object.fromEntries( Object.entries(timing).map(([key, value]) => [ key, typeof value === 'number' ? Math.round(value * 10) / 10 : value, ]), ) as AuctionBidServerTiming; } private logSlowBidTiming( matchId: string, timing: AuctionBidServerTiming, ): void { const serviceTotalDurationMS = timing.serviceTotalDurationMS ?? 0; if (serviceTotalDurationMS < 250) return; this.logger.warn( `Auction bid latency match=${matchId} service=${serviceTotalDurationMS}ms context=${timing.redisBidContextReadDurationMS ?? 0}ms redisBid=${timing.redisBidCommandDurationMS ?? 0}ms fallback=${timing.fallbackFullStatePath ? '1' : '0'}`, ); } private applyTopTierPriority( order: AuctionPlayerSnapshot[], threshold: AuctionTopTierThreshold, manualTopTierUserIds: mongoose.Types.ObjectId[], ): AuctionPlayerSnapshot[] { if (threshold === 'NONE') return order; if (threshold === 'MANUAL') { const manualIds = new Set( manualTopTierUserIds.map((userId) => userId.toString()), ); if (manualIds.size === 0) return order; const selected = order.filter((snap) => manualIds.has(snap.userId.toString()), ); const rest = order.filter( (snap) => !manualIds.has(snap.userId.toString()), ); return [...selected, ...rest]; } const ranks = [ 'IRON', 'BRONZE', 'SILVER', 'GOLD', 'PLATINUM', 'EMERALD', 'DIAMOND', 'MASTER', 'GRANDMASTER', 'CHALLENGER', ]; const cutoff = ranks.indexOf(threshold); const score = (snap: AuctionPlayerSnapshot) => { const solo = snap.tiers.find( (tier) => tier.queueType === 'RANKED_SOLO_5x5', ); if (!solo) return -1; const tierIdx = ranks.indexOf(solo.tier); if (tierIdx < cutoff) return -1; const rankBonus = ({ I: 4, II: 3, III: 2, IV: 1, '': 0 } as Record)[ solo.rank ] ?? 0; return ( tierIdx * 1000 + rankBonus * 100 + (solo.leaguePoints ?? 0) * 0.001 ); }; const top = order .filter((snap) => score(snap) >= 0) .sort((left, right) => score(right) - score(left)); const rest = order.filter((snap) => score(snap) < 0); return [...top, ...rest]; } private shuffleAuctionPlayerOrder( order: AuctionPlayerSnapshot[], ): AuctionPlayerSnapshot[] { const shuffled = [...order]; for (let index = shuffled.length - 1; index > 0; index -= 1) { const swapIndex = Math.floor(Math.random() * (index + 1)); [shuffled[index], shuffled[swapIndex]] = [ shuffled[swapIndex], shuffled[index], ]; } return shuffled; } private cloneAuctionPlayerSnapshot( player: AuctionPlayerSnapshot, ): AuctionPlayerSnapshot { return JSON.parse(JSON.stringify(player)) as AuctionPlayerSnapshot; } private normalizeChatMessage(message: string): string { const normalized = message.trim(); if (!normalized) { throw new BadRequestException('Chat message is required.'); } if (Array.from(normalized).length > AUCTION_CHAT_MAX_MESSAGE_LENGTH) { throw new BadRequestException( `Chat message must be ${AUCTION_CHAT_MAX_MESSAGE_LENGTH} characters or less.`, ); } return normalized; } private normalizeChatDisplayName(displayName: string | undefined): string { const normalized = displayName?.trim() || '관전자'; const chars = Array.from(normalized); if (chars.length <= AUCTION_CHAT_MAX_DISPLAY_NAME_LENGTH) { return normalized; } return chars.slice(0, AUCTION_CHAT_MAX_DISPLAY_NAME_LENGTH).join(''); } private async recordSnapshot( auction: AuctionDocument, action: AuctionActionType, actorUserId?: mongoose.Types.ObjectId, ): Promise { const AuctionHistoryModel = await this.connectionService.getModel('auctionHistory'); const latest = await AuctionHistoryModel.findOne({ auctionId: auction._id }) .sort({ sequence: -1 }) .select({ sequence: 1 }) .lean() .exec(); const snapshotBefore = typeof auction.toObject === 'function' ? auction.toObject({ depopulate: true }) : auction; await AuctionHistoryModel.create({ auctionId: auction._id, matchId: auction.matchId, sequence: (latest?.sequence ?? 0) + 1, action, actorUserId, snapshotBefore: JSON.parse(JSON.stringify(snapshotBefore)), takenAt: new Date(), }); } private formatHistoryActionLabel(action: AuctionActionType): string { switch (action) { case 'start': return '경매 시작'; case 'open-bidding': return '입찰 열기'; case 'bid': return '입찰'; case 'sold': return '낙찰 처리'; case 'passed': return '유찰'; case 'next': return '다음 선수'; case 'complete': return '경매 완료'; case 'reset': return '경매 초기화'; case 'undo': return '되돌리기'; default: return action; } } private applyAuctionCut(match: { participants: MatchParticipant[]; }): MatchParticipant[] { const ordered = [...match.participants].sort( (left, right) => left.joinedAt.getTime() - right.joinedAt.getTime(), ); const desiredAuctionCount = Math.floor(ordered.length / 10) * 10; const activeIds = new Set( ordered .slice(0, desiredAuctionCount) .map((participant) => participant.userId.toString()), ); match.participants.forEach((participant) => { participant.excluded = !activeIds.has(participant.userId.toString()); }); return ordered.slice(0, desiredAuctionCount); } private assertCaptainAssignments( captains: StartAuctionParams['captains'], activeParticipants: Array<{ userId: mongoose.Types.ObjectId }>, expectedCaptainCount: number, ): void { const activeUserIds = new Set( activeParticipants.map((participant) => participant.userId.toString()), ); const captainUserIds = new Set(); const teamIndexes = new Set(); for (const captain of captains) { const userId = captain.userId.toString(); if (!activeUserIds.has(userId)) { throw new BadRequestException( 'All captains must be active participants of the match.', ); } if (captainUserIds.has(userId)) { throw new BadRequestException('Captains must be different users.'); } captainUserIds.add(userId); if ( !Number.isInteger(captain.teamIndex) || captain.teamIndex < 1 || captain.teamIndex > expectedCaptainCount ) { throw new BadRequestException('Captain teamIndex is out of range.'); } if (teamIndexes.has(captain.teamIndex)) { throw new BadRequestException('Duplicate captain team assignment.'); } teamIndexes.add(captain.teamIndex); } for (let teamIndex = 1; teamIndex <= expectedCaptainCount; teamIndex += 1) { if (!teamIndexes.has(teamIndex)) { throw new BadRequestException('Each teamIndex needs one captain.'); } } } private findAuctionTeamByIndex( auction: AuctionDocument, teamIndex: number, ): AuctionTeam | undefined { return auction.teams.find((team) => team.teamIndex === teamIndex); } private createDeadline(secondsFromNow: number): Date { return new Date(Date.now() + secondsFromNow * 1000); } private resolveBidExtensionSeconds(auction: AuctionDocument): number { const maxTimerSeconds = Math.max(5, auction.maxTimerSeconds ?? 30); const bidExtensionSeconds = Math.max(0, auction.bidExtensionSeconds ?? 5); const minimumRemainingSeconds = Math.min( maxTimerSeconds, bidExtensionSeconds, ); if (!auction.currentDeadline) { return maxTimerSeconds; } const remainingSeconds = Math.ceil( (auction.currentDeadline.getTime() - Date.now()) / 1000, ); return Math.min( maxTimerSeconds, Math.max(minimumRemainingSeconds, remainingSeconds), ); } private assertTeamHasSlot(team: AuctionTeam): void { if (this.countTeamMembersIncludingCaptain(team) >= AUCTION_MAX_TEAM_SIZE) { throw new BadRequestException('Team already has maximum members.'); } } private assertValidBidPointAmount(amount: number): void { if (!Number.isInteger(amount) || amount <= 0) { throw new BadRequestException('Bid amount must be a positive integer.'); } } private calculateMaxBidForTeam(team: AuctionTeam): number { const remainingSlotsAfterCurrentBid = Math.max( 0, AUCTION_MAX_TEAM_SIZE - this.countTeamMembersIncludingCaptain(team) - 1, ); const reservedPoints = remainingSlotsAfterCurrentBid * AUCTION_MIN_BID_POINTS; return Math.max(0, team.points - reservedPoints); } private countTeamMembersIncludingCaptain(team: AuctionTeam): number { const userIds = new Set([team.captainUserId.toString()]); for (const member of team.members) { userIds.add(member.userId.toString()); } return userIds.size; } private isRedisV1Auction(auction: AuctionDocument): boolean { return auction.auctionEngineVersion === 'redis-v1'; } private isRestartableResetRedisAuction(auction: AuctionDocument): boolean { return ( this.isRedisV1Auction(auction) && auction.phase === 'waiting' && auction.matchSideEffectStatus === 'completed' ); } private isRedisResetStillApplying(auction: AuctionDocument): boolean { return ( this.isRedisV1Auction(auction) && auction.phase === 'waiting' && auction.matchSideEffectStatus !== 'completed' ); } private async resetMatchAfterAuctionCancellation( match: MatchDocument, session: mongoose.ClientSession, ): Promise { await this.tournamentCodeService.releaseFromMatch(match); await this.tournamentResultService.cancelPolling(match); match.status = 'recruiting'; match.teams = []; match.tournamentCodeIds = []; match.gameSchedule = []; match.participants.forEach((participant) => { participant.excluded = false; }); match.teamBuiltAt = undefined; match.result = undefined; match.resultPollState = undefined; await match.save({ session }); } private assertLiveAuctionOperationSupported(auction: AuctionDocument): void { if (auction.auctionEngineVersion && !this.isRedisV1Auction(auction)) { throw new BadRequestException( 'Legacy auction live operations are not supported.', ); } } private async syncMatchTeamsFromAuction( auction: AuctionDocument, ): Promise { const MatchModel = await this.connectionService.getModel('match'); const match = await MatchModel.findById(auction.matchId); if (!match) throw new NotFoundException('Match not found.'); const participantByUserId = new Map( match.participants.map((participant) => [ participant.userId.toString(), participant, ]), ); const matchTeams = auction.teams.map((team) => { const captain = participantByUserId.get(team.captainUserId.toString()); const members: MatchTeamMember[] = [ { userId: team.captainUserId, assignedPosition: captain?.preferredPositions[0]?.position ?? 'MID', cost: 0, }, ...team.members .filter((member) => !member.userId.equals(team.captainUserId)) .map((member) => ({ userId: member.userId, assignedPosition: member.assignedPosition, cost: member.cost, })), ]; return { teamIndex: team.teamIndex, name: this.resolveTeamName(team.teamIndex), captainUserId: team.captainUserId, members, }; }); if (matchTeams.length === 0) { throw new Error( `Auction completed without teams for match ${match._id.toString()}.`, ); } match.teams = matchTeams; match.status = 'team-built'; match.teamBuiltAt = match.teamBuiltAt ?? new Date(); await match.save(); await this.tournamentCodeService.reserveForMatch(match); await this.tournamentResultService.scheduleInitialPoll(match); } private async syncMatchTeamsFromRedisAuctionState( auction: AuctionDocument, state: Record, ): Promise { const MatchModel = await this.connectionService.getModel('match'); const match = await MatchModel.findById(auction.matchId); if (!match) throw new NotFoundException('Match not found.'); const participantByUserId = new Map( match.participants.map((participant) => [ participant.userId.toString(), participant, ]), ); const structureInput = this.buildRedisStructureInputFromState(state); const teams = this.convertRedisTeamsToLegacyTeams( structureInput.auctionTeams, ); const matchTeams = teams.map((team) => { const captain = participantByUserId.get(team.captainUserId.toString()); const members: MatchTeamMember[] = [ { userId: team.captainUserId, assignedPosition: captain?.preferredPositions[0]?.position ?? 'MID', cost: 0, }, ...team.members .filter( (member) => member.userId.toString() !== team.captainUserId.toString(), ) .map((member) => ({ userId: member.userId, assignedPosition: member.assignedPosition, cost: member.cost, })), ]; return { teamIndex: team.teamIndex, name: this.resolveTeamName(team.teamIndex), captainUserId: team.captainUserId, members, }; }); if (matchTeams.length === 0) { throw new Error( `Redis auction completed without teams for match ${match._id.toString()}.`, ); } match.teams = matchTeams; match.status = 'team-built'; match.teamBuiltAt = match.teamBuiltAt ?? new Date(); await match.save(); await this.tournamentCodeService.reserveForMatch(match); await this.tournamentResultService.scheduleInitialPoll(match); } private async hydrateRedisStateFromAuctionDocument( auction: AuctionDocument, ): Promise { const auctionTeams = auction.auctionTeams && auction.auctionTeams.length > 0 ? auction.auctionTeams : convertLegacyAuctionTeamsToRedisTeams(auction.teams ?? []); const structureInput = { auctionPlayerOrder: auction.auctionPlayerOrder ?? auction.order ?? [], auctionTeams, bidRoundExtensionSeconds: auction.bidRoundExtensionSeconds ?? auction.bidExtensionSeconds ?? 5, currentAuctionPlayerOrderIndex: auction.currentAuctionPlayerOrderIndex ?? auction.currentIndex ?? 0, currentAuctionRound: auction.currentAuctionRound ?? auction.auctionRound ?? 1, initialTeamBidPointAmount: auction.initialTeamBidPointAmount ?? auction.initialPoints ?? 1000, manualTopTierAuctionPriorityUserIds: auction.manualTopTierAuctionPriorityUserIds ?? auction.manualTopTierUserIds ?? [], maximumBidRoundDurationSeconds: auction.maximumBidRoundDurationSeconds ?? auction.maxTimerSeconds ?? 30, passedAuctionPlayerQueue: auction.passedAuctionPlayerQueue ?? auction.passedQueue ?? [], topTierAuctionPriorityThreshold: auction.topTierAuctionPriorityThreshold ?? auction.topTierThreshold ?? 'NONE', }; await this.auctionRedisCommandService.hydrateState( auction.matchId.toString(), { auctionHistorySequence: auction.currentAuctionHistorySequence ?? 0, auctionLifecycleId: auction.auctionLifecycleId ?? `auction:${auction._id.toString()}:rehydrated`, liveStatePatch: { ...buildAuctionRedisLiveStatePatchFromStructure(structureInput), currentHighestBidPointAmount: auction.currentHighestBidPointAmount ?? auction.currentBid ?? 0, currentHighestBidderTeamIndex: auction.currentHighestBidderTeamIndex ?? auction.currentBidderTeamIndex ?? -1, }, maximumBidRoundDurationSeconds: structureInput.maximumBidRoundDurationSeconds, matchId: auction.matchId.toString(), phase: auction.phase, revision: auction.revision ?? 0, structureStateJson: stringifyAuctionRedisStructureState(structureInput), }, ); } private async clearRedisAuctionRuntimeForLifecycle( matchId: string, expectedAuctionLifecycleId?: string, ): Promise { const keys = buildAuctionRedisKeys(matchId); const cleared = await this.auctionRedisService .raw() .sendCommand([ 'EVAL', [ 'local expectedAuctionLifecycleId = ARGV[2]', "if expectedAuctionLifecycleId ~= '' then", " local currentAuctionLifecycleId = redis.call('HGET', KEYS[1], 'auctionLifecycleId')", ' if currentAuctionLifecycleId and currentAuctionLifecycleId ~= expectedAuctionLifecycleId then', ' return 0', ' end', 'end', "redis.call('ZREM', KEYS[2], ARGV[1])", "redis.call('DEL', KEYS[1], KEYS[3], KEYS[4], KEYS[5], KEYS[6], KEYS[7], KEYS[8], KEYS[9], KEYS[10], KEYS[11])", 'return 1', ].join('\n'), '11', keys.liveStateKey, keys.deadlineQueueKey, keys.structureStateKey, keys.appliedTransitionIdsKey, keys.bidHistoryKey, keys.bidRequestResultsKey, keys.bidRequestResultOrderKey, keys.actionRequestResultsKey, keys.actionRequestResultOrderKey, keys.rehydrateLockKey, keys.stateTransitionLockKey, matchId, expectedAuctionLifecycleId ?? '', ]); if (Number(cleared) !== 1) return; await this.clearRedisDurabilityPayloadsForLifecycle( keys, expectedAuctionLifecycleId, ); } private async clearRedisDurabilityPayloadsForLifecycle( keys: ReturnType, expectedAuctionLifecycleId?: string, ): Promise { let cursor = '0'; do { const reply = await this.auctionRedisService .raw() .sendCommand([ 'SCAN', cursor, 'MATCH', `${keys.durabilityPayloadKeyPrefix}*`, 'COUNT', '100', ]); if (!Array.isArray(reply) || reply.length < 2) return; cursor = String(reply[0]); const payloadKeys = Array.isArray(reply[1]) ? reply[1].map(String) : []; if (payloadKeys.length === 0) continue; const values = await this.auctionRedisService .raw() .sendCommand(['MGET', ...payloadKeys]); const payloadKeysToDelete = payloadKeys.filter((payloadKey, index) => this.shouldDeleteRedisDurabilityPayload( Array.isArray(values) ? values[index] : undefined, expectedAuctionLifecycleId, payloadKey, ), ); if (payloadKeysToDelete.length === 0) continue; await this.auctionRedisService .raw() .sendCommand([ 'ZREM', keys.durabilityRetryQueueKey, ...payloadKeysToDelete, ]); await this.auctionRedisService .raw() .sendCommand([ 'ZREM', keys.durabilityDeadLetterQueueKey, ...payloadKeysToDelete, ]); await this.auctionRedisService .raw() .sendCommand(['DEL', ...payloadKeysToDelete]); } while (cursor !== '0'); } private shouldDeleteRedisDurabilityPayload( payloadValue: unknown, expectedAuctionLifecycleId: string | undefined, payloadKey: string, ): boolean { if (!expectedAuctionLifecycleId) return true; if (typeof payloadValue !== 'string') return false; try { const payload = JSON.parse(payloadValue) as Record; return payload.auctionLifecycleId === expectedAuctionLifecycleId; } catch { this.logger.warn( `Failed to parse auction durability payload ${payloadKey}.`, ); return false; } } private enqueueBackgroundOrderEnrichment(params: { auctionId: mongoose.Types.ObjectId; targets: AuctionEnrichmentTarget[]; platform: RiotPlatformRoute; region: RiotRegionalRoute; }): void { if (params.targets.length === 0) return; // 경매 시작 UX를 막지 않도록 Riot 최신화는 뒤에서 1명씩 천천히 수행한다. void this.refreshOrderSnapshotsFromRiot(params).catch((error: unknown) => { this.logger.warn( `Auction background Riot refresh failed for ${params.auctionId.toString()}: ${ error instanceof Error ? error.message : error }`, ); }); } private async refreshOrderSnapshotsFromRiot(params: { auctionId: mongoose.Types.ObjectId; targets: AuctionEnrichmentTarget[]; platform: RiotPlatformRoute; region: RiotRegionalRoute; }): Promise { const AuctionModel = await this.connectionService.getModel('auction'); this.logger.debug( `Refreshing Riot snapshots for ${params.targets.length} auction players in background.`, ); await runWithConcurrency( params.targets, AUCTION_BACKGROUND_ENRICHMENT_CONCURRENCY, async (target) => { try { const result = await this.enrichmentService.enrichRiotAccount({ userId: target.userId, puuid: target.puuid, options: { force: false, platform: params.platform, region: params.region, }, }); const account = result.account; if (!account) return; await AuctionModel.updateOne( { _id: params.auctionId, 'order.userId': target.userId, }, { $set: { 'order.$.gameName': account.gameName, 'order.$.tagLine': account.tagLine, 'order.$.profileIconId': account.profileIconId, 'order.$.tiers': account.tiers, 'order.$.tierHistory': account.tierHistory ?? [], 'order.$.masteries': account.championMasteries, 'order.$.recentStatsSummary': account.recentStatsSummary, updatedAt: new Date(), }, }, ).exec(); } catch (error: unknown) { this.logger.warn( `Failed to refresh auction Riot snapshot for ${target.puuid}: ${ error instanceof Error ? error.message : error }`, ); } }, ); } private wasRecentlyRefreshed(account: RiotAccount, cutoff: number): boolean { return this.getLatestRefreshAt(account) >= cutoff; } private getLatestRefreshAt(account: RiotAccount): number { const timestamps = [ account.lastRefreshRequestedAt, account.recentStatsFetchedAt, account.championMasteriesFetchedAt, account.matchIdsFetchedAt, ...account.tiers.map((tier) => tier.fetchedAt), ]; return timestamps.reduce((latest, value) => { const timestamp = value instanceof Date ? value.getTime() : 0; return Math.max(latest, timestamp); }, 0); } private resolveTeamName(teamIndex: number): string { return `${teamIndex}팀`; } } async function runWithConcurrency( items: T[], concurrency: number, worker: (item: T) => Promise, ): Promise { if (items.length === 0) return; const queue = [...items]; const runners = Array.from( { length: Math.min(concurrency, queue.length) }, async () => { while (queue.length > 0) { const item = queue.shift(); if (item === undefined) return; await worker(item); } }, ); await Promise.allSettled(runners); }