[Refactor] Redis로 세션/캐싱/상태 관리 (#363)

* refactor: redis 캐시에서 battleState 저장 및 로드 #353

* fix: 배틀 종료 시 캐시에서 배틀 정보 삭제 #353

* refactor: refreshToken redis 세션 관리 및 rtr 적용 #353

* refactor: gemini 다중화 사용량 측정 redis로 전환 #353

* test: oauth 테스트코드 변경된 로직으로 변경 #353

* refactor: redis polling으로 타이머 관리 #353

* chore: console.log 제거 #353

Author: jjjjjinseo

backend/src/battles/adapters/out/state/battleStateRepository.adapter.ts

@@ -2,6 +2,7 @@ import { Injectable, NotFoundException } from '@nestjs/common'
 import { Prisma } from 'generated/prisma/client'
 import { type Battle as PrismaBattle } from 'generated/prisma/client'
 import { PrismaService } from '../../../../prisma/prisma.service'
+import { RedisRepository } from '../../../../redis/redis.repository'
 import {
   ActiveBattleState,
   BattleTeam,
@@ -33,64 +34,63 @@ interface BattleChatSnapshot extends Omit<BattleChat, 'createdAt'> {
   createdAt: string
 }
 
+interface SerializedBattleState {
+  battleId: string
+  all: {
+    roomId: string
+    chats: BattleChatSnapshot[]
+    attacks: (BattleDiscussion | null)[]
+    defenses: (BattleDefense | null)[]
+  }
+  teamA: {
+    roomId: string
+    chats: BattleChatSnapshot[]
+    attacks: (BattleDiscussion | null)[]
+    defenses: (BattleDefense | null)[]
+    users: string[]
+  }
+  teamB: {
+    roomId: string
+    chats: BattleChatSnapshot[]
+    attacks: (BattleDiscussion | null)[]
+    defenses: (BattleDefense | null)[]
+    users: string[]
+  }
+  participants: [string, BattleTeam][]
+  teamVotes: [string, BattleTeam][]
+  userInfoMap: [string, string][]
+  opinionHistory: BattleDiscussion[]
+  skipState: string[]
+  round: number
+  topics: string[]
+  totalRounds: number
+  phase: BattlePhaseName
+  phaseCount: number
+  startedAt: number | null
+  expiredAt: number | null
+}
+
 @Injectable()
 export class BattleStateRepositoryAdapter implements BattleStatePort {
-  constructor(private readonly prisma: PrismaService) {}
+  private readonly cachePrefix = 'battle:state:'
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly redis: RedisRepository,
+  ) {}
 
   async loadBattleState(battleId: string): Promise<{ battle: PrismaBattle; state: ActiveBattleState }> {
+    const cachedState = await this.loadStateFromCache(battleId)
+
     const battle = await this.prisma.battle.findUnique({ where: { id: battleId } })
     if (!battle) throw new NotFoundException('배틀이 존재하지 않습니다.')
 
-    const participants = this.parseParticipantsState(battle.participantsState)
-    const teamVotes = this.parseTeamVotesState(battle.teamVotesState)
-    const userInfoMap = this.parseUserInfoState(battle.userInfoState)
-    const attackState = this.parseAttackState(battle.attacksState)
-    const defenseState = this.parseDefenseState(battle.defensesState)
-    const opinionHistory = this.parseOpinionHistoryState(battle.opinionHistoryState)
-    const skipState = new Set<string>(Array.isArray(battle.skipState) ? battle.skipState : [])
-
-    const playTime = BATTLE_PLAYTIME[battle.playTime as keyof typeof BATTLE_PLAYTIME]
-    if (!playTime) {
-      throw new NotFoundException('올바르지 않은 배틀 진행 시간입니다.')
-    }
-
-    const state: ActiveBattleState = {
-      battleId,
-      all: {
-        roomId: this.getBattleRoomId(battleId),
-        chats: this.parseChatState(battle.chatsAllState),
-        attacks: attackState.all,
-        defenses: defenseState.all,
-      },
-      teamA: {
-        roomId: this.getBattleRoomId(battleId, BATTLE_TEAM.A),
-        users: [],
-        chats: this.parseChatState(battle.chatsTeamAState),
-        attacks: attackState.teamA,
-        defenses: defenseState.teamA,
-      },
-      teamB: {
-        roomId: this.getBattleRoomId(battleId, BATTLE_TEAM.B),
-        users: [],
-        chats: this.parseChatState(battle.chatsTeamBState),
-        attacks: attackState.teamB,
-        defenses: defenseState.teamB,
-      },
-      participants,
-      teamVotes,
-      userInfoMap,
-      opinionHistory,
-      skipState,
-      round: battle.currentRound ?? 1,
-      topics: battle.topics,
-      totalRounds: playTime.rounds,
-      phase: (battle.currentPhase ?? BATTLE_PHASE.PENDING.name) as BattlePhaseName,
-      phaseCount: battle.phaseCount ?? 1,
-      startedAt: battle.startedAt ? battle.startedAt.getTime() : null,
-      expiredAt: battle.expiredAt ? battle.expiredAt.getTime() : null,
+    //캐시에서 가져온 데이터가 있으면 바로 반환
+    if (cachedState) {
+      return { battle, state: cachedState }
     }
 
-    this.rebuildTeamUsers(state)
+    const state = this.buildStateFromBattle(battle)
+    await this.persistStateCache(state)
     return { battle, state }
   }
 
@@ -124,6 +124,7 @@ export class BattleStateRepositoryAdapter implements BattleStatePort {
         updatedAt: new Date(),
       },
     })
+    await this.persistStateCache(state)
   }
 
   async updateSkipState(battleId: string, skipList: Set<string>): Promise<void> {
@@ -134,6 +135,11 @@ export class BattleStateRepositoryAdapter implements BattleStatePort {
         updatedAt: new Date(),
       },
     })
+    await this.patchSkipCache(battleId, skipList)
+  }
+
+  async clearCache(battleId: string): Promise<void> {
+    await this.redis.del(this.getCacheKey(battleId))
   }
 
   parseMvpsState(value: unknown): Mvp[] {
@@ -257,6 +263,171 @@ export class BattleStateRepositoryAdapter implements BattleStatePort {
     return value.filter(item => item && typeof item === 'object') as BattleDiscussion[]
   }
 
+  //캐시에서 가져오기
+  private async loadStateFromCache(battleId: string): Promise<ActiveBattleState | null> {
+    try {
+      const payload = await this.redis.get(this.getCacheKey(battleId))
+      if (!payload) return null
+      return this.deserializeState(JSON.parse(payload) as SerializedBattleState)
+    } catch {
+      return null
+    }
+  }
+
+  //캐시에 저장하기
+  private async persistStateCache(state: ActiveBattleState): Promise<void> {
+    const payload = this.serializeState(state)
+    await this.redis.set(this.getCacheKey(state.battleId), JSON.stringify(payload))
+  }
+
+  //skipState 업데이트 시 캐시 업데이트
+  private async patchSkipCache(battleId: string, skipList: Set<string>): Promise<void> {
+    const cachedState = await this.loadStateFromCache(battleId)
+    if (!cachedState) return
+    cachedState.skipState = new Set(skipList)
+    await this.persistStateCache(cachedState)
+  }
+
+  //캐시에 저장할 데이터 직렬화
+  private serializeState(state: ActiveBattleState): SerializedBattleState {
+    return {
+      battleId: state.battleId,
+      all: {
+        roomId: state.all.roomId,
+        chats: this.serializeChatState(state.all.chats),
+        attacks: state.all.attacks,
+        defenses: state.all.defenses,
+      },
+      teamA: {
+        roomId: state.teamA.roomId,
+        chats: this.serializeChatState(state.teamA.chats),
+        attacks: state.teamA.attacks,
+        defenses: state.teamA.defenses,
+        users: [...state.teamA.users],
+      },
+      teamB: {
+        roomId: state.teamB.roomId,
+        chats: this.serializeChatState(state.teamB.chats),
+        attacks: state.teamB.attacks,
+        defenses: state.teamB.defenses,
+        users: [...state.teamB.users],
+      },
+      participants: [...state.participants.entries()],
+      teamVotes: [...state.teamVotes.entries()],
+      userInfoMap: [...state.userInfoMap.entries()],
+      opinionHistory: state.opinionHistory,
+      skipState: Array.from(state.skipState),
+      round: state.round,
+      topics: state.topics,
+      totalRounds: state.totalRounds,
+      phase: state.phase,
+      phaseCount: state.phaseCount,
+      startedAt: state.startedAt,
+      expiredAt: state.expiredAt,
+    }
+  }
+
+  //캐시에서 가져온 데이터 역직렬화
+  private deserializeState(payload: SerializedBattleState): ActiveBattleState {
+    const participants = new Map<string, BattleTeam>(payload.participants ?? [])
+    const teamVotes = new Map<string, BattleTeam>(payload.teamVotes ?? [])
+    const userInfoMap = new Map<string, string>(payload.userInfoMap ?? [])
+
+    const state: ActiveBattleState = {
+      battleId: payload.battleId,
+      all: {
+        roomId: payload.all.roomId,
+        chats: this.parseChatState(payload.all.chats),
+        attacks: payload.all.attacks ?? [],
+        defenses: payload.all.defenses ?? [],
+      },
+      teamA: {
+        roomId: payload.teamA.roomId,
+        chats: this.parseChatState(payload.teamA.chats),
+        attacks: payload.teamA.attacks ?? [],
+        defenses: payload.teamA.defenses ?? [],
+        users: payload.teamA.users ?? [],
+      },
+      teamB: {
+        roomId: payload.teamB.roomId,
+        chats: this.parseChatState(payload.teamB.chats),
+        attacks: payload.teamB.attacks ?? [],
+        defenses: payload.teamB.defenses ?? [],
+        users: payload.teamB.users ?? [],
+      },
+      participants,
+      teamVotes,
+      userInfoMap,
+      opinionHistory: payload.opinionHistory ?? [],
+      skipState: new Set(payload.skipState ?? []),
+      round: payload.round,
+      topics: payload.topics,
+      totalRounds: payload.totalRounds,
+      phase: payload.phase,
+      phaseCount: payload.phaseCount,
+      startedAt: payload.startedAt,
+      expiredAt: payload.expiredAt,
+    }
+
+    this.rebuildTeamUsers(state)
+    return state
+  }
+
+  //데이터베이스에서 가져온 데이터 빌드
+  private buildStateFromBattle(battle: PrismaBattle): ActiveBattleState {
+    const participants = this.parseParticipantsState(battle.participantsState)
+    const teamVotes = this.parseTeamVotesState(battle.teamVotesState)
+    const userInfoMap = this.parseUserInfoState(battle.userInfoState)
+    const attackState = this.parseAttackState(battle.attacksState)
+    const defenseState = this.parseDefenseState(battle.defensesState)
+    const opinionHistory = this.parseOpinionHistoryState(battle.opinionHistoryState)
+    const skipState = new Set<string>(Array.isArray(battle.skipState) ? battle.skipState : [])
+
+    const playTime = BATTLE_PLAYTIME[battle.playTime as keyof typeof BATTLE_PLAYTIME]
+    if (!playTime) {
+      throw new NotFoundException('올바르지 않은 배틀 진행 시간입니다.')
+    }
+
+    const state: ActiveBattleState = {
+      battleId: battle.id,
+      all: {
+        roomId: this.getBattleRoomId(battle.id),
+        chats: this.parseChatState(battle.chatsAllState),
+        attacks: attackState.all,
+        defenses: defenseState.all,
+      },
+      teamA: {
+        roomId: this.getBattleRoomId(battle.id, BATTLE_TEAM.A),
+        users: [],
+        chats: this.parseChatState(battle.chatsTeamAState),
+        attacks: attackState.teamA,
+        defenses: defenseState.teamA,
+      },
+      teamB: {
+        roomId: this.getBattleRoomId(battle.id, BATTLE_TEAM.B),
+        users: [],
+        chats: this.parseChatState(battle.chatsTeamBState),
+        attacks: attackState.teamB,
+        defenses: defenseState.teamB,
+      },
+      participants,
+      teamVotes,
+      userInfoMap,
+      opinionHistory,
+      skipState,
+      round: battle.currentRound ?? 1,
+      topics: battle.topics,
+      totalRounds: playTime.rounds,
+      phase: (battle.currentPhase ?? BATTLE_PHASE.PENDING.name) as BattlePhaseName,
+      phaseCount: battle.phaseCount ?? 1,
+      startedAt: battle.startedAt ? battle.startedAt.getTime() : null,
+      expiredAt: battle.expiredAt ? battle.expiredAt.getTime() : null,
+    }
+
+    this.rebuildTeamUsers(state)
+    return state
+  }
+
   private rebuildTeamUsers(state: ActiveBattleState): void {
     state.teamA.users = []
     state.teamB.users = []
@@ -267,6 +438,10 @@ export class BattleStateRepositoryAdapter implements BattleStatePort {
     }
   }
 
+  private getCacheKey(battleId: string): string {
+    return `${this.cachePrefix}${battleId}`
+  }
+
   private getBattleRoomId(battleId: string, team?: BattleTeam): string {
     return team ? `battle:${battleId}:${team}` : `battle:${battleId}`
   }

backend/src/battles/adapters/out/timer/battleTimer.adapter.ts

@@ -1,39 +1,44 @@
 import { Injectable } from '@nestjs/common'
 import { ActiveBattleState } from '../../../domains/models/types/battle.types'
 import { BattleTimerPort } from '../../../application/ports/out/battleTimer.port'
+import { RedisRepository } from '../../../../redis/redis.repository'
 
 @Injectable()
 export class BattleTimerAdapter implements BattleTimerPort {
-  private battleTimers: Map<string, NodeJS.Timeout> = new Map()
+  private readonly TIMERS_KEY = 'battle:timers'
+
+  constructor(private readonly redisRepository: RedisRepository) {}
 
   //배틀 타이머 스케줄러
-  schedule(battleId: string, state: ActiveBattleState, updatePhase: (battleId: string) => Promise<void>): void {
+  schedule(battleId: string, state: ActiveBattleState): void {
     if (!state.expiredAt) return
 
-    const prevTimer = this.battleTimers.get(battleId)
-    if (prevTimer) clearTimeout(prevTimer)
+    // Redis Sorted Set에 저장
+    void this.redisRepository.zadd(this.TIMERS_KEY, state.expiredAt, battleId)
+  }
 
-    const remaining = Math.max(state.expiredAt - Date.now(), 0)
+  //배틀 타이머 취소
+  cancel(battleId: string): void {
+    void this.redisRepository.zrem(this.TIMERS_KEY, battleId)
+  }
 
-    const battleTimer = setTimeout(() => {
-      void updatePhase(battleId)
-    }, remaining)
+  //만료된 배틀 ID 목록 조회
+  async getExpiredBattles(): Promise<string[]> {
+    const now = Date.now()
 
-    this.battleTimers.set(battleId, battleTimer)
+    // 현재 시간보다 작은 score를 가진 모든 member 조회
+    return await this.redisRepository.zrangebyscore(this.TIMERS_KEY, '-inf', now)
   }
 
-  //배틀 타이머 취소
-  cancel(battleId: string): void {
-    const battleTimer = this.battleTimers.get(battleId)
-    if (battleTimer) {
-      clearTimeout(battleTimer)
-      this.battleTimers.delete(battleId)
-    }
+  //만료된 배틀 제거
+  async removeExpiredBattles(battleIds: string[]): Promise<void> {
+    if (battleIds.length === 0) return
+
+    await this.redisRepository.zrem(this.TIMERS_KEY, ...battleIds)
   }
 
   //모든 배틀 타이머 취소 (테스트용)
   clear(): void {
-    this.battleTimers.forEach(timer => clearTimeout(timer))
-    this.battleTimers.clear()
+    void this.redisRepository.del(this.TIMERS_KEY)
   }
 }

backend/src/battles/application/ports/out/battleState.port.ts

@@ -7,6 +7,8 @@ export interface BattleStatePort {
   loadBattleState(battleId: string): Promise<{ battle: PrismaBattle; state: ActiveBattleState }>
   //배틀 상태 저장
   saveBattleState(battleId: string, state: ActiveBattleState): Promise<void>
+  //캐시 삭제
+  clearCache(battleId: string): Promise<void>
   //페이즈 스킵 상태 업데이트
   updateSkipState(battleId: string, skipList: Set<string>): Promise<void>
   //MVP 상태 파싱