Compare commits
20
Commits
release/80
...
release/83
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
8567948084 | ||
|
|
37f1f4225d | ||
|
|
6dbc643c44 | ||
|
|
d2fc126fed | ||
|
|
ab721873f3 | ||
|
|
2984bd1604 | ||
|
|
e50a683336 | ||
|
|
9c69e35cfa | ||
|
|
55b80e62cd | ||
|
|
09d304d782 | ||
|
|
46c8007e94 | ||
|
|
b367328df0 | ||
|
|
c6f5a7077f | ||
|
|
7c372f0392 | ||
|
|
e8bb20d988 | ||
|
|
737702d78c | ||
|
|
98c2323ff2 | ||
|
|
d2fe4604dd | ||
|
|
b0dc857463 | ||
|
|
bac29ac933 |
No files matched your search
+1
-1
@@ -1 +1 @@
|
||||
77
|
||||
83
|
||||
+8
-1
@@ -41,9 +41,16 @@ COPY --from=prod-deps --chown=nonroot:nonroot /app/package.json ./package.json
|
||||
COPY --from=prod-deps --chown=nonroot:nonroot /app/node_modules ./node_modules
|
||||
COPY --from=prod-deps --chown=nonroot:nonroot /app/apps/api/package.json ./apps/api/package.json
|
||||
COPY --from=prod-deps --chown=nonroot:nonroot /app/apps/api/node_modules ./apps/api/node_modules
|
||||
COPY --chown=nonroot:nonroot apps/api/newrelic.cjs ./apps/api/newrelic.cjs
|
||||
COPY --from=build --chown=nonroot:nonroot /app/apps/api/dist ./apps/api/dist
|
||||
COPY --chown=nonroot:nonroot apps/project.env ./project.env
|
||||
|
||||
EXPOSE 10712
|
||||
|
||||
CMD ["apps/api/dist/main.js"]
|
||||
ENV NEW_RELIC_HOME=/app/apps/api \
|
||||
NEW_RELIC_APP_NAME=lolympus \
|
||||
NEW_RELIC_AI_MONITORING_ENABLED=true \
|
||||
NEW_RELIC_CUSTOM_INSIGHTS_EVENTS_MAX_SAMPLES_STORED=100000 \
|
||||
NEW_RELIC_SPAN_EVENTS_MAX_SAMPLES_STORED=10000
|
||||
|
||||
CMD ["--import", "/app/apps/api/node_modules/newrelic/esm-loader.mjs", "-r", "/app/apps/api/node_modules/newrelic", "apps/api/dist/main.js"]
|
||||
@@ -4,7 +4,7 @@ LOLYMPUS는 리그 오브 레전드 커뮤니티의 여러 이벤트 중 내전(
|
||||
|
||||
<p align="center">
|
||||
<video
|
||||
src="https://git.dahyeon.us/dahyeon/lolympus-tournament-support/raw/branch/release/77/docs/screenshots/lolympus-demo.mp4"
|
||||
src="https://git.dahyeon.us/dahyeon/lolympus-tournament-support/raw/branch/release/83/docs/screenshots/lolympus-demo.mp4"
|
||||
poster="docs/screenshots/lolympus-auction.png"
|
||||
width="960"
|
||||
autoplay="autoplay"
|
||||
@@ -13,20 +13,20 @@ LOLYMPUS는 리그 오브 레전드 커뮤니티의 여러 이벤트 중 내전(
|
||||
playsinline="playsinline"
|
||||
controls
|
||||
>
|
||||
<a href="https://git.dahyeon.us/dahyeon/lolympus-tournament-support/raw/branch/release/77/docs/screenshots/lolympus-demo.mp4">3초 간격 데모 영상 보기</a>
|
||||
<a href="https://git.dahyeon.us/dahyeon/lolympus-tournament-support/raw/branch/release/83/docs/screenshots/lolympus-demo.mp4">3초 간격 데모 영상 보기</a>
|
||||
</video>
|
||||
</p>
|
||||
|
||||
<p align="center">
|
||||
<a href="https://git.dahyeon.us/dahyeon/lolympus-tournament-support/raw/branch/release/77/docs/screenshots/lolympus-demo.mp4">3초 간격 데모 영상 보기</a>
|
||||
<a href="https://git.dahyeon.us/dahyeon/lolympus-tournament-support/raw/branch/release/83/docs/screenshots/lolympus-demo.mp4">3초 간격 데모 영상 보기</a>
|
||||
</p>
|
||||
|
||||
## 배포 주소
|
||||
|
||||
| Environment | Version | URL |
|
||||
| ----------- | ------- | -------------------------------------- |
|
||||
| Production | v77 | <https://lolympus.dahyeon.us/> |
|
||||
| Staging | v77 | <https://890c50be.lolympus.pages.dev/> |
|
||||
| Production | v83 | <https://lolympus.dahyeon.us/> |
|
||||
| Staging | v83 | <https://release-83.lolympus.pages.dev/> |
|
||||
|
||||
## 개요
|
||||
|
||||
@@ -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`를 읽고, 두 값이 같은 호스트/포트를 가리키면 부팅을 거부합니다.
|
||||
|
||||
## 실행 방법
|
||||
|
||||
@@ -125,6 +128,23 @@ pnpm start:web:dev
|
||||
|
||||
웹 앱은 기본적으로 `apps/web/.env.development` 값을 사용합니다. API 환경값은 `apps/project.env`와 실행 환경의 시크릿 설정을 함께 확인합니다.
|
||||
|
||||
### API New Relic APM
|
||||
|
||||
API 서버는 `newrelic` Node.js agent를 앱 코드보다 먼저 preload합니다. Docker 런타임과 `pnpm start:api:*` 스크립트 모두 `NEW_RELIC_HOME`을 API 패키지로 지정해 `apps/api/newrelic.cjs` 설정을 읽습니다.
|
||||
|
||||
Kubernetes에서는 Infisical이 `NEW_RELIC_LICENSE_KEY`를 프로세스 시작 전에 환경변수로 주입해야 합니다. 저장소에는 라이선스 키를 두지 않습니다.
|
||||
|
||||
비밀이 아닌 기본값은 Dockerfile과 `apps/api/newrelic.cjs`에 정의되어 있으며 필요하면 런타임 환경변수로 덮어쓸 수 있습니다.
|
||||
|
||||
```bash
|
||||
NEW_RELIC_APP_NAME=lolympus
|
||||
NEW_RELIC_AI_MONITORING_ENABLED=true
|
||||
NEW_RELIC_CUSTOM_INSIGHTS_EVENTS_MAX_SAMPLES_STORED=100000
|
||||
NEW_RELIC_SPAN_EVENTS_MAX_SAMPLES_STORED=10000
|
||||
```
|
||||
|
||||
New Relic Node agent의 정수 환경변수는 `100k` 같은 축약형 대신 `100000`처럼 숫자 문자열을 사용합니다.
|
||||
|
||||
카카오톡 기반 명령어 기능은 Dakao(커스텀 카카오톡 게이트웨이) 연동이 필요합니다. Dakao가 실행 중이 아니거나 NATS를 통해 API 서버와 연결되어 있지 않으면 일정 조회, 내전 참가, 참가 취소, 계정 등록 같은 카카오톡 명령어는 사용할 수 없습니다.
|
||||
|
||||
## 커맨드
|
||||
|
||||
@@ -0,0 +1,69 @@
|
||||
'use strict';
|
||||
|
||||
function readBoolean(name, defaultValue) {
|
||||
const value = process.env[name];
|
||||
if (value == null || value === '') return defaultValue;
|
||||
|
||||
return !['0', 'false', 'f', 'no', 'n', 'disabled'].includes(
|
||||
value.toLowerCase(),
|
||||
);
|
||||
}
|
||||
|
||||
function readInteger(name, defaultValue) {
|
||||
const rawValue = process.env[name]?.trim();
|
||||
if (!rawValue) return defaultValue;
|
||||
|
||||
if (/^\d+$/.test(rawValue)) {
|
||||
return Number.parseInt(rawValue, 10);
|
||||
}
|
||||
|
||||
process.env[name] = String(defaultValue);
|
||||
return defaultValue;
|
||||
}
|
||||
|
||||
const hasLicenseKey = Boolean(process.env.NEW_RELIC_LICENSE_KEY);
|
||||
|
||||
exports.config = {
|
||||
app_name: [process.env.NEW_RELIC_APP_NAME || 'lolympus'],
|
||||
license_key: process.env.NEW_RELIC_LICENSE_KEY || '',
|
||||
agent_enabled: readBoolean('NEW_RELIC_ENABLED', hasLicenseKey),
|
||||
distributed_tracing: {
|
||||
enabled: true,
|
||||
},
|
||||
ai_monitoring: {
|
||||
enabled: readBoolean('NEW_RELIC_AI_MONITORING_ENABLED', true),
|
||||
},
|
||||
custom_insights_events: {
|
||||
max_samples_stored: readInteger(
|
||||
'NEW_RELIC_CUSTOM_INSIGHTS_EVENTS_MAX_SAMPLES_STORED',
|
||||
100000,
|
||||
),
|
||||
},
|
||||
span_events: {
|
||||
max_samples_stored: readInteger(
|
||||
'NEW_RELIC_SPAN_EVENTS_MAX_SAMPLES_STORED',
|
||||
10000,
|
||||
),
|
||||
},
|
||||
logging: {
|
||||
level: process.env.NEW_RELIC_LOG_LEVEL || 'info',
|
||||
},
|
||||
instrumentation: {
|
||||
timers: {
|
||||
enabled: false,
|
||||
},
|
||||
},
|
||||
allow_all_headers: false,
|
||||
attributes: {
|
||||
exclude: [
|
||||
'request.headers.cookie',
|
||||
'request.headers.authorization',
|
||||
'request.headers.proxyAuthorization',
|
||||
'request.headers.setCookie*',
|
||||
'response.headers.cookie',
|
||||
'response.headers.authorization',
|
||||
'response.headers.proxyAuthorization',
|
||||
'response.headers.setCookie*',
|
||||
],
|
||||
},
|
||||
};
|
||||
@@ -10,9 +10,9 @@
|
||||
"format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
|
||||
"seed:dev": "ts-node src/seed.ts",
|
||||
"seed:dakao-participant": "ts-node src/seed-dakao-participant.ts",
|
||||
"start:dev": "node -e \"process.env.NODE_ENV='dev'; require('./dist/main.js')\"",
|
||||
"start:staging": "node -e \"process.env.NODE_ENV='staging'; require('./dist/main.js')\"",
|
||||
"start:prod": "node -e \"process.env.NODE_ENV='prod'; require('./dist/main.js')\"",
|
||||
"start:dev": "NODE_ENV=dev NEW_RELIC_HOME=. node --import newrelic/esm-loader.mjs -r newrelic dist/main.js",
|
||||
"start:staging": "NODE_ENV=staging NEW_RELIC_HOME=. node --import newrelic/esm-loader.mjs -r newrelic dist/main.js",
|
||||
"start:prod": "NODE_ENV=prod NEW_RELIC_HOME=. node --import newrelic/esm-loader.mjs -r newrelic dist/main.js",
|
||||
"pm2:dev": "pm2 start npm --name lolympus-tournament-support --update-env -- run start:dev",
|
||||
"pm2:staging": "pm2 start npm --name lolympus-tournament-support --update-env -- run start:staging",
|
||||
"pm2:prod": "pm2 start npm --name lolympus-tournament-support --update-env -- run start:prod",
|
||||
@@ -32,11 +32,13 @@
|
||||
"@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",
|
||||
"mongoose": "^9.4.1",
|
||||
"nats": "^2.29.3",
|
||||
"newrelic": "^14.1.2",
|
||||
"redis": "^5.12.1",
|
||||
"reflect-metadata": "^0.2.2",
|
||||
"rxjs": "^7.8.1",
|
||||
|
||||
@@ -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;
|
||||
|
||||
|
||||
@@ -191,4 +191,54 @@ describe('CommunityStatsService', () => {
|
||||
response,
|
||||
);
|
||||
});
|
||||
|
||||
it('includes internal match route fields in user internal history matches', async () => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const userId = new mongoose.Types.ObjectId();
|
||||
const participant = record(matchId);
|
||||
participant.userId = userId.toString();
|
||||
participant.gameNumber = 2;
|
||||
participant.riotMatchId = 'KR_1234';
|
||||
|
||||
const cacheService = {
|
||||
get: jest.fn().mockResolvedValue(null),
|
||||
set: jest.fn().mockResolvedValue(undefined),
|
||||
} as unknown as jest.Mocked<CommunityStatsCacheService>;
|
||||
const service = new CommunityStatsService(
|
||||
{} as ConnectionService,
|
||||
cacheService,
|
||||
{} as MatchStatsRepository,
|
||||
{} as MatchStatsService,
|
||||
);
|
||||
(service as unknown as { buildBaseDataset: jest.Mock }).buildBaseDataset =
|
||||
jest.fn().mockResolvedValue({
|
||||
season: {
|
||||
id: 'all',
|
||||
label: '전체',
|
||||
startTime: null,
|
||||
endTime: null,
|
||||
},
|
||||
matches: [],
|
||||
records: [participant],
|
||||
detailsByMatchId: new Map(),
|
||||
});
|
||||
|
||||
const response = await service.getUserInternalHistory({
|
||||
communityId,
|
||||
userId,
|
||||
filters: { limit: 5 },
|
||||
});
|
||||
|
||||
expect(response.matches[0]).toMatchObject({
|
||||
matchId: 'KR_1234',
|
||||
internalMatchId: matchId.toString(),
|
||||
gameNumber: 2,
|
||||
queueLabel: '내전',
|
||||
});
|
||||
expect(cacheService.set).toHaveBeenCalledWith(
|
||||
expect.stringContaining(`userInternal:v2:${userId.toString()}`),
|
||||
response,
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -293,7 +293,7 @@ export class CommunityStatsService {
|
||||
filters: CommunityStatsFilters;
|
||||
}): Promise<UserInternalHistoryResponse> {
|
||||
const key = this.cacheKey(
|
||||
`userInternal:${params.userId.toString()}`,
|
||||
`userInternal:v2:${params.userId.toString()}`,
|
||||
params.communityId,
|
||||
params.filters,
|
||||
);
|
||||
@@ -789,6 +789,8 @@ export class CommunityStatsService {
|
||||
?.find((game) => game.riotMatchId === record.riotMatchId);
|
||||
return {
|
||||
matchId: record.riotMatchId,
|
||||
internalMatchId: record.matchId,
|
||||
gameNumber: record.gameNumber,
|
||||
queueId: 0,
|
||||
queueLabel: '내전',
|
||||
gameCreation: record.gameCreation,
|
||||
|
||||
@@ -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;
|
||||
@@ -1225,7 +1326,6 @@ export const TournamentCodeSchema = new Schema<TournamentCode>(
|
||||
type: String,
|
||||
required: true,
|
||||
trim: true,
|
||||
uppercase: true,
|
||||
},
|
||||
region: { type: String, required: true, default: 'kr' },
|
||||
mapType: {
|
||||
@@ -1647,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 },
|
||||
@@ -1657,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 },
|
||||
@@ -1682,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],
|
||||
@@ -1721,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,
|
||||
@@ -1728,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,
|
||||
@@ -1745,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 },
|
||||
},
|
||||
{
|
||||
@@ -1767,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(
|
||||
{
|
||||
@@ -1841,6 +2127,11 @@ export const tournamentModelDefinitions: ModelDefinition[] = [
|
||||
schema: AuctionHistoryEntrySchema,
|
||||
schemaName: 'auctionHistory',
|
||||
},
|
||||
{
|
||||
name: 'auctionSideEffectApplication',
|
||||
schema: AuctionSideEffectApplicationSchema,
|
||||
schemaName: 'auctionSideEffectApplication',
|
||||
},
|
||||
{
|
||||
name: 'matchStats',
|
||||
schema: MatchStatsSchema,
|
||||
@@ -1861,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,39 @@
|
||||
// [AUCTION-DEBUG] 경매 "중복 멤버" 조사용 서버 계측 래퍼. 조사 종료 후 호출부와 함께
|
||||
// 제거 대상(범용으로 남길 거면 이 마커만 떼면 됨).
|
||||
import newrelicAgent from 'newrelic';
|
||||
|
||||
export type NewRelicAttributeValue = string | number | boolean | null;
|
||||
|
||||
// newrelic 기본 export는 타입이 느슨해 unsafe-call로 잡힌다. 우리가 쓰는 부분만
|
||||
// 좁게 타입을 고정한다(에이전트는 -r newrelic로 이미 preload됨).
|
||||
interface NewRelicCustomEventApi {
|
||||
recordCustomEvent(
|
||||
eventType: string,
|
||||
attributes: Record<string, NewRelicAttributeValue>,
|
||||
): void;
|
||||
}
|
||||
const agent = newrelicAgent as unknown as NewRelicCustomEventApi;
|
||||
|
||||
/**
|
||||
* 서버 커스텀 이벤트를 New Relic으로 보낸다(클라의 addPageAction 대응).
|
||||
*
|
||||
* - 에이전트는 `-r newrelic`로 이미 preload되어 있으므로 여기서 import만 하면 된다.
|
||||
* - `recordCustomEvent`는 활성 트랜잭션이 없어도 동작하므로 durability 스케줄러
|
||||
* tick이나 socket.io 핸들러처럼 HTTP 컨텍스트 밖에서도 그대로 호출할 수 있다.
|
||||
* - 평탄한 스칼라만 받는다(중첩 객체/배열 불가). undefined 속성은 제거한다.
|
||||
* - 에이전트 비활성/테스트 환경에서도 호출부가 깨지지 않도록 예외를 삼킨다.
|
||||
*/
|
||||
export function recordNewRelicCustomEvent(
|
||||
eventType: string,
|
||||
attributes: Record<string, NewRelicAttributeValue | undefined>,
|
||||
): void {
|
||||
try {
|
||||
const flat: Record<string, NewRelicAttributeValue> = {};
|
||||
for (const [key, value] of Object.entries(attributes)) {
|
||||
if (value !== undefined) flat[key] = value;
|
||||
}
|
||||
agent.recordCustomEvent(eventType, flat);
|
||||
} catch {
|
||||
// 관측성 실패가 비즈니스 로직을 막아선 안 된다.
|
||||
}
|
||||
}
|
||||
@@ -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(
|
||||
|
||||
@@ -135,6 +135,8 @@ export interface RecentMatchTeamParticipantView {
|
||||
|
||||
export interface RecentMatchView {
|
||||
matchId: string;
|
||||
internalMatchId?: string;
|
||||
gameNumber?: number;
|
||||
queueId: number;
|
||||
queueLabel: string;
|
||||
gameCreation: number;
|
||||
|
||||
@@ -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,111 @@
|
||||
import {
|
||||
SYSTEM_TOURNAMENT_CODE_UPLOADED_BY,
|
||||
TournamentCodeAutoProvisionService,
|
||||
} from './tournament-code-auto-provision.service';
|
||||
import { TournamentCodeService } from './tournament-code.service';
|
||||
import { TournamentCodeVendorService } from './tournament-code-vendor.service';
|
||||
|
||||
describe('TournamentCodeAutoProvisionService', () => {
|
||||
function createFixture(params?: {
|
||||
availableCounts?: number[];
|
||||
vendorCodes?: string[];
|
||||
}) {
|
||||
const availableCounts = [...(params?.availableCounts ?? [30])];
|
||||
const vendorCodes = [...(params?.vendorCodes ?? [])];
|
||||
const tournamentCodeService = {
|
||||
countUsableAvailable: jest.fn().mockImplementation(async () => {
|
||||
return availableCounts.shift() ?? 30;
|
||||
}),
|
||||
bulkUpload: jest.fn().mockResolvedValue({
|
||||
inserted: 1,
|
||||
duplicates: [],
|
||||
invalid: [],
|
||||
}),
|
||||
} as unknown as jest.Mocked<TournamentCodeService>;
|
||||
const vendorService = {
|
||||
fetchTournamentCode: jest.fn().mockImplementation(async () => {
|
||||
const code = vendorCodes.shift();
|
||||
if (!code) throw new Error('No vendor code');
|
||||
return code;
|
||||
}),
|
||||
} as unknown as jest.Mocked<TournamentCodeVendorService>;
|
||||
const service = new TournamentCodeAutoProvisionService(
|
||||
tournamentCodeService,
|
||||
vendorService,
|
||||
);
|
||||
jest
|
||||
.spyOn(
|
||||
service as unknown as { sleepBeforeVendorRequest(): Promise<void> },
|
||||
'sleepBeforeVendorRequest',
|
||||
)
|
||||
.mockResolvedValue(undefined);
|
||||
|
||||
return { service, tournamentCodeService, vendorService };
|
||||
}
|
||||
|
||||
it('does nothing when the usable pool already meets the target', async () => {
|
||||
const { service, tournamentCodeService, vendorService } = createFixture({
|
||||
availableCounts: [30],
|
||||
});
|
||||
|
||||
await expect(service.ensurePool()).resolves.toMatchObject({
|
||||
target: 30,
|
||||
before: 30,
|
||||
after: 30,
|
||||
requested: 0,
|
||||
inserted: 0,
|
||||
});
|
||||
expect(vendorService.fetchTournamentCode).not.toHaveBeenCalled();
|
||||
expect(tournamentCodeService.bulkUpload).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('requests vendor codes until the pool reaches 30', async () => {
|
||||
const { service, tournamentCodeService, vendorService } = createFixture({
|
||||
availableCounts: [28, 29, 30],
|
||||
vendorCodes: ['KR05090-aBc', 'KR05090-dEf'],
|
||||
});
|
||||
|
||||
const result = await service.ensurePool();
|
||||
|
||||
expect(result).toMatchObject({
|
||||
target: 30,
|
||||
before: 28,
|
||||
after: 30,
|
||||
requested: 2,
|
||||
inserted: 2,
|
||||
});
|
||||
expect(vendorService.fetchTournamentCode).toHaveBeenCalledTimes(2);
|
||||
expect(
|
||||
(
|
||||
service as unknown as {
|
||||
sleepBeforeVendorRequest: jest.Mock;
|
||||
}
|
||||
).sleepBeforeVendorRequest,
|
||||
).toHaveBeenCalledTimes(2);
|
||||
expect(tournamentCodeService.bulkUpload).toHaveBeenCalledWith({
|
||||
uploadedBy: SYSTEM_TOURNAMENT_CODE_UPLOADED_BY,
|
||||
codes: [
|
||||
expect.objectContaining({
|
||||
code: 'KR05090-aBc',
|
||||
source: 'deeplol-vendor',
|
||||
spectatorType: 'ALL',
|
||||
}),
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
it('shares an in-flight refill instead of starting overlapping vendor loops', async () => {
|
||||
const { service, vendorService } = createFixture({
|
||||
availableCounts: [29, 30],
|
||||
vendorCodes: ['KR05090-aBc'],
|
||||
});
|
||||
|
||||
const [left, right] = await Promise.all([
|
||||
service.ensurePool(),
|
||||
service.ensurePool(),
|
||||
]);
|
||||
|
||||
expect(left).toBe(right);
|
||||
expect(vendorService.fetchTournamentCode).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,128 @@
|
||||
import { Injectable, Logger } from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import { TOURNAMENT_CODE_EXPIRY_MARGIN_MS } from './tournament-code.constants';
|
||||
import { TournamentCodeService } from './tournament-code.service';
|
||||
import {
|
||||
resolveVendorRequestDelayMs,
|
||||
TournamentCodeVendorService,
|
||||
} from './tournament-code-vendor.service';
|
||||
|
||||
const DEFAULT_POOL_TARGET = 30;
|
||||
const DEFAULT_VENDOR_CODE_EXPIRES_IN_MS = 14 * 24 * 60 * 60 * 1000;
|
||||
const MAX_REFILL_ATTEMPTS_MULTIPLIER = 2;
|
||||
|
||||
export const SYSTEM_TOURNAMENT_CODE_UPLOADED_BY = new mongoose.Types.ObjectId(
|
||||
'000000000000000000000000',
|
||||
);
|
||||
|
||||
export interface TournamentCodeAutoProvisionResult {
|
||||
target: number;
|
||||
before: number;
|
||||
after: number;
|
||||
requested: number;
|
||||
inserted: number;
|
||||
duplicates: number;
|
||||
invalid: number;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class TournamentCodeAutoProvisionService {
|
||||
private readonly logger = new Logger(TournamentCodeAutoProvisionService.name);
|
||||
private inFlight?: Promise<TournamentCodeAutoProvisionResult>;
|
||||
|
||||
constructor(
|
||||
private readonly tournamentCodeService: TournamentCodeService,
|
||||
private readonly vendorService: TournamentCodeVendorService,
|
||||
) {}
|
||||
|
||||
public async ensurePool(): Promise<TournamentCodeAutoProvisionResult> {
|
||||
if (this.inFlight) return this.inFlight;
|
||||
|
||||
this.inFlight = this.refillPool().finally(() => {
|
||||
this.inFlight = undefined;
|
||||
});
|
||||
return this.inFlight;
|
||||
}
|
||||
|
||||
public async sleepBeforeVendorRequest(): Promise<void> {
|
||||
await sleep(resolveVendorRequestDelayMs());
|
||||
}
|
||||
|
||||
private async refillPool(): Promise<TournamentCodeAutoProvisionResult> {
|
||||
const target = resolvePoolTarget();
|
||||
const before = await this.tournamentCodeService.countUsableAvailable();
|
||||
let after = before;
|
||||
let requested = 0;
|
||||
let inserted = 0;
|
||||
let duplicates = 0;
|
||||
let invalid = 0;
|
||||
|
||||
const maxAttempts = Math.max(
|
||||
1,
|
||||
(target - before) * MAX_REFILL_ATTEMPTS_MULTIPLIER,
|
||||
);
|
||||
|
||||
while (after < target && requested < maxAttempts) {
|
||||
await this.sleepBeforeVendorRequest();
|
||||
const code = await this.vendorService.fetchTournamentCode();
|
||||
requested += 1;
|
||||
|
||||
const uploadResult = await this.tournamentCodeService.bulkUpload({
|
||||
uploadedBy: SYSTEM_TOURNAMENT_CODE_UPLOADED_BY,
|
||||
codes: [
|
||||
{
|
||||
code,
|
||||
expiresAt: resolveVendorCodeExpiresAt().toISOString(),
|
||||
spectatorType: 'ALL',
|
||||
source: 'deeplol-vendor',
|
||||
notes: 'auto-provisioned from Deeplol vendor',
|
||||
},
|
||||
],
|
||||
});
|
||||
inserted += uploadResult.inserted;
|
||||
duplicates += uploadResult.duplicates.length;
|
||||
invalid += uploadResult.invalid.length;
|
||||
after = await this.tournamentCodeService.countUsableAvailable();
|
||||
}
|
||||
|
||||
if (inserted > 0 || before < target) {
|
||||
this.logger.log(
|
||||
`Tournament code pool refill: before=${before} after=${after} target=${target} requested=${requested} inserted=${inserted} duplicates=${duplicates} invalid=${invalid}`,
|
||||
);
|
||||
}
|
||||
|
||||
return {
|
||||
target,
|
||||
before,
|
||||
after,
|
||||
requested,
|
||||
inserted,
|
||||
duplicates,
|
||||
invalid,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
function resolvePoolTarget(): number {
|
||||
const configured = Number(process.env.TOURNAMENT_CODE_POOL_TARGET);
|
||||
return Number.isInteger(configured) && configured > 0
|
||||
? configured
|
||||
: DEFAULT_POOL_TARGET;
|
||||
}
|
||||
|
||||
function resolveVendorCodeExpiresAt(): Date {
|
||||
const configuredHours = Number(
|
||||
process.env.TOURNAMENT_CODE_VENDOR_EXPIRES_IN_HOURS,
|
||||
);
|
||||
const expiresInMs =
|
||||
Number.isFinite(configuredHours) && configuredHours > 0
|
||||
? configuredHours * 60 * 60 * 1000
|
||||
: DEFAULT_VENDOR_CODE_EXPIRES_IN_MS;
|
||||
return new Date(
|
||||
Date.now() + Math.max(expiresInMs, TOURNAMENT_CODE_EXPIRY_MARGIN_MS),
|
||||
);
|
||||
}
|
||||
|
||||
function sleep(ms: number): Promise<void> {
|
||||
return new Promise((resolve) => setTimeout(resolve, ms));
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
import {
|
||||
buildDeeplolTournamentCodeRequest,
|
||||
resolveVendorRequestDelayMs,
|
||||
TournamentCodeVendorService,
|
||||
} from './tournament-code-vendor.service';
|
||||
|
||||
describe('TournamentCodeVendorService', () => {
|
||||
const originalFetch = global.fetch;
|
||||
|
||||
afterEach(() => {
|
||||
global.fetch = originalFetch;
|
||||
jest.restoreAllMocks();
|
||||
});
|
||||
|
||||
it('builds the Deeplol request URL and browser-like headers', () => {
|
||||
const request = buildDeeplolTournamentCodeRequest();
|
||||
|
||||
expect(request.url.toString()).toBe(
|
||||
'https://b2c-api.deeplol.gg/tournament/tournament_code?server_id=212&server_name=%EB%A1%A4%EB%A6%BC%ED%91%B8%EC%8A%A4&server_comment=LPS_%EB%82%B4%EC%A0%84&spectator_type=ALL&pick_type=TOURNAMENT_DRAFT&map_name=SUMMONERS_RIFT&platform_id=KR',
|
||||
);
|
||||
expect(request.headers).toMatchObject({
|
||||
accept: '*/*',
|
||||
'accept-encoding': 'gzip, deflate, br, zstd',
|
||||
'accept-language': 'ko,en;q=0.9,en-US;q=0.8',
|
||||
'cache-control': 'no-cache',
|
||||
host: 'b2c-api.deeplol.gg',
|
||||
origin: 'https://clash.deeplol.gg',
|
||||
pragma: 'no-cache',
|
||||
priority: 'u=1, i',
|
||||
referer: 'https://clash.deeplol.gg/',
|
||||
'sec-ch-ua':
|
||||
'"Microsoft Edge";v="149", "Chromium";v="149", "Not)A;Brand";v="24"',
|
||||
'sec-ch-ua-mobile': '?0',
|
||||
'sec-ch-ua-platform': '"Windows"',
|
||||
'sec-fetch-dest': 'empty',
|
||||
'sec-fetch-mode': 'cors',
|
||||
'sec-fetch-site': 'same-site',
|
||||
'user-agent':
|
||||
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36 Edg/149.0.0.0',
|
||||
});
|
||||
expect(Object.keys(request.headers)).not.toContain(':authority');
|
||||
});
|
||||
|
||||
it('fetches the first tournament code from the vendor response', async () => {
|
||||
global.fetch = jest.fn().mockResolvedValue({
|
||||
ok: true,
|
||||
status: 200,
|
||||
json: jest.fn().mockResolvedValue({
|
||||
tournament_code_list: [
|
||||
'KR05090-85d64e26-0a7d-438b-9ada-11784e46add3',
|
||||
],
|
||||
}),
|
||||
});
|
||||
const service = new TournamentCodeVendorService();
|
||||
|
||||
await expect(service.fetchTournamentCode()).resolves.toBe(
|
||||
'KR05090-85d64e26-0a7d-438b-9ada-11784e46add3',
|
||||
);
|
||||
expect(global.fetch).toHaveBeenCalledWith(
|
||||
expect.stringContaining(
|
||||
'https://b2c-api.deeplol.gg/tournament/tournament_code?',
|
||||
),
|
||||
expect.objectContaining({
|
||||
method: 'GET',
|
||||
headers: expect.objectContaining({
|
||||
origin: 'https://clash.deeplol.gg',
|
||||
referer: 'https://clash.deeplol.gg/',
|
||||
}),
|
||||
signal: expect.any(AbortSignal),
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('rejects malformed vendor responses', async () => {
|
||||
global.fetch = jest.fn().mockResolvedValue({
|
||||
ok: true,
|
||||
status: 200,
|
||||
json: jest.fn().mockResolvedValue({
|
||||
tournament_code_list: [null],
|
||||
}),
|
||||
});
|
||||
const service = new TournamentCodeVendorService();
|
||||
|
||||
await expect(service.fetchTournamentCode()).rejects.toThrow(
|
||||
'Vendor tournament code response is malformed.',
|
||||
);
|
||||
});
|
||||
|
||||
it('generates mostly near-5-second delays with occasional extra delay', () => {
|
||||
expect(resolveVendorRequestDelayMs(() => 0.1)).toBe(5_050);
|
||||
expect(resolveVendorRequestDelayMs(() => 0.84)).toBe(5_420);
|
||||
expect(resolveVendorRequestDelayMs(() => 0.9)).toBe(8_700);
|
||||
expect(resolveVendorRequestDelayMs(() => 0)).toBeGreaterThanOrEqual(5_000);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,152 @@
|
||||
import { Injectable } from '@nestjs/common';
|
||||
|
||||
const DEFAULT_VENDOR_URL =
|
||||
'https://b2c-api.deeplol.gg/tournament/tournament_code';
|
||||
const DEFAULT_FETCH_TIMEOUT_MS = 10_000;
|
||||
const MIN_REQUEST_DELAY_MS = 5_000;
|
||||
|
||||
const DEFAULT_QUERY_PARAMS = {
|
||||
server_id: '212',
|
||||
server_name: '롤림푸스',
|
||||
server_comment: 'LPS_내전',
|
||||
spectator_type: 'ALL',
|
||||
pick_type: 'TOURNAMENT_DRAFT',
|
||||
map_name: 'SUMMONERS_RIFT',
|
||||
platform_id: 'KR',
|
||||
} as const;
|
||||
|
||||
const BROWSER_LIKE_HEADERS = {
|
||||
accept: '*/*',
|
||||
'accept-encoding': 'gzip, deflate, br, zstd',
|
||||
'accept-language': 'ko,en;q=0.9,en-US;q=0.8',
|
||||
'cache-control': 'no-cache',
|
||||
host: 'b2c-api.deeplol.gg',
|
||||
origin: 'https://clash.deeplol.gg',
|
||||
pragma: 'no-cache',
|
||||
priority: 'u=1, i',
|
||||
referer: 'https://clash.deeplol.gg/',
|
||||
'sec-ch-ua':
|
||||
'"Microsoft Edge";v="149", "Chromium";v="149", "Not)A;Brand";v="24"',
|
||||
'sec-ch-ua-mobile': '?0',
|
||||
'sec-ch-ua-platform': '"Windows"',
|
||||
'sec-fetch-dest': 'empty',
|
||||
'sec-fetch-mode': 'cors',
|
||||
'sec-fetch-site': 'same-site',
|
||||
'user-agent':
|
||||
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36 Edg/149.0.0.0',
|
||||
} as const;
|
||||
|
||||
interface DeeplolTournamentCodeResponse {
|
||||
tournament_code_list?: unknown;
|
||||
}
|
||||
|
||||
export interface DeeplolTournamentCodeRequest {
|
||||
url: URL;
|
||||
headers: Record<string, string>;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class TournamentCodeVendorService {
|
||||
public async fetchTournamentCode(): Promise<string> {
|
||||
const request = buildDeeplolTournamentCodeRequest();
|
||||
const controller = new AbortController();
|
||||
const timeout = setTimeout(() => {
|
||||
controller.abort();
|
||||
}, resolveFetchTimeoutMs());
|
||||
|
||||
try {
|
||||
const response = await fetch(request.url.toString(), {
|
||||
method: 'GET',
|
||||
headers: request.headers,
|
||||
signal: controller.signal,
|
||||
});
|
||||
|
||||
if (!response.ok) {
|
||||
throw new Error(
|
||||
`Vendor tournament code request failed (${response.status}).`,
|
||||
);
|
||||
}
|
||||
|
||||
const payload = (await response.json()) as DeeplolTournamentCodeResponse;
|
||||
return parseVendorTournamentCode(payload);
|
||||
} finally {
|
||||
clearTimeout(timeout);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export function buildDeeplolTournamentCodeRequest(
|
||||
env: NodeJS.ProcessEnv = process.env,
|
||||
): DeeplolTournamentCodeRequest {
|
||||
const url = new URL(
|
||||
env.TOURNAMENT_CODE_VENDOR_URL?.trim() || DEFAULT_VENDOR_URL,
|
||||
);
|
||||
const params = {
|
||||
server_id:
|
||||
env.TOURNAMENT_CODE_VENDOR_SERVER_ID ?? DEFAULT_QUERY_PARAMS.server_id,
|
||||
server_name:
|
||||
env.TOURNAMENT_CODE_VENDOR_SERVER_NAME ??
|
||||
DEFAULT_QUERY_PARAMS.server_name,
|
||||
server_comment:
|
||||
env.TOURNAMENT_CODE_VENDOR_SERVER_COMMENT ??
|
||||
DEFAULT_QUERY_PARAMS.server_comment,
|
||||
spectator_type:
|
||||
env.TOURNAMENT_CODE_VENDOR_SPECTATOR_TYPE ??
|
||||
DEFAULT_QUERY_PARAMS.spectator_type,
|
||||
pick_type:
|
||||
env.TOURNAMENT_CODE_VENDOR_PICK_TYPE ?? DEFAULT_QUERY_PARAMS.pick_type,
|
||||
map_name:
|
||||
env.TOURNAMENT_CODE_VENDOR_MAP_NAME ?? DEFAULT_QUERY_PARAMS.map_name,
|
||||
platform_id:
|
||||
env.TOURNAMENT_CODE_VENDOR_PLATFORM_ID ??
|
||||
DEFAULT_QUERY_PARAMS.platform_id,
|
||||
};
|
||||
|
||||
for (const [key, value] of Object.entries(params)) {
|
||||
url.searchParams.set(key, value);
|
||||
}
|
||||
|
||||
return {
|
||||
url,
|
||||
headers: {
|
||||
...BROWSER_LIKE_HEADERS,
|
||||
host: url.host,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
export function resolveVendorRequestDelayMs(
|
||||
random: () => number = Math.random,
|
||||
): number {
|
||||
const roll = clampRandom(random());
|
||||
if (roll < 0.85) {
|
||||
return MIN_REQUEST_DELAY_MS + Math.round(roll * 500);
|
||||
}
|
||||
return MIN_REQUEST_DELAY_MS + 100 + Math.round(roll * 4_000);
|
||||
}
|
||||
|
||||
function parseVendorTournamentCode(
|
||||
payload: DeeplolTournamentCodeResponse,
|
||||
): string {
|
||||
const codes = payload.tournament_code_list;
|
||||
if (
|
||||
!Array.isArray(codes) ||
|
||||
typeof codes[0] !== 'string' ||
|
||||
!codes[0].trim()
|
||||
) {
|
||||
throw new Error('Vendor tournament code response is malformed.');
|
||||
}
|
||||
return codes[0].trim();
|
||||
}
|
||||
|
||||
function resolveFetchTimeoutMs(): number {
|
||||
const configured = Number(process.env.TOURNAMENT_CODE_VENDOR_TIMEOUT_MS);
|
||||
return Number.isFinite(configured) && configured > 0
|
||||
? configured
|
||||
: DEFAULT_FETCH_TIMEOUT_MS;
|
||||
}
|
||||
|
||||
function clampRandom(value: number): number {
|
||||
if (!Number.isFinite(value)) return 0;
|
||||
return Math.min(1, Math.max(0, value));
|
||||
}
|
||||
@@ -1,12 +1,21 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { TournamentResultModule } from '../tournament-result/tournament-result.module';
|
||||
import { TournamentCodeController } from './tournament-code.controller';
|
||||
import { TournamentCodeAutoProvisionService } from './tournament-code-auto-provision.service';
|
||||
import { TournamentCodeReplacementController } from './tournament-code-replacement.controller';
|
||||
import { TournamentCodeScheduler } from './tournament-code.scheduler';
|
||||
import { TournamentCodeService } from './tournament-code.service';
|
||||
import { TournamentCodeVendorService } from './tournament-code-vendor.service';
|
||||
|
||||
@Module({
|
||||
imports: [TournamentResultModule],
|
||||
controllers: [TournamentCodeController, TournamentCodeReplacementController],
|
||||
providers: [TournamentCodeService, TournamentCodeScheduler],
|
||||
providers: [
|
||||
TournamentCodeService,
|
||||
TournamentCodeVendorService,
|
||||
TournamentCodeAutoProvisionService,
|
||||
TournamentCodeScheduler,
|
||||
],
|
||||
exports: [TournamentCodeService],
|
||||
})
|
||||
export class TournamentCodeModule {}
|
||||
@@ -0,0 +1,62 @@
|
||||
import { TournamentCodeScheduler } from './tournament-code.scheduler';
|
||||
|
||||
describe('TournamentCodeScheduler', () => {
|
||||
function createScheduler(params?: {
|
||||
attachedMatches?: unknown[];
|
||||
scheduleInitialPoll?: jest.Mock;
|
||||
}) {
|
||||
const tournamentCodeService = {
|
||||
attachPendingMatchDocuments: jest
|
||||
.fn()
|
||||
.mockResolvedValue(params?.attachedMatches ?? []),
|
||||
markExpired: jest.fn().mockResolvedValue(0),
|
||||
};
|
||||
const autoProvisionService = {
|
||||
ensurePool: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const tournamentResultService = {
|
||||
scheduleInitialPoll:
|
||||
params?.scheduleInitialPoll ?? jest.fn().mockResolvedValue(null),
|
||||
};
|
||||
const scheduler = new TournamentCodeScheduler(
|
||||
tournamentCodeService as never,
|
||||
autoProvisionService as never,
|
||||
tournamentResultService as never,
|
||||
) as unknown as { attachPending(): Promise<void> };
|
||||
|
||||
return {
|
||||
scheduler,
|
||||
tournamentCodeService,
|
||||
tournamentResultService,
|
||||
};
|
||||
}
|
||||
|
||||
it('starts result polling after attaching delayed tournament codes', async () => {
|
||||
const attachedMatches = [{ _id: 'match-1' }, { _id: 'match-2' }];
|
||||
const { scheduler, tournamentResultService } = createScheduler({
|
||||
attachedMatches,
|
||||
});
|
||||
|
||||
await scheduler.attachPending();
|
||||
|
||||
expect(tournamentResultService.scheduleInitialPoll).toHaveBeenCalledTimes(
|
||||
2,
|
||||
);
|
||||
expect(tournamentResultService.scheduleInitialPoll).toHaveBeenNthCalledWith(
|
||||
1,
|
||||
attachedMatches[0],
|
||||
);
|
||||
expect(tournamentResultService.scheduleInitialPoll).toHaveBeenNthCalledWith(
|
||||
2,
|
||||
attachedMatches[1],
|
||||
);
|
||||
});
|
||||
|
||||
it('does not schedule result polling when no match received new codes', async () => {
|
||||
const { scheduler, tournamentResultService } = createScheduler();
|
||||
|
||||
await scheduler.attachPending();
|
||||
|
||||
expect(tournamentResultService.scheduleInitialPoll).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
@@ -1,4 +1,6 @@
|
||||
import { Injectable, Logger, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
|
||||
import { TournamentResultService } from '../tournament-result/tournament-result.service';
|
||||
import { TournamentCodeAutoProvisionService } from './tournament-code-auto-provision.service';
|
||||
import { TournamentCodeService } from './tournament-code.service';
|
||||
|
||||
@Injectable()
|
||||
@@ -6,8 +8,13 @@ export class TournamentCodeScheduler implements OnModuleInit, OnModuleDestroy {
|
||||
private readonly logger = new Logger(TournamentCodeScheduler.name);
|
||||
private attachTimer?: NodeJS.Timeout;
|
||||
private expireTimer?: NodeJS.Timeout;
|
||||
private refillTimer?: NodeJS.Timeout;
|
||||
|
||||
constructor(private readonly tournamentCodeService: TournamentCodeService) {}
|
||||
constructor(
|
||||
private readonly tournamentCodeService: TournamentCodeService,
|
||||
private readonly autoProvisionService: TournamentCodeAutoProvisionService,
|
||||
private readonly tournamentResultService: TournamentResultService,
|
||||
) {}
|
||||
|
||||
public onModuleInit() {
|
||||
this.attachTimer = setInterval(() => {
|
||||
@@ -16,23 +23,39 @@ export class TournamentCodeScheduler implements OnModuleInit, OnModuleDestroy {
|
||||
this.expireTimer = setInterval(() => {
|
||||
void this.markExpired();
|
||||
}, 60 * 60 * 1000);
|
||||
if (isAutoProvisionEnabled()) {
|
||||
this.refillTimer = setInterval(() => {
|
||||
void this.ensureVendorPool();
|
||||
}, 5 * 60 * 1000);
|
||||
}
|
||||
this.attachTimer.unref?.();
|
||||
this.expireTimer.unref?.();
|
||||
this.refillTimer?.unref?.();
|
||||
|
||||
void this.attachPending();
|
||||
void this.markExpired();
|
||||
if (isAutoProvisionEnabled()) {
|
||||
void this.ensureVendorPool();
|
||||
}
|
||||
}
|
||||
|
||||
public onModuleDestroy() {
|
||||
if (this.attachTimer) clearInterval(this.attachTimer);
|
||||
if (this.expireTimer) clearInterval(this.expireTimer);
|
||||
if (this.refillTimer) clearInterval(this.refillTimer);
|
||||
}
|
||||
|
||||
private async attachPending() {
|
||||
try {
|
||||
const touched = await this.tournamentCodeService.attachPendingMatches();
|
||||
if (touched > 0) {
|
||||
this.logger.debug(`Attached tournament codes for ${touched} matches.`);
|
||||
const matches =
|
||||
await this.tournamentCodeService.attachPendingMatchDocuments();
|
||||
if (matches.length > 0) {
|
||||
this.logger.debug(
|
||||
`Attached tournament codes for ${matches.length} matches.`,
|
||||
);
|
||||
for (const match of matches) {
|
||||
await this.tournamentResultService.scheduleInitialPoll(match);
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
this.logger.warn(
|
||||
@@ -54,4 +77,23 @@ export class TournamentCodeScheduler implements OnModuleInit, OnModuleDestroy {
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
private async ensureVendorPool() {
|
||||
try {
|
||||
await this.autoProvisionService.ensurePool();
|
||||
} catch (error) {
|
||||
this.logger.warn(
|
||||
`Failed to auto-provision tournament codes: ${
|
||||
error instanceof Error ? error.message : error
|
||||
}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function isAutoProvisionEnabled(): boolean {
|
||||
const raw = process.env.TOURNAMENT_CODE_AUTO_PROVISION_ENABLED
|
||||
?.trim()
|
||||
.toLowerCase();
|
||||
return raw !== 'false' && raw !== '0' && raw !== 'off';
|
||||
}
|
||||
@@ -1,4 +1,7 @@
|
||||
import type { MatchDocument } from '../global/database/schema';
|
||||
import {
|
||||
TournamentCodeSchema,
|
||||
type MatchDocument,
|
||||
} from '../global/database/schema';
|
||||
import mongoose from 'mongoose';
|
||||
import { TournamentCodeService } from './tournament-code.service';
|
||||
|
||||
@@ -14,6 +17,7 @@ type TournamentCodeServiceInternals = TournamentCodeService & {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
gameNumber: number;
|
||||
}): Promise<unknown>;
|
||||
attachPendingMatches(communityId?: mongoose.Types.ObjectId): Promise<number>;
|
||||
};
|
||||
|
||||
function createService() {
|
||||
@@ -222,8 +226,10 @@ describe('TournamentCodeService round-robin scheduling', () => {
|
||||
(game) => game.roundNumber === roundNumber,
|
||||
);
|
||||
expect(round).toHaveLength(4);
|
||||
expect(new Set(round.flatMap((game) => [game.teamAIndex, game.teamBIndex])).size)
|
||||
.toBe(8);
|
||||
expect(
|
||||
new Set(round.flatMap((game) => [game.teamAIndex, game.teamBIndex]))
|
||||
.size,
|
||||
).toBe(8);
|
||||
}
|
||||
});
|
||||
|
||||
@@ -318,6 +324,152 @@ describe('TournamentCodeService round-robin scheduling', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe('TournamentCodeService bulk upload', () => {
|
||||
it('preserves tournament code casing at the schema layer', async () => {
|
||||
const connection = mongoose.createConnection();
|
||||
try {
|
||||
const TournamentCodeModel = connection.model(
|
||||
'TournamentCodeCasingSpec',
|
||||
TournamentCodeSchema,
|
||||
);
|
||||
|
||||
const code = new TournamentCodeModel({
|
||||
code: ' AbC-12345 ',
|
||||
expiresAt: new Date(Date.now() + 60 * 60 * 1000),
|
||||
uploadedBy: new mongoose.Types.ObjectId(),
|
||||
});
|
||||
|
||||
expect(code.code).toBe('AbC-12345');
|
||||
} finally {
|
||||
await connection.close();
|
||||
}
|
||||
});
|
||||
|
||||
it('stores tournament codes with the exact casing from input', async () => {
|
||||
const insertMany = jest.fn().mockResolvedValue(undefined);
|
||||
const TournamentCodeModel = {
|
||||
find: jest.fn().mockReturnValue({
|
||||
select: jest.fn().mockReturnValue({
|
||||
lean: jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue([]),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
insertMany,
|
||||
};
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockResolvedValue(TournamentCodeModel),
|
||||
};
|
||||
const service = new TournamentCodeService(
|
||||
connectionService as never,
|
||||
) as unknown as TournamentCodeServiceInternals;
|
||||
service.attachPendingMatches = jest.fn().mockResolvedValue(0);
|
||||
|
||||
await service.bulkUpload({
|
||||
communityId: new mongoose.Types.ObjectId(),
|
||||
uploadedBy: new mongoose.Types.ObjectId(),
|
||||
codes: [
|
||||
{
|
||||
code: ' AbC-12345 ',
|
||||
expiresAt: new Date(Date.now() + 60 * 60 * 1000).toISOString(),
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
expect(insertMany).toHaveBeenCalledWith(
|
||||
[
|
||||
expect.objectContaining({
|
||||
code: 'AbC-12345',
|
||||
}),
|
||||
],
|
||||
{ ordered: false },
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('TournamentCodeService pool stats', () => {
|
||||
it('counts only available codes that are usable beyond the expiry margin', async () => {
|
||||
const countDocuments = jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue(12),
|
||||
});
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockResolvedValue({ countDocuments }),
|
||||
};
|
||||
const service = new TournamentCodeService(connectionService as never);
|
||||
|
||||
await expect(service.countUsableAvailable()).resolves.toBe(12);
|
||||
expect(countDocuments).toHaveBeenCalledWith({
|
||||
state: 'available',
|
||||
expiresAt: {
|
||||
$gt: expect.any(Date),
|
||||
},
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('TournamentCodeService pending match attachment', () => {
|
||||
it('does not attach tournament codes before match teams are built', async () => {
|
||||
const invalidMatch = {
|
||||
...createMatch({
|
||||
status: 'team-built',
|
||||
teams: [],
|
||||
tournamentCodeIds: [],
|
||||
} as unknown as MatchOverrides),
|
||||
isModified: jest.fn().mockReturnValue(false),
|
||||
};
|
||||
const validMatch = {
|
||||
...createMatch({
|
||||
status: 'team-built',
|
||||
teams: [
|
||||
{
|
||||
teamIndex: 1,
|
||||
members: [{ userId: new mongoose.Types.ObjectId() }],
|
||||
},
|
||||
{
|
||||
teamIndex: 2,
|
||||
members: [{ userId: new mongoose.Types.ObjectId() }],
|
||||
},
|
||||
],
|
||||
tournamentCodeIds: [],
|
||||
} as unknown as MatchOverrides),
|
||||
isModified: jest.fn().mockReturnValue(false),
|
||||
};
|
||||
const codeId = new mongoose.Types.ObjectId();
|
||||
const MatchModel = {
|
||||
find: jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue([invalidMatch, validMatch]),
|
||||
}),
|
||||
findById: jest.fn().mockResolvedValue(validMatch),
|
||||
};
|
||||
const TournamentCodeModel = {
|
||||
findOneAndUpdate: jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue({ _id: codeId }),
|
||||
}),
|
||||
};
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockImplementation((modelName: string) => {
|
||||
if (modelName === 'match') return Promise.resolve(MatchModel);
|
||||
if (modelName === 'tournamentCode') {
|
||||
return Promise.resolve(TournamentCodeModel);
|
||||
}
|
||||
throw new Error(`Unexpected model: ${modelName}`);
|
||||
}),
|
||||
};
|
||||
const service = new TournamentCodeService(connectionService as never);
|
||||
|
||||
const matches = await service.attachPendingMatchDocuments();
|
||||
|
||||
expect(matches).toEqual([validMatch]);
|
||||
expect(MatchModel.findById).toHaveBeenCalledTimes(1);
|
||||
expect(MatchModel.findById).toHaveBeenCalledWith(validMatch._id);
|
||||
expect(TournamentCodeModel.findOneAndUpdate).toHaveBeenCalledTimes(1);
|
||||
expect(validMatch.tournamentCodeIds.map((id) => id.toString())).toEqual([
|
||||
codeId.toString(),
|
||||
]);
|
||||
expect(invalidMatch.tournamentCodeIds).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe('TournamentCodeService code replacement', () => {
|
||||
function queryResult<T>(value: T) {
|
||||
return { exec: jest.fn().mockResolvedValue(value) };
|
||||
|
||||
@@ -37,7 +37,7 @@ export class TournamentCodeService {
|
||||
constructor(private readonly connectionService: ConnectionService) {}
|
||||
|
||||
public async bulkUpload(params: {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
communityId?: mongoose.Types.ObjectId;
|
||||
uploadedBy: mongoose.Types.ObjectId;
|
||||
codes: TournamentCodeUploadItem[];
|
||||
}): Promise<BulkUploadTournamentCodesResponse> {
|
||||
@@ -121,6 +121,17 @@ export class TournamentCodeService {
|
||||
};
|
||||
}
|
||||
|
||||
public async countUsableAvailable(): Promise<number> {
|
||||
const TournamentCodeModel =
|
||||
await this.connectionService.getModel('tournamentCode');
|
||||
return TournamentCodeModel.countDocuments({
|
||||
state: 'available',
|
||||
expiresAt: {
|
||||
$gt: new Date(Date.now() + TOURNAMENT_CODE_EXPIRY_MARGIN_MS),
|
||||
},
|
||||
}).exec();
|
||||
}
|
||||
|
||||
public async list(params: {
|
||||
state?: TournamentCodeState;
|
||||
limit?: number;
|
||||
@@ -153,10 +164,9 @@ export class TournamentCodeService {
|
||||
_id: TournamentCodeState;
|
||||
count: number;
|
||||
}>([{ $group: { _id: '$state', count: { $sum: 1 } } }]).exec();
|
||||
const byState = Object.fromEntries(states.map((state) => [state, 0])) as Record<
|
||||
TournamentCodeState,
|
||||
number
|
||||
>;
|
||||
const byState = Object.fromEntries(
|
||||
states.map((state) => [state, 0]),
|
||||
) as Record<TournamentCodeState, number>;
|
||||
for (const entry of counts) byState[entry._id] = entry.count;
|
||||
|
||||
const expiringSoon = await TournamentCodeModel.countDocuments({
|
||||
@@ -178,7 +188,9 @@ export class TournamentCodeService {
|
||||
state: 'available',
|
||||
}).exec();
|
||||
if (result.deletedCount === 0) {
|
||||
throw new BadRequestException('Only available tournament codes can be deleted.');
|
||||
throw new BadRequestException(
|
||||
'Only available tournament codes can be deleted.',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -238,7 +250,9 @@ export class TournamentCodeService {
|
||||
|
||||
const reservedIds: mongoose.Types.ObjectId[] = [];
|
||||
const startGameNumber = match.tournamentCodeIds.length + 1;
|
||||
const expiresAfter = new Date(Date.now() + TOURNAMENT_CODE_EXPIRY_MARGIN_MS);
|
||||
const expiresAfter = new Date(
|
||||
Date.now() + TOURNAMENT_CODE_EXPIRY_MARGIN_MS,
|
||||
);
|
||||
|
||||
for (let index = 0; index < need; index += 1) {
|
||||
const code = await TournamentCodeModel.findOneAndUpdate(
|
||||
@@ -323,10 +337,14 @@ export class TournamentCodeService {
|
||||
throw new NotFoundException('Assigned tournament code not found.');
|
||||
}
|
||||
if (currentCode.state === 'used' || currentCode.riotMatchId) {
|
||||
throw new BadRequestException('Used tournament codes cannot be replaced.');
|
||||
throw new BadRequestException(
|
||||
'Used tournament codes cannot be replaced.',
|
||||
);
|
||||
}
|
||||
|
||||
const expiresAfter = new Date(Date.now() + TOURNAMENT_CODE_EXPIRY_MARGIN_MS);
|
||||
const expiresAfter = new Date(
|
||||
Date.now() + TOURNAMENT_CODE_EXPIRY_MARGIN_MS,
|
||||
);
|
||||
const replacement = await TournamentCodeModel.findOneAndUpdate(
|
||||
{
|
||||
state: 'available',
|
||||
@@ -347,7 +365,9 @@ export class TournamentCodeService {
|
||||
{ sort: { expiresAt: 1 }, returnDocument: 'after' },
|
||||
).exec();
|
||||
if (!replacement) {
|
||||
throw new BadRequestException('No available tournament code to replace with.');
|
||||
throw new BadRequestException(
|
||||
'No available tournament code to replace with.',
|
||||
);
|
||||
}
|
||||
|
||||
currentCode.state = 'released';
|
||||
@@ -419,6 +439,13 @@ export class TournamentCodeService {
|
||||
public async attachPendingMatches(
|
||||
communityId?: mongoose.Types.ObjectId,
|
||||
): Promise<number> {
|
||||
const matches = await this.attachPendingMatchDocuments(communityId);
|
||||
return matches.length;
|
||||
}
|
||||
|
||||
public async attachPendingMatchDocuments(
|
||||
communityId?: mongoose.Types.ObjectId,
|
||||
): Promise<MatchDocument[]> {
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const filter: {
|
||||
status: { $in: string[] };
|
||||
@@ -429,20 +456,33 @@ export class TournamentCodeService {
|
||||
if (communityId) filter.communityId = communityId;
|
||||
|
||||
const matches = await MatchModel.find(filter).exec();
|
||||
let touched = 0;
|
||||
const touched: MatchDocument[] = [];
|
||||
for (const match of matches) {
|
||||
if ((match.tournamentCodeIds?.length ?? 0) >= this.resolveRequiredSlots(match)) {
|
||||
if (!this.hasBuiltTeams(match)) continue;
|
||||
if (
|
||||
(match.tournamentCodeIds?.length ?? 0) >=
|
||||
this.resolveRequiredSlots(match)
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
const before = match.tournamentCodeIds?.length ?? 0;
|
||||
await this.reserveForMatch(match);
|
||||
const after = match.tournamentCodeIds?.length ?? 0;
|
||||
if (after > before) touched += 1;
|
||||
const updatedMatch = await this.reserveForMatch(match);
|
||||
const after = updatedMatch.tournamentCodeIds?.length ?? 0;
|
||||
if (after > before) touched.push(updatedMatch);
|
||||
}
|
||||
return touched;
|
||||
}
|
||||
|
||||
public async buildSlots(match: MatchDocument): Promise<TournamentCodeSlotView[]> {
|
||||
private hasBuiltTeams(match: MatchDocument): boolean {
|
||||
return Boolean(
|
||||
match.teams.length >= 2 &&
|
||||
match.teams.every((team) => team.members.length > 0),
|
||||
);
|
||||
}
|
||||
|
||||
public async buildSlots(
|
||||
match: MatchDocument,
|
||||
): Promise<TournamentCodeSlotView[]> {
|
||||
if (
|
||||
(match.gameMode ?? 'pair') === 'round-robin' &&
|
||||
(match.gameSchedule?.length ?? 0) === 0 &&
|
||||
@@ -492,7 +532,7 @@ export class TournamentCodeService {
|
||||
}
|
||||
|
||||
private normalizeCode(code: string | undefined): string {
|
||||
return (code ?? '').trim().toUpperCase();
|
||||
return (code ?? '').trim();
|
||||
}
|
||||
|
||||
private replaceTournamentCodeId(
|
||||
|
||||
@@ -1,7 +1,11 @@
|
||||
import mongoose from 'mongoose';
|
||||
import type { MatchDocument } from '../global/database/schema';
|
||||
import type { RiotMatchDto } from '../riot/riot.types';
|
||||
import { computeGameResult, type MatchPuuidLookup } from './team-mapping.util';
|
||||
import {
|
||||
collectCaptainAndLimitedTeamMemberUserIds,
|
||||
computeGameResult,
|
||||
type MatchPuuidLookup,
|
||||
} from './team-mapping.util';
|
||||
|
||||
function makeMatch(): {
|
||||
match: MatchDocument;
|
||||
@@ -9,8 +13,14 @@ function makeMatch(): {
|
||||
blueUserIds: mongoose.Types.ObjectId[];
|
||||
redUserIds: mongoose.Types.ObjectId[];
|
||||
} {
|
||||
const blueUserIds = Array.from({ length: 5 }, () => new mongoose.Types.ObjectId());
|
||||
const redUserIds = Array.from({ length: 5 }, () => new mongoose.Types.ObjectId());
|
||||
const blueUserIds = Array.from(
|
||||
{ length: 5 },
|
||||
() => new mongoose.Types.ObjectId(),
|
||||
);
|
||||
const redUserIds = Array.from(
|
||||
{ length: 5 },
|
||||
() => new mongoose.Types.ObjectId(),
|
||||
);
|
||||
const puuidByUserId = new Map<string, string>();
|
||||
const userIdByPuuid = new Map<string, mongoose.Types.ObjectId>();
|
||||
|
||||
@@ -47,7 +57,12 @@ function makeMatch(): {
|
||||
})),
|
||||
} as unknown as MatchDocument;
|
||||
|
||||
return { match, lookup: { puuidByUserId, userIdByPuuid }, blueUserIds, redUserIds };
|
||||
return {
|
||||
match,
|
||||
lookup: { puuidByUserId, userIdByPuuid },
|
||||
blueUserIds,
|
||||
redUserIds,
|
||||
};
|
||||
}
|
||||
|
||||
function makeRiotMatch(params: {
|
||||
@@ -154,3 +169,24 @@ describe('computeGameResult', () => {
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('collectCaptainAndLimitedTeamMemberUserIds', () => {
|
||||
it('keeps captains and caps extra members per team', () => {
|
||||
const { blueUserIds, match, redUserIds } = makeMatch();
|
||||
match.teams[0].captainUserId = blueUserIds[0];
|
||||
match.teams[1].captainUserId = redUserIds[0];
|
||||
|
||||
const userIds = collectCaptainAndLimitedTeamMemberUserIds(match, 2).map(
|
||||
(userId) => userId.toString(),
|
||||
);
|
||||
|
||||
expect(userIds).toEqual([
|
||||
blueUserIds[0].toString(),
|
||||
blueUserIds[1].toString(),
|
||||
blueUserIds[2].toString(),
|
||||
redUserIds[0].toString(),
|
||||
redUserIds[1].toString(),
|
||||
redUserIds[2].toString(),
|
||||
]);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +1,9 @@
|
||||
import mongoose from 'mongoose';
|
||||
import type { MatchDocument, MatchGameResult, TeamSide } from '../global/database/schema';
|
||||
import type {
|
||||
MatchDocument,
|
||||
MatchGameResult,
|
||||
TeamSide,
|
||||
} from '../global/database/schema';
|
||||
import type { RiotMatchDto } from '../riot/riot.types';
|
||||
|
||||
const RIOT_BLUE_TEAM_ID = 100;
|
||||
@@ -11,19 +15,46 @@ export interface MatchPuuidLookup {
|
||||
userIdByPuuid: Map<string, mongoose.Types.ObjectId>;
|
||||
}
|
||||
|
||||
export function collectCaptainUserIds(match: MatchDocument): mongoose.Types.ObjectId[] {
|
||||
export function collectCaptainUserIds(
|
||||
match: MatchDocument,
|
||||
): mongoose.Types.ObjectId[] {
|
||||
return match.teams
|
||||
.map((team) => team.captainUserId)
|
||||
.filter((userId): userId is mongoose.Types.ObjectId => Boolean(userId));
|
||||
}
|
||||
|
||||
export function collectMatchUserIds(match: MatchDocument): mongoose.Types.ObjectId[] {
|
||||
export function collectCaptainAndLimitedTeamMemberUserIds(
|
||||
match: MatchDocument,
|
||||
memberLimitPerTeam: number,
|
||||
): mongoose.Types.ObjectId[] {
|
||||
const ids = new Map<string, mongoose.Types.ObjectId>();
|
||||
for (const team of match.teams) {
|
||||
if (team.captainUserId) {
|
||||
ids.set(team.captainUserId.toString(), team.captainUserId);
|
||||
}
|
||||
let memberCount = 0;
|
||||
for (const member of team.members) {
|
||||
if (team.captainUserId?.toString() === member.userId.toString()) {
|
||||
continue;
|
||||
}
|
||||
if (memberCount >= memberLimitPerTeam) break;
|
||||
ids.set(member.userId.toString(), member.userId);
|
||||
memberCount += 1;
|
||||
}
|
||||
}
|
||||
return [...ids.values()];
|
||||
}
|
||||
|
||||
export function collectMatchUserIds(
|
||||
match: MatchDocument,
|
||||
): mongoose.Types.ObjectId[] {
|
||||
const ids = new Map<string, mongoose.Types.ObjectId>();
|
||||
for (const participant of match.participants) {
|
||||
ids.set(participant.userId.toString(), participant.userId);
|
||||
}
|
||||
for (const team of match.teams) {
|
||||
if (team.captainUserId) ids.set(team.captainUserId.toString(), team.captainUserId);
|
||||
if (team.captainUserId)
|
||||
ids.set(team.captainUserId.toString(), team.captainUserId);
|
||||
for (const member of team.members) {
|
||||
ids.set(member.userId.toString(), member.userId);
|
||||
}
|
||||
@@ -78,8 +109,10 @@ export function computeGameResult(params: {
|
||||
const reversedOverlap =
|
||||
countOverlap(team100Puuids, teamBPuuids) +
|
||||
countOverlap(team200Puuids, teamAPuuids);
|
||||
const blueTeamIndex = normalOverlap >= reversedOverlap ? teamAIndex : teamBIndex;
|
||||
const redTeamIndex = normalOverlap >= reversedOverlap ? teamBIndex : teamAIndex;
|
||||
const blueTeamIndex =
|
||||
normalOverlap >= reversedOverlap ? teamAIndex : teamBIndex;
|
||||
const redTeamIndex =
|
||||
normalOverlap >= reversedOverlap ? teamBIndex : teamAIndex;
|
||||
const teamIndexByRiotTeamId: Record<number, number> = {
|
||||
[RIOT_BLUE_TEAM_ID]: blueTeamIndex,
|
||||
[RIOT_RED_TEAM_ID]: redTeamIndex,
|
||||
|
||||
@@ -4,6 +4,7 @@ import type { RiotMatchDto } from '../riot/riot.types';
|
||||
import { TournamentResultService } from './tournament-result.service';
|
||||
|
||||
type TournamentResultServiceInternals = TournamentResultService & {
|
||||
nextPollDelayMs(elapsedMs: number): number | null;
|
||||
resolveRequiredGameSlots(match: MatchDocument): number;
|
||||
resolveSeriesRefForGameNumber(
|
||||
match: MatchDocument,
|
||||
@@ -101,6 +102,206 @@ describe('TournamentResultService round-robin scheduling', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe('TournamentResultService tournament code polling', () => {
|
||||
function queryResult<T>(value: T) {
|
||||
return { exec: jest.fn().mockResolvedValue(value) };
|
||||
}
|
||||
|
||||
function sortedQueryResult<T>(value: T) {
|
||||
return {
|
||||
sort: jest.fn().mockReturnValue(queryResult(value)),
|
||||
};
|
||||
}
|
||||
|
||||
function createPollFixture(params: {
|
||||
storedCode: string;
|
||||
riotTournamentCode: string;
|
||||
}) {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const codeId = new mongoose.Types.ObjectId();
|
||||
const users = Array.from({ length: 10 }, (_, index) => ({
|
||||
userId: new mongoose.Types.ObjectId(),
|
||||
puuid: `poll-puuid-${index + 1}`,
|
||||
}));
|
||||
const match = {
|
||||
_id: matchId,
|
||||
communityId,
|
||||
status: 'team-built',
|
||||
teamBuiltAt: new Date('2026-05-03T10:00:00.000Z'),
|
||||
gameCount: 1,
|
||||
gameMode: 'pair',
|
||||
tournamentCodeIds: [codeId],
|
||||
gameSchedule: [],
|
||||
resultPollState: {
|
||||
startedAt: new Date(),
|
||||
matchedCount: 0,
|
||||
expandedToAllPuuids: true,
|
||||
state: 'polling',
|
||||
},
|
||||
participants: users.map((user) => ({
|
||||
userId: user.userId,
|
||||
puuid: user.puuid,
|
||||
excluded: false,
|
||||
})),
|
||||
teams: [
|
||||
{
|
||||
teamIndex: 1,
|
||||
members: users.slice(0, 5).map((user) => ({ userId: user.userId })),
|
||||
},
|
||||
{
|
||||
teamIndex: 2,
|
||||
members: users.slice(5).map((user) => ({ userId: user.userId })),
|
||||
},
|
||||
],
|
||||
save: jest.fn().mockResolvedValue(undefined),
|
||||
} as unknown as MatchDocument & {
|
||||
save: jest.Mock;
|
||||
result?: MatchDocument['result'];
|
||||
};
|
||||
const code = {
|
||||
_id: codeId,
|
||||
code: params.storedCode,
|
||||
state: 'reserved',
|
||||
gameNumber: 1,
|
||||
riotMatchId: undefined,
|
||||
save: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const detail = {
|
||||
metadata: {
|
||||
matchId: 'KR_9876543210',
|
||||
participants: users.map((user) => user.puuid),
|
||||
},
|
||||
info: {
|
||||
tournamentCode: params.riotTournamentCode,
|
||||
gameCreation: Date.parse('2026-05-03T10:30:00.000Z'),
|
||||
gameEndTimestamp: Date.parse('2026-05-03T11:00:00.000Z'),
|
||||
gameDuration: 1800,
|
||||
participants: users.map((user, index) => ({
|
||||
puuid: user.puuid,
|
||||
teamId: index < 5 ? 100 : 200,
|
||||
championId: 1,
|
||||
kills: 1,
|
||||
deaths: 1,
|
||||
assists: 1,
|
||||
win: index < 5,
|
||||
})),
|
||||
teams: [
|
||||
{ teamId: 100, win: true },
|
||||
{ teamId: 200, win: false },
|
||||
],
|
||||
},
|
||||
} as unknown as RiotMatchDto;
|
||||
const TournamentCodeModel = {
|
||||
find: jest
|
||||
.fn()
|
||||
.mockReturnValueOnce(sortedQueryResult([code]))
|
||||
.mockReturnValueOnce(sortedQueryResult([code])),
|
||||
exists: jest.fn().mockResolvedValue(null),
|
||||
};
|
||||
const RiotMatchModel = {
|
||||
findOne: jest.fn().mockReturnValue(queryResult(null)),
|
||||
updateOne: jest.fn().mockReturnValue(queryResult(undefined)),
|
||||
};
|
||||
const CommunityModel = {
|
||||
findById: jest.fn().mockReturnValue({
|
||||
select: jest.fn().mockReturnValue({
|
||||
lean: jest.fn().mockReturnValue(queryResult({ riotRegion: 'asia' })),
|
||||
}),
|
||||
}),
|
||||
};
|
||||
const connectionService = {
|
||||
getModel: jest.fn().mockImplementation(async (name: string) => {
|
||||
if (name === 'match') {
|
||||
return { findById: jest.fn().mockResolvedValue(match) };
|
||||
}
|
||||
if (name === 'tournamentCode') return TournamentCodeModel;
|
||||
if (name === 'community') return CommunityModel;
|
||||
if (name === 'riotMatch') return RiotMatchModel;
|
||||
throw new Error(`Unexpected model: ${name}`);
|
||||
}),
|
||||
};
|
||||
const riotMatchService = {
|
||||
getMatchIdsByPuuid: jest.fn().mockResolvedValue(['KR_9876543210']),
|
||||
getMatch: jest.fn().mockResolvedValue(detail),
|
||||
};
|
||||
const riotJobQueueService = {
|
||||
enqueueTournamentResultPoll: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const service = new TournamentResultService(
|
||||
connectionService as never,
|
||||
riotMatchService as never,
|
||||
riotJobQueueService as never,
|
||||
{ invalidateCommunity: jest.fn().mockResolvedValue(undefined) } as never,
|
||||
{ buildAndUpsert: jest.fn().mockResolvedValue(undefined) } as never,
|
||||
);
|
||||
|
||||
return { service, match, code, riotMatchService };
|
||||
}
|
||||
|
||||
it('matches Riot tournament codes using exact casing', async () => {
|
||||
const { service, match, code } = createPollFixture({
|
||||
storedCode: 'AbC-12345',
|
||||
riotTournamentCode: 'AbC-12345',
|
||||
});
|
||||
|
||||
await service.processPollJob({
|
||||
matchId: match._id.toString(),
|
||||
attempt: 1,
|
||||
expandedToAllPuuids: true,
|
||||
});
|
||||
|
||||
expect(code.state).toBe('used');
|
||||
expect(code.riotMatchId).toBe('KR_9876543210');
|
||||
expect(code.save).toHaveBeenCalled();
|
||||
expect(match.result?.games).toHaveLength(1);
|
||||
});
|
||||
|
||||
it('limits expanded polling to two team members per team', async () => {
|
||||
const { service, match, riotMatchService } = createPollFixture({
|
||||
storedCode: 'AbC-12345',
|
||||
riotTournamentCode: 'AbC-12345',
|
||||
});
|
||||
|
||||
await service.processPollJob({
|
||||
matchId: match._id.toString(),
|
||||
attempt: 1,
|
||||
expandedToAllPuuids: true,
|
||||
});
|
||||
|
||||
expect(
|
||||
riotMatchService.getMatchIdsByPuuid.mock.calls.map(([puuid]) => puuid),
|
||||
).toEqual(['poll-puuid-1', 'poll-puuid-2', 'poll-puuid-6', 'poll-puuid-7']);
|
||||
});
|
||||
|
||||
it('does not match tournament codes when casing differs', async () => {
|
||||
const { service, match, code } = createPollFixture({
|
||||
storedCode: 'ABC-12345',
|
||||
riotTournamentCode: 'abc-12345',
|
||||
});
|
||||
|
||||
await service.processPollJob({
|
||||
matchId: match._id.toString(),
|
||||
attempt: 1,
|
||||
expandedToAllPuuids: true,
|
||||
});
|
||||
|
||||
expect(code.state).toBe('reserved');
|
||||
expect(code.riotMatchId).toBeUndefined();
|
||||
expect(code.save).not.toHaveBeenCalled();
|
||||
expect(match.result?.games).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('TournamentResultService polling cadence', () => {
|
||||
it('polls every two minutes during the first hour', () => {
|
||||
const service = createService();
|
||||
|
||||
expect(service.nextPollDelayMs(0)).toBe(2 * 60_000);
|
||||
expect(service.nextPollDelayMs(60 * 60_000)).toBe(2 * 60_000);
|
||||
});
|
||||
});
|
||||
|
||||
describe('TournamentResultService manual result collection', () => {
|
||||
function createManualFixture() {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
|
||||
@@ -23,6 +23,7 @@ import {
|
||||
resolveRoundRobinTeamCount,
|
||||
} from '../tournament-code/round-robin.util';
|
||||
import {
|
||||
collectCaptainAndLimitedTeamMemberUserIds,
|
||||
collectCaptainUserIds,
|
||||
collectMatchUserIds,
|
||||
computeGameResult,
|
||||
@@ -34,10 +35,11 @@ import type {
|
||||
PollTournamentResultJob,
|
||||
} from './tournament-result.types';
|
||||
|
||||
const FIRST_HOUR_POLL_DELAY_MS = 5 * 60_000;
|
||||
const FIRST_HOUR_POLL_DELAY_MS = 2 * 60_000;
|
||||
const LATER_POLL_DELAY_MS = 60 * 60_000;
|
||||
const POLL_EXPIRY_MS = 24 * 60 * 60_000;
|
||||
const EXPAND_AFTER_MS = 60 * 60_000;
|
||||
const EXPANDED_MEMBER_LIMIT_PER_TEAM = 2;
|
||||
const TOURNAMENT_LOOKUP_START_MARGIN_SECONDS = 60;
|
||||
|
||||
interface ManualGameAssignment {
|
||||
@@ -216,7 +218,13 @@ export class TournamentResultService {
|
||||
const region = community?.riotRegion ?? 'asia';
|
||||
const lookup = await this.buildPuuidLookup(match);
|
||||
const puuids = job.expandedToAllPuuids
|
||||
? this.collectPollingPuuids(collectMatchUserIds(match), lookup)
|
||||
? this.collectPollingPuuids(
|
||||
collectCaptainAndLimitedTeamMemberUserIds(
|
||||
match,
|
||||
EXPANDED_MEMBER_LIMIT_PER_TEAM,
|
||||
),
|
||||
lookup,
|
||||
)
|
||||
: this.collectPollingPuuids(collectCaptainUserIds(match), lookup);
|
||||
|
||||
const matchedGameNumbers = new Set<number>();
|
||||
@@ -262,7 +270,7 @@ export class TournamentResultService {
|
||||
);
|
||||
continue;
|
||||
}
|
||||
const tournamentCode = detail.info.tournamentCode?.trim().toUpperCase();
|
||||
const tournamentCode = detail.info.tournamentCode?.trim();
|
||||
if (!tournamentCode) continue;
|
||||
|
||||
const code = unmatchedByCode.get(tournamentCode);
|
||||
|
||||
@@ -0,0 +1,90 @@
|
||||
import { createRequire } from 'node:module';
|
||||
|
||||
const CONFIG_PATH = '../newrelic.cjs';
|
||||
const requireConfig = createRequire(__filename);
|
||||
|
||||
interface NewRelicConfig {
|
||||
app_name: string[];
|
||||
license_key: string;
|
||||
agent_enabled: boolean;
|
||||
ai_monitoring: {
|
||||
enabled: boolean;
|
||||
};
|
||||
custom_insights_events: {
|
||||
max_samples_stored: number;
|
||||
};
|
||||
span_events: {
|
||||
max_samples_stored: number;
|
||||
};
|
||||
}
|
||||
|
||||
interface NewRelicConfigModule {
|
||||
config: NewRelicConfig;
|
||||
}
|
||||
|
||||
function loadConfig(): NewRelicConfig {
|
||||
jest.resetModules();
|
||||
const module = requireConfig(CONFIG_PATH) as unknown as NewRelicConfigModule;
|
||||
return module.config;
|
||||
}
|
||||
|
||||
describe('New Relic config', () => {
|
||||
let originalEnv: NodeJS.ProcessEnv;
|
||||
|
||||
beforeEach(() => {
|
||||
originalEnv = { ...process.env };
|
||||
delete process.env.NEW_RELIC_ENABLED;
|
||||
delete process.env.NEW_RELIC_LICENSE_KEY;
|
||||
delete process.env.NEW_RELIC_APP_NAME;
|
||||
delete process.env.NEW_RELIC_AI_MONITORING_ENABLED;
|
||||
delete process.env.NEW_RELIC_CUSTOM_INSIGHTS_EVENTS_MAX_SAMPLES_STORED;
|
||||
delete process.env.NEW_RELIC_SPAN_EVENTS_MAX_SAMPLES_STORED;
|
||||
jest.resetModules();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
process.env = originalEnv;
|
||||
jest.resetModules();
|
||||
});
|
||||
|
||||
it('uses safe defaults and stays disabled without a license key', () => {
|
||||
const config = loadConfig();
|
||||
|
||||
expect(config.app_name).toEqual(['lolympus']);
|
||||
expect(config.agent_enabled).toBe(false);
|
||||
expect(config.ai_monitoring.enabled).toBe(true);
|
||||
expect(config.custom_insights_events.max_samples_stored).toBe(100000);
|
||||
expect(config.span_events.max_samples_stored).toBe(10000);
|
||||
});
|
||||
|
||||
it('enables the agent when a license key exists and honors runtime overrides', () => {
|
||||
process.env.NEW_RELIC_LICENSE_KEY = 'test-license';
|
||||
process.env.NEW_RELIC_APP_NAME = 'lolympus-api-test';
|
||||
process.env.NEW_RELIC_AI_MONITORING_ENABLED = 'false';
|
||||
process.env.NEW_RELIC_CUSTOM_INSIGHTS_EVENTS_MAX_SAMPLES_STORED = '5000';
|
||||
process.env.NEW_RELIC_SPAN_EVENTS_MAX_SAMPLES_STORED = '4000';
|
||||
|
||||
const config = loadConfig();
|
||||
|
||||
expect(config.app_name).toEqual(['lolympus-api-test']);
|
||||
expect(config.license_key).toBe('test-license');
|
||||
expect(config.agent_enabled).toBe(true);
|
||||
expect(config.ai_monitoring.enabled).toBe(false);
|
||||
expect(config.custom_insights_events.max_samples_stored).toBe(5000);
|
||||
expect(config.span_events.max_samples_stored).toBe(4000);
|
||||
});
|
||||
|
||||
it('normalizes shorthand sample sizes before New Relic applies env overrides', () => {
|
||||
process.env.NEW_RELIC_CUSTOM_INSIGHTS_EVENTS_MAX_SAMPLES_STORED = '100k';
|
||||
process.env.NEW_RELIC_SPAN_EVENTS_MAX_SAMPLES_STORED = '10k';
|
||||
|
||||
const config = loadConfig();
|
||||
|
||||
expect(config.custom_insights_events.max_samples_stored).toBe(100000);
|
||||
expect(config.span_events.max_samples_stored).toBe(10000);
|
||||
expect(
|
||||
process.env.NEW_RELIC_CUSTOM_INSIGHTS_EVENTS_MAX_SAMPLES_STORED,
|
||||
).toBe('100000');
|
||||
expect(process.env.NEW_RELIC_SPAN_EVENTS_MAX_SAMPLES_STORED).toBe('10000');
|
||||
});
|
||||
});
|
||||
@@ -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);
|
||||
});
|
||||
@@ -1,7 +1,15 @@
|
||||
VITE_API_BASE_URL=http://localhost:3000
|
||||
VITE_API_BASE_URL=http://126.dahyeon.us:3000
|
||||
VITE_DEFAULT_COMMUNITY_ID=69ebe0adf627c11be2f020a1
|
||||
VITE_MSAL_CLIENT_ID=15fb5a20-47e0-44fa-9a41-b50ca9d0e7e3
|
||||
VITE_MSAL_AUTHORITY=https://login.microsoftonline.com/5ef88004-e953-4b04-93db-64bbf49c6863
|
||||
VITE_MSAL_API_SCOPE=api://15fb5a20-47e0-44fa-9a41-b50ca9d0e7e3/lolympus-tournament-support-dev
|
||||
VITE_MSAL_REDIRECT_URI=http://localhost:5173/auth/callback
|
||||
VITE_MSAL_SILENT_REDIRECT_URI=http://localhost:5173/auth/silent-callback.html
|
||||
VITE_NEW_RELIC_ENABLED=false
|
||||
VITE_NEW_RELIC_APPLICATION_ID=601654991
|
||||
VITE_NEW_RELIC_ACCOUNT_ID=8100154
|
||||
VITE_NEW_RELIC_AGENT_ID=601654991
|
||||
VITE_NEW_RELIC_LICENSE_KEY=NRJS-caad7f6e90b92fe88de
|
||||
VITE_NEW_RELIC_TRUST_KEY=8100154
|
||||
VITE_NEW_RELIC_BEACON=bam.nr-data.net
|
||||
VITE_NEW_RELIC_RELEASE_NAME=lolympus-web
|
||||
@@ -5,3 +5,13 @@ VITE_MSAL_AUTHORITY=https://login.microsoftonline.com/<tenant-id>
|
||||
VITE_MSAL_API_SCOPE=api://lolympus-api/access_as_user
|
||||
VITE_MSAL_REDIRECT_URI=http://localhost:5173/auth/callback
|
||||
VITE_MSAL_SILENT_REDIRECT_URI=http://localhost:5173/auth/silent-callback.html
|
||||
VITE_NEW_RELIC_ENABLED=false
|
||||
VITE_NEW_RELIC_APPLICATION_ID=
|
||||
VITE_NEW_RELIC_ACCOUNT_ID=
|
||||
VITE_NEW_RELIC_AGENT_ID=
|
||||
VITE_NEW_RELIC_LICENSE_KEY=
|
||||
VITE_NEW_RELIC_TRUST_KEY=
|
||||
VITE_NEW_RELIC_BEACON=bam.nr-data.net
|
||||
VITE_NEW_RELIC_APPLICATION_VERSION=
|
||||
VITE_NEW_RELIC_RELEASE_ID=
|
||||
VITE_NEW_RELIC_RELEASE_NAME=lolympus-web
|
||||
@@ -5,4 +5,13 @@ VITE_MSAL_AUTHORITY=https://login.microsoftonline.com/5ef88004-e953-4b04-93db-64
|
||||
VITE_MSAL_API_SCOPE=api://15fb5a20-47e0-44fa-9a41-b50ca9d0e7e3/lolympus-tournament-support-dev
|
||||
VITE_MSAL_REDIRECT_URI=https://lolympus.dahyeon.us/auth/callback
|
||||
VITE_MSAL_SILENT_REDIRECT_URI=https://lolympus.dahyeon.us/auth/silent-callback.html
|
||||
|
||||
VITE_NEW_RELIC_ENABLED=true
|
||||
VITE_NEW_RELIC_APPLICATION_ID=601654991
|
||||
VITE_NEW_RELIC_ACCOUNT_ID=8100154
|
||||
VITE_NEW_RELIC_AGENT_ID=601654991
|
||||
VITE_NEW_RELIC_LICENSE_KEY=NRJS-caad7f6e90b92fe88de
|
||||
VITE_NEW_RELIC_TRUST_KEY=8100154
|
||||
VITE_NEW_RELIC_BEACON=bam.nr-data.net
|
||||
VITE_NEW_RELIC_APPLICATION_VERSION=83
|
||||
VITE_NEW_RELIC_RELEASE_ID=release-83
|
||||
VITE_NEW_RELIC_RELEASE_NAME=lolympus-web
|
||||
+12
-2
@@ -1,6 +1,16 @@
|
||||
VITE_API_BASE_URL=https://lolympus-api-staging.dahyeon.us
|
||||
VITE_DEFAULT_COMMUNITY_ID=69ebe0adf627c11be2f020a1
|
||||
VITE_MSAL_CLIENT_ID=15fb5a20-47e0-44fa-9a41-b50ca9d0e7e3
|
||||
VITE_MSAL_CLIENT_ID=66dadf46-418c-43c8-a908-3c15dcc0465d
|
||||
VITE_MSAL_AUTHORITY=https://login.microsoftonline.com/5ef88004-e953-4b04-93db-64bbf49c6863
|
||||
VITE_MSAL_API_SCOPE=api://15fb5a20-47e0-44fa-9a41-b50ca9d0e7e3/lolympus-tournament-support-dev
|
||||
VITE_MSAL_REDIRECT_URI=http://localhost:5173/auth/callback
|
||||
VITE_MSAL_REDIRECT_URI=https://release-83.lolympus.pages.dev/auth/callback
|
||||
VITE_NEW_RELIC_ENABLED=true
|
||||
VITE_NEW_RELIC_APPLICATION_ID=601654991
|
||||
VITE_NEW_RELIC_ACCOUNT_ID=8100154
|
||||
VITE_NEW_RELIC_AGENT_ID=601654991
|
||||
VITE_NEW_RELIC_LICENSE_KEY=NRJS-caad7f6e90b92fe88de
|
||||
VITE_NEW_RELIC_TRUST_KEY=8100154
|
||||
VITE_NEW_RELIC_BEACON=bam.nr-data.net
|
||||
VITE_NEW_RELIC_APPLICATION_VERSION=83
|
||||
VITE_NEW_RELIC_RELEASE_ID=release-83
|
||||
VITE_NEW_RELIC_RELEASE_NAME=lolympus-web
|
||||
@@ -20,6 +20,7 @@
|
||||
"dependencies": {
|
||||
"@azure/msal-browser": "^5.8.0",
|
||||
"@azure/msal-react": "^5.3.1",
|
||||
"@newrelic/browser-agent": "^1.316.0",
|
||||
"@tanstack/react-query": "^5.100.1",
|
||||
"lucide-react": "^1.14.0",
|
||||
"react": "^19.2.4",
|
||||
|
||||
@@ -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,
|
||||
}),
|
||||
}),
|
||||
});
|
||||
}
|
||||
|
||||
+106
-42
@@ -36,6 +36,9 @@ export interface TeamParticipantView extends ParticipantView {
|
||||
export interface TeamView {
|
||||
teamIndex: number;
|
||||
name: string;
|
||||
captainUserId?: string;
|
||||
captainName?: string;
|
||||
captainTag?: string;
|
||||
participants: TeamParticipantView[];
|
||||
}
|
||||
|
||||
@@ -116,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;
|
||||
@@ -130,6 +135,7 @@ export interface AuctionStateView {
|
||||
}[];
|
||||
currentBid: number;
|
||||
currentBidder: { teamIndex: number } | null;
|
||||
remainingMs: number;
|
||||
timer: number;
|
||||
maxTimer: number;
|
||||
bidExtensionSeconds: number;
|
||||
@@ -227,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,
|
||||
@@ -241,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,
|
||||
@@ -270,7 +277,7 @@ function createFallbackParticipant(userId: string): ParticipantView {
|
||||
}
|
||||
|
||||
function mapAuctionTeamToView(
|
||||
team: ApiAuctionTeam,
|
||||
team: NormalizedApiAuctionTeam,
|
||||
playerLookup: Map<string, AuctionPlayerView>,
|
||||
participantLookup: Map<string, ParticipantView>,
|
||||
): AuctionTeamView {
|
||||
@@ -413,21 +420,32 @@ export function mapApiMatchToMatchDetail(match: ApiMatch): MatchDetailView {
|
||||
participants.map((participant) => [participant.userId, participant]),
|
||||
);
|
||||
|
||||
const teams = match.teams.map((team) => ({
|
||||
teamIndex: team.teamIndex,
|
||||
name: teamIndexLabel(team.teamIndex, team.name),
|
||||
participants: team.members.map((member) => {
|
||||
const participant =
|
||||
participantLookup.get(member.userId) ??
|
||||
createFallbackParticipant(member.userId);
|
||||
const teams = match.teams.map((team) => {
|
||||
const captain = team.captainUserId
|
||||
? participantLookup.get(team.captainUserId)
|
||||
: undefined;
|
||||
|
||||
return {
|
||||
...participant,
|
||||
assignedPosition: member.assignedPosition,
|
||||
cost: member.cost,
|
||||
};
|
||||
}),
|
||||
}));
|
||||
return {
|
||||
teamIndex: team.teamIndex,
|
||||
name: teamIndexLabel(team.teamIndex, team.name),
|
||||
captainUserId: team.captainUserId,
|
||||
captainName:
|
||||
captain?.summonerName ??
|
||||
(team.captainUserId ? `User ${team.captainUserId.slice(-4)}` : undefined),
|
||||
captainTag: captain?.tag,
|
||||
participants: team.members.map((member) => {
|
||||
const participant =
|
||||
participantLookup.get(member.userId) ??
|
||||
createFallbackParticipant(member.userId);
|
||||
|
||||
return {
|
||||
...participant,
|
||||
assignedPosition: member.assignedPosition,
|
||||
cost: member.cost,
|
||||
};
|
||||
}),
|
||||
};
|
||||
});
|
||||
|
||||
const winnerTeam = match.result?.winnerTeamIndex
|
||||
? teams.find((team) => team.teamIndex === match.result?.winnerTeamIndex)
|
||||
@@ -475,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,
|
||||
);
|
||||
|
||||
@@ -489,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),
|
||||
),
|
||||
@@ -513,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,
|
||||
}));
|
||||
}
|
||||
Loaded 100 of 109 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user