diff --git a/README.md b/README.md index 876df721..df452ab4 100644 --- a/README.md +++ b/README.md @@ -91,7 +91,8 @@ LOLYMPUS는 이 반복 작업을 줄이는 데 초점을 맞췄습니다. 운영 - TanStack Query - NestJS - MongoDB -- Redis/Garnet +- Redis +- Redis 8.4 (경매 실시간 상태 전용) - NATS - Riot API - pnpm workspace @@ -113,7 +114,9 @@ scripts/ deployment and maintenance scripts - Node.js 24 이상 - pnpm 10.4.1 (`packageManager` 기준, `corepack enable`로 활성화 권장) -- MongoDB 7.0, Redis 5.0 이상, NATS 실행 환경 +- MongoDB 7.0, 일반 캐시/스트림용 Redis, 경매 실시간 상태 전용 Redis 8.4, NATS 실행 환경 + +경매 Redis는 라이브 경매 상태의 source of truth로 사용되므로 일반 캐시/스트림 Redis와 물리적으로 분리해야 합니다. API는 `REDIS_URL`/`REDIS_ENDPOINT`와 별도로 `AUCTION_REDIS_URL`/`AUCTION_REDIS_ENDPOINT`를 읽고, 두 값이 같은 호스트/포트를 가리키면 부팅을 거부합니다. ## 실행 방법 diff --git a/apps/api/package.json b/apps/api/package.json index cd8552e2..414d8c73 100644 --- a/apps/api/package.json +++ b/apps/api/package.json @@ -32,6 +32,7 @@ "@nestjs/platform-socket.io": "^11.1.19", "@nestjs/swagger": "^11.2.7", "@nestjs/websockets": "^11.1.19", + "@socket.io/redis-adapter": "^8.3.0", "class-transformer": "^0.5.1", "class-validator": "^0.15.1", "jose": "^6.2.2", diff --git a/apps/api/src/main.ts b/apps/api/src/main.ts index 375ab8a4..c8e901bb 100644 --- a/apps/api/src/main.ts +++ b/apps/api/src/main.ts @@ -2,6 +2,7 @@ import { ValidationPipe } from '@nestjs/common'; import { NestFactory } from '@nestjs/core'; import { AppModule } from './app.module'; import { createCorsOrigin } from './cors-origin'; +import { RedisIoAdapter } from './redis-io.adapter'; async function bootstrap() { const app = await NestFactory.create(AppModule, { @@ -10,6 +11,9 @@ async function bootstrap() { const nodeEnv = process.env.NODE_ENV; const isDev = nodeEnv === 'dev'; + const redisIoAdapter = new RedisIoAdapter(app); + await redisIoAdapter.connectToRedis(); + app.useWebSocketAdapter(redisIoAdapter); app.enableCors({ origin: createCorsOrigin(nodeEnv), diff --git a/apps/api/src/modules/auction/auction-deadline.scheduler.spec.ts b/apps/api/src/modules/auction/auction-deadline.scheduler.spec.ts new file mode 100644 index 00000000..b8e7efae --- /dev/null +++ b/apps/api/src/modules/auction/auction-deadline.scheduler.spec.ts @@ -0,0 +1,205 @@ +import { AuctionRedisService } from './redis/auction-redis.service'; +import { AuctionDeadlineScheduler } from './auction-deadline.scheduler'; +import { AuctionRedisCommandService } from './redis/auction-redis-command.service'; +import { AuctionService } from './auction.service'; + +function makeScheduler(params: { + dueReply?: unknown; + leaderLockAcquired?: boolean; + expireReply?: unknown; + completedState?: unknown; + currentRedisTimestampMS?: number; +}) { + const sendCommand = jest.fn().mockResolvedValue(params.dueReply ?? []); + const redis = { + acquireTokenLock: jest + .fn() + .mockResolvedValue(params.leaderLockAcquired ?? true), + getCurrentRedisTimestampMS: jest + .fn() + .mockResolvedValue(params.currentRedisTimestampMS ?? 1000), + releaseTokenLock: jest.fn().mockResolvedValue(true), + raw: jest.fn().mockReturnValue({ sendCommand }), + } as unknown as jest.Mocked; + const redisCommand = { + expirePrepare: jest.fn().mockResolvedValue( + params.expireReply ?? { + auctionStateTransitionId: 'expire-1', + bidRoundExpiryDecision: 'passed', + currentServerTimestampMS: 1000, + ok: true, + revision: 2, + }, + ), + } as unknown as jest.Mocked; + const auctionService = { + completePreparedExpiry: jest + .fn() + .mockResolvedValue(params.completedState ?? { phase: 'passed' }), + } as unknown as jest.Mocked; + return { + auctionService, + redis, + redisCommand, + scheduler: new AuctionDeadlineScheduler( + redis, + redisCommand, + auctionService, + ), + sendCommand, + }; +} + +describe('AuctionDeadlineScheduler', () => { + afterEach(() => { + jest.restoreAllMocks(); + }); + + it('starts and clears the deadline tick timer', () => { + const setIntervalSpy = jest.spyOn(global, 'setInterval'); + const clearIntervalSpy = jest.spyOn(global, 'clearInterval'); + const { scheduler } = makeScheduler({}); + + scheduler.onModuleInit(); + scheduler.onModuleDestroy(); + + expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 1000); + expect(clearIntervalSpy).toHaveBeenCalledTimes(1); + }); + + it('processes a deadline tick only while holding the Redis leader lock', async () => { + const { redis, scheduler } = makeScheduler({}); + const processDueBidRoundDeadlinesSpy = jest + .spyOn(scheduler, 'processDueBidRoundDeadlines') + .mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 }); + + await (scheduler as unknown as { safeTick: () => Promise }).safeTick(); + + const leaderLockToken = redis.acquireTokenLock.mock.calls[0]?.[1]; + expect(redis.acquireTokenLock).toHaveBeenCalledWith( + 'auction:bidRoundDeadlineScheduler:leader', + expect.any(String), + 2500, + ); + expect(processDueBidRoundDeadlinesSpy).toHaveBeenCalledWith(20); + expect(redis.releaseTokenLock).toHaveBeenCalledWith( + 'auction:bidRoundDeadlineScheduler:leader', + leaderLockToken, + ); + }); + + it('skips deadline tick work when another instance holds the leader lock', async () => { + const { redis, scheduler } = makeScheduler({ leaderLockAcquired: false }); + const processDueBidRoundDeadlinesSpy = jest + .spyOn(scheduler, 'processDueBidRoundDeadlines') + .mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 }); + + await (scheduler as unknown as { safeTick: () => Promise }).safeTick(); + + expect(processDueBidRoundDeadlinesSpy).not.toHaveBeenCalled(); + expect(redis.releaseTokenLock).not.toHaveBeenCalled(); + }); + + it('reads due match ids from the Redis deadline queue with a batch limit', async () => { + const { redis, scheduler } = makeScheduler({ + dueReply: ['match-1', 'match-2'], + }); + + await expect(scheduler.readDueMatchIds(1_000, 2)).resolves.toEqual([ + 'match-1', + 'match-2', + ]); + expect(redis.raw().sendCommand).toHaveBeenCalledWith([ + 'ZRANGEBYSCORE', + 'auction:bidRoundDeadlineQueue', + '-inf', + '1000', + 'LIMIT', + '0', + '2', + ]); + }); + + it('prepares and completes due auction deadlines', async () => { + const matchId = '665f2f01f1f1f1f1f1f1f1f1'; + const { auctionService, redisCommand, scheduler } = makeScheduler({ + dueReply: [matchId], + }); + + await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({ + completed: 1, + prepared: 1, + skipped: 0, + }); + expect(redisCommand.expirePrepare).toHaveBeenCalledWith( + matchId, + expect.objectContaining({ + bidRoundExpiryRetryDelayMS: 3000, + matchId, + }), + ); + expect(auctionService.completePreparedExpiry).toHaveBeenCalledTimes(1); + }); + + it('skips noop expiry preparations', async () => { + const { auctionService, scheduler } = makeScheduler({ + dueReply: ['665f2f01f1f1f1f1f1f1f1f1'], + expireReply: { + code: 'NOT_DUE', + currentServerTimestampMS: 1000, + noop: true, + }, + }); + + await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({ + completed: 0, + prepared: 0, + skipped: 1, + }); + expect(auctionService.completePreparedExpiry).not.toHaveBeenCalled(); + }); + + it('removes invalid deadline queue members', async () => { + const { scheduler, sendCommand } = makeScheduler({ + dueReply: ['not-a-match-id'], + }); + + await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({ + completed: 0, + prepared: 0, + skipped: 1, + }); + expect(sendCommand).toHaveBeenLastCalledWith([ + 'ZREM', + 'auction:bidRoundDeadlineQueue', + 'not-a-match-id', + ]); + }); + + it('continues processing later deadline items after one item fails', async () => { + const matchIds = [ + '665f2f01f1f1f1f1f1f1f1f1', + '665f2f02f1f1f1f1f1f1f1f1', + ]; + const { auctionService, redisCommand, scheduler } = makeScheduler({ + dueReply: matchIds, + }); + redisCommand.expirePrepare + .mockRejectedValueOnce(new Error('temporary redis error')) + .mockResolvedValueOnce({ + auctionStateTransitionId: 'expire-2', + bidRoundExpiryDecision: 'passed', + currentServerTimestampMS: 1000, + ok: true, + revision: 3, + }); + + await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({ + completed: 1, + prepared: 1, + skipped: 1, + }); + expect(redisCommand.expirePrepare).toHaveBeenCalledTimes(2); + expect(auctionService.completePreparedExpiry).toHaveBeenCalledTimes(1); + }); +}); diff --git a/apps/api/src/modules/auction/auction-deadline.scheduler.ts b/apps/api/src/modules/auction/auction-deadline.scheduler.ts new file mode 100644 index 00000000..43f568a6 --- /dev/null +++ b/apps/api/src/modules/auction/auction-deadline.scheduler.ts @@ -0,0 +1,150 @@ +import { + Injectable, + Logger, + OnModuleDestroy, + OnModuleInit, +} from '@nestjs/common'; +import { randomUUID } from 'crypto'; +import mongoose from 'mongoose'; +import { AuctionService } from './auction.service'; +import { AuctionRedisCommandService } from './redis/auction-redis-command.service'; +import { AuctionRedisService } from './redis/auction-redis.service'; + +const BID_ROUND_DEADLINE_QUEUE_KEY = 'auction:bidRoundDeadlineQueue'; +const BID_ROUND_EXPIRY_RETRY_DELAY_MS = 3000; +const BID_ROUND_DEADLINE_TICK_INTERVAL_MS = 1000; +const BID_ROUND_DEADLINE_BATCH_LIMIT = 20; +const BID_ROUND_DEADLINE_LEADER_LOCK_KEY = + 'auction:bidRoundDeadlineScheduler:leader'; +const BID_ROUND_DEADLINE_LEADER_LOCK_TTL_MS = 2500; + +@Injectable() +export class AuctionDeadlineScheduler implements OnModuleInit, OnModuleDestroy { + private readonly logger = new Logger(AuctionDeadlineScheduler.name); + private tickTimer?: NodeJS.Timeout; + private tickInProgress = false; + + constructor( + private readonly auctionRedisService: AuctionRedisService, + private readonly auctionRedisCommandService: AuctionRedisCommandService, + private readonly auctionService: AuctionService, + ) {} + + public onModuleInit(): void { + this.tickTimer = setInterval( + () => void this.safeTick(), + BID_ROUND_DEADLINE_TICK_INTERVAL_MS, + ); + this.tickTimer.unref?.(); + } + + public onModuleDestroy(): void { + if (this.tickTimer) clearInterval(this.tickTimer); + } + + private async safeTick(): Promise { + if (this.tickInProgress) return; + this.tickInProgress = true; + const leaderLockToken = randomUUID(); + let leaderLockAcquired = false; + try { + leaderLockAcquired = await this.auctionRedisService.acquireTokenLock( + BID_ROUND_DEADLINE_LEADER_LOCK_KEY, + leaderLockToken, + BID_ROUND_DEADLINE_LEADER_LOCK_TTL_MS, + ); + if (!leaderLockAcquired) return; + await this.processDueBidRoundDeadlines(BID_ROUND_DEADLINE_BATCH_LIMIT); + } catch (error) { + this.logger.warn( + `Auction deadline tick failed: ${ + error instanceof Error ? error.message : error + }`, + ); + } finally { + if (leaderLockAcquired) { + await this.auctionRedisService.releaseTokenLock( + BID_ROUND_DEADLINE_LEADER_LOCK_KEY, + leaderLockToken, + ); + } + this.tickInProgress = false; + } + } + + public async readDueMatchIds( + currentRedisTimestampMS: number, + batchLimit: number, + ): Promise { + const reply = await this.auctionRedisService.raw().sendCommand([ + 'ZRANGEBYSCORE', + BID_ROUND_DEADLINE_QUEUE_KEY, + '-inf', + String(currentRedisTimestampMS), + 'LIMIT', + '0', + String(batchLimit), + ]); + return Array.isArray(reply) ? reply.map(String) : []; + } + + public async processDueBidRoundDeadlines(batchLimit: number): Promise<{ + completed: number; + prepared: number; + skipped: number; + }> { + const currentRedisTimestampMS = + await this.auctionRedisService.getCurrentRedisTimestampMS(); + const matchIds = await this.readDueMatchIds( + currentRedisTimestampMS, + batchLimit, + ); + let prepared = 0; + let completed = 0; + let skipped = 0; + + for (const matchId of matchIds) { + if (!mongoose.isValidObjectId(matchId)) { + skipped += 1; + await this.removeBidRoundDeadlineQueueEntry(matchId); + continue; + } + try { + const result = await this.auctionRedisCommandService.expirePrepare( + matchId, + { + auctionStateTransitionId: `expire:${matchId}:${randomUUID()}`, + bidRoundExpiryRetryDelayMS: BID_ROUND_EXPIRY_RETRY_DELAY_MS, + matchId, + }, + ); + if ('noop' in result) { + skipped += 1; + continue; + } + prepared += 1; + const completedState = await this.auctionService.completePreparedExpiry( + new mongoose.Types.ObjectId(matchId), + ); + if (completedState) completed += 1; + } catch (error) { + skipped += 1; + this.logger.warn( + `Auction deadline item failed for ${matchId}: ${ + error instanceof Error ? error.message : error + }`, + ); + } + } + + return { completed, prepared, skipped }; + } + + private async removeBidRoundDeadlineQueueEntry(matchId: string): Promise { + await this.auctionRedisService.raw().sendCommand([ + 'ZREM', + BID_ROUND_DEADLINE_QUEUE_KEY, + matchId, + ]); + } +} diff --git a/apps/api/src/modules/auction/auction-durability.scheduler.spec.ts b/apps/api/src/modules/auction/auction-durability.scheduler.spec.ts new file mode 100644 index 00000000..b7b0e90f --- /dev/null +++ b/apps/api/src/modules/auction/auction-durability.scheduler.spec.ts @@ -0,0 +1,1012 @@ +import { + AuctionDurabilityScheduler, + buildAuctionHistoryUpsert, + buildAuctionProjectionGuardedUpdate, + buildSideEffectApplicationUpsert, + shouldApplyAuctionProjection, + shouldProcessAuctionDurabilityPayload, +} from './auction-durability.scheduler'; + +const payload = { + actorUserId: 'user-1', + afterAuctionMongoProjection: { phase: 'sold', revision: 9 }, + auctionActionType: 'sold', + auctionHistorySequence: 4, + auctionId: 'auction-1', + auctionLifecycleId: 'life-1', + auctionStateTransitionId: 'transition-1', + committedAtRedisTimestampMS: 1780000000000, + matchId: 'match-1', + matchSideEffectMutation: { type: 'none' }, + revision: 9, + snapshotBefore: { phase: 'bidding' }, +} as const; + +describe('auction durability projection helpers', () => { + it('builds idempotent history upsert by auction and transition id', () => { + expect(buildAuctionHistoryUpsert(payload)).toEqual({ + updateOne: { + filter: { + auctionId: 'auction-1', + auctionStateTransitionId: 'transition-1', + }, + update: { + $setOnInsert: { + action: 'sold', + actorUserId: 'user-1', + auctionId: 'auction-1', + auctionLifecycleId: 'life-1', + auctionStateTransitionId: 'transition-1', + matchId: 'match-1', + matchSideEffectMutation: { type: 'none' }, + revision: 9, + sequence: 4, + snapshotBefore: { phase: 'bidding' }, + takenAt: new Date(1780000000000), + }, + }, + upsert: true, + }, + }); + }); + + it('guards projection updates by lifecycle and lower revision', () => { + expect(buildAuctionProjectionGuardedUpdate(payload)).toEqual({ + filter: { + _id: 'auction-1', + auctionLifecycleId: 'life-1', + revision: { $lt: 9 }, + }, + update: { + $set: { phase: 'sold', revision: 9 }, + }, + }); + }); + + it('builds idempotent side-effect application upsert', () => { + expect( + buildSideEffectApplicationUpsert(payload, { + type: 'syncMatchTeamsAfterComplete', + }), + ).toEqual({ + filter: { + auctionId: 'auction-1', + auctionStateTransitionId: 'transition-1', + sideEffectType: 'syncMatchTeamsAfterComplete', + }, + update: { + $setOnInsert: expect.objectContaining({ + attempts: 0, + auctionId: 'auction-1', + auctionLifecycleId: 'life-1', + auctionStateTransitionId: 'transition-1', + matchId: 'match-1', + payload: { type: 'syncMatchTeamsAfterComplete' }, + sideEffectType: 'syncMatchTeamsAfterComplete', + state: 'pending', + }), + }, + }); + }); + + it.each([ + { current: { auctionLifecycleId: 'life-1', revision: 8 }, expected: true }, + { current: { auctionLifecycleId: 'life-1', revision: 9 }, expected: false }, + { current: { auctionLifecycleId: 'new-life', revision: 1 }, expected: false }, + ])('decides whether projection can apply %#', ({ current, expected }) => { + expect(shouldApplyAuctionProjection(current, payload)).toBe(expected); + }); + + it.each([ + { current: { auctionLifecycleId: 'life-1', revision: 8 }, expected: true }, + { current: { auctionLifecycleId: 'life-1', revision: 9 }, expected: true }, + { current: { auctionLifecycleId: 'life-1', revision: 10 }, expected: false }, + { current: { auctionLifecycleId: 'new-life', revision: 1 }, expected: false }, + { current: {}, expected: false }, + ])('decides whether a durability payload can be processed %#', ({ current, expected }) => { + expect(shouldProcessAuctionDurabilityPayload(current, payload)).toBe( + expected, + ); + }); + + it('reads due durability payload keys from Redis', async () => { + const sendCommand = jest.fn().mockResolvedValue(['payload-1']); + const scheduler = new AuctionDurabilityScheduler( + { getModel: jest.fn(), createSession: jest.fn() } as never, + { + raw: jest.fn().mockReturnValue({ sendCommand }), + } as never, + ); + + await expect( + scheduler.readDueDurabilityPayloadKeys(1000, 10), + ).resolves.toEqual(['payload-1']); + expect(sendCommand).toHaveBeenCalledWith([ + 'ZRANGEBYSCORE', + 'auction:auctionDurabilityRetryQueue', + '-inf', + '1000', + 'LIMIT', + '0', + '10', + ]); + }); + + it('parses a durability payload hash', async () => { + const scheduler = new AuctionDurabilityScheduler( + { getModel: jest.fn(), createSession: jest.fn() } as never, + { + raw: jest.fn().mockReturnValue({ + sendCommand: jest.fn().mockResolvedValue({ + broadcastStateRevision: '9', + committedAtRedisTimestampMS: '1780000000000', + payloadJson: JSON.stringify(payload), + shouldBroadcastState: '1', + }), + }), + } as never, + ); + + await expect(scheduler.readDurabilityPayload('payload-1')).resolves.toEqual( + { + ...payload, + broadcastStateRevision: 9, + shouldBroadcastState: true, + }, + ); + }); + + it('applies history and projection updates in a session', async () => { + const session = { + abortTransaction: jest.fn().mockResolvedValue(undefined), + commitTransaction: jest.fn().mockResolvedValue(undefined), + endSession: jest.fn().mockResolvedValue(undefined), + startTransaction: jest.fn(), + }; + const historyUpdateOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ upsertedCount: 1 }), + }); + const auctionUpdateOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ modifiedCount: 1 }), + }); + const scheduler = new AuctionDurabilityScheduler( + { + createSession: jest.fn().mockResolvedValue(session), + getModel: jest.fn((name: string) => + name === 'auctionHistory' + ? { updateOne: historyUpdateOne } + : { updateOne: auctionUpdateOne }, + ), + } as never, + { raw: jest.fn() } as never, + ); + + await scheduler.applyDurabilityPayload(payload); + + expect(session.startTransaction).toHaveBeenCalledTimes(1); + expect(historyUpdateOne).toHaveBeenCalledWith( + { + auctionId: 'auction-1', + auctionStateTransitionId: 'transition-1', + }, + expect.objectContaining({ $setOnInsert: expect.any(Object) }), + { session, upsert: true }, + ); + expect(auctionUpdateOne).toHaveBeenCalledWith( + { + _id: 'auction-1', + auctionLifecycleId: 'life-1', + revision: { $lt: 9 }, + }, + { $set: { phase: 'sold', revision: 9 } }, + { session }, + ); + expect(session.commitTransaction).toHaveBeenCalledTimes(1); + expect(session.endSession).toHaveBeenCalledTimes(1); + }); + + it('broadcasts latest Redis state when durability payload requests it', async () => { + const session = { + abortTransaction: jest.fn().mockResolvedValue(undefined), + commitTransaction: jest.fn().mockResolvedValue(undefined), + endSession: jest.fn().mockResolvedValue(undefined), + startTransaction: jest.fn(), + }; + const historyUpdateOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ upsertedCount: 1 }), + }); + const auctionUpdateOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ modifiedCount: 1 }), + }); + const readAuctionStateView = jest.fn().mockResolvedValue({ + auctionLifecycleId: 'life-1', + phase: 'sold', + revision: 9, + }); + const broadcastState = jest.fn(); + const scheduler = new AuctionDurabilityScheduler( + { + createSession: jest.fn().mockResolvedValue(session), + getModel: jest.fn((name: string) => + name === 'auctionHistory' + ? { updateOne: historyUpdateOne } + : { updateOne: auctionUpdateOne }, + ), + } as never, + { raw: jest.fn() } as never, + undefined, + undefined, + undefined, + { broadcastState } as never, + { readAuctionStateView } as never, + ); + + await scheduler.applyDurabilityPayload({ + ...payload, + broadcastStateRevision: 9, + shouldBroadcastState: true, + }); + + expect(readAuctionStateView).toHaveBeenCalledWith('match-1'); + expect(broadcastState).toHaveBeenCalledWith('match-1', { + auctionLifecycleId: 'life-1', + phase: 'sold', + revision: 9, + }); + }); + + it('does not broadcast stale Redis state below requested revision', async () => { + const session = { + abortTransaction: jest.fn().mockResolvedValue(undefined), + commitTransaction: jest.fn().mockResolvedValue(undefined), + endSession: jest.fn().mockResolvedValue(undefined), + startTransaction: jest.fn(), + }; + const historyUpdateOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ upsertedCount: 1 }), + }); + const auctionUpdateOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ modifiedCount: 1 }), + }); + const readAuctionStateView = jest.fn().mockResolvedValue({ + auctionLifecycleId: 'life-1', + phase: 'bidding', + revision: 8, + }); + const broadcastState = jest.fn(); + const scheduler = new AuctionDurabilityScheduler( + { + createSession: jest.fn().mockResolvedValue(session), + getModel: jest.fn((name: string) => + name === 'auctionHistory' + ? { updateOne: historyUpdateOne } + : { updateOne: auctionUpdateOne }, + ), + } as never, + { raw: jest.fn() } as never, + undefined, + undefined, + undefined, + { broadcastState } as never, + { readAuctionStateView } as never, + ); + + await scheduler.applyDurabilityPayload({ + ...payload, + broadcastStateRevision: 9, + shouldBroadcastState: true, + }); + + expect(readAuctionStateView).toHaveBeenCalledWith('match-1'); + expect(broadcastState).not.toHaveBeenCalled(); + }); + + it('applies undo history mutation only when projection can advance', async () => { + const session = { + abortTransaction: jest.fn().mockResolvedValue(undefined), + commitTransaction: jest.fn().mockResolvedValue(undefined), + endSession: jest.fn().mockResolvedValue(undefined), + startTransaction: jest.fn(), + }; + const historyDeleteMany = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ deletedCount: 2 }), + }); + const historyUpdateOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ upsertedCount: 1 }), + }); + const auctionUpdateOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ modifiedCount: 1 }), + }); + const projectionExec = jest.fn().mockResolvedValue({ + auctionLifecycleId: 'life-1', + revision: 8, + }); + const auctionFindById = jest.fn().mockReturnValue({ + select: jest.fn().mockReturnValue({ + session: jest.fn().mockReturnValue({ + lean: jest.fn().mockReturnValue({ exec: projectionExec }), + }), + }), + }); + const scheduler = new AuctionDurabilityScheduler( + { + createSession: jest.fn().mockResolvedValue(session), + getModel: jest.fn((name: string) => { + if (name === 'auctionHistory') { + return { deleteMany: historyDeleteMany, updateOne: historyUpdateOne }; + } + if (name === 'auction') { + return { findById: auctionFindById, updateOne: auctionUpdateOne }; + } + return { updateOne: jest.fn() }; + }), + } as never, + { raw: jest.fn() } as never, + ); + + await scheduler.applyDurabilityPayload({ + ...payload, + historyMutation: { + targetHistorySequence: 2, + type: 'deleteAfterSequenceAndAppendUndo', + }, + }); + + expect(historyDeleteMany).toHaveBeenCalledWith( + { + auctionId: 'auction-1', + sequence: { $gt: 2 }, + }, + { session }, + ); + expect(historyUpdateOne).toHaveBeenCalledWith( + { + auctionId: 'auction-1', + auctionStateTransitionId: 'transition-1', + }, + expect.objectContaining({ + $setOnInsert: expect.objectContaining({ + historyMutation: { + targetHistorySequence: 2, + type: 'deleteAfterSequenceAndAppendUndo', + }, + }), + }), + { session, upsert: true }, + ); + }); + + it('skips destructive history mutation for stale payloads', async () => { + const session = { + abortTransaction: jest.fn().mockResolvedValue(undefined), + commitTransaction: jest.fn().mockResolvedValue(undefined), + endSession: jest.fn().mockResolvedValue(undefined), + startTransaction: jest.fn(), + }; + const historyDeleteMany = jest.fn(); + const historyUpdateOne = jest.fn(); + const auctionUpdateOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ matchedCount: 0, modifiedCount: 0 }), + }); + const projectionExec = jest.fn().mockResolvedValue({ + auctionLifecycleId: 'life-1', + revision: 10, + }); + const auctionFindById = jest.fn().mockReturnValue({ + select: jest.fn().mockReturnValue({ + session: jest.fn().mockReturnValue({ + lean: jest.fn().mockReturnValue({ exec: projectionExec }), + }), + }), + }); + const scheduler = new AuctionDurabilityScheduler( + { + createSession: jest.fn().mockResolvedValue(session), + getModel: jest.fn((name: string) => { + if (name === 'auctionHistory') { + return { deleteMany: historyDeleteMany, updateOne: historyUpdateOne }; + } + if (name === 'auction') { + return { findById: auctionFindById, updateOne: auctionUpdateOne }; + } + return { updateOne: jest.fn() }; + }), + } as never, + { raw: jest.fn() } as never, + ); + + await scheduler.applyDurabilityPayload({ + ...payload, + historyMutation: { + targetHistorySequence: 2, + type: 'deleteAfterSequenceAndAppendUndo', + }, + }); + + expect(historyDeleteMany).not.toHaveBeenCalled(); + expect(historyUpdateOne).not.toHaveBeenCalled(); + expect(auctionUpdateOne).not.toHaveBeenCalled(); + }); + + it('processes due payloads and clears successful outbox entries', async () => { + const sendCommand = jest + .fn() + .mockResolvedValueOnce(['payload-1']) + .mockResolvedValueOnce({ + committedAtRedisTimestampMS: '1780000000000', + payloadJson: JSON.stringify(payload), + }) + .mockResolvedValueOnce(1) + .mockResolvedValueOnce(1); + const scheduler = new AuctionDurabilityScheduler( + { + createSession: jest.fn().mockResolvedValue(null), + getModel: jest.fn((name: string) => + name === 'auctionHistory' + ? { + updateOne: jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({}), + }), + } + : { + updateOne: jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({}), + }), + }, + ), + } as never, + { + getCurrentRedisTimestampMS: jest.fn().mockResolvedValue(1000), + raw: jest.fn().mockReturnValue({ sendCommand }), + } as never, + ); + + await expect(scheduler.processDueDurabilityPayloads(10)).resolves.toEqual({ + applied: 1, + failed: 0, + skipped: 0, + }); + expect(sendCommand).toHaveBeenLastCalledWith(['DEL', 'payload-1']); + }); + + it('requeues failed durability payloads with an incremented attempt count', async () => { + const sendCommand = jest + .fn() + .mockResolvedValueOnce(['payload-1']) + .mockResolvedValueOnce({ + committedAtRedisTimestampMS: '1780000000000', + payloadJson: JSON.stringify(payload), + }) + .mockResolvedValueOnce(1) + .mockResolvedValueOnce(1) + .mockResolvedValueOnce(1); + const scheduler = new AuctionDurabilityScheduler( + { createSession: jest.fn(), getModel: jest.fn() } as never, + { + getCurrentRedisTimestampMS: jest.fn().mockResolvedValue(1000), + raw: jest.fn().mockReturnValue({ sendCommand }), + } as never, + ); + jest + .spyOn(scheduler, 'applyDurabilityPayload') + .mockRejectedValue(new Error('mongo down')); + + await expect(scheduler.processDueDurabilityPayloads(10)).resolves.toEqual({ + applied: 0, + failed: 1, + skipped: 0, + }); + expect(sendCommand).toHaveBeenNthCalledWith(3, [ + 'HINCRBY', + 'payload-1', + 'attempts', + '1', + ]); + expect(sendCommand).toHaveBeenNthCalledWith(4, [ + 'HSET', + 'payload-1', + 'lastError', + 'mongo down', + 'lastFailedAtRedisTimestampMS', + '1000', + ]); + expect(sendCommand).toHaveBeenNthCalledWith(5, [ + 'ZADD', + 'auction:auctionDurabilityRetryQueue', + '6000', + 'payload-1', + ]); + }); + + it('uses bounded exponential backoff for repeated durability failures', async () => { + const sendCommand = jest + .fn() + .mockResolvedValueOnce(['payload-1']) + .mockResolvedValueOnce({ + committedAtRedisTimestampMS: '1780000000000', + payloadJson: JSON.stringify(payload), + }) + .mockResolvedValueOnce(3) + .mockResolvedValueOnce(1) + .mockResolvedValueOnce(1); + const scheduler = new AuctionDurabilityScheduler( + { createSession: jest.fn(), getModel: jest.fn() } as never, + { + getCurrentRedisTimestampMS: jest.fn().mockResolvedValue(1000), + raw: jest.fn().mockReturnValue({ sendCommand }), + } as never, + ); + jest + .spyOn(scheduler, 'applyDurabilityPayload') + .mockRejectedValue(new Error('mongo down')); + + await expect(scheduler.processDueDurabilityPayloads(10)).resolves.toEqual({ + applied: 0, + failed: 1, + skipped: 0, + }); + expect(sendCommand).toHaveBeenNthCalledWith(5, [ + 'ZADD', + 'auction:auctionDurabilityRetryQueue', + '21000', + 'payload-1', + ]); + }); + + it('moves repeatedly failing durability payloads to the dead-letter queue', async () => { + const sendCommand = jest + .fn() + .mockResolvedValueOnce(['payload-1']) + .mockResolvedValueOnce({ + committedAtRedisTimestampMS: '1780000000000', + payloadJson: JSON.stringify(payload), + }) + .mockResolvedValueOnce(10) + .mockResolvedValueOnce(1) + .mockResolvedValueOnce(1) + .mockResolvedValueOnce(1) + .mockResolvedValueOnce(1); + const scheduler = new AuctionDurabilityScheduler( + { createSession: jest.fn(), getModel: jest.fn() } as never, + { + getCurrentRedisTimestampMS: jest.fn().mockResolvedValue(1000), + raw: jest.fn().mockReturnValue({ sendCommand }), + } as never, + ); + jest + .spyOn(scheduler, 'applyDurabilityPayload') + .mockRejectedValue(new Error('side effect down')); + + await expect(scheduler.processDueDurabilityPayloads(10)).resolves.toEqual({ + applied: 0, + failed: 1, + skipped: 0, + }); + expect(sendCommand).toHaveBeenNthCalledWith(5, [ + 'ZREM', + 'auction:auctionDurabilityRetryQueue', + 'payload-1', + ]); + expect(sendCommand).toHaveBeenNthCalledWith(6, [ + 'HSET', + 'payload-1', + 'deadLetteredAtRedisTimestampMS', + '1000', + ]); + expect(sendCommand).toHaveBeenNthCalledWith(7, [ + 'ZADD', + 'auction:auctionDurabilityDeadLetterQueue', + '1000', + 'payload-1', + ]); + }); + + it('processes durability ticks only while holding the Redis leader lock', async () => { + const scheduler = new AuctionDurabilityScheduler( + { createSession: jest.fn(), getModel: jest.fn() } as never, + { + acquireTokenLock: jest.fn().mockResolvedValue(true), + releaseTokenLock: jest.fn().mockResolvedValue(true), + } as never, + ); + const processDueDurabilityPayloadsSpy = jest + .spyOn(scheduler, 'processDueDurabilityPayloads') + .mockResolvedValue({ applied: 0, failed: 0, skipped: 0 }); + + await (scheduler as unknown as { safeTick: () => Promise }).safeTick(); + + const auctionRedisService = ( + scheduler as unknown as { + auctionRedisService: { + acquireTokenLock: jest.Mock; + releaseTokenLock: jest.Mock; + }; + } + ).auctionRedisService; + const leaderLockToken = + auctionRedisService.acquireTokenLock.mock.calls[0]?.[1]; + expect(auctionRedisService.acquireTokenLock).toHaveBeenCalledWith( + 'auction:auctionDurabilityScheduler:leader', + expect.any(String), + 2500, + ); + expect(processDueDurabilityPayloadsSpy).toHaveBeenCalledWith(20); + expect(auctionRedisService.releaseTokenLock).toHaveBeenCalledWith( + 'auction:auctionDurabilityScheduler:leader', + leaderLockToken, + ); + }); + + it('skips durability ticks when another instance holds the leader lock', async () => { + const scheduler = new AuctionDurabilityScheduler( + { createSession: jest.fn(), getModel: jest.fn() } as never, + { + acquireTokenLock: jest.fn().mockResolvedValue(false), + releaseTokenLock: jest.fn().mockResolvedValue(true), + } as never, + ); + const processDueDurabilityPayloadsSpy = jest + .spyOn(scheduler, 'processDueDurabilityPayloads') + .mockResolvedValue({ applied: 0, failed: 0, skipped: 0 }); + + await (scheduler as unknown as { safeTick: () => Promise }).safeTick(); + + const auctionRedisService = ( + scheduler as unknown as { + auctionRedisService: { + releaseTokenLock: jest.Mock; + }; + } + ).auctionRedisService; + expect(processDueDurabilityPayloadsSpy).not.toHaveBeenCalled(); + expect(auctionRedisService.releaseTokenLock).not.toHaveBeenCalled(); + }); + + it('applies sync match teams side effect after durable projection', async () => { + const completePayload = { + ...payload, + afterAuctionMongoProjection: { + auctionTeams: [ + { + teamIndex: 1, + captainUserId: 'captain-1', + members: [ + { + assignedPosition: 'ADC', + memberAcquisitionBidPointAmount: 30, + userId: 'member-1', + }, + ], + }, + ], + matchSideEffectRevision: 1, + phase: 'complete', + revision: 10, + }, + auctionActionType: 'complete', + matchSideEffectMutation: { type: 'syncMatchTeamsAfterComplete' }, + revision: 10, + } as const; + const match = { + participants: [ + { + userId: { toString: () => 'captain-1' }, + preferredPositions: [{ position: 'TOP' }], + }, + { + userId: { toString: () => 'member-1' }, + preferredPositions: [{ position: 'ADC' }], + }, + ], + save: jest.fn().mockResolvedValue(undefined), + status: 'recruiting', + teamBuiltAt: undefined, + teams: [], + }; + const historyUpdateOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ upsertedCount: 1 }), + }); + const auctionUpdateOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ modifiedCount: 1 }), + }); + const auctionFindOneAndUpdate = jest + .fn() + .mockReturnValueOnce({ + exec: jest.fn().mockResolvedValue({ + auctionLifecycleId: 'life-1', + matchSideEffectRevision: 2, + matchSideEffectStatus: 'processing', + }), + }) + .mockReturnValueOnce({ + exec: jest.fn().mockResolvedValue({ + auctionLifecycleId: 'life-1', + matchSideEffectRevision: 3, + matchSideEffectStatus: 'completed', + }), + }); + const sideEffectUpdateOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ matchedCount: 1, modifiedCount: 1 }), + }); + const reserveForMatch = jest.fn().mockResolvedValue(match); + const scheduleInitialPoll = jest.fn().mockResolvedValue(null); + const mirrorMatchSideEffectStatus = jest.fn().mockResolvedValue(true); + const broadcastMatchSideEffect = jest.fn(); + const sendCommand = jest.fn().mockResolvedValue(1); + const scheduler = new AuctionDurabilityScheduler( + { + createSession: jest.fn().mockResolvedValue(null), + getModel: jest.fn((name: string) => { + if (name === 'auctionHistory') return { updateOne: historyUpdateOne }; + if (name === 'auction') { + return { + findOneAndUpdate: auctionFindOneAndUpdate, + updateOne: auctionUpdateOne, + }; + } + if (name === 'auctionSideEffectApplication') { + return { updateOne: sideEffectUpdateOne }; + } + if (name === 'match') return { findById: jest.fn().mockReturnValue(match) }; + return {}; + }), + } as never, + { + getCurrentRedisTimestampMS: jest + .fn() + .mockResolvedValueOnce(2000) + .mockResolvedValueOnce(3000), + raw: jest.fn().mockReturnValue({ sendCommand }), + } as never, + { reserveForMatch } as never, + { scheduleInitialPoll } as never, + { mirrorMatchSideEffectStatus } as never, + { broadcastMatchSideEffect } as never, + ); + + await scheduler.applyDurabilityPayload(completePayload); + + expect(match.teams).toEqual([ + { + captainUserId: 'captain-1', + members: [ + { assignedPosition: 'TOP', cost: 0, userId: 'captain-1' }, + { assignedPosition: 'ADC', cost: 30, userId: 'member-1' }, + ], + name: '1팀', + teamIndex: 1, + }, + ]); + expect(match.save).toHaveBeenCalledTimes(1); + expect(reserveForMatch).toHaveBeenCalledWith(match); + expect(scheduleInitialPoll).toHaveBeenCalledWith(match); + expect(sideEffectUpdateOne).toHaveBeenCalledWith( + expect.objectContaining({ + auctionId: 'auction-1', + auctionStateTransitionId: 'transition-1', + sideEffectType: 'syncMatchTeamsAfterComplete', + }), + expect.objectContaining({ $setOnInsert: expect.any(Object) }), + { session: null, upsert: true }, + ); + expect(auctionFindOneAndUpdate).toHaveBeenNthCalledWith( + 1, + { + _id: 'auction-1', + auctionLifecycleId: 'life-1', + matchSideEffectRevision: 1, + }, + { + $inc: { matchSideEffectRevision: 1 }, + $set: { matchSideEffectStatus: 'processing' }, + $unset: { matchSideEffectError: '' }, + }, + expect.objectContaining({ returnDocument: 'after' }), + ); + expect(auctionFindOneAndUpdate).toHaveBeenNthCalledWith( + 2, + { + _id: 'auction-1', + auctionLifecycleId: 'life-1', + matchSideEffectRevision: 2, + }, + { + $inc: { matchSideEffectRevision: 1 }, + $set: { matchSideEffectStatus: 'completed' }, + $unset: { matchSideEffectError: '' }, + }, + expect.objectContaining({ returnDocument: 'after' }), + ); + expect(mirrorMatchSideEffectStatus).toHaveBeenCalledWith({ + auctionLifecycleId: 'life-1', + matchId: 'match-1', + matchSideEffectRevision: 2, + matchSideEffectStatus: 'processing', + }); + expect(mirrorMatchSideEffectStatus).toHaveBeenLastCalledWith({ + auctionLifecycleId: 'life-1', + matchId: 'match-1', + matchSideEffectRevision: 3, + matchSideEffectStatus: 'completed', + }); + expect(broadcastMatchSideEffect).toHaveBeenNthCalledWith( + 1, + 'match-1', + { + auctionLifecycleId: 'life-1', + currentServerTimestampMS: 2000, + matchSideEffectRevision: 2, + matchSideEffectStatus: 'processing', + }, + ); + expect(broadcastMatchSideEffect).toHaveBeenNthCalledWith( + 2, + 'match-1', + { + auctionLifecycleId: 'life-1', + currentServerTimestampMS: 3000, + matchSideEffectRevision: 3, + matchSideEffectStatus: 'completed', + }, + ); + expect(sendCommand).toHaveBeenCalledWith([ + 'EVAL', + expect.stringContaining("redis.call('EXPIRE'"), + '11', + 'auction:match-1:liveAuctionState', + 'auction:bidRoundDeadlineQueue', + 'auction:match-1:auctionStructureState', + 'auction:match-1:appliedAuctionStateTransitionIds', + 'auction:match-1:auctionBidHistory', + 'auction:match-1:bidRequestResults', + 'auction:match-1:bidRequestResultOrder', + 'auction:match-1:auctionActionRequestResults', + 'auction:match-1:auctionActionRequestResultOrder', + 'auction:match-1:rehydrateLock', + 'auction:match-1:auctionStateTransitionLock', + 'match-1', + 'life-1', + String(7 * 24 * 60 * 60), + ]); + }); + + it('applies reset match side effect after durable projection', async () => { + const resetPayload = { + ...payload, + afterAuctionMongoProjection: { + matchSideEffectRevision: 1, + matchSideEffectStatus: 'pending', + phase: 'waiting', + revision: 10, + }, + auctionActionType: 'reset', + historyMutation: { resetMode: 'clear-history', type: 'reset' }, + matchSideEffectMutation: { type: 'resetMatchAfterAuctionReset' }, + revision: 10, + } as const; + const match = { + gameSchedule: [{ gameNumber: 1 }], + participants: [{ excluded: true }, { excluded: false }], + result: { games: [] }, + resultPollState: { state: 'polling' }, + save: jest.fn().mockResolvedValue(undefined), + status: 'team-built', + teamBuiltAt: new Date(1780000000000), + teams: [{ teamIndex: 1 }], + tournamentCodeIds: ['code-1'], + }; + const historyDeleteMany = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ deletedCount: 3 }), + }); + const historyUpdateOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ upsertedCount: 1 }), + }); + const auctionUpdateOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ modifiedCount: 1 }), + }); + const projectionExec = jest.fn().mockResolvedValue({ + auctionLifecycleId: 'life-1', + revision: 9, + }); + const auctionFindById = jest.fn().mockReturnValue({ + select: jest.fn().mockReturnValue({ + session: jest.fn().mockReturnValue({ + lean: jest.fn().mockReturnValue({ exec: projectionExec }), + }), + }), + }); + const auctionFindOneAndUpdate = jest + .fn() + .mockReturnValueOnce({ + exec: jest.fn().mockResolvedValue({ + auctionLifecycleId: 'life-1', + matchSideEffectRevision: 2, + matchSideEffectStatus: 'processing', + }), + }) + .mockReturnValueOnce({ + exec: jest.fn().mockResolvedValue({ + auctionLifecycleId: 'life-1', + matchSideEffectRevision: 3, + matchSideEffectStatus: 'completed', + }), + }); + const sideEffectUpdateOne = jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ matchedCount: 1, modifiedCount: 1 }), + }); + const releaseFromMatch = jest.fn().mockResolvedValue(undefined); + const cancelPolling = jest.fn().mockResolvedValue(undefined); + const mirrorMatchSideEffectStatus = jest.fn().mockResolvedValue(true); + const broadcastMatchSideEffect = jest.fn(); + const scheduler = new AuctionDurabilityScheduler( + { + createSession: jest.fn().mockResolvedValue(null), + getModel: jest.fn((name: string) => { + if (name === 'auctionHistory') { + return { deleteMany: historyDeleteMany, updateOne: historyUpdateOne }; + } + if (name === 'auction') { + return { + findById: auctionFindById, + findOneAndUpdate: auctionFindOneAndUpdate, + updateOne: auctionUpdateOne, + }; + } + if (name === 'auctionSideEffectApplication') { + return { updateOne: sideEffectUpdateOne }; + } + if (name === 'match') return { findById: jest.fn().mockReturnValue(match) }; + return {}; + }), + } as never, + { + getCurrentRedisTimestampMS: jest + .fn() + .mockResolvedValueOnce(2000) + .mockResolvedValueOnce(3000), + raw: jest.fn(), + } as never, + { releaseFromMatch } as never, + { cancelPolling } as never, + { mirrorMatchSideEffectStatus } as never, + { broadcastMatchSideEffect } as never, + ); + + await scheduler.applyDurabilityPayload(resetPayload); + + expect(releaseFromMatch).toHaveBeenCalledWith(match); + expect(cancelPolling).toHaveBeenCalledWith(match); + expect(match).toMatchObject({ + gameSchedule: [], + result: undefined, + resultPollState: undefined, + status: 'recruiting', + teamBuiltAt: undefined, + teams: [], + tournamentCodeIds: [], + }); + expect(match.participants).toEqual([{ excluded: false }, { excluded: false }]); + expect(match.save).toHaveBeenCalledTimes(1); + expect(sideEffectUpdateOne).toHaveBeenCalledWith( + expect.objectContaining({ + auctionId: 'auction-1', + auctionStateTransitionId: 'transition-1', + sideEffectType: 'resetMatchAfterAuctionReset', + }), + expect.objectContaining({ $setOnInsert: expect.any(Object) }), + { session: null, upsert: true }, + ); + expect(mirrorMatchSideEffectStatus).toHaveBeenLastCalledWith({ + auctionLifecycleId: 'life-1', + matchId: 'match-1', + matchSideEffectRevision: 3, + matchSideEffectStatus: 'completed', + }); + expect(broadcastMatchSideEffect).toHaveBeenLastCalledWith('match-1', { + auctionLifecycleId: 'life-1', + currentServerTimestampMS: 3000, + matchSideEffectRevision: 3, + matchSideEffectStatus: 'completed', + }); + }); +}); diff --git a/apps/api/src/modules/auction/auction-durability.scheduler.ts b/apps/api/src/modules/auction/auction-durability.scheduler.ts new file mode 100644 index 00000000..6b7653a2 --- /dev/null +++ b/apps/api/src/modules/auction/auction-durability.scheduler.ts @@ -0,0 +1,1199 @@ +import { + Injectable, + Logger, + OnModuleDestroy, + OnModuleInit, + Optional, +} from '@nestjs/common'; +import { createHash, randomUUID } from 'crypto'; +import type mongoose from 'mongoose'; +import { ConnectionService } from '../global/database/connection.service'; +import type { + AuctionMatchSideEffectStatus, + MatchTeamMember, + Position, +} from '../global/database/schema'; +import { TournamentCodeService } from '../tournament-code/tournament-code.service'; +import { TournamentResultService } from '../tournament-result/tournament-result.service'; +import { AuctionEventBusService } from './auction-event-bus.service'; +import { + AuctionSideEffectService, + buildMatchSideEffectDelta, + buildSideEffectLeaseAcquireUpdate, + type MatchSideEffectDelta, +} from './auction-side-effect.service'; +import { AuctionRedisService } from './redis/auction-redis.service'; +import { AuctionRedisStateReaderService } from './redis/auction-redis-state-reader.service'; +import { + AUCTION_DURABILITY_DEAD_LETTER_QUEUE_KEY, + AUCTION_DURABILITY_RETRY_QUEUE_KEY, + buildAuctionRedisKeys, +} from './redis/auction-redis.keys'; +const AUCTION_DURABILITY_TICK_INTERVAL_MS = 1000; +const AUCTION_DURABILITY_BATCH_LIMIT = 20; +const AUCTION_DURABILITY_RETRY_DELAY_MS = 5000; +const AUCTION_DURABILITY_MAX_RETRY_DELAY_MS = 60_000; +const AUCTION_DURABILITY_MAX_ATTEMPTS = 10; +const AUCTION_DURABILITY_ERROR_MESSAGE_MAX_LENGTH = 2000; +const AUCTION_DURABILITY_LEADER_LOCK_KEY = + 'auction:auctionDurabilityScheduler:leader'; +const AUCTION_DURABILITY_LEADER_LOCK_TTL_MS = 2500; +const AUCTION_REDIS_COMPLETED_RETAIN_SECONDS = 7 * 24 * 60 * 60; +const AUCTION_SIDE_EFFECT_LEASE_DURATION_MS = 30_000; +const SYNC_MATCH_TEAMS_SIDE_EFFECT_TYPE = 'syncMatchTeamsAfterComplete'; +const RESET_MATCH_SIDE_EFFECT_TYPE = 'resetMatchAfterAuctionReset'; +const UNDO_COMPLETED_MATCH_SIDE_EFFECT_TYPE = 'undoCompletedAuctionSideEffects'; + +export interface AuctionDurabilityPayload { + actorUserId?: unknown; + afterAuctionMongoProjection: Record; + auctionActionType: string; + auctionHistorySequence: number; + auctionId: unknown; + auctionLifecycleId: string; + auctionStateTransitionId: string; + committedAtRedisTimestampMS?: number; + historyMutation?: Record; + matchId: unknown; + matchSideEffectMutation: Record; + shouldBroadcastState?: boolean; + broadcastStateRevision?: number; + revision: number; + snapshotBefore: Record; +} + +export interface AuctionProjectionIdentity { + auctionLifecycleId?: string; + revision?: number; +} + +type ParsedAuctionHistoryMutation = + | { type: 'append' } + | { targetHistorySequence: number; type: 'deleteAfterSequenceAndAppendUndo' } + | { resetMode: 'clear-history' | 'preserve-audit'; type: 'reset' }; + +type ParsedMatchSideEffectMutation = + | { type: typeof SYNC_MATCH_TEAMS_SIDE_EFFECT_TYPE } + | { type: typeof RESET_MATCH_SIDE_EFFECT_TYPE } + | { type: typeof UNDO_COMPLETED_MATCH_SIDE_EFFECT_TYPE }; + +interface CleanupSideEffectMatchDocument { + gameSchedule?: unknown[]; + participants: Array<{ excluded?: boolean }>; + result?: unknown; + resultPollState?: unknown; + save(): Promise; + status: string; + teamBuiltAt?: Date; + teams?: unknown[]; + tournamentCodeIds?: unknown[]; +} + +@Injectable() +export class AuctionDurabilityScheduler + implements OnModuleInit, OnModuleDestroy +{ + private readonly logger = new Logger(AuctionDurabilityScheduler.name); + private tickTimer?: NodeJS.Timeout; + private tickInProgress = false; + + constructor( + private readonly connectionService: ConnectionService, + private readonly auctionRedisService: AuctionRedisService, + @Optional() + private readonly tournamentCodeService?: TournamentCodeService, + @Optional() + private readonly tournamentResultService?: TournamentResultService, + @Optional() + private readonly auctionSideEffectService?: AuctionSideEffectService, + @Optional() + private readonly auctionEventBusService?: AuctionEventBusService, + @Optional() + private readonly auctionRedisStateReaderService?: AuctionRedisStateReaderService, + ) {} + + public onModuleInit(): void { + this.tickTimer = setInterval( + () => void this.safeTick(), + AUCTION_DURABILITY_TICK_INTERVAL_MS, + ); + this.tickTimer.unref?.(); + } + + public onModuleDestroy(): void { + if (this.tickTimer) clearInterval(this.tickTimer); + } + + public async readDueDurabilityPayloadKeys( + currentRedisTimestampMS: number, + batchLimit: number, + ): Promise { + const reply = await this.auctionRedisService.raw().sendCommand([ + 'ZRANGEBYSCORE', + AUCTION_DURABILITY_RETRY_QUEUE_KEY, + '-inf', + String(currentRedisTimestampMS), + 'LIMIT', + '0', + String(batchLimit), + ]); + return Array.isArray(reply) ? reply.map(String) : []; + } + + public async processDueDurabilityPayloads(batchLimit: number): Promise<{ + applied: number; + failed: number; + skipped: number; + }> { + const currentRedisTimestampMS = + await this.auctionRedisService.getCurrentRedisTimestampMS(); + const payloadKeys = await this.readDueDurabilityPayloadKeys( + currentRedisTimestampMS, + batchLimit, + ); + let applied = 0; + let failed = 0; + let skipped = 0; + + for (const payloadKey of payloadKeys) { + try { + const payload = await this.readDurabilityPayload(payloadKey); + if (!payload) { + skipped += 1; + await this.clearDurabilityPayload(payloadKey); + continue; + } + await this.applyDurabilityPayload(payload); + applied += 1; + await this.clearDurabilityPayload(payloadKey); + } catch (error) { + failed += 1; + const failureDisposition = + await this.recordDurabilityPayloadFailure( + payloadKey, + currentRedisTimestampMS, + error, + ); + this.logger.warn( + `Auction durability payload failed for ${payloadKey} (${failureDisposition}): ${ + error instanceof Error ? error.message : error + }`, + ); + } + } + + return { applied, failed, skipped }; + } + + public async readDurabilityPayload( + payloadKey: string, + ): Promise { + const reply = await this.auctionRedisService + .raw() + .sendCommand(['HGETALL', payloadKey]); + const hash = parseRedisHash(reply); + const payloadJson = hash.payloadJson; + if (!payloadJson) return null; + const payload = JSON.parse(payloadJson) as AuctionDurabilityPayload; + const committedAtRedisTimestampMS = Number(hash.committedAtRedisTimestampMS); + if (Number.isFinite(committedAtRedisTimestampMS)) { + payload.committedAtRedisTimestampMS = committedAtRedisTimestampMS; + } + payload.shouldBroadcastState = hash.shouldBroadcastState === '1'; + const broadcastStateRevision = Number(hash.broadcastStateRevision); + if (Number.isFinite(broadcastStateRevision)) { + payload.broadcastStateRevision = broadcastStateRevision; + } + return payload; + } + + public async applyDurabilityPayload( + payload: AuctionDurabilityPayload, + ): Promise { + const AuctionHistoryModel = + await this.connectionService.getModel('auctionHistory'); + const AuctionModel = await this.connectionService.getModel('auction'); + const AuctionSideEffectApplicationModel = + await this.connectionService.getModel('auctionSideEffectApplication'); + const session = await this.connectionService.createSession(); + const sideEffectMutation = parseMatchSideEffectMutation( + payload.matchSideEffectMutation, + ); + + try { + session?.startTransaction(); + if (typeof AuctionModel.findById === 'function') { + const currentProjection = await readAuctionProjectionIdentityForMutation( + AuctionModel, + payload.auctionId, + session, + ); + if (!shouldProcessAuctionDurabilityPayload(currentProjection, payload)) { + if (session) await session.commitTransaction(); + return; + } + } + await this.applyAuctionHistoryMutation({ + AuctionHistoryModel, + AuctionModel, + payload, + session, + }); + const projectionOperation = buildAuctionProjectionGuardedUpdate(payload); + await execMaybe( + AuctionModel.updateOne( + projectionOperation.filter as never, + projectionOperation.update as never, + { session } as never, + ), + ); + if (sideEffectMutation) { + const sideEffectOperation = buildSideEffectApplicationUpsert( + payload, + sideEffectMutation, + ); + await execMaybe( + AuctionSideEffectApplicationModel.updateOne( + sideEffectOperation.filter as never, + sideEffectOperation.update as never, + { + session, + upsert: true, + } as never, + ), + ); + } + if (session) await session.commitTransaction(); + } catch (error) { + if (session) await session.abortTransaction(); + throw error; + } finally { + if (session) await session.endSession(); + } + + await this.broadcastLatestRedisAuctionStateIfRequested(payload); + + if (sideEffectMutation) { + await this.applyMatchSideEffect(payload, sideEffectMutation); + } + } + + private async broadcastLatestRedisAuctionStateIfRequested( + payload: AuctionDurabilityPayload, + ): Promise { + if (!payload.shouldBroadcastState) return; + if (!this.auctionRedisStateReaderService || !this.auctionEventBusService) { + return; + } + const matchId = String(payload.matchId); + const state = + await this.auctionRedisStateReaderService.readAuctionStateView(matchId); + if (!state) return; + const stateRevision = Number(state.revision); + if ( + Number.isFinite(payload.broadcastStateRevision) && + Number.isFinite(stateRevision) && + stateRevision < Number(payload.broadcastStateRevision) + ) { + return; + } + this.auctionEventBusService.broadcastState(matchId, state); + } + + private async applyMatchSideEffect( + payload: AuctionDurabilityPayload, + mutation: ParsedMatchSideEffectMutation, + ): Promise { + if (mutation.type === SYNC_MATCH_TEAMS_SIDE_EFFECT_TYPE) { + await this.applySyncMatchTeamsSideEffect(payload, mutation); + return; + } + if (mutation.type === RESET_MATCH_SIDE_EFFECT_TYPE) { + await this.applyResetMatchSideEffect(payload, mutation); + return; + } + if (mutation.type === UNDO_COMPLETED_MATCH_SIDE_EFFECT_TYPE) { + await this.applyUndoCompletedMatchSideEffect(payload, mutation); + } + } + + private async applySyncMatchTeamsSideEffect( + payload: AuctionDurabilityPayload, + mutation: ParsedMatchSideEffectMutation, + ): Promise { + if (!this.tournamentCodeService || !this.tournamentResultService) { + throw new Error('Auction side-effect services are not available.'); + } + + const AuctionModel = await this.connectionService.getModel('auction'); + const AuctionSideEffectApplicationModel = + await this.connectionService.getModel('auctionSideEffectApplication'); + const MatchModel = await this.connectionService.getModel('match'); + const currentRedisTimestampMS = + await this.auctionRedisService.getCurrentRedisTimestampMS(); + const ownerToken = randomUUID(); + const identity = buildSideEffectApplicationIdentityFromPayload( + payload, + mutation, + ); + const leaseResult = await execMaybe( + AuctionSideEffectApplicationModel.updateOne( + { + ...identity, + $or: [ + { state: 'pending' }, + { state: 'failed' }, + { + state: 'processing', + processingLeaseExpiresAtTimestampMS: { + $lte: currentRedisTimestampMS, + }, + }, + ], + } as never, + buildSideEffectLeaseAcquireUpdate({ + currentRedisTimestampMS, + leaseDurationMS: AUCTION_SIDE_EFFECT_LEASE_DURATION_MS, + ownerToken, + }) as never, + ), + ); + if (!hasMatchedDocument(leaseResult)) return; + + const processingDelta = await this.persistAndBroadcastMatchSideEffectStatus({ + AuctionModel, + currentServerTimestampMS: currentRedisTimestampMS, + expectedMatchSideEffectRevision: Number( + payload.afterAuctionMongoProjection.matchSideEffectRevision ?? 0, + ), + payload, + status: 'processing', + }); + if (!processingDelta) return; + let expectedMatchSideEffectRevision = + processingDelta.matchSideEffectRevision; + + try { + const match = (await execMaybe( + MatchModel.findById(payload.matchId) as never, + )) as { + participants: Array<{ + preferredPositions?: Array<{ position?: Position }>; + userId: { toString(): string }; + }>; + save(): Promise; + status: string; + teamBuiltAt?: Date; + teams: ReturnType; + } | null; + if (!match) throw new Error(`Match not found: ${String(payload.matchId)}`); + match.teams = buildMatchTeamsFromProjection( + payload.afterAuctionMongoProjection, + match, + ); + match.status = 'team-built'; + match.teamBuiltAt = match.teamBuiltAt ?? new Date(); + await match.save(); + await this.tournamentCodeService.reserveForMatch(match as never); + await this.tournamentResultService.scheduleInitialPoll(match as never); + + const completedAtTimestampMS = + await this.auctionRedisService.getCurrentRedisTimestampMS(); + await execMaybe( + AuctionSideEffectApplicationModel.updateOne( + identity as never, + { + $set: { + completedAtTimestampMS, + state: 'completed', + }, + $unset: { + lastError: '', + processingLeaseExpiresAtTimestampMS: '', + processingOwnerToken: '', + processingStartedAtTimestampMS: '', + }, + } as never, + ), + ); + await this.persistAndBroadcastMatchSideEffectStatus({ + AuctionModel, + currentServerTimestampMS: completedAtTimestampMS, + errorMessage: undefined, + expectedMatchSideEffectRevision, + payload, + status: 'completed', + }); + await this.expireCompletedAuctionRedisRuntime(payload); + } catch (error) { + const failureTimestampMS = + await this.auctionRedisService.getCurrentRedisTimestampMS(); + await execMaybe( + AuctionSideEffectApplicationModel.updateOne( + identity as never, + { + $set: { + lastError: error instanceof Error ? error.message : String(error), + state: 'failed', + }, + $unset: { + processingLeaseExpiresAtTimestampMS: '', + processingOwnerToken: '', + processingStartedAtTimestampMS: '', + }, + } as never, + ), + ); + await this.persistAndBroadcastMatchSideEffectStatus({ + AuctionModel, + currentServerTimestampMS: failureTimestampMS, + errorMessage: error instanceof Error ? error.message : String(error), + expectedMatchSideEffectRevision, + payload, + status: 'failed', + }); + throw error; + } + } + + private async applyResetMatchSideEffect( + payload: AuctionDurabilityPayload, + mutation: ParsedMatchSideEffectMutation, + ): Promise { + await this.applyMatchCleanupSideEffect({ + mutation, + payload, + updateMatch: async (match) => { + await this.tournamentCodeService?.releaseFromMatch(match as never); + await this.tournamentResultService?.cancelPolling(match as never); + 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(); + }, + }); + } + + private async applyUndoCompletedMatchSideEffect( + payload: AuctionDurabilityPayload, + mutation: ParsedMatchSideEffectMutation, + ): Promise { + await this.applyMatchCleanupSideEffect({ + mutation, + payload, + updateMatch: async (match) => { + await this.tournamentCodeService?.releaseFromMatch(match as never); + await this.tournamentResultService?.cancelPolling(match as never); + match.status = 'team-built'; + match.result = undefined; + match.resultPollState = undefined; + await match.save(); + }, + }); + } + + private async applyMatchCleanupSideEffect(params: { + mutation: ParsedMatchSideEffectMutation; + payload: AuctionDurabilityPayload; + updateMatch: (match: CleanupSideEffectMatchDocument) => Promise; + }): Promise { + if (!this.tournamentCodeService || !this.tournamentResultService) { + throw new Error('Auction side-effect services are not available.'); + } + + const AuctionModel = await this.connectionService.getModel('auction'); + const AuctionSideEffectApplicationModel = + await this.connectionService.getModel('auctionSideEffectApplication'); + const MatchModel = await this.connectionService.getModel('match'); + const currentRedisTimestampMS = + await this.auctionRedisService.getCurrentRedisTimestampMS(); + const ownerToken = randomUUID(); + const identity = buildSideEffectApplicationIdentityFromPayload( + params.payload, + params.mutation, + ); + const leaseResult = await execMaybe( + AuctionSideEffectApplicationModel.updateOne( + { + ...identity, + $or: [ + { state: 'pending' }, + { state: 'failed' }, + { + state: 'processing', + processingLeaseExpiresAtTimestampMS: { + $lte: currentRedisTimestampMS, + }, + }, + ], + } as never, + buildSideEffectLeaseAcquireUpdate({ + currentRedisTimestampMS, + leaseDurationMS: AUCTION_SIDE_EFFECT_LEASE_DURATION_MS, + ownerToken, + }) as never, + ), + ); + if (!hasMatchedDocument(leaseResult)) return; + + const processingDelta = await this.persistAndBroadcastMatchSideEffectStatus({ + AuctionModel, + currentServerTimestampMS: currentRedisTimestampMS, + expectedMatchSideEffectRevision: Number( + params.payload.afterAuctionMongoProjection.matchSideEffectRevision ?? 0, + ), + payload: params.payload, + status: 'processing', + }); + if (!processingDelta) return; + let expectedMatchSideEffectRevision = + processingDelta.matchSideEffectRevision; + + try { + const match = (await execMaybe( + MatchModel.findById(params.payload.matchId) as never, + )) as CleanupSideEffectMatchDocument | null; + if (!match) { + throw new Error(`Match not found: ${String(params.payload.matchId)}`); + } + await params.updateMatch(match); + + const completedAtTimestampMS = + await this.auctionRedisService.getCurrentRedisTimestampMS(); + await execMaybe( + AuctionSideEffectApplicationModel.updateOne( + identity as never, + { + $set: { + completedAtTimestampMS, + state: 'completed', + }, + $unset: { + lastError: '', + processingLeaseExpiresAtTimestampMS: '', + processingOwnerToken: '', + processingStartedAtTimestampMS: '', + }, + } as never, + ), + ); + await this.persistAndBroadcastMatchSideEffectStatus({ + AuctionModel, + currentServerTimestampMS: completedAtTimestampMS, + errorMessage: undefined, + expectedMatchSideEffectRevision, + payload: params.payload, + status: 'completed', + }); + } catch (error) { + const failureTimestampMS = + await this.auctionRedisService.getCurrentRedisTimestampMS(); + const errorMessage = error instanceof Error ? error.message : String(error); + await execMaybe( + AuctionSideEffectApplicationModel.updateOne( + identity as never, + { + $set: { + lastError: errorMessage, + state: 'failed', + }, + $unset: { + processingLeaseExpiresAtTimestampMS: '', + processingOwnerToken: '', + processingStartedAtTimestampMS: '', + }, + } as never, + ), + ); + await this.persistAndBroadcastMatchSideEffectStatus({ + AuctionModel, + currentServerTimestampMS: failureTimestampMS, + errorMessage, + expectedMatchSideEffectRevision, + payload: params.payload, + status: 'failed', + }); + throw error; + } + } + + private async applyAuctionHistoryMutation(params: { + AuctionHistoryModel: { + deleteMany?: (...args: never[]) => unknown; + updateOne: (...args: never[]) => unknown; + }; + AuctionModel: { + findById?: (...args: never[]) => { + lean?: () => { exec?: () => Promise }; + session?: (...args: never[]) => { + lean?: () => { exec?: () => Promise }; + select?: (...args: never[]) => { + lean?: () => { exec?: () => Promise }; + session?: (...args: never[]) => unknown; + }; + }; + select?: (...args: never[]) => { + lean?: () => { exec?: () => Promise }; + session?: (...args: never[]) => unknown; + }; + }; + }; + payload: AuctionDurabilityPayload; + session: mongoose.ClientSession | null | undefined; + }): Promise { + const mutation = parseAuctionHistoryMutation(params.payload.historyMutation); + if (isDestructiveHistoryMutation(mutation)) { + if (mutation.type === 'deleteAfterSequenceAndAppendUndo') { + if (!params.AuctionHistoryModel.deleteMany) { + throw new Error('Auction history deleteMany is not available.'); + } + await execMaybe( + params.AuctionHistoryModel.deleteMany( + { + auctionId: params.payload.auctionId, + sequence: { $gt: mutation.targetHistorySequence }, + } as never, + { session: params.session } as never, + ) as Promise | { exec(): Promise }, + ); + } + if (mutation.type === 'reset' && mutation.resetMode === 'clear-history') { + if (!params.AuctionHistoryModel.deleteMany) { + throw new Error('Auction history deleteMany is not available.'); + } + await execMaybe( + params.AuctionHistoryModel.deleteMany( + { + auctionId: params.payload.auctionId, + } as never, + { session: params.session } as never, + ) as Promise | { exec(): Promise }, + ); + } + } + + const historyOperation = buildAuctionHistoryUpsert(params.payload).updateOne; + await execMaybe( + params.AuctionHistoryModel.updateOne( + historyOperation.filter as never, + historyOperation.update as never, + { + session: params.session, + upsert: true, + } as never, + ) as Promise | { exec(): Promise }, + ); + } + + private async persistAndBroadcastMatchSideEffectStatus(params: { + AuctionModel: { + findOneAndUpdate( + filter: never, + update: never, + options: never, + ): Promise | { exec(): Promise }; + }; + currentServerTimestampMS: number; + errorMessage?: string; + expectedMatchSideEffectRevision: number; + payload: AuctionDurabilityPayload; + status: AuctionMatchSideEffectStatus; + }): Promise { + const updatedAuction = (await execMaybe( + params.AuctionModel.findOneAndUpdate( + { + _id: params.payload.auctionId, + auctionLifecycleId: params.payload.auctionLifecycleId, + matchSideEffectRevision: params.expectedMatchSideEffectRevision, + } as never, + { + $inc: { matchSideEffectRevision: 1 }, + $set: { + ...(params.errorMessage + ? { matchSideEffectError: params.errorMessage } + : {}), + matchSideEffectStatus: params.status, + }, + ...(params.errorMessage ? {} : { $unset: { matchSideEffectError: '' } }), + } as never, + { + projection: { + auctionLifecycleId: 1, + matchSideEffectRevision: 1, + matchSideEffectStatus: 1, + }, + returnDocument: 'after', + } as never, + ), + )) as + | { + auctionLifecycleId?: string; + matchSideEffectRevision?: number; + matchSideEffectStatus?: AuctionMatchSideEffectStatus; + } + | null; + if (!updatedAuction?.auctionLifecycleId) return null; + + const delta = buildMatchSideEffectDelta({ + auctionLifecycleId: updatedAuction.auctionLifecycleId, + currentServerTimestampMS: params.currentServerTimestampMS, + matchSideEffectRevision: Number( + updatedAuction.matchSideEffectRevision ?? 0, + ), + matchSideEffectStatus: + updatedAuction.matchSideEffectStatus ?? params.status, + }); + + await this.auctionSideEffectService?.mirrorMatchSideEffectStatus({ + auctionLifecycleId: delta.auctionLifecycleId, + matchId: String(params.payload.matchId), + matchSideEffectRevision: delta.matchSideEffectRevision, + matchSideEffectStatus: delta.matchSideEffectStatus, + }); + this.auctionEventBusService?.broadcastMatchSideEffect( + String(params.payload.matchId), + delta, + ); + return delta; + } + + private async safeTick(): Promise { + if (this.tickInProgress) return; + this.tickInProgress = true; + const leaderLockToken = randomUUID(); + let leaderLockAcquired = false; + try { + leaderLockAcquired = await this.auctionRedisService.acquireTokenLock( + AUCTION_DURABILITY_LEADER_LOCK_KEY, + leaderLockToken, + AUCTION_DURABILITY_LEADER_LOCK_TTL_MS, + ); + if (!leaderLockAcquired) return; + await this.processDueDurabilityPayloads(AUCTION_DURABILITY_BATCH_LIMIT); + } catch (error) { + this.logger.warn( + `Auction durability tick failed: ${ + error instanceof Error ? error.message : error + }`, + ); + } finally { + if (leaderLockAcquired) { + await this.auctionRedisService.releaseTokenLock( + AUCTION_DURABILITY_LEADER_LOCK_KEY, + leaderLockToken, + ); + } + this.tickInProgress = false; + } + } + + private async clearDurabilityPayload(payloadKey: string): Promise { + await this.auctionRedisService + .raw() + .sendCommand(['ZREM', AUCTION_DURABILITY_RETRY_QUEUE_KEY, payloadKey]); + await this.auctionRedisService.raw().sendCommand(['DEL', payloadKey]); + } + + private async requeueDurabilityPayload( + payloadKey: string, + retryAtRedisTimestampMS: number, + ): Promise { + await this.auctionRedisService.raw().sendCommand([ + 'ZADD', + AUCTION_DURABILITY_RETRY_QUEUE_KEY, + String(retryAtRedisTimestampMS), + payloadKey, + ]); + } + + private async recordDurabilityPayloadFailure( + payloadKey: string, + currentRedisTimestampMS: number, + error: unknown, + ): Promise<'dead-lettered' | 'requeued'> { + const errorMessage = formatErrorMessageForRedis(error); + const attemptReply = await this.auctionRedisService.raw().sendCommand([ + 'HINCRBY', + payloadKey, + 'attempts', + '1', + ]); + const attempts = Number(attemptReply); + await this.auctionRedisService.raw().sendCommand([ + 'HSET', + payloadKey, + 'lastError', + errorMessage, + 'lastFailedAtRedisTimestampMS', + String(currentRedisTimestampMS), + ]); + + if ( + Number.isFinite(attempts) && + attempts >= AUCTION_DURABILITY_MAX_ATTEMPTS + ) { + await this.auctionRedisService.raw().sendCommand([ + 'ZREM', + AUCTION_DURABILITY_RETRY_QUEUE_KEY, + payloadKey, + ]); + await this.auctionRedisService.raw().sendCommand([ + 'HSET', + payloadKey, + 'deadLetteredAtRedisTimestampMS', + String(currentRedisTimestampMS), + ]); + await this.auctionRedisService.raw().sendCommand([ + 'ZADD', + AUCTION_DURABILITY_DEAD_LETTER_QUEUE_KEY, + String(currentRedisTimestampMS), + payloadKey, + ]); + return 'dead-lettered'; + } + + await this.requeueDurabilityPayload( + payloadKey, + currentRedisTimestampMS + calculateDurabilityRetryDelayMS(attempts), + ); + return 'requeued'; + } + + private async expireCompletedAuctionRedisRuntime( + payload: AuctionDurabilityPayload, + ): Promise { + const matchId = String(payload.matchId); + const keys = buildAuctionRedisKeys(matchId); + await this.auctionRedisService.raw().sendCommand([ + 'EVAL', + [ + "local expectedAuctionLifecycleId = ARGV[2]", + "local currentAuctionLifecycleId = redis.call('HGET', KEYS[1], 'auctionLifecycleId')", + "if currentAuctionLifecycleId ~= expectedAuctionLifecycleId then", + ' return 0', + 'end', + "redis.call('ZREM', KEYS[2], ARGV[1])", + 'for index = 1, #KEYS do', + ' if index ~= 2 then', + " redis.call('EXPIRE', KEYS[index], ARGV[3])", + ' end', + 'end', + '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, + payload.auctionLifecycleId, + String(AUCTION_REDIS_COMPLETED_RETAIN_SECONDS), + ]); + } +} + +export function buildAuctionHistoryUpsert(payload: AuctionDurabilityPayload) { + return { + updateOne: { + filter: { + auctionId: payload.auctionId, + auctionStateTransitionId: payload.auctionStateTransitionId, + }, + update: { + $setOnInsert: { + action: payload.auctionActionType, + actorUserId: payload.actorUserId, + auctionId: payload.auctionId, + auctionLifecycleId: payload.auctionLifecycleId, + auctionStateTransitionId: payload.auctionStateTransitionId, + historyMutation: payload.historyMutation, + matchId: payload.matchId, + matchSideEffectMutation: payload.matchSideEffectMutation, + revision: payload.revision, + sequence: payload.auctionHistorySequence, + snapshotBefore: payload.snapshotBefore, + takenAt: new Date(payload.committedAtRedisTimestampMS ?? 0), + }, + }, + upsert: true, + }, + }; +} + +export function parseAuctionHistoryMutation( + mutation: unknown, +): ParsedAuctionHistoryMutation { + if (!mutation || typeof mutation !== 'object') return { type: 'append' }; + const record = mutation as Record; + if (record.type === 'deleteAfterSequenceAndAppendUndo') { + const targetHistorySequence = Number(record.targetHistorySequence); + if (!Number.isFinite(targetHistorySequence) || targetHistorySequence < 0) { + throw new Error('Invalid undo history mutation target sequence.'); + } + return { + targetHistorySequence, + type: 'deleteAfterSequenceAndAppendUndo', + }; + } + if (record.type === 'reset') { + const resetMode = + record.resetMode === 'preserve-audit' ? 'preserve-audit' : 'clear-history'; + return { resetMode, type: 'reset' }; + } + return { type: 'append' }; +} + +function isDestructiveHistoryMutation( + mutation: ParsedAuctionHistoryMutation, +): boolean { + return ( + mutation.type === 'deleteAfterSequenceAndAppendUndo' || + (mutation.type === 'reset' && mutation.resetMode === 'clear-history') + ); +} + +async function readAuctionProjectionIdentityForMutation( + AuctionModel: { + findById?: (...args: never[]) => unknown; + }, + auctionId: unknown, + session: mongoose.ClientSession | null | undefined, +): Promise { + if (!AuctionModel.findById) return {}; + const query = AuctionModel.findById(auctionId as never); + const selected = + query && typeof query === 'object' && 'select' in query + ? (query as { select: (...args: never[]) => unknown }).select({ + auctionLifecycleId: 1, + revision: 1, + } as never) + : query; + const scoped = + selected && typeof selected === 'object' && 'session' in selected + ? (selected as { session: (...args: never[]) => unknown }).session( + session as never, + ) + : selected; + const leaned = + scoped && typeof scoped === 'object' && 'lean' in scoped + ? (scoped as { lean: () => unknown }).lean() + : scoped; + const projection = + leaned && typeof leaned === 'object' && 'exec' in leaned + ? await (leaned as { exec: () => Promise }).exec() + : await Promise.resolve(leaned); + if (!projection || typeof projection !== 'object') return {}; + const record = projection as Record; + return { + auctionLifecycleId: + typeof record.auctionLifecycleId === 'string' + ? record.auctionLifecycleId + : undefined, + revision: + typeof record.revision === 'number' + ? record.revision + : Number(record.revision), + }; +} + +export function buildAuctionProjectionGuardedUpdate( + payload: AuctionDurabilityPayload, +) { + return { + filter: { + _id: payload.auctionId, + auctionLifecycleId: payload.auctionLifecycleId, + revision: { $lt: payload.revision }, + }, + update: { + $set: payload.afterAuctionMongoProjection, + }, + }; +} + +export function shouldApplyAuctionProjection( + current: AuctionProjectionIdentity, + payload: Pick, +): boolean { + if (current.auctionLifecycleId !== payload.auctionLifecycleId) return false; + return (current.revision ?? -1) < payload.revision; +} + +export function shouldProcessAuctionDurabilityPayload( + current: AuctionProjectionIdentity, + payload: Pick, +): boolean { + if (current.auctionLifecycleId !== payload.auctionLifecycleId) return false; + return (current.revision ?? -1) <= payload.revision; +} + +export function buildSideEffectApplicationUpsert( + payload: AuctionDurabilityPayload, + mutation: ParsedMatchSideEffectMutation, +) { + const identity = buildSideEffectApplicationIdentityFromPayload(payload, mutation); + return { + filter: identity, + update: { + $setOnInsert: { + ...identity, + auctionLifecycleId: payload.auctionLifecycleId, + matchId: payload.matchId, + attempts: 0, + payload: mutation, + payloadChecksum: hashStableJson(mutation), + state: 'pending', + }, + }, + }; +} + +function parseMatchSideEffectMutation( + value: Record | undefined, +): ParsedMatchSideEffectMutation | null { + if (value?.type === SYNC_MATCH_TEAMS_SIDE_EFFECT_TYPE) { + return { type: SYNC_MATCH_TEAMS_SIDE_EFFECT_TYPE }; + } + if (value?.type === RESET_MATCH_SIDE_EFFECT_TYPE) { + return { type: RESET_MATCH_SIDE_EFFECT_TYPE }; + } + if (value?.type === UNDO_COMPLETED_MATCH_SIDE_EFFECT_TYPE) { + return { type: UNDO_COMPLETED_MATCH_SIDE_EFFECT_TYPE }; + } + return null; +} + +function buildSideEffectApplicationIdentityFromPayload( + payload: AuctionDurabilityPayload, + mutation: ParsedMatchSideEffectMutation, +) { + return { + auctionId: payload.auctionId, + auctionStateTransitionId: payload.auctionStateTransitionId, + sideEffectType: mutation.type, + }; +} + +function hashStableJson(value: unknown): string { + return createHash('sha256') + .update(JSON.stringify(value, Object.keys(value as Record).sort())) + .digest('hex'); +} + +function hasMatchedDocument(result: unknown): boolean { + if (!result || typeof result !== 'object') return false; + const record = result as Record; + const matchedCount = Number(record.matchedCount ?? record.modifiedCount ?? 0); + return matchedCount > 0; +} + +function buildMatchTeamsFromProjection( + projection: Record, + match: { + participants: Array<{ + preferredPositions?: Array<{ position?: string }>; + userId: { toString(): string }; + }>; + }, +) { + const auctionTeams = Array.isArray(projection.auctionTeams) + ? (projection.auctionTeams as Array>) + : []; + const participantByUserId = new Map( + match.participants.map((participant) => [ + participant.userId.toString(), + participant, + ]), + ); + + return auctionTeams.map((team) => { + const teamIndex = Number(team.teamIndex); + const captainUserId = team.captainUserId as MatchTeamMember['userId']; + const captain = participantByUserId.get(captainUserId.toString()); + const rawMembers = Array.isArray(team.members) + ? (team.members as Array>) + : []; + const members: MatchTeamMember[] = [ + { + assignedPosition: + (captain?.preferredPositions?.[0]?.position as Position | undefined) ?? + 'MID', + cost: 0, + userId: captainUserId, + }, + ...rawMembers + .filter((member) => member.userId?.toString() !== captainUserId.toString()) + .map((member) => ({ + assignedPosition: (member.assignedPosition ?? 'MID') as Position, + cost: Number(member.memberAcquisitionBidPointAmount ?? 0), + userId: member.userId as MatchTeamMember['userId'], + })), + ]; + + return { + captainUserId, + members, + name: `${teamIndex}팀`, + teamIndex, + }; + }); +} + +function parseRedisHash(reply: unknown): Record { + if (!reply) return {}; + if (Array.isArray(reply)) { + const result: Record = {}; + for (let index = 0; index < reply.length; index += 2) { + result[String(reply[index])] = String(reply[index + 1]); + } + return result; + } + if (typeof reply === 'object') { + return Object.fromEntries( + Object.entries(reply as Record).map(([key, value]) => [ + key, + String(value), + ]), + ); + } + return {}; +} + +function formatErrorMessageForRedis(error: unknown): string { + const message = error instanceof Error ? error.message : String(error); + return message.slice(0, AUCTION_DURABILITY_ERROR_MESSAGE_MAX_LENGTH); +} + +function calculateDurabilityRetryDelayMS(attempts: number): number { + if (!Number.isFinite(attempts) || attempts <= 1) { + return AUCTION_DURABILITY_RETRY_DELAY_MS; + } + return Math.min( + AUCTION_DURABILITY_MAX_RETRY_DELAY_MS, + AUCTION_DURABILITY_RETRY_DELAY_MS * 2 ** (attempts - 1), + ); +} + +async function execMaybe(queryOrPromise: Promise | { exec(): Promise }) { + if ( + queryOrPromise && + typeof (queryOrPromise as { exec?: unknown }).exec === 'function' + ) { + return (queryOrPromise as { exec(): Promise }).exec(); + } + return queryOrPromise; +} diff --git a/apps/api/src/modules/auction/auction-event-bus.service.ts b/apps/api/src/modules/auction/auction-event-bus.service.ts new file mode 100644 index 00000000..d4cac7d5 --- /dev/null +++ b/apps/api/src/modules/auction/auction-event-bus.service.ts @@ -0,0 +1,27 @@ +import { Injectable } from '@nestjs/common'; +import type { Namespace } from 'socket.io'; +import type { AuctionStateResponse } from './auction.service'; +import type { MatchSideEffectDelta } from './auction-side-effect.service'; + +@Injectable() +export class AuctionEventBusService { + private auctionNamespace?: Namespace; + + public attachAuctionNamespace(namespace: Namespace): void { + this.auctionNamespace = namespace; + } + + public broadcastMatchSideEffect( + matchId: string, + delta: MatchSideEffectDelta, + ): void { + this.auctionNamespace?.to(matchId).emit('match-side-effect', delta); + } + + public broadcastState(matchId: string, state: AuctionStateResponse): void { + this.auctionNamespace?.to(matchId).emit( + 'state', + JSON.parse(JSON.stringify(state)), + ); + } +} diff --git a/apps/api/src/modules/auction/auction-side-effect.service.spec.ts b/apps/api/src/modules/auction/auction-side-effect.service.spec.ts new file mode 100644 index 00000000..ffdac4c0 --- /dev/null +++ b/apps/api/src/modules/auction/auction-side-effect.service.spec.ts @@ -0,0 +1,101 @@ +import { + AuctionSideEffectService, + buildMatchSideEffectDelta, + buildSideEffectApplicationIdentity, + buildSideEffectLeaseAcquireUpdate, + canAcquireSideEffectLease, +} from './auction-side-effect.service'; + +describe('auction side effect helpers', () => { + it('builds idempotency identity from transition and side effect type', () => { + expect( + buildSideEffectApplicationIdentity({ + auctionId: 'auction-1', + auctionStateTransitionId: 'transition-1', + sideEffectType: 'syncMatchTeams', + }), + ).toEqual({ + auctionId: 'auction-1', + auctionStateTransitionId: 'transition-1', + sideEffectType: 'syncMatchTeams', + }); + }); + + it('allows lease acquisition for pending, failed, or stale processing items only', () => { + expect(canAcquireSideEffectLease({ state: 'pending' }, 1000)).toBe(true); + expect(canAcquireSideEffectLease({ state: 'failed' }, 1000)).toBe(true); + expect( + canAcquireSideEffectLease( + { processingLeaseExpiresAtTimestampMS: 999, state: 'processing' }, + 1000, + ), + ).toBe(true); + expect( + canAcquireSideEffectLease( + { processingLeaseExpiresAtTimestampMS: 1001, state: 'processing' }, + 1000, + ), + ).toBe(false); + expect(canAcquireSideEffectLease({ state: 'completed' }, 1000)).toBe(false); + }); + + it('builds lease acquire update with Redis TIME timestamps', () => { + expect( + buildSideEffectLeaseAcquireUpdate({ + currentRedisTimestampMS: 1000, + leaseDurationMS: 5000, + ownerToken: 'worker-1', + }), + ).toEqual({ + $inc: { attempts: 1 }, + $set: { + processingLeaseExpiresAtTimestampMS: 6000, + processingOwnerToken: 'worker-1', + processingStartedAtTimestampMS: 1000, + state: 'processing', + }, + }); + }); + + it('builds side-effect socket delta independently from auction revision', () => { + expect( + buildMatchSideEffectDelta({ + auctionLifecycleId: 'life-1', + currentServerTimestampMS: 1000, + matchSideEffectRevision: 3, + matchSideEffectStatus: 'completed', + }), + ).toEqual({ + auctionLifecycleId: 'life-1', + currentServerTimestampMS: 1000, + matchSideEffectRevision: 3, + matchSideEffectStatus: 'completed', + }); + }); + + it('mirrors side-effect status into Redis live state with lifecycle and revision guard', async () => { + const sendCommand = jest.fn().mockResolvedValue(1); + const service = new AuctionSideEffectService({ + raw: jest.fn().mockReturnValue({ sendCommand }), + } as never); + + await expect( + service.mirrorMatchSideEffectStatus({ + auctionLifecycleId: 'life-1', + matchId: 'match-1', + matchSideEffectRevision: 2, + matchSideEffectStatus: 'completed', + }), + ).resolves.toBe(true); + + expect(sendCommand).toHaveBeenCalledWith([ + 'EVAL', + expect.stringContaining('auctionLifecycleId'), + '1', + 'auction:match-1:liveAuctionState', + 'life-1', + '2', + 'completed', + ]); + }); +}); diff --git a/apps/api/src/modules/auction/auction-side-effect.service.ts b/apps/api/src/modules/auction/auction-side-effect.service.ts new file mode 100644 index 00000000..2dbc3b2e --- /dev/null +++ b/apps/api/src/modules/auction/auction-side-effect.service.ts @@ -0,0 +1,110 @@ +import { Injectable } from '@nestjs/common'; +import type { + AuctionMatchSideEffectStatus, + AuctionSideEffectApplicationState, +} from '../global/database/schema'; +import { buildAuctionRedisKeys } from './redis/auction-redis.keys'; +import { AuctionRedisService } from './redis/auction-redis.service'; + +export interface SideEffectApplicationIdentity { + auctionId: unknown; + auctionStateTransitionId: string; + sideEffectType: string; +} + +export interface SideEffectLeaseState { + processingLeaseExpiresAtTimestampMS?: number; + state: AuctionSideEffectApplicationState; +} + +export interface BuildSideEffectLeaseAcquireUpdateParams { + currentRedisTimestampMS: number; + leaseDurationMS: number; + ownerToken: string; +} + +export interface MatchSideEffectDelta { + auctionLifecycleId: string; + currentServerTimestampMS: number; + matchSideEffectRevision: number; + matchSideEffectStatus: AuctionMatchSideEffectStatus; +} + +@Injectable() +export class AuctionSideEffectService { + constructor(private readonly auctionRedisService: AuctionRedisService) {} + + public async mirrorMatchSideEffectStatus(params: { + auctionLifecycleId: string; + matchId: string; + matchSideEffectRevision: number; + matchSideEffectStatus: AuctionMatchSideEffectStatus; + }): Promise { + const keys = buildAuctionRedisKeys(params.matchId); + const result = await this.auctionRedisService.raw().sendCommand([ + 'EVAL', + [ + "if redis.call('HGET', KEYS[1], 'auctionLifecycleId') ~= ARGV[1] then return 0 end", + "local currentRevision = tonumber(redis.call('HGET', KEYS[1], 'matchSideEffectRevision') or '-1')", + 'local nextRevision = tonumber(ARGV[2])', + 'if currentRevision >= nextRevision then return 0 end', + "redis.call('HSET', KEYS[1], 'matchSideEffectRevision', ARGV[2], 'matchSideEffectStatus', ARGV[3])", + 'return 1', + ].join('\n'), + '1', + keys.liveStateKey, + params.auctionLifecycleId, + String(params.matchSideEffectRevision), + params.matchSideEffectStatus, + ]); + return Number(result) === 1; + } +} + +export function buildSideEffectApplicationIdentity( + params: SideEffectApplicationIdentity, +): SideEffectApplicationIdentity { + return { + auctionId: params.auctionId, + auctionStateTransitionId: params.auctionStateTransitionId, + sideEffectType: params.sideEffectType, + }; +} + +export function canAcquireSideEffectLease( + state: SideEffectLeaseState, + currentRedisTimestampMS: number, +): boolean { + if (state.state === 'pending' || state.state === 'failed') return true; + if (state.state !== 'processing') return false; + return ( + (state.processingLeaseExpiresAtTimestampMS ?? 0) <= + currentRedisTimestampMS + ); +} + +export function buildSideEffectLeaseAcquireUpdate( + params: BuildSideEffectLeaseAcquireUpdateParams, +) { + return { + $inc: { attempts: 1 }, + $set: { + processingLeaseExpiresAtTimestampMS: + params.currentRedisTimestampMS + params.leaseDurationMS, + processingOwnerToken: params.ownerToken, + processingStartedAtTimestampMS: params.currentRedisTimestampMS, + state: 'processing', + }, + }; +} + +export function buildMatchSideEffectDelta( + params: MatchSideEffectDelta, +): MatchSideEffectDelta { + return { + auctionLifecycleId: params.auctionLifecycleId, + currentServerTimestampMS: params.currentServerTimestampMS, + matchSideEffectRevision: params.matchSideEffectRevision, + matchSideEffectStatus: params.matchSideEffectStatus, + }; +} diff --git a/apps/api/src/modules/auction/auction.controller.ts b/apps/api/src/modules/auction/auction.controller.ts index 70fd1560..3aca5420 100644 --- a/apps/api/src/modules/auction/auction.controller.ts +++ b/apps/api/src/modules/auction/auction.controller.ts @@ -20,7 +20,11 @@ import type { UserDocument } from '../global/database/schema'; import { AuctionService } from './auction.service'; import { AuctionGateway } from './auction.gateway'; import { + NextAuctionDto, + OpenBiddingDto, + PassedAuctionDto, PlaceBidDto, + ResetAuctionDto, SoldDto, StartAuctionDto, UndoAuctionDto, @@ -47,18 +51,22 @@ export class AuctionController { return this.auctionService.start({ matchId, communityId, + startAuctionRequestId: body.startAuctionRequestId, + actorUserId: currentUser._id, captains: body.captains.map((c) => ({ teamIndex: c.teamIndex, userId: new mongoose.Types.ObjectId(c.userId), - initialPoints: c.initialPoints, + initialTeamBidPointAmount: c.initialTeamBidPointAmount, })), - initialPoints: body.initialPoints ?? 1000, - maxTimerSeconds: body.maxTimerSeconds ?? 30, - bidExtensionSeconds: body.bidExtensionSeconds ?? 5, - topTierThreshold: body.topTierThreshold ?? 'NONE', - manualTopTierUserIds: (body.manualTopTierUserIds ?? []).map( - (userId) => new mongoose.Types.ObjectId(userId), - ), + initialTeamBidPointAmount: body.initialTeamBidPointAmount ?? 1000, + maximumBidRoundDurationSeconds: + body.maximumBidRoundDurationSeconds ?? 30, + bidRoundExtensionSeconds: body.bidRoundExtensionSeconds ?? 5, + topTierAuctionPriorityThreshold: + body.topTierAuctionPriorityThreshold ?? 'NONE', + manualTopTierAuctionPriorityUserIds: ( + body.manualTopTierAuctionPriorityUserIds ?? [] + ).map((userId) => new mongoose.Types.ObjectId(userId)), }); } @@ -67,7 +75,7 @@ export class AuctionController { public async getAuction( @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, ) { - return this.auctionService.getByMatchId(matchId); + return this.auctionService.getStateByMatchId(matchId); } // 공개 — 팀장 2명만 쓸 엔드포인트(트러스트 기반, 10명 동시 관전). @@ -76,23 +84,26 @@ export class AuctionController { @HttpCode(HttpStatus.OK) public async openBidding( @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, + @Body() body: OpenBiddingDto = {}, ) { - return this.auctionService.openBidding(matchId); + return this.auctionService.openBidding(matchId, body); } @Post('bids') @AllowPublicAccess() @HttpCode(HttpStatus.OK) public async placeBid( - @CurrentUser() currentUser: UserDocument | undefined, @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, @Body() body: PlaceBidDto, ) { return this.auctionService.placeBid({ matchId, - teamIndex: body.teamIndex, - amount: body.amount, - bidderUserId: this.resolveBidder(currentUser, body.bidderUserId), + teamIndex: body.bidderTeamIndex, + amount: body.bidPointAmount, + bidRequestId: body.bidRequestId, + clientObservedAuctionLifecycleId: body.clientObservedAuctionLifecycleId, + clientObservedCurrentBidRoundPlayerUserId: + body.clientObservedCurrentBidRoundPlayerUserId, }); } @@ -106,16 +117,35 @@ export class AuctionController { return this.auctionService.markSold({ matchId, assignedPosition: body.assignedPosition, + auctionActionRequestId: body.auctionActionRequestId, + clientObservedAuctionLifecycleId: body.clientObservedAuctionLifecycleId, + clientObservedCurrentAuctionPlayerOrderIndex: + body.clientObservedCurrentAuctionPlayerOrderIndex, + clientObservedCurrentBidRoundPlayerUserId: + body.clientObservedCurrentBidRoundPlayerUserId, + clientObservedPhase: body.clientObservedPhase, + clientObservedRevision: body.clientObservedRevision, }); } + @Post('passed') + @AllowPublicAccess() + @HttpCode(HttpStatus.OK) + public async markPassed( + @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, + @Body() body: PassedAuctionDto = {}, + ) { + return this.auctionService.markPassed(matchId, body); + } + @Post('next') @AllowPublicAccess() @HttpCode(HttpStatus.OK) public async next( @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, + @Body() body: NextAuctionDto = {}, ) { - return this.auctionService.next(matchId); + return this.auctionService.next(matchId, body); } @Get('history') @@ -147,6 +177,14 @@ export class AuctionController { matchId, communityId, sequence: body.sequence, + auctionActionRequestId: body.auctionActionRequestId, + clientObservedAuctionLifecycleId: body.clientObservedAuctionLifecycleId, + clientObservedCurrentAuctionPlayerOrderIndex: + body.clientObservedCurrentAuctionPlayerOrderIndex, + clientObservedCurrentBidRoundPlayerUserId: + body.clientObservedCurrentBidRoundPlayerUserId, + clientObservedPhase: body.clientObservedPhase, + clientObservedRevision: body.clientObservedRevision, }); this.auctionGateway.broadcastState(matchId.toString(), auction); return auction; @@ -161,24 +199,24 @@ export class AuctionController { @Param('communityId', ParseObjectIdPipe) communityId: mongoose.Types.ObjectId, @Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId, + @Body() body: ResetAuctionDto = {}, ) { this.assertSameCommunity(currentUser, communityId); - await this.auctionService.reset({ matchId, communityId }); + await this.auctionService.reset({ + matchId, + communityId, + auctionActionRequestId: body.auctionActionRequestId, + clientObservedAuctionLifecycleId: body.clientObservedAuctionLifecycleId, + clientObservedCurrentAuctionPlayerOrderIndex: + body.clientObservedCurrentAuctionPlayerOrderIndex, + clientObservedCurrentBidRoundPlayerUserId: + body.clientObservedCurrentBidRoundPlayerUserId, + clientObservedPhase: body.clientObservedPhase, + clientObservedRevision: body.clientObservedRevision, + }); this.auctionGateway.broadcastReset(matchId.toString()); } - private resolveBidder( - currentUser: UserDocument | undefined, - bodyBidder?: string, - ): mongoose.Types.ObjectId | undefined { - if (currentUser) return currentUser._id; - if (!bodyBidder) return undefined; - if (!mongoose.isValidObjectId(bodyBidder)) { - throw new BadRequestException('Invalid bidderUserId.'); - } - return new mongoose.Types.ObjectId(bodyBidder); - } - private assertSameCommunity( user: UserDocument, communityId: mongoose.Types.ObjectId, diff --git a/apps/api/src/modules/auction/auction.gateway.spec.ts b/apps/api/src/modules/auction/auction.gateway.spec.ts new file mode 100644 index 00000000..6bdf1beb --- /dev/null +++ b/apps/api/src/modules/auction/auction.gateway.spec.ts @@ -0,0 +1,253 @@ +import mongoose from 'mongoose'; + +jest.mock('../auth/jwt.service', () => ({ + JwtService: class JwtService {}, +})); + +import { AuctionGateway } from './auction.gateway'; + +describe('AuctionGateway', () => { + function createGateway(params?: { + placeBid?: jest.Mock; + }) { + const auctionService = { + placeBid: params?.placeBid ?? jest.fn(), + }; + const gateway = new AuctionGateway( + auctionService as never, + { resolveDevUserById: jest.fn() } as never, + { verify: jest.fn() } as never, + { findOrCreateByOid: jest.fn() } as never, + { getModel: jest.fn() } as never, + { attachAuctionNamespace: jest.fn() } as never, + ); + const emit = jest.fn(); + const to = jest.fn().mockReturnValue({ emit }); + (gateway as unknown as { server: { to: jest.Mock } }).server = { to }; + + return { + auctionService, + emit, + gateway, + to, + }; + } + + it('broadcasts a bid delta and acknowledges the matching bid request', async () => { + const matchId = new mongoose.Types.ObjectId().toString(); + const auctionBidHistoryEntry = { + bidderTeamIndex: 2, + bidderUserId: 'captain-2', + bidPlacedAtTimestampMS: 1780000000000, + bidPointAmount: 120, + }; + const placeBid = jest.fn().mockResolvedValue({ + auctionBidHistory: [auctionBidHistoryEntry], + auctionLifecycleId: 'life-1', + currentBidRoundDeadlineTimestampMS: 1780000030000, + currentHighestBidderTeamIndex: 2, + currentHighestBidPointAmount: 120, + currentServerTimestampMS: 1780000000000, + revision: 9, + }); + const { emit, gateway, to } = createGateway({ placeBid }); + const ack = jest.fn(); + + await gateway.handleBid( + { data: { matchId }, emit: jest.fn() } as never, + { + bidPointAmount: 120, + bidderTeamIndex: 2, + bidRequestId: 'bid-1', + clientObservedAuctionLifecycleId: 'life-1', + clientObservedCurrentBidRoundPlayerUserId: 'player-1', + }, + ack, + ); + + expect(placeBid).toHaveBeenCalledWith({ + amount: 120, + bidRequestId: 'bid-1', + clientObservedAuctionLifecycleId: 'life-1', + clientObservedCurrentBidRoundPlayerUserId: 'player-1', + matchId: new mongoose.Types.ObjectId(matchId), + teamIndex: 2, + }); + expect(to).toHaveBeenCalledWith(matchId); + expect(emit).toHaveBeenCalledWith('bid', { + auctionBidHistoryEntry, + auctionLifecycleId: 'life-1', + bidRequestId: 'bid-1', + currentBidRoundDeadlineTimestampMS: 1780000030000, + currentHighestBidderTeamIndex: 2, + currentHighestBidPointAmount: 120, + currentServerTimestampMS: 1780000000000, + revision: 9, + }); + expect(ack).toHaveBeenCalledWith({ + bidRequestId: 'bid-1', + ok: true, + state: expect.objectContaining({ + auctionLifecycleId: 'life-1', + revision: 9, + }), + }); + }); + + it('generates one bid request id when the client omits it', async () => { + const matchId = new mongoose.Types.ObjectId().toString(); + const placeBid = jest.fn().mockResolvedValue({ + auctionBidHistory: [ + { + bidderTeamIndex: 1, + bidPointAmount: 50, + }, + ], + auctionLifecycleId: 'life-1', + currentHighestBidderTeamIndex: 1, + currentHighestBidPointAmount: 50, + revision: 3, + }); + const { emit, gateway } = createGateway({ placeBid }); + const ack = jest.fn(); + + await gateway.handleBid( + { data: { matchId }, emit: jest.fn() } as never, + { + bidPointAmount: 50, + bidderTeamIndex: 1, + }, + ack, + ); + + const generatedBidRequestId = placeBid.mock.calls[0][0].bidRequestId; + expect(generatedBidRequestId).toEqual(expect.any(String)); + expect(generatedBidRequestId).not.toHaveLength(0); + expect(emit).toHaveBeenCalledWith( + 'bid', + expect.objectContaining({ + bidRequestId: generatedBidRequestId, + }), + ); + expect(ack).toHaveBeenCalledWith( + expect.objectContaining({ + bidRequestId: generatedBidRequestId, + ok: true, + }), + ); + }); + + it('acknowledges bid failures with the request id used for the attempt', async () => { + const matchId = new mongoose.Types.ObjectId().toString(); + const placeBid = jest.fn().mockRejectedValue(new Error('Bid failed')); + const socketEmit = jest.fn(); + const { gateway } = createGateway({ placeBid }); + const ack = jest.fn(); + + await gateway.handleBid( + { data: { matchId }, emit: socketEmit } as never, + { + bidPointAmount: 50, + bidderTeamIndex: 1, + bidRequestId: 'bid-1', + }, + ack, + ); + + expect(socketEmit).toHaveBeenCalledWith('error', { + message: 'Bid failed', + }); + expect(ack).toHaveBeenCalledWith({ + bidRequestId: 'bid-1', + code: 'Bid failed', + rejected: true, + }); + }); + + it('rate limits excessive bid requests from the same socket', async () => { + jest.spyOn(Date, 'now').mockReturnValue(1780000000000); + const matchId = new mongoose.Types.ObjectId().toString(); + const placeBid = jest.fn().mockResolvedValue({ + auctionBidHistory: [ + { + bidderTeamIndex: 1, + bidPointAmount: 50, + }, + ], + currentHighestBidderTeamIndex: 1, + currentHighestBidPointAmount: 50, + revision: 3, + }); + const socketEmit = jest.fn(); + const socket = { data: { matchId }, emit: socketEmit }; + const { gateway } = createGateway({ placeBid }); + const acknowledgements: Array> = []; + + for (let index = 0; index < 9; index += 1) { + await gateway.handleBid( + socket as never, + { + bidPointAmount: 50, + bidderTeamIndex: 1, + bidRequestId: `bid-${index}`, + }, + (response) => acknowledgements.push(response), + ); + } + + expect(placeBid).toHaveBeenCalledTimes(8); + expect(socketEmit).toHaveBeenCalledWith('error', { + message: '입찰 요청이 너무 많습니다. 잠시 후 다시 시도해주세요.', + }); + expect(acknowledgements[8]).toEqual({ + bidRequestId: 'bid-8', + code: 'BID_RATE_LIMITED', + message: '입찰 요청이 너무 많습니다. 잠시 후 다시 시도해주세요.', + rejected: true, + }); + }); + + it('allows bid requests again after the rate limit window resets', async () => { + const nowSpy = jest.spyOn(Date, 'now'); + nowSpy.mockReturnValue(1780000000000); + const matchId = new mongoose.Types.ObjectId().toString(); + const placeBid = jest.fn().mockResolvedValue({ + auctionBidHistory: [ + { + bidderTeamIndex: 1, + bidPointAmount: 50, + }, + ], + currentHighestBidderTeamIndex: 1, + currentHighestBidPointAmount: 50, + revision: 3, + }); + const socket = { data: { matchId }, emit: jest.fn() }; + const { gateway } = createGateway({ placeBid }); + + for (let index = 0; index < 8; index += 1) { + await gateway.handleBid( + socket as never, + { + bidPointAmount: 50, + bidderTeamIndex: 1, + bidRequestId: `bid-${index}`, + }, + jest.fn(), + ); + } + + nowSpy.mockReturnValue(1780000001000); + await gateway.handleBid( + socket as never, + { + bidPointAmount: 50, + bidderTeamIndex: 1, + bidRequestId: 'bid-reset', + }, + jest.fn(), + ); + + expect(placeBid).toHaveBeenCalledTimes(9); + }); +}); diff --git a/apps/api/src/modules/auction/auction.gateway.ts b/apps/api/src/modules/auction/auction.gateway.ts index 91c0c613..bc2477c9 100644 --- a/apps/api/src/modules/auction/auction.gateway.ts +++ b/apps/api/src/modules/auction/auction.gateway.ts @@ -1,9 +1,11 @@ import { Logger } from '@nestjs/common'; +import { randomUUID } from 'crypto'; import { + Ack, ConnectedSocket, MessageBody, OnGatewayConnection, - OnGatewayDisconnect, + OnGatewayInit, SubscribeMessage, WebSocketGateway, WebSocketServer, @@ -23,26 +25,50 @@ import type { UserDocument, } from '../global/database/schema'; import { AuctionService } from './auction.service'; +import type { AuctionStateResponse } from './auction.service'; +import { AuctionEventBusService } from './auction-event-bus.service'; +import type { MatchSideEffectDelta } from './auction-side-effect.service'; interface JoinAuctionPayload { matchId: string; } interface BidPayload { - teamIndex: number; - amount: number; - bidderUserId?: string; + bidderTeamIndex: number; + bidPointAmount: number; + bidRequestId?: string; + clientObservedAuctionLifecycleId?: string; + clientObservedCurrentBidRoundPlayerUserId?: string; } interface SoldPayload { + auctionActionRequestId?: string; assignedPosition?: Position; + clientObservedAuctionLifecycleId?: string; + clientObservedCurrentAuctionPlayerOrderIndex?: number; + clientObservedCurrentBidRoundPlayerUserId?: string; + clientObservedPhase?: string; + clientObservedRevision?: number; } +type AuctionActionPayload = Omit; + interface ChatMessagePayload { message?: string; displayName?: string; } +interface BidRateLimitState { + count: number; + windowStartedAtTimestampMS: number; +} + +const BID_RATE_LIMIT_WINDOW_MS = 1000; +const BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW = 8; +const BID_RATE_LIMIT_REJECTION_CODE = 'BID_RATE_LIMITED'; +const BID_RATE_LIMIT_REJECTION_MESSAGE = + '입찰 요청이 너무 많습니다. 잠시 후 다시 시도해주세요.'; + @WebSocketGateway({ namespace: '/auction', cors: { @@ -52,13 +78,12 @@ interface ChatMessagePayload { }, }) export class AuctionGateway - implements OnGatewayConnection, OnGatewayDisconnect + implements OnGatewayConnection, OnGatewayInit { @WebSocketServer() private server!: Namespace; private readonly logger = new Logger(AuctionGateway.name); - private readonly roomTimers = new Map(); constructor( private readonly auctionService: AuctionService, @@ -66,8 +91,13 @@ export class AuctionGateway private readonly jwtService: JwtService, private readonly identityService: IdentityService, private readonly connectionService: ConnectionService, + private readonly auctionEventBusService: AuctionEventBusService, ) {} + public afterInit(server: Namespace): void { + this.auctionEventBusService.attachAuctionNamespace(server); + } + public async handleConnection(socket: Socket) { try { await this.authenticateSocket(socket); @@ -82,12 +112,6 @@ export class AuctionGateway } } - public handleDisconnect(socket: Socket) { - const matchId = this.getSocketMatchId(socket); - if (!matchId) return; - this.maybeClearRoomTimer(matchId); - } - @SubscribeMessage('join') public async handleJoin( @ConnectedSocket() socket: Socket, @@ -106,8 +130,11 @@ export class AuctionGateway const auction = await this.auctionService.getByMatchId( new mongoose.Types.ObjectId(payload.matchId), ); + const auctionState = await this.auctionService.getStateByMatchId( + new mongoose.Types.ObjectId(payload.matchId), + ); this.emitChatHistory(socket, auction); - this.broadcastState(payload.matchId, auction); + this.broadcastState(payload.matchId, auctionState); } catch (error) { this.emitKnownError(socket, error); } @@ -117,41 +144,85 @@ export class AuctionGateway public async handleBid( @ConnectedSocket() socket: Socket, @MessageBody() payload: BidPayload, + @Ack() ack?: (response: Record) => void, ) { const matchId = this.requireJoinedMatchId(socket); if (!matchId) return; - const bidderUserId = this.resolveBidderUserId(socket, payload?.bidderUserId); - if (payload?.bidderUserId && !bidderUserId) { - this.emitError(socket, 'Invalid bidderUserId.'); + const bidRequestId = payload.bidRequestId ?? randomUUID(); + if (!this.consumeBidRateLimit(socket)) { + this.emitError(socket, BID_RATE_LIMIT_REJECTION_MESSAGE); + ack?.({ + bidRequestId, + code: BID_RATE_LIMIT_REJECTION_CODE, + message: BID_RATE_LIMIT_REJECTION_MESSAGE, + rejected: true, + }); return; } try { const auction = await this.auctionService.placeBid({ matchId: new mongoose.Types.ObjectId(matchId), - teamIndex: payload.teamIndex, - amount: payload.amount, - bidderUserId, + teamIndex: payload.bidderTeamIndex, + amount: payload.bidPointAmount, + bidRequestId, + clientObservedAuctionLifecycleId: + payload.clientObservedAuctionLifecycleId, + clientObservedCurrentBidRoundPlayerUserId: + payload.clientObservedCurrentBidRoundPlayerUserId, + }); + const bidDelta = this.buildBidDeltaFromAuctionState( + auction, + bidRequestId, + ); + if (bidDelta) { + this.broadcastBid(matchId, bidDelta); + } else { + this.broadcastState(matchId, auction); + } + ack?.({ + ok: true, + bidRequestId, + state: this.serializeAuction(auction), }); - this.broadcastState(matchId, auction); } catch (error) { this.emitKnownError(socket, error); + ack?.({ + bidRequestId, + code: error instanceof Error ? error.message : 'UNKNOWN', + rejected: true, + }); } } @SubscribeMessage('open-bidding') - public async handleOpenBidding(@ConnectedSocket() socket: Socket) { + public async handleOpenBidding( + @ConnectedSocket() socket: Socket, + @MessageBody() payload: AuctionActionPayload, + @Ack() ack?: (response: Record) => void, + ) { const matchId = this.requireJoinedMatchId(socket); if (!matchId) return; try { const auction = await this.auctionService.openBidding( new mongoose.Types.ObjectId(matchId), + this.toAuctionActionRequest(payload), ); this.broadcastState(matchId, auction); + ack?.({ + auctionActionRequestId: payload?.auctionActionRequestId, + ok: true, + state: this.serializeAuction(auction), + }); } catch (error) { this.emitKnownError(socket, error); + ack?.({ + auctionActionRequestId: payload?.auctionActionRequestId, + code: error instanceof Error ? error.message : 'UNKNOWN', + rejected: true, + }); } } @@ -159,6 +230,7 @@ export class AuctionGateway public async handleSold( @ConnectedSocket() socket: Socket, @MessageBody() payload: SoldPayload, + @Ack() ack?: (response: Record) => void, ) { const matchId = this.requireJoinedMatchId(socket); if (!matchId) return; @@ -167,25 +239,81 @@ export class AuctionGateway const auction = await this.auctionService.markSold({ matchId: new mongoose.Types.ObjectId(matchId), assignedPosition: payload?.assignedPosition, + ...this.toAuctionActionRequest(payload), }); this.broadcastState(matchId, auction); + ack?.({ + auctionActionRequestId: payload?.auctionActionRequestId, + ok: true, + state: this.serializeAuction(auction), + }); } catch (error) { this.emitKnownError(socket, error); + ack?.({ + auctionActionRequestId: payload?.auctionActionRequestId, + code: error instanceof Error ? error.message : 'UNKNOWN', + rejected: true, + }); } } @SubscribeMessage('next') - public async handleNext(@ConnectedSocket() socket: Socket) { + public async handleNext( + @ConnectedSocket() socket: Socket, + @MessageBody() payload: AuctionActionPayload, + @Ack() ack?: (response: Record) => void, + ) { const matchId = this.requireJoinedMatchId(socket); if (!matchId) return; try { const auction = await this.auctionService.next( new mongoose.Types.ObjectId(matchId), + this.toAuctionActionRequest(payload), ); this.broadcastState(matchId, auction); + ack?.({ + auctionActionRequestId: payload?.auctionActionRequestId, + ok: true, + state: this.serializeAuction(auction), + }); } catch (error) { this.emitKnownError(socket, error); + ack?.({ + auctionActionRequestId: payload?.auctionActionRequestId, + code: error instanceof Error ? error.message : 'UNKNOWN', + rejected: true, + }); + } + } + + @SubscribeMessage('passed') + public async handlePassed( + @ConnectedSocket() socket: Socket, + @MessageBody() payload: AuctionActionPayload, + @Ack() ack?: (response: Record) => void, + ) { + const matchId = this.requireJoinedMatchId(socket); + if (!matchId) return; + + try { + const auction = await this.auctionService.markPassed( + new mongoose.Types.ObjectId(matchId), + this.toAuctionActionRequest(payload), + ); + this.broadcastState(matchId, auction); + ack?.({ + auctionActionRequestId: payload?.auctionActionRequestId, + ok: true, + state: this.serializeAuction(auction), + }); + } catch (error) { + this.emitKnownError(socket, error); + ack?.({ + auctionActionRequestId: payload?.auctionActionRequestId, + code: error instanceof Error ? error.message : 'UNKNOWN', + rejected: true, + }); } } @@ -226,24 +354,45 @@ export class AuctionGateway return matchId; } + private consumeBidRateLimit(socket: Socket): boolean { + const currentTimestampMS = Date.now(); + const previousState = socket.data + .auctionBidRateLimit as BidRateLimitState | undefined; + if ( + !previousState || + currentTimestampMS - previousState.windowStartedAtTimestampMS >= + BID_RATE_LIMIT_WINDOW_MS + ) { + socket.data.auctionBidRateLimit = { + count: 1, + windowStartedAtTimestampMS: currentTimestampMS, + }; + return true; + } + + previousState.count += 1; + socket.data.auctionBidRateLimit = previousState; + return previousState.count <= BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW; + } + private getSocketMatchId(socket: Socket): string | undefined { return typeof socket.data.matchId === 'string' ? socket.data.matchId : undefined; } - private resolveBidderUserId( - socket: Socket, - payloadBidderUserId?: string, - ): mongoose.Types.ObjectId | undefined { - const candidate = - payloadBidderUserId ?? - (socket.data.user as UserDocument | undefined)?._id.toString() ?? - this.readHandshakeUserId(socket); - if (!candidate || !mongoose.isValidObjectId(candidate)) { - return undefined; - } - return new mongoose.Types.ObjectId(candidate); + private toAuctionActionRequest(payload?: AuctionActionPayload) { + return { + auctionActionRequestId: payload?.auctionActionRequestId, + clientObservedAuctionLifecycleId: + payload?.clientObservedAuctionLifecycleId, + clientObservedCurrentAuctionPlayerOrderIndex: + payload?.clientObservedCurrentAuctionPlayerOrderIndex, + clientObservedCurrentBidRoundPlayerUserId: + payload?.clientObservedCurrentBidRoundPlayerUserId, + clientObservedPhase: payload?.clientObservedPhase, + clientObservedRevision: payload?.clientObservedRevision, + }; } private readHandshakeUserId(socket: Socket): string | undefined { @@ -359,16 +508,25 @@ export class AuctionGateway return typeof value === 'string' && value.length > 0 ? value : undefined; } - public broadcastState(matchId: string, auction: AuctionDocument) { + public broadcastState(matchId: string, auction: AuctionStateResponse) { this.server.to(matchId).emit('state', this.serializeAuction(auction)); - this.syncRoomTimer(matchId, auction); + } + + public broadcastBid(matchId: string, delta: Record) { + this.server.to(matchId).emit('bid', delta); } public broadcastReset(matchId: string) { - this.clearRoomTimer(matchId); this.server.to(matchId).emit('reset', { matchId }); } + public broadcastMatchSideEffect( + matchId: string, + delta: MatchSideEffectDelta, + ) { + this.server.to(matchId).emit('match-side-effect', delta); + } + private emitChatHistory(socket: Socket, auction: AuctionDocument) { socket.emit('chat-history', { messages: (auction.chatMessages ?? []).map((message) => @@ -377,90 +535,91 @@ export class AuctionGateway }); } - private syncRoomTimer(matchId: string, auction: AuctionDocument) { - this.clearRoomTimer(matchId); - if (!auction.currentDeadline) return; - - const deadline = auction.currentDeadline; - const deadlineIso = deadline.toISOString(); - if (Date.now() >= deadline.getTime()) { - void this.handleDeadlineExpiry(matchId); - return; - } - this.server.to(matchId).emit('tick', { - deadline: deadlineIso, - serverTime: new Date().toISOString(), - }); - - const timer = setInterval(() => { - this.server.to(matchId).emit('tick', { - deadline: deadlineIso, - serverTime: new Date().toISOString(), - }); - - if (Date.now() >= deadline.getTime()) { - this.clearRoomTimer(matchId); - void this.handleDeadlineExpiry(matchId); - } - }, 1000); - - this.roomTimers.set(matchId, timer); - } - - private async handleDeadlineExpiry(matchIdStr: string) { - const matchId = new mongoose.Types.ObjectId(matchIdStr); - const auction = await this.auctionService - .getByMatchId(matchId) - .catch(() => null); - if (!auction || auction.phase !== 'bidding') return; - if (!auction.currentDeadline || auction.currentDeadline.getTime() > Date.now()) { - return; - } - - try { - const nextAuction = - auction.currentBid > 0 - ? await this.auctionService.markSold({ matchId }) - : await this.auctionService.markPassed(matchId); - this.broadcastState(matchIdStr, nextAuction); - } catch (error) { - this.emitKnownErrorToRoom(matchIdStr, error); - } - } - - private maybeClearRoomTimer(matchId: string) { - const room = this.server.adapter.rooms.get(matchId); - if (room && room.size > 0) return; - this.clearRoomTimer(matchId); - } - - private clearRoomTimer(matchId: string) { - const timer = this.roomTimers.get(matchId); - if (!timer) return; - clearInterval(timer); - this.roomTimers.delete(matchId); - } - private emitKnownError(socket: Socket, error: unknown) { const message = error instanceof Error ? error.message : 'Unexpected auction gateway error.'; this.emitError(socket, message); } - private emitKnownErrorToRoom(matchId: string, error: unknown) { - const message = - error instanceof Error ? error.message : 'Unexpected auction gateway error.'; - this.server.to(matchId).emit('error', { message }); - } - private emitError(socket: Socket, message: string) { socket.emit('error', { message }); } - private serializeAuction(auction: AuctionDocument) { + private serializeAuction(auction: AuctionStateResponse) { return JSON.parse(JSON.stringify(auction)); } + private buildBidDeltaFromAuctionState( + auction: AuctionStateResponse, + bidRequestId?: string, + ): Record | null { + const serialized = this.serializeAuction(auction) as Record; + const revision = Number(serialized.revision); + const currentHighestBidPointAmount = Number( + serialized.currentHighestBidPointAmount ?? serialized.currentBid, + ); + const currentHighestBidderTeamIndex = Number( + serialized.currentHighestBidderTeamIndex ?? + serialized.currentBidderTeamIndex, + ); + const currentBidRoundDeadlineTimestampMS = Number( + serialized.currentBidRoundDeadlineTimestampMS ?? + (typeof serialized.currentDeadline === 'string' + ? Date.parse(serialized.currentDeadline) + : 0), + ); + const redisBidHistory = Array.isArray(serialized.auctionBidHistory) + ? serialized.auctionBidHistory + : []; + const legacyBidHistory = Array.isArray(serialized.bids) + ? serialized.bids + : []; + const auctionBidHistoryEntry = + redisBidHistory[redisBidHistory.length - 1] ?? + this.convertLegacyBidToRedisBidHistoryEntry( + legacyBidHistory[legacyBidHistory.length - 1], + ); + + if ( + !Number.isFinite(currentHighestBidPointAmount) || + !Number.isFinite(currentHighestBidderTeamIndex) || + !auctionBidHistoryEntry + ) { + return null; + } + + return { + auctionBidHistoryEntry, + auctionLifecycleId: serialized.auctionLifecycleId, + bidRequestId, + currentBidRoundDeadlineTimestampMS: Number.isFinite( + currentBidRoundDeadlineTimestampMS, + ) + ? currentBidRoundDeadlineTimestampMS + : undefined, + currentHighestBidPointAmount, + currentHighestBidderTeamIndex, + currentServerTimestampMS: serialized.currentServerTimestampMS, + revision: Number.isFinite(revision) ? revision : undefined, + }; + } + + private convertLegacyBidToRedisBidHistoryEntry( + bid: unknown, + ): Record | null { + if (!bid || typeof bid !== 'object') return null; + const record = bid as Record; + return { + bidderTeamIndex: record.teamIndex, + bidPointAmount: record.amount, + bidderUserId: record.bidderUserId, + bidPlacedAtTimestampMS: + typeof record.timestamp === 'string' + ? Date.parse(record.timestamp) + : undefined, + }; + } + private serializeChatMessage(message: AuctionChatMessage) { return JSON.parse(JSON.stringify(message)); } diff --git a/apps/api/src/modules/auction/auction.module.ts b/apps/api/src/modules/auction/auction.module.ts index fbbb1ccd..cdf7c595 100644 --- a/apps/api/src/modules/auction/auction.module.ts +++ b/apps/api/src/modules/auction/auction.module.ts @@ -4,12 +4,29 @@ import { TournamentCodeModule } from '../tournament-code/tournament-code.module' import { TournamentResultModule } from '../tournament-result/tournament-result.module'; import { AuctionGateway } from './auction.gateway'; import { AuctionController } from './auction.controller'; +import { AuctionDeadlineScheduler } from './auction-deadline.scheduler'; +import { AuctionDurabilityScheduler } from './auction-durability.scheduler'; +import { AuctionEventBusService } from './auction-event-bus.service'; +import { AuctionRedisModule } from './redis/auction-redis.module'; +import { AuctionSideEffectService } from './auction-side-effect.service'; import { AuctionService } from './auction.service'; @Module({ - imports: [RiotModule, TournamentCodeModule, TournamentResultModule], + imports: [ + RiotModule, + TournamentCodeModule, + TournamentResultModule, + AuctionRedisModule, + ], controllers: [AuctionController], - providers: [AuctionService, AuctionGateway], + providers: [ + AuctionService, + AuctionGateway, + AuctionEventBusService, + AuctionDeadlineScheduler, + AuctionDurabilityScheduler, + AuctionSideEffectService, + ], exports: [AuctionService], }) export class AuctionModule {} diff --git a/apps/api/src/modules/auction/auction.service.spec.ts b/apps/api/src/modules/auction/auction.service.spec.ts index 8283132e..93f5cf06 100644 --- a/apps/api/src/modules/auction/auction.service.spec.ts +++ b/apps/api/src/modules/auction/auction.service.spec.ts @@ -37,6 +37,62 @@ describe('AuctionService', () => { scheduleInitialPoll: jest.fn().mockResolvedValue(null), cancelPolling: jest.fn().mockResolvedValue(undefined), }; + const auctionRedisService = { + acquireTokenLock: jest.fn().mockResolvedValue(true), + getCurrentRedisTimestampMS: jest.fn().mockResolvedValue(1780000000000), + releaseTokenLock: jest.fn().mockResolvedValue(true), + raw: jest.fn().mockReturnValue({ + sendCommand: jest.fn().mockResolvedValue(1), + }), + }; + const auctionRedisCommandService = { + applyTransition: jest.fn().mockResolvedValue({ + auctionStateTransitionId: 'transition-1', + currentServerTimestampMS: 1780000000000, + ok: true, + revision: 2, + }), + reserveActionRequest: jest.fn().mockImplementation( + async ( + _matchId: string, + input: { + auctionActionRequestId: string; + auctionStateTransitionId: string; + clientObservedAuctionLifecycleId: string; + }, + ) => ({ + actionRequestScopeKey: `${input.clientObservedAuctionLifecycleId}:${input.auctionActionRequestId}`, + auctionStateTransitionId: input.auctionStateTransitionId, + currentServerTimestampMS: 1780000000000, + newAuctionLifecycleId: '', + observedProcessingLeaseVersion: 1, + reserved: true, + wasLeaseExpired: false, + }), + ), + hydrateState: jest.fn().mockResolvedValue({ + currentServerTimestampMS: 1780000000000, + hydrated: true, + revision: 1, + }), + placeBid: jest.fn().mockResolvedValue({ + auctionBidHistoryEntry: { bidPointAmount: 20 }, + bidRequestId: 'bid-1', + currentBidRoundDeadlineTimestampMS: 1780000030000, + currentHighestBidderTeamIndex: 1, + currentHighestBidPointAmount: 20, + currentServerTimestampMS: 1780000000000, + ok: true, + revision: 3, + }), + }; + const auctionRedisStateReaderService = { + readLiveStateIdentity: jest.fn().mockResolvedValue({ + auctionLifecycleId: 'life-1', + revision: 1, + }), + readAuctionStateView: jest.fn().mockResolvedValue(null), + }; return { service: new AuctionService( @@ -44,11 +100,17 @@ describe('AuctionService', () => { enrichmentService as never, tournamentCodeService as never, tournamentResultService as never, + auctionRedisService as never, + auctionRedisCommandService as never, + auctionRedisStateReaderService as never, ), connectionService, tournamentCodeService, tournamentResultService, auctionHistoryModel, + auctionRedisCommandService, + auctionRedisService, + auctionRedisStateReaderService, }; } @@ -70,6 +132,55 @@ describe('AuctionService', () => { jest.useRealTimers(); }); + it('rejects live operations for migrated legacy auctions', async () => { + const matchId = new mongoose.Types.ObjectId(); + const auction = { + auctionEngineVersion: 'legacy-renamed', + matchId, + phase: 'bidding', + }; + const { service } = createService({ + auction: { + findOne: jest.fn().mockResolvedValue(auction), + }, + }); + + await expect( + service.placeBid({ + amount: 10, + matchId, + teamIndex: 1, + }), + ).rejects.toThrow('Legacy auction live operations are not supported.'); + }); + + it('rejects non-positive or fractional bid amounts before loading auction state', async () => { + const matchId = new mongoose.Types.ObjectId(); + const auctionFindOne = jest.fn(); + const { service, auctionRedisCommandService, auctionRedisService } = createService({ + auction: { + findOne: auctionFindOne, + }, + }); + + await expect( + service.placeBid({ + amount: 0, + matchId, + teamIndex: 1, + }), + ).rejects.toThrow('Bid amount must be a positive integer.'); + await expect( + service.placeBid({ + amount: 10.5, + matchId, + teamIndex: 1, + }), + ).rejects.toThrow('Bid amount must be a positive integer.'); + expect(auctionFindOne).not.toHaveBeenCalled(); + expect(auctionRedisCommandService.placeBid).not.toHaveBeenCalled(); + }); + it('starts an auction without reserving tournament codes before teams are complete', async () => { const matchId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId(); @@ -141,15 +252,16 @@ describe('AuctionService', () => { await service.start({ matchId, communityId, + startAuctionRequestId: '00000000-0000-4000-8000-000000000001', captains: [ { teamIndex: 1, userId: userIds[0] }, { teamIndex: 2, userId: userIds[1] }, ], - initialPoints: 1000, - maxTimerSeconds: 30, - bidExtensionSeconds: 5, - topTierThreshold: 'NONE', - manualTopTierUserIds: [], + initialTeamBidPointAmount: 1000, + maximumBidRoundDurationSeconds: 30, + bidRoundExtensionSeconds: 5, + topTierAuctionPriorityThreshold: 'NONE', + manualTopTierAuctionPriorityUserIds: [], }); expect(match.status).toBe('team-built'); @@ -159,6 +271,839 @@ describe('AuctionService', () => { expect(tournamentResultService.scheduleInitialPoll).not.toHaveBeenCalled(); }); + it('creates redis-v1 auction fields and bootstraps Redis state when starting', async () => { + const matchId = new mongoose.Types.ObjectId(); + const communityId = new mongoose.Types.ObjectId(); + const userIds = Array.from( + { length: 10 }, + () => new mongoose.Types.ObjectId(), + ); + const participants = userIds.map((userId, index) => ({ + userId, + preferredPositions: [{ position: 'MID', priority: 1 }], + joinedAt: new Date(index), + excluded: false, + })); + const match = { + _id: matchId, + communityId, + participants, + status: 'recruiting', + teamBuiltAt: undefined, + save: jest.fn().mockResolvedValue(undefined), + }; + const users = userIds.slice(2).map((userId, index) => ({ + _id: userId, + riotAccounts: [ + { + puuid: `puuid-${index}`, + gameName: `Player${index}`, + tagLine: 'KR1', + profileIconId: index, + tiers: [], + championMasteries: [], + recentStatsSummary: undefined, + lastRefreshRequestedAt: new Date(), + isPrimary: true, + }, + ], + })); + const auctionCreate = jest.fn().mockImplementation(async (payload) => ({ + _id: payload._id, + matchId, + ...payload, + toObject: jest.fn().mockReturnValue({ matchId, ...payload }), + })); + const { service, auctionRedisCommandService, auctionRedisService } = + createService({ + match: { + findById: jest.fn().mockResolvedValue(match), + }, + user: { + find: jest.fn().mockResolvedValue(users), + }, + auction: { + findOne: jest.fn().mockResolvedValue(null), + create: auctionCreate, + }, + community: { + findById: jest.fn().mockReturnValue({ + select: jest.fn().mockReturnValue({ + lean: jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ + riotPlatform: 'kr', + riotRegion: 'asia', + }), + }), + }), + }), + }, + }); + + await service.start({ + matchId, + communityId, + startAuctionRequestId: '00000000-0000-4000-8000-000000000011', + captains: [ + { teamIndex: 1, userId: userIds[0] }, + { + teamIndex: 2, + userId: userIds[1], + initialTeamBidPointAmount: 1200, + }, + ], + initialTeamBidPointAmount: 1000, + maximumBidRoundDurationSeconds: 30, + bidRoundExtensionSeconds: 5, + topTierAuctionPriorityThreshold: 'NONE', + manualTopTierAuctionPriorityUserIds: [], + }); + + const createdPayload = auctionCreate.mock.calls[0][0]; + expect(auctionRedisService.getCurrentRedisTimestampMS).toHaveBeenCalled(); + expect(createdPayload).toMatchObject({ + auctionEngineVersion: 'redis-v1', + currentAuctionHistorySequence: 1, + currentAuctionPlayerOrderIndex: 0, + currentAuctionRound: 1, + currentHighestBidPointAmount: 0, + initialTeamBidPointAmount: 1000, + matchSideEffectRevision: 0, + matchSideEffectStatus: 'none', + phase: 'presenting', + revision: 1, + }); + expect(createdPayload.auctionTeams).toEqual([ + expect.objectContaining({ + remainingBidPointAmount: 1000, + teamIndex: 1, + }), + expect.objectContaining({ + remainingBidPointAmount: 1200, + teamIndex: 2, + }), + ]); + expect(createdPayload.auctionStartedAtTimestampMS).toBe(1780000000000); + expect(createdPayload.startedAt).toEqual(new Date(1780000000000)); + expect(auctionRedisCommandService.hydrateState).toHaveBeenCalledWith( + matchId.toString(), + expect.objectContaining({ + auctionHistorySequence: 1, + maximumBidRoundDurationSeconds: 30, + matchId: matchId.toString(), + phase: 'presenting', + revision: 0, + }), + ); + }); + + it('replays start when the same startAuctionRequestId already created the auction', async () => { + const matchId = new mongoose.Types.ObjectId(); + const communityId = new mongoose.Types.ObjectId(); + const existingAuction = { + _id: new mongoose.Types.ObjectId(), + matchId, + startAuctionRequestId: '00000000-0000-4000-8000-000000000010', + }; + const auctionCreate = jest.fn(); + const { service } = createService({ + match: { + findById: jest.fn().mockResolvedValue({ + _id: matchId, + communityId, + }), + }, + user: { + find: jest.fn(), + }, + auction: { + findOne: jest.fn().mockResolvedValue(existingAuction), + create: auctionCreate, + }, + community: { + findById: jest.fn(), + }, + }); + + await expect( + service.start({ + matchId, + communityId, + startAuctionRequestId: '00000000-0000-4000-8000-000000000010', + captains: [], + initialTeamBidPointAmount: 1000, + maximumBidRoundDurationSeconds: 30, + bidRoundExtensionSeconds: 5, + topTierAuctionPriorityThreshold: 'NONE', + manualTopTierAuctionPriorityUserIds: [], + }), + ).resolves.toBe(existingAuction); + expect(auctionCreate).not.toHaveBeenCalled(); + }); + + it('rejects start while a redis reset side effect is still applying', async () => { + const matchId = new mongoose.Types.ObjectId(); + const communityId = new mongoose.Types.ObjectId(); + const existingAuction = { + _id: new mongoose.Types.ObjectId(), + auctionEngineVersion: 'redis-v1', + matchSideEffectStatus: 'pending', + phase: 'waiting', + startAuctionRequestId: '00000000-0000-4000-8000-000000000020', + }; + const auctionCreate = jest.fn(); + const { service } = createService({ + match: { + findById: jest.fn().mockResolvedValue({ + _id: matchId, + communityId, + }), + }, + user: { + find: jest.fn(), + }, + auction: { + findOne: jest.fn().mockResolvedValue(existingAuction), + create: auctionCreate, + }, + community: { + findById: jest.fn(), + }, + }); + + await expect( + service.start({ + matchId, + communityId, + startAuctionRequestId: '00000000-0000-4000-8000-000000000021', + captains: [], + initialTeamBidPointAmount: 1000, + maximumBidRoundDurationSeconds: 30, + bidRoundExtensionSeconds: 5, + topTierAuctionPriorityThreshold: 'NONE', + manualTopTierAuctionPriorityUserIds: [], + }), + ).rejects.toThrow('Auction reset is still being applied.'); + expect(auctionCreate).not.toHaveBeenCalled(); + }); + + it('removes a completed redis reset auction before starting again', async () => { + const matchId = new mongoose.Types.ObjectId(); + const communityId = new mongoose.Types.ObjectId(); + const oldAuctionId = new mongoose.Types.ObjectId(); + const userIds = Array.from( + { length: 10 }, + () => new mongoose.Types.ObjectId(), + ); + const participants = userIds.map((userId, index) => ({ + userId, + preferredPositions: [{ position: 'MID', priority: 1 }], + joinedAt: new Date(index), + excluded: false, + })); + const users = userIds.slice(2).map((userId, index) => ({ + _id: userId, + riotAccounts: [ + { + puuid: `puuid-${index}`, + gameName: `Player${index}`, + tagLine: 'KR1', + profileIconId: index, + tiers: [], + championMasteries: [], + recentStatsSummary: undefined, + lastRefreshRequestedAt: new Date(), + isPrimary: true, + }, + ], + })); + const existingAuction = { + _id: oldAuctionId, + auctionEngineVersion: 'redis-v1', + auctionLifecycleId: 'old-life-1', + matchSideEffectStatus: 'completed', + phase: 'waiting', + startAuctionRequestId: '00000000-0000-4000-8000-000000000022', + }; + const match = { + _id: matchId, + communityId, + participants, + status: 'recruiting', + teamBuiltAt: undefined, + save: jest.fn().mockResolvedValue(undefined), + }; + const auctionCreate = jest.fn().mockImplementation(async (payload) => ({ + _id: payload._id, + matchId, + ...payload, + toObject: jest.fn().mockReturnValue({ matchId, ...payload }), + })); + const auctionDeleteOne = jest.fn().mockResolvedValue({ deletedCount: 1 }); + const historyDeleteMany = jest.fn().mockResolvedValue({ deletedCount: 2 }); + const { service, auctionRedisCommandService, auctionRedisService } = createService({ + match: { + findById: jest.fn().mockResolvedValue(match), + }, + user: { + find: jest.fn().mockResolvedValue(users), + }, + auction: { + create: auctionCreate, + deleteOne: auctionDeleteOne, + findOne: jest.fn().mockResolvedValue(existingAuction), + }, + auctionHistory: { + create: jest.fn().mockResolvedValue(undefined), + deleteMany: historyDeleteMany, + findOne: jest.fn().mockReturnValue({ + sort: jest.fn().mockReturnValue({ + select: jest.fn().mockReturnValue({ + lean: jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue(null), + }), + }), + }), + }), + }, + community: { + findById: jest.fn().mockReturnValue({ + select: jest.fn().mockReturnValue({ + lean: jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ + riotPlatform: 'kr', + riotRegion: 'asia', + }), + }), + }), + }), + }, + }); + + await service.start({ + matchId, + communityId, + startAuctionRequestId: '00000000-0000-4000-8000-000000000023', + captains: [ + { teamIndex: 1, userId: userIds[0] }, + { teamIndex: 2, userId: userIds[1] }, + ], + initialTeamBidPointAmount: 1000, + maximumBidRoundDurationSeconds: 30, + bidRoundExtensionSeconds: 5, + topTierAuctionPriorityThreshold: 'NONE', + manualTopTierAuctionPriorityUserIds: [], + }); + + expect(historyDeleteMany).toHaveBeenCalledWith({ auctionId: oldAuctionId }); + expect(auctionDeleteOne).toHaveBeenCalledWith({ _id: oldAuctionId }); + expect(auctionRedisService.raw().sendCommand).toHaveBeenCalledWith([ + 'EVAL', + expect.stringContaining('currentAuctionLifecycleId'), + '11', + `auction:${matchId.toString()}:liveAuctionState`, + 'auction:bidRoundDeadlineQueue', + `auction:${matchId.toString()}:auctionStructureState`, + `auction:${matchId.toString()}:appliedAuctionStateTransitionIds`, + `auction:${matchId.toString()}:auctionBidHistory`, + `auction:${matchId.toString()}:bidRequestResults`, + `auction:${matchId.toString()}:bidRequestResultOrder`, + `auction:${matchId.toString()}:auctionActionRequestResults`, + `auction:${matchId.toString()}:auctionActionRequestResultOrder`, + `auction:${matchId.toString()}:rehydrateLock`, + `auction:${matchId.toString()}:auctionStateTransitionLock`, + matchId.toString(), + 'old-life-1', + ]); + expect(auctionCreate).toHaveBeenCalledTimes(1); + expect(auctionRedisCommandService.hydrateState).toHaveBeenCalled(); + }); + + it('replays start after a concurrent create wins with the same request id', async () => { + const matchId = new mongoose.Types.ObjectId(); + const communityId = new mongoose.Types.ObjectId(); + const userIds = Array.from( + { length: 10 }, + () => new mongoose.Types.ObjectId(), + ); + const participants = userIds.map((userId, index) => ({ + userId, + preferredPositions: [{ position: 'MID', priority: 1 }], + joinedAt: new Date(index), + excluded: false, + })); + const users = userIds.slice(2).map((userId, index) => ({ + _id: userId, + riotAccounts: [ + { + puuid: `puuid-${index}`, + gameName: `Player${index}`, + tagLine: 'KR1', + profileIconId: index, + tiers: [], + championMasteries: [], + recentStatsSummary: undefined, + lastRefreshRequestedAt: new Date(), + isPrimary: true, + }, + ], + })); + const raceWinner = { + _id: new mongoose.Types.ObjectId(), + matchId, + startAuctionRequestId: '00000000-0000-4000-8000-000000000012', + }; + const match = { + _id: matchId, + communityId, + participants, + status: 'recruiting', + save: jest.fn().mockResolvedValue(undefined), + }; + const auctionFindOne = jest + .fn() + .mockResolvedValueOnce(null) + .mockResolvedValueOnce(raceWinner); + const auctionCreate = jest.fn().mockRejectedValue({ code: 11000 }); + const { service, auctionRedisCommandService } = createService({ + match: { + findById: jest.fn().mockResolvedValue(match), + }, + user: { + find: jest.fn().mockResolvedValue(users), + }, + auction: { + findOne: auctionFindOne, + create: auctionCreate, + }, + community: { + findById: jest.fn().mockReturnValue({ + select: jest.fn().mockReturnValue({ + lean: jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ + riotPlatform: 'kr', + riotRegion: 'asia', + }), + }), + }), + }), + }, + }); + + await expect( + service.start({ + matchId, + communityId, + startAuctionRequestId: '00000000-0000-4000-8000-000000000012', + captains: [ + { teamIndex: 1, userId: userIds[0] }, + { teamIndex: 2, userId: userIds[1] }, + ], + initialTeamBidPointAmount: 1000, + maximumBidRoundDurationSeconds: 30, + bidRoundExtensionSeconds: 5, + topTierAuctionPriorityThreshold: 'NONE', + manualTopTierAuctionPriorityUserIds: [], + }), + ).resolves.toBe(raceWinner); + + expect(auctionCreate).toHaveBeenCalledTimes(1); + expect(auctionRedisCommandService.hydrateState).not.toHaveBeenCalled(); + expect(match.save).not.toHaveBeenCalled(); + }); + + it('reads Redis state view for redis-v1 auctions', async () => { + const matchId = new mongoose.Types.ObjectId(); + const auction = { + _id: new mongoose.Types.ObjectId(), + matchId, + auctionEngineVersion: 'redis-v1', + chatMessages: [{ id: 'chat-1' }], + toObject: jest.fn().mockReturnValue({ + matchId, + phase: 'presenting', + revision: 1, + }), + }; + const { service, auctionRedisStateReaderService } = createService({ + auction: { + findOne: jest.fn().mockResolvedValue(auction), + }, + }); + auctionRedisStateReaderService.readAuctionStateView.mockResolvedValue({ + phase: 'bidding', + revision: 2, + currentServerTimestampMS: 1000, + }); + + await expect(service.getStateByMatchId(matchId)).resolves.toMatchObject({ + chatMessages: [{ id: 'chat-1' }], + currentServerTimestampMS: 1000, + phase: 'bidding', + revision: 2, + }); + expect( + auctionRedisStateReaderService.readAuctionStateView, + ).toHaveBeenCalledWith(matchId.toString()); + }); + + it('rehydrates Redis state from Mongo projection when live state is missing', async () => { + const matchId = new mongoose.Types.ObjectId(); + const playerUserId = new mongoose.Types.ObjectId(); + const captainUserId = new mongoose.Types.ObjectId(); + const auction = { + _id: new mongoose.Types.ObjectId(), + matchId, + auctionEngineVersion: 'redis-v1', + auctionLifecycleId: 'life-1', + phase: 'presenting', + revision: 4, + currentAuctionHistorySequence: 3, + auctionTeams: [ + { + teamIndex: 1, + captainUserId: captainUserId.toString(), + remainingBidPointAmount: 1000, + members: [], + }, + ], + auctionPlayerOrder: [{ userId: playerUserId.toString() }], + passedAuctionPlayerQueue: [], + currentAuctionRound: 1, + currentAuctionPlayerOrderIndex: 0, + maximumBidRoundDurationSeconds: 30, + bidRoundExtensionSeconds: 5, + initialTeamBidPointAmount: 1000, + topTierAuctionPriorityThreshold: 'NONE', + manualTopTierAuctionPriorityUserIds: [], + chatMessages: [], + toObject: jest.fn().mockReturnValue({ + matchId, + phase: 'presenting', + revision: 4, + }), + }; + const redisState = { + auctionLifecycleId: 'life-1', + phase: 'presenting', + revision: 5, + shouldForceAuctionStateResync: true, + }; + const { + service, + auctionRedisCommandService, + auctionRedisService, + auctionRedisStateReaderService, + } = createService({ + auction: { + findOne: jest.fn().mockResolvedValue(auction), + }, + }); + auctionRedisStateReaderService.readLiveStateIdentity.mockResolvedValue(null); + auctionRedisStateReaderService.readAuctionStateView.mockResolvedValue( + redisState, + ); + + await expect(service.getStateByMatchId(matchId)).resolves.toMatchObject({ + phase: 'presenting', + revision: 5, + shouldForceAuctionStateResync: true, + }); + expect(auctionRedisService.acquireTokenLock).toHaveBeenCalledWith( + `auction:${matchId.toString()}:rehydrateLock`, + expect.any(String), + 5000, + ); + expect(auctionRedisCommandService.hydrateState).toHaveBeenCalledWith( + matchId.toString(), + expect.objectContaining({ + auctionLifecycleId: 'life-1', + phase: 'presenting', + revision: 4, + }), + ); + expect( + auctionRedisStateReaderService.readAuctionStateView, + ).toHaveBeenCalledWith(matchId.toString(), { + shouldForceAuctionStateResync: true, + }); + }); + + it('opens bidding through Redis for redis-v1 auctions', async () => { + const matchId = new mongoose.Types.ObjectId(); + const auction = { + _id: new mongoose.Types.ObjectId(), + matchId, + auctionEngineVersion: 'redis-v1', + }; + const presentingState = { + auctionLifecycleId: 'life-1', + auctionTeams: [ + { + teamIndex: 1, + captainUserId: new mongoose.Types.ObjectId().toString(), + remainingBidPointAmount: 1000, + members: [], + }, + ], + auctionPlayerOrder: [ + { + userId: new mongoose.Types.ObjectId().toString(), + preferredPositions: [{ position: 'MID', priority: 1 }], + }, + ], + bidRoundExtensionSeconds: 5, + currentAuctionHistorySequence: 1, + currentAuctionPlayerOrderIndex: 0, + currentAuctionRound: 1, + initialTeamBidPointAmount: 1000, + maximumBidRoundDurationSeconds: 30, + passedAuctionPlayerQueue: [], + phase: 'presenting', + revision: 1, + topTierAuctionPriorityThreshold: 'NONE', + }; + const biddingState = { + ...presentingState, + currentBidRoundDeadlineTimestampMS: 1780000030000, + phase: 'bidding', + revision: 2, + }; + const { service, auctionRedisCommandService, auctionRedisStateReaderService } = + createService({ + auction: { + findOne: jest.fn().mockResolvedValue(auction), + }, + }); + auctionRedisStateReaderService.readAuctionStateView + .mockResolvedValueOnce(presentingState) + .mockResolvedValueOnce(biddingState); + + await expect( + service.openBidding(matchId, { + auctionActionRequestId: '00000000-0000-4000-8000-000000000060', + clientObservedAuctionLifecycleId: 'life-1', + clientObservedCurrentAuctionPlayerOrderIndex: 0, + clientObservedPhase: 'presenting', + clientObservedRevision: 1, + }), + ).resolves.toMatchObject({ + phase: 'bidding', + revision: 2, + }); + expect( + auctionRedisCommandService.reserveActionRequest, + ).toHaveBeenCalledWith( + matchId.toString(), + expect.objectContaining({ + auctionActionRequestId: '00000000-0000-4000-8000-000000000060', + auctionActionType: 'open-bidding', + auctionStateTransitionId: + 'open-bidding:life-1:00000000-0000-4000-8000-000000000060', + clientObservedAuctionLifecycleId: 'life-1', + clientObservedCurrentAuctionPlayerOrderIndex: 0, + clientObservedPhase: 'presenting', + clientObservedRevision: 1, + }), + ); + expect(auctionRedisCommandService.applyTransition).toHaveBeenCalledWith( + matchId.toString(), + expect.objectContaining({ + actionRequest: expect.objectContaining({ + observedProcessingLeaseVersion: 1, + scopeKey: 'life-1:00000000-0000-4000-8000-000000000060', + }), + auctionStateTransitionId: + 'open-bidding:life-1:00000000-0000-4000-8000-000000000060', + deadline: { durationSeconds: 30, mode: 'set-relative' }, + expectedPhase: 'presenting', + expectedRevision: 1, + liveStatePatch: expect.objectContaining({ + currentHighestBidPointAmount: 0, + currentHighestBidderTeamIndex: -1, + phase: 'bidding', + 'team:1:assignedAuctionTeamMemberCount': 1, + 'team:1:remainingBidPointAmount': 1000, + }), + }), + ); + const transitionInput = + auctionRedisCommandService.applyTransition.mock.calls[0][1]; + expect(JSON.parse(transitionInput.durabilityPayloadJson)).toMatchObject({ + afterAuctionMongoProjection: expect.objectContaining({ + phase: 'bidding', + revision: 2, + }), + auctionActionType: 'open-bidding', + historyMutation: { type: 'append' }, + matchSideEffectMutation: { type: 'none' }, + snapshotBefore: expect.objectContaining({ + phase: 'presenting', + }), + }); + }); + + it('places bids through Redis for redis-v1 auctions', async () => { + const matchId = new mongoose.Types.ObjectId(); + const captainUserId = new mongoose.Types.ObjectId(); + const playerUserId = new mongoose.Types.ObjectId(); + const auction = { + _id: new mongoose.Types.ObjectId(), + matchId, + auctionEngineVersion: 'redis-v1', + }; + const biddingState = { + auctionLifecycleId: 'life-1', + auctionTeams: [ + { + teamIndex: 1, + captainUserId: captainUserId.toString(), + remainingBidPointAmount: 1000, + members: [], + }, + ], + currentBidRoundPlayerUserId: playerUserId.toString(), + phase: 'bidding', + revision: 2, + }; + const afterBidState = { + ...biddingState, + currentHighestBidderTeamIndex: 1, + currentHighestBidPointAmount: 120, + revision: 3, + }; + const { service, auctionRedisCommandService, auctionRedisStateReaderService } = + createService({ + auction: { + findOne: jest.fn().mockResolvedValue(auction), + }, + }); + auctionRedisStateReaderService.readAuctionStateView + .mockResolvedValueOnce(biddingState) + .mockResolvedValueOnce(afterBidState); + + await expect( + service.placeBid({ + amount: 120, + bidRequestId: '00000000-0000-4000-8000-000000000050', + matchId, + teamIndex: 1, + }), + ).resolves.toMatchObject({ + currentHighestBidderTeamIndex: 1, + currentHighestBidPointAmount: 120, + revision: 3, + }); + expect(auctionRedisCommandService.placeBid).toHaveBeenCalledWith( + matchId.toString(), + expect.objectContaining({ + bidPointAmount: 120, + bidderTeamIndex: 1, + bidderUserId: captainUserId.toString(), + clientObservedAuctionLifecycleId: 'life-1', + clientObservedCurrentBidRoundPlayerUserId: playerUserId.toString(), + }), + ); + }); + + it('syncs match teams when a redis-v1 auction completes', async () => { + const matchId = new mongoose.Types.ObjectId(); + const captainUserId = new mongoose.Types.ObjectId(); + const memberUserId = new mongoose.Types.ObjectId(); + const auction = { + _id: new mongoose.Types.ObjectId(), + matchId, + auctionEngineVersion: 'redis-v1', + }; + const soldState = { + auctionLifecycleId: 'life-1', + auctionTeams: [ + { + teamIndex: 1, + captainUserId: captainUserId.toString(), + remainingBidPointAmount: 970, + members: [ + { + userId: memberUserId.toString(), + assignedPosition: 'ADC', + memberAcquisitionBidPointAmount: 30, + }, + ], + }, + ], + auctionPlayerOrder: [{ userId: memberUserId.toString() }], + bidRoundExtensionSeconds: 5, + currentAuctionHistorySequence: 2, + currentAuctionPlayerOrderIndex: 0, + currentAuctionRound: 1, + initialTeamBidPointAmount: 1000, + maximumBidRoundDurationSeconds: 30, + passedAuctionPlayerQueue: [], + phase: 'sold', + revision: 3, + topTierAuctionPriorityThreshold: 'NONE', + }; + const completeState = { + ...soldState, + auctionCompletedAtTimestampMS: 1780000100000, + phase: 'complete', + revision: 4, + }; + const match = { + participants: [ + { + userId: captainUserId, + preferredPositions: [{ position: 'TOP', priority: 1 }], + }, + { + userId: memberUserId, + preferredPositions: [{ position: 'ADC', priority: 1 }], + }, + ], + status: 'team-built', + teams: [], + teamBuiltAt: undefined, + save: jest.fn().mockResolvedValue(undefined), + }; + const { + service, + auctionRedisCommandService, + auctionRedisStateReaderService, + tournamentCodeService, + tournamentResultService, + } = + createService({ + auction: { + findOne: jest.fn().mockResolvedValue(auction), + }, + match: { + findById: jest.fn().mockResolvedValue(match), + }, + }); + auctionRedisStateReaderService.readAuctionStateView + .mockResolvedValueOnce(soldState) + .mockResolvedValueOnce(completeState); + + await expect(service.next(matchId)).resolves.toMatchObject({ + phase: 'complete', + revision: 4, + }); + const [, transitionInput] = + auctionRedisCommandService.applyTransition.mock.calls.at(-1) ?? []; + expect(JSON.parse(transitionInput.durabilityPayloadJson)).toMatchObject({ + afterAuctionMongoProjection: { + matchSideEffectStatus: 'pending', + phase: 'complete', + }, + auctionActionType: 'complete', + matchSideEffectMutation: { type: 'syncMatchTeamsAfterComplete' }, + }); + expect(match.teams).toEqual([]); + expect(match.save).not.toHaveBeenCalled(); + expect(tournamentCodeService.reserveForMatch).not.toHaveBeenCalled(); + expect(tournamentResultService.scheduleInitialPoll).not.toHaveBeenCalled(); + }); + it('appends a chat message and keeps only the latest 200 messages', async () => { const matchId = new mongoose.Types.ObjectId(); const userId = new mongoose.Types.ObjectId(); @@ -300,15 +1245,16 @@ describe('AuctionService', () => { await service.start({ matchId, communityId, + startAuctionRequestId: '00000000-0000-4000-8000-000000000002', captains: [ { teamIndex: 1, userId: userIds[0] }, { teamIndex: 2, userId: userIds[1] }, ], - initialPoints: 1000, - maxTimerSeconds: 30, - bidExtensionSeconds: 5, - topTierThreshold: 'NONE', - manualTopTierUserIds: [], + initialTeamBidPointAmount: 1000, + maximumBidRoundDurationSeconds: 30, + bidRoundExtensionSeconds: 5, + topTierAuctionPriorityThreshold: 'NONE', + manualTopTierAuctionPriorityUserIds: [], }); const signupOrder = userIds.slice(2).map((userId) => userId.toString()); @@ -413,15 +1359,16 @@ describe('AuctionService', () => { await service.start({ matchId, communityId, + startAuctionRequestId: '00000000-0000-4000-8000-000000000003', captains: [ { teamIndex: 1, userId: userIds[0] }, { teamIndex: 2, userId: userIds[1] }, ], - initialPoints: 1000, - maxTimerSeconds: 30, - bidExtensionSeconds: 5, - topTierThreshold: 'NONE', - manualTopTierUserIds: [], + initialTeamBidPointAmount: 1000, + maximumBidRoundDurationSeconds: 30, + bidRoundExtensionSeconds: 5, + topTierAuctionPriorityThreshold: 'NONE', + manualTopTierAuctionPriorityUserIds: [], }); const firstPlayerSnapshot = auctionCreate.mock.calls[0][0].order.find( @@ -923,6 +1870,141 @@ describe('AuctionService', () => { expect(session.commitTransaction).toHaveBeenCalledTimes(1); }); + it('uses Redis transition when resetting a redis-v1 auction', async () => { + const matchId = new mongoose.Types.ObjectId(); + const communityId = new mongoose.Types.ObjectId(); + const auctionId = new mongoose.Types.ObjectId(); + const session = { + startTransaction: jest.fn(), + commitTransaction: jest.fn().mockResolvedValue(undefined), + abortTransaction: jest.fn().mockResolvedValue(undefined), + endSession: jest.fn().mockResolvedValue(undefined), + }; + const auction = { + _id: auctionId, + auctionEngineVersion: 'redis-v1', + auctionLifecycleId: 'life-1', + matchId, + matchSideEffectRevision: 0, + deleteOne: jest.fn().mockResolvedValue(undefined), + }; + const match = { + communityId, + status: 'team-built', + teams: [], + tournamentCodeIds: [], + gameSchedule: [], + participants: [], + save: jest.fn().mockResolvedValue(undefined), + }; + const currentRedisState = { + auctionLifecycleId: 'life-1', + auctionPlayerOrder: [{ userId: 'player-1', passCount: 0 }], + auctionTeams: [ + { + captainUserId: new mongoose.Types.ObjectId(), + members: [], + remainingBidPointAmount: 1000, + teamIndex: 1, + }, + ], + bidRoundExtensionSeconds: 5, + currentAuctionHistorySequence: 4, + currentAuctionPlayerOrderIndex: 0, + currentAuctionRound: 1, + currentBidRoundPlayerUserId: 'player-1', + currentHighestBidPointAmount: 20, + currentHighestBidderTeamIndex: 1, + initialTeamBidPointAmount: 1000, + maximumBidRoundDurationSeconds: 30, + passedAuctionPlayerQueue: [], + phase: 'bidding', + revision: 4, + topTierAuctionPriorityThreshold: 'NONE', + }; + const resetRedisState = { + ...currentRedisState, + auctionPlayerOrder: [], + auctionTeams: [], + currentAuctionHistorySequence: 5, + currentAuctionPlayerOrderIndex: 0, + currentHighestBidPointAmount: 0, + currentHighestBidderTeamIndex: -1, + matchSideEffectRevision: 1, + matchSideEffectStatus: 'pending', + phase: 'waiting', + revision: 5, + }; + const { service, connectionService, auctionRedisCommandService, auctionRedisStateReaderService } = createService({ + auction: { + findOne: jest.fn().mockReturnValue({ + session: jest.fn().mockResolvedValue(auction), + }), + }, + match: { + findById: jest.fn().mockReturnValue({ + session: jest.fn().mockResolvedValue(match), + }), + }, + }); + connectionService.createSession.mockResolvedValue(session); + auctionRedisStateReaderService.readAuctionStateView + .mockResolvedValueOnce(currentRedisState) + .mockResolvedValueOnce(resetRedisState); + + await service.reset({ + auctionActionRequestId: '00000000-0000-4000-8000-000000000080', + clientObservedAuctionLifecycleId: 'life-1', + clientObservedCurrentAuctionPlayerOrderIndex: 0, + clientObservedCurrentBidRoundPlayerUserId: 'player-1', + clientObservedPhase: 'bidding', + clientObservedRevision: 4, + matchId, + communityId, + }); + + expect(auction.deleteOne).not.toHaveBeenCalled(); + expect(match.save).not.toHaveBeenCalled(); + expect(auctionRedisCommandService.reserveActionRequest).toHaveBeenCalledWith( + matchId.toString(), + expect.objectContaining({ + auctionActionRequestId: '00000000-0000-4000-8000-000000000080', + auctionStateTransitionId: + 'reset:life-1:00000000-0000-4000-8000-000000000080', + clientObservedAuctionLifecycleId: 'life-1', + clientObservedCurrentAuctionPlayerOrderIndex: 0, + clientObservedCurrentBidRoundPlayerUserId: 'player-1', + clientObservedPhase: 'bidding', + clientObservedRevision: 4, + }), + ); + expect(auctionRedisCommandService.applyTransition).toHaveBeenCalledTimes(1); + const transitionInput = + auctionRedisCommandService.applyTransition.mock.calls[0][1]; + expect(transitionInput.deadline).toEqual({ mode: 'remove' }); + expect(transitionInput.expectedPhase).toBe('bidding'); + expect(transitionInput.liveStatePatch).toMatchObject({ + currentBidRoundDeadlineTimestampMS: 0, + currentBidRoundPlayerUserId: '', + currentHighestBidPointAmount: 0, + currentHighestBidderTeamIndex: -1, + matchSideEffectRevision: 1, + matchSideEffectStatus: 'pending', + phase: 'waiting', + 'team:1:assignedAuctionTeamMemberCount': 0, + 'team:1:remainingBidPointAmount': 0, + }); + expect(transitionInput.shouldResetBidRuntime).toBe(true); + const durabilityPayload = JSON.parse( + transitionInput.durabilityPayloadJson, + ); + expect(durabilityPayload).toMatchObject({ + auctionActionType: 'reset', + historyMutation: { resetMode: 'clear-history', type: 'reset' }, + matchSideEffectMutation: { type: 'resetMatchAfterAuctionReset' }, + }); + }); + it('undoes to a history snapshot and releases resources when leaving complete', async () => { const matchId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId(); @@ -1010,4 +2092,155 @@ describe('AuctionService', () => { ); expect(session.commitTransaction).toHaveBeenCalledTimes(1); }); + + it('uses Redis transition when undoing a redis-v1 auction', async () => { + const matchId = new mongoose.Types.ObjectId(); + const communityId = new mongoose.Types.ObjectId(); + const auctionId = new mongoose.Types.ObjectId(); + const session = { + startTransaction: jest.fn(), + commitTransaction: jest.fn().mockResolvedValue(undefined), + abortTransaction: jest.fn().mockResolvedValue(undefined), + endSession: jest.fn().mockResolvedValue(undefined), + }; + const auction = { + _id: auctionId, + auctionEngineVersion: 'redis-v1', + auctionLifecycleId: 'life-1', + completedAt: new Date(), + matchId, + matchSideEffectRevision: 0, + }; + const snapshot = { + _id: auctionId.toString(), + auctionLifecycleId: 'life-1', + auctionPlayerOrder: [{ userId: 'player-1', passCount: 0 }], + auctionTeams: [], + bidRoundExtensionSeconds: 5, + currentAuctionHistorySequence: 3, + currentAuctionPlayerOrderIndex: 0, + currentAuctionRound: 1, + currentHighestBidPointAmount: 0, + currentHighestBidderTeamIndex: -1, + initialTeamBidPointAmount: 1000, + matchId: matchId.toString(), + maximumBidRoundDurationSeconds: 30, + passedAuctionPlayerQueue: [], + phase: 'bidding', + revision: 4, + topTierAuctionPriorityThreshold: 'NONE', + }; + const match = { + communityId, + }; + const currentRedisState = { + auctionLifecycleId: 'life-1', + auctionPlayerOrder: [{ userId: 'player-2', passCount: 0 }], + auctionTeams: [], + bidRoundExtensionSeconds: 5, + currentAuctionHistorySequence: 5, + currentAuctionPlayerOrderIndex: 0, + currentAuctionRound: 1, + currentBidRoundPlayerUserId: 'player-2', + currentHighestBidPointAmount: 0, + currentHighestBidderTeamIndex: -1, + initialTeamBidPointAmount: 1000, + maximumBidRoundDurationSeconds: 30, + passedAuctionPlayerQueue: [], + phase: 'complete', + revision: 5, + topTierAuctionPriorityThreshold: 'NONE', + }; + const restoredRedisState = { + ...snapshot, + currentServerTimestampMS: 1780000000000, + phase: 'bidding', + revision: 6, + }; + const historyFindOneQuery = { + session: jest.fn().mockReturnValue({ + lean: jest.fn().mockReturnValue({ + exec: jest.fn().mockResolvedValue({ + auctionId, + matchId, + sequence: 3, + snapshotBefore: snapshot, + }), + }), + }), + }; + const auctionReplaceOne = jest.fn(); + const { service, connectionService, auctionRedisCommandService, auctionRedisStateReaderService } = + createService({ + auction: { + findOne: jest.fn().mockReturnValue({ + session: jest.fn().mockResolvedValue(auction), + }), + replaceOne: auctionReplaceOne, + }, + auctionHistory: { + findOne: jest.fn().mockReturnValue(historyFindOneQuery), + }, + match: { + findById: jest.fn().mockReturnValue({ + session: jest.fn().mockResolvedValue(match), + }), + }, + }); + connectionService.createSession.mockResolvedValue(session); + auctionRedisStateReaderService.readAuctionStateView + .mockResolvedValueOnce(currentRedisState) + .mockResolvedValueOnce(restoredRedisState); + + await expect( + service.undoTo({ + auctionActionRequestId: '00000000-0000-4000-8000-000000000070', + clientObservedAuctionLifecycleId: 'life-1', + clientObservedCurrentAuctionPlayerOrderIndex: 0, + clientObservedCurrentBidRoundPlayerUserId: 'player-2', + clientObservedPhase: 'complete', + clientObservedRevision: 5, + matchId, + communityId, + sequence: 3, + }), + ).resolves.toBe(restoredRedisState); + + expect(auctionReplaceOne).not.toHaveBeenCalled(); + expect(auctionRedisCommandService.reserveActionRequest).toHaveBeenCalledWith( + matchId.toString(), + expect.objectContaining({ + auctionActionRequestId: '00000000-0000-4000-8000-000000000070', + auctionStateTransitionId: + 'undo:life-1:00000000-0000-4000-8000-000000000070', + clientObservedAuctionLifecycleId: 'life-1', + clientObservedCurrentAuctionPlayerOrderIndex: 0, + clientObservedCurrentBidRoundPlayerUserId: 'player-2', + clientObservedPhase: 'complete', + clientObservedRevision: 5, + }), + ); + expect(auctionRedisCommandService.applyTransition).toHaveBeenCalledTimes(1); + const transitionInput = + auctionRedisCommandService.applyTransition.mock.calls[0][1]; + expect(transitionInput.expectedPhase).toBe('complete'); + expect(transitionInput.deadline).toEqual({ + durationSeconds: 30, + mode: 'set-relative', + }); + const durabilityPayload = JSON.parse( + transitionInput.durabilityPayloadJson, + ); + expect(durabilityPayload).toMatchObject({ + auctionActionType: 'undo', + historyMutation: { + targetHistorySequence: 3, + type: 'deleteAfterSequenceAndAppendUndo', + }, + matchSideEffectMutation: { + type: 'undoCompletedAuctionSideEffects', + }, + }); + expect(session.commitTransaction).toHaveBeenCalledTimes(1); + }); }); diff --git a/apps/api/src/modules/auction/auction.service.ts b/apps/api/src/modules/auction/auction.service.ts index ded8b1d1..aca77cde 100644 --- a/apps/api/src/modules/auction/auction.service.ts +++ b/apps/api/src/modules/auction/auction.service.ts @@ -24,6 +24,17 @@ import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.se 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 } 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'; const AUCTION_MAX_TEAM_SIZE = 5; const AUCTION_MIN_BID_POINTS = 10; @@ -32,34 +43,82 @@ 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; interface StartAuctionParams { matchId: mongoose.Types.ObjectId; communityId: mongoose.Types.ObjectId; + startAuctionRequestId: string; + actorUserId?: mongoose.Types.ObjectId; captains: { teamIndex: number; userId: mongoose.Types.ObjectId; - initialPoints?: number; + initialTeamBidPointAmount?: number; }[]; - initialPoints: number; - maxTimerSeconds: number; - bidExtensionSeconds: number; - topTierThreshold: AuctionTopTierThreshold; - manualTopTierUserIds: mongoose.Types.ObjectId[]; + 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 MarkSoldParams { +interface AuctionStructureActionRequestParams { + auctionActionRequestId?: string; + clientObservedAuctionLifecycleId?: string; + clientObservedCurrentAuctionPlayerOrderIndex?: number; + clientObservedCurrentBidRoundPlayerUserId?: string; + clientObservedPhase?: string; + clientObservedRevision?: number; +} + +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; @@ -74,11 +133,21 @@ export interface AuctionHistoryView { takenAt: Date; } +export type AuctionStateResponse = AuctionDocument | Record; + 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); @@ -88,12 +157,17 @@ export class AuctionService { 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); @@ -104,7 +178,23 @@ export class AuctionService { const existing = await AuctionModel.findOne({ matchId: params.matchId }); if (existing) { - throw new BadRequestException('Auction already exists for this match.'); + 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); @@ -184,34 +274,110 @@ export class AuctionService { const shuffledOrder = this.shuffleAuctionPlayerOrder(order); const prioritizedOrder = this.applyTopTierPriority( shuffledOrder, - params.topTierThreshold, - params.manualTopTierUserIds, + params.topTierAuctionPriorityThreshold, + params.manualTopTierAuctionPriorityUserIds, ); - const auction = await AuctionModel.create({ - matchId: params.matchId, - phase: 'presenting', - teams: params.captains.map((c) => ({ - teamIndex: c.teamIndex, - captainUserId: c.userId, - points: c.initialPoints ?? params.initialPoints, - members: [], - })), - order: prioritizedOrder, - passedQueue: [], - auctionRound: 1, - currentIndex: 0, - bids: [], - currentBid: 0, - maxTimerSeconds: params.maxTimerSeconds, - bidExtensionSeconds: params.bidExtensionSeconds, - initialPoints: params.initialPoints, - topTierThreshold: params.topTierThreshold, - manualTopTierUserIds: - params.topTierThreshold === 'MANUAL' ? params.manualTopTierUserIds : [], - startedAt: new Date(), - }); + 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'; match.teamBuiltAt = match.teamBuiltAt ?? new Date(); @@ -235,6 +401,78 @@ export class AuctionService { 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; @@ -291,8 +529,13 @@ export class AuctionService { public async openBidding( matchId: mongoose.Types.ObjectId, - ): Promise { + 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.'); } @@ -305,8 +548,13 @@ export class AuctionService { return auction; } - public async placeBid(params: PlaceBidParams): Promise { + 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.'); } @@ -342,8 +590,398 @@ export class AuctionService { return auction; } - public async markSold(params: MarkSoldParams): Promise { + 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, + state, + structureInput, + }); + } + + private async placeRedisBid( + auction: AuctionDocument, + params: PlaceBidParams, + ): 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 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 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, + }); + if ('rejected' in result) { + throw new BadRequestException(this.formatRedisBidRejectCode(result.code)); + } + + return this.requireRedisAuctionState(matchId); + } + + 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); + } + + 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', + }, + 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', + }, + 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, + }, + 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.'); } @@ -376,8 +1014,13 @@ export class AuctionService { public async markPassed( matchId: mongoose.Types.ObjectId, - ): Promise { + 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.'); } @@ -399,8 +1042,13 @@ export class AuctionService { public async next( matchId: mongoose.Types.ObjectId, - ): Promise { + 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' && @@ -444,7 +1092,36 @@ export class AuctionService { 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 { @@ -457,6 +1134,12 @@ export class AuctionService { if (!session) { throw new InternalServerErrorException('Failed to start DB session.'); } + let redisResetContext: + | { + actionRequestParams?: AuctionStructureActionRequestParams; + auction: AuctionDocument; + } + | null = null; try { session.startTransaction(); const auction = await AuctionModel.findOne({ @@ -470,23 +1153,30 @@ export class AuctionService { throw new BadRequestException('Community mismatch.'); } - 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 }); + if (this.isRedisV1Auction(auction)) { + redisResetContext = { + auction, + actionRequestParams: params, + }; + } 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) { @@ -495,13 +1185,23 @@ export class AuctionService { } finally { await session.endSession(); } + + if (redisResetContext) { + await this.resetRedisAuction(redisResetContext); + } } 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 { + }): Promise { const AuctionModel = await this.connectionService.getModel('auction'); const AuctionHistoryModel = await this.connectionService.getModel('auctionHistory'); @@ -512,6 +1212,17 @@ export class AuctionService { 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({ @@ -541,6 +1252,16 @@ export class AuctionService { 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); @@ -560,15 +1281,654 @@ export class AuctionService { .exec(); await session.commitTransaction(); - const restored = await AuctionModel.findById(auction._id); + restored = await AuctionModel.findById(auction._id); if (!restored) throw new NotFoundException('Auction not found.'); - return restored; + } } 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; + matchSideEffectMutation?: Record; + 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: true, + shouldResetBidRuntime: params.shouldResetBidRuntime, + actionRequest: params.actionRequest?.actionRequest, + }, + ); + if ('rejected' in result) { + throw new BadRequestException( + `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, + ); + + 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.arrayFromState(state.auctionPlayerOrder), + auctionTeams: this.arrayFromState(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.arrayFromState( + state.manualTopTierAuctionPriorityUserIds, + ), + maximumBidRoundDurationSeconds: this.numberFromState( + state.maximumBidRoundDurationSeconds, + 30, + ), + passedAuctionPlayerQueue: this.arrayFromState( + state.passedAuctionPlayerQueue, + ), + topTierAuctionPriorityThreshold: + this.isAuctionTopTierThreshold(state.topTierAuctionPriorityThreshold) + ? state.topTierAuctionPriorityThreshold + : 'NONE', + }; + } + + private buildRedisStructureInputFromAuctionSnapshot( + snapshot: Record, + ): Parameters[0] { + const legacyTeams = this.arrayFromState(snapshot.teams); + return { + auctionPlayerOrder: this.arrayFromState( + snapshot.auctionPlayerOrder ?? snapshot.order, + ), + auctionTeams: this.arrayFromState(snapshot.auctionTeams).length > 0 + ? this.arrayFromState(snapshot.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.arrayFromState( + snapshot.manualTopTierAuctionPriorityUserIds ?? + snapshot.manualTopTierUserIds, + ), + maximumBidRoundDurationSeconds: this.numberFromState( + snapshot.maximumBidRoundDurationSeconds ?? snapshot.maxTimerSeconds, + 30, + ), + passedAuctionPlayerQueue: this.arrayFromState( + 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[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 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 applyTopTierPriority( @@ -711,6 +2071,10 @@ export class AuctionService { return '다음 선수'; case 'complete': return '경매 완료'; + case 'reset': + return '경매 초기화'; + case 'undo': + return '되돌리기'; default: return action; } @@ -815,6 +2179,12 @@ export class AuctionService { } } + 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, @@ -833,6 +2203,34 @@ export class AuctionService { 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 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 { @@ -878,6 +2276,146 @@ export class AuctionService { 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, + ); + + match.teams = 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, + }; + }); + 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); + await this.auctionRedisService.raw().sendCommand([ + 'EVAL', + [ + "local expectedAuctionLifecycleId = ARGV[2]", + "if expectedAuctionLifecycleId ~= '' then", + " local currentAuctionLifecycleId = redis.call('HGET', KEYS[1], 'auctionLifecycleId')", + " if 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 ?? '', + ]); + } + private enqueueBackgroundOrderEnrichment(params: { auctionId: mongoose.Types.ObjectId; targets: AuctionEnrichmentTarget[]; diff --git a/apps/api/src/modules/auction/dto/auction.dto.ts b/apps/api/src/modules/auction/dto/auction.dto.ts index 9c4e4b8e..d7a58e7f 100644 --- a/apps/api/src/modules/auction/dto/auction.dto.ts +++ b/apps/api/src/modules/auction/dto/auction.dto.ts @@ -7,6 +7,8 @@ import { IsInt, IsMongoId, IsOptional, + IsString, + IsUUID, Max, Min, ValidateNested, @@ -28,10 +30,13 @@ class CaptainAssignmentDto { @IsInt() @Min(100) @Max(100000) - initialPoints?: number; + initialTeamBidPointAmount?: number; } export class StartAuctionDto { + @IsUUID() + startAuctionRequestId!: string; + @IsArray() @ArrayMinSize(2) @ArrayMaxSize(16) @@ -43,50 +48,92 @@ export class StartAuctionDto { @IsInt() @Min(100) @Max(100000) - initialPoints?: number; + initialTeamBidPointAmount?: number; @IsOptional() @IsEnum(AUCTION_TOP_TIER_THRESHOLDS) - topTierThreshold?: AuctionTopTierThreshold; + topTierAuctionPriorityThreshold?: AuctionTopTierThreshold; @IsOptional() @IsArray() @ArrayMaxSize(100) @IsMongoId({ each: true }) - manualTopTierUserIds?: string[]; + manualTopTierAuctionPriorityUserIds?: string[]; @IsOptional() @IsInt() @Min(5) - maxTimerSeconds?: number; + maximumBidRoundDurationSeconds?: number; @IsOptional() @IsInt() @Min(0) - bidExtensionSeconds?: number; + bidRoundExtensionSeconds?: number; } export class PlaceBidDto { - @IsInt() - @Min(1) - teamIndex!: number; + @IsOptional() + @IsUUID() + bidRequestId?: string; @IsInt() @Min(1) - amount!: number; + bidderTeamIndex!: number; + + @IsInt() + @Min(1) + bidPointAmount!: number; @IsOptional() - @IsMongoId() - bidderUserId?: string; + clientObservedAuctionLifecycleId?: string; + + @IsOptional() + clientObservedCurrentBidRoundPlayerUserId?: string; } -export class SoldDto { +export class AuctionActionRequestDto { + @IsOptional() + @IsUUID() + auctionActionRequestId?: string; + + @IsOptional() + @IsString() + clientObservedAuctionLifecycleId?: string; + + @IsOptional() + @IsInt() + @Min(0) + clientObservedRevision?: number; + + @IsOptional() + @IsString() + clientObservedPhase?: string; + + @IsOptional() + @IsString() + clientObservedCurrentBidRoundPlayerUserId?: string; + + @IsOptional() + @IsInt() + @Min(0) + clientObservedCurrentAuctionPlayerOrderIndex?: number; +} + +export class SoldDto extends AuctionActionRequestDto { @IsOptional() @IsEnum(['TOP', 'JGL', 'MID', 'ADC', 'SUP']) assignedPosition?: 'TOP' | 'JGL' | 'MID' | 'ADC' | 'SUP'; } -export class UndoAuctionDto { +export class OpenBiddingDto extends AuctionActionRequestDto {} + +export class NextAuctionDto extends AuctionActionRequestDto {} + +export class PassedAuctionDto extends AuctionActionRequestDto {} + +export class ResetAuctionDto extends AuctionActionRequestDto {} + +export class UndoAuctionDto extends AuctionActionRequestDto { @IsInt() @Min(1) sequence!: number; diff --git a/apps/api/src/modules/auction/redis/auction-redis-command.service.spec.ts b/apps/api/src/modules/auction/redis/auction-redis-command.service.spec.ts new file mode 100644 index 00000000..9362c45c --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis-command.service.spec.ts @@ -0,0 +1,377 @@ +import { AuctionRedisService } from './auction-redis.service'; +import { AuctionRedisCommandService } from './auction-redis-command.service'; +import { AUCTION_APPLY_TRANSITION_SCRIPT } from './auction-redis.apply-transition'; +import { AUCTION_BID_SCRIPT } from './auction-redis.bid'; +import { AUCTION_EXPIRE_PREPARE_SCRIPT } from './auction-redis.expire-prepare'; +import { AUCTION_RESERVE_ACTION_REQUEST_SCRIPT } from './auction-redis.reserve-action'; +import { AUCTION_HYDRATE_STATE_SCRIPT } from './auction-redis.state'; + +function makeService(reply: unknown) { + const auctionRedisService = { + evalScript: jest.fn().mockResolvedValue(reply), + } as unknown as jest.Mocked; + return { + auctionRedisService, + service: new AuctionRedisCommandService(auctionRedisService), + }; +} + +describe('AuctionRedisCommandService', () => { + it('executes BID script and parses successful reply', async () => { + const { service, auctionRedisService } = makeService([ + 'OK', + 'bid-1', + '9', + '1000', + '120', + '2', + '31000', + '{"bidPointAmount":120}', + ]); + + await expect( + service.placeBid('match-1', { + bidderTeamIndex: 2, + bidPointAmount: 120, + bidRequestId: 'bid-1', + bidderUserId: 'captain-2', + clientObservedAuctionLifecycleId: 'life-1', + clientObservedCurrentBidRoundPlayerUserId: 'player-1', + maximumAuctionTeamMemberCount: 5, + maximumStoredAuctionBidHistoryCount: 200, + maximumStoredBidRequestResultCount: 100, + matchId: 'match-1', + minimumBidPointReservePerRemainingAuctionTeamMemberSlot: 10, + minimumBidRequestResultReplayWindowMS: 60_000, + }), + ).resolves.toEqual({ + auctionBidHistoryEntry: { bidPointAmount: 120 }, + bidRequestId: 'bid-1', + currentHighestBidderTeamIndex: 2, + currentHighestBidPointAmount: 120, + currentBidRoundDeadlineTimestampMS: 31_000, + currentServerTimestampMS: 1_000, + ok: true, + revision: 9, + }); + expect(auctionRedisService.evalScript).toHaveBeenCalledWith( + AUCTION_BID_SCRIPT, + expect.arrayContaining(['auction:match-1:liveAuctionState']), + expect.arrayContaining(['match-1', '2', '120']), + ); + }); + + it('parses BID rejected reply', async () => { + const { service } = makeService([ + 'REJECTED', + 'TOO_LOW', + 'bid-1', + '1000', + ]); + + await expect( + service.placeBid('match-1', { + bidderTeamIndex: 2, + bidPointAmount: 120, + bidRequestId: 'bid-1', + bidderUserId: 'captain-2', + clientObservedAuctionLifecycleId: 'life-1', + clientObservedCurrentBidRoundPlayerUserId: 'player-1', + maximumAuctionTeamMemberCount: 5, + maximumStoredAuctionBidHistoryCount: 200, + maximumStoredBidRequestResultCount: 100, + matchId: 'match-1', + minimumBidPointReservePerRemainingAuctionTeamMemberSlot: 10, + minimumBidRequestResultReplayWindowMS: 60_000, + }), + ).resolves.toEqual({ + bidRequestId: 'bid-1', + code: 'TOO_LOW', + currentServerTimestampMS: 1000, + rejected: true, + }); + }); + + it('executes reserve action request and parses lease metadata', async () => { + const { service, auctionRedisService } = makeService([ + 'RESERVED', + 'life-1:request-1', + 'transition-1', + '', + '2', + '1', + '1000', + ]); + + await expect( + service.reserveActionRequest('match-1', { + auctionActionRequestId: 'request-1', + auctionActionType: 'sold', + auctionStateTransitionId: 'transition-1', + clientObservedAuctionLifecycleId: 'life-1', + clientObservedPhase: 'bidding', + clientObservedRevision: 8, + leaseDurationMS: 10_000, + maximumStoredAuctionActionRequestResultCount: 100, + minimumAuctionActionRequestResultReplayWindowMS: 60_000, + processingOwnerToken: 'owner-1', + }), + ).resolves.toEqual({ + actionRequestScopeKey: 'life-1:request-1', + auctionStateTransitionId: 'transition-1', + currentServerTimestampMS: 1000, + newAuctionLifecycleId: '', + observedProcessingLeaseVersion: 2, + reserved: true, + wasLeaseExpired: true, + }); + expect(auctionRedisService.evalScript).toHaveBeenCalledWith( + AUCTION_RESERVE_ACTION_REQUEST_SCRIPT, + expect.arrayContaining(['auction:match-1:auctionActionRequestResults']), + expect.arrayContaining(['life-1', 'request-1', 'sold']), + ); + }); + + it('parses reserve action request replay refetch metadata', async () => { + const { service } = makeService([ + 'REPLAY', + 'applied', + 'life-1:request-1', + '11', + '', + 'transition-1', + '', + '2', + '3000', + '', + '1', + ]); + + await expect( + service.reserveActionRequest('match-1', { + auctionActionRequestId: 'request-1', + auctionActionType: 'sold', + auctionStateTransitionId: 'transition-1', + clientObservedAuctionLifecycleId: 'life-1', + clientObservedPhase: 'bidding', + clientObservedRevision: 8, + leaseDurationMS: 10_000, + maximumStoredAuctionActionRequestResultCount: 100, + minimumAuctionActionRequestResultReplayWindowMS: 60_000, + processingOwnerToken: 'owner-1', + }), + ).resolves.toEqual({ + actionRequestScopeKey: 'life-1:request-1', + currentServerTimestampMS: 3000, + isReplay: true, + requiresRefetch: true, + replayStatus: 'applied', + revision: 11, + }); + }); + + it('executes apply transition and parses successful reply', async () => { + const { service, auctionRedisService } = makeService([ + 'OK', + 'transition-1', + '11', + '2000', + ]); + + await expect( + service.applyTransition('match-1', { + afterAuctionStructureStateJson: '{"auctionTeams":[]}', + auctionHistorySequence: 5, + auctionLifecycleId: 'life-1', + auctionStateTransitionId: 'transition-1', + broadcastStateRevision: 11, + deadline: { mode: 'remove' }, + durabilityPayloadJson: '{"auctionStateTransitionId":"transition-1"}', + expectedPhase: 'bidding', + expectedRevision: 10, + liveStatePatch: { phase: 'sold' }, + matchId: 'match-1', + shouldBroadcastState: true, + }), + ).resolves.toEqual({ + auctionStateTransitionId: 'transition-1', + currentServerTimestampMS: 2000, + ok: true, + revision: 11, + }); + expect(auctionRedisService.evalScript).toHaveBeenCalledWith( + AUCTION_APPLY_TRANSITION_SCRIPT, + expect.arrayContaining(['auction:match-1:liveAuctionState']), + expect.arrayContaining(['match-1', 'life-1', 'transition-1']), + ); + }); + + it('parses apply transition replay and rejected replies', async () => { + await expect( + makeService(['REPLAY', 'APPLIED', 'transition-1', '2100']) + .service.applyTransition('match-1', { + afterAuctionStructureStateJson: '{}', + auctionHistorySequence: 5, + auctionLifecycleId: 'life-1', + auctionStateTransitionId: 'transition-1', + broadcastStateRevision: 11, + deadline: { mode: 'none' }, + durabilityPayloadJson: '{}', + expectedPhase: 'sold', + expectedRevision: 10, + liveStatePatch: {}, + matchId: 'match-1', + shouldBroadcastState: false, + }), + ).resolves.toEqual({ + auctionStateTransitionId: 'transition-1', + currentServerTimestampMS: 2100, + isReplay: true, + replayStatus: 'APPLIED', + }); + + await expect( + makeService(['REJECTED', 'CONFLICT', 'transition-1', '2200']) + .service.applyTransition('match-1', { + afterAuctionStructureStateJson: '{}', + auctionHistorySequence: 5, + auctionLifecycleId: 'life-1', + auctionStateTransitionId: 'transition-1', + broadcastStateRevision: 11, + deadline: { mode: 'none' }, + durabilityPayloadJson: '{}', + expectedPhase: 'sold', + expectedRevision: 10, + liveStatePatch: {}, + matchId: 'match-1', + shouldBroadcastState: false, + }), + ).resolves.toEqual({ + auctionStateTransitionId: 'transition-1', + code: 'CONFLICT', + currentServerTimestampMS: 2200, + rejected: true, + }); + }); + + it('executes expire prepare and parses expiry decisions', async () => { + const { service, auctionRedisService } = makeService([ + 'OK', + 'sold', + 'expire-1', + '12', + '3000', + ]); + + await expect( + service.expirePrepare('match-1', { + auctionStateTransitionId: 'expire-1', + bidRoundExpiryRetryDelayMS: 3000, + matchId: 'match-1', + }), + ).resolves.toEqual({ + auctionStateTransitionId: 'expire-1', + bidRoundExpiryDecision: 'sold', + currentServerTimestampMS: 3000, + isReplay: undefined, + ok: true, + revision: 12, + }); + expect(auctionRedisService.evalScript).toHaveBeenCalledWith( + AUCTION_EXPIRE_PREPARE_SCRIPT, + expect.arrayContaining(['auction:match-1:liveAuctionState']), + expect.arrayContaining(['match-1', 'expire-1']), + ); + }); + + it('parses expire prepare replay and noop replies', async () => { + await expect( + makeService(['REPLAY', 'passed', 'expire-1', '12', '3100']) + .service.expirePrepare('match-1', { + auctionStateTransitionId: 'expire-1', + bidRoundExpiryRetryDelayMS: 3000, + matchId: 'match-1', + }), + ).resolves.toMatchObject({ + auctionStateTransitionId: 'expire-1', + bidRoundExpiryDecision: 'passed', + currentServerTimestampMS: 3100, + isReplay: true, + ok: true, + revision: 12, + }); + + await expect( + makeService(['NOOP', 'NOT_DUE', '3200']).service.expirePrepare( + 'match-1', + { + auctionStateTransitionId: 'expire-1', + bidRoundExpiryRetryDelayMS: 3000, + matchId: 'match-1', + }, + ), + ).resolves.toEqual({ + code: 'NOT_DUE', + currentServerTimestampMS: 3200, + noop: true, + }); + }); + + it('executes hydrate state and parses hydrate/noop replies', async () => { + const { service, auctionRedisService } = makeService(['OK', '7', '4000']); + + await expect( + service.hydrateState('match-1', { + auctionHistorySequence: 3, + auctionLifecycleId: 'life-1', + maximumBidRoundDurationSeconds: 30, + matchId: 'match-1', + phase: 'presenting', + revision: 6, + structureStateJson: '{"auctionTeams":[]}', + }), + ).resolves.toEqual({ + currentServerTimestampMS: 4000, + hydrated: true, + revision: 7, + }); + expect(auctionRedisService.evalScript).toHaveBeenCalledWith( + AUCTION_HYDRATE_STATE_SCRIPT, + expect.arrayContaining(['auction:match-1:liveAuctionState']), + expect.arrayContaining(['match-1', 'life-1', '6']), + ); + + await expect( + makeService(['NOOP', '8', '4100']).service.hydrateState('match-1', { + auctionHistorySequence: 3, + auctionLifecycleId: 'life-1', + maximumBidRoundDurationSeconds: 30, + matchId: 'match-1', + phase: 'presenting', + revision: 6, + structureStateJson: '{}', + }), + ).resolves.toEqual({ + currentServerTimestampMS: 4100, + noop: true, + revision: 8, + }); + + await expect( + makeService(['REJECTED', 'INVALID_PATCH_ARITY', '4200']) + .service.hydrateState('match-1', { + auctionHistorySequence: 3, + auctionLifecycleId: 'life-1', + maximumBidRoundDurationSeconds: 30, + matchId: 'match-1', + phase: 'presenting', + revision: 6, + structureStateJson: '{}', + }), + ).resolves.toEqual({ + code: 'INVALID_PATCH_ARITY', + currentServerTimestampMS: 4200, + rejected: true, + }); + }); +}); diff --git a/apps/api/src/modules/auction/redis/auction-redis-command.service.ts b/apps/api/src/modules/auction/redis/auction-redis-command.service.ts new file mode 100644 index 00000000..fa979c80 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis-command.service.ts @@ -0,0 +1,375 @@ +import { Injectable } from '@nestjs/common'; +import { + type AuctionApplyTransitionScriptInput, + buildAuctionApplyTransitionScriptInvocation, +} from './auction-redis.apply-transition'; +import { + type AuctionBidScriptInput, + buildAuctionBidScriptInvocation, +} from './auction-redis.bid'; +import { + type AuctionExpirePrepareScriptInput, + buildAuctionExpirePrepareScriptInvocation, +} from './auction-redis.expire-prepare'; +import { buildAuctionRedisKeys } from './auction-redis.keys'; +import { AuctionRedisService } from './auction-redis.service'; +import { + type AuctionReserveActionRequestScriptInput, + buildAuctionReserveActionRequestScriptInvocation, +} from './auction-redis.reserve-action'; +import { + type HydrateAuctionStateScriptInput, + buildHydrateAuctionStateScriptInvocation, +} from './auction-redis.state'; + +export type AuctionBidCommandResult = + | { + auctionBidHistoryEntry: Record; + bidRequestId: string; + currentBidRoundDeadlineTimestampMS: number; + currentHighestBidderTeamIndex: number; + currentHighestBidPointAmount: number; + currentServerTimestampMS: number; + isReplay?: boolean; + ok: true; + revision: number; + } + | { + bidRequestId: string; + code: string; + currentServerTimestampMS: number; + isReplay?: boolean; + rejected: true; + }; + +export type AuctionReserveActionRequestCommandResult = + | { + actionRequestScopeKey: string; + auctionStateTransitionId: string; + currentServerTimestampMS: number; + newAuctionLifecycleId: string; + observedProcessingLeaseVersion: number; + reserved: true; + wasLeaseExpired: boolean; + } + | { + actionRequestScopeKey: string; + code: string; + currentServerTimestampMS: number; + rejected: true; + } + | { + actionRequestScopeKey: string; + currentServerTimestampMS: number; + isReplay: true; + requiresRefetch?: boolean; + replayStatus: string; + responseJson?: string; + revision?: number; + }; + +export type AuctionApplyTransitionCommandResult = + | { + auctionStateTransitionId: string; + currentServerTimestampMS: number; + ok: true; + revision: number; + } + | { + auctionStateTransitionId: string; + currentServerTimestampMS: number; + isReplay: true; + replayStatus: string; + } + | { + auctionStateTransitionId: string; + code: string; + currentServerTimestampMS: number; + rejected: true; + }; + +export type AuctionExpirePrepareCommandResult = + | { + auctionStateTransitionId: string; + bidRoundExpiryDecision: 'passed' | 'sold'; + currentServerTimestampMS: number; + isReplay?: boolean; + ok: true; + revision: number; + } + | { + code: string; + currentServerTimestampMS: number; + noop: true; + }; + +export type AuctionHydrateStateCommandResult = + | { + currentServerTimestampMS: number; + hydrated: true; + revision: number; + } + | { + currentServerTimestampMS: number; + noop: true; + revision: number; + } + | { + code: string; + currentServerTimestampMS: number; + rejected: true; + }; + +@Injectable() +export class AuctionRedisCommandService { + constructor(private readonly auctionRedisService: AuctionRedisService) {} + + public async placeBid( + matchId: string, + input: AuctionBidScriptInput, + ): Promise { + const invocation = buildAuctionBidScriptInvocation( + buildAuctionRedisKeys(matchId), + input, + ); + const reply = await this.auctionRedisService.evalScript( + invocation.script, + invocation.keys, + invocation.values, + ); + return parseBidCommandReply(reply); + } + + public async reserveActionRequest( + matchId: string, + input: AuctionReserveActionRequestScriptInput, + ): Promise { + const invocation = buildAuctionReserveActionRequestScriptInvocation( + buildAuctionRedisKeys(matchId), + input, + ); + const reply = await this.auctionRedisService.evalScript( + invocation.script, + invocation.keys, + invocation.values, + ); + return parseReserveActionRequestReply(reply); + } + + public async applyTransition( + matchId: string, + input: AuctionApplyTransitionScriptInput, + ): Promise { + const invocation = buildAuctionApplyTransitionScriptInvocation( + buildAuctionRedisKeys(matchId), + input, + ); + const reply = await this.auctionRedisService.evalScript( + invocation.script, + invocation.keys, + invocation.values, + ); + return parseApplyTransitionReply(reply); + } + + public async expirePrepare( + matchId: string, + input: AuctionExpirePrepareScriptInput, + ): Promise { + const invocation = buildAuctionExpirePrepareScriptInvocation( + buildAuctionRedisKeys(matchId), + input, + ); + const reply = await this.auctionRedisService.evalScript( + invocation.script, + invocation.keys, + invocation.values, + ); + return parseExpirePrepareReply(reply); + } + + public async hydrateState( + matchId: string, + input: HydrateAuctionStateScriptInput, + ): Promise { + const invocation = buildHydrateAuctionStateScriptInvocation( + buildAuctionRedisKeys(matchId), + input, + ); + const reply = await this.auctionRedisService.evalScript( + invocation.script, + invocation.keys, + invocation.values, + ); + return parseHydrateStateReply(reply); + } +} + +function parseBidCommandReply(reply: unknown[]): AuctionBidCommandResult { + const values = reply.map(String); + const kind = values[0]; + if (kind === 'OK') { + return { + auctionBidHistoryEntry: JSON.parse(values[7] || '{}') as Record< + string, + unknown + >, + bidRequestId: values[1], + currentBidRoundDeadlineTimestampMS: numberValue(values[6]), + currentHighestBidderTeamIndex: numberValue(values[5]), + currentHighestBidPointAmount: numberValue(values[4]), + currentServerTimestampMS: numberValue(values[3]), + ok: true, + revision: numberValue(values[2]), + }; + } + if (kind === 'REPLAY') { + const status = values[1]; + if (status === 'ok') { + return { + auctionBidHistoryEntry: JSON.parse(values[8] || '{}') as Record< + string, + unknown + >, + bidRequestId: values[2], + currentBidRoundDeadlineTimestampMS: numberValue(values[7]), + currentHighestBidderTeamIndex: numberValue(values[6]), + currentHighestBidPointAmount: numberValue(values[5]), + currentServerTimestampMS: numberValue(values[9]), + isReplay: true, + ok: true, + revision: numberValue(values[3]), + }; + } + return { + bidRequestId: values[2], + code: values[4] || status, + currentServerTimestampMS: numberValue(values[9]), + isReplay: true, + rejected: true, + }; + } + return { + bidRequestId: values[2] ?? '', + code: values[1] ?? 'UNKNOWN', + currentServerTimestampMS: numberValue(values[3]), + rejected: true, + }; +} + +function parseReserveActionRequestReply( + reply: unknown[], +): AuctionReserveActionRequestCommandResult { + const values = reply.map(String); + const kind = values[0]; + if (kind === 'RESERVED') { + return { + actionRequestScopeKey: values[1], + auctionStateTransitionId: values[2], + currentServerTimestampMS: numberValue(values[6]), + newAuctionLifecycleId: values[3], + observedProcessingLeaseVersion: numberValue(values[4]), + reserved: true, + wasLeaseExpired: values[5] === '1', + }; + } + if (kind === 'REPLAY') { + return { + actionRequestScopeKey: values[2], + currentServerTimestampMS: numberValue(values[8]), + isReplay: true, + requiresRefetch: values[10] === '1' || undefined, + replayStatus: values[1], + responseJson: values[9] || undefined, + revision: values[3] ? numberValue(values[3]) : undefined, + }; + } + return { + actionRequestScopeKey: values[2] ?? '', + code: values[1] ?? 'UNKNOWN', + currentServerTimestampMS: numberValue(values[3]), + rejected: true, + }; +} + +function parseApplyTransitionReply( + reply: unknown[], +): AuctionApplyTransitionCommandResult { + const values = reply.map(String); + const kind = values[0]; + if (kind === 'OK') { + return { + auctionStateTransitionId: values[1], + currentServerTimestampMS: numberValue(values[3]), + ok: true, + revision: numberValue(values[2]), + }; + } + if (kind === 'REPLAY') { + return { + auctionStateTransitionId: values[2], + currentServerTimestampMS: numberValue(values[3]), + isReplay: true, + replayStatus: values[1], + }; + } + return { + auctionStateTransitionId: values[2] ?? '', + code: values[1] ?? 'UNKNOWN', + currentServerTimestampMS: numberValue(values[3]), + rejected: true, + }; +} + +function parseExpirePrepareReply( + reply: unknown[], +): AuctionExpirePrepareCommandResult { + const values = reply.map(String); + const kind = values[0]; + if (kind === 'OK' || kind === 'REPLAY') { + return { + auctionStateTransitionId: values[2], + bidRoundExpiryDecision: + values[1] === 'sold' || values[1] === 'passed' ? values[1] : 'passed', + currentServerTimestampMS: numberValue(values[4]), + isReplay: kind === 'REPLAY' || undefined, + ok: true, + revision: numberValue(values[3]), + }; + } + return { + code: values[1] ?? 'UNKNOWN', + currentServerTimestampMS: numberValue(values[2]), + noop: true, + }; +} + +function parseHydrateStateReply( + reply: unknown[], +): AuctionHydrateStateCommandResult { + const values = reply.map(String); + if (values[0] === 'OK') { + return { + currentServerTimestampMS: numberValue(values[2]), + hydrated: true, + revision: numberValue(values[1]), + }; + } + if (values[0] === 'REJECTED') { + return { + code: values[1] ?? 'UNKNOWN', + currentServerTimestampMS: numberValue(values[2]), + rejected: true, + }; + } + return { + currentServerTimestampMS: numberValue(values[2]), + noop: true, + revision: numberValue(values[1]), + }; +} + +function numberValue(value: string | undefined): number { + const parsed = Number(value); + return Number.isFinite(parsed) ? parsed : 0; +} diff --git a/apps/api/src/modules/auction/redis/auction-redis-projection.spec.ts b/apps/api/src/modules/auction/redis/auction-redis-projection.spec.ts new file mode 100644 index 00000000..d365d96e --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis-projection.spec.ts @@ -0,0 +1,152 @@ +import mongoose from 'mongoose'; +import { + buildAuctionRedisLiveStatePatchFromStructure, + buildAuctionRedisStructureState, + convertLegacyAuctionTeamsToRedisTeams, +} from './auction-redis-projection'; + +describe('auction redis projection helpers', () => { + it('converts legacy auction team fields to redis-v1 names', () => { + const captainUserId = new mongoose.Types.ObjectId(); + const memberUserId = new mongoose.Types.ObjectId(); + + expect( + convertLegacyAuctionTeamsToRedisTeams([ + { + teamIndex: 1, + captainUserId, + points: 970, + members: [ + { + userId: memberUserId, + assignedPosition: 'ADC', + cost: 30, + }, + ], + }, + ]), + ).toEqual([ + { + teamIndex: 1, + captainUserId, + remainingBidPointAmount: 970, + members: [ + { + userId: memberUserId, + assignedPosition: 'ADC', + memberAcquisitionBidPointAmount: 30, + }, + ], + }, + ]); + }); + + it('builds the redis structure state with only structure/config fields', () => { + const captainUserId = new mongoose.Types.ObjectId(); + const playerUserId = new mongoose.Types.ObjectId(); + + expect( + buildAuctionRedisStructureState({ + auctionPlayerOrder: [ + { + userId: playerUserId, + puuid: 'puuid', + gameName: 'Player', + tagLine: 'KR1', + profileIconId: 1, + preferredPositions: [{ position: 'MID', priority: 1 }], + tiers: [], + tierHistory: [], + masteries: [], + passCount: 0, + }, + ], + auctionTeams: [ + { + teamIndex: 1, + captainUserId, + remainingBidPointAmount: 1000, + members: [], + }, + ], + bidRoundExtensionSeconds: 5, + currentAuctionPlayerOrderIndex: 0, + currentAuctionRound: 1, + initialTeamBidPointAmount: 1000, + manualTopTierAuctionPriorityUserIds: [], + maximumBidRoundDurationSeconds: 30, + passedAuctionPlayerQueue: [], + topTierAuctionPriorityThreshold: 'NONE', + }), + ).toMatchObject({ + auctionPlayerOrder: [expect.objectContaining({ userId: playerUserId })], + auctionTeams: [ + expect.objectContaining({ + captainUserId, + remainingBidPointAmount: 1000, + teamIndex: 1, + }), + ], + bidRoundExtensionSeconds: 5, + currentAuctionPlayerOrderIndex: 0, + currentAuctionRound: 1, + initialTeamBidPointAmount: 1000, + maximumBidRoundDurationSeconds: 30, + passedAuctionPlayerQueue: [], + topTierAuctionPriorityThreshold: 'NONE', + }); + }); + + it('builds live state patch required by BID Lua', () => { + const captainUserId = new mongoose.Types.ObjectId(); + const playerUserId = new mongoose.Types.ObjectId(); + + expect( + buildAuctionRedisLiveStatePatchFromStructure({ + auctionPlayerOrder: [ + { + userId: playerUserId, + puuid: 'puuid', + gameName: 'Player', + tagLine: 'KR1', + profileIconId: 1, + preferredPositions: [{ position: 'MID', priority: 1 }], + tiers: [], + tierHistory: [], + masteries: [], + passCount: 0, + }, + ], + auctionTeams: [ + { + teamIndex: 2, + captainUserId, + remainingBidPointAmount: 970, + members: [ + { + userId: new mongoose.Types.ObjectId(), + assignedPosition: 'ADC', + memberAcquisitionBidPointAmount: 30, + }, + ], + }, + ], + bidRoundExtensionSeconds: 5, + currentAuctionPlayerOrderIndex: 0, + currentAuctionRound: 1, + initialTeamBidPointAmount: 1000, + manualTopTierAuctionPriorityUserIds: [], + maximumBidRoundDurationSeconds: 30, + passedAuctionPlayerQueue: [], + topTierAuctionPriorityThreshold: 'NONE', + }), + ).toEqual({ + bidRoundExtensionSeconds: 5, + currentAuctionPlayerOrderIndex: 0, + currentBidRoundPlayerUserId: playerUserId.toString(), + maximumBidRoundDurationSeconds: 30, + 'team:2:assignedAuctionTeamMemberCount': 2, + 'team:2:remainingBidPointAmount': 970, + }); + }); +}); diff --git a/apps/api/src/modules/auction/redis/auction-redis-projection.ts b/apps/api/src/modules/auction/redis/auction-redis-projection.ts new file mode 100644 index 00000000..500a61b8 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis-projection.ts @@ -0,0 +1,92 @@ +import type { + AuctionPlayerSnapshot, + AuctionTeam, + AuctionTopTierThreshold, + RedisAuctionTeam, +} from '../../global/database/schema'; +import type mongoose from 'mongoose'; + +export interface AuctionRedisStructureStateInput { + auctionPlayerOrder: AuctionPlayerSnapshot[]; + auctionTeams: RedisAuctionTeam[]; + bidRoundExtensionSeconds: number; + currentAuctionPlayerOrderIndex: number; + currentAuctionRound: number; + initialTeamBidPointAmount: number; + manualTopTierAuctionPriorityUserIds: mongoose.Types.ObjectId[]; + maximumBidRoundDurationSeconds: number; + passedAuctionPlayerQueue: AuctionPlayerSnapshot[]; + topTierAuctionPriorityThreshold: AuctionTopTierThreshold; +} + +export function convertLegacyAuctionTeamsToRedisTeams( + teams: AuctionTeam[], +): RedisAuctionTeam[] { + return teams.map((team) => ({ + teamIndex: team.teamIndex, + captainUserId: team.captainUserId, + remainingBidPointAmount: team.points, + members: team.members.map((member) => ({ + userId: member.userId, + assignedPosition: member.assignedPosition, + memberAcquisitionBidPointAmount: member.cost, + })), + })); +} + +export function buildAuctionRedisStructureState( + input: AuctionRedisStructureStateInput, +): Record { + return { + auctionPlayerOrder: input.auctionPlayerOrder, + auctionTeams: input.auctionTeams, + bidRoundExtensionSeconds: input.bidRoundExtensionSeconds, + currentAuctionPlayerOrderIndex: input.currentAuctionPlayerOrderIndex, + currentAuctionRound: input.currentAuctionRound, + initialTeamBidPointAmount: input.initialTeamBidPointAmount, + manualTopTierAuctionPriorityUserIds: + input.manualTopTierAuctionPriorityUserIds, + maximumBidRoundDurationSeconds: input.maximumBidRoundDurationSeconds, + passedAuctionPlayerQueue: input.passedAuctionPlayerQueue, + topTierAuctionPriorityThreshold: input.topTierAuctionPriorityThreshold, + }; +} + +export function buildAuctionRedisLiveStatePatchFromStructure( + input: AuctionRedisStructureStateInput, +): Record { + const patch: Record = { + bidRoundExtensionSeconds: input.bidRoundExtensionSeconds, + currentAuctionPlayerOrderIndex: input.currentAuctionPlayerOrderIndex, + maximumBidRoundDurationSeconds: input.maximumBidRoundDurationSeconds, + }; + + const currentPlayer = + input.auctionPlayerOrder[input.currentAuctionPlayerOrderIndex]; + if (currentPlayer) { + patch.currentBidRoundPlayerUserId = currentPlayer.userId.toString(); + } + + for (const team of input.auctionTeams) { + patch[`team:${team.teamIndex}:remainingBidPointAmount`] = + team.remainingBidPointAmount; + patch[`team:${team.teamIndex}:assignedAuctionTeamMemberCount`] = + countAuctionTeamMembersIncludingCaptain(team); + } + + return patch; +} + +export function stringifyAuctionRedisStructureState( + input: AuctionRedisStructureStateInput, +): string { + return JSON.stringify(buildAuctionRedisStructureState(input)); +} + +function countAuctionTeamMembersIncludingCaptain(team: RedisAuctionTeam): number { + const userIds = new Set([team.captainUserId.toString()]); + for (const member of team.members) { + userIds.add(member.userId.toString()); + } + return userIds.size; +} diff --git a/apps/api/src/modules/auction/redis/auction-redis-state-reader.service.spec.ts b/apps/api/src/modules/auction/redis/auction-redis-state-reader.service.spec.ts new file mode 100644 index 00000000..1d78ed31 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis-state-reader.service.spec.ts @@ -0,0 +1,160 @@ +import { AuctionRedisService } from './auction-redis.service'; +import { AuctionRedisStateReaderService } from './auction-redis-state-reader.service'; + +function makeService(commandReplies: unknown[], currentServerTimestampMS = 1000) { + const sendCommand = jest + .fn() + .mockImplementation(() => Promise.resolve(commandReplies.shift())); + const auctionRedisService = { + getCurrentRedisTimestampMS: jest + .fn() + .mockResolvedValue(currentServerTimestampMS), + raw: jest.fn().mockReturnValue({ sendCommand }), + } as unknown as jest.Mocked; + + return { + auctionRedisService, + sendCommand, + service: new AuctionRedisStateReaderService(auctionRedisService), + }; +} + +describe('AuctionRedisStateReaderService', () => { + it('reads live state identity', async () => { + const { service, sendCommand } = makeService([['life-1', '7']]); + + await expect(service.readLiveStateIdentity('match-1')).resolves.toEqual({ + auctionLifecycleId: 'life-1', + revision: 7, + }); + expect(sendCommand).toHaveBeenCalledWith([ + 'HMGET', + 'auction:match-1:liveAuctionState', + 'auctionLifecycleId', + 'revision', + ]); + }); + + it('returns null when live state identity is missing', async () => { + const { service } = makeService([[null, null]]); + + await expect(service.readLiveStateIdentity('match-1')).resolves.toBeNull(); + }); + + it('assembles a public auction view from Redis state', async () => { + const { service, sendCommand } = makeService([ + [ + 'auctionLifecycleId', + 'life-1', + 'phase', + 'expiring', + 'revision', + '8', + 'currentHighestBidPointAmount', + '100', + 'currentHighestBidderTeamIndex', + '2', + 'team:2:remainingBidPointAmount', + '900', + 'bidRoundExpiryDecision', + 'sold', + ], + '{"auctionTeams":[{"teamIndex":1}]}', + ['{"bidPointAmount":100,"bidderTeamIndex":2}'], + ]); + + const view = await service.readAuctionStateView('match-1', { + shouldForceAuctionStateResync: true, + }); + + expect(view).toMatchObject({ + auctionBidHistory: [{ bidPointAmount: 100, bidderTeamIndex: 2 }], + auctionLifecycleId: 'life-1', + auctionTeams: [{ teamIndex: 1 }], + canPlaceBidInCurrentBidRound: false, + currentHighestBidderTeamIndex: 2, + currentHighestBidPointAmount: 100, + currentServerTimestampMS: 1000, + isAuctionStateTransitionInProgress: true, + phase: 'bidding', + revision: 8, + shouldForceAuctionStateResync: true, + }); + expect(view).not.toHaveProperty('team:2:remainingBidPointAmount'); + expect(view).not.toHaveProperty('bidRoundExpiryDecision'); + expect(sendCommand).toHaveBeenNthCalledWith(1, [ + 'HGETALL', + 'auction:match-1:liveAuctionState', + ]); + expect(sendCommand).toHaveBeenNthCalledWith(2, [ + 'GET', + 'auction:match-1:auctionStructureState', + ]); + expect(sendCommand).toHaveBeenNthCalledWith(3, [ + 'LRANGE', + 'auction:match-1:auctionBidHistory', + '0', + '-1', + ]); + }); + + it('assembles state when HGETALL returns an object', async () => { + const { service } = makeService([ + { + auctionLifecycleId: 'life-1', + phase: 'presenting', + revision: '3', + }, + '{"auctionTeams":[]}', + [], + ]); + + await expect(service.readAuctionStateView('match-1')).resolves.toMatchObject({ + auctionLifecycleId: 'life-1', + auctionTeams: [], + phase: 'presenting', + revision: 3, + }); + }); + + it('can expose internal live fields for server-side expiry completion', async () => { + const { service } = makeService([ + { + auctionLifecycleId: 'life-1', + bidRoundExpiryDecision: 'sold', + phase: 'expiring', + revision: '4', + 'team:1:remainingBidPointAmount': '900', + }, + '{"auctionTeams":[]}', + [], + ]); + + await expect( + service.readAuctionStateView('match-1', { + includeInternalLiveStateFields: true, + }), + ).resolves.toMatchObject({ + bidRoundExpiryDecision: 'sold', + redisInternalPhase: 'expiring', + 'team:1:remainingBidPointAmount': '900', + }); + }); + + + it('returns null when live or structure state is absent', async () => { + await expect( + makeService([[], '{"auctionTeams":[]}', []]).service.readAuctionStateView( + 'match-1', + ), + ).resolves.toBeNull(); + + await expect( + makeService([ + { auctionLifecycleId: 'life-1', phase: 'presenting', revision: '1' }, + null, + [], + ]).service.readAuctionStateView('match-1'), + ).resolves.toBeNull(); + }); +}); diff --git a/apps/api/src/modules/auction/redis/auction-redis-state-reader.service.ts b/apps/api/src/modules/auction/redis/auction-redis-state-reader.service.ts new file mode 100644 index 00000000..3f9019a7 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis-state-reader.service.ts @@ -0,0 +1,155 @@ +import { Injectable } from '@nestjs/common'; +import { buildAuctionRedisKeys } from './auction-redis.keys'; +import { AuctionRedisService } from './auction-redis.service'; +import { assembleAuctionViewFromRedisState } from './auction-redis.state'; + +const NUMERIC_LIVE_STATE_FIELDS = new Set([ + 'bidRoundExpiryPlayerOrderIndex', + 'bidRoundExpiryRevision', + 'bidRoundExpiryWinningBidPointAmount', + 'bidRoundExpiryWinningBidderTeamIndex', + 'currentAuctionHistorySequence', + 'currentAuctionPlayerOrderIndex', + 'currentBidRoundDeadlineTimestampMS', + 'currentHighestBidPointAmount', + 'currentHighestBidderTeamIndex', + 'matchSideEffectRevision', + 'revision', +]); + +export interface AuctionRedisLiveStateIdentity { + auctionLifecycleId?: string; + revision?: number; +} + +export interface AuctionRedisStateViewReadOptions { + includeInternalLiveStateFields?: boolean; + shouldForceAuctionStateResync?: boolean; +} + +@Injectable() +export class AuctionRedisStateReaderService { + constructor(private readonly auctionRedisService: AuctionRedisService) {} + + public async readLiveStateIdentity( + matchId: string, + ): Promise { + const keys = buildAuctionRedisKeys(matchId); + const reply = await this.auctionRedisService.raw().sendCommand([ + 'HMGET', + keys.liveStateKey, + 'auctionLifecycleId', + 'revision', + ]); + if (!Array.isArray(reply)) return null; + const auctionLifecycleId = + typeof reply[0] === 'string' && reply[0] ? reply[0] : undefined; + const revision = + typeof reply[1] === 'string' || typeof reply[1] === 'number' + ? Number(reply[1]) + : Number.NaN; + if (!auctionLifecycleId && !Number.isFinite(revision)) return null; + return { + auctionLifecycleId, + revision: Number.isFinite(revision) ? revision : undefined, + }; + } + + public async readAuctionStateView( + matchId: string, + options: AuctionRedisStateViewReadOptions = {}, + ): Promise | null> { + const keys = buildAuctionRedisKeys(matchId); + const [currentServerTimestampMS, liveReply, structureStateJson, bidEntries] = + await Promise.all([ + this.auctionRedisService.getCurrentRedisTimestampMS(), + this.auctionRedisService.raw().sendCommand(['HGETALL', keys.liveStateKey]), + this.auctionRedisService.raw().sendCommand(['GET', keys.structureStateKey]), + this.auctionRedisService.raw().sendCommand([ + 'LRANGE', + keys.bidHistoryKey, + '0', + '-1', + ]), + ]); + + const liveState = parseHashReply(liveReply, { + includeInternalLiveStateFields: + options.includeInternalLiveStateFields ?? false, + }); + if (!liveState) return null; + if ( + typeof liveState.auctionLifecycleId !== 'string' || + typeof liveState.phase !== 'string' || + typeof liveState.revision !== 'number' + ) { + return null; + } + if (typeof structureStateJson !== 'string' || !structureStateJson) { + return null; + } + + const view = assembleAuctionViewFromRedisState({ + auctionBidHistoryEntries: Array.isArray(bidEntries) + ? bidEntries.map(String) + : [], + currentServerTimestampMS, + liveState: liveState as Record & { + auctionLifecycleId: string; + phase: string; + revision: number; + }, + shouldForceAuctionStateResync: options.shouldForceAuctionStateResync, + structureState: JSON.parse(structureStateJson) as Record, + }); + if (options.includeInternalLiveStateFields) { + view.redisInternalPhase = liveState.phase; + } + return view; + } +} + +function parseHashReply( + reply: unknown, + options: { includeInternalLiveStateFields?: boolean } = {}, +): Record | null { + if (!reply) return null; + if (Array.isArray(reply)) { + if (reply.length === 0) return null; + const entries: [string, unknown][] = []; + for (let index = 0; index < reply.length; index += 2) { + entries.push([String(reply[index]), reply[index + 1]]); + } + return parseHashEntries(entries, options); + } + if (typeof reply === 'object') { + const entries = Object.entries(reply as Record); + if (entries.length === 0) return null; + return parseHashEntries(entries, options); + } + return null; +} + +function parseHashEntries( + entries: [string, unknown][], + options: { includeInternalLiveStateFields?: boolean } = {}, +): Record { + const result: Record = {}; + for (const [field, rawValue] of entries) { + if (!options.includeInternalLiveStateFields && isInternalLiveStateField(field)) { + continue; + } + const value = String(rawValue); + if (NUMERIC_LIVE_STATE_FIELDS.has(field)) { + const parsed = Number(value); + result[field] = Number.isFinite(parsed) ? parsed : 0; + continue; + } + result[field] = value; + } + return result; +} + +function isInternalLiveStateField(field: string): boolean { + return field.startsWith('team:') || field.startsWith('bidRoundExpiry'); +} diff --git a/apps/api/src/modules/auction/redis/auction-redis.apply-transition.spec.ts b/apps/api/src/modules/auction/redis/auction-redis.apply-transition.spec.ts new file mode 100644 index 00000000..90dd2586 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.apply-transition.spec.ts @@ -0,0 +1,113 @@ +import { buildAuctionRedisKeys } from './auction-redis.keys'; +import { + AUCTION_APPLY_TRANSITION_SCRIPT, + buildAuctionApplyTransitionScriptInvocation, +} from './auction-redis.apply-transition'; + +describe('auction apply transition redis script contract', () => { + it('builds APPLY_TRANSITION keys and values in a stable order', () => { + const keys = buildAuctionRedisKeys('match-1'); + const invocation = buildAuctionApplyTransitionScriptInvocation(keys, { + actionRequest: { + observedProcessingLeaseVersion: 3, + processingOwnerToken: 'owner-1', + scopeKey: 'life-1:request-1', + }, + afterAuctionStructureStateJson: '{"auctionTeams":[]}', + auctionHistorySequence: 4, + auctionLifecycleId: 'life-1', + auctionStateTransitionId: 'transition-1', + broadcastStateRevision: 9, + deadline: { durationSeconds: 30, mode: 'set-relative' }, + durabilityPayloadJson: '{"revision":9}', + expectedCurrentAuctionPlayerOrderIndex: 2, + expectedCurrentBidRoundPlayerUserId: 'player-1', + expectedAuctionHistorySequence: 3, + expectedPhase: 'bidding', + expectedRevision: 8, + liveStatePatch: { + currentAuctionHistorySequence: 4, + phase: 'sold', + }, + matchId: 'match-1', + shouldBroadcastState: true, + }); + + expect(invocation.script).toBe(AUCTION_APPLY_TRANSITION_SCRIPT); + expect(invocation.keys).toEqual([ + 'auction:match-1:liveAuctionState', + 'auction:match-1:auctionStructureState', + 'auction:match-1:appliedAuctionStateTransitionIds', + 'auction:match-1:durability:transition-1', + 'auction:auctionDurabilityRetryQueue', + 'auction:match-1:auctionActionRequestResults', + 'auction:match-1:auctionActionRequestResultOrder', + 'auction:match-1:auctionBidHistory', + 'auction:match-1:bidRequestResults', + 'auction:match-1:bidRequestResultOrder', + 'auction:bidRoundDeadlineQueue', + ]); + expect(invocation.values.slice(0, 19)).toEqual([ + 'match-1', + 'life-1', + 'transition-1', + '8', + '3', + 'bidding', + 'player-1', + '2', + '{"auctionTeams":[]}', + '4', + '{"revision":9}', + '1', + '9', + 'set-relative', + '30', + '0', + 'life-1:request-1', + 'owner-1', + '3', + ]); + expect(invocation.values.slice(19)).toEqual([ + '2', + 'currentAuctionHistorySequence', + '4', + 'phase', + 'sold', + ]); + }); + + it('keeps critical atomicity guards in Lua', () => { + expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain("redis.call('TIME')"); + expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain( + 'ACTION_REQUEST_LEASE_VERSION_MISMATCH', + ); + expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain( + 'ACTION_REQUEST_TRANSITION_MISMATCH', + ); + expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain( + 'INVALID_PATCH_ARITY', + ); + expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain( + 'shouldBroadcastState', + ); + expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain( + "redis.call('SADD'", + ); + expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain( + "redis.call('HINCRBY'", + ); + expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain( + 'currentAuctionHistorySequence', + ); + expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain( + 'storeValidatedActionRequestRejection', + ); + expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain( + "actionRequestPrefix .. 'status'", + ); + expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain( + "actionRequestPrefix .. 'requiresRefetch'", + ); + }); +}); diff --git a/apps/api/src/modules/auction/redis/auction-redis.apply-transition.ts b/apps/api/src/modules/auction/redis/auction-redis.apply-transition.ts new file mode 100644 index 00000000..9650592e --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.apply-transition.ts @@ -0,0 +1,325 @@ +import type { AuctionRedisKeys } from './auction-redis.keys'; +import { defineAuctionRedisScript } from './auction-redis.scripts'; + +export type ApplyTransitionDeadlineInput = + | { mode: 'none' } + | { mode: 'remove' } + | { durationSeconds: number; mode: 'set-relative' }; + +export interface ApplyTransitionActionRequestInput { + observedProcessingLeaseVersion: number; + processingOwnerToken: string; + scopeKey: string; +} + +export interface AuctionApplyTransitionScriptInput { + actionRequest?: ApplyTransitionActionRequestInput; + afterAuctionStructureStateJson: string; + auctionHistorySequence: number; + auctionLifecycleId: string; + auctionStateTransitionId: string; + broadcastStateRevision: number; + deadline: ApplyTransitionDeadlineInput; + durabilityPayloadJson: string; + expectedCurrentAuctionPlayerOrderIndex?: number; + expectedCurrentBidRoundPlayerUserId?: string; + expectedAuctionHistorySequence?: number; + expectedPhase: string; + expectedRevision: number; + liveStatePatch: Record; + matchId: string; + shouldBroadcastState: boolean; + shouldResetBidRuntime?: boolean; +} + +export interface AuctionApplyTransitionScriptInvocation { + keys: string[]; + script: typeof AUCTION_APPLY_TRANSITION_SCRIPT; + values: string[]; +} + +function stringifyRedisValue(value: string | number | boolean | null): string { + if (typeof value === 'boolean') return value ? '1' : '0'; + if (value === null) return ''; + return String(value); +} + +function flattenLiveStatePatch( + liveStatePatch: AuctionApplyTransitionScriptInput['liveStatePatch'], +): string[] { + return Object.entries(liveStatePatch) + .filter(([, value]) => value !== undefined) + .sort(([a], [b]) => a.localeCompare(b)) + .flatMap(([key, value]) => [ + key, + stringifyRedisValue(value as string | number | boolean | null), + ]); +} + +export function buildAuctionApplyTransitionScriptInvocation( + keys: AuctionRedisKeys, + input: AuctionApplyTransitionScriptInput, +): AuctionApplyTransitionScriptInvocation { + const liveStatePatchPairs = flattenLiveStatePatch(input.liveStatePatch); + const deadlineDurationSeconds = + input.deadline.mode === 'set-relative' + ? String(input.deadline.durationSeconds) + : '0'; + + return { + keys: [ + keys.liveStateKey, + keys.structureStateKey, + keys.appliedTransitionIdsKey, + keys.durabilityPayloadKey(input.auctionStateTransitionId), + keys.durabilityRetryQueueKey, + keys.actionRequestResultsKey, + keys.actionRequestResultOrderKey, + keys.bidHistoryKey, + keys.bidRequestResultsKey, + keys.bidRequestResultOrderKey, + keys.deadlineQueueKey, + ], + script: AUCTION_APPLY_TRANSITION_SCRIPT, + values: [ + input.matchId, + input.auctionLifecycleId, + input.auctionStateTransitionId, + String(input.expectedRevision), + String( + input.expectedAuctionHistorySequence ?? + input.auctionHistorySequence - 1, + ), + input.expectedPhase, + input.expectedCurrentBidRoundPlayerUserId ?? '', + input.expectedCurrentAuctionPlayerOrderIndex === undefined + ? '' + : String(input.expectedCurrentAuctionPlayerOrderIndex), + input.afterAuctionStructureStateJson, + String(input.auctionHistorySequence), + input.durabilityPayloadJson, + input.shouldBroadcastState ? '1' : '0', + String(input.broadcastStateRevision), + input.deadline.mode, + deadlineDurationSeconds, + input.shouldResetBidRuntime ? '1' : '0', + input.actionRequest?.scopeKey ?? '', + input.actionRequest?.processingOwnerToken ?? '', + input.actionRequest?.observedProcessingLeaseVersion === undefined + ? '' + : String(input.actionRequest.observedProcessingLeaseVersion), + String(liveStatePatchPairs.length / 2), + ...liveStatePatchPairs, + ], + }; +} + +export const AUCTION_APPLY_TRANSITION_SCRIPT = defineAuctionRedisScript( + 'auction.applyTransition', + ` +local liveAuctionStateKey = KEYS[1] +local auctionStructureStateKey = KEYS[2] +local appliedAuctionStateTransitionIdsKey = KEYS[3] +local durabilityPayloadKey = KEYS[4] +local durabilityRetryQueueKey = KEYS[5] +local auctionActionRequestResultsKey = KEYS[6] +local auctionActionRequestResultOrderKey = KEYS[7] +local auctionBidHistoryKey = KEYS[8] +local bidRequestResultsKey = KEYS[9] +local bidRequestResultOrderKey = KEYS[10] +local bidRoundDeadlineQueueKey = KEYS[11] + +local matchId = ARGV[1] +local auctionLifecycleId = ARGV[2] +local auctionStateTransitionId = ARGV[3] +local expectedRevision = tonumber(ARGV[4]) +local expectedAuctionHistorySequence = tonumber(ARGV[5]) +local expectedPhase = ARGV[6] +local expectedCurrentBidRoundPlayerUserId = ARGV[7] +local expectedCurrentAuctionPlayerOrderIndex = ARGV[8] +local afterAuctionStructureStateJson = ARGV[9] +local auctionHistorySequence = tonumber(ARGV[10]) +local durabilityPayloadJson = ARGV[11] +local shouldBroadcastState = ARGV[12] +local broadcastStateRevision = tonumber(ARGV[13]) +local deadlineMode = ARGV[14] +local deadlineDurationSeconds = tonumber(ARGV[15]) +local shouldResetBidRuntime = ARGV[16] +local actionRequestScopeKey = ARGV[17] +local processingOwnerToken = ARGV[18] +local observedProcessingLeaseVersion = ARGV[19] +local liveStatePatchPairCount = tonumber(ARGV[20]) + +local redisTime = redis.call('TIME') +local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000) +local validatedActionRequestScopeKey = '' + +local function storeValidatedActionRequestRejection(code) + if validatedActionRequestScopeKey == '' then + return + end + local actionRequestPrefix = validatedActionRequestScopeKey .. ':' + redis.call( + 'HSET', + auctionActionRequestResultsKey, + actionRequestPrefix .. 'status', + 'rejected', + actionRequestPrefix .. 'rejectCode', + code, + actionRequestPrefix .. 'requiresRefetch', + '1', + actionRequestPrefix .. 'responseServerTimestampMS', + tostring(currentRedisTimestampMS) + ) +end + +local function reject(code) + storeValidatedActionRequestRejection(code) + return {'REJECTED', code, auctionStateTransitionId, tostring(currentRedisTimestampMS)} +end + +if not liveStatePatchPairCount then + return reject('INVALID_PATCH_ARITY') +end +if #ARGV ~= 20 + (liveStatePatchPairCount * 2) then + return reject('INVALID_PATCH_ARITY') +end +if not durabilityPayloadJson or durabilityPayloadJson == '' then + return reject('MISSING_DURABILITY_PAYLOAD') +end +if shouldBroadcastState ~= '0' and shouldBroadcastState ~= '1' then + return reject('INVALID_SHOULD_BROADCAST_STATE') +end +if shouldBroadcastState == '1' and not broadcastStateRevision then + return reject('INVALID_BROADCAST_STATE_REVISION') +end +if deadlineMode ~= 'none' and deadlineMode ~= 'remove' and deadlineMode ~= 'set-relative' then + return reject('INVALID_DEADLINE_MODE') +end +if deadlineMode == 'set-relative' and (not deadlineDurationSeconds or deadlineDurationSeconds <= 0) then + return reject('INVALID_DEADLINE_DURATION') +end + +if actionRequestScopeKey ~= '' then + local actionRequestPrefix = actionRequestScopeKey .. ':' + local storedTransitionId = redis.call('HGET', auctionActionRequestResultsKey, actionRequestPrefix .. 'auctionStateTransitionId') + if not storedTransitionId then + return reject('ACTION_REQUEST_NOT_RESERVED') + end + if storedTransitionId ~= auctionStateTransitionId then + return reject('ACTION_REQUEST_TRANSITION_MISMATCH') + end + local storedOwnerToken = redis.call('HGET', auctionActionRequestResultsKey, actionRequestPrefix .. 'processingOwnerToken') + local leaseExpiresAtTimestampMS = tonumber(redis.call('HGET', auctionActionRequestResultsKey, actionRequestPrefix .. 'processingLeaseExpiresAtTimestampMS') or '0') + if leaseExpiresAtTimestampMS <= currentRedisTimestampMS then + return reject('ACTION_REQUEST_LEASE_EXPIRED') + end + if storedOwnerToken ~= processingOwnerToken then + return reject('ACTION_REQUEST_IN_PROGRESS') + end + local storedLeaseVersion = redis.call('HGET', auctionActionRequestResultsKey, actionRequestPrefix .. 'processingLeaseVersion') or '' + if storedLeaseVersion ~= observedProcessingLeaseVersion then + return reject('ACTION_REQUEST_LEASE_VERSION_MISMATCH') + end + validatedActionRequestScopeKey = actionRequestScopeKey +end + +local currentRevision = tonumber(redis.call('HGET', liveAuctionStateKey, 'revision') or '-1') +if currentRevision ~= expectedRevision then + return reject('CONFLICT') +end +local currentAuctionHistorySequence = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentAuctionHistorySequence') or '-1') +if currentAuctionHistorySequence ~= expectedAuctionHistorySequence then + return reject('CONFLICT') +end +if redis.call('HGET', liveAuctionStateKey, 'auctionLifecycleId') ~= auctionLifecycleId then + return reject('CONFLICT') +end +if redis.call('HGET', liveAuctionStateKey, 'phase') ~= expectedPhase then + return reject('CONFLICT') +end +if expectedCurrentBidRoundPlayerUserId ~= '' and redis.call('HGET', liveAuctionStateKey, 'currentBidRoundPlayerUserId') ~= expectedCurrentBidRoundPlayerUserId then + return reject('CONFLICT') +end +if expectedCurrentAuctionPlayerOrderIndex ~= '' and redis.call('HGET', liveAuctionStateKey, 'currentAuctionPlayerOrderIndex') ~= expectedCurrentAuctionPlayerOrderIndex then + return reject('CONFLICT') +end + +local transitionDedupeMember = auctionLifecycleId .. ':' .. auctionStateTransitionId +if redis.call('SISMEMBER', appliedAuctionStateTransitionIdsKey, transitionDedupeMember) == 1 then + return {'REPLAY', 'APPLIED', auctionStateTransitionId, tostring(currentRedisTimestampMS)} +end + +local newRevision = redis.call('HINCRBY', liveAuctionStateKey, 'revision', 1) +redis.call('SET', auctionStructureStateKey, afterAuctionStructureStateJson) + +local hsetArgs = { + liveAuctionStateKey, + 'auctionLifecycleId', + auctionLifecycleId, + 'currentAuctionHistorySequence', + tostring(auctionHistorySequence), + 'lastAppliedAuctionStateTransitionId', + auctionStateTransitionId +} +local patchIndex = 21 +for i = 1, liveStatePatchPairCount do + table.insert(hsetArgs, ARGV[patchIndex]) + table.insert(hsetArgs, ARGV[patchIndex + 1]) + patchIndex = patchIndex + 2 +end +redis.call('HSET', unpack(hsetArgs)) + +if deadlineMode == 'set-relative' then + local currentBidRoundDeadlineTimestampMS = currentRedisTimestampMS + (deadlineDurationSeconds * 1000) + redis.call('HSET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS', tostring(currentBidRoundDeadlineTimestampMS)) + redis.call('ZADD', bidRoundDeadlineQueueKey, currentBidRoundDeadlineTimestampMS, matchId) +elseif deadlineMode == 'remove' then + redis.call('ZREM', bidRoundDeadlineQueueKey, matchId) +end + +if shouldResetBidRuntime == '1' then + redis.call('DEL', auctionBidHistoryKey, bidRequestResultsKey, bidRequestResultOrderKey) +end + +redis.call('SADD', appliedAuctionStateTransitionIdsKey, transitionDedupeMember) +redis.call( + 'HSET', + durabilityPayloadKey, + 'payloadJson', + durabilityPayloadJson, + 'preparedAtRedisTimestampMS', + tostring(currentRedisTimestampMS), + 'committedAtRedisTimestampMS', + tostring(currentRedisTimestampMS), + 'auctionLifecycleId', + auctionLifecycleId, + 'revision', + tostring(newRevision), + 'shouldBroadcastState', + shouldBroadcastState, + 'broadcastStateRevision', + tostring(broadcastStateRevision) +) +redis.call('ZADD', durabilityRetryQueueKey, currentRedisTimestampMS, durabilityPayloadKey) + +if actionRequestScopeKey ~= '' then + local actionRequestPrefix = actionRequestScopeKey .. ':' + redis.call( + 'HSET', + auctionActionRequestResultsKey, + actionRequestPrefix .. 'status', + 'applied', + actionRequestPrefix .. 'revision', + tostring(newRevision), + actionRequestPrefix .. 'requiresRefetch', + '1', + actionRequestPrefix .. 'responseServerTimestampMS', + tostring(currentRedisTimestampMS) + ) + redis.call('RPUSH', auctionActionRequestResultOrderKey, actionRequestScopeKey) +end + +return {'OK', auctionStateTransitionId, tostring(newRevision), tostring(currentRedisTimestampMS)} +`, +); diff --git a/apps/api/src/modules/auction/redis/auction-redis.bid.spec.ts b/apps/api/src/modules/auction/redis/auction-redis.bid.spec.ts new file mode 100644 index 00000000..fe0a5c7a --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.bid.spec.ts @@ -0,0 +1,72 @@ +import { buildAuctionRedisKeys } from './auction-redis.keys'; +import { + AUCTION_BID_SCRIPT, + buildAuctionBidScriptInvocation, + buildBidRequestPayloadFingerprint, +} from './auction-redis.bid'; + +describe('auction bid redis script contract', () => { + it('builds the BID script KEYS and ARGV in the documented order', () => { + const keys = buildAuctionRedisKeys('match-1'); + const invocation = buildAuctionBidScriptInvocation(keys, { + bidderTeamIndex: 2, + bidPointAmount: 120, + bidRequestId: 'bid-1', + bidderUserId: 'captain-2', + clientObservedAuctionLifecycleId: 'life-1', + clientObservedCurrentBidRoundPlayerUserId: 'player-1', + maximumAuctionTeamMemberCount: 5, + maximumStoredAuctionBidHistoryCount: 200, + maximumStoredBidRequestResultCount: 100, + matchId: 'match-1', + minimumBidPointReservePerRemainingAuctionTeamMemberSlot: 10, + minimumBidRequestResultReplayWindowMS: 60_000, + }); + + expect(invocation.script).toBe(AUCTION_BID_SCRIPT); + expect(invocation.keys).toEqual([ + 'auction:match-1:liveAuctionState', + 'auction:match-1:auctionBidHistory', + 'auction:match-1:bidRequestResults', + 'auction:match-1:bidRequestResultOrder', + 'auction:bidRoundDeadlineQueue', + ]); + expect(invocation.values).toEqual([ + 'match-1', + '2', + '120', + '5', + '10', + 'bid-1', + 'captain-2', + 'life-1', + 'player-1', + 'match-1|life-1|player-1|2|120', + '100', + '60000', + '200', + ]); + }); + + it('keeps bid fingerprints stable and timestamp-free', () => { + expect( + buildBidRequestPayloadFingerprint({ + bidderTeamIndex: 2, + bidPointAmount: 120, + clientObservedAuctionLifecycleId: 'life-1', + clientObservedCurrentBidRoundPlayerUserId: 'player-1', + matchId: 'match-1', + }), + ).toBe('match-1|life-1|player-1|2|120'); + }); + + it('uses Redis TIME and scalar hash fields rather than JSON parsing', () => { + expect(AUCTION_BID_SCRIPT.lua).toContain("redis.call('TIME')"); + expect(AUCTION_BID_SCRIPT.lua).toContain("redis.call('HINCRBY'"); + expect(AUCTION_BID_SCRIPT.lua).toContain('BID_REQUEST_RESULT_LIMIT'); + expect(AUCTION_BID_SCRIPT.lua).toContain( + 'currentHighestBidPointAmount', + ); + expect(AUCTION_BID_SCRIPT.lua).not.toContain('cjson.decode'); + }); +}); diff --git a/apps/api/src/modules/auction/redis/auction-redis.bid.ts b/apps/api/src/modules/auction/redis/auction-redis.bid.ts new file mode 100644 index 00000000..88c6c763 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.bid.ts @@ -0,0 +1,310 @@ +import type { AuctionRedisKeys } from './auction-redis.keys'; +import { defineAuctionRedisScript } from './auction-redis.scripts'; + +export interface AuctionBidScriptInput { + bidderTeamIndex: number; + bidPointAmount: number; + bidRequestId: string; + bidderUserId: string; + clientObservedAuctionLifecycleId: string; + clientObservedCurrentBidRoundPlayerUserId: string; + maximumAuctionTeamMemberCount: number; + maximumStoredAuctionBidHistoryCount: number; + maximumStoredBidRequestResultCount: number; + matchId: string; + minimumBidPointReservePerRemainingAuctionTeamMemberSlot: number; + minimumBidRequestResultReplayWindowMS: number; +} + +export interface AuctionBidScriptInvocation { + keys: string[]; + script: typeof AUCTION_BID_SCRIPT; + values: string[]; +} + +const BID_RESULT_HASH_SUFFIXES = [ + 'fingerprint', + 'status', + 'revision', + 'rejectCode', + 'currentHighestBidPointAmount', + 'currentHighestBidderTeamIndex', + 'currentBidRoundDeadlineTimestampMS', + 'auctionBidHistoryEntryJson', + 'responseServerTimestampMS', + 'createdAtTimestampMS', +] as const; + +export function buildBidRequestPayloadFingerprint(params: { + bidderTeamIndex: number; + bidPointAmount: number; + clientObservedAuctionLifecycleId: string; + clientObservedCurrentBidRoundPlayerUserId: string; + matchId: string; +}): string { + return [ + params.matchId, + params.clientObservedAuctionLifecycleId, + params.clientObservedCurrentBidRoundPlayerUserId, + params.bidderTeamIndex, + params.bidPointAmount, + ].join('|'); +} + +export function buildAuctionBidScriptInvocation( + keys: AuctionRedisKeys, + input: AuctionBidScriptInput, +): AuctionBidScriptInvocation { + return { + keys: [ + keys.liveStateKey, + keys.bidHistoryKey, + keys.bidRequestResultsKey, + keys.bidRequestResultOrderKey, + keys.deadlineQueueKey, + ], + script: AUCTION_BID_SCRIPT, + values: [ + input.matchId, + String(input.bidderTeamIndex), + String(input.bidPointAmount), + String(input.maximumAuctionTeamMemberCount), + String(input.minimumBidPointReservePerRemainingAuctionTeamMemberSlot), + input.bidRequestId, + input.bidderUserId, + input.clientObservedAuctionLifecycleId, + input.clientObservedCurrentBidRoundPlayerUserId, + buildBidRequestPayloadFingerprint(input), + String(input.maximumStoredBidRequestResultCount), + String(input.minimumBidRequestResultReplayWindowMS), + String(input.maximumStoredAuctionBidHistoryCount), + ], + }; +} + +export const AUCTION_BID_SCRIPT = defineAuctionRedisScript( + 'auction.bid', + ` +local liveAuctionStateKey = KEYS[1] +local auctionBidHistoryKey = KEYS[2] +local bidRequestResultsKey = KEYS[3] +local bidRequestResultOrderKey = KEYS[4] +local bidRoundDeadlineQueueKey = KEYS[5] + +local matchId = ARGV[1] +local bidderTeamIndex = ARGV[2] +local bidPointAmount = tonumber(ARGV[3]) +local maximumAuctionTeamMemberCount = tonumber(ARGV[4]) +local minimumBidPointReservePerRemainingAuctionTeamMemberSlot = tonumber(ARGV[5]) +local bidRequestId = ARGV[6] +local bidderUserId = ARGV[7] +local clientObservedAuctionLifecycleId = ARGV[8] +local clientObservedCurrentBidRoundPlayerUserId = ARGV[9] +local bidRequestPayloadFingerprint = ARGV[10] +local maximumStoredBidRequestResultCount = tonumber(ARGV[11]) +local minimumBidRequestResultReplayWindowMS = tonumber(ARGV[12]) +local maximumStoredAuctionBidHistoryCount = tonumber(ARGV[13]) + +local redisTime = redis.call('TIME') +local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000) + +local function requestField(suffix) + return bidRequestId .. ':' .. suffix +end + +local function hdelBidRequest(requestId) + redis.call( + 'HDEL', + bidRequestResultsKey, + requestId .. ':fingerprint', + requestId .. ':status', + requestId .. ':revision', + requestId .. ':rejectCode', + requestId .. ':currentHighestBidPointAmount', + requestId .. ':currentHighestBidderTeamIndex', + requestId .. ':currentBidRoundDeadlineTimestampMS', + requestId .. ':auctionBidHistoryEntryJson', + requestId .. ':responseServerTimestampMS', + requestId .. ':createdAtTimestampMS' + ) +end + +local function trimOldBidRequestResults() + while redis.call('LLEN', bidRequestResultOrderKey) >= maximumStoredBidRequestResultCount do + local oldestBidRequestId = redis.call('LINDEX', bidRequestResultOrderKey, 0) + if not oldestBidRequestId then + return + end + local createdAtTimestampMS = tonumber(redis.call('HGET', bidRequestResultsKey, oldestBidRequestId .. ':createdAtTimestampMS') or '0') + if createdAtTimestampMS > currentRedisTimestampMS - minimumBidRequestResultReplayWindowMS then + return + end + redis.call('LPOP', bidRequestResultOrderKey) + hdelBidRequest(oldestBidRequestId) + end +end + +local function replayExistingRequest() + local status = redis.call('HGET', bidRequestResultsKey, requestField('status')) or '' + return { + 'REPLAY', + status, + bidRequestId, + redis.call('HGET', bidRequestResultsKey, requestField('revision')) or '', + redis.call('HGET', bidRequestResultsKey, requestField('rejectCode')) or '', + redis.call('HGET', bidRequestResultsKey, requestField('currentHighestBidPointAmount')) or '', + redis.call('HGET', bidRequestResultsKey, requestField('currentHighestBidderTeamIndex')) or '', + redis.call('HGET', bidRequestResultsKey, requestField('currentBidRoundDeadlineTimestampMS')) or '', + redis.call('HGET', bidRequestResultsKey, requestField('auctionBidHistoryEntryJson')) or '', + redis.call('HGET', bidRequestResultsKey, requestField('responseServerTimestampMS')) or tostring(currentRedisTimestampMS) + } +end + +local existingFingerprint = redis.call('HGET', bidRequestResultsKey, requestField('fingerprint')) +if existingFingerprint then + if existingFingerprint ~= bidRequestPayloadFingerprint then + return {'REJECTED', 'DUPLICATE_REQUEST_CONFLICT', bidRequestId, tostring(currentRedisTimestampMS)} + end + return replayExistingRequest() +end + +trimOldBidRequestResults() +if redis.call('LLEN', bidRequestResultOrderKey) >= maximumStoredBidRequestResultCount then + return {'REJECTED', 'BID_REQUEST_RESULT_LIMIT', bidRequestId, tostring(currentRedisTimestampMS)} +end + +local function storeRejectedRequest(rejectCode) + redis.call( + 'HSET', + bidRequestResultsKey, + requestField('fingerprint'), + bidRequestPayloadFingerprint, + requestField('status'), + 'rejected', + requestField('rejectCode'), + rejectCode, + requestField('responseServerTimestampMS'), + tostring(currentRedisTimestampMS), + requestField('createdAtTimestampMS'), + tostring(currentRedisTimestampMS) + ) + redis.call('RPUSH', bidRequestResultOrderKey, bidRequestId) + return {'REJECTED', rejectCode, bidRequestId, tostring(currentRedisTimestampMS)} +end + +local phase = redis.call('HGET', liveAuctionStateKey, 'phase') +if phase ~= 'bidding' then + return storeRejectedRequest('PHASE') +end + +local auctionLifecycleId = redis.call('HGET', liveAuctionStateKey, 'auctionLifecycleId') +local currentBidRoundPlayerUserId = redis.call('HGET', liveAuctionStateKey, 'currentBidRoundPlayerUserId') +if auctionLifecycleId ~= clientObservedAuctionLifecycleId or currentBidRoundPlayerUserId ~= clientObservedCurrentBidRoundPlayerUserId then + return storeRejectedRequest('STALE_BID_ROUND') +end + +local currentBidRoundDeadlineTimestampMS = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS') or '0') +if currentBidRoundDeadlineTimestampMS <= currentRedisTimestampMS then + return storeRejectedRequest('EXPIRED') +end + +local currentHighestBidPointAmount = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentHighestBidPointAmount') or '0') +if bidPointAmount <= currentHighestBidPointAmount then + return storeRejectedRequest('TOO_LOW') +end + +local remainingBidPointAmountField = 'team:' .. bidderTeamIndex .. ':remainingBidPointAmount' +local assignedAuctionTeamMemberCountField = 'team:' .. bidderTeamIndex .. ':assignedAuctionTeamMemberCount' +local remainingBidPointAmountRaw = redis.call('HGET', liveAuctionStateKey, remainingBidPointAmountField) +if not remainingBidPointAmountRaw then + return storeRejectedRequest('UNKNOWN_TEAM') +end + +local assignedAuctionTeamMemberCount = tonumber(redis.call('HGET', liveAuctionStateKey, assignedAuctionTeamMemberCountField) or '0') +if assignedAuctionTeamMemberCount >= maximumAuctionTeamMemberCount then + return storeRejectedRequest('FULL') +end + +local remainingBidPointAmount = tonumber(remainingBidPointAmountRaw) +local remainingSlotsAfterBid = maximumAuctionTeamMemberCount - assignedAuctionTeamMemberCount - 1 +local requiredReserveAfterBid = remainingSlotsAfterBid * minimumBidPointReservePerRemainingAuctionTeamMemberSlot +if bidPointAmount + requiredReserveAfterBid > remainingBidPointAmount then + return storeRejectedRequest('INSUFFICIENT') +end + +if redis.call('LLEN', auctionBidHistoryKey) >= maximumStoredAuctionBidHistoryCount then + return storeRejectedRequest('BID_HISTORY_LIMIT') +end + +local maximumBidRoundDurationSeconds = tonumber(redis.call('HGET', liveAuctionStateKey, 'maximumBidRoundDurationSeconds') or '0') +local bidRoundExtensionSeconds = tonumber(redis.call('HGET', liveAuctionStateKey, 'bidRoundExtensionSeconds') or '0') +local remainingBidRoundTimeMS = currentBidRoundDeadlineTimestampMS - currentRedisTimestampMS +local nextRemainingBidRoundTimeMS = remainingBidRoundTimeMS +local bidRoundExtensionMS = bidRoundExtensionSeconds * 1000 +local maximumBidRoundDurationMS = maximumBidRoundDurationSeconds * 1000 +if nextRemainingBidRoundTimeMS < bidRoundExtensionMS then + nextRemainingBidRoundTimeMS = bidRoundExtensionMS +end +if nextRemainingBidRoundTimeMS > maximumBidRoundDurationMS then + nextRemainingBidRoundTimeMS = maximumBidRoundDurationMS +end +local nextBidRoundDeadlineTimestampMS = currentRedisTimestampMS + nextRemainingBidRoundTimeMS + +local revision = redis.call('HINCRBY', liveAuctionStateKey, 'revision', 1) +local auctionBidHistoryEntryJson = + '{"bidderTeamIndex":' .. bidderTeamIndex .. + ',"bidPointAmount":' .. tostring(bidPointAmount) .. + ',"bidderUserId":"' .. bidderUserId .. + '","bidPlacedAtTimestampMS":' .. tostring(currentRedisTimestampMS) .. + '}' + +redis.call('RPUSH', auctionBidHistoryKey, auctionBidHistoryEntryJson) +redis.call( + 'HSET', + liveAuctionStateKey, + 'currentHighestBidPointAmount', + tostring(bidPointAmount), + 'currentHighestBidderTeamIndex', + bidderTeamIndex, + 'currentBidRoundDeadlineTimestampMS', + tostring(nextBidRoundDeadlineTimestampMS) +) +redis.call('ZADD', bidRoundDeadlineQueueKey, nextBidRoundDeadlineTimestampMS, matchId) +redis.call( + 'HSET', + bidRequestResultsKey, + requestField('fingerprint'), + bidRequestPayloadFingerprint, + requestField('status'), + 'ok', + requestField('revision'), + tostring(revision), + requestField('currentHighestBidPointAmount'), + tostring(bidPointAmount), + requestField('currentHighestBidderTeamIndex'), + bidderTeamIndex, + requestField('currentBidRoundDeadlineTimestampMS'), + tostring(nextBidRoundDeadlineTimestampMS), + requestField('auctionBidHistoryEntryJson'), + auctionBidHistoryEntryJson, + requestField('responseServerTimestampMS'), + tostring(currentRedisTimestampMS), + requestField('createdAtTimestampMS'), + tostring(currentRedisTimestampMS) +) +redis.call('RPUSH', bidRequestResultOrderKey, bidRequestId) + +return { + 'OK', + bidRequestId, + tostring(revision), + tostring(currentRedisTimestampMS), + tostring(bidPointAmount), + bidderTeamIndex, + tostring(nextBidRoundDeadlineTimestampMS), + auctionBidHistoryEntryJson +} +`, +); + +export const BID_RESULT_HASH_FIELD_SUFFIXES = BID_RESULT_HASH_SUFFIXES; diff --git a/apps/api/src/modules/auction/redis/auction-redis.constants.ts b/apps/api/src/modules/auction/redis/auction-redis.constants.ts new file mode 100644 index 00000000..4a565349 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.constants.ts @@ -0,0 +1 @@ +export const AUCTION_REDIS_CLIENT = Symbol('AUCTION_REDIS_CLIENT'); diff --git a/apps/api/src/modules/auction/redis/auction-redis.expire-prepare.spec.ts b/apps/api/src/modules/auction/redis/auction-redis.expire-prepare.spec.ts new file mode 100644 index 00000000..6936d578 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.expire-prepare.spec.ts @@ -0,0 +1,38 @@ +import { buildAuctionRedisKeys } from './auction-redis.keys'; +import { + AUCTION_EXPIRE_PREPARE_SCRIPT, + buildAuctionExpirePrepareScriptInvocation, +} from './auction-redis.expire-prepare'; + +describe('auction expire prepare redis script contract', () => { + it('builds EXPIRE_PREPARE keys and values', () => { + const invocation = buildAuctionExpirePrepareScriptInvocation( + buildAuctionRedisKeys('match-1'), + { + auctionStateTransitionId: 'expire-1', + bidRoundExpiryRetryDelayMS: 3_000, + matchId: 'match-1', + }, + ); + + expect(invocation.script).toBe(AUCTION_EXPIRE_PREPARE_SCRIPT); + expect(invocation.keys).toEqual([ + 'auction:match-1:liveAuctionState', + 'auction:bidRoundDeadlineQueue', + ]); + expect(invocation.values).toEqual(['match-1', 'expire-1', '3000']); + }); + + it('freezes expiry context with Redis TIME and expiring phase', () => { + expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain("redis.call('TIME')"); + expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain("'phase'"); + expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain("'expiring'"); + expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain( + 'bidRoundExpiryRevision', + ); + expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain( + 'bidRoundExpiryWinningBidderTeamIndex', + ); + expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain("'ZADD'"); + }); +}); diff --git a/apps/api/src/modules/auction/redis/auction-redis.expire-prepare.ts b/apps/api/src/modules/auction/redis/auction-redis.expire-prepare.ts new file mode 100644 index 00000000..29cd6999 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.expire-prepare.ts @@ -0,0 +1,107 @@ +import type { AuctionRedisKeys } from './auction-redis.keys'; +import { defineAuctionRedisScript } from './auction-redis.scripts'; + +export interface AuctionExpirePrepareScriptInput { + auctionStateTransitionId: string; + bidRoundExpiryRetryDelayMS: number; + matchId: string; +} + +export interface AuctionExpirePrepareScriptInvocation { + keys: string[]; + script: typeof AUCTION_EXPIRE_PREPARE_SCRIPT; + values: string[]; +} + +export function buildAuctionExpirePrepareScriptInvocation( + keys: AuctionRedisKeys, + input: AuctionExpirePrepareScriptInput, +): AuctionExpirePrepareScriptInvocation { + return { + keys: [keys.liveStateKey, keys.deadlineQueueKey], + script: AUCTION_EXPIRE_PREPARE_SCRIPT, + values: [ + input.matchId, + input.auctionStateTransitionId, + String(input.bidRoundExpiryRetryDelayMS), + ], + }; +} + +export const AUCTION_EXPIRE_PREPARE_SCRIPT = defineAuctionRedisScript( + 'auction.expirePrepare', + ` +local liveAuctionStateKey = KEYS[1] +local bidRoundDeadlineQueueKey = KEYS[2] + +local matchId = ARGV[1] +local auctionStateTransitionId = ARGV[2] +local bidRoundExpiryRetryDelayMS = tonumber(ARGV[3]) + +local redisTime = redis.call('TIME') +local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000) + +local phase = redis.call('HGET', liveAuctionStateKey, 'phase') +if phase == 'expiring' then + return { + 'REPLAY', + redis.call('HGET', liveAuctionStateKey, 'bidRoundExpiryDecision') or '', + redis.call('HGET', liveAuctionStateKey, 'bidRoundExpiryAuctionStateTransitionId') or '', + redis.call('HGET', liveAuctionStateKey, 'bidRoundExpiryRevision') or '', + tostring(currentRedisTimestampMS) + } +end +if phase ~= 'bidding' then + redis.call('ZREM', bidRoundDeadlineQueueKey, matchId) + return {'NOOP', 'PHASE', tostring(currentRedisTimestampMS)} +end + +local currentBidRoundDeadlineTimestampMS = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS') or '0') +if currentBidRoundDeadlineTimestampMS > currentRedisTimestampMS then + return {'NOOP', 'NOT_DUE', tostring(currentRedisTimestampMS)} +end + +local currentHighestBidPointAmount = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentHighestBidPointAmount') or '0') +local currentHighestBidderTeamIndex = redis.call('HGET', liveAuctionStateKey, 'currentHighestBidderTeamIndex') or '-1' +local bidRoundExpiryDecision = 'passed' +if currentHighestBidPointAmount > 0 then + bidRoundExpiryDecision = 'sold' +end + +local revision = redis.call('HINCRBY', liveAuctionStateKey, 'revision', 1) +redis.call( + 'HSET', + liveAuctionStateKey, + 'phase', + 'expiring', + 'bidRoundExpiryDecision', + bidRoundExpiryDecision, + 'bidRoundExpiryAuctionStateTransitionId', + auctionStateTransitionId, + 'bidRoundExpiryPlayerUserId', + redis.call('HGET', liveAuctionStateKey, 'currentBidRoundPlayerUserId') or '', + 'bidRoundExpiryPlayerOrderIndex', + redis.call('HGET', liveAuctionStateKey, 'currentAuctionPlayerOrderIndex') or '', + 'bidRoundExpiryWinningBidPointAmount', + tostring(currentHighestBidPointAmount), + 'bidRoundExpiryWinningBidderTeamIndex', + currentHighestBidderTeamIndex, + 'bidRoundExpiryRevision', + tostring(revision) +) +redis.call( + 'ZADD', + bidRoundDeadlineQueueKey, + currentRedisTimestampMS + bidRoundExpiryRetryDelayMS, + matchId +) + +return { + 'OK', + bidRoundExpiryDecision, + auctionStateTransitionId, + tostring(revision), + tostring(currentRedisTimestampMS) +} +`, +); diff --git a/apps/api/src/modules/auction/redis/auction-redis.keys.spec.ts b/apps/api/src/modules/auction/redis/auction-redis.keys.spec.ts new file mode 100644 index 00000000..b03377b1 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.keys.spec.ts @@ -0,0 +1,29 @@ +import { buildAuctionRedisKeys } from './auction-redis.keys'; + +describe('auction redis keys', () => { + it('builds lifecycle-safe key names from match id', () => { + expect(buildAuctionRedisKeys('match-1')).toMatchObject({ + actionRequestResultOrderKey: 'auction:match-1:auctionActionRequestResultOrder', + actionRequestResultsKey: 'auction:match-1:auctionActionRequestResults', + appliedTransitionIdsKey: 'auction:match-1:appliedAuctionStateTransitionIds', + bidHistoryKey: 'auction:match-1:auctionBidHistory', + bidRequestResultOrderKey: 'auction:match-1:bidRequestResultOrder', + bidRequestResultsKey: 'auction:match-1:bidRequestResults', + deadlineQueueKey: 'auction:bidRoundDeadlineQueue', + durabilityDeadLetterQueueKey: 'auction:auctionDurabilityDeadLetterQueue', + durabilityPayloadKeyPrefix: 'auction:match-1:durability:', + durabilityRetryQueueKey: 'auction:auctionDurabilityRetryQueue', + liveStateKey: 'auction:match-1:liveAuctionState', + rehydrateLockKey: 'auction:match-1:rehydrateLock', + stateTransitionLockKey: 'auction:match-1:auctionStateTransitionLock', + structureStateKey: 'auction:match-1:auctionStructureState', + }); + }); + + it('builds transition durability payload keys', () => { + const keys = buildAuctionRedisKeys('match-1'); + expect(keys.durabilityPayloadKey('transition-1')).toBe( + 'auction:match-1:durability:transition-1', + ); + }); +}); diff --git a/apps/api/src/modules/auction/redis/auction-redis.keys.ts b/apps/api/src/modules/auction/redis/auction-redis.keys.ts new file mode 100644 index 00000000..0ef9a636 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.keys.ts @@ -0,0 +1,47 @@ +export const AUCTION_BID_ROUND_DEADLINE_QUEUE_KEY = + 'auction:bidRoundDeadlineQueue'; +export const AUCTION_DURABILITY_RETRY_QUEUE_KEY = + 'auction:auctionDurabilityRetryQueue'; +export const AUCTION_DURABILITY_DEAD_LETTER_QUEUE_KEY = + 'auction:auctionDurabilityDeadLetterQueue'; + +export interface AuctionRedisKeys { + actionRequestResultOrderKey: string; + actionRequestResultsKey: string; + appliedTransitionIdsKey: string; + bidHistoryKey: string; + bidRequestResultOrderKey: string; + bidRequestResultsKey: string; + deadlineQueueKey: string; + durabilityDeadLetterQueueKey: string; + durabilityPayloadKey: (auctionStateTransitionId: string) => string; + durabilityPayloadKeyPrefix: string; + durabilityRetryQueueKey: string; + liveStateKey: string; + rehydrateLockKey: string; + stateTransitionLockKey: string; + structureStateKey: string; +} + +export function buildAuctionRedisKeys(matchId: string): AuctionRedisKeys { + const prefix = `auction:${matchId}`; + const durabilityPayloadKeyPrefix = `${prefix}:durability:`; + return { + actionRequestResultOrderKey: `${prefix}:auctionActionRequestResultOrder`, + actionRequestResultsKey: `${prefix}:auctionActionRequestResults`, + appliedTransitionIdsKey: `${prefix}:appliedAuctionStateTransitionIds`, + bidHistoryKey: `${prefix}:auctionBidHistory`, + bidRequestResultOrderKey: `${prefix}:bidRequestResultOrder`, + bidRequestResultsKey: `${prefix}:bidRequestResults`, + deadlineQueueKey: AUCTION_BID_ROUND_DEADLINE_QUEUE_KEY, + durabilityDeadLetterQueueKey: AUCTION_DURABILITY_DEAD_LETTER_QUEUE_KEY, + durabilityPayloadKey: (auctionStateTransitionId: string) => + `${durabilityPayloadKeyPrefix}${auctionStateTransitionId}`, + durabilityPayloadKeyPrefix, + durabilityRetryQueueKey: AUCTION_DURABILITY_RETRY_QUEUE_KEY, + liveStateKey: `${prefix}:liveAuctionState`, + rehydrateLockKey: `${prefix}:rehydrateLock`, + stateTransitionLockKey: `${prefix}:auctionStateTransitionLock`, + structureStateKey: `${prefix}:auctionStructureState`, + }; +} diff --git a/apps/api/src/modules/auction/redis/auction-redis.module.ts b/apps/api/src/modules/auction/redis/auction-redis.module.ts new file mode 100644 index 00000000..d3b1b3a9 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.module.ts @@ -0,0 +1,100 @@ +import { Logger, Module } from '@nestjs/common'; +import { createClient } from 'redis'; +import { SecretModule } from '../../global/secret/secret.module'; +import { SecretService } from '../../global/secret/secret.service'; +import { + assertDistinctRedisInstances, + resolveRedisClientOptions, +} from '../../global/redis/redis.config'; +import { AUCTION_REDIS_CLIENT } from './auction-redis.constants'; +import { + AuctionRedisService, + type AuctionRedisClient, +} from './auction-redis.service'; +import { AuctionRedisCommandService } from './auction-redis-command.service'; +import { AuctionRedisStateReaderService } from './auction-redis-state-reader.service'; + +async function readFirstSecret( + secretService: SecretService, + keys: string[], +): Promise { + for (const key of keys) { + const value = await secretService.get(key, ''); + const trimmed = value.trim(); + if (trimmed) return trimmed; + } + return undefined; +} + +@Module({ + imports: [SecretModule], + providers: [ + { + provide: AUCTION_REDIS_CLIENT, + inject: [SecretService], + useFactory: async ( + secretService: SecretService, + ): Promise => { + await secretService.ready(); + + const [ + redisUrl, + redisEndpoint, + auctionRedisUrl, + auctionRedisEndpoint, + auctionRedisUsername, + auctionRedisPassword, + ] = await Promise.all([ + readFirstSecret(secretService, ['REDIS_URL', 'GARNET_URL']), + readFirstSecret(secretService, ['REDIS_ENDPOINT', 'GARNET_ENDPOINT']), + readFirstSecret(secretService, ['AUCTION_REDIS_URL']), + readFirstSecret(secretService, ['AUCTION_REDIS_ENDPOINT']), + readFirstSecret(secretService, [ + 'AUCTION_REDIS_USERNAME', + 'AUCTION_REDIS_USERID', + ]), + readFirstSecret(secretService, ['AUCTION_REDIS_PASSWORD']), + ]); + + const redisOptions = resolveRedisClientOptions({ + endpoint: redisEndpoint, + endpointEnvName: 'REDIS_ENDPOINT', + url: redisUrl, + urlEnvName: 'REDIS_URL', + }); + const auctionRedisOptions = resolveRedisClientOptions({ + endpoint: auctionRedisEndpoint, + endpointEnvName: 'AUCTION_REDIS_ENDPOINT', + password: auctionRedisPassword, + url: auctionRedisUrl, + urlEnvName: 'AUCTION_REDIS_URL', + username: auctionRedisUsername, + }); + assertDistinctRedisInstances(redisOptions.url, auctionRedisOptions.url); + + const logger = new Logger('AuctionRedisClient'); + const client = createClient(auctionRedisOptions); + client.on('error', (error) => { + logger.error( + `Auction Redis client error: ${error?.message ?? error}`, + ); + }); + + await client.connect(); + logger.log('Auction Redis connected'); + + return client; + }, + }, + AuctionRedisService, + AuctionRedisCommandService, + AuctionRedisStateReaderService, + ], + exports: [ + AuctionRedisService, + AuctionRedisCommandService, + AuctionRedisStateReaderService, + AUCTION_REDIS_CLIENT, + ], +}) +export class AuctionRedisModule {} diff --git a/apps/api/src/modules/auction/redis/auction-redis.reserve-action.spec.ts b/apps/api/src/modules/auction/redis/auction-redis.reserve-action.spec.ts new file mode 100644 index 00000000..ec16743c --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.reserve-action.spec.ts @@ -0,0 +1,77 @@ +import { buildAuctionRedisKeys } from './auction-redis.keys'; +import { + AUCTION_RESERVE_ACTION_REQUEST_SCRIPT, + buildActionRequestPayloadFingerprint, + buildAuctionReserveActionRequestScriptInvocation, +} from './auction-redis.reserve-action'; + +describe('auction reserve action request redis script contract', () => { + it('builds RESERVE_AUCTION_ACTION_REQUEST keys and values', () => { + const invocation = buildAuctionReserveActionRequestScriptInvocation( + buildAuctionRedisKeys('match-1'), + { + auctionActionRequestId: 'request-1', + auctionActionType: 'sold', + auctionStateTransitionId: 'transition-1', + clientObservedAuctionLifecycleId: 'life-1', + clientObservedPhase: 'bidding', + clientObservedRevision: 8, + leaseDurationMS: 10_000, + maximumStoredAuctionActionRequestResultCount: 100, + minimumAuctionActionRequestResultReplayWindowMS: 60_000, + newAuctionLifecycleId: undefined, + processingOwnerToken: 'owner-1', + }, + ); + + expect(invocation.script).toBe(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT); + expect(invocation.keys).toEqual([ + 'auction:match-1:auctionActionRequestResults', + 'auction:match-1:auctionActionRequestResultOrder', + ]); + expect(invocation.values).toEqual([ + 'life-1', + 'request-1', + 'sold', + 'transition-1', + '', + 'owner-1', + '10000', + '100', + '60000', + 'life-1|request-1|sold|8|bidding||', + ]); + }); + + it('builds stable action request fingerprints', () => { + expect( + buildActionRequestPayloadFingerprint({ + auctionActionRequestId: 'request-1', + auctionActionType: 'next', + clientObservedAuctionLifecycleId: 'life-1', + clientObservedCurrentAuctionPlayerOrderIndex: 3, + clientObservedCurrentBidRoundPlayerUserId: 'player-1', + clientObservedPhase: 'sold', + clientObservedRevision: 9, + }), + ).toBe('life-1|request-1|next|9|sold|player-1|3'); + }); + + it('keeps lease version and replay guards in Lua', () => { + expect(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT.lua).toContain( + "redis.call('TIME')", + ); + expect(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT.lua).toContain( + 'processingLeaseVersion', + ); + expect(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT.lua).toContain( + 'ACTION_REQUEST_IN_PROGRESS', + ); + expect(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT.lua).toContain( + 'ACTION_REQUEST_RESULT_LIMIT', + ); + expect(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT.lua).toContain( + 'DUPLICATE_ACTION_REQUEST_CONFLICT', + ); + }); +}); diff --git a/apps/api/src/modules/auction/redis/auction-redis.reserve-action.ts b/apps/api/src/modules/auction/redis/auction-redis.reserve-action.ts new file mode 100644 index 00000000..fcd16690 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.reserve-action.ts @@ -0,0 +1,233 @@ +import type { AuctionRedisKeys } from './auction-redis.keys'; +import { defineAuctionRedisScript } from './auction-redis.scripts'; + +export interface AuctionReserveActionRequestScriptInput { + auctionActionRequestId: string; + auctionActionType: string; + auctionStateTransitionId: string; + clientObservedAuctionLifecycleId: string; + clientObservedCurrentAuctionPlayerOrderIndex?: number; + clientObservedCurrentBidRoundPlayerUserId?: string; + clientObservedPhase: string; + clientObservedRevision: number; + leaseDurationMS: number; + maximumStoredAuctionActionRequestResultCount: number; + minimumAuctionActionRequestResultReplayWindowMS: number; + newAuctionLifecycleId?: string; + processingOwnerToken: string; +} + +export interface AuctionReserveActionRequestScriptInvocation { + keys: string[]; + script: typeof AUCTION_RESERVE_ACTION_REQUEST_SCRIPT; + values: string[]; +} + +export function buildActionRequestPayloadFingerprint(params: { + auctionActionRequestId: string; + auctionActionType: string; + clientObservedAuctionLifecycleId: string; + clientObservedCurrentAuctionPlayerOrderIndex?: number; + clientObservedCurrentBidRoundPlayerUserId?: string; + clientObservedPhase: string; + clientObservedRevision: number; +}): string { + return [ + params.clientObservedAuctionLifecycleId, + params.auctionActionRequestId, + params.auctionActionType, + params.clientObservedRevision, + params.clientObservedPhase, + params.clientObservedCurrentBidRoundPlayerUserId ?? '', + params.clientObservedCurrentAuctionPlayerOrderIndex ?? '', + ].join('|'); +} + +export function buildAuctionReserveActionRequestScriptInvocation( + keys: AuctionRedisKeys, + input: AuctionReserveActionRequestScriptInput, +): AuctionReserveActionRequestScriptInvocation { + return { + keys: [keys.actionRequestResultsKey, keys.actionRequestResultOrderKey], + script: AUCTION_RESERVE_ACTION_REQUEST_SCRIPT, + values: [ + input.clientObservedAuctionLifecycleId, + input.auctionActionRequestId, + input.auctionActionType, + input.auctionStateTransitionId, + input.newAuctionLifecycleId ?? '', + input.processingOwnerToken, + String(input.leaseDurationMS), + String(input.maximumStoredAuctionActionRequestResultCount), + String(input.minimumAuctionActionRequestResultReplayWindowMS), + buildActionRequestPayloadFingerprint(input), + ], + }; +} + +export const AUCTION_RESERVE_ACTION_REQUEST_SCRIPT = defineAuctionRedisScript( + 'auction.reserveActionRequest', + ` +local auctionActionRequestResultsKey = KEYS[1] +local auctionActionRequestResultOrderKey = KEYS[2] + +local clientObservedAuctionLifecycleId = ARGV[1] +local auctionActionRequestId = ARGV[2] +local auctionActionType = ARGV[3] +local auctionStateTransitionId = ARGV[4] +local newAuctionLifecycleId = ARGV[5] +local processingOwnerToken = ARGV[6] +local leaseDurationMS = tonumber(ARGV[7]) +local maximumStoredAuctionActionRequestResultCount = tonumber(ARGV[8]) +local minimumAuctionActionRequestResultReplayWindowMS = tonumber(ARGV[9]) +local actionRequestPayloadFingerprint = ARGV[10] + +local redisTime = redis.call('TIME') +local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000) +local actionRequestScopeKey = clientObservedAuctionLifecycleId .. ':' .. auctionActionRequestId + +local function requestField(suffix) + return actionRequestScopeKey .. ':' .. suffix +end + +local function hdelActionRequest(scopeKey) + redis.call( + 'HDEL', + auctionActionRequestResultsKey, + scopeKey .. ':fingerprint', + scopeKey .. ':status', + scopeKey .. ':revision', + scopeKey .. ':rejectCode', + scopeKey .. ':auctionActionType', + scopeKey .. ':auctionStateTransitionId', + scopeKey .. ':newAuctionLifecycleId', + scopeKey .. ':processingOwnerToken', + scopeKey .. ':processingLeaseExpiresAtTimestampMS', + scopeKey .. ':processingLeaseVersion', + scopeKey .. ':responseServerTimestampMS', + scopeKey .. ':responseJson', + scopeKey .. ':requiresRefetch', + scopeKey .. ':createdAtTimestampMS' + ) +end + +local function trimOldActionRequestResults() + while redis.call('LLEN', auctionActionRequestResultOrderKey) >= maximumStoredAuctionActionRequestResultCount do + local oldestActionRequestScopeKey = redis.call('LINDEX', auctionActionRequestResultOrderKey, 0) + if not oldestActionRequestScopeKey then + return + end + local createdAtTimestampMS = tonumber(redis.call('HGET', auctionActionRequestResultsKey, oldestActionRequestScopeKey .. ':createdAtTimestampMS') or '0') + if createdAtTimestampMS > currentRedisTimestampMS - minimumAuctionActionRequestResultReplayWindowMS then + return + end + redis.call('LPOP', auctionActionRequestResultOrderKey) + hdelActionRequest(oldestActionRequestScopeKey) + end +end + +local existingFingerprint = redis.call('HGET', auctionActionRequestResultsKey, requestField('fingerprint')) +if existingFingerprint then + if existingFingerprint ~= actionRequestPayloadFingerprint then + return {'REJECTED', 'DUPLICATE_ACTION_REQUEST_CONFLICT', actionRequestScopeKey, tostring(currentRedisTimestampMS)} + end + + local status = redis.call('HGET', auctionActionRequestResultsKey, requestField('status')) or '' + if status == 'applied' or status == 'rejected' then + return { + 'REPLAY', + status, + actionRequestScopeKey, + redis.call('HGET', auctionActionRequestResultsKey, requestField('revision')) or '', + redis.call('HGET', auctionActionRequestResultsKey, requestField('rejectCode')) or '', + redis.call('HGET', auctionActionRequestResultsKey, requestField('auctionStateTransitionId')) or '', + redis.call('HGET', auctionActionRequestResultsKey, requestField('newAuctionLifecycleId')) or '', + redis.call('HGET', auctionActionRequestResultsKey, requestField('processingLeaseVersion')) or '', + redis.call('HGET', auctionActionRequestResultsKey, requestField('responseServerTimestampMS')) or tostring(currentRedisTimestampMS), + redis.call('HGET', auctionActionRequestResultsKey, requestField('responseJson')) or '', + redis.call('HGET', auctionActionRequestResultsKey, requestField('requiresRefetch')) or '' + } + end + + local leaseExpiresAtTimestampMS = tonumber(redis.call('HGET', auctionActionRequestResultsKey, requestField('processingLeaseExpiresAtTimestampMS')) or '0') + local storedOwnerToken = redis.call('HGET', auctionActionRequestResultsKey, requestField('processingOwnerToken')) or '' + local storedLeaseVersion = tonumber(redis.call('HGET', auctionActionRequestResultsKey, requestField('processingLeaseVersion')) or '1') + if leaseExpiresAtTimestampMS > currentRedisTimestampMS and storedOwnerToken ~= processingOwnerToken then + return {'REJECTED', 'ACTION_REQUEST_IN_PROGRESS', actionRequestScopeKey, tostring(currentRedisTimestampMS)} + end + + local nextLeaseVersion = storedLeaseVersion + local wasLeaseExpired = '0' + if leaseExpiresAtTimestampMS <= currentRedisTimestampMS then + nextLeaseVersion = storedLeaseVersion + 1 + wasLeaseExpired = '1' + end + + redis.call( + 'HSET', + auctionActionRequestResultsKey, + requestField('status'), + 'processing', + requestField('processingOwnerToken'), + processingOwnerToken, + requestField('processingLeaseExpiresAtTimestampMS'), + tostring(currentRedisTimestampMS + leaseDurationMS), + requestField('processingLeaseVersion'), + tostring(nextLeaseVersion), + requestField('responseServerTimestampMS'), + tostring(currentRedisTimestampMS) + ) + + return { + 'RESERVED', + actionRequestScopeKey, + redis.call('HGET', auctionActionRequestResultsKey, requestField('auctionStateTransitionId')) or auctionStateTransitionId, + redis.call('HGET', auctionActionRequestResultsKey, requestField('newAuctionLifecycleId')) or '', + tostring(nextLeaseVersion), + wasLeaseExpired, + tostring(currentRedisTimestampMS) + } +end + +trimOldActionRequestResults() +if redis.call('LLEN', auctionActionRequestResultOrderKey) >= maximumStoredAuctionActionRequestResultCount then + return {'REJECTED', 'ACTION_REQUEST_RESULT_LIMIT', actionRequestScopeKey, tostring(currentRedisTimestampMS)} +end + +redis.call( + 'HSET', + auctionActionRequestResultsKey, + requestField('fingerprint'), + actionRequestPayloadFingerprint, + requestField('status'), + 'processing', + requestField('auctionActionType'), + auctionActionType, + requestField('auctionStateTransitionId'), + auctionStateTransitionId, + requestField('newAuctionLifecycleId'), + newAuctionLifecycleId, + requestField('processingOwnerToken'), + processingOwnerToken, + requestField('processingLeaseExpiresAtTimestampMS'), + tostring(currentRedisTimestampMS + leaseDurationMS), + requestField('processingLeaseVersion'), + '1', + requestField('responseServerTimestampMS'), + tostring(currentRedisTimestampMS), + requestField('createdAtTimestampMS'), + tostring(currentRedisTimestampMS) +) +redis.call('RPUSH', auctionActionRequestResultOrderKey, actionRequestScopeKey) + +return { + 'RESERVED', + actionRequestScopeKey, + auctionStateTransitionId, + newAuctionLifecycleId, + '1', + '0', + tostring(currentRedisTimestampMS) +} +`, +); diff --git a/apps/api/src/modules/auction/redis/auction-redis.scripts.spec.ts b/apps/api/src/modules/auction/redis/auction-redis.scripts.spec.ts new file mode 100644 index 00000000..258eb643 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.scripts.spec.ts @@ -0,0 +1,14 @@ +import { createHash } from 'crypto'; +import { defineAuctionRedisScript } from './auction-redis.scripts'; + +describe('auction redis scripts', () => { + it('stores normalized Lua and its SHA1', () => { + const script = defineAuctionRedisScript('test', 'return 1\n'); + + expect(script).toEqual({ + lua: 'return 1\n', + name: 'test', + sha: createHash('sha1').update('return 1\n').digest('hex'), + }); + }); +}); diff --git a/apps/api/src/modules/auction/redis/auction-redis.scripts.ts b/apps/api/src/modules/auction/redis/auction-redis.scripts.ts new file mode 100644 index 00000000..ad8656be --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.scripts.ts @@ -0,0 +1,18 @@ +import { createHash } from 'crypto'; + +export interface AuctionRedisScriptDefinition { + lua: string; + name: string; + sha: string; +} + +export function defineAuctionRedisScript( + name: string, + lua: string, +): AuctionRedisScriptDefinition { + return { + lua, + name, + sha: createHash('sha1').update(lua).digest('hex'), + }; +} diff --git a/apps/api/src/modules/auction/redis/auction-redis.service.spec.ts b/apps/api/src/modules/auction/redis/auction-redis.service.spec.ts new file mode 100644 index 00000000..9098dec1 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.service.spec.ts @@ -0,0 +1,64 @@ +import { + AuctionRedisNoscriptError, + AuctionRedisService, +} from './auction-redis.service'; + +function makeService(sendCommand: jest.Mock) { + const client = { + destroy: jest.fn(), + quit: jest.fn().mockResolvedValue(undefined), + sendCommand, + }; + + return new AuctionRedisService(client as never); +} + +describe('AuctionRedisService', () => { + it('uses Redis TIME as the timestamp source', async () => { + const service = makeService(jest.fn().mockResolvedValue(['1781700000', '123000'])); + + await expect(service.getCurrentRedisTimestampMS()).resolves.toBe( + 1_781_700_000_123, + ); + }); + + it('loads and retries a script once when EVALSHA returns NOSCRIPT', async () => { + const sendCommand = jest + .fn() + .mockRejectedValueOnce(new AuctionRedisNoscriptError()) + .mockResolvedValueOnce('sha-from-redis') + .mockResolvedValueOnce(['ok']); + const service = makeService(sendCommand); + + await expect( + service.evalShaWithReload({ + keys: ['auction:state:1'], + script: 'return 1', + scriptSha: 'old-sha', + values: ['v1'], + }), + ).resolves.toEqual(['ok']); + + expect(sendCommand.mock.calls).toEqual([ + [['EVALSHA', 'old-sha', '1', 'auction:state:1', 'v1']], + [['SCRIPT', 'LOAD', 'return 1']], + [['EVALSHA', 'sha-from-redis', '1', 'auction:state:1', 'v1']], + ]); + }); + + it('does not reload scripts for non-NOSCRIPT errors', async () => { + const error = new Error('OOM command not allowed'); + const sendCommand = jest.fn().mockRejectedValue(error); + const service = makeService(sendCommand); + + await expect( + service.evalShaWithReload({ + keys: [], + script: 'return 1', + scriptSha: 'sha', + values: [], + }), + ).rejects.toBe(error); + expect(sendCommand).toHaveBeenCalledTimes(1); + }); +}); diff --git a/apps/api/src/modules/auction/redis/auction-redis.service.ts b/apps/api/src/modules/auction/redis/auction-redis.service.ts new file mode 100644 index 00000000..571787cd --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.service.ts @@ -0,0 +1,131 @@ +import { Inject, Injectable, OnModuleDestroy } from '@nestjs/common'; +import type { createClient } from 'redis'; +import { AUCTION_REDIS_CLIENT } from './auction-redis.constants'; +import type { AuctionRedisScriptDefinition } from './auction-redis.scripts'; + +export type AuctionRedisClient = ReturnType; + +export interface EvalShaWithReloadParams { + keys: string[]; + script: string; + scriptSha: string; + values: string[]; +} + +export class AuctionRedisNoscriptError extends Error { + constructor(message = 'NOSCRIPT No matching script. Please use EVAL.') { + super(message); + this.name = 'AuctionRedisNoscriptError'; + } +} + +function isNoscriptError(error: unknown): boolean { + if (error instanceof AuctionRedisNoscriptError) return true; + const message = + error instanceof Error ? error.message : typeof error === 'string' ? error : ''; + return /\bNOSCRIPT\b/iu.test(message); +} + +function buildEvalShaCommand( + scriptSha: string, + keys: string[], + values: string[], +): string[] { + return ['EVALSHA', scriptSha, String(keys.length), ...keys, ...values]; +} + +function parseRedisTimeReply(reply: unknown): number { + if (Array.isArray(reply) && reply.length >= 2) { + const seconds = Number(reply[0]); + const microseconds = Number(reply[1]); + if (Number.isFinite(seconds) && Number.isFinite(microseconds)) { + return seconds * 1000 + Math.floor(microseconds / 1000); + } + } + + throw new Error(`Unexpected Redis TIME reply: ${JSON.stringify(reply)}`); +} + +@Injectable() +export class AuctionRedisService implements OnModuleDestroy { + constructor( + @Inject(AUCTION_REDIS_CLIENT) + private readonly client: AuctionRedisClient, + ) {} + + async onModuleDestroy() { + try { + await this.client.quit(); + } catch { + this.client.destroy(); + } + } + + public raw(): AuctionRedisClient { + return this.client; + } + + public async getCurrentRedisTimestampMS(): Promise { + const reply = await this.client.sendCommand(['TIME']); + return parseRedisTimeReply(reply); + } + + public async evalShaWithReload( + params: EvalShaWithReloadParams, + ): Promise { + try { + return (await this.client.sendCommand( + buildEvalShaCommand(params.scriptSha, params.keys, params.values), + )) as T; + } catch (error) { + if (!isNoscriptError(error)) throw error; + } + + const loadedSha = String( + await this.client.sendCommand(['SCRIPT', 'LOAD', params.script]), + ); + return (await this.client.sendCommand( + buildEvalShaCommand(loadedSha, params.keys, params.values), + )) as T; + } + + public async evalScript( + script: AuctionRedisScriptDefinition, + keys: string[], + values: string[], + ): Promise { + return this.evalShaWithReload({ + keys, + script: script.lua, + scriptSha: script.sha, + values, + }); + } + + public async acquireTokenLock( + key: string, + token: string, + ttlMS: number, + ): Promise { + const result = await this.client.sendCommand([ + 'SET', + key, + token, + 'PX', + String(ttlMS), + 'NX', + ]); + return String(result) === 'OK'; + } + + public async releaseTokenLock(key: string, token: string): Promise { + const result = await this.client.sendCommand([ + 'EVAL', + 'if redis.call("GET", KEYS[1]) == ARGV[1] then return redis.call("DEL", KEYS[1]) else return 0 end', + '1', + key, + token, + ]); + return Number(result) === 1; + } +} diff --git a/apps/api/src/modules/auction/redis/auction-redis.state.spec.ts b/apps/api/src/modules/auction/redis/auction-redis.state.spec.ts new file mode 100644 index 00000000..810b77d0 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.state.spec.ts @@ -0,0 +1,111 @@ +import { buildAuctionRedisKeys } from './auction-redis.keys'; +import { + AUCTION_HYDRATE_STATE_SCRIPT, + assembleAuctionViewFromRedisState, + buildHydrateAuctionStateScriptInvocation, + shouldHydrateRedisAuctionState, +} from './auction-redis.state'; + +describe('auction redis state assembly', () => { + it.each([ + { + expected: true, + live: null, + mongo: { auctionLifecycleId: 'life-1', revision: 1 }, + }, + { + expected: true, + live: { auctionLifecycleId: 'life-1', revision: 1 }, + mongo: { auctionLifecycleId: 'life-1', revision: 2 }, + }, + { + expected: true, + live: { auctionLifecycleId: 'old-life', revision: 2 }, + mongo: { auctionLifecycleId: 'new-life', revision: 2 }, + }, + { + expected: false, + live: { auctionLifecycleId: 'redis-life', revision: 3 }, + mongo: { auctionLifecycleId: 'mongo-life', revision: 2 }, + }, + ])('decides rehydrate need: %#', ({ live, mongo, expected }) => { + expect(shouldHydrateRedisAuctionState({ live, mongo })).toBe(expected); + }); + + it('assembles public view and maps internal expiring phase to bidding', () => { + expect( + assembleAuctionViewFromRedisState({ + auctionBidHistoryEntries: ['{"bidPointAmount":100}'], + currentServerTimestampMS: 1_000, + liveState: { + auctionLifecycleId: 'life-1', + currentBidRoundPlayerUserId: 'player-1', + phase: 'expiring', + revision: 3, + }, + shouldForceAuctionStateResync: true, + structureState: { + auctionTeams: [], + }, + }), + ).toMatchObject({ + auctionBidHistory: [{ bidPointAmount: 100 }], + auctionLifecycleId: 'life-1', + canPlaceBidInCurrentBidRound: false, + currentBidRoundPlayerUserId: 'player-1', + currentServerTimestampMS: 1000, + isAuctionStateTransitionInProgress: true, + phase: 'bidding', + revision: 3, + shouldForceAuctionStateResync: true, + }); + }); + + it('builds HYDRATE invocation and keeps CAS conditions in Lua', () => { + const invocation = buildHydrateAuctionStateScriptInvocation( + buildAuctionRedisKeys('match-1'), + { + auctionHistorySequence: 4, + auctionLifecycleId: 'life-1', + liveStatePatch: { + 'team:1:assignedAuctionTeamMemberCount': 1, + 'team:1:remainingBidPointAmount': 1000, + }, + maximumBidRoundDurationSeconds: 30, + matchId: 'match-1', + phase: 'bidding', + revision: 7, + structureStateJson: '{"auctionTeams":[]}', + }, + ); + + expect(invocation.script).toBe(AUCTION_HYDRATE_STATE_SCRIPT); + expect(invocation.keys).toEqual([ + 'auction:match-1:liveAuctionState', + 'auction:match-1:auctionStructureState', + 'auction:bidRoundDeadlineQueue', + ]); + expect(invocation.values).toEqual([ + 'match-1', + 'life-1', + '7', + 'bidding', + '4', + '30', + '{"auctionTeams":[]}', + '2', + 'team:1:assignedAuctionTeamMemberCount', + '1', + 'team:1:remainingBidPointAmount', + '1000', + ]); + expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain("redis.call('TIME')"); + expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain( + 'INVALID_PATCH_ARITY', + ); + expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain( + 'mongoRevision > redisRevision', + ); + expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain("redis.call('ZADD'"); + }); +}); diff --git a/apps/api/src/modules/auction/redis/auction-redis.state.ts b/apps/api/src/modules/auction/redis/auction-redis.state.ts new file mode 100644 index 00000000..477a7396 --- /dev/null +++ b/apps/api/src/modules/auction/redis/auction-redis.state.ts @@ -0,0 +1,188 @@ +import type { AuctionRedisKeys } from './auction-redis.keys'; +import { defineAuctionRedisScript } from './auction-redis.scripts'; + +export interface AuctionRedisRevisionIdentity { + auctionLifecycleId?: string; + revision?: number; +} + +export interface ShouldHydrateRedisAuctionStateParams { + live: AuctionRedisRevisionIdentity | null; + mongo: Required; +} + +export interface AssembleAuctionViewParams { + auctionBidHistoryEntries: string[]; + currentServerTimestampMS: number; + liveState: Record & { + auctionLifecycleId: string; + phase: string; + revision: number; + }; + shouldForceAuctionStateResync?: boolean; + structureState: Record; +} + +export interface HydrateAuctionStateScriptInput { + auctionHistorySequence: number; + auctionLifecycleId: string; + liveStatePatch?: Record; + maximumBidRoundDurationSeconds: number; + matchId: string; + phase: string; + revision: number; + structureStateJson: string; +} + +export interface HydrateAuctionStateScriptInvocation { + keys: string[]; + script: typeof AUCTION_HYDRATE_STATE_SCRIPT; + values: string[]; +} + +function stringifyRedisValue(value: string | number | boolean | null): string { + if (typeof value === 'boolean') return value ? '1' : '0'; + if (value === null) return ''; + return String(value); +} + +function flattenLiveStatePatch( + liveStatePatch: HydrateAuctionStateScriptInput['liveStatePatch'], +): string[] { + return Object.entries(liveStatePatch ?? {}) + .filter(([, value]) => value !== undefined) + .sort(([a], [b]) => a.localeCompare(b)) + .flatMap(([key, value]) => [ + key, + stringifyRedisValue(value as string | number | boolean | null), + ]); +} + +export function shouldHydrateRedisAuctionState( + params: ShouldHydrateRedisAuctionStateParams, +): boolean { + if (!params.live) return true; + const redisRevision = params.live.revision ?? -1; + const mongoRevision = params.mongo.revision; + if (mongoRevision > redisRevision) return true; + return ( + mongoRevision === redisRevision && + params.mongo.auctionLifecycleId !== params.live.auctionLifecycleId + ); +} + +export function assembleAuctionViewFromRedisState( + params: AssembleAuctionViewParams, +): Record { + const isExpiring = params.liveState.phase === 'expiring'; + return { + ...params.structureState, + ...params.liveState, + auctionBidHistory: params.auctionBidHistoryEntries.map((entry) => + JSON.parse(entry), + ), + canPlaceBidInCurrentBidRound: !isExpiring, + currentServerTimestampMS: params.currentServerTimestampMS, + isAuctionStateTransitionInProgress: isExpiring, + phase: isExpiring ? 'bidding' : params.liveState.phase, + shouldForceAuctionStateResync: + params.shouldForceAuctionStateResync || undefined, + }; +} + +export function buildHydrateAuctionStateScriptInvocation( + keys: AuctionRedisKeys, + input: HydrateAuctionStateScriptInput, +): HydrateAuctionStateScriptInvocation { + const liveStatePatchPairs = flattenLiveStatePatch(input.liveStatePatch); + return { + keys: [keys.liveStateKey, keys.structureStateKey, keys.deadlineQueueKey], + script: AUCTION_HYDRATE_STATE_SCRIPT, + values: [ + input.matchId, + input.auctionLifecycleId, + String(input.revision), + input.phase, + String(input.auctionHistorySequence), + String(input.maximumBidRoundDurationSeconds), + input.structureStateJson, + String(liveStatePatchPairs.length / 2), + ...liveStatePatchPairs, + ], + }; +} + +export const AUCTION_HYDRATE_STATE_SCRIPT = defineAuctionRedisScript( + 'auction.hydrateState', + ` +local liveAuctionStateKey = KEYS[1] +local auctionStructureStateKey = KEYS[2] +local bidRoundDeadlineQueueKey = KEYS[3] + +local matchId = ARGV[1] +local mongoAuctionLifecycleId = ARGV[2] +local mongoRevision = tonumber(ARGV[3]) +local phase = ARGV[4] +local auctionHistorySequence = ARGV[5] +local maximumBidRoundDurationSeconds = tonumber(ARGV[6]) +local structureStateJson = ARGV[7] +local liveStatePatchPairCount = tonumber(ARGV[8]) + +local redisTime = redis.call('TIME') +local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000) +local redisRevision = tonumber(redis.call('HGET', liveAuctionStateKey, 'revision') or '-1') +local redisAuctionLifecycleId = redis.call('HGET', liveAuctionStateKey, 'auctionLifecycleId') + +if not liveStatePatchPairCount or #ARGV ~= 8 + (liveStatePatchPairCount * 2) then + return {'REJECTED', 'INVALID_PATCH_ARITY', tostring(currentRedisTimestampMS)} +end + +local shouldHydrate = false +if redisRevision < 0 then + shouldHydrate = true +elseif mongoRevision > redisRevision then + shouldHydrate = true +elseif mongoRevision == redisRevision and mongoAuctionLifecycleId ~= redisAuctionLifecycleId then + shouldHydrate = true +end + +if not shouldHydrate then + return {'NOOP', tostring(redisRevision), tostring(currentRedisTimestampMS)} +end + +local hydratedRevision = mongoRevision + 1 +redis.call('SET', auctionStructureStateKey, structureStateJson) +local hsetArgs = { + liveAuctionStateKey, + 'auctionLifecycleId', + mongoAuctionLifecycleId, + 'revision', + tostring(hydratedRevision), + 'phase', + phase, + 'currentAuctionHistorySequence', + auctionHistorySequence, + 'currentHighestBidPointAmount', + '0', + 'currentHighestBidderTeamIndex', + '-1' +} +local patchIndex = 9 +for i = 1, liveStatePatchPairCount do + table.insert(hsetArgs, ARGV[patchIndex]) + table.insert(hsetArgs, ARGV[patchIndex + 1]) + patchIndex = patchIndex + 2 +end +redis.call('HSET', unpack(hsetArgs)) + +if phase == 'bidding' then + local currentBidRoundDeadlineTimestampMS = currentRedisTimestampMS + (maximumBidRoundDurationSeconds * 1000) + redis.call('HSET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS', tostring(currentBidRoundDeadlineTimestampMS)) + redis.call('ZADD', bidRoundDeadlineQueueKey, currentBidRoundDeadlineTimestampMS, matchId) +else + redis.call('ZREM', bidRoundDeadlineQueueKey, matchId) +end + +return {'OK', tostring(hydratedRevision), tostring(currentRedisTimestampMS)} +`, +); diff --git a/apps/api/src/modules/community-stats/community-stats-cache.service.ts b/apps/api/src/modules/community-stats/community-stats-cache.service.ts index 6f3c26f2..2d50765a 100644 --- a/apps/api/src/modules/community-stats/community-stats-cache.service.ts +++ b/apps/api/src/modules/community-stats/community-stats-cache.service.ts @@ -1,5 +1,5 @@ import { Injectable, Logger } from '@nestjs/common'; -import { GarnetService } from '../global/garnet/garnet.service'; +import { RedisService } from '../global/redis/redis.service'; const COMMUNITY_STATS_TTL_SECONDS = 5 * 60; const COMMUNITY_STATS_DETAIL_TTL_SECONDS = 24 * 60 * 60; @@ -8,10 +8,10 @@ const COMMUNITY_STATS_DETAIL_TTL_SECONDS = 24 * 60 * 60; export class CommunityStatsCacheService { private readonly logger = new Logger(CommunityStatsCacheService.name); - constructor(private readonly garnetService: GarnetService) {} + constructor(private readonly redisService: RedisService) {} public get(key: string): Promise { - return this.garnetService.getJson(key); + return this.redisService.getJson(key); } public set( @@ -19,7 +19,7 @@ export class CommunityStatsCacheService { value: unknown, ttlSeconds = COMMUNITY_STATS_TTL_SECONDS, ): Promise { - return this.garnetService.setJson(key, value, ttlSeconds); + return this.redisService.setJson(key, value, ttlSeconds); } public setDetail(key: string, value: unknown): Promise { @@ -29,7 +29,7 @@ export class CommunityStatsCacheService { public async invalidateCommunity(communityId: string): Promise { const prefix = `riot:communitystats:`; const match = `${prefix}*${communityId}*`; - const client = this.garnetService.raw(); + const client = this.redisService.raw(); let cursor = '0'; let deleted = 0; diff --git a/apps/api/src/modules/global/database/auction-redis-schema.spec.ts b/apps/api/src/modules/global/database/auction-redis-schema.spec.ts new file mode 100644 index 00000000..c984c8cd --- /dev/null +++ b/apps/api/src/modules/global/database/auction-redis-schema.spec.ts @@ -0,0 +1,94 @@ +import { + AuctionHistoryEntrySchema, + AuctionSchema, + AuctionSideEffectApplicationSchema, + tournamentModelDefinitions, +} from './schema'; + +function indexWithKeys( + schemaIndexes: ReturnType, + expectedKeys: Record, +) { + return schemaIndexes.find(([keys]) => { + return JSON.stringify(keys) === JSON.stringify(expectedKeys); + }); +} + +describe('auction Redis schema foundation', () => { + it('defines Redis v1 projection metadata on auction documents', () => { + expect(AuctionSchema.path('revision')).toBeDefined(); + expect(AuctionSchema.path('auctionEngineVersion')).toBeDefined(); + expect(AuctionSchema.path('auctionLifecycleId')).toBeDefined(); + expect(AuctionSchema.path('lastAppliedAuctionStateTransitionId')).toBeDefined(); + expect(AuctionSchema.path('currentAuctionHistorySequence')).toBeDefined(); + expect(AuctionSchema.path('startAuctionRequestId')).toBeDefined(); + expect(AuctionSchema.path('startAuctionStateTransitionId')).toBeDefined(); + expect(AuctionSchema.path('matchSideEffectStatus')).toBeDefined(); + expect(AuctionSchema.path('matchSideEffectRevision')).toBeDefined(); + }); + + it('defines the new auction state field names for migration targets', () => { + expect(AuctionSchema.path('auctionTeams')).toBeDefined(); + expect(AuctionSchema.path('auctionPlayerOrder')).toBeDefined(); + expect(AuctionSchema.path('passedAuctionPlayerQueue')).toBeDefined(); + expect(AuctionSchema.path('currentAuctionRound')).toBeDefined(); + expect(AuctionSchema.path('currentAuctionPlayerOrderIndex')).toBeDefined(); + expect(AuctionSchema.path('auctionBidHistory')).toBeDefined(); + expect(AuctionSchema.path('currentHighestBidPointAmount')).toBeDefined(); + expect(AuctionSchema.path('currentHighestBidderTeamIndex')).toBeDefined(); + expect(AuctionSchema.path('currentBidRoundDeadlineTimestampMS')).toBeDefined(); + expect(AuctionSchema.path('maximumBidRoundDurationSeconds')).toBeDefined(); + expect(AuctionSchema.path('bidRoundExtensionSeconds')).toBeDefined(); + expect(AuctionSchema.path('initialTeamBidPointAmount')).toBeDefined(); + expect(AuctionSchema.path('topTierAuctionPriorityThreshold')).toBeDefined(); + expect(AuctionSchema.path('manualTopTierAuctionPriorityUserIds')).toBeDefined(); + expect(AuctionSchema.path('auctionStartedAtTimestampMS')).toBeDefined(); + expect(AuctionSchema.path('auctionCompletedAtTimestampMS')).toBeDefined(); + }); + + it('adds history transition fields and reset/undo action enum values', () => { + expect(AuctionHistoryEntrySchema.path('auctionStateTransitionId')).toBeDefined(); + expect(AuctionHistoryEntrySchema.path('auctionLifecycleId')).toBeDefined(); + expect(AuctionHistoryEntrySchema.path('revision')).toBeDefined(); + expect(AuctionHistoryEntrySchema.path('historyMutation')).toBeDefined(); + expect(AuctionHistoryEntrySchema.path('matchSideEffectMutation')).toBeDefined(); + expect( + AuctionHistoryEntrySchema.path('action').options.enum, + ).toEqual( + expect.arrayContaining(['start', 'open-bidding', 'bid', 'sold', 'passed', 'next', 'complete', 'reset', 'undo']), + ); + }); + + it('adds unique history indexes for sequence and transition idempotency', () => { + const indexes = AuctionHistoryEntrySchema.indexes(); + + expect(indexWithKeys(indexes, { auctionId: 1, sequence: 1 })?.[1]).toMatchObject({ + unique: true, + }); + expect( + indexWithKeys(indexes, { auctionId: 1, auctionStateTransitionId: 1 })?.[1], + ).toMatchObject({ unique: true, sparse: true }); + }); + + it('registers auction side effect application model with lease fields and unique idempotency index', () => { + expect(AuctionSideEffectApplicationSchema.path('processingOwnerToken')).toBeDefined(); + expect( + AuctionSideEffectApplicationSchema.path('processingLeaseExpiresAtTimestampMS'), + ).toBeDefined(); + expect(AuctionSideEffectApplicationSchema.path('payloadChecksum')).toBeDefined(); + + const indexes = AuctionSideEffectApplicationSchema.indexes(); + expect( + indexWithKeys(indexes, { + auctionId: 1, + auctionStateTransitionId: 1, + sideEffectType: 1, + })?.[1], + ).toMatchObject({ unique: true }); + expect( + tournamentModelDefinitions.some( + (definition) => definition.name === 'auctionSideEffectApplication', + ), + ).toBe(true); + }); +}); diff --git a/apps/api/src/modules/global/database/connection.service.ts b/apps/api/src/modules/global/database/connection.service.ts index 6d46b340..413e6568 100644 --- a/apps/api/src/modules/global/database/connection.service.ts +++ b/apps/api/src/modules/global/database/connection.service.ts @@ -95,6 +95,6 @@ export class ConnectionService implements OnModuleInit { } public async onModuleDestroy() { - this.connection?.close(); + await this.connection?.close(); } } diff --git a/apps/api/src/modules/global/database/migrations/20260622-auction-redis-field-rename.spec.ts b/apps/api/src/modules/global/database/migrations/20260622-auction-redis-field-rename.spec.ts new file mode 100644 index 00000000..7d4e92dc --- /dev/null +++ b/apps/api/src/modules/global/database/migrations/20260622-auction-redis-field-rename.spec.ts @@ -0,0 +1,219 @@ +import { migrateAuctionRedisFieldRename } from './20260622-auction-redis-field-rename'; + +type Doc = Record & { _id: string }; + +function createDb(params: { auctions?: Doc[]; history?: Doc[] }) { + const collections = { + auction: params.auctions ?? [], + auctionHistory: params.history ?? [], + }; + + return { + collections, + db: { + collection(name: string) { + const docs = + name === 'auction' + ? collections.auction + : name === 'auctionHistory' + ? collections.auctionHistory + : []; + return { + find() { + return { + limit() { + return { + async *[Symbol.asyncIterator]() { + for (const doc of docs) yield doc; + }, + }; + }, + }; + }, + async bulkWrite(writes: Array<{ + updateOne: { + filter: { _id: unknown }; + update: { + $set?: Record; + $unset?: Record; + }; + }; + }>) { + for (const write of writes) { + const doc = docs.find((item) => item._id === write.updateOne.filter._id); + if (!doc) continue; + Object.assign(doc, write.updateOne.update.$set ?? {}); + for (const key of Object.keys(write.updateOne.update.$unset ?? {})) { + delete doc[key]; + } + } + }, + }; + }, + }, + }; +} + +describe('migrateAuctionRedisFieldRename', () => { + it('renames auction fields and nested bid/team fields', async () => { + const deadline = new Date('2026-06-22T01:02:03.004Z'); + const { db, collections } = createDb({ + auctions: [ + { + _id: 'auction-1', + teams: [ + { + teamIndex: 1, + captainUserId: 'u1', + points: 900, + members: [{ userId: 'u1', assignedPosition: 'TOP', cost: 100 }], + }, + ], + order: [{ userId: 'p1', passCount: 0 }], + passedQueue: [{ userId: 'p2', passCount: 1 }], + auctionRound: 2, + currentIndex: 3, + bids: [ + { + teamIndex: 1, + amount: 120, + bidderUserId: 'u1', + timestamp: deadline, + }, + ], + currentBid: 120, + currentBidderTeamIndex: 1, + currentDeadline: deadline, + maxTimerSeconds: 30, + bidExtensionSeconds: 5, + initialPoints: 1000, + topTierThreshold: 'DIAMOND', + manualTopTierUserIds: ['u2'], + startedAt: deadline, + completedAt: deadline, + }, + ], + }); + + const dryRunStats = await migrateAuctionRedisFieldRename(db, { + dryRun: true, + }); + expect(dryRunStats.changedAuctions).toBe(1); + expect(collections.auction[0]).toHaveProperty('teams'); + + const stats = await migrateAuctionRedisFieldRename(db, { dryRun: false }); + + expect(stats.changedAuctions).toBe(1); + expect(collections.auction[0]).toMatchObject({ + auctionEngineVersion: 'legacy-renamed', + auctionLifecycleId: 'legacy-auction:auction-1', + revision: 0, + currentAuctionHistorySequence: 0, + matchSideEffectStatus: 'none', + matchSideEffectRevision: 0, + auctionTeams: [ + { + teamIndex: 1, + captainUserId: 'u1', + remainingBidPointAmount: 900, + members: [ + { + userId: 'u1', + assignedPosition: 'TOP', + memberAcquisitionBidPointAmount: 100, + }, + ], + }, + ], + auctionPlayerOrder: [{ userId: 'p1', passCount: 0 }], + passedAuctionPlayerQueue: [{ userId: 'p2', passCount: 1 }], + currentAuctionRound: 2, + currentAuctionPlayerOrderIndex: 3, + auctionBidHistory: [ + { + bidderTeamIndex: 1, + bidPointAmount: 120, + bidderUserId: 'u1', + bidPlacedAtTimestampMS: deadline.getTime(), + }, + ], + currentHighestBidPointAmount: 120, + currentHighestBidderTeamIndex: 1, + currentBidRoundDeadlineTimestampMS: deadline.getTime(), + maximumBidRoundDurationSeconds: 30, + bidRoundExtensionSeconds: 5, + initialTeamBidPointAmount: 1000, + topTierAuctionPriorityThreshold: 'DIAMOND', + manualTopTierAuctionPriorityUserIds: ['u2'], + auctionStartedAtTimestampMS: deadline.getTime(), + auctionCompletedAtTimestampMS: deadline.getTime(), + }); + expect(collections.auction[0]).not.toHaveProperty('teams'); + expect(collections.auction[0]).not.toHaveProperty('bids'); + expect(collections.auction[0]).not.toHaveProperty('currentDeadline'); + }); + + it('renames history snapshots and adds transition metadata', async () => { + const { db, collections } = createDb({ + history: [ + { + _id: 'history-1', + auctionId: 'auction-1', + matchId: 'match-1', + sequence: 2, + action: 'sold', + snapshotBefore: { + currentBid: 100, + bids: [{ teamIndex: 1, amount: 100, timestamp: 123 }], + }, + }, + ], + }); + + await migrateAuctionRedisFieldRename(db, { dryRun: false }); + + expect(collections.auctionHistory[0]).toMatchObject({ + auctionLifecycleId: 'legacy-auction:auction-1', + auctionStateTransitionId: 'legacy-history:auction-1:2', + revision: 2, + historyMutation: { type: 'append' }, + matchSideEffectMutation: { type: 'none' }, + snapshotBefore: { + currentHighestBidPointAmount: 100, + auctionBidHistory: [ + { + bidderTeamIndex: 1, + bidPointAmount: 100, + bidPlacedAtTimestampMS: 123, + }, + ], + }, + }); + }); + + it('is idempotent after applying updates', async () => { + const { db } = createDb({ + auctions: [{ _id: 'auction-1', teams: [] }], + history: [{ _id: 'history-1', auctionId: 'auction-1', sequence: 1 }], + }); + + await migrateAuctionRedisFieldRename(db, { dryRun: false }); + const stats = await migrateAuctionRedisFieldRename(db, { dryRun: false }); + + expect(stats.changedAuctions).toBe(0); + expect(stats.changedHistoryEntries).toBe(0); + }); + + it('fails apply when duplicate history sequences would break unique indexes', async () => { + const { db } = createDb({ + history: [ + { _id: 'h1', auctionId: 'auction-1', sequence: 1 }, + { _id: 'h2', auctionId: 'auction-1', sequence: 1 }, + ], + }); + + await expect( + migrateAuctionRedisFieldRename(db, { dryRun: false }), + ).rejects.toThrow('Duplicate auctionHistory sequence'); + }); +}); diff --git a/apps/api/src/modules/global/database/migrations/20260622-auction-redis-field-rename.ts b/apps/api/src/modules/global/database/migrations/20260622-auction-redis-field-rename.ts new file mode 100644 index 00000000..a1a0d67c --- /dev/null +++ b/apps/api/src/modules/global/database/migrations/20260622-auction-redis-field-rename.ts @@ -0,0 +1,336 @@ +interface MigrationCollection { + find(filter: Record): { + limit(limit: number): AsyncIterable; + }; + bulkWrite( + writes: Array<{ + updateOne: { + filter: { _id: unknown }; + update: { $set?: Record; $unset?: Record }; + }; + }>, + options: { ordered: boolean }, + ): Promise; +} + +interface MigrationDb { + collection(name: string): MigrationCollection; +} + +interface MigrationOptions { + dryRun?: boolean; + limit?: number; +} + +interface MigrationStats { + changedAuctions: number; + changedHistoryEntries: number; + duplicateHistorySequences: number; + scannedAuctions: number; + scannedHistoryEntries: number; +} + +type AnyDoc = Record & { _id: unknown }; +type UpdateDoc = { $set?: Record; $unset?: Record }; + +const AUCTION_FIELD_RENAMES: Array<{ + from: string; + to: string; + transform?: (value: unknown) => unknown; +}> = [ + { from: 'teams', to: 'auctionTeams', transform: transformAuctionTeams }, + { from: 'order', to: 'auctionPlayerOrder' }, + { from: 'passedQueue', to: 'passedAuctionPlayerQueue' }, + { from: 'auctionRound', to: 'currentAuctionRound' }, + { from: 'currentIndex', to: 'currentAuctionPlayerOrderIndex' }, + { from: 'bids', to: 'auctionBidHistory', transform: transformAuctionBidHistory }, + { from: 'currentBid', to: 'currentHighestBidPointAmount' }, + { from: 'currentBidderTeamIndex', to: 'currentHighestBidderTeamIndex' }, + { + from: 'currentDeadline', + to: 'currentBidRoundDeadlineTimestampMS', + transform: toTimestampMS, + }, + { from: 'maxTimerSeconds', to: 'maximumBidRoundDurationSeconds' }, + { from: 'bidExtensionSeconds', to: 'bidRoundExtensionSeconds' }, + { from: 'initialPoints', to: 'initialTeamBidPointAmount' }, + { from: 'topTierThreshold', to: 'topTierAuctionPriorityThreshold' }, + { + from: 'manualTopTierUserIds', + to: 'manualTopTierAuctionPriorityUserIds', + }, + { + from: 'startedAt', + to: 'auctionStartedAtTimestampMS', + transform: toTimestampMS, + }, + { + from: 'completedAt', + to: 'auctionCompletedAtTimestampMS', + transform: toTimestampMS, + }, +]; + +export async function migrateAuctionRedisFieldRename( + db: MigrationDb, + options: MigrationOptions = {}, +): Promise { + const dryRun = options.dryRun ?? true; + const stats: MigrationStats = { + changedAuctions: 0, + changedHistoryEntries: 0, + duplicateHistorySequences: 0, + scannedAuctions: 0, + scannedHistoryEntries: 0, + }; + + stats.duplicateHistorySequences = await countDuplicateHistorySequences( + db.collection('auctionHistory'), + options.limit, + ); + if (!dryRun && stats.duplicateHistorySequences > 0) { + throw new Error( + `Duplicate auctionHistory sequence entries found: ${stats.duplicateHistorySequences}`, + ); + } + + await migrateCollection( + db.collection('auction'), + options.limit, + dryRun, + stats, + 'auction', + ); + await migrateCollection( + db.collection('auctionHistory'), + options.limit, + dryRun, + stats, + 'auctionHistory', + ); + + return stats; +} + +async function migrateCollection( + collection: MigrationCollection, + limit: number | undefined, + dryRun: boolean, + stats: MigrationStats, + kind: 'auction' | 'auctionHistory', +) { + const writes: Array<{ + updateOne: { + filter: { _id: unknown }; + update: UpdateDoc; + }; + }> = []; + + for await (const doc of collection.find({}).limit(limit ?? 0)) { + if (kind === 'auction') stats.scannedAuctions += 1; + if (kind === 'auctionHistory') stats.scannedHistoryEntries += 1; + + const update = + kind === 'auction' ? migrateAuctionDoc(doc) : migrateHistoryDoc(doc); + if (!update) continue; + + if (kind === 'auction') stats.changedAuctions += 1; + if (kind === 'auctionHistory') stats.changedHistoryEntries += 1; + writes.push({ + updateOne: { + filter: { _id: doc._id }, + update, + }, + }); + } + + if (!dryRun && writes.length > 0) { + await collection.bulkWrite(writes, { ordered: false }); + } +} + +async function countDuplicateHistorySequences( + collection: MigrationCollection, + limit: number | undefined, +): Promise { + const seen = new Set(); + const duplicates = new Set(); + for await (const doc of collection.find({}).limit(limit ?? 0)) { + const auctionId = stringifyId(doc.auctionId); + const sequence = typeof doc.sequence === 'number' ? doc.sequence : undefined; + if (!auctionId || sequence === undefined) continue; + + const key = `${auctionId}:${sequence}`; + if (seen.has(key)) duplicates.add(key); + seen.add(key); + } + return duplicates.size; +} + +function migrateAuctionDoc(doc: AnyDoc): UpdateDoc | null { + const set: Record = {}; + const unset: Record = {}; + + for (const rename of AUCTION_FIELD_RENAMES) { + renameField(doc, rename.from, rename.to, set, unset, rename.transform); + } + + setDefault(doc, set, 'revision', 0); + setDefault(doc, set, 'currentAuctionHistorySequence', 0); + setDefault(doc, set, 'auctionEngineVersion', 'legacy-renamed'); + setDefault(doc, set, 'auctionLifecycleId', legacyAuctionLifecycleId(doc._id)); + setDefault(doc, set, 'matchSideEffectStatus', 'none'); + setDefault(doc, set, 'matchSideEffectRevision', 0); + + return buildUpdate(set, unset); +} + +function migrateHistoryDoc(doc: AnyDoc): UpdateDoc | null { + const set: Record = {}; + const unset: Record = {}; + const auctionId = stringifyId(doc.auctionId); + const sequence = typeof doc.sequence === 'number' ? doc.sequence : 0; + + setDefault( + doc, + set, + 'auctionLifecycleId', + auctionId ? legacyAuctionLifecycleId(auctionId) : undefined, + ); + setDefault( + doc, + set, + 'auctionStateTransitionId', + auctionId ? `legacy-history:${auctionId}:${sequence}` : undefined, + ); + setDefault(doc, set, 'revision', sequence); + setDefault(doc, set, 'historyMutation', { type: 'append' }); + setDefault(doc, set, 'matchSideEffectMutation', { type: 'none' }); + + const snapshotBefore = isRecord(doc.snapshotBefore) + ? migrateAuctionSnapshot(doc.snapshotBefore) + : undefined; + if (snapshotBefore?.changed) { + set.snapshotBefore = snapshotBefore.value; + } + + return buildUpdate(set, unset); +} + +function migrateAuctionSnapshot(snapshot: Record): { + changed: boolean; + value: Record; +} { + const value = { ...snapshot }; + let changed = false; + for (const rename of AUCTION_FIELD_RENAMES) { + if (!(rename.from in value)) continue; + if (!(rename.to in value)) { + value[rename.to] = rename.transform + ? rename.transform(value[rename.from]) + : value[rename.from]; + } + delete value[rename.from]; + changed = true; + } + return { changed, value }; +} + +function renameField( + doc: Record, + from: string, + to: string, + set: Record, + unset: Record, + transform?: (value: unknown) => unknown, +) { + if (!(from in doc)) return; + if (!(to in doc)) { + set[to] = transform ? transform(doc[from]) : doc[from]; + } + unset[from] = ''; +} + +function setDefault( + doc: Record, + set: Record, + key: string, + value: unknown, +) { + if (value === undefined || key in doc || key in set) return; + set[key] = value; +} + +function buildUpdate( + set: Record, + unset: Record, +): UpdateDoc | null { + const update: UpdateDoc = {}; + if (Object.keys(set).length > 0) update.$set = set; + if (Object.keys(unset).length > 0) update.$unset = unset; + return update.$set || update.$unset ? update : null; +} + +function transformAuctionTeams(value: unknown): unknown[] { + return asArray(value).map((team) => { + const next = { ...team }; + if ('points' in next && !('remainingBidPointAmount' in next)) { + next.remainingBidPointAmount = next.points; + } + delete next.points; + next.members = asArray(next.members).map((member) => { + const migratedMember = { ...member }; + if ( + 'cost' in migratedMember && + !('memberAcquisitionBidPointAmount' in migratedMember) + ) { + migratedMember.memberAcquisitionBidPointAmount = migratedMember.cost; + } + delete migratedMember.cost; + return migratedMember; + }); + return next; + }); +} + +function transformAuctionBidHistory(value: unknown): unknown[] { + return asArray(value).map((bid) => { + const next: Record = {}; + if ('teamIndex' in bid) next.bidderTeamIndex = bid.teamIndex; + if ('amount' in bid) next.bidPointAmount = bid.amount; + if ('bidderUserId' in bid) next.bidderUserId = bid.bidderUserId; + if ('timestamp' in bid) { + next.bidPlacedAtTimestampMS = toTimestampMS(bid.timestamp); + } + return next; + }); +} + +function toTimestampMS(value: unknown): unknown { + if (value instanceof Date) return value.getTime(); + if (typeof value === 'number') return value; + if (typeof value === 'string') { + const parsed = Date.parse(value); + return Number.isNaN(parsed) ? value : parsed; + } + return value; +} + +function legacyAuctionLifecycleId(value: unknown): string { + return `legacy-auction:${stringifyId(value) ?? 'unknown'}`; +} + +function stringifyId(value: unknown): string | undefined { + if (value === undefined || value === null) return undefined; + return typeof value === 'string' ? value : String(value); +} + +function asArray(value: unknown): Record[] { + return Array.isArray(value) + ? value.filter(isRecord).map((item) => ({ ...item })) + : []; +} + +function isRecord(value: unknown): value is Record { + return Boolean(value && typeof value === 'object' && !Array.isArray(value)); +} diff --git a/apps/api/src/modules/global/database/migrations/run-auction-redis-field-rename.ts b/apps/api/src/modules/global/database/migrations/run-auction-redis-field-rename.ts new file mode 100644 index 00000000..afba5e10 --- /dev/null +++ b/apps/api/src/modules/global/database/migrations/run-auction-redis-field-rename.ts @@ -0,0 +1,363 @@ +import 'reflect-metadata'; +import { Module } from '@nestjs/common'; +import { ConfigModule } from '@nestjs/config'; +import { NestFactory } from '@nestjs/core'; +import mongoose from 'mongoose'; +import { readFile } from 'node:fs/promises'; +import { resolve } from 'node:path'; +import { ConnectionService, resolveMongoDbName } from '../connection.service'; +import { SecretModule } from '../../secret/secret.module'; +import { migrateAuctionRedisFieldRename } from './20260622-auction-redis-field-rename'; + +interface CliOptions { + duplicateSampleLimit: number; + dryRun: boolean; + limit?: number; + listDuplicates: boolean; + nodeEnv: string; + repairDuplicateSequences: boolean; +} + +interface DuplicateSequenceRepairStats { + affectedAuctions: number; + changedAuctionSequenceFields: number; + changedHistoryEntries: number; + scannedHistoryEntries: number; +} + +@Module({ + imports: [ + ConfigModule.forRoot({ + isGlobal: true, + envFilePath: [ + resolve(__dirname, '../../../../../../project.env'), + resolve(process.cwd(), '../project.env'), + resolve(process.cwd(), 'apps/project.env'), + resolve(process.cwd(), 'project.env'), + ], + }), + SecretModule, + ], + providers: [ConnectionService], +}) +class MigrationModule {} + +async function loadMachineEnvFile() { + const homeDir = process.env.HOME ?? process.env.USERPROFILE; + if (!homeDir) return; + + const machineEnvFile = resolve(homeDir, 'source/global-env-vars.txt'); + + try { + const file = await readFile(machineEnvFile, 'utf8'); + for (const rawLine of file.split(/\r?\n/)) { + const line = rawLine.trim(); + if (!line || line.startsWith('#')) continue; + + const matched = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/); + if (!matched) continue; + + const [, key, rawValue] = matched; + process.env[key] = rawValue.replace(/^["']|["']$/g, ''); + } + } catch { + // 로컬 machine env 파일이 없으면 그냥 지나간다. + } +} + +function parseArgs(argv: string[]): CliOptions { + let dryRun = true; + let duplicateSampleLimit = 20; + let limit: number | undefined; + let listDuplicates = false; + let nodeEnv = process.env.NODE_ENV ?? 'dev'; + let repairDuplicateSequences = false; + + for (let index = 0; index < argv.length; index += 1) { + const arg = argv[index]; + if (arg === '--apply') { + dryRun = false; + continue; + } + if (arg === '--dry-run') { + dryRun = true; + continue; + } + if (arg === '--list-duplicates') { + listDuplicates = true; + continue; + } + if (arg === '--repair-duplicate-sequences') { + repairDuplicateSequences = true; + continue; + } + if (arg === '--duplicate-sample-limit') { + duplicateSampleLimit = parsePositiveInteger( + argv[index + 1], + '--duplicate-sample-limit', + ); + index += 1; + continue; + } + if (arg.startsWith('--duplicate-sample-limit=')) { + duplicateSampleLimit = parsePositiveInteger( + arg.slice('--duplicate-sample-limit='.length), + '--duplicate-sample-limit', + ); + continue; + } + if (arg === '--env') { + const value = argv[index + 1]; + if (!value) throw new Error('--env requires dev, staging, or prod.'); + nodeEnv = value; + index += 1; + continue; + } + if (arg.startsWith('--env=')) { + nodeEnv = arg.slice('--env='.length); + continue; + } + if (arg === '--limit') { + limit = parsePositiveInteger(argv[index + 1], '--limit'); + index += 1; + continue; + } + if (arg.startsWith('--limit=')) { + limit = parsePositiveInteger(arg.slice('--limit='.length), '--limit'); + continue; + } + if (arg === '--help' || arg === '-h') { + printHelp(); + process.exit(0); + } + throw new Error(`Unknown argument: ${arg}`); + } + + if (!['dev', 'staging', 'prod'].includes(nodeEnv)) { + throw new Error('--env must be dev, staging, or prod.'); + } + + return { + duplicateSampleLimit, + dryRun, + limit, + listDuplicates, + nodeEnv, + repairDuplicateSequences, + }; +} + +function parsePositiveInteger(value: string | undefined, label: string) { + const parsed = Number(value); + if (!Number.isInteger(parsed) || parsed < 1) { + throw new Error(`${label} requires a positive integer.`); + } + return parsed; +} + +function printHelp() { + console.log(`Usage: + pnpm --filter api exec ts-node src/modules/global/database/migrations/run-auction-redis-field-rename.ts [--dry-run] + pnpm --filter api exec ts-node src/modules/global/database/migrations/run-auction-redis-field-rename.ts --env staging --apply + +Options: + --dry-run Print affected counts without writing. Default. + --apply Apply auction and auctionHistory field updates. + --env dev | staging | prod. Default: NODE_ENV or dev. + --limit Only scan first n documents per collection. + --list-duplicates + Print duplicate auctionHistory auctionId+sequence samples. + --duplicate-sample-limit + Max duplicate groups to print. Default: 20. + --repair-duplicate-sequences + Resequence affected auctionHistory rows by takenAt/createdAt/_id before migration. +`); +} + +async function findAuctionIdsWithDuplicateHistorySequences( + db: NonNullable, +): Promise { + const groups = await db + .collection('auctionHistory') + .aggregate([ + { + $group: { + _id: { auctionId: '$auctionId', sequence: '$sequence' }, + count: { $sum: 1 }, + }, + }, + { $match: { count: { $gt: 1 } } }, + { $group: { _id: '$_id.auctionId' } }, + ]) + .toArray(); + + return groups.map((group) => group._id).filter(Boolean); +} + +async function listDuplicateHistorySequences( + db: NonNullable, + sampleLimit: number, +) { + return db + .collection('auctionHistory') + .aggregate([ + { + $group: { + _id: { auctionId: '$auctionId', sequence: '$sequence' }, + actions: { $push: '$action' }, + count: { $sum: 1 }, + createdAtValues: { $push: '$createdAt' }, + historyIds: { $push: '$_id' }, + matchIds: { $addToSet: '$matchId' }, + takenAtValues: { $push: '$takenAt' }, + }, + }, + { $match: { count: { $gt: 1 } } }, + { $sort: { count: -1, '_id.sequence': 1 } }, + { $limit: sampleLimit }, + ]) + .toArray(); +} + +function printDuplicateHistorySequences(groups: Awaited< + ReturnType +>) { + if (groups.length === 0) { + console.log('No duplicate auctionHistory auctionId+sequence groups found.'); + return; + } + + console.log('Duplicate auctionHistory auctionId+sequence groups:'); + console.table( + groups.map((group) => ({ + actions: (group.actions as unknown[]).map(String).join(', '), + auctionId: String(group._id?.auctionId ?? ''), + count: group.count, + createdAt: (group.createdAtValues as unknown[]).map(String).join(', '), + historyIds: (group.historyIds as unknown[]).map(String).join(', '), + matchIds: (group.matchIds as unknown[]).map(String).join(', '), + sequence: group._id?.sequence, + takenAt: (group.takenAtValues as unknown[]).map(String).join(', '), + })), + ); +} + +async function repairDuplicateHistorySequences( + db: NonNullable, + dryRun: boolean, +): Promise { + const historyCollection = db.collection('auctionHistory'); + const auctionCollection = db.collection('auction'); + const affectedAuctionIds = await findAuctionIdsWithDuplicateHistorySequences(db); + const stats: DuplicateSequenceRepairStats = { + affectedAuctions: affectedAuctionIds.length, + changedAuctionSequenceFields: 0, + changedHistoryEntries: 0, + scannedHistoryEntries: 0, + }; + + for (const auctionId of affectedAuctionIds) { + const histories = await historyCollection + .find({ auctionId }) + .project({ _id: 1, createdAt: 1, sequence: 1, takenAt: 1 }) + .sort({ takenAt: 1, createdAt: 1, _id: 1 }) + .toArray(); + stats.scannedHistoryEntries += histories.length; + + const writes = histories + .map((history, index) => ({ + history, + nextSequence: index + 1, + })) + .filter(({ history, nextSequence }) => history.sequence !== nextSequence); + + stats.changedHistoryEntries += writes.length; + stats.changedAuctionSequenceFields += 1; + + if (dryRun) continue; + if (writes.length > 0) { + await historyCollection.bulkWrite( + writes.map(({ history, nextSequence }) => ({ + updateOne: { + filter: { _id: history._id }, + update: { $set: { sequence: nextSequence } }, + }, + })), + { ordered: true }, + ); + } + await auctionCollection.updateOne( + { _id: auctionId } as Record, + { $set: { currentAuctionHistorySequence: histories.length } }, + ); + } + + return stats; +} + +async function main() { + const options = parseArgs(process.argv.slice(2)); + process.env.NODE_ENV = options.nodeEnv; + process.env.SECRET_SOURCE = process.env.SECRET_SOURCE || 'infisical'; + await loadMachineEnvFile(); + + const app = await NestFactory.createApplicationContext(MigrationModule, { + logger: ['log', 'warn', 'error'], + }); + + try { + const connectionService = app.get(ConnectionService); + const connection = await connectionService.getConnection(); + if (!connection.db) { + throw new Error('MongoDB connection has no db handle.'); + } + + const dbName = resolveMongoDbName(options.nodeEnv); + console.log( + `[auction redis field rename migration] mode=${ + options.dryRun ? 'dry-run' : 'apply' + } env=${options.nodeEnv} db=${dbName}`, + ); + + if (options.repairDuplicateSequences) { + const repairStats = await repairDuplicateHistorySequences( + connection.db, + options.dryRun, + ); + console.log('Duplicate auctionHistory sequence repair:'); + console.table(repairStats); + } + + const stats = await migrateAuctionRedisFieldRename( + connection.db as Parameters[0], + { + dryRun: options.dryRun, + limit: options.limit, + }, + ); + + console.table(stats); + if (options.listDuplicates && stats.duplicateHistorySequences > 0) { + const duplicateGroups = await listDuplicateHistorySequences( + connection.db, + options.duplicateSampleLimit, + ); + printDuplicateHistorySequences(duplicateGroups); + } + if (options.dryRun) { + console.log( + 'No writes were made. Re-run with --apply to update documents.', + ); + } else { + console.log('Migration applied.'); + } + } finally { + await app.close(); + await mongoose.disconnect(); + } +} + +void main().catch((error: unknown) => { + console.error(error instanceof Error ? error.message : error); + process.exitCode = 1; +}); diff --git a/apps/api/src/modules/global/database/schema.ts b/apps/api/src/modules/global/database/schema.ts index 410ec9a2..541cf813 100644 --- a/apps/api/src/modules/global/database/schema.ts +++ b/apps/api/src/modules/global/database/schema.ts @@ -153,14 +153,42 @@ export const AUCTION_TOP_TIER_THRESHOLDS = [ ] as const; export type AuctionTopTierThreshold = (typeof AUCTION_TOP_TIER_THRESHOLDS)[number]; -export type AuctionActionType = - | 'start' - | 'open-bidding' - | 'bid' - | 'sold' - | 'passed' - | 'next' - | 'complete'; +export const AUCTION_ACTION_TYPES = [ + 'start', + 'open-bidding', + 'bid', + 'sold', + 'passed', + 'next', + 'complete', + 'reset', + 'undo', +] as const; +export type AuctionActionType = (typeof AUCTION_ACTION_TYPES)[number]; +export const AUCTION_ENGINE_VERSIONS = ['redis-v1', 'legacy-renamed'] as const; +export type AuctionEngineVersion = (typeof AUCTION_ENGINE_VERSIONS)[number]; +export const AUCTION_MATCH_SIDE_EFFECT_STATUSES = [ + 'none', + 'pending', + 'processing', + 'completed', + 'failed', +] as const; +export type AuctionMatchSideEffectStatus = + (typeof AUCTION_MATCH_SIDE_EFFECT_STATUSES)[number]; +export const AUCTION_SIDE_EFFECT_APPLICATION_STATES = [ + 'pending', + 'processing', + 'completed', + 'failed', +] as const; +export type AuctionSideEffectApplicationState = + (typeof AUCTION_SIDE_EFFECT_APPLICATION_STATES)[number]; + +export type AuctionHistoryMutation = + | { type: 'append' } + | { targetHistorySequence: number; type: 'deleteAfterSequenceAndAppendUndo' } + | { resetMode: 'clear-history' | 'preserve-audit'; type: 'reset' }; export interface MongooseTimestamps { createdAt: Date; @@ -616,6 +644,20 @@ export interface AuctionTeam { members: AuctionTeamMember[]; } +export interface RedisAuctionTeamMember { + userId: mongoose.Types.ObjectId; + assignedPosition: Position; + memberAcquisitionBidPointAmount: number; +} + +export interface RedisAuctionTeam { + teamIndex: number; + name?: string; + captainUserId: mongoose.Types.ObjectId; + remainingBidPointAmount: number; + members: RedisAuctionTeamMember[]; +} + export interface AuctionBid { teamIndex: number; amount: number; @@ -623,6 +665,13 @@ export interface AuctionBid { timestamp: Date; } +export interface AuctionBidHistoryEntry { + bidderTeamIndex: number; + bidPointAmount: number; + bidderUserId: mongoose.Types.ObjectId; + bidPlacedAtTimestampMS: number; +} + export interface AuctionChatMessage { id: string; userId?: mongoose.Types.ObjectId; @@ -634,6 +683,17 @@ export interface AuctionChatMessage { export interface Auction extends MongooseTimestamps { matchId: mongoose.Types.ObjectId; phase: AuctionPhase; + revision: number; + auctionEngineVersion?: AuctionEngineVersion; + auctionLifecycleId?: string; + lastAppliedAuctionStateTransitionId?: string; + currentAuctionHistorySequence: number; + startAuctionRequestId?: string; + startAuctionStateTransitionId?: string; + auctionStartedByUserId?: mongoose.Types.ObjectId; + matchSideEffectStatus: AuctionMatchSideEffectStatus; + matchSideEffectRevision: number; + matchSideEffectError?: string; teams: AuctionTeam[]; order: AuctionPlayerSnapshot[]; passedQueue: AuctionPlayerSnapshot[]; @@ -651,6 +711,22 @@ export interface Auction extends MongooseTimestamps { chatMessages: AuctionChatMessage[]; startedAt?: Date; completedAt?: Date; + auctionTeams?: RedisAuctionTeam[]; + auctionPlayerOrder?: AuctionPlayerSnapshot[]; + passedAuctionPlayerQueue?: AuctionPlayerSnapshot[]; + currentAuctionRound?: number; + currentAuctionPlayerOrderIndex?: number; + auctionBidHistory?: AuctionBidHistoryEntry[]; + currentHighestBidPointAmount?: number; + currentHighestBidderTeamIndex?: number; + currentBidRoundDeadlineTimestampMS?: number; + maximumBidRoundDurationSeconds?: number; + bidRoundExtensionSeconds?: number; + initialTeamBidPointAmount?: number; + topTierAuctionPriorityThreshold?: AuctionTopTierThreshold; + manualTopTierAuctionPriorityUserIds?: mongoose.Types.ObjectId[]; + auctionStartedAtTimestampMS?: number; + auctionCompletedAtTimestampMS?: number; } export type AuctionDocument = HydratedDocument; @@ -660,13 +736,38 @@ export interface AuctionHistoryEntry extends MongooseTimestamps { matchId: mongoose.Types.ObjectId; sequence: number; action: AuctionActionType; + auctionStateTransitionId?: string; + auctionLifecycleId?: string; + revision?: number; actorUserId?: mongoose.Types.ObjectId; snapshotBefore: Record; + historyMutation?: AuctionHistoryMutation; + matchSideEffectMutation?: Record; takenAt: Date; } export type AuctionHistoryEntryDocument = HydratedDocument; +export interface AuctionSideEffectApplication extends MongooseTimestamps { + auctionId: mongoose.Types.ObjectId; + matchId: mongoose.Types.ObjectId; + auctionStateTransitionId: string; + auctionLifecycleId: string; + sideEffectType: string; + state: AuctionSideEffectApplicationState; + payload: Record; + payloadChecksum: string; + attempts: number; + processingStartedAtTimestampMS?: number; + processingLeaseExpiresAtTimestampMS?: number; + processingOwnerToken?: string; + completedAtTimestampMS?: number; + lastError?: string; +} + +export type AuctionSideEffectApplicationDocument = + HydratedDocument; + // ===== MatchStats (precomputed internal stats fragment) ===== export interface MatchStatsRuneStyleSelection { styleId: number; @@ -1646,6 +1747,34 @@ const AuctionTeamSubSchema = new Schema( { _id: false }, ); +const RedisAuctionTeamMemberSubSchema = new Schema( + { + userId: { type: Schema.Types.ObjectId, ref: 'user', required: true }, + assignedPosition: { type: String, enum: POSITIONS, required: true }, + memberAcquisitionBidPointAmount: { + type: Number, + required: true, + default: 0, + }, + }, + { _id: false }, +); + +const RedisAuctionTeamSubSchema = new Schema( + { + teamIndex: { type: Number, required: true, min: 1 }, + name: { type: String, required: false }, + captainUserId: { type: Schema.Types.ObjectId, ref: 'user', required: true }, + remainingBidPointAmount: { type: Number, required: true, default: 0 }, + members: { + type: [RedisAuctionTeamMemberSubSchema], + required: true, + default: [], + }, + }, + { _id: false }, +); + const AuctionBidSubSchema = new Schema( { teamIndex: { type: Number, required: true, min: 1 }, @@ -1656,6 +1785,16 @@ const AuctionBidSubSchema = new Schema( { _id: false }, ); +const AuctionBidHistoryEntrySubSchema = new Schema( + { + bidderTeamIndex: { type: Number, required: true, min: 1 }, + bidPointAmount: { type: Number, required: true }, + bidderUserId: { type: Schema.Types.ObjectId, ref: 'user', required: true }, + bidPlacedAtTimestampMS: { type: Number, required: true }, + }, + { _id: false }, +); + const AuctionChatMessageSubSchema = new Schema( { id: { type: String, required: true }, @@ -1681,6 +1820,40 @@ export const AuctionSchema = new Schema( required: true, default: 'waiting', }, + revision: { type: Number, required: true, default: 0, min: 0 }, + auctionEngineVersion: { + type: String, + enum: AUCTION_ENGINE_VERSIONS, + required: false, + }, + auctionLifecycleId: { type: String, required: false }, + lastAppliedAuctionStateTransitionId: { type: String, required: false }, + currentAuctionHistorySequence: { + type: Number, + required: true, + default: 0, + min: 0, + }, + startAuctionRequestId: { type: String, required: false }, + startAuctionStateTransitionId: { type: String, required: false }, + auctionStartedByUserId: { + type: Schema.Types.ObjectId, + ref: 'user', + required: false, + }, + matchSideEffectStatus: { + type: String, + enum: AUCTION_MATCH_SIDE_EFFECT_STATUSES, + required: true, + default: 'none', + }, + matchSideEffectRevision: { + type: Number, + required: true, + default: 0, + min: 0, + }, + matchSideEffectError: { type: String, required: false }, teams: { type: [AuctionTeamSubSchema], required: true, default: [] }, order: { type: [AuctionPlayerSnapshotSubSchema], @@ -1720,6 +1893,55 @@ export const AuctionSchema = new Schema( }, startedAt: { type: Date, required: false }, completedAt: { type: Date, required: false }, + auctionTeams: { + type: [RedisAuctionTeamSubSchema], + required: false, + default: undefined, + }, + auctionPlayerOrder: { + type: [AuctionPlayerSnapshotSubSchema], + required: false, + default: undefined, + }, + passedAuctionPlayerQueue: { + type: [AuctionPlayerSnapshotSubSchema], + required: false, + default: undefined, + }, + currentAuctionRound: { type: Number, required: false, min: 1 }, + currentAuctionPlayerOrderIndex: { type: Number, required: false, min: 0 }, + auctionBidHistory: { + type: [AuctionBidHistoryEntrySubSchema], + required: false, + default: undefined, + }, + currentHighestBidPointAmount: { type: Number, required: false, min: 0 }, + currentHighestBidderTeamIndex: { type: Number, required: false, min: 1 }, + currentBidRoundDeadlineTimestampMS: { + type: Number, + required: false, + min: 0, + }, + maximumBidRoundDurationSeconds: { + type: Number, + required: false, + min: 1, + }, + bidRoundExtensionSeconds: { type: Number, required: false, min: 0 }, + initialTeamBidPointAmount: { type: Number, required: false, min: 0 }, + topTierAuctionPriorityThreshold: { + type: String, + enum: AUCTION_TOP_TIER_THRESHOLDS, + required: false, + }, + manualTopTierAuctionPriorityUserIds: { + type: [Schema.Types.ObjectId], + ref: 'user', + required: false, + default: undefined, + }, + auctionStartedAtTimestampMS: { type: Number, required: false, min: 0 }, + auctionCompletedAtTimestampMS: { type: Number, required: false, min: 0 }, }, { timestamps: true, @@ -1727,7 +1949,7 @@ export const AuctionSchema = new Schema( }, ); -const AuctionHistoryEntrySchema = new Schema( +export const AuctionHistoryEntrySchema = new Schema( { auctionId: { type: Schema.Types.ObjectId, @@ -1744,19 +1966,16 @@ const AuctionHistoryEntrySchema = new Schema( sequence: { type: Number, required: true, min: 1 }, action: { type: String, - enum: [ - 'start', - 'open-bidding', - 'bid', - 'sold', - 'passed', - 'next', - 'complete', - ], + enum: AUCTION_ACTION_TYPES, required: true, }, + auctionStateTransitionId: { type: String, required: false }, + auctionLifecycleId: { type: String, required: false }, + revision: { type: Number, required: false, min: 0 }, actorUserId: { type: Schema.Types.ObjectId, ref: 'user', required: false }, snapshotBefore: { type: Schema.Types.Mixed, required: true }, + historyMutation: { type: Schema.Types.Mixed, required: false }, + matchSideEffectMutation: { type: Schema.Types.Mixed, required: false }, takenAt: { type: Date, required: true, default: Date.now }, }, { @@ -1766,6 +1985,74 @@ const AuctionHistoryEntrySchema = new Schema( ); AuctionHistoryEntrySchema.index({ auctionId: 1, sequence: -1 }); +AuctionHistoryEntrySchema.index( + { auctionId: 1, sequence: 1 }, + { unique: true }, +); +AuctionHistoryEntrySchema.index( + { auctionId: 1, auctionStateTransitionId: 1 }, + { sparse: true, unique: true }, +); + +export const AuctionSideEffectApplicationSchema = + new Schema( + { + auctionId: { + type: Schema.Types.ObjectId, + ref: 'auction', + required: true, + index: true, + }, + matchId: { + type: Schema.Types.ObjectId, + ref: 'match', + required: true, + index: true, + }, + auctionStateTransitionId: { type: String, required: true }, + auctionLifecycleId: { type: String, required: true }, + sideEffectType: { type: String, required: true }, + state: { + type: String, + enum: AUCTION_SIDE_EFFECT_APPLICATION_STATES, + required: true, + default: 'pending', + }, + payload: { type: Schema.Types.Mixed, required: true, default: {} }, + payloadChecksum: { type: String, required: true }, + attempts: { type: Number, required: true, default: 0, min: 0 }, + processingStartedAtTimestampMS: { + type: Number, + required: false, + min: 0, + }, + processingLeaseExpiresAtTimestampMS: { + type: Number, + required: false, + min: 0, + }, + processingOwnerToken: { type: String, required: false }, + completedAtTimestampMS: { type: Number, required: false, min: 0 }, + lastError: { type: String, required: false }, + }, + { + timestamps: true, + collection: 'auctionSideEffectApplications', + }, + ); + +AuctionSideEffectApplicationSchema.index( + { + auctionId: 1, + auctionStateTransitionId: 1, + sideEffectType: 1, + }, + { unique: true }, +); +AuctionSideEffectApplicationSchema.index({ + state: 1, + processingLeaseExpiresAtTimestampMS: 1, +}); export const MatchStatsSchema: mongoose.Schema = new Schema( { @@ -1840,6 +2127,11 @@ export const tournamentModelDefinitions: ModelDefinition[] = [ schema: AuctionHistoryEntrySchema, schemaName: 'auctionHistory', }, + { + name: 'auctionSideEffectApplication', + schema: AuctionSideEffectApplicationSchema, + schemaName: 'auctionSideEffectApplication', + }, { name: 'matchStats', schema: MatchStatsSchema, @@ -1860,5 +2152,6 @@ export interface TournamentModelTypes { match: Match; auction: Auction; auctionHistory: AuctionHistoryEntry; + auctionSideEffectApplication: AuctionSideEffectApplication; matchStats: MatchStats; } diff --git a/apps/api/src/modules/global/garnet/garnet.constants.ts b/apps/api/src/modules/global/garnet/garnet.constants.ts deleted file mode 100644 index 842616cb..00000000 --- a/apps/api/src/modules/global/garnet/garnet.constants.ts +++ /dev/null @@ -1 +0,0 @@ -export const GARNET_CLIENT = Symbol('GARNET_CLIENT'); diff --git a/apps/api/src/modules/global/garnet/garnet.module.ts b/apps/api/src/modules/global/garnet/garnet.module.ts deleted file mode 100644 index 8bc9ec66..00000000 --- a/apps/api/src/modules/global/garnet/garnet.module.ts +++ /dev/null @@ -1,57 +0,0 @@ -import { Logger, Module } from '@nestjs/common'; -import { createClient } from 'redis'; -import { SecretModule } from '../secret/secret.module'; -import { SecretService } from '../secret/secret.service'; -import { GARNET_CLIENT } from './garnet.constants'; -import { GarnetService, type GarnetRedisClient } from './garnet.service'; - -function normalizeGarnetUrl(endpoint: string): string { - const trimmed = endpoint.trim(); - if (!trimmed) { - throw new Error('GARNET_ENDPOINT cannot be empty'); - } - if (/^redis(s)?:\/\//iu.test(trimmed)) { - return trimmed; - } - return `redis://${trimmed}`; -} - -@Module({ - imports: [SecretModule], - providers: [ - { - provide: GARNET_CLIENT, - inject: [SecretService], - useFactory: async ( - secretService: SecretService, - ): Promise => { - await secretService.ready(); - - const [endpoint, username, password] = await Promise.all([ - secretService.get('GARNET_ENDPOINT'), - secretService.get('GARNET_USERID'), - secretService.get('GARNET_PASSWORD'), - ]); - - const logger = new Logger('GarnetClient'); - const client = createClient({ - url: normalizeGarnetUrl(endpoint), - username, - password, - }); - - client.on('error', (error) => { - logger.error(`Garnet client error: ${error?.message ?? error}`); - }); - - await client.connect(); - logger.log('Garnet connected'); - - return client; - }, - }, - GarnetService, - ], - exports: [GarnetService, GARNET_CLIENT], -}) -export class GarnetModule {} diff --git a/apps/api/src/modules/global/global.module.ts b/apps/api/src/modules/global/global.module.ts index ba3ea479..55af9336 100644 --- a/apps/api/src/modules/global/global.module.ts +++ b/apps/api/src/modules/global/global.module.ts @@ -2,12 +2,12 @@ import { Module, Global } from '@nestjs/common'; import { SecretModule } from './secret/secret.module'; import { NatsModule } from './nats/nats.module'; import { DatabaseModule } from './database/database.module'; -import { GarnetModule } from './garnet/garnet.module'; +import { RedisModule } from './redis/redis.module'; @Global() @Module({ - imports: [SecretModule, NatsModule, DatabaseModule, GarnetModule], + imports: [SecretModule, NatsModule, DatabaseModule, RedisModule], providers: [], - exports: [SecretModule, NatsModule, DatabaseModule, GarnetModule], + exports: [SecretModule, NatsModule, DatabaseModule, RedisModule], }) export class GlobalModule {} diff --git a/apps/api/src/modules/global/redis/redis.config.spec.ts b/apps/api/src/modules/global/redis/redis.config.spec.ts new file mode 100644 index 00000000..a3e50e66 --- /dev/null +++ b/apps/api/src/modules/global/redis/redis.config.spec.ts @@ -0,0 +1,59 @@ +import { + assertDistinctRedisInstances, + normalizeRedisUrl, + resolveRedisClientOptions, +} from './redis.config'; + +describe('redis.config', () => { + it('normalizes host:port endpoints into redis URLs', () => { + expect(normalizeRedisUrl('127.0.0.1:6379', 'REDIS_ENDPOINT')).toBe( + 'redis://127.0.0.1:6379', + ); + expect(normalizeRedisUrl('rediss://cache.example.com:6380')).toBe( + 'rediss://cache.example.com:6380', + ); + }); + + it('throws a clear error for empty endpoints', () => { + expect(() => normalizeRedisUrl(' ', 'REDIS_ENDPOINT')).toThrow( + 'REDIS_ENDPOINT cannot be empty', + ); + }); + + it('keeps credentials optional when resolving client options', () => { + expect( + resolveRedisClientOptions({ + endpoint: 'redis.internal:6379', + username: '', + password: undefined, + endpointEnvName: 'REDIS_ENDPOINT', + }), + ).toEqual({ + url: 'redis://redis.internal:6379', + }); + }); + + it('rejects auction Redis when it points at the same physical Redis instance', () => { + expect(() => + assertDistinctRedisInstances( + 'redis://cache.internal:6379/0', + 'redis://cache.internal:6379/1', + ), + ).toThrow('AUCTION_REDIS must use a separate Redis instance'); + }); + + it('allows different Redis hosts or ports', () => { + expect(() => + assertDistinctRedisInstances( + 'redis://cache.internal:6379', + 'redis://auction.internal:6379', + ), + ).not.toThrow(); + expect(() => + assertDistinctRedisInstances( + 'redis://cache.internal:6379', + 'redis://cache.internal:6380', + ), + ).not.toThrow(); + }); +}); diff --git a/apps/api/src/modules/global/redis/redis.config.ts b/apps/api/src/modules/global/redis/redis.config.ts new file mode 100644 index 00000000..e98a9c8c --- /dev/null +++ b/apps/api/src/modules/global/redis/redis.config.ts @@ -0,0 +1,77 @@ +export interface RedisClientOptions { + password?: string; + url: string; + username?: string; +} + +export interface ResolveRedisClientOptionsParams { + endpoint?: string; + endpointEnvName?: string; + password?: string; + url?: string; + urlEnvName?: string; + username?: string; +} + +function trimOptional(value: string | undefined): string | undefined { + const trimmed = value?.trim(); + return trimmed ? trimmed : undefined; +} + +export function normalizeRedisUrl( + endpointOrUrl: string, + envName = 'REDIS_URL', +): string { + const trimmed = endpointOrUrl.trim(); + if (!trimmed) { + throw new Error(`${envName} cannot be empty`); + } + if (/^redis(s)?:\/\//iu.test(trimmed)) { + return trimmed; + } + return `redis://${trimmed}`; +} + +export function resolveRedisClientOptions( + params: ResolveRedisClientOptionsParams, +): RedisClientOptions { + const url = trimOptional(params.url); + const endpoint = trimOptional(params.endpoint); + const selectedEndpoint = url ?? endpoint; + const selectedEnvName = url + ? (params.urlEnvName ?? 'REDIS_URL') + : (params.endpointEnvName ?? 'REDIS_ENDPOINT'); + + if (!selectedEndpoint) { + throw new Error(`${selectedEnvName} cannot be empty`); + } + + const options: RedisClientOptions = { + url: normalizeRedisUrl(selectedEndpoint, selectedEnvName), + }; + const username = trimOptional(params.username); + const password = trimOptional(params.password); + if (username) options.username = username; + if (password) options.password = password; + return options; +} + +function parseRedisInstanceIdentity(redisUrl: string): string { + const url = new URL(normalizeRedisUrl(redisUrl)); + const hostname = url.hostname.toLowerCase(); + const port = url.port || '6379'; + return `${hostname}:${port}`; +} + +export function assertDistinctRedisInstances( + redisUrl: string, + auctionRedisUrl: string, +): void { + const redisIdentity = parseRedisInstanceIdentity(redisUrl); + const auctionRedisIdentity = parseRedisInstanceIdentity(auctionRedisUrl); + if (redisIdentity === auctionRedisIdentity) { + throw new Error( + 'AUCTION_REDIS must use a separate Redis instance from REDIS because auction Redis is a live state source of truth.', + ); + } +} diff --git a/apps/api/src/modules/global/redis/redis.constants.ts b/apps/api/src/modules/global/redis/redis.constants.ts new file mode 100644 index 00000000..8f1a24b2 --- /dev/null +++ b/apps/api/src/modules/global/redis/redis.constants.ts @@ -0,0 +1 @@ +export const REDIS_CLIENT = Symbol('REDIS_CLIENT'); diff --git a/apps/api/src/modules/global/redis/redis.module.ts b/apps/api/src/modules/global/redis/redis.module.ts new file mode 100644 index 00000000..18ba4316 --- /dev/null +++ b/apps/api/src/modules/global/redis/redis.module.ts @@ -0,0 +1,68 @@ +import { Logger, Module } from '@nestjs/common'; +import { createClient } from 'redis'; +import { SecretModule } from '../secret/secret.module'; +import { SecretService } from '../secret/secret.service'; +import { REDIS_CLIENT } from './redis.constants'; +import { resolveRedisClientOptions } from './redis.config'; +import { RedisService, type RedisClient } from './redis.service'; + +async function readFirstSecret( + secretService: SecretService, + keys: string[], +): Promise { + for (const key of keys) { + const value = await secretService.get(key, ''); + const trimmed = value.trim(); + if (trimmed) return trimmed; + } + return undefined; +} + +@Module({ + imports: [SecretModule], + providers: [ + { + provide: REDIS_CLIENT, + inject: [SecretService], + useFactory: async (secretService: SecretService): Promise => { + await secretService.ready(); + + const [url, endpoint, username, password] = await Promise.all([ + readFirstSecret(secretService, ['REDIS_URL', 'GARNET_URL']), + readFirstSecret(secretService, ['REDIS_ENDPOINT', 'GARNET_ENDPOINT']), + readFirstSecret(secretService, [ + 'REDIS_USERNAME', + 'REDIS_USERID', + 'GARNET_USERNAME', + 'GARNET_USERID', + ]), + readFirstSecret(secretService, ['REDIS_PASSWORD', 'GARNET_PASSWORD']), + ]); + + const logger = new Logger('RedisClient'); + const client = createClient( + resolveRedisClientOptions({ + endpoint, + endpointEnvName: 'REDIS_ENDPOINT', + password, + url, + urlEnvName: 'REDIS_URL', + username, + }), + ); + + client.on('error', (error) => { + logger.error(`Redis client error: ${error?.message ?? error}`); + }); + + await client.connect(); + logger.log('Redis connected'); + + return client; + }, + }, + RedisService, + ], + exports: [RedisService, REDIS_CLIENT], +}) +export class RedisModule {} diff --git a/apps/api/src/modules/global/garnet/garnet.service.ts b/apps/api/src/modules/global/redis/redis.service.ts similarity index 93% rename from apps/api/src/modules/global/garnet/garnet.service.ts rename to apps/api/src/modules/global/redis/redis.service.ts index 2b50df91..084c18de 100644 --- a/apps/api/src/modules/global/garnet/garnet.service.ts +++ b/apps/api/src/modules/global/redis/redis.service.ts @@ -1,8 +1,8 @@ import { Inject, Injectable, Logger, OnModuleDestroy } from '@nestjs/common'; import type { createClient } from 'redis'; -import { GARNET_CLIENT } from './garnet.constants'; +import { REDIS_CLIENT } from './redis.constants'; -export type GarnetRedisClient = ReturnType; +export type RedisClient = ReturnType; export interface StreamEntry { deliveriesCounter?: number; @@ -48,12 +48,10 @@ function normalizeStreamFields(fields: unknown): Record { } @Injectable() -export class GarnetService implements OnModuleDestroy { - private readonly logger = new Logger(GarnetService.name); +export class RedisService implements OnModuleDestroy { + private readonly logger = new Logger(RedisService.name); - constructor( - @Inject(GARNET_CLIENT) private readonly client: GarnetRedisClient, - ) {} + constructor(@Inject(REDIS_CLIENT) private readonly client: RedisClient) {} async onModuleDestroy() { try { @@ -63,7 +61,7 @@ export class GarnetService implements OnModuleDestroy { } } - public raw(): GarnetRedisClient { + public raw(): RedisClient { return this.client; } diff --git a/apps/api/src/modules/legacy-import/legacy-import.service.ts b/apps/api/src/modules/legacy-import/legacy-import.service.ts index 9f6a9244..cb3522e0 100644 --- a/apps/api/src/modules/legacy-import/legacy-import.service.ts +++ b/apps/api/src/modules/legacy-import/legacy-import.service.ts @@ -16,7 +16,7 @@ import type { RiotMatch as StoredRiotMatch, UserDocument, } from '../global/database/schema'; -import { GarnetService } from '../global/garnet/garnet.service'; +import { RedisService } from '../global/redis/redis.service'; import { RIOT_JOB_LOW_STREAM } from '../riot-job-queue/riot-job-queue.types'; import { RiotMatchService } from '../riot/riot-match.service'; import type { RiotMatchDto, RiotRegionalRoute } from '../riot/riot.types'; @@ -53,7 +53,7 @@ export class LegacyImportService { constructor( private readonly connectionService: ConnectionService, - private readonly garnetService: GarnetService, + private readonly redisService: RedisService, private readonly riotMatchService: RiotMatchService, private readonly communityStatsService: CommunityStatsService, private readonly matchStatsService: MatchStatsService, @@ -80,7 +80,7 @@ export class LegacyImportService { }): Promise { const lockKey = this.communityLockKey(params.communityId); const jobId = randomUUID(); - const acquired = await this.garnetService.setStringIfAbsent( + const acquired = await this.redisService.setStringIfAbsent( lockKey, jobId, LEGACY_IMPORT_LOCK_TTL_SECONDS, @@ -148,7 +148,7 @@ export class LegacyImportService { triggeredBy: params.triggeredBy.toString(), region: (community.riotRegion ?? 'asia') as RiotRegionalRoute, }; - await this.garnetService.appendStream( + await this.redisService.appendStream( RIOT_JOB_LOW_STREAM, { job: JSON.stringify(job) }, { maxLen: 10_000 }, @@ -160,7 +160,7 @@ export class LegacyImportService { { jobId }, { $set: { state: 'completed', completedAt: new Date() } }, ).exec(); - await this.garnetService.delete(lockKey); + await this.redisService.delete(lockKey); } return { @@ -169,7 +169,7 @@ export class LegacyImportService { etaSeconds: windows.length * LEGACY_IMPORT_MEMBER_AVG_SECONDS, }; } catch (error) { - await this.garnetService.delete(lockKey); + await this.redisService.delete(lockKey); throw error; } } @@ -220,7 +220,7 @@ export class LegacyImportService { ).exec(); if (!job) throw new NotFoundException('Running legacy import job not found.'); - await this.garnetService.delete(this.communityLockKey(params.communityId)); + await this.redisService.delete(this.communityLockKey(params.communityId)); return job; } @@ -500,7 +500,7 @@ export class LegacyImportService { userByPuuid: UserByPuuidMap, ): Promise { const lockKey = `legacy-import:match:${riotMatchId}`; - const acquired = await this.garnetService.setStringIfAbsent( + const acquired = await this.redisService.setStringIfAbsent( lockKey, job.parentJobId, MATCH_IMPORT_LOCK_TTL_SECONDS, @@ -577,7 +577,7 @@ export class LegacyImportService { }); return 'error'; } finally { - await this.garnetService.delete(lockKey); + await this.redisService.delete(lockKey); } } @@ -656,7 +656,7 @@ export class LegacyImportService { if (completed) { await Promise.all([ - this.garnetService.delete( + this.redisService.delete( this.communityLockKey(new mongoose.Types.ObjectId(job.communityId)), ), this.communityStatsService.invalidateCommunity( diff --git a/apps/api/src/modules/riot-background-refresh/background-refresh.scheduler.spec.ts b/apps/api/src/modules/riot-background-refresh/background-refresh.scheduler.spec.ts index fa0d8196..3cb32bc5 100644 --- a/apps/api/src/modules/riot-background-refresh/background-refresh.scheduler.spec.ts +++ b/apps/api/src/modules/riot-background-refresh/background-refresh.scheduler.spec.ts @@ -1,5 +1,5 @@ import mongoose from 'mongoose'; -import { GarnetService } from '../global/garnet/garnet.service'; +import { RedisService } from '../global/redis/redis.service'; import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service'; import { RiotRateLimiterService } from '../riot/riot-rate-limiter.service'; import { BackgroundRefreshScheduler } from './background-refresh.scheduler'; @@ -33,13 +33,13 @@ function makeScheduler() { const rawClient = { sendCommand: jest.fn().mockResolvedValue(1), }; - const garnet = { + const redis = { getString: jest.fn().mockResolvedValue(null), setString: jest.fn().mockResolvedValue(undefined), setStringIfAbsent: jest.fn().mockResolvedValue(true), delete: jest.fn().mockResolvedValue(1), raw: jest.fn().mockReturnValue(rawClient), - } as unknown as jest.Mocked & { raw: jest.Mock }; + } as unknown as jest.Mocked & { raw: jest.Mock }; const rateLimiter = { isRefreshWindowOpen: jest.fn().mockResolvedValue(true), } as unknown as jest.Mocked; @@ -51,7 +51,7 @@ function makeScheduler() { findStaleAccounts: jest.fn().mockResolvedValue([]), } as unknown as jest.Mocked; const scheduler = new BackgroundRefreshScheduler( - garnet, + redis, rateLimiter, enrichmentService, staleAccountRepository, @@ -59,7 +59,7 @@ function makeScheduler() { return { scheduler, - garnet, + redis, rawClient, rateLimiter, enrichmentService, @@ -115,8 +115,8 @@ describe('BackgroundRefreshScheduler', () => { it('does not query stale accounts when another leader holds the lock', async () => { jest.useFakeTimers().setSystemTime(new Date('2026-05-02T18:00:00.000Z')); - const { scheduler, garnet, staleAccountRepository } = makeScheduler(); - garnet.getString.mockResolvedValue('another-consumer'); + const { scheduler, redis, staleAccountRepository } = makeScheduler(); + redis.getString.mockResolvedValue('another-consumer'); await scheduler.tick(); @@ -193,12 +193,12 @@ describe('BackgroundRefreshScheduler', () => { it('skips candidates already in failure backoff', async () => { jest.useFakeTimers().setSystemTime(new Date('2026-05-02T18:00:00.000Z')); - const { scheduler, garnet, enrichmentService, staleAccountRepository } = + const { scheduler, redis, enrichmentService, staleAccountRepository } = makeScheduler(); staleAccountRepository.findStaleAccounts.mockResolvedValue([ candidate('skip-me'), ]); - garnet.getString.mockImplementation(async (key: string) => { + redis.getString.mockImplementation(async (key: string) => { if (key.includes('riot:bg:fail:skip-me')) return '3'; return null; }); diff --git a/apps/api/src/modules/riot-background-refresh/background-refresh.scheduler.ts b/apps/api/src/modules/riot-background-refresh/background-refresh.scheduler.ts index 82dc3936..f7c81fd7 100644 --- a/apps/api/src/modules/riot-background-refresh/background-refresh.scheduler.ts +++ b/apps/api/src/modules/riot-background-refresh/background-refresh.scheduler.ts @@ -9,7 +9,7 @@ import { RiotAccountEnrichmentService, } from '../riot/riot-account-enrichment.service'; import { RiotRateLimiterService } from '../riot/riot-rate-limiter.service'; -import { GarnetService } from '../global/garnet/garnet.service'; +import { RedisService } from '../global/redis/redis.service'; import { isInKstBackgroundWindow } from './kst-window.util'; import { StaleAccountRepository } from './stale-account.repository'; @@ -41,7 +41,7 @@ export class BackgroundRefreshScheduler private readonly consumer = `${process.pid}:${Math.random().toString(36).slice(2)}`; constructor( - private readonly garnet: GarnetService, + private readonly redis: RedisService, private readonly rateLimiter: RiotRateLimiterService, private readonly enrichmentService: RiotAccountEnrichmentService, private readonly staleAccountRepository: StaleAccountRepository, @@ -158,9 +158,9 @@ export class BackgroundRefreshScheduler } private async tryBecomeLeader(): Promise { - const current = await this.garnet.getString(LEADER_KEY); + const current = await this.redis.getString(LEADER_KEY); if (current === this.consumer) { - await this.garnet.setString( + await this.redis.setString( LEADER_KEY, this.consumer, LEADER_TTL_SECONDS, @@ -169,7 +169,7 @@ export class BackgroundRefreshScheduler } if (current) return false; - return this.garnet.setStringIfAbsent( + return this.redis.setStringIfAbsent( LEADER_KEY, this.consumer, LEADER_TTL_SECONDS, @@ -178,9 +178,9 @@ export class BackgroundRefreshScheduler private async renewLeaderIfHeld(): Promise { try { - const current = await this.garnet.getString(LEADER_KEY); + const current = await this.redis.getString(LEADER_KEY); if (current !== this.consumer) return; - await this.garnet.setString( + await this.redis.setString( LEADER_KEY, this.consumer, LEADER_TTL_SECONDS, @@ -200,7 +200,7 @@ export class BackgroundRefreshScheduler } private async getFailureCount(puuid: string): Promise { - const raw = await this.garnet.getString(this.failureBackoffKey(puuid)); + const raw = await this.redis.getString(this.failureBackoffKey(puuid)); const count = Number(raw ?? 0); if (!Number.isFinite(count) || count < 0) return 0; return count; @@ -208,7 +208,7 @@ export class BackgroundRefreshScheduler private async bumpFailureCounter(puuid: string): Promise { const key = this.failureBackoffKey(puuid); - const client = this.garnet.raw(); + const client = this.redis.raw(); const response = await client.sendCommand(['INCR', key]); await client.sendCommand([ 'EXPIRE', @@ -225,7 +225,7 @@ export class BackgroundRefreshScheduler } private async clearFailureCounter(puuid: string): Promise { - await this.garnet.delete(this.failureBackoffKey(puuid)); + await this.redis.delete(this.failureBackoffKey(puuid)); } private isFailedEnrichment(result: EnrichResult): boolean { diff --git a/apps/api/src/modules/riot-job-queue/riot-job-queue.service.ts b/apps/api/src/modules/riot-job-queue/riot-job-queue.service.ts index ecacef15..3c416113 100644 --- a/apps/api/src/modules/riot-job-queue/riot-job-queue.service.ts +++ b/apps/api/src/modules/riot-job-queue/riot-job-queue.service.ts @@ -13,7 +13,7 @@ import type { RiotAccount, UserDocument, } from '../global/database/schema'; -import { GarnetService } from '../global/garnet/garnet.service'; +import { RedisService } from '../global/redis/redis.service'; import { isRiotQueueGroup, resolveRiotQueueIds, @@ -51,7 +51,7 @@ interface RefreshContext { export class RiotJobQueueService { constructor( private readonly connectionService: ConnectionService, - private readonly garnetService: GarnetService, + private readonly redisService: RedisService, ) {} public async enqueueRefresh(params: { @@ -64,12 +64,12 @@ export class RiotJobQueueService { const context = await this.resolveContext(params); const queueGroups = this.normalizeQueueGroups(params.queueGroups); const stream = this.resolveStream(params.priority); - const streamLength = await this.garnetService.streamLength(stream); + const streamLength = await this.redisService.streamLength(stream); const dedupKeys = queueGroups.map((queueGroup) => this.dedupKey(context.account.puuid, queueGroup), ); const existingJobIds = await Promise.all( - dedupKeys.map((key) => this.garnetService.getString(key)), + dedupKeys.map((key) => this.redisService.getString(key)), ); const needsNewJob = existingJobIds.some((jobId) => !jobId); @@ -114,13 +114,13 @@ export class RiotJobQueueService { requestedBy: params.requestedBy, priority: params.priority, }; - const acquired = await this.garnetService.setStringIfAbsent( + const acquired = await this.redisService.setStringIfAbsent( dedupKeys[index], job.jobId, RIOT_JOB_DEDUP_TTL_SECONDS, ); if (!acquired) { - const jobId = await this.garnetService.getString(dedupKeys[index]); + const jobId = await this.redisService.getString(dedupKeys[index]); if (!jobId) continue; const status = await this.getStatus(jobId); subJobs.push({ @@ -149,7 +149,7 @@ export class RiotJobQueueService { await Promise.all([ this.setStatus(status), - this.garnetService.appendStream( + this.redisService.appendStream( stream, { job: JSON.stringify(job) }, { maxLen: 10_000 }, @@ -209,7 +209,7 @@ export class RiotJobQueueService { } public async promoteDueScheduledJobs(limit = 100): Promise { - const client = this.garnetService.raw(); + const client = this.redisService.raw(); const raw = (await client.sendCommand([ 'ZRANGEBYSCORE', RIOT_JOB_SCHEDULED_ZSET, @@ -239,13 +239,13 @@ export class RiotJobQueueService { } public async getStatus(jobId: string): Promise { - return this.garnetService.getJson(this.statusKey(jobId)); + return this.redisService.getJson(this.statusKey(jobId)); } public async getParentStatus( parentJobId: string, ): Promise { - const jobIds = await this.garnetService.getJson( + const jobIds = await this.redisService.getJson( this.parentKey(parentJobId), ); if (!jobIds) return null; @@ -296,7 +296,7 @@ export class RiotJobQueueService { }; await Promise.all([ this.setStatus(next), - this.garnetService.delete(this.dedupKey(job.puuid, job.queueGroup)), + this.redisService.delete(this.dedupKey(job.puuid, job.queueGroup)), ]); return this.toEvent(next); } @@ -317,7 +317,7 @@ export class RiotJobQueueService { }; await Promise.all([ this.setStatus(next), - this.garnetService.delete(this.dedupKey(job.puuid, job.queueGroup)), + this.redisService.delete(this.dedupKey(job.puuid, job.queueGroup)), ]); return this.toEvent(next); } @@ -400,7 +400,7 @@ export class RiotJobQueueService { } private async appendJob(job: RiotRefreshSubJob | PollTournamentResultJob) { - await this.garnetService.appendStream( + await this.redisService.appendStream( this.resolveStream(job.priority), { job: JSON.stringify(job) }, { maxLen: 10_000 }, @@ -411,7 +411,7 @@ export class RiotJobQueueService { job: PollTournamentResultJob, deferUntilMs: number, ): Promise { - await this.garnetService.raw().sendCommand([ + await this.redisService.raw().sendCommand([ 'ZADD', RIOT_JOB_SCHEDULED_ZSET, String(deferUntilMs), @@ -442,7 +442,7 @@ export class RiotJobQueueService { } private async setStatus(status: RiotJobStatus): Promise { - await this.garnetService.setJson( + await this.redisService.setJson( this.statusKey(status.jobId), status, RIOT_JOB_STATUS_TTL_SECONDS, @@ -450,7 +450,7 @@ export class RiotJobQueueService { } private async setParent(parentJobId: string, jobIds: string[]): Promise { - await this.garnetService.setJson( + await this.redisService.setJson( this.parentKey(parentJobId), jobIds, RIOT_JOB_STATUS_TTL_SECONDS, diff --git a/apps/api/src/modules/riot-job-queue/riot-job-worker.service.spec.ts b/apps/api/src/modules/riot-job-queue/riot-job-worker.service.spec.ts index cca7bc82..def3f7bf 100644 --- a/apps/api/src/modules/riot-job-queue/riot-job-worker.service.spec.ts +++ b/apps/api/src/modules/riot-job-queue/riot-job-worker.service.spec.ts @@ -1,6 +1,6 @@ import mongoose from 'mongoose'; import { ConnectionService } from '../global/database/connection.service'; -import { GarnetService } from '../global/garnet/garnet.service'; +import { RedisService } from '../global/redis/redis.service'; import { LegacyImportService } from '../legacy-import/legacy-import.service'; import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service'; import { RiotRecentMatchesService } from '../riot/riot-recent-matches.service'; @@ -15,10 +15,10 @@ function execResult(value: T) { } function makeWorker() { - const garnetService = { + const redisService = { acknowledgeStream: jest.fn().mockResolvedValue(undefined), deleteStreamEntries: jest.fn().mockResolvedValue(undefined), - } as unknown as jest.Mocked; + } as unknown as jest.Mocked; const jobQueueService = { markProcessing: jest.fn().mockResolvedValue(undefined), markCompleted: jest.fn().mockResolvedValue({ @@ -53,7 +53,7 @@ function makeWorker() { } as unknown as jest.Mocked; const worker = new RiotJobWorkerService( - garnetService, + redisService, jobQueueService, recentMatchesService, connectionService, @@ -65,7 +65,7 @@ function makeWorker() { return { worker, - garnetService, + redisService, jobQueueService, recentMatchesService, connectionService, @@ -76,7 +76,7 @@ function makeWorker() { describe('RiotJobWorkerService', () => { it('acknowledges and deletes invalid stream entries', async () => { - const { worker, garnetService } = makeWorker(); + const { worker, redisService } = makeWorker(); await ( worker as unknown as { @@ -90,19 +90,19 @@ describe('RiotJobWorkerService', () => { message: { job: 'not-json' }, }); - expect(garnetService.acknowledgeStream).toHaveBeenCalledWith( + expect(redisService.acknowledgeStream).toHaveBeenCalledWith( 'riot:queue:high', RIOT_JOB_GROUP, 'bad-1', ); - expect(garnetService.deleteStreamEntries).toHaveBeenCalledWith( + expect(redisService.deleteStreamEntries).toHaveBeenCalledWith( 'riot:queue:high', 'bad-1', ); }); it('refreshes league entries while processing user history refresh jobs', async () => { - const { worker, enrichmentService, recentMatchesService, garnetService } = + const { worker, enrichmentService, recentMatchesService, redisService } = makeWorker(); const userId = new mongoose.Types.ObjectId().toString(); const job: RiotRefreshSubJob = { @@ -136,19 +136,19 @@ describe('RiotJobWorkerService', () => { puuid: 'puuid-1', platform: 'kr', }); - expect(garnetService.acknowledgeStream).toHaveBeenCalledWith( + expect(redisService.acknowledgeStream).toHaveBeenCalledWith( 'riot:queue:high', RIOT_JOB_GROUP, '1-0', ); - expect(garnetService.deleteStreamEntries).toHaveBeenCalledWith( + expect(redisService.deleteStreamEntries).toHaveBeenCalledWith( 'riot:queue:high', '1-0', ); expect( - garnetService.acknowledgeStream.mock.invocationCallOrder[0], + redisService.acknowledgeStream.mock.invocationCallOrder[0], ).toBeLessThan( - garnetService.deleteStreamEntries.mock.invocationCallOrder[0], + redisService.deleteStreamEntries.mock.invocationCallOrder[0], ); }); }); diff --git a/apps/api/src/modules/riot-job-queue/riot-job-worker.service.ts b/apps/api/src/modules/riot-job-queue/riot-job-worker.service.ts index 8ed9ebc6..48aad1f1 100644 --- a/apps/api/src/modules/riot-job-queue/riot-job-worker.service.ts +++ b/apps/api/src/modules/riot-job-queue/riot-job-worker.service.ts @@ -6,7 +6,7 @@ import { } from '@nestjs/common'; import mongoose from 'mongoose'; import { ConnectionService } from '../global/database/connection.service'; -import { GarnetService, StreamEntry } from '../global/garnet/garnet.service'; +import { RedisService, StreamEntry } from '../global/redis/redis.service'; import { LegacyImportService } from '../legacy-import/legacy-import.service'; import type { LegacyImportMemberJob } from '../legacy-import/legacy-import.types'; import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service'; @@ -33,7 +33,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy { private stopped = false; constructor( - private readonly garnetService: GarnetService, + private readonly redisService: RedisService, private readonly jobQueueService: RiotJobQueueService, private readonly recentMatchesService: RiotRecentMatchesService, private readonly connectionService: ConnectionService, @@ -145,7 +145,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy { stream: string, id: string, ): Promise { - await this.garnetService.acknowledgeStream(stream, RIOT_JOB_GROUP, id); + await this.redisService.acknowledgeStream(stream, RIOT_JOB_GROUP, id); await this.deleteAcknowledgedEntry(stream, id); } @@ -154,7 +154,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy { id: string, ): Promise { try { - await this.garnetService.deleteStreamEntries(stream, id); + await this.redisService.deleteStreamEntries(stream, id); } catch (error) { this.logger.warn( `Failed to delete acknowledged Riot job stream entry ${stream} ${id}: ${ @@ -226,7 +226,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy { stream: string, blockMs: number, ): Promise<{ stream: string; message: StreamEntry } | null> { - const result = await this.garnetService.readGroup( + const result = await this.redisService.readGroup( stream, RIOT_JOB_GROUP, this.consumer, @@ -241,7 +241,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy { await Promise.all( [RIOT_JOB_HIGH_STREAM, RIOT_JOB_LOW_STREAM].map(async (stream) => { try { - await this.garnetService.createConsumerGroup(stream, RIOT_JOB_GROUP); + await this.redisService.createConsumerGroup(stream, RIOT_JOB_GROUP); } catch (error) { const message = error instanceof Error ? error.message : String(error); @@ -252,9 +252,9 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy { } private async tryBecomeLeader(): Promise { - const current = await this.garnetService.getString(LEADER_KEY); + const current = await this.redisService.getString(LEADER_KEY); if (current === this.consumer) { - await this.garnetService.setString( + await this.redisService.setString( LEADER_KEY, this.consumer, LEADER_TTL_SECONDS, @@ -262,7 +262,7 @@ export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy { return true; } if (current) return false; - return this.garnetService.setStringIfAbsent( + return this.redisService.setStringIfAbsent( LEADER_KEY, this.consumer, LEADER_TTL_SECONDS, diff --git a/apps/api/src/modules/riot/riot-ddragon.service.ts b/apps/api/src/modules/riot/riot-ddragon.service.ts index a66d65fb..f5c7e83b 100644 --- a/apps/api/src/modules/riot/riot-ddragon.service.ts +++ b/apps/api/src/modules/riot/riot-ddragon.service.ts @@ -1,5 +1,5 @@ import { Injectable, Logger } from '@nestjs/common'; -import { GarnetService } from '../global/garnet/garnet.service'; +import { RedisService } from '../global/redis/redis.service'; const DDRAGON_BASE = 'https://ddragon.leagueoflegends.com'; const DDRAGON_CDN = `${DDRAGON_BASE}/cdn`; @@ -75,13 +75,13 @@ export class RiotDdragonService { private readonly logger = new Logger(RiotDdragonService.name); private inflight = new Map>(); - constructor(private readonly garnetService: GarnetService) {} + constructor(private readonly redisService: RedisService) {} public async getManifest(locale: string = DEFAULT_LOCALE): Promise { const normalizedLocale = normalizeLocale(locale); const cacheKey = manifestCacheKey(normalizedLocale); - const cached = await this.garnetService.getJson(cacheKey); + const cached = await this.redisService.getJson(cacheKey); if (cached) return cached; const pending = this.inflight.get(cacheKey); @@ -89,7 +89,7 @@ export class RiotDdragonService { const promise = this.buildManifest(normalizedLocale) .then(async (manifest) => { - await this.garnetService.setJson(cacheKey, manifest, CACHE_TTL_SECONDS); + await this.redisService.setJson(cacheKey, manifest, CACHE_TTL_SECONDS); return manifest; }) .finally(() => { diff --git a/apps/api/src/modules/riot/riot-rate-limiter.service.spec.ts b/apps/api/src/modules/riot/riot-rate-limiter.service.spec.ts index 67023ba6..d753bb98 100644 --- a/apps/api/src/modules/riot/riot-rate-limiter.service.spec.ts +++ b/apps/api/src/modules/riot/riot-rate-limiter.service.spec.ts @@ -1,15 +1,15 @@ -import { GarnetService } from '../global/garnet/garnet.service'; +import { RedisService } from '../global/redis/redis.service'; import { RiotRateLimiterService } from './riot-rate-limiter.service'; function makeService(sendCommand = jest.fn().mockResolvedValue(0)) { - const garnet = { + const redis = { getString: jest.fn().mockResolvedValue(null), raw: jest.fn().mockReturnValue({ sendCommand }), setString: jest.fn().mockResolvedValue(undefined), - } as unknown as jest.Mocked; + } as unknown as jest.Mocked; return { - service: new RiotRateLimiterService(garnet), - garnet, + service: new RiotRateLimiterService(redis), + redis, sendCommand, }; } @@ -51,12 +51,12 @@ describe('RiotRateLimiterService', () => { it('records the 120 second app rate observation from Riot headers', async () => { jest.spyOn(Date, 'now').mockReturnValue(1_000_000); - const { service, garnet } = makeService(); + const { service, redis } = makeService(); await service.recordAppRateLimitObservation('47:120,3:1', '100:120,20:1'); - expect(garnet.setString).toHaveBeenCalledTimes(1); - const [key, raw, ttl] = garnet.setString.mock.calls[0]; + expect(redis.setString).toHaveBeenCalledTimes(1); + const [key, raw, ttl] = redis.setString.mock.calls[0]; expect(key).toBe('riot:app:rl:observed'); expect(ttl).toBe(300); expect(JSON.parse(raw)).toEqual({ @@ -68,10 +68,10 @@ describe('RiotRateLimiterService', () => { }); it('resets the inferred window when Riot count decreases or observation is stale', async () => { - const { service, garnet } = makeService(); + const { service, redis } = makeService(); jest.spyOn(Date, 'now').mockReturnValue(1_060_000); - garnet.getString.mockResolvedValueOnce( + redis.getString.mockResolvedValueOnce( observedState({ count120: 80, observedAt: 1_050_000, @@ -81,13 +81,13 @@ describe('RiotRateLimiterService', () => { await service.recordAppRateLimitObservation('2:120', null); - expect(JSON.parse(garnet.setString.mock.calls[0][1])).toMatchObject({ + expect(JSON.parse(redis.setString.mock.calls[0][1])).toMatchObject({ count120: 2, windowStartAt: 1_060_000, }); jest.spyOn(Date, 'now').mockReturnValue(1_240_000); - garnet.getString.mockResolvedValueOnce( + redis.getString.mockResolvedValueOnce( observedState({ count120: 20, observedAt: 1_120_000, @@ -97,18 +97,18 @@ describe('RiotRateLimiterService', () => { await service.recordAppRateLimitObservation('25:120', null); - expect(JSON.parse(garnet.setString.mock.calls[1][1])).toMatchObject({ + expect(JSON.parse(redis.setString.mock.calls[1][1])).toMatchObject({ count120: 25, windowStartAt: 1_240_000, }); }); it('opens the refresh gate when there is no active observation', async () => { - const { service, garnet } = makeService(); + const { service, redis } = makeService(); await expect(service.isRefreshWindowOpen(0.5)).resolves.toBe(true); - garnet.getString.mockResolvedValueOnce( + redis.getString.mockResolvedValueOnce( observedState({ count120: 90, observedAt: 1_000_000, @@ -129,8 +129,8 @@ describe('RiotRateLimiterService', () => { 'checks tail headroom for refresh gate ratio=$ratio count=$count120', async ({ ratio, count120, expected }) => { jest.spyOn(Date, 'now').mockReturnValue(1_070_000); - const { service, garnet } = makeService(); - garnet.getString.mockResolvedValue( + const { service, redis } = makeService(); + redis.getString.mockResolvedValue( observedState({ count120, observedAt: 1_069_000, @@ -144,8 +144,8 @@ describe('RiotRateLimiterService', () => { it('keeps the refresh gate closed before the 120 second window tail', async () => { jest.spyOn(Date, 'now').mockReturnValue(1_050_000); - const { service, garnet } = makeService(); - garnet.getString.mockResolvedValue( + const { service, redis } = makeService(); + redis.getString.mockResolvedValue( observedState({ count120: 10, observedAt: 1_049_000, diff --git a/apps/api/src/modules/riot/riot-rate-limiter.service.ts b/apps/api/src/modules/riot/riot-rate-limiter.service.ts index a7d39e99..6b1f8f12 100644 --- a/apps/api/src/modules/riot/riot-rate-limiter.service.ts +++ b/apps/api/src/modules/riot/riot-rate-limiter.service.ts @@ -1,6 +1,6 @@ import { Injectable, Logger } from '@nestjs/common'; import type { RiotPlatformRoute, RiotRegionalRoute } from './riot.types'; -import { GarnetService } from '../global/garnet/garnet.service'; +import { RedisService } from '../global/redis/redis.service'; const APP_LIMITS = [ { windowMs: 1_000, max: 15 }, @@ -85,7 +85,7 @@ return 0 export class RiotRateLimiterService { private readonly logger = new Logger(RiotRateLimiterService.name); - constructor(private readonly garnet: GarnetService) {} + constructor(private readonly redis: RedisService) {} public async acquire( route: RiotRegionalRoute | RiotPlatformRoute, @@ -133,7 +133,7 @@ export class RiotRateLimiterService { // Concurrent responses can race here. This observation is advisory, so // last-writer-wins is acceptable and self-corrects on the next Riot header. - await this.garnet.setString( + await this.redis.setString( APP_OBSERVED_KEY, JSON.stringify(observation), APP_OBSERVED_TTL_SECONDS, @@ -167,7 +167,7 @@ export class RiotRateLimiterService { now: number, cost: number, ): Promise { - const client = this.garnet.raw(); + const client = this.redis.raw(); const member = `${process.pid}:${now}:${Math.random().toString(36).slice(2)}`; const argumentsList = [ String(now), @@ -190,7 +190,7 @@ export class RiotRateLimiterService { } private async getAppRateObservation(): Promise { - const raw = await this.garnet.getString(APP_OBSERVED_KEY); + const raw = await this.redis.getString(APP_OBSERVED_KEY); if (!raw) return null; try { diff --git a/apps/api/src/modules/riot/riot-recent-matches.service.ts b/apps/api/src/modules/riot/riot-recent-matches.service.ts index 704550e9..2d96434a 100644 --- a/apps/api/src/modules/riot/riot-recent-matches.service.ts +++ b/apps/api/src/modules/riot/riot-recent-matches.service.ts @@ -4,7 +4,7 @@ import type { RiotMatch as StoredRiotMatch, } from '../global/database/schema'; import { ConnectionService } from '../global/database/connection.service'; -import { GarnetService } from '../global/garnet/garnet.service'; +import { RedisService } from '../global/redis/redis.service'; import type { RiotRegionalRoute } from './riot.types'; import { RiotMatchService } from './riot-match.service'; @@ -22,7 +22,7 @@ export class RiotRecentMatchesService { constructor( private readonly connectionService: ConnectionService, private readonly matchService: RiotMatchService, - private readonly garnetService: GarnetService, + private readonly redisService: RedisService, ) {} public async syncRecentMatches(params: { @@ -37,7 +37,7 @@ export class RiotRecentMatchesService { const lockKey = `riot:enrich:matches:${params.puuid}`; const lockValue = `${process.pid}:${Date.now()}`; - const acquired = await this.garnetService.setStringIfAbsent( + const acquired = await this.redisService.setStringIfAbsent( lockKey, lockValue, MATCH_ENRICHMENT_LOCK_TTL_SECONDS, @@ -103,7 +103,7 @@ export class RiotRecentMatchesService { return this.loadFromDb({ puuid: params.puuid, limit, queueId }); } finally { - await this.garnetService.delete(lockKey).catch((error: unknown) => { + await this.redisService.delete(lockKey).catch((error: unknown) => { this.logger.warn( `Failed to release recent matches lock for ${params.puuid}: ${ (error as Error)?.message ?? error diff --git a/apps/api/src/redis-io.adapter.ts b/apps/api/src/redis-io.adapter.ts new file mode 100644 index 00000000..3066e65f --- /dev/null +++ b/apps/api/src/redis-io.adapter.ts @@ -0,0 +1,46 @@ +import { INestApplicationContext } from '@nestjs/common'; +import { IoAdapter } from '@nestjs/platform-socket.io'; +import { createAdapter } from '@socket.io/redis-adapter'; +import type { ServerOptions } from 'socket.io'; +import { + AuctionRedisService, + type AuctionRedisClient, +} from './modules/auction/redis/auction-redis.service'; + +type RedisAdapterConstructor = ReturnType; +type DuplicatedRedisClient = ReturnType; + +export class RedisIoAdapter extends IoAdapter { + private adapterConstructor?: RedisAdapterConstructor; + private subClient?: DuplicatedRedisClient; + + constructor(private readonly app: INestApplicationContext) { + super(app); + } + + public async connectToRedis(): Promise { + const auctionRedisService = this.app.get(AuctionRedisService); + const pubClient = auctionRedisService.raw(); + this.subClient = pubClient.duplicate(); + await this.subClient.connect(); + this.adapterConstructor = createAdapter(pubClient, this.subClient); + } + + override createIOServer(port: number, options?: ServerOptions) { + const server = super.createIOServer(port, options); + if (this.adapterConstructor) { + server.adapter(this.adapterConstructor); + } + return server; + } + + override close(server: unknown) { + const closeResult = super.close(server as never); + if (this.subClient) { + void this.subClient.quit().catch(() => { + this.subClient?.destroy(); + }); + } + return closeResult; + } +} diff --git a/apps/api/src/scripts/auction-redis-rehearsal.ts b/apps/api/src/scripts/auction-redis-rehearsal.ts new file mode 100644 index 00000000..83f71829 --- /dev/null +++ b/apps/api/src/scripts/auction-redis-rehearsal.ts @@ -0,0 +1,603 @@ +import { ConfigService } from '@nestjs/config'; +import { randomUUID } from 'crypto'; +import fs from 'fs'; +import mongoose from 'mongoose'; +import path from 'path'; +import { createClient } from 'redis'; +import { AuctionDeadlineScheduler } from '../modules/auction/auction-deadline.scheduler'; +import { AuctionDurabilityScheduler } from '../modules/auction/auction-durability.scheduler'; +import { AuctionService } from '../modules/auction/auction.service'; +import { AuctionRedisCommandService } from '../modules/auction/redis/auction-redis-command.service'; +import { buildAuctionRedisKeys } from '../modules/auction/redis/auction-redis.keys'; +import { AuctionRedisService } from '../modules/auction/redis/auction-redis.service'; +import { AuctionRedisStateReaderService } from '../modules/auction/redis/auction-redis-state-reader.service'; +import { ConnectionService, resolveMongoDbName } from '../modules/global/database/connection.service'; +import { + assertDistinctRedisInstances, + resolveRedisClientOptions, +} from '../modules/global/redis/redis.config'; +import { SecretService } from '../modules/global/secret/secret.service'; + +type RedisClient = ReturnType; + +const REHEARSAL_PREFIX = 'redis-sot-rehearsal'; +const WAIT_FOR_EXPIRY_MS = 6200; + +interface RehearsalResources { + auctionIds: mongoose.Types.ObjectId[]; + communityId?: mongoose.Types.ObjectId; + matchId?: mongoose.Types.ObjectId; + userIds: mongoose.Types.ObjectId[]; +} + +function loadProjectEnv(): void { + const candidates = [ + path.resolve(process.cwd(), 'project.env'), + path.resolve(process.cwd(), '../project.env'), + path.resolve(process.cwd(), 'apps/project.env'), + ]; + for (const candidate of candidates) { + if (!fs.existsSync(candidate)) continue; + for (const line of fs.readFileSync(candidate, 'utf8').split(/\r?\n/u)) { + const trimmed = line.trim(); + if (!trimmed || trimmed.startsWith('#')) continue; + const separatorIndex = trimmed.indexOf('='); + if (separatorIndex < 0) continue; + const key = trimmed.slice(0, separatorIndex).trim(); + const value = trimmed + .slice(separatorIndex + 1) + .trim() + .replace(/^['"]|['"]$/gu, ''); + if (key && process.env[key] === undefined) { + process.env[key] = value; + } + } + } +} + +async function readFirstSecret( + secretService: SecretService, + keys: string[], +): Promise { + for (const key of keys) { + const value = await secretService.get(key, ''); + const trimmed = value.trim(); + if (trimmed) return trimmed; + } + return undefined; +} + +function requireSafeNodeEnv(): void { + if (process.env.NODE_ENV === 'prod' && process.env.ALLOW_PROD_AUCTION_REHEARSAL !== 'true') { + throw new Error( + 'Refusing to run auction Redis rehearsal against prod. Set ALLOW_PROD_AUCTION_REHEARSAL=true only for an explicit production drill.', + ); + } +} + +function logStep(message: string): void { + console.log(`[auction-rehearsal] ${message}`); +} + +async function createRedisClientFromSecrets( + secretService: SecretService, + kind: 'common' | 'auction', +): Promise { + const prefix = kind === 'auction' ? 'AUCTION_REDIS' : 'REDIS'; + const urlKeys = kind === 'auction' ? [`${prefix}_URL`] : ['REDIS_URL', 'GARNET_URL']; + const endpointKeys = + kind === 'auction' ? [`${prefix}_ENDPOINT`] : ['REDIS_ENDPOINT', 'GARNET_ENDPOINT']; + const usernameKeys = + kind === 'auction' + ? [`${prefix}_USERNAME`, `${prefix}_USERID`] + : ['REDIS_USERNAME', 'REDIS_USERID', 'GARNET_USERNAME', 'GARNET_USERID']; + const passwordKeys = + kind === 'auction' ? [`${prefix}_PASSWORD`] : ['REDIS_PASSWORD', 'GARNET_PASSWORD']; + const [url, endpoint, username, password] = await Promise.all([ + readFirstSecret(secretService, urlKeys), + readFirstSecret(secretService, endpointKeys), + readFirstSecret(secretService, usernameKeys), + readFirstSecret(secretService, passwordKeys), + ]); + const client = createClient( + resolveRedisClientOptions({ + endpoint, + endpointEnvName: `${prefix}_ENDPOINT`, + password, + url, + urlEnvName: `${prefix}_URL`, + username, + }), + ); + client.on('error', (error) => { + console.error(`[auction-rehearsal] ${kind} Redis error:`, error); + }); + await client.connect(); + return client; +} + +async function assertRedisTopology( + secretService: SecretService, +): Promise<{ auctionRedisClient: RedisClient; commonRedisClient: RedisClient }> { + const [ + redisUrl, + redisEndpoint, + auctionRedisUrl, + auctionRedisEndpoint, + ] = await Promise.all([ + readFirstSecret(secretService, ['REDIS_URL', 'GARNET_URL']), + readFirstSecret(secretService, ['REDIS_ENDPOINT', 'GARNET_ENDPOINT']), + readFirstSecret(secretService, ['AUCTION_REDIS_URL']), + readFirstSecret(secretService, ['AUCTION_REDIS_ENDPOINT']), + ]); + const redisOptions = resolveRedisClientOptions({ + endpoint: redisEndpoint, + endpointEnvName: 'REDIS_ENDPOINT', + url: redisUrl, + urlEnvName: 'REDIS_URL', + }); + const auctionRedisOptions = resolveRedisClientOptions({ + endpoint: auctionRedisEndpoint, + endpointEnvName: 'AUCTION_REDIS_ENDPOINT', + url: auctionRedisUrl, + urlEnvName: 'AUCTION_REDIS_URL', + }); + assertDistinctRedisInstances(redisOptions.url, auctionRedisOptions.url); + + const [commonRedisClient, auctionRedisClient] = await Promise.all([ + createRedisClientFromSecrets(secretService, 'common'), + createRedisClientFromSecrets(secretService, 'auction'), + ]); + await Promise.all([ + commonRedisClient.sendCommand(['PING']), + auctionRedisClient.sendCommand(['PING']), + auctionRedisClient.sendCommand(['TIME']), + ]); + return { auctionRedisClient, commonRedisClient }; +} + +async function cleanupRedis( + auctionRedisService: AuctionRedisService, + matchId: mongoose.Types.ObjectId, +): Promise { + const keys = buildAuctionRedisKeys(matchId.toString()); + await auctionRedisService.raw().sendCommand([ + 'DEL', + keys.liveStateKey, + keys.structureStateKey, + keys.appliedTransitionIdsKey, + keys.bidHistoryKey, + keys.bidRequestResultsKey, + keys.bidRequestResultOrderKey, + keys.actionRequestResultsKey, + keys.actionRequestResultOrderKey, + keys.rehydrateLockKey, + keys.stateTransitionLockKey, + ]); + await auctionRedisService.raw().sendCommand([ + 'ZREM', + keys.deadlineQueueKey, + matchId.toString(), + ]); + + let cursor = '0'; + do { + const reply = await 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) { + await auctionRedisService.raw().sendCommand([ + 'ZREM', + keys.durabilityRetryQueueKey, + ...payloadKeys, + ]); + await auctionRedisService.raw().sendCommand([ + 'ZREM', + keys.durabilityDeadLetterQueueKey, + ...payloadKeys, + ]); + await auctionRedisService.raw().sendCommand(['DEL', ...payloadKeys]); + } + } while (cursor !== '0'); +} + +async function closeRedisClient( + client: RedisClient, + label: 'auction' | 'common', +): Promise { + try { + const result = await Promise.race([ + client.quit().then(() => 'closed' as const), + new Promise<'timeout'>((resolve) => { + setTimeout(() => resolve('timeout'), 3_000); + }), + ]); + if (result === 'timeout') { + client.destroy(); + logStep(`${label} Redis quit timed out; destroyed client`); + } + } catch { + client.destroy(); + logStep(`${label} Redis quit failed; destroyed client`); + } +} + +async function cleanupMongo( + connectionService: ConnectionService, + resources: RehearsalResources, +): Promise { + const AuctionModel = await connectionService.getModel('auction'); + const AuctionHistoryModel = await connectionService.getModel('auctionHistory'); + const SideEffectModel = await connectionService.getModel( + 'auctionSideEffectApplication', + ); + const MatchModel = await connectionService.getModel('match'); + const UserModel = await connectionService.getModel('user'); + const CommunityModel = await connectionService.getModel('community'); + const auctionIds = new Set(resources.auctionIds.map((id) => id.toString())); + if (resources.matchId) { + const existingAuctions = await AuctionModel.find({ + matchId: resources.matchId, + }) + .select({ _id: 1 }) + .lean() + .exec(); + for (const auction of existingAuctions) { + auctionIds.add(String(auction._id)); + } + await SideEffectModel.deleteMany({ matchId: resources.matchId }).exec(); + await MatchModel.deleteOne({ _id: resources.matchId }).exec(); + } + if (auctionIds.size > 0) { + const ids = [...auctionIds].map((id) => new mongoose.Types.ObjectId(id)); + await AuctionHistoryModel.deleteMany({ auctionId: { $in: ids } }).exec(); + await AuctionModel.deleteMany({ _id: { $in: ids } }).exec(); + } + if (resources.userIds.length > 0) { + await UserModel.deleteMany({ _id: { $in: resources.userIds } }).exec(); + } + if (resources.communityId) { + await CommunityModel.deleteOne({ _id: resources.communityId }).exec(); + } +} + +async function seedMatch( + connectionService: ConnectionService, +): Promise { + const CommunityModel = await connectionService.getModel('community'); + const UserModel = await connectionService.getModel('user'); + const MatchModel = await connectionService.getModel('match'); + const suffix = `${Date.now()}-${randomUUID().slice(0, 8)}`; + const communityId = new mongoose.Types.ObjectId(); + const ownerUserId = new mongoose.Types.ObjectId(); + const community = await CommunityModel.create({ + _id: communityId, + description: 'Temporary auction Redis rehearsal community', + name: `${REHEARSAL_PREFIX}-${suffix}`, + ownerUserId, + riotPlatform: 'kr', + riotRegion: 'asia', + }); + const userIds = Array.from({ length: 10 }, (_, index) => + index === 0 ? ownerUserId : new mongoose.Types.ObjectId(), + ); + await UserModel.insertMany( + userIds.map((userId, index) => ({ + _id: userId, + communityId: community._id, + preferredPositions: [{ position: 'MID', priority: 1 }], + riotAccounts: [ + { + championMasteries: [], + championRecords: {}, + gameName: `Rehearsal${index + 1}`, + isPrimary: true, + lastRefreshRequestedAt: new Date(), + profileIconId: 1, + puuid: `${REHEARSAL_PREFIX}-puuid-${suffix}-${index + 1}`, + tagLine: 'TEST', + tierHistory: [], + tiers: [], + }, + ], + role: index === 0 ? 'owner' : 'member', + })), + ); + const match = await MatchModel.create({ + communityId: community._id, + description: 'Temporary Redis SoT rehearsal match', + gameCount: 1, + gameMode: 'pair', + maxParticipants: 10, + participants: userIds.map((userId, index) => ({ + excluded: false, + joinedAt: new Date(Date.now() + index), + preferredPositions: [{ position: 'MID', priority: 1 }], + userId, + })), + scheduledAt: new Date(Date.now() + 60_000), + shortCode: `R${Math.random().toString(36).slice(2, 6)}`.slice(0, 6).toUpperCase(), + status: 'recruiting', + title: `${REHEARSAL_PREFIX}-${suffix}`, + }); + return { + auctionIds: [], + communityId: community._id, + matchId: match._id, + userIds, + }; +} + +async function flushDurability( + durabilityScheduler: AuctionDurabilityScheduler, +): Promise { + for (let attempt = 0; attempt < 5; attempt += 1) { + const result = await durabilityScheduler.processDueDurabilityPayloads(50); + if (result.applied === 0 && result.failed === 0) return; + } +} + +function assertState( + state: Record | null, + expectedPhase: string, +): Record { + if (!state) throw new Error(`Expected auction state phase=${expectedPhase}, got null`); + if (state.phase !== expectedPhase) { + throw new Error( + `Expected auction phase=${expectedPhase}, got ${String(state.phase)}`, + ); + } + return state; +} + +async function main(): Promise { + loadProjectEnv(); + process.env.NODE_ENV = process.env.NODE_ENV || 'staging'; + process.env.SECRET_SOURCE = process.env.SECRET_SOURCE || 'infisical'; + requireSafeNodeEnv(); + + const keep = process.argv.includes('--keep'); + const configService = new ConfigService(process.env); + const secretService = new SecretService(configService); + await secretService.ready(); + logStep(`secrets loaded, nodeEnv=${process.env.NODE_ENV}, db=${resolveMongoDbName()}`); + + const { auctionRedisClient, commonRedisClient } = + await assertRedisTopology(secretService); + const connectionService = new ConnectionService(secretService); + const auctionRedisService = new AuctionRedisService(auctionRedisClient); + const auctionRedisCommandService = new AuctionRedisCommandService( + auctionRedisService, + ); + const auctionRedisStateReaderService = new AuctionRedisStateReaderService( + auctionRedisService, + ); + const dummyTournamentCodeService = { + releaseFromMatch: async () => undefined, + reserveForMatch: async () => undefined, + }; + const dummyTournamentResultService = { + cancelPolling: async () => undefined, + scheduleInitialPoll: async () => undefined, + }; + const dummySideEffectService = { + mirrorMatchSideEffectStatus: async () => true, + }; + const dummyEventBus = { + broadcastMatchSideEffect: () => undefined, + broadcastState: () => undefined, + }; + const auctionService = new AuctionService( + connectionService, + { + enrichRiotAccount: async () => ({ + account: null, + league: 'fresh', + masteries: 'fresh', + recentMatches: 'fresh', + summoner: 'fresh', + }), + } as never, + dummyTournamentCodeService as never, + dummyTournamentResultService as never, + auctionRedisService, + auctionRedisCommandService, + auctionRedisStateReaderService, + ); + const durabilityScheduler = new AuctionDurabilityScheduler( + connectionService, + auctionRedisService, + dummyTournamentCodeService as never, + dummyTournamentResultService as never, + dummySideEffectService as never, + dummyEventBus as never, + ); + const deadlineScheduler = new AuctionDeadlineScheduler( + auctionRedisService, + auctionRedisCommandService, + auctionService, + ); + + const resources: RehearsalResources = { auctionIds: [], userIds: [] }; + try { + Object.assign(resources, await seedMatch(connectionService)); + if (!resources.matchId || !resources.communityId) { + throw new Error('Failed to seed rehearsal match.'); + } + logStep(`seeded match=${resources.matchId.toString()}`); + + const auction = await auctionService.start({ + bidRoundExtensionSeconds: 1, + captains: [ + { teamIndex: 1, userId: resources.userIds[0] }, + { teamIndex: 2, userId: resources.userIds[1] }, + ], + communityId: resources.communityId, + initialTeamBidPointAmount: 100, + manualTopTierAuctionPriorityUserIds: [], + matchId: resources.matchId, + maximumBidRoundDurationSeconds: 5, + startAuctionRequestId: randomUUID(), + topTierAuctionPriorityThreshold: 'NONE', + }); + resources.auctionIds.push(auction._id); + assertState( + await auctionRedisStateReaderService.readAuctionStateView( + resources.matchId.toString(), + ), + 'presenting', + ); + logStep('start -> presenting OK'); + + await auctionService.openBidding(resources.matchId, { + auctionActionRequestId: randomUUID(), + }); + await flushDurability(durabilityScheduler); + assertState( + await auctionRedisStateReaderService.readAuctionStateView( + resources.matchId.toString(), + ), + 'bidding', + ); + logStep('open-bidding -> bidding OK'); + + const bidResult = await auctionService.placeBid({ + amount: 10, + bidRequestId: randomUUID(), + matchId: resources.matchId, + teamIndex: 1, + }); + if (!('revision' in bidResult)) throw new Error('Bid did not return state.'); + logStep('bid OK'); + + await auctionService.markSold({ + assignedPosition: 'MID', + auctionActionRequestId: randomUUID(), + matchId: resources.matchId, + }); + await flushDurability(durabilityScheduler); + assertState( + await auctionRedisStateReaderService.readAuctionStateView( + resources.matchId.toString(), + ), + 'sold', + ); + logStep('sold transition OK'); + + await auctionService.next(resources.matchId, { + auctionActionRequestId: randomUUID(), + }); + await flushDurability(durabilityScheduler); + assertState( + await auctionRedisStateReaderService.readAuctionStateView( + resources.matchId.toString(), + ), + 'presenting', + ); + logStep('next -> presenting OK'); + + await auctionService.openBidding(resources.matchId, { + auctionActionRequestId: randomUUID(), + }); + await flushDurability(durabilityScheduler); + logStep(`waiting ${WAIT_FOR_EXPIRY_MS}ms for Redis TIME deadline`); + await new Promise((resolve) => setTimeout(resolve, WAIT_FOR_EXPIRY_MS)); + const deadlineResult = await deadlineScheduler.processDueBidRoundDeadlines(20); + if (deadlineResult.completed < 1) { + throw new Error( + `Expected deadline completion, got ${JSON.stringify(deadlineResult)}`, + ); + } + await flushDurability(durabilityScheduler); + assertState( + await auctionRedisStateReaderService.readAuctionStateView( + resources.matchId.toString(), + ), + 'passed', + ); + logStep('automatic expiry -> passed OK'); + + const historyBeforeUndo = await auctionService.listHistory({ + communityId: resources.communityId, + matchId: resources.matchId, + }); + const undoTarget = historyBeforeUndo[historyBeforeUndo.length - 1]?.sequence; + if (!undoTarget) throw new Error('No history sequence to undo.'); + await auctionService.undoTo({ + auctionActionRequestId: randomUUID(), + communityId: resources.communityId, + matchId: resources.matchId, + sequence: undoTarget, + }); + await flushDurability(durabilityScheduler); + logStep(`undo to sequence=${undoTarget} OK`); + + await auctionService.reset({ + auctionActionRequestId: randomUUID(), + communityId: resources.communityId, + matchId: resources.matchId, + }); + await flushDurability(durabilityScheduler); + assertState( + await auctionRedisStateReaderService.readAuctionStateView( + resources.matchId.toString(), + ), + 'waiting', + ); + logStep('reset -> waiting + side effect OK'); + + const restartedAuction = await auctionService.start({ + bidRoundExtensionSeconds: 1, + captains: [ + { teamIndex: 1, userId: resources.userIds[0] }, + { teamIndex: 2, userId: resources.userIds[1] }, + ], + communityId: resources.communityId, + initialTeamBidPointAmount: 100, + manualTopTierAuctionPriorityUserIds: [], + matchId: resources.matchId, + maximumBidRoundDurationSeconds: 5, + startAuctionRequestId: randomUUID(), + topTierAuctionPriorityThreshold: 'NONE', + }); + resources.auctionIds.push(restartedAuction._id); + assertState( + await auctionRedisStateReaderService.readAuctionStateView( + resources.matchId.toString(), + ), + 'presenting', + ); + logStep('restart after reset OK'); + logStep('REHEARSAL PASSED'); + } finally { + if (!keep) { + if (resources.matchId) { + await cleanupRedis(auctionRedisService, resources.matchId); + } + await cleanupMongo(connectionService, resources); + logStep('cleanup complete'); + } else { + logStep('kept rehearsal data because --keep was provided'); + } + await closeRedisClient(auctionRedisClient, 'auction'); + await closeRedisClient(commonRedisClient, 'common'); + await connectionService.onModuleDestroy(); + await mongoose.disconnect().catch(() => undefined); + logStep('connections closed'); + } +} + +void main().then(() => { + process.exit(0); +}).catch((error) => { + console.error('[auction-rehearsal] FAILED:', error); + process.exit(1); +}); diff --git a/apps/web/src/api/hooks.ts b/apps/web/src/api/hooks.ts index 27927829..c5c6ff3b 100644 --- a/apps/web/src/api/hooks.ts +++ b/apps/web/src/api/hooks.ts @@ -221,9 +221,21 @@ export function useAuctionHistory( export function useUndoAuction(communityId = DEFAULT_COMMUNITY_ID) { return useMutation({ mutationFn: ({ + auctionActionRequestId, + clientObservedAuctionLifecycleId, + clientObservedCurrentAuctionPlayerOrderIndex, + clientObservedCurrentBidRoundPlayerUserId, + clientObservedPhase, + clientObservedRevision, matchId, sequence, }: { + auctionActionRequestId?: string; + clientObservedAuctionLifecycleId?: string; + clientObservedCurrentAuctionPlayerOrderIndex?: number; + clientObservedCurrentBidRoundPlayerUserId?: string; + clientObservedPhase?: string; + clientObservedRevision?: number; matchId: string; sequence: number; }) => @@ -231,7 +243,15 @@ export function useUndoAuction(communityId = DEFAULT_COMMUNITY_ID) { `/communities/${communityId}/matches/${matchId}/auction/undo`, { method: 'POST', - body: JSON.stringify({ sequence }), + body: JSON.stringify({ + auctionActionRequestId, + clientObservedAuctionLifecycleId, + clientObservedCurrentAuctionPlayerOrderIndex, + clientObservedCurrentBidRoundPlayerUserId, + clientObservedPhase, + clientObservedRevision, + sequence, + }), }, ), }); @@ -239,9 +259,33 @@ export function useUndoAuction(communityId = DEFAULT_COMMUNITY_ID) { export function useResetAuction(communityId = DEFAULT_COMMUNITY_ID) { return useMutation({ - mutationFn: ({ matchId }: { matchId: string }) => + mutationFn: ({ + auctionActionRequestId, + clientObservedAuctionLifecycleId, + clientObservedCurrentAuctionPlayerOrderIndex, + clientObservedCurrentBidRoundPlayerUserId, + clientObservedPhase, + clientObservedRevision, + matchId, + }: { + auctionActionRequestId?: string; + clientObservedAuctionLifecycleId?: string; + clientObservedCurrentAuctionPlayerOrderIndex?: number; + clientObservedCurrentBidRoundPlayerUserId?: string; + clientObservedPhase?: string; + clientObservedRevision?: number; + matchId: string; + }) => apiFetch(`/communities/${communityId}/matches/${matchId}/auction`, { method: 'DELETE', + body: JSON.stringify({ + auctionActionRequestId, + clientObservedAuctionLifecycleId, + clientObservedCurrentAuctionPlayerOrderIndex, + clientObservedCurrentBidRoundPlayerUserId, + clientObservedPhase, + clientObservedRevision, + }), }), }); } diff --git a/apps/web/src/api/mappers.ts b/apps/web/src/api/mappers.ts index bf94b334..1c7eece1 100644 --- a/apps/web/src/api/mappers.ts +++ b/apps/web/src/api/mappers.ts @@ -119,6 +119,8 @@ export interface AuctionTeamView { export interface AuctionStateView { matchId: string; phase: ApiAuction["phase"]; + matchSideEffectRevision?: number; + matchSideEffectStatus?: ApiAuction["matchSideEffectStatus"]; teams: AuctionTeamView[]; currentPlayer: AuctionPlayerView | null; currentPlayerIndex: number; @@ -273,7 +275,7 @@ function createFallbackParticipant(userId: string): ParticipantView { } function mapAuctionTeamToView( - team: ApiAuctionTeam, + team: NormalizedApiAuctionTeam, playerLookup: Map, participantLookup: Map, ): AuctionTeamView { @@ -489,12 +491,33 @@ export function mapApiAuctionToAuctionState( .map(mapMatchParticipantToView) .map((participant) => [participant.userId, participant]), ); - const auctionOrder = auction.order.map(mapAuctionPlayerToView); - const passedQueue = (auction.passedQueue ?? []).map(mapAuctionPlayerToView); + const rawAuctionOrder = auction.auctionPlayerOrder ?? auction.order ?? []; + const rawPassedQueue = + auction.passedAuctionPlayerQueue ?? auction.passedQueue ?? []; + const rawAuctionTeams = auction.auctionTeams ?? auction.teams ?? []; + const currentAuctionPlayerOrderIndex = + auction.currentAuctionPlayerOrderIndex ?? auction.currentIndex ?? 0; + const currentBid = + auction.currentHighestBidPointAmount ?? auction.currentBid ?? 0; + const rawCurrentBidderTeamIndex = + auction.currentHighestBidderTeamIndex ?? auction.currentBidderTeamIndex; + const currentBidderTeamIndex = + rawCurrentBidderTeamIndex !== undefined && rawCurrentBidderTeamIndex > 0 + ? rawCurrentBidderTeamIndex + : undefined; + const maximumBidRoundDurationSeconds = + auction.maximumBidRoundDurationSeconds ?? auction.maxTimerSeconds ?? 30; + const bidRoundExtensionSeconds = + auction.bidRoundExtensionSeconds ?? auction.bidExtensionSeconds ?? 5; + const currentBidRoundDeadlineTimestampMS = + auction.currentBidRoundDeadlineTimestampMS ?? + (auction.currentDeadline ? Date.parse(auction.currentDeadline) : undefined); + const auctionOrder = rawAuctionOrder.map(mapAuctionPlayerToView); + const passedQueue = rawPassedQueue.map(mapAuctionPlayerToView); const auctionPlayerLookup = new Map( auctionOrder.map((player) => [player.userId, player]), ); - const teams = [...auction.teams].sort( + const teams = rawAuctionTeams.map(normalizeApiAuctionTeam).sort( (left, right) => left.teamIndex - right.teamIndex, ); @@ -503,15 +526,15 @@ export function mapApiAuctionToAuctionState( auction.phase === "complete" ? null : (auctionPlayerLookup.get( - auction.order[auction.currentIndex]?.userId ?? "", + rawAuctionOrder[currentAuctionPlayerOrderIndex]?.userId ?? "", ) ?? null); const currentPlayerIndex = - auction.phase === "complete" ? totalPlayers : auction.currentIndex; - const timer = auction.currentDeadline + auction.phase === "complete" ? totalPlayers : currentAuctionPlayerOrderIndex; + const timer = currentBidRoundDeadlineTimestampMS ? Math.max( 0, Math.ceil( - (new Date(auction.currentDeadline).getTime() - now.getTime()) / 1000, + (currentBidRoundDeadlineTimestampMS - now.getTime()) / 1000, ), ) : 0; @@ -519,6 +542,8 @@ export function mapApiAuctionToAuctionState( return { matchId: auction.matchId, phase: auction.phase, + matchSideEffectRevision: auction.matchSideEffectRevision, + matchSideEffectStatus: auction.matchSideEffectStatus, teams: teams.map((team) => mapAuctionTeamToView(team, auctionPlayerLookup, participantLookup), ), @@ -527,21 +552,47 @@ export function mapApiAuctionToAuctionState( totalPlayers, auctionOrder, passedQueue, - auctionRound: auction.auctionRound ?? 1, - bids: auction.bids.map((bid) => ({ - teamIndex: bid.teamIndex, - amount: bid.amount, - timestamp: bid.timestamp, - })), - currentBid: auction.currentBid, - currentBidder: auction.currentBidderTeamIndex + auctionRound: auction.currentAuctionRound ?? auction.auctionRound ?? 1, + bids: normalizeApiAuctionBids(auction), + currentBid, + currentBidder: currentBidderTeamIndex !== undefined ? { - teamIndex: auction.currentBidderTeamIndex, + teamIndex: currentBidderTeamIndex, } : null, timer, - maxTimer: auction.maxTimerSeconds, - bidExtensionSeconds: auction.bidExtensionSeconds ?? 5, - deadline: auction.currentDeadline, + maxTimer: maximumBidRoundDurationSeconds, + bidExtensionSeconds: bidRoundExtensionSeconds, + deadline: currentBidRoundDeadlineTimestampMS + ? new Date(currentBidRoundDeadlineTimestampMS).toISOString() + : undefined, }; } + +type NormalizedApiAuctionTeam = ApiAuctionTeam & { points: number }; + +function normalizeApiAuctionTeam(team: ApiAuctionTeam): NormalizedApiAuctionTeam { + return { + ...team, + points: team.points ?? team.remainingBidPointAmount ?? 0, + members: (team.members ?? []).map((member) => ({ + ...member, + cost: member.cost ?? member.memberAcquisitionBidPointAmount ?? 0, + })), + }; +} + +function normalizeApiAuctionBids(auction: ApiAuction) { + if (auction.auctionBidHistory) { + return auction.auctionBidHistory.map((bid) => ({ + amount: bid.bidPointAmount, + teamIndex: bid.bidderTeamIndex, + timestamp: new Date(bid.bidPlacedAtTimestampMS).toISOString(), + })); + } + return (auction.bids ?? []).map((bid) => ({ + teamIndex: bid.teamIndex, + amount: bid.amount, + timestamp: bid.timestamp, + })); +} diff --git a/apps/web/src/api/types.ts b/apps/web/src/api/types.ts index 20395d44..7df6726a 100644 --- a/apps/web/src/api/types.ts +++ b/apps/web/src/api/types.ts @@ -278,12 +278,14 @@ export interface ApiAuctionTeamMember { userId: string; assignedPosition: Position; cost: number; + memberAcquisitionBidPointAmount?: number; } export interface ApiAuctionTeam { teamIndex: number; captainUserId: string; - points: number; + points?: number; + remainingBidPointAmount?: number; members: ApiAuctionTeamMember[]; } @@ -306,20 +308,48 @@ export interface ApiAuction { _id: string; matchId: string; phase: AuctionPhase; - teams: ApiAuctionTeam[]; - order: ApiAuctionPlayerSnapshot[]; - passedQueue: ApiAuctionPlayerSnapshot[]; - auctionRound: number; - currentIndex: number; - bids: ApiAuctionBid[]; - currentBid: number; + teams?: ApiAuctionTeam[]; + auctionTeams: ApiAuctionTeam[]; + order?: ApiAuctionPlayerSnapshot[]; + auctionPlayerOrder: ApiAuctionPlayerSnapshot[]; + passedQueue?: ApiAuctionPlayerSnapshot[]; + passedAuctionPlayerQueue: ApiAuctionPlayerSnapshot[]; + auctionRound?: number; + currentAuctionRound: number; + currentIndex?: number; + currentAuctionPlayerOrderIndex: number; + bids?: ApiAuctionBid[]; + auctionBidHistory?: Array<{ + bidderTeamIndex: number; + bidPointAmount: number; + bidderUserId: string; + bidPlacedAtTimestampMS: number; + }>; + currentBid?: number; + currentHighestBidPointAmount: number; currentBidderTeamIndex?: number; - maxTimerSeconds: number; - bidExtensionSeconds: number; + currentHighestBidderTeamIndex?: number; + maxTimerSeconds?: number; + maximumBidRoundDurationSeconds: number; + bidExtensionSeconds?: number; + bidRoundExtensionSeconds: number; currentDeadline?: string; - initialPoints: number; - topTierThreshold: AuctionTopTierThreshold; - manualTopTierUserIds: string[]; + currentBidRoundDeadlineTimestampMS?: number; + currentBidRoundPlayerUserId?: string; + currentServerTimestampMS?: number; + initialPoints?: number; + initialTeamBidPointAmount: number; + topTierThreshold?: AuctionTopTierThreshold; + topTierAuctionPriorityThreshold: AuctionTopTierThreshold; + manualTopTierUserIds?: string[]; + manualTopTierAuctionPriorityUserIds: string[]; + revision?: number; + auctionLifecycleId?: string; + matchSideEffectRevision?: number; + matchSideEffectStatus?: 'none' | 'pending' | 'processing' | 'completed' | 'failed'; + canPlaceBidInCurrentBidRound?: boolean; + isAuctionStateTransitionInProgress?: boolean; + shouldForceAuctionStateResync?: boolean; chatMessages?: ApiAuctionChatMessage[]; startedAt?: string; completedAt?: string; @@ -336,7 +366,9 @@ export interface ApiAuctionHistoryEntry { | 'sold' | 'passed' | 'next' - | 'complete'; + | 'complete' + | 'undo' + | 'reset'; actionLabel: string; takenAt: string; } diff --git a/apps/web/src/api/useAuctionSocket.ts b/apps/web/src/api/useAuctionSocket.ts index 0d138887..ec2dfdb9 100644 --- a/apps/web/src/api/useAuctionSocket.ts +++ b/apps/web/src/api/useAuctionSocket.ts @@ -12,9 +12,11 @@ type ConnectionStatus = | 'error'; interface BidPayload { - teamIndex: number; - amount: number; - bidderUserId?: string; + bidderTeamIndex: number; + bidPointAmount: number; + bidRequestId?: string; + clientObservedAuctionLifecycleId?: string; + clientObservedCurrentBidRoundPlayerUserId?: string; } interface ChatMessagePayload { @@ -22,6 +24,19 @@ interface ChatMessagePayload { message: string; } +interface AuctionActionPayload { + auctionActionRequestId?: string; + clientObservedAuctionLifecycleId?: string; + clientObservedCurrentAuctionPlayerOrderIndex?: number; + clientObservedCurrentBidRoundPlayerUserId?: string; + clientObservedPhase?: string; + clientObservedRevision?: number; +} + +interface SoldPayload extends AuctionActionPayload { + assignedPosition?: Position; +} + interface ChatHistoryPayload { messages?: ApiAuctionChatMessage[]; } @@ -30,9 +45,29 @@ interface ResetPayload { matchId?: string; } -interface TickPayload { - deadline?: string; - serverTime?: string; +type MatchSideEffectStatus = NonNullable; + +interface MatchSideEffectPayload { + auctionLifecycleId?: string; + currentServerTimestampMS?: number; + matchSideEffectRevision?: number; + matchSideEffectStatus?: MatchSideEffectStatus; +} + +interface BidDeltaPayload { + auctionBidHistoryEntry?: { + bidderTeamIndex?: number; + bidPointAmount?: number; + bidderUserId?: string; + bidPlacedAtTimestampMS?: number; + }; + auctionLifecycleId?: string; + bidRequestId?: string; + currentBidRoundDeadlineTimestampMS?: number; + currentHighestBidderTeamIndex?: number; + currentHighestBidPointAmount?: number; + currentServerTimestampMS?: number; + revision?: number; } const MAX_CHAT_MESSAGES = 200; @@ -54,8 +89,20 @@ function mergeChatMessages( export function useAuctionSocket(matchId: string | undefined) { const authUserId = useAuthUserId(); const socketRef = useRef(null); + const pendingBidTimeoutsRef = useRef< + Record> + >({}); + const pendingActionTimeoutsRef = useRef< + Record> + >({}); const [auction, setAuction] = useState(null); const [chatMessages, setChatMessages] = useState([]); + const [pendingBidRequests, setPendingBidRequests] = useState< + Record + >({}); + const [pendingActionRequests, setPendingActionRequests] = useState< + Record + >({}); const [resetAt, setResetAt] = useState(null); const [connectionStatus, setConnectionStatus] = useState('idle'); @@ -99,23 +146,20 @@ export function useAuctionSocket(matchId: string | undefined) { }); socket.on('state', (nextAuction: ApiAuction) => { - setAuction(nextAuction); + setAuction((current) => + shouldApplyIncomingAuctionState(current, nextAuction) + ? nextAuction + : current, + ); + if (typeof nextAuction.currentServerTimestampMS === 'number') { + setServerTimeOffsetMs(nextAuction.currentServerTimestampMS - Date.now()); + } if (nextAuction.chatMessages) { setChatMessages(mergeChatMessages([], nextAuction.chatMessages)); } setError(null); }); - socket.on('tick', (payload: TickPayload) => { - const serverTime = - typeof payload?.serverTime === 'string' - ? Date.parse(payload.serverTime) - : NaN; - if (Number.isFinite(serverTime)) { - setServerTimeOffsetMs(serverTime - Date.now()); - } - }); - socket.on('chat-history', (payload: ChatHistoryPayload) => { setChatMessages(mergeChatMessages([], payload.messages ?? [])); }); @@ -124,6 +168,52 @@ export function useAuctionSocket(matchId: string | undefined) { setChatMessages((current) => mergeChatMessages(current, [message])); }); + socket.on('bid', (payload: BidDeltaPayload) => { + if (typeof payload?.currentServerTimestampMS === 'number') { + setServerTimeOffsetMs(payload.currentServerTimestampMS - Date.now()); + } + if (payload?.bidRequestId) { + clearPendingBidRequest(payload.bidRequestId); + } + setAuction((current) => applyBidDelta(current, payload)); + }); + + socket.on('match-side-effect', (payload: MatchSideEffectPayload) => { + if (typeof payload?.currentServerTimestampMS === 'number') { + setServerTimeOffsetMs(payload.currentServerTimestampMS - Date.now()); + } + if ( + !payload?.matchSideEffectStatus || + typeof payload.matchSideEffectRevision !== 'number' + ) { + return; + } + const matchSideEffectRevision = payload.matchSideEffectRevision; + const matchSideEffectStatus = payload.matchSideEffectStatus; + + setAuction((current) => { + if (!current) return current; + if ( + payload.auctionLifecycleId && + current.auctionLifecycleId && + payload.auctionLifecycleId !== current.auctionLifecycleId + ) { + return current; + } + if ( + matchSideEffectRevision <= + (current.matchSideEffectRevision ?? -1) + ) { + return current; + } + return { + ...current, + matchSideEffectRevision, + matchSideEffectStatus, + }; + }); + }); + socket.on('reset', (payload: ResetPayload) => { if (payload.matchId && payload.matchId !== matchId) return; setAuction(null); @@ -144,11 +234,43 @@ export function useAuctionSocket(matchId: string | undefined) { socket?.removeAllListeners(); socket?.disconnect(); socketRef.current = null; + Object.values(pendingBidTimeoutsRef.current).forEach((timeoutId) => + clearTimeout(timeoutId), + ); + Object.values(pendingActionTimeoutsRef.current).forEach((timeoutId) => + clearTimeout(timeoutId), + ); + pendingBidTimeoutsRef.current = {}; + pendingActionTimeoutsRef.current = {}; + setPendingBidRequests({}); + setPendingActionRequests({}); setConnectionStatus('idle'); setServerTimeOffsetMs(0); }; }, [authUserId, matchId]); + function clearPendingBidRequest(bidRequestId: string) { + const timeoutId = pendingBidTimeoutsRef.current[bidRequestId]; + if (timeoutId) clearTimeout(timeoutId); + delete pendingBidTimeoutsRef.current[bidRequestId]; + setPendingBidRequests((current) => { + const next = { ...current }; + delete next[bidRequestId]; + return next; + }); + } + + function clearPendingActionRequest(auctionActionRequestId: string) { + const timeoutId = pendingActionTimeoutsRef.current[auctionActionRequestId]; + if (timeoutId) clearTimeout(timeoutId); + delete pendingActionTimeoutsRef.current[auctionActionRequestId]; + setPendingActionRequests((current) => { + const next = { ...current }; + delete next[auctionActionRequestId]; + return next; + }); + } + function emit(eventName: string, payload?: unknown) { const socket = socketRef.current; if (!socket || !socket.connected) { @@ -166,7 +288,74 @@ export function useAuctionSocket(matchId: string | undefined) { socket.emit(eventName, payload); } - const visibleAuction = auction?.matchId === matchId ? auction : null; + function buildAuctionActionPayload(): AuctionActionPayload { + return { + auctionActionRequestId: createClientRequestId(), + clientObservedAuctionLifecycleId: auction?.auctionLifecycleId, + clientObservedCurrentAuctionPlayerOrderIndex: + auction?.currentAuctionPlayerOrderIndex, + clientObservedCurrentBidRoundPlayerUserId: + auction?.currentBidRoundPlayerUserId, + clientObservedPhase: auction?.phase, + clientObservedRevision: auction?.revision, + }; + } + + function emitAuctionAction(eventName: string, payload: AuctionActionPayload) { + const socket = socketRef.current; + if (!socket || !socket.connected) { + setError('소켓이 아직 연결되지 않았습니다.'); + return; + } + + const auctionActionRequestId = + payload.auctionActionRequestId ?? createClientRequestId(); + const actionPayload = { + ...payload, + auctionActionRequestId, + }; + setError(null); + setPendingActionRequests((current) => ({ + ...current, + [auctionActionRequestId]: { action: eventName }, + })); + pendingActionTimeoutsRef.current[auctionActionRequestId] = setTimeout(() => { + clearPendingActionRequest(auctionActionRequestId); + setError('경매 진행 응답이 지연되어 최신 상태를 다시 확인해주세요.'); + }, 10_000); + socket.emit( + eventName, + actionPayload, + (ack?: { + auctionActionRequestId?: string; + code?: string; + rejected?: boolean; + state?: ApiAuction; + }) => { + clearPendingActionRequest( + ack?.auctionActionRequestId ?? auctionActionRequestId, + ); + if (ack?.rejected) { + setError(ack.code ?? '경매 진행 상태가 반영되지 않았습니다.'); + return; + } + const ackState = ack?.state; + if (ackState) { + setAuction((current) => + shouldApplyIncomingAuctionState(current, ackState) + ? ackState + : current, + ); + } + }, + ); + } + + const currentAuction = auction; + const visibleAuction = + currentAuction && currentAuction.matchId === matchId + ? applyPendingBidOverlay(currentAuction, pendingBidRequests) + : null; const visibleConnectionStatus: ConnectionStatus = matchId ? connectionStatus : 'idle'; @@ -174,24 +363,252 @@ export function useAuctionSocket(matchId: string | undefined) { return { auction: visibleAuction, chatMessages: visibleAuction ? chatMessages : [], + isAuctionActionPending: Object.keys(pendingActionRequests).length > 0, + isBidPending: Object.keys(pendingBidRequests).length > 0, + pendingActionRequests, + pendingBidRequests, resetAt, connectionStatus: visibleConnectionStatus, error, serverTimeOffsetMs: matchId ? serverTimeOffsetMs : 0, placeBid(payload: BidPayload) { - emit('bid', payload); + const socket = socketRef.current; + if (!socket || !socket.connected) { + setError('소켓이 아직 연결되지 않았습니다.'); + return; + } + + const bidRequestId = payload.bidRequestId ?? createClientRequestId(); + const bidPayload: BidPayload = { + ...payload, + bidRequestId, + clientObservedAuctionLifecycleId: + payload.clientObservedAuctionLifecycleId ?? + auction?.auctionLifecycleId, + clientObservedCurrentBidRoundPlayerUserId: + payload.clientObservedCurrentBidRoundPlayerUserId ?? + auction?.currentBidRoundPlayerUserId, + }; + + setError(null); + setPendingBidRequests((current) => ({ + ...current, + [bidRequestId]: { + amount: bidPayload.bidPointAmount, + teamIndex: bidPayload.bidderTeamIndex, + }, + })); + pendingBidTimeoutsRef.current[bidRequestId] = setTimeout(() => { + clearPendingBidRequest(bidRequestId); + setError('입찰 응답이 지연되어 최신 상태를 다시 확인해주세요.'); + }, 10_000); + socket.emit( + 'bid', + bidPayload, + (ack?: { + code?: string; + rejected?: boolean; + state?: ApiAuction; + }) => { + clearPendingBidRequest(bidRequestId); + if (ack?.rejected) { + setError(ack.code ?? '입찰이 반영되지 않았습니다.'); + return; + } + const ackState = ack?.state; + if (ackState) { + setAuction((current) => + shouldApplyIncomingAuctionState(current, ackState) + ? ackState + : current, + ); + } + }, + ); }, openBidding() { - emit('open-bidding', {}); + emitAuctionAction('open-bidding', buildAuctionActionPayload()); }, markSold(assignedPosition?: Position) { - emit('sold', assignedPosition ? { assignedPosition } : {}); + const payload: SoldPayload = { + ...buildAuctionActionPayload(), + assignedPosition, + }; + emitAuctionAction('sold', payload); + }, + markPassed() { + emitAuctionAction('passed', buildAuctionActionPayload()); }, next() { - emit('next', {}); + emitAuctionAction('next', buildAuctionActionPayload()); }, sendChatMessage(payload: ChatMessagePayload) { emit('chat-message', payload); }, }; } + +function createClientRequestId(): string { + if (typeof crypto !== 'undefined' && 'randomUUID' in crypto) { + return crypto.randomUUID(); + } + return `${Date.now()}-${Math.random().toString(16).slice(2)}`; +} + +function shouldApplyIncomingAuctionState( + current: ApiAuction | null, + incoming: ApiAuction, +): boolean { + if (!current) return true; + if (incoming.shouldForceAuctionStateResync) return true; + if ( + current.auctionLifecycleId && + incoming.auctionLifecycleId && + current.auctionLifecycleId !== incoming.auctionLifecycleId + ) { + return true; + } + if ( + typeof current.revision === 'number' && + typeof incoming.revision === 'number' && + incoming.revision <= current.revision + ) { + return false; + } + return true; +} + +function applyBidDelta( + current: ApiAuction | null, + payload: BidDeltaPayload, +): ApiAuction | null { + if (!current) return current; + if ( + payload.auctionLifecycleId && + current.auctionLifecycleId && + payload.auctionLifecycleId !== current.auctionLifecycleId + ) { + return current; + } + if ( + typeof current.revision === 'number' && + typeof payload.revision === 'number' && + payload.revision <= current.revision + ) { + return current; + } + + const bidPointAmount = Number(payload.currentHighestBidPointAmount); + const bidderTeamIndex = Number(payload.currentHighestBidderTeamIndex); + if (!Number.isFinite(bidPointAmount) || !Number.isFinite(bidderTeamIndex)) { + return current; + } + + const bidHistoryEntry = normalizeBidHistoryEntry(payload.auctionBidHistoryEntry); + const currentBidRoundDeadlineTimestampMS = + typeof payload.currentBidRoundDeadlineTimestampMS === 'number' + ? payload.currentBidRoundDeadlineTimestampMS + : current.currentBidRoundDeadlineTimestampMS; + + return { + ...current, + auctionBidHistory: appendUniqueAuctionBidHistoryEntry( + current.auctionBidHistory ?? [], + bidHistoryEntry, + ), + bids: bidHistoryEntry + ? appendUniqueLegacyBidEntry(current.bids ?? [], bidHistoryEntry) + : current.bids, + currentBid: bidPointAmount, + currentBidderTeamIndex: bidderTeamIndex, + currentDeadline: currentBidRoundDeadlineTimestampMS + ? new Date(currentBidRoundDeadlineTimestampMS).toISOString() + : current.currentDeadline, + currentHighestBidPointAmount: bidPointAmount, + currentHighestBidderTeamIndex: bidderTeamIndex, + currentBidRoundDeadlineTimestampMS, + currentServerTimestampMS: + payload.currentServerTimestampMS ?? current.currentServerTimestampMS, + revision: payload.revision ?? current.revision, + }; +} + +function normalizeBidHistoryEntry( + entry: BidDeltaPayload['auctionBidHistoryEntry'], +): NonNullable[number] | null { + if (!entry) return null; + const bidderTeamIndex = Number(entry.bidderTeamIndex); + const bidPointAmount = Number(entry.bidPointAmount); + const bidPlacedAtTimestampMS = Number(entry.bidPlacedAtTimestampMS); + if (!Number.isFinite(bidderTeamIndex) || !Number.isFinite(bidPointAmount)) { + return null; + } + return { + bidderTeamIndex, + bidPointAmount, + bidderUserId: entry.bidderUserId ?? '', + bidPlacedAtTimestampMS: Number.isFinite(bidPlacedAtTimestampMS) + ? bidPlacedAtTimestampMS + : Date.now(), + }; +} + +function appendUniqueAuctionBidHistoryEntry( + current: NonNullable, + entry: NonNullable[number] | null, +) { + if (!entry) return current; + if ( + current.some( + (existing) => + existing.bidderTeamIndex === entry.bidderTeamIndex && + existing.bidPointAmount === entry.bidPointAmount && + existing.bidPlacedAtTimestampMS === entry.bidPlacedAtTimestampMS, + ) + ) { + return current; + } + return [...current, entry]; +} + +function appendUniqueLegacyBidEntry( + current: ApiAuction['bids'], + entry: NonNullable[number], +) { + const currentBids = current ?? []; + const legacyBid = { + amount: entry.bidPointAmount, + bidderUserId: entry.bidderUserId, + teamIndex: entry.bidderTeamIndex, + timestamp: new Date(entry.bidPlacedAtTimestampMS).toISOString(), + }; + if ( + currentBids.some( + (existing) => + existing.teamIndex === legacyBid.teamIndex && + existing.amount === legacyBid.amount && + existing.timestamp === legacyBid.timestamp, + ) + ) { + return currentBids; + } + return [...currentBids, legacyBid]; +} + +function applyPendingBidOverlay( + auction: ApiAuction, + pendingBidRequests: Record, +): ApiAuction { + const pendingBids = Object.values(pendingBidRequests); + const latestPendingBid = pendingBids[pendingBids.length - 1]; + if (!latestPendingBid || latestPendingBid.amount <= (auction.currentBid ?? 0)) { + return auction; + } + return { + ...auction, + currentBid: latestPendingBid.amount, + currentBidderTeamIndex: latestPendingBid.teamIndex, + currentHighestBidPointAmount: latestPendingBid.amount, + currentHighestBidderTeamIndex: latestPendingBid.teamIndex, + }; +} diff --git a/apps/web/src/pages/AuctionPage.tsx b/apps/web/src/pages/AuctionPage.tsx index bd69d05b..e4a2978a 100644 --- a/apps/web/src/pages/AuctionPage.tsx +++ b/apps/web/src/pages/AuctionPage.tsx @@ -64,6 +64,13 @@ function formatPoints(value: number) { return value.toLocaleString(); } +function createClientRequestId(): string { + if (typeof crypto !== 'undefined' && 'randomUUID' in crypto) { + return crypto.randomUUID(); + } + return `${Date.now()}-${Math.random().toString(16).slice(2)}`; +} + function relativeTime(dateLike: string) { const seconds = Math.max( 0, @@ -114,12 +121,27 @@ function getAuctionUpdatedAt(auction: ApiAuction | null | undefined) { return Date.parse(auction.updatedAt ?? auction.createdAt ?? '') || 0; } +function getAuctionRevision(auction: ApiAuction | null | undefined) { + return typeof auction?.revision === 'number' ? auction.revision : null; +} + function pickLatestAuction( socketAuction: ApiAuction | null, queryAuction: ApiAuction | undefined, ) { if (!socketAuction) return queryAuction ?? null; if (!queryAuction) return socketAuction; + if ( + socketAuction.auctionLifecycleId && + queryAuction.auctionLifecycleId && + socketAuction.auctionLifecycleId === queryAuction.auctionLifecycleId + ) { + const socketRevision = getAuctionRevision(socketAuction); + const queryRevision = getAuctionRevision(queryAuction); + if (socketRevision !== null && queryRevision !== null) { + return queryRevision > socketRevision ? queryAuction : socketAuction; + } + } return getAuctionUpdatedAt(queryAuction) > getAuctionUpdatedAt(socketAuction) ? queryAuction : socketAuction; @@ -574,10 +596,12 @@ function PlayerSpotlight({ function BidControls({ state, captainRole, + isBidPending, onBid, }: { state: AuctionStateView; captainRole: CaptainRole | null; + isBidPending: boolean; onBid: (teamIndex: number, amount: number) => void; }) { const [bidAmount, setBidAmount] = useState(100); @@ -641,7 +665,11 @@ function BidControls({ )} {auctionState.phase === 'bidding' && ( @@ -1141,8 +1206,20 @@ export default function AuctionPage() { type="button" className="btn btn-primary btn-sm px-5 text-xs" onClick={() => socket.markSold(assignedPosition)} + disabled={socket.isAuctionActionPending} > - 낙찰 처리 + {socket.isAuctionActionPending ? '반영 중...' : '낙찰 처리'} + + )} @@ -1152,8 +1229,9 @@ export default function AuctionPage() { type="button" className="btn btn-primary btn-sm px-5 text-xs" onClick={() => socket.next()} + disabled={socket.isAuctionActionPending} > - 다음 선수 + {socket.isAuctionActionPending ? '반영 중...' : '다음 선수'} )}
@@ -1562,3 +1640,15 @@ function ChatPanel({
); } + +function resolveMatchSideEffectMessage( + status: AuctionStateView['matchSideEffectStatus'], +): string | null { + if (status === 'pending' || status === 'processing') { + return '팀 편성, 토너먼트 코드, 결과 수집 예약을 반영 중입니다.'; + } + if (status === 'failed') { + return '팀 편성 후속 처리에 실패했습니다. 운영진 확인이 필요합니다.'; + } + return null; +} diff --git a/apps/web/src/pages/MatchDetailPage.tsx b/apps/web/src/pages/MatchDetailPage.tsx index d48ef73e..47a22422 100644 --- a/apps/web/src/pages/MatchDetailPage.tsx +++ b/apps/web/src/pages/MatchDetailPage.tsx @@ -52,7 +52,7 @@ type CaptainSelectionSlot = { type CaptainSelection = { userId: string; - initialPoints: string; + initialTeamBidPointAmountInput: string; }; const DEFAULT_AUCTION_MAX_TIMER_SECONDS = 30; @@ -2387,17 +2387,23 @@ export default function MatchDetailPage() { const [captainSelections, setCaptainSelections] = useState< Record >({}); - const [topTierThreshold, setTopTierThreshold] = + const [ + topTierAuctionPriorityThreshold, + setTopTierAuctionPriorityThreshold, + ] = useState("NONE"); - const [manualTopTierUserIds, setManualTopTierUserIds] = useState( - [], - ); - const [maxTimerSeconds, setMaxTimerSeconds] = useState( + const [ + manualTopTierAuctionPriorityUserIds, + setManualTopTierAuctionPriorityUserIds, + ] = useState([]); + const [ + maximumBidRoundDurationSecondsInput, + setMaximumBidRoundDurationSecondsInput, + ] = useState( String(DEFAULT_AUCTION_MAX_TIMER_SECONDS), ); - const [bidExtensionSeconds, setBidExtensionSeconds] = useState( - String(DEFAULT_AUCTION_BID_EXTENSION_SECONDS), - ); + const [bidRoundExtensionSecondsInput, setBidRoundExtensionSecondsInput] = + useState(String(DEFAULT_AUCTION_BID_EXTENSION_SECONDS)); const [manualResultStartTime, setManualResultStartTime] = useState(""); const [manualResultEndTime, setManualResultEndTime] = useState(""); const [manualRiotMatchId, setManualRiotMatchId] = useState(""); @@ -2550,29 +2556,33 @@ export default function MatchDetailPage() { }); const startAuctionMutation = useMutation({ - mutationFn: () => + mutationFn: (startAuctionRequestId: string) => apiFetch(`/communities/${DEFAULT_COMMUNITY_ID}/matches/${id}/auction`, { method: "POST", body: JSON.stringify({ + startAuctionRequestId, captains: buildCaptainSlots(matchQuery.data?.participants ?? []).map( (slot) => ({ teamIndex: slot.teamIndex, userId: captainSelections[captainSlotKey(slot)]?.userId, - initialPoints: + initialTeamBidPointAmount: parseInitialPointsInput( - captainSelections[captainSlotKey(slot)]?.initialPoints ?? "", + captainSelections[captainSlotKey(slot)] + ?.initialTeamBidPointAmountInput ?? "", ) ?? 1000, }), ), - initialPoints: 1000, - topTierThreshold, - manualTopTierUserIds: - topTierThreshold === "MANUAL" ? selectedManualTopTierUserIds : [], - maxTimerSeconds: - parseAuctionSecondsInput(maxTimerSeconds, 5) ?? + initialTeamBidPointAmount: 1000, + topTierAuctionPriorityThreshold, + manualTopTierAuctionPriorityUserIds: + topTierAuctionPriorityThreshold === "MANUAL" + ? selectedManualTopTierUserIds + : [], + maximumBidRoundDurationSeconds: + parseAuctionSecondsInput(maximumBidRoundDurationSecondsInput, 5) ?? DEFAULT_AUCTION_MAX_TIMER_SECONDS, - bidExtensionSeconds: - parseAuctionSecondsInput(bidExtensionSeconds, 0) ?? + bidRoundExtensionSeconds: + parseAuctionSecondsInput(bidRoundExtensionSecondsInput, 0) ?? DEFAULT_AUCTION_BID_EXTENSION_SECONDS, }), }), @@ -2681,7 +2691,8 @@ export default function MatchDetailPage() { if (currentIsValid) { next[key] = { userId: currentUserId, - initialPoints: currentSelection?.initialPoints ?? "1000", + initialTeamBidPointAmountInput: + currentSelection?.initialTeamBidPointAmountInput ?? "1000", }; usedUserIds.add(currentUserId); continue; @@ -2692,7 +2703,8 @@ export default function MatchDetailPage() { ); next[key] = { userId: fallback?.userId ?? "", - initialPoints: currentSelection?.initialPoints ?? "1000", + initialTeamBidPointAmountInput: + currentSelection?.initialTeamBidPointAmountInput ?? "1000", }; if (fallback) usedUserIds.add(fallback.userId); } @@ -2754,7 +2766,8 @@ export default function MatchDetailPage() { const hasValidCaptainInitialPoints = captainSlots.every((slot) => Boolean( parseInitialPointsInput( - captainSelections[captainSlotKey(slot)]?.initialPoints ?? "", + captainSelections[captainSlotKey(slot)] + ?.initialTeamBidPointAmountInput ?? "", ), ), ); @@ -2764,12 +2777,16 @@ export default function MatchDetailPage() { const manualPriorityCandidateIds = new Set( manualPriorityCandidates.map((participant) => participant.userId), ); - const selectedManualTopTierUserIds = manualTopTierUserIds.filter((userId) => - manualPriorityCandidateIds.has(userId), + const selectedManualTopTierUserIds = + manualTopTierAuctionPriorityUserIds.filter((userId) => + manualPriorityCandidateIds.has(userId), + ); + const parsedMaxTimerSeconds = parseAuctionSecondsInput( + maximumBidRoundDurationSecondsInput, + 5, ); - const parsedMaxTimerSeconds = parseAuctionSecondsInput(maxTimerSeconds, 5); const parsedBidExtensionSeconds = parseAuctionSecondsInput( - bidExtensionSeconds, + bidRoundExtensionSecondsInput, 0, ); const hasValidAuctionTimerSettings = @@ -2997,8 +3014,9 @@ export default function MatchDetailPage() { ...current, [key]: { userId: event.target.value, - initialPoints: - current[key]?.initialPoints ?? + initialTeamBidPointAmountInput: + current[key] + ?.initialTeamBidPointAmountInput ?? "1000", }, })) @@ -3035,28 +3053,34 @@ export default function MatchDetailPage() { step={50} className="w-full border border-base-content/10 bg-transparent px-2 py-2 text-sm tabular-nums" value={ - currentSelection?.initialPoints ?? "1000" + currentSelection + ?.initialTeamBidPointAmountInput ?? + "1000" } onChange={(event) => setCaptainSelections((current) => ({ ...current, [key]: { userId: current[key]?.userId ?? "", - initialPoints: event.target.value, + initialTeamBidPointAmountInput: + event.target.value, }, })) } onBlur={() => setCaptainSelections((current) => { const points = parseInitialPointsInput( - current[key]?.initialPoints ?? "", + current[key] + ?.initialTeamBidPointAmountInput ?? + "", ); if (points !== null) return current; return { ...current, [key]: { userId: current[key]?.userId ?? "", - initialPoints: "1000", + initialTeamBidPointAmountInput: + "1000", }, }; }) @@ -3082,17 +3106,22 @@ export default function MatchDetailPage() { max={MAX_AUCTION_TIMER_SECONDS} step={5} className="min-w-0 flex-1 bg-transparent px-2 py-2 text-sm tabular-nums focus:outline-none" - value={maxTimerSeconds} + value={maximumBidRoundDurationSecondsInput} onChange={(event) => - setMaxTimerSeconds(event.target.value) + setMaximumBidRoundDurationSecondsInput( + event.target.value, + ) } onBlur={() => { if ( - parseAuctionSecondsInput(maxTimerSeconds, 5) + parseAuctionSecondsInput( + maximumBidRoundDurationSecondsInput, + 5, + ) ) { return; } - setMaxTimerSeconds( + setMaximumBidRoundDurationSecondsInput( String(DEFAULT_AUCTION_MAX_TIMER_SECONDS), ); }} @@ -3111,20 +3140,22 @@ export default function MatchDetailPage() { max={MAX_AUCTION_TIMER_SECONDS} step={1} className="min-w-0 flex-1 bg-transparent px-2 py-2 text-sm tabular-nums focus:outline-none" - value={bidExtensionSeconds} + value={bidRoundExtensionSecondsInput} onChange={(event) => - setBidExtensionSeconds(event.target.value) + setBidRoundExtensionSecondsInput( + event.target.value, + ) } onBlur={() => { if ( parseAuctionSecondsInput( - bidExtensionSeconds, + bidRoundExtensionSecondsInput, 0, ) !== null ) { return; } - setBidExtensionSeconds( + setBidRoundExtensionSecondsInput( String(DEFAULT_AUCTION_BID_EXTENSION_SECONDS), ); }} @@ -3142,9 +3173,9 @@ export default function MatchDetailPage() { 상위 티어 우선 등장 - {topTierThreshold === "MANUAL" && ( + {topTierAuctionPriorityThreshold === "MANUAL" && (
우선 등장 선수 @@ -3193,18 +3224,19 @@ export default function MatchDetailPage() { className="checkbox checkbox-primary checkbox-xs" checked={checked} onChange={(event) => - setManualTopTierUserIds((current) => - event.target.checked - ? [ - ...new Set([ - ...current, - participant.userId, - ]), - ] - : current.filter( - (userId) => - userId !== participant.userId, - ), + setManualTopTierAuctionPriorityUserIds( + (current) => + event.target.checked + ? [ + ...new Set([ + ...current, + participant.userId, + ]), + ] + : current.filter( + (userId) => + userId !== participant.userId, + ), ) } /> @@ -3226,7 +3258,9 @@ export default function MatchDetailPage() { disabled={ !canStartAuction || startAuctionMutation.isPending } - onClick={() => startAuctionMutation.mutate()} + onClick={() => + startAuctionMutation.mutate(crypto.randomUUID()) + } > {startAuctionMutation.isPending ? "시작 중..." diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index d4bdcf56..285db9de 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -35,6 +35,9 @@ importers: '@nestjs/websockets': specifier: ^11.1.19 version: 11.1.19(@nestjs/common@11.1.18(class-transformer@0.5.1)(class-validator@0.15.1)(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.18)(@nestjs/platform-socket.io@11.1.19)(reflect-metadata@0.2.2)(rxjs@7.8.2) + '@socket.io/redis-adapter': + specifier: ^8.3.0 + version: 8.3.0(socket.io-adapter@2.5.6) class-transformer: specifier: ^0.5.1 version: 0.5.1 @@ -1733,6 +1736,12 @@ packages: '@socket.io/component-emitter@3.1.2': resolution: {integrity: sha512-9BCxFwvbGg/RsZK9tjXd8s4UcwR0MWeFQ1XEKIQVVvAGJyINdrqKMcTRyLoK8Rse1GjzLV9cwjWV1olXRWEXVA==} + '@socket.io/redis-adapter@8.3.0': + resolution: {integrity: sha512-ly0cra+48hDmChxmIpnESKrc94LjRL80TEmZVscuQ/WWkRP81nNj8W8cCGMqbI4L6NCuAaPRSzZF1a9GlAxxnA==} + engines: {node: '>=10.0.0'} + peerDependencies: + socket.io-adapter: ^2.5.4 + '@speed-highlight/core@1.2.15': resolution: {integrity: sha512-BMq1K3DsElxDWawkX6eLg9+CKJrTVGCBAWVuHXVUV2u0s2711qiChLSId6ikYPfxhdYocLNt3wWwSvDiTvFabw==} @@ -2670,6 +2679,15 @@ packages: daisyui@5.5.19: resolution: {integrity: sha512-pbFAkl1VCEh/MPCeclKL61I/MqRIFFhNU7yiXoDDRapXN4/qNCoMxeCCswyxEEhqL5eiTTfwHvucFtOE71C9sA==} + debug@4.3.7: + resolution: {integrity: sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==} + engines: {node: '>=6.0'} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true + debug@4.4.3: resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==} engines: {node: '>=6.0'} @@ -3798,6 +3816,9 @@ packages: resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==} engines: {node: '>=0.10.0'} + notepack.io@3.0.1: + resolution: {integrity: sha512-TKC/8zH5pXIAMVQio2TvVDTtPRX+DJPHDqjRbxogtFiByHyzKmy96RA0JtCQJ+WouyyL4A10xomQzgbUT+1jCg==} + npm-run-path@4.0.1: resolution: {integrity: sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==} engines: {node: '>=8'} @@ -4478,6 +4499,10 @@ packages: engines: {node: '>=0.8.0'} hasBin: true + uid2@1.0.0: + resolution: {integrity: sha512-+I6aJUv63YAcY9n4mQreLUt0d4lvwkkopDNmpomkAUz0fAkEMV9pRWxN0EjhW1YfRhcuyHg2v3mwddCDW1+LFQ==} + engines: {node: '>= 4.0.0'} + uid@2.0.2: resolution: {integrity: sha512-u3xV3X7uzvi5b1MncmZo3i2Aw222Zk1keqLA1YkHldREkAhAqi65wuPfe7lHx8H/Wzy+8CE7S7uS3jekIM5s8g==} engines: {node: '>=8'} @@ -6629,6 +6654,15 @@ snapshots: '@socket.io/component-emitter@3.1.2': {} + '@socket.io/redis-adapter@8.3.0(socket.io-adapter@2.5.6)': + dependencies: + debug: 4.3.7 + notepack.io: 3.0.1 + socket.io-adapter: 2.5.6 + uid2: 1.0.0 + transitivePeerDependencies: + - supports-color + '@speed-highlight/core@1.2.15': {} '@standard-schema/spec@1.1.0': {} @@ -7636,6 +7670,10 @@ snapshots: daisyui@5.5.19: {} + debug@4.3.7: + dependencies: + ms: 2.1.3 + debug@4.4.3: dependencies: ms: 2.1.3 @@ -8917,6 +8955,8 @@ snapshots: normalize-path@3.0.0: {} + notepack.io@3.0.1: {} + npm-run-path@4.0.1: dependencies: path-key: 3.1.1 @@ -9672,6 +9712,8 @@ snapshots: uglify-js@3.19.3: optional: true + uid2@1.0.0: {} + uid@2.0.2: dependencies: '@lukeed/csprng': 1.1.0