Compare commits
7
Commits
release/81
...
release/82
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
55b80e62cd | ||
|
|
09d304d782 | ||
|
|
46c8007e94 | ||
|
|
b367328df0 | ||
|
|
c6f5a7077f | ||
|
|
7c372f0392 | ||
|
|
e8bb20d988 |
No files matched your search
@@ -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`를 읽고, 두 값이 같은 호스트/포트를 가리키면 부팅을 거부합니다.
|
||||
|
||||
## 실행 방법
|
||||
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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),
|
||||
|
||||
@@ -0,0 +1,217 @@
|
||||
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';
|
||||
import { AuctionEventBusService } from './auction-event-bus.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<AuctionRedisService>;
|
||||
const redisCommand = {
|
||||
expirePrepare: jest.fn().mockResolvedValue(
|
||||
params.expireReply ?? {
|
||||
auctionStateTransitionId: 'expire-1',
|
||||
bidRoundExpiryDecision: 'passed',
|
||||
currentServerTimestampMS: 1000,
|
||||
ok: true,
|
||||
revision: 2,
|
||||
},
|
||||
),
|
||||
} as unknown as jest.Mocked<AuctionRedisCommandService>;
|
||||
const auctionService = {
|
||||
completePreparedExpiry: jest
|
||||
.fn()
|
||||
.mockResolvedValue(params.completedState ?? { phase: 'passed' }),
|
||||
} as unknown as jest.Mocked<AuctionService>;
|
||||
const eventBus = {
|
||||
broadcastState: jest.fn(),
|
||||
} as unknown as jest.Mocked<AuctionEventBusService>;
|
||||
return {
|
||||
auctionService,
|
||||
eventBus,
|
||||
redis,
|
||||
redisCommand,
|
||||
scheduler: new AuctionDeadlineScheduler(
|
||||
redis,
|
||||
redisCommand,
|
||||
auctionService,
|
||||
eventBus,
|
||||
),
|
||||
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<void> }).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<void> }).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 completedState = { phase: 'passed', revision: 3 };
|
||||
const { auctionService, eventBus, redisCommand, scheduler } = makeScheduler({
|
||||
dueReply: [matchId],
|
||||
completedState,
|
||||
});
|
||||
|
||||
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);
|
||||
// 만료 확정 결과는 즉시 1차 broadcast돼야 한다(클라가 입찰 라운드에 멈춰
|
||||
// 후속 액션에서 CONFLICT가 반복되는 것을 막는 핵심 동작).
|
||||
expect(eventBus.broadcastState).toHaveBeenCalledWith(matchId, completedState);
|
||||
});
|
||||
|
||||
it('skips noop expiry preparations', async () => {
|
||||
const { auctionService, eventBus, 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();
|
||||
expect(eventBus.broadcastState).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);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,187 @@
|
||||
import {
|
||||
Injectable,
|
||||
Logger,
|
||||
OnModuleDestroy,
|
||||
OnModuleInit,
|
||||
} from '@nestjs/common';
|
||||
import { randomUUID } from 'crypto';
|
||||
import mongoose from 'mongoose';
|
||||
import { AuctionService } from './auction.service';
|
||||
import { AuctionEventBusService } from './auction-event-bus.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;
|
||||
|
||||
/**
|
||||
* 입찰 라운드 마감(deadline)을 감시해 자동으로 만료시키는 단일 리더 스위퍼.
|
||||
*
|
||||
* 만료는 2단계로 처리한다(정확히-1회 + 노드 크래시 복구를 위해):
|
||||
* 1) EXPIRE_PREPARE Lua: `bidding → expiring`으로 flip하고 만료 결정/컨텍스트를
|
||||
* `liveAuctionState`에 고정 + deadline ZSET에 재시도 점수 재등록.
|
||||
* 2) `completePreparedExpiry`: 고정된 컨텍스트로 APPLY_TRANSITION을 돌려
|
||||
* `sold`/`passed`로 확정하고 Mongo durability outbox를 enqueue.
|
||||
*
|
||||
* 중요(브로드캐스트 책임):
|
||||
* - 관리자 수동 전환(sold/next 등)은 게이트웨이가 응답 직후 동기로 `state`를
|
||||
* broadcast하지만, 자동 만료는 게이트웨이를 거치지 않는다.
|
||||
* - 따라서 만료 확정 결과를 클라이언트에 즉시 알리는 1차 전달 책임은 이 스위퍼에
|
||||
* 있다. 여기서 broadcast하지 않으면 클라는 입찰 라운드 revision에 멈춰 있다가
|
||||
* "다음" 등 후속 액션에서 stale 관측값으로 CONFLICT를 반복하게 된다.
|
||||
* - `AuctionDurabilityScheduler`의 broadcast는 Mongo 영속화 성공에 묶인 ~1초 주기의
|
||||
* "노드 크래시 복구용 백업"이지 1차 전달 경로가 아니다(중복 emit돼도 클라
|
||||
* revision 가드로 무해).
|
||||
*
|
||||
* 멀티 인스턴스: 리더 락을 잡은 한 인스턴스만 만료를 처리/방송하고, socket.io Redis
|
||||
* adapter가 전 인스턴스 소켓으로 fanout한다.
|
||||
*/
|
||||
@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,
|
||||
// 만료 확정 결과를 클라이언트에 즉시 알리기 위한 1차 broadcast 채널.
|
||||
private readonly auctionEventBusService: AuctionEventBusService,
|
||||
) {}
|
||||
|
||||
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<void> {
|
||||
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<string[]> {
|
||||
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 {
|
||||
// 1단계: 만료 결정/컨텍스트 고정(bidding → expiring). 아직 마감 전이거나
|
||||
// 이미 다른 phase면 noop으로 빠진다(stale ZSET 엔트리는 Lua가 정리).
|
||||
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;
|
||||
// 2단계: 고정된 컨텍스트로 sold/passed 확정. 재진입(다른 인스턴스/다음 틱)해도
|
||||
// appliedAuctionStateTransitionIds dedupe로 정확히-1회만 반영된다.
|
||||
const completedState = await this.auctionService.completePreparedExpiry(
|
||||
new mongoose.Types.ObjectId(matchId),
|
||||
);
|
||||
if (completedState) {
|
||||
completed += 1;
|
||||
// 1차 전달: 만료 확정 즉시 최신 state를 방송한다. 이게 없으면 클라가
|
||||
// 입찰 라운드에 멈춰 후속 액션에서 CONFLICT가 반복된다(durability
|
||||
// worker 백업 방송은 Mongo 성공 + ~1초 tick에 묶여 1차 전달로 부적합).
|
||||
// 이미 처리된 전환은 completePreparedExpiry가 null을 반환하므로 중복
|
||||
// 방송되지 않고, 혹시 겹쳐도 클라 revision 가드로 무해하다.
|
||||
this.auctionEventBusService.broadcastState(matchId, completedState);
|
||||
}
|
||||
} 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<void> {
|
||||
await this.auctionRedisService.raw().sendCommand([
|
||||
'ZREM',
|
||||
BID_ROUND_DEADLINE_QUEUE_KEY,
|
||||
matchId,
|
||||
]);
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,28 @@
|
||||
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';
|
||||
import { serializeRealtimeAuction } from './auction-realtime-serializer';
|
||||
|
||||
@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',
|
||||
serializeRealtimeAuction(state),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
import type { AuctionStateResponse } from './auction.service';
|
||||
|
||||
export function serializeRealtimeAuction(auction: AuctionStateResponse) {
|
||||
const serialized = JSON.parse(JSON.stringify(auction)) as Record<
|
||||
string,
|
||||
unknown
|
||||
>;
|
||||
const auctionPlayerOrder = getRecordArray(
|
||||
serialized.auctionPlayerOrder ?? serialized.order,
|
||||
);
|
||||
const currentAuctionPlayerOrderIndex = Number(
|
||||
serialized.currentAuctionPlayerOrderIndex ?? serialized.currentIndex ?? 0,
|
||||
);
|
||||
const currentBidRoundPlayerUserId =
|
||||
typeof serialized.currentBidRoundPlayerUserId === 'string'
|
||||
? serialized.currentBidRoundPlayerUserId
|
||||
: getStringField(
|
||||
auctionPlayerOrder[currentAuctionPlayerOrderIndex],
|
||||
'userId',
|
||||
);
|
||||
|
||||
if (Array.isArray(serialized.auctionPlayerOrder)) {
|
||||
serialized.auctionPlayerOrder = auctionPlayerOrder.map((player) =>
|
||||
serializeRealtimeAuctionPlayer(player, currentBidRoundPlayerUserId),
|
||||
);
|
||||
} else if (Array.isArray(serialized.order)) {
|
||||
serialized.order = auctionPlayerOrder.map((player) =>
|
||||
serializeRealtimeAuctionPlayer(player, currentBidRoundPlayerUserId),
|
||||
);
|
||||
}
|
||||
|
||||
const passedAuctionPlayerQueue = getRecordArray(
|
||||
serialized.passedAuctionPlayerQueue ?? serialized.passedQueue,
|
||||
);
|
||||
if (Array.isArray(serialized.passedAuctionPlayerQueue)) {
|
||||
serialized.passedAuctionPlayerQueue = passedAuctionPlayerQueue.map(
|
||||
(player) =>
|
||||
serializeRealtimeAuctionPlayer(player, currentBidRoundPlayerUserId),
|
||||
);
|
||||
} else if (Array.isArray(serialized.passedQueue)) {
|
||||
serialized.passedQueue = passedAuctionPlayerQueue.map((player) =>
|
||||
serializeRealtimeAuctionPlayer(player, currentBidRoundPlayerUserId),
|
||||
);
|
||||
}
|
||||
|
||||
if ('auctionPlayerOrder' in serialized) delete serialized.order;
|
||||
if ('auctionTeams' in serialized) delete serialized.teams;
|
||||
if ('passedAuctionPlayerQueue' in serialized) delete serialized.passedQueue;
|
||||
if ('auctionBidHistory' in serialized) delete serialized.bids;
|
||||
if ('maximumBidRoundDurationSeconds' in serialized) {
|
||||
delete serialized.maxTimerSeconds;
|
||||
}
|
||||
if ('bidRoundExtensionSeconds' in serialized) {
|
||||
delete serialized.bidExtensionSeconds;
|
||||
}
|
||||
if ('initialTeamBidPointAmount' in serialized) {
|
||||
delete serialized.initialPoints;
|
||||
}
|
||||
if ('topTierAuctionPriorityThreshold' in serialized) {
|
||||
delete serialized.topTierThreshold;
|
||||
}
|
||||
if ('manualTopTierAuctionPriorityUserIds' in serialized) {
|
||||
delete serialized.manualTopTierUserIds;
|
||||
}
|
||||
|
||||
return serialized;
|
||||
}
|
||||
|
||||
function serializeRealtimeAuctionPlayer(
|
||||
player: Record<string, unknown>,
|
||||
currentBidRoundPlayerUserId?: string,
|
||||
) {
|
||||
if (getStringField(player, 'userId') === currentBidRoundPlayerUserId) {
|
||||
return player;
|
||||
}
|
||||
|
||||
const {
|
||||
masteries: _masteries,
|
||||
puuid: _puuid,
|
||||
recentStatsSummary: _recentStatsSummary,
|
||||
tierHistory: _tierHistory,
|
||||
...lightweightPlayer
|
||||
} = player;
|
||||
|
||||
return lightweightPlayer;
|
||||
}
|
||||
|
||||
function getRecordArray(value: unknown): Array<Record<string, unknown>> {
|
||||
return Array.isArray(value)
|
||||
? value.filter(
|
||||
(item): item is Record<string, unknown> =>
|
||||
typeof item === 'object' && item !== null,
|
||||
)
|
||||
: [];
|
||||
}
|
||||
|
||||
function getStringField(
|
||||
value: Record<string, unknown> | undefined,
|
||||
fieldName: string,
|
||||
): string | undefined {
|
||||
const fieldValue = value?.[fieldName];
|
||||
return typeof fieldValue === 'string' ? fieldValue : undefined;
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
import {
|
||||
AUCTION_REJECTION_REASON,
|
||||
isAuctionResyncRecommended,
|
||||
resolveAuctionRejectionReason,
|
||||
} from './auction-rejection';
|
||||
|
||||
describe('resolveAuctionRejectionReason', () => {
|
||||
it('maps the internal CONFLICT code to the descriptive transition reason', () => {
|
||||
expect(resolveAuctionRejectionReason('CONFLICT')).toBe(
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY,
|
||||
);
|
||||
});
|
||||
|
||||
it('maps internal bid codes to descriptive bid reasons', () => {
|
||||
expect(resolveAuctionRejectionReason('EXPIRED')).toBe(
|
||||
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_BID_ROUND_DEADLINE_PASSED,
|
||||
);
|
||||
expect(resolveAuctionRejectionReason('TOO_LOW')).toBe(
|
||||
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_AMOUNT_NOT_HIGHER_THAN_CURRENT_HIGHEST,
|
||||
);
|
||||
});
|
||||
|
||||
it('maps known BadRequest messages without a structured code', () => {
|
||||
expect(
|
||||
resolveAuctionRejectionReason(undefined, 'Cannot advance from current phase.'),
|
||||
).toBe(
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE,
|
||||
);
|
||||
});
|
||||
|
||||
it('falls back via the message when the code carries the full sentence', () => {
|
||||
// 구조 전환 경로는 code 자리에 message 문장이 들어올 수 있다.
|
||||
expect(
|
||||
resolveAuctionRejectionReason('Auction is not in bidding phase.'),
|
||||
).toBe(
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE,
|
||||
);
|
||||
});
|
||||
|
||||
it('treats internal coordination codes as retryable', () => {
|
||||
expect(resolveAuctionRejectionReason('ACTION_REQUEST_LEASE_EXPIRED')).toBe(
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_REQUEST_COORDINATION_RETRYABLE,
|
||||
);
|
||||
expect(resolveAuctionRejectionReason('INVALID_DEADLINE_MODE')).toBe(
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_REQUEST_COORDINATION_RETRYABLE,
|
||||
);
|
||||
});
|
||||
|
||||
it('falls back to the unrecognized reason for unknown input', () => {
|
||||
expect(resolveAuctionRejectionReason('SOMETHING_NEW', 'weird')).toBe(
|
||||
AUCTION_REJECTION_REASON.AUCTION_REQUEST_REJECTED_FOR_UNRECOGNIZED_REASON,
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('isAuctionResyncRecommended', () => {
|
||||
it('recommends resync for stale-view rejections', () => {
|
||||
expect(
|
||||
isAuctionResyncRecommended(
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY,
|
||||
),
|
||||
).toBe(true);
|
||||
expect(
|
||||
isAuctionResyncRecommended(
|
||||
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_BID_ROUND_DEADLINE_PASSED,
|
||||
),
|
||||
).toBe(true);
|
||||
});
|
||||
|
||||
it('does not recommend resync for genuine constraint rejections', () => {
|
||||
expect(
|
||||
isAuctionResyncRecommended(
|
||||
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_TEAM_ROSTER_FULL,
|
||||
),
|
||||
).toBe(false);
|
||||
expect(
|
||||
isAuctionResyncRecommended(
|
||||
AUCTION_REJECTION_REASON.AUCTION_REQUEST_REJECTED_FOR_UNRECOGNIZED_REASON,
|
||||
),
|
||||
).toBe(false);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,170 @@
|
||||
/**
|
||||
* 경매 거부(rejection)를 클라이언트에 알릴 때 쓰는 "설명적 거부코드" 체계.
|
||||
*
|
||||
* 배경:
|
||||
* - 내부 Lua/서비스는 `CONFLICT`, `EXPIRED`, `TOO_LOW` 같은 짧은 코드를 쓴다.
|
||||
* 이 코드들은 구현 디테일이고, 그대로 클라/운영자에게 노출하면 "무엇이 왜
|
||||
* 거부됐는지"를 알기 어렵다(특히 `CONFLICT`는 원인이 광범위하다).
|
||||
* - 그래서 ack의 `code`/`message`는 그대로 두되(진단/하위호환), 별도로
|
||||
* `auctionRejectionReason`이라는 **맥락을 코드 이름에 담은 안정적 식별자**를
|
||||
* 함께 내려준다. 클라는 이 reason을 사람이 읽는 문구로 매핑한다(프론트 사전).
|
||||
*
|
||||
* 명명 규칙:
|
||||
* - 다소 길어지더라도 "무엇이(BID/AUCTION_TRANSITION) + 왜(BECAUSE_...)"를
|
||||
* 이름만으로 알 수 있게 풀어쓴다.
|
||||
*
|
||||
* resync 권장 여부:
|
||||
* - `AUCTION_RESYNC_RECOMMENDED_REASONS`에 속한 reason은 "클라가 본 상태가 이미
|
||||
* 바뀌었다(낙관적 동시성 충돌/만료/단계 전이)"는 신호다. 이 경우 클라는 최신
|
||||
* state로 rebaseline한 뒤 (구조 액션이라면) 1회 재시도하는 것이 안전하다.
|
||||
* - 반대로 정원 초과/포인트 부족처럼 "상태를 새로고침해도 결과가 같은" 거부는
|
||||
* resync 권장 대상이 아니다(재시도해도 또 거부됨).
|
||||
*/
|
||||
|
||||
export const AUCTION_REJECTION_REASON = {
|
||||
// === 구조 전환(낙찰/유찰/다음/입찰오픈) ===
|
||||
/** 내가 본 revision/phase/선수가 commit 직전 이미 바뀜(낙관적 동시성 충돌, 내부 `CONFLICT`). */
|
||||
AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY:
|
||||
'AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY',
|
||||
/** 입찰 단계가 아닌데 입찰 단계 전환을 시도함(이미 sold/passed/presenting 등). */
|
||||
AUCTION_TRANSITION_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE:
|
||||
'AUCTION_TRANSITION_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE',
|
||||
/** 현재 단계에서 "다음"으로 진행할 수 없음(sold/passed/presenting이 아님 — 보통 이미 진행됨). */
|
||||
AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE:
|
||||
'AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE',
|
||||
/** 낙찰 처리할 유효한 최고 입찰이 없음(만료 처리로 이미 정리됐을 수 있음). */
|
||||
AUCTION_TRANSITION_REJECTED_BECAUSE_NO_WINNING_BID_TO_MARK_SOLD:
|
||||
'AUCTION_TRANSITION_REJECTED_BECAUSE_NO_WINNING_BID_TO_MARK_SOLD',
|
||||
/** 진행 중인 입찰이 있는 선수를 유찰 처리하려 함. */
|
||||
AUCTION_TRANSITION_REJECTED_BECAUSE_ACTIVE_BID_PRESENT:
|
||||
'AUCTION_TRANSITION_REJECTED_BECAUSE_ACTIVE_BID_PRESENT',
|
||||
/** 전환 요청 조정(예약/리스/멱등) 단계의 일시적 거부 — 최신 상태로 재시도하면 보통 해소됨. */
|
||||
AUCTION_TRANSITION_REJECTED_BECAUSE_REQUEST_COORDINATION_RETRYABLE:
|
||||
'AUCTION_TRANSITION_REJECTED_BECAUSE_REQUEST_COORDINATION_RETRYABLE',
|
||||
|
||||
// === 입찰(bid) ===
|
||||
/** 입찰 라운드가 이미 다음 선수/다음 라운드로 넘어감(내부 `STALE_BID_ROUND`). */
|
||||
BID_REJECTED_BECAUSE_BID_ROUND_ALREADY_ADVANCED:
|
||||
'BID_REJECTED_BECAUSE_BID_ROUND_ALREADY_ADVANCED',
|
||||
/** 입찰 라운드 마감 시각이 이미 지남(내부 `EXPIRED`). */
|
||||
BID_REJECTED_BECAUSE_BID_ROUND_DEADLINE_PASSED:
|
||||
'BID_REJECTED_BECAUSE_BID_ROUND_DEADLINE_PASSED',
|
||||
/** 경매가 입찰 단계가 아님(내부 `PHASE`). */
|
||||
BID_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE:
|
||||
'BID_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE',
|
||||
/** 입찰 금액이 현재 최고가보다 높지 않음(내부 `TOO_LOW`). */
|
||||
BID_REJECTED_BECAUSE_AMOUNT_NOT_HIGHER_THAN_CURRENT_HIGHEST:
|
||||
'BID_REJECTED_BECAUSE_AMOUNT_NOT_HIGHER_THAN_CURRENT_HIGHEST',
|
||||
/** 팀 정원이 이미 가득 참(내부 `FULL`). */
|
||||
BID_REJECTED_BECAUSE_TEAM_ROSTER_FULL:
|
||||
'BID_REJECTED_BECAUSE_TEAM_ROSTER_FULL',
|
||||
/** 남은 슬롯 최소 확보분을 고려하면 포인트가 부족함(내부 `INSUFFICIENT`). */
|
||||
BID_REJECTED_BECAUSE_INSUFFICIENT_REMAINING_POINTS_FOR_SLOTS:
|
||||
'BID_REJECTED_BECAUSE_INSUFFICIENT_REMAINING_POINTS_FOR_SLOTS',
|
||||
/** 알 수 없는 팀 인덱스(내부 `UNKNOWN_TEAM`). */
|
||||
BID_REJECTED_BECAUSE_UNKNOWN_TEAM: 'BID_REJECTED_BECAUSE_UNKNOWN_TEAM',
|
||||
/** 같은 요청 id에 다른 내용이 온 멱등성 충돌(내부 `DUPLICATE_REQUEST_CONFLICT`). */
|
||||
BID_REJECTED_BECAUSE_DUPLICATE_REQUEST_PAYLOAD_CONFLICT:
|
||||
'BID_REJECTED_BECAUSE_DUPLICATE_REQUEST_PAYLOAD_CONFLICT',
|
||||
/** 짧은 시간에 너무 많은 입찰 요청(게이트웨이 rate limit). */
|
||||
BID_REJECTED_BECAUSE_RATE_LIMITED: 'BID_REJECTED_BECAUSE_RATE_LIMITED',
|
||||
|
||||
// === 공통/그 외 ===
|
||||
/** 실시간 상태를 아직 사용할 수 없음(재접속/재조회 필요). */
|
||||
AUCTION_REQUEST_REJECTED_BECAUSE_REALTIME_STATE_UNAVAILABLE:
|
||||
'AUCTION_REQUEST_REJECTED_BECAUSE_REALTIME_STATE_UNAVAILABLE',
|
||||
/** 위 어디에도 해당하지 않는 미분류 거부(원문 message로 안내). */
|
||||
AUCTION_REQUEST_REJECTED_FOR_UNRECOGNIZED_REASON:
|
||||
'AUCTION_REQUEST_REJECTED_FOR_UNRECOGNIZED_REASON',
|
||||
} as const;
|
||||
|
||||
export type AuctionRejectionReason =
|
||||
(typeof AUCTION_REJECTION_REASON)[keyof typeof AUCTION_REJECTION_REASON];
|
||||
|
||||
/** 내부 짧은 코드 → 설명적 reason. */
|
||||
const INTERNAL_CODE_TO_REASON: Record<string, AuctionRejectionReason> = {
|
||||
CONFLICT:
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY,
|
||||
STALE_BID_ROUND:
|
||||
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_BID_ROUND_ALREADY_ADVANCED,
|
||||
EXPIRED:
|
||||
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_BID_ROUND_DEADLINE_PASSED,
|
||||
PHASE:
|
||||
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE,
|
||||
TOO_LOW:
|
||||
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_AMOUNT_NOT_HIGHER_THAN_CURRENT_HIGHEST,
|
||||
FULL: AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_TEAM_ROSTER_FULL,
|
||||
INSUFFICIENT:
|
||||
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_INSUFFICIENT_REMAINING_POINTS_FOR_SLOTS,
|
||||
UNKNOWN_TEAM: AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_UNKNOWN_TEAM,
|
||||
DUPLICATE_REQUEST_CONFLICT:
|
||||
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_DUPLICATE_REQUEST_PAYLOAD_CONFLICT,
|
||||
BID_RATE_LIMITED: AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_RATE_LIMITED,
|
||||
};
|
||||
|
||||
/** 구조화된 code 없이 message만 던지는 BadRequest(구조 전환 검증 등) → 설명적 reason. */
|
||||
const MESSAGE_TO_REASON: Record<string, AuctionRejectionReason> = {
|
||||
'Auction is not in bidding phase.':
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE,
|
||||
'Cannot advance from current phase.':
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE,
|
||||
'No bid to mark sold.':
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_NO_WINNING_BID_TO_MARK_SOLD,
|
||||
'Cannot pass a player with an active bid.':
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_ACTIVE_BID_PRESENT,
|
||||
'Auction realtime state is not available.':
|
||||
AUCTION_REJECTION_REASON.AUCTION_REQUEST_REJECTED_BECAUSE_REALTIME_STATE_UNAVAILABLE,
|
||||
};
|
||||
|
||||
/**
|
||||
* resync(최신 state로 rebaseline 후 재시도)가 권장되는 reason 집합.
|
||||
* "내가 본 상태가 낡았을 뿐, 다시 보면 가능할 수 있는" 거부들이다.
|
||||
*/
|
||||
export const AUCTION_RESYNC_RECOMMENDED_REASONS: ReadonlySet<AuctionRejectionReason> =
|
||||
new Set<AuctionRejectionReason>([
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY,
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE,
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE,
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_NO_WINNING_BID_TO_MARK_SOLD,
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_ACTIVE_BID_PRESENT,
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_REQUEST_COORDINATION_RETRYABLE,
|
||||
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_BID_ROUND_ALREADY_ADVANCED,
|
||||
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_BID_ROUND_DEADLINE_PASSED,
|
||||
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE,
|
||||
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_AMOUNT_NOT_HIGHER_THAN_CURRENT_HIGHEST,
|
||||
AUCTION_REJECTION_REASON.AUCTION_REQUEST_REJECTED_BECAUSE_REALTIME_STATE_UNAVAILABLE,
|
||||
]);
|
||||
|
||||
/**
|
||||
* 내부 거부 code(짧은 코드) 또는 BadRequest message로부터 설명적 reason을 해석한다.
|
||||
* 둘 다 모르면 미분류 reason으로 떨어뜨린다(원문 message는 ack에 그대로 남는다).
|
||||
*/
|
||||
export function resolveAuctionRejectionReason(
|
||||
internalCode?: string,
|
||||
message?: string,
|
||||
): AuctionRejectionReason {
|
||||
if (internalCode && INTERNAL_CODE_TO_REASON[internalCode]) {
|
||||
return INTERNAL_CODE_TO_REASON[internalCode];
|
||||
}
|
||||
if (message && MESSAGE_TO_REASON[message]) {
|
||||
return MESSAGE_TO_REASON[message];
|
||||
}
|
||||
// 구조 전환 경로는 code 자리에 message 문장이 들어올 수 있어 한 번 더 확인한다.
|
||||
if (internalCode && MESSAGE_TO_REASON[internalCode]) {
|
||||
return MESSAGE_TO_REASON[internalCode];
|
||||
}
|
||||
if (
|
||||
internalCode &&
|
||||
(internalCode.startsWith('ACTION_REQUEST_') ||
|
||||
internalCode.startsWith('INVALID_'))
|
||||
) {
|
||||
return AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_REQUEST_COORDINATION_RETRYABLE;
|
||||
}
|
||||
return AUCTION_REJECTION_REASON.AUCTION_REQUEST_REJECTED_FOR_UNRECOGNIZED_REASON;
|
||||
}
|
||||
|
||||
export function isAuctionResyncRecommended(
|
||||
reason: AuctionRejectionReason,
|
||||
): boolean {
|
||||
return AUCTION_RESYNC_RECOMMENDED_REASONS.has(reason);
|
||||
}
|
||||
@@ -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',
|
||||
]);
|
||||
});
|
||||
});
|
||||
@@ -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<boolean> {
|
||||
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,
|
||||
};
|
||||
}
|
||||
@@ -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,
|
||||
|
||||
@@ -0,0 +1,319 @@
|
||||
import mongoose from 'mongoose';
|
||||
|
||||
jest.mock('../auth/jwt.service', () => ({
|
||||
JwtService: class JwtService {},
|
||||
}));
|
||||
|
||||
import { AuctionGateway } from './auction.gateway';
|
||||
|
||||
describe('AuctionGateway', () => {
|
||||
function createGateway(params?: {
|
||||
getCurrentRedisTimestampMS?: jest.Mock;
|
||||
placeBidDelta?: jest.Mock;
|
||||
}) {
|
||||
const auctionService = {
|
||||
placeBidDelta: params?.placeBidDelta ?? jest.fn(),
|
||||
};
|
||||
const auctionRedisService = {
|
||||
getCurrentRedisTimestampMS:
|
||||
params?.getCurrentRedisTimestampMS ??
|
||||
jest.fn().mockResolvedValue(1780000000000),
|
||||
};
|
||||
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,
|
||||
auctionRedisService 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,
|
||||
auctionRedisService,
|
||||
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 placeBidDelta = jest.fn().mockResolvedValue({
|
||||
auctionBidHistoryEntry,
|
||||
auctionLifecycleId: 'life-1',
|
||||
currentBidRoundDeadlineTimestampMS: 1780000030000,
|
||||
currentHighestBidderTeamIndex: 2,
|
||||
currentHighestBidPointAmount: 120,
|
||||
currentServerTimestampMS: 1780000000000,
|
||||
revision: 9,
|
||||
});
|
||||
const { emit, gateway, to } = createGateway({ placeBidDelta });
|
||||
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(placeBidDelta).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(
|
||||
expect.objectContaining({
|
||||
bidDelta: {
|
||||
auctionBidHistoryEntry,
|
||||
auctionLifecycleId: 'life-1',
|
||||
bidRequestId: 'bid-1',
|
||||
currentBidRoundDeadlineTimestampMS: 1780000030000,
|
||||
currentHighestBidderTeamIndex: 2,
|
||||
currentHighestBidPointAmount: 120,
|
||||
currentServerTimestampMS: 1780000000000,
|
||||
revision: 9,
|
||||
},
|
||||
bidRequestId: 'bid-1',
|
||||
bidServerTiming: expect.objectContaining({
|
||||
gatewayTotalDurationMS: expect.any(Number),
|
||||
}),
|
||||
ok: true,
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('generates one bid request id when the client omits it', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
const placeBidDelta = jest.fn().mockResolvedValue({
|
||||
auctionBidHistoryEntry: {
|
||||
bidderTeamIndex: 1,
|
||||
bidPointAmount: 50,
|
||||
},
|
||||
auctionLifecycleId: 'life-1',
|
||||
currentHighestBidderTeamIndex: 1,
|
||||
currentHighestBidPointAmount: 50,
|
||||
revision: 3,
|
||||
});
|
||||
const { emit, gateway } = createGateway({ placeBidDelta });
|
||||
const ack = jest.fn();
|
||||
|
||||
await gateway.handleBid(
|
||||
{ data: { matchId }, emit: jest.fn() } as never,
|
||||
{
|
||||
bidPointAmount: 50,
|
||||
bidderTeamIndex: 1,
|
||||
},
|
||||
ack,
|
||||
);
|
||||
|
||||
const generatedBidRequestId = placeBidDelta.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 placeBidDelta = jest.fn().mockRejectedValue({
|
||||
getResponse: () => ({
|
||||
bidDiagnostics: {
|
||||
currentBidRoundDeadlineTimestampMS: 1780000002500,
|
||||
currentServerTimestampMS: 1780000003000,
|
||||
},
|
||||
bidServerTiming: {
|
||||
redisBidCommandDurationMS: 2,
|
||||
redisBidContextReadDurationMS: 1,
|
||||
serviceTotalDurationMS: 4,
|
||||
},
|
||||
code: 'EXPIRED',
|
||||
message: 'Bid deadline has already expired.',
|
||||
}),
|
||||
});
|
||||
const socketEmit = jest.fn();
|
||||
const { gateway } = createGateway({ placeBidDelta });
|
||||
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 deadline has already expired.',
|
||||
});
|
||||
expect(ack).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
bidDiagnostics: {
|
||||
currentBidRoundDeadlineTimestampMS: 1780000002500,
|
||||
currentServerTimestampMS: 1780000003000,
|
||||
},
|
||||
bidRequestId: 'bid-1',
|
||||
bidServerTiming: expect.objectContaining({
|
||||
gatewayTotalDurationMS: expect.any(Number),
|
||||
redisBidCommandDurationMS: 2,
|
||||
redisBidContextReadDurationMS: 1,
|
||||
serviceTotalDurationMS: 4,
|
||||
}),
|
||||
code: 'EXPIRED',
|
||||
message: 'Bid deadline has already expired.',
|
||||
rejected: true,
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('acknowledges time sync with Redis server time', async () => {
|
||||
const getCurrentRedisTimestampMS = jest
|
||||
.fn()
|
||||
.mockResolvedValue(1780000001234);
|
||||
const { gateway } = createGateway({ getCurrentRedisTimestampMS });
|
||||
const ack = jest.fn();
|
||||
|
||||
await gateway.handleTimeSync(
|
||||
{
|
||||
clientSentAtTimestampMS: 1780000000000,
|
||||
sequence: 7,
|
||||
},
|
||||
ack,
|
||||
);
|
||||
|
||||
expect(getCurrentRedisTimestampMS).toHaveBeenCalledTimes(1);
|
||||
expect(ack).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
clientSentAtTimestampMS: 1780000000000,
|
||||
currentServerTimestampMS: 1780000001234,
|
||||
ok: true,
|
||||
sequence: 7,
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
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 placeBidDelta = jest.fn().mockResolvedValue({
|
||||
auctionBidHistoryEntry: {
|
||||
bidderTeamIndex: 1,
|
||||
bidPointAmount: 50,
|
||||
},
|
||||
currentHighestBidderTeamIndex: 1,
|
||||
currentHighestBidPointAmount: 50,
|
||||
revision: 3,
|
||||
});
|
||||
const socketEmit = jest.fn();
|
||||
const socket = { data: { matchId }, emit: socketEmit };
|
||||
const { gateway } = createGateway({ placeBidDelta });
|
||||
const acknowledgements: Array<Record<string, unknown>> = [];
|
||||
|
||||
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(placeBidDelta).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 placeBidDelta = jest.fn().mockResolvedValue({
|
||||
auctionBidHistoryEntry: {
|
||||
bidderTeamIndex: 1,
|
||||
bidPointAmount: 50,
|
||||
},
|
||||
currentHighestBidderTeamIndex: 1,
|
||||
currentHighestBidPointAmount: 50,
|
||||
revision: 3,
|
||||
});
|
||||
const socket = { data: { matchId }, emit: jest.fn() };
|
||||
const { gateway } = createGateway({ placeBidDelta });
|
||||
|
||||
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(placeBidDelta).toHaveBeenCalledTimes(9);
|
||||
});
|
||||
});
|
||||
@@ -1,9 +1,12 @@
|
||||
import { Logger } from '@nestjs/common';
|
||||
import { randomUUID } from 'crypto';
|
||||
import { performance } from 'perf_hooks';
|
||||
import {
|
||||
Ack,
|
||||
ConnectedSocket,
|
||||
MessageBody,
|
||||
OnGatewayConnection,
|
||||
OnGatewayDisconnect,
|
||||
OnGatewayInit,
|
||||
SubscribeMessage,
|
||||
WebSocketGateway,
|
||||
WebSocketServer,
|
||||
@@ -23,26 +26,64 @@ import type {
|
||||
UserDocument,
|
||||
} from '../global/database/schema';
|
||||
import { AuctionService } from './auction.service';
|
||||
import type {
|
||||
AuctionBidDeltaResponse,
|
||||
AuctionStateResponse,
|
||||
} from './auction.service';
|
||||
import { AuctionEventBusService } from './auction-event-bus.service';
|
||||
import {
|
||||
isAuctionResyncRecommended,
|
||||
resolveAuctionRejectionReason,
|
||||
} from './auction-rejection';
|
||||
import type { MatchSideEffectDelta } from './auction-side-effect.service';
|
||||
import { serializeRealtimeAuction } from './auction-realtime-serializer';
|
||||
import { AuctionRedisService } from './redis/auction-redis.service';
|
||||
|
||||
interface JoinAuctionPayload {
|
||||
matchId: string;
|
||||
}
|
||||
|
||||
interface BidPayload {
|
||||
teamIndex: number;
|
||||
amount: number;
|
||||
bidderUserId?: string;
|
||||
bidderTeamIndex: number;
|
||||
bidPointAmount: number;
|
||||
bidRequestId?: string;
|
||||
clientObservedAuctionLifecycleId?: string;
|
||||
clientObservedCurrentBidRoundPlayerUserId?: string;
|
||||
}
|
||||
|
||||
interface TimeSyncPayload {
|
||||
clientSentAtTimestampMS?: number;
|
||||
sequence?: number;
|
||||
}
|
||||
|
||||
interface SoldPayload {
|
||||
auctionActionRequestId?: string;
|
||||
assignedPosition?: Position;
|
||||
clientObservedAuctionLifecycleId?: string;
|
||||
clientObservedCurrentAuctionPlayerOrderIndex?: number;
|
||||
clientObservedCurrentBidRoundPlayerUserId?: string;
|
||||
clientObservedPhase?: string;
|
||||
clientObservedRevision?: number;
|
||||
}
|
||||
|
||||
type AuctionActionPayload = Omit<SoldPayload, 'assignedPosition'>;
|
||||
|
||||
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 +93,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<string, NodeJS.Timeout>();
|
||||
|
||||
constructor(
|
||||
private readonly auctionService: AuctionService,
|
||||
@@ -66,8 +106,14 @@ export class AuctionGateway
|
||||
private readonly jwtService: JwtService,
|
||||
private readonly identityService: IdentityService,
|
||||
private readonly connectionService: ConnectionService,
|
||||
private readonly auctionEventBusService: AuctionEventBusService,
|
||||
private readonly auctionRedisService: AuctionRedisService,
|
||||
) {}
|
||||
|
||||
public afterInit(server: Namespace): void {
|
||||
this.auctionEventBusService.attachAuctionNamespace(server);
|
||||
}
|
||||
|
||||
public async handleConnection(socket: Socket) {
|
||||
try {
|
||||
await this.authenticateSocket(socket);
|
||||
@@ -82,12 +128,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 +146,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 +160,133 @@ export class AuctionGateway
|
||||
public async handleBid(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@MessageBody() payload: BidPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
const gatewayBidStartedAtMS = performance.now();
|
||||
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({
|
||||
const bidResult = await this.auctionService.placeBidDelta({
|
||||
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.isBidDeltaResponse(bidResult)
|
||||
? {
|
||||
...bidResult,
|
||||
bidRequestId: bidResult.bidRequestId ?? bidRequestId,
|
||||
}
|
||||
: this.buildBidDeltaFromAuctionState(bidResult, bidRequestId);
|
||||
const bidServerTiming = this.extractBidServerTiming(bidDelta);
|
||||
const broadcastBidDelta = this.stripBidServerTiming(bidDelta);
|
||||
if (broadcastBidDelta) {
|
||||
this.broadcastBid(matchId, broadcastBidDelta);
|
||||
} else {
|
||||
this.broadcastState(matchId, bidResult as AuctionStateResponse);
|
||||
}
|
||||
ack?.({
|
||||
...(bidDelta
|
||||
? {}
|
||||
: { state: this.serializeAuction(bidResult as AuctionStateResponse) }),
|
||||
ok: true,
|
||||
bidRequestId,
|
||||
bidDelta: broadcastBidDelta,
|
||||
bidServerTiming: this.buildGatewayBidTiming(
|
||||
gatewayBidStartedAtMS,
|
||||
bidServerTiming,
|
||||
),
|
||||
});
|
||||
this.broadcastState(matchId, auction);
|
||||
} catch (error) {
|
||||
this.emitKnownError(socket, error);
|
||||
const rejectionAckFields = await this.resolveRejectionAckFields(
|
||||
matchId,
|
||||
error,
|
||||
);
|
||||
const bidServerTiming = this.extractBidServerTiming(rejectionAckFields);
|
||||
this.emitError(socket, String(rejectionAckFields.message ?? ''));
|
||||
ack?.({
|
||||
...rejectionAckFields,
|
||||
bidRequestId,
|
||||
bidServerTiming: this.buildGatewayBidTiming(
|
||||
gatewayBidStartedAtMS,
|
||||
bidServerTiming,
|
||||
),
|
||||
rejected: true,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeMessage('time-sync')
|
||||
public async handleTimeSync(
|
||||
@MessageBody() payload: TimeSyncPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
const receivedAtMonotonicMS = performance.now();
|
||||
try {
|
||||
const currentServerTimestampMS =
|
||||
await this.auctionRedisService.getCurrentRedisTimestampMS();
|
||||
ack?.({
|
||||
clientSentAtTimestampMS: payload?.clientSentAtTimestampMS,
|
||||
currentServerTimestampMS,
|
||||
ok: true,
|
||||
sequence: payload?.sequence,
|
||||
serverProcessingDurationMS:
|
||||
Math.round((performance.now() - receivedAtMonotonicMS) * 10) / 10,
|
||||
});
|
||||
} catch (error) {
|
||||
const errorPayload = this.resolveErrorPayload(error);
|
||||
ack?.({
|
||||
...errorPayload,
|
||||
clientSentAtTimestampMS: payload?.clientSentAtTimestampMS,
|
||||
rejected: true,
|
||||
sequence: payload?.sequence,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeMessage('open-bidding')
|
||||
public async handleOpenBidding(@ConnectedSocket() socket: Socket) {
|
||||
public async handleOpenBidding(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@MessageBody() payload: AuctionActionPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
const matchId = this.requireJoinedMatchId(socket);
|
||||
if (!matchId) return;
|
||||
|
||||
try {
|
||||
const auction = await this.auctionService.openBidding(
|
||||
new mongoose.Types.ObjectId(matchId),
|
||||
this.toSocketAuctionActionRequest(payload),
|
||||
);
|
||||
this.broadcastState(matchId, auction);
|
||||
ack?.({
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
ok: true,
|
||||
});
|
||||
} catch (error) {
|
||||
this.emitKnownError(socket, error);
|
||||
ack?.({
|
||||
...(await this.resolveRejectionAckFields(matchId, error)),
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
rejected: true,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@@ -159,6 +294,7 @@ export class AuctionGateway
|
||||
public async handleSold(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@MessageBody() payload: SoldPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
const matchId = this.requireJoinedMatchId(socket);
|
||||
if (!matchId) return;
|
||||
@@ -167,25 +303,78 @@ export class AuctionGateway
|
||||
const auction = await this.auctionService.markSold({
|
||||
matchId: new mongoose.Types.ObjectId(matchId),
|
||||
assignedPosition: payload?.assignedPosition,
|
||||
...this.toSocketAuctionActionRequest(payload),
|
||||
});
|
||||
this.broadcastState(matchId, auction);
|
||||
ack?.({
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
ok: true,
|
||||
});
|
||||
} catch (error) {
|
||||
this.emitKnownError(socket, error);
|
||||
ack?.({
|
||||
...(await this.resolveRejectionAckFields(matchId, error)),
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
rejected: true,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeMessage('next')
|
||||
public async handleNext(@ConnectedSocket() socket: Socket) {
|
||||
public async handleNext(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@MessageBody() payload: AuctionActionPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
const matchId = this.requireJoinedMatchId(socket);
|
||||
if (!matchId) return;
|
||||
|
||||
try {
|
||||
const auction = await this.auctionService.next(
|
||||
new mongoose.Types.ObjectId(matchId),
|
||||
this.toSocketAuctionActionRequest(payload),
|
||||
);
|
||||
this.broadcastState(matchId, auction);
|
||||
ack?.({
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
ok: true,
|
||||
});
|
||||
} catch (error) {
|
||||
this.emitKnownError(socket, error);
|
||||
ack?.({
|
||||
...(await this.resolveRejectionAckFields(matchId, error)),
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
rejected: true,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeMessage('passed')
|
||||
public async handlePassed(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@MessageBody() payload: AuctionActionPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
const matchId = this.requireJoinedMatchId(socket);
|
||||
if (!matchId) return;
|
||||
|
||||
try {
|
||||
const auction = await this.auctionService.markPassed(
|
||||
new mongoose.Types.ObjectId(matchId),
|
||||
this.toSocketAuctionActionRequest(payload),
|
||||
);
|
||||
this.broadcastState(matchId, auction);
|
||||
ack?.({
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
ok: true,
|
||||
});
|
||||
} catch (error) {
|
||||
this.emitKnownError(socket, error);
|
||||
ack?.({
|
||||
...(await this.resolveRejectionAckFields(matchId, error)),
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
rejected: true,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@@ -226,24 +415,52 @@ 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 toSocketAuctionActionRequest(payload?: AuctionActionPayload) {
|
||||
return {
|
||||
...this.toAuctionActionRequest(payload),
|
||||
shouldBroadcastStateAfterDurability: false,
|
||||
};
|
||||
}
|
||||
|
||||
private readHandshakeUserId(socket: Socket): string | undefined {
|
||||
@@ -359,16 +576,25 @@ export class AuctionGateway
|
||||
return typeof value === 'string' && value.length > 0 ? value : undefined;
|
||||
}
|
||||
|
||||
public broadcastState(matchId: string, auction: AuctionDocument) {
|
||||
this.server.to(matchId).emit('state', this.serializeAuction(auction));
|
||||
this.syncRoomTimer(matchId, auction);
|
||||
public broadcastState(matchId: string, auction: AuctionStateResponse) {
|
||||
this.server.to(matchId).emit('state', serializeRealtimeAuction(auction));
|
||||
}
|
||||
|
||||
public broadcastBid(matchId: string, delta: Record<string, unknown>) {
|
||||
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 +603,207 @@ 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 });
|
||||
this.emitError(socket, this.resolveErrorPayload(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));
|
||||
}
|
||||
|
||||
/**
|
||||
* 거부 ack에 실을 공통 필드를 만든다.
|
||||
*
|
||||
* - `code`/`message`: 기존 내부 코드/문구(진단·하위호환).
|
||||
* - `auctionRejectionReason`: 맥락을 담은 설명적 거부코드(클라가 문구로 매핑).
|
||||
* - `resyncRecommended`: "내가 본 상태가 낡았다"는 신호면 true.
|
||||
* - `state`: resync 권장 거부에 한해 최신 권위 state를 동봉해, 클라가 join
|
||||
* 왕복 없이 즉시 rebaseline하도록 한다(후속 액션의 반복 CONFLICT 차단).
|
||||
*/
|
||||
private async resolveRejectionAckFields(
|
||||
matchId: string,
|
||||
error: unknown,
|
||||
): Promise<Record<string, unknown>> {
|
||||
const errorPayload = this.resolveErrorPayload(error);
|
||||
const auctionRejectionReason = resolveAuctionRejectionReason(
|
||||
typeof errorPayload.code === 'string' ? errorPayload.code : undefined,
|
||||
errorPayload.message,
|
||||
);
|
||||
const resyncRecommended = isAuctionResyncRecommended(auctionRejectionReason);
|
||||
const state = resyncRecommended
|
||||
? await this.fetchSerializedAuctionState(matchId)
|
||||
: undefined;
|
||||
return {
|
||||
...errorPayload,
|
||||
auctionRejectionReason,
|
||||
resyncRecommended,
|
||||
...(state ? { state } : {}),
|
||||
};
|
||||
}
|
||||
|
||||
private async fetchSerializedAuctionState(
|
||||
matchId: string,
|
||||
): Promise<Record<string, unknown> | undefined> {
|
||||
try {
|
||||
const state = await this.auctionService.getStateByMatchId(
|
||||
new mongoose.Types.ObjectId(matchId),
|
||||
);
|
||||
return state ? this.serializeAuction(state) : undefined;
|
||||
} catch {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
private resolveErrorPayload(error: unknown): Record<string, unknown> & {
|
||||
message: string;
|
||||
} {
|
||||
const response =
|
||||
typeof (error as { getResponse?: unknown })?.getResponse === 'function'
|
||||
? (error as { getResponse: () => unknown }).getResponse()
|
||||
: undefined;
|
||||
if (typeof response === 'object' && response !== null) {
|
||||
const record = response as Record<string, unknown>;
|
||||
const message = Array.isArray(record.message)
|
||||
? record.message.join(', ')
|
||||
: typeof record.message === 'string'
|
||||
? record.message
|
||||
: error instanceof Error
|
||||
? error.message
|
||||
: 'Unexpected auction gateway error.';
|
||||
return {
|
||||
...record,
|
||||
code:
|
||||
typeof record.code === 'string'
|
||||
? record.code
|
||||
: error instanceof Error
|
||||
? error.message
|
||||
: 'UNKNOWN',
|
||||
message,
|
||||
};
|
||||
}
|
||||
return {
|
||||
code: error instanceof Error ? error.message : 'UNKNOWN',
|
||||
message:
|
||||
error instanceof Error ? error.message : 'Unexpected auction gateway error.',
|
||||
};
|
||||
}
|
||||
|
||||
private buildGatewayBidTiming(
|
||||
gatewayBidStartedAtMS: number,
|
||||
bidServerTiming?: Record<string, unknown>,
|
||||
): Record<string, unknown> {
|
||||
return {
|
||||
...(bidServerTiming ?? {}),
|
||||
gatewayTotalDurationMS:
|
||||
Math.round((performance.now() - gatewayBidStartedAtMS) * 10) / 10,
|
||||
};
|
||||
}
|
||||
|
||||
private extractBidServerTiming(
|
||||
bidDelta: Record<string, unknown> | null,
|
||||
): Record<string, unknown> | undefined {
|
||||
const timing = bidDelta?.bidServerTiming;
|
||||
return typeof timing === 'object' && timing !== null
|
||||
? (timing as Record<string, unknown>)
|
||||
: undefined;
|
||||
}
|
||||
|
||||
private stripBidServerTiming(
|
||||
bidDelta: Record<string, unknown> | null,
|
||||
): Record<string, unknown> | null {
|
||||
if (!bidDelta || !('bidServerTiming' in bidDelta)) return bidDelta;
|
||||
const { bidServerTiming: _bidServerTiming, ...publicBidDelta } = bidDelta;
|
||||
return publicBidDelta;
|
||||
}
|
||||
|
||||
private buildBidDeltaFromAuctionState(
|
||||
auction: AuctionStateResponse,
|
||||
bidRequestId?: string,
|
||||
): Record<string, unknown> | null {
|
||||
const serialized = this.serializeAuction(auction) as Record<string, unknown>;
|
||||
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 isBidDeltaResponse(
|
||||
value: unknown,
|
||||
): value is AuctionBidDeltaResponse {
|
||||
return (
|
||||
typeof value === 'object' &&
|
||||
value !== null &&
|
||||
'auctionBidHistoryEntry' in value &&
|
||||
'currentHighestBidPointAmount' in value &&
|
||||
'currentHighestBidderTeamIndex' in value &&
|
||||
'revision' in value
|
||||
);
|
||||
}
|
||||
|
||||
private convertLegacyBidToRedisBidHistoryEntry(
|
||||
bid: unknown,
|
||||
): Record<string, unknown> | null {
|
||||
if (!bid || typeof bid !== 'object') return null;
|
||||
const record = bid as Record<string, unknown>;
|
||||
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));
|
||||
}
|
||||
|
||||
@@ -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 {}
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -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;
|
||||
|
||||
@@ -0,0 +1,379 @@
|
||||
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<AuctionRedisService>;
|
||||
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',
|
||||
'31000',
|
||||
]);
|
||||
|
||||
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',
|
||||
currentBidRoundDeadlineTimestampMS: 31_000,
|
||||
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,
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,384 @@
|
||||
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<string, unknown>;
|
||||
bidRequestId: string;
|
||||
currentBidRoundDeadlineTimestampMS: number;
|
||||
currentHighestBidderTeamIndex: number;
|
||||
currentHighestBidPointAmount: number;
|
||||
currentServerTimestampMS: number;
|
||||
isReplay?: boolean;
|
||||
ok: true;
|
||||
revision: number;
|
||||
}
|
||||
| {
|
||||
bidRequestId: string;
|
||||
code: string;
|
||||
currentBidRoundDeadlineTimestampMS?: number;
|
||||
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<AuctionBidCommandResult> {
|
||||
const invocation = buildAuctionBidScriptInvocation(
|
||||
buildAuctionRedisKeys(matchId),
|
||||
input,
|
||||
);
|
||||
const reply = await this.auctionRedisService.evalScript<unknown[]>(
|
||||
invocation.script,
|
||||
invocation.keys,
|
||||
invocation.values,
|
||||
);
|
||||
return parseBidCommandReply(reply);
|
||||
}
|
||||
|
||||
public async reserveActionRequest(
|
||||
matchId: string,
|
||||
input: AuctionReserveActionRequestScriptInput,
|
||||
): Promise<AuctionReserveActionRequestCommandResult> {
|
||||
const invocation = buildAuctionReserveActionRequestScriptInvocation(
|
||||
buildAuctionRedisKeys(matchId),
|
||||
input,
|
||||
);
|
||||
const reply = await this.auctionRedisService.evalScript<unknown[]>(
|
||||
invocation.script,
|
||||
invocation.keys,
|
||||
invocation.values,
|
||||
);
|
||||
return parseReserveActionRequestReply(reply);
|
||||
}
|
||||
|
||||
public async applyTransition(
|
||||
matchId: string,
|
||||
input: AuctionApplyTransitionScriptInput,
|
||||
): Promise<AuctionApplyTransitionCommandResult> {
|
||||
const invocation = buildAuctionApplyTransitionScriptInvocation(
|
||||
buildAuctionRedisKeys(matchId),
|
||||
input,
|
||||
);
|
||||
const reply = await this.auctionRedisService.evalScript<unknown[]>(
|
||||
invocation.script,
|
||||
invocation.keys,
|
||||
invocation.values,
|
||||
);
|
||||
return parseApplyTransitionReply(reply);
|
||||
}
|
||||
|
||||
public async expirePrepare(
|
||||
matchId: string,
|
||||
input: AuctionExpirePrepareScriptInput,
|
||||
): Promise<AuctionExpirePrepareCommandResult> {
|
||||
const invocation = buildAuctionExpirePrepareScriptInvocation(
|
||||
buildAuctionRedisKeys(matchId),
|
||||
input,
|
||||
);
|
||||
const reply = await this.auctionRedisService.evalScript<unknown[]>(
|
||||
invocation.script,
|
||||
invocation.keys,
|
||||
invocation.values,
|
||||
);
|
||||
return parseExpirePrepareReply(reply);
|
||||
}
|
||||
|
||||
public async hydrateState(
|
||||
matchId: string,
|
||||
input: HydrateAuctionStateScriptInput,
|
||||
): Promise<AuctionHydrateStateCommandResult> {
|
||||
const invocation = buildHydrateAuctionStateScriptInvocation(
|
||||
buildAuctionRedisKeys(matchId),
|
||||
input,
|
||||
);
|
||||
const reply = await this.auctionRedisService.evalScript<unknown[]>(
|
||||
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,
|
||||
currentBidRoundDeadlineTimestampMS: optionalNumberValue(values[7]),
|
||||
currentServerTimestampMS: numberValue(values[9]),
|
||||
isReplay: true,
|
||||
rejected: true,
|
||||
};
|
||||
}
|
||||
return {
|
||||
bidRequestId: values[2] ?? '',
|
||||
code: values[1] ?? 'UNKNOWN',
|
||||
currentBidRoundDeadlineTimestampMS: optionalNumberValue(values[4]),
|
||||
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;
|
||||
}
|
||||
|
||||
function optionalNumberValue(value: string | undefined): number | undefined {
|
||||
if (value === undefined || value === '') return undefined;
|
||||
const parsed = Number(value);
|
||||
return Number.isFinite(parsed) ? parsed : undefined;
|
||||
}
|
||||
@@ -0,0 +1,153 @@
|
||||
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:captainUserId': captainUserId.toString(),
|
||||
'team:2:remainingBidPointAmount': 970,
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,94 @@
|
||||
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<string, unknown> {
|
||||
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<string, string | number> {
|
||||
const patch: Record<string, string | number> = {
|
||||
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}:captainUserId`] =
|
||||
team.captainUserId.toString();
|
||||
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<string>([team.captainUserId.toString()]);
|
||||
for (const member of team.members) {
|
||||
userIds.add(member.userId.toString());
|
||||
}
|
||||
return userIds.size;
|
||||
}
|
||||
@@ -0,0 +1,200 @@
|
||||
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<AuctionRedisService>;
|
||||
|
||||
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('reads bid context from the live state hot path fields', async () => {
|
||||
const { service, sendCommand } = makeService([
|
||||
['bidding', 'life-1', 'player-1', 'captain-2'],
|
||||
]);
|
||||
|
||||
await expect(service.readBidContext('match-1', 2)).resolves.toEqual({
|
||||
auctionLifecycleId: 'life-1',
|
||||
bidderTeamCaptainUserId: 'captain-2',
|
||||
currentBidRoundPlayerUserId: 'player-1',
|
||||
phase: 'bidding',
|
||||
});
|
||||
expect(sendCommand).toHaveBeenCalledTimes(1);
|
||||
expect(sendCommand).toHaveBeenCalledWith([
|
||||
'HMGET',
|
||||
'auction:match-1:liveAuctionState',
|
||||
'phase',
|
||||
'auctionLifecycleId',
|
||||
'currentBidRoundPlayerUserId',
|
||||
'team:2:captainUserId',
|
||||
]);
|
||||
});
|
||||
|
||||
it('falls back to structure state when bid context has no live captain field', async () => {
|
||||
const { service, sendCommand } = makeService([
|
||||
['bidding', 'life-1', 'player-1', null],
|
||||
'{"auctionTeams":[{"teamIndex":2,"captainUserId":"captain-2"}]}',
|
||||
]);
|
||||
|
||||
await expect(service.readBidContext('match-1', 2)).resolves.toEqual({
|
||||
auctionLifecycleId: 'life-1',
|
||||
bidderTeamCaptainUserId: 'captain-2',
|
||||
currentBidRoundPlayerUserId: 'player-1',
|
||||
phase: 'bidding',
|
||||
});
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(2, [
|
||||
'GET',
|
||||
'auction:match-1:auctionStructureState',
|
||||
]);
|
||||
});
|
||||
|
||||
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();
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,229 @@
|
||||
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 AuctionRedisBidContext {
|
||||
auctionLifecycleId: string;
|
||||
bidderTeamCaptainUserId?: string;
|
||||
currentBidRoundPlayerUserId?: string;
|
||||
phase: string;
|
||||
}
|
||||
|
||||
export interface AuctionRedisStateViewReadOptions {
|
||||
includeInternalLiveStateFields?: boolean;
|
||||
shouldForceAuctionStateResync?: boolean;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class AuctionRedisStateReaderService {
|
||||
constructor(private readonly auctionRedisService: AuctionRedisService) {}
|
||||
|
||||
public async readLiveStateIdentity(
|
||||
matchId: string,
|
||||
): Promise<AuctionRedisLiveStateIdentity | null> {
|
||||
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 readBidContext(
|
||||
matchId: string,
|
||||
bidderTeamIndex: number,
|
||||
): Promise<AuctionRedisBidContext | null> {
|
||||
const keys = buildAuctionRedisKeys(matchId);
|
||||
const bidderTeamCaptainUserIdField = `team:${bidderTeamIndex}:captainUserId`;
|
||||
const liveReply = await this.auctionRedisService.raw().sendCommand([
|
||||
'HMGET',
|
||||
keys.liveStateKey,
|
||||
'phase',
|
||||
'auctionLifecycleId',
|
||||
'currentBidRoundPlayerUserId',
|
||||
bidderTeamCaptainUserIdField,
|
||||
]);
|
||||
if (!Array.isArray(liveReply)) return null;
|
||||
|
||||
const phase = stringValue(liveReply[0]);
|
||||
const auctionLifecycleId = stringValue(liveReply[1]);
|
||||
const currentBidRoundPlayerUserId = stringValue(liveReply[2]);
|
||||
const liveCaptainUserId = stringValue(liveReply[3]);
|
||||
if (!phase || !auctionLifecycleId) return null;
|
||||
|
||||
return {
|
||||
auctionLifecycleId,
|
||||
bidderTeamCaptainUserId:
|
||||
liveCaptainUserId ??
|
||||
(await this.readBidderTeamCaptainUserIdFromStructure(
|
||||
keys.structureStateKey,
|
||||
bidderTeamIndex,
|
||||
)),
|
||||
currentBidRoundPlayerUserId,
|
||||
phase,
|
||||
};
|
||||
}
|
||||
|
||||
public async readAuctionStateView(
|
||||
matchId: string,
|
||||
options: AuctionRedisStateViewReadOptions = {},
|
||||
): Promise<Record<string, unknown> | 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<string, unknown> & {
|
||||
auctionLifecycleId: string;
|
||||
phase: string;
|
||||
revision: number;
|
||||
},
|
||||
shouldForceAuctionStateResync: options.shouldForceAuctionStateResync,
|
||||
structureState: JSON.parse(structureStateJson) as Record<string, unknown>,
|
||||
});
|
||||
view.matchId = matchId;
|
||||
if (options.includeInternalLiveStateFields) {
|
||||
view.redisInternalPhase = liveState.phase;
|
||||
}
|
||||
return view;
|
||||
}
|
||||
|
||||
private async readBidderTeamCaptainUserIdFromStructure(
|
||||
structureStateKey: string,
|
||||
bidderTeamIndex: number,
|
||||
): Promise<string | undefined> {
|
||||
const structureStateJson = await this.auctionRedisService
|
||||
.raw()
|
||||
.sendCommand(['GET', structureStateKey]);
|
||||
if (typeof structureStateJson !== 'string' || !structureStateJson) {
|
||||
return undefined;
|
||||
}
|
||||
const structureState = JSON.parse(structureStateJson) as Record<
|
||||
string,
|
||||
unknown
|
||||
>;
|
||||
const auctionTeams = Array.isArray(structureState.auctionTeams)
|
||||
? structureState.auctionTeams
|
||||
: [];
|
||||
const bidderTeam = auctionTeams.find((entry) => {
|
||||
if (!entry || typeof entry !== 'object') return false;
|
||||
return (
|
||||
Number((entry as Record<string, unknown>).teamIndex) === bidderTeamIndex
|
||||
);
|
||||
});
|
||||
if (!bidderTeam || typeof bidderTeam !== 'object') return undefined;
|
||||
return stringValue((bidderTeam as Record<string, unknown>).captainUserId);
|
||||
}
|
||||
}
|
||||
|
||||
function stringValue(value: unknown): string | undefined {
|
||||
return typeof value === 'string' && value ? value : undefined;
|
||||
}
|
||||
|
||||
function parseHashReply(
|
||||
reply: unknown,
|
||||
options: { includeInternalLiveStateFields?: boolean } = {},
|
||||
): Record<string, unknown> | 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<string, unknown>);
|
||||
if (entries.length === 0) return null;
|
||||
return parseHashEntries(entries, options);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function parseHashEntries(
|
||||
entries: [string, unknown][],
|
||||
options: { includeInternalLiveStateFields?: boolean } = {},
|
||||
): Record<string, unknown> {
|
||||
const result: Record<string, unknown> = {};
|
||||
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');
|
||||
}
|
||||
@@ -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'",
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -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<string, string | number | boolean | null | undefined>;
|
||||
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)}
|
||||
`,
|
||||
);
|
||||
@@ -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');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,313 @@
|
||||
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)
|
||||
local rejectedCurrentBidRoundDeadlineTimestampMS = redis.call('HGET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS') or ''
|
||||
redis.call(
|
||||
'HSET',
|
||||
bidRequestResultsKey,
|
||||
requestField('fingerprint'),
|
||||
bidRequestPayloadFingerprint,
|
||||
requestField('status'),
|
||||
'rejected',
|
||||
requestField('rejectCode'),
|
||||
rejectCode,
|
||||
requestField('currentBidRoundDeadlineTimestampMS'),
|
||||
rejectedCurrentBidRoundDeadlineTimestampMS,
|
||||
requestField('responseServerTimestampMS'),
|
||||
tostring(currentRedisTimestampMS),
|
||||
requestField('createdAtTimestampMS'),
|
||||
tostring(currentRedisTimestampMS)
|
||||
)
|
||||
redis.call('RPUSH', bidRequestResultOrderKey, bidRequestId)
|
||||
return {'REJECTED', rejectCode, bidRequestId, tostring(currentRedisTimestampMS), rejectedCurrentBidRoundDeadlineTimestampMS}
|
||||
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;
|
||||
@@ -0,0 +1 @@
|
||||
export const AUCTION_REDIS_CLIENT = Symbol('AUCTION_REDIS_CLIENT');
|
||||
@@ -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'");
|
||||
});
|
||||
});
|
||||
@@ -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)
|
||||
}
|
||||
`,
|
||||
);
|
||||
@@ -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',
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -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`,
|
||||
};
|
||||
}
|
||||
@@ -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<string | undefined> {
|
||||
for (const key of keys) {
|
||||
const value = await secretService.get<string>(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<AuctionRedisClient> => {
|
||||
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 {}
|
||||
@@ -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',
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -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)
|
||||
}
|
||||
`,
|
||||
);
|
||||
@@ -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'),
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -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'),
|
||||
};
|
||||
}
|
||||
@@ -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);
|
||||
});
|
||||
});
|
||||
@@ -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<typeof createClient>;
|
||||
|
||||
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<number> {
|
||||
const reply = await this.client.sendCommand(['TIME']);
|
||||
return parseRedisTimeReply(reply);
|
||||
}
|
||||
|
||||
public async evalShaWithReload<T = unknown>(
|
||||
params: EvalShaWithReloadParams,
|
||||
): Promise<T> {
|
||||
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<T = unknown>(
|
||||
script: AuctionRedisScriptDefinition,
|
||||
keys: string[],
|
||||
values: string[],
|
||||
): Promise<T> {
|
||||
return this.evalShaWithReload<T>({
|
||||
keys,
|
||||
script: script.lua,
|
||||
scriptSha: script.sha,
|
||||
values,
|
||||
});
|
||||
}
|
||||
|
||||
public async acquireTokenLock(
|
||||
key: string,
|
||||
token: string,
|
||||
ttlMS: number,
|
||||
): Promise<boolean> {
|
||||
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<boolean> {
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -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'");
|
||||
});
|
||||
});
|
||||
@@ -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<AuctionRedisRevisionIdentity>;
|
||||
}
|
||||
|
||||
export interface AssembleAuctionViewParams {
|
||||
auctionBidHistoryEntries: string[];
|
||||
currentServerTimestampMS: number;
|
||||
liveState: Record<string, unknown> & {
|
||||
auctionLifecycleId: string;
|
||||
phase: string;
|
||||
revision: number;
|
||||
};
|
||||
shouldForceAuctionStateResync?: boolean;
|
||||
structureState: Record<string, unknown>;
|
||||
}
|
||||
|
||||
export interface HydrateAuctionStateScriptInput {
|
||||
auctionHistorySequence: number;
|
||||
auctionLifecycleId: string;
|
||||
liveStatePatch?: Record<string, string | number | boolean | null | undefined>;
|
||||
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<string, unknown> {
|
||||
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)}
|
||||
`,
|
||||
);
|
||||
@@ -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<T>(key: string): Promise<T | null> {
|
||||
return this.garnetService.getJson<T>(key);
|
||||
return this.redisService.getJson<T>(key);
|
||||
}
|
||||
|
||||
public set(
|
||||
@@ -19,7 +19,7 @@ export class CommunityStatsCacheService {
|
||||
value: unknown,
|
||||
ttlSeconds = COMMUNITY_STATS_TTL_SECONDS,
|
||||
): Promise<void> {
|
||||
return this.garnetService.setJson(key, value, ttlSeconds);
|
||||
return this.redisService.setJson(key, value, ttlSeconds);
|
||||
}
|
||||
|
||||
public setDetail(key: string, value: unknown): Promise<void> {
|
||||
@@ -29,7 +29,7 @@ export class CommunityStatsCacheService {
|
||||
public async invalidateCommunity(communityId: string): Promise<number> {
|
||||
const prefix = `riot:communitystats:`;
|
||||
const match = `${prefix}*${communityId}*`;
|
||||
const client = this.garnetService.raw();
|
||||
const client = this.redisService.raw();
|
||||
let cursor = '0';
|
||||
let deleted = 0;
|
||||
|
||||
|
||||
@@ -0,0 +1,94 @@
|
||||
import {
|
||||
AuctionHistoryEntrySchema,
|
||||
AuctionSchema,
|
||||
AuctionSideEffectApplicationSchema,
|
||||
tournamentModelDefinitions,
|
||||
} from './schema';
|
||||
|
||||
function indexWithKeys(
|
||||
schemaIndexes: ReturnType<typeof AuctionSchema.indexes>,
|
||||
expectedKeys: Record<string, 1 | -1>,
|
||||
) {
|
||||
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<string>('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);
|
||||
});
|
||||
});
|
||||
@@ -95,6 +95,6 @@ export class ConnectionService implements OnModuleInit {
|
||||
}
|
||||
|
||||
public async onModuleDestroy() {
|
||||
this.connection?.close();
|
||||
await this.connection?.close();
|
||||
}
|
||||
}
|
||||
+219
@@ -0,0 +1,219 @@
|
||||
import { migrateAuctionRedisFieldRename } from './20260622-auction-redis-field-rename';
|
||||
|
||||
type Doc = Record<string, unknown> & { _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<string, unknown>;
|
||||
$unset?: Record<string, ''>;
|
||||
};
|
||||
};
|
||||
}>) {
|
||||
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');
|
||||
});
|
||||
});
|
||||
+336
@@ -0,0 +1,336 @@
|
||||
interface MigrationCollection {
|
||||
find(filter: Record<string, unknown>): {
|
||||
limit(limit: number): AsyncIterable<AnyDoc>;
|
||||
};
|
||||
bulkWrite(
|
||||
writes: Array<{
|
||||
updateOne: {
|
||||
filter: { _id: unknown };
|
||||
update: { $set?: Record<string, unknown>; $unset?: Record<string, ''> };
|
||||
};
|
||||
}>,
|
||||
options: { ordered: boolean },
|
||||
): Promise<unknown>;
|
||||
}
|
||||
|
||||
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<string, unknown> & { _id: unknown };
|
||||
type UpdateDoc = { $set?: Record<string, unknown>; $unset?: Record<string, ''> };
|
||||
|
||||
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<MigrationStats> {
|
||||
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<number> {
|
||||
const seen = new Set<string>();
|
||||
const duplicates = new Set<string>();
|
||||
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<string, unknown> = {};
|
||||
const unset: Record<string, ''> = {};
|
||||
|
||||
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<string, unknown> = {};
|
||||
const unset: Record<string, ''> = {};
|
||||
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<string, unknown>): {
|
||||
changed: boolean;
|
||||
value: Record<string, unknown>;
|
||||
} {
|
||||
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<string, unknown>,
|
||||
from: string,
|
||||
to: string,
|
||||
set: Record<string, unknown>,
|
||||
unset: Record<string, ''>,
|
||||
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<string, unknown>,
|
||||
set: Record<string, unknown>,
|
||||
key: string,
|
||||
value: unknown,
|
||||
) {
|
||||
if (value === undefined || key in doc || key in set) return;
|
||||
set[key] = value;
|
||||
}
|
||||
|
||||
function buildUpdate(
|
||||
set: Record<string, unknown>,
|
||||
unset: Record<string, ''>,
|
||||
): 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<string, unknown> = {};
|
||||
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<string, unknown>[] {
|
||||
return Array.isArray(value)
|
||||
? value.filter(isRecord).map((item) => ({ ...item }))
|
||||
: [];
|
||||
}
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return Boolean(value && typeof value === 'object' && !Array.isArray(value));
|
||||
}
|
||||
@@ -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 <env> dev | staging | prod. Default: NODE_ENV or dev.
|
||||
--limit <n> Only scan first n documents per collection.
|
||||
--list-duplicates
|
||||
Print duplicate auctionHistory auctionId+sequence samples.
|
||||
--duplicate-sample-limit <n>
|
||||
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<mongoose.Connection['db']>,
|
||||
): Promise<unknown[]> {
|
||||
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<mongoose.Connection['db']>,
|
||||
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<typeof listDuplicateHistorySequences>
|
||||
>) {
|
||||
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<mongoose.Connection['db']>,
|
||||
dryRun: boolean,
|
||||
): Promise<DuplicateSequenceRepairStats> {
|
||||
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<string, unknown>,
|
||||
{ $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<typeof migrateAuctionRedisFieldRename>[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;
|
||||
});
|
||||
@@ -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<Auction>;
|
||||
@@ -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<string, unknown>;
|
||||
historyMutation?: AuctionHistoryMutation;
|
||||
matchSideEffectMutation?: Record<string, unknown>;
|
||||
takenAt: Date;
|
||||
}
|
||||
|
||||
export type AuctionHistoryEntryDocument = HydratedDocument<AuctionHistoryEntry>;
|
||||
|
||||
export interface AuctionSideEffectApplication extends MongooseTimestamps {
|
||||
auctionId: mongoose.Types.ObjectId;
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
auctionStateTransitionId: string;
|
||||
auctionLifecycleId: string;
|
||||
sideEffectType: string;
|
||||
state: AuctionSideEffectApplicationState;
|
||||
payload: Record<string, unknown>;
|
||||
payloadChecksum: string;
|
||||
attempts: number;
|
||||
processingStartedAtTimestampMS?: number;
|
||||
processingLeaseExpiresAtTimestampMS?: number;
|
||||
processingOwnerToken?: string;
|
||||
completedAtTimestampMS?: number;
|
||||
lastError?: string;
|
||||
}
|
||||
|
||||
export type AuctionSideEffectApplicationDocument =
|
||||
HydratedDocument<AuctionSideEffectApplication>;
|
||||
|
||||
// ===== MatchStats (precomputed internal stats fragment) =====
|
||||
export interface MatchStatsRuneStyleSelection {
|
||||
styleId: number;
|
||||
@@ -1646,6 +1747,34 @@ const AuctionTeamSubSchema = new Schema<AuctionTeam>(
|
||||
{ _id: false },
|
||||
);
|
||||
|
||||
const RedisAuctionTeamMemberSubSchema = new Schema<RedisAuctionTeamMember>(
|
||||
{
|
||||
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<RedisAuctionTeam>(
|
||||
{
|
||||
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<AuctionBid>(
|
||||
{
|
||||
teamIndex: { type: Number, required: true, min: 1 },
|
||||
@@ -1656,6 +1785,16 @@ const AuctionBidSubSchema = new Schema<AuctionBid>(
|
||||
{ _id: false },
|
||||
);
|
||||
|
||||
const AuctionBidHistoryEntrySubSchema = new Schema<AuctionBidHistoryEntry>(
|
||||
{
|
||||
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<AuctionChatMessage>(
|
||||
{
|
||||
id: { type: String, required: true },
|
||||
@@ -1681,6 +1820,40 @@ export const AuctionSchema = new Schema<Auction>(
|
||||
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<Auction>(
|
||||
},
|
||||
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<Auction>(
|
||||
},
|
||||
);
|
||||
|
||||
const AuctionHistoryEntrySchema = new Schema<AuctionHistoryEntry>(
|
||||
export const AuctionHistoryEntrySchema = new Schema<AuctionHistoryEntry>(
|
||||
{
|
||||
auctionId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
@@ -1744,19 +1966,16 @@ const AuctionHistoryEntrySchema = new Schema<AuctionHistoryEntry>(
|
||||
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<AuctionHistoryEntry>(
|
||||
);
|
||||
|
||||
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<AuctionSideEffectApplication>(
|
||||
{
|
||||
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<MatchStats> = 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;
|
||||
}
|
||||
@@ -1 +0,0 @@
|
||||
export const GARNET_CLIENT = Symbol('GARNET_CLIENT');
|
||||
@@ -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<GarnetRedisClient> => {
|
||||
await secretService.ready();
|
||||
|
||||
const [endpoint, username, password] = await Promise.all([
|
||||
secretService.get<string>('GARNET_ENDPOINT'),
|
||||
secretService.get<string>('GARNET_USERID'),
|
||||
secretService.get<string>('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 {}
|
||||
@@ -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 {}
|
||||
@@ -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();
|
||||
});
|
||||
});
|
||||
@@ -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.',
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
export const REDIS_CLIENT = Symbol('REDIS_CLIENT');
|
||||
@@ -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<string | undefined> {
|
||||
for (const key of keys) {
|
||||
const value = await secretService.get<string>(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<RedisClient> => {
|
||||
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 {}
|
||||
+6
-8
@@ -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<typeof createClient>;
|
||||
export type RedisClient = ReturnType<typeof createClient>;
|
||||
|
||||
export interface StreamEntry {
|
||||
deliveriesCounter?: number;
|
||||
@@ -48,12 +48,10 @@ function normalizeStreamFields(fields: unknown): Record<string, string> {
|
||||
}
|
||||
|
||||
@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;
|
||||
}
|
||||
|
||||
@@ -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<StartLegacyImportResponse> {
|
||||
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<ImportOutcome> {
|
||||
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(
|
||||
|
||||
@@ -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<GarnetService> & { raw: jest.Mock };
|
||||
} as unknown as jest.Mocked<RedisService> & { raw: jest.Mock };
|
||||
const rateLimiter = {
|
||||
isRefreshWindowOpen: jest.fn().mockResolvedValue(true),
|
||||
} as unknown as jest.Mocked<RiotRateLimiterService>;
|
||||
@@ -51,7 +51,7 @@ function makeScheduler() {
|
||||
findStaleAccounts: jest.fn().mockResolvedValue([]),
|
||||
} as unknown as jest.Mocked<StaleAccountRepository>;
|
||||
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;
|
||||
});
|
||||
|
||||
@@ -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<boolean> {
|
||||
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<void> {
|
||||
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<number> {
|
||||
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<void> {
|
||||
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<void> {
|
||||
await this.garnet.delete(this.failureBackoffKey(puuid));
|
||||
await this.redis.delete(this.failureBackoffKey(puuid));
|
||||
}
|
||||
|
||||
private isFailedEnrichment(result: EnrichResult): boolean {
|
||||
|
||||
@@ -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<number> {
|
||||
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<RiotJobStatus | null> {
|
||||
return this.garnetService.getJson<RiotJobStatus>(this.statusKey(jobId));
|
||||
return this.redisService.getJson<RiotJobStatus>(this.statusKey(jobId));
|
||||
}
|
||||
|
||||
public async getParentStatus(
|
||||
parentJobId: string,
|
||||
): Promise<RiotParentJobStatus | null> {
|
||||
const jobIds = await this.garnetService.getJson<string[]>(
|
||||
const jobIds = await this.redisService.getJson<string[]>(
|
||||
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<void> {
|
||||
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<void> {
|
||||
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<void> {
|
||||
await this.garnetService.setJson(
|
||||
await this.redisService.setJson(
|
||||
this.parentKey(parentJobId),
|
||||
jobIds,
|
||||
RIOT_JOB_STATUS_TTL_SECONDS,
|
||||
|
||||
@@ -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<T>(value: T) {
|
||||
}
|
||||
|
||||
function makeWorker() {
|
||||
const garnetService = {
|
||||
const redisService = {
|
||||
acknowledgeStream: jest.fn().mockResolvedValue(undefined),
|
||||
deleteStreamEntries: jest.fn().mockResolvedValue(undefined),
|
||||
} as unknown as jest.Mocked<GarnetService>;
|
||||
} as unknown as jest.Mocked<RedisService>;
|
||||
const jobQueueService = {
|
||||
markProcessing: jest.fn().mockResolvedValue(undefined),
|
||||
markCompleted: jest.fn().mockResolvedValue({
|
||||
@@ -53,7 +53,7 @@ function makeWorker() {
|
||||
} as unknown as jest.Mocked<RiotAccountEnrichmentService>;
|
||||
|
||||
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],
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -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<void> {
|
||||
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<void> {
|
||||
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<boolean> {
|
||||
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,
|
||||
|
||||
@@ -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<string, Promise<DdragonManifest>>();
|
||||
|
||||
constructor(private readonly garnetService: GarnetService) {}
|
||||
constructor(private readonly redisService: RedisService) {}
|
||||
|
||||
public async getManifest(locale: string = DEFAULT_LOCALE): Promise<DdragonManifest> {
|
||||
const normalizedLocale = normalizeLocale(locale);
|
||||
const cacheKey = manifestCacheKey(normalizedLocale);
|
||||
|
||||
const cached = await this.garnetService.getJson<DdragonManifest>(cacheKey);
|
||||
const cached = await this.redisService.getJson<DdragonManifest>(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(() => {
|
||||
|
||||
@@ -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<GarnetService>;
|
||||
} as unknown as jest.Mocked<RedisService>;
|
||||
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,
|
||||
|
||||
@@ -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<number> {
|
||||
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<AppRateObservation | null> {
|
||||
const raw = await this.garnet.getString(APP_OBSERVED_KEY);
|
||||
const raw = await this.redis.getString(APP_OBSERVED_KEY);
|
||||
if (!raw) return null;
|
||||
|
||||
try {
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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<typeof createAdapter>;
|
||||
type DuplicatedRedisClient = ReturnType<AuctionRedisClient['duplicate']>;
|
||||
|
||||
export class RedisIoAdapter extends IoAdapter {
|
||||
private adapterConstructor?: RedisAdapterConstructor;
|
||||
private subClient?: DuplicatedRedisClient;
|
||||
|
||||
constructor(private readonly app: INestApplicationContext) {
|
||||
super(app);
|
||||
}
|
||||
|
||||
public async connectToRedis(): Promise<void> {
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,643 @@
|
||||
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<typeof createClient>;
|
||||
|
||||
const REHEARSAL_PREFIX = 'redis-sot-rehearsal';
|
||||
const WAIT_FOR_EXPIRY_POLL_INTERVAL_MS = 1000;
|
||||
const WAIT_FOR_EXPIRY_TIMEOUT_MS = 20_000;
|
||||
|
||||
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<string | undefined> {
|
||||
for (const key of keys) {
|
||||
const value = await secretService.get<string>(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<RedisClient> {
|
||||
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<void> {
|
||||
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<void> {
|
||||
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<void> {
|
||||
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<RehearsalResources> {
|
||||
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<void> {
|
||||
for (let attempt = 0; attempt < 5; attempt += 1) {
|
||||
const result = await durabilityScheduler.processDueDurabilityPayloads(50);
|
||||
if (result.applied === 0 && result.failed === 0) return;
|
||||
}
|
||||
}
|
||||
|
||||
async function waitForDeadlineCompletion(
|
||||
deadlineScheduler: AuctionDeadlineScheduler,
|
||||
): Promise<void> {
|
||||
const startedAt = Date.now();
|
||||
let lastResult: Awaited<
|
||||
ReturnType<AuctionDeadlineScheduler['processDueBidRoundDeadlines']>
|
||||
> | null = null;
|
||||
|
||||
while (Date.now() - startedAt < WAIT_FOR_EXPIRY_TIMEOUT_MS) {
|
||||
await new Promise((resolve) =>
|
||||
setTimeout(resolve, WAIT_FOR_EXPIRY_POLL_INTERVAL_MS),
|
||||
);
|
||||
lastResult = await deadlineScheduler.processDueBidRoundDeadlines(20);
|
||||
if (lastResult.completed >= 1) return;
|
||||
}
|
||||
|
||||
throw new Error(
|
||||
`Expected deadline completion, got ${JSON.stringify(lastResult)}`,
|
||||
);
|
||||
}
|
||||
|
||||
function assertState(
|
||||
state: Record<string, unknown> | null,
|
||||
expectedPhase: string,
|
||||
): Record<string, unknown> {
|
||||
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<void> {
|
||||
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,
|
||||
dummyEventBus as never,
|
||||
);
|
||||
|
||||
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);
|
||||
const secondBiddingState = assertState(
|
||||
await auctionRedisStateReaderService.readAuctionStateView(
|
||||
resources.matchId.toString(),
|
||||
),
|
||||
'bidding',
|
||||
);
|
||||
const secondBiddingKeys = buildAuctionRedisKeys(resources.matchId.toString());
|
||||
const queuedDeadlineScore = await auctionRedisService.raw().sendCommand([
|
||||
'ZSCORE',
|
||||
secondBiddingKeys.deadlineQueueKey,
|
||||
resources.matchId.toString(),
|
||||
]);
|
||||
if (!queuedDeadlineScore) {
|
||||
throw new Error(
|
||||
`Expected deadline queue item after second open-bidding, state deadline=${String(
|
||||
secondBiddingState.currentBidRoundDeadlineTimestampMS,
|
||||
)}`,
|
||||
);
|
||||
}
|
||||
logStep(
|
||||
`waiting up to ${WAIT_FOR_EXPIRY_TIMEOUT_MS}ms for Redis TIME deadline`,
|
||||
);
|
||||
await waitForDeadlineCompletion(deadlineScheduler);
|
||||
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);
|
||||
const resetState = await auctionRedisStateReaderService.readAuctionStateView(
|
||||
resources.matchId.toString(),
|
||||
);
|
||||
if (resetState) {
|
||||
throw new Error(
|
||||
`Expected reset to clear Redis state, got phase=${String(resetState.phase)}`,
|
||||
);
|
||||
}
|
||||
logStep('reset -> auction data cleared 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);
|
||||
});
|
||||
@@ -0,0 +1,101 @@
|
||||
/**
|
||||
* 경매 거부코드 → 사용자 문구 매핑(프론트 전용).
|
||||
*
|
||||
* 서버(`apps/api/.../auction-rejection.ts`)가 ack에 실어주는 설명적 거부코드
|
||||
* `auctionRejectionReason`를 사람이 읽는 한국어 문구로 바꾼다. reason 문자열은
|
||||
* 서버와의 계약이므로 양쪽을 함께 바꿔야 한다(서버는 영문 message도 함께 보내므로,
|
||||
* 매핑이 빠진 reason은 message로 폴백된다).
|
||||
*
|
||||
* 또한 ack가 없는 `error` 이벤트 채널(영문 message만 옴)도 같은 톤의 한국어로
|
||||
* 바꿀 수 있도록 영문 message → 한국어 매핑을 함께 둔다.
|
||||
*/
|
||||
|
||||
/** 서버 `AUCTION_REJECTION_REASON`와 1:1로 맞춘 사용자 문구. */
|
||||
const REASON_TO_USER_MESSAGE: Record<string, string> = {
|
||||
// 구조 전환
|
||||
AUCTION_TRANSITION_REJECTED_BECAUSE_LIVE_STATE_CHANGED_BEFORE_APPLY:
|
||||
'경매 상태가 바뀌어 최신 상태로 맞췄어요. 다시 시도해 주세요.',
|
||||
AUCTION_TRANSITION_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE:
|
||||
'이미 입찰 단계가 아니에요. 최신 상태로 맞췄어요.',
|
||||
AUCTION_TRANSITION_REJECTED_BECAUSE_PHASE_DOES_NOT_ALLOW_ADVANCE:
|
||||
'이미 다음 단계로 넘어간 상태예요. 최신 상태로 맞췄어요.',
|
||||
AUCTION_TRANSITION_REJECTED_BECAUSE_NO_WINNING_BID_TO_MARK_SOLD:
|
||||
'낙찰할 입찰이 없어요. 최신 상태로 맞췄어요.',
|
||||
AUCTION_TRANSITION_REJECTED_BECAUSE_ACTIVE_BID_PRESENT:
|
||||
'진행 중인 입찰이 있어 유찰할 수 없어요.',
|
||||
AUCTION_TRANSITION_REJECTED_BECAUSE_REQUEST_COORDINATION_RETRYABLE:
|
||||
'잠시 처리 중이라 반영되지 않았어요. 다시 시도해 주세요.',
|
||||
// 입찰
|
||||
BID_REJECTED_BECAUSE_BID_ROUND_ALREADY_ADVANCED: '이미 다음 선수로 넘어갔어요.',
|
||||
BID_REJECTED_BECAUSE_BID_ROUND_DEADLINE_PASSED: '마감되어 반영되지 않았어요.',
|
||||
BID_REJECTED_BECAUSE_AUCTION_NOT_IN_BIDDING_PHASE:
|
||||
'지금은 입찰할 수 없는 단계예요.',
|
||||
BID_REJECTED_BECAUSE_AMOUNT_NOT_HIGHER_THAN_CURRENT_HIGHEST:
|
||||
'더 높은 입찰이 있었어요.',
|
||||
BID_REJECTED_BECAUSE_TEAM_ROSTER_FULL: '팀 정원이 가득 찼어요.',
|
||||
BID_REJECTED_BECAUSE_INSUFFICIENT_REMAINING_POINTS_FOR_SLOTS:
|
||||
'남은 슬롯을 고려하면 포인트가 부족해요.',
|
||||
BID_REJECTED_BECAUSE_UNKNOWN_TEAM: '알 수 없는 팀이에요.',
|
||||
BID_REJECTED_BECAUSE_DUPLICATE_REQUEST_PAYLOAD_CONFLICT: '중복된 요청이에요.',
|
||||
BID_REJECTED_BECAUSE_RATE_LIMITED:
|
||||
'요청이 너무 많아요. 잠시 후 다시 시도해 주세요.',
|
||||
// 공통
|
||||
AUCTION_REQUEST_REJECTED_BECAUSE_REALTIME_STATE_UNAVAILABLE:
|
||||
'실시간 상태를 불러오는 중이에요. 잠시 후 다시 시도해 주세요.',
|
||||
};
|
||||
|
||||
/** ack 없이 `error` 이벤트로만 오는 영문 message → 한국어. */
|
||||
const ENGLISH_MESSAGE_TO_USER_MESSAGE: Record<string, string> = {
|
||||
'Bid deadline has already expired.': '마감되어 반영되지 않았어요.',
|
||||
'Bid must exceed current bid.': '더 높은 입찰이 있었어요.',
|
||||
'Bid round has already changed.': '이미 다음 선수로 넘어갔어요.',
|
||||
'Auction is not in bidding phase.': '지금은 입찰할 수 없는 단계예요.',
|
||||
'Team already has maximum members.': '팀 정원이 가득 찼어요.',
|
||||
'Bid must reserve minimum points for remaining slots.':
|
||||
'남은 슬롯을 고려하면 포인트가 부족해요.',
|
||||
'Unknown team.': '알 수 없는 팀이에요.',
|
||||
'Bid request conflicts with an earlier request.': '중복된 요청이에요.',
|
||||
'Cannot advance from current phase.':
|
||||
'이미 다음 단계로 넘어간 상태예요. 최신 상태로 맞췄어요.',
|
||||
'No bid to mark sold.': '낙찰할 입찰이 없어요. 최신 상태로 맞췄어요.',
|
||||
'Cannot pass a player with an active bid.':
|
||||
'진행 중인 입찰이 있어 유찰할 수 없어요.',
|
||||
};
|
||||
|
||||
const DEFAULT_REJECTION_MESSAGE = '요청이 반영되지 않았어요.';
|
||||
const DEFAULT_ERROR_MESSAGE = '실시간 경매 연결 중 오류가 발생했습니다.';
|
||||
|
||||
export interface AuctionRejectionAckLike {
|
||||
auctionRejectionReason?: string;
|
||||
code?: string;
|
||||
message?: string;
|
||||
resyncRecommended?: boolean;
|
||||
}
|
||||
|
||||
/** 거부 ack → 사용자 문구. reason 매핑 우선, 없으면 영문 message 매핑, 그래도 없으면 원문/기본값. */
|
||||
export function resolveAuctionRejectionMessage(
|
||||
ack: AuctionRejectionAckLike,
|
||||
): string {
|
||||
if (ack.auctionRejectionReason) {
|
||||
const mapped = REASON_TO_USER_MESSAGE[ack.auctionRejectionReason];
|
||||
if (mapped) return mapped;
|
||||
}
|
||||
if (ack.message) {
|
||||
const mapped = ENGLISH_MESSAGE_TO_USER_MESSAGE[ack.message];
|
||||
if (mapped) return mapped;
|
||||
}
|
||||
return ack.message ?? ack.code ?? DEFAULT_REJECTION_MESSAGE;
|
||||
}
|
||||
|
||||
/** `error` 이벤트(영문 message) → 사용자 문구. */
|
||||
export function resolveAuctionErrorMessage(message?: string): string {
|
||||
if (message && ENGLISH_MESSAGE_TO_USER_MESSAGE[message]) {
|
||||
return ENGLISH_MESSAGE_TO_USER_MESSAGE[message];
|
||||
}
|
||||
return message ?? DEFAULT_ERROR_MESSAGE;
|
||||
}
|
||||
|
||||
/** 최신 상태로 rebaseline 후 재시도가 권장되는 거부인지. */
|
||||
export function isAuctionResyncRecommended(ack: AuctionRejectionAckLike): boolean {
|
||||
return ack.resyncRecommended === true;
|
||||
}
|
||||
@@ -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<void>(`/communities/${communityId}/matches/${matchId}/auction`, {
|
||||
method: 'DELETE',
|
||||
body: JSON.stringify({
|
||||
auctionActionRequestId,
|
||||
clientObservedAuctionLifecycleId,
|
||||
clientObservedCurrentAuctionPlayerOrderIndex,
|
||||
clientObservedCurrentBidRoundPlayerUserId,
|
||||
clientObservedPhase,
|
||||
clientObservedRevision,
|
||||
}),
|
||||
}),
|
||||
});
|
||||
}
|
||||
|
||||
+78
-28
@@ -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;
|
||||
@@ -133,6 +135,7 @@ export interface AuctionStateView {
|
||||
}[];
|
||||
currentBid: number;
|
||||
currentBidder: { teamIndex: number } | null;
|
||||
remainingMs: number;
|
||||
timer: number;
|
||||
maxTimer: number;
|
||||
bidExtensionSeconds: number;
|
||||
@@ -230,10 +233,11 @@ function mapAuctionPlayerToView(
|
||||
player: ApiAuctionPlayerSnapshot,
|
||||
): AuctionPlayerView {
|
||||
const { mainPosition, subPosition } = resolveMainAndSubPosition(
|
||||
player.preferredPositions,
|
||||
player.preferredPositions ?? [],
|
||||
);
|
||||
const summary = player.recentStatsSummary;
|
||||
const primary = pickPrimary(summary, mainPosition);
|
||||
const masteries = player.masteries ?? [];
|
||||
|
||||
return {
|
||||
id: player.userId,
|
||||
@@ -244,9 +248,9 @@ function mapAuctionPlayerToView(
|
||||
tierHistory: player.tierHistory ?? [],
|
||||
mainPosition,
|
||||
subPosition,
|
||||
profileIconId: player.profileIconId,
|
||||
profileIconId: player.profileIconId ?? 0,
|
||||
passCount: player.passCount ?? 0,
|
||||
masteries: player.masteries.slice(0, 5).map((mastery) => ({
|
||||
masteries: masteries.slice(0, 5).map((mastery) => ({
|
||||
championId: mastery.championId,
|
||||
level: mastery.championLevel,
|
||||
points: mastery.championPoints,
|
||||
@@ -273,7 +277,7 @@ function createFallbackParticipant(userId: string): ParticipantView {
|
||||
}
|
||||
|
||||
function mapAuctionTeamToView(
|
||||
team: ApiAuctionTeam,
|
||||
team: NormalizedApiAuctionTeam,
|
||||
playerLookup: Map<string, AuctionPlayerView>,
|
||||
participantLookup: Map<string, ParticipantView>,
|
||||
): AuctionTeamView {
|
||||
@@ -489,12 +493,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,22 +528,20 @@ 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
|
||||
? Math.max(
|
||||
0,
|
||||
Math.ceil(
|
||||
(new Date(auction.currentDeadline).getTime() - now.getTime()) / 1000,
|
||||
),
|
||||
)
|
||||
auction.phase === "complete" ? totalPlayers : currentAuctionPlayerOrderIndex;
|
||||
const remainingMs = currentBidRoundDeadlineTimestampMS
|
||||
? Math.max(0, currentBidRoundDeadlineTimestampMS - now.getTime())
|
||||
: 0;
|
||||
const timer = Math.floor(remainingMs / 1000);
|
||||
|
||||
return {
|
||||
matchId: auction.matchId,
|
||||
phase: auction.phase,
|
||||
matchSideEffectRevision: auction.matchSideEffectRevision,
|
||||
matchSideEffectStatus: auction.matchSideEffectStatus,
|
||||
teams: teams.map((team) =>
|
||||
mapAuctionTeamToView(team, auctionPlayerLookup, participantLookup),
|
||||
),
|
||||
@@ -527,21 +550,48 @@ 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,
|
||||
remainingMs,
|
||||
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,
|
||||
}));
|
||||
}
|
||||
+46
-14
@@ -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;
|
||||
}
|
||||
|
||||
@@ -3,6 +3,11 @@ import { io, type Socket } from 'socket.io-client';
|
||||
import { API_BASE_URL, useAuthUserId } from '../config';
|
||||
import { acquireAccessToken } from '../lib/auth/token-provider';
|
||||
import type { ApiAuction, ApiAuctionChatMessage, Position } from './types';
|
||||
import {
|
||||
isAuctionResyncRecommended,
|
||||
resolveAuctionErrorMessage,
|
||||
resolveAuctionRejectionMessage,
|
||||
} from './auctionRejectionMessages';
|
||||
|
||||
type ConnectionStatus =
|
||||
| 'idle'
|
||||
@@ -12,9 +17,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 +29,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,12 +50,76 @@ interface ResetPayload {
|
||||
matchId?: string;
|
||||
}
|
||||
|
||||
interface TickPayload {
|
||||
deadline?: string;
|
||||
serverTime?: string;
|
||||
type MatchSideEffectStatus = NonNullable<ApiAuction['matchSideEffectStatus']>;
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
interface BidServerTimingPayload {
|
||||
fallbackFullStatePath?: boolean;
|
||||
gatewayTotalDurationMS?: number;
|
||||
redisBidCommandDurationMS?: number;
|
||||
redisBidContextReadDurationMS?: number;
|
||||
serviceTotalDurationMS?: number;
|
||||
}
|
||||
|
||||
interface BidDiagnosticsPayload {
|
||||
currentBidRoundDeadlineTimestampMS?: number;
|
||||
currentServerTimestampMS?: number;
|
||||
}
|
||||
|
||||
interface BidAckPayload {
|
||||
auctionRejectionReason?: string;
|
||||
bidDelta?: BidDeltaPayload | null;
|
||||
bidDiagnostics?: BidDiagnosticsPayload;
|
||||
bidServerTiming?: BidServerTimingPayload;
|
||||
code?: string;
|
||||
message?: string;
|
||||
rejected?: boolean;
|
||||
resyncRecommended?: boolean;
|
||||
state?: ApiAuction;
|
||||
}
|
||||
|
||||
interface TimeSyncAckPayload {
|
||||
clientSentAtTimestampMS?: number;
|
||||
currentServerTimestampMS?: number;
|
||||
ok?: boolean;
|
||||
rejected?: boolean;
|
||||
sequence?: number;
|
||||
serverProcessingDurationMS?: number;
|
||||
}
|
||||
|
||||
export interface BidLatencyDiagnostics {
|
||||
bidDiagnostics?: BidDiagnosticsPayload;
|
||||
bidServerTiming?: BidServerTimingPayload;
|
||||
clientObservedRemainingBidRoundTimeMS?: number;
|
||||
serverObservedRemainingBidRoundTimeMS?: number;
|
||||
serverRoundTripDurationMS?: number;
|
||||
}
|
||||
|
||||
const MAX_CHAT_MESSAGES = 200;
|
||||
const TIME_SYNC_INTERVAL_MS = 5000;
|
||||
const TIME_SYNC_TIMEOUT_MS = 3000;
|
||||
|
||||
function mergeChatMessages(
|
||||
current: ApiAuctionChatMessage[],
|
||||
@@ -54,13 +138,182 @@ function mergeChatMessages(
|
||||
export function useAuctionSocket(matchId: string | undefined) {
|
||||
const authUserId = useAuthUserId();
|
||||
const socketRef = useRef<Socket | null>(null);
|
||||
const pendingBidTimeoutsRef = useRef<
|
||||
Record<string, ReturnType<typeof setTimeout>>
|
||||
>({});
|
||||
const pendingActionTimeoutsRef = useRef<
|
||||
Record<string, ReturnType<typeof setTimeout>>
|
||||
>({});
|
||||
const timeSyncIntervalRef = useRef<ReturnType<typeof setInterval> | null>(
|
||||
null,
|
||||
);
|
||||
const timeSyncTimeoutsRef = useRef<
|
||||
Record<number, ReturnType<typeof setTimeout>>
|
||||
>({});
|
||||
const timeSyncSequenceRef = useRef(0);
|
||||
const hasSyncedServerTimeRef = useRef(false);
|
||||
const latestAuctionRef = useRef<ApiAuction | null>(null);
|
||||
const latestConfirmedBidPointAmountRef = useRef(0);
|
||||
const [auction, setAuction] = useState<ApiAuction | null>(null);
|
||||
const [chatMessages, setChatMessages] = useState<ApiAuctionChatMessage[]>([]);
|
||||
const [pendingBidRequests, setPendingBidRequests] = useState<
|
||||
Record<string, { amount: number; teamIndex: number }>
|
||||
>({});
|
||||
const [pendingActionRequests, setPendingActionRequests] = useState<
|
||||
Record<string, { action: string }>
|
||||
>({});
|
||||
const [resetAt, setResetAt] = useState<number | null>(null);
|
||||
const [connectionStatus, setConnectionStatus] =
|
||||
useState<ConnectionStatus>('idle');
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const [serverTimeOffsetMs, setServerTimeOffsetMs] = useState(0);
|
||||
const [serverRoundTripMs, setServerRoundTripMs] = useState<number | null>(
|
||||
null,
|
||||
);
|
||||
const [bidLatencyDiagnostics, setBidLatencyDiagnostics] =
|
||||
useState<BidLatencyDiagnostics | null>(null);
|
||||
|
||||
function syncLatestConfirmedBidPointAmountFromAuction(
|
||||
nextAuction: ApiAuction,
|
||||
) {
|
||||
latestConfirmedBidPointAmountRef.current =
|
||||
resolveCurrentBidPointAmount(nextAuction);
|
||||
}
|
||||
|
||||
function commitAuctionState(nextAuction: ApiAuction): boolean {
|
||||
const currentAuction = latestAuctionRef.current;
|
||||
if (!shouldApplyIncomingAuctionState(currentAuction, nextAuction)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
latestAuctionRef.current = nextAuction;
|
||||
syncLatestConfirmedBidPointAmountFromAuction(nextAuction);
|
||||
setAuction(nextAuction);
|
||||
return true;
|
||||
}
|
||||
|
||||
function commitBidDelta(payload: BidDeltaPayload): boolean {
|
||||
const currentAuction = latestAuctionRef.current;
|
||||
const nextAuction = applyBidDelta(currentAuction, payload);
|
||||
if (!nextAuction || nextAuction === currentAuction) {
|
||||
return false;
|
||||
}
|
||||
|
||||
latestAuctionRef.current = nextAuction;
|
||||
syncLatestConfirmedBidPointAmountFromAuction(nextAuction);
|
||||
setAuction(nextAuction);
|
||||
return true;
|
||||
}
|
||||
|
||||
function applyFallbackServerTimestamp(currentServerTimestampMS?: number) {
|
||||
if (hasSyncedServerTimeRef.current) return;
|
||||
if (typeof currentServerTimestampMS !== 'number') return;
|
||||
setServerTimeOffsetMs(currentServerTimestampMS - Date.now());
|
||||
}
|
||||
|
||||
function clearTimeSyncTimers() {
|
||||
if (timeSyncIntervalRef.current) {
|
||||
clearInterval(timeSyncIntervalRef.current);
|
||||
timeSyncIntervalRef.current = null;
|
||||
}
|
||||
Object.values(timeSyncTimeoutsRef.current).forEach((timeoutId) =>
|
||||
clearTimeout(timeoutId),
|
||||
);
|
||||
timeSyncTimeoutsRef.current = {};
|
||||
}
|
||||
|
||||
function requestServerTimeSync(socket: Socket) {
|
||||
if (!socket.connected) return;
|
||||
|
||||
const sequence = timeSyncSequenceRef.current + 1;
|
||||
timeSyncSequenceRef.current = sequence;
|
||||
const clientSentAtTimestampMS = Date.now();
|
||||
|
||||
timeSyncTimeoutsRef.current[sequence] = setTimeout(() => {
|
||||
delete timeSyncTimeoutsRef.current[sequence];
|
||||
}, TIME_SYNC_TIMEOUT_MS);
|
||||
|
||||
socket.emit(
|
||||
'time-sync',
|
||||
{ clientSentAtTimestampMS, sequence },
|
||||
(ack?: TimeSyncAckPayload) => {
|
||||
const clientReceivedAtTimestampMS = Date.now();
|
||||
const timeoutId = timeSyncTimeoutsRef.current[sequence];
|
||||
if (!timeoutId) return;
|
||||
clearTimeout(timeoutId);
|
||||
delete timeSyncTimeoutsRef.current[sequence];
|
||||
|
||||
if (
|
||||
!ack?.ok ||
|
||||
ack.sequence !== sequence ||
|
||||
typeof ack.currentServerTimestampMS !== 'number'
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
const totalRoundTripDurationMS = Math.max(
|
||||
0,
|
||||
clientReceivedAtTimestampMS - clientSentAtTimestampMS,
|
||||
);
|
||||
const serverProcessingDurationMS = Number(
|
||||
ack.serverProcessingDurationMS,
|
||||
);
|
||||
const estimatedNetworkOneWayDurationMS =
|
||||
Math.max(
|
||||
0,
|
||||
totalRoundTripDurationMS -
|
||||
(Number.isFinite(serverProcessingDurationMS)
|
||||
? serverProcessingDurationMS
|
||||
: 0),
|
||||
) / 2;
|
||||
const estimatedServerTimestampAtClientReceiveMS =
|
||||
ack.currentServerTimestampMS + estimatedNetworkOneWayDurationMS;
|
||||
|
||||
hasSyncedServerTimeRef.current = true;
|
||||
setServerRoundTripMs(Math.round(totalRoundTripDurationMS));
|
||||
setServerTimeOffsetMs(
|
||||
Math.round(
|
||||
estimatedServerTimestampAtClientReceiveMS -
|
||||
clientReceivedAtTimestampMS,
|
||||
),
|
||||
);
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
function captureBidLatencyDiagnostics(ack?: BidAckPayload) {
|
||||
if (!ack?.bidDiagnostics && !ack?.bidServerTiming) return;
|
||||
|
||||
const currentAuction = latestAuctionRef.current;
|
||||
const currentDeadlineTimestampMS =
|
||||
currentAuction?.currentBidRoundDeadlineTimestampMS ??
|
||||
(currentAuction?.currentDeadline
|
||||
? Date.parse(currentAuction.currentDeadline)
|
||||
: undefined);
|
||||
const clientObservedRemainingBidRoundTimeMS =
|
||||
typeof currentDeadlineTimestampMS === 'number'
|
||||
? Math.max(0, currentDeadlineTimestampMS - (Date.now() + serverTimeOffsetMs))
|
||||
: undefined;
|
||||
const serverDeadlineTimestampMS =
|
||||
ack.bidDiagnostics?.currentBidRoundDeadlineTimestampMS ??
|
||||
ack.bidDelta?.currentBidRoundDeadlineTimestampMS;
|
||||
const serverTimestampMS =
|
||||
ack.bidDiagnostics?.currentServerTimestampMS ??
|
||||
ack.bidDelta?.currentServerTimestampMS;
|
||||
const serverObservedRemainingBidRoundTimeMS =
|
||||
typeof serverDeadlineTimestampMS === 'number' &&
|
||||
typeof serverTimestampMS === 'number'
|
||||
? serverDeadlineTimestampMS - serverTimestampMS
|
||||
: undefined;
|
||||
|
||||
setBidLatencyDiagnostics({
|
||||
bidDiagnostics: ack?.bidDiagnostics,
|
||||
bidServerTiming: ack?.bidServerTiming,
|
||||
clientObservedRemainingBidRoundTimeMS,
|
||||
serverObservedRemainingBidRoundTimeMS,
|
||||
serverRoundTripDurationMS: serverRoundTripMs ?? undefined,
|
||||
});
|
||||
}
|
||||
|
||||
useEffect(() => {
|
||||
if (!matchId) {
|
||||
@@ -92,27 +345,32 @@ export function useAuctionSocket(matchId: string | undefined) {
|
||||
socket.on('connect', () => {
|
||||
setConnectionStatus('connected');
|
||||
socket.emit('join', { matchId });
|
||||
requestServerTimeSync(socket);
|
||||
if (timeSyncIntervalRef.current) {
|
||||
clearInterval(timeSyncIntervalRef.current);
|
||||
}
|
||||
timeSyncIntervalRef.current = setInterval(
|
||||
() => requestServerTimeSync(socket),
|
||||
TIME_SYNC_INTERVAL_MS,
|
||||
);
|
||||
});
|
||||
|
||||
socket.on('disconnect', () => {
|
||||
clearTimeSyncTimers();
|
||||
setConnectionStatus('disconnected');
|
||||
});
|
||||
|
||||
socket.on('state', (nextAuction: ApiAuction) => {
|
||||
setAuction(nextAuction);
|
||||
const didApplyState = commitAuctionState(nextAuction);
|
||||
if (didApplyState) {
|
||||
clearPendingActionRequests();
|
||||
}
|
||||
applyFallbackServerTimestamp(nextAuction.currentServerTimestampMS);
|
||||
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());
|
||||
if (didApplyState) {
|
||||
setError(null);
|
||||
}
|
||||
});
|
||||
|
||||
@@ -124,8 +382,59 @@ export function useAuctionSocket(matchId: string | undefined) {
|
||||
setChatMessages((current) => mergeChatMessages(current, [message]));
|
||||
});
|
||||
|
||||
socket.on('bid', (payload: BidDeltaPayload) => {
|
||||
applyFallbackServerTimestamp(payload?.currentServerTimestampMS);
|
||||
const didApplyBidDelta = commitBidDelta(payload);
|
||||
if (payload?.bidRequestId) {
|
||||
if (
|
||||
didApplyBidDelta ||
|
||||
pendingBidTimeoutsRef.current[payload.bidRequestId]
|
||||
) {
|
||||
clearPendingBidRequest(payload.bidRequestId);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
socket.on('match-side-effect', (payload: MatchSideEffectPayload) => {
|
||||
applyFallbackServerTimestamp(payload?.currentServerTimestampMS);
|
||||
if (
|
||||
!payload?.matchSideEffectStatus ||
|
||||
typeof payload.matchSideEffectRevision !== 'number'
|
||||
) {
|
||||
return;
|
||||
}
|
||||
const matchSideEffectRevision = payload.matchSideEffectRevision;
|
||||
const matchSideEffectStatus = payload.matchSideEffectStatus;
|
||||
|
||||
const currentAuction = latestAuctionRef.current;
|
||||
if (!currentAuction) return;
|
||||
if (
|
||||
payload.auctionLifecycleId &&
|
||||
currentAuction.auctionLifecycleId &&
|
||||
payload.auctionLifecycleId !== currentAuction.auctionLifecycleId
|
||||
) {
|
||||
return;
|
||||
}
|
||||
if (
|
||||
matchSideEffectRevision <=
|
||||
(currentAuction.matchSideEffectRevision ?? -1)
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
const nextAuction = {
|
||||
...currentAuction,
|
||||
matchSideEffectRevision,
|
||||
matchSideEffectStatus,
|
||||
};
|
||||
latestAuctionRef.current = nextAuction;
|
||||
setAuction(nextAuction);
|
||||
});
|
||||
|
||||
socket.on('reset', (payload: ResetPayload) => {
|
||||
if (payload.matchId && payload.matchId !== matchId) return;
|
||||
latestAuctionRef.current = null;
|
||||
latestConfirmedBidPointAmountRef.current = 0;
|
||||
setAuction(null);
|
||||
setChatMessages([]);
|
||||
setResetAt(Date.now());
|
||||
@@ -133,8 +442,8 @@ export function useAuctionSocket(matchId: string | undefined) {
|
||||
});
|
||||
|
||||
socket.on('error', (payload: { message?: string }) => {
|
||||
setConnectionStatus('error');
|
||||
setError(payload.message ?? '실시간 경매 연결 중 오류가 발생했습니다.');
|
||||
// ack 없는 error 채널(영문 message만)도 같은 톤의 한국어로 매핑한다.
|
||||
setError(resolveAuctionErrorMessage(payload.message));
|
||||
});
|
||||
})();
|
||||
|
||||
@@ -144,11 +453,57 @@ export function useAuctionSocket(matchId: string | undefined) {
|
||||
socket?.removeAllListeners();
|
||||
socket?.disconnect();
|
||||
socketRef.current = null;
|
||||
clearTimeSyncTimers();
|
||||
Object.values(pendingBidTimeoutsRef.current).forEach((timeoutId) =>
|
||||
clearTimeout(timeoutId),
|
||||
);
|
||||
Object.values(pendingActionTimeoutsRef.current).forEach((timeoutId) =>
|
||||
clearTimeout(timeoutId),
|
||||
);
|
||||
pendingBidTimeoutsRef.current = {};
|
||||
pendingActionTimeoutsRef.current = {};
|
||||
latestAuctionRef.current = null;
|
||||
latestConfirmedBidPointAmountRef.current = 0;
|
||||
hasSyncedServerTimeRef.current = false;
|
||||
setPendingBidRequests({});
|
||||
setPendingActionRequests({});
|
||||
setConnectionStatus('idle');
|
||||
setServerTimeOffsetMs(0);
|
||||
setServerRoundTripMs(null);
|
||||
setBidLatencyDiagnostics(null);
|
||||
};
|
||||
}, [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 clearPendingActionRequests() {
|
||||
Object.values(pendingActionTimeoutsRef.current).forEach((timeoutId) =>
|
||||
clearTimeout(timeoutId),
|
||||
);
|
||||
pendingActionTimeoutsRef.current = {};
|
||||
setPendingActionRequests({});
|
||||
}
|
||||
|
||||
function emit(eventName: string, payload?: unknown) {
|
||||
const socket = socketRef.current;
|
||||
if (!socket || !socket.connected) {
|
||||
@@ -166,7 +521,115 @@ export function useAuctionSocket(matchId: string | undefined) {
|
||||
socket.emit(eventName, payload);
|
||||
}
|
||||
|
||||
const visibleAuction = auction?.matchId === matchId ? auction : null;
|
||||
function buildAuctionActionPayload(): AuctionActionPayload {
|
||||
const currentAuction = latestAuctionRef.current ?? auction;
|
||||
return {
|
||||
auctionActionRequestId: createClientRequestId(),
|
||||
clientObservedAuctionLifecycleId: currentAuction?.auctionLifecycleId,
|
||||
clientObservedCurrentAuctionPlayerOrderIndex:
|
||||
currentAuction?.currentAuctionPlayerOrderIndex,
|
||||
clientObservedCurrentBidRoundPlayerUserId:
|
||||
currentAuction?.currentBidRoundPlayerUserId,
|
||||
clientObservedPhase: currentAuction?.phase,
|
||||
clientObservedRevision: currentAuction?.revision,
|
||||
};
|
||||
}
|
||||
|
||||
// 거부 등으로 클라 상태가 낡았을 때 서버 최신 state를 다시 받아 rebaseline한다.
|
||||
// join 핸들러가 getStateByMatchId → broadcastState로 fresh state를 내려주고,
|
||||
// revision 가드상 더 높은 revision이라 정상 적용된다(force-resync 아님).
|
||||
function resyncAuctionState() {
|
||||
const socket = socketRef.current;
|
||||
if (!socket || !socket.connected || !matchId) return;
|
||||
socket.emit('join', { matchId });
|
||||
}
|
||||
|
||||
// retryAttempt: 거부 후 자동 재시도 횟수(루프 방지를 위해 1회로 제한).
|
||||
function emitAuctionAction(
|
||||
eventName: string,
|
||||
payload: AuctionActionPayload,
|
||||
retryAttempt = 0,
|
||||
) {
|
||||
const socket = socketRef.current;
|
||||
if (!socket || !socket.connected) {
|
||||
setError('소켓이 아직 연결되지 않았습니다.');
|
||||
return;
|
||||
}
|
||||
if (Object.keys(pendingActionTimeoutsRef.current).length > 0) {
|
||||
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;
|
||||
auctionRejectionReason?: string;
|
||||
code?: string;
|
||||
message?: string;
|
||||
rejected?: boolean;
|
||||
resyncRecommended?: boolean;
|
||||
state?: ApiAuction;
|
||||
}) => {
|
||||
if (ack?.rejected) {
|
||||
clearPendingActionRequest(
|
||||
ack?.auctionActionRequestId ?? auctionActionRequestId,
|
||||
);
|
||||
// 1) rebaseline: 서버가 동봉한 최신 state를 즉시 반영(없으면 join으로 재요청).
|
||||
// commitAuctionState는 latestAuctionRef를 동기로 갱신하므로, 이후
|
||||
// buildAuctionActionPayload는 최신 관측값(revision/phase/선수)을 읽는다.
|
||||
if (ack.state) {
|
||||
commitAuctionState(ack.state);
|
||||
} else if (isAuctionResyncRecommended(ack)) {
|
||||
resyncAuctionState();
|
||||
}
|
||||
// 2) 자동 재시도: "낡은 화면 때문에 거부"였고 동기 rebaseline 소스(state)가
|
||||
// 있을 때만 1회. assignedPosition 등 원래 payload는 유지하고 관측값/요청
|
||||
// id만 새로 만든다. 재시도 시에는 중간 에러 문구를 띄우지 않는다(무음 복구).
|
||||
const canAutoRetry =
|
||||
Boolean(ack.state) &&
|
||||
isAuctionResyncRecommended(ack) &&
|
||||
retryAttempt < 1;
|
||||
if (canAutoRetry) {
|
||||
emitAuctionAction(
|
||||
eventName,
|
||||
{ ...payload, ...buildAuctionActionPayload() },
|
||||
retryAttempt + 1,
|
||||
);
|
||||
} else {
|
||||
setError(resolveAuctionRejectionMessage(ack));
|
||||
}
|
||||
return;
|
||||
}
|
||||
const ackState = ack?.state;
|
||||
if (ackState) {
|
||||
clearPendingActionRequest(
|
||||
ack.auctionActionRequestId ?? auctionActionRequestId,
|
||||
);
|
||||
commitAuctionState(ackState);
|
||||
}
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
const currentAuction = auction;
|
||||
const visibleAuction =
|
||||
currentAuction && currentAuction.matchId === matchId ? currentAuction : null;
|
||||
const visibleConnectionStatus: ConnectionStatus = matchId
|
||||
? connectionStatus
|
||||
: 'idle';
|
||||
@@ -174,24 +637,259 @@ 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,
|
||||
bidLatencyDiagnostics,
|
||||
serverRoundTripMs: matchId ? serverRoundTripMs : null,
|
||||
serverTimeOffsetMs: matchId ? serverTimeOffsetMs : 0,
|
||||
placeBid(payload: BidPayload) {
|
||||
emit('bid', payload);
|
||||
const socket = socketRef.current;
|
||||
if (!socket || !socket.connected) {
|
||||
setError('소켓이 아직 연결되지 않았습니다.');
|
||||
return;
|
||||
}
|
||||
if (Object.keys(pendingBidTimeoutsRef.current).length > 0) {
|
||||
return;
|
||||
}
|
||||
if (payload.bidPointAmount <= latestConfirmedBidPointAmountRef.current) {
|
||||
return;
|
||||
}
|
||||
|
||||
const bidRequestId = payload.bidRequestId ?? createClientRequestId();
|
||||
const currentAuction = latestAuctionRef.current ?? auction;
|
||||
const bidPayload: BidPayload = {
|
||||
...payload,
|
||||
bidRequestId,
|
||||
clientObservedAuctionLifecycleId:
|
||||
payload.clientObservedAuctionLifecycleId ??
|
||||
currentAuction?.auctionLifecycleId,
|
||||
clientObservedCurrentBidRoundPlayerUserId:
|
||||
payload.clientObservedCurrentBidRoundPlayerUserId ??
|
||||
currentAuction?.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?: BidAckPayload) => {
|
||||
captureBidLatencyDiagnostics(ack);
|
||||
if (ack?.rejected) {
|
||||
clearPendingBidRequest(bidRequestId);
|
||||
// 입찰 거부도 최신 state로 rebaseline(예: 0초 입찰 EXPIRED → 만료된
|
||||
// 라운드 화면에서 벗어나게). 단 입찰은 자동 재시도하지 않는다(의도치
|
||||
// 않은 금액 재입찰 방지).
|
||||
if (ack.state) {
|
||||
commitAuctionState(ack.state);
|
||||
} else if (isAuctionResyncRecommended(ack)) {
|
||||
resyncAuctionState();
|
||||
}
|
||||
setError(resolveAuctionRejectionMessage(ack));
|
||||
return;
|
||||
}
|
||||
if (ack?.bidDelta) {
|
||||
clearPendingBidRequest(bidRequestId);
|
||||
commitBidDelta(ack.bidDelta);
|
||||
return;
|
||||
}
|
||||
const ackState = ack?.state;
|
||||
if (ackState) {
|
||||
clearPendingBidRequest(bidRequestId);
|
||||
commitAuctionState(ackState);
|
||||
}
|
||||
},
|
||||
);
|
||||
},
|
||||
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 resolveCurrentBidPointAmount(auction: ApiAuction): number {
|
||||
const bidPointAmount = Math.max(
|
||||
Number(auction.currentHighestBidPointAmount),
|
||||
Number(auction.currentBid),
|
||||
0,
|
||||
);
|
||||
return Number.isFinite(bidPointAmount) ? bidPointAmount : 0;
|
||||
}
|
||||
|
||||
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<ApiAuction['auctionBidHistory']>[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<ApiAuction['auctionBidHistory']>,
|
||||
entry: NonNullable<ApiAuction['auctionBidHistory']>[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<ApiAuction['auctionBidHistory']>[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];
|
||||
}
|
||||
@@ -1,5 +1,6 @@
|
||||
import {
|
||||
lazy,
|
||||
memo,
|
||||
Suspense,
|
||||
useEffect,
|
||||
useMemo,
|
||||
@@ -26,7 +27,10 @@ import {
|
||||
type AuctionPlayerView,
|
||||
type AuctionStateView,
|
||||
} from '../api/mappers';
|
||||
import { useAuctionSocket } from '../api/useAuctionSocket';
|
||||
import {
|
||||
useAuctionSocket,
|
||||
type BidLatencyDiagnostics,
|
||||
} from '../api/useAuctionSocket';
|
||||
import {
|
||||
DEFAULT_COMMUNITY_ID,
|
||||
setDevCaptainTeamIndex,
|
||||
@@ -64,6 +68,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 +125,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;
|
||||
@@ -154,6 +180,53 @@ function getMaxBidForTeam(team: AuctionStateView['teams'][number]) {
|
||||
return Math.max(0, team.points - getReservedPointsAfterCurrentBid(team));
|
||||
}
|
||||
|
||||
function formatLatencyMs(value: number | undefined) {
|
||||
return typeof value === 'number' && Number.isFinite(value)
|
||||
? `${Math.round(value)}ms`
|
||||
: '-';
|
||||
}
|
||||
|
||||
function formatBidLatencyDiagnostics(
|
||||
diagnostics: BidLatencyDiagnostics | null,
|
||||
) {
|
||||
if (!diagnostics) return null;
|
||||
|
||||
const serverDeadlineTimestampMS =
|
||||
diagnostics.bidDiagnostics?.currentBidRoundDeadlineTimestampMS;
|
||||
const serverTimestampMS = diagnostics.bidDiagnostics?.currentServerTimestampMS;
|
||||
const serverRemainingMS =
|
||||
typeof diagnostics.serverObservedRemainingBidRoundTimeMS === 'number'
|
||||
? diagnostics.serverObservedRemainingBidRoundTimeMS
|
||||
: typeof serverDeadlineTimestampMS === 'number' &&
|
||||
typeof serverTimestampMS === 'number'
|
||||
? serverDeadlineTimestampMS - serverTimestampMS
|
||||
: undefined;
|
||||
const timing = diagnostics.bidServerTiming;
|
||||
const parts = [
|
||||
`RTT ${formatLatencyMs(diagnostics.serverRoundTripDurationMS)}`,
|
||||
`gateway ${formatLatencyMs(timing?.gatewayTotalDurationMS)}`,
|
||||
`service ${formatLatencyMs(timing?.serviceTotalDurationMS)}`,
|
||||
`redis ${formatLatencyMs(timing?.redisBidCommandDurationMS)}`,
|
||||
`context ${formatLatencyMs(timing?.redisBidContextReadDurationMS)}`,
|
||||
];
|
||||
|
||||
if (timing?.fallbackFullStatePath) {
|
||||
parts.push('fallback full-state');
|
||||
}
|
||||
if (typeof diagnostics.clientObservedRemainingBidRoundTimeMS === 'number') {
|
||||
parts.push(
|
||||
`client-left ${formatLatencyMs(
|
||||
diagnostics.clientObservedRemainingBidRoundTimeMS,
|
||||
)}`,
|
||||
);
|
||||
}
|
||||
if (typeof serverRemainingMS === 'number') {
|
||||
parts.push(`server-left ${formatLatencyMs(serverRemainingMS)}`);
|
||||
}
|
||||
|
||||
return parts.join(' · ');
|
||||
}
|
||||
|
||||
function getSoloTierHistory(entries: ApiTierHistoryEntry[]) {
|
||||
return entries.filter((entry) => entry.queueType === 'RANKED_SOLO_5x5');
|
||||
}
|
||||
@@ -174,7 +247,7 @@ function TimerBar({ timer, maxTimer }: { timer: number; maxTimer: number }) {
|
||||
return (
|
||||
<div className="w-full h-1.5 bg-base-content/5">
|
||||
<div
|
||||
className={`h-full transition-all duration-1000 linear ${urgent ? 'bg-red-500' : 'bg-primary'}`}
|
||||
className={`h-full transition-all duration-300 linear ${urgent ? 'bg-red-500' : 'bg-primary'}`}
|
||||
style={{ width: `${pct}%` }}
|
||||
/>
|
||||
</div>
|
||||
@@ -404,6 +477,8 @@ function TeamPanel({
|
||||
);
|
||||
}
|
||||
|
||||
const MemoTeamPanel = memo(TeamPanel);
|
||||
|
||||
function PlayerSpotlight({
|
||||
state,
|
||||
historyBackTo,
|
||||
@@ -411,24 +486,52 @@ function PlayerSpotlight({
|
||||
state: AuctionStateView;
|
||||
historyBackTo: string;
|
||||
}) {
|
||||
const { data: ddragon } = useDdragonManifest();
|
||||
const player = state.currentPlayer;
|
||||
const snapshotSoloTierHistory = player
|
||||
? getSoloTierHistory(player.tierHistory)
|
||||
: [];
|
||||
const historyProfileQuery = useUserHistoryProfile(
|
||||
player?.userId,
|
||||
DEFAULT_COMMUNITY_ID,
|
||||
Boolean(player && snapshotSoloTierHistory.length === 0),
|
||||
);
|
||||
if (!player) return null;
|
||||
|
||||
return (
|
||||
<div className="border border-base-content/10 bg-base-100">
|
||||
<MemoPlayerProfileDetails player={player} historyBackTo={historyBackTo} />
|
||||
<PlayerBidStatus state={state} />
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
const MemoPlayerSpotlight = memo(
|
||||
PlayerSpotlight,
|
||||
(previous, next) =>
|
||||
previous.historyBackTo === next.historyBackTo &&
|
||||
areSameAuctionPlayerProfile(
|
||||
previous.state.currentPlayer,
|
||||
next.state.currentPlayer,
|
||||
) &&
|
||||
previous.state.phase === next.state.phase &&
|
||||
previous.state.currentBid === next.state.currentBid &&
|
||||
previous.state.currentBidder?.teamIndex === next.state.currentBidder?.teamIndex &&
|
||||
previous.state.auctionRound === next.state.auctionRound,
|
||||
);
|
||||
|
||||
function PlayerProfileDetails({
|
||||
player,
|
||||
historyBackTo,
|
||||
}: {
|
||||
player: NonNullable<AuctionStateView['currentPlayer']>;
|
||||
historyBackTo: string;
|
||||
}) {
|
||||
const { data: ddragon } = useDdragonManifest();
|
||||
const snapshotSoloTierHistory = getSoloTierHistory(player.tierHistory);
|
||||
const historyProfileQuery = useUserHistoryProfile(
|
||||
player.userId,
|
||||
DEFAULT_COMMUNITY_ID,
|
||||
snapshotSoloTierHistory.length === 0,
|
||||
);
|
||||
const tierHistory =
|
||||
snapshotSoloTierHistory.length > 0
|
||||
? snapshotSoloTierHistory
|
||||
: getSoloTierHistory(historyProfileQuery.data?.tierHistory ?? []);
|
||||
|
||||
return (
|
||||
<div className="border border-base-content/10 bg-base-100">
|
||||
<>
|
||||
<div className="p-5 border-b border-base-content/8">
|
||||
<div className="flex items-start gap-4">
|
||||
<Link
|
||||
@@ -535,7 +638,41 @@ function PlayerSpotlight({
|
||||
|
||||
<RecentSoloStats player={player} />
|
||||
</div>
|
||||
</>
|
||||
);
|
||||
}
|
||||
|
||||
const MemoPlayerProfileDetails = memo(
|
||||
PlayerProfileDetails,
|
||||
(previous, next) =>
|
||||
areSameAuctionPlayerProfile(previous.player, next.player) &&
|
||||
previous.historyBackTo === next.historyBackTo,
|
||||
);
|
||||
|
||||
function areSameAuctionPlayerProfile(
|
||||
previous: AuctionPlayerView | null,
|
||||
next: AuctionPlayerView | null,
|
||||
) {
|
||||
if (previous === next) return true;
|
||||
if (!previous || !next) return false;
|
||||
return (
|
||||
previous.userId === next.userId &&
|
||||
previous.summonerName === next.summonerName &&
|
||||
previous.tag === next.tag &&
|
||||
previous.mainPosition === next.mainPosition &&
|
||||
previous.subPosition === next.subPosition &&
|
||||
previous.profileIconId === next.profileIconId &&
|
||||
previous.passCount === next.passCount &&
|
||||
JSON.stringify(previous.tier) === JSON.stringify(next.tier) &&
|
||||
JSON.stringify(previous.tierHistory) === JSON.stringify(next.tierHistory) &&
|
||||
JSON.stringify(previous.masteries) === JSON.stringify(next.masteries) &&
|
||||
JSON.stringify(previous.recentStats) === JSON.stringify(next.recentStats)
|
||||
);
|
||||
}
|
||||
|
||||
function PlayerBidStatus({ state }: { state: AuctionStateView }) {
|
||||
return (
|
||||
<>
|
||||
{(state.phase === 'bidding' || state.phase === 'sold') && (
|
||||
<div className="border-t border-base-content/8 px-4 py-3 bg-base-content/[0.02]">
|
||||
<div className="flex items-center justify-between">
|
||||
@@ -567,17 +704,19 @@ function PlayerSpotlight({
|
||||
</span>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
</>
|
||||
);
|
||||
}
|
||||
|
||||
function BidControls({
|
||||
state,
|
||||
captainRole,
|
||||
isBidPending,
|
||||
onBid,
|
||||
}: {
|
||||
state: AuctionStateView;
|
||||
captainRole: CaptainRole | null;
|
||||
isBidPending: boolean;
|
||||
onBid: (teamIndex: number, amount: number) => void;
|
||||
}) {
|
||||
const [bidAmount, setBidAmount] = useState(100);
|
||||
@@ -592,6 +731,10 @@ function BidControls({
|
||||
: 0;
|
||||
const maxBid = activeTeam ? getMaxBidForTeam(activeTeam) : 0;
|
||||
const canAffordNextBid = !isActiveTeamFull && maxBid >= minBid;
|
||||
const isBidExpired = state.remainingMs <= 0;
|
||||
const effectiveBidAmount = activeTeam
|
||||
? Math.min(maxBid, Math.max(minBid, bidAmount))
|
||||
: Math.max(minBid, bidAmount);
|
||||
|
||||
useEffect(() => {
|
||||
const nextBid = Math.max(minBid, Math.ceil(minBid / 10) * 10);
|
||||
@@ -641,7 +784,11 @@ function BidControls({
|
||||
<button
|
||||
key={preset}
|
||||
onClick={() => setBidAmount(Math.min(maxBid, Math.max(minBid, preset)))}
|
||||
disabled={!canAffordNextBid || Math.max(minBid, preset) > maxBid}
|
||||
disabled={
|
||||
isBidPending ||
|
||||
!canAffordNextBid ||
|
||||
Math.max(minBid, preset) > maxBid
|
||||
}
|
||||
className={`text-xs px-2.5 py-1 border transition-colors ${
|
||||
bidAmount === preset
|
||||
? 'border-primary/40 bg-primary/10 text-primary'
|
||||
@@ -659,16 +806,18 @@ function BidControls({
|
||||
}
|
||||
min={minBid}
|
||||
max={maxBid}
|
||||
disabled={!canAffordNextBid}
|
||||
disabled={isBidPending || !canAffordNextBid}
|
||||
className="w-24 text-xs px-2 py-1 border border-base-content/10 bg-transparent text-base-content tabular-nums text-right focus:outline-none focus:border-primary/30"
|
||||
/>
|
||||
</div>
|
||||
<button
|
||||
onClick={() => onBid(activeTeam.teamIndex, bidAmount)}
|
||||
onClick={() => onBid(activeTeam.teamIndex, effectiveBidAmount)}
|
||||
disabled={
|
||||
isBidPending ||
|
||||
!canAffordNextBid ||
|
||||
bidAmount > maxBid ||
|
||||
bidAmount <= state.currentBid
|
||||
isBidExpired ||
|
||||
effectiveBidAmount > maxBid ||
|
||||
effectiveBidAmount <= state.currentBid
|
||||
}
|
||||
className={`w-full py-2 text-xs font-bold uppercase tracking-wide border transition-colors disabled:opacity-30 disabled:cursor-not-allowed ${
|
||||
`${teamIndexColorClasses(activeTeam.teamIndex).border} ${teamIndexColorClasses(activeTeam.teamIndex).bg} ${teamIndexColorClasses(activeTeam.teamIndex).text} hover:bg-base-content/5`
|
||||
@@ -676,9 +825,13 @@ function BidControls({
|
||||
>
|
||||
{isActiveTeamFull
|
||||
? `${teamIndexLabel(activeTeam.teamIndex, activeTeam.name)} 정원 완료 (${activeTeamSize}/${AUCTION_MAX_TEAM_SIZE})`
|
||||
: isBidPending
|
||||
? '입찰 반영 중...'
|
||||
: isBidExpired
|
||||
? '입찰 마감 확인 중'
|
||||
: !canAffordNextBid
|
||||
? `입찰 불가 (다음 ${formatPoints(minBid)}P · 최대 ${formatPoints(maxBid)}P)`
|
||||
: `${teamIndexLabel(activeTeam.teamIndex, activeTeam.name)} 입찰 (${formatPoints(bidAmount)}P)`}
|
||||
: `${teamIndexLabel(activeTeam.teamIndex, activeTeam.name)} 입찰 (${formatPoints(effectiveBidAmount)}P)`}
|
||||
</button>
|
||||
</div>
|
||||
);
|
||||
@@ -721,6 +874,8 @@ function BidLog({ bids }: { bids: AuctionStateView['bids'] }) {
|
||||
);
|
||||
}
|
||||
|
||||
const MemoBidLog = memo(BidLog);
|
||||
|
||||
export default function AuctionPage() {
|
||||
const { id } = useParams();
|
||||
const location = useLocation();
|
||||
@@ -755,23 +910,35 @@ export default function AuctionPage() {
|
||||
const historyBackTo = `${location.pathname}${location.search}${location.hash}`;
|
||||
const canConfirmAuctionCancel = cancelConfirmText.trim() === '예';
|
||||
|
||||
async function invalidateAuctionData() {
|
||||
async function clearAuctionDataAfterCancel() {
|
||||
if (!id) return;
|
||||
const auctionQueryKey = ['auction', DEFAULT_COMMUNITY_ID, id] as const;
|
||||
const auctionHistoryQueryKey = [
|
||||
'auction-history',
|
||||
DEFAULT_COMMUNITY_ID,
|
||||
id,
|
||||
] as const;
|
||||
|
||||
await Promise.all([
|
||||
queryClient.invalidateQueries({
|
||||
queryKey: ['auction', DEFAULT_COMMUNITY_ID, id],
|
||||
}),
|
||||
queryClient.invalidateQueries({
|
||||
queryKey: ['auction-history', DEFAULT_COMMUNITY_ID, id],
|
||||
}),
|
||||
queryClient.invalidateQueries({
|
||||
queryKey: ['match', DEFAULT_COMMUNITY_ID, id],
|
||||
queryClient.cancelQueries({ queryKey: auctionQueryKey, exact: true }),
|
||||
queryClient.cancelQueries({
|
||||
queryKey: auctionHistoryQueryKey,
|
||||
exact: true,
|
||||
}),
|
||||
]);
|
||||
queryClient.removeQueries({ queryKey: auctionQueryKey, exact: true });
|
||||
queryClient.removeQueries({
|
||||
queryKey: auctionHistoryQueryKey,
|
||||
exact: true,
|
||||
});
|
||||
await queryClient.invalidateQueries({
|
||||
queryKey: ['match', DEFAULT_COMMUNITY_ID, id],
|
||||
exact: true,
|
||||
});
|
||||
}
|
||||
|
||||
useEffect(() => {
|
||||
const timer = window.setInterval(() => setNow(Date.now()), 1000);
|
||||
const timer = window.setInterval(() => setNow(Date.now()), 250);
|
||||
return () => window.clearInterval(timer);
|
||||
}, []);
|
||||
|
||||
@@ -782,14 +949,28 @@ export default function AuctionPage() {
|
||||
|
||||
const liveAuction = pickLatestAuction(socket.auction, auctionQuery.data);
|
||||
const syncedNow = now + socket.serverTimeOffsetMs;
|
||||
const auctionState =
|
||||
liveAuction && matchQuery.data
|
||||
? mapApiAuctionToAuctionState(
|
||||
liveAuction,
|
||||
matchQuery.data,
|
||||
new Date(syncedNow),
|
||||
)
|
||||
: null;
|
||||
const baseAuctionState = useMemo(
|
||||
() =>
|
||||
liveAuction && matchQuery.data
|
||||
? mapApiAuctionToAuctionState(liveAuction, matchQuery.data)
|
||||
: null,
|
||||
[liveAuction, matchQuery.data],
|
||||
);
|
||||
const auctionState = useMemo(() => {
|
||||
if (!baseAuctionState) return null;
|
||||
const deadlineTimestampMS = baseAuctionState.deadline
|
||||
? Date.parse(baseAuctionState.deadline)
|
||||
: undefined;
|
||||
const remainingMs =
|
||||
typeof deadlineTimestampMS === 'number' && Number.isFinite(deadlineTimestampMS)
|
||||
? Math.max(0, deadlineTimestampMS - syncedNow)
|
||||
: 0;
|
||||
return {
|
||||
...baseAuctionState,
|
||||
remainingMs,
|
||||
timer: Math.floor(remainingMs / 1000),
|
||||
};
|
||||
}, [baseAuctionState, syncedNow]);
|
||||
const availableTeamIndexes = useMemo(() => {
|
||||
const indexes = new Set((auctionState?.teams ?? []).map((team) => team.teamIndex));
|
||||
return [...indexes].sort((left, right) => left - right);
|
||||
@@ -817,7 +998,7 @@ export default function AuctionPage() {
|
||||
|
||||
useEffect(() => {
|
||||
if (!socket.resetAt || !id) return;
|
||||
void invalidateAuctionData().finally(() => {
|
||||
void clearAuctionDataAfterCancel().finally(() => {
|
||||
navigate(`/match/${id}`, { replace: true });
|
||||
});
|
||||
}, [id, navigate, socket.resetAt]);
|
||||
@@ -872,12 +1053,29 @@ export default function AuctionPage() {
|
||||
const errorMessage =
|
||||
socket.error ??
|
||||
(auctionQuery.error instanceof Error ? auctionQuery.error.message : null);
|
||||
const bidLatencyMessage = formatBidLatencyDiagnostics(
|
||||
socket.bidLatencyDiagnostics,
|
||||
);
|
||||
const matchSideEffectMessage = resolveMatchSideEffectMessage(
|
||||
auctionState.matchSideEffectStatus,
|
||||
);
|
||||
|
||||
function handleUndo(sequence: number) {
|
||||
if (!id) return;
|
||||
if (!window.confirm(`${sequence}번 액션 직전으로 되돌릴까요?`)) return;
|
||||
undoMutation.mutate(
|
||||
{ matchId: id, sequence },
|
||||
{
|
||||
auctionActionRequestId: createClientRequestId(),
|
||||
clientObservedAuctionLifecycleId: liveAuction?.auctionLifecycleId,
|
||||
clientObservedCurrentAuctionPlayerOrderIndex:
|
||||
liveAuction?.currentAuctionPlayerOrderIndex,
|
||||
clientObservedCurrentBidRoundPlayerUserId:
|
||||
liveAuction?.currentBidRoundPlayerUserId,
|
||||
clientObservedPhase: liveAuction?.phase,
|
||||
clientObservedRevision: liveAuction?.revision,
|
||||
matchId: id,
|
||||
sequence,
|
||||
},
|
||||
{
|
||||
onSuccess: async () => {
|
||||
await Promise.all([
|
||||
@@ -899,12 +1097,22 @@ export default function AuctionPage() {
|
||||
function handleResetAuction() {
|
||||
if (!id || !canConfirmAuctionCancel) return;
|
||||
resetAuctionMutation.mutate(
|
||||
{ matchId: id },
|
||||
{
|
||||
auctionActionRequestId: createClientRequestId(),
|
||||
clientObservedAuctionLifecycleId: liveAuction?.auctionLifecycleId,
|
||||
clientObservedCurrentAuctionPlayerOrderIndex:
|
||||
liveAuction?.currentAuctionPlayerOrderIndex,
|
||||
clientObservedCurrentBidRoundPlayerUserId:
|
||||
liveAuction?.currentBidRoundPlayerUserId,
|
||||
clientObservedPhase: liveAuction?.phase,
|
||||
clientObservedRevision: liveAuction?.revision,
|
||||
matchId: id,
|
||||
},
|
||||
{
|
||||
onSuccess: async () => {
|
||||
setShowCancelModal(false);
|
||||
setCancelConfirmText('');
|
||||
await invalidateAuctionData();
|
||||
await clearAuctionDataAfterCancel();
|
||||
navigate(`/match/${id}`, { replace: true });
|
||||
},
|
||||
},
|
||||
@@ -973,6 +1181,12 @@ export default function AuctionPage() {
|
||||
</div>
|
||||
)}
|
||||
|
||||
{import.meta.env.DEV && canManageAuction && bidLatencyMessage && (
|
||||
<div className="mb-4 border border-base-content/10 bg-base-100 px-4 py-2 text-xs text-base-content/45">
|
||||
입찰 계측 · {bidLatencyMessage}
|
||||
</div>
|
||||
)}
|
||||
|
||||
{undoMutation.error instanceof Error && (
|
||||
<div className="mb-4 border border-red-500/20 bg-red-500/10 px-4 py-3 text-sm text-red-500">
|
||||
{undoMutation.error.message}
|
||||
@@ -1049,12 +1263,12 @@ export default function AuctionPage() {
|
||||
|
||||
<div className="grid grid-cols-1 xl:grid-cols-[260px_minmax(0,1fr)_minmax(340px,440px)_320px] gap-4 mt-4">
|
||||
<aside className="hidden xl:block">
|
||||
<PoolPanel state={auctionState} />
|
||||
<MemoPoolPanel state={auctionState} />
|
||||
</aside>
|
||||
|
||||
<div className="grid sm:grid-cols-2 gap-4 content-start">
|
||||
{auctionState.teams.map((team) => (
|
||||
<TeamPanel
|
||||
<MemoTeamPanel
|
||||
key={team.teamIndex}
|
||||
team={team}
|
||||
isActive={isCurrentBidder(auctionState.currentBidder, team)}
|
||||
@@ -1074,6 +1288,11 @@ export default function AuctionPage() {
|
||||
<div className="text-xs text-base-content/40">
|
||||
모든 선수가 팀에 배정되었습니다.
|
||||
</div>
|
||||
{matchSideEffectMessage && (
|
||||
<div className="mt-3 border border-amber-500/20 bg-amber-500/10 px-3 py-2 text-xs text-amber-600">
|
||||
{matchSideEffectMessage}
|
||||
</div>
|
||||
)}
|
||||
<Link
|
||||
to={`/match/${id}`}
|
||||
className="btn btn-primary btn-sm mt-4 px-6 text-xs"
|
||||
@@ -1085,7 +1304,7 @@ export default function AuctionPage() {
|
||||
</>
|
||||
) : (
|
||||
<>
|
||||
<PlayerSpotlight
|
||||
<MemoPlayerSpotlight
|
||||
state={auctionState}
|
||||
historyBackTo={historyBackTo}
|
||||
/>
|
||||
@@ -1104,11 +1323,15 @@ export default function AuctionPage() {
|
||||
<BidControls
|
||||
state={auctionState}
|
||||
captainRole={captainRole}
|
||||
isBidPending={socket.isBidPending}
|
||||
onBid={(teamIndex, amount) =>
|
||||
socket.placeBid({ teamIndex, amount })
|
||||
socket.placeBid({
|
||||
bidderTeamIndex: teamIndex,
|
||||
bidPointAmount: amount,
|
||||
})
|
||||
}
|
||||
/>
|
||||
<BidLog bids={auctionState.bids} />
|
||||
<MemoBidLog bids={auctionState.bids} />
|
||||
|
||||
{canManageAuction && (
|
||||
<div className="border border-base-content/10 bg-base-100 p-4 space-y-3">
|
||||
@@ -1120,8 +1343,9 @@ export default function AuctionPage() {
|
||||
type="button"
|
||||
className="btn btn-primary btn-sm px-5 text-xs"
|
||||
onClick={() => socket.openBidding()}
|
||||
disabled={socket.isAuctionActionPending}
|
||||
>
|
||||
입찰 열기
|
||||
{socket.isAuctionActionPending ? '반영 중...' : '입찰 열기'}
|
||||
</button>
|
||||
)}
|
||||
{auctionState.phase === 'bidding' && (
|
||||
@@ -1141,8 +1365,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 ? '반영 중...' : '낙찰 처리'}
|
||||
</button>
|
||||
<button
|
||||
type="button"
|
||||
className="btn btn-outline btn-sm px-5 text-xs"
|
||||
onClick={() => socket.markPassed()}
|
||||
disabled={
|
||||
socket.isAuctionActionPending ||
|
||||
auctionState.currentBid > 0
|
||||
}
|
||||
>
|
||||
{socket.isAuctionActionPending ? '반영 중...' : '유찰 처리'}
|
||||
</button>
|
||||
</div>
|
||||
)}
|
||||
@@ -1152,8 +1388,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 ? '반영 중...' : '다음 선수'}
|
||||
</button>
|
||||
)}
|
||||
<div className="border-t border-base-content/10 pt-3">
|
||||
@@ -1380,6 +1617,17 @@ function PoolPanel({ state }: { state: AuctionStateView }) {
|
||||
);
|
||||
}
|
||||
|
||||
const MemoPoolPanel = memo(
|
||||
PoolPanel,
|
||||
(previous, next) =>
|
||||
previous.state.phase === next.state.phase &&
|
||||
previous.state.currentPlayerIndex === next.state.currentPlayerIndex &&
|
||||
previous.state.currentPlayer?.userId === next.state.currentPlayer?.userId &&
|
||||
previous.state.auctionOrder === next.state.auctionOrder &&
|
||||
previous.state.passedQueue === next.state.passedQueue &&
|
||||
previous.state.teams === next.state.teams,
|
||||
);
|
||||
|
||||
function PoolTabButton({
|
||||
label,
|
||||
count,
|
||||
@@ -1562,3 +1810,15 @@ function ChatPanel({
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
function resolveMatchSideEffectMessage(
|
||||
status: AuctionStateView['matchSideEffectStatus'],
|
||||
): string | null {
|
||||
if (status === 'pending' || status === 'processing') {
|
||||
return '팀 편성, 토너먼트 코드, 결과 수집 예약을 반영 중입니다.';
|
||||
}
|
||||
if (status === 'failed') {
|
||||
return '팀 편성 후속 처리에 실패했습니다. 운영진 확인이 필요합니다.';
|
||||
}
|
||||
return null;
|
||||
}
|
||||
@@ -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<string, CaptainSelection>
|
||||
>({});
|
||||
const [topTierThreshold, setTopTierThreshold] =
|
||||
const [
|
||||
topTierAuctionPriorityThreshold,
|
||||
setTopTierAuctionPriorityThreshold,
|
||||
] =
|
||||
useState<AuctionTopTierThreshold>("NONE");
|
||||
const [manualTopTierUserIds, setManualTopTierUserIds] = useState<string[]>(
|
||||
[],
|
||||
);
|
||||
const [maxTimerSeconds, setMaxTimerSeconds] = useState(
|
||||
const [
|
||||
manualTopTierAuctionPriorityUserIds,
|
||||
setManualTopTierAuctionPriorityUserIds,
|
||||
] = useState<string[]>([]);
|
||||
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);
|
||||
}
|
||||
@@ -2740,7 +2752,8 @@ export default function MatchDetailPage() {
|
||||
meQuery.isLoading || (meQuery.isFetching && !meQuery.data);
|
||||
const auctionNotStarted =
|
||||
auctionQuery.error instanceof ApiError && auctionQuery.error.status === 404;
|
||||
const showAuctionLink = Boolean(auctionQuery.data);
|
||||
const activeAuction = auctionNotStarted ? null : auctionQuery.data;
|
||||
const showAuctionLink = Boolean(activeAuction);
|
||||
const auctionParticipantPool = buildAuctionParticipantPool(
|
||||
matchQuery.data.participants,
|
||||
);
|
||||
@@ -2754,7 +2767,8 @@ export default function MatchDetailPage() {
|
||||
const hasValidCaptainInitialPoints = captainSlots.every((slot) =>
|
||||
Boolean(
|
||||
parseInitialPointsInput(
|
||||
captainSelections[captainSlotKey(slot)]?.initialPoints ?? "",
|
||||
captainSelections[captainSlotKey(slot)]
|
||||
?.initialTeamBidPointAmountInput ?? "",
|
||||
),
|
||||
),
|
||||
);
|
||||
@@ -2764,12 +2778,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 +3015,9 @@ export default function MatchDetailPage() {
|
||||
...current,
|
||||
[key]: {
|
||||
userId: event.target.value,
|
||||
initialPoints:
|
||||
current[key]?.initialPoints ??
|
||||
initialTeamBidPointAmountInput:
|
||||
current[key]
|
||||
?.initialTeamBidPointAmountInput ??
|
||||
"1000",
|
||||
},
|
||||
}))
|
||||
@@ -3035,28 +3054,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 +3107,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 +3141,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 +3174,9 @@ export default function MatchDetailPage() {
|
||||
상위 티어 우선 등장
|
||||
<select
|
||||
className="mt-1 h-[38px] w-full border border-base-content/10 bg-transparent px-2 py-2 text-sm focus:border-primary/30 focus:outline-none"
|
||||
value={topTierThreshold}
|
||||
value={topTierAuctionPriorityThreshold}
|
||||
onChange={(event) =>
|
||||
setTopTierThreshold(
|
||||
setTopTierAuctionPriorityThreshold(
|
||||
event.target.value as AuctionTopTierThreshold,
|
||||
)
|
||||
}
|
||||
@@ -3157,7 +3189,7 @@ export default function MatchDetailPage() {
|
||||
</select>
|
||||
</label>
|
||||
</div>
|
||||
{topTierThreshold === "MANUAL" && (
|
||||
{topTierAuctionPriorityThreshold === "MANUAL" && (
|
||||
<div className="border border-base-content/10 bg-base-200/20 p-3">
|
||||
<div className="mb-2 text-xs font-bold uppercase tracking-wider text-base-content/35">
|
||||
우선 등장 선수
|
||||
@@ -3193,18 +3225,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 +3259,9 @@ export default function MatchDetailPage() {
|
||||
disabled={
|
||||
!canStartAuction || startAuctionMutation.isPending
|
||||
}
|
||||
onClick={() => startAuctionMutation.mutate()}
|
||||
onClick={() =>
|
||||
startAuctionMutation.mutate(crypto.randomUUID())
|
||||
}
|
||||
>
|
||||
{startAuctionMutation.isPending
|
||||
? "시작 중..."
|
||||
|
||||
Generated
+42
@@ -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
|
||||
|
||||
Reference in new issue
Block a user