Compare commits
22
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
8d741ef9a7 | ||
|
|
23a0a3f8dd | ||
|
|
e349684523 | ||
|
|
9d7c888b0a | ||
|
|
5882585f69 | ||
|
|
2d8027cb16 | ||
|
|
fbf22284e8 | ||
|
|
6efbd50db7 | ||
|
|
3f68997b9a | ||
|
|
be4de61bb7 | ||
|
|
6c582ba3cf | ||
|
|
9064340584 | ||
|
|
cc358697d4 | ||
|
|
f6686bbf17 | ||
|
|
0d7617e2d2 | ||
|
|
20e1e6ec04 | ||
|
|
664af15255 | ||
|
|
7e0cd7cb19 | ||
|
|
38a89b5374 | ||
|
|
da7b502936 | ||
|
|
f649490cd2 | ||
|
|
f2eec479d9 |
No files matched your search
@@ -0,0 +1,11 @@
|
||||
{
|
||||
"version": "0.0.1",
|
||||
"configurations": [
|
||||
{
|
||||
"name": "web-staging",
|
||||
"runtimeExecutable": "pnpm",
|
||||
"runtimeArgs": ["--filter", "web", "start:staging"],
|
||||
"port": 5173
|
||||
}
|
||||
]
|
||||
}
|
||||
+6
-5
@@ -23,11 +23,12 @@ website/LICENSE
|
||||
|
||||
*.md
|
||||
!README.md
|
||||
!docs/specs/internal-match-game-analysis.md
|
||||
!docs/plans/internal-match-game-analysis-p0-p1.md
|
||||
!docs/specs/double-elimination-connector-routing.md
|
||||
!docs/plans/double-elimination-connector-routing.md
|
||||
!docs/plans/redis-8.10-optimization.md
|
||||
!design-qa.md
|
||||
!docs/specs/home-banner-production.md
|
||||
!docs/specs/match-status-and-result-presentation.md
|
||||
!docs/specs/information-visible-ui.md
|
||||
!docs/ux-audit-2026-11-10/06-ui-improvement-review.md
|
||||
!docs/ux-audit-2026-11-10/07-visual-design-review.md
|
||||
/tmp/
|
||||
/user-game-history/
|
||||
/*.txt
|
||||
|
||||
@@ -144,7 +144,9 @@ pnpm --filter api build
|
||||
|
||||
`test:redis`는 PATH의 `redis-server` 또는 `REDIS_TEST_SERVER`에 지정한 실행 파일로 Redis 8.10.x를 직접 실행합니다. 임의의 로컬 포트와 일회용 암호를 사용하고, 저장을 비활성화하며, 종료 후 프로세스와 임시 디렉터리를 정리합니다. 애플리케이션 Redis 연결 설정은 사용하지 않습니다. Windows에서는 PowerShell에서 `$env:REDIS_TEST_SERVER = 'C:\tools\redis\redis-server.exe'`처럼 지정할 수 있습니다.
|
||||
|
||||
커뮤니티 통계 캐시는 `riot:communitystats:v2:{communityId}:scope` Hash로 전환됩니다. 항목별 TTL은 일반 5분, 완성된 상세 24시간, 미완성 상세 60초를 유지합니다. 이전 String 캐시는 기존 TTL로 만료되며 새 캐시는 첫 조회에 생성됩니다. 구버전과 신버전은 무효화 대상이 다르므로 API 인스턴스를 같은 버전으로 함께 전환해야 합니다. 구현 범위와 검증 기록은 [Redis 변경 계획](docs/plans/redis-8.10-optimization.md)을 참고하세요.
|
||||
커뮤니티 통계 캐시는 `riot:communitystats:v2:{communityId}:scope` Hash를 사용합니다. 항목별 TTL은 일반 5분, 완성된 상세 24시간, 미완성 상세 60초입니다. 이전 String 캐시는 기존 TTL로 만료되며 새 캐시는 첫 조회에 생성됩니다. 구버전과 신버전은 무효화 대상이 다르므로 배포와 롤백 모두 API 인스턴스를 같은 버전으로 함께 전환해야 합니다.
|
||||
|
||||
스트림이 계속 커지면 소비자 그룹별 미처리 항목을 확인합니다. 사용이 중단된 그룹도 미처리 항목을 계속 보존할 수 있습니다.
|
||||
|
||||
### API New Relic APM
|
||||
|
||||
@@ -171,6 +173,8 @@ API 성능 계측은 기본 비활성화이며 필요할 때 `API_PERF_OBSERVABI
|
||||
|
||||
카카오톡 기반 명령어 기능은 Dakao(커스텀 카카오톡 게이트웨이) 연동이 필요합니다. Dakao가 실행 중이 아니거나 NATS를 통해 API 서버와 연결되어 있지 않으면 일정 조회, 내전 참가, 참가 취소, 계정 등록 같은 카카오톡 명령어는 사용할 수 없습니다.
|
||||
|
||||
카카오톡 방을 옮긴 뒤에는 새 방에서 `!내전 데이터이관 예전 닉네임`을 실행합니다. 같은 커뮤니티에서 Riot 계정이 등록된 기존 사용자의 카카오톡 ID만 바뀝니다. 기존 사용자 ID, 권한, 참가 기록은 유지됩니다. 닉네임이 중복되거나 새 ID가 이미 다른 사용자에 연결돼 있으면 운영자가 확인합니다. 계정 소유권 확인은 운영 절차에서 담당합니다.
|
||||
|
||||
## 커맨드
|
||||
|
||||
| Command | Description |
|
||||
|
||||
@@ -62,6 +62,105 @@ $ pnpm run test:e2e
|
||||
|
||||
# test coverage
|
||||
$ pnpm run test:cov
|
||||
|
||||
# auction cancellation/undo transactions against a real local MongoDB replica set
|
||||
$ pnpm run test:mongodb
|
||||
```
|
||||
|
||||
`test:mongodb` requires `mongod` on PATH, or `MONGODB_TEST_SERVER` set to its
|
||||
executable path. The runner starts an isolated replica set on a random loopback
|
||||
port, uses a temporary database directory, and removes it after the tests. It
|
||||
does not use the application's database connection settings.
|
||||
|
||||
## Temporary auction role selection
|
||||
|
||||
Until captain accounts are issued, bids use the team selected in the auction UI.
|
||||
By default, both WebSocket and HTTP bids accept guests and signed-in users without
|
||||
checking whether the user is that team's captain. Team existence, bid amounts,
|
||||
remaining points, roster limits, deadlines and round consistency are still checked.
|
||||
Bid history continues to identify the selected team's captain, so it is not proof
|
||||
of the account that submitted a bid in this temporary mode.
|
||||
|
||||
After issuing accounts, set `AUCTION_REQUIRE_CAPTAIN_AUTH=true` in the API
|
||||
environment (or `project.env`) and restart the API to require a signed-in captain
|
||||
for the selected team on all bid paths. Unset or `false` keeps temporary mode.
|
||||
|
||||
## Auction durability
|
||||
|
||||
Accepted Redis bids now enter `auction:bidArchivePayloads` and
|
||||
`auction:bidArchiveQueue` atomically with the bid. The durability scheduler saves
|
||||
them to `auctionBidRecords` using deterministic IDs before removing queue entries.
|
||||
Recent state snapshots remain capped at 1000 bids; the archive is not capped and
|
||||
retains accepted bids across undo/cancellation for audit. These records begin with
|
||||
this deployment; bids already discarded by an older version cannot be recovered.
|
||||
`GET /communities/:communityId/matches/:matchId/auction/bids/history` pages through
|
||||
the current lifecycle's persisted archive using `afterRevision` and `limit` (1–200).
|
||||
Persistence is asynchronous, so an empty last page may gain entries afterward.
|
||||
|
||||
Invalid archive entries are moved atomically to `auction:bidArchiveDeadLetterQueue`
|
||||
and `auction:bidArchiveDeadLetterPayloads`. The payload stores the original text
|
||||
(or `null` for a missing payload), error, ID, and quarantine time. Monitor these
|
||||
keys and review quarantined data before repairing/requeuing it; it is not retried
|
||||
automatically or expired. Other bids continue to persist. Mongo write failures
|
||||
leave valid entries in the pending queue for idempotent retries.
|
||||
|
||||
Older in-flight rounds can produce `bidRoundId: ''`; the archive treats this as
|
||||
an absent optional round ID. Empty player IDs and other invalid field types
|
||||
remain validation errors.
|
||||
|
||||
Cancellation commits its completion marker and pending cleanup fields in Match.
|
||||
The scheduler retries cleanup after restarts, with a delay capped at 60 seconds.
|
||||
Reset notifications include the lifecycle to protect a newly started auction.
|
||||
Dead-letter status notifications use `auction:deadLetterStatusQueue`; failures to
|
||||
persist or mirror the terminal status are retried without rerunning the side effect.
|
||||
Older side-effect dead letters are also reconciled automatically.
|
||||
|
||||
Before deploying the cleanup worker, create its partial Match index using the
|
||||
additive, repeatable migration below. Schema declarations alone do not create
|
||||
indexes when `MONGODB_AUTO_INDEX` is disabled (the default). Choose the target
|
||||
environment explicitly; dry-run does not create indexes or modify documents.
|
||||
|
||||
```bash
|
||||
pnpm --filter api auction:indexes -- --env staging --dry-run
|
||||
pnpm --filter api auction:indexes -- --env staging --apply
|
||||
# Use --env prod for production.
|
||||
```
|
||||
|
||||
The index is `{ auctionCancellationCleanupRetryAt: 1 }`, restricted to
|
||||
`{ auctionCancellationCleanupPending: true }`. The worker only reads due pending
|
||||
entries; it no longer scans legacy cancellation markers without a pending flag.
|
||||
|
||||
## Riot archive recovery
|
||||
|
||||
Newly saved or repaired Riot match data refreshes affected internal match
|
||||
statistics at the same Competition revision. Existing archives and duplicate
|
||||
imports do not trigger recovery. Recovery failures are logged and do not block
|
||||
result collection or match refresh. Only communities with recovered statistics
|
||||
have their caches invalidated, once per recovery batch; one failed rebuild does
|
||||
not prevent other successful rebuilds from being reflected. Detail
|
||||
requests also check for newly archived data when a cached game is missing raw
|
||||
data. An absent archive does not trigger a rebuild or a Riot match fetch. If a
|
||||
detail rebuild makes no progress, the process waits 60 seconds before retrying
|
||||
that source revision and does not invalidate the community cache.
|
||||
|
||||
Recovery cache invalidations first try Redis with a one-second command timeout.
|
||||
On failure they return immediately and schedule up to three in-process retries,
|
||||
waiting 1, 5, then 30 seconds between attempts. A community has one retry budget;
|
||||
additional immediate failures do not reset it, and a successful current request
|
||||
cancels the pending retry. Timers are unreferenced and cleared on shutdown.
|
||||
Retries are not persisted or resumed after a restart. Detail requests detect
|
||||
newly archived raw data even behind a stale cache, and other response caches
|
||||
expire after five minutes. A detail response whose immediate invalidation fails
|
||||
is returned without being cached. No Mongo invalidation collection or periodic
|
||||
queue scan is used.
|
||||
|
||||
Before deploying this recovery path, add its Riot ID lookup index. The migration
|
||||
defaults to dry-run and leaves other indexes and game records unchanged.
|
||||
|
||||
```bash
|
||||
pnpm --filter api stats:indexes -- --env staging --dry-run
|
||||
pnpm --filter api stats:indexes -- --env staging --apply
|
||||
# Use --env prod for production.
|
||||
```
|
||||
|
||||
## Deployment
|
||||
|
||||
@@ -1,10 +1,11 @@
|
||||
// @ts-check
|
||||
import eslint from '@eslint/js';
|
||||
import { defineConfig } from 'eslint/config';
|
||||
import eslintPluginPrettierRecommended from 'eslint-plugin-prettier/recommended';
|
||||
import globals from 'globals';
|
||||
import tseslint from 'typescript-eslint';
|
||||
|
||||
export default tseslint.config(
|
||||
export default defineConfig(
|
||||
{
|
||||
ignores: ['eslint.config.mjs'],
|
||||
},
|
||||
|
||||
+10
-6
@@ -9,6 +9,9 @@
|
||||
"build": "nest build",
|
||||
"format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
|
||||
"competition:migrate": "ts-node src/modules/global/database/migrations/run-competition-domain.ts",
|
||||
"competition:repair-grand-final": "ts-node src/modules/global/database/migrations/repair-grand-final-bo3.ts",
|
||||
"auction:indexes": "ts-node src/modules/global/database/migrations/run-auction-cancellation-index.ts",
|
||||
"stats:indexes": "ts-node src/modules/global/database/migrations/run-match-stats-raw-index.ts",
|
||||
"seed:dev": "ts-node src/seed.ts",
|
||||
"seed:dakao-participant": "ts-node src/seed-dakao-participant.ts",
|
||||
"start:dev": "NODE_ENV=dev NEW_RELIC_HOME=. node --import newrelic/esm-loader.mjs -r newrelic dist/main.js",
|
||||
@@ -24,6 +27,7 @@
|
||||
"test": "jest",
|
||||
"typecheck": "tsc --noEmit --incremental false",
|
||||
"test:redis": "node test/run-redis-tests.mjs",
|
||||
"test:mongodb": "node test/run-mongo-tests.mjs",
|
||||
"test:watch": "jest --watch",
|
||||
"test:cov": "jest --coverage",
|
||||
"test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
|
||||
@@ -31,19 +35,20 @@
|
||||
},
|
||||
"dependencies": {
|
||||
"@lolympus/contracts": "workspace:*",
|
||||
"@nats-io/jetstream": "^3.4.0",
|
||||
"@nats-io/transport-node": "^3.4.0",
|
||||
"@nestjs/common": "^11.1.28",
|
||||
"@nestjs/config": "^4.0.4",
|
||||
"@nestjs/core": "^11.1.28",
|
||||
"@nestjs/platform-express": "^11.1.28",
|
||||
"@nestjs/platform-socket.io": "^11.1.28",
|
||||
"@nestjs/swagger": "^11.4.6",
|
||||
"@nestjs/swagger": "^11.4.8",
|
||||
"@nestjs/websockets": "^11.1.28",
|
||||
"@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",
|
||||
"mongoose": "9.12.1",
|
||||
"newrelic": "^14.3.3",
|
||||
"redis": "^5.12.1",
|
||||
"reflect-metadata": "^0.2.2",
|
||||
@@ -52,8 +57,7 @@
|
||||
"temporal-polyfill": "^0.3.2"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@eslint/eslintrc": "^3.2.0",
|
||||
"@eslint/js": "^9.18.0",
|
||||
"@eslint/js": "^10.0.1",
|
||||
"@nestjs/cli": "^11.0.0",
|
||||
"@nestjs/schematics": "^11.0.0",
|
||||
"@nestjs/testing": "^11.0.1",
|
||||
@@ -61,7 +65,7 @@
|
||||
"@types/jest": "^30.0.0",
|
||||
"@types/node": "^26.1.1",
|
||||
"@types/supertest": "^7.0.0",
|
||||
"eslint": "^9.18.0",
|
||||
"eslint": "^10.14.0",
|
||||
"eslint-config-prettier": "^10.0.1",
|
||||
"eslint-plugin-prettier": "^5.2.2",
|
||||
"globals": "^17.0.0",
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
import mongoose from 'mongoose';
|
||||
import { AuctionBidArchiveService } from './auction-bid-archive.service';
|
||||
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
|
||||
function bid(overrides: Record<string, unknown> = {}) {
|
||||
return {
|
||||
_id: `${matchId}:life:${String(1).padStart(16, '0')}`,
|
||||
matchId,
|
||||
auctionLifecycleId: 'life',
|
||||
revision: 1,
|
||||
bidRequestId: 'bid-1',
|
||||
bidderUserId: new mongoose.Types.ObjectId().toString(),
|
||||
playerUserId: new mongoose.Types.ObjectId().toString(),
|
||||
bidderTeamIndex: 1,
|
||||
bidPointAmount: 10,
|
||||
bidPlacedAtTimestampMS: 1_700_000_000_000,
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
function fixture(payload: Record<string, unknown>) {
|
||||
const raw = JSON.stringify(payload);
|
||||
const commands: string[][] = [];
|
||||
const sendCommand = jest.fn(async (command: string[]) => {
|
||||
commands.push(command);
|
||||
if (command[0] === 'ZRANGE') return [payload._id];
|
||||
if (command[0] === 'HMGET') return [raw];
|
||||
return 1;
|
||||
});
|
||||
const bulkWrite = jest.fn(async (operations: unknown[]) => ({
|
||||
matchedCount: 0,
|
||||
upsertedCount: operations.length,
|
||||
}));
|
||||
const service = new AuctionBidArchiveService(
|
||||
{ getModel: async () => ({ bulkWrite }) } as never,
|
||||
{ raw: () => ({ sendCommand }) } as never,
|
||||
);
|
||||
return { service, bulkWrite, commands };
|
||||
}
|
||||
|
||||
function savedEvent(bulkWrite: jest.Mock) {
|
||||
const [[operations]] = bulkWrite.mock.calls as unknown as [
|
||||
[
|
||||
Array<{
|
||||
updateOne: { update: { $setOnInsert: Record<string, unknown> } };
|
||||
}>,
|
||||
],
|
||||
];
|
||||
return operations[0].updateOne.update.$setOnInsert;
|
||||
}
|
||||
|
||||
function quarantined(commands: string[][]) {
|
||||
return commands.some(
|
||||
(command) =>
|
||||
command[0] === 'EVAL' &&
|
||||
command[1].includes("redis.call('ZADD', KEYS[4]"),
|
||||
);
|
||||
}
|
||||
|
||||
it('archives a pre-upgrade bid with an empty round ID without the field', async () => {
|
||||
const f = fixture(bid({ bidRoundId: '' }));
|
||||
await expect(f.service.persistPendingBids()).resolves.toBe(1);
|
||||
expect(quarantined(f.commands)).toBe(false);
|
||||
expect(savedEvent(f.bulkWrite)).not.toHaveProperty('bidRoundId');
|
||||
});
|
||||
|
||||
it('keeps a non-empty round ID on the archived bid', async () => {
|
||||
const f = fixture(bid({ bidRoundId: 'round-1' }));
|
||||
await expect(f.service.persistPendingBids()).resolves.toBe(1);
|
||||
expect(savedEvent(f.bulkWrite)).toMatchObject({ bidRoundId: 'round-1' });
|
||||
});
|
||||
|
||||
it.each([' ', null, 1])(
|
||||
'still quarantines an invalid round ID %j',
|
||||
async (bidRoundId) => {
|
||||
const f = fixture(bid({ bidRoundId }));
|
||||
await expect(f.service.persistPendingBids()).resolves.toBe(0);
|
||||
expect(f.bulkWrite).not.toHaveBeenCalled();
|
||||
expect(quarantined(f.commands)).toBe(true);
|
||||
},
|
||||
);
|
||||
@@ -0,0 +1,242 @@
|
||||
import {
|
||||
BadRequestException,
|
||||
Injectable,
|
||||
Logger,
|
||||
NotFoundException,
|
||||
} from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import type { AuctionBidRecord } from '../global/database/schema';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import { AuctionRedisService } from './redis/auction-redis.service';
|
||||
import {
|
||||
AUCTION_BID_ARCHIVE_PAYLOADS_KEY,
|
||||
AUCTION_BID_ARCHIVE_QUEUE_KEY,
|
||||
AUCTION_BID_ARCHIVE_DEAD_LETTER_QUEUE_KEY,
|
||||
AUCTION_BID_ARCHIVE_DEAD_LETTER_PAYLOADS_KEY,
|
||||
} from './redis/auction-redis.keys';
|
||||
|
||||
// Compare the payload as well as the ID: a concurrent repair must not be moved
|
||||
// or acknowledged by a worker that read an older value.
|
||||
const QUARANTINE_BID_ARCHIVE_SCRIPT = `
|
||||
local moved = 0
|
||||
for i = 2, #ARGV, 4 do
|
||||
local current = redis.call('HGET', KEYS[1], ARGV[i])
|
||||
local matches = (ARGV[i+1] == '0' and current == false) or (ARGV[i+1] == '1' and current == ARGV[i+2])
|
||||
if matches and redis.call('ZSCORE', KEYS[2], ARGV[i]) then
|
||||
redis.call('HSET', KEYS[3], ARGV[i], ARGV[i+3])
|
||||
redis.call('ZADD', KEYS[4], ARGV[1], ARGV[i])
|
||||
redis.call('HDEL', KEYS[1], ARGV[i])
|
||||
redis.call('ZREM', KEYS[2], ARGV[i])
|
||||
moved = moved + 1
|
||||
end
|
||||
end
|
||||
return moved
|
||||
`;
|
||||
|
||||
@Injectable()
|
||||
export class AuctionBidArchiveService {
|
||||
private readonly logger = new Logger(AuctionBidArchiveService.name);
|
||||
|
||||
constructor(
|
||||
private readonly database: ConnectionService,
|
||||
private readonly redis: AuctionRedisService,
|
||||
) {}
|
||||
|
||||
public async persistPendingBids(limit = 200): Promise<number> {
|
||||
const client = this.redis.raw();
|
||||
const reply = await client.sendCommand([
|
||||
'ZRANGE',
|
||||
AUCTION_BID_ARCHIVE_QUEUE_KEY,
|
||||
'0',
|
||||
String(limit - 1),
|
||||
]);
|
||||
const ids = Array.isArray(reply) ? reply.map(String) : [];
|
||||
if (!ids.length) return 0;
|
||||
const values = await client.sendCommand<Array<string | null>>([
|
||||
'HMGET',
|
||||
AUCTION_BID_ARCHIVE_PAYLOADS_KEY,
|
||||
...ids,
|
||||
]);
|
||||
const valid: Array<{ event: AuctionBidRecord; raw: string }> = [];
|
||||
const invalid: Array<{ id: string; raw: string | null; error: string }> =
|
||||
[];
|
||||
for (let index = 0; index < ids.length; index++) {
|
||||
const raw = values[index] ?? null;
|
||||
try {
|
||||
valid.push({ event: parseBidArchiveEvent(ids[index], raw), raw: raw! });
|
||||
} catch (error) {
|
||||
invalid.push({
|
||||
id: ids[index],
|
||||
raw,
|
||||
error: String(error).slice(0, 2000),
|
||||
});
|
||||
}
|
||||
}
|
||||
if (invalid.length) {
|
||||
const now = Date.now();
|
||||
const moved = await client.sendCommand<number>([
|
||||
'EVAL',
|
||||
QUARANTINE_BID_ARCHIVE_SCRIPT,
|
||||
'4',
|
||||
AUCTION_BID_ARCHIVE_PAYLOADS_KEY,
|
||||
AUCTION_BID_ARCHIVE_QUEUE_KEY,
|
||||
AUCTION_BID_ARCHIVE_DEAD_LETTER_PAYLOADS_KEY,
|
||||
AUCTION_BID_ARCHIVE_DEAD_LETTER_QUEUE_KEY,
|
||||
String(now),
|
||||
...invalid.flatMap(({ id, raw, error }) => [
|
||||
id,
|
||||
raw === null ? '0' : '1',
|
||||
raw ?? '',
|
||||
JSON.stringify({
|
||||
id,
|
||||
rawPayload: raw,
|
||||
error,
|
||||
quarantinedAtTimestampMS: now,
|
||||
}),
|
||||
]),
|
||||
]);
|
||||
if (moved > 0)
|
||||
this.logger.warn(`Quarantined ${moved} invalid bid archive events.`);
|
||||
}
|
||||
if (valid.length) {
|
||||
const model = await this.database.getModel('auctionBidRecord');
|
||||
// The deterministic _id is the dedupe key, including after a crash between
|
||||
// Mongo acknowledgement and Redis cleanup. Never trim unpersisted events.
|
||||
const result = await model.bulkWrite(
|
||||
valid.map(({ event }) => ({
|
||||
updateOne: {
|
||||
filter: { _id: event._id },
|
||||
update: { $setOnInsert: event },
|
||||
upsert: true,
|
||||
},
|
||||
})),
|
||||
{ ordered: false, throwOnValidationError: true },
|
||||
);
|
||||
// A partial/ambiguous write leaves valid entries queued. Replaying the
|
||||
// upserts is safe; assuming that a resolved bulkWrite saved all is not.
|
||||
if (result.matchedCount + result.upsertedCount !== valid.length) {
|
||||
throw new Error(
|
||||
'Bid archive batch was not fully acknowledged by MongoDB.',
|
||||
);
|
||||
}
|
||||
await client.sendCommand([
|
||||
'EVAL',
|
||||
"for i = 1, #ARGV, 2 do if redis.call('HGET', KEYS[1], ARGV[i]) == ARGV[i+1] then redis.call('HDEL', KEYS[1], ARGV[i]); redis.call('ZREM', KEYS[2], ARGV[i]) end end return 1",
|
||||
'2',
|
||||
AUCTION_BID_ARCHIVE_PAYLOADS_KEY,
|
||||
AUCTION_BID_ARCHIVE_QUEUE_KEY,
|
||||
...valid.flatMap(({ event, raw }) => [event._id, raw]),
|
||||
]);
|
||||
}
|
||||
return valid.length;
|
||||
}
|
||||
|
||||
public async list(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
afterRevision = -1,
|
||||
limit = 100,
|
||||
) {
|
||||
if (
|
||||
!Number.isSafeInteger(afterRevision) ||
|
||||
afterRevision < -1 ||
|
||||
!Number.isSafeInteger(limit) ||
|
||||
limit < 1 ||
|
||||
limit > 200
|
||||
) {
|
||||
throw new BadRequestException('Invalid bid history cursor or limit.');
|
||||
}
|
||||
const AuctionModel = await this.database.getModel('auction');
|
||||
const auction = await AuctionModel.findOne({ matchId })
|
||||
.select({ auctionLifecycleId: 1 })
|
||||
.lean()
|
||||
.exec();
|
||||
if (!auction) throw new NotFoundException('Auction not found.');
|
||||
const prefix = `${matchId.toString()}:${auction.auctionLifecycleId}:`;
|
||||
const model = await this.database.getModel('auctionBidRecord');
|
||||
// The built-in _id index supports ordered pagination without an additional
|
||||
// production index or an unbounded array inside an Auction document.
|
||||
const items = await model
|
||||
.find({
|
||||
_id: {
|
||||
$gt:
|
||||
afterRevision < 0
|
||||
? prefix
|
||||
: prefix + String(afterRevision).padStart(16, '0'),
|
||||
$lt: prefix + '\uffff',
|
||||
},
|
||||
})
|
||||
.sort({ _id: 1 })
|
||||
.limit(limit + 1)
|
||||
.lean()
|
||||
.exec();
|
||||
const hasMore = items.length > limit;
|
||||
if (hasMore) items.pop();
|
||||
return {
|
||||
items,
|
||||
hasMore,
|
||||
nextRevision: items.at(-1)?.revision ?? afterRevision,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
function parseBidArchiveEvent(
|
||||
id: string,
|
||||
raw: string | null,
|
||||
): AuctionBidRecord {
|
||||
if (raw === null) throw new Error('Missing bid archive payload.');
|
||||
const value: unknown = JSON.parse(raw);
|
||||
if (!value || typeof value !== 'object' || Array.isArray(value)) {
|
||||
throw new Error('Bid archive payload must be an object.');
|
||||
}
|
||||
const event = value as Record<string, unknown>;
|
||||
const string = (field: string): string => {
|
||||
const value = event[field];
|
||||
if (typeof value !== 'string' || !value.trim()) {
|
||||
throw new Error(`Invalid bid archive ${field}.`);
|
||||
}
|
||||
return value;
|
||||
};
|
||||
const integer = (field: string, minimum = 0): number => {
|
||||
const value = event[field];
|
||||
if (
|
||||
typeof value !== 'number' ||
|
||||
!Number.isSafeInteger(value) ||
|
||||
value < minimum
|
||||
) {
|
||||
throw new Error(`Invalid bid archive ${field}.`);
|
||||
}
|
||||
return value;
|
||||
};
|
||||
const objectId = (field: string): mongoose.Types.ObjectId => {
|
||||
const value = string(field);
|
||||
if (!mongoose.isObjectIdOrHexString(value)) {
|
||||
throw new Error(`Invalid bid archive ${field}.`);
|
||||
}
|
||||
return new mongoose.Types.ObjectId(value);
|
||||
};
|
||||
const matchId = objectId('matchId');
|
||||
const auctionLifecycleId = string('auctionLifecycleId');
|
||||
const revision = integer('revision');
|
||||
const expectedId = `${matchId.toString()}:${auctionLifecycleId}:${String(revision).padStart(16, '0')}`;
|
||||
if (event._id !== id || id !== expectedId) {
|
||||
throw new Error('Bid archive identity does not match its payload.');
|
||||
}
|
||||
return {
|
||||
_id: id,
|
||||
matchId,
|
||||
auctionLifecycleId,
|
||||
revision,
|
||||
bidRequestId: string('bidRequestId'),
|
||||
bidderUserId: objectId('bidderUserId'),
|
||||
bidderTeamIndex: integer('bidderTeamIndex', 1),
|
||||
bidPointAmount: integer('bidPointAmount'),
|
||||
bidPlacedAtTimestampMS: integer('bidPlacedAtTimestampMS'),
|
||||
...(event.playerUserId !== undefined
|
||||
? { playerUserId: objectId('playerUserId') }
|
||||
: {}),
|
||||
// Pre-upgrade rounds have no Redis round ID; the bid Lua records ''.
|
||||
...(event.bidRoundId !== undefined && event.bidRoundId !== ''
|
||||
? { bidRoundId: string('bidRoundId') }
|
||||
: {}),
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
/**
|
||||
* 계정 지급 전에는 화면에서 선택한 팀으로 입찰하는 임시 운영 모드가 기본이다.
|
||||
* 계정 지급 후 AUCTION_REQUIRE_CAPTAIN_AUTH=true로 로그인·팀장 검증을 복구한다.
|
||||
*/
|
||||
export function isAuctionCaptainAuthRequired(): boolean {
|
||||
return (
|
||||
process.env.AUCTION_REQUIRE_CAPTAIN_AUTH?.trim().toLowerCase() === 'true'
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,154 @@
|
||||
import { NotFoundException } from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import { AuctionService } from './auction.service';
|
||||
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
|
||||
function sessionQuery<T>(value: T) {
|
||||
return { session: async () => value };
|
||||
}
|
||||
|
||||
function fixture(options: {
|
||||
auction: Record<string, unknown> | null;
|
||||
match: Record<string, unknown>;
|
||||
failRedisCleanup?: boolean;
|
||||
}) {
|
||||
const session = {
|
||||
startTransaction: jest.fn(),
|
||||
commitTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
abortTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
endSession: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const deleteMany = jest.fn(() => sessionQuery(undefined));
|
||||
const models: Record<string, unknown> = {
|
||||
auction: { findOne: () => sessionQuery(options.auction) },
|
||||
auctionHistory: { deleteMany },
|
||||
auctionSideEffectApplication: { deleteMany },
|
||||
match: { findById: () => sessionQuery(options.match) },
|
||||
};
|
||||
const redisCommands: string[][] = [];
|
||||
const sendCommand = jest.fn(async (command: string[]) => {
|
||||
redisCommands.push(command);
|
||||
if (command[0] === 'EVAL' && options.failRedisCleanup)
|
||||
throw new Error('redis unavailable');
|
||||
return command[0] === 'SCAN' ? ['0', []] : 1;
|
||||
});
|
||||
const service = new AuctionService(
|
||||
{
|
||||
getModel: async (name: string) => models[name],
|
||||
createSession: async () => session,
|
||||
} as never,
|
||||
{} as never,
|
||||
{ releaseFromMatch: jest.fn().mockResolvedValue(undefined) } as never,
|
||||
{ cancelPolling: jest.fn().mockResolvedValue(undefined) } as never,
|
||||
{
|
||||
acquireTokenLock: async () => true,
|
||||
releaseTokenLock: async () => true,
|
||||
raw: () => ({ sendCommand }),
|
||||
} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
return { service, session, redisCommands };
|
||||
}
|
||||
|
||||
function liveMatch(): Record<string, unknown> {
|
||||
return {
|
||||
communityId,
|
||||
status: 'team-built',
|
||||
teams: [],
|
||||
tournamentCodeIds: [],
|
||||
gameSchedule: [],
|
||||
participants: [],
|
||||
save: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
}
|
||||
|
||||
function redisAuction() {
|
||||
return {
|
||||
_id: new mongoose.Types.ObjectId(),
|
||||
auctionEngineVersion: 'redis-v1',
|
||||
auctionLifecycleId: 'life',
|
||||
deleteOne: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
}
|
||||
|
||||
it('records the cancelled lifecycle and still succeeds when Redis cleanup fails', async () => {
|
||||
const match = liveMatch();
|
||||
const f = fixture({
|
||||
auction: redisAuction(),
|
||||
match,
|
||||
failRedisCleanup: true,
|
||||
});
|
||||
await expect(
|
||||
f.service.reset({
|
||||
matchId,
|
||||
communityId,
|
||||
clientObservedAuctionLifecycleId: 'life',
|
||||
}),
|
||||
).resolves.toBeUndefined();
|
||||
expect(f.session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(match.lastCancelledAuctionLifecycleId).toBe('life');
|
||||
expect(match.status).toBe('recruiting');
|
||||
});
|
||||
|
||||
it('answers a retransmitted cancellation and durably schedules Redis cleanup', async () => {
|
||||
const match = { ...liveMatch(), lastCancelledAuctionLifecycleId: 'life' };
|
||||
const f = fixture({ auction: null, match });
|
||||
await expect(
|
||||
f.service.reset({
|
||||
matchId,
|
||||
communityId,
|
||||
clientObservedAuctionLifecycleId: 'life',
|
||||
}),
|
||||
).resolves.toBeUndefined();
|
||||
expect(match).toMatchObject({
|
||||
auctionCancellationCleanupPending: true,
|
||||
auctionCancellationCleanupRetryAt: expect.any(Date),
|
||||
});
|
||||
expect(f.redisCommands).toEqual([]);
|
||||
});
|
||||
|
||||
it('preserves a committed cancellation even if its lock renewal fails before returning', async () => {
|
||||
jest.useFakeTimers();
|
||||
try {
|
||||
const match = liveMatch();
|
||||
const f = fixture({ auction: redisAuction(), match });
|
||||
f.session.commitTransaction.mockImplementation(async () => {
|
||||
await jest.advanceTimersByTimeAsync(10000);
|
||||
});
|
||||
await expect(
|
||||
f.service.reset({
|
||||
matchId,
|
||||
communityId,
|
||||
clientObservedAuctionLifecycleId: 'life',
|
||||
}),
|
||||
).resolves.toBeUndefined();
|
||||
expect(match.auctionCancellationCleanupPending).toBe(true);
|
||||
expect(f.session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
} finally {
|
||||
jest.useRealTimers();
|
||||
}
|
||||
});
|
||||
|
||||
it('keeps 404 for a missing auction that was not cancelled with this lifecycle', async () => {
|
||||
for (const [observed, recorded] of [
|
||||
['other', 'life'],
|
||||
[undefined, 'life'],
|
||||
['life', undefined],
|
||||
] as const) {
|
||||
const f = fixture({
|
||||
auction: null,
|
||||
match: { ...liveMatch(), lastCancelledAuctionLifecycleId: recorded },
|
||||
});
|
||||
await expect(
|
||||
f.service.reset({
|
||||
matchId,
|
||||
communityId,
|
||||
clientObservedAuctionLifecycleId: observed,
|
||||
}),
|
||||
).rejects.toBeInstanceOf(NotFoundException);
|
||||
expect(f.session.abortTransaction).toHaveBeenCalled();
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,156 @@
|
||||
import mongoose from 'mongoose';
|
||||
import { BadRequestException } from '@nestjs/common';
|
||||
jest.mock('../auth/jwt.service', () => ({ JwtService: class JwtService {} }));
|
||||
import { AuctionGateway } from './auction.gateway';
|
||||
|
||||
function setup() {
|
||||
const appendChatMessage = jest.fn();
|
||||
const gateway = new AuctionGateway(
|
||||
{ appendChatMessage } as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
const broadcast = jest.fn();
|
||||
const to = jest.fn().mockReturnValue({ emit: broadcast });
|
||||
(gateway as unknown as { server: unknown }).server = {
|
||||
to,
|
||||
};
|
||||
const socket = {
|
||||
data: {
|
||||
matchId: new mongoose.Types.ObjectId().toString(),
|
||||
user: {
|
||||
_id: new mongoose.Types.ObjectId(),
|
||||
role: 'admin',
|
||||
riotAccounts: [],
|
||||
kakaoTalkNickname: '운영자',
|
||||
},
|
||||
},
|
||||
emit: jest.fn(),
|
||||
};
|
||||
return { gateway, appendChatMessage, broadcast, socket, to };
|
||||
}
|
||||
|
||||
describe('Auction chat delivery', () => {
|
||||
const payload = {
|
||||
message: '준비해 주세요',
|
||||
clientMessageId: '0589e8a4-bccd-4ccd-a3ae-28f117401e79',
|
||||
};
|
||||
it('acknowledges only after saving and assigns the operator role from the socket user', async () => {
|
||||
const { gateway, appendChatMessage, broadcast, socket } = setup();
|
||||
const message = { id: 'saved', ...payload, sentAt: new Date() };
|
||||
let finish!: (result: unknown) => void;
|
||||
appendChatMessage.mockReturnValue(
|
||||
new Promise((resolve) => {
|
||||
finish = resolve;
|
||||
}),
|
||||
);
|
||||
const ack = jest.fn();
|
||||
const pending = gateway.handleChatMessage(socket as never, payload, ack);
|
||||
expect(ack).not.toHaveBeenCalled();
|
||||
expect(broadcast).not.toHaveBeenCalled();
|
||||
finish({ message, created: true });
|
||||
await pending;
|
||||
expect(appendChatMessage).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
clientMessageId: payload.clientMessageId,
|
||||
senderRole: 'operator',
|
||||
displayName: '운영자',
|
||||
}),
|
||||
);
|
||||
expect(ack).toHaveBeenCalledWith({
|
||||
ok: true,
|
||||
message: expect.objectContaining({ id: 'saved' }),
|
||||
});
|
||||
expect(broadcast).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('acknowledges a retry without broadcasting a duplicate', async () => {
|
||||
const { gateway, appendChatMessage, broadcast, socket } = setup();
|
||||
appendChatMessage.mockResolvedValue({
|
||||
message: { id: 'saved' },
|
||||
created: false,
|
||||
});
|
||||
const ack = jest.fn();
|
||||
await gateway.handleChatMessage(socket as never, payload, ack);
|
||||
expect(ack).toHaveBeenCalledWith({ ok: true, message: { id: 'saved' } });
|
||||
expect(broadcast).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('returns rejection to the requesting composer without reporting success', async () => {
|
||||
const { gateway, appendChatMessage, broadcast, socket } = setup();
|
||||
appendChatMessage.mockRejectedValue(
|
||||
new BadRequestException('Chat message is required.'),
|
||||
);
|
||||
const ack = jest.fn();
|
||||
await gateway.handleChatMessage(socket as never, payload, ack);
|
||||
expect(ack).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
ok: false,
|
||||
message: 'Chat message is required.',
|
||||
}),
|
||||
);
|
||||
expect(broadcast).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Auction live reactions', () => {
|
||||
it('broadcasts to the joined room with the server-resolved name, without saving a chat message', () => {
|
||||
const { gateway, appendChatMessage, broadcast, socket, to } = setup();
|
||||
const ack = jest.fn();
|
||||
gateway.handleChatReaction(socket as never, { kind: 'clap' }, ack);
|
||||
expect(to).toHaveBeenCalledWith(socket.data.matchId);
|
||||
expect(broadcast).toHaveBeenCalledWith(
|
||||
'chat-reaction',
|
||||
expect.objectContaining({
|
||||
id: expect.any(String),
|
||||
kind: 'clap',
|
||||
displayName: '운영자',
|
||||
userId: socket.data.user._id.toString(),
|
||||
}),
|
||||
);
|
||||
expect(ack).toHaveBeenCalledWith({
|
||||
ok: true,
|
||||
reaction: broadcast.mock.calls[0][1],
|
||||
});
|
||||
expect(appendChatMessage).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('rejects unjoined clients and arbitrary reaction values', () => {
|
||||
const { gateway, broadcast, socket } = setup();
|
||||
const ack = jest.fn();
|
||||
gateway.handleChatReaction({ data: {} } as never, { kind: 'heart' }, ack);
|
||||
expect(ack).toHaveBeenLastCalledWith({ ok: false, code: 'NOT_JOINED' });
|
||||
for (const kind of ['__proto__', 'not-supported', 1, null]) {
|
||||
gateway.handleChatReaction(socket as never, { kind }, ack);
|
||||
expect(ack).toHaveBeenLastCalledWith({
|
||||
ok: false,
|
||||
code: 'INVALID_REACTION',
|
||||
});
|
||||
}
|
||||
expect(broadcast).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('throttles bursts, then accepts the next reaction after the interval', () => {
|
||||
const { gateway, broadcast, socket } = setup();
|
||||
const clock = jest.spyOn(Date, 'now').mockReturnValue(1000);
|
||||
const ack = jest.fn();
|
||||
try {
|
||||
gateway.handleChatReaction(socket as never, { kind: 'heart' }, ack);
|
||||
gateway.handleChatReaction(socket as never, { kind: 'heart' }, ack);
|
||||
expect(ack).toHaveBeenLastCalledWith({
|
||||
ok: false,
|
||||
code: 'REACTION_RATE_LIMITED',
|
||||
});
|
||||
expect(broadcast).toHaveBeenCalledTimes(1);
|
||||
clock.mockReturnValue(1400);
|
||||
gateway.handleChatReaction(socket as never, { kind: 'celebrate' }, ack);
|
||||
expect(broadcast).toHaveBeenCalledTimes(2);
|
||||
} finally {
|
||||
clock.mockRestore();
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,607 @@
|
||||
import mongoose from 'mongoose';
|
||||
import { AuctionService } from './auction.service';
|
||||
import {
|
||||
AuctionDurabilityScheduler,
|
||||
buildAuctionProjectionGuardedUpdate,
|
||||
type AuctionDurabilityPayload,
|
||||
} from './auction-durability.scheduler';
|
||||
import { AuctionDeadlineScheduler } from './auction-deadline.scheduler';
|
||||
import { AuctionLifecycleLock } from './auction-lifecycle-lock';
|
||||
|
||||
const query = <T>(value: T) => ({
|
||||
select() {
|
||||
return this;
|
||||
},
|
||||
session() {
|
||||
return this;
|
||||
},
|
||||
lean() {
|
||||
return this;
|
||||
},
|
||||
exec: async () => value,
|
||||
});
|
||||
const session = () => ({
|
||||
startTransaction: jest.fn(),
|
||||
commitTransaction: jest.fn(),
|
||||
abortTransaction: jest.fn(),
|
||||
endSession: jest.fn(),
|
||||
});
|
||||
const state = {
|
||||
auctionLifecycleId: 'life',
|
||||
revision: 12,
|
||||
phase: 'presenting',
|
||||
currentAuctionHistorySequence: 7,
|
||||
currentAuctionPlayerOrderIndex: 0,
|
||||
currentAuctionRound: 1,
|
||||
auctionTeams: [],
|
||||
auctionPlayerOrder: [],
|
||||
passedAuctionPlayerQueue: [],
|
||||
currentHighestBidPointAmount: 0,
|
||||
currentHighestBidderTeamIndex: -1,
|
||||
auctionCompletedAtTimestampMS: 0,
|
||||
currentBidRoundDeadlineTimestampMS: 0,
|
||||
};
|
||||
|
||||
beforeEach(() => {
|
||||
jest
|
||||
.spyOn(AuctionLifecycleLock.prototype, 'run')
|
||||
.mockImplementation(async (_id, work) => work());
|
||||
});
|
||||
afterEach(() => jest.restoreAllMocks());
|
||||
|
||||
function matches(
|
||||
document: Record<string, unknown>,
|
||||
filter: Record<string, unknown>,
|
||||
): boolean {
|
||||
return Object.entries(filter).every(([key, value]) => {
|
||||
if (key === '$or')
|
||||
return (value as Record<string, unknown>[]).some((alternative) =>
|
||||
matches(document, alternative),
|
||||
);
|
||||
if (value && typeof value === 'object') {
|
||||
return Object.entries(value).every(([operator, limit]) => {
|
||||
if (operator === '$exists')
|
||||
return (document[key] !== undefined) === limit;
|
||||
if (operator === '$lt') return Number(document[key]) < Number(limit);
|
||||
if (operator === '$lte') return Number(document[key]) <= Number(limit);
|
||||
return false;
|
||||
});
|
||||
}
|
||||
return document[key] === value;
|
||||
});
|
||||
}
|
||||
function update(
|
||||
document: Record<string, unknown>,
|
||||
mutation: Record<string, Record<string, unknown>>,
|
||||
) {
|
||||
Object.assign(document, mutation.$set);
|
||||
for (const [key, amount] of Object.entries(mutation.$inc ?? {}))
|
||||
document[key] = Number(document[key] ?? 0) + Number(amount);
|
||||
for (const key of Object.keys(mutation.$unset ?? {})) delete document[key];
|
||||
}
|
||||
|
||||
function sideEffectFixture(withReader = false) {
|
||||
const projection: Record<string, unknown> = {
|
||||
_id: 'auction',
|
||||
auctionLifecycleId: 'life',
|
||||
revision: 9,
|
||||
matchSideEffectRevision: 0,
|
||||
};
|
||||
const application: Record<string, unknown> = {};
|
||||
const payload: AuctionDurabilityPayload = {
|
||||
auctionId: 'auction',
|
||||
matchId: 'match',
|
||||
auctionLifecycleId: 'life',
|
||||
auctionStateTransitionId: 'complete',
|
||||
auctionActionType: 'complete',
|
||||
auctionHistorySequence: 10,
|
||||
revision: 10,
|
||||
snapshotBefore: {},
|
||||
historyMutation: { type: 'append' },
|
||||
matchSideEffectMutation: { type: 'syncMatchTeamsAfterComplete' },
|
||||
afterAuctionMongoProjection: {
|
||||
auctionLifecycleId: 'life',
|
||||
revision: 10,
|
||||
phase: 'complete',
|
||||
matchSideEffectRevision: 1,
|
||||
matchSideEffectStatus: 'pending',
|
||||
matchSideEffectTransitionId: 'complete',
|
||||
auctionTeams: [{ teamIndex: 1, captainUserId: 'captain', members: [] }],
|
||||
},
|
||||
};
|
||||
const AuctionModel = {
|
||||
findById: () => query({ ...projection }),
|
||||
updateOne: (
|
||||
filter: Record<string, unknown>,
|
||||
mutation: Record<string, Record<string, unknown>>,
|
||||
) => {
|
||||
const matchedCount = Number(matches(projection, filter));
|
||||
if (matchedCount) update(projection, mutation);
|
||||
return query({ matchedCount });
|
||||
},
|
||||
findOneAndUpdate: (
|
||||
filter: Record<string, unknown>,
|
||||
mutation: Record<string, Record<string, unknown>>,
|
||||
) => {
|
||||
if (!matches(projection, filter)) return query(null);
|
||||
update(projection, mutation);
|
||||
return query({ ...projection });
|
||||
},
|
||||
};
|
||||
const ApplicationModel = {
|
||||
findOne: () => query({ ...application }),
|
||||
updateOne: (
|
||||
filter: Record<string, unknown>,
|
||||
mutation: Record<string, Record<string, unknown>>,
|
||||
) => {
|
||||
if (mutation.$setOnInsert) {
|
||||
if (!application.state)
|
||||
Object.assign(application, mutation.$setOnInsert);
|
||||
return query({ matchedCount: 1 });
|
||||
}
|
||||
const matchedCount = Number(matches(application, filter));
|
||||
if (matchedCount) update(application, mutation);
|
||||
return query({ matchedCount });
|
||||
},
|
||||
};
|
||||
const match = {
|
||||
participants: [],
|
||||
teams: [],
|
||||
save: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const historyFindOne = jest.fn().mockReturnValue(query(null));
|
||||
const historyUpdateOne = jest
|
||||
.fn()
|
||||
.mockReturnValue(query({ matchedCount: 1 }));
|
||||
const models: Record<string, unknown> = {
|
||||
auction: AuctionModel,
|
||||
auctionHistory: {
|
||||
findOne: historyFindOne,
|
||||
updateOne: historyUpdateOne,
|
||||
},
|
||||
auctionSideEffectApplication: ApplicationModel,
|
||||
match: {
|
||||
findById: () => ({ ...query(match), session: async () => match }),
|
||||
},
|
||||
};
|
||||
const reserveForMatch = jest
|
||||
.fn()
|
||||
.mockRejectedValueOnce(new Error('temporary reservation error'))
|
||||
.mockResolvedValue(match);
|
||||
const scheduleInitialPoll = jest.fn().mockResolvedValue(undefined);
|
||||
const releaseFromMatch = jest.fn().mockResolvedValue(undefined);
|
||||
const cancelPolling = jest.fn().mockResolvedValue(undefined);
|
||||
let queued = true;
|
||||
const sendCommand = jest.fn(async (command: string[]) => {
|
||||
if (command[0] === 'ZRANGEBYSCORE') return queued ? ['payload'] : [];
|
||||
if (command[0] === 'HGETALL')
|
||||
return { payloadJson: JSON.stringify(payload) };
|
||||
if (command[0] === 'DEL') queued = false;
|
||||
if (command[0] === 'HINCRBY') return 1;
|
||||
return 1;
|
||||
});
|
||||
const scheduler = new AuctionDurabilityScheduler(
|
||||
{
|
||||
getModel: async (name: string) => models[name],
|
||||
createSession: async () => session(),
|
||||
} as never,
|
||||
{
|
||||
getCurrentRedisTimestampMS: async () => 10000,
|
||||
raw: () => ({ sendCommand }),
|
||||
} as never,
|
||||
{ reserveForMatch, releaseFromMatch } as never,
|
||||
{ scheduleInitialPoll, cancelPolling } as never,
|
||||
undefined,
|
||||
undefined,
|
||||
withReader
|
||||
? ({
|
||||
readAuctionStateView: async () => ({
|
||||
auctionLifecycleId: 'life',
|
||||
phase: payload.afterAuctionMongoProjection.phase,
|
||||
matchSideEffectTransitionId: 'complete',
|
||||
}),
|
||||
} as never)
|
||||
: undefined,
|
||||
);
|
||||
return {
|
||||
scheduler,
|
||||
payload,
|
||||
projection,
|
||||
application,
|
||||
reserveForMatch,
|
||||
scheduleInitialPoll,
|
||||
sendCommand,
|
||||
match,
|
||||
historyFindOne,
|
||||
historyUpdateOne,
|
||||
releaseFromMatch,
|
||||
cancelPolling,
|
||||
};
|
||||
}
|
||||
|
||||
it('retries failed completion work with the current generation and only then deletes the payload', async () => {
|
||||
const f = sideEffectFixture();
|
||||
expect(await f.scheduler.processDueDurabilityPayloads(20)).toMatchObject({
|
||||
failed: 1,
|
||||
});
|
||||
expect(f.projection.matchSideEffectStatus).toBe('failed');
|
||||
expect(await f.scheduler.processDueDurabilityPayloads(20)).toMatchObject({
|
||||
applied: 1,
|
||||
});
|
||||
expect(f.reserveForMatch).toHaveBeenCalledTimes(2);
|
||||
expect(f.scheduleInitialPoll).toHaveBeenCalledTimes(1);
|
||||
expect(f.application.state).toBe('completed');
|
||||
expect(f.projection.matchSideEffectStatus).toBe('completed');
|
||||
expect(f.projection.matchSideEffectRevision).toBe(5);
|
||||
expect(f.sendCommand).toHaveBeenCalledWith(['DEL', 'payload']);
|
||||
});
|
||||
|
||||
it('keeps an outbox payload while another worker owns its side-effect lease', async () => {
|
||||
const f = sideEffectFixture();
|
||||
Object.assign(f.application, {
|
||||
auctionId: 'auction',
|
||||
auctionStateTransitionId: 'complete',
|
||||
sideEffectType: 'syncMatchTeamsAfterComplete',
|
||||
state: 'processing',
|
||||
processingOwnerToken: 'other',
|
||||
processingLeaseExpiresAtTimestampMS: 50000,
|
||||
});
|
||||
expect(await f.scheduler.processDueDurabilityPayloads(20)).toEqual({
|
||||
applied: 0,
|
||||
failed: 0,
|
||||
skipped: 1,
|
||||
});
|
||||
expect(f.sendCommand).not.toHaveBeenCalledWith(['DEL', 'payload']);
|
||||
expect(
|
||||
f.sendCommand.mock.calls.some(([command]) => command[0] === 'HINCRBY'),
|
||||
).toBe(false);
|
||||
expect(f.reserveForMatch).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('recovers side effects when a later ordinary projection was persisted first', async () => {
|
||||
const f = sideEffectFixture(true);
|
||||
f.reserveForMatch.mockReset().mockResolvedValue(undefined);
|
||||
Object.assign(f.projection, { revision: 12 });
|
||||
await f.scheduler.applyDurabilityPayload(f.payload);
|
||||
expect(f.reserveForMatch).toHaveBeenCalledTimes(1);
|
||||
expect(f.projection.revision).toBe(12);
|
||||
expect(f.projection.matchSideEffectTransitionId).toBe('complete');
|
||||
expect(f.projection.matchSideEffectStatus).toBe('completed');
|
||||
});
|
||||
|
||||
it('still cleans up completed Match state when a second undo invalidates the first undo history', async () => {
|
||||
const f = sideEffectFixture(true);
|
||||
Object.assign(f.projection, { revision: 12 });
|
||||
Object.assign(f.payload, {
|
||||
matchSideEffectMutation: { type: 'undoCompletedAuctionSideEffects' },
|
||||
});
|
||||
f.payload.afterAuctionMongoProjection.phase = 'presenting';
|
||||
Object.assign(f.match, {
|
||||
teams: [{ teamIndex: 1 }],
|
||||
teamBuiltAt: new Date(),
|
||||
tournamentCodeIds: ['code'],
|
||||
gameSchedule: [{}],
|
||||
});
|
||||
f.historyFindOne.mockReturnValue(
|
||||
query({
|
||||
sequence: 12,
|
||||
historyMutation: {
|
||||
type: 'deleteAfterSequenceAndAppendUndo',
|
||||
targetHistorySequence: 2,
|
||||
},
|
||||
}),
|
||||
);
|
||||
await f.scheduler.applyDurabilityPayload(f.payload);
|
||||
expect(f.historyUpdateOne).not.toHaveBeenCalled();
|
||||
expect(f.releaseFromMatch).toHaveBeenCalledTimes(1);
|
||||
expect(f.cancelPolling).toHaveBeenCalledTimes(1);
|
||||
expect(f.match).toMatchObject({
|
||||
teams: [],
|
||||
teamBuiltAt: undefined,
|
||||
tournamentCodeIds: [],
|
||||
gameSchedule: [],
|
||||
});
|
||||
expect(f.projection.matchSideEffectStatus).toBe('completed');
|
||||
});
|
||||
|
||||
it('does not let a superseded side effect overwrite the newer generation', async () => {
|
||||
const f = sideEffectFixture();
|
||||
Object.assign(f.projection, {
|
||||
revision: 12,
|
||||
matchSideEffectTransitionId: 'undo',
|
||||
matchSideEffectRevision: 6,
|
||||
});
|
||||
await f.scheduler.applyDurabilityPayload(f.payload);
|
||||
expect(f.reserveForMatch).not.toHaveBeenCalled();
|
||||
expect(f.projection.matchSideEffectTransitionId).toBe('undo');
|
||||
});
|
||||
|
||||
it('removes obsolete projection fields both from Mongo updates and subsequent undo snapshots', () => {
|
||||
const service = new AuctionService(
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
const internal = service as unknown as {
|
||||
buildAuctionMongoProjectionFromState(
|
||||
auction: unknown,
|
||||
state: Record<string, unknown>,
|
||||
): Record<string, unknown>;
|
||||
buildAuctionSnapshotFromRedisState(
|
||||
auction: unknown,
|
||||
state: Record<string, unknown>,
|
||||
): Record<string, unknown>;
|
||||
};
|
||||
const old = {
|
||||
_id: new mongoose.Types.ObjectId(),
|
||||
matchId: new mongoose.Types.ObjectId(),
|
||||
completedAt: new Date(),
|
||||
auctionCompletedAtTimestampMS: 100,
|
||||
currentHighestBidderTeamIndex: 2,
|
||||
currentBidderTeamIndex: 2,
|
||||
};
|
||||
const projection = internal.buildAuctionMongoProjectionFromState(old, state);
|
||||
const mutation = buildAuctionProjectionGuardedUpdate({
|
||||
auctionId: old._id,
|
||||
auctionLifecycleId: 'life',
|
||||
revision: 12,
|
||||
afterAuctionMongoProjection: projection,
|
||||
} as AuctionDurabilityPayload).update;
|
||||
const stored = { ...old } as Record<string, unknown>;
|
||||
update(stored, mutation);
|
||||
const snapshot = internal.buildAuctionSnapshotFromRedisState(old, state);
|
||||
for (const record of [stored, snapshot]) {
|
||||
expect(record).not.toHaveProperty('completedAt');
|
||||
expect(record).not.toHaveProperty('currentHighestBidderTeamIndex');
|
||||
expect(record.phase).toBe('presenting');
|
||||
}
|
||||
});
|
||||
|
||||
it('applies delayed undo history cleanup without deleting newer branch entries or rolling back projection', async () => {
|
||||
const deleteMany = jest.fn().mockReturnValue(query({}));
|
||||
const updateOne = jest.fn().mockReturnValue(query({}));
|
||||
const projectionUpdate = jest.fn();
|
||||
const models: Record<string, unknown> = {
|
||||
auction: {
|
||||
findById: () => query({ auctionLifecycleId: 'life', revision: 12 }),
|
||||
updateOne: projectionUpdate,
|
||||
},
|
||||
auctionHistory: { findOne: () => query(null), deleteMany, updateOne },
|
||||
auctionSideEffectApplication: {},
|
||||
};
|
||||
const scheduler = new AuctionDurabilityScheduler(
|
||||
{
|
||||
getModel: async (name: string) => models[name],
|
||||
createSession: async () => null,
|
||||
} as never,
|
||||
{} as never,
|
||||
);
|
||||
await scheduler.applyDurabilityPayload({
|
||||
auctionId: 'auction',
|
||||
matchId: 'match',
|
||||
auctionStateTransitionId: 'undo',
|
||||
auctionLifecycleId: 'life',
|
||||
revision: 11,
|
||||
auctionHistorySequence: 9,
|
||||
auctionActionType: 'undo',
|
||||
historyMutation: {
|
||||
type: 'deleteAfterSequenceAndAppendUndo',
|
||||
targetHistorySequence: 3,
|
||||
},
|
||||
matchSideEffectMutation: { type: 'none' },
|
||||
afterAuctionMongoProjection: {},
|
||||
snapshotBefore: {},
|
||||
} as AuctionDurabilityPayload);
|
||||
expect(deleteMany).toHaveBeenCalledWith(
|
||||
{ auctionId: 'auction', sequence: { $gt: 3, $lt: 9 } },
|
||||
{ session: null },
|
||||
);
|
||||
expect(updateOne).toHaveBeenCalledTimes(1);
|
||||
expect(projectionUpdate).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('rejects a cancellation from a prior lifecycle before deleting anything', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId(),
|
||||
communityId = new mongoose.Types.ObjectId();
|
||||
const deleteOne = jest.fn();
|
||||
const service = new AuctionService(
|
||||
{
|
||||
createSession: async () => session(),
|
||||
getModel: async () => ({
|
||||
findOne: () => ({
|
||||
session: async () => ({
|
||||
auctionEngineVersion: 'redis-v1',
|
||||
auctionLifecycleId: 'new-life',
|
||||
deleteOne,
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
await expect(
|
||||
service.reset({
|
||||
matchId,
|
||||
communityId,
|
||||
clientObservedAuctionLifecycleId: 'old-life',
|
||||
}),
|
||||
).rejects.toThrow('lifecycle has changed');
|
||||
expect(deleteOne).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('resumes startup after Mongo creation instead of returning an unfinished auction', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId(),
|
||||
communityId = new mongoose.Types.ObjectId();
|
||||
const captain = new mongoose.Types.ObjectId(),
|
||||
player = new mongoose.Types.ObjectId(),
|
||||
lateJoiner = new mongoose.Types.ObjectId();
|
||||
const auction = {
|
||||
_id: new mongoose.Types.ObjectId(),
|
||||
matchId,
|
||||
auctionLifecycleId: 'life',
|
||||
revision: 1,
|
||||
phase: 'presenting',
|
||||
startupCompleted: false,
|
||||
startAuctionRequestId: 'same-request',
|
||||
teams: [{ captainUserId: captain, members: [], teamIndex: 1 }],
|
||||
order: [{ userId: player }],
|
||||
};
|
||||
const match = {
|
||||
communityId,
|
||||
status: 'recruiting',
|
||||
participants: [captain, player, lateJoiner].map((userId) => ({
|
||||
userId,
|
||||
excluded: false,
|
||||
})),
|
||||
save: jest.fn(),
|
||||
};
|
||||
const updateOne = jest.fn();
|
||||
const historyUpdate = jest.fn();
|
||||
const models: Record<string, unknown> = {
|
||||
auction: { findOne: async () => auction, updateOne },
|
||||
match: { findById: async () => match },
|
||||
auctionHistory: { updateOne: historyUpdate },
|
||||
};
|
||||
const hydrateState = jest.fn().mockResolvedValue({ hydrated: true });
|
||||
const service = new AuctionService(
|
||||
{ getModel: async (name: string) => models[name] } as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{ hydrateState } as never,
|
||||
{} as never,
|
||||
);
|
||||
await service.start({
|
||||
matchId,
|
||||
communityId,
|
||||
startAuctionRequestId: 'same-request',
|
||||
} as never);
|
||||
expect(hydrateState).toHaveBeenCalledTimes(1);
|
||||
expect(historyUpdate).toHaveBeenCalledTimes(1);
|
||||
expect(match.save).toHaveBeenCalledTimes(1);
|
||||
expect(match.status).toBe('team-built');
|
||||
expect(auction.startupCompleted).toBe(true);
|
||||
expect(match.participants.map((entry) => entry.excluded)).toEqual([
|
||||
false,
|
||||
false,
|
||||
true,
|
||||
]);
|
||||
});
|
||||
|
||||
it('does not open bidding until interrupted startup has been completed', async () => {
|
||||
const service = new AuctionService(
|
||||
{
|
||||
getModel: async () => ({
|
||||
findOne: async () => ({
|
||||
auctionEngineVersion: 'redis-v1',
|
||||
startupCompleted: false,
|
||||
}),
|
||||
}),
|
||||
} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
await expect(
|
||||
service.openBidding(new mongoose.Types.ObjectId()),
|
||||
).rejects.toThrow('startup is not complete');
|
||||
});
|
||||
|
||||
it('uses Redis completion state to schedule cleanup despite a delayed Mongo projection', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId(),
|
||||
communityId = new mongoose.Types.ObjectId();
|
||||
const auction = {
|
||||
_id: new mongoose.Types.ObjectId(),
|
||||
matchId,
|
||||
auctionEngineVersion: 'redis-v1',
|
||||
auctionLifecycleId: 'life',
|
||||
phase: 'sold',
|
||||
revision: 9,
|
||||
};
|
||||
const snapshot = { ...state, phase: 'bidding', revision: 5 };
|
||||
const models: Record<string, unknown> = {
|
||||
auction: { findOne: () => ({ session: async () => auction }) },
|
||||
match: { findById: () => ({ session: async () => ({ communityId }) }) },
|
||||
auctionHistory: { findOne: () => query({ snapshotBefore: snapshot }) },
|
||||
};
|
||||
const applyTransition = jest.fn().mockResolvedValue({ ok: true });
|
||||
const commands = {
|
||||
reserveActionRequest: async () => ({
|
||||
reserved: true,
|
||||
actionRequestScopeKey: 'scope',
|
||||
auctionStateTransitionId: 'undo',
|
||||
observedProcessingLeaseVersion: 1,
|
||||
}),
|
||||
applyTransition,
|
||||
};
|
||||
const service = new AuctionService(
|
||||
{
|
||||
getModel: async (name: string) => models[name],
|
||||
createSession: async () => session(),
|
||||
} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
commands as never,
|
||||
{
|
||||
readAuctionStateView: async () => ({
|
||||
...state,
|
||||
phase: 'complete',
|
||||
revision: 10,
|
||||
}),
|
||||
} as never,
|
||||
);
|
||||
await service.undoTo({ matchId, communityId, sequence: 2 });
|
||||
const input = applyTransition.mock.calls[0][1] as {
|
||||
durabilityPayloadJson: string;
|
||||
};
|
||||
expect(JSON.parse(input.durabilityPayloadJson)).toMatchObject({
|
||||
matchSideEffectMutation: { type: 'undoCompletedAuctionSideEffects' },
|
||||
});
|
||||
});
|
||||
|
||||
it.each(['deadline', 'durability'])(
|
||||
'continues %s ticks when lock release fails',
|
||||
async (kind) => {
|
||||
const redis = {
|
||||
acquireTokenLock: jest.fn().mockResolvedValue(true),
|
||||
releaseTokenLock: jest
|
||||
.fn()
|
||||
.mockRejectedValue(new Error('redis disconnected')),
|
||||
};
|
||||
const scheduler =
|
||||
kind === 'deadline'
|
||||
? new AuctionDeadlineScheduler(
|
||||
redis as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
)
|
||||
: new AuctionDurabilityScheduler({} as never, redis as never);
|
||||
const work = jest.fn().mockResolvedValue({});
|
||||
Object.assign(
|
||||
scheduler,
|
||||
kind === 'deadline'
|
||||
? { processDueBidRoundDeadlines: work }
|
||||
: { processDueDurabilityPayloads: work },
|
||||
);
|
||||
const internal = scheduler as unknown as { safeTick(): Promise<void> };
|
||||
await internal.safeTick();
|
||||
await internal.safeTick();
|
||||
expect(work).toHaveBeenCalledTimes(2);
|
||||
},
|
||||
);
|
||||
@@ -88,10 +88,13 @@ export class AuctionDeadlineScheduler implements OnModuleInit, OnModuleDestroy {
|
||||
);
|
||||
} finally {
|
||||
if (leaderLockAcquired) {
|
||||
await this.auctionRedisService.releaseTokenLock(
|
||||
BID_ROUND_DEADLINE_LEADER_LOCK_KEY,
|
||||
leaderLockToken,
|
||||
);
|
||||
await this.auctionRedisService
|
||||
.releaseTokenLock(BID_ROUND_DEADLINE_LEADER_LOCK_KEY, leaderLockToken)
|
||||
.catch((error: unknown) => {
|
||||
this.logger.warn(
|
||||
`Auction deadline lock release failed: ${String(error)}`,
|
||||
);
|
||||
});
|
||||
}
|
||||
this.tickInProgress = false;
|
||||
}
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
import { AuctionLifecycleLock } from './auction-lifecycle-lock';
|
||||
import { buildAuctionProjectionUnset } from './auction-projection';
|
||||
import {
|
||||
AuctionDurabilityScheduler,
|
||||
buildAuctionHistoryUpsert,
|
||||
@@ -23,6 +25,12 @@ const payload = {
|
||||
} as const;
|
||||
|
||||
describe('auction durability projection helpers', () => {
|
||||
beforeEach(() => {
|
||||
jest
|
||||
.spyOn(AuctionLifecycleLock.prototype, 'run')
|
||||
.mockImplementation(async (_id, work) => work());
|
||||
});
|
||||
afterEach(() => jest.restoreAllMocks());
|
||||
it('builds idempotent history upsert by auction and transition id', () => {
|
||||
expect(buildAuctionHistoryUpsert(payload)).toEqual({
|
||||
updateOne: {
|
||||
@@ -59,6 +67,9 @@ describe('auction durability projection helpers', () => {
|
||||
},
|
||||
update: {
|
||||
$set: { phase: 'sold', revision: 9 },
|
||||
$unset: buildAuctionProjectionUnset(
|
||||
payload.afterAuctionMongoProjection,
|
||||
),
|
||||
},
|
||||
});
|
||||
});
|
||||
@@ -210,13 +221,68 @@ describe('auction durability projection helpers', () => {
|
||||
auctionLifecycleId: 'life-1',
|
||||
revision: { $lt: 9 },
|
||||
},
|
||||
{ $set: { phase: 'sold', revision: 9 } },
|
||||
{
|
||||
$set: { phase: 'sold', revision: 9 },
|
||||
$unset: buildAuctionProjectionUnset(
|
||||
payload.afterAuctionMongoProjection,
|
||||
),
|
||||
},
|
||||
{ session },
|
||||
);
|
||||
expect(session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(session.endSession).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('notifies history only after commit, including when state rebroadcast is disabled', async () => {
|
||||
let finishCommit!: () => void;
|
||||
const session = {
|
||||
startTransaction: jest.fn(),
|
||||
commitTransaction: jest.fn().mockImplementation(
|
||||
() =>
|
||||
new Promise<void>((resolve) => {
|
||||
finishCommit = resolve;
|
||||
}),
|
||||
),
|
||||
abortTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
endSession: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const updateOne = jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue({ upsertedCount: 1 }),
|
||||
});
|
||||
const broadcastHistoryUpdated = jest.fn();
|
||||
const scheduler = new AuctionDurabilityScheduler(
|
||||
{
|
||||
createSession: async () => session,
|
||||
getModel: async () => ({ updateOne }),
|
||||
} as never,
|
||||
{} as never,
|
||||
undefined,
|
||||
undefined,
|
||||
undefined,
|
||||
{ broadcastHistoryUpdated } as never,
|
||||
);
|
||||
const pending = scheduler.applyDurabilityPayload({
|
||||
...payload,
|
||||
shouldBroadcastState: false,
|
||||
});
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
expect(session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(broadcastHistoryUpdated).not.toHaveBeenCalled();
|
||||
finishCommit();
|
||||
await pending;
|
||||
expect(broadcastHistoryUpdated).toHaveBeenCalledWith({
|
||||
matchId: 'match-1',
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
});
|
||||
session.commitTransaction.mockRejectedValueOnce(new Error('commit failed'));
|
||||
await expect(scheduler.applyDurabilityPayload(payload)).rejects.toThrow(
|
||||
'commit failed',
|
||||
);
|
||||
expect(broadcastHistoryUpdated).toHaveBeenCalledTimes(1);
|
||||
expect(session.abortTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('broadcasts latest Redis state when durability payload requests it', async () => {
|
||||
const session = {
|
||||
abortTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
@@ -249,7 +315,7 @@ describe('auction durability projection helpers', () => {
|
||||
undefined,
|
||||
undefined,
|
||||
undefined,
|
||||
{ broadcastState } as never,
|
||||
{ broadcastState, broadcastHistoryUpdated: jest.fn() } as never,
|
||||
{ readAuctionStateView } as never,
|
||||
);
|
||||
|
||||
@@ -299,7 +365,7 @@ describe('auction durability projection helpers', () => {
|
||||
undefined,
|
||||
undefined,
|
||||
undefined,
|
||||
{ broadcastState } as never,
|
||||
{ broadcastState, broadcastHistoryUpdated: jest.fn() } as never,
|
||||
{ readAuctionStateView } as never,
|
||||
);
|
||||
|
||||
@@ -370,7 +436,7 @@ describe('auction durability projection helpers', () => {
|
||||
expect(historyDeleteMany).toHaveBeenCalledWith(
|
||||
{
|
||||
auctionId: 'auction-1',
|
||||
sequence: { $gt: 2 },
|
||||
sequence: { $gt: 2, $lt: 4 },
|
||||
},
|
||||
{ session },
|
||||
);
|
||||
@@ -391,60 +457,71 @@ describe('auction durability projection helpers', () => {
|
||||
);
|
||||
});
|
||||
|
||||
it('skips destructive history mutation for stale payloads', async () => {
|
||||
const session = {
|
||||
abortTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
commitTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
endSession: jest.fn().mockResolvedValue(undefined),
|
||||
startTransaction: jest.fn(),
|
||||
};
|
||||
const historyDeleteMany = jest.fn();
|
||||
const historyUpdateOne = jest.fn();
|
||||
const auctionUpdateOne = jest.fn().mockReturnValue({
|
||||
exec: jest.fn().mockResolvedValue({ matchedCount: 0, modifiedCount: 0 }),
|
||||
});
|
||||
const projectionExec = jest.fn().mockResolvedValue({
|
||||
auctionLifecycleId: 'life-1',
|
||||
revision: 10,
|
||||
});
|
||||
const auctionFindById = jest.fn().mockReturnValue({
|
||||
select: jest.fn().mockReturnValue({
|
||||
session: jest.fn().mockReturnValue({
|
||||
lean: jest.fn().mockReturnValue({ exec: projectionExec }),
|
||||
it.each(['life-1', 'new-life'])(
|
||||
'skips stale history changes and notifications for current lifecycle %s',
|
||||
async (auctionLifecycleId) => {
|
||||
const broadcastHistoryUpdated = jest.fn();
|
||||
const session = {
|
||||
abortTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
commitTransaction: jest.fn().mockResolvedValue(undefined),
|
||||
endSession: jest.fn().mockResolvedValue(undefined),
|
||||
startTransaction: jest.fn(),
|
||||
};
|
||||
const historyDeleteMany = jest.fn();
|
||||
const historyUpdateOne = jest.fn();
|
||||
const auctionUpdateOne = jest.fn().mockReturnValue({
|
||||
exec: jest
|
||||
.fn()
|
||||
.mockResolvedValue({ matchedCount: 0, modifiedCount: 0 }),
|
||||
});
|
||||
const projectionExec = jest.fn().mockResolvedValue({
|
||||
auctionLifecycleId,
|
||||
revision: 10,
|
||||
});
|
||||
const auctionFindById = jest.fn().mockReturnValue({
|
||||
select: jest.fn().mockReturnValue({
|
||||
session: jest.fn().mockReturnValue({
|
||||
lean: jest.fn().mockReturnValue({ exec: projectionExec }),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
});
|
||||
const scheduler = new AuctionDurabilityScheduler(
|
||||
{
|
||||
createSession: jest.fn().mockResolvedValue(session),
|
||||
getModel: jest.fn((name: string) => {
|
||||
if (name === 'auctionHistory') {
|
||||
return {
|
||||
deleteMany: historyDeleteMany,
|
||||
updateOne: historyUpdateOne,
|
||||
};
|
||||
}
|
||||
if (name === 'auction') {
|
||||
return { findById: auctionFindById, updateOne: auctionUpdateOne };
|
||||
}
|
||||
return { updateOne: jest.fn() };
|
||||
}),
|
||||
} as never,
|
||||
{ raw: jest.fn() } as never,
|
||||
);
|
||||
});
|
||||
const scheduler = new AuctionDurabilityScheduler(
|
||||
{
|
||||
createSession: jest.fn().mockResolvedValue(session),
|
||||
getModel: jest.fn((name: string) => {
|
||||
if (name === 'auctionHistory') {
|
||||
return {
|
||||
deleteMany: historyDeleteMany,
|
||||
updateOne: historyUpdateOne,
|
||||
};
|
||||
}
|
||||
if (name === 'auction') {
|
||||
return { findById: auctionFindById, updateOne: auctionUpdateOne };
|
||||
}
|
||||
return { updateOne: jest.fn() };
|
||||
}),
|
||||
} as never,
|
||||
{ raw: jest.fn() } as never,
|
||||
undefined,
|
||||
undefined,
|
||||
undefined,
|
||||
{ broadcastHistoryUpdated } as never,
|
||||
);
|
||||
|
||||
await scheduler.applyDurabilityPayload({
|
||||
...payload,
|
||||
historyMutation: {
|
||||
targetHistorySequence: 2,
|
||||
type: 'deleteAfterSequenceAndAppendUndo',
|
||||
},
|
||||
});
|
||||
await scheduler.applyDurabilityPayload({
|
||||
...payload,
|
||||
historyMutation: {
|
||||
targetHistorySequence: 2,
|
||||
type: 'deleteAfterSequenceAndAppendUndo',
|
||||
},
|
||||
});
|
||||
|
||||
expect(historyDeleteMany).not.toHaveBeenCalled();
|
||||
expect(historyUpdateOne).not.toHaveBeenCalled();
|
||||
expect(auctionUpdateOne).not.toHaveBeenCalled();
|
||||
});
|
||||
expect(historyDeleteMany).not.toHaveBeenCalled();
|
||||
expect(historyUpdateOne).not.toHaveBeenCalled();
|
||||
expect(auctionUpdateOne).not.toHaveBeenCalled();
|
||||
expect(broadcastHistoryUpdated).not.toHaveBeenCalled();
|
||||
},
|
||||
);
|
||||
|
||||
it('recovers stale append payloads as history-only records', async () => {
|
||||
const session = {
|
||||
@@ -581,6 +658,7 @@ describe('auction durability projection helpers', () => {
|
||||
});
|
||||
|
||||
it('clears stale append payloads after history-only recovery', async () => {
|
||||
const broadcastHistoryUpdated = jest.fn();
|
||||
const sendCommand = jest
|
||||
.fn()
|
||||
.mockResolvedValueOnce(['payload-1'])
|
||||
@@ -637,6 +715,10 @@ describe('auction durability projection helpers', () => {
|
||||
getCurrentRedisTimestampMS: jest.fn().mockResolvedValue(1000),
|
||||
raw: jest.fn().mockReturnValue({ sendCommand }),
|
||||
} as never,
|
||||
undefined,
|
||||
undefined,
|
||||
undefined,
|
||||
{ broadcastHistoryUpdated } as never,
|
||||
);
|
||||
|
||||
await expect(scheduler.processDueDurabilityPayloads(10)).resolves.toEqual({
|
||||
@@ -646,6 +728,11 @@ describe('auction durability projection helpers', () => {
|
||||
});
|
||||
|
||||
expect(historyUpdateOne).toHaveBeenCalledTimes(1);
|
||||
expect(broadcastHistoryUpdated).toHaveBeenCalledWith({
|
||||
matchId: 'match-1',
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
});
|
||||
expect(auctionUpdateOne).not.toHaveBeenCalled();
|
||||
expect(sideEffectUpdateOne).not.toHaveBeenCalled();
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(3, [
|
||||
@@ -811,21 +898,14 @@ describe('auction durability projection helpers', () => {
|
||||
skipped: 0,
|
||||
});
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(5, [
|
||||
'ZREM',
|
||||
'EVAL',
|
||||
expect.stringContaining("redis.call('HEXISTS'"),
|
||||
'4',
|
||||
'payload-1',
|
||||
'auction:auctionDurabilityRetryQueue',
|
||||
'payload-1',
|
||||
]);
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(6, [
|
||||
'HSET',
|
||||
'payload-1',
|
||||
'deadLetteredAtRedisTimestampMS',
|
||||
'1000',
|
||||
]);
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(7, [
|
||||
'ZADD',
|
||||
'auction:auctionDurabilityDeadLetterQueue',
|
||||
'auction:deadLetterStatusQueue',
|
||||
'1000',
|
||||
'payload-1',
|
||||
]);
|
||||
});
|
||||
|
||||
@@ -997,7 +1077,7 @@ describe('auction durability projection helpers', () => {
|
||||
{ reserveForMatch } as never,
|
||||
{ scheduleInitialPoll } as never,
|
||||
{ mirrorMatchSideEffectStatus } as never,
|
||||
{ broadcastMatchSideEffect } as never,
|
||||
{ broadcastMatchSideEffect, broadcastHistoryUpdated: jest.fn() } as never,
|
||||
);
|
||||
|
||||
await scheduler.applyDurabilityPayload(completePayload);
|
||||
@@ -1030,11 +1110,20 @@ describe('auction durability projection helpers', () => {
|
||||
{
|
||||
_id: 'auction-1',
|
||||
auctionLifecycleId: 'life-1',
|
||||
matchSideEffectRevision: 1,
|
||||
$or: [
|
||||
{ matchSideEffectTransitionId: 'transition-1' },
|
||||
{
|
||||
matchSideEffectTransitionId: { $exists: false },
|
||||
matchSideEffectRevision: 1,
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
$inc: { matchSideEffectRevision: 1 },
|
||||
$set: { matchSideEffectStatus: 'processing' },
|
||||
$set: {
|
||||
matchSideEffectStatus: 'processing',
|
||||
matchSideEffectTransitionId: 'transition-1',
|
||||
},
|
||||
$unset: { matchSideEffectError: '' },
|
||||
},
|
||||
expect.objectContaining({ returnDocument: 'after' }),
|
||||
@@ -1045,34 +1134,42 @@ describe('auction durability projection helpers', () => {
|
||||
_id: 'auction-1',
|
||||
auctionLifecycleId: 'life-1',
|
||||
matchSideEffectRevision: 2,
|
||||
matchSideEffectTransitionId: 'transition-1',
|
||||
},
|
||||
{
|
||||
$inc: { matchSideEffectRevision: 1 },
|
||||
$set: { matchSideEffectStatus: 'completed' },
|
||||
$set: {
|
||||
matchSideEffectStatus: 'completed',
|
||||
matchSideEffectTransitionId: 'transition-1',
|
||||
},
|
||||
$unset: { matchSideEffectError: '' },
|
||||
},
|
||||
expect.objectContaining({ returnDocument: 'after' }),
|
||||
);
|
||||
expect(mirrorMatchSideEffectStatus).toHaveBeenCalledWith({
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
matchId: 'match-1',
|
||||
matchSideEffectRevision: 2,
|
||||
matchSideEffectStatus: 'processing',
|
||||
});
|
||||
expect(mirrorMatchSideEffectStatus).toHaveBeenLastCalledWith({
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
matchId: 'match-1',
|
||||
matchSideEffectRevision: 3,
|
||||
matchSideEffectStatus: 'completed',
|
||||
});
|
||||
expect(broadcastMatchSideEffect).toHaveBeenNthCalledWith(1, 'match-1', {
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
currentServerTimestampMS: 2000,
|
||||
matchSideEffectRevision: 2,
|
||||
matchSideEffectStatus: 'processing',
|
||||
});
|
||||
expect(broadcastMatchSideEffect).toHaveBeenNthCalledWith(2, 'match-1', {
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
currentServerTimestampMS: 3000,
|
||||
matchSideEffectRevision: 3,
|
||||
matchSideEffectStatus: 'completed',
|
||||
@@ -1080,7 +1177,7 @@ describe('auction durability projection helpers', () => {
|
||||
expect(sendCommand).toHaveBeenCalledWith([
|
||||
'EVAL',
|
||||
expect.stringContaining("redis.call('EXPIRE'"),
|
||||
'11',
|
||||
'12',
|
||||
'auction:match-1:liveAuctionState',
|
||||
'auction:bidRoundDeadlineQueue',
|
||||
'auction:match-1:auctionStructureState',
|
||||
@@ -1092,6 +1189,7 @@ describe('auction durability projection helpers', () => {
|
||||
'auction:match-1:auctionActionRequestResultOrder',
|
||||
'auction:match-1:rehydrateLock',
|
||||
'auction:match-1:auctionStateTransitionLock',
|
||||
'auction:match-1:rejectedBidRequestResultOrder',
|
||||
'match-1',
|
||||
'life-1',
|
||||
String(7 * 24 * 60 * 60),
|
||||
@@ -1176,7 +1274,7 @@ describe('auction durability projection helpers', () => {
|
||||
{ reserveForMatch } as never,
|
||||
{ scheduleInitialPoll } as never,
|
||||
{ mirrorMatchSideEffectStatus } as never,
|
||||
{ broadcastMatchSideEffect } as never,
|
||||
{ broadcastMatchSideEffect, broadcastHistoryUpdated: jest.fn() } as never,
|
||||
);
|
||||
|
||||
await expect(
|
||||
@@ -1263,7 +1361,12 @@ describe('auction durability projection helpers', () => {
|
||||
const broadcastMatchSideEffect = jest.fn();
|
||||
const scheduler = new AuctionDurabilityScheduler(
|
||||
{
|
||||
createSession: jest.fn().mockResolvedValue(null),
|
||||
createSession: jest.fn().mockResolvedValueOnce(null).mockResolvedValue({
|
||||
startTransaction: jest.fn(),
|
||||
commitTransaction: jest.fn(),
|
||||
abortTransaction: jest.fn(),
|
||||
endSession: jest.fn(),
|
||||
}),
|
||||
getModel: jest.fn((name: string) => {
|
||||
if (name === 'auctionHistory') {
|
||||
return {
|
||||
@@ -1282,7 +1385,11 @@ describe('auction durability projection helpers', () => {
|
||||
return { updateOne: sideEffectUpdateOne };
|
||||
}
|
||||
if (name === 'match')
|
||||
return { findById: jest.fn().mockReturnValue(match) };
|
||||
return {
|
||||
findById: jest.fn().mockReturnValue({
|
||||
session: jest.fn().mockResolvedValue(match),
|
||||
}),
|
||||
};
|
||||
return {};
|
||||
}),
|
||||
} as never,
|
||||
@@ -1296,13 +1403,13 @@ describe('auction durability projection helpers', () => {
|
||||
{ releaseFromMatch } as never,
|
||||
{ cancelPolling } as never,
|
||||
{ mirrorMatchSideEffectStatus } as never,
|
||||
{ broadcastMatchSideEffect } as never,
|
||||
{ broadcastMatchSideEffect, broadcastHistoryUpdated: jest.fn() } as never,
|
||||
);
|
||||
|
||||
await scheduler.applyDurabilityPayload(resetPayload);
|
||||
|
||||
expect(releaseFromMatch).toHaveBeenCalledWith(match);
|
||||
expect(cancelPolling).toHaveBeenCalledWith(match);
|
||||
expect(releaseFromMatch).toHaveBeenCalledWith(match, expect.any(Object));
|
||||
expect(cancelPolling).toHaveBeenCalledWith(match, expect.any(Object));
|
||||
expect(match).toMatchObject({
|
||||
gameSchedule: [],
|
||||
result: undefined,
|
||||
@@ -1328,12 +1435,14 @@ describe('auction durability projection helpers', () => {
|
||||
);
|
||||
expect(mirrorMatchSideEffectStatus).toHaveBeenLastCalledWith({
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
matchId: 'match-1',
|
||||
matchSideEffectRevision: 3,
|
||||
matchSideEffectStatus: 'completed',
|
||||
});
|
||||
expect(broadcastMatchSideEffect).toHaveBeenLastCalledWith('match-1', {
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
currentServerTimestampMS: 3000,
|
||||
matchSideEffectRevision: 3,
|
||||
matchSideEffectStatus: 'completed',
|
||||
|
||||
@@ -4,6 +4,7 @@ import {
|
||||
OnModuleDestroy,
|
||||
OnModuleInit,
|
||||
Optional,
|
||||
ConflictException,
|
||||
} from '@nestjs/common';
|
||||
import { createHash, randomUUID } from 'crypto';
|
||||
import type mongoose from 'mongoose';
|
||||
@@ -16,6 +17,10 @@ import type {
|
||||
import { TournamentCodeService } from '../tournament-code/tournament-code.service';
|
||||
import { TournamentResultService } from '../tournament-result/tournament-result.service';
|
||||
import { AuctionEventBusService } from './auction-event-bus.service';
|
||||
import { AuctionService } from './auction.service';
|
||||
import { AuctionBidArchiveService } from './auction-bid-archive.service';
|
||||
import { AuctionLifecycleLock } from './auction-lifecycle-lock';
|
||||
import { buildAuctionProjectionUnset } from './auction-projection';
|
||||
import {
|
||||
AuctionSideEffectService,
|
||||
buildMatchSideEffectDelta,
|
||||
@@ -26,6 +31,7 @@ import { AuctionRedisService } from './redis/auction-redis.service';
|
||||
import { AuctionRedisStateReaderService } from './redis/auction-redis-state-reader.service';
|
||||
import {
|
||||
AUCTION_DURABILITY_DEAD_LETTER_QUEUE_KEY,
|
||||
AUCTION_DEAD_LETTER_STATUS_QUEUE_KEY,
|
||||
AUCTION_DURABILITY_RETRY_QUEUE_KEY,
|
||||
buildAuctionRedisKeys,
|
||||
} from './redis/auction-redis.keys';
|
||||
@@ -36,6 +42,8 @@ const AUCTION_DURABILITY_BATCH_LIMIT = 20;
|
||||
const AUCTION_DURABILITY_RETRY_DELAY_MS = 5000;
|
||||
const AUCTION_DURABILITY_MAX_RETRY_DELAY_MS = 60_000;
|
||||
const AUCTION_DURABILITY_MAX_ATTEMPTS = 10;
|
||||
const AUCTION_DURABILITY_MAX_PENDING_ATTEMPTS = 120;
|
||||
const AUCTION_DURABILITY_MAX_PENDING_DURATION_MS = 10 * 60 * 1000;
|
||||
const AUCTION_DURABILITY_ERROR_MESSAGE_MAX_LENGTH = 2000;
|
||||
const AUCTION_DURABILITY_LEADER_LOCK_KEY =
|
||||
'auction:auctionDurabilityScheduler:leader';
|
||||
@@ -45,6 +53,7 @@ const AUCTION_SIDE_EFFECT_LEASE_DURATION_MS = 30_000;
|
||||
const SYNC_MATCH_TEAMS_SIDE_EFFECT_TYPE = 'syncMatchTeamsAfterComplete';
|
||||
const RESET_MATCH_SIDE_EFFECT_TYPE = 'resetMatchAfterAuctionReset';
|
||||
const UNDO_COMPLETED_MATCH_SIDE_EFFECT_TYPE = 'undoCompletedAuctionSideEffects';
|
||||
class SideEffectPendingError extends Error {}
|
||||
|
||||
export interface AuctionDurabilityPayload {
|
||||
actorUserId?: unknown;
|
||||
@@ -67,6 +76,7 @@ export interface AuctionDurabilityPayload {
|
||||
export interface AuctionProjectionIdentity {
|
||||
auctionLifecycleId?: string;
|
||||
revision?: number;
|
||||
matchSideEffectTransitionId?: string;
|
||||
}
|
||||
|
||||
type ParsedAuctionHistoryMutation =
|
||||
@@ -85,7 +95,7 @@ interface CleanupSideEffectMatchDocument {
|
||||
participants: Array<{ excluded?: boolean }>;
|
||||
result?: unknown;
|
||||
resultPollState?: unknown;
|
||||
save(): Promise<unknown>;
|
||||
save(options?: { session: mongoose.ClientSession }): Promise<unknown>;
|
||||
status: string;
|
||||
teamBuiltAt?: Date;
|
||||
teams?: unknown[];
|
||||
@@ -99,6 +109,7 @@ export class AuctionDurabilityScheduler
|
||||
private readonly logger = new Logger(AuctionDurabilityScheduler.name);
|
||||
private tickTimer?: NodeJS.Timeout;
|
||||
private tickInProgress = false;
|
||||
private deadLetterScanCursor = '0';
|
||||
|
||||
constructor(
|
||||
private readonly connectionService: ConnectionService,
|
||||
@@ -113,6 +124,9 @@ export class AuctionDurabilityScheduler
|
||||
private readonly auctionEventBusService?: AuctionEventBusService,
|
||||
@Optional()
|
||||
private readonly auctionRedisStateReaderService?: AuctionRedisStateReaderService,
|
||||
@Optional() private readonly auctionService?: AuctionService,
|
||||
@Optional()
|
||||
private readonly auctionBidArchiveService?: AuctionBidArchiveService,
|
||||
) {}
|
||||
|
||||
public onModuleInit(): void {
|
||||
@@ -187,6 +201,23 @@ export class AuctionDurabilityScheduler
|
||||
});
|
||||
await this.clearDurabilityPayload(payloadKey);
|
||||
} catch (error) {
|
||||
if (
|
||||
error instanceof SideEffectPendingError ||
|
||||
error instanceof ConflictException
|
||||
) {
|
||||
const disposition = await this.deferDurabilityPayload(
|
||||
payloadKey,
|
||||
currentRedisTimestampMS,
|
||||
error,
|
||||
);
|
||||
if (disposition === 'dead-lettered') {
|
||||
failed += 1;
|
||||
this.logger.warn(
|
||||
`Auction durability payload exceeded its pending limit: ${payloadKey}`,
|
||||
);
|
||||
} else skipped += 1;
|
||||
continue;
|
||||
}
|
||||
failed += 1;
|
||||
const failureDisposition = await this.recordDurabilityPayloadFailure(
|
||||
payloadKey,
|
||||
@@ -214,6 +245,14 @@ export class AuctionDurabilityScheduler
|
||||
const payloadJson = hash.payloadJson;
|
||||
if (!payloadJson) return null;
|
||||
const payload = JSON.parse(payloadJson) as AuctionDurabilityPayload;
|
||||
const committedDeadline = Number(hash.committedBidRoundDeadlineTimestampMS);
|
||||
if (Number.isFinite(committedDeadline) && committedDeadline > 0) {
|
||||
payload.afterAuctionMongoProjection.currentBidRoundDeadlineTimestampMS =
|
||||
committedDeadline;
|
||||
payload.afterAuctionMongoProjection.currentDeadline = new Date(
|
||||
committedDeadline,
|
||||
).toISOString();
|
||||
}
|
||||
const committedAtRedisTimestampMS = Number(
|
||||
hash.committedAtRedisTimestampMS,
|
||||
);
|
||||
@@ -240,12 +279,12 @@ export class AuctionDurabilityScheduler
|
||||
const sideEffectMutation = parseMatchSideEffectMutation(
|
||||
payload.matchSideEffectMutation,
|
||||
);
|
||||
let shouldUpdateProjection = true;
|
||||
let shouldApplySideEffects = true;
|
||||
let shouldApplyHistoryMutation = true;
|
||||
|
||||
try {
|
||||
session?.startTransaction();
|
||||
const historyMutation = parseAuctionHistoryMutation(
|
||||
payload.historyMutation,
|
||||
);
|
||||
if (typeof AuctionModel.findById === 'function') {
|
||||
const currentProjection =
|
||||
await readAuctionProjectionIdentityForMutation(
|
||||
@@ -256,37 +295,44 @@ export class AuctionDurabilityScheduler
|
||||
if (
|
||||
!shouldProcessAuctionDurabilityPayload(currentProjection, payload)
|
||||
) {
|
||||
// 뒤 payload가 먼저 projection revision을 올리면 앞 append payload가 stale이 된다.
|
||||
// 이때 projection/side effect는 건드리지 않고 undo용 history만 멱등 복구한다.
|
||||
if (
|
||||
historyMutation.type === 'append' &&
|
||||
currentProjection.auctionLifecycleId === payload.auctionLifecycleId
|
||||
currentProjection.auctionLifecycleId !== payload.auctionLifecycleId
|
||||
) {
|
||||
await this.applyStaleAppendHistoryRecovery({
|
||||
if (session) await session.commitTransaction();
|
||||
return;
|
||||
}
|
||||
shouldApplyHistoryMutation =
|
||||
!(await this.isAppendHistoryInvalidatedByLaterDestructiveMutation({
|
||||
AuctionHistoryModel,
|
||||
payload,
|
||||
session,
|
||||
});
|
||||
}
|
||||
if (session) await session.commitTransaction();
|
||||
return;
|
||||
}));
|
||||
// History operations have their own sequence bounds. A newer ordinary
|
||||
// projection must not discard an earlier undo's history cleanup.
|
||||
shouldUpdateProjection = false;
|
||||
shouldApplySideEffects =
|
||||
Boolean(this.auctionRedisStateReaderService) ||
|
||||
currentProjection.matchSideEffectTransitionId ===
|
||||
payload.auctionStateTransitionId;
|
||||
}
|
||||
}
|
||||
await this.applyAuctionHistoryMutation({
|
||||
AuctionHistoryModel,
|
||||
AuctionModel,
|
||||
payload,
|
||||
session,
|
||||
});
|
||||
if (shouldApplyHistoryMutation)
|
||||
await this.applyAuctionHistoryMutation({
|
||||
AuctionHistoryModel,
|
||||
AuctionModel,
|
||||
payload,
|
||||
session,
|
||||
});
|
||||
const projectionOperation = buildAuctionProjectionGuardedUpdate(payload);
|
||||
await execMaybe(
|
||||
AuctionModel.updateOne(
|
||||
projectionOperation.filter as never,
|
||||
projectionOperation.update as never,
|
||||
{ session } as never,
|
||||
),
|
||||
);
|
||||
if (sideEffectMutation) {
|
||||
if (shouldUpdateProjection)
|
||||
await execMaybe(
|
||||
AuctionModel.updateOne(
|
||||
projectionOperation.filter as never,
|
||||
projectionOperation.update as never,
|
||||
{ session } as never,
|
||||
),
|
||||
);
|
||||
if (sideEffectMutation && shouldApplySideEffects) {
|
||||
const sideEffectOperation = buildSideEffectApplicationUpsert(
|
||||
payload,
|
||||
sideEffectMutation,
|
||||
@@ -310,9 +356,18 @@ export class AuctionDurabilityScheduler
|
||||
if (session) await session.endSession();
|
||||
}
|
||||
|
||||
if (shouldApplyHistoryMutation) {
|
||||
// This is independent of the primary state broadcast. HTTP reads on every
|
||||
// node can see the committed history before clients are notified.
|
||||
this.auctionEventBusService?.broadcastHistoryUpdated({
|
||||
matchId: String(payload.matchId),
|
||||
auctionLifecycleId: payload.auctionLifecycleId,
|
||||
auctionStateTransitionId: payload.auctionStateTransitionId,
|
||||
});
|
||||
}
|
||||
await this.broadcastLatestRedisAuctionStateIfRequested(payload);
|
||||
|
||||
if (sideEffectMutation) {
|
||||
if (sideEffectMutation && shouldApplySideEffects) {
|
||||
await this.applyMatchSideEffect(payload, sideEffectMutation);
|
||||
}
|
||||
}
|
||||
@@ -352,6 +407,64 @@ export class AuctionDurabilityScheduler
|
||||
private async applyMatchSideEffect(
|
||||
payload: AuctionDurabilityPayload,
|
||||
mutation: ParsedMatchSideEffectMutation,
|
||||
): Promise<void> {
|
||||
return new AuctionLifecycleLock(this.auctionRedisService).run(
|
||||
String(payload.matchId),
|
||||
async () => {
|
||||
if (this.auctionRedisStateReaderService) {
|
||||
const state =
|
||||
await this.auctionRedisStateReaderService.readAuctionStateView(
|
||||
String(payload.matchId),
|
||||
);
|
||||
if (!state)
|
||||
throw new SideEffectPendingError(
|
||||
'Auction realtime state is unavailable.',
|
||||
);
|
||||
if (
|
||||
state.auctionLifecycleId !== payload.auctionLifecycleId ||
|
||||
(state.matchSideEffectTransitionId &&
|
||||
state.matchSideEffectTransitionId !==
|
||||
payload.auctionStateTransitionId) ||
|
||||
(mutation.type === SYNC_MATCH_TEAMS_SIDE_EFFECT_TYPE &&
|
||||
state.phase !== 'complete')
|
||||
)
|
||||
return;
|
||||
// An ordinary later projection may have reached Mongo before this
|
||||
// side-effect-bearing transition. Install its pending generation only
|
||||
// while Redis still names it and Mongo has not advanced beyond it.
|
||||
const AuctionModel = await this.connectionService.getModel('auction');
|
||||
const pendingRevision = Number(
|
||||
payload.afterAuctionMongoProjection.matchSideEffectRevision ?? 0,
|
||||
);
|
||||
await execMaybe(
|
||||
AuctionModel.updateOne(
|
||||
{
|
||||
_id: payload.auctionId,
|
||||
auctionLifecycleId: payload.auctionLifecycleId,
|
||||
$or: [
|
||||
{ matchSideEffectRevision: { $lt: pendingRevision } },
|
||||
{ matchSideEffectRevision: { $exists: false } },
|
||||
],
|
||||
} as never,
|
||||
{
|
||||
$set: {
|
||||
matchSideEffectTransitionId: payload.auctionStateTransitionId,
|
||||
matchSideEffectRevision: pendingRevision,
|
||||
matchSideEffectStatus: 'pending',
|
||||
},
|
||||
$unset: { matchSideEffectError: '' },
|
||||
} as never,
|
||||
),
|
||||
);
|
||||
}
|
||||
await this.applyMatchSideEffectWhileLocked(payload, mutation);
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
private async applyMatchSideEffectWhileLocked(
|
||||
payload: AuctionDurabilityPayload,
|
||||
mutation: ParsedMatchSideEffectMutation,
|
||||
): Promise<void> {
|
||||
if (mutation.type === SYNC_MATCH_TEAMS_SIDE_EFFECT_TYPE) {
|
||||
await this.applySyncMatchTeamsSideEffect(payload, mutation);
|
||||
@@ -407,7 +520,26 @@ export class AuctionDurabilityScheduler
|
||||
}) as never,
|
||||
),
|
||||
);
|
||||
if (!hasMatchedDocument(leaseResult)) return;
|
||||
if (!hasMatchedDocument(leaseResult)) {
|
||||
const existing = await AuctionSideEffectApplicationModel.findOne(
|
||||
identity as never,
|
||||
)
|
||||
.lean()
|
||||
.exec();
|
||||
if (existing?.state === 'completed') {
|
||||
await this.persistAndBroadcastMatchSideEffectStatus({
|
||||
AuctionModel,
|
||||
currentServerTimestampMS: currentRedisTimestampMS,
|
||||
payload,
|
||||
status: 'completed',
|
||||
});
|
||||
await this.expireCompletedAuctionRedisRuntime(payload);
|
||||
return;
|
||||
}
|
||||
throw new SideEffectPendingError(
|
||||
'Auction side effect is still owned by another worker.',
|
||||
);
|
||||
}
|
||||
|
||||
const processingDelta = await this.persistAndBroadcastMatchSideEffectStatus(
|
||||
{
|
||||
@@ -420,7 +552,11 @@ export class AuctionDurabilityScheduler
|
||||
status: 'processing',
|
||||
},
|
||||
);
|
||||
if (!processingDelta) return;
|
||||
if (!processingDelta) {
|
||||
throw new SideEffectPendingError(
|
||||
'Auction side-effect generation is not ready.',
|
||||
);
|
||||
}
|
||||
const expectedMatchSideEffectRevision =
|
||||
processingDelta.matchSideEffectRevision;
|
||||
|
||||
@@ -489,7 +625,11 @@ export class AuctionDurabilityScheduler
|
||||
await this.auctionRedisService.getCurrentRedisTimestampMS();
|
||||
await execMaybe(
|
||||
AuctionSideEffectApplicationModel.updateOne(
|
||||
identity as never,
|
||||
{
|
||||
...identity,
|
||||
processingOwnerToken: ownerToken,
|
||||
state: 'processing',
|
||||
} as never,
|
||||
{
|
||||
$set: {
|
||||
completedAtTimestampMS,
|
||||
@@ -518,7 +658,11 @@ export class AuctionDurabilityScheduler
|
||||
await this.auctionRedisService.getCurrentRedisTimestampMS();
|
||||
await execMaybe(
|
||||
AuctionSideEffectApplicationModel.updateOne(
|
||||
identity as never,
|
||||
{
|
||||
...identity,
|
||||
processingOwnerToken: ownerToken,
|
||||
state: 'processing',
|
||||
} as never,
|
||||
{
|
||||
$set: {
|
||||
lastError: error instanceof Error ? error.message : String(error),
|
||||
@@ -544,33 +688,6 @@ export class AuctionDurabilityScheduler
|
||||
}
|
||||
}
|
||||
|
||||
private async applyStaleAppendHistoryRecovery(params: {
|
||||
AuctionHistoryModel: {
|
||||
findOne?: (...args: never[]) => unknown;
|
||||
updateOne: (...args: never[]) => unknown;
|
||||
};
|
||||
payload: AuctionDurabilityPayload;
|
||||
session: mongoose.ClientSession | null | undefined;
|
||||
}): Promise<void> {
|
||||
const invalidated =
|
||||
await this.isAppendHistoryInvalidatedByLaterDestructiveMutation(params);
|
||||
if (invalidated) return;
|
||||
|
||||
const historyOperation = buildAuctionHistoryUpsert(
|
||||
params.payload,
|
||||
).updateOne;
|
||||
await execMaybe(
|
||||
params.AuctionHistoryModel.updateOne(
|
||||
historyOperation.filter as never,
|
||||
historyOperation.update as never,
|
||||
{
|
||||
session: params.session,
|
||||
upsert: true,
|
||||
} as never,
|
||||
) as Promise<unknown> | { exec(): Promise<unknown> },
|
||||
);
|
||||
}
|
||||
|
||||
private async isAppendHistoryInvalidatedByLaterDestructiveMutation(params: {
|
||||
AuctionHistoryModel: {
|
||||
findOne?: (...args: never[]) => unknown;
|
||||
@@ -622,9 +739,7 @@ export class AuctionDurabilityScheduler
|
||||
await this.applyMatchCleanupSideEffect({
|
||||
mutation,
|
||||
payload,
|
||||
updateMatch: async (match) => {
|
||||
await this.tournamentCodeService?.releaseFromMatch(match as never);
|
||||
await this.tournamentResultService?.cancelPolling(match as never);
|
||||
updateMatch: (match) => {
|
||||
match.status = 'recruiting';
|
||||
match.teams = [];
|
||||
match.tournamentCodeIds = [];
|
||||
@@ -635,7 +750,6 @@ export class AuctionDurabilityScheduler
|
||||
match.teamBuiltAt = undefined;
|
||||
match.result = undefined;
|
||||
match.resultPollState = undefined;
|
||||
await match.save();
|
||||
},
|
||||
});
|
||||
}
|
||||
@@ -647,13 +761,14 @@ export class AuctionDurabilityScheduler
|
||||
await this.applyMatchCleanupSideEffect({
|
||||
mutation,
|
||||
payload,
|
||||
updateMatch: async (match) => {
|
||||
await this.tournamentCodeService?.releaseFromMatch(match as never);
|
||||
await this.tournamentResultService?.cancelPolling(match as never);
|
||||
updateMatch: (match) => {
|
||||
match.status = 'team-built';
|
||||
match.teams = [];
|
||||
match.teamBuiltAt = undefined;
|
||||
match.tournamentCodeIds = [];
|
||||
match.gameSchedule = [];
|
||||
match.result = undefined;
|
||||
match.resultPollState = undefined;
|
||||
await match.save();
|
||||
},
|
||||
});
|
||||
}
|
||||
@@ -661,7 +776,7 @@ export class AuctionDurabilityScheduler
|
||||
private async applyMatchCleanupSideEffect(params: {
|
||||
mutation: ParsedMatchSideEffectMutation;
|
||||
payload: AuctionDurabilityPayload;
|
||||
updateMatch: (match: CleanupSideEffectMatchDocument) => Promise<void>;
|
||||
updateMatch: (match: CleanupSideEffectMatchDocument) => void;
|
||||
}): Promise<void> {
|
||||
if (!this.tournamentCodeService || !this.tournamentResultService) {
|
||||
throw new Error('Auction side-effect services are not available.');
|
||||
@@ -700,7 +815,25 @@ export class AuctionDurabilityScheduler
|
||||
}) as never,
|
||||
),
|
||||
);
|
||||
if (!hasMatchedDocument(leaseResult)) return;
|
||||
if (!hasMatchedDocument(leaseResult)) {
|
||||
const existing = await AuctionSideEffectApplicationModel.findOne(
|
||||
identity as never,
|
||||
)
|
||||
.lean()
|
||||
.exec();
|
||||
if (existing?.state === 'completed') {
|
||||
await this.persistAndBroadcastMatchSideEffectStatus({
|
||||
AuctionModel,
|
||||
currentServerTimestampMS: currentRedisTimestampMS,
|
||||
payload: params.payload,
|
||||
status: 'completed',
|
||||
});
|
||||
return;
|
||||
}
|
||||
throw new SideEffectPendingError(
|
||||
'Auction side effect is still owned by another worker.',
|
||||
);
|
||||
}
|
||||
|
||||
const processingDelta = await this.persistAndBroadcastMatchSideEffectStatus(
|
||||
{
|
||||
@@ -714,29 +847,56 @@ export class AuctionDurabilityScheduler
|
||||
status: 'processing',
|
||||
},
|
||||
);
|
||||
if (!processingDelta) return;
|
||||
if (!processingDelta) {
|
||||
throw new SideEffectPendingError(
|
||||
'Auction side-effect generation is not ready.',
|
||||
);
|
||||
}
|
||||
const expectedMatchSideEffectRevision =
|
||||
processingDelta.matchSideEffectRevision;
|
||||
|
||||
try {
|
||||
const match = (await execMaybe(
|
||||
MatchModel.findById(params.payload.matchId) as never,
|
||||
)) as CleanupSideEffectMatchDocument | null;
|
||||
if (!match) {
|
||||
throw new Error(`Match not found: ${String(params.payload.matchId)}`);
|
||||
}
|
||||
if (match.competitionId) {
|
||||
throw new Error(
|
||||
'Cannot reset or undo Match teams after the immutable Competition has been created.',
|
||||
const session = await this.connectionService.createSession();
|
||||
if (!session)
|
||||
throw new Error('Failed to start Match cleanup transaction.');
|
||||
try {
|
||||
session.startTransaction();
|
||||
const match = (await MatchModel.findById(
|
||||
params.payload.matchId,
|
||||
).session(session)) as CleanupSideEffectMatchDocument | null;
|
||||
if (!match)
|
||||
throw new Error(`Match not found: ${String(params.payload.matchId)}`);
|
||||
if (match.competitionId)
|
||||
throw new Error(
|
||||
'Cannot reset or undo Match teams after the immutable Competition has been created.',
|
||||
);
|
||||
await this.tournamentCodeService.releaseFromMatch(
|
||||
match as never,
|
||||
session,
|
||||
);
|
||||
await this.tournamentResultService.cancelPolling(
|
||||
match as never,
|
||||
session,
|
||||
);
|
||||
params.updateMatch(match);
|
||||
await match.save({ session });
|
||||
await session.commitTransaction();
|
||||
} catch (error) {
|
||||
await session.abortTransaction();
|
||||
throw error;
|
||||
} finally {
|
||||
await session.endSession();
|
||||
}
|
||||
await params.updateMatch(match);
|
||||
|
||||
const completedAtTimestampMS =
|
||||
await this.auctionRedisService.getCurrentRedisTimestampMS();
|
||||
await execMaybe(
|
||||
AuctionSideEffectApplicationModel.updateOne(
|
||||
identity as never,
|
||||
{
|
||||
...identity,
|
||||
processingOwnerToken: ownerToken,
|
||||
state: 'processing',
|
||||
} as never,
|
||||
{
|
||||
$set: {
|
||||
completedAtTimestampMS,
|
||||
@@ -766,7 +926,11 @@ export class AuctionDurabilityScheduler
|
||||
error instanceof Error ? error.message : String(error);
|
||||
await execMaybe(
|
||||
AuctionSideEffectApplicationModel.updateOne(
|
||||
identity as never,
|
||||
{
|
||||
...identity,
|
||||
processingOwnerToken: ownerToken,
|
||||
state: 'processing',
|
||||
} as never,
|
||||
{
|
||||
$set: {
|
||||
lastError: errorMessage,
|
||||
@@ -828,7 +992,10 @@ export class AuctionDurabilityScheduler
|
||||
params.AuctionHistoryModel.deleteMany(
|
||||
{
|
||||
auctionId: params.payload.auctionId,
|
||||
sequence: { $gt: mutation.targetHistorySequence },
|
||||
sequence: {
|
||||
$gt: mutation.targetHistorySequence,
|
||||
$lt: params.payload.auctionHistorySequence,
|
||||
},
|
||||
} as never,
|
||||
{ session: params.session } as never,
|
||||
) as Promise<unknown> | { exec(): Promise<unknown> },
|
||||
@@ -842,6 +1009,7 @@ export class AuctionDurabilityScheduler
|
||||
params.AuctionHistoryModel.deleteMany(
|
||||
{
|
||||
auctionId: params.payload.auctionId,
|
||||
sequence: { $lt: params.payload.auctionHistorySequence },
|
||||
} as never,
|
||||
{ session: params.session } as never,
|
||||
) as Promise<unknown> | { exec(): Promise<unknown> },
|
||||
@@ -874,16 +1042,43 @@ export class AuctionDurabilityScheduler
|
||||
};
|
||||
currentServerTimestampMS: number;
|
||||
errorMessage?: string;
|
||||
expectedMatchSideEffectRevision: number;
|
||||
expectedMatchSideEffectRevision?: number;
|
||||
payload: AuctionDurabilityPayload;
|
||||
status: AuctionMatchSideEffectStatus;
|
||||
onlyUnfinished?: boolean;
|
||||
}): Promise<MatchSideEffectDelta | null> {
|
||||
const updatedAuction = (await execMaybe(
|
||||
params.AuctionModel.findOneAndUpdate(
|
||||
{
|
||||
_id: params.payload.auctionId,
|
||||
auctionLifecycleId: params.payload.auctionLifecycleId,
|
||||
matchSideEffectRevision: params.expectedMatchSideEffectRevision,
|
||||
...(params.onlyUnfinished
|
||||
? { matchSideEffectStatus: { $ne: 'completed' } }
|
||||
: {}),
|
||||
...(params.status === 'processing'
|
||||
? {
|
||||
$or: [
|
||||
{
|
||||
matchSideEffectTransitionId:
|
||||
params.payload.auctionStateTransitionId,
|
||||
},
|
||||
{
|
||||
matchSideEffectTransitionId: { $exists: false },
|
||||
matchSideEffectRevision:
|
||||
params.expectedMatchSideEffectRevision,
|
||||
},
|
||||
],
|
||||
}
|
||||
: {
|
||||
matchSideEffectTransitionId:
|
||||
params.payload.auctionStateTransitionId,
|
||||
...(params.expectedMatchSideEffectRevision === undefined
|
||||
? {}
|
||||
: {
|
||||
matchSideEffectRevision:
|
||||
params.expectedMatchSideEffectRevision,
|
||||
}),
|
||||
}),
|
||||
} as never,
|
||||
{
|
||||
$inc: { matchSideEffectRevision: 1 },
|
||||
@@ -892,6 +1087,8 @@ export class AuctionDurabilityScheduler
|
||||
? { matchSideEffectError: params.errorMessage }
|
||||
: {}),
|
||||
matchSideEffectStatus: params.status,
|
||||
matchSideEffectTransitionId:
|
||||
params.payload.auctionStateTransitionId,
|
||||
},
|
||||
...(params.errorMessage
|
||||
? {}
|
||||
@@ -915,6 +1112,7 @@ export class AuctionDurabilityScheduler
|
||||
|
||||
const delta = buildMatchSideEffectDelta({
|
||||
auctionLifecycleId: updatedAuction.auctionLifecycleId,
|
||||
auctionStateTransitionId: params.payload.auctionStateTransitionId,
|
||||
currentServerTimestampMS: params.currentServerTimestampMS,
|
||||
matchSideEffectRevision: Number(
|
||||
updatedAuction.matchSideEffectRevision ?? 0,
|
||||
@@ -923,19 +1121,170 @@ export class AuctionDurabilityScheduler
|
||||
updatedAuction.matchSideEffectStatus ?? params.status,
|
||||
});
|
||||
|
||||
await this.auctionSideEffectService?.mirrorMatchSideEffectStatus({
|
||||
auctionLifecycleId: delta.auctionLifecycleId,
|
||||
matchId: String(params.payload.matchId),
|
||||
matchSideEffectRevision: delta.matchSideEffectRevision,
|
||||
matchSideEffectStatus: delta.matchSideEffectStatus,
|
||||
});
|
||||
this.auctionEventBusService?.broadcastMatchSideEffect(
|
||||
String(params.payload.matchId),
|
||||
delta,
|
||||
);
|
||||
const mirrored =
|
||||
await this.auctionSideEffectService?.mirrorMatchSideEffectStatus({
|
||||
auctionLifecycleId: delta.auctionLifecycleId,
|
||||
auctionStateTransitionId: params.payload.auctionStateTransitionId,
|
||||
matchId: String(params.payload.matchId),
|
||||
matchSideEffectRevision: delta.matchSideEffectRevision,
|
||||
matchSideEffectStatus: delta.matchSideEffectStatus,
|
||||
});
|
||||
if (mirrored !== false) {
|
||||
this.auctionEventBusService?.broadcastMatchSideEffect(
|
||||
String(params.payload.matchId),
|
||||
delta,
|
||||
);
|
||||
}
|
||||
return delta;
|
||||
}
|
||||
|
||||
public async reconcileDeadLetterStatuses(limit = 20): Promise<void> {
|
||||
const client = this.auctionRedisService.raw();
|
||||
const now = await this.auctionRedisService.getCurrentRedisTimestampMS();
|
||||
// Also reconcile entries dead-lettered before status notifications existed.
|
||||
const scanned = await client.sendCommand([
|
||||
'ZSCAN',
|
||||
AUCTION_DURABILITY_DEAD_LETTER_QUEUE_KEY,
|
||||
this.deadLetterScanCursor,
|
||||
'COUNT',
|
||||
String(limit),
|
||||
]);
|
||||
if (Array.isArray(scanned) && Array.isArray(scanned[1])) {
|
||||
this.deadLetterScanCursor = String(scanned[0]);
|
||||
for (let index = 0; index < scanned[1].length; index += 2) {
|
||||
const key = String(scanned[1][index]);
|
||||
if (
|
||||
!(await client.sendCommand([
|
||||
'HGET',
|
||||
key,
|
||||
'deadLetterStatusReconciledAtTimestampMS',
|
||||
]))
|
||||
) {
|
||||
await client.sendCommand([
|
||||
'ZADD',
|
||||
AUCTION_DEAD_LETTER_STATUS_QUEUE_KEY,
|
||||
'NX',
|
||||
String(now),
|
||||
key,
|
||||
]);
|
||||
}
|
||||
}
|
||||
}
|
||||
const reply = await client.sendCommand([
|
||||
'ZRANGEBYSCORE',
|
||||
AUCTION_DEAD_LETTER_STATUS_QUEUE_KEY,
|
||||
'-inf',
|
||||
String(now),
|
||||
'LIMIT',
|
||||
'0',
|
||||
String(limit),
|
||||
]);
|
||||
if (!Array.isArray(reply)) return;
|
||||
for (const key of reply.map(String)) {
|
||||
try {
|
||||
const payload = await this.readDurabilityPayload(key);
|
||||
if (
|
||||
payload &&
|
||||
parseMatchSideEffectMutation(payload.matchSideEffectMutation)
|
||||
) {
|
||||
const state =
|
||||
await this.auctionRedisStateReaderService?.readAuctionStateView(
|
||||
String(payload.matchId),
|
||||
);
|
||||
// A terminal notification for a previous generation must not change
|
||||
// a new completion/undo, even when Mongo is behind Redis.
|
||||
const superseded =
|
||||
state &&
|
||||
(state.auctionLifecycleId !== payload.auctionLifecycleId ||
|
||||
state.matchSideEffectStatus === 'completed' ||
|
||||
(state.matchSideEffectTransitionId &&
|
||||
state.matchSideEffectTransitionId !==
|
||||
payload.auctionStateTransitionId));
|
||||
if (!superseded) {
|
||||
const AuctionModel =
|
||||
await this.connectionService.getModel('auction');
|
||||
if (
|
||||
state?.matchSideEffectTransitionId ===
|
||||
payload.auctionStateTransitionId
|
||||
) {
|
||||
const revision = Number(
|
||||
payload.afterAuctionMongoProjection.matchSideEffectRevision ??
|
||||
0,
|
||||
);
|
||||
await AuctionModel.updateOne(
|
||||
{
|
||||
_id: payload.auctionId,
|
||||
auctionLifecycleId: payload.auctionLifecycleId,
|
||||
$or: [
|
||||
{ matchSideEffectRevision: { $lt: revision } },
|
||||
{ matchSideEffectRevision: { $exists: false } },
|
||||
],
|
||||
} as never,
|
||||
{
|
||||
$set: {
|
||||
matchSideEffectTransitionId:
|
||||
payload.auctionStateTransitionId,
|
||||
matchSideEffectRevision: revision,
|
||||
matchSideEffectStatus: 'pending',
|
||||
},
|
||||
},
|
||||
);
|
||||
// Heal a same-generation revision mismatch before sending the
|
||||
// terminal status; otherwise Redis could ignore it as older.
|
||||
await AuctionModel.updateOne(
|
||||
{
|
||||
_id: payload.auctionId,
|
||||
auctionLifecycleId: payload.auctionLifecycleId,
|
||||
matchSideEffectTransitionId: payload.auctionStateTransitionId,
|
||||
matchSideEffectStatus: { $ne: 'completed' },
|
||||
} as never,
|
||||
{
|
||||
$max: {
|
||||
matchSideEffectRevision: Number(
|
||||
state.matchSideEffectRevision ?? revision,
|
||||
),
|
||||
},
|
||||
},
|
||||
);
|
||||
}
|
||||
const error = await client.sendCommand(['HGET', key, 'lastError']);
|
||||
await this.persistAndBroadcastMatchSideEffectStatus({
|
||||
AuctionModel: AuctionModel as never,
|
||||
payload,
|
||||
currentServerTimestampMS: now,
|
||||
status: 'failed',
|
||||
onlyUnfinished: true,
|
||||
errorMessage:
|
||||
typeof error === 'string'
|
||||
? error
|
||||
: 'Auction side effect exhausted its retry limit.',
|
||||
});
|
||||
}
|
||||
}
|
||||
await client.sendCommand([
|
||||
'EVAL',
|
||||
"if redis.call('HEXISTS', KEYS[1], 'payloadJson') == 1 then redis.call('HSET', KEYS[1], 'deadLetterStatusReconciledAtTimestampMS', ARGV[1]) end redis.call('ZREM', KEYS[2], KEYS[1]); return 1",
|
||||
'2',
|
||||
key,
|
||||
AUCTION_DEAD_LETTER_STATUS_QUEUE_KEY,
|
||||
String(now),
|
||||
]);
|
||||
} catch (error) {
|
||||
// Mongo or Redis mirroring may be unavailable at dead-letter time. Keep
|
||||
// the notification durable until the failure can be shown to viewers.
|
||||
await client.sendCommand([
|
||||
'ZADD',
|
||||
AUCTION_DEAD_LETTER_STATUS_QUEUE_KEY,
|
||||
String(now + 5000),
|
||||
key,
|
||||
]);
|
||||
this.logger.warn(
|
||||
`Auction terminal status will retry for ${key}: ${String(error)}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async safeTick(): Promise<void> {
|
||||
if (this.tickInProgress) return;
|
||||
this.tickInProgress = true;
|
||||
@@ -948,7 +1297,22 @@ export class AuctionDurabilityScheduler
|
||||
AUCTION_DURABILITY_LEADER_LOCK_TTL_MS,
|
||||
);
|
||||
if (!leaderLockAcquired) return;
|
||||
await this.processDueDurabilityPayloads(AUCTION_DURABILITY_BATCH_LIMIT);
|
||||
// A failed maintenance task must not starve the other durable queues.
|
||||
for (const work of [
|
||||
() => this.processDueDurabilityPayloads(AUCTION_DURABILITY_BATCH_LIMIT),
|
||||
() => this.reconcileDeadLetterStatuses(AUCTION_DURABILITY_BATCH_LIMIT),
|
||||
() => this.auctionBidArchiveService?.persistPendingBids(),
|
||||
() =>
|
||||
this.auctionService?.retryPendingCancellations(
|
||||
AUCTION_DURABILITY_BATCH_LIMIT,
|
||||
),
|
||||
]) {
|
||||
try {
|
||||
await work();
|
||||
} catch (error) {
|
||||
this.logger.warn(`Auction maintenance task failed: ${String(error)}`);
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
this.logger.warn(
|
||||
`Auction durability tick failed: ${
|
||||
@@ -957,10 +1321,13 @@ export class AuctionDurabilityScheduler
|
||||
);
|
||||
} finally {
|
||||
if (leaderLockAcquired) {
|
||||
await this.auctionRedisService.releaseTokenLock(
|
||||
AUCTION_DURABILITY_LEADER_LOCK_KEY,
|
||||
leaderLockToken,
|
||||
);
|
||||
await this.auctionRedisService
|
||||
.releaseTokenLock(AUCTION_DURABILITY_LEADER_LOCK_KEY, leaderLockToken)
|
||||
.catch((error: unknown) => {
|
||||
this.logger.warn(
|
||||
`Auction durability lock release failed: ${String(error)}`,
|
||||
);
|
||||
});
|
||||
}
|
||||
this.tickInProgress = false;
|
||||
}
|
||||
@@ -987,6 +1354,51 @@ export class AuctionDurabilityScheduler
|
||||
]);
|
||||
}
|
||||
|
||||
private async deferDurabilityPayload(
|
||||
payloadKey: string,
|
||||
timestampMS: number,
|
||||
error: unknown,
|
||||
): Promise<'gone' | 'requeued' | 'dead-lettered'> {
|
||||
// Keep coordination waits separate from failed work, but bound them across
|
||||
// restarts too. Updating the payload and queue atomically avoids orphan jobs.
|
||||
const result = await this.auctionRedisService
|
||||
.raw()
|
||||
.sendCommand([
|
||||
'EVAL',
|
||||
[
|
||||
"if redis.call('HEXISTS', KEYS[1], 'payloadJson') == 0 then return 0 end",
|
||||
"local count = redis.call('HINCRBY', KEYS[1], 'pendingAttempts', 1)",
|
||||
"redis.call('HSETNX', KEYS[1], 'pendingSinceTimestampMS', ARGV[1])",
|
||||
"local since = tonumber(redis.call('HGET', KEYS[1], 'pendingSinceTimestampMS'))",
|
||||
"redis.call('HSET', KEYS[1], 'lastPendingReason', ARGV[5], 'lastPendingAtTimestampMS', ARGV[1])",
|
||||
'if count >= tonumber(ARGV[3]) or tonumber(ARGV[1]) - since >= tonumber(ARGV[4]) then',
|
||||
" redis.call('ZREM', KEYS[2], KEYS[1])",
|
||||
" redis.call('HSET', KEYS[1], 'deadLetteredAtRedisTimestampMS', ARGV[1], 'lastError', ARGV[5])",
|
||||
" redis.call('ZADD', KEYS[3], ARGV[1], KEYS[1])",
|
||||
" redis.call('ZADD', KEYS[4], ARGV[1], KEYS[1])",
|
||||
' return 2',
|
||||
'end',
|
||||
"redis.call('ZADD', KEYS[2], tonumber(ARGV[1]) + tonumber(ARGV[2]), KEYS[1])",
|
||||
'return 1',
|
||||
].join('\n'),
|
||||
'4',
|
||||
payloadKey,
|
||||
AUCTION_DURABILITY_RETRY_QUEUE_KEY,
|
||||
AUCTION_DURABILITY_DEAD_LETTER_QUEUE_KEY,
|
||||
AUCTION_DEAD_LETTER_STATUS_QUEUE_KEY,
|
||||
String(timestampMS),
|
||||
String(AUCTION_DURABILITY_RETRY_DELAY_MS),
|
||||
String(AUCTION_DURABILITY_MAX_PENDING_ATTEMPTS),
|
||||
String(AUCTION_DURABILITY_MAX_PENDING_DURATION_MS),
|
||||
formatErrorMessageForRedis(error),
|
||||
]);
|
||||
return Number(result) === 2
|
||||
? 'dead-lettered'
|
||||
: Number(result) === 1
|
||||
? 'requeued'
|
||||
: 'gone';
|
||||
}
|
||||
|
||||
private async recordDurabilityPayloadFailure(
|
||||
payloadKey: string,
|
||||
currentRedisTimestampMS: number,
|
||||
@@ -1012,24 +1424,17 @@ export class AuctionDurabilityScheduler
|
||||
Number.isFinite(attempts) &&
|
||||
attempts >= AUCTION_DURABILITY_MAX_ATTEMPTS
|
||||
) {
|
||||
await this.auctionRedisService
|
||||
.raw()
|
||||
.sendCommand(['ZREM', AUCTION_DURABILITY_RETRY_QUEUE_KEY, payloadKey]);
|
||||
await this.auctionRedisService
|
||||
.raw()
|
||||
.sendCommand([
|
||||
'HSET',
|
||||
'EVAL',
|
||||
"if redis.call('HEXISTS', KEYS[1], 'payloadJson') == 0 then return 0 end redis.call('HSET', KEYS[1], 'deadLetteredAtRedisTimestampMS', ARGV[1]); redis.call('ZREM', KEYS[2], KEYS[1]); redis.call('ZADD', KEYS[3], ARGV[1], KEYS[1]); redis.call('ZADD', KEYS[4], ARGV[1], KEYS[1]); return 1",
|
||||
'4',
|
||||
payloadKey,
|
||||
'deadLetteredAtRedisTimestampMS',
|
||||
String(currentRedisTimestampMS),
|
||||
]);
|
||||
await this.auctionRedisService
|
||||
.raw()
|
||||
.sendCommand([
|
||||
'ZADD',
|
||||
AUCTION_DURABILITY_RETRY_QUEUE_KEY,
|
||||
AUCTION_DURABILITY_DEAD_LETTER_QUEUE_KEY,
|
||||
AUCTION_DEAD_LETTER_STATUS_QUEUE_KEY,
|
||||
String(currentRedisTimestampMS),
|
||||
payloadKey,
|
||||
]);
|
||||
return 'dead-lettered';
|
||||
}
|
||||
@@ -1064,7 +1469,7 @@ export class AuctionDurabilityScheduler
|
||||
'end',
|
||||
'return 1',
|
||||
].join('\n'),
|
||||
'11',
|
||||
'12',
|
||||
keys.liveStateKey,
|
||||
keys.deadlineQueueKey,
|
||||
keys.structureStateKey,
|
||||
@@ -1076,6 +1481,7 @@ export class AuctionDurabilityScheduler
|
||||
keys.actionRequestResultOrderKey,
|
||||
keys.rehydrateLockKey,
|
||||
keys.stateTransitionLockKey,
|
||||
keys.rejectedBidRequestResultOrderKey,
|
||||
matchId,
|
||||
payload.auctionLifecycleId,
|
||||
String(AUCTION_REDIS_COMPLETED_RETAIN_SECONDS),
|
||||
@@ -1159,6 +1565,7 @@ async function readAuctionProjectionIdentityForMutation(
|
||||
? (query as { select: (...args: never[]) => unknown }).select({
|
||||
auctionLifecycleId: 1,
|
||||
revision: 1,
|
||||
matchSideEffectTransitionId: 1,
|
||||
} as never)
|
||||
: query;
|
||||
const scoped =
|
||||
@@ -1178,6 +1585,10 @@ async function readAuctionProjectionIdentityForMutation(
|
||||
if (!projection || typeof projection !== 'object') return {};
|
||||
const record = projection as Record<string, unknown>;
|
||||
return {
|
||||
matchSideEffectTransitionId:
|
||||
typeof record.matchSideEffectTransitionId === 'string'
|
||||
? record.matchSideEffectTransitionId
|
||||
: undefined,
|
||||
auctionLifecycleId:
|
||||
typeof record.auctionLifecycleId === 'string'
|
||||
? record.auctionLifecycleId
|
||||
@@ -1200,6 +1611,7 @@ export function buildAuctionProjectionGuardedUpdate(
|
||||
},
|
||||
update: {
|
||||
$set: payload.afterAuctionMongoProjection,
|
||||
$unset: buildAuctionProjectionUnset(payload.afterAuctionMongoProjection),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
import { Injectable } from '@nestjs/common';
|
||||
import type { Namespace } from 'socket.io';
|
||||
import type { AuctionHistoryUpdatedEvent } from '@lolympus/contracts';
|
||||
import type { AuctionStateResponse } from './auction.service';
|
||||
import type { MatchSideEffectDelta } from './auction-side-effect.service';
|
||||
import { serializeRealtimeAuction } from './auction-realtime-serializer';
|
||||
@@ -24,4 +25,14 @@ export class AuctionEventBusService {
|
||||
?.to(matchId)
|
||||
.emit('state', serializeRealtimeAuction(state));
|
||||
}
|
||||
|
||||
public broadcastHistoryUpdated(event: AuctionHistoryUpdatedEvent): void {
|
||||
this.auctionNamespace?.to(event.matchId).emit('history-updated', event);
|
||||
}
|
||||
|
||||
public broadcastReset(matchId: string, auctionLifecycleId: string): void {
|
||||
this.auctionNamespace
|
||||
?.to(matchId)
|
||||
.emit('reset', { matchId, auctionLifecycleId });
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
import { AuctionLifecycleLock } from './auction-lifecycle-lock';
|
||||
|
||||
afterEach(() => jest.useRealTimers());
|
||||
|
||||
it('renews ownership and handles renewal/release failures without unhandled rejection', async () => {
|
||||
jest.useFakeTimers();
|
||||
const sendCommand = jest
|
||||
.fn()
|
||||
.mockRejectedValue(new Error('redis disconnected'));
|
||||
const releaseTokenLock = jest
|
||||
.fn()
|
||||
.mockRejectedValue(new Error('release failed'));
|
||||
const lock = new AuctionLifecycleLock({
|
||||
acquireTokenLock: jest.fn().mockResolvedValue(true),
|
||||
releaseTokenLock,
|
||||
raw: () => ({ sendCommand }),
|
||||
} as never);
|
||||
const result = lock.run('match', async () => {
|
||||
await jest.advanceTimersByTimeAsync(10000);
|
||||
});
|
||||
await expect(result).rejects.toThrow('redis disconnected');
|
||||
expect(releaseTokenLock).toHaveBeenCalledTimes(1);
|
||||
expect(jest.getTimerCount()).toBe(0);
|
||||
});
|
||||
|
||||
it('preserves an operation result if only lock release fails', async () => {
|
||||
const lock = new AuctionLifecycleLock({
|
||||
acquireTokenLock: jest.fn().mockResolvedValue(true),
|
||||
releaseTokenLock: jest.fn().mockRejectedValue(new Error('release failed')),
|
||||
} as never);
|
||||
await expect(lock.run('match', async () => 42)).resolves.toBe(42);
|
||||
});
|
||||
@@ -0,0 +1,72 @@
|
||||
import { ConflictException, Logger } from '@nestjs/common';
|
||||
import { randomUUID } from 'crypto';
|
||||
import { AuctionRedisService } from './redis/auction-redis.service';
|
||||
|
||||
export class AuctionLifecycleBusyError extends ConflictException {
|
||||
constructor() {
|
||||
super({
|
||||
code: 'AUCTION_LIFECYCLE_BUSY',
|
||||
message: '다른 경매 작업을 처리 중입니다. 잠시 후 다시 시도해 주세요.',
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/** Serializes startup, cancellation, undo and Match side effects across nodes. */
|
||||
export class AuctionLifecycleLock {
|
||||
private readonly logger = new Logger(AuctionLifecycleLock.name);
|
||||
|
||||
constructor(private readonly redis: AuctionRedisService) {}
|
||||
|
||||
async run<T>(matchId: string, operation: () => Promise<T>): Promise<T> {
|
||||
// Kept outside runtime cleanup: cancelling an auction must not release a
|
||||
// lock still held by its cancellation/recovery operation.
|
||||
const key = `auction:${matchId}:lifecycleMutationLock`;
|
||||
const token = randomUUID();
|
||||
if (!(await this.redis.acquireTokenLock(key, token, 30_000))) {
|
||||
throw new AuctionLifecycleBusyError();
|
||||
}
|
||||
let renewal: Promise<void> | undefined;
|
||||
let ownershipError: Error | undefined;
|
||||
const timer = setInterval(() => {
|
||||
if (renewal) return;
|
||||
renewal = this.redis
|
||||
.raw()
|
||||
.sendCommand<string | null>([
|
||||
'SET',
|
||||
key,
|
||||
token,
|
||||
'IFEQ',
|
||||
token,
|
||||
'PX',
|
||||
'30000',
|
||||
])
|
||||
.then((result) => {
|
||||
if (result !== 'OK')
|
||||
throw new Error('Auction lifecycle lock ownership was lost.');
|
||||
})
|
||||
.catch((error: unknown) => {
|
||||
ownershipError =
|
||||
error instanceof Error ? error : new Error(String(error));
|
||||
})
|
||||
.finally(() => {
|
||||
renewal = undefined;
|
||||
});
|
||||
}, 10_000);
|
||||
timer.unref?.();
|
||||
try {
|
||||
const result = await operation();
|
||||
clearInterval(timer);
|
||||
await renewal;
|
||||
if (ownershipError) throw ownershipError;
|
||||
return result;
|
||||
} finally {
|
||||
clearInterval(timer);
|
||||
await renewal;
|
||||
await this.redis.releaseTokenLock(key, token).catch((error: unknown) => {
|
||||
this.logger.warn(
|
||||
`Auction lifecycle lock release failed: ${String(error)}`,
|
||||
);
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
/** Missing optional fields in a complete projection mean deletion, not retention. */
|
||||
export const AUCTION_OPTIONAL_PROJECTION_FIELDS = [
|
||||
'completedAt',
|
||||
'auctionCompletedAtTimestampMS',
|
||||
'currentBidderTeamIndex',
|
||||
'currentHighestBidderTeamIndex',
|
||||
'currentDeadline',
|
||||
'currentBidRoundDeadlineTimestampMS',
|
||||
'currentBidRoundId',
|
||||
] as const;
|
||||
|
||||
export function buildAuctionProjectionUnset(
|
||||
projection: Record<string, unknown>,
|
||||
) {
|
||||
return Object.fromEntries(
|
||||
AUCTION_OPTIONAL_PROJECTION_FIELDS.filter(
|
||||
(field) => projection[field] === undefined,
|
||||
).map((field) => [field, '']),
|
||||
);
|
||||
}
|
||||
@@ -5,6 +5,11 @@ import {
|
||||
} from './auction-rejection';
|
||||
|
||||
describe('resolveAuctionRejectionReason', () => {
|
||||
it('distinguishes an outdated client from a stale round and does not suggest a state-only resync', () => {
|
||||
const reason = resolveAuctionRejectionReason('BID_CLIENT_UPDATE_REQUIRED');
|
||||
expect(reason).toBe('BID_REJECTED_BECAUSE_CLIENT_UPDATE_REQUIRED');
|
||||
expect(isAuctionResyncRecommended(reason)).toBe(false);
|
||||
});
|
||||
it('reports roster validation failures without recommending a retry', () => {
|
||||
const reason = resolveAuctionRejectionReason(
|
||||
'AUCTION_ROSTER_INVALID',
|
||||
|
||||
@@ -46,6 +46,8 @@ export const AUCTION_REJECTION_REASON = {
|
||||
'AUCTION_TRANSITION_REJECTED_BECAUSE_REQUEST_COORDINATION_RETRYABLE',
|
||||
|
||||
// === 입찰(bid) ===
|
||||
BID_REJECTED_BECAUSE_CLIENT_UPDATE_REQUIRED:
|
||||
'BID_REJECTED_BECAUSE_CLIENT_UPDATE_REQUIRED',
|
||||
/** 입찰 라운드가 이미 다음 선수/다음 라운드로 넘어감(내부 `STALE_BID_ROUND`). */
|
||||
BID_REJECTED_BECAUSE_BID_ROUND_ALREADY_ADVANCED:
|
||||
'BID_REJECTED_BECAUSE_BID_ROUND_ALREADY_ADVANCED',
|
||||
@@ -86,6 +88,8 @@ export type AuctionRejectionReason =
|
||||
|
||||
/** 내부 짧은 코드 → 설명적 reason. */
|
||||
const INTERNAL_CODE_TO_REASON: Record<string, AuctionRejectionReason> = {
|
||||
BID_CLIENT_UPDATE_REQUIRED:
|
||||
AUCTION_REJECTION_REASON.BID_REJECTED_BECAUSE_CLIENT_UPDATE_REQUIRED,
|
||||
AUCTION_ROSTER_INVALID:
|
||||
AUCTION_REJECTION_REASON.AUCTION_TRANSITION_REJECTED_BECAUSE_ROSTER_INVALID,
|
||||
CONFLICT:
|
||||
|
||||
@@ -96,6 +96,7 @@ describe('auction side effect helpers', () => {
|
||||
'life-1',
|
||||
'2',
|
||||
'completed',
|
||||
'',
|
||||
]);
|
||||
});
|
||||
});
|
||||
@@ -25,6 +25,7 @@ export interface BuildSideEffectLeaseAcquireUpdateParams {
|
||||
|
||||
export interface MatchSideEffectDelta {
|
||||
auctionLifecycleId: string;
|
||||
auctionStateTransitionId?: string;
|
||||
currentServerTimestampMS: number;
|
||||
matchSideEffectRevision: number;
|
||||
matchSideEffectStatus: AuctionMatchSideEffectStatus;
|
||||
@@ -36,6 +37,7 @@ export class AuctionSideEffectService {
|
||||
|
||||
public async mirrorMatchSideEffectStatus(params: {
|
||||
auctionLifecycleId: string;
|
||||
auctionStateTransitionId?: string;
|
||||
matchId: string;
|
||||
matchSideEffectRevision: number;
|
||||
matchSideEffectStatus: AuctionMatchSideEffectStatus;
|
||||
@@ -47,6 +49,8 @@ export class AuctionSideEffectService {
|
||||
'EVAL',
|
||||
[
|
||||
"if redis.call('HGET', KEYS[1], 'auctionLifecycleId') ~= ARGV[1] then return 0 end",
|
||||
"local generation = redis.call('HGET', KEYS[1], 'matchSideEffectTransitionId')",
|
||||
"if ARGV[4] ~= '' and generation and generation ~= ARGV[4] 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',
|
||||
@@ -58,6 +62,7 @@ export class AuctionSideEffectService {
|
||||
params.auctionLifecycleId,
|
||||
String(params.matchSideEffectRevision),
|
||||
params.matchSideEffectStatus,
|
||||
params.auctionStateTransitionId ?? '',
|
||||
]);
|
||||
return Number(result) === 1;
|
||||
}
|
||||
@@ -104,6 +109,9 @@ export function buildMatchSideEffectDelta(
|
||||
): MatchSideEffectDelta {
|
||||
return {
|
||||
auctionLifecycleId: params.auctionLifecycleId,
|
||||
...(params.auctionStateTransitionId
|
||||
? { auctionStateTransitionId: params.auctionStateTransitionId }
|
||||
: {}),
|
||||
currentServerTimestampMS: params.currentServerTimestampMS,
|
||||
matchSideEffectRevision: params.matchSideEffectRevision,
|
||||
matchSideEffectStatus: params.matchSideEffectStatus,
|
||||
|
||||
@@ -0,0 +1,101 @@
|
||||
import 'reflect-metadata';
|
||||
import mongoose from 'mongoose';
|
||||
import { GUARDS_METADATA } from '@nestjs/common/constants';
|
||||
import { METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED } from '../auth/allow-public-access.decorator';
|
||||
import type { UserDocument } from '../global/database/schema';
|
||||
|
||||
jest.mock('../auth/jwt.service', () => ({
|
||||
JwtService: class JwtService {},
|
||||
}));
|
||||
|
||||
import { AuctionController } from './auction.controller';
|
||||
|
||||
describe('AuctionController bid authentication', () => {
|
||||
beforeEach(() => {
|
||||
jest.replaceProperty(process, 'env', { ...process.env });
|
||||
delete process.env.AUCTION_REQUIRE_CAPTAIN_AUTH;
|
||||
});
|
||||
|
||||
afterEach(() => jest.restoreAllMocks());
|
||||
|
||||
it('allows HTTP guests to reach the configurable bid checks', () => {
|
||||
const handler = AuctionController.prototype.placeBid;
|
||||
expect(
|
||||
Reflect.getMetadata(METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED, handler),
|
||||
).toBe(true);
|
||||
expect(Reflect.getMetadata(GUARDS_METADATA, handler)).toBeUndefined();
|
||||
});
|
||||
|
||||
it.each([undefined, 'false', 'true'])(
|
||||
'handles HTTP guests with captain auth=%s',
|
||||
async (auth) => {
|
||||
if (auth !== undefined) process.env.AUCTION_REQUIRE_CAPTAIN_AUTH = auth;
|
||||
const placeBid = jest.fn().mockResolvedValue({ revision: 2 });
|
||||
const controller = new AuctionController(
|
||||
{ placeBid } as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const result = controller.placeBid(
|
||||
undefined,
|
||||
new mongoose.Types.ObjectId(),
|
||||
matchId,
|
||||
{
|
||||
bidderTeamIndex: 2,
|
||||
bidPointAmount: 20,
|
||||
},
|
||||
);
|
||||
if (auth === 'true') {
|
||||
await expect(result).rejects.toThrow(
|
||||
'팀장 계정으로 로그인해야 입찰할 수 있습니다.',
|
||||
);
|
||||
expect(placeBid).not.toHaveBeenCalled();
|
||||
} else {
|
||||
await expect(result).resolves.toEqual({ revision: 2 });
|
||||
expect(placeBid).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
matchId,
|
||||
teamIndex: 2,
|
||||
amount: 20,
|
||||
bidderUserId: undefined,
|
||||
}),
|
||||
);
|
||||
}
|
||||
},
|
||||
);
|
||||
|
||||
it('passes the signed-in user to service checks and restores community validation in strict mode', async () => {
|
||||
const placeBid = jest.fn().mockResolvedValue({ revision: 2 });
|
||||
const controller = new AuctionController(
|
||||
{ placeBid } as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
const user = {
|
||||
_id: new mongoose.Types.ObjectId(),
|
||||
communityId: new mongoose.Types.ObjectId(),
|
||||
} as UserDocument;
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const body = { bidderTeamIndex: 2, bidPointAmount: 20 };
|
||||
await controller.placeBid(
|
||||
user,
|
||||
new mongoose.Types.ObjectId(),
|
||||
matchId,
|
||||
body,
|
||||
);
|
||||
expect(placeBid).toHaveBeenLastCalledWith(
|
||||
expect.objectContaining({ bidderUserId: user._id }),
|
||||
);
|
||||
|
||||
process.env.AUCTION_REQUIRE_CAPTAIN_AUTH = 'true';
|
||||
await expect(
|
||||
controller.placeBid(user, new mongoose.Types.ObjectId(), matchId, body),
|
||||
).rejects.toThrow('Different community.');
|
||||
expect(placeBid).toHaveBeenCalledTimes(1);
|
||||
await expect(
|
||||
controller.placeBid(user, user.communityId, matchId, body),
|
||||
).resolves.toEqual({ revision: 2 });
|
||||
expect(placeBid).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
});
|
||||
@@ -3,12 +3,14 @@ import {
|
||||
Body,
|
||||
Controller,
|
||||
Delete,
|
||||
ForbiddenException,
|
||||
Get,
|
||||
HttpCode,
|
||||
HttpStatus,
|
||||
Param,
|
||||
Post,
|
||||
UseGuards,
|
||||
Query,
|
||||
} from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import { AllowPublicAccess } from '../auth/allow-public-access.decorator';
|
||||
@@ -18,7 +20,9 @@ import { RolesGuard } from '../auth/roles.guard';
|
||||
import { ParseObjectIdPipe } from '../common/parse-object-id.pipe';
|
||||
import type { UserDocument } from '../global/database/schema';
|
||||
import { AuctionService } from './auction.service';
|
||||
import { isAuctionCaptainAuthRequired } from './auction-bid-auth';
|
||||
import { AuctionGateway } from './auction.gateway';
|
||||
import { AuctionBidArchiveService } from './auction-bid-archive.service';
|
||||
import {
|
||||
NextAuctionDto,
|
||||
OpenBiddingDto,
|
||||
@@ -35,6 +39,7 @@ export class AuctionController {
|
||||
constructor(
|
||||
private readonly auctionService: AuctionService,
|
||||
private readonly auctionGateway: AuctionGateway,
|
||||
private readonly auctionBidArchiveService: AuctionBidArchiveService,
|
||||
) {}
|
||||
|
||||
@Post()
|
||||
@@ -77,7 +82,21 @@ export class AuctionController {
|
||||
return this.auctionService.getStateByMatchId(matchId);
|
||||
}
|
||||
|
||||
// 공개 — 팀장 2명만 쓸 엔드포인트(트러스트 기반, 10명 동시 관전).
|
||||
// 공개 입찰 기록 조회.
|
||||
@Get('bids/history')
|
||||
@AllowPublicAccess()
|
||||
public async getBidHistory(
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Query('afterRevision') afterRevision?: string,
|
||||
@Query('limit') limit?: string,
|
||||
) {
|
||||
return this.auctionBidArchiveService.list(
|
||||
matchId,
|
||||
afterRevision === undefined ? -1 : Number(afterRevision),
|
||||
limit === undefined ? 100 : Number(limit),
|
||||
);
|
||||
}
|
||||
|
||||
@Post('open-bidding')
|
||||
@AllowPublicAccess()
|
||||
@HttpCode(HttpStatus.OK)
|
||||
@@ -92,14 +111,27 @@ export class AuctionController {
|
||||
@AllowPublicAccess()
|
||||
@HttpCode(HttpStatus.OK)
|
||||
public async placeBid(
|
||||
@CurrentUser() currentUser: UserDocument | undefined,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Body() body: PlaceBidDto,
|
||||
) {
|
||||
if (isAuctionCaptainAuthRequired()) {
|
||||
if (!currentUser) {
|
||||
throw new ForbiddenException(
|
||||
'팀장 계정으로 로그인해야 입찰할 수 있습니다.',
|
||||
);
|
||||
}
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
}
|
||||
return this.auctionService.placeBid({
|
||||
matchId,
|
||||
bidderUserId: currentUser?._id,
|
||||
teamIndex: body.bidderTeamIndex,
|
||||
amount: body.bidPointAmount,
|
||||
bidRequestId: body.bidRequestId,
|
||||
clientObservedBidRoundId: body.clientObservedBidRoundId,
|
||||
clientObservedAuctionLifecycleId: body.clientObservedAuctionLifecycleId,
|
||||
clientObservedCurrentBidRoundPlayerUserId:
|
||||
body.clientObservedCurrentBidRoundPlayerUserId,
|
||||
@@ -213,7 +245,10 @@ export class AuctionController {
|
||||
clientObservedPhase: body.clientObservedPhase,
|
||||
clientObservedRevision: body.clientObservedRevision,
|
||||
});
|
||||
this.auctionGateway.broadcastReset(matchId.toString());
|
||||
this.auctionGateway.broadcastReset(
|
||||
matchId.toString(),
|
||||
body.clientObservedAuctionLifecycleId,
|
||||
);
|
||||
}
|
||||
|
||||
private assertSameCommunity(
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import mongoose from 'mongoose';
|
||||
import { ServiceUnavailableException } from '@nestjs/common';
|
||||
|
||||
jest.mock('../auth/jwt.service', () => ({
|
||||
JwtService: class JwtService {},
|
||||
@@ -7,12 +8,100 @@ jest.mock('../auth/jwt.service', () => ({
|
||||
import { AuctionGateway } from './auction.gateway';
|
||||
|
||||
describe('AuctionGateway', () => {
|
||||
beforeEach(() => {
|
||||
jest.replaceProperty(process, 'env', { ...process.env });
|
||||
delete process.env.AUCTION_REQUIRE_CAPTAIN_AUTH;
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
jest.restoreAllMocks();
|
||||
});
|
||||
|
||||
it('signals pending initial state so the client can retry privately after recovery', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
const gateway = new AuctionGateway(
|
||||
{
|
||||
getByMatchId: async () => ({}),
|
||||
getStateByMatchId: async () => {
|
||||
throw new ServiceUnavailableException({
|
||||
code: 'AUCTION_STATE_RECOVERING',
|
||||
message: 'recovering',
|
||||
});
|
||||
},
|
||||
} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
const socket = { data: { matchId }, join: jest.fn(), emit: jest.fn() };
|
||||
const ack = jest.fn();
|
||||
await gateway.handleJoin(socket as never, { matchId }, ack);
|
||||
expect(ack).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ ok: false, code: 'AUCTION_STATE_RECOVERING' }),
|
||||
);
|
||||
expect(socket.emit).toHaveBeenCalledTimes(1);
|
||||
expect(socket.emit).toHaveBeenCalledWith('state-pending', {
|
||||
retryAfterMS: 500,
|
||||
});
|
||||
});
|
||||
it('sends join and resync snapshots only to the requesting socket and coalesces in-flight resyncs', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
const getStateByMatchId = jest.fn().mockResolvedValue({ revision: 3 });
|
||||
const gateway = new AuctionGateway(
|
||||
{
|
||||
getByMatchId: async () => ({ chatMessages: [] }),
|
||||
getStateByMatchId,
|
||||
} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
const broadcast = jest.fn();
|
||||
(gateway as unknown as { server: unknown }).server = {
|
||||
to: () => ({ emit: broadcast }),
|
||||
};
|
||||
const socket = { data: { matchId }, join: jest.fn(), emit: jest.fn() };
|
||||
await gateway.handleJoin(socket as never, { matchId });
|
||||
expect(socket.emit).toHaveBeenCalledWith('state', { revision: 3 });
|
||||
expect(broadcast).not.toHaveBeenCalled();
|
||||
let finish!: (value: unknown) => void;
|
||||
getStateByMatchId.mockImplementationOnce(
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
finish = resolve;
|
||||
}),
|
||||
);
|
||||
const ack = jest.fn(),
|
||||
busyAck = jest.fn();
|
||||
const pending = gateway.handleResync(socket as never, {}, ack);
|
||||
await gateway.handleResync(socket as never, {}, busyAck);
|
||||
expect(busyAck).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ code: 'RESYNC_BUSY' }),
|
||||
);
|
||||
finish({ revision: 4 });
|
||||
await pending;
|
||||
expect(ack).toHaveBeenCalledWith({ ok: true, state: { revision: 4 } });
|
||||
expect(getStateByMatchId).toHaveBeenCalledTimes(2);
|
||||
expect(broadcast).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
const bidderUserId = new mongoose.Types.ObjectId();
|
||||
|
||||
function createGateway(params?: {
|
||||
getCurrentRedisTimestampMS?: jest.Mock;
|
||||
placeBidDelta?: jest.Mock;
|
||||
getRealtimeIdentity?: jest.Mock;
|
||||
}) {
|
||||
const auctionService = {
|
||||
placeBidDelta: params?.placeBidDelta ?? jest.fn(),
|
||||
getRealtimeIdentity:
|
||||
params?.getRealtimeIdentity ?? jest.fn().mockResolvedValue(null),
|
||||
};
|
||||
const auctionRedisService = {
|
||||
getCurrentRedisTimestampMS:
|
||||
@@ -41,6 +130,67 @@ describe('AuctionGateway', () => {
|
||||
};
|
||||
}
|
||||
|
||||
it('requires an authenticated user when captain authentication is enabled', async () => {
|
||||
process.env.AUCTION_REQUIRE_CAPTAIN_AUTH = 'true';
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
const { gateway, auctionService } = createGateway();
|
||||
const ack = jest.fn();
|
||||
|
||||
await gateway.handleBid(
|
||||
{ data: { matchId }, emit: jest.fn() } as never,
|
||||
{ bidderTeamIndex: 1, bidPointAmount: 100 },
|
||||
ack,
|
||||
);
|
||||
|
||||
expect(auctionService.placeBidDelta).not.toHaveBeenCalled();
|
||||
expect(ack).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ rejected: true }),
|
||||
);
|
||||
});
|
||||
|
||||
it.each([undefined, bidderUserId])(
|
||||
'accepts the selected team in temporary mode for user %s',
|
||||
async (userId) => {
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
const placeBidDelta = jest.fn().mockResolvedValue({
|
||||
auctionBidHistoryEntry: {
|
||||
bidderTeamIndex: 2,
|
||||
bidderUserId: new mongoose.Types.ObjectId().toString(),
|
||||
bidPointAmount: 120,
|
||||
bidPlacedAtTimestampMS: 1780000000000,
|
||||
},
|
||||
currentHighestBidderTeamIndex: 2,
|
||||
currentHighestBidPointAmount: 120,
|
||||
currentServerTimestampMS: 1780000000000,
|
||||
revision: 9,
|
||||
});
|
||||
const { gateway, emit } = createGateway({ placeBidDelta });
|
||||
const ack = jest.fn();
|
||||
|
||||
await gateway.handleBid(
|
||||
{
|
||||
data: { matchId, user: userId ? { _id: userId } : undefined },
|
||||
emit: jest.fn(),
|
||||
} as never,
|
||||
{ bidderTeamIndex: 2, bidPointAmount: 120 },
|
||||
ack,
|
||||
);
|
||||
|
||||
expect(placeBidDelta).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
teamIndex: 2,
|
||||
amount: 120,
|
||||
bidderUserId: userId,
|
||||
}),
|
||||
);
|
||||
expect(ack).toHaveBeenCalledWith(expect.objectContaining({ ok: true }));
|
||||
expect(emit).toHaveBeenCalledWith(
|
||||
'bid',
|
||||
expect.objectContaining({ currentHighestBidderTeamIndex: 2 }),
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
it('broadcasts a bid delta and acknowledges the matching bid request', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
const auctionBidHistoryEntry = {
|
||||
@@ -62,7 +212,10 @@ describe('AuctionGateway', () => {
|
||||
const ack = jest.fn();
|
||||
|
||||
await gateway.handleBid(
|
||||
{ data: { matchId }, emit: jest.fn() } as never,
|
||||
{
|
||||
data: { matchId, user: { _id: bidderUserId } },
|
||||
emit: jest.fn(),
|
||||
} as never,
|
||||
{
|
||||
bidPointAmount: 120,
|
||||
bidderTeamIndex: 2,
|
||||
@@ -76,6 +229,7 @@ describe('AuctionGateway', () => {
|
||||
expect(placeBidDelta).toHaveBeenCalledWith({
|
||||
amount: 120,
|
||||
bidRequestId: 'bid-1',
|
||||
bidderUserId,
|
||||
clientObservedAuctionLifecycleId: 'life-1',
|
||||
clientObservedCurrentBidRoundPlayerUserId: 'player-1',
|
||||
matchId: new mongoose.Types.ObjectId(matchId),
|
||||
@@ -129,7 +283,10 @@ describe('AuctionGateway', () => {
|
||||
const ack = jest.fn();
|
||||
|
||||
await gateway.handleBid(
|
||||
{ data: { matchId }, emit: jest.fn() } as never,
|
||||
{
|
||||
data: { matchId, user: { _id: bidderUserId } },
|
||||
emit: jest.fn(),
|
||||
} as never,
|
||||
{
|
||||
bidPointAmount: 50,
|
||||
bidderTeamIndex: 1,
|
||||
@@ -176,7 +333,10 @@ describe('AuctionGateway', () => {
|
||||
const ack = jest.fn();
|
||||
|
||||
await gateway.handleBid(
|
||||
{ data: { matchId }, emit: socketEmit } as never,
|
||||
{
|
||||
data: { matchId, user: { _id: bidderUserId } },
|
||||
emit: socketEmit,
|
||||
} as never,
|
||||
{
|
||||
bidPointAmount: 50,
|
||||
bidderTeamIndex: 1,
|
||||
@@ -234,6 +394,46 @@ describe('AuctionGateway', () => {
|
||||
);
|
||||
});
|
||||
|
||||
it('adds lightweight auction identity to heartbeats for the joined match', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
const identity = {
|
||||
auctionLifecycleId: 'life-1',
|
||||
revision: 11,
|
||||
matchSideEffectRevision: 3,
|
||||
};
|
||||
const getRealtimeIdentity = jest.fn().mockResolvedValue(identity);
|
||||
const { gateway } = createGateway({ getRealtimeIdentity });
|
||||
const ack = jest.fn();
|
||||
await gateway.handleTimeSync({ sequence: 1 }, ack, {
|
||||
data: { matchId },
|
||||
} as never);
|
||||
expect(getRealtimeIdentity).toHaveBeenCalledWith(matchId);
|
||||
expect(ack).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ ok: true, auctionState: identity }),
|
||||
);
|
||||
});
|
||||
|
||||
it('continues clock sync when the optional auction identity read fails', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
const { gateway } = createGateway({
|
||||
getRealtimeIdentity: jest
|
||||
.fn()
|
||||
.mockRejectedValue(new Error('identity unavailable')),
|
||||
});
|
||||
const ack = jest.fn();
|
||||
await gateway.handleTimeSync({ sequence: 2 }, ack, {
|
||||
data: { matchId },
|
||||
} as never);
|
||||
expect(ack).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
ok: true,
|
||||
sequence: 2,
|
||||
currentServerTimestampMS: 1780000000000,
|
||||
auctionStateUnavailable: true,
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('rate limits excessive bid requests from the same socket', async () => {
|
||||
jest.spyOn(Date, 'now').mockReturnValue(1780000000000);
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
@@ -247,7 +447,10 @@ describe('AuctionGateway', () => {
|
||||
revision: 3,
|
||||
});
|
||||
const socketEmit = jest.fn();
|
||||
const socket = { data: { matchId }, emit: socketEmit };
|
||||
const socket = {
|
||||
data: { matchId, user: { _id: bidderUserId } },
|
||||
emit: socketEmit,
|
||||
};
|
||||
const { gateway } = createGateway({ placeBidDelta });
|
||||
const acknowledgements: Array<Record<string, unknown>> = [];
|
||||
|
||||
@@ -288,7 +491,10 @@ describe('AuctionGateway', () => {
|
||||
currentHighestBidPointAmount: 50,
|
||||
revision: 3,
|
||||
});
|
||||
const socket = { data: { matchId }, emit: jest.fn() };
|
||||
const socket = {
|
||||
data: { matchId, user: { _id: bidderUserId } },
|
||||
emit: jest.fn(),
|
||||
};
|
||||
const { gateway } = createGateway({ placeBidDelta });
|
||||
|
||||
for (let index = 0; index < 8; index += 1) {
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import { Logger } from '@nestjs/common';
|
||||
import { ForbiddenException, Logger } from '@nestjs/common';
|
||||
import { randomUUID } from 'crypto';
|
||||
import { performance } from 'perf_hooks';
|
||||
import {
|
||||
@@ -14,6 +14,11 @@ import {
|
||||
import mongoose from 'mongoose';
|
||||
import type { JWTPayload } from 'jose';
|
||||
import type { DefaultEventsMap, Namespace, Socket } from 'socket.io';
|
||||
import type {
|
||||
AuctionReactionEvent,
|
||||
AuctionReactionKind,
|
||||
AuctionReactionReply,
|
||||
} from '@lolympus/contracts';
|
||||
import { AuthService } from '../auth/auth.service';
|
||||
import { IdentityService } from '../auth/identity.service';
|
||||
import { JwtService } from '../auth/jwt.service';
|
||||
@@ -31,6 +36,7 @@ import type {
|
||||
AuctionStateResponse,
|
||||
} from './auction.service';
|
||||
import { AuctionEventBusService } from './auction-event-bus.service';
|
||||
import { isAuctionCaptainAuthRequired } from './auction-bid-auth';
|
||||
import {
|
||||
isAuctionResyncRecommended,
|
||||
resolveAuctionRejectionReason,
|
||||
@@ -44,6 +50,7 @@ interface JoinAuctionPayload {
|
||||
}
|
||||
|
||||
interface BidPayload {
|
||||
clientObservedBidRoundId?: string;
|
||||
bidderTeamIndex: number;
|
||||
bidPointAmount: number;
|
||||
bidRequestId?: string;
|
||||
@@ -71,6 +78,7 @@ type AuctionActionPayload = Omit<SoldPayload, 'assignedPosition'>;
|
||||
interface ChatMessagePayload {
|
||||
message?: string;
|
||||
displayName?: string;
|
||||
clientMessageId?: string;
|
||||
}
|
||||
|
||||
interface BidRateLimitState {
|
||||
@@ -79,10 +87,14 @@ interface BidRateLimitState {
|
||||
}
|
||||
|
||||
interface AuctionSocketData {
|
||||
auctionReactionSentAt?: number;
|
||||
auctionResyncAtTimestampMS?: number;
|
||||
auctionResyncInProgress?: boolean;
|
||||
auctionBidRateLimit?: BidRateLimitState;
|
||||
identity?: IdentityDocument;
|
||||
matchId?: string;
|
||||
user?: UserDocument;
|
||||
devUser?: UserDocument;
|
||||
}
|
||||
|
||||
type AuctionSocket = Socket<
|
||||
@@ -93,6 +105,24 @@ type AuctionSocket = Socket<
|
||||
>;
|
||||
|
||||
const BID_RATE_LIMIT_WINDOW_MS = 1000;
|
||||
const REACTION_KINDS: Record<AuctionReactionKind, true> = {
|
||||
'thumbs-up': true,
|
||||
heart: true,
|
||||
clap: true,
|
||||
laugh: true,
|
||||
wow: true,
|
||||
sad: true,
|
||||
fire: true,
|
||||
celebrate: true,
|
||||
eyes: true,
|
||||
thinking: true,
|
||||
'skull-crossbones': true,
|
||||
poop: true,
|
||||
pray: true,
|
||||
'sweat-smile': true,
|
||||
money: true,
|
||||
trophy: true,
|
||||
};
|
||||
const BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW = 8;
|
||||
const BID_RATE_LIMIT_REJECTION_CODE = 'BID_RATE_LIMITED';
|
||||
const BID_RATE_LIMIT_REJECTION_MESSAGE =
|
||||
@@ -111,6 +141,10 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
|
||||
private server!: Namespace;
|
||||
|
||||
private readonly logger = new Logger(AuctionGateway.name);
|
||||
private readonly socketAuthentication = new WeakMap<
|
||||
AuctionSocket,
|
||||
Promise<void>
|
||||
>();
|
||||
|
||||
constructor(
|
||||
private readonly auctionService: AuctionService,
|
||||
@@ -127,8 +161,10 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
|
||||
}
|
||||
|
||||
public async handleConnection(socket: AuctionSocket) {
|
||||
const authentication = this.authenticateSocket(socket);
|
||||
this.socketAuthentication.set(socket, authentication);
|
||||
try {
|
||||
await this.authenticateSocket(socket);
|
||||
await authentication;
|
||||
this.logger.debug(`Auction client connected: ${socket.id}`);
|
||||
} catch (err) {
|
||||
this.logger.warn(
|
||||
@@ -144,17 +180,21 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
|
||||
public async handleJoin(
|
||||
@ConnectedSocket() socket: AuctionSocket,
|
||||
@MessageBody() payload: JoinAuctionPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
if (!payload?.matchId || !mongoose.isValidObjectId(payload.matchId)) {
|
||||
this.emitError(socket, 'Invalid matchId.');
|
||||
ack?.({ ok: false, code: 'INVALID_MATCH_ID' });
|
||||
return;
|
||||
}
|
||||
|
||||
await socket.join(payload.matchId);
|
||||
socket.data.matchId = payload.matchId;
|
||||
|
||||
try {
|
||||
socket.data.matchId = undefined;
|
||||
socket.data.user = undefined;
|
||||
await this.socketAuthentication.get(socket);
|
||||
await socket.join(payload.matchId);
|
||||
await this.resolveSocketUserForMatch(socket, payload.matchId);
|
||||
socket.data.matchId = payload.matchId;
|
||||
const auction = await this.auctionService.getByMatchId(
|
||||
new mongoose.Types.ObjectId(payload.matchId),
|
||||
);
|
||||
@@ -162,9 +202,57 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
|
||||
new mongoose.Types.ObjectId(payload.matchId),
|
||||
);
|
||||
this.emitChatHistory(socket, auction);
|
||||
this.broadcastState(payload.matchId, auctionState);
|
||||
socket.emit('state', serializeRealtimeAuction(auctionState));
|
||||
ack?.({ ok: true });
|
||||
} catch (error) {
|
||||
this.emitKnownError(socket, error);
|
||||
const rejection = this.resolveErrorPayload(error);
|
||||
ack?.({ ...rejection, ok: false });
|
||||
if (rejection.code === 'AUCTION_STATE_RECOVERING') {
|
||||
socket.emit('state-pending', { retryAfterMS: 500 });
|
||||
} else {
|
||||
this.emitKnownError(socket, error);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeMessage('resync')
|
||||
public async handleResync(
|
||||
@ConnectedSocket() socket: AuctionSocket,
|
||||
@MessageBody() _payload: unknown,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
const matchId = this.requireJoinedMatchId(socket);
|
||||
if (!matchId) {
|
||||
ack?.({ ok: false, code: 'JOIN_REQUIRED' });
|
||||
return;
|
||||
}
|
||||
const now = Date.now();
|
||||
const retryAfterMS =
|
||||
500 - (now - (socket.data.auctionResyncAtTimestampMS ?? 0));
|
||||
if (socket.data.auctionResyncInProgress || retryAfterMS > 0) {
|
||||
ack?.({
|
||||
ok: false,
|
||||
code: 'RESYNC_BUSY',
|
||||
retryAfterMS: Math.max(500, retryAfterMS),
|
||||
});
|
||||
return;
|
||||
}
|
||||
socket.data.auctionResyncInProgress = true;
|
||||
socket.data.auctionResyncAtTimestampMS = now;
|
||||
try {
|
||||
const state = await this.auctionService.getStateByMatchId(
|
||||
new mongoose.Types.ObjectId(matchId),
|
||||
);
|
||||
// Only the requesting socket receives the full snapshot.
|
||||
ack?.({ ok: true, state: serializeRealtimeAuction(state) });
|
||||
} catch (error) {
|
||||
ack?.({
|
||||
...this.resolveErrorPayload(error),
|
||||
ok: false,
|
||||
retryAfterMS: 500,
|
||||
});
|
||||
} finally {
|
||||
socket.data.auctionResyncInProgress = false;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -191,11 +279,18 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
|
||||
}
|
||||
|
||||
try {
|
||||
const bidderUserId = this.resolveSocketUserId(socket);
|
||||
if (isAuctionCaptainAuthRequired() && !bidderUserId)
|
||||
throw new ForbiddenException(
|
||||
'팀장 계정으로 로그인해야 입찰할 수 있습니다.',
|
||||
);
|
||||
const bidResult = await this.auctionService.placeBidDelta({
|
||||
matchId: new mongoose.Types.ObjectId(matchId),
|
||||
teamIndex: payload.bidderTeamIndex,
|
||||
amount: payload.bidPointAmount,
|
||||
bidRequestId,
|
||||
bidderUserId,
|
||||
clientObservedBidRoundId: payload.clientObservedBidRoundId,
|
||||
clientObservedAuctionLifecycleId:
|
||||
payload.clientObservedAuctionLifecycleId,
|
||||
clientObservedCurrentBidRoundPlayerUserId:
|
||||
@@ -256,14 +351,27 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
|
||||
public async handleTimeSync(
|
||||
@MessageBody() payload: TimeSyncPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
@ConnectedSocket() socket?: AuctionSocket,
|
||||
) {
|
||||
const receivedAtMonotonicMS = performance.now();
|
||||
try {
|
||||
const currentServerTimestampMS =
|
||||
await this.auctionRedisService.getCurrentRedisTimestampMS();
|
||||
const [currentServerTimestampMS, auctionState] = await Promise.all([
|
||||
this.auctionRedisService.getCurrentRedisTimestampMS(),
|
||||
socket?.data.matchId
|
||||
? this.auctionService
|
||||
.getRealtimeIdentity(socket.data.matchId)
|
||||
.catch(() => undefined)
|
||||
: undefined,
|
||||
]);
|
||||
ack?.({
|
||||
clientSentAtTimestampMS: payload?.clientSentAtTimestampMS,
|
||||
currentServerTimestampMS,
|
||||
...(socket?.data.matchId
|
||||
? {
|
||||
auctionState,
|
||||
auctionStateUnavailable: auctionState === undefined,
|
||||
}
|
||||
: {}),
|
||||
ok: true,
|
||||
sequence: payload?.sequence,
|
||||
serverProcessingDurationMS:
|
||||
@@ -401,30 +509,82 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
|
||||
public async handleChatMessage(
|
||||
@ConnectedSocket() socket: AuctionSocket,
|
||||
@MessageBody() payload: ChatMessagePayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
const matchId = this.requireJoinedMatchId(socket);
|
||||
if (!matchId) return;
|
||||
if (!matchId) {
|
||||
ack?.({ ok: false, message: 'Join a match room before sending events.' });
|
||||
return;
|
||||
}
|
||||
|
||||
if (typeof payload?.message !== 'string') {
|
||||
this.emitError(socket, 'Chat message is required.');
|
||||
ack?.({ ok: false, message: 'Chat message is required.' });
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
const { message } = await this.auctionService.appendChatMessage({
|
||||
const { message, created } = await this.auctionService.appendChatMessage({
|
||||
matchId: new mongoose.Types.ObjectId(matchId),
|
||||
clientMessageId: payload.clientMessageId,
|
||||
senderRole: ['owner', 'admin'].includes(socket.data.user?.role ?? '')
|
||||
? 'operator'
|
||||
: undefined,
|
||||
userId: this.resolveSocketUserId(socket),
|
||||
displayName: this.resolveChatDisplayName(socket, payload.displayName),
|
||||
message: payload.message,
|
||||
});
|
||||
this.server
|
||||
.to(matchId)
|
||||
.emit('chat-message', this.serializeChatMessage(message));
|
||||
const serialized = this.serializeChatMessage(message);
|
||||
if (created) this.server.to(matchId).emit('chat-message', serialized);
|
||||
ack?.({ ok: true, message: serialized });
|
||||
} catch (error) {
|
||||
this.emitKnownError(socket, error);
|
||||
if (ack) ack({ ok: false, ...this.resolveErrorPayload(error) });
|
||||
else this.emitKnownError(socket, error);
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeMessage('chat-reaction')
|
||||
public handleChatReaction(
|
||||
@ConnectedSocket() socket: AuctionSocket,
|
||||
@MessageBody() payload: { kind?: unknown },
|
||||
@Ack() ack?: (response: AuctionReactionReply) => void,
|
||||
) {
|
||||
const matchId = this.getSocketMatchId(socket);
|
||||
if (!matchId) {
|
||||
ack?.({ ok: false, code: 'NOT_JOINED' });
|
||||
return;
|
||||
}
|
||||
if (
|
||||
typeof payload?.kind !== 'string' ||
|
||||
!Object.hasOwn(REACTION_KINDS, payload.kind)
|
||||
) {
|
||||
ack?.({ ok: false, code: 'INVALID_REACTION' });
|
||||
return;
|
||||
}
|
||||
const now = Date.now();
|
||||
if (
|
||||
socket.data.auctionReactionSentAt !== undefined &&
|
||||
now - socket.data.auctionReactionSentAt < 400
|
||||
) {
|
||||
ack?.({ ok: false, code: 'REACTION_RATE_LIMITED' });
|
||||
return;
|
||||
}
|
||||
socket.data.auctionReactionSentAt = now;
|
||||
const reaction: AuctionReactionEvent = {
|
||||
id: randomUUID(),
|
||||
kind: payload.kind as AuctionReactionKind,
|
||||
displayName: Array.from(this.resolveChatDisplayName(socket))
|
||||
.slice(0, 40)
|
||||
.join(''),
|
||||
userId: this.resolveSocketUserId(socket)?.toString(),
|
||||
sentAt: now,
|
||||
};
|
||||
// The room adapter fans out to all viewers. Reactions never enter the
|
||||
// persisted message history, so reconnects do not replay old animations.
|
||||
this.server.to(matchId).emit('chat-reaction', reaction);
|
||||
ack?.({ ok: true, reaction });
|
||||
}
|
||||
|
||||
private requireJoinedMatchId(socket: AuctionSocket): string | null {
|
||||
const matchId = this.getSocketMatchId(socket);
|
||||
if (!matchId) {
|
||||
@@ -523,14 +683,13 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
|
||||
this.readHandshakeUserId(socket),
|
||||
);
|
||||
if (fallback) {
|
||||
socket.data.user = fallback.user;
|
||||
socket.data.devUser = fallback.user;
|
||||
socket.data.identity = fallback.identity;
|
||||
return;
|
||||
}
|
||||
|
||||
const token = this.readHandshakeToken(socket);
|
||||
if (!token) {
|
||||
// 임시 운영용: 경매 진행 중에는 로그인 없이도 관전/팀장 모드 선택/입찰을 허용한다.
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -572,14 +731,22 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
|
||||
socket: AuctionSocket,
|
||||
matchId: string,
|
||||
): Promise<void> {
|
||||
if (socket.data.user || !socket.data.identity) return;
|
||||
const devUser = socket.data.devUser;
|
||||
const identity = socket.data.identity;
|
||||
if (!devUser && !identity) return;
|
||||
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const match = await MatchModel.findById(matchId).select({
|
||||
communityId: 1,
|
||||
});
|
||||
if (!match) return;
|
||||
if (devUser) {
|
||||
socket.data.user = devUser.communityId.equals(match.communityId)
|
||||
? devUser
|
||||
: undefined;
|
||||
return;
|
||||
}
|
||||
if (!identity) return;
|
||||
|
||||
const UserModel = await this.connectionService.getModel('user');
|
||||
const user = await UserModel.findOne({
|
||||
@@ -609,8 +776,11 @@ export class AuctionGateway implements OnGatewayConnection, OnGatewayInit {
|
||||
this.server.to(matchId).emit('bid', delta);
|
||||
}
|
||||
|
||||
public broadcastReset(matchId: string) {
|
||||
this.server.to(matchId).emit('reset', { matchId });
|
||||
public broadcastReset(matchId: string, auctionLifecycleId?: string) {
|
||||
this.server.to(matchId).emit('reset', {
|
||||
matchId,
|
||||
...(auctionLifecycleId ? { auctionLifecycleId } : {}),
|
||||
});
|
||||
}
|
||||
|
||||
public broadcastMatchSideEffect(
|
||||
|
||||
@@ -10,6 +10,7 @@ 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';
|
||||
import { AuctionBidArchiveService } from './auction-bid-archive.service';
|
||||
|
||||
@Module({
|
||||
imports: [
|
||||
@@ -21,6 +22,7 @@ import { AuctionService } from './auction.service';
|
||||
controllers: [AuctionController],
|
||||
providers: [
|
||||
AuctionService,
|
||||
AuctionBidArchiveService,
|
||||
AuctionGateway,
|
||||
AuctionEventBusService,
|
||||
AuctionDeadlineScheduler,
|
||||
|
||||
@@ -45,6 +45,10 @@ describe('AuctionService', () => {
|
||||
const allModels = {
|
||||
auctionHistory: auctionHistoryModel,
|
||||
...models,
|
||||
auction: {
|
||||
updateOne: jest.fn().mockResolvedValue({ matchedCount: 1 }),
|
||||
...((models.auction as object) ?? {}),
|
||||
},
|
||||
};
|
||||
const connectionService = {
|
||||
getModel: jest.fn((name: string) => allModels[name]),
|
||||
@@ -152,6 +156,11 @@ describe('AuctionService', () => {
|
||||
};
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
jest.replaceProperty(process, 'env', { ...process.env });
|
||||
delete process.env.AUCTION_REQUIRE_CAPTAIN_AUTH;
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
jest.restoreAllMocks();
|
||||
jest.useRealTimers();
|
||||
@@ -206,8 +215,7 @@ describe('AuctionService', () => {
|
||||
expect(auctionRedisCommandService.placeBid).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('lists auction history with a summary projection and short local cache', async () => {
|
||||
const nowSpy = jest.spyOn(Date, 'now').mockReturnValue(1000);
|
||||
it('reads committed history on every node without retaining a local cache', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const match = {
|
||||
@@ -233,7 +241,7 @@ describe('AuctionService', () => {
|
||||
const historySort = jest.fn().mockReturnValue({ limit: historyLimit });
|
||||
const historySelect = jest.fn().mockReturnValue({ sort: historySort });
|
||||
const historyFind = jest.fn().mockReturnValue({ select: historySelect });
|
||||
const { service } = createService({
|
||||
const models = {
|
||||
auctionHistory: {
|
||||
find: historyFind,
|
||||
},
|
||||
@@ -242,7 +250,9 @@ describe('AuctionService', () => {
|
||||
select: jest.fn().mockResolvedValue(match),
|
||||
}),
|
||||
},
|
||||
});
|
||||
};
|
||||
const { service } = createService(models);
|
||||
const otherNode = createService(models).service;
|
||||
|
||||
await expect(
|
||||
service.listHistory({ matchId, communityId }),
|
||||
@@ -262,7 +272,7 @@ describe('AuctionService', () => {
|
||||
]);
|
||||
await service.listHistory({ matchId, communityId });
|
||||
|
||||
expect(historyFind).toHaveBeenCalledTimes(1);
|
||||
expect(historyFind).toHaveBeenCalledTimes(2);
|
||||
expect(historySelect).toHaveBeenCalledWith({
|
||||
_id: 0,
|
||||
action: 1,
|
||||
@@ -272,9 +282,17 @@ describe('AuctionService', () => {
|
||||
expect(historySort).toHaveBeenCalledWith({ sequence: -1 });
|
||||
expect(historyLimit).toHaveBeenCalledWith(100);
|
||||
|
||||
nowSpy.mockReturnValue(3101);
|
||||
await service.listHistory({ matchId, communityId });
|
||||
expect(historyFind).toHaveBeenCalledTimes(2);
|
||||
historyExec.mockResolvedValue([
|
||||
{ action: 'undo', sequence: 5, takenAt: new Date() },
|
||||
historyRows[1],
|
||||
]);
|
||||
const [firstNodeHistory, secondNodeHistory] = await Promise.all([
|
||||
service.listHistory({ matchId, communityId }),
|
||||
otherNode.listHistory({ matchId, communityId }),
|
||||
]);
|
||||
expect(firstNodeHistory.map(({ sequence }) => sequence)).toEqual([5, 3]);
|
||||
expect(secondNodeHistory).toEqual(firstNodeHistory);
|
||||
expect(historyFind).toHaveBeenCalledTimes(4);
|
||||
});
|
||||
|
||||
it('starts an auction without reserving tournament codes before teams are complete', async () => {
|
||||
@@ -697,7 +715,7 @@ describe('AuctionService', () => {
|
||||
expect(auctionRedisService.raw().sendCommand).toHaveBeenCalledWith([
|
||||
'EVAL',
|
||||
expect.stringContaining('currentAuctionLifecycleId'),
|
||||
'11',
|
||||
'12',
|
||||
`auction:${matchId.toString()}:liveAuctionState`,
|
||||
'auction:bidRoundDeadlineQueue',
|
||||
`auction:${matchId.toString()}:auctionStructureState`,
|
||||
@@ -709,6 +727,7 @@ describe('AuctionService', () => {
|
||||
`auction:${matchId.toString()}:auctionActionRequestResultOrder`,
|
||||
`auction:${matchId.toString()}:rehydrateLock`,
|
||||
`auction:${matchId.toString()}:auctionStateTransitionLock`,
|
||||
`auction:${matchId.toString()}:rejectedBidRequestResultOrder`,
|
||||
matchId.toString(),
|
||||
'old-life-1',
|
||||
]);
|
||||
@@ -909,9 +928,9 @@ describe('AuctionService', () => {
|
||||
shouldForceAuctionStateResync: true,
|
||||
});
|
||||
expect(auctionRedisService.acquireTokenLock).toHaveBeenCalledWith(
|
||||
`auction:${matchId.toString()}:rehydrateLock`,
|
||||
`auction:${matchId.toString()}:lifecycleMutationLock`,
|
||||
expect.any(String),
|
||||
5000,
|
||||
30000,
|
||||
);
|
||||
expect(auctionRedisCommandService.hydrateState).toHaveBeenCalledWith(
|
||||
matchId.toString(),
|
||||
@@ -1050,6 +1069,113 @@ describe('AuctionService', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe.each(['realtime', 'redis-fallback', 'legacy'] as const)(
|
||||
'%s bid authorization',
|
||||
(path) => {
|
||||
it.each([
|
||||
[undefined, 'guest'],
|
||||
[undefined, 'other-user'],
|
||||
['false', 'other-user'],
|
||||
['true', 'guest'],
|
||||
['true', 'other-user'],
|
||||
['true', 'captain'],
|
||||
] as const)('checks auth=%s for %s', async (auth, actor) => {
|
||||
if (auth !== undefined) process.env.AUCTION_REQUIRE_CAPTAIN_AUTH = auth;
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const captainUserId = new mongoose.Types.ObjectId();
|
||||
const playerUserId = new mongoose.Types.ObjectId();
|
||||
const bidderUserId =
|
||||
actor === 'guest'
|
||||
? undefined
|
||||
: actor === 'captain'
|
||||
? captainUserId
|
||||
: new mongoose.Types.ObjectId();
|
||||
const team = { teamIndex: 2, captainUserId, points: 1000, members: [] };
|
||||
const auction = {
|
||||
_id: new mongoose.Types.ObjectId(),
|
||||
matchId,
|
||||
auctionEngineVersion: path === 'legacy' ? undefined : 'redis-v1',
|
||||
phase: 'bidding',
|
||||
teams: [team],
|
||||
currentBid: 0,
|
||||
bidExtensionSeconds: 5,
|
||||
bids: [],
|
||||
save: jest.fn().mockResolvedValue(undefined),
|
||||
toObject: () => ({ matchId, teams: [team], phase: 'bidding' }),
|
||||
};
|
||||
const {
|
||||
service,
|
||||
auctionRedisCommandService,
|
||||
auctionRedisStateReaderService,
|
||||
} = createService({
|
||||
auction: { findOne: jest.fn().mockResolvedValue(auction) },
|
||||
});
|
||||
const state = {
|
||||
auctionLifecycleId: 'life-1',
|
||||
currentBidRoundPlayerUserId: playerUserId.toString(),
|
||||
phase: 'bidding',
|
||||
revision: 2,
|
||||
auctionTeams: [
|
||||
{
|
||||
teamIndex: 2,
|
||||
captainUserId: captainUserId.toString(),
|
||||
remainingBidPointAmount: 1000,
|
||||
members: [],
|
||||
},
|
||||
],
|
||||
};
|
||||
auctionRedisStateReaderService.readAuctionStateView.mockResolvedValue(
|
||||
state,
|
||||
);
|
||||
if (path === 'realtime') {
|
||||
auctionRedisStateReaderService.readBidContext.mockResolvedValue({
|
||||
...state,
|
||||
bidderTeamCaptainUserId: captainUserId.toString(),
|
||||
});
|
||||
}
|
||||
|
||||
const result = service.placeBidDelta({
|
||||
matchId,
|
||||
teamIndex: 2,
|
||||
amount: 20,
|
||||
bidderUserId,
|
||||
bidRequestId: 'auth-mode-bid',
|
||||
});
|
||||
if (auth === 'true' && actor !== 'captain') {
|
||||
await expect(result).rejects.toThrow(
|
||||
actor === 'guest'
|
||||
? '팀장 계정으로 로그인해야 입찰할 수 있습니다.'
|
||||
: '해당 팀의 팀장만 입찰할 수 있습니다.',
|
||||
);
|
||||
expect(auctionRedisCommandService.placeBid).not.toHaveBeenCalled();
|
||||
expect(auction.save).not.toHaveBeenCalled();
|
||||
return;
|
||||
}
|
||||
|
||||
await expect(result).resolves.toBeDefined();
|
||||
if (path === 'legacy') {
|
||||
expect(auction.bids).toEqual([
|
||||
expect.objectContaining({
|
||||
teamIndex: 2,
|
||||
amount: 20,
|
||||
bidderUserId: captainUserId,
|
||||
}),
|
||||
]);
|
||||
expect(auction.save).toHaveBeenCalledTimes(1);
|
||||
} else {
|
||||
expect(auctionRedisCommandService.placeBid).toHaveBeenCalledWith(
|
||||
matchId.toString(),
|
||||
expect.objectContaining({
|
||||
bidderTeamIndex: 2,
|
||||
bidPointAmount: 20,
|
||||
bidderUserId: captainUserId.toString(),
|
||||
}),
|
||||
);
|
||||
}
|
||||
});
|
||||
},
|
||||
);
|
||||
|
||||
it('places bids through Redis for redis-v1 auctions', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const captainUserId = new mongoose.Types.ObjectId();
|
||||
@@ -1742,9 +1868,17 @@ describe('AuctionService', () => {
|
||||
chatMessages: oldMessages,
|
||||
save: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const findOneAndUpdate = jest.fn().mockImplementation((_filter, update) => {
|
||||
auction.chatMessages = [
|
||||
...auction.chatMessages,
|
||||
...update.$push.chatMessages.$each,
|
||||
].slice(-200);
|
||||
return auction;
|
||||
});
|
||||
const { service } = createService({
|
||||
auction: {
|
||||
findOne: jest.fn().mockResolvedValue(auction),
|
||||
findOneAndUpdate,
|
||||
},
|
||||
});
|
||||
|
||||
@@ -1765,7 +1899,54 @@ describe('AuctionService', () => {
|
||||
expect(auction.chatMessages).toHaveLength(200);
|
||||
expect(auction.chatMessages[0].id).toBe('old-1');
|
||||
expect(auction.chatMessages.at(-1)).toBe(appended.message);
|
||||
expect(auction.save).toHaveBeenCalledTimes(1);
|
||||
expect(auction.save).not.toHaveBeenCalled();
|
||||
expect(appended.created).toBe(true);
|
||||
expect(findOneAndUpdate).toHaveBeenCalledWith(
|
||||
{ matchId, 'chatMessages.id': { $ne: appended.message.id } },
|
||||
{ $push: { chatMessages: { $each: [appended.message], $slice: -200 } } },
|
||||
{ returnDocument: 'after' },
|
||||
);
|
||||
});
|
||||
|
||||
it('returns the saved message on retry without appending or broadcasting it again', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const userId = new mongoose.Types.ObjectId();
|
||||
const clientMessageId = '0589e8a4-bccd-4ccd-a3ae-28f117401e79';
|
||||
const saved = {
|
||||
id: `${userId.toString()}:${clientMessageId}`,
|
||||
clientMessageId,
|
||||
userId,
|
||||
displayName: '팀장',
|
||||
message: '확인했습니다',
|
||||
sentAt: new Date(),
|
||||
};
|
||||
const findOneAndUpdate = jest.fn().mockResolvedValue(null);
|
||||
const auction = { matchId, chatMessages: [saved] };
|
||||
const { service } = createService({
|
||||
auction: {
|
||||
findOneAndUpdate,
|
||||
findOne: jest.fn().mockResolvedValue(auction),
|
||||
},
|
||||
});
|
||||
await expect(
|
||||
service.appendChatMessage({
|
||||
matchId,
|
||||
userId,
|
||||
clientMessageId,
|
||||
message: '확인했습니다',
|
||||
}),
|
||||
).resolves.toEqual({ auction, message: saved, created: false });
|
||||
expect(findOneAndUpdate.mock.calls[0][0]['chatMessages.id']).toEqual({
|
||||
$ne: saved.id,
|
||||
});
|
||||
await expect(
|
||||
service.appendChatMessage({
|
||||
matchId,
|
||||
userId,
|
||||
clientMessageId,
|
||||
message: '다른 메시지',
|
||||
}),
|
||||
).rejects.toThrow('Chat message conflicts with an earlier request.');
|
||||
});
|
||||
|
||||
it('rejects blank and overly long chat messages', async () => {
|
||||
@@ -2621,8 +2802,14 @@ describe('AuctionService', () => {
|
||||
auctionRedisCommandService.reserveActionRequest,
|
||||
).not.toHaveBeenCalled();
|
||||
expect(auctionRedisCommandService.applyTransition).not.toHaveBeenCalled();
|
||||
expect(tournamentCodeService.releaseFromMatch).toHaveBeenCalledWith(match);
|
||||
expect(tournamentResultService.cancelPolling).toHaveBeenCalledWith(match);
|
||||
expect(tournamentCodeService.releaseFromMatch).toHaveBeenCalledWith(
|
||||
match,
|
||||
session,
|
||||
);
|
||||
expect(tournamentResultService.cancelPolling).toHaveBeenCalledWith(
|
||||
match,
|
||||
session,
|
||||
);
|
||||
expect(match).toMatchObject({
|
||||
gameSchedule: [],
|
||||
result: undefined,
|
||||
@@ -2642,13 +2829,12 @@ describe('AuctionService', () => {
|
||||
auctionId,
|
||||
});
|
||||
expect(auction.deleteOne).toHaveBeenCalledWith({ session });
|
||||
expect(redisClient.sendCommand).toHaveBeenCalledWith(
|
||||
expect.arrayContaining([
|
||||
'auction:bidRoundDeadlineQueue',
|
||||
matchId.toString(),
|
||||
'life-1',
|
||||
]),
|
||||
);
|
||||
expect(redisClient.sendCommand).not.toHaveBeenCalled();
|
||||
expect(match).toMatchObject({
|
||||
lastCancelledAuctionLifecycleId: 'life-1',
|
||||
auctionCancellationCleanupPending: true,
|
||||
auctionCancellationCleanupRetryAt: expect.any(Date),
|
||||
});
|
||||
expect(session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
@@ -2732,8 +2918,14 @@ describe('AuctionService', () => {
|
||||
service.undoTo({ matchId, communityId, sequence: 3 }),
|
||||
).resolves.toBe(restored);
|
||||
|
||||
expect(tournamentCodeService.releaseFromMatch).toHaveBeenCalledWith(match);
|
||||
expect(tournamentResultService.cancelPolling).toHaveBeenCalledWith(match);
|
||||
expect(tournamentCodeService.releaseFromMatch).toHaveBeenCalledWith(
|
||||
match,
|
||||
session,
|
||||
);
|
||||
expect(tournamentResultService.cancelPolling).toHaveBeenCalledWith(
|
||||
match,
|
||||
session,
|
||||
);
|
||||
expect(match.status).toBe('team-built');
|
||||
expect(match.result).toBeUndefined();
|
||||
expect(auctionReplaceOne).toHaveBeenCalledWith(
|
||||
|
||||
@@ -1,12 +1,23 @@
|
||||
import {
|
||||
BadRequestException,
|
||||
ForbiddenException,
|
||||
ConflictException,
|
||||
Injectable,
|
||||
InternalServerErrorException,
|
||||
Logger,
|
||||
NotFoundException,
|
||||
ServiceUnavailableException,
|
||||
Optional,
|
||||
} from '@nestjs/common';
|
||||
import { randomUUID } from 'crypto';
|
||||
import type { AuctionStateIdentity } from '@lolympus/contracts';
|
||||
import {
|
||||
AuctionLifecycleLock,
|
||||
AuctionLifecycleBusyError,
|
||||
} from './auction-lifecycle-lock';
|
||||
import { AUCTION_OPTIONAL_PROJECTION_FIELDS } from './auction-projection';
|
||||
import { AuctionEventBusService } from './auction-event-bus.service';
|
||||
import { isAuctionCaptainAuthRequired } from './auction-bid-auth';
|
||||
import { performance } from 'perf_hooks';
|
||||
import mongoose from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
@@ -58,11 +69,7 @@ const AUCTION_BID_REQUEST_REPLAY_WINDOW_MS = 5 * 60 * 1000;
|
||||
const AUCTION_MAX_STORED_ACTION_REQUEST_RESULT_COUNT = 500;
|
||||
const AUCTION_ACTION_REQUEST_REPLAY_WINDOW_MS = 5 * 60 * 1000;
|
||||
const AUCTION_ACTION_REQUEST_LEASE_DURATION_MS = 15 * 1000;
|
||||
const AUCTION_REHYDRATE_LOCK_TTL_MS = 5 * 1000;
|
||||
const AUCTION_REHYDRATE_LOCK_WAIT_MS = 50;
|
||||
const AUCTION_HISTORY_LIST_LIMIT = 100;
|
||||
const AUCTION_HISTORY_LIST_CACHE_TTL_MS = 2 * 1000;
|
||||
const AUCTION_HISTORY_LIST_CACHE_MAX_ENTRIES = 256;
|
||||
|
||||
interface StartAuctionParams {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
@@ -82,6 +89,7 @@ interface StartAuctionParams {
|
||||
}
|
||||
|
||||
interface PlaceBidParams {
|
||||
clientObservedBidRoundId?: string;
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
teamIndex: number;
|
||||
amount: number;
|
||||
@@ -134,6 +142,8 @@ type RedisActionRequestContext =
|
||||
|
||||
interface AppendChatMessageParams {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
clientMessageId?: string;
|
||||
senderRole?: 'operator';
|
||||
userId?: mongoose.Types.ObjectId;
|
||||
displayName?: string;
|
||||
message: string;
|
||||
@@ -152,14 +162,10 @@ interface AuctionHistorySummaryRecord {
|
||||
takenAt: Date;
|
||||
}
|
||||
|
||||
interface AuctionHistoryListCacheEntry {
|
||||
entries: AuctionHistoryView[];
|
||||
expiresAtTimestampMS: number;
|
||||
}
|
||||
|
||||
export type AuctionStateResponse = AuctionDocument | Record<string, unknown>;
|
||||
|
||||
export interface AuctionBidDeltaResponse {
|
||||
currentBidRoundId?: string;
|
||||
auctionBidHistoryEntry: Record<string, unknown>;
|
||||
auctionLifecycleId?: string;
|
||||
bidServerTiming?: AuctionBidServerTiming;
|
||||
@@ -199,10 +205,6 @@ function isMongoDuplicateKeyError(error: unknown): boolean {
|
||||
@Injectable()
|
||||
export class AuctionService {
|
||||
private readonly logger = new Logger(AuctionService.name);
|
||||
private readonly auctionHistoryListCache = new Map<
|
||||
string,
|
||||
AuctionHistoryListCacheEntry
|
||||
>();
|
||||
|
||||
constructor(
|
||||
private readonly connectionService: ConnectionService,
|
||||
@@ -212,9 +214,20 @@ export class AuctionService {
|
||||
private readonly auctionRedisService: AuctionRedisService,
|
||||
private readonly auctionRedisCommandService: AuctionRedisCommandService,
|
||||
private readonly auctionRedisStateReaderService: AuctionRedisStateReaderService,
|
||||
@Optional()
|
||||
private readonly auctionEventBusService?: AuctionEventBusService,
|
||||
) {}
|
||||
|
||||
public async start(params: StartAuctionParams): Promise<AuctionDocument> {
|
||||
return new AuctionLifecycleLock(this.auctionRedisService).run(
|
||||
params.matchId.toString(),
|
||||
() => this.startLocked(params),
|
||||
);
|
||||
}
|
||||
|
||||
private async startLocked(
|
||||
params: StartAuctionParams,
|
||||
): Promise<AuctionDocument> {
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const UserModel = await this.connectionService.getModel('user');
|
||||
const AuctionModel = await this.connectionService.getModel('auction');
|
||||
@@ -231,7 +244,7 @@ export class AuctionService {
|
||||
const existing = await AuctionModel.findOne({ matchId: params.matchId });
|
||||
if (existing) {
|
||||
if (existing.startAuctionRequestId === params.startAuctionRequestId) {
|
||||
return existing;
|
||||
return this.finishAuctionStartup(existing, match);
|
||||
}
|
||||
if (this.isRestartableResetRedisAuction(existing)) {
|
||||
await this.clearRedisAuctionRuntimeForLifecycle(
|
||||
@@ -249,6 +262,19 @@ export class AuctionService {
|
||||
}
|
||||
}
|
||||
|
||||
// No Mongo auction owns this match. Remove runtime left by an interrupted
|
||||
// cancellation before creating a new lifecycle (under the lifecycle lock).
|
||||
const orphanedRuntime =
|
||||
await this.auctionRedisStateReaderService.readLiveStateIdentity(
|
||||
params.matchId.toString(),
|
||||
);
|
||||
if (orphanedRuntime?.auctionLifecycleId) {
|
||||
await this.clearRedisAuctionRuntimeForLifecycle(
|
||||
params.matchId.toString(),
|
||||
orphanedRuntime.auctionLifecycleId,
|
||||
);
|
||||
}
|
||||
|
||||
const activeParticipants = this.applyAuctionCut(match);
|
||||
const desiredAuctionCount = activeParticipants.length;
|
||||
if (desiredAuctionCount < 10) {
|
||||
@@ -381,6 +407,7 @@ export class AuctionService {
|
||||
auctionStartedByUserId: params.actorUserId,
|
||||
matchSideEffectStatus: 'none',
|
||||
matchSideEffectRevision: 0,
|
||||
startupCompleted: false,
|
||||
teams: legacyTeams,
|
||||
order: prioritizedOrder,
|
||||
passedQueue: [],
|
||||
@@ -419,12 +446,12 @@ export class AuctionService {
|
||||
matchId: params.matchId,
|
||||
});
|
||||
if (raceWinner?.startAuctionRequestId === params.startAuctionRequestId) {
|
||||
return raceWinner;
|
||||
return this.finishAuctionStartup(raceWinner, match);
|
||||
}
|
||||
throw new BadRequestException('Auction already exists for this match.');
|
||||
}
|
||||
await this.recordSnapshot(auction, 'start');
|
||||
await this.auctionRedisCommandService.hydrateState(
|
||||
const hydration = await this.auctionRedisCommandService.hydrateState(
|
||||
params.matchId.toString(),
|
||||
{
|
||||
auctionHistorySequence: 1,
|
||||
@@ -437,9 +464,18 @@ export class AuctionService {
|
||||
structureStateJson,
|
||||
},
|
||||
);
|
||||
if ('rejected' in hydration)
|
||||
throw new ConflictException(
|
||||
`Auction initialization failed: ${hydration.code}.`,
|
||||
);
|
||||
|
||||
match.status = 'team-built';
|
||||
await match.save();
|
||||
auction.startupCompleted = true;
|
||||
await AuctionModel.updateOne(
|
||||
{ _id: auction._id },
|
||||
{ $set: { startupCompleted: true } },
|
||||
);
|
||||
this.enqueueBackgroundOrderEnrichment({
|
||||
auctionId: auction._id,
|
||||
targets: enrichTargets,
|
||||
@@ -450,6 +486,61 @@ export class AuctionService {
|
||||
return auction;
|
||||
}
|
||||
|
||||
private async finishAuctionStartup(
|
||||
auction: AuctionDocument,
|
||||
match: MatchDocument,
|
||||
): Promise<AuctionDocument> {
|
||||
// Documents predating the startup marker already completed the old path.
|
||||
if (auction.startupCompleted !== false) return auction;
|
||||
// Retry the original cut; recruiting may have changed since Mongo creation.
|
||||
const roster = new Set([
|
||||
...auction.teams.map((team) => team.captainUserId.toString()),
|
||||
...auction.order.map((player) => player.userId.toString()),
|
||||
]);
|
||||
const participants = new Set(
|
||||
match.participants.map((entry) => entry.userId.toString()),
|
||||
);
|
||||
if ([...roster].some((id) => !participants.has(id))) {
|
||||
throw new ConflictException(
|
||||
'Auction startup roster has changed. Cancel and restart the auction.',
|
||||
);
|
||||
}
|
||||
const History = await this.connectionService.getModel('auctionHistory');
|
||||
await History.updateOne(
|
||||
{ auctionId: auction._id, sequence: 1 },
|
||||
{
|
||||
$setOnInsert: {
|
||||
auctionId: auction._id,
|
||||
matchId: auction.matchId,
|
||||
sequence: 1,
|
||||
action: 'start',
|
||||
snapshotBefore: this.cloneJson(
|
||||
typeof auction.toObject === 'function'
|
||||
? auction.toObject()
|
||||
: auction,
|
||||
),
|
||||
takenAt: auction.startedAt ?? new Date(),
|
||||
},
|
||||
},
|
||||
{ upsert: true },
|
||||
);
|
||||
await this.hydrateRedisStateFromAuctionDocument(auction);
|
||||
if (match.status === 'recruiting') {
|
||||
match.participants.forEach((participant) => {
|
||||
participant.excluded = !roster.has(participant.userId.toString());
|
||||
});
|
||||
match.status = 'team-built';
|
||||
await match.save();
|
||||
}
|
||||
const AuctionModel = await this.connectionService.getModel('auction');
|
||||
await AuctionModel.updateOne(
|
||||
{ _id: auction._id },
|
||||
{ $set: { startupCompleted: true } },
|
||||
);
|
||||
auction.startupCompleted = true;
|
||||
return auction;
|
||||
}
|
||||
|
||||
public async getByMatchId(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
): Promise<AuctionDocument> {
|
||||
@@ -462,18 +553,52 @@ export class AuctionService {
|
||||
public async getStateByMatchId(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
): Promise<AuctionStateResponse> {
|
||||
const auction = await this.getByMatchId(matchId);
|
||||
for (let attempt = 0; ; attempt++) {
|
||||
try {
|
||||
return await this.getStateByMatchIdOnce(matchId);
|
||||
} catch (error) {
|
||||
if (!(error instanceof AuctionLifecycleBusyError)) throw error;
|
||||
if (attempt >= 4)
|
||||
throw new ServiceUnavailableException({
|
||||
code: 'AUCTION_STATE_RECOVERING',
|
||||
retryAfterMS: 500,
|
||||
message: '경매 상태를 복구 중입니다. 잠시 후 다시 시도해 주세요.',
|
||||
});
|
||||
await new Promise((resolve) => setTimeout(resolve, 50 * (attempt + 1)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public getRealtimeIdentity(
|
||||
matchId: string,
|
||||
): Promise<AuctionStateIdentity | null> {
|
||||
return this.auctionRedisStateReaderService.readLiveStateIdentity(matchId);
|
||||
}
|
||||
|
||||
private async getStateByMatchIdOnce(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
): Promise<AuctionStateResponse> {
|
||||
let auction = await this.getByMatchId(matchId);
|
||||
if (!this.isRedisV1Auction(auction)) return auction;
|
||||
|
||||
if (auction.startupCompleted === false) {
|
||||
auction = await new AuctionLifecycleLock(this.auctionRedisService).run(
|
||||
matchId.toString(),
|
||||
async () => {
|
||||
const current = await this.getByMatchId(matchId);
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const match = await MatchModel.findById(matchId);
|
||||
if (!match) throw new NotFoundException('Match not found.');
|
||||
return this.finishAuctionStartup(current, match);
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
const redisState = await this.readRedisAuctionStateOrRehydrate(auction);
|
||||
if (!redisState) return auction;
|
||||
|
||||
const mongoState =
|
||||
typeof auction.toObject === 'function'
|
||||
? auction.toObject({ depopulate: true })
|
||||
: auction;
|
||||
return {
|
||||
...this.cloneJson(mongoState),
|
||||
...this.buildAuctionSnapshotFromRedisState(auction, redisState),
|
||||
...redisState,
|
||||
chatMessages: auction.chatMessages ?? [],
|
||||
};
|
||||
@@ -485,12 +610,15 @@ export class AuctionService {
|
||||
const matchId = auction.matchId.toString();
|
||||
const mongoRevision = auction.revision ?? 0;
|
||||
const mongoAuctionLifecycleId = auction.auctionLifecycleId;
|
||||
if (!mongoAuctionLifecycleId || auction.phase === 'complete') {
|
||||
if (!mongoAuctionLifecycleId) {
|
||||
return this.auctionRedisStateReaderService.readAuctionStateView(matchId);
|
||||
}
|
||||
|
||||
const liveIdentity =
|
||||
await this.auctionRedisStateReaderService.readLiveStateIdentity(matchId);
|
||||
// Completed runtimes expire after the retention period. Mongo remains the
|
||||
// archive; viewing it must not create an immortal Redis runtime again.
|
||||
if (!liveIdentity && auction.phase === 'complete') return null;
|
||||
const shouldHydrate = shouldHydrateRedisAuctionState({
|
||||
live: liveIdentity,
|
||||
mongo: {
|
||||
@@ -503,29 +631,32 @@ export class AuctionService {
|
||||
return this.auctionRedisStateReaderService.readAuctionStateView(matchId);
|
||||
}
|
||||
|
||||
const keys = buildAuctionRedisKeys(matchId);
|
||||
const lockToken = randomUUID();
|
||||
const lockAcquired = await this.auctionRedisService.acquireTokenLock(
|
||||
keys.rehydrateLockKey,
|
||||
lockToken,
|
||||
AUCTION_REHYDRATE_LOCK_TTL_MS,
|
||||
await new AuctionLifecycleLock(this.auctionRedisService).run(
|
||||
matchId,
|
||||
async () => {
|
||||
const currentAuction = await this.getByMatchId(auction.matchId);
|
||||
if (currentAuction.auctionLifecycleId !== mongoAuctionLifecycleId) {
|
||||
throw new ConflictException(
|
||||
'Auction lifecycle has changed. Refresh the auction.',
|
||||
);
|
||||
}
|
||||
const currentLive =
|
||||
await this.auctionRedisStateReaderService.readLiveStateIdentity(
|
||||
matchId,
|
||||
);
|
||||
if (
|
||||
currentLive?.auctionLifecycleId &&
|
||||
currentLive.auctionLifecycleId !== mongoAuctionLifecycleId
|
||||
) {
|
||||
await this.clearRedisAuctionRuntimeForLifecycle(
|
||||
matchId,
|
||||
currentLive.auctionLifecycleId,
|
||||
);
|
||||
}
|
||||
await this.hydrateRedisStateFromAuctionDocument(currentAuction);
|
||||
},
|
||||
);
|
||||
|
||||
if (lockAcquired) {
|
||||
try {
|
||||
await this.hydrateRedisStateFromAuctionDocument(auction);
|
||||
} finally {
|
||||
await this.auctionRedisService.releaseTokenLock(
|
||||
keys.rehydrateLockKey,
|
||||
lockToken,
|
||||
);
|
||||
}
|
||||
} else {
|
||||
await new Promise((resolve) =>
|
||||
setTimeout(resolve, AUCTION_REHYDRATE_LOCK_WAIT_MS),
|
||||
);
|
||||
}
|
||||
|
||||
return this.auctionRedisStateReaderService.readAuctionStateView(matchId, {
|
||||
shouldForceAuctionStateResync: true,
|
||||
});
|
||||
@@ -534,26 +665,57 @@ export class AuctionService {
|
||||
public async appendChatMessage(params: AppendChatMessageParams): Promise<{
|
||||
auction: AuctionDocument;
|
||||
message: AuctionChatMessage;
|
||||
created: boolean;
|
||||
}> {
|
||||
const auction = await this.getByMatchId(params.matchId);
|
||||
const messageText = this.normalizeChatMessage(params.message);
|
||||
if (
|
||||
params.clientMessageId !== undefined &&
|
||||
!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
|
||||
params.clientMessageId,
|
||||
)
|
||||
) {
|
||||
throw new BadRequestException('Invalid chat message id.');
|
||||
}
|
||||
// A retry keeps its ID. The conditional push is atomic, including when
|
||||
// the first request is still saving after the client has timed out.
|
||||
const id = params.clientMessageId
|
||||
? `${params.userId?.toString() ?? 'guest'}:${params.clientMessageId}`
|
||||
: randomUUID();
|
||||
const message: AuctionChatMessage = {
|
||||
id: randomUUID(),
|
||||
id,
|
||||
clientMessageId: params.clientMessageId,
|
||||
senderRole: params.senderRole,
|
||||
userId: params.userId,
|
||||
displayName: this.normalizeChatDisplayName(params.displayName),
|
||||
message: messageText,
|
||||
sentAt: new Date(),
|
||||
};
|
||||
|
||||
auction.chatMessages ??= [];
|
||||
auction.chatMessages.push(message);
|
||||
const overflow = auction.chatMessages.length - AUCTION_CHAT_MAX_MESSAGES;
|
||||
if (overflow > 0) {
|
||||
auction.chatMessages.splice(0, overflow);
|
||||
}
|
||||
const AuctionModel = await this.connectionService.getModel('auction');
|
||||
const auction = await AuctionModel.findOneAndUpdate(
|
||||
{ matchId: params.matchId, 'chatMessages.id': { $ne: id } },
|
||||
{
|
||||
$push: {
|
||||
chatMessages: {
|
||||
$each: [message],
|
||||
$slice: -AUCTION_CHAT_MAX_MESSAGES,
|
||||
},
|
||||
},
|
||||
},
|
||||
{ returnDocument: 'after' },
|
||||
);
|
||||
if (auction) return { auction, message, created: true };
|
||||
|
||||
await auction.save();
|
||||
return { auction, message };
|
||||
const existingAuction = await this.getByMatchId(params.matchId);
|
||||
const existing = existingAuction.chatMessages.find(
|
||||
(entry) => entry.id === id,
|
||||
);
|
||||
if (!existing || existing.message !== messageText) {
|
||||
throw new BadRequestException(
|
||||
'Chat message conflicts with an earlier request.',
|
||||
);
|
||||
}
|
||||
return { auction: existingAuction, message: existing, created: false };
|
||||
}
|
||||
|
||||
public async listHistory(params: {
|
||||
@@ -571,10 +733,6 @@ export class AuctionService {
|
||||
throw new BadRequestException('Match does not belong to this community.');
|
||||
}
|
||||
|
||||
const cacheKey = this.buildAuctionHistoryListCacheKey(params);
|
||||
const cachedHistory = this.getCachedAuctionHistoryList(cacheKey);
|
||||
if (cachedHistory) return cachedHistory;
|
||||
|
||||
const entries = (await AuctionHistoryModel.find({ matchId: params.matchId })
|
||||
.select({ _id: 0, action: 1, sequence: 1, takenAt: 1 })
|
||||
.sort({ sequence: -1 })
|
||||
@@ -588,49 +746,9 @@ export class AuctionService {
|
||||
actionLabel: this.formatHistoryActionLabel(entry.action),
|
||||
takenAt: entry.takenAt,
|
||||
}));
|
||||
this.setCachedAuctionHistoryList(cacheKey, history);
|
||||
return history;
|
||||
}
|
||||
|
||||
private buildAuctionHistoryListCacheKey(params: {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
}): string {
|
||||
return `${params.communityId.toString()}:${params.matchId.toString()}`;
|
||||
}
|
||||
|
||||
private getCachedAuctionHistoryList(
|
||||
cacheKey: string,
|
||||
): AuctionHistoryView[] | null {
|
||||
const cached = this.auctionHistoryListCache.get(cacheKey);
|
||||
if (!cached) return null;
|
||||
if (cached.expiresAtTimestampMS <= Date.now()) {
|
||||
this.auctionHistoryListCache.delete(cacheKey);
|
||||
return null;
|
||||
}
|
||||
return cached.entries;
|
||||
}
|
||||
|
||||
private setCachedAuctionHistoryList(
|
||||
cacheKey: string,
|
||||
entries: AuctionHistoryView[],
|
||||
): void {
|
||||
if (
|
||||
!this.auctionHistoryListCache.has(cacheKey) &&
|
||||
this.auctionHistoryListCache.size >=
|
||||
AUCTION_HISTORY_LIST_CACHE_MAX_ENTRIES
|
||||
) {
|
||||
const oldestKey = this.auctionHistoryListCache.keys().next().value as
|
||||
| string
|
||||
| undefined;
|
||||
if (oldestKey) this.auctionHistoryListCache.delete(oldestKey);
|
||||
}
|
||||
this.auctionHistoryListCache.set(cacheKey, {
|
||||
entries,
|
||||
expiresAtTimestampMS: Date.now() + AUCTION_HISTORY_LIST_CACHE_TTL_MS,
|
||||
});
|
||||
}
|
||||
|
||||
public async openBidding(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
actionRequest: AuctionStructureActionRequestParams = {},
|
||||
@@ -664,6 +782,10 @@ export class AuctionService {
|
||||
}
|
||||
const team = this.findAuctionTeamByIndex(auction, params.teamIndex);
|
||||
if (!team) throw new BadRequestException('Unknown team.');
|
||||
this.assertBidderIsCaptain(
|
||||
params.bidderUserId,
|
||||
team.captainUserId.toString(),
|
||||
);
|
||||
if (params.amount <= auction.currentBid) {
|
||||
throw new BadRequestException('Bid must exceed current bid.');
|
||||
}
|
||||
@@ -676,8 +798,6 @@ export class AuctionService {
|
||||
'Bid must reserve minimum points for remaining slots.',
|
||||
);
|
||||
}
|
||||
// 임시 운영용: 클라이언트에서 선택한 팀장 모드를 신뢰하고 실제 로그인 사용자 검증은 건너뛴다.
|
||||
|
||||
await this.recordSnapshot(auction, 'bid', params.bidderUserId);
|
||||
auction.currentBid = params.amount;
|
||||
auction.currentBidderTeamIndex = params.teamIndex;
|
||||
@@ -798,6 +918,10 @@ export class AuctionService {
|
||||
if (!bidContext.bidderTeamCaptainUserId) {
|
||||
throw new BadRequestException('Unknown team.');
|
||||
}
|
||||
this.assertBidderIsCaptain(
|
||||
params.bidderUserId,
|
||||
bidContext.bidderTeamCaptainUserId,
|
||||
);
|
||||
|
||||
const auctionLifecycleId =
|
||||
params.clientObservedAuctionLifecycleId ?? bidContext.auctionLifecycleId;
|
||||
@@ -814,6 +938,7 @@ export class AuctionService {
|
||||
bidderTeamIndex: params.teamIndex,
|
||||
bidderUserId: bidContext.bidderTeamCaptainUserId,
|
||||
bidRequestId: params.bidRequestId ?? randomUUID(),
|
||||
clientObservedBidRoundId: params.clientObservedBidRoundId,
|
||||
clientObservedAuctionLifecycleId: auctionLifecycleId,
|
||||
clientObservedCurrentBidRoundPlayerUserId: currentBidRoundPlayerUserId,
|
||||
matchId,
|
||||
@@ -873,6 +998,10 @@ export class AuctionService {
|
||||
(entry) => Number(entry.teamIndex) === params.teamIndex,
|
||||
);
|
||||
if (!team) throw new BadRequestException('Unknown team.');
|
||||
this.assertBidderIsCaptain(
|
||||
params.bidderUserId,
|
||||
this.stringFromState(team.captainUserId),
|
||||
);
|
||||
|
||||
const auctionLifecycleId =
|
||||
params.clientObservedAuctionLifecycleId ??
|
||||
@@ -890,6 +1019,7 @@ export class AuctionService {
|
||||
bidderTeamIndex: params.teamIndex,
|
||||
bidderUserId: this.stringFromState(team.captainUserId),
|
||||
bidRequestId: params.bidRequestId ?? randomUUID(),
|
||||
clientObservedBidRoundId: params.clientObservedBidRoundId,
|
||||
clientObservedAuctionLifecycleId: auctionLifecycleId,
|
||||
clientObservedCurrentBidRoundPlayerUserId: currentBidRoundPlayerUserId,
|
||||
matchId,
|
||||
@@ -923,6 +1053,10 @@ export class AuctionService {
|
||||
): AuctionBidDeltaResponse {
|
||||
return {
|
||||
auctionBidHistoryEntry: result.auctionBidHistoryEntry,
|
||||
currentBidRoundId:
|
||||
typeof result.auctionBidHistoryEntry.bidRoundId === 'string'
|
||||
? result.auctionBidHistoryEntry.bidRoundId
|
||||
: undefined,
|
||||
auctionLifecycleId: this.stringFromState(state.auctionLifecycleId),
|
||||
bidRequestId: result.bidRequestId,
|
||||
currentBidRoundDeadlineTimestampMS:
|
||||
@@ -1408,6 +1542,34 @@ export class AuctionService {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
}): Promise<void> {
|
||||
let committed = false;
|
||||
try {
|
||||
await new AuctionLifecycleLock(this.auctionRedisService).run(
|
||||
params.matchId.toString(),
|
||||
() =>
|
||||
this.resetLocked(params, () => {
|
||||
committed = true;
|
||||
}),
|
||||
);
|
||||
} catch (error) {
|
||||
if (!committed) throw error;
|
||||
// A committed cancellation is successful even if lock renewal/teardown
|
||||
// fails afterward. Cleanup is durably queued in the same Mongo transaction.
|
||||
this.logger.warn(
|
||||
`Auction cancellation committed; post-commit coordination failed: ${String(error)}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
private async resetLocked(
|
||||
params: {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
clientObservedAuctionLifecycleId?: string;
|
||||
clientObservedRevision?: number;
|
||||
},
|
||||
onCommitted: () => void,
|
||||
): Promise<void> {
|
||||
const AuctionModel = await this.connectionService.getModel('auction');
|
||||
const AuctionHistoryModel =
|
||||
await this.connectionService.getModel('auctionHistory');
|
||||
@@ -1419,70 +1581,155 @@ export class AuctionService {
|
||||
if (!session) {
|
||||
throw new InternalServerErrorException('Failed to start DB session.');
|
||||
}
|
||||
let redisRuntimeToClear: {
|
||||
auctionLifecycleId?: string;
|
||||
matchId: string;
|
||||
} | null = null;
|
||||
try {
|
||||
session.startTransaction();
|
||||
const auction = await AuctionModel.findOne({
|
||||
matchId: params.matchId,
|
||||
}).session(session);
|
||||
if (!auction) throw new NotFoundException('Auction not found.');
|
||||
|
||||
const match = await MatchModel.findById(params.matchId).session(session);
|
||||
if (!match) throw new NotFoundException('Match not found.');
|
||||
if (!match.communityId.equals(params.communityId)) {
|
||||
throw new BadRequestException('Community mismatch.');
|
||||
}
|
||||
this.assertCompetitionLifecycleMutable(match, 'reset the auction');
|
||||
|
||||
if (this.isRedisV1Auction(auction)) {
|
||||
redisRuntimeToClear = {
|
||||
auctionLifecycleId: auction.auctionLifecycleId,
|
||||
matchId: params.matchId.toString(),
|
||||
};
|
||||
await this.resetMatchAfterAuctionCancellation(match, session);
|
||||
await AuctionSideEffectApplicationModel.deleteMany({
|
||||
auctionId: auction._id,
|
||||
}).session(session);
|
||||
await AuctionHistoryModel.deleteMany({
|
||||
auctionId: auction._id,
|
||||
}).session(session);
|
||||
await auction.deleteOne({ session });
|
||||
if (!auction) {
|
||||
// 이미 커밋된 취소의 재전송이면 성공으로 응답하고 남은 Redis 정리만 재시도한다.
|
||||
const cancelledMatch = params.clientObservedAuctionLifecycleId
|
||||
? await MatchModel.findById(params.matchId).session(session)
|
||||
: null;
|
||||
if (
|
||||
!cancelledMatch ||
|
||||
cancelledMatch.lastCancelledAuctionLifecycleId !==
|
||||
params.clientObservedAuctionLifecycleId
|
||||
) {
|
||||
throw new NotFoundException('Auction not found.');
|
||||
}
|
||||
if (!cancelledMatch.communityId.equals(params.communityId)) {
|
||||
throw new BadRequestException('Community mismatch.');
|
||||
}
|
||||
cancelledMatch.auctionCancellationCleanupPending = true;
|
||||
cancelledMatch.auctionCancellationCleanupRetryAt = new Date();
|
||||
await cancelledMatch.save({ session });
|
||||
} else {
|
||||
await auction.deleteOne({ session });
|
||||
await AuctionHistoryModel.deleteMany({
|
||||
auctionId: auction._id,
|
||||
}).session(session);
|
||||
if (match.status === 'team-built') {
|
||||
await this.tournamentCodeService.releaseFromMatch(match);
|
||||
match.status = 'recruiting';
|
||||
match.teams = [];
|
||||
match.tournamentCodeIds = [];
|
||||
match.gameSchedule = [];
|
||||
match.participants.forEach((participant) => {
|
||||
participant.excluded = false;
|
||||
});
|
||||
match.teamBuiltAt = undefined;
|
||||
match.result = undefined;
|
||||
match.resultPollState = undefined;
|
||||
await match.save({ session });
|
||||
if (
|
||||
this.isRedisV1Auction(auction) &&
|
||||
(!params.clientObservedAuctionLifecycleId ||
|
||||
params.clientObservedAuctionLifecycleId !==
|
||||
auction.auctionLifecycleId)
|
||||
) {
|
||||
throw new ConflictException(
|
||||
'Auction lifecycle has changed. Refresh before cancelling.',
|
||||
);
|
||||
}
|
||||
|
||||
const match = await MatchModel.findById(params.matchId).session(
|
||||
session,
|
||||
);
|
||||
if (!match) throw new NotFoundException('Match not found.');
|
||||
if (!match.communityId.equals(params.communityId)) {
|
||||
throw new BadRequestException('Community mismatch.');
|
||||
}
|
||||
this.assertCompetitionLifecycleMutable(match, 'reset the auction');
|
||||
|
||||
if (this.isRedisV1Auction(auction)) {
|
||||
// 같은 트랜잭션에서 취소 완료를 기록해, 재전송을 멱등 처리한다.
|
||||
match.lastCancelledAuctionLifecycleId = auction.auctionLifecycleId;
|
||||
match.auctionCancellationCleanupPending = true;
|
||||
match.auctionCancellationCleanupRetryAt = new Date();
|
||||
match.auctionCancellationCleanupAttempts = 0;
|
||||
match.auctionCancellationCleanupError = undefined;
|
||||
await this.resetMatchAfterAuctionCancellation(match, session);
|
||||
await AuctionSideEffectApplicationModel.deleteMany({
|
||||
auctionId: auction._id,
|
||||
}).session(session);
|
||||
await AuctionHistoryModel.deleteMany({
|
||||
auctionId: auction._id,
|
||||
}).session(session);
|
||||
await auction.deleteOne({ session });
|
||||
} else {
|
||||
await auction.deleteOne({ session });
|
||||
await AuctionHistoryModel.deleteMany({
|
||||
auctionId: auction._id,
|
||||
}).session(session);
|
||||
if (match.status === 'team-built') {
|
||||
await this.tournamentCodeService.releaseFromMatch(match, session);
|
||||
match.status = 'recruiting';
|
||||
match.teams = [];
|
||||
match.tournamentCodeIds = [];
|
||||
match.gameSchedule = [];
|
||||
match.participants.forEach((participant) => {
|
||||
participant.excluded = false;
|
||||
});
|
||||
match.teamBuiltAt = undefined;
|
||||
match.result = undefined;
|
||||
match.resultPollState = undefined;
|
||||
await match.save({ session });
|
||||
}
|
||||
}
|
||||
}
|
||||
await session.commitTransaction();
|
||||
onCommitted();
|
||||
} catch (err) {
|
||||
await session.abortTransaction();
|
||||
throw err;
|
||||
} finally {
|
||||
await session.endSession();
|
||||
}
|
||||
}
|
||||
|
||||
if (redisRuntimeToClear) {
|
||||
await this.clearRedisAuctionRuntimeForLifecycle(
|
||||
redisRuntimeToClear.matchId,
|
||||
redisRuntimeToClear.auctionLifecycleId,
|
||||
);
|
||||
public async retryPendingCancellations(batchLimit = 20): Promise<void> {
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const pending = await MatchModel.find({
|
||||
auctionCancellationCleanupPending: true,
|
||||
auctionCancellationCleanupRetryAt: { $lte: new Date() },
|
||||
})
|
||||
.sort({ auctionCancellationCleanupRetryAt: 1 })
|
||||
.limit(batchLimit)
|
||||
.lean()
|
||||
.exec();
|
||||
for (const match of pending) {
|
||||
const lifecycle = match.lastCancelledAuctionLifecycleId;
|
||||
if (!lifecycle) continue;
|
||||
const filter = {
|
||||
_id: match._id,
|
||||
lastCancelledAuctionLifecycleId: lifecycle,
|
||||
};
|
||||
try {
|
||||
await new AuctionLifecycleLock(this.auctionRedisService).run(
|
||||
match._id.toString(),
|
||||
async () => {
|
||||
// Compare-and-delete in Redis also protects a newly started lifecycle.
|
||||
await this.clearRedisAuctionRuntimeForLifecycle(
|
||||
match._id.toString(),
|
||||
lifecycle,
|
||||
);
|
||||
const AuctionModel =
|
||||
await this.connectionService.getModel('auction');
|
||||
if (!(await AuctionModel.exists({ matchId: match._id }))) {
|
||||
this.auctionEventBusService?.broadcastReset(
|
||||
match._id.toString(),
|
||||
lifecycle,
|
||||
);
|
||||
}
|
||||
await MatchModel.updateOne(filter, {
|
||||
$set: { auctionCancellationCleanupPending: false },
|
||||
$unset: {
|
||||
auctionCancellationCleanupRetryAt: '',
|
||||
auctionCancellationCleanupError: '',
|
||||
},
|
||||
});
|
||||
},
|
||||
);
|
||||
} catch (error) {
|
||||
const attempts = (match.auctionCancellationCleanupAttempts ?? 0) + 1;
|
||||
await MatchModel.updateOne(filter, {
|
||||
$set: {
|
||||
auctionCancellationCleanupPending: true,
|
||||
auctionCancellationCleanupRetryAt: new Date(
|
||||
Date.now() + Math.min(60000, 1000 * 2 ** Math.min(attempts, 6)),
|
||||
),
|
||||
auctionCancellationCleanupError: String(error).slice(0, 2000),
|
||||
},
|
||||
$inc: { auctionCancellationCleanupAttempts: 1 },
|
||||
});
|
||||
this.logger.warn(
|
||||
`Auction cancellation cleanup will retry for ${match._id.toString()}: ${String(error)}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1497,6 +1744,19 @@ export class AuctionService {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
sequence: number;
|
||||
}): Promise<AuctionStateResponse> {
|
||||
return new AuctionLifecycleLock(this.auctionRedisService).run(
|
||||
params.matchId.toString(),
|
||||
() => this.undoToLocked(params),
|
||||
);
|
||||
}
|
||||
|
||||
private async undoToLocked(
|
||||
params: AuctionStructureActionRequestParams & {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
sequence: number;
|
||||
},
|
||||
): Promise<AuctionStateResponse> {
|
||||
const AuctionModel = await this.connectionService.getModel('auction');
|
||||
const AuctionHistoryModel =
|
||||
await this.connectionService.getModel('auctionHistory');
|
||||
@@ -1508,6 +1768,7 @@ export class AuctionService {
|
||||
}
|
||||
|
||||
let redisUndoContext: {
|
||||
state?: Record<string, unknown>;
|
||||
actionRequestParams?: AuctionStructureActionRequestParams;
|
||||
auction: AuctionDocument;
|
||||
snapshot: Record<string, unknown>;
|
||||
@@ -1543,8 +1804,12 @@ export class AuctionService {
|
||||
throw new BadRequestException('Auction history snapshot is invalid.');
|
||||
}
|
||||
|
||||
const undoingCompletedAuction =
|
||||
Boolean(auction.completedAt) && !('completedAt' in snapshot);
|
||||
const liveState = this.isRedisV1Auction(auction)
|
||||
? await this.requireRedisAuctionState(params.matchId.toString())
|
||||
: undefined;
|
||||
const undoingCompletedAuction = liveState
|
||||
? liveState.phase === 'complete' && snapshot.phase !== 'complete'
|
||||
: Boolean(auction.completedAt) && !('completedAt' in snapshot);
|
||||
if (undoingCompletedAuction) {
|
||||
this.assertCompetitionLifecycleMutable(
|
||||
match,
|
||||
@@ -1553,6 +1818,7 @@ export class AuctionService {
|
||||
}
|
||||
if (this.isRedisV1Auction(auction)) {
|
||||
redisUndoContext = {
|
||||
state: liveState,
|
||||
auction,
|
||||
actionRequestParams: params,
|
||||
snapshot: snapshot,
|
||||
@@ -1562,8 +1828,8 @@ export class AuctionService {
|
||||
await session.commitTransaction();
|
||||
} else {
|
||||
if (undoingCompletedAuction) {
|
||||
await this.tournamentCodeService.releaseFromMatch(match);
|
||||
await this.tournamentResultService.cancelPolling(match);
|
||||
await this.tournamentCodeService.releaseFromMatch(match, session);
|
||||
await this.tournamentResultService.cancelPolling(match, session);
|
||||
match.status = 'team-built';
|
||||
match.result = undefined;
|
||||
await match.save({ session });
|
||||
@@ -1758,6 +2024,14 @@ export class AuctionService {
|
||||
currentAuctionHistorySequence: auctionHistorySequence,
|
||||
lastAppliedAuctionStateTransitionId: auctionStateTransitionId,
|
||||
revision: expectedRevision + 1,
|
||||
currentBidRoundId:
|
||||
params.deadline.mode === 'set-relative'
|
||||
? auctionStateTransitionId
|
||||
: params.state.currentBidRoundId,
|
||||
currentBidRoundDeadlineTimestampMS:
|
||||
params.deadline.mode === 'remove'
|
||||
? 0
|
||||
: params.state.currentBidRoundDeadlineTimestampMS,
|
||||
};
|
||||
const afterAuctionMongoProjection =
|
||||
this.buildAuctionMongoProjectionFromState(params.auction, afterState);
|
||||
@@ -1769,8 +2043,18 @@ export class AuctionService {
|
||||
if (matchSideEffectMutation.type !== 'none') {
|
||||
afterAuctionMongoProjection.matchSideEffectStatus = 'pending';
|
||||
afterAuctionMongoProjection.matchSideEffectRevision =
|
||||
(params.auction.matchSideEffectRevision ?? 0) + 1;
|
||||
Math.max(
|
||||
params.auction.matchSideEffectRevision ?? 0,
|
||||
this.numberFromState(params.state.matchSideEffectRevision),
|
||||
) + 1;
|
||||
afterAuctionMongoProjection.matchSideEffectError = undefined;
|
||||
afterAuctionMongoProjection.matchSideEffectTransitionId =
|
||||
auctionStateTransitionId;
|
||||
params.liveStatePatch.matchSideEffectTransitionId =
|
||||
auctionStateTransitionId;
|
||||
params.liveStatePatch.matchSideEffectStatus = 'pending';
|
||||
params.liveStatePatch.matchSideEffectRevision =
|
||||
afterAuctionMongoProjection.matchSideEffectRevision as number;
|
||||
}
|
||||
|
||||
const durabilityPayload = {
|
||||
@@ -1925,6 +2209,7 @@ export class AuctionService {
|
||||
}
|
||||
|
||||
private async undoRedisAuction(params: {
|
||||
state?: Record<string, unknown>;
|
||||
actionRequestParams?: AuctionStructureActionRequestParams;
|
||||
auction: AuctionDocument;
|
||||
snapshot: Record<string, unknown>;
|
||||
@@ -1932,7 +2217,8 @@ export class AuctionService {
|
||||
undoingCompletedAuction: boolean;
|
||||
}): Promise<AuctionStateResponse> {
|
||||
const matchId = params.auction.matchId.toString();
|
||||
const state = await this.requireRedisAuctionState(matchId);
|
||||
const state =
|
||||
params.state ?? (await this.requireRedisAuctionState(matchId));
|
||||
const actionRequest = await this.reserveRedisStructureActionRequest({
|
||||
action: 'undo',
|
||||
matchId,
|
||||
@@ -2118,8 +2404,11 @@ export class AuctionService {
|
||||
typeof auction.toObject === 'function'
|
||||
? (auction.toObject({ depopulate: true }) as Record<string, unknown>)
|
||||
: (auction as unknown as Record<string, unknown>);
|
||||
const snapshotBase = this.cloneJson(base);
|
||||
for (const field of AUCTION_OPTIONAL_PROJECTION_FIELDS)
|
||||
delete snapshotBase[field];
|
||||
return {
|
||||
...this.cloneJson(base),
|
||||
...snapshotBase,
|
||||
...this.buildAuctionMongoProjectionFromState(auction, state),
|
||||
_id: auction._id,
|
||||
matchId: auction.matchId,
|
||||
@@ -2145,6 +2434,7 @@ export class AuctionService {
|
||||
);
|
||||
const phase = this.stringFromState(state.phase) || 'presenting';
|
||||
const projection: Record<string, unknown> = {
|
||||
currentBidRoundId: state.currentBidRoundId || undefined,
|
||||
auctionBidHistory,
|
||||
auctionCompletedAtTimestampMS:
|
||||
phase === 'complete' &&
|
||||
@@ -2285,6 +2575,8 @@ export class AuctionService {
|
||||
|
||||
private formatRedisBidRejectCode(code: string): string {
|
||||
switch (code) {
|
||||
case 'BID_CLIENT_UPDATE_REQUIRED':
|
||||
return '경매 화면이 업데이트되었습니다. 새로고침한 뒤 다시 입찰해 주세요.';
|
||||
case 'PHASE':
|
||||
return 'Auction is not in bidding phase.';
|
||||
case 'STALE_BID_ROUND':
|
||||
@@ -2611,6 +2903,21 @@ export class AuctionService {
|
||||
return auction.teams.find((team) => team.teamIndex === teamIndex);
|
||||
}
|
||||
|
||||
private assertBidderIsCaptain(
|
||||
bidderUserId: mongoose.Types.ObjectId | undefined,
|
||||
captainUserId: string,
|
||||
) {
|
||||
if (!isAuctionCaptainAuthRequired()) return;
|
||||
if (!bidderUserId) {
|
||||
throw new ForbiddenException(
|
||||
'팀장 계정으로 로그인해야 입찰할 수 있습니다.',
|
||||
);
|
||||
}
|
||||
if (bidderUserId.toString() !== captainUserId) {
|
||||
throw new ForbiddenException('해당 팀의 팀장만 입찰할 수 있습니다.');
|
||||
}
|
||||
}
|
||||
|
||||
private createDeadline(secondsFromNow: number): Date {
|
||||
return new Date(Date.now() + secondsFromNow * 1000);
|
||||
}
|
||||
@@ -2701,8 +3008,8 @@ export class AuctionService {
|
||||
match: MatchDocument,
|
||||
session: mongoose.ClientSession,
|
||||
): Promise<void> {
|
||||
await this.tournamentCodeService.releaseFromMatch(match);
|
||||
await this.tournamentResultService.cancelPolling(match);
|
||||
await this.tournamentCodeService.releaseFromMatch(match, session);
|
||||
await this.tournamentResultService.cancelPolling(match, session);
|
||||
match.status = 'recruiting';
|
||||
match.teams = [];
|
||||
match.tournamentCodeIds = [];
|
||||
@@ -2717,6 +3024,11 @@ export class AuctionService {
|
||||
}
|
||||
|
||||
private assertLiveAuctionOperationSupported(auction: AuctionDocument): void {
|
||||
if (auction.startupCompleted === false) {
|
||||
throw new ConflictException(
|
||||
'Auction startup is not complete. Refresh to resume initialization.',
|
||||
);
|
||||
}
|
||||
if (auction.auctionEngineVersion && !this.isRedisV1Auction(auction)) {
|
||||
throw new BadRequestException(
|
||||
'Legacy auction live operations are not supported.',
|
||||
@@ -2881,7 +3193,7 @@ export class AuctionService {
|
||||
auction.topTierThreshold ??
|
||||
'NONE',
|
||||
};
|
||||
await this.auctionRedisCommandService.hydrateState(
|
||||
const hydration = await this.auctionRedisCommandService.hydrateState(
|
||||
auction.matchId.toString(),
|
||||
{
|
||||
auctionHistorySequence: auction.currentAuctionHistorySequence ?? 0,
|
||||
@@ -2889,6 +3201,10 @@ export class AuctionService {
|
||||
auction.auctionLifecycleId ??
|
||||
`auction:${auction._id.toString()}:rehydrated`,
|
||||
liveStatePatch: {
|
||||
currentBidRoundId: auction.phase === 'bidding' ? randomUUID() : '',
|
||||
matchSideEffectTransitionId: auction.matchSideEffectTransitionId,
|
||||
matchSideEffectRevision: auction.matchSideEffectRevision,
|
||||
matchSideEffectStatus: auction.matchSideEffectStatus,
|
||||
...buildAuctionRedisLiveStatePatchFromStructure(structureInput),
|
||||
currentHighestBidPointAmount:
|
||||
auction.currentHighestBidPointAmount ?? auction.currentBid ?? 0,
|
||||
@@ -2905,6 +3221,10 @@ export class AuctionService {
|
||||
structureStateJson: stringifyAuctionRedisStructureState(structureInput),
|
||||
},
|
||||
);
|
||||
if ('rejected' in hydration)
|
||||
throw new ConflictException(
|
||||
`Auction recovery failed: ${hydration.code}.`,
|
||||
);
|
||||
}
|
||||
|
||||
private async clearRedisAuctionRuntimeForLifecycle(
|
||||
@@ -2925,10 +3245,10 @@ export class AuctionService {
|
||||
' end',
|
||||
'end',
|
||||
"redis.call('ZREM', KEYS[2], ARGV[1])",
|
||||
"redis.call('DEL', KEYS[1], KEYS[3], KEYS[4], KEYS[5], KEYS[6], KEYS[7], KEYS[8], KEYS[9], KEYS[10], KEYS[11])",
|
||||
"redis.call('DEL', KEYS[1], KEYS[3], KEYS[4], KEYS[5], KEYS[6], KEYS[7], KEYS[8], KEYS[9], KEYS[10], KEYS[11], KEYS[12])",
|
||||
'return 1',
|
||||
].join('\n'),
|
||||
'11',
|
||||
'12',
|
||||
keys.liveStateKey,
|
||||
keys.deadlineQueueKey,
|
||||
keys.structureStateKey,
|
||||
@@ -2940,6 +3260,7 @@ export class AuctionService {
|
||||
keys.actionRequestResultOrderKey,
|
||||
keys.rehydrateLockKey,
|
||||
keys.stateTransitionLockKey,
|
||||
keys.rejectedBidRequestResultOrderKey,
|
||||
matchId,
|
||||
expectedAuctionLifecycleId ?? '',
|
||||
]);
|
||||
|
||||
@@ -72,6 +72,10 @@ export class StartAuctionDto {
|
||||
}
|
||||
|
||||
export class PlaceBidDto {
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
clientObservedBidRoundId?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsUUID()
|
||||
bidRequestId?: string;
|
||||
|
||||
@@ -7,7 +7,13 @@ function makeService(
|
||||
) {
|
||||
const sendCommand = jest
|
||||
.fn()
|
||||
.mockImplementation(() => Promise.resolve(commandReplies.shift()));
|
||||
.mockImplementation((command: string[]) =>
|
||||
Promise.resolve(
|
||||
command[0] === 'EVAL'
|
||||
? [currentServerTimestampMS, ...commandReplies.splice(0, 3)]
|
||||
: commandReplies.shift(),
|
||||
),
|
||||
);
|
||||
const auctionRedisService = {
|
||||
getCurrentRedisTimestampMS: jest
|
||||
.fn()
|
||||
@@ -24,17 +30,23 @@ function makeService(
|
||||
|
||||
describe('AuctionRedisStateReaderService', () => {
|
||||
it('reads live state identity', async () => {
|
||||
const { service, sendCommand } = makeService([['life-1', '7']]);
|
||||
const { service, sendCommand } = makeService([
|
||||
['life-1', '7', '3', 'transition-1'],
|
||||
]);
|
||||
|
||||
await expect(service.readLiveStateIdentity('match-1')).resolves.toEqual({
|
||||
auctionLifecycleId: 'life-1',
|
||||
revision: 7,
|
||||
matchSideEffectRevision: 3,
|
||||
matchSideEffectTransitionId: 'transition-1',
|
||||
});
|
||||
expect(sendCommand).toHaveBeenCalledWith([
|
||||
'HMGET',
|
||||
'auction:match-1:liveAuctionState',
|
||||
'auctionLifecycleId',
|
||||
'revision',
|
||||
'matchSideEffectRevision',
|
||||
'matchSideEffectTransitionId',
|
||||
]);
|
||||
});
|
||||
|
||||
@@ -112,7 +124,9 @@ describe('AuctionRedisStateReaderService', () => {
|
||||
|
||||
expect(view).toMatchObject({
|
||||
auctionBidHistory: [{ bidPointAmount: 100, bidderTeamIndex: 2 }],
|
||||
auctionEngineVersion: 'redis-v1',
|
||||
auctionLifecycleId: 'life-1',
|
||||
matchId: 'match-1',
|
||||
auctionTeams: [{ teamIndex: 1 }],
|
||||
canPlaceBidInCurrentBidRound: false,
|
||||
currentHighestBidderTeamIndex: 2,
|
||||
@@ -125,19 +139,14 @@ describe('AuctionRedisStateReaderService', () => {
|
||||
});
|
||||
expect(view).not.toHaveProperty('team:2:remainingBidPointAmount');
|
||||
expect(view).not.toHaveProperty('bidRoundExpiryDecision');
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(1, [
|
||||
'HGETALL',
|
||||
expect(sendCommand).toHaveBeenCalledTimes(1);
|
||||
expect(sendCommand).toHaveBeenCalledWith([
|
||||
'EVAL',
|
||||
expect.stringContaining("redis.call('TIME')"),
|
||||
'3',
|
||||
'auction:match-1:liveAuctionState',
|
||||
]);
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(2, [
|
||||
'GET',
|
||||
'auction:match-1:auctionStructureState',
|
||||
]);
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(3, [
|
||||
'LRANGE',
|
||||
'auction:match-1:auctionBidHistory',
|
||||
'0',
|
||||
'-1',
|
||||
]);
|
||||
});
|
||||
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import { Injectable } from '@nestjs/common';
|
||||
import type { AuctionStateIdentity } from '@lolympus/contracts';
|
||||
import { buildAuctionRedisKeys } from './auction-redis.keys';
|
||||
import { AuctionRedisService } from './auction-redis.service';
|
||||
import { assembleAuctionViewFromRedisState } from './auction-redis.state';
|
||||
@@ -17,10 +18,7 @@ const NUMERIC_LIVE_STATE_FIELDS = new Set([
|
||||
'revision',
|
||||
]);
|
||||
|
||||
export interface AuctionRedisLiveStateIdentity {
|
||||
auctionLifecycleId?: string;
|
||||
revision?: number;
|
||||
}
|
||||
export type AuctionRedisLiveStateIdentity = AuctionStateIdentity;
|
||||
|
||||
export interface AuctionRedisBidContext {
|
||||
auctionLifecycleId: string;
|
||||
@@ -49,6 +47,8 @@ export class AuctionRedisStateReaderService {
|
||||
keys.liveStateKey,
|
||||
'auctionLifecycleId',
|
||||
'revision',
|
||||
'matchSideEffectRevision',
|
||||
'matchSideEffectTransitionId',
|
||||
]);
|
||||
if (!Array.isArray(reply)) return null;
|
||||
const auctionLifecycleId =
|
||||
@@ -61,6 +61,12 @@ export class AuctionRedisStateReaderService {
|
||||
return {
|
||||
auctionLifecycleId,
|
||||
revision: Number.isFinite(revision) ? revision : undefined,
|
||||
matchSideEffectRevision:
|
||||
reply[2] !== null && Number.isFinite(Number(reply[2]))
|
||||
? Number(reply[2])
|
||||
: undefined,
|
||||
matchSideEffectTransitionId:
|
||||
typeof reply[3] === 'string' && reply[3] ? reply[3] : undefined,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -111,18 +117,11 @@ export class AuctionRedisStateReaderService {
|
||||
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']),
|
||||
]);
|
||||
] = await this.auctionRedisService
|
||||
.raw()
|
||||
.sendCommand<
|
||||
unknown[]
|
||||
>(['EVAL', ["local now = redis.call('TIME')", 'local timestamp = tonumber(now[1]) * 1000 + math.floor(tonumber(now[2]) / 1000)', "return {tostring(timestamp), redis.call('HGETALL', KEYS[1]), redis.call('GET', KEYS[2]), redis.call('LRANGE', KEYS[3], 0, -1)}"].join('\n'), '3', keys.liveStateKey, keys.structureStateKey, keys.bidHistoryKey]);
|
||||
|
||||
const liveState = parseHashReply(liveReply, {
|
||||
includeInternalLiveStateFields:
|
||||
@@ -144,7 +143,7 @@ export class AuctionRedisStateReaderService {
|
||||
auctionBidHistoryEntries: Array.isArray(bidEntries)
|
||||
? bidEntries.map(String)
|
||||
: [],
|
||||
currentServerTimestampMS,
|
||||
currentServerTimestampMS: Number(currentServerTimestampMS),
|
||||
liveState: liveState as Record<string, unknown> & {
|
||||
auctionLifecycleId: string;
|
||||
phase: string;
|
||||
@@ -154,6 +153,7 @@ export class AuctionRedisStateReaderService {
|
||||
structureState: parseJsonRecord(structureStateJson),
|
||||
});
|
||||
view.matchId = matchId;
|
||||
view.auctionEngineVersion = 'redis-v1';
|
||||
if (options.includeInternalLiveStateFields) {
|
||||
view.redisInternalPhase = liveState.phase;
|
||||
}
|
||||
|
||||
@@ -46,6 +46,7 @@ describe('auction apply transition redis script contract', () => {
|
||||
'auction:match-1:bidRequestResults',
|
||||
'auction:match-1:bidRequestResultOrder',
|
||||
'auction:bidRoundDeadlineQueue',
|
||||
'auction:match-1:rejectedBidRequestResultOrder',
|
||||
]);
|
||||
expect(invocation.values.slice(0, 19)).toEqual([
|
||||
'match-1',
|
||||
|
||||
@@ -79,6 +79,7 @@ export function buildAuctionApplyTransitionScriptInvocation(
|
||||
keys.bidRequestResultsKey,
|
||||
keys.bidRequestResultOrderKey,
|
||||
keys.deadlineQueueKey,
|
||||
keys.rejectedBidRequestResultOrderKey,
|
||||
],
|
||||
script: AUCTION_APPLY_TRANSITION_SCRIPT,
|
||||
values: [
|
||||
@@ -128,6 +129,7 @@ local auctionBidHistoryKey = KEYS[8]
|
||||
local bidRequestResultsKey = KEYS[9]
|
||||
local bidRequestResultOrderKey = KEYS[10]
|
||||
local bidRoundDeadlineQueueKey = KEYS[11]
|
||||
local rejectedBidRequestResultOrderKey = KEYS[12]
|
||||
|
||||
local matchId = ARGV[1]
|
||||
local auctionLifecycleId = ARGV[2]
|
||||
@@ -270,16 +272,27 @@ for i = 1, liveStatePatchPairCount do
|
||||
end
|
||||
redis.call('HSET', unpack(hsetArgs))
|
||||
|
||||
local committedBidRoundDeadlineTimestampMS = ''
|
||||
if deadlineMode == 'set-relative' then
|
||||
local currentBidRoundDeadlineTimestampMS = currentRedisTimestampMS + (deadlineDurationSeconds * 1000)
|
||||
committedBidRoundDeadlineTimestampMS = tostring(currentBidRoundDeadlineTimestampMS)
|
||||
redis.call('HSET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS', tostring(currentBidRoundDeadlineTimestampMS))
|
||||
redis.call('HSET', liveAuctionStateKey, 'currentBidRoundId', auctionStateTransitionId)
|
||||
redis.call('ZADD', bidRoundDeadlineQueueKey, currentBidRoundDeadlineTimestampMS, matchId)
|
||||
elseif deadlineMode == 'remove' then
|
||||
redis.call('ZREM', bidRoundDeadlineQueueKey, matchId)
|
||||
redis.call('HDEL', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS')
|
||||
end
|
||||
|
||||
-- A resumed auction must not disappear when its former completion TTL elapses.
|
||||
if redis.call('HGET', liveAuctionStateKey, 'phase') ~= 'complete' then
|
||||
for _, index in ipairs({1, 2, 3, 6, 7, 8, 9, 10, 12}) do
|
||||
redis.call('PERSIST', KEYS[index])
|
||||
end
|
||||
end
|
||||
|
||||
if shouldResetBidRuntime == '1' then
|
||||
redis.call('DEL', auctionBidHistoryKey, bidRequestResultsKey, bidRequestResultOrderKey)
|
||||
redis.call('DEL', auctionBidHistoryKey, bidRequestResultsKey, bidRequestResultOrderKey, rejectedBidRequestResultOrderKey)
|
||||
end
|
||||
|
||||
redis.call('SADD', appliedAuctionStateTransitionIdsKey, transitionDedupeMember)
|
||||
@@ -288,6 +301,8 @@ redis.call(
|
||||
durabilityPayloadKey,
|
||||
'payloadJson',
|
||||
durabilityPayloadJson,
|
||||
'committedBidRoundDeadlineTimestampMS',
|
||||
committedBidRoundDeadlineTimestampMS,
|
||||
'preparedAtRedisTimestampMS',
|
||||
tostring(currentRedisTimestampMS),
|
||||
'committedAtRedisTimestampMS',
|
||||
|
||||
@@ -30,6 +30,9 @@ describe('auction bid redis script contract', () => {
|
||||
'auction:match-1:bidRequestResults',
|
||||
'auction:match-1:bidRequestResultOrder',
|
||||
'auction:bidRoundDeadlineQueue',
|
||||
'auction:match-1:rejectedBidRequestResultOrder',
|
||||
'auction:bidArchiveQueue',
|
||||
'auction:bidArchivePayloads',
|
||||
]);
|
||||
expect(invocation.values).toEqual([
|
||||
'match-1',
|
||||
@@ -45,6 +48,7 @@ describe('auction bid redis script contract', () => {
|
||||
'100',
|
||||
'60000',
|
||||
'200',
|
||||
'',
|
||||
]);
|
||||
});
|
||||
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
import type { AuctionRedisKeys } from './auction-redis.keys';
|
||||
import {
|
||||
AUCTION_BID_ARCHIVE_QUEUE_KEY,
|
||||
AUCTION_BID_ARCHIVE_PAYLOADS_KEY,
|
||||
} from './auction-redis.keys';
|
||||
import { defineAuctionRedisScript } from './auction-redis.scripts';
|
||||
|
||||
export interface AuctionBidScriptInput {
|
||||
@@ -8,6 +12,7 @@ export interface AuctionBidScriptInput {
|
||||
bidderUserId: string;
|
||||
clientObservedAuctionLifecycleId: string;
|
||||
clientObservedCurrentBidRoundPlayerUserId: string;
|
||||
clientObservedBidRoundId?: string;
|
||||
maximumAuctionTeamMemberCount: number;
|
||||
maximumStoredAuctionBidHistoryCount: number;
|
||||
maximumStoredBidRequestResultCount: number;
|
||||
@@ -40,15 +45,19 @@ export function buildBidRequestPayloadFingerprint(params: {
|
||||
bidPointAmount: number;
|
||||
clientObservedAuctionLifecycleId: string;
|
||||
clientObservedCurrentBidRoundPlayerUserId: string;
|
||||
clientObservedBidRoundId?: string;
|
||||
matchId: string;
|
||||
}): string {
|
||||
return [
|
||||
const parts = [
|
||||
params.matchId,
|
||||
params.clientObservedAuctionLifecycleId,
|
||||
params.clientObservedCurrentBidRoundPlayerUserId,
|
||||
params.bidderTeamIndex,
|
||||
params.bidPointAmount,
|
||||
].join('|');
|
||||
];
|
||||
if (params.clientObservedBidRoundId)
|
||||
parts.push(params.clientObservedBidRoundId);
|
||||
return parts.join('|');
|
||||
}
|
||||
|
||||
export function buildAuctionBidScriptInvocation(
|
||||
@@ -62,6 +71,9 @@ export function buildAuctionBidScriptInvocation(
|
||||
keys.bidRequestResultsKey,
|
||||
keys.bidRequestResultOrderKey,
|
||||
keys.deadlineQueueKey,
|
||||
keys.rejectedBidRequestResultOrderKey,
|
||||
AUCTION_BID_ARCHIVE_QUEUE_KEY,
|
||||
AUCTION_BID_ARCHIVE_PAYLOADS_KEY,
|
||||
],
|
||||
script: AUCTION_BID_SCRIPT,
|
||||
values: [
|
||||
@@ -78,6 +90,7 @@ export function buildAuctionBidScriptInvocation(
|
||||
String(input.maximumStoredBidRequestResultCount),
|
||||
String(input.minimumBidRequestResultReplayWindowMS),
|
||||
String(input.maximumStoredAuctionBidHistoryCount),
|
||||
input.clientObservedBidRoundId ?? '',
|
||||
],
|
||||
};
|
||||
}
|
||||
@@ -90,6 +103,9 @@ local auctionBidHistoryKey = KEYS[2]
|
||||
local bidRequestResultsKey = KEYS[3]
|
||||
local bidRequestResultOrderKey = KEYS[4]
|
||||
local bidRoundDeadlineQueueKey = KEYS[5]
|
||||
local rejectedBidRequestResultOrderKey = KEYS[6]
|
||||
local bidArchiveQueueKey = KEYS[7]
|
||||
local bidArchivePayloadsKey = KEYS[8]
|
||||
|
||||
local matchId = ARGV[1]
|
||||
local bidderTeamIndex = ARGV[2]
|
||||
@@ -104,6 +120,7 @@ local bidRequestPayloadFingerprint = ARGV[10]
|
||||
local maximumStoredBidRequestResultCount = tonumber(ARGV[11])
|
||||
local minimumBidRequestResultReplayWindowMS = tonumber(ARGV[12])
|
||||
local maximumStoredAuctionBidHistoryCount = tonumber(ARGV[13])
|
||||
local clientObservedBidRoundId = ARGV[14] or ''
|
||||
|
||||
local redisTime = redis.call('TIME')
|
||||
local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000)
|
||||
@@ -168,12 +185,23 @@ if existingFingerprint then
|
||||
return replayExistingRequest()
|
||||
end
|
||||
|
||||
trimOldBidRequestResults()
|
||||
if redis.call('LLEN', bidRequestResultOrderKey) >= maximumStoredBidRequestResultCount then
|
||||
return {'REJECTED', 'BID_REQUEST_RESULT_LIMIT', bidRequestId, tostring(currentRedisTimestampMS)}
|
||||
-- Upgrade the old shared queue once, preserving every accepted replay record.
|
||||
if redis.call('HSETNX', bidRequestResultsKey, '_acceptedOnlyOrderV1', '1') == 1 then
|
||||
for _, oldRequestId in ipairs(redis.call('LRANGE', bidRequestResultOrderKey, 0, -1)) do
|
||||
if redis.call('HGET', bidRequestResultsKey, oldRequestId .. ':status') == 'rejected' then
|
||||
redis.call('LREM', bidRequestResultOrderKey, 0, oldRequestId)
|
||||
hdelBidRequest(oldRequestId)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local function storeRejectedRequest(rejectCode)
|
||||
-- Rejections have their own bounded retention. They must never consume the
|
||||
-- protected replay capacity of accepted bids.
|
||||
while redis.call('LLEN', rejectedBidRequestResultOrderKey) >= maximumStoredBidRequestResultCount do
|
||||
local oldest = redis.call('LPOP', rejectedBidRequestResultOrderKey)
|
||||
if oldest then hdelBidRequest(oldest) end
|
||||
end
|
||||
local rejectedCurrentBidRoundDeadlineTimestampMS = redis.call('HGET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS') or ''
|
||||
redis.call(
|
||||
'HSET',
|
||||
@@ -191,7 +219,7 @@ local function storeRejectedRequest(rejectCode)
|
||||
requestField('createdAtTimestampMS'),
|
||||
tostring(currentRedisTimestampMS)
|
||||
)
|
||||
redis.call('RPUSH', bidRequestResultOrderKey, bidRequestId)
|
||||
redis.call('RPUSH', rejectedBidRequestResultOrderKey, bidRequestId)
|
||||
return {'REJECTED', rejectCode, bidRequestId, tostring(currentRedisTimestampMS), rejectedCurrentBidRoundDeadlineTimestampMS}
|
||||
end
|
||||
|
||||
@@ -202,9 +230,16 @@ end
|
||||
|
||||
local auctionLifecycleId = redis.call('HGET', liveAuctionStateKey, 'auctionLifecycleId')
|
||||
local currentBidRoundPlayerUserId = redis.call('HGET', liveAuctionStateKey, 'currentBidRoundPlayerUserId')
|
||||
local currentBidRoundId = redis.call('HGET', liveAuctionStateKey, 'currentBidRoundId') or ''
|
||||
if currentBidRoundId ~= '' and clientObservedBidRoundId == '' then
|
||||
return storeRejectedRequest('BID_CLIENT_UPDATE_REQUIRED')
|
||||
end
|
||||
if auctionLifecycleId ~= clientObservedAuctionLifecycleId or currentBidRoundPlayerUserId ~= clientObservedCurrentBidRoundPlayerUserId then
|
||||
return storeRejectedRequest('STALE_BID_ROUND')
|
||||
end
|
||||
if currentBidRoundId ~= clientObservedBidRoundId then
|
||||
return storeRejectedRequest('STALE_BID_ROUND')
|
||||
end
|
||||
|
||||
local currentBidRoundDeadlineTimestampMS = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS') or '0')
|
||||
if currentBidRoundDeadlineTimestampMS <= currentRedisTimestampMS then
|
||||
@@ -235,8 +270,9 @@ if bidPointAmount + requiredReserveAfterBid > remainingBidPointAmount then
|
||||
return storeRejectedRequest('INSUFFICIENT')
|
||||
end
|
||||
|
||||
if redis.call('LLEN', auctionBidHistoryKey) >= maximumStoredAuctionBidHistoryCount then
|
||||
return storeRejectedRequest('BID_HISTORY_LIMIT')
|
||||
trimOldBidRequestResults()
|
||||
if redis.call('LLEN', bidRequestResultOrderKey) >= maximumStoredBidRequestResultCount then
|
||||
return {'REJECTED', 'BID_REQUEST_RESULT_LIMIT', bidRequestId, tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
|
||||
local maximumBidRoundDurationSeconds = tonumber(redis.call('HGET', liveAuctionStateKey, 'maximumBidRoundDurationSeconds') or '0')
|
||||
@@ -254,14 +290,36 @@ 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) ..
|
||||
'}'
|
||||
local auctionBidHistoryEntryJson = cjson.encode({
|
||||
bidRequestId = bidRequestId,
|
||||
revision = revision,
|
||||
bidderTeamIndex = tonumber(bidderTeamIndex),
|
||||
bidPointAmount = bidPointAmount,
|
||||
bidderUserId = bidderUserId,
|
||||
playerUserId = currentBidRoundPlayerUserId,
|
||||
bidRoundId = currentBidRoundId,
|
||||
bidPlacedAtTimestampMS = currentRedisTimestampMS
|
||||
})
|
||||
|
||||
-- Accepted replay returns above this point. Persist every accepted event before
|
||||
-- trimming the recent view; the durable archive worker removes only saved events.
|
||||
local archiveId = matchId .. ':' .. auctionLifecycleId .. ':' .. string.format('%016d', revision)
|
||||
redis.call('HSET', bidArchivePayloadsKey, archiveId, cjson.encode({
|
||||
_id = archiveId,
|
||||
matchId = matchId,
|
||||
auctionLifecycleId = auctionLifecycleId,
|
||||
revision = revision,
|
||||
bidRequestId = bidRequestId,
|
||||
bidderTeamIndex = tonumber(bidderTeamIndex),
|
||||
bidPointAmount = bidPointAmount,
|
||||
bidderUserId = bidderUserId,
|
||||
playerUserId = currentBidRoundPlayerUserId,
|
||||
bidRoundId = currentBidRoundId,
|
||||
bidPlacedAtTimestampMS = currentRedisTimestampMS
|
||||
}))
|
||||
redis.call('ZADD', bidArchiveQueueKey, currentRedisTimestampMS, archiveId)
|
||||
redis.call('RPUSH', auctionBidHistoryKey, auctionBidHistoryEntryJson)
|
||||
redis.call('LTRIM', auctionBidHistoryKey, -maximumStoredAuctionBidHistoryCount, -1)
|
||||
redis.call(
|
||||
'HSET',
|
||||
liveAuctionStateKey,
|
||||
|
||||
@@ -4,6 +4,14 @@ export const AUCTION_DURABILITY_RETRY_QUEUE_KEY =
|
||||
'auction:auctionDurabilityRetryQueue';
|
||||
export const AUCTION_DURABILITY_DEAD_LETTER_QUEUE_KEY =
|
||||
'auction:auctionDurabilityDeadLetterQueue';
|
||||
export const AUCTION_DEAD_LETTER_STATUS_QUEUE_KEY =
|
||||
'auction:deadLetterStatusQueue';
|
||||
export const AUCTION_BID_ARCHIVE_QUEUE_KEY = 'auction:bidArchiveQueue';
|
||||
export const AUCTION_BID_ARCHIVE_PAYLOADS_KEY = 'auction:bidArchivePayloads';
|
||||
export const AUCTION_BID_ARCHIVE_DEAD_LETTER_QUEUE_KEY =
|
||||
'auction:bidArchiveDeadLetterQueue';
|
||||
export const AUCTION_BID_ARCHIVE_DEAD_LETTER_PAYLOADS_KEY =
|
||||
'auction:bidArchiveDeadLetterPayloads';
|
||||
|
||||
export interface AuctionRedisKeys {
|
||||
actionRequestResultOrderKey: string;
|
||||
@@ -12,6 +20,7 @@ export interface AuctionRedisKeys {
|
||||
bidHistoryKey: string;
|
||||
bidRequestResultOrderKey: string;
|
||||
bidRequestResultsKey: string;
|
||||
rejectedBidRequestResultOrderKey: string;
|
||||
deadlineQueueKey: string;
|
||||
durabilityDeadLetterQueueKey: string;
|
||||
durabilityPayloadKey: (auctionStateTransitionId: string) => string;
|
||||
@@ -33,6 +42,7 @@ export function buildAuctionRedisKeys(matchId: string): AuctionRedisKeys {
|
||||
bidHistoryKey: `${prefix}:auctionBidHistory`,
|
||||
bidRequestResultOrderKey: `${prefix}:bidRequestResultOrder`,
|
||||
bidRequestResultsKey: `${prefix}:bidRequestResults`,
|
||||
rejectedBidRequestResultOrderKey: `${prefix}:rejectedBidRequestResultOrder`,
|
||||
deadlineQueueKey: AUCTION_BID_ROUND_DEADLINE_QUEUE_KEY,
|
||||
durabilityDeadLetterQueueKey: AUCTION_DURABILITY_DEAD_LETTER_QUEUE_KEY,
|
||||
durabilityPayloadKey: (auctionStateTransitionId: string) =>
|
||||
|
||||
@@ -24,7 +24,7 @@ describe('auction redis state assembly', () => {
|
||||
mongo: { auctionLifecycleId: 'new-life', revision: 2 },
|
||||
},
|
||||
{
|
||||
expected: false,
|
||||
expected: true,
|
||||
live: { auctionLifecycleId: 'redis-life', revision: 3 },
|
||||
mongo: { auctionLifecycleId: 'mongo-life', revision: 2 },
|
||||
},
|
||||
|
||||
@@ -62,13 +62,11 @@ export function shouldHydrateRedisAuctionState(
|
||||
params: ShouldHydrateRedisAuctionStateParams,
|
||||
): boolean {
|
||||
if (!params.live) return true;
|
||||
if (params.mongo.auctionLifecycleId !== params.live.auctionLifecycleId)
|
||||
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
|
||||
);
|
||||
return mongoRevision > redisRevision;
|
||||
}
|
||||
|
||||
export function assembleAuctionViewFromRedisState(
|
||||
@@ -140,13 +138,17 @@ if not liveStatePatchPairCount or #ARGV ~= 8 + (liveStatePatchPairCount * 2) the
|
||||
return {'REJECTED', 'INVALID_PATCH_ARITY', tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
|
||||
-- A lifecycle replacement requires Mongo authority and an explicit cleanup
|
||||
-- under the lifecycle lock. Revision numbers from different runs are unrelated.
|
||||
if redisAuctionLifecycleId and redisAuctionLifecycleId ~= mongoAuctionLifecycleId then
|
||||
return {'REJECTED', 'LIFECYCLE_CONFLICT', 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
|
||||
@@ -184,6 +186,7 @@ if phase == 'bidding' then
|
||||
redis.call('ZADD', bidRoundDeadlineQueueKey, currentBidRoundDeadlineTimestampMS, matchId)
|
||||
else
|
||||
redis.call('ZREM', bidRoundDeadlineQueueKey, matchId)
|
||||
redis.call('HDEL', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS')
|
||||
end
|
||||
|
||||
return {'OK', tostring(hydratedRevision), tostring(currentRedisTimestampMS)}
|
||||
|
||||
@@ -0,0 +1,198 @@
|
||||
import { Logger } from '@nestjs/common';
|
||||
import { CommunityStatsCacheService } from './community-stats-cache.service';
|
||||
|
||||
describe('Community stats cache invalidation retries', () => {
|
||||
let service: CommunityStatsCacheService;
|
||||
let invalidate: jest.SpyInstance<Promise<number>, [string, number?]>;
|
||||
|
||||
beforeEach(() => {
|
||||
jest.useFakeTimers();
|
||||
jest.spyOn(Logger.prototype, 'warn').mockImplementation(() => undefined);
|
||||
service = new CommunityStatsCacheService({} as never);
|
||||
invalidate = jest
|
||||
.spyOn(service, 'invalidateCommunity')
|
||||
.mockRejectedValue(new Error('Redis down'));
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
service.onModuleDestroy();
|
||||
jest.restoreAllMocks();
|
||||
jest.useRealTimers();
|
||||
});
|
||||
|
||||
it('returns true even when successful invalidation deletes no cache entries', async () => {
|
||||
invalidate.mockResolvedValue(0);
|
||||
expect(await service.invalidateCommunityWithRetry('community')).toBe(true);
|
||||
expect(invalidate).toHaveBeenCalledWith('community', 1_000);
|
||||
expect(jest.getTimerCount()).toBe(0);
|
||||
});
|
||||
|
||||
it('returns false immediately, then retries at most three times with increasing delays', async () => {
|
||||
expect(await service.invalidateCommunityWithRetry('community')).toBe(false);
|
||||
expect(invalidate).toHaveBeenCalledTimes(1);
|
||||
for (const [index, delay] of [1_000, 5_000, 30_000].entries()) {
|
||||
await jest.advanceTimersByTimeAsync(delay - 1);
|
||||
expect(invalidate).toHaveBeenCalledTimes(index + 1);
|
||||
await jest.advanceTimersByTimeAsync(1);
|
||||
expect(invalidate).toHaveBeenCalledTimes(index + 2);
|
||||
}
|
||||
expect(jest.getTimerCount()).toBe(0);
|
||||
await jest.advanceTimersByTimeAsync(60_000);
|
||||
expect(invalidate).toHaveBeenCalledTimes(4);
|
||||
expect(Logger.prototype.warn).toHaveBeenCalledWith(
|
||||
expect.stringContaining('retries exhausted for community'),
|
||||
);
|
||||
});
|
||||
|
||||
it('does not reset the scheduled delay or remaining budget after another immediate failure', async () => {
|
||||
await service.invalidateCommunityWithRetry('community');
|
||||
await jest.advanceTimersByTimeAsync(1_000);
|
||||
expect(invalidate).toHaveBeenCalledTimes(2);
|
||||
await jest.advanceTimersByTimeAsync(2_000);
|
||||
expect(await service.invalidateCommunityWithRetry('community')).toBe(false);
|
||||
expect(jest.getTimerCount()).toBe(1);
|
||||
await jest.advanceTimersByTimeAsync(2_999);
|
||||
expect(invalidate).toHaveBeenCalledTimes(3);
|
||||
await jest.advanceTimersByTimeAsync(1);
|
||||
expect(invalidate).toHaveBeenCalledTimes(4);
|
||||
expect(await service.invalidateCommunityWithRetry('community')).toBe(false);
|
||||
await jest.advanceTimersByTimeAsync(30_000);
|
||||
expect(invalidate).toHaveBeenCalledTimes(6);
|
||||
expect(jest.getTimerCount()).toBe(0);
|
||||
await jest.advanceTimersByTimeAsync(60_000);
|
||||
expect(invalidate).toHaveBeenCalledTimes(6);
|
||||
});
|
||||
|
||||
it.each(['immediate', 'background'] as const)(
|
||||
'cancels remaining retries after a successful %s attempt',
|
||||
async (attempt) => {
|
||||
await service.invalidateCommunityWithRetry('community');
|
||||
invalidate.mockResolvedValue(0);
|
||||
if (attempt === 'immediate') {
|
||||
expect(await service.invalidateCommunityWithRetry('community')).toBe(
|
||||
true,
|
||||
);
|
||||
} else {
|
||||
await jest.advanceTimersByTimeAsync(1_000);
|
||||
}
|
||||
expect(jest.getTimerCount()).toBe(0);
|
||||
await jest.advanceTimersByTimeAsync(60_000);
|
||||
expect(invalidate).toHaveBeenCalledTimes(2);
|
||||
},
|
||||
);
|
||||
|
||||
it('unrefs every retry timer so it does not keep the process alive', async () => {
|
||||
const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
|
||||
await service.invalidateCommunityWithRetry('community');
|
||||
for (const delay of [1_000, 5_000, 30_000]) {
|
||||
const timer = setTimeoutSpy.mock.results.at(-1)!.value as NodeJS.Timeout;
|
||||
expect(timer.hasRef()).toBe(false);
|
||||
await jest.advanceTimersByTimeAsync(delay);
|
||||
}
|
||||
});
|
||||
|
||||
it('keeps different communities independent when one continues to fail', async () => {
|
||||
await service.invalidateCommunityWithRetry('first');
|
||||
await service.invalidateCommunityWithRetry('second');
|
||||
invalidate.mockImplementation(async (id) => {
|
||||
if (id === 'first') throw new Error('still unavailable');
|
||||
return 1;
|
||||
});
|
||||
await jest.advanceTimersByTimeAsync(36_000);
|
||||
expect(invalidate.mock.calls.filter(([id]) => id === 'first')).toHaveLength(
|
||||
4,
|
||||
);
|
||||
expect(
|
||||
invalidate.mock.calls.filter(([id]) => id === 'second'),
|
||||
).toHaveLength(2);
|
||||
expect(jest.getTimerCount()).toBe(0);
|
||||
});
|
||||
|
||||
it('clears scheduled retries on shutdown', async () => {
|
||||
await service.invalidateCommunityWithRetry('community');
|
||||
service.onModuleDestroy();
|
||||
expect(jest.getTimerCount()).toBe(0);
|
||||
await jest.advanceTimersByTimeAsync(60_000);
|
||||
expect(invalidate).toHaveBeenCalledTimes(1);
|
||||
expect(await service.invalidateCommunityWithRetry('community')).toBe(false);
|
||||
expect(invalidate).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it.each(['shutdown', 'immediate success'] as const)(
|
||||
'does not reschedule an in-flight retry after %s',
|
||||
async (finish) => {
|
||||
await service.invalidateCommunityWithRetry('community');
|
||||
const pending = deferred();
|
||||
invalidate.mockImplementationOnce(() => pending.promise);
|
||||
await jest.advanceTimersByTimeAsync(1_000);
|
||||
expect(invalidate).toHaveBeenCalledTimes(2);
|
||||
if (finish === 'shutdown') {
|
||||
service.onModuleDestroy();
|
||||
} else {
|
||||
invalidate.mockResolvedValueOnce(1);
|
||||
expect(await service.invalidateCommunityWithRetry('community')).toBe(
|
||||
true,
|
||||
);
|
||||
}
|
||||
pending.reject(new Error('late failure'));
|
||||
await jest.advanceTimersByTimeAsync(60_000);
|
||||
expect(invalidate).toHaveBeenCalledTimes(finish === 'shutdown' ? 2 : 3);
|
||||
expect(jest.getTimerCount()).toBe(0);
|
||||
},
|
||||
);
|
||||
|
||||
it('does not cancel a newer failed request when an older immediate attempt succeeds late', async () => {
|
||||
const pending = deferred();
|
||||
invalidate.mockImplementationOnce(() => pending.promise);
|
||||
const first = service.invalidateCommunityWithRetry('community');
|
||||
expect(await service.invalidateCommunityWithRetry('community')).toBe(false);
|
||||
pending.resolve(1);
|
||||
expect(await first).toBe(true);
|
||||
expect(jest.getTimerCount()).toBe(1);
|
||||
invalidate.mockResolvedValue(1);
|
||||
await jest.advanceTimersByTimeAsync(1_000);
|
||||
expect(invalidate).toHaveBeenCalledTimes(3);
|
||||
expect(jest.getTimerCount()).toBe(0);
|
||||
});
|
||||
|
||||
it('preserves the retry budget when an immediate request fails during an in-flight retry', async () => {
|
||||
await service.invalidateCommunityWithRetry('community');
|
||||
const pending = deferred();
|
||||
invalidate.mockImplementationOnce(() => pending.promise);
|
||||
await jest.advanceTimersByTimeAsync(1_000);
|
||||
expect(await service.invalidateCommunityWithRetry('community')).toBe(false);
|
||||
await jest.advanceTimersByTimeAsync(5_000);
|
||||
expect(invalidate).toHaveBeenCalledTimes(3);
|
||||
pending.resolve(1);
|
||||
await jest.advanceTimersByTimeAsync(5_000);
|
||||
expect(invalidate).toHaveBeenCalledTimes(4);
|
||||
await jest.advanceTimersByTimeAsync(30_000);
|
||||
expect(invalidate).toHaveBeenCalledTimes(5);
|
||||
expect(jest.getTimerCount()).toBe(0);
|
||||
});
|
||||
|
||||
it('does not restart an exhausted budget when an older immediate request fails late', async () => {
|
||||
await service.invalidateCommunityWithRetry('community');
|
||||
await jest.advanceTimersByTimeAsync(6_000);
|
||||
const pending = deferred();
|
||||
invalidate.mockImplementationOnce(() => pending.promise);
|
||||
const immediate = service.invalidateCommunityWithRetry('community');
|
||||
await jest.advanceTimersByTimeAsync(30_000);
|
||||
expect(invalidate).toHaveBeenCalledTimes(5);
|
||||
pending.reject(new Error('late failure'));
|
||||
expect(await immediate).toBe(false);
|
||||
expect(jest.getTimerCount()).toBe(0);
|
||||
await jest.advanceTimersByTimeAsync(60_000);
|
||||
expect(invalidate).toHaveBeenCalledTimes(5);
|
||||
});
|
||||
});
|
||||
|
||||
function deferred() {
|
||||
let resolve!: (value: number) => void;
|
||||
let reject!: (reason: Error) => void;
|
||||
const promise = new Promise<number>((done, fail) => {
|
||||
resolve = done;
|
||||
reject = fail;
|
||||
});
|
||||
return { promise, resolve, reject };
|
||||
}
|
||||
@@ -1,9 +1,15 @@
|
||||
import { Injectable, Logger } from '@nestjs/common';
|
||||
import { Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
|
||||
import { randomUUID } from 'crypto';
|
||||
import { RedisService } from '../global/redis/redis.service';
|
||||
|
||||
const COMMUNITY_STATS_TTL_SECONDS = 5 * 60;
|
||||
const COMMUNITY_STATS_DETAIL_TTL_SECONDS = 24 * 60 * 60;
|
||||
const INVALIDATION_RETRY_DELAYS_MS = [1_000, 5_000, 30_000] as const;
|
||||
interface InvalidationRetry {
|
||||
attempts: number;
|
||||
requestVersion: number;
|
||||
timer?: NodeJS.Timeout;
|
||||
}
|
||||
const CACHE_SCOPES = [
|
||||
'matches',
|
||||
'leaderboard',
|
||||
@@ -64,11 +70,105 @@ return deleted
|
||||
`;
|
||||
|
||||
@Injectable()
|
||||
export class CommunityStatsCacheService {
|
||||
export class CommunityStatsCacheService implements OnModuleDestroy {
|
||||
private readonly logger = new Logger(CommunityStatsCacheService.name);
|
||||
private readonly invalidationRetries = new Map<string, InvalidationRetry>();
|
||||
private destroyed = false;
|
||||
|
||||
constructor(private readonly redisService: RedisService) {}
|
||||
|
||||
public onModuleDestroy(): void {
|
||||
this.destroyed = true;
|
||||
for (const pending of this.invalidationRetries.values()) {
|
||||
if (pending.timer) clearTimeout(pending.timer);
|
||||
}
|
||||
this.invalidationRetries.clear();
|
||||
}
|
||||
|
||||
// Only the immediate attempt determines whether the caller may cache its response.
|
||||
public async invalidateCommunityWithRetry(
|
||||
communityId: string,
|
||||
): Promise<boolean> {
|
||||
if (this.destroyed) return false;
|
||||
const pending = this.invalidationRetries.get(communityId) ?? {
|
||||
attempts: 0,
|
||||
requestVersion: 0,
|
||||
};
|
||||
this.invalidationRetries.set(communityId, pending);
|
||||
const version = ++pending.requestVersion;
|
||||
const succeeded = await this.tryInvalidateCommunity(communityId);
|
||||
if (succeeded && pending.requestVersion === version) {
|
||||
this.clearInvalidationRetry(communityId, pending);
|
||||
} else if (!succeeded) {
|
||||
// An existing retry keeps its remaining budget, including while in flight.
|
||||
this.scheduleInvalidationRetry(communityId, pending);
|
||||
}
|
||||
return succeeded;
|
||||
}
|
||||
|
||||
private scheduleInvalidationRetry(
|
||||
communityId: string,
|
||||
pending: InvalidationRetry,
|
||||
): void {
|
||||
if (
|
||||
this.destroyed ||
|
||||
this.invalidationRetries.get(communityId) !== pending ||
|
||||
pending.timer
|
||||
)
|
||||
return;
|
||||
const delay = INVALIDATION_RETRY_DELAYS_MS[pending.attempts];
|
||||
if (delay === undefined) {
|
||||
this.clearInvalidationRetry(communityId, pending);
|
||||
this.logger.warn(
|
||||
`Stats cache invalidation retries exhausted for ${communityId}; detail recovery and cache expiry will refresh stale responses.`,
|
||||
);
|
||||
return;
|
||||
}
|
||||
pending.attempts += 1;
|
||||
pending.timer = setTimeout(
|
||||
() => void this.retryInvalidation(communityId, pending),
|
||||
delay,
|
||||
);
|
||||
pending.timer.unref();
|
||||
}
|
||||
|
||||
private async retryInvalidation(
|
||||
communityId: string,
|
||||
pending: InvalidationRetry,
|
||||
): Promise<void> {
|
||||
const version = pending.requestVersion;
|
||||
const succeeded = await this.tryInvalidateCommunity(communityId);
|
||||
if (this.invalidationRetries.get(communityId) !== pending) return;
|
||||
pending.timer = undefined;
|
||||
// An older completion must not cancel a newer request's retry.
|
||||
if (succeeded && pending.requestVersion === version) {
|
||||
this.clearInvalidationRetry(communityId, pending);
|
||||
} else {
|
||||
this.scheduleInvalidationRetry(communityId, pending);
|
||||
}
|
||||
}
|
||||
|
||||
private clearInvalidationRetry(
|
||||
communityId: string,
|
||||
pending: InvalidationRetry,
|
||||
): void {
|
||||
if (this.invalidationRetries.get(communityId) !== pending) return;
|
||||
if (pending.timer) clearTimeout(pending.timer);
|
||||
this.invalidationRetries.delete(communityId);
|
||||
}
|
||||
|
||||
private async tryInvalidateCommunity(communityId: string): Promise<boolean> {
|
||||
try {
|
||||
await this.invalidateCommunity(communityId, 1_000);
|
||||
return true;
|
||||
} catch (error) {
|
||||
this.logger.warn(
|
||||
`Stats cache invalidation failed for ${communityId}: ${String(error)}`,
|
||||
);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public async get<T>(key: CommunityStatsCacheKey): Promise<T | null> {
|
||||
const reply = await this.redisService
|
||||
.raw()
|
||||
@@ -117,19 +217,25 @@ export class CommunityStatsCacheService {
|
||||
return this.set(key, value, COMMUNITY_STATS_DETAIL_TTL_SECONDS);
|
||||
}
|
||||
|
||||
public async invalidateCommunity(communityId: string): Promise<number> {
|
||||
public async invalidateCommunity(
|
||||
communityId: string,
|
||||
timeoutMs?: number,
|
||||
): Promise<number> {
|
||||
const prefix = communityPrefix(communityId);
|
||||
const deleted = Number(
|
||||
await this.redisService
|
||||
.raw()
|
||||
.sendCommand([
|
||||
'EVAL',
|
||||
INVALIDATE_CACHE_SCRIPT,
|
||||
String(CACHE_SCOPES.length + 1),
|
||||
`${prefix}:generation`,
|
||||
...CACHE_SCOPES.map((scope) => `${prefix}:${scope}`),
|
||||
randomUUID(),
|
||||
]),
|
||||
.sendCommand(
|
||||
[
|
||||
'EVAL',
|
||||
INVALIDATE_CACHE_SCRIPT,
|
||||
String(CACHE_SCOPES.length + 1),
|
||||
`${prefix}:generation`,
|
||||
...CACHE_SCOPES.map((scope) => `${prefix}:${scope}`),
|
||||
randomUUID(),
|
||||
],
|
||||
timeoutMs === undefined ? undefined : { timeout: timeoutMs },
|
||||
),
|
||||
);
|
||||
|
||||
if (deleted > 0) {
|
||||
|
||||
@@ -0,0 +1,321 @@
|
||||
import mongoose from 'mongoose';
|
||||
import { CommunityStatsService } from './community-stats.service';
|
||||
import { CommunityStatsCacheKey } from './community-stats-cache.service';
|
||||
import type { InternalMatchDetailResponse } from './community-stats.types';
|
||||
|
||||
describe('Community stats raw archive recovery', () => {
|
||||
it.each([true, false])(
|
||||
'recovers a cached missing game even if invalidation needs retry (%s)',
|
||||
async (invalidationSucceeds) => {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
let archived = false;
|
||||
let enriched = false;
|
||||
let generation = 'before';
|
||||
let cached: InternalMatchDetailResponse | null = null;
|
||||
const exists = jest.fn(() => query(archived ? { _id: 'archive' } : null));
|
||||
const buildAndUpsert = jest.fn(async () => {
|
||||
enriched = true;
|
||||
});
|
||||
const invalidateCommunity = jest.fn(async () => {
|
||||
if (!invalidationSucceeds) return false;
|
||||
cached = null;
|
||||
generation = 'after';
|
||||
return true;
|
||||
});
|
||||
const setDetail = jest.fn(
|
||||
async (
|
||||
key: CommunityStatsCacheKey,
|
||||
value: InternalMatchDetailResponse,
|
||||
) => {
|
||||
expect(key.generation).toBe(generation);
|
||||
cached = value;
|
||||
},
|
||||
);
|
||||
const service = new CommunityStatsService(
|
||||
{ getModel: async () => ({ exists }) } as never,
|
||||
{
|
||||
get: async (key: CommunityStatsCacheKey) => {
|
||||
key.generation = generation;
|
||||
return cached;
|
||||
},
|
||||
setDetail,
|
||||
invalidateCommunityWithRetry: invalidateCommunity,
|
||||
} as never,
|
||||
{} as never,
|
||||
{ buildAndUpsert } as never,
|
||||
);
|
||||
const internals = service as unknown as {
|
||||
getDetailRevision: () => Promise<string>;
|
||||
buildBaseDataset: () => Promise<unknown>;
|
||||
matchDetailInFlight: Map<string, unknown>;
|
||||
};
|
||||
jest
|
||||
.spyOn(internals, 'getDetailRevision')
|
||||
.mockResolvedValue('same-revision');
|
||||
jest
|
||||
.spyOn(internals, 'buildBaseDataset')
|
||||
.mockImplementation(async () => ({
|
||||
matches: [{ matchId: matchId.toString() }],
|
||||
detailsByMatchId: new Map([
|
||||
[
|
||||
matchId.toString(),
|
||||
[
|
||||
{
|
||||
gameNumber: 1,
|
||||
riotMatchId: 'KR_1',
|
||||
rawAvailable: enriched,
|
||||
timelineLoaded: enriched,
|
||||
teams: [],
|
||||
},
|
||||
],
|
||||
],
|
||||
]),
|
||||
competition: {
|
||||
projection: {
|
||||
games: [
|
||||
{
|
||||
id: 'official-game',
|
||||
displayNumber: 1,
|
||||
evidence: { type: 'riot', riotMatchId: 'KR_1' },
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
}));
|
||||
|
||||
const missing = await service.getMatchDetail({ communityId, matchId });
|
||||
expect(missing.games[0].analysisAvailability).toBe('missing');
|
||||
expect(await service.getMatchDetail({ communityId, matchId })).toBe(
|
||||
missing,
|
||||
);
|
||||
expect(buildAndUpsert).not.toHaveBeenCalled();
|
||||
|
||||
archived = true;
|
||||
const recovered = await service.getMatchDetail({ communityId, matchId });
|
||||
expect(recovered.games[0]).toMatchObject({
|
||||
gameId: 'official-game',
|
||||
analysisAvailability: 'available',
|
||||
riotMatchId: 'KR_1',
|
||||
});
|
||||
expect(buildAndUpsert).toHaveBeenCalledWith(matchId, {
|
||||
includeTimeline: true,
|
||||
});
|
||||
expect(invalidateCommunity).toHaveBeenCalledWith(communityId.toString());
|
||||
expect(internals.matchDetailInFlight.size).toBe(0);
|
||||
expect(setDetail).toHaveBeenCalledTimes(invalidationSucceeds ? 2 : 1);
|
||||
expect(await service.getMatchDetail({ communityId, matchId })).toEqual(
|
||||
recovered,
|
||||
);
|
||||
expect(buildAndUpsert).toHaveBeenCalledTimes(1);
|
||||
},
|
||||
);
|
||||
|
||||
it('rebuilds only affected missing fragments and invalidates every affected community after the writes', async () => {
|
||||
const first = new mongoose.Types.ObjectId();
|
||||
const second = new mongoose.Types.ObjectId();
|
||||
const fragments = [
|
||||
{
|
||||
matchId: new mongoose.Types.ObjectId(),
|
||||
communityId: first,
|
||||
gameDetails: [{ riotMatchId: 'KR_1', rawAvailable: false }],
|
||||
},
|
||||
{
|
||||
matchId: new mongoose.Types.ObjectId(),
|
||||
communityId: first,
|
||||
gameDetails: [{ riotMatchId: 'KR_1', rawAvailable: true }],
|
||||
},
|
||||
{
|
||||
matchId: new mongoose.Types.ObjectId(),
|
||||
communityId: second,
|
||||
gameDetails: [{ riotMatchId: 'KR_1', rawAvailable: false }],
|
||||
},
|
||||
];
|
||||
const order: string[] = [];
|
||||
const buildAndUpsert = jest.fn(async () => {
|
||||
order.push('build');
|
||||
});
|
||||
const invalidateCommunity = jest.fn(async () => {
|
||||
order.push('invalidate');
|
||||
return true;
|
||||
});
|
||||
const findByRiotMatchIds = jest.fn().mockResolvedValue(fragments);
|
||||
const service = new CommunityStatsService(
|
||||
{
|
||||
getModel: async () => ({ find: () => query([{ matchId: 'KR_1' }]) }),
|
||||
} as never,
|
||||
{ invalidateCommunityWithRetry: invalidateCommunity } as never,
|
||||
{
|
||||
findByRiotMatchIds,
|
||||
findByMatch: async () => ({
|
||||
gameDetails: [{ riotMatchId: 'KR_1', rawAvailable: true }],
|
||||
}),
|
||||
} as never,
|
||||
{ buildAndUpsert } as never,
|
||||
);
|
||||
|
||||
await service.refreshForRiotMatches(['KR_1', 'KR_1', 'KR_ABSENT']);
|
||||
|
||||
expect(findByRiotMatchIds).toHaveBeenCalledWith(['KR_1']);
|
||||
expect(buildAndUpsert.mock.calls).toEqual([
|
||||
[fragments[0].matchId],
|
||||
[fragments[2].matchId],
|
||||
]);
|
||||
expect(invalidateCommunity.mock.calls).toEqual([
|
||||
[first.toString()],
|
||||
[second.toString()],
|
||||
]);
|
||||
expect(order).toEqual(['build', 'build', 'invalidate', 'invalidate']);
|
||||
});
|
||||
|
||||
it('does not invalidate already enriched games or builds that make no progress', async () => {
|
||||
const game = { riotMatchId: 'KR_1', rawAvailable: false };
|
||||
const fragment = {
|
||||
matchId: new mongoose.Types.ObjectId(),
|
||||
communityId: new mongoose.Types.ObjectId(),
|
||||
gameDetails: [game],
|
||||
};
|
||||
const buildAndUpsert = jest.fn().mockResolvedValue(undefined);
|
||||
const invalidateCommunity = jest.fn();
|
||||
const service = new CommunityStatsService(
|
||||
{
|
||||
getModel: async () => ({ find: () => query([{ matchId: 'KR_1' }]) }),
|
||||
} as never,
|
||||
{ invalidateCommunityWithRetry: invalidateCommunity } as never,
|
||||
{
|
||||
findByRiotMatchIds: async () => [fragment],
|
||||
findByMatch: async () => fragment,
|
||||
} as never,
|
||||
{ buildAndUpsert } as never,
|
||||
);
|
||||
await service.refreshForRiotMatches(['KR_1']);
|
||||
game.rawAvailable = true;
|
||||
await service.refreshForRiotMatches(['KR_1']);
|
||||
expect(buildAndUpsert).toHaveBeenCalledTimes(1);
|
||||
expect(invalidateCommunity).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('does not rebuild when raw is still absent', async () => {
|
||||
const findByRiotMatchIds = jest.fn();
|
||||
const buildAndUpsert = jest.fn();
|
||||
const service = new CommunityStatsService(
|
||||
{ getModel: async () => ({ find: () => query([]) }) } as never,
|
||||
{} as never,
|
||||
{ findByRiotMatchIds } as never,
|
||||
{ buildAndUpsert } as never,
|
||||
);
|
||||
await service.refreshForRiotMatches(['KR_1']);
|
||||
expect(findByRiotMatchIds).not.toHaveBeenCalled();
|
||||
expect(buildAndUpsert).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('invalidates successful communities once even when another game fails mid-batch', async () => {
|
||||
const communities = Array.from(
|
||||
{ length: 4 },
|
||||
() => new mongoose.Types.ObjectId(),
|
||||
);
|
||||
const fragments = [0, 1, 0, 2, 3].map((community, index) => ({
|
||||
matchId: new mongoose.Types.ObjectId(),
|
||||
communityId: communities[community],
|
||||
gameDetails: [{ riotMatchId: 'KR_1', rawAvailable: index === 4 }],
|
||||
}));
|
||||
const buildAndUpsert = jest.fn(async (matchId: mongoose.Types.ObjectId) => {
|
||||
const fragment = fragments.find((item) => item.matchId === matchId)!;
|
||||
if (fragment === fragments[1]) throw new Error('one build fails');
|
||||
fragment.gameDetails[0].rawAvailable = true;
|
||||
});
|
||||
const invalidate = jest.fn().mockResolvedValue(true);
|
||||
const service = new CommunityStatsService(
|
||||
{
|
||||
getModel: async () => ({ find: () => query([{ matchId: 'KR_1' }]) }),
|
||||
} as never,
|
||||
{ invalidateCommunityWithRetry: invalidate } as never,
|
||||
{
|
||||
findByRiotMatchIds: async () => fragments,
|
||||
findByMatch: async (id: mongoose.Types.ObjectId) =>
|
||||
fragments.find((item) => item.matchId === id),
|
||||
} as never,
|
||||
{ buildAndUpsert } as never,
|
||||
);
|
||||
await service.refreshForRiotMatches(['KR_1']);
|
||||
expect(buildAndUpsert).toHaveBeenCalledTimes(4);
|
||||
expect(invalidate.mock.calls).toEqual([
|
||||
[communities[0].toString()],
|
||||
[communities[2].toString()],
|
||||
]);
|
||||
});
|
||||
|
||||
it('backs off raw recovery that makes no progress and does not invalidate the community', async () => {
|
||||
let now = 1000;
|
||||
const clock = jest.spyOn(Date, 'now').mockImplementation(() => now);
|
||||
try {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
let cached: InternalMatchDetailResponse | null = null;
|
||||
const buildAndUpsert = jest.fn().mockResolvedValue(undefined);
|
||||
const invalidate = jest.fn();
|
||||
const service = new CommunityStatsService(
|
||||
{
|
||||
getModel: async () => ({ exists: () => query({ _id: 'archive' }) }),
|
||||
} as never,
|
||||
{
|
||||
get: async () => cached,
|
||||
setDetail: async (
|
||||
_key: unknown,
|
||||
value: InternalMatchDetailResponse,
|
||||
) => {
|
||||
cached = value;
|
||||
},
|
||||
invalidateCommunityWithRetry: invalidate,
|
||||
} as never,
|
||||
{} as never,
|
||||
{ buildAndUpsert } as never,
|
||||
);
|
||||
const internals = service as unknown as {
|
||||
getDetailRevision: () => Promise<string>;
|
||||
buildBaseDataset: () => Promise<unknown>;
|
||||
};
|
||||
jest
|
||||
.spyOn(internals, 'getDetailRevision')
|
||||
.mockResolvedValue('same-revision');
|
||||
jest.spyOn(internals, 'buildBaseDataset').mockResolvedValue({
|
||||
matches: [{ matchId: matchId.toString() }],
|
||||
detailsByMatchId: new Map([
|
||||
[
|
||||
matchId.toString(),
|
||||
[
|
||||
{
|
||||
gameNumber: 1,
|
||||
riotMatchId: 'KR_1',
|
||||
rawAvailable: false,
|
||||
timelineLoaded: false,
|
||||
teams: [],
|
||||
},
|
||||
],
|
||||
],
|
||||
]),
|
||||
});
|
||||
await service.getMatchDetail({ communityId, matchId });
|
||||
await service.getMatchDetail({ communityId, matchId });
|
||||
expect(buildAndUpsert).toHaveBeenCalledTimes(1);
|
||||
now += 60_000;
|
||||
await service.getMatchDetail({ communityId, matchId });
|
||||
expect(buildAndUpsert).toHaveBeenCalledTimes(2);
|
||||
expect(invalidate).not.toHaveBeenCalled();
|
||||
} finally {
|
||||
clock.mockRestore();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
function query<T>(value: T) {
|
||||
return {
|
||||
select() {
|
||||
return this;
|
||||
},
|
||||
lean() {
|
||||
return this;
|
||||
},
|
||||
exec: async () => value,
|
||||
};
|
||||
}
|
||||
@@ -1,4 +1,10 @@
|
||||
import { Controller, Get, Param, Query } from '@nestjs/common';
|
||||
import {
|
||||
BadRequestException,
|
||||
Controller,
|
||||
Get,
|
||||
Param,
|
||||
Query,
|
||||
} from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import { AllowPublicAccess } from '../auth/allow-public-access.decorator';
|
||||
import { ParseObjectIdPipe } from '../common/parse-object-id.pipe';
|
||||
@@ -9,6 +15,15 @@ import type { CommunityStatsFilters } from './community-stats.types';
|
||||
export class CommunityStatsController {
|
||||
constructor(private readonly communityStatsService: CommunityStatsService) {}
|
||||
|
||||
@Get('internal-stats/seasons')
|
||||
@AllowPublicAccess()
|
||||
public getSeasons(
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
) {
|
||||
return this.communityStatsService.getSeasons(communityId);
|
||||
}
|
||||
|
||||
@Get('internal-stats/matches')
|
||||
@AllowPublicAccess()
|
||||
public getMatches(
|
||||
@@ -20,7 +35,30 @@ export class CommunityStatsController {
|
||||
@Query('championId') championId?: string,
|
||||
@Query('cursor') cursor?: string,
|
||||
@Query('limit') limit?: string,
|
||||
@Query('q') query?: string,
|
||||
@Query('format') format?: string,
|
||||
@Query('playerId') playerId?: string,
|
||||
@Query('cursorMatchId') cursorMatchId?: string,
|
||||
) {
|
||||
if (format !== undefined && format !== 'pair' && format !== 'tournament') {
|
||||
throw new BadRequestException('Invalid format.');
|
||||
}
|
||||
if (playerId !== undefined && !mongoose.isObjectIdOrHexString(playerId)) {
|
||||
throw new BadRequestException('Invalid playerId.');
|
||||
}
|
||||
if (
|
||||
cursorMatchId !== undefined &&
|
||||
(!mongoose.isObjectIdOrHexString(cursorMatchId) ||
|
||||
this.toNumber(cursor) === undefined)
|
||||
) {
|
||||
throw new BadRequestException('Invalid cursor.');
|
||||
}
|
||||
if (
|
||||
cursor !== undefined &&
|
||||
Number.isNaN(new Date(this.toNumber(cursor) ?? NaN).getTime())
|
||||
) {
|
||||
throw new BadRequestException('Invalid cursor.');
|
||||
}
|
||||
return this.communityStatsService.getMatches({
|
||||
communityId,
|
||||
filters: this.toFilters({
|
||||
@@ -30,6 +68,10 @@ export class CommunityStatsController {
|
||||
championId,
|
||||
cursor,
|
||||
limit,
|
||||
query,
|
||||
format,
|
||||
playerId,
|
||||
cursorMatchId,
|
||||
}),
|
||||
});
|
||||
}
|
||||
@@ -43,10 +85,12 @@ export class CommunityStatsController {
|
||||
@Query('from') from?: string,
|
||||
@Query('to') to?: string,
|
||||
@Query('championId') championId?: string,
|
||||
@Query('q') query?: string,
|
||||
@Query('lane') lane?: string,
|
||||
) {
|
||||
return this.communityStatsService.getLeaderboard({
|
||||
communityId,
|
||||
filters: this.toFilters({ seasonId, from, to, championId }),
|
||||
filters: this.toFilters({ seasonId, from, to, championId, query, lane }),
|
||||
});
|
||||
}
|
||||
|
||||
@@ -88,18 +132,24 @@ export class CommunityStatsController {
|
||||
@Query('championId') championId?: string,
|
||||
@Query('cursor') cursor?: string,
|
||||
@Query('limit') limit?: string,
|
||||
@Query('lane') lane?: string,
|
||||
@Query('includePositionCounts') includePositionCounts?: string,
|
||||
) {
|
||||
return this.communityStatsService.getUserInternalHistory({
|
||||
communityId,
|
||||
userId,
|
||||
filters: this.toFilters({
|
||||
seasonId,
|
||||
from,
|
||||
to,
|
||||
championId,
|
||||
cursor,
|
||||
limit,
|
||||
}),
|
||||
filters: {
|
||||
...this.toFilters({
|
||||
seasonId,
|
||||
from,
|
||||
to,
|
||||
championId,
|
||||
cursor,
|
||||
limit,
|
||||
lane,
|
||||
}),
|
||||
includePositionCounts: includePositionCounts === 'true',
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
@@ -110,7 +160,24 @@ export class CommunityStatsController {
|
||||
championId?: string;
|
||||
cursor?: string;
|
||||
limit?: string;
|
||||
query?: string;
|
||||
format?: CommunityStatsFilters['format'];
|
||||
playerId?: string;
|
||||
cursorMatchId?: string;
|
||||
lane?: string;
|
||||
}): CommunityStatsFilters {
|
||||
if (
|
||||
params.lane !== undefined &&
|
||||
!['TOP', 'JUNGLE', 'MIDDLE', 'BOTTOM', 'UTILITY'].includes(params.lane)
|
||||
) {
|
||||
throw new BadRequestException('Invalid lane.');
|
||||
}
|
||||
if (
|
||||
params.query !== undefined &&
|
||||
(typeof params.query !== 'string' || params.query.length > 100)
|
||||
) {
|
||||
throw new BadRequestException('Invalid search query.');
|
||||
}
|
||||
return {
|
||||
seasonId: params.seasonId,
|
||||
from: params.from,
|
||||
@@ -118,6 +185,11 @@ export class CommunityStatsController {
|
||||
championId: this.toNumber(params.championId),
|
||||
cursor: this.toNumber(params.cursor),
|
||||
limit: this.toNumber(params.limit),
|
||||
query: params.query?.trim(),
|
||||
format: params.format,
|
||||
playerId: params.playerId,
|
||||
cursorMatchId: params.cursorMatchId,
|
||||
lane: params.lane as CommunityStatsFilters['lane'],
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { forwardRef, Module } from '@nestjs/common';
|
||||
import { RiotModule } from '../riot/riot.module';
|
||||
import { CommunityStatsCacheService } from './community-stats-cache.service';
|
||||
import { CommunityStatsController } from './community-stats.controller';
|
||||
@@ -8,7 +8,7 @@ import { MatchStatsRepository } from './match-stats.repository';
|
||||
import { MatchStatsService } from './match-stats.service';
|
||||
|
||||
@Module({
|
||||
imports: [RiotModule],
|
||||
imports: [forwardRef(() => RiotModule)],
|
||||
controllers: [CommunityStatsController],
|
||||
providers: [
|
||||
CommunityStatsService,
|
||||
|
||||
@@ -86,6 +86,246 @@ function record(matchId: mongoose.Types.ObjectId): InternalRecord {
|
||||
}
|
||||
|
||||
describe('CommunityStatsService', () => {
|
||||
it('reads the official result again on a filtered page cache hit and excludes games from stale revisions', async () => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const competitionId = new mongoose.Types.ObjectId();
|
||||
const playerId = new mongoose.Types.ObjectId().toString();
|
||||
const scheduledAt = new Date('2026-06-18T12:00:00Z');
|
||||
const matchCard = {
|
||||
matchId: matchId.toString(),
|
||||
scheduledAt: scheduledAt.toISOString(),
|
||||
games: [{ gameNumber: 1, winnerTeamIndex: 1 }],
|
||||
};
|
||||
const findMatchPage = jest.fn().mockResolvedValue([
|
||||
{
|
||||
matchId,
|
||||
scheduledAt,
|
||||
matchCard,
|
||||
gameDetails: [{ gameNumber: 1, gameCreation: 1000 }],
|
||||
sourceCompetitionId: competitionId,
|
||||
sourceRevision: 4,
|
||||
},
|
||||
{ matchId: new mongoose.Types.ObjectId() },
|
||||
]);
|
||||
const source = {
|
||||
_id: competitionId,
|
||||
matchId,
|
||||
communityId,
|
||||
revision: 4,
|
||||
createdAt: scheduledAt,
|
||||
updatedAt: scheduledAt,
|
||||
teams: [],
|
||||
projection: {
|
||||
phase: 'completed',
|
||||
formatType: 'double-elimination',
|
||||
series: [],
|
||||
outcome: { type: 'double-elimination', championTeamId: 'winner' },
|
||||
},
|
||||
};
|
||||
const find = jest.fn().mockReturnValue({
|
||||
select: () => ({ lean: () => ({ exec: async () => [source] }) }),
|
||||
});
|
||||
let cachedPage: unknown = null;
|
||||
const service = new CommunityStatsService(
|
||||
{
|
||||
getModel: async (name: string) =>
|
||||
name === 'community'
|
||||
? { findById: () => ({ exec: async () => ({ _id: communityId }) }) }
|
||||
: { find },
|
||||
} as unknown as ConnectionService,
|
||||
{
|
||||
get: async () => cachedPage,
|
||||
set: async (_key: unknown, page: unknown) => {
|
||||
cachedPage = JSON.parse(JSON.stringify(page));
|
||||
},
|
||||
} as unknown as CommunityStatsCacheService,
|
||||
{ findMatchPage } as unknown as MatchStatsRepository,
|
||||
{} as MatchStatsService,
|
||||
);
|
||||
jest
|
||||
.spyOn(
|
||||
service as unknown as {
|
||||
repairCommunityFragments: () => Promise<number>;
|
||||
},
|
||||
'repairCommunityFragments',
|
||||
)
|
||||
.mockResolvedValue(0);
|
||||
|
||||
const params = {
|
||||
communityId,
|
||||
filters: {
|
||||
seasonId: 'all',
|
||||
query: '결승',
|
||||
format: 'tournament' as const,
|
||||
playerId,
|
||||
limit: 1,
|
||||
},
|
||||
};
|
||||
const initial = await service.getMatches(params);
|
||||
expect(initial.matches[0]).toMatchObject({
|
||||
games: [{ gameNumber: 1 }],
|
||||
resultPresentation: {
|
||||
type: 'official',
|
||||
phase: 'completed',
|
||||
sourceRevision: 4,
|
||||
outcome: { championTeamId: 'winner' },
|
||||
},
|
||||
});
|
||||
Object.assign(source, {
|
||||
revision: 5,
|
||||
projection: {
|
||||
...source.projection,
|
||||
phase: 'running',
|
||||
outcome: undefined,
|
||||
},
|
||||
});
|
||||
const result = await service.getMatches(params);
|
||||
|
||||
expect(findMatchPage).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
query: '결승',
|
||||
format: 'tournament',
|
||||
playerId,
|
||||
limit: 2,
|
||||
}),
|
||||
);
|
||||
expect(find).toHaveBeenCalledWith({
|
||||
communityId,
|
||||
matchId: { $in: [matchId] },
|
||||
});
|
||||
expect(findMatchPage).toHaveBeenCalledTimes(1);
|
||||
expect(find).toHaveBeenCalledTimes(2);
|
||||
expect(result.matches[0]).toMatchObject({
|
||||
games: [],
|
||||
resultPresentation: {
|
||||
type: 'official',
|
||||
competitionId: competitionId.toString(),
|
||||
sourceRevision: 5,
|
||||
phase: 'running',
|
||||
},
|
||||
});
|
||||
expect(result.nextCursor).toBe(scheduledAt.getTime());
|
||||
expect(result.nextCursorMatchId).toBe(matchId.toString());
|
||||
});
|
||||
|
||||
it.each(['legacy', 'riot', 'unlinked'] as const)(
|
||||
'preserves the scoreboard without retrying a missing Riot archive for %s evidence',
|
||||
async (type) => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const match = { matchId: matchId.toString() };
|
||||
const participant = record(matchId);
|
||||
const matchKey = type === 'legacy' ? 'legacy-reference' : 'KR_1';
|
||||
const buildAndUpsert = jest.fn().mockResolvedValue(undefined);
|
||||
const set = jest.fn();
|
||||
const setDetail = jest.fn();
|
||||
const service = new CommunityStatsService(
|
||||
{
|
||||
getModel: async () => ({
|
||||
exists: () => ({ exec: async () => null }),
|
||||
}),
|
||||
} as unknown as ConnectionService,
|
||||
{
|
||||
get: async () => null,
|
||||
set,
|
||||
setDetail,
|
||||
} as unknown as CommunityStatsCacheService,
|
||||
{} as MatchStatsRepository,
|
||||
{ buildAndUpsert } as unknown as MatchStatsService,
|
||||
);
|
||||
jest
|
||||
.spyOn(
|
||||
service as unknown as { getDetailRevision: () => Promise<string> },
|
||||
'getDetailRevision',
|
||||
)
|
||||
.mockResolvedValue('revision-1');
|
||||
(service as unknown as { buildBaseDataset: jest.Mock }).buildBaseDataset =
|
||||
jest.fn().mockResolvedValue({
|
||||
matches: [match],
|
||||
detailsByMatchId: new Map([
|
||||
[
|
||||
match.matchId,
|
||||
[
|
||||
{
|
||||
gameNumber: 1,
|
||||
riotMatchId: matchKey,
|
||||
gameCreation: 1000,
|
||||
gameDuration: 1800,
|
||||
rawAvailable: false,
|
||||
timelineLoaded: false,
|
||||
teams: [
|
||||
{
|
||||
teamIndex: 1,
|
||||
side: 'blue',
|
||||
win: true,
|
||||
objectives: objectives(),
|
||||
participants: [participant],
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
],
|
||||
]),
|
||||
competition:
|
||||
type === 'unlinked'
|
||||
? undefined
|
||||
: {
|
||||
projection: {
|
||||
games: [
|
||||
{
|
||||
id: 'game-1',
|
||||
seriesId: 'series-1',
|
||||
gameSlotId: 'slot-1',
|
||||
ordinal: 1,
|
||||
displayNumber: 1,
|
||||
evidence:
|
||||
type === 'legacy'
|
||||
? { type, legacyReference: matchKey }
|
||||
: { type, riotMatchId: matchKey },
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
const response = await service.getMatchDetail({ communityId, matchId });
|
||||
const afterCacheMiss = await service.getMatchDetail({
|
||||
communityId,
|
||||
matchId,
|
||||
});
|
||||
|
||||
expect(response.games).toHaveLength(1);
|
||||
expect(response.games).toMatchObject([
|
||||
{
|
||||
...(type === 'unlinked' ? {} : { gameId: 'game-1' }),
|
||||
analysisAvailability: 'missing',
|
||||
teams: [
|
||||
{
|
||||
win: true,
|
||||
participants: [
|
||||
{
|
||||
kills: participant.kills,
|
||||
deaths: participant.deaths,
|
||||
assists: participant.assists,
|
||||
championId: participant.championId,
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
},
|
||||
]);
|
||||
expect(afterCacheMiss).toEqual(response);
|
||||
expect(buildAndUpsert).not.toHaveBeenCalled();
|
||||
expect(set).not.toHaveBeenCalled();
|
||||
expect(setDetail).toHaveBeenCalledTimes(2);
|
||||
expect(setDetail).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ field: expect.stringContaining(':r9:') }),
|
||||
response,
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
it('ignores detail caches missing unified events or containing invalid checkpoints', async () => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
@@ -222,7 +462,13 @@ describe('CommunityStatsService', () => {
|
||||
buildAndUpsert: jest.fn().mockResolvedValue(undefined),
|
||||
} as unknown as jest.Mocked<MatchStatsService>;
|
||||
const service = new CommunityStatsService(
|
||||
{} as ConnectionService,
|
||||
{
|
||||
getModel: jest.fn().mockResolvedValue({
|
||||
findOne: () => ({
|
||||
select: () => ({ lean: () => ({ exec: async () => null }) }),
|
||||
}),
|
||||
}),
|
||||
} as unknown as ConnectionService,
|
||||
cacheService,
|
||||
{} as MatchStatsRepository,
|
||||
matchStatsService,
|
||||
@@ -284,7 +530,7 @@ describe('CommunityStatsService', () => {
|
||||
expect(setDetail).toHaveBeenCalledTimes(2);
|
||||
expect(setDetail).toHaveBeenNthCalledWith(
|
||||
2,
|
||||
expect.objectContaining({ field: expect.stringContaining(':r4:') }),
|
||||
expect.objectContaining({ field: expect.stringContaining(':r9:') }),
|
||||
invalidCheckpointResponse,
|
||||
);
|
||||
});
|
||||
@@ -309,6 +555,7 @@ describe('CommunityStatsService', () => {
|
||||
gameCreation: 1_000,
|
||||
gameDuration: 1_800,
|
||||
winnerSide: 'blue',
|
||||
rawAvailable: true,
|
||||
timelineLoaded: false,
|
||||
timeline: [],
|
||||
objectiveEvents: [],
|
||||
@@ -361,7 +608,13 @@ describe('CommunityStatsService', () => {
|
||||
} as unknown as jest.Mocked<CommunityStatsCacheService>;
|
||||
const buildAndUpsert = jest.fn().mockResolvedValue(undefined);
|
||||
const service = new CommunityStatsService(
|
||||
{} as ConnectionService,
|
||||
{
|
||||
getModel: jest.fn().mockResolvedValue({
|
||||
findOne: () => ({
|
||||
select: () => ({ lean: () => ({ exec: async () => null }) }),
|
||||
}),
|
||||
}),
|
||||
} as unknown as ConnectionService,
|
||||
cacheService,
|
||||
{} as MatchStatsRepository,
|
||||
{ buildAndUpsert } as unknown as MatchStatsService,
|
||||
@@ -378,9 +631,13 @@ describe('CommunityStatsService', () => {
|
||||
const backedOff = await service.getMatchDetail({ communityId, matchId });
|
||||
|
||||
expect(backedOff).toBe(fallback);
|
||||
expect(fallback.games[0].analysisAvailability).toBe('available');
|
||||
expect(buildAndUpsert).toHaveBeenCalledTimes(1);
|
||||
expect(buildAndUpsert).toHaveBeenCalledWith(matchId, {
|
||||
includeTimeline: true,
|
||||
});
|
||||
expect(set).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ field: expect.stringContaining(':r4:') }),
|
||||
expect.objectContaining({ field: expect.stringContaining(':r9:') }),
|
||||
fallback,
|
||||
60,
|
||||
);
|
||||
@@ -392,7 +649,7 @@ describe('CommunityStatsService', () => {
|
||||
expect(buildAndUpsert).toHaveBeenCalledTimes(2);
|
||||
expect(setDetail).toHaveBeenCalledTimes(1);
|
||||
expect(setDetail).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ field: expect.stringContaining(':r4:') }),
|
||||
expect.objectContaining({ field: expect.stringContaining(':r9:') }),
|
||||
recovered,
|
||||
);
|
||||
});
|
||||
@@ -459,7 +716,13 @@ describe('CommunityStatsService', () => {
|
||||
setDetail,
|
||||
} as unknown as jest.Mocked<CommunityStatsCacheService>;
|
||||
const service = new CommunityStatsService(
|
||||
{} as ConnectionService,
|
||||
{
|
||||
getModel: jest.fn().mockResolvedValue({
|
||||
findOne: () => ({
|
||||
select: () => ({ lean: () => ({ exec: async () => null }) }),
|
||||
}),
|
||||
}),
|
||||
} as unknown as ConnectionService,
|
||||
cacheService,
|
||||
{} as MatchStatsRepository,
|
||||
{} as MatchStatsService,
|
||||
@@ -557,6 +820,73 @@ describe('CommunityStatsService', () => {
|
||||
);
|
||||
});
|
||||
|
||||
it('returns independent recent-20 lane windows and counts from records before pagination', async () => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const userId = new mongoose.Types.ObjectId();
|
||||
const records = Array.from({ length: 60 }, (_, index) => ({
|
||||
...record(matchId),
|
||||
userId: userId.toString(),
|
||||
gameNumber: index + 1,
|
||||
riotMatchId: `KR_${index}`,
|
||||
gameCreation: index * 1000,
|
||||
teamPosition: index < 25 ? 'MIDDLE' : 'TOP',
|
||||
}));
|
||||
const repository = {
|
||||
findUserRecordFragments: jest
|
||||
.fn()
|
||||
.mockResolvedValue([
|
||||
{ matchId, builderVersion: MATCH_STATS_BUILDER_VERSION, records },
|
||||
]),
|
||||
findDetailsByMatches: jest.fn().mockResolvedValue([]),
|
||||
} as unknown as jest.Mocked<MatchStatsRepository>;
|
||||
const cache = {
|
||||
get: jest.fn().mockResolvedValue(null),
|
||||
set: jest.fn().mockResolvedValue(undefined),
|
||||
} as unknown as CommunityStatsCacheService;
|
||||
const service = new CommunityStatsService(
|
||||
{} as ConnectionService,
|
||||
cache,
|
||||
repository,
|
||||
{} as MatchStatsService,
|
||||
);
|
||||
(service as unknown as { resolveContext: jest.Mock }).resolveContext = jest
|
||||
.fn()
|
||||
.mockResolvedValue({
|
||||
community: {},
|
||||
season: { id: 'all', label: '전체', startedAt: null, endedAt: null },
|
||||
from: null,
|
||||
to: null,
|
||||
});
|
||||
const mid = await service.getUserInternalHistory({
|
||||
communityId,
|
||||
userId,
|
||||
filters: { limit: 20, lane: 'MIDDLE', includePositionCounts: true },
|
||||
});
|
||||
expect(mid.matches).toHaveLength(20);
|
||||
expect(mid.matches[0].matchId).toBe('KR_24');
|
||||
expect(mid.matches[19].matchId).toBe('KR_5');
|
||||
expect(mid.matches[0].damageShare).toBe(30);
|
||||
expect(mid.positionCounts).toEqual({
|
||||
ALL: 20,
|
||||
TOP: 20,
|
||||
JUNGLE: 0,
|
||||
MIDDLE: 20,
|
||||
BOTTOM: 0,
|
||||
UTILITY: 0,
|
||||
});
|
||||
expect(repository.findUserRecordFragments).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ limit: 0 }),
|
||||
);
|
||||
const all = await service.getUserInternalHistory({
|
||||
communityId,
|
||||
userId,
|
||||
filters: { limit: 20, includePositionCounts: true },
|
||||
});
|
||||
expect(all.matches.every((game) => game.teamPosition === 'TOP')).toBe(true);
|
||||
expect(all.positionCounts).toEqual(mid.positionCounts);
|
||||
});
|
||||
|
||||
it('coalesces concurrent user internal history cache misses', async () => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -1,3 +1,12 @@
|
||||
import type {
|
||||
GameAnalysisAvailability,
|
||||
GameId,
|
||||
GameSlotId,
|
||||
InternalMatchCompetition,
|
||||
InternalMatchResultPresentation,
|
||||
SeriesId,
|
||||
SeriesProjection,
|
||||
} from '@lolympus/contracts';
|
||||
import type {
|
||||
MatchStatsParticipantCheckpoints,
|
||||
MatchStatsItemBuildEvent,
|
||||
@@ -13,17 +22,24 @@ import type {
|
||||
} from '../match-history/match-history.types';
|
||||
|
||||
export interface CommunityStatsFilters {
|
||||
includePositionCounts?: boolean;
|
||||
seasonId?: string;
|
||||
from?: string;
|
||||
to?: string;
|
||||
championId?: number;
|
||||
cursor?: number;
|
||||
limit?: number;
|
||||
query?: string;
|
||||
format?: 'pair' | 'tournament';
|
||||
playerId?: string;
|
||||
cursorMatchId?: string;
|
||||
lane?: RiotLane;
|
||||
}
|
||||
|
||||
export interface InternalMatchListResponse {
|
||||
matches: InternalMatchCardView[];
|
||||
nextCursor: number | null;
|
||||
nextCursorMatchId?: string;
|
||||
season: HistorySeasonDto;
|
||||
}
|
||||
|
||||
@@ -34,6 +50,9 @@ export interface InternalMatchCardView {
|
||||
status: 'finished' | 'in-progress';
|
||||
gameCount: number;
|
||||
winnerTeamIndex?: number;
|
||||
resultPresentation?: InternalMatchResultPresentation;
|
||||
/** Official series only. Historical opponent pairs are not inferred rounds. */
|
||||
series?: SeriesProjection[];
|
||||
seriesResults: Array<{
|
||||
teamAIndex: number;
|
||||
teamBIndex: number;
|
||||
@@ -43,6 +62,9 @@ export interface InternalMatchCardView {
|
||||
}>;
|
||||
games: Array<{
|
||||
gameNumber: number;
|
||||
seriesId?: string;
|
||||
ordinal?: number;
|
||||
analysisAvailability?: GameAnalysisAvailability | 'pending';
|
||||
riotMatchId: string | null;
|
||||
blueTeamIndex: number;
|
||||
redTeamIndex: number;
|
||||
@@ -52,6 +74,7 @@ export interface InternalMatchCardView {
|
||||
}>;
|
||||
teams: Array<{
|
||||
teamIndex: number;
|
||||
teamId?: string;
|
||||
name: string;
|
||||
members: Array<{
|
||||
userId: string;
|
||||
@@ -63,12 +86,15 @@ export interface InternalMatchCardView {
|
||||
|
||||
export interface LeaderboardResponse {
|
||||
rows: LeaderboardRow[];
|
||||
lane?: RiotLane;
|
||||
season: HistorySeasonDto;
|
||||
matchedUserIds?: string[];
|
||||
}
|
||||
|
||||
export interface LeaderboardRow {
|
||||
userId: string;
|
||||
summonerName: string;
|
||||
tagLine?: string;
|
||||
profileIconId: number;
|
||||
games: number;
|
||||
wins: number;
|
||||
@@ -95,16 +121,25 @@ export interface LeaderHighlight {
|
||||
summonerName: string;
|
||||
championId?: number;
|
||||
matchId?: string;
|
||||
internalMatchId?: string;
|
||||
gameNumber?: number;
|
||||
isSingleGame: boolean;
|
||||
}
|
||||
|
||||
export interface TeamInsightsResponse {
|
||||
season: HistorySeasonDto;
|
||||
totals: {
|
||||
matches: number;
|
||||
games: number;
|
||||
analyzedGames: number;
|
||||
players: number;
|
||||
};
|
||||
sideWinRate: {
|
||||
blue: number;
|
||||
red: number;
|
||||
bluePicks: number;
|
||||
redPicks: number;
|
||||
confirmed: { sampleSize: number; blue: number; red: number };
|
||||
};
|
||||
topKda: LeaderHighlight | null;
|
||||
mostKills: LeaderHighlight | null;
|
||||
@@ -116,8 +151,14 @@ export interface TeamInsightsResponse {
|
||||
|
||||
export interface InternalMatchDetailResponse {
|
||||
match: InternalMatchCardView;
|
||||
competition?: InternalMatchCompetition;
|
||||
games: Array<{
|
||||
gameNumber: number;
|
||||
gameId?: GameId;
|
||||
analysisAvailability?: GameAnalysisAvailability;
|
||||
gameSlotId?: GameSlotId;
|
||||
seriesId?: SeriesId;
|
||||
ordinal?: number;
|
||||
riotMatchId: string;
|
||||
gameCreation: number;
|
||||
gameDuration: number;
|
||||
@@ -191,7 +232,9 @@ export interface InternalMatchDetailResponse {
|
||||
}
|
||||
|
||||
export interface UserInternalHistoryResponse {
|
||||
positionCounts?: Record<string, number>;
|
||||
season: HistorySeasonDto;
|
||||
playerStats?: LeaderboardRow | null;
|
||||
championStats: LeaderboardChampionStats;
|
||||
summary: {
|
||||
windowSize: number;
|
||||
|
||||
@@ -0,0 +1,378 @@
|
||||
import { BadRequestException } from '@nestjs/common';
|
||||
import { Test } from '@nestjs/testing';
|
||||
import request from 'supertest';
|
||||
import type { Server } from 'node:http';
|
||||
import mongoose from 'mongoose';
|
||||
import { CommunityStatsService } from './community-stats.service';
|
||||
import { CommunityStatsController } from './community-stats.controller';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import { CommunityStatsCacheService } from './community-stats-cache.service';
|
||||
import { MatchStatsRepository } from './match-stats.repository';
|
||||
import { MatchStatsService } from './match-stats.service';
|
||||
import {
|
||||
MATCH_STATS_BUILDER_VERSION,
|
||||
type InternalRecord,
|
||||
} from './match-stats.types';
|
||||
import { presentStatsCard, statsDate } from './internal-stats-presentation';
|
||||
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const userId = new mongoose.Types.ObjectId();
|
||||
const start = Date.parse('2026-06-18T12:00:00Z');
|
||||
function record(
|
||||
gameNumber: number,
|
||||
values: Partial<InternalRecord> = {},
|
||||
): InternalRecord {
|
||||
return {
|
||||
matchId: matchId.toString(),
|
||||
title: '여름 내전',
|
||||
scheduledAt: new Date(start),
|
||||
gameNumber,
|
||||
riotMatchId: `KR_${gameNumber}`,
|
||||
gameCreation: start + gameNumber * 1800000,
|
||||
gameDuration: 1800,
|
||||
userId: userId.toString(),
|
||||
summonerName: '선수',
|
||||
tagLine: 'KR1',
|
||||
profileIconId: 1,
|
||||
teamIndex: 1,
|
||||
side: 'blue',
|
||||
championId: 1,
|
||||
teamPosition: 'TOP',
|
||||
kills: 8,
|
||||
deaths: 2,
|
||||
assists: 4,
|
||||
win: true,
|
||||
cs: 240,
|
||||
csPerMin: 8,
|
||||
gold: 12000,
|
||||
gpm: 400,
|
||||
killParticipation: 60,
|
||||
damageShare: 30,
|
||||
visionScore: 12,
|
||||
damageDealtToChampions: 18000,
|
||||
...values,
|
||||
} as InternalRecord;
|
||||
}
|
||||
function fixture() {
|
||||
const records = [
|
||||
record(1),
|
||||
record(2, {
|
||||
teamPosition: 'JUNGLE',
|
||||
championId: 2,
|
||||
kills: 2,
|
||||
deaths: 4,
|
||||
assists: 6,
|
||||
win: false,
|
||||
csPerMin: 4,
|
||||
gpm: 300,
|
||||
killParticipation: 40,
|
||||
}),
|
||||
record(3, { kills: 99 }),
|
||||
record(3, { userId: new mongoose.Types.ObjectId().toString() }),
|
||||
];
|
||||
const fragment = {
|
||||
matchId,
|
||||
builderVersion: MATCH_STATS_BUILDER_VERSION,
|
||||
records,
|
||||
gameDetails: [1, 2, 3].map((gameNumber) => ({
|
||||
gameNumber,
|
||||
gameCreation: start + gameNumber * 1800000,
|
||||
winnerSide: gameNumber === 2 ? 'red' : 'blue',
|
||||
rawAvailable: gameNumber !== 3,
|
||||
})),
|
||||
};
|
||||
const cache = new Map<string, unknown>();
|
||||
const repository = {
|
||||
findSeasonStats: jest.fn().mockResolvedValue([fragment]),
|
||||
findUserRecordFragments: jest.fn().mockResolvedValue([fragment]),
|
||||
findDetailsByMatches: jest.fn().mockResolvedValue([]),
|
||||
};
|
||||
const service = new CommunityStatsService(
|
||||
{
|
||||
getModel: async () => ({
|
||||
findById: () => ({
|
||||
exec: async () => ({
|
||||
seasons: [
|
||||
{
|
||||
id: 'june',
|
||||
label: '6월',
|
||||
startedAt: new Date('2026-06-01T00:00:00+09:00'),
|
||||
endedAt: new Date('2026-06-30T23:59:59.999+09:00'),
|
||||
},
|
||||
],
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
} as unknown as ConnectionService,
|
||||
{
|
||||
get: async (key: unknown) => cache.get(JSON.stringify(key)),
|
||||
set: async (key: unknown, value: unknown) => {
|
||||
cache.set(JSON.stringify(key), value);
|
||||
},
|
||||
} as unknown as CommunityStatsCacheService,
|
||||
repository as unknown as MatchStatsRepository,
|
||||
{} as MatchStatsService,
|
||||
);
|
||||
jest
|
||||
.spyOn(
|
||||
service as unknown as { repairCommunityFragments: () => Promise<number> },
|
||||
'repairCommunityFragments',
|
||||
)
|
||||
.mockResolvedValue(0);
|
||||
return { service, repository };
|
||||
}
|
||||
|
||||
describe('internal stats API contract', () => {
|
||||
it('serves the scoped player and leaderboard contracts through the HTTP routes', async () => {
|
||||
const { service } = fixture();
|
||||
const module = await Test.createTestingModule({
|
||||
controllers: [CommunityStatsController],
|
||||
providers: [{ provide: CommunityStatsService, useValue: service }],
|
||||
}).compile();
|
||||
const app = module.createNestApplication();
|
||||
await app.init();
|
||||
const server: Server = app.getHttpServer();
|
||||
try {
|
||||
const base = `/communities/${communityId.toString()}`;
|
||||
const leaderboard = await request(server)
|
||||
.get(`${base}/internal-stats/leaderboard?seasonId=all&lane=TOP`)
|
||||
.expect(200);
|
||||
expect(leaderboard.body).toMatchObject({
|
||||
lane: 'TOP',
|
||||
rows: [{ games: 1, kda: 6 }],
|
||||
});
|
||||
const player = await request(server)
|
||||
.get(
|
||||
`${base}/users/${userId.toString()}/internal-history?seasonId=all&lane=JUNGLE`,
|
||||
)
|
||||
.expect(200);
|
||||
expect(player.body).toMatchObject({
|
||||
playerStats: { games: 1, kda: 2 },
|
||||
matches: [{ gameNumber: 2 }],
|
||||
});
|
||||
await request(server)
|
||||
.get(`${base}/internal-stats/leaderboard?lane=invalid`)
|
||||
.expect(400);
|
||||
await request(server)
|
||||
.get(`${base}/internal-stats/leaderboard?from=2026-02-30`)
|
||||
.expect(400);
|
||||
await request(server)
|
||||
.get('/communities/invalid/internal-stats/leaderboard')
|
||||
.expect(400);
|
||||
} finally {
|
||||
await app.close();
|
||||
}
|
||||
});
|
||||
it('searches escaped text across title, team and player without losing date or cursor constraints', async () => {
|
||||
const chain = {
|
||||
select: jest.fn().mockReturnThis(),
|
||||
sort: jest.fn().mockReturnThis(),
|
||||
limit: jest.fn().mockReturnThis(),
|
||||
lean: jest.fn().mockReturnThis(),
|
||||
exec: jest.fn().mockResolvedValue([]),
|
||||
};
|
||||
const find = jest.fn().mockReturnValue(chain);
|
||||
const repository = new MatchStatsRepository({
|
||||
getModel: async () => ({ find }),
|
||||
} as unknown as ConnectionService);
|
||||
await repository.findMatchPage({
|
||||
communityId,
|
||||
query: '팀.*',
|
||||
from: start,
|
||||
cursor: start + 1000,
|
||||
cursorMatchId: matchId.toString(),
|
||||
limit: 4,
|
||||
});
|
||||
expect(find).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
communityId,
|
||||
$and: expect.arrayContaining([
|
||||
{
|
||||
$or: [
|
||||
'matchCard.title',
|
||||
'matchCard.teams.name',
|
||||
'matchCard.teams.members.summonerName',
|
||||
].map((field) => ({
|
||||
[field]: { $regex: '팀\\.\\*', $options: 'i' },
|
||||
})),
|
||||
},
|
||||
]),
|
||||
}),
|
||||
);
|
||||
expect(chain.limit).toHaveBeenCalledWith(4);
|
||||
expect(chain.select).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ 'gameDetails.rawAvailable': 1 }),
|
||||
);
|
||||
});
|
||||
it('recalculates every metric per lane, isolates cached scopes and excludes missing raw data', async () => {
|
||||
const { service } = fixture();
|
||||
const all = await service.getLeaderboard({
|
||||
communityId,
|
||||
filters: { seasonId: 'all' },
|
||||
});
|
||||
const top = await service.getLeaderboard({
|
||||
communityId,
|
||||
filters: { seasonId: 'all', lane: 'TOP' },
|
||||
});
|
||||
const jungle = await service.getLeaderboard({
|
||||
communityId,
|
||||
filters: { seasonId: 'all', lane: 'JUNGLE' },
|
||||
});
|
||||
expect(all.rows).toHaveLength(1);
|
||||
expect(all.rows[0]).toMatchObject({
|
||||
games: 2,
|
||||
totalKills: 10,
|
||||
winRate: 50,
|
||||
avgGoldPerMin: 350,
|
||||
avgCsPerMin: 6,
|
||||
avgKillParticipation: 50,
|
||||
});
|
||||
expect(top).toMatchObject({
|
||||
lane: 'TOP',
|
||||
rows: [
|
||||
{
|
||||
games: 1,
|
||||
kda: 6,
|
||||
winRate: 100,
|
||||
avgGoldPerMin: 400,
|
||||
avgCsPerMin: 8,
|
||||
avgKillParticipation: 60,
|
||||
},
|
||||
],
|
||||
});
|
||||
expect(jungle).toMatchObject({
|
||||
lane: 'JUNGLE',
|
||||
rows: [{ games: 1, kda: 2, winRate: 0, avgGoldPerMin: 300 }],
|
||||
});
|
||||
expect(
|
||||
await service.getLeaderboard({
|
||||
communityId,
|
||||
filters: { seasonId: 'all' },
|
||||
}),
|
||||
).toEqual(all);
|
||||
const insight = await service.getTeamInsights({
|
||||
communityId,
|
||||
filters: { seasonId: 'all' },
|
||||
});
|
||||
expect(insight.totals).toEqual({
|
||||
matches: 1,
|
||||
games: 3,
|
||||
analyzedGames: 2,
|
||||
players: 2,
|
||||
});
|
||||
expect(insight.topTeamGpm).toMatchObject({
|
||||
internalMatchId: matchId.toString(),
|
||||
gameNumber: 1,
|
||||
metric: 400,
|
||||
});
|
||||
});
|
||||
it('keeps player summary and matches in the same scope while retaining champion choices', async () => {
|
||||
const { service } = fixture();
|
||||
const history = await service.getUserInternalHistory({
|
||||
communityId,
|
||||
userId,
|
||||
filters: { seasonId: 'all', championId: 1 },
|
||||
});
|
||||
expect(history.playerStats).toMatchObject({ games: 1, kda: 6 });
|
||||
expect(history.matches).toHaveLength(1);
|
||||
expect(history.matches[0]).toMatchObject({
|
||||
internalMatchId: matchId.toString(),
|
||||
internalMatchTitle: '여름 내전',
|
||||
gameNumber: 1,
|
||||
});
|
||||
expect(history.championStats.champions).toHaveLength(2);
|
||||
});
|
||||
it('intersects custom dates with the season and accepts inclusive KST calendar dates', async () => {
|
||||
const { service, repository } = fixture();
|
||||
await service.getLeaderboard({
|
||||
communityId,
|
||||
filters: { seasonId: 'june', from: '2026-05-01', to: '2026-07-31' },
|
||||
});
|
||||
expect(repository.findSeasonStats).toHaveBeenCalledWith({
|
||||
communityId,
|
||||
from: Date.parse('2026-05-31T15:00:00Z'),
|
||||
to: Date.parse('2026-06-30T14:59:59.999Z'),
|
||||
});
|
||||
expect(statsDate('2026-06-18', false)?.toISOString()).toBe(
|
||||
'2026-06-17T15:00:00.000Z',
|
||||
);
|
||||
expect(statsDate('2026-06-18', true)?.toISOString()).toBe(
|
||||
'2026-06-18T14:59:59.999Z',
|
||||
);
|
||||
await expect(
|
||||
service.getLeaderboard({ communityId, filters: { from: '2026-02-30' } }),
|
||||
).rejects.toBeInstanceOf(BadRequestException);
|
||||
await expect(
|
||||
service.getLeaderboard({
|
||||
communityId,
|
||||
filters: { from: '2026-06-20', to: '2026-06-19' },
|
||||
}),
|
||||
).rejects.toBeInstanceOf(BadRequestException);
|
||||
});
|
||||
it('rejects unsupported lanes at the HTTP controller boundary', () => {
|
||||
const controller = new CommunityStatsController(
|
||||
{} as CommunityStatsService,
|
||||
);
|
||||
expect(() =>
|
||||
(
|
||||
controller as unknown as {
|
||||
toFilters: (params: { lane: string }) => unknown;
|
||||
}
|
||||
).toFilters({ lane: 'SUPPORT' }),
|
||||
).toThrow(BadRequestException);
|
||||
});
|
||||
it('uses official evidence to distinguish rematches and does not invent round identities', () => {
|
||||
type Card = Parameters<typeof presentStatsCard>[0];
|
||||
type Competition = NonNullable<Parameters<typeof presentStatsCard>[1]>;
|
||||
const card = {
|
||||
games: [
|
||||
{ gameNumber: 1, riotMatchId: 'KR_1' },
|
||||
{ gameNumber: 2, riotMatchId: 'KR_2' },
|
||||
{ gameNumber: 3, riotMatchId: 'old' },
|
||||
],
|
||||
teams: [{ teamIndex: 1 }],
|
||||
} as Card;
|
||||
const competition = {
|
||||
teams: [{ displayOrder: 1, teamId: 'a' }],
|
||||
projection: {
|
||||
games: [
|
||||
{
|
||||
displayNumber: 1,
|
||||
ordinal: 1,
|
||||
seriesId: 'upper',
|
||||
evidence: { type: 'riot', riotMatchId: 'KR_1' },
|
||||
},
|
||||
{
|
||||
displayNumber: 2,
|
||||
ordinal: 1,
|
||||
seriesId: 'final',
|
||||
evidence: { type: 'riot', riotMatchId: 'KR_2' },
|
||||
},
|
||||
{
|
||||
displayNumber: 3,
|
||||
ordinal: 2,
|
||||
seriesId: 'final',
|
||||
evidence: { type: 'riot', riotMatchId: 'replacement' },
|
||||
},
|
||||
],
|
||||
series: [
|
||||
{ seriesId: 'upper' },
|
||||
{ seriesId: 'final' },
|
||||
{ seriesId: 'other', status: 'scheduled' },
|
||||
],
|
||||
},
|
||||
} as unknown as Competition;
|
||||
const result = presentStatsCard(card, competition);
|
||||
expect(result.games.map((game) => game.seriesId)).toEqual([
|
||||
'upper',
|
||||
'final',
|
||||
undefined,
|
||||
]);
|
||||
expect(result.series?.map((series) => series.seriesId)).toEqual([
|
||||
'upper',
|
||||
'final',
|
||||
]);
|
||||
expect(result.teams[0].teamId).toBe('a');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,59 @@
|
||||
import type { InternalMatchCompetition } from '@lolympus/contracts';
|
||||
import type { InternalMatchCardView } from './community-stats.types';
|
||||
|
||||
/** Attach official identities without merging rematches between the same teams. */
|
||||
export function presentStatsCard(
|
||||
card: InternalMatchCardView,
|
||||
competition?: Pick<InternalMatchCompetition, 'teams' | 'projection'>,
|
||||
): InternalMatchCardView {
|
||||
if (!competition) return card;
|
||||
const officialGames = competition.projection.games ?? [];
|
||||
const games = card.games.map((game) => {
|
||||
const official = officialGames.find(
|
||||
(candidate) =>
|
||||
candidate.displayNumber === game.gameNumber &&
|
||||
(candidate.evidence.type === 'riot'
|
||||
? candidate.evidence.riotMatchId
|
||||
: candidate.evidence.legacyReference) === game.riotMatchId,
|
||||
);
|
||||
return official
|
||||
? { ...game, seriesId: official.seriesId, ordinal: official.ordinal }
|
||||
: game;
|
||||
});
|
||||
const visible = new Set(games.map((game) => game.seriesId));
|
||||
return {
|
||||
...card,
|
||||
games,
|
||||
teams: card.teams?.map((team) => ({
|
||||
...team,
|
||||
teamId: competition.teams.find((t) => t.displayOrder === team.teamIndex)
|
||||
?.teamId,
|
||||
})),
|
||||
series: (competition.projection.series ?? []).filter(
|
||||
(series) =>
|
||||
visible.has(series.seriesId) ||
|
||||
(series.status === 'completed' && series.outcome.type !== 'played'),
|
||||
),
|
||||
};
|
||||
}
|
||||
|
||||
/** Date-only inputs are inclusive Korean calendar days; ISO timestamps remain supported. */
|
||||
export function statsDate(
|
||||
value: string | undefined,
|
||||
end: boolean,
|
||||
): Date | null {
|
||||
if (!value) return null;
|
||||
if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
|
||||
const date = new Date(
|
||||
`${value}T${end ? '23:59:59.999' : '00:00:00.000'}+09:00`,
|
||||
);
|
||||
const midnight = new Date(`${value}T00:00:00.000Z`);
|
||||
if (
|
||||
!Number.isFinite(midnight.getTime()) ||
|
||||
midnight.toISOString().slice(0, 10) !== value
|
||||
)
|
||||
return new Date(NaN);
|
||||
return date;
|
||||
}
|
||||
return new Date(value);
|
||||
}
|
||||
@@ -1,4 +1,5 @@
|
||||
import { Injectable } from '@nestjs/common';
|
||||
import { readMultiKills } from '../riot/riot-multi-kill';
|
||||
import mongoose from 'mongoose';
|
||||
import type {
|
||||
MatchDocument,
|
||||
@@ -183,6 +184,7 @@ export class MatchStatsFragmentBuilder {
|
||||
winnerSide: game.winnerSide,
|
||||
timeline: this.toTimeline(raw, rawTeamIdBySide, usableTimeline),
|
||||
timelineLoaded: Boolean(usableTimeline),
|
||||
rawAvailable: true,
|
||||
objectiveEvents,
|
||||
timelineEvents,
|
||||
teams: (['blue', 'red'] as TeamSide[]).map((side) => {
|
||||
@@ -253,6 +255,7 @@ export class MatchStatsFragmentBuilder {
|
||||
winnerSide: game.winnerSide,
|
||||
timeline: [],
|
||||
timelineLoaded: false,
|
||||
rawAvailable: false,
|
||||
objectiveEvents: [],
|
||||
timelineEvents: [],
|
||||
teams: (['blue', 'red'] as TeamSide[]).map((side) => ({
|
||||
@@ -349,6 +352,8 @@ export class MatchStatsFragmentBuilder {
|
||||
rawParticipant?.individualPosition ||
|
||||
'',
|
||||
kills: participant.kills,
|
||||
multiKills: readMultiKills(rawParticipant),
|
||||
tier: snapshot?.tier,
|
||||
deaths: participant.deaths,
|
||||
assists: participant.assists,
|
||||
win: participant.win,
|
||||
|
||||
@@ -0,0 +1,173 @@
|
||||
import mongoose from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import { MatchStatsFragmentBuilder } from './match-stats-fragment.builder';
|
||||
import { MatchStatsRepository } from './match-stats.repository';
|
||||
import { MatchStatsService } from './match-stats.service';
|
||||
import { MATCH_STATS_BUILDER_VERSION } from './match-stats.types';
|
||||
|
||||
describe('MatchStatsService outbox idempotency', () => {
|
||||
it('reuses the latest stored revision when an older outbox event is delivered', async () => {
|
||||
const h = createHarness();
|
||||
h.isCurrent.mockResolvedValue(true);
|
||||
|
||||
await h.service.buildAndUpsert(h.matchId, { sourceRevision: 10 });
|
||||
|
||||
expect(h.isCurrent).toHaveBeenCalledWith({
|
||||
matchId: h.matchId,
|
||||
sourceCompetitionId: h.competitionId,
|
||||
sourceRevision: 12,
|
||||
projectorVersion: 3,
|
||||
builderVersion: MATCH_STATS_BUILDER_VERSION,
|
||||
});
|
||||
expect(h.riotFind).not.toHaveBeenCalled();
|
||||
expect(h.builder.buildFragment).not.toHaveBeenCalled();
|
||||
expect(h.upsert).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('builds once across repeated deliveries after the write succeeds', async () => {
|
||||
const h = createHarness();
|
||||
h.upsert.mockImplementation(async () => {
|
||||
h.isCurrent.mockResolvedValue(true);
|
||||
});
|
||||
|
||||
await h.service.buildAndUpsert(h.matchId, { sourceRevision: 12 });
|
||||
await h.service.buildAndUpsert(h.matchId, { sourceRevision: 12 });
|
||||
|
||||
expect(h.riotFind).toHaveBeenCalledTimes(1);
|
||||
expect(h.builder.buildFragment).toHaveBeenCalledTimes(1);
|
||||
expect(h.upsert).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('retries a failed write without treating an attempted build as complete', async () => {
|
||||
const h = createHarness();
|
||||
h.upsert.mockRejectedValueOnce(new Error('database unavailable'));
|
||||
await expect(
|
||||
h.service.buildAndUpsert(h.matchId, { sourceRevision: 12 }),
|
||||
).rejects.toThrow('database unavailable');
|
||||
|
||||
await h.service.buildAndUpsert(h.matchId, { sourceRevision: 12 });
|
||||
|
||||
expect(h.builder.buildFragment).toHaveBeenCalledTimes(2);
|
||||
expect(h.upsert).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
|
||||
it.each([{}, { sourceRevision: 12, includeTimeline: true }])(
|
||||
'still performs explicit rebuilds and timeline hydration (%j)',
|
||||
async (options) => {
|
||||
const h = createHarness();
|
||||
h.isCurrent.mockResolvedValue(true);
|
||||
|
||||
await h.service.buildAndUpsert(h.matchId, options);
|
||||
|
||||
expect(h.isCurrent).not.toHaveBeenCalled();
|
||||
expect(h.builder.buildFragment).toHaveBeenCalledTimes(1);
|
||||
expect(h.upsert).toHaveBeenCalledTimes(1);
|
||||
if ('includeTimeline' in options) {
|
||||
expect(h.getMatchTimeline).toHaveBeenCalledWith('KR_1', {
|
||||
region: 'asia',
|
||||
});
|
||||
}
|
||||
},
|
||||
);
|
||||
|
||||
it('deletes reversed zero-game stats even if their versions were current', async () => {
|
||||
const h = createHarness();
|
||||
h.competition.projection.games = [];
|
||||
h.isCurrent.mockResolvedValue(true);
|
||||
|
||||
await h.service.buildAndUpsert(h.matchId, { sourceRevision: 12 });
|
||||
|
||||
expect(h.isCurrent).not.toHaveBeenCalled();
|
||||
expect(h.deleteByMatch).toHaveBeenCalledWith(h.matchId, {
|
||||
sourceCompetitionId: h.competitionId,
|
||||
sourceRevision: 12,
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
function createHarness() {
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const competitionId = new mongoose.Types.ObjectId();
|
||||
const teamAId = new mongoose.Types.ObjectId();
|
||||
const teamBId = new mongoose.Types.ObjectId();
|
||||
const match = {
|
||||
_id: matchId,
|
||||
communityId: new mongoose.Types.ObjectId(),
|
||||
status: 'in-progress',
|
||||
scheduledAt: new Date(),
|
||||
teams: [],
|
||||
};
|
||||
const competition = {
|
||||
_id: competitionId,
|
||||
revision: 12,
|
||||
projectorVersion: 3,
|
||||
teams: [
|
||||
{ teamId: teamAId, displayOrder: 1 },
|
||||
{ teamId: teamBId, displayOrder: 2 },
|
||||
],
|
||||
projection: {
|
||||
phase: 'running',
|
||||
games: [
|
||||
{
|
||||
displayNumber: 1,
|
||||
evidence: { type: 'riot', riotMatchId: 'KR_1' },
|
||||
teams: { blue: { teamId: teamAId }, red: { teamId: teamBId } },
|
||||
winnerTeamId: teamAId,
|
||||
},
|
||||
],
|
||||
},
|
||||
};
|
||||
const riotFind = jest.fn(() => query([{ matchId: 'KR_1', raw: {} }]));
|
||||
const models = {
|
||||
match: { findById: () => query(match) },
|
||||
competition: { findOne: () => query(competition) },
|
||||
riotMatch: { find: riotFind },
|
||||
community: { findById: () => query({ riotRegion: 'asia' }) },
|
||||
};
|
||||
const connection = {
|
||||
getModel: async (name: keyof typeof models) => models[name],
|
||||
} as unknown as ConnectionService;
|
||||
const isCurrent = jest.fn().mockResolvedValue(false);
|
||||
const upsert = jest.fn().mockResolvedValue(undefined);
|
||||
const deleteByMatch = jest.fn().mockResolvedValue(undefined);
|
||||
const repository = {
|
||||
hasCurrentCompetitionFragment: isCurrent,
|
||||
upsert,
|
||||
deleteByMatch,
|
||||
} as unknown as MatchStatsRepository;
|
||||
const builder = {
|
||||
buildFragment: jest.fn().mockReturnValue({
|
||||
matchCard: {},
|
||||
records: [],
|
||||
gameDetails: [],
|
||||
userIds: [],
|
||||
championIds: [],
|
||||
gameCreationMin: 1,
|
||||
gameCreationMax: 2,
|
||||
}),
|
||||
} as unknown as jest.Mocked<MatchStatsFragmentBuilder>;
|
||||
const getMatchTimeline = jest.fn().mockResolvedValue(undefined);
|
||||
const service = new MatchStatsService(connection, repository, builder, {
|
||||
getMatchTimeline,
|
||||
} as never);
|
||||
return {
|
||||
service,
|
||||
matchId,
|
||||
competitionId,
|
||||
competition,
|
||||
isCurrent,
|
||||
upsert,
|
||||
deleteByMatch,
|
||||
riotFind,
|
||||
builder,
|
||||
getMatchTimeline,
|
||||
};
|
||||
}
|
||||
|
||||
function query<T>(value: T) {
|
||||
return {
|
||||
select: jest.fn().mockReturnThis(),
|
||||
lean: jest.fn().mockReturnThis(),
|
||||
exec: async () => value,
|
||||
};
|
||||
}
|
||||
@@ -4,6 +4,35 @@ import type { MatchStats } from '../global/database/schema';
|
||||
import { MatchStatsRepository } from './match-stats.repository';
|
||||
|
||||
describe('MatchStatsRepository', () => {
|
||||
it.each([null, { _id: new Types.ObjectId() }])(
|
||||
'checks persisted source identity and every build version without loading payloads (%j)',
|
||||
async (stored) => {
|
||||
const exists = jest.fn(() => ({ exec: async () => stored }));
|
||||
const connection = {
|
||||
getModel: jest.fn().mockResolvedValue({ exists }),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = new MatchStatsRepository(connection);
|
||||
const source = {
|
||||
matchId: new Types.ObjectId(),
|
||||
sourceCompetitionId: new Types.ObjectId(),
|
||||
sourceRevision: 12,
|
||||
projectorVersion: 3,
|
||||
builderVersion: 10,
|
||||
};
|
||||
|
||||
await expect(
|
||||
repository.hasCurrentCompetitionFragment(source),
|
||||
).resolves.toBe(Boolean(stored));
|
||||
expect(exists).toHaveBeenCalledWith({
|
||||
matchId: source.matchId,
|
||||
sourceCompetitionId: source.sourceCompetitionId,
|
||||
sourceRevision: { $gte: 12 },
|
||||
projectorVersion: { $gte: 3 },
|
||||
builderVersion: { $gte: 10 },
|
||||
});
|
||||
},
|
||||
);
|
||||
|
||||
it('does not let a legacy upsert overwrite a Competition-backed fragment', async () => {
|
||||
const fragment = {
|
||||
...statsFragment(12),
|
||||
|
||||
@@ -5,8 +5,12 @@ import type { MatchStats, MatchStatsDocument } from '../global/database/schema';
|
||||
|
||||
export type MatchStatsUserRecordFragment = Pick<
|
||||
MatchStats,
|
||||
'matchId' | 'records'
|
||||
>;
|
||||
'matchId' | 'records' | 'builderVersion'
|
||||
> & {
|
||||
gameDetails?: Array<
|
||||
Pick<MatchStats['gameDetails'][number], 'gameNumber' | 'rawAvailable'>
|
||||
>;
|
||||
};
|
||||
|
||||
export type MatchStatsDetailFragment = Pick<
|
||||
MatchStats,
|
||||
@@ -22,6 +26,25 @@ export interface MatchStatsDeleteGuard {
|
||||
export class MatchStatsRepository {
|
||||
constructor(private readonly connectionService: ConnectionService) {}
|
||||
|
||||
public async hasCurrentCompetitionFragment(params: {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
sourceCompetitionId: mongoose.Types.ObjectId;
|
||||
sourceRevision: number;
|
||||
projectorVersion: number;
|
||||
builderVersion: number;
|
||||
}): Promise<boolean> {
|
||||
const MatchStatsModel = await this.connectionService.getModel('matchStats');
|
||||
return Boolean(
|
||||
await MatchStatsModel.exists({
|
||||
matchId: params.matchId,
|
||||
sourceCompetitionId: params.sourceCompetitionId,
|
||||
sourceRevision: { $gte: params.sourceRevision },
|
||||
projectorVersion: { $gte: params.projectorVersion },
|
||||
builderVersion: { $gte: params.builderVersion },
|
||||
}).exec(),
|
||||
);
|
||||
}
|
||||
|
||||
public async upsert(
|
||||
fragment: Omit<MatchStats, 'createdAt' | 'updatedAt'>,
|
||||
): Promise<void> {
|
||||
@@ -133,6 +156,119 @@ export class MatchStatsRepository {
|
||||
return MatchStatsModel.findOne({ matchId }).exec();
|
||||
}
|
||||
|
||||
public async findByRiotMatchIds(riotMatchIds: string[]) {
|
||||
const MatchStatsModel = await this.connectionService.getModel('matchStats');
|
||||
return MatchStatsModel.find({
|
||||
'gameDetails.riotMatchId': { $in: riotMatchIds },
|
||||
})
|
||||
.select({
|
||||
matchId: 1,
|
||||
communityId: 1,
|
||||
'gameDetails.riotMatchId': 1,
|
||||
'gameDetails.rawAvailable': 1,
|
||||
})
|
||||
.lean()
|
||||
.exec();
|
||||
}
|
||||
|
||||
public async findMatchPage(params: {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
from?: number;
|
||||
to?: number;
|
||||
query?: string;
|
||||
format?: 'pair' | 'tournament';
|
||||
playerId?: string;
|
||||
championId?: number;
|
||||
cursor?: number;
|
||||
cursorMatchId?: string;
|
||||
limit: number;
|
||||
}) {
|
||||
const model = await this.connectionService.getModel('matchStats');
|
||||
const filter: Record<string, unknown> = { communityId: params.communityId };
|
||||
const conditions: Array<Record<string, unknown>> = [];
|
||||
const gameCreation = {
|
||||
...(params.from === undefined ? {} : { $gte: params.from }),
|
||||
...(params.to === undefined ? {} : { $lte: params.to }),
|
||||
};
|
||||
if (Object.keys(gameCreation).length > 0) {
|
||||
conditions.push({
|
||||
$or: [
|
||||
{ gameDetails: { $elemMatch: { gameCreation } } },
|
||||
{
|
||||
'gameDetails.0': { $exists: false },
|
||||
gameCreationMin: gameCreation,
|
||||
},
|
||||
],
|
||||
});
|
||||
}
|
||||
if (params.from !== undefined)
|
||||
filter.gameCreationMax = { $gte: params.from };
|
||||
if (params.to !== undefined) filter.gameCreationMin = { $lte: params.to };
|
||||
if (params.championId) {
|
||||
filter.records = {
|
||||
$elemMatch: {
|
||||
championId: params.championId,
|
||||
...(Object.keys(gameCreation).length > 0 ? { gameCreation } : {}),
|
||||
},
|
||||
};
|
||||
}
|
||||
if (params.query) {
|
||||
const search = {
|
||||
$regex: params.query.replace(/[.*+?^$\x7b\x7d()|[\]\\]/g, '\\$&'),
|
||||
$options: 'i',
|
||||
};
|
||||
conditions.push({
|
||||
$or: [
|
||||
{ 'matchCard.title': search },
|
||||
{ 'matchCard.teams.name': search },
|
||||
{ 'matchCard.teams.members.summonerName': search },
|
||||
],
|
||||
});
|
||||
}
|
||||
if (params.format) {
|
||||
filter['matchCard.teams.1'] = { $exists: true };
|
||||
filter['matchCard.teams.2'] = { $exists: params.format === 'tournament' };
|
||||
}
|
||||
if (params.playerId) {
|
||||
filter['matchCard.teams.members.userId'] = params.playerId;
|
||||
}
|
||||
if (params.cursor !== undefined) {
|
||||
const cursor = new Date(params.cursor);
|
||||
if (params.cursorMatchId) {
|
||||
conditions.push({
|
||||
$or: [
|
||||
{ scheduledAt: { $lt: cursor } },
|
||||
{
|
||||
scheduledAt: cursor,
|
||||
matchId: {
|
||||
$lt: new mongoose.Types.ObjectId(params.cursorMatchId),
|
||||
},
|
||||
},
|
||||
],
|
||||
});
|
||||
} else {
|
||||
filter.scheduledAt = { $lt: cursor };
|
||||
}
|
||||
}
|
||||
if (conditions.length > 0) filter.$and = conditions;
|
||||
return model
|
||||
.find(filter)
|
||||
.select({
|
||||
matchId: 1,
|
||||
scheduledAt: 1,
|
||||
matchCard: 1,
|
||||
sourceCompetitionId: 1,
|
||||
sourceRevision: 1,
|
||||
'gameDetails.gameNumber': 1,
|
||||
'gameDetails.gameCreation': 1,
|
||||
'gameDetails.rawAvailable': 1,
|
||||
})
|
||||
.sort({ scheduledAt: -1, matchId: -1 })
|
||||
.limit(params.limit)
|
||||
.lean()
|
||||
.exec();
|
||||
}
|
||||
|
||||
public async findByCommunity(params: {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
fromGameCreation?: number;
|
||||
@@ -156,6 +292,54 @@ export class MatchStatsRepository {
|
||||
.exec();
|
||||
}
|
||||
|
||||
public async findSeasonStats(params: {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
from?: number;
|
||||
to?: number;
|
||||
}) {
|
||||
const model = await this.connectionService.getModel('matchStats');
|
||||
return model
|
||||
.find({
|
||||
communityId: params.communityId,
|
||||
...(params.from === undefined
|
||||
? {}
|
||||
: { gameCreationMax: { $gte: params.from } }),
|
||||
...(params.to === undefined
|
||||
? {}
|
||||
: { gameCreationMin: { $lte: params.to } }),
|
||||
})
|
||||
.select({
|
||||
_id: 0,
|
||||
matchId: 1,
|
||||
scheduledAt: 1,
|
||||
'records.userId': 1,
|
||||
'records.summonerName': 1,
|
||||
'records.tagLine': 1,
|
||||
'records.profileIconId': 1,
|
||||
'records.gameCreation': 1,
|
||||
'records.gameNumber': 1,
|
||||
'records.matchId': 1,
|
||||
'records.championId': 1,
|
||||
'records.teamPosition': 1,
|
||||
'records.win': 1,
|
||||
'records.kills': 1,
|
||||
'records.deaths': 1,
|
||||
'records.assists': 1,
|
||||
'records.gpm': 1,
|
||||
'records.csPerMin': 1,
|
||||
'records.killParticipation': 1,
|
||||
'records.visionScore': 1,
|
||||
'records.damageShare': 1,
|
||||
'gameDetails.gameCreation': 1,
|
||||
'gameDetails.gameNumber': 1,
|
||||
'gameDetails.winnerSide': 1,
|
||||
'gameDetails.rawAvailable': 1,
|
||||
})
|
||||
.sort({ scheduledAt: -1 })
|
||||
.lean()
|
||||
.exec();
|
||||
}
|
||||
|
||||
public async findByUser(params: {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
userId: mongoose.Types.ObjectId;
|
||||
@@ -183,7 +367,14 @@ export class MatchStatsRepository {
|
||||
return MatchStatsModel.find(filter)
|
||||
.sort({ scheduledAt: -1 })
|
||||
.limit(params.limit ?? 300)
|
||||
.select({ _id: 0, matchId: 1, records: 1 })
|
||||
.select({
|
||||
_id: 0,
|
||||
matchId: 1,
|
||||
records: 1,
|
||||
builderVersion: 1,
|
||||
'gameDetails.gameNumber': 1,
|
||||
'gameDetails.rawAvailable': 1,
|
||||
})
|
||||
.lean<MatchStatsUserRecordFragment[]>()
|
||||
.exec();
|
||||
}
|
||||
|
||||
@@ -24,6 +24,7 @@ describe('MatchStatsService', () => {
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
hasCurrentCompetitionFragment: jest.fn().mockResolvedValue(false),
|
||||
deleteByMatch: jest.fn().mockResolvedValue(undefined),
|
||||
upsert: jest.fn(),
|
||||
} as unknown as jest.Mocked<MatchStatsRepository>;
|
||||
@@ -72,6 +73,7 @@ describe('MatchStatsService', () => {
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
hasCurrentCompetitionFragment: jest.fn().mockResolvedValue(false),
|
||||
deleteByMatch: jest.fn().mockResolvedValue(undefined),
|
||||
upsert: jest.fn(),
|
||||
} as unknown as jest.Mocked<MatchStatsRepository>;
|
||||
@@ -132,6 +134,7 @@ describe('MatchStatsService', () => {
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
hasCurrentCompetitionFragment: jest.fn().mockResolvedValue(false),
|
||||
upsert: jest.fn().mockResolvedValue(undefined),
|
||||
deleteByMatch: jest.fn(),
|
||||
} as unknown as jest.Mocked<MatchStatsRepository>;
|
||||
@@ -273,6 +276,7 @@ describe('MatchStatsService', () => {
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
hasCurrentCompetitionFragment: jest.fn().mockResolvedValue(false),
|
||||
upsert: jest.fn().mockResolvedValue(undefined),
|
||||
deleteByMatch: jest.fn(),
|
||||
deleteLegacyByMatch: jest.fn(),
|
||||
@@ -408,6 +412,7 @@ describe('MatchStatsService', () => {
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
hasCurrentCompetitionFragment: jest.fn().mockResolvedValue(false),
|
||||
upsert: jest.fn().mockResolvedValue(undefined),
|
||||
deleteByMatch: jest.fn(),
|
||||
} as unknown as jest.Mocked<MatchStatsRepository>;
|
||||
@@ -512,6 +517,7 @@ describe('MatchStatsService', () => {
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
hasCurrentCompetitionFragment: jest.fn().mockResolvedValue(false),
|
||||
upsert: jest.fn().mockResolvedValue(undefined),
|
||||
deleteByMatch: jest.fn().mockResolvedValue(undefined),
|
||||
deleteLegacyByMatch: jest.fn(),
|
||||
@@ -573,6 +579,7 @@ describe('MatchStatsService', () => {
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const repository = {
|
||||
hasCurrentCompetitionFragment: jest.fn().mockResolvedValue(false),
|
||||
upsert: jest.fn(),
|
||||
deleteByMatch: jest.fn(),
|
||||
} as unknown as jest.Mocked<MatchStatsRepository>;
|
||||
|
||||
@@ -47,7 +47,7 @@ export class MatchStatsService {
|
||||
? competitionStatsSource(match, competition)
|
||||
: undefined;
|
||||
const sourceMatch = competitionSource?.match ?? match;
|
||||
if (!this.isEligible(sourceMatch)) {
|
||||
if (!this.isEligible(sourceMatch) && competition?.phase !== 'completed') {
|
||||
if (competitionSource) {
|
||||
await this.repository.deleteByMatch(matchId, {
|
||||
sourceCompetitionId: competitionSource.sourceCompetitionId,
|
||||
@@ -59,6 +59,24 @@ export class MatchStatsService {
|
||||
return;
|
||||
}
|
||||
|
||||
// Outbox redelivery (including older events observing the latest revision)
|
||||
// must not reload Riot payloads or replace an already enriched fragment.
|
||||
// Explicit rebuilds and timeline hydration still run at the same revision.
|
||||
if (
|
||||
options.sourceRevision !== undefined &&
|
||||
!options.includeTimeline &&
|
||||
competitionSource &&
|
||||
(await this.repository.hasCurrentCompetitionFragment({
|
||||
matchId,
|
||||
sourceCompetitionId: competitionSource.sourceCompetitionId,
|
||||
sourceRevision: competitionSource.sourceRevision,
|
||||
projectorVersion: competitionSource.projectorVersion,
|
||||
builderVersion: MATCH_STATS_BUILDER_VERSION,
|
||||
}))
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
const riotIds = competitionSource?.riotMatchIds ?? [
|
||||
...new Set(
|
||||
(match.result?.games ?? [])
|
||||
|
||||
@@ -4,7 +4,7 @@ import type {
|
||||
} from '../global/database/schema';
|
||||
import type { InternalMatchCardView } from './community-stats.types';
|
||||
|
||||
export const MATCH_STATS_BUILDER_VERSION = 10;
|
||||
export const MATCH_STATS_BUILDER_VERSION = 11;
|
||||
|
||||
export type InternalRecord = MatchStatsRecord;
|
||||
export type InternalGameDetail = MatchStatsGameDetail;
|
||||
|
||||
@@ -5,6 +5,7 @@ import {
|
||||
CompetitionBootstrapService,
|
||||
type CompetitionBootstrapMatch,
|
||||
} from './competition-bootstrap.service';
|
||||
import type { SeriesDefinition } from './domain/series-graph';
|
||||
|
||||
describe('CompetitionBootstrapService', () => {
|
||||
it('creates a deterministic paired-Series Competition and immutable snapshots', async () => {
|
||||
@@ -210,6 +211,40 @@ describe('CompetitionBootstrapService', () => {
|
||||
expect(harness.competitionModel.findOneAndUpdate).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('gives a configured BO3 grand final three slots without changing the other stage rules', async () => {
|
||||
const harness = createHarness();
|
||||
const service = new CompetitionBootstrapService(harness.connectionService);
|
||||
const match = matchSnapshot({
|
||||
gameMode: 'double-elimination',
|
||||
teamCount: 4,
|
||||
gameCount: 5,
|
||||
});
|
||||
match.doubleElimination = {
|
||||
teamCount: 4,
|
||||
resetFinalEnabled: true,
|
||||
grandFinalGameCount: 3,
|
||||
seeds: [1, 2, 3, 4].map((teamIndex) => ({
|
||||
seedNumber: teamIndex,
|
||||
teamIndex,
|
||||
})),
|
||||
};
|
||||
|
||||
await service.bootstrap(match);
|
||||
|
||||
const { format, seriesGraph } = harness.insertedPayloads[0];
|
||||
expect(format).toMatchObject({
|
||||
rules: {
|
||||
upper: { maxGames: 5, winsRequired: 3 },
|
||||
lower: { maxGames: 1, winsRequired: 1 },
|
||||
grandFinal: { maxGames: 3, winsRequired: 2 },
|
||||
resetFinal: { maxGames: 1, winsRequired: 1 },
|
||||
},
|
||||
});
|
||||
expect(
|
||||
seriesGraph.find(({ code }) => code === 'GF')?.gameSlots,
|
||||
).toHaveLength(3);
|
||||
});
|
||||
|
||||
it('rejects incomplete and duplicate team assignments before opening a transaction', async () => {
|
||||
const cases: Array<[string, (match: CompetitionBootstrapMatch) => void]> = [
|
||||
[
|
||||
@@ -451,7 +486,7 @@ interface InsertPayload {
|
||||
legacyTeamIndex: number;
|
||||
seedNumber: number;
|
||||
}>;
|
||||
seriesGraph: Array<{ code?: string; rule: unknown }>;
|
||||
seriesGraph: SeriesDefinition[];
|
||||
[key: string]: any;
|
||||
}
|
||||
|
||||
|
||||
@@ -41,6 +41,7 @@ export interface CompetitionBootstrapMatch {
|
||||
doubleElimination?: {
|
||||
teamCount: 4 | 8;
|
||||
resetFinalEnabled: boolean;
|
||||
grandFinalGameCount?: 1 | 3 | 5;
|
||||
seeds: Array<{ seedNumber: number; teamIndex: number }>;
|
||||
};
|
||||
}
|
||||
@@ -514,6 +515,8 @@ function mapMatchFormat(
|
||||
winsRequired: 1,
|
||||
maxGames: 1,
|
||||
};
|
||||
const grandFinalGameCount =
|
||||
match.doubleElimination?.grandFinalGameCount ?? 1;
|
||||
return {
|
||||
type: 'double-elimination',
|
||||
teamCount: teams.length,
|
||||
@@ -525,7 +528,11 @@ function mapMatchFormat(
|
||||
maxGames: match.gameCount,
|
||||
},
|
||||
lower: { ...bestOfOne },
|
||||
grandFinal: { ...bestOfOne },
|
||||
grandFinal: {
|
||||
type: 'first-to',
|
||||
winsRequired: Math.floor(grandFinalGameCount / 2) + 1,
|
||||
maxGames: grandFinalGameCount,
|
||||
},
|
||||
resetFinal: { ...bestOfOne },
|
||||
},
|
||||
};
|
||||
|
||||
@@ -821,7 +821,7 @@ function buildOutbox(
|
||||
};
|
||||
}
|
||||
|
||||
function factForProjection(
|
||||
export function factForProjection(
|
||||
fact: Readonly<Record<string, unknown>>,
|
||||
): Readonly<Record<string, unknown>> {
|
||||
const plain = toPlain(fact) as Readonly<Record<string, unknown>>;
|
||||
|
||||
@@ -13,6 +13,7 @@ export const COMPETITION_FACT_TYPES = [
|
||||
'game-voided',
|
||||
'series-adjudicated',
|
||||
'adjudication-reversed',
|
||||
'grand-final-rule-corrected',
|
||||
] as const;
|
||||
export type CompetitionFactType = (typeof COMPETITION_FACT_TYPES)[number];
|
||||
|
||||
@@ -200,6 +201,7 @@ export interface CompetitionFact {
|
||||
adjudicationFactId?: mongoose.Types.ObjectId;
|
||||
decision?: Record<string, unknown>;
|
||||
reason?: string;
|
||||
ruleCorrection?: { previousMaxGames: 1; nextMaxGames: 3 };
|
||||
createdAt: Date;
|
||||
updatedAt: Date;
|
||||
}
|
||||
@@ -339,6 +341,7 @@ export const CompetitionFactSchema = new Schema<CompetitionFact>(
|
||||
adjudicationFactId: { type: Schema.Types.ObjectId },
|
||||
decision: { type: Schema.Types.Mixed },
|
||||
reason: { type: String },
|
||||
ruleCorrection: { type: Schema.Types.Mixed },
|
||||
},
|
||||
{ timestamps: true, collection: 'competition_fact' },
|
||||
);
|
||||
|
||||
@@ -131,7 +131,12 @@ export interface CompetitionProjection {
|
||||
export function projectCompetition(
|
||||
input: ProjectCompetitionInput,
|
||||
): CompetitionProjection {
|
||||
assertPrimaryFactTargetsGraph(input.seriesGraph, input.facts);
|
||||
// The repair commits the corrected graph and its audit fact together. The
|
||||
// audit fact occupies a revision but is not a game or adjudication.
|
||||
const resultFacts = input.facts.filter(
|
||||
(fact) => !isRecord(fact) || fact.type !== 'grand-final-rule-corrected',
|
||||
);
|
||||
assertPrimaryFactTargetsGraph(input.seriesGraph, resultFacts);
|
||||
const teamBySeed = new Map<number, string>();
|
||||
const knownTeams = new Set<string>();
|
||||
for (const team of input.teams) {
|
||||
@@ -169,7 +174,7 @@ export function projectCompetition(
|
||||
teamBySeed,
|
||||
projectedById,
|
||||
),
|
||||
facts: input.facts,
|
||||
facts: resultFacts,
|
||||
active: false,
|
||||
}),
|
||||
);
|
||||
@@ -188,7 +193,7 @@ export function projectCompetition(
|
||||
projectSeries({
|
||||
definition: asProjectorDefinition(definition),
|
||||
participants,
|
||||
facts: input.facts,
|
||||
facts: resultFacts,
|
||||
}),
|
||||
);
|
||||
remaining.delete(seriesId);
|
||||
@@ -211,7 +216,7 @@ export function projectCompetition(
|
||||
projectSeries({
|
||||
definition: asProjectorDefinition(definition),
|
||||
participants,
|
||||
facts: input.facts,
|
||||
facts: resultFacts,
|
||||
...(definition.activation ? { active: false } : {}),
|
||||
}),
|
||||
);
|
||||
@@ -221,7 +226,7 @@ export function projectCompetition(
|
||||
const gameProjection = projectGamesAndSlots(
|
||||
input.seriesGraph,
|
||||
series,
|
||||
input.facts,
|
||||
resultFacts,
|
||||
);
|
||||
const common = {
|
||||
competitionId: input.competitionId,
|
||||
|
||||
@@ -88,6 +88,7 @@ export interface DoubleEliminationEvent {
|
||||
export interface DoubleEliminationBracket {
|
||||
teamCount: 4 | 8;
|
||||
resetFinalEnabled: boolean;
|
||||
grandFinalGameCount?: 1 | 3 | 5;
|
||||
resetFinalCreated: boolean;
|
||||
seeds: DoubleEliminationSeed[];
|
||||
bracketMatches: DoubleEliminationBracketMatch[];
|
||||
@@ -98,6 +99,7 @@ export interface DoubleEliminationBracket {
|
||||
export interface BuildDoubleEliminationBracketOptions {
|
||||
resetFinalEnabled: boolean;
|
||||
winnerBracketGameCount?: number;
|
||||
grandFinalGameCount?: 1 | 3 | 5;
|
||||
}
|
||||
|
||||
export interface DoubleEliminationSeriesRule {
|
||||
@@ -146,6 +148,9 @@ export function buildDoubleEliminationBracket(
|
||||
const bracket: DoubleEliminationBracket = {
|
||||
teamCount: seededTeamIndexes.length,
|
||||
resetFinalEnabled: options.resetFinalEnabled,
|
||||
...(options.grandFinalGameCount === undefined
|
||||
? {}
|
||||
: { grandFinalGameCount: options.grandFinalGameCount }),
|
||||
resetFinalCreated: false,
|
||||
seeds,
|
||||
bracketMatches:
|
||||
@@ -171,11 +176,17 @@ export function resolveDoubleEliminationSeriesRule(
|
||||
bracketMatchId: string;
|
||||
roundNumber: number;
|
||||
},
|
||||
options: { winnerBracketGameCount?: number } = {},
|
||||
options: Pick<
|
||||
BuildDoubleEliminationBracketOptions,
|
||||
'winnerBracketGameCount' | 'grandFinalGameCount'
|
||||
> = {},
|
||||
): DoubleEliminationSeriesRule {
|
||||
if (params.bracketSide === 'winner') {
|
||||
return seriesRule(options.winnerBracketGameCount ?? 3);
|
||||
}
|
||||
if (params.bracketSide === 'grand-final') {
|
||||
return seriesRule(options.grandFinalGameCount ?? 1);
|
||||
}
|
||||
return seriesRule(1);
|
||||
}
|
||||
|
||||
@@ -431,6 +442,7 @@ function rebuildWithSeeds(
|
||||
): DoubleEliminationBracket {
|
||||
const next = buildDoubleEliminationBracket(teamIndexes, {
|
||||
resetFinalEnabled: bracket.resetFinalEnabled,
|
||||
grandFinalGameCount: bracket.grandFinalGameCount,
|
||||
});
|
||||
next.events = [
|
||||
...bracket.events,
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
export const AUCTION_CANCELLATION_CLEANUP_INDEX = {
|
||||
key: { auctionCancellationCleanupRetryAt: 1 as const },
|
||||
options: {
|
||||
name: 'auction_cancellation_cleanup_due',
|
||||
partialFilterExpression: { auctionCancellationCleanupPending: true },
|
||||
},
|
||||
};
|
||||
@@ -7,6 +7,7 @@ import { readFile } from 'node:fs/promises';
|
||||
import { resolve } from 'node:path';
|
||||
import { ConnectionService, resolveMongoDbName } from '../connection.service';
|
||||
import type {
|
||||
Community,
|
||||
MatchGameResult,
|
||||
MatchParticipant,
|
||||
MatchSeriesResult,
|
||||
@@ -250,16 +251,17 @@ async function main() {
|
||||
);
|
||||
}
|
||||
|
||||
const match = await MatchModel.create(payload);
|
||||
console.log(`[temp result seed] created=${match._id.toString()}`);
|
||||
console.log(`[temp result seed] route=/match/${match._id.toString()}`);
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
await MatchModel.create({ ...payload, _id: matchId });
|
||||
console.log(`[temp result seed] created=${matchId.toString()}`);
|
||||
console.log(`[temp result seed] route=/match/${matchId.toString()}`);
|
||||
} finally {
|
||||
await app.close();
|
||||
}
|
||||
}
|
||||
|
||||
async function resolveCommunity(
|
||||
CommunityModel: mongoose.Model<unknown>,
|
||||
CommunityModel: mongoose.Model<Community>,
|
||||
communityId?: string,
|
||||
): Promise<CommunityLean> {
|
||||
const community = communityId
|
||||
@@ -316,11 +318,11 @@ function buildMatchPayload(
|
||||
description:
|
||||
'결과 페이지 검증용으로 생성된 30명, 6팀, 15경기 완료 임시 데이터입니다.',
|
||||
mapId: 11,
|
||||
status: 'finished',
|
||||
status: 'finished' as const,
|
||||
scheduledAt: options.scheduledAt,
|
||||
maxParticipants: TOTAL_PLAYERS,
|
||||
gameCount: GAME_COUNT_PER_SERIES_GROUP,
|
||||
gameMode: 'round-robin',
|
||||
gameMode: 'round-robin' as const,
|
||||
tournamentCodeIds: [],
|
||||
teamBuiltAt: new Date(options.scheduledAt.getTime() - 30 * 60000),
|
||||
participants,
|
||||
@@ -335,10 +337,10 @@ function buildMatchPayload(
|
||||
resultPollState: {
|
||||
startedAt: new Date(options.scheduledAt.getTime() + 2 * 60 * 60 * 1000),
|
||||
lastPolledAt: now,
|
||||
lastPollOutcome: 'matched',
|
||||
lastPollOutcome: 'matched' as const,
|
||||
matchedCount: games.length,
|
||||
expandedToAllPuuids: true,
|
||||
state: 'complete',
|
||||
state: 'complete' as const,
|
||||
},
|
||||
legacyImported: true,
|
||||
legacyImportSource: {
|
||||
|
||||
@@ -0,0 +1,4 @@
|
||||
export const MATCH_STATS_RIOT_MATCH_INDEX = {
|
||||
key: { 'gameDetails.riotMatchId': 1 as const },
|
||||
options: { name: 'gameDetails.riotMatchId_1' },
|
||||
};
|
||||
+39
@@ -0,0 +1,39 @@
|
||||
import type { mongo } from 'mongoose';
|
||||
import { AUCTION_CANCELLATION_CLEANUP_INDEX } from '../auction-cancellation-index';
|
||||
|
||||
/** Creates only this additive index; never drops or rebuilds other indexes. */
|
||||
export async function migrateAuctionCancellationIndex(
|
||||
db: mongo.Db,
|
||||
{ dryRun = true }: { dryRun?: boolean } = {},
|
||||
) {
|
||||
const { key, options } = AUCTION_CANCELLATION_CLEANUP_INDEX;
|
||||
const collection = db.collection('match');
|
||||
const indexes = await collection
|
||||
.listIndexes()
|
||||
.toArray()
|
||||
.catch((error: unknown) => {
|
||||
if (error instanceof Error && 'code' in error && error.code === 26)
|
||||
return [];
|
||||
throw error;
|
||||
});
|
||||
const existing = indexes.find((index) => index.name === options.name);
|
||||
if (
|
||||
existing &&
|
||||
(JSON.stringify(existing.key) !== JSON.stringify(key) ||
|
||||
JSON.stringify(existing.partialFilterExpression) !==
|
||||
JSON.stringify(options.partialFilterExpression) ||
|
||||
existing.unique === true ||
|
||||
existing.sparse === true ||
|
||||
existing.hidden === true)
|
||||
) {
|
||||
throw new Error(
|
||||
`Index ${options.name} already exists with a different definition.`,
|
||||
);
|
||||
}
|
||||
if (!dryRun) await collection.createIndex(key, options);
|
||||
return {
|
||||
dryRun,
|
||||
alreadyPresent: Boolean(existing),
|
||||
index: { key, ...options },
|
||||
};
|
||||
}
|
||||
+47
@@ -0,0 +1,47 @@
|
||||
import type { mongo } from 'mongoose';
|
||||
import { migrateMatchStatsRawIndex } from './20261111-match-stats-raw-index';
|
||||
import { MATCH_STATS_RIOT_MATCH_INDEX } from '../match-stats-raw-index';
|
||||
import { parseMatchStatsIndexOptions } from './run-match-stats-raw-index';
|
||||
|
||||
it('defaults to a read-only plan and validates the target environment', async () => {
|
||||
expect(parseMatchStatsIndexOptions(['--env', 'prod']).dryRun).toBe(true);
|
||||
expect(() => parseMatchStatsIndexOptions(['--env', 'unknown'])).toThrow();
|
||||
const createIndex = jest.fn();
|
||||
await migrateMatchStatsRawIndex(database([], createIndex));
|
||||
expect(createIndex).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('adds only the lookup index and accepts an identical existing index', async () => {
|
||||
const { key, options } = MATCH_STATS_RIOT_MATCH_INDEX;
|
||||
const createIndex = jest.fn();
|
||||
const result = await migrateMatchStatsRawIndex(
|
||||
database([{ key, ...options }], createIndex),
|
||||
{ dryRun: false },
|
||||
);
|
||||
expect(result.alreadyPresent).toBe(true);
|
||||
expect(createIndex).toHaveBeenCalledWith(key, options);
|
||||
});
|
||||
|
||||
it('rejects an incompatible existing index without dropping or recreating it', async () => {
|
||||
const { key, options } = MATCH_STATS_RIOT_MATCH_INDEX;
|
||||
const createIndex = jest.fn();
|
||||
await expect(
|
||||
migrateMatchStatsRawIndex(
|
||||
database([{ key, ...options, unique: true }], createIndex),
|
||||
{ dryRun: false },
|
||||
),
|
||||
).rejects.toThrow('different definition');
|
||||
expect(createIndex).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
function database(indexes: unknown[], createIndex: jest.Mock): mongo.Db {
|
||||
return {
|
||||
collection: (name: string) => {
|
||||
expect(name).toBe('match_stats');
|
||||
return {
|
||||
listIndexes: () => ({ toArray: async () => indexes }),
|
||||
createIndex,
|
||||
};
|
||||
},
|
||||
} as unknown as mongo.Db;
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
import type { mongo } from 'mongoose';
|
||||
import { MATCH_STATS_RIOT_MATCH_INDEX } from '../match-stats-raw-index';
|
||||
|
||||
/** Adds the lookup index without dropping indexes or modifying game records. */
|
||||
export async function migrateMatchStatsRawIndex(
|
||||
db: mongo.Db,
|
||||
{ dryRun = true }: { dryRun?: boolean } = {},
|
||||
) {
|
||||
const { key, options } = MATCH_STATS_RIOT_MATCH_INDEX;
|
||||
const collection = db.collection('match_stats');
|
||||
const indexes = await collection
|
||||
.listIndexes()
|
||||
.toArray()
|
||||
.catch((error: unknown) => {
|
||||
if (error instanceof Error && 'code' in error && error.code === 26)
|
||||
return [];
|
||||
throw error;
|
||||
});
|
||||
const existing = indexes.find((index) => index.name === options.name);
|
||||
if (
|
||||
existing &&
|
||||
(JSON.stringify(existing.key) !== JSON.stringify(key) ||
|
||||
existing.unique === true ||
|
||||
existing.sparse === true ||
|
||||
existing.hidden === true ||
|
||||
existing.partialFilterExpression !== undefined)
|
||||
) {
|
||||
throw new Error(
|
||||
`Index ${options.name} already exists with a different definition.`,
|
||||
);
|
||||
}
|
||||
if (!dryRun) await collection.createIndex(key, options);
|
||||
return {
|
||||
dryRun,
|
||||
alreadyPresent: Boolean(existing),
|
||||
index: { key, ...options },
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,293 @@
|
||||
import mongoose from 'mongoose';
|
||||
import { projectCompetition } from '../../../competition/domain/competition-projector';
|
||||
import { generateSeriesGraph } from '../../../competition/domain/series-graph';
|
||||
import {
|
||||
parseGrandFinalRepairOptions,
|
||||
planGrandFinalBo3Repair,
|
||||
repairGrandFinalBo3,
|
||||
} from './repair-grand-final-bo3';
|
||||
|
||||
describe('grand final BO3 repair', () => {
|
||||
it.each([false, true])(
|
||||
'keeps game 28 and finishes only after two wins (split: %s)',
|
||||
(split) => {
|
||||
const input = finishedTournament();
|
||||
const plan = planGrandFinalBo3Repair(input);
|
||||
|
||||
expect(plan.before.phase).toBe('completed');
|
||||
expect(plan.preservedGame).toBe(28);
|
||||
expect(plan.newGameNumbers).toEqual([29, 30]);
|
||||
expect(plan.projection.games).toEqual(plan.before.games);
|
||||
expect(plan.projection).toMatchObject({
|
||||
phase: 'running',
|
||||
placements: [],
|
||||
});
|
||||
expect(plan.projection).not.toHaveProperty('outcome');
|
||||
expect(
|
||||
plan.projection.series.find(
|
||||
({ seriesId }) => seriesId === plan.seriesId,
|
||||
),
|
||||
).toMatchObject({
|
||||
status: 'in-progress',
|
||||
entries: [
|
||||
{ slot: 'A', gameWins: 1 },
|
||||
{ slot: 'B', gameWins: 0 },
|
||||
],
|
||||
});
|
||||
|
||||
const facts = [
|
||||
...input.facts,
|
||||
{
|
||||
id: 'rule-audit',
|
||||
type: 'grand-final-rule-corrected',
|
||||
seriesId: plan.seriesId,
|
||||
revision: plan.projection.sourceRevision,
|
||||
ordinalWithinRevision: 1,
|
||||
},
|
||||
];
|
||||
const replay = () =>
|
||||
projectCompetition({
|
||||
...input,
|
||||
facts,
|
||||
revision: facts.length,
|
||||
format: plan.format,
|
||||
seriesGraph: plan.seriesGraph,
|
||||
});
|
||||
expect(replay()).toEqual(plan.projection);
|
||||
|
||||
const second = replay().gameSlots.find(
|
||||
({ displayNumber }) => displayNumber === 29,
|
||||
)!;
|
||||
facts.push(acceptedGame(second, facts.length + 1, split ? 'B' : 'A'));
|
||||
if (split) {
|
||||
expect(replay().phase).toBe('running');
|
||||
const third = replay().gameSlots.find(
|
||||
({ displayNumber }) => displayNumber === 30,
|
||||
)!;
|
||||
expect(third.status).toBe('ready');
|
||||
facts.push(acceptedGame(third, facts.length + 1, 'A'));
|
||||
}
|
||||
const completed = replay();
|
||||
expect(completed.phase).toBe('completed');
|
||||
expect(
|
||||
completed.gameSlots.find(({ displayNumber }) => displayNumber === 30)
|
||||
?.status,
|
||||
).toBe(split ? 'completed' : 'inactive');
|
||||
expect(completed.games.at(-1)?.displayNumber).toBe(split ? 30 : 29);
|
||||
},
|
||||
);
|
||||
|
||||
it('refuses to reopen a bracket that enables a reset final', () => {
|
||||
const input = finishedTournament();
|
||||
expect(() =>
|
||||
planGrandFinalBo3Repair({
|
||||
...input,
|
||||
format: { ...input.format, resetFinalEnabled: true },
|
||||
}),
|
||||
).toThrow('no reset or later series');
|
||||
});
|
||||
|
||||
it('requires a target and a reviewed revision before applying', () => {
|
||||
const target = ['--match-id', '000000000000000000000001', '--env', 'prod'];
|
||||
expect(parseGrandFinalRepairOptions(target)).toMatchObject({
|
||||
apply: false,
|
||||
});
|
||||
expect(() => parseGrandFinalRepairOptions(['--apply', ...target])).toThrow(
|
||||
'--expected-revision',
|
||||
);
|
||||
expect(
|
||||
parseGrandFinalRepairOptions([
|
||||
'--apply',
|
||||
...target,
|
||||
'--expected-revision',
|
||||
'23',
|
||||
]),
|
||||
).toMatchObject({ apply: true, expectedRevision: 23 });
|
||||
});
|
||||
|
||||
it('previews without writes and applies the graph, match status and audit in one transaction', async () => {
|
||||
const input = finishedTournament();
|
||||
const competitionId = new mongoose.Types.ObjectId(input.competitionId);
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const match = {
|
||||
_id: matchId,
|
||||
competitionId,
|
||||
communityId,
|
||||
gameMode: 'double-elimination',
|
||||
status: 'finished',
|
||||
teamBuiltAt: new Date(),
|
||||
doubleElimination: { resetFinalEnabled: false },
|
||||
resultPollState: { state: 'complete' },
|
||||
};
|
||||
const competition = {
|
||||
...input,
|
||||
_id: competitionId,
|
||||
schemaVersion: 1,
|
||||
phase: 'completed',
|
||||
teams: input.teams.map((team) => ({
|
||||
...team,
|
||||
teamId: new mongoose.Types.ObjectId(team.teamId),
|
||||
})),
|
||||
projection: projectCompetition(input),
|
||||
};
|
||||
const query = (value: unknown) => ({
|
||||
session: jest.fn().mockReturnThis(),
|
||||
lean: jest.fn().mockReturnThis(),
|
||||
sort: jest.fn().mockReturnThis(),
|
||||
exec: jest.fn().mockResolvedValue(value),
|
||||
});
|
||||
const update = () => jest.fn(() => query({ matchedCount: 1 }));
|
||||
const models = {
|
||||
match: { findById: jest.fn(() => query(match)), updateOne: update() },
|
||||
competition: {
|
||||
findOne: jest.fn(() => query(competition)),
|
||||
updateOne: update(),
|
||||
},
|
||||
competitionFact: {
|
||||
find: jest.fn(() => query(input.facts)),
|
||||
insertMany: jest.fn(),
|
||||
},
|
||||
competitionOutbox: { insertMany: jest.fn() },
|
||||
};
|
||||
const session = {
|
||||
withTransaction: jest.fn((run: () => unknown) => run()),
|
||||
endSession: jest.fn(),
|
||||
};
|
||||
const connections = {
|
||||
getModel: jest.fn((name: keyof typeof models) => models[name]),
|
||||
createSession: jest.fn().mockResolvedValue(session),
|
||||
} as never;
|
||||
const options = { matchId, nodeEnv: 'prod', apply: false };
|
||||
|
||||
const preview = await repairGrandFinalBo3(connections, options);
|
||||
expect(preview).toMatchObject({
|
||||
mode: 'dry-run',
|
||||
preservedGame: 28,
|
||||
newGameNumbers: [29, 30],
|
||||
});
|
||||
expect(models.match.updateOne).not.toHaveBeenCalled();
|
||||
expect(models.competition.updateOne).not.toHaveBeenCalled();
|
||||
expect(models.competitionFact.insertMany).not.toHaveBeenCalled();
|
||||
expect(models.competitionOutbox.insertMany).not.toHaveBeenCalled();
|
||||
|
||||
await expect(
|
||||
repairGrandFinalBo3(connections, {
|
||||
...options,
|
||||
apply: true,
|
||||
expectedRevision: preview.revisionBefore,
|
||||
}),
|
||||
).resolves.toMatchObject({
|
||||
mode: 'applied',
|
||||
phase: 'completed -> running',
|
||||
});
|
||||
expect(session.withTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(models.match.updateOne).toHaveBeenCalledWith(
|
||||
{ _id: matchId, status: 'finished', competitionId },
|
||||
{
|
||||
$set: expect.objectContaining({
|
||||
status: 'in-progress',
|
||||
'resultPollState.state': 'polling',
|
||||
}),
|
||||
},
|
||||
{ session, runValidators: true },
|
||||
);
|
||||
expect(models.competition.updateOne).toHaveBeenCalledWith(
|
||||
{ _id: competitionId, revision: preview.revisionBefore },
|
||||
{
|
||||
$set: expect.objectContaining({
|
||||
phase: 'running',
|
||||
revision: preview.revisionAfter,
|
||||
}),
|
||||
},
|
||||
{ session, runValidators: true },
|
||||
);
|
||||
expect(models.competitionFact.insertMany).toHaveBeenCalledWith(
|
||||
[
|
||||
expect.objectContaining({
|
||||
type: 'grand-final-rule-corrected',
|
||||
revision: preview.revisionAfter,
|
||||
}),
|
||||
],
|
||||
{ session },
|
||||
);
|
||||
expect(models.competitionOutbox.insertMany).toHaveBeenCalledWith(
|
||||
[
|
||||
expect.objectContaining({
|
||||
type: 'competition.projection-updated',
|
||||
revision: preview.revisionAfter,
|
||||
}),
|
||||
],
|
||||
{ session },
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
function finishedTournament() {
|
||||
const competitionId = '000000000000000000000001';
|
||||
const teams = Array.from({ length: 8 }, (_, index) => ({
|
||||
teamId: (index + 1).toString(16).padStart(24, '0'),
|
||||
displayOrder: index + 1,
|
||||
seedNumber: index + 1,
|
||||
}));
|
||||
const bo1 = { type: 'first-to', maxGames: 1, winsRequired: 1 } as const;
|
||||
const format = {
|
||||
type: 'double-elimination' as const,
|
||||
teamCount: 8 as const,
|
||||
resetFinalEnabled: false,
|
||||
rules: {
|
||||
upper: { ...bo1, maxGames: 3, winsRequired: 2 },
|
||||
lower: bo1,
|
||||
grandFinal: bo1,
|
||||
resetFinal: bo1,
|
||||
},
|
||||
};
|
||||
const seriesGraph = generateSeriesGraph({ competitionId, teams, format });
|
||||
const facts: Record<string, unknown>[] = [];
|
||||
const input = {
|
||||
competitionId,
|
||||
teams,
|
||||
format,
|
||||
seriesGraph,
|
||||
facts,
|
||||
projectorVersion: 1,
|
||||
revision: 0,
|
||||
};
|
||||
for (let index = 0; index < 28; index += 1) {
|
||||
const slot = projectCompetition(input).gameSlots.find(
|
||||
({ status }) => status === 'ready',
|
||||
);
|
||||
if (!slot) break;
|
||||
facts.push(acceptedGame(slot, index + 1, 'A'));
|
||||
input.revision += 1;
|
||||
}
|
||||
return input;
|
||||
}
|
||||
|
||||
function acceptedGame(
|
||||
slot: ReturnType<typeof projectCompetition>['gameSlots'][number],
|
||||
revision: number,
|
||||
winner: 'A' | 'B',
|
||||
): Record<string, unknown> {
|
||||
const [a, b] = slot.entries;
|
||||
const recordedAt = new Date(Date.UTC(2026, 6, 26, 0, revision)).toISOString();
|
||||
return {
|
||||
id: `fact-${revision}`,
|
||||
type: 'game-accepted',
|
||||
revision,
|
||||
ordinalWithinRevision: 1,
|
||||
gameId: `game-${revision}`,
|
||||
seriesId: slot.seriesId,
|
||||
gameSlotId: slot.id,
|
||||
ordinal: slot.ordinal,
|
||||
recordedAt,
|
||||
occurredAt: recordedAt,
|
||||
evidence: { type: 'riot', riotMatchId: `KR_${revision}` },
|
||||
mapping: {
|
||||
blueTeamId: a.teamId,
|
||||
redTeamId: b.teamId,
|
||||
winnerTeamId: winner === 'A' ? a.teamId : b.teamId,
|
||||
participantAssignments: [],
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,410 @@
|
||||
import 'reflect-metadata';
|
||||
import { ConfigService } from '@nestjs/config';
|
||||
import mongoose from 'mongoose';
|
||||
import { createHash } from 'node:crypto';
|
||||
import { isDeepStrictEqual } from 'node:util';
|
||||
import { factForProjection } from '../../../competition/competition-command.service';
|
||||
import { projectCompetition } from '../../../competition/domain/competition-projector';
|
||||
import {
|
||||
generateSeriesGraph,
|
||||
type CompetitionGraphFormat,
|
||||
type CompetitionGraphTeam,
|
||||
type SeriesDefinition,
|
||||
} from '../../../competition/domain/series-graph';
|
||||
import { SecretService } from '../../secret/secret.service';
|
||||
import { ConnectionService, resolveMongoDbName } from '../connection.service';
|
||||
|
||||
const CORRECTION_TYPE = 'grand-final-rule-corrected' as const;
|
||||
const BO3 = { type: 'first-to', winsRequired: 2, maxGames: 3 } as const;
|
||||
|
||||
interface RepairInput {
|
||||
competitionId: string;
|
||||
revision: number;
|
||||
projectorVersion: number;
|
||||
teams: readonly CompetitionGraphTeam[];
|
||||
format: CompetitionGraphFormat;
|
||||
seriesGraph: readonly SeriesDefinition[];
|
||||
facts: readonly Record<string, unknown>[];
|
||||
}
|
||||
|
||||
export function planGrandFinalBo3Repair(input: RepairInput) {
|
||||
const { format, seriesGraph, facts } = input;
|
||||
const final = seriesGraph.find(({ stage }) => stage.type === 'grand-final');
|
||||
if (
|
||||
format.type !== 'double-elimination' ||
|
||||
format.resetFinalEnabled ||
|
||||
format.rules.grandFinal.type !== 'first-to' ||
|
||||
format.rules.grandFinal.maxGames !== 1 ||
|
||||
format.rules.grandFinal.winsRequired !== 1 ||
|
||||
!final ||
|
||||
!isDeepStrictEqual(final.rule, format.rules.grandFinal) ||
|
||||
final.gameSlots.length !== 1 ||
|
||||
seriesGraph.some(
|
||||
({ stage }) => stage.displayOrder > final.stage.displayOrder,
|
||||
)
|
||||
) {
|
||||
throw new Error(
|
||||
'Expected a BO1 grand final with no reset or later series.',
|
||||
);
|
||||
}
|
||||
|
||||
const before = projectCompetition(input);
|
||||
const previousFinal = before.series.find(
|
||||
({ seriesId }) => seriesId === final.id,
|
||||
);
|
||||
const finalGames = before.games.filter(
|
||||
({ seriesId }) => seriesId === final.id,
|
||||
);
|
||||
const firstGame = finalGames[0];
|
||||
if (
|
||||
before.phase !== 'completed' ||
|
||||
previousFinal?.status !== 'completed' ||
|
||||
previousFinal.outcome.type !== 'played' ||
|
||||
finalGames.length !== 1 ||
|
||||
firstGame.ordinal !== 1 ||
|
||||
firstGame.evidence.type !== 'riot' ||
|
||||
facts.filter((fact) => fact.seriesId === final.id).length !== 1
|
||||
) {
|
||||
throw new Error(
|
||||
'Expected exactly one Riot result and no other final facts.',
|
||||
);
|
||||
}
|
||||
|
||||
const correctedFormat = {
|
||||
...format,
|
||||
rules: { ...format.rules, grandFinal: BO3 },
|
||||
};
|
||||
const generatedFinal = generateSeriesGraph({
|
||||
competitionId: input.competitionId,
|
||||
teams: input.teams,
|
||||
format: correctedFormat,
|
||||
}).find(({ stage }) => stage.type === 'grand-final');
|
||||
if (
|
||||
generatedFinal?.id !== final.id ||
|
||||
!isDeepStrictEqual(generatedFinal.gameSlots[0], final.gameSlots[0])
|
||||
) {
|
||||
throw new Error(
|
||||
'The existing grand final does not match its stable slot identity.',
|
||||
);
|
||||
}
|
||||
const correctedGraph = seriesGraph.map((series) =>
|
||||
series.id === final.id
|
||||
? { ...series, rule: BO3, gameSlots: generatedFinal.gameSlots }
|
||||
: series,
|
||||
);
|
||||
const projection = projectCompetition({
|
||||
...input,
|
||||
revision: input.revision + 1,
|
||||
format: correctedFormat,
|
||||
seriesGraph: correctedGraph,
|
||||
});
|
||||
const readySlots = projection.gameSlots.filter(
|
||||
({ status }) => status === 'ready',
|
||||
);
|
||||
if (
|
||||
projection.phase !== 'running' ||
|
||||
!isDeepStrictEqual(projection.games, before.games) ||
|
||||
readySlots.length !== 2 ||
|
||||
readySlots.some(
|
||||
(slot, index) =>
|
||||
slot.seriesId !== final.id ||
|
||||
slot.ordinal !== index + 2 ||
|
||||
slot.displayNumber !== firstGame.displayNumber + index + 1,
|
||||
) ||
|
||||
!isDeepStrictEqual(
|
||||
projection.series.filter(({ seriesId }) => seriesId !== final.id),
|
||||
before.series.filter(({ seriesId }) => seriesId !== final.id),
|
||||
)
|
||||
) {
|
||||
throw new Error(
|
||||
'Repair would change existing results or fail to reopen the final.',
|
||||
);
|
||||
}
|
||||
|
||||
return {
|
||||
before,
|
||||
format: correctedFormat,
|
||||
seriesGraph: correctedGraph,
|
||||
projection,
|
||||
seriesId: final.id,
|
||||
preservedGame: firstGame.displayNumber,
|
||||
newGameNumbers: readySlots.map(({ displayNumber }) => displayNumber),
|
||||
};
|
||||
}
|
||||
|
||||
interface CliOptions {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
nodeEnv: string;
|
||||
expectedRevision?: number;
|
||||
apply: boolean;
|
||||
}
|
||||
|
||||
export function parseGrandFinalRepairOptions(argv: string[]): CliOptions {
|
||||
let matchId: mongoose.Types.ObjectId | undefined;
|
||||
let nodeEnv = 'dev';
|
||||
let expectedRevision: number | undefined;
|
||||
let apply = false;
|
||||
for (let index = 0; index < argv.length; index += 1) {
|
||||
switch (argv[index]) {
|
||||
case '--':
|
||||
break;
|
||||
case '--apply':
|
||||
apply = true;
|
||||
break;
|
||||
case '--match-id': {
|
||||
const value = argv[++index];
|
||||
if (!/^[a-f\d]{24}$/i.test(value ?? '')) {
|
||||
throw new Error('--match-id must be a 24-character ObjectId.');
|
||||
}
|
||||
matchId = new mongoose.Types.ObjectId(value);
|
||||
break;
|
||||
}
|
||||
case '--env':
|
||||
nodeEnv = argv[++index];
|
||||
if (!['dev', 'staging', 'prod'].includes(nodeEnv)) {
|
||||
throw new Error('--env must be dev, staging, or prod.');
|
||||
}
|
||||
break;
|
||||
case '--expected-revision': {
|
||||
const value = argv[++index];
|
||||
expectedRevision = Number(value);
|
||||
if (
|
||||
!/^\d+$/.test(value ?? '') ||
|
||||
!Number.isSafeInteger(expectedRevision)
|
||||
) {
|
||||
throw new Error('--expected-revision must be a nonnegative integer.');
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
throw new Error(`Unknown argument: ${argv[index]}`);
|
||||
}
|
||||
}
|
||||
if (!matchId || (apply && expectedRevision === undefined)) {
|
||||
throw new Error(
|
||||
'--match-id is required; --apply also requires --expected-revision from the dry run.',
|
||||
);
|
||||
}
|
||||
return { matchId, nodeEnv, expectedRevision, apply };
|
||||
}
|
||||
|
||||
export async function repairGrandFinalBo3(
|
||||
connectionService: ConnectionService,
|
||||
options: CliOptions,
|
||||
) {
|
||||
if (options.apply && options.expectedRevision === undefined) {
|
||||
throw new Error('An expected revision is required to apply the repair.');
|
||||
}
|
||||
const [Match, Competition, Fact, Outbox] = await Promise.all([
|
||||
connectionService.getModel('match'),
|
||||
connectionService.getModel('competition'),
|
||||
connectionService.getModel('competitionFact'),
|
||||
connectionService.getModel('competitionOutbox'),
|
||||
]);
|
||||
async function run(session: mongoose.ClientSession | null) {
|
||||
const match = await Match.findById(options.matchId)
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec();
|
||||
if (
|
||||
!match?.competitionId ||
|
||||
match.gameMode !== 'double-elimination' ||
|
||||
match.status !== 'finished' ||
|
||||
!match.teamBuiltAt ||
|
||||
!match.doubleElimination
|
||||
) {
|
||||
throw new Error(
|
||||
'Expected a finished double-elimination Match with a linked Competition.',
|
||||
);
|
||||
}
|
||||
const competition = await Competition.findOne({
|
||||
_id: match.competitionId,
|
||||
matchId: match._id,
|
||||
communityId: match.communityId,
|
||||
})
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec();
|
||||
if (!competition || competition.phase !== 'completed') {
|
||||
throw new Error('Expected a completed Competition linked to this Match.');
|
||||
}
|
||||
if (
|
||||
options.expectedRevision !== undefined &&
|
||||
competition.revision !== options.expectedRevision
|
||||
) {
|
||||
throw new Error(
|
||||
`Competition revision is ${competition.revision}; run the preview again.`,
|
||||
);
|
||||
}
|
||||
const facts = await Fact.find({ competitionId: competition._id })
|
||||
.sort({ revision: 1, ordinalWithinRevision: 1 })
|
||||
.session(session)
|
||||
.lean()
|
||||
.exec();
|
||||
const plan = planGrandFinalBo3Repair({
|
||||
competitionId: competition._id.toHexString(),
|
||||
revision: competition.revision,
|
||||
projectorVersion: competition.projectorVersion,
|
||||
teams: competition.teams.map(({ teamId, displayOrder, seedNumber }) => ({
|
||||
teamId: teamId.toHexString(),
|
||||
displayOrder,
|
||||
seedNumber,
|
||||
})),
|
||||
format: competition.format as unknown as CompetitionGraphFormat,
|
||||
seriesGraph: competition.seriesGraph as unknown as SeriesDefinition[],
|
||||
facts: facts.map((fact) => factForProjection({ ...fact })),
|
||||
});
|
||||
if (!isDeepStrictEqual(plan.before, competition.projection)) {
|
||||
throw new Error(
|
||||
'The fact ledger does not reproduce the stored projection.',
|
||||
);
|
||||
}
|
||||
const revision = plan.projection.sourceRevision;
|
||||
if (session) {
|
||||
const now = new Date();
|
||||
const idempotencyKey = `repair:grand-final-bo3:${competition._id.toHexString()}`;
|
||||
const requestHash = createHash('sha256')
|
||||
.update(idempotencyKey)
|
||||
.digest('hex');
|
||||
const commandId = `cmpcmd_${requestHash.slice(0, 32)}`;
|
||||
const receipt = {
|
||||
competitionId: competition._id,
|
||||
revision,
|
||||
commandId,
|
||||
idempotencyKey,
|
||||
requestHash,
|
||||
};
|
||||
const factId = new mongoose.Types.ObjectId();
|
||||
const competitionWrite = await Competition.updateOne(
|
||||
{ _id: competition._id, revision: competition.revision },
|
||||
{
|
||||
$set: {
|
||||
revision,
|
||||
format: plan.format,
|
||||
seriesGraph: plan.seriesGraph,
|
||||
projection: plan.projection,
|
||||
phase: plan.projection.phase,
|
||||
},
|
||||
},
|
||||
{ session, runValidators: true },
|
||||
).exec();
|
||||
const matchWrite = await Match.updateOne(
|
||||
{ _id: match._id, status: 'finished', competitionId: competition._id },
|
||||
{
|
||||
$set: {
|
||||
status: 'in-progress',
|
||||
'doubleElimination.grandFinalGameCount': 3,
|
||||
...(match.resultPollState
|
||||
? {
|
||||
'resultPollState.state': 'polling',
|
||||
'resultPollState.matchedCount': plan.projection.games.length,
|
||||
}
|
||||
: {}),
|
||||
},
|
||||
},
|
||||
{ session, runValidators: true },
|
||||
).exec();
|
||||
if (
|
||||
competitionWrite.matchedCount !== 1 ||
|
||||
matchWrite.matchedCount !== 1
|
||||
) {
|
||||
throw new Error(
|
||||
'Match or Competition changed during repair; run the preview again.',
|
||||
);
|
||||
}
|
||||
await Fact.insertMany(
|
||||
[
|
||||
{
|
||||
...receipt,
|
||||
_id: factId,
|
||||
type: CORRECTION_TYPE,
|
||||
ordinalWithinRevision: 1,
|
||||
schemaVersion: competition.schemaVersion,
|
||||
actor: { type: 'system' },
|
||||
seriesId: new mongoose.Types.ObjectId(plan.seriesId),
|
||||
occurredAt: now,
|
||||
recordedAt: now,
|
||||
reason:
|
||||
'Restore the intended BO3 grand final without voiding the first game.',
|
||||
ruleCorrection: { previousMaxGames: 1, nextMaxGames: 3 },
|
||||
},
|
||||
],
|
||||
{ session },
|
||||
);
|
||||
await Outbox.insertMany(
|
||||
[
|
||||
{
|
||||
...receipt,
|
||||
eventId: `${commandId}:competition-projected`,
|
||||
type: 'competition.projection-updated',
|
||||
payload: {
|
||||
competitionId: competition._id.toHexString(),
|
||||
sourceRevision: revision,
|
||||
factIds: [factId.toHexString()],
|
||||
projection: plan.projection,
|
||||
phase: plan.projection.phase,
|
||||
updatedAt: now,
|
||||
},
|
||||
state: 'pending',
|
||||
availableAt: now,
|
||||
},
|
||||
],
|
||||
{ session },
|
||||
);
|
||||
}
|
||||
return {
|
||||
mode: session ? 'applied' : 'dry-run',
|
||||
database: resolveMongoDbName(options.nodeEnv),
|
||||
matchId: match._id.toHexString(),
|
||||
competitionId: competition._id.toHexString(),
|
||||
revisionBefore: competition.revision,
|
||||
revisionAfter: revision,
|
||||
phase: `${competition.phase} -> ${plan.projection.phase}`,
|
||||
preservedGame: plan.preservedGame,
|
||||
totalPreservedGames: plan.projection.games.length,
|
||||
newGameNumbers: plan.newGameNumbers,
|
||||
};
|
||||
}
|
||||
|
||||
if (!options.apply) return run(null);
|
||||
const session = await connectionService.createSession();
|
||||
if (!session) throw new Error('Repair requires a MongoDB transaction.');
|
||||
try {
|
||||
return await session.withTransaction(() => run(session));
|
||||
} finally {
|
||||
await session.endSession();
|
||||
}
|
||||
}
|
||||
|
||||
async function main() {
|
||||
const args = process.argv.slice(2);
|
||||
if (args.includes('--help')) {
|
||||
process.stdout.write(
|
||||
'Usage: pnpm --filter api competition:repair-grand-final --env <dev|staging|prod> --match-id <id> [--expected-revision <n> --apply]\n',
|
||||
);
|
||||
return;
|
||||
}
|
||||
const options = parseGrandFinalRepairOptions(args);
|
||||
process.env.NODE_ENV = options.nodeEnv;
|
||||
process.env.MONGODB_AUTO_INDEX = 'false';
|
||||
const connections = new ConnectionService(
|
||||
new SecretService(new ConfigService()),
|
||||
);
|
||||
const connection = await connections.getConnection();
|
||||
try {
|
||||
process.stdout.write(
|
||||
`${JSON.stringify(await repairGrandFinalBo3(connections, options), null, 2)}\n`,
|
||||
);
|
||||
} finally {
|
||||
await connection.close();
|
||||
}
|
||||
}
|
||||
|
||||
if (require.main === module) {
|
||||
void main().catch((error: unknown) => {
|
||||
process.stderr.write(
|
||||
`${error instanceof Error ? error.message : String(error)}\n`,
|
||||
);
|
||||
process.exitCode = 1;
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,105 @@
|
||||
import 'reflect-metadata';
|
||||
import { Module } from '@nestjs/common';
|
||||
import { ConfigModule } from '@nestjs/config';
|
||||
import { NestFactory } from '@nestjs/core';
|
||||
import { readFile } from 'node:fs/promises';
|
||||
import { resolve } from 'node:path';
|
||||
import { ConnectionService, resolveMongoDbName } from '../connection.service';
|
||||
import { SecretModule } from '../../secret/secret.module';
|
||||
import { migrateAuctionCancellationIndex } from './20261109-auction-cancellation-index';
|
||||
|
||||
@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 {}
|
||||
|
||||
export function parseAuctionIndexOptions(argv: string[]) {
|
||||
let dryRun = true;
|
||||
let help = false;
|
||||
let nodeEnv = process.env.NODE_ENV ?? 'dev';
|
||||
for (let index = 0; index < argv.length; index++) {
|
||||
const argument = argv[index];
|
||||
if (argument === '--') continue;
|
||||
if (argument === '--apply') dryRun = false;
|
||||
else if (argument === '--dry-run') dryRun = true;
|
||||
else if (argument === '--help' || argument === '-h') help = true;
|
||||
else if (argument === '--env') nodeEnv = argv[++index] ?? '';
|
||||
else if (argument.startsWith('--env=')) nodeEnv = argument.slice(6);
|
||||
else throw new Error(`Unknown argument: ${argument}`);
|
||||
}
|
||||
if (!help && !['dev', 'staging', 'prod'].includes(nodeEnv)) {
|
||||
throw new Error('--env must be dev, staging, or prod.');
|
||||
}
|
||||
return { dryRun, help, nodeEnv };
|
||||
}
|
||||
|
||||
async function main(): Promise<void> {
|
||||
const options = parseAuctionIndexOptions(process.argv.slice(2));
|
||||
if (options.help) {
|
||||
console.log(`Usage:
|
||||
pnpm --filter api auction:indexes -- --env staging --dry-run
|
||||
pnpm --filter api auction:indexes -- --env prod --apply
|
||||
|
||||
Defaults to dry-run. --env accepts dev, staging, or prod (NODE_ENV or dev by default).
|
||||
Creates the Match cancellation cleanup partial index; does not modify documents.`);
|
||||
return;
|
||||
}
|
||||
// Use the same optional machine environment as the existing migration runners.
|
||||
const machineHome = process.env.HOME ?? process.env.USERPROFILE;
|
||||
if (machineHome) {
|
||||
const contents = await readFile(
|
||||
resolve(machineHome, 'source/global-env-vars.txt'),
|
||||
'utf8',
|
||||
).catch(() => '');
|
||||
for (const line of contents.split(/\r?\n/)) {
|
||||
const match = line.trim().match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
|
||||
if (match) process.env[match[1]] = match[2].replace(/^["']|["']$/g, '');
|
||||
}
|
||||
}
|
||||
process.env.NODE_ENV = options.nodeEnv;
|
||||
// Even a dry-run with auto-index enabled in the environment must not write.
|
||||
process.env.MONGODB_AUTO_INDEX = 'false';
|
||||
const app = await NestFactory.createApplicationContext(MigrationModule, {
|
||||
logger: ['warn', 'error'],
|
||||
});
|
||||
try {
|
||||
const connection = await app.get(ConnectionService).getConnection();
|
||||
if (!connection.db) throw new Error('MongoDB connection has no db handle.');
|
||||
const result = await migrateAuctionCancellationIndex(
|
||||
connection.db,
|
||||
options,
|
||||
);
|
||||
console.log(
|
||||
JSON.stringify(
|
||||
{
|
||||
env: options.nodeEnv,
|
||||
db: resolveMongoDbName(options.nodeEnv),
|
||||
...result,
|
||||
},
|
||||
null,
|
||||
2,
|
||||
),
|
||||
);
|
||||
} finally {
|
||||
await app.close();
|
||||
}
|
||||
}
|
||||
|
||||
if (require.main === module) {
|
||||
void main().catch((error: unknown) => {
|
||||
console.error(error instanceof Error ? error.message : error);
|
||||
process.exitCode = 1;
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,102 @@
|
||||
import 'reflect-metadata';
|
||||
import { Module } from '@nestjs/common';
|
||||
import { ConfigModule } from '@nestjs/config';
|
||||
import { NestFactory } from '@nestjs/core';
|
||||
import { readFile } from 'node:fs/promises';
|
||||
import { resolve } from 'node:path';
|
||||
import { ConnectionService, resolveMongoDbName } from '../connection.service';
|
||||
import { SecretModule } from '../../secret/secret.module';
|
||||
import { migrateMatchStatsRawIndex } from './20261111-match-stats-raw-index';
|
||||
|
||||
@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 {}
|
||||
|
||||
export function parseMatchStatsIndexOptions(argv: string[]) {
|
||||
let dryRun = true;
|
||||
let help = false;
|
||||
let nodeEnv = process.env.NODE_ENV ?? 'dev';
|
||||
for (let index = 0; index < argv.length; index++) {
|
||||
const argument = argv[index];
|
||||
if (argument === '--') continue;
|
||||
if (argument === '--apply') dryRun = false;
|
||||
else if (argument === '--dry-run') dryRun = true;
|
||||
else if (argument === '--help' || argument === '-h') help = true;
|
||||
else if (argument === '--env') nodeEnv = argv[++index] ?? '';
|
||||
else if (argument.startsWith('--env=')) nodeEnv = argument.slice(6);
|
||||
else throw new Error(`Unknown argument: ${argument}`);
|
||||
}
|
||||
if (!help && !['dev', 'staging', 'prod'].includes(nodeEnv)) {
|
||||
throw new Error('--env must be dev, staging, or prod.');
|
||||
}
|
||||
return { dryRun, help, nodeEnv };
|
||||
}
|
||||
|
||||
async function main(): Promise<void> {
|
||||
const options = parseMatchStatsIndexOptions(process.argv.slice(2));
|
||||
if (options.help) {
|
||||
console.log(`Usage:
|
||||
pnpm --filter api stats:indexes -- --env staging --dry-run
|
||||
pnpm --filter api stats:indexes -- --env prod --apply
|
||||
|
||||
Defaults to dry-run. --env accepts dev, staging, or prod (NODE_ENV or dev by default).
|
||||
Creates the internal stats Riot match ID index; does not modify documents.`);
|
||||
return;
|
||||
}
|
||||
// Use the same optional machine environment as the existing migration runners.
|
||||
const machineHome = process.env.HOME ?? process.env.USERPROFILE;
|
||||
if (machineHome) {
|
||||
const contents = await readFile(
|
||||
resolve(machineHome, 'source/global-env-vars.txt'),
|
||||
'utf8',
|
||||
).catch(() => '');
|
||||
for (const line of contents.split(/\r?\n/)) {
|
||||
const match = line.trim().match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
|
||||
if (match) process.env[match[1]] = match[2].replace(/^["']|["']$/g, '');
|
||||
}
|
||||
}
|
||||
process.env.NODE_ENV = options.nodeEnv;
|
||||
// Even a dry-run with auto-index enabled in the environment must not write.
|
||||
process.env.MONGODB_AUTO_INDEX = 'false';
|
||||
const app = await NestFactory.createApplicationContext(MigrationModule, {
|
||||
logger: ['warn', 'error'],
|
||||
});
|
||||
try {
|
||||
const connection = await app.get(ConnectionService).getConnection();
|
||||
if (!connection.db) throw new Error('MongoDB connection has no db handle.');
|
||||
const result = await migrateMatchStatsRawIndex(connection.db, options);
|
||||
console.log(
|
||||
JSON.stringify(
|
||||
{
|
||||
env: options.nodeEnv,
|
||||
db: resolveMongoDbName(options.nodeEnv),
|
||||
...result,
|
||||
},
|
||||
null,
|
||||
2,
|
||||
),
|
||||
);
|
||||
} finally {
|
||||
await app.close();
|
||||
}
|
||||
}
|
||||
|
||||
if (require.main === module) {
|
||||
void main().catch((error: unknown) => {
|
||||
console.error(error instanceof Error ? error.message : error);
|
||||
process.exitCode = 1;
|
||||
});
|
||||
}
|
||||
@@ -1,4 +1,5 @@
|
||||
import mongoose, { Schema, HydratedDocument } from 'mongoose';
|
||||
import type { MatchEventType } from '@lolympus/contracts';
|
||||
import type {
|
||||
RiotPlatformRoute,
|
||||
RiotRegionalRoute,
|
||||
@@ -12,6 +13,8 @@ import {
|
||||
competitionModelDefinitions,
|
||||
} from '../../competition/competition.schema';
|
||||
import { ModelDefinition } from './types';
|
||||
import { AUCTION_CANCELLATION_CLEANUP_INDEX } from './auction-cancellation-index';
|
||||
import { MATCH_STATS_RIOT_MATCH_INDEX } from './match-stats-raw-index';
|
||||
|
||||
export type Position = 'TOP' | 'JGL' | 'MID' | 'ADC' | 'SUP';
|
||||
export const POSITIONS: Position[] = ['TOP', 'JGL', 'MID', 'ADC', 'SUP'];
|
||||
@@ -37,6 +40,11 @@ export const MATCH_STATUSES: MatchStatus[] = [
|
||||
'finished',
|
||||
];
|
||||
|
||||
export const MATCH_EVENT_TYPES = [
|
||||
'inhouse',
|
||||
'tournament',
|
||||
] as const satisfies readonly MatchEventType[];
|
||||
|
||||
export type TeamSide = 'blue' | 'red';
|
||||
export const TEAM_SIDES: TeamSide[] = ['blue', 'red'];
|
||||
|
||||
@@ -643,6 +651,7 @@ export interface DoubleEliminationEvent {
|
||||
export interface DoubleEliminationBracket {
|
||||
teamCount: 4 | 8;
|
||||
resetFinalEnabled: boolean;
|
||||
grandFinalGameCount?: 1 | 3 | 5;
|
||||
resetFinalCreated: boolean;
|
||||
seeds: DoubleEliminationSeed[];
|
||||
bracketMatches: DoubleEliminationBracketMatch[];
|
||||
@@ -684,6 +693,7 @@ export interface Match extends MongooseTimestamps {
|
||||
competitionId?: mongoose.Types.ObjectId;
|
||||
shortCode?: string;
|
||||
title: string;
|
||||
eventType?: MatchEventType;
|
||||
description: string;
|
||||
mapId: number; // Riot Match-V5 mapId (11=소환사의 협곡, 12=ARAM 등)
|
||||
status: MatchStatus;
|
||||
@@ -700,6 +710,12 @@ export interface Match extends MongooseTimestamps {
|
||||
teams: MatchTeam[];
|
||||
result?: MatchResult;
|
||||
resultPollState?: MatchResultPollState;
|
||||
/** 마지막으로 취소된 Redis 경매 lifecycle. 취소 재전송을 멱등 처리한다. */
|
||||
lastCancelledAuctionLifecycleId?: string;
|
||||
auctionCancellationCleanupPending?: boolean;
|
||||
auctionCancellationCleanupRetryAt?: Date;
|
||||
auctionCancellationCleanupAttempts?: number;
|
||||
auctionCancellationCleanupError?: string;
|
||||
doubleElimination?: DoubleEliminationBracket;
|
||||
legacyImported?: boolean;
|
||||
legacyImportSource?: {
|
||||
@@ -804,14 +820,45 @@ export interface AuctionBid {
|
||||
}
|
||||
|
||||
export interface AuctionBidHistoryEntry {
|
||||
bidRequestId?: string;
|
||||
revision?: number;
|
||||
bidRoundId?: string;
|
||||
playerUserId?: mongoose.Types.ObjectId;
|
||||
bidderTeamIndex: number;
|
||||
bidPointAmount: number;
|
||||
bidderUserId: mongoose.Types.ObjectId;
|
||||
bidPlacedAtTimestampMS: number;
|
||||
}
|
||||
|
||||
export interface AuctionBidRecord extends AuctionBidHistoryEntry {
|
||||
_id: string;
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
auctionLifecycleId: string;
|
||||
revision: number;
|
||||
bidRequestId: string;
|
||||
}
|
||||
|
||||
export const AuctionBidRecordSchema = new Schema<AuctionBidRecord>(
|
||||
{
|
||||
_id: { type: String, required: true },
|
||||
matchId: { type: Schema.Types.ObjectId, required: true },
|
||||
auctionLifecycleId: { type: String, required: true },
|
||||
revision: { type: Number, required: true },
|
||||
bidRequestId: { type: String, required: true },
|
||||
bidRoundId: { type: String },
|
||||
playerUserId: { type: Schema.Types.ObjectId },
|
||||
bidderUserId: { type: Schema.Types.ObjectId, required: true },
|
||||
bidderTeamIndex: { type: Number, required: true },
|
||||
bidPointAmount: { type: Number, required: true },
|
||||
bidPlacedAtTimestampMS: { type: Number, required: true },
|
||||
},
|
||||
{ collection: 'auctionBidRecords', versionKey: false },
|
||||
);
|
||||
|
||||
export interface AuctionChatMessage {
|
||||
id: string;
|
||||
clientMessageId?: string;
|
||||
senderRole?: 'operator';
|
||||
userId?: mongoose.Types.ObjectId;
|
||||
displayName: string;
|
||||
message: string;
|
||||
@@ -832,6 +879,8 @@ export interface Auction extends MongooseTimestamps {
|
||||
matchSideEffectStatus: AuctionMatchSideEffectStatus;
|
||||
matchSideEffectRevision: number;
|
||||
matchSideEffectError?: string;
|
||||
matchSideEffectTransitionId?: string;
|
||||
startupCompleted?: boolean;
|
||||
teams: AuctionTeam[];
|
||||
order: AuctionPlayerSnapshot[];
|
||||
passedQueue: AuctionPlayerSnapshot[];
|
||||
@@ -858,6 +907,7 @@ export interface Auction extends MongooseTimestamps {
|
||||
currentHighestBidPointAmount?: number;
|
||||
currentHighestBidderTeamIndex?: number;
|
||||
currentBidRoundDeadlineTimestampMS?: number;
|
||||
currentBidRoundId?: string;
|
||||
maximumBidRoundDurationSeconds?: number;
|
||||
bidRoundExtensionSeconds?: number;
|
||||
initialTeamBidPointAmount?: number;
|
||||
@@ -975,6 +1025,14 @@ export interface MatchStatsRecord {
|
||||
championLevel: number;
|
||||
teamPosition: string;
|
||||
kills: number;
|
||||
multiKills?: {
|
||||
doubleKills: number;
|
||||
tripleKills: number;
|
||||
quadraKills: number;
|
||||
pentaKills: number;
|
||||
largestMultiKill: number;
|
||||
};
|
||||
tier?: TierInfo;
|
||||
deaths: number;
|
||||
assists: number;
|
||||
win: boolean;
|
||||
@@ -1007,6 +1065,7 @@ export interface MatchStatsGameDetail {
|
||||
gameCreation: number;
|
||||
gameDuration: number;
|
||||
gameVersion?: string;
|
||||
rawAvailable?: boolean;
|
||||
winnerSide: TeamSide;
|
||||
timeline: MatchStatsTimelinePoint[];
|
||||
timelineLoaded?: boolean;
|
||||
@@ -1811,6 +1870,7 @@ const DoubleEliminationBracketSubSchema = new Schema<DoubleEliminationBracket>(
|
||||
{
|
||||
teamCount: { type: Number, enum: [4, 8], required: true },
|
||||
resetFinalEnabled: { type: Boolean, required: true, default: false },
|
||||
grandFinalGameCount: { type: Number, enum: [1, 3, 5] },
|
||||
resetFinalCreated: { type: Boolean, required: true, default: false },
|
||||
seeds: {
|
||||
type: [DoubleEliminationSeedSubSchema],
|
||||
@@ -1913,6 +1973,7 @@ export const MatchSchema = new Schema<Match>(
|
||||
maxlength: 6,
|
||||
},
|
||||
title: { type: String, required: true },
|
||||
eventType: { type: String, enum: MATCH_EVENT_TYPES, default: 'inhouse' },
|
||||
description: { type: String, required: false, default: '' },
|
||||
mapId: { type: Number, required: true, default: 11 },
|
||||
status: {
|
||||
@@ -1971,6 +2032,11 @@ export const MatchSchema = new Schema<Match>(
|
||||
type: MatchResultPollStateSubSchema,
|
||||
required: false,
|
||||
},
|
||||
lastCancelledAuctionLifecycleId: { type: String, required: false },
|
||||
auctionCancellationCleanupPending: { type: Boolean },
|
||||
auctionCancellationCleanupRetryAt: { type: Date },
|
||||
auctionCancellationCleanupAttempts: { type: Number },
|
||||
auctionCancellationCleanupError: { type: String },
|
||||
doubleElimination: {
|
||||
type: DoubleEliminationBracketSubSchema,
|
||||
required: false,
|
||||
@@ -1995,6 +2061,10 @@ export const MatchSchema = new Schema<Match>(
|
||||
);
|
||||
|
||||
MatchSchema.index({ communityId: 1, scheduledAt: -1 });
|
||||
MatchSchema.index(
|
||||
AUCTION_CANCELLATION_CLEANUP_INDEX.key,
|
||||
AUCTION_CANCELLATION_CLEANUP_INDEX.options,
|
||||
);
|
||||
applyCompetitionDomainInvariantIndexes(MatchSchema, 'match');
|
||||
MatchSchema.index({ communityId: 1, status: 1, scheduledAt: -1 });
|
||||
MatchSchema.index(
|
||||
@@ -2174,6 +2244,8 @@ const AuctionBidSubSchema = new Schema<AuctionBid>(
|
||||
|
||||
const AuctionBidHistoryEntrySubSchema = new Schema<AuctionBidHistoryEntry>(
|
||||
{
|
||||
bidRoundId: { type: String },
|
||||
playerUserId: { type: Schema.Types.ObjectId, ref: 'user' },
|
||||
bidderTeamIndex: { type: Number, required: true, min: 1 },
|
||||
bidPointAmount: { type: Number, required: true },
|
||||
bidderUserId: { type: Schema.Types.ObjectId, ref: 'user', required: true },
|
||||
@@ -2185,6 +2257,8 @@ const AuctionBidHistoryEntrySubSchema = new Schema<AuctionBidHistoryEntry>(
|
||||
const AuctionChatMessageSubSchema = new Schema<AuctionChatMessage>(
|
||||
{
|
||||
id: { type: String, required: true },
|
||||
clientMessageId: { type: String, required: false },
|
||||
senderRole: { type: String, enum: ['operator'], required: false },
|
||||
userId: { type: Schema.Types.ObjectId, ref: 'user', required: false },
|
||||
displayName: { type: String, required: true },
|
||||
message: { type: String, required: true },
|
||||
@@ -2195,6 +2269,9 @@ const AuctionChatMessageSubSchema = new Schema<AuctionChatMessage>(
|
||||
|
||||
export const AuctionSchema = new Schema<Auction>(
|
||||
{
|
||||
startupCompleted: { type: Boolean },
|
||||
matchSideEffectTransitionId: { type: String },
|
||||
currentBidRoundId: { type: String },
|
||||
matchId: {
|
||||
type: Schema.Types.ObjectId,
|
||||
ref: 'match',
|
||||
@@ -2475,7 +2552,7 @@ export const MatchStatsSchema: mongoose.Schema<MatchStats> = new Schema(
|
||||
{ timestamps: true, collection: 'match_stats' },
|
||||
) as mongoose.Schema<MatchStats>;
|
||||
|
||||
MatchStatsSchema.index({ communityId: 1, scheduledAt: -1 });
|
||||
MatchStatsSchema.index({ communityId: 1, scheduledAt: -1, matchId: -1 });
|
||||
MatchStatsSchema.index({
|
||||
communityId: 1,
|
||||
gameCreationMin: 1,
|
||||
@@ -2484,6 +2561,10 @@ MatchStatsSchema.index({
|
||||
MatchStatsSchema.index({ communityId: 1, userIds: 1 });
|
||||
MatchStatsSchema.index({ communityId: 1, userIds: 1, scheduledAt: -1 });
|
||||
MatchStatsSchema.index({ communityId: 1, championIds: 1 });
|
||||
MatchStatsSchema.index(
|
||||
MATCH_STATS_RIOT_MATCH_INDEX.key,
|
||||
MATCH_STATS_RIOT_MATCH_INDEX.options,
|
||||
);
|
||||
|
||||
export const tournamentModelDefinitions: Array<
|
||||
ModelDefinition & { name: keyof TournamentModelTypes }
|
||||
@@ -2520,6 +2601,11 @@ export const tournamentModelDefinitions: Array<
|
||||
},
|
||||
{ name: 'match', schema: MatchSchema, schemaName: 'match' },
|
||||
{ name: 'auction', schema: AuctionSchema, schemaName: 'auction' },
|
||||
{
|
||||
name: 'auctionBidRecord',
|
||||
schema: AuctionBidRecordSchema,
|
||||
schemaName: 'auctionBidRecords',
|
||||
},
|
||||
{
|
||||
name: 'auctionHistory',
|
||||
schema: AuctionHistoryEntrySchema,
|
||||
@@ -2553,6 +2639,7 @@ export interface TournamentModelTypes {
|
||||
legacyImportJob: LegacyImportJob;
|
||||
match: Match;
|
||||
auction: Auction;
|
||||
auctionBidRecord: AuctionBidRecord;
|
||||
auctionHistory: AuctionHistoryEntry;
|
||||
auctionSideEffectApplication: AuctionSideEffectApplication;
|
||||
matchStats: MatchStats;
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { connect } from 'nats';
|
||||
import type { NatsConnection } from 'nats';
|
||||
import { connect, type NatsConnection } from '@nats-io/transport-node';
|
||||
import { SecretModule } from '../secret/secret.module';
|
||||
import { SecretService } from '../secret/secret.service';
|
||||
import { NATS_CLIENT } from './nats.constants';
|
||||
|
||||
@@ -2,20 +2,21 @@ import { Inject, Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
|
||||
import {
|
||||
AckPolicy,
|
||||
DeliverPolicy,
|
||||
nanos,
|
||||
jetstream,
|
||||
jetstreamManager,
|
||||
ReplayPolicy,
|
||||
RetentionPolicy,
|
||||
StorageType,
|
||||
StringCodec,
|
||||
} from 'nats';
|
||||
import type {
|
||||
ConsumerMessages,
|
||||
JsMsg,
|
||||
Msg,
|
||||
NatsConnection,
|
||||
PubAck,
|
||||
Subscription,
|
||||
} from 'nats';
|
||||
type ConsumerMessages,
|
||||
type JsMsg,
|
||||
type PubAck,
|
||||
} from '@nats-io/jetstream';
|
||||
import {
|
||||
nanos,
|
||||
type Msg,
|
||||
type NatsConnection,
|
||||
type Subscription,
|
||||
} from '@nats-io/transport-node';
|
||||
import { NATS_CLIENT } from './nats.constants';
|
||||
|
||||
export type NatsMessageHandler<T = unknown> = (
|
||||
@@ -64,7 +65,6 @@ const JET_STREAM_CONSUMER_RESTART_DELAY_MILLISECONDS = 1_000;
|
||||
@Injectable()
|
||||
export class NatsService implements OnModuleDestroy {
|
||||
private readonly logger = new Logger(NatsService.name);
|
||||
private readonly stringCodec = StringCodec();
|
||||
private readonly subscriptions = new Set<Subscription>();
|
||||
private readonly jetStreamConsumers = new Set<ConsumerMessages>();
|
||||
private isDestroying = false;
|
||||
@@ -108,10 +108,7 @@ export class NatsService implements OnModuleDestroy {
|
||||
}
|
||||
|
||||
public async publish<T = unknown>(subject: string, data: T): Promise<void> {
|
||||
this.natsClient.publish(
|
||||
subject,
|
||||
this.stringCodec.encode(JSON.stringify(data)),
|
||||
);
|
||||
this.natsClient.publish(subject, JSON.stringify(data));
|
||||
await this.natsClient.flush();
|
||||
}
|
||||
|
||||
@@ -133,19 +130,16 @@ export class NatsService implements OnModuleDestroy {
|
||||
data: T,
|
||||
options?: { messageId?: string; timeoutMs?: number },
|
||||
): Promise<PubAck> {
|
||||
const ack = await this.natsClient
|
||||
.jetstream()
|
||||
.publish(subject, this.stringCodec.encode(JSON.stringify(data)), {
|
||||
msgID: options?.messageId,
|
||||
timeout: options?.timeoutMs ?? 5000,
|
||||
});
|
||||
return ack;
|
||||
return jetstream(this.natsClient).publish(subject, JSON.stringify(data), {
|
||||
msgID: options?.messageId,
|
||||
timeout: options?.timeoutMs ?? 5000,
|
||||
});
|
||||
}
|
||||
|
||||
public async ensureJetStreamStream(
|
||||
options: JetStreamStreamOptions,
|
||||
): Promise<void> {
|
||||
const manager = await this.natsClient.jetstreamManager();
|
||||
const manager = await jetstreamManager(this.natsClient);
|
||||
const config = {
|
||||
name: options.name,
|
||||
subjects: options.subjects,
|
||||
@@ -173,7 +167,7 @@ export class NatsService implements OnModuleDestroy {
|
||||
public async ensureJetStreamConsumer(
|
||||
options: JetStreamConsumerOptions,
|
||||
): Promise<void> {
|
||||
const manager = await this.natsClient.jetstreamManager();
|
||||
const manager = await jetstreamManager(this.natsClient);
|
||||
const config = {
|
||||
durable_name: options.durable,
|
||||
name: options.durable,
|
||||
@@ -206,9 +200,10 @@ export class NatsService implements OnModuleDestroy {
|
||||
): Promise<void> {
|
||||
while (!this.isDestroying) {
|
||||
try {
|
||||
const consumer = await this.natsClient
|
||||
.jetstream()
|
||||
.consumers.get(options.stream, options.durable);
|
||||
const consumer = await jetstream(this.natsClient).consumers.get(
|
||||
options.stream,
|
||||
options.durable,
|
||||
);
|
||||
const messages = await consumer.consume({
|
||||
max_messages: options.maxMessages ?? 10,
|
||||
expires: options.expiresMs ?? 30000,
|
||||
@@ -263,8 +258,7 @@ export class NatsService implements OnModuleDestroy {
|
||||
): Promise<void> {
|
||||
let data: T;
|
||||
try {
|
||||
const decoded = this.stringCodec.decode(msg.data);
|
||||
data = JSON.parse(decoded) as T;
|
||||
data = msg.json<T>();
|
||||
} catch (err) {
|
||||
this.logger.warn(
|
||||
`Failed to decode NATS message on subject="${msg.subject}": ${
|
||||
@@ -292,7 +286,7 @@ export class NatsService implements OnModuleDestroy {
|
||||
): Promise<void> {
|
||||
let data: T;
|
||||
try {
|
||||
data = JSON.parse(msg.string()) as T;
|
||||
data = msg.json<T>();
|
||||
} catch (err) {
|
||||
this.logger.warn(
|
||||
`Terminating undecodable JetStream message subject="${msg.subject}" stream="${options.stream}": ${
|
||||
|
||||
@@ -389,6 +389,7 @@ describe('Legacy import Competition result cutover', () => {
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const communityStatsService = {
|
||||
refreshForRiotMatches: jest.fn().mockResolvedValue(undefined),
|
||||
invalidateCommunity: jest.fn().mockResolvedValue(undefined),
|
||||
} as unknown as jest.Mocked<CommunityStatsService>;
|
||||
const service = createService({
|
||||
@@ -642,6 +643,7 @@ function createService(
|
||||
{} as RiotMatchService,
|
||||
options.communityStatsService ??
|
||||
({
|
||||
refreshForRiotMatches: jest.fn().mockResolvedValue(undefined),
|
||||
invalidateCommunity: jest.fn().mockResolvedValue(undefined),
|
||||
} as unknown as CommunityStatsService),
|
||||
options.matchStatsService ?? ({} as MatchStatsService),
|
||||
@@ -977,6 +979,7 @@ function createBulkDeleteFailureHarness(options: {
|
||||
}),
|
||||
} as unknown as ConnectionService;
|
||||
const communityStatsService = {
|
||||
refreshForRiotMatches: jest.fn().mockResolvedValue(undefined),
|
||||
invalidateCommunity: jest.fn().mockResolvedValue(0),
|
||||
} as unknown as jest.Mocked<CommunityStatsService>;
|
||||
const service = createService({ connectionService, communityStatsService });
|
||||
|
||||
@@ -59,6 +59,7 @@ describe('LegacyImportService member job completion', () => {
|
||||
releaseLockIfOwned: jest.fn().mockResolvedValue(true),
|
||||
} as unknown as jest.Mocked<DistributedLockService>;
|
||||
const communityStatsService = {
|
||||
refreshForRiotMatches: jest.fn().mockResolvedValue(undefined),
|
||||
invalidateCommunity: jest.fn().mockResolvedValue(undefined),
|
||||
} as unknown as jest.Mocked<CommunityStatsService>;
|
||||
const service = new LegacyImportService(
|
||||
|
||||
@@ -797,7 +797,9 @@ export class LegacyImportService {
|
||||
'evidence.type': 'riot',
|
||||
'evidence.riotMatchId': riotMatchId,
|
||||
});
|
||||
if (existing) return 'duplicate';
|
||||
if (existing) {
|
||||
return 'duplicate';
|
||||
}
|
||||
|
||||
const detail = await this.ensureRiotMatchPersisted(
|
||||
riotMatchId,
|
||||
@@ -930,7 +932,9 @@ export class LegacyImportService {
|
||||
const stored = await RiotMatchModel.findOne({
|
||||
matchId: riotMatchId,
|
||||
}).exec();
|
||||
if (isRiotMatchDto(stored?.raw)) return stored.raw;
|
||||
if (isRiotMatchDto(stored?.raw)) {
|
||||
return stored.raw;
|
||||
}
|
||||
|
||||
const dto = await this.riotMatchService.getMatch(riotMatchId, { region });
|
||||
const payload: Partial<StoredRiotMatch> = {
|
||||
@@ -948,6 +952,13 @@ export class LegacyImportService {
|
||||
{ $set: payload },
|
||||
{ upsert: true },
|
||||
).exec();
|
||||
await this.communityStatsService
|
||||
.refreshForRiotMatches([dto.metadata.matchId])
|
||||
.catch((error: unknown) => {
|
||||
this.logger.warn(
|
||||
`Stats recovery failed after saving ${dto.metadata.matchId}: ${String(error)}`,
|
||||
);
|
||||
});
|
||||
return dto;
|
||||
}
|
||||
|
||||
|
||||
@@ -56,6 +56,7 @@ export class MatchHistoryController {
|
||||
@Query('seasonId') seasonId?: string,
|
||||
@Query('championId') championId?: string,
|
||||
@Query('limit') limit?: string,
|
||||
@Query('lane') lane?: string,
|
||||
) {
|
||||
return this.matchHistoryService.getRecentSummary({
|
||||
communityId,
|
||||
@@ -66,6 +67,7 @@ export class MatchHistoryController {
|
||||
seasonId,
|
||||
championId: this.toNumber(championId),
|
||||
limit: this.toNumber(limit),
|
||||
lane,
|
||||
},
|
||||
});
|
||||
}
|
||||
@@ -82,6 +84,8 @@ export class MatchHistoryController {
|
||||
@Query('championId') championId?: string,
|
||||
@Query('limit') limit?: string,
|
||||
@Query('cursor') cursor?: string,
|
||||
@Query('lane') lane?: string,
|
||||
@Query('includePositionCounts') includePositionCounts?: string,
|
||||
) {
|
||||
return this.matchHistoryService.getRecentMatches({
|
||||
communityId,
|
||||
@@ -93,6 +97,8 @@ export class MatchHistoryController {
|
||||
championId: this.toNumber(championId),
|
||||
limit: this.toNumber(limit),
|
||||
cursor: this.toNumber(cursor),
|
||||
lane,
|
||||
includePositionCounts: includePositionCounts === 'true',
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
@@ -0,0 +1,340 @@
|
||||
import mongoose from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import { MatchHistoryService } from './match-history.service';
|
||||
|
||||
const SEASON_START = Date.parse('2026-01-01T00:00:00Z');
|
||||
|
||||
describe('MatchHistoryService champion filtering', () => {
|
||||
it('selects a lane before limiting and uses only the requested participant, including legacy individualPosition', async () => {
|
||||
const { service, scope, find } = createHarness();
|
||||
const result = await service.getRecentMatches({
|
||||
...scope,
|
||||
filters: { rank: 'solo', lane: 'MIDDLE', limit: 20 },
|
||||
});
|
||||
expect(result.matches.map((game) => game.matchId)).toEqual([
|
||||
'KR_3',
|
||||
'KR_2',
|
||||
'KR_1',
|
||||
]);
|
||||
expect(result.matches.every((game) => game.teamPosition === 'MIDDLE')).toBe(
|
||||
true,
|
||||
);
|
||||
expect(result.matches[0].damageShare).toBe(100);
|
||||
expect(find.mock.calls[0][0]['raw.info.participants']?.$elemMatch).toEqual({
|
||||
puuid: 'player',
|
||||
$or: [
|
||||
{ teamPosition: 'MIDDLE' },
|
||||
{ teamPosition: { $in: ['', null] }, individualPosition: 'MIDDLE' },
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
it('combines champion and lane filtering and rejects invalid lanes', async () => {
|
||||
const { service, scope } = createHarness();
|
||||
const result = await service.getRecentMatches({
|
||||
...scope,
|
||||
filters: { rank: 'solo', championId: 1, lane: 'MIDDLE', limit: 20 },
|
||||
});
|
||||
expect(result.matches).toEqual([]);
|
||||
await expect(
|
||||
service.getRecentMatches({ ...scope, filters: { lane: 'unknown' } }),
|
||||
).rejects.toThrow('Invalid lane');
|
||||
});
|
||||
|
||||
it('counts independent lane windows across the season and caps each at twenty', async () => {
|
||||
const { service, scope, aggregate } = createHarness();
|
||||
const result = await service.getRecentMatches({
|
||||
...scope,
|
||||
filters: {
|
||||
rank: 'solo',
|
||||
lane: 'MIDDLE',
|
||||
limit: 20,
|
||||
includePositionCounts: true,
|
||||
},
|
||||
});
|
||||
expect(result.positionCounts).toEqual({
|
||||
ALL: 20,
|
||||
TOP: 20,
|
||||
JUNGLE: 0,
|
||||
MIDDLE: 3,
|
||||
BOTTOM: 0,
|
||||
UTILITY: 0,
|
||||
});
|
||||
expect(aggregate.mock.calls[0][0][0]).toEqual({
|
||||
$match: {
|
||||
participantPuuids: 'player',
|
||||
queueId: { $in: [420] },
|
||||
gameCreation: { $gte: SEASON_START },
|
||||
},
|
||||
});
|
||||
expect(JSON.stringify(aggregate.mock.calls[0][0])).toContain('$$p.puuid');
|
||||
expect(JSON.stringify(aggregate.mock.calls[0][0])).not.toContain('$limit');
|
||||
});
|
||||
|
||||
it('paginates matching games beyond 120 newer games and excludes opponents using the champion', async () => {
|
||||
const harness = createHarness();
|
||||
const filters = { championId: 99, rank: 'solo', limit: 2 };
|
||||
const first = await harness.service.getRecentMatches({
|
||||
...harness.scope,
|
||||
filters,
|
||||
});
|
||||
|
||||
expect(first.matches.map((match) => match.matchId)).toEqual([
|
||||
'KR_3',
|
||||
'KR_2',
|
||||
]);
|
||||
expect(first.nextCursor).toBe(SEASON_START + 2_000);
|
||||
expect(first.matches[0].largestMultiKill).toBe(3);
|
||||
expect(first.matches[0].teams[0].participants[0].tier).toMatchObject({
|
||||
tier: 'GOLD',
|
||||
rank: 'II',
|
||||
});
|
||||
const second = await harness.service.getRecentMatches({
|
||||
...harness.scope,
|
||||
filters: { ...filters, cursor: first.nextCursor! },
|
||||
});
|
||||
expect(second.matches.map((match) => match.matchId)).toEqual(['KR_1']);
|
||||
expect(second.nextCursor).toBeNull();
|
||||
expect(harness.returnedCounts).toEqual([3, 1]);
|
||||
expect(harness.find).toHaveBeenLastCalledWith({
|
||||
participantPuuids: 'player',
|
||||
queueId: { $in: [420] },
|
||||
gameCreation: { $gte: SEASON_START, $lt: first.nextCursor },
|
||||
'raw.info.participants': {
|
||||
$elemMatch: { puuid: 'player', championId: 99 },
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it('summarizes matching games across the former scan boundary', async () => {
|
||||
const { service, scope, returnedCounts } = createHarness();
|
||||
const summary = await service.getRecentSummary({
|
||||
...scope,
|
||||
filters: { championId: 99, rank: 'solo', limit: 20 },
|
||||
});
|
||||
|
||||
expect(summary).toMatchObject({ windowSize: 3, wins: 3, losses: 0 });
|
||||
expect(summary.topChampions).toEqual([
|
||||
expect.objectContaining({ championId: 99, games: 3 }),
|
||||
]);
|
||||
expect(returnedCounts).toEqual([3]);
|
||||
});
|
||||
|
||||
it('keeps unfiltered pagination and does not transfer timeline payloads', async () => {
|
||||
const { service, scope, find, select, returnedCounts } = createHarness();
|
||||
const result = await service.getRecentMatches({
|
||||
...scope,
|
||||
filters: { rank: 'solo', limit: 2 },
|
||||
});
|
||||
|
||||
expect(result.matches.map((match) => match.matchId)).toEqual([
|
||||
'KR_130',
|
||||
'KR_129',
|
||||
]);
|
||||
expect(result.nextCursor).toBe(SEASON_START + 129_000);
|
||||
expect(find.mock.calls[0][0]['raw.info.participants']).toBeUndefined();
|
||||
expect(select).toHaveBeenCalledWith({ timeline: 0 });
|
||||
expect(returnedCounts).toEqual([3]);
|
||||
});
|
||||
});
|
||||
|
||||
interface HistoryQuery {
|
||||
participantPuuids: string;
|
||||
queueId: { $in: number[] };
|
||||
gameCreation?: { $gte?: number; $lt?: number };
|
||||
'raw.info.participants'?: {
|
||||
$elemMatch: {
|
||||
puuid: string;
|
||||
championId?: number;
|
||||
$or?: Array<{
|
||||
teamPosition: string | { $in: (string | null)[] };
|
||||
individualPosition?: string;
|
||||
}>;
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
function createHarness() {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const userId = new mongoose.Types.ObjectId();
|
||||
// In the newer games only the opponent played champion 99.
|
||||
const rows = [
|
||||
...Array.from({ length: 127 }, (_, index) => storedMatch(index + 4, 1)),
|
||||
storedMatch(3, 99),
|
||||
storedMatch(2, 99),
|
||||
storedMatch(1, 99),
|
||||
storedMatch(131, 99, 450), // Wrong queue.
|
||||
storedMatch(-1, 99), // Before the season.
|
||||
];
|
||||
const returnedCounts: number[] = [];
|
||||
const select = jest.fn();
|
||||
const find = jest.fn((filter: HistoryQuery) => {
|
||||
let limit = rows.length;
|
||||
const query = {
|
||||
sort: jest.fn().mockReturnThis(),
|
||||
limit: (value: number) => {
|
||||
limit = value;
|
||||
return query;
|
||||
},
|
||||
select: (projection: unknown) => {
|
||||
select(projection);
|
||||
return query;
|
||||
},
|
||||
exec: async () => {
|
||||
const participant = filter['raw.info.participants']?.$elemMatch;
|
||||
const result = rows
|
||||
.filter(
|
||||
(row) =>
|
||||
row.participantPuuids.includes(filter.participantPuuids) &&
|
||||
filter.queueId.$in.includes(row.queueId) &&
|
||||
(filter.gameCreation?.$gte === undefined ||
|
||||
row.gameCreation >= filter.gameCreation.$gte) &&
|
||||
(filter.gameCreation?.$lt === undefined ||
|
||||
row.gameCreation < filter.gameCreation.$lt) &&
|
||||
(!participant ||
|
||||
row.raw.info.participants.some(
|
||||
(entry) =>
|
||||
entry.puuid === participant.puuid &&
|
||||
(participant.championId === undefined ||
|
||||
entry.championId === participant.championId) &&
|
||||
(!participant.$or ||
|
||||
participant.$or.some((condition) =>
|
||||
typeof condition.teamPosition === 'string'
|
||||
? entry.teamPosition === condition.teamPosition
|
||||
: condition.teamPosition.$in.includes(
|
||||
entry.teamPosition ?? null,
|
||||
) &&
|
||||
entry.individualPosition ===
|
||||
condition.individualPosition,
|
||||
)),
|
||||
)),
|
||||
)
|
||||
.sort((a, b) => b.gameCreation - a.gameCreation)
|
||||
.slice(0, limit);
|
||||
returnedCounts.push(result.length);
|
||||
return result;
|
||||
},
|
||||
};
|
||||
return query;
|
||||
});
|
||||
const aggregate = jest.fn<
|
||||
{ exec: () => Promise<Array<{ _id: string; count: number }>> },
|
||||
[unknown[]]
|
||||
>(() => ({
|
||||
exec: async () => [
|
||||
{ _id: 'TOP', count: 127 },
|
||||
{ _id: 'MIDDLE', count: 3 },
|
||||
],
|
||||
}));
|
||||
const models = {
|
||||
user: {
|
||||
find: () => ({
|
||||
select: () => ({
|
||||
lean: () => ({
|
||||
exec: async () => [
|
||||
{
|
||||
riotAccounts: [
|
||||
{
|
||||
puuid: 'player',
|
||||
tierHistory: [
|
||||
{
|
||||
queueType: 'RANKED_SOLO_5x5',
|
||||
tier: 'PLATINUM',
|
||||
recordedAt: new Date(SEASON_START + 4_000),
|
||||
},
|
||||
{
|
||||
queueType: 'RANKED_SOLO_5x5',
|
||||
tier: 'GOLD',
|
||||
rank: 'II',
|
||||
recordedAt: new Date(SEASON_START),
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
findById: () => ({
|
||||
exec: async () => ({
|
||||
_id: userId,
|
||||
communityId,
|
||||
riotAccounts: [{ puuid: 'player', isPrimary: true }],
|
||||
}),
|
||||
}),
|
||||
},
|
||||
community: {
|
||||
findById: () => ({
|
||||
exec: async () => ({
|
||||
_id: communityId,
|
||||
seasonStartedAt: new Date(SEASON_START),
|
||||
}),
|
||||
}),
|
||||
},
|
||||
riotMatch: { find, aggregate },
|
||||
};
|
||||
const connection = {
|
||||
getModel: async (name: keyof typeof models) => models[name],
|
||||
} as unknown as ConnectionService;
|
||||
return {
|
||||
service: new MatchHistoryService(connection),
|
||||
scope: { communityId, userId },
|
||||
find,
|
||||
select,
|
||||
returnedCounts,
|
||||
aggregate,
|
||||
};
|
||||
}
|
||||
|
||||
function storedMatch(sequence: number, championId: number, queueId = 420) {
|
||||
const gameCreation = SEASON_START + sequence * 1_000;
|
||||
const participant = {
|
||||
puuid: 'player',
|
||||
championId,
|
||||
teamPosition:
|
||||
sequence === 2 ? undefined : championId === 99 ? 'MIDDLE' : 'TOP',
|
||||
individualPosition: championId === 99 ? 'MIDDLE' : 'TOP',
|
||||
teamId: 100,
|
||||
win: true,
|
||||
kills: 5,
|
||||
tripleKills: 1,
|
||||
deaths: 2,
|
||||
assists: 3,
|
||||
totalMinionsKilled: 100,
|
||||
neutralMinionsKilled: 20,
|
||||
goldEarned: 10_000,
|
||||
totalDamageDealtToChampions: 10_000,
|
||||
totalDamageTaken: 5_000,
|
||||
perks: { styles: [] },
|
||||
};
|
||||
return {
|
||||
gameCreation,
|
||||
queueId,
|
||||
participantPuuids: ['player', 'opponent'],
|
||||
fetchedAt: new Date(),
|
||||
raw: {
|
||||
metadata: { matchId: `KR_${sequence}` },
|
||||
info: {
|
||||
gameCreation,
|
||||
queueId,
|
||||
gameDuration: 1_800,
|
||||
participants: [
|
||||
participant,
|
||||
{
|
||||
...participant,
|
||||
puuid: 'opponent',
|
||||
teamId: 200,
|
||||
championId: 99,
|
||||
teamPosition: 'MIDDLE',
|
||||
win: false,
|
||||
},
|
||||
],
|
||||
teams: [
|
||||
{ teamId: 100, win: true },
|
||||
{ teamId: 200, win: false },
|
||||
],
|
||||
},
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -21,6 +21,7 @@ import {
|
||||
type RiotRankFilter,
|
||||
} from '../riot/riot-queue.constants';
|
||||
import type { RiotMatchDto, RiotMatchParticipantDto } from '../riot/riot.types';
|
||||
import { readMultiKills } from '../riot/riot-multi-kill';
|
||||
import type {
|
||||
ChampionStatsResponse,
|
||||
ChampionStatsRow,
|
||||
@@ -36,7 +37,6 @@ const DEFAULT_RANK: RiotRankFilter = 'all';
|
||||
const DEFAULT_RECENT_LIMIT = 10;
|
||||
const DEFAULT_SUMMARY_LIMIT = 20;
|
||||
const MAX_AGGREGATE_MATCHES = 500;
|
||||
const MAX_RECENT_SCAN = 120;
|
||||
|
||||
interface HistoryContext {
|
||||
community: CommunityDocument;
|
||||
@@ -53,6 +53,8 @@ interface MatchFilters {
|
||||
championId?: number;
|
||||
limit?: number;
|
||||
cursor?: number;
|
||||
lane?: string;
|
||||
includePositionCounts?: boolean;
|
||||
}
|
||||
|
||||
interface AggregatedChampion {
|
||||
@@ -183,8 +185,8 @@ export class MatchHistoryService {
|
||||
context,
|
||||
queueIds,
|
||||
championId: params.filters.championId,
|
||||
lane: params.filters.lane,
|
||||
limit,
|
||||
scanLimit: params.filters.championId ? MAX_RECENT_SCAN : undefined,
|
||||
});
|
||||
const views = docs
|
||||
.map((doc) => this.toRecentMatchView(doc, context.account.puuid))
|
||||
@@ -213,17 +215,27 @@ export class MatchHistoryService {
|
||||
context,
|
||||
queueIds,
|
||||
championId: params.filters.championId,
|
||||
lane: params.filters.lane,
|
||||
limit: limit + 1,
|
||||
cursor: params.filters.cursor,
|
||||
scanLimit: params.filters.championId ? MAX_RECENT_SCAN : undefined,
|
||||
});
|
||||
const views = docs
|
||||
.map((doc) => this.toRecentMatchView(doc, context.account.puuid))
|
||||
.filter((view): view is RecentMatchView => Boolean(view));
|
||||
const page = views.slice(0, limit);
|
||||
await this.attachRecordedRanks(params.communityId, page);
|
||||
|
||||
return {
|
||||
matches: page,
|
||||
...(params.filters.includePositionCounts
|
||||
? {
|
||||
positionCounts: await this.getPositionCounts(
|
||||
context,
|
||||
queueIds,
|
||||
params.filters.championId,
|
||||
),
|
||||
}
|
||||
: {}),
|
||||
nextCursor:
|
||||
views.length > limit
|
||||
? (page[page.length - 1]?.gameCreation ?? null)
|
||||
@@ -233,6 +245,64 @@ export class MatchHistoryService {
|
||||
};
|
||||
}
|
||||
|
||||
private async attachRecordedRanks(
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
page: RecentMatchView[],
|
||||
) {
|
||||
const ranked = page.filter(
|
||||
(game) => game.queueId === 420 || game.queueId === 440,
|
||||
);
|
||||
const puuids = new Set(
|
||||
ranked.flatMap((game) =>
|
||||
game.teams.flatMap((team) =>
|
||||
team.participants.map(({ puuid }) => puuid),
|
||||
),
|
||||
),
|
||||
);
|
||||
if (puuids.size === 0) return;
|
||||
const UserModel = await this.connectionService.getModel('user');
|
||||
const users = await UserModel.find({
|
||||
communityId,
|
||||
'riotAccounts.puuid': { $in: [...puuids] },
|
||||
})
|
||||
.select({ 'riotAccounts.puuid': 1, 'riotAccounts.tierHistory': 1 })
|
||||
.lean()
|
||||
.exec();
|
||||
const history = new Map(
|
||||
users.flatMap(({ riotAccounts }) =>
|
||||
riotAccounts
|
||||
.filter(({ puuid }) => puuids.has(puuid))
|
||||
.map(({ puuid, tierHistory }) => [puuid, tierHistory ?? []] as const),
|
||||
),
|
||||
);
|
||||
for (const game of ranked) {
|
||||
const queueType =
|
||||
game.queueId === 420 ? 'RANKED_SOLO_5x5' : 'RANKED_FLEX_SR';
|
||||
for (const participant of game.teams.flatMap(
|
||||
(team) => team.participants,
|
||||
)) {
|
||||
const snapshot = history
|
||||
.get(participant.puuid)
|
||||
?.filter(
|
||||
(entry) =>
|
||||
entry.queueType === queueType &&
|
||||
entry.recordedAt.getTime() <= game.gameCreation,
|
||||
)
|
||||
.sort(
|
||||
(left, right) =>
|
||||
right.recordedAt.getTime() - left.recordedAt.getTime(),
|
||||
)[0];
|
||||
if (snapshot)
|
||||
participant.tier = {
|
||||
tier: snapshot.tier,
|
||||
rank: snapshot.rank,
|
||||
leaguePoints: snapshot.leaguePoints,
|
||||
fetchedAt: snapshot.recordedAt.toISOString(),
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async resolveContext(params: {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
userId: mongoose.Types.ObjectId;
|
||||
@@ -337,8 +407,14 @@ export class MatchHistoryService {
|
||||
limit: number;
|
||||
cursor?: number;
|
||||
championId?: number;
|
||||
scanLimit?: number;
|
||||
lane?: string;
|
||||
}): Promise<RiotMatchDocument[]> {
|
||||
if (
|
||||
params.lane &&
|
||||
!['TOP', 'JUNGLE', 'MIDDLE', 'BOTTOM', 'UTILITY'].includes(params.lane)
|
||||
) {
|
||||
throw new BadRequestException('Invalid lane.');
|
||||
}
|
||||
if (params.queueIds.length === 0) return [];
|
||||
const RiotMatchModel = await this.connectionService.getModel('riotMatch');
|
||||
const gameCreation: Record<string, number> = {};
|
||||
@@ -352,22 +428,102 @@ export class MatchHistoryService {
|
||||
queueId: { $in: params.queueIds },
|
||||
};
|
||||
if (Object.keys(gameCreation).length > 0) query.gameCreation = gameCreation;
|
||||
if (params.championId !== undefined || params.lane) {
|
||||
// Both conditions must match the same participant, before pagination.
|
||||
query['raw.info.participants'] = {
|
||||
$elemMatch: {
|
||||
puuid: params.context.account.puuid,
|
||||
...(params.championId !== undefined
|
||||
? { championId: params.championId }
|
||||
: {}),
|
||||
...(params.lane
|
||||
? {
|
||||
$or: [
|
||||
{ teamPosition: params.lane },
|
||||
{
|
||||
teamPosition: { $in: ['', null] },
|
||||
individualPosition: params.lane,
|
||||
},
|
||||
],
|
||||
}
|
||||
: {}),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
const docs = await RiotMatchModel.find(query)
|
||||
return RiotMatchModel.find(query)
|
||||
.sort({ gameCreation: -1 })
|
||||
.limit(params.scanLimit ?? params.limit)
|
||||
.limit(params.limit)
|
||||
.select({ timeline: 0 })
|
||||
.exec();
|
||||
}
|
||||
|
||||
if (!params.championId) return docs.slice(0, params.limit);
|
||||
return docs
|
||||
.filter((doc) => {
|
||||
const participant = this.findParticipant(
|
||||
doc.raw as unknown as RiotMatchDto,
|
||||
params.context.account.puuid,
|
||||
);
|
||||
return participant?.championId === params.championId;
|
||||
})
|
||||
.slice(0, params.limit);
|
||||
/** Counts independent position windows, without transferring full match payloads. */
|
||||
private async getPositionCounts(
|
||||
context: HistoryContext,
|
||||
queueIds: number[],
|
||||
championId?: number,
|
||||
): Promise<Record<string, number>> {
|
||||
const model = await this.connectionService.getModel('riotMatch');
|
||||
const rows = await model
|
||||
.aggregate<{ _id: string; count: number }>([
|
||||
{
|
||||
$match: {
|
||||
participantPuuids: context.account.puuid,
|
||||
queueId: { $in: queueIds },
|
||||
...(context.seasonStartedAt
|
||||
? { gameCreation: { $gte: context.seasonStartedAt.getTime() } }
|
||||
: {}),
|
||||
},
|
||||
},
|
||||
{
|
||||
$project: {
|
||||
participant: {
|
||||
$first: {
|
||||
$filter: {
|
||||
input: '$raw.info.participants',
|
||||
as: 'p',
|
||||
cond: { $eq: ['$$p.puuid', context.account.puuid] },
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
$match: {
|
||||
participant: { $ne: null },
|
||||
...(championId !== undefined
|
||||
? { 'participant.championId': championId }
|
||||
: {}),
|
||||
},
|
||||
},
|
||||
{
|
||||
$group: {
|
||||
_id: {
|
||||
$cond: [
|
||||
{ $in: [{ $ifNull: ['$participant.teamPosition', ''] }, ['']] },
|
||||
'$participant.individualPosition',
|
||||
'$participant.teamPosition',
|
||||
],
|
||||
},
|
||||
count: { $sum: 1 },
|
||||
},
|
||||
},
|
||||
])
|
||||
.exec();
|
||||
const counts: Record<string, number> = {
|
||||
ALL: Math.min(
|
||||
20,
|
||||
rows.reduce((sum, row) => sum + row.count, 0),
|
||||
),
|
||||
};
|
||||
for (const lane of ['TOP', 'JUNGLE', 'MIDDLE', 'BOTTOM', 'UTILITY']) {
|
||||
counts[lane] = Math.min(
|
||||
20,
|
||||
rows.find((row) => row._id === lane)?.count ?? 0,
|
||||
);
|
||||
}
|
||||
return counts;
|
||||
}
|
||||
|
||||
private async aggregateChampionStats(params: {
|
||||
@@ -598,6 +754,7 @@ export class MatchHistoryService {
|
||||
championLevel: participant.champLevel,
|
||||
teamPosition: participant.teamPosition || participant.individualPosition,
|
||||
kills: participant.kills,
|
||||
largestMultiKill: readMultiKills(participant)?.largestMultiKill,
|
||||
deaths: participant.deaths,
|
||||
assists: participant.assists,
|
||||
kda: this.resolveKda(
|
||||
@@ -620,6 +777,7 @@ export class MatchHistoryService {
|
||||
wardsPlaced: participant.wardsPlaced,
|
||||
wardsKilled: participant.wardsKilled,
|
||||
damageDealtToChampions: participant.totalDamageDealtToChampions,
|
||||
damageShare: damageShare * 100,
|
||||
damageTaken: participant.totalDamageTaken,
|
||||
goldEarned: participant.goldEarned,
|
||||
items: [
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import type { MatchStatsRunePerks, RiotLane } from '../global/database/schema';
|
||||
import type { RecentMatchParticipantRank } from '@lolympus/contracts';
|
||||
import type {
|
||||
RiotQueueGroup,
|
||||
RiotRankFilter,
|
||||
@@ -102,6 +103,8 @@ export interface RecentSummaryResponse {
|
||||
}
|
||||
|
||||
export interface RecentMatchesResponse {
|
||||
/** Available games in each independent recent-20 window. */
|
||||
positionCounts?: Record<string, number>;
|
||||
matches: RecentMatchView[];
|
||||
nextCursor: number | null;
|
||||
lastFetchedAt: string | null;
|
||||
@@ -115,6 +118,7 @@ export interface RecentMatchTeamParticipantView {
|
||||
championId: number;
|
||||
championLevel: number;
|
||||
teamPosition: string;
|
||||
tier?: RecentMatchParticipantRank;
|
||||
kills: number;
|
||||
deaths: number;
|
||||
assists: number;
|
||||
@@ -134,8 +138,11 @@ export interface RecentMatchTeamParticipantView {
|
||||
}
|
||||
|
||||
export interface RecentMatchView {
|
||||
/** Player champion damage / team champion damage, as a percentage. */
|
||||
damageShare?: number;
|
||||
matchId: string;
|
||||
internalMatchId?: string;
|
||||
internalMatchTitle?: string;
|
||||
gameNumber?: number;
|
||||
queueId: number;
|
||||
queueLabel: string;
|
||||
@@ -147,6 +154,7 @@ export interface RecentMatchView {
|
||||
championLevel: number;
|
||||
teamPosition: string;
|
||||
kills: number;
|
||||
largestMultiKill?: number;
|
||||
deaths: number;
|
||||
assists: number;
|
||||
kda: number;
|
||||
|
||||
@@ -3,7 +3,11 @@ import { BadRequestException, ValidationPipe } from '@nestjs/common';
|
||||
import { plainToInstance } from 'class-transformer';
|
||||
import { validateSync } from 'class-validator';
|
||||
import mongoose from 'mongoose';
|
||||
import { CreateMatchDto, JoinMatchDto } from './create-match.dto';
|
||||
import {
|
||||
CreateMatchDto,
|
||||
JoinMatchDto,
|
||||
UpdateMatchDto,
|
||||
} from './create-match.dto';
|
||||
|
||||
describe('CreateMatchDto game mode cutover', () => {
|
||||
it('rejects the removed live bracket mode', () => {
|
||||
@@ -61,3 +65,53 @@ describe('JoinMatchDto self-join boundary', () => {
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('Grand final format validation', () => {
|
||||
it('allows BO3 on creation and rejects an even game count on update', () => {
|
||||
const create = plainToInstance(CreateMatchDto, {
|
||||
title: 'Competition',
|
||||
scheduledAt: '2026-07-13T10:00:00.000Z',
|
||||
gameMode: 'double-elimination',
|
||||
doubleEliminationGrandFinalGameCount: 3,
|
||||
});
|
||||
expect(validateSync(create)).toEqual([]);
|
||||
const update = plainToInstance(UpdateMatchDto, {
|
||||
doubleEliminationGrandFinalGameCount: 2,
|
||||
});
|
||||
expect(validateSync(update)).toEqual([
|
||||
expect.objectContaining({
|
||||
property: 'doubleEliminationGrandFinalGameCount',
|
||||
}),
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Match event type validation', () => {
|
||||
it.each(['inhouse', 'tournament', undefined])(
|
||||
'accepts %s in create and update requests',
|
||||
(eventType) => {
|
||||
expect(
|
||||
validateSync(
|
||||
plainToInstance(CreateMatchDto, {
|
||||
title: 'Competition',
|
||||
scheduledAt: '2026-07-13T10:00:00.000Z',
|
||||
eventType,
|
||||
}),
|
||||
),
|
||||
).toEqual([]);
|
||||
expect(
|
||||
validateSync(plainToInstance(UpdateMatchDto, { eventType })),
|
||||
).toEqual([]);
|
||||
},
|
||||
);
|
||||
|
||||
it.each(['double-elimination', null])(
|
||||
'rejects %s as an event type',
|
||||
(eventType) => {
|
||||
const dto = plainToInstance(UpdateMatchDto, { eventType });
|
||||
expect(validateSync(dto)).toEqual([
|
||||
expect.objectContaining({ property: 'eventType' }),
|
||||
]);
|
||||
},
|
||||
);
|
||||
});
|
||||
@@ -1,3 +1,4 @@
|
||||
import type { GrandFinalGameCount, MatchEventType } from '@lolympus/contracts';
|
||||
import { Type } from 'class-transformer';
|
||||
import {
|
||||
ArrayMaxSize,
|
||||
@@ -14,11 +15,12 @@ import {
|
||||
MaxLength,
|
||||
Min,
|
||||
MinLength,
|
||||
ValidateIf,
|
||||
ValidateNested,
|
||||
ValidationArguments,
|
||||
ValidationOptions,
|
||||
} from 'class-validator';
|
||||
import { POSITIONS } from '../../global/database/schema';
|
||||
import { MATCH_EVENT_TYPES, POSITIONS } from '../../global/database/schema';
|
||||
import type { MatchGameMode, Position } from '../../global/database/schema';
|
||||
|
||||
const LIVE_MATCH_GAME_MODES = [
|
||||
@@ -82,6 +84,10 @@ export class CreateMatchDto {
|
||||
@MaxLength(128)
|
||||
title!: string;
|
||||
|
||||
@ValidateIf((_object, value) => value !== undefined)
|
||||
@IsIn(MATCH_EVENT_TYPES)
|
||||
eventType?: MatchEventType;
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(2048)
|
||||
@@ -119,6 +125,10 @@ export class CreateMatchDto {
|
||||
@IsBoolean()
|
||||
doubleEliminationResetFinalEnabled?: boolean;
|
||||
|
||||
@IsOptional()
|
||||
@IsIn([1, 3, 5])
|
||||
doubleEliminationGrandFinalGameCount?: GrandFinalGameCount;
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@IsString({ each: true })
|
||||
@@ -145,6 +155,10 @@ export class UpdateMatchDto {
|
||||
@MaxLength(128)
|
||||
title?: string;
|
||||
|
||||
@ValidateIf((_object, value) => value !== undefined)
|
||||
@IsIn(MATCH_EVENT_TYPES)
|
||||
eventType?: MatchEventType;
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(2048)
|
||||
@@ -183,6 +197,10 @@ export class UpdateMatchDto {
|
||||
@IsBoolean()
|
||||
doubleEliminationResetFinalEnabled?: boolean;
|
||||
|
||||
@IsOptional()
|
||||
@IsIn([1, 3, 5])
|
||||
doubleEliminationGrandFinalGameCount?: GrandFinalGameCount;
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@IsString({ each: true })
|
||||
|
||||
@@ -0,0 +1,168 @@
|
||||
import mongoose from 'mongoose';
|
||||
import {
|
||||
summarizeMatchHistoryResult,
|
||||
type HistoryCompetition,
|
||||
} from './match-history-result';
|
||||
|
||||
const firstId = new mongoose.Types.ObjectId();
|
||||
const secondId = new mongoose.Types.ObjectId();
|
||||
const thirdId = new mongoose.Types.ObjectId();
|
||||
const teams = [
|
||||
{
|
||||
teamId: firstId,
|
||||
name: '첫 팀',
|
||||
displayOrder: 1,
|
||||
seedNumber: 1,
|
||||
members: [],
|
||||
},
|
||||
{
|
||||
teamId: secondId,
|
||||
name: '둘째 팀',
|
||||
displayOrder: 2,
|
||||
seedNumber: 2,
|
||||
members: [],
|
||||
},
|
||||
{
|
||||
teamId: thirdId,
|
||||
name: '셋째 팀',
|
||||
displayOrder: 3,
|
||||
seedNumber: 3,
|
||||
members: [],
|
||||
},
|
||||
];
|
||||
const finishedMatch = {
|
||||
status: 'finished' as const,
|
||||
competitionId: new mongoose.Types.ObjectId(),
|
||||
teams: [],
|
||||
};
|
||||
const singleSeries = {
|
||||
status: 'completed',
|
||||
entries: [
|
||||
{ teamId: secondId.toString(), gameWins: 2 },
|
||||
{ teamId: firstId.toString(), gameWins: 1 },
|
||||
],
|
||||
outcome: { type: 'played', winnerTeamId: secondId.toString() },
|
||||
};
|
||||
|
||||
describe('summarizeMatchHistoryResult', () => {
|
||||
it('shows played scores only for one completed series between two teams', () => {
|
||||
const competition: HistoryCompetition = {
|
||||
teams: teams.slice(0, 2),
|
||||
projection: {
|
||||
series: [singleSeries],
|
||||
outcome: { type: 'paired-series' },
|
||||
},
|
||||
};
|
||||
|
||||
expect(summarizeMatchHistoryResult(finishedMatch, competition)).toEqual({
|
||||
type: 'score',
|
||||
teamAWins: 2,
|
||||
teamBWins: 1,
|
||||
teamAName: '둘째 팀',
|
||||
teamBName: '첫 팀',
|
||||
winnerTeamName: '둘째 팀',
|
||||
});
|
||||
expect(
|
||||
summarizeMatchHistoryResult(
|
||||
{ ...finishedMatch, status: 'in-progress' },
|
||||
competition,
|
||||
),
|
||||
).toBeUndefined();
|
||||
expect(
|
||||
summarizeMatchHistoryResult(finishedMatch, {
|
||||
...competition,
|
||||
projection: {
|
||||
...competition.projection,
|
||||
series: [singleSeries, singleSeries],
|
||||
},
|
||||
}),
|
||||
).toBeUndefined();
|
||||
});
|
||||
|
||||
it('shows adjudication without a score even if some games were played', () => {
|
||||
expect(
|
||||
summarizeMatchHistoryResult(finishedMatch, {
|
||||
teams: teams.slice(0, 2),
|
||||
projection: {
|
||||
series: [
|
||||
{
|
||||
...singleSeries,
|
||||
outcome: { ...singleSeries.outcome, type: 'forfeit' },
|
||||
},
|
||||
],
|
||||
outcome: { type: 'paired-series' },
|
||||
},
|
||||
}),
|
||||
).toEqual({
|
||||
type: 'decision',
|
||||
decision: 'forfeit',
|
||||
winnerTeamName: '둘째 팀',
|
||||
});
|
||||
});
|
||||
|
||||
it('uses the tournament winner or joint leaders instead of a series score', () => {
|
||||
expect(
|
||||
summarizeMatchHistoryResult(finishedMatch, {
|
||||
teams,
|
||||
projection: {
|
||||
series: [singleSeries],
|
||||
outcome: {
|
||||
type: 'double-elimination',
|
||||
championTeamId: thirdId.toString(),
|
||||
},
|
||||
},
|
||||
}),
|
||||
).toEqual({ type: 'winners', teamNames: ['셋째 팀'] });
|
||||
expect(
|
||||
summarizeMatchHistoryResult(finishedMatch, {
|
||||
teams,
|
||||
projection: {
|
||||
series: [singleSeries],
|
||||
outcome: {
|
||||
type: 'round-robin',
|
||||
leaderTeamIds: [firstId.toString(), secondId.toString()],
|
||||
},
|
||||
},
|
||||
}),
|
||||
).toEqual({ type: 'winners', teamNames: ['첫 팀', '둘째 팀'] });
|
||||
});
|
||||
|
||||
it('uses collected games for legacy two-team records without a Competition', () => {
|
||||
const match = {
|
||||
status: 'finished' as const,
|
||||
teams: [
|
||||
{ teamIndex: 2, name: '둘째 팀', members: [] },
|
||||
{ teamIndex: 1, name: '첫 팀', members: [] },
|
||||
],
|
||||
result: {
|
||||
winnerTeamIndex: 2,
|
||||
riotMatchIds: ['KR_1'],
|
||||
games: [
|
||||
{
|
||||
gameNumber: 1,
|
||||
riotMatchId: 'KR_1',
|
||||
blueTeamIndex: 1,
|
||||
redTeamIndex: 2,
|
||||
winnerTeamIndex: 2,
|
||||
winnerSide: 'red' as const,
|
||||
gameCreation: 0,
|
||||
gameDuration: 1800,
|
||||
participants: [],
|
||||
},
|
||||
],
|
||||
},
|
||||
};
|
||||
|
||||
expect(summarizeMatchHistoryResult(match)).toEqual({
|
||||
type: 'score',
|
||||
teamAWins: 0,
|
||||
teamBWins: 1,
|
||||
teamAName: '첫 팀',
|
||||
teamBName: '둘째 팀',
|
||||
winnerTeamName: '둘째 팀',
|
||||
});
|
||||
expect(
|
||||
summarizeMatchHistoryResult({ ...match, competitionId: firstId }),
|
||||
).toBeUndefined();
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,121 @@
|
||||
import type { MatchHistoryResult } from '@lolympus/contracts';
|
||||
import type { Competition } from '../competition/competition.schema';
|
||||
import type { CompetitionProjection } from '../competition/domain/competition-projector';
|
||||
import type { Match } from '../global/database/schema';
|
||||
|
||||
type HistoryMatch = Pick<
|
||||
Match,
|
||||
'status' | 'competitionId' | 'teams' | 'result' | 'doubleElimination'
|
||||
>;
|
||||
export type HistoryCompetition = Pick<Competition, 'projection' | 'teams'>;
|
||||
|
||||
export function summarizeMatchHistoryResult(
|
||||
match: HistoryMatch,
|
||||
competition?: HistoryCompetition,
|
||||
): MatchHistoryResult | undefined {
|
||||
if (match.status !== 'finished') return;
|
||||
if (!match.competitionId) return summarizeLegacyResult(match);
|
||||
if (!competition) return;
|
||||
|
||||
const { series, outcome } = competition.projection as Pick<
|
||||
CompetitionProjection,
|
||||
'series' | 'outcome'
|
||||
>;
|
||||
if (!outcome) return;
|
||||
|
||||
const teamName = (teamId: string | null) => {
|
||||
const team = competition.teams.find(
|
||||
(item) => String(item.teamId) === teamId,
|
||||
);
|
||||
return team && (team.name.trim() || `${team.displayOrder}팀`);
|
||||
};
|
||||
|
||||
const singleSeries = series?.length === 1 ? series[0] : undefined;
|
||||
if (competition.teams.length === 2 && singleSeries?.status === 'completed') {
|
||||
const decision = singleSeries.outcome;
|
||||
const winnerTeamName =
|
||||
decision.type === 'draw' ? undefined : teamName(decision.winnerTeamId);
|
||||
if (
|
||||
decision.type === 'played' ||
|
||||
(decision.type === 'draw' && decision.basis.type === 'played')
|
||||
) {
|
||||
const [teamA, teamB] = singleSeries.entries;
|
||||
return {
|
||||
type: 'score',
|
||||
teamAWins: teamA.gameWins,
|
||||
teamBWins: teamB.gameWins,
|
||||
teamAName: teamName(teamA.teamId),
|
||||
teamBName: teamName(teamB.teamId),
|
||||
winnerTeamName,
|
||||
};
|
||||
}
|
||||
return { type: 'decision', decision: decision.type, winnerTeamName };
|
||||
}
|
||||
|
||||
const winnerIds =
|
||||
outcome.type === 'double-elimination'
|
||||
? [outcome.championTeamId]
|
||||
: outcome.type === 'round-robin'
|
||||
? outcome.leaderTeamIds
|
||||
: [];
|
||||
const teamNames = winnerIds.map(teamName);
|
||||
if (teamNames.length > 0 && teamNames.every((name) => name !== undefined)) {
|
||||
return { type: 'winners', teamNames };
|
||||
}
|
||||
}
|
||||
|
||||
function summarizeLegacyResult(
|
||||
match: HistoryMatch,
|
||||
): MatchHistoryResult | undefined {
|
||||
const placement = match.doubleElimination?.placements.firstTeamIndex;
|
||||
if (placement !== undefined) {
|
||||
const champion = match.teams.find((team) => team.teamIndex === placement);
|
||||
if (champion) {
|
||||
return {
|
||||
type: 'winners',
|
||||
teamNames: [champion.name.trim() || `${placement}팀`],
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
if (match.teams.length !== 2 || !match.result?.games.length) return;
|
||||
const [teamA, teamB] = [...match.teams].sort(
|
||||
(a, b) => a.teamIndex - b.teamIndex,
|
||||
);
|
||||
const { games } = match.result;
|
||||
const teamIndices = new Set([teamA.teamIndex, teamB.teamIndex]);
|
||||
if (
|
||||
games.some(
|
||||
({ blueTeamIndex, redTeamIndex }) =>
|
||||
blueTeamIndex === redTeamIndex ||
|
||||
!teamIndices.has(blueTeamIndex) ||
|
||||
!teamIndices.has(redTeamIndex),
|
||||
)
|
||||
)
|
||||
return;
|
||||
const teamAWins = games.filter(
|
||||
(game) => game.winnerTeamIndex === teamA.teamIndex,
|
||||
).length;
|
||||
const teamBWins = games.filter(
|
||||
(game) => game.winnerTeamIndex === teamB.teamIndex,
|
||||
).length;
|
||||
if (teamAWins + teamBWins !== games.length) return;
|
||||
const winner = match.teams.find(
|
||||
(team) => team.teamIndex === match.result?.winnerTeamIndex,
|
||||
);
|
||||
if (
|
||||
winner &&
|
||||
(teamAWins === teamBWins ||
|
||||
winner.teamIndex !==
|
||||
(teamAWins > teamBWins ? teamA.teamIndex : teamB.teamIndex))
|
||||
)
|
||||
return;
|
||||
return {
|
||||
type: 'score',
|
||||
teamAWins,
|
||||
teamBWins,
|
||||
teamAName: teamA.name.trim() || `${teamA.teamIndex}팀`,
|
||||
teamBName: teamB.name.trim() || `${teamB.teamIndex}팀`,
|
||||
winnerTeamName: winner && (winner.name.trim() || `${winner.teamIndex}팀`),
|
||||
};
|
||||
}
|
||||
@@ -75,6 +75,7 @@ describe('presentPublicMatch', () => {
|
||||
communityId: oid('2').toString(),
|
||||
competitionId: oid('3').toString(),
|
||||
title: '내전',
|
||||
eventType: 'inhouse',
|
||||
doubleEliminationResetFinalEnabled: false,
|
||||
scheduledAt: '2026-07-12T10:00:00.000Z',
|
||||
participants: [
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
import type { MatchDetailResponse, MatchTierView } from '@lolympus/contracts';
|
||||
import type {
|
||||
MatchDetailResponse,
|
||||
MatchEventType,
|
||||
MatchTierView,
|
||||
} from '@lolympus/contracts';
|
||||
import type {
|
||||
MatchGameMode,
|
||||
MatchStatus,
|
||||
@@ -13,6 +17,7 @@ interface PublicMatchSource {
|
||||
competitionId?: IdLike;
|
||||
shortCode?: string;
|
||||
title: string;
|
||||
eventType?: MatchEventType;
|
||||
description: string;
|
||||
mapId: number;
|
||||
status: MatchStatus;
|
||||
@@ -21,7 +26,10 @@ interface PublicMatchSource {
|
||||
gameCount: number;
|
||||
gameMode: MatchGameMode;
|
||||
roundRobinMaxRounds?: number;
|
||||
doubleElimination?: { resetFinalEnabled?: boolean };
|
||||
doubleElimination?: {
|
||||
resetFinalEnabled?: boolean;
|
||||
grandFinalGameCount?: 1 | 3 | 5;
|
||||
};
|
||||
hostUserId?: IdLike;
|
||||
participants: Array<{
|
||||
userId: IdLike;
|
||||
@@ -67,6 +75,7 @@ export function presentPublicMatch(
|
||||
: {}),
|
||||
...(source.shortCode ? { shortCode: source.shortCode } : {}),
|
||||
title: source.title,
|
||||
eventType: source.eventType ?? 'inhouse',
|
||||
description: source.description,
|
||||
mapId: source.mapId,
|
||||
status: source.status,
|
||||
@@ -81,6 +90,8 @@ export function presentPublicMatch(
|
||||
? {
|
||||
doubleEliminationResetFinalEnabled:
|
||||
source.doubleElimination?.resetFinalEnabled ?? false,
|
||||
doubleEliminationGrandFinalGameCount:
|
||||
source.doubleElimination?.grandFinalGameCount ?? 1,
|
||||
}
|
||||
: {}),
|
||||
...(source.hostUserId
|
||||
|
||||
@@ -1,12 +1,89 @@
|
||||
import 'reflect-metadata';
|
||||
import { GUARDS_METADATA } from '@nestjs/common/constants';
|
||||
import mongoose from 'mongoose';
|
||||
import { plainToInstance } from 'class-transformer';
|
||||
import { METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED } from '../auth/allow-public-access.decorator';
|
||||
import { ROLES_KEY } from '../auth/roles.decorator';
|
||||
import { RolesGuard } from '../auth/roles.guard';
|
||||
import type { UserDocument } from '../global/database/schema';
|
||||
import { UpdateMatchDto } from './dto/create-match.dto';
|
||||
import { MatchController } from './match.controller';
|
||||
|
||||
describe('MatchController history summaries', () => {
|
||||
it('only attaches the page results when requested', async () => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const match = { _id: new mongoose.Types.ObjectId() };
|
||||
const summary = { _id: match._id.toString() };
|
||||
const historyResult = { type: 'score', teamAWins: 2, teamBWins: 1 };
|
||||
const matchService = {
|
||||
listPage: jest
|
||||
.fn()
|
||||
.mockResolvedValue({ matches: [match], total: 1, page: 1, limit: 10 }),
|
||||
serialize: jest.fn().mockReturnValue(summary),
|
||||
getHistoryResults: jest
|
||||
.fn()
|
||||
.mockResolvedValue(new Map([[summary._id, historyResult]])),
|
||||
};
|
||||
const controller = new MatchController(matchService as never);
|
||||
|
||||
await expect(
|
||||
controller.listMatches(undefined, communityId),
|
||||
).resolves.toMatchObject({
|
||||
matches: [summary],
|
||||
});
|
||||
expect(matchService.getHistoryResults).not.toHaveBeenCalled();
|
||||
|
||||
await expect(
|
||||
controller.listMatches(
|
||||
undefined,
|
||||
communityId,
|
||||
undefined,
|
||||
'10',
|
||||
'1',
|
||||
undefined,
|
||||
undefined,
|
||||
undefined,
|
||||
'desc',
|
||||
'true',
|
||||
'tournament',
|
||||
),
|
||||
).resolves.toMatchObject({ matches: [{ ...summary, historyResult }] });
|
||||
expect(matchService.listPage).toHaveBeenLastCalledWith(
|
||||
expect.objectContaining({ eventType: 'tournament' }),
|
||||
);
|
||||
expect(matchService.getHistoryResults).toHaveBeenCalledWith(communityId, [
|
||||
match,
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
describe('MatchController partial updates', () => {
|
||||
it('passes only supplied fields when reclassifying a match', async () => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const user = { _id: new mongoose.Types.ObjectId(), communityId };
|
||||
const matchService = {
|
||||
update: jest.fn().mockResolvedValue({ participants: [] }),
|
||||
serialize: jest.fn(),
|
||||
};
|
||||
const controller = new MatchController(matchService as never);
|
||||
const body = plainToInstance(UpdateMatchDto, { eventType: 'tournament' });
|
||||
|
||||
await controller.updateMatch(
|
||||
user as UserDocument,
|
||||
communityId,
|
||||
matchId,
|
||||
body,
|
||||
);
|
||||
|
||||
expect(matchService.update).toHaveBeenCalledWith({
|
||||
communityId,
|
||||
matchId,
|
||||
patch: { eventType: 'tournament' },
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('MatchController participant access', () => {
|
||||
function createController() {
|
||||
const joinedMatch = { _id: new mongoose.Types.ObjectId() };
|
||||
|
||||
@@ -1,6 +1,9 @@
|
||||
import type {
|
||||
HallOfFameResponse,
|
||||
MatchDetailResponse,
|
||||
MatchEventType,
|
||||
MatchListResponse,
|
||||
MatchListView,
|
||||
} from '@lolympus/contracts';
|
||||
import {
|
||||
BadRequestException,
|
||||
@@ -16,6 +19,7 @@ import {
|
||||
Query,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import { isISO8601 } from 'class-validator';
|
||||
import mongoose from 'mongoose';
|
||||
import { AllowPublicAccess } from '../auth/allow-public-access.decorator';
|
||||
import { CurrentUser } from '../auth/current-user.decorator';
|
||||
@@ -23,6 +27,7 @@ import { Roles } from '../auth/roles.decorator';
|
||||
import { RolesGuard } from '../auth/roles.guard';
|
||||
import { ParseObjectIdPipe } from '../common/parse-object-id.pipe';
|
||||
import type { MatchStatus, UserDocument } from '../global/database/schema';
|
||||
import { MATCH_EVENT_TYPES } from '../global/database/schema';
|
||||
import {
|
||||
AddParticipantDto,
|
||||
CreateMatchDto,
|
||||
@@ -51,6 +56,7 @@ export class MatchController {
|
||||
hostUserId: currentUser._id,
|
||||
data: {
|
||||
title: body.title,
|
||||
eventType: body.eventType,
|
||||
description: body.description ?? '',
|
||||
mapId: body.mapId ?? 11,
|
||||
scheduledAt: body.scheduledAt,
|
||||
@@ -60,6 +66,8 @@ export class MatchController {
|
||||
roundRobinMaxRounds: body.roundRobinMaxRounds,
|
||||
doubleEliminationResetFinalEnabled:
|
||||
body.doubleEliminationResetFinalEnabled,
|
||||
doubleEliminationGrandFinalGameCount:
|
||||
body.doubleEliminationGrandFinalGameCount,
|
||||
prizes: body.prizes ?? [],
|
||||
notices: body.notices ?? [],
|
||||
schedule: body.schedule ?? [],
|
||||
@@ -82,21 +90,63 @@ export class MatchController {
|
||||
@Query('scheduledFrom') scheduledFrom?: string,
|
||||
@Query('scheduledTo') scheduledTo?: string,
|
||||
@Query('sort') sort?: 'asc' | 'desc',
|
||||
@Query('includeResults') includeResults?: string,
|
||||
@Query('eventType') eventType?: MatchEventType,
|
||||
@Query('view') view?: MatchListView,
|
||||
@Query('asOf') asOf?: string,
|
||||
): Promise<MatchListResponse> {
|
||||
if (eventType !== undefined && !MATCH_EVENT_TYPES.includes(eventType)) {
|
||||
throw new BadRequestException('Invalid eventType.');
|
||||
}
|
||||
if (
|
||||
view !== undefined &&
|
||||
view !== 'active' &&
|
||||
view !== 'upcoming' &&
|
||||
view !== 'history'
|
||||
) {
|
||||
throw new BadRequestException('Invalid view.');
|
||||
}
|
||||
if (
|
||||
view &&
|
||||
(status !== undefined ||
|
||||
scheduledFrom !== undefined ||
|
||||
scheduledTo !== undefined)
|
||||
) {
|
||||
throw new BadRequestException(
|
||||
'view cannot be combined with status or schedule filters.',
|
||||
);
|
||||
}
|
||||
const asOfDate = this.toOptionalDate(asOf);
|
||||
if (
|
||||
asOf !== undefined &&
|
||||
(typeof asOf !== 'string' ||
|
||||
!isISO8601(asOf, { strict: true, strictSeparator: true }) ||
|
||||
!asOfDate)
|
||||
)
|
||||
throw new BadRequestException('Invalid asOf.');
|
||||
const result = await this.matchService.listPage({
|
||||
communityId,
|
||||
status,
|
||||
eventType,
|
||||
limit: this.toOptionalNumber(limit),
|
||||
page: this.toOptionalNumber(page),
|
||||
offset: this.toOptionalNumber(offset),
|
||||
scheduledFrom: this.toOptionalDate(scheduledFrom),
|
||||
scheduledTo: this.toOptionalDate(scheduledTo),
|
||||
sort,
|
||||
...(view ? { view, asOf: asOfDate } : {}),
|
||||
});
|
||||
const historyResults =
|
||||
includeResults === 'true'
|
||||
? await this.matchService.getHistoryResults(communityId, result.matches)
|
||||
: undefined;
|
||||
const eventProgress = view
|
||||
? await this.matchService.getEventProgress(result.matches)
|
||||
: undefined;
|
||||
return {
|
||||
...result,
|
||||
matches: result.matches.map((match) =>
|
||||
this.matchService.serialize(match, {
|
||||
matches: result.matches.map((match) => {
|
||||
const summary = this.matchService.serialize(match, {
|
||||
...(currentUser
|
||||
? {
|
||||
joined: match.participants.some((participant) =>
|
||||
@@ -104,11 +154,28 @@ export class MatchController {
|
||||
),
|
||||
}
|
||||
: {}),
|
||||
}),
|
||||
),
|
||||
});
|
||||
const historyResult = historyResults?.get(summary._id);
|
||||
return {
|
||||
...summary,
|
||||
...(historyResult ? { historyResult } : {}),
|
||||
...(eventProgress
|
||||
? { eventProgress: eventProgress.get(summary._id) }
|
||||
: {}),
|
||||
};
|
||||
}),
|
||||
};
|
||||
}
|
||||
|
||||
@Get('hall-of-fame')
|
||||
@AllowPublicAccess()
|
||||
public getHallOfFame(
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
): Promise<HallOfFameResponse> {
|
||||
return this.matchService.getHallOfFame(communityId);
|
||||
}
|
||||
|
||||
@Get(':matchId')
|
||||
@AllowPublicAccess()
|
||||
public async getMatch(
|
||||
@@ -118,7 +185,7 @@ export class MatchController {
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
): Promise<MatchDetailResponse> {
|
||||
const match = await this.matchService.getById(matchId, communityId);
|
||||
return this.matchService.serialize(match, {
|
||||
const summary = this.matchService.serialize(match, {
|
||||
joined: Boolean(
|
||||
currentUser &&
|
||||
match.participants.some((participant) =>
|
||||
@@ -126,6 +193,8 @@ export class MatchController {
|
||||
),
|
||||
),
|
||||
});
|
||||
const progress = await this.matchService.getEventProgress([match]);
|
||||
return { ...summary, eventProgress: progress.get(summary._id) };
|
||||
}
|
||||
|
||||
@Patch(':matchId')
|
||||
@@ -142,7 +211,7 @@ export class MatchController {
|
||||
const match = await this.matchService.update({
|
||||
matchId,
|
||||
communityId,
|
||||
patch: body,
|
||||
patch: mongoose.omitUndefined({ ...body }),
|
||||
});
|
||||
return this.matchService.serialize(match, {
|
||||
joined: match.participants.some((participant) =>
|
||||
@@ -241,6 +310,23 @@ export class MatchController {
|
||||
}
|
||||
|
||||
// 관리자 전용 — 참가자 강제 제외.
|
||||
@Delete(':matchId/participants')
|
||||
@Roles('admin', 'owner', 'member')
|
||||
@UseGuards(RolesGuard)
|
||||
public async cancelJoin(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
): Promise<MatchDetailResponse> {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
const match = await this.matchService.cancelJoin({
|
||||
matchId,
|
||||
userId: currentUser._id,
|
||||
});
|
||||
return this.matchService.serialize(match, { joined: false });
|
||||
}
|
||||
|
||||
@Delete(':matchId/participants/:userId')
|
||||
@Roles('admin', 'owner')
|
||||
@UseGuards(RolesGuard)
|
||||
|
||||
@@ -2,6 +2,104 @@ import mongoose from 'mongoose';
|
||||
import { MatchService } from './match.service';
|
||||
|
||||
describe('MatchService', () => {
|
||||
it('selects the official hall-of-fame roster by team ID when names repeat', async () => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const championId = new mongoose.Types.ObjectId();
|
||||
const captainUserId = new mongoose.Types.ObjectId();
|
||||
const MatchModel = {
|
||||
aggregate: jest.fn().mockReturnValue({
|
||||
exec: async () => [
|
||||
{
|
||||
_id: matchId,
|
||||
title: '멸망전',
|
||||
official: [
|
||||
{
|
||||
projection: {
|
||||
outcome: {
|
||||
type: 'double-elimination',
|
||||
championTeamId: championId.toString(),
|
||||
},
|
||||
},
|
||||
teams: [
|
||||
{
|
||||
teamId: new mongoose.Types.ObjectId(),
|
||||
name: '별무리',
|
||||
members: [],
|
||||
},
|
||||
{
|
||||
teamId: championId,
|
||||
name: '별무리',
|
||||
captainUserId,
|
||||
members: [
|
||||
{
|
||||
userId: captainUserId,
|
||||
assignedPosition: 'TOP',
|
||||
gameName: '별빛',
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
}),
|
||||
};
|
||||
const CompetitionModel = { collection: { name: 'competition' } };
|
||||
const service = new MatchService(
|
||||
{
|
||||
getModel: async (name: string) =>
|
||||
name === 'match' ? MatchModel : CompetitionModel,
|
||||
} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
|
||||
await expect(service.getHallOfFame(communityId)).resolves.toMatchObject({
|
||||
match: { id: matchId.toString(), title: '멸망전' },
|
||||
teams: [
|
||||
{
|
||||
name: '별무리',
|
||||
captainUserId: captainUserId.toString(),
|
||||
members: [
|
||||
{
|
||||
userId: captainUserId.toString(),
|
||||
position: 'TOP',
|
||||
gameName: '별빛',
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
});
|
||||
const [pipeline] = MatchModel.aggregate.mock.calls[0];
|
||||
expect(pipeline[0]).toMatchObject({
|
||||
$match: {
|
||||
communityId,
|
||||
eventType: 'tournament',
|
||||
$or: [
|
||||
{ competitionId: { $type: 'objectId' } },
|
||||
expect.objectContaining({ competitionId: null, status: 'finished' }),
|
||||
],
|
||||
},
|
||||
});
|
||||
expect(pipeline[0].$match).not.toHaveProperty('status');
|
||||
expect(pipeline[2]).toMatchObject({
|
||||
$lookup: {
|
||||
pipeline: [
|
||||
expect.objectContaining({
|
||||
$match: expect.objectContaining({
|
||||
communityId,
|
||||
phase: 'completed',
|
||||
}),
|
||||
}),
|
||||
expect.anything(),
|
||||
],
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
function createServiceWithCreateModels() {
|
||||
const createdPayloads: Record<string, unknown>[] = [];
|
||||
const MatchModel = {
|
||||
@@ -195,7 +293,7 @@ describe('MatchService', () => {
|
||||
|
||||
expect(MatchModel.find).toHaveBeenCalledWith({ communityId });
|
||||
expect(MatchModel.countDocuments).toHaveBeenCalledWith({ communityId });
|
||||
expect(sort).toHaveBeenCalledWith({ scheduledAt: -1 });
|
||||
expect(sort).toHaveBeenCalledWith({ scheduledAt: -1, _id: -1 });
|
||||
expect(skip).toHaveBeenCalledWith(5);
|
||||
expect(limit).toHaveBeenCalledWith(5);
|
||||
expect(page).toEqual({
|
||||
@@ -254,7 +352,7 @@ describe('MatchService', () => {
|
||||
communityId,
|
||||
scheduledAt: { $gte: scheduledFrom },
|
||||
});
|
||||
expect(sort).toHaveBeenCalledWith({ scheduledAt: 1 });
|
||||
expect(sort).toHaveBeenCalledWith({ scheduledAt: 1, _id: 1 });
|
||||
});
|
||||
|
||||
it('filters past matches and keeps newest first for history sections', async () => {
|
||||
@@ -277,9 +375,31 @@ describe('MatchService', () => {
|
||||
communityId,
|
||||
scheduledAt: { $lt: scheduledTo },
|
||||
});
|
||||
expect(sort).toHaveBeenCalledWith({ scheduledAt: -1 });
|
||||
expect(sort).toHaveBeenCalledWith({ scheduledAt: -1, _id: -1 });
|
||||
});
|
||||
|
||||
it.each([
|
||||
['inhouse', { $in: ['inhouse', null] }],
|
||||
['tournament', 'tournament'],
|
||||
] as const)(
|
||||
'filters both results and pagination totals for %s events',
|
||||
async (eventType, expectedEventType) => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const scheduledTo = new Date('2026-06-08T12:00:00.000Z');
|
||||
const { service, MatchModel } = createServiceWithListModel();
|
||||
|
||||
await service.listPage({ communityId, scheduledTo, eventType });
|
||||
|
||||
const expectedFilter = {
|
||||
communityId,
|
||||
scheduledAt: { $lt: scheduledTo },
|
||||
eventType: expectedEventType,
|
||||
};
|
||||
expect(MatchModel.find).toHaveBeenCalledWith(expectedFilter);
|
||||
expect(MatchModel.countDocuments).toHaveBeenCalledWith(expectedFilter);
|
||||
},
|
||||
);
|
||||
|
||||
it('uses saved user preferences when joining without explicit positions', async () => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const userId = new mongoose.Types.ObjectId();
|
||||
@@ -531,6 +651,7 @@ describe('MatchService', () => {
|
||||
gameCount: 5,
|
||||
gameMode: 'double-elimination',
|
||||
doubleEliminationResetFinalEnabled: true,
|
||||
doubleEliminationGrandFinalGameCount: 3,
|
||||
},
|
||||
});
|
||||
|
||||
@@ -543,6 +664,7 @@ describe('MatchService', () => {
|
||||
doubleElimination: {
|
||||
teamCount: 4,
|
||||
resetFinalEnabled: true,
|
||||
grandFinalGameCount: 3,
|
||||
resetFinalCreated: false,
|
||||
seeds: [],
|
||||
bracketMatches: [],
|
||||
@@ -635,6 +757,26 @@ describe('MatchService', () => {
|
||||
expect(match.set).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('allows reclassifying a finished match without altering its competition settings', async () => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const match = {
|
||||
communityId,
|
||||
status: 'finished',
|
||||
set: jest.fn(),
|
||||
save: jest.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
const { service } = createService(match);
|
||||
|
||||
await service.update({
|
||||
matchId: new mongoose.Types.ObjectId(),
|
||||
communityId,
|
||||
patch: { eventType: 'tournament' },
|
||||
});
|
||||
|
||||
expect(match.set).toHaveBeenCalledWith({ eventType: 'tournament' });
|
||||
expect(match.save).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('rejects game count changes after recruiting', async () => {
|
||||
const communityId = new mongoose.Types.ObjectId();
|
||||
const match = {
|
||||
|
||||
@@ -1,3 +1,12 @@
|
||||
import type {
|
||||
HallOfFameResponse,
|
||||
MatchEventStage,
|
||||
MatchEventType,
|
||||
MatchHistoryResult,
|
||||
MatchId,
|
||||
MatchListView,
|
||||
UserId,
|
||||
} from '@lolympus/contracts';
|
||||
import {
|
||||
BadRequestException,
|
||||
ConflictException,
|
||||
@@ -8,6 +17,7 @@ import {
|
||||
import mongoose from 'mongoose';
|
||||
import { MatchStatsService } from '../community-stats/match-stats.service';
|
||||
import { CommunityStatsService } from '../community-stats/community-stats.service';
|
||||
import type { CompetitionProjection } from '../competition/domain/competition-projector';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import {
|
||||
Match,
|
||||
@@ -20,6 +30,10 @@ import {
|
||||
} from '../global/database/schema';
|
||||
import { DEFAULT_TOURNAMENT_GAME_COUNT } from '../tournament-code/tournament-code.constants';
|
||||
import { TournamentCodeService } from '../tournament-code/tournament-code.service';
|
||||
import {
|
||||
summarizeMatchHistoryResult,
|
||||
type HistoryCompetition,
|
||||
} from './match-history-result';
|
||||
import { presentPublicMatch } from './match-public.presenter';
|
||||
|
||||
const MATCH_SHORT_CODE_ALPHABET = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
|
||||
@@ -32,6 +46,7 @@ const DEFAULT_DOUBLE_ELIMINATION_SERIES_GAME_COUNT = 3;
|
||||
|
||||
interface DoubleEliminationConfigInput {
|
||||
doubleEliminationResetFinalEnabled?: boolean;
|
||||
doubleEliminationGrandFinalGameCount?: 1 | 3 | 5;
|
||||
}
|
||||
|
||||
interface CreateMatchParams {
|
||||
@@ -51,10 +66,13 @@ interface UpdateMatchParams {
|
||||
interface ListMatchesQuery {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
status?: MatchStatus;
|
||||
eventType?: MatchEventType;
|
||||
limit?: number;
|
||||
scheduledFrom?: Date;
|
||||
scheduledTo?: Date;
|
||||
sort?: 'asc' | 'desc';
|
||||
view?: MatchListView;
|
||||
asOf?: Date;
|
||||
}
|
||||
|
||||
interface ListMatchesPageQuery extends ListMatchesQuery {
|
||||
@@ -65,10 +83,15 @@ interface ListMatchesPageQuery extends ListMatchesQuery {
|
||||
interface MatchListFilter {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
status?: MatchStatus;
|
||||
eventType?: MatchEventType | { $in: (MatchEventType | null)[] };
|
||||
scheduledAt?: {
|
||||
$gte?: Date;
|
||||
$lt?: Date;
|
||||
};
|
||||
$or?: Array<{
|
||||
status: MatchStatus | { $in: MatchStatus[] };
|
||||
scheduledAt?: { $lt: Date };
|
||||
}>;
|
||||
}
|
||||
|
||||
interface JoinMatchParams {
|
||||
@@ -170,6 +193,244 @@ export class MatchService {
|
||||
};
|
||||
}
|
||||
|
||||
public async getHistoryResults(
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
matches: readonly MatchDocument[],
|
||||
): Promise<Map<string, MatchHistoryResult>> {
|
||||
const finished = matches.filter((match) => match.status === 'finished');
|
||||
const competitionIds = finished.flatMap((match) =>
|
||||
match.competitionId ? [match.competitionId] : [],
|
||||
);
|
||||
const competitions = new Map<string, HistoryCompetition>();
|
||||
if (competitionIds.length > 0) {
|
||||
const CompetitionModel =
|
||||
await this.connectionService.getModel('competition');
|
||||
const completed = await CompetitionModel.find({
|
||||
_id: { $in: competitionIds },
|
||||
communityId,
|
||||
phase: 'completed',
|
||||
})
|
||||
.select({
|
||||
matchId: 1,
|
||||
'teams.teamId': 1,
|
||||
'teams.name': 1,
|
||||
'teams.displayOrder': 1,
|
||||
'projection.outcome': 1,
|
||||
'projection.series': 1,
|
||||
})
|
||||
.lean()
|
||||
.exec();
|
||||
for (const competition of completed) {
|
||||
competitions.set(competition.matchId.toString(), competition);
|
||||
}
|
||||
}
|
||||
|
||||
const results = new Map<string, MatchHistoryResult>();
|
||||
for (const match of finished) {
|
||||
const id = match._id.toString();
|
||||
const result = summarizeMatchHistoryResult(match, competitions.get(id));
|
||||
if (result) results.set(id, result);
|
||||
}
|
||||
return results;
|
||||
}
|
||||
|
||||
public async getHallOfFame(
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
): Promise<HallOfFameResponse> {
|
||||
const [MatchModel, CompetitionModel] = await Promise.all([
|
||||
this.connectionService.getModel('match'),
|
||||
this.connectionService.getModel('competition'),
|
||||
]);
|
||||
const legacyChampion = {
|
||||
competitionId: null,
|
||||
status: 'finished',
|
||||
'doubleElimination.placements.firstTeamIndex': { $type: 'number' },
|
||||
};
|
||||
const [match] = await MatchModel.aggregate<
|
||||
Pick<Match, 'title' | 'teams' | 'participants' | 'doubleElimination'> & {
|
||||
_id: mongoose.Types.ObjectId;
|
||||
official: HistoryCompetition[];
|
||||
}
|
||||
>([
|
||||
{
|
||||
$match: {
|
||||
communityId,
|
||||
eventType: 'tournament',
|
||||
$or: [{ competitionId: { $type: 'objectId' } }, legacyChampion],
|
||||
},
|
||||
},
|
||||
{ $sort: { scheduledAt: -1, _id: -1 } },
|
||||
{
|
||||
$lookup: {
|
||||
from: CompetitionModel.collection.name,
|
||||
localField: 'competitionId',
|
||||
foreignField: '_id',
|
||||
let: { matchId: '$_id' },
|
||||
pipeline: [
|
||||
{
|
||||
$match: {
|
||||
communityId,
|
||||
phase: 'completed',
|
||||
$expr: { $eq: ['$matchId', '$$matchId'] },
|
||||
$or: [
|
||||
{ 'projection.outcome.type': 'double-elimination' },
|
||||
{
|
||||
'projection.outcome.type': 'round-robin',
|
||||
'projection.outcome.leaderTeamIds.0': { $exists: true },
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
{ $project: { teams: 1, 'projection.outcome': 1 } },
|
||||
],
|
||||
as: 'official',
|
||||
},
|
||||
},
|
||||
{
|
||||
$match: { $or: [{ 'official.0': { $exists: true } }, legacyChampion] },
|
||||
},
|
||||
{ $limit: 1 },
|
||||
{
|
||||
$project: {
|
||||
title: 1,
|
||||
teams: 1,
|
||||
participants: 1,
|
||||
doubleElimination: 1,
|
||||
official: 1,
|
||||
},
|
||||
},
|
||||
]).exec();
|
||||
if (!match) return { match: null, teams: [] };
|
||||
|
||||
const featuredMatch = {
|
||||
id: match._id.toString() as MatchId,
|
||||
title: match.title,
|
||||
};
|
||||
const [competition] = match.official;
|
||||
if (competition) {
|
||||
const { outcome } = competition.projection as Pick<
|
||||
CompetitionProjection,
|
||||
'outcome'
|
||||
>;
|
||||
const winnerIds =
|
||||
outcome?.type === 'double-elimination'
|
||||
? [outcome.championTeamId]
|
||||
: outcome?.type === 'round-robin'
|
||||
? outcome.leaderTeamIds
|
||||
: [];
|
||||
const teams = competition.teams
|
||||
.filter((team) => winnerIds.includes(team.teamId.toString()))
|
||||
.map((team) => ({
|
||||
name: team.name.trim() || `${team.displayOrder}팀`,
|
||||
captainUserId: team.captainUserId?.toString() as UserId | undefined,
|
||||
members: team.members.map((member) => ({
|
||||
userId: member.userId.toString() as UserId,
|
||||
position: POSITIONS.find(
|
||||
(position) => position === member.assignedPosition,
|
||||
),
|
||||
gameName: member.gameName,
|
||||
tagLine: member.tagLine,
|
||||
profileIconId: member.profileIconId,
|
||||
})),
|
||||
}));
|
||||
return { match: featuredMatch, teams };
|
||||
}
|
||||
|
||||
const placement = match.doubleElimination?.placements.firstTeamIndex;
|
||||
const champion =
|
||||
placement === undefined
|
||||
? undefined
|
||||
: match.teams.find((team) => team.teamIndex === placement);
|
||||
if (!champion) return { match: featuredMatch, teams: [] };
|
||||
const participants = new Map(
|
||||
match.participants.map((participant) => [
|
||||
participant.userId.toString(),
|
||||
participant,
|
||||
]),
|
||||
);
|
||||
return {
|
||||
match: featuredMatch,
|
||||
teams: [
|
||||
{
|
||||
name: champion.name.trim() || `${champion.teamIndex}팀`,
|
||||
captainUserId: champion.captainUserId?.toString() as
|
||||
| UserId
|
||||
| undefined,
|
||||
members: champion.members.map((member) => {
|
||||
const userId = member.userId.toString() as UserId;
|
||||
const participant = participants.get(userId);
|
||||
return {
|
||||
userId,
|
||||
position: member.assignedPosition,
|
||||
gameName: participant?.gameName,
|
||||
tagLine: participant?.tagLine,
|
||||
profileIconId: participant?.profileIconId,
|
||||
};
|
||||
}),
|
||||
},
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
public async getEventProgress(matches: readonly MatchDocument[]) {
|
||||
const teamBuilding = matches.filter(
|
||||
(match) => match.status === 'team-built',
|
||||
);
|
||||
const byMatchId = new Map<string, MatchEventStage>();
|
||||
if (teamBuilding.length > 0) {
|
||||
const AuctionModel = await this.connectionService.getModel('auction');
|
||||
const auctions = await AuctionModel.find({
|
||||
matchId: { $in: teamBuilding.map(({ _id }) => _id) },
|
||||
})
|
||||
.select({
|
||||
matchId: 1,
|
||||
phase: 1,
|
||||
auctionLifecycleId: 1,
|
||||
startupCompleted: 1,
|
||||
matchSideEffectStatus: 1,
|
||||
})
|
||||
.lean()
|
||||
.exec();
|
||||
for (const auction of auctions) {
|
||||
const match = teamBuilding.find(({ _id }) =>
|
||||
_id.equals(auction.matchId),
|
||||
);
|
||||
if (
|
||||
!match ||
|
||||
(auction.auctionLifecycleId &&
|
||||
auction.auctionLifecycleId ===
|
||||
match.lastCancelledAuctionLifecycleId)
|
||||
)
|
||||
continue;
|
||||
if (
|
||||
auction.matchSideEffectStatus === 'failed' ||
|
||||
auction.startupCompleted === false ||
|
||||
(auction.phase === 'complete' &&
|
||||
(auction.matchSideEffectStatus === 'pending' ||
|
||||
auction.matchSideEffectStatus === 'processing'))
|
||||
) {
|
||||
byMatchId.set(match._id.toString(), 'team-check');
|
||||
} else if (auction.phase !== 'complete') {
|
||||
byMatchId.set(match._id.toString(), 'auction');
|
||||
}
|
||||
}
|
||||
}
|
||||
return new Map(
|
||||
matches.map((match) => {
|
||||
const id = match._id.toString();
|
||||
const stage: MatchEventStage =
|
||||
match.status !== 'team-built'
|
||||
? match.status
|
||||
: (byMatchId.get(id) ??
|
||||
(match.teams.length >= 2 &&
|
||||
(match.competitionId || match.teamBuiltAt)
|
||||
? 'team-ready'
|
||||
: 'team-check'));
|
||||
return [id, { stage }] as const;
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
public async ensureShortCode(match: MatchDocument): Promise<MatchDocument> {
|
||||
if (match.shortCode) return match;
|
||||
|
||||
@@ -232,6 +493,14 @@ export class MatchService {
|
||||
'maxParticipants, gameCount, gameMode, roundRobinMaxRounds, and doubleEliminationResetFinalEnabled can only be changed while recruiting.',
|
||||
);
|
||||
}
|
||||
if (
|
||||
previousStatus !== 'recruiting' &&
|
||||
'doubleEliminationGrandFinalGameCount' in params.patch
|
||||
) {
|
||||
throw new BadRequestException(
|
||||
'Grand final game count can only be changed while recruiting.',
|
||||
);
|
||||
}
|
||||
const patchToSet =
|
||||
previousStatus === 'recruiting'
|
||||
? this.normalizeMatchConfig({
|
||||
@@ -246,6 +515,10 @@ export class MatchService {
|
||||
params.patch.doubleEliminationResetFinalEnabled ??
|
||||
params.patch.doubleElimination?.resetFinalEnabled ??
|
||||
match.doubleElimination?.resetFinalEnabled,
|
||||
doubleEliminationGrandFinalGameCount:
|
||||
params.patch.doubleEliminationGrandFinalGameCount ??
|
||||
params.patch.doubleElimination?.grandFinalGameCount ??
|
||||
match.doubleElimination?.grandFinalGameCount,
|
||||
})
|
||||
: this.stripMatchConfigInput(params.patch);
|
||||
match.set(patchToSet);
|
||||
@@ -360,6 +633,9 @@ export class MatchService {
|
||||
input.doubleEliminationResetFinalEnabled ??
|
||||
input.doubleElimination?.resetFinalEnabled ??
|
||||
false,
|
||||
grandFinalGameCount:
|
||||
input.doubleEliminationGrandFinalGameCount ??
|
||||
input.doubleElimination?.grandFinalGameCount,
|
||||
resetFinalCreated: false,
|
||||
seeds: [],
|
||||
bracketMatches: [],
|
||||
@@ -381,6 +657,7 @@ export class MatchService {
|
||||
>(input: T): Partial<Match> {
|
||||
const patch = { ...input };
|
||||
delete patch.doubleEliminationResetFinalEnabled;
|
||||
delete patch.doubleEliminationGrandFinalGameCount;
|
||||
return patch;
|
||||
}
|
||||
|
||||
@@ -649,6 +926,27 @@ export class MatchService {
|
||||
communityId: query.communityId,
|
||||
};
|
||||
if (query.status) filter.status = query.status;
|
||||
if (query.view === 'history') filter.status = 'finished';
|
||||
if (query.view === 'upcoming') {
|
||||
filter.status = 'recruiting';
|
||||
filter.scheduledAt = { $gte: query.asOf ?? new Date() };
|
||||
}
|
||||
if (query.view === 'active') {
|
||||
filter.$or = [
|
||||
{ status: { $in: ['team-built', 'in-progress'] } },
|
||||
{
|
||||
status: 'recruiting',
|
||||
scheduledAt: { $lt: query.asOf ?? new Date() },
|
||||
},
|
||||
];
|
||||
}
|
||||
if (query.eventType) {
|
||||
// MongoDB matches missing fields as well as explicit null values.
|
||||
filter.eventType =
|
||||
query.eventType === 'inhouse'
|
||||
? { $in: ['inhouse', null] }
|
||||
: query.eventType;
|
||||
}
|
||||
if (query.scheduledFrom || query.scheduledTo) {
|
||||
filter.scheduledAt = {};
|
||||
if (query.scheduledFrom) filter.scheduledAt.$gte = query.scheduledFrom;
|
||||
@@ -657,8 +955,12 @@ export class MatchService {
|
||||
return filter;
|
||||
}
|
||||
|
||||
private buildListSort(sort?: 'asc' | 'desc'): { scheduledAt: 1 | -1 } {
|
||||
return { scheduledAt: sort === 'asc' ? 1 : -1 };
|
||||
private buildListSort(sort?: 'asc' | 'desc'): {
|
||||
scheduledAt: 1 | -1;
|
||||
_id: 1 | -1;
|
||||
} {
|
||||
const direction = sort === 'asc' ? 1 : -1;
|
||||
return { scheduledAt: direction, _id: direction };
|
||||
}
|
||||
|
||||
private normalizeListLimit(limit?: number): number {
|
||||
|
||||
@@ -0,0 +1,191 @@
|
||||
import { Test } from '@nestjs/testing';
|
||||
import { ConfigService } from '@nestjs/config';
|
||||
import { CommunityStatsService } from '../community-stats/community-stats.service';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import { RedisService } from '../global/redis/redis.service';
|
||||
import { DistributedLockService } from '../global/redis/distributed-lock.service';
|
||||
import { LegacyImportService } from '../legacy-import/legacy-import.service';
|
||||
import { TournamentResultService } from '../tournament-result/tournament-result.service';
|
||||
import { RiotModule } from './riot.module';
|
||||
import { RiotRecentMatchesService } from './riot-recent-matches.service';
|
||||
import type { RiotMatchDto } from './riot.types';
|
||||
|
||||
const detail = {
|
||||
metadata: { matchId: 'KR_1', participants: [] },
|
||||
info: { participants: [], teams: [], queueId: 420 },
|
||||
} as unknown as RiotMatchDto;
|
||||
|
||||
describe('Riot raw persistence recovery hooks', () => {
|
||||
it('resolves the Riot and community stats providers without external connections', async () => {
|
||||
const external = new Set<unknown>([
|
||||
ConnectionService,
|
||||
RedisService,
|
||||
DistributedLockService,
|
||||
ConfigService,
|
||||
]);
|
||||
const module = await Test.createTestingModule({ imports: [RiotModule] })
|
||||
.useMocker((token) => (external.has(token) ? {} : undefined))
|
||||
.compile();
|
||||
expect(module.get(RiotRecentMatchesService)).toBeInstanceOf(
|
||||
RiotRecentMatchesService,
|
||||
);
|
||||
expect(module.get(CommunityStatsService)).toBeInstanceOf(
|
||||
CommunityStatsService,
|
||||
);
|
||||
await module.close();
|
||||
});
|
||||
|
||||
it.each([
|
||||
['legacy', false],
|
||||
['legacy', true],
|
||||
['tournament', false],
|
||||
['tournament', true],
|
||||
] as const)(
|
||||
'returns saved %s raw data even if stats recovery fails (%s), without retrying stored raw',
|
||||
async (kind, recoveryFails) => {
|
||||
let stored: { raw: RiotMatchDto } | null = null;
|
||||
const events: string[] = [];
|
||||
const updateOne = jest.fn(() => ({
|
||||
exec: async () => {
|
||||
stored = { raw: detail };
|
||||
events.push('save');
|
||||
},
|
||||
}));
|
||||
const connection = {
|
||||
getModel: async () => ({
|
||||
findOne: () => ({ exec: async () => stored }),
|
||||
updateOne,
|
||||
}),
|
||||
};
|
||||
const getMatch = jest.fn().mockResolvedValue(detail);
|
||||
const refreshForRiotMatches = jest.fn(async () => {
|
||||
expect(stored?.raw).toBe(detail);
|
||||
events.push('refresh');
|
||||
if (recoveryFails) throw new Error('Stats unavailable');
|
||||
});
|
||||
const stats = { refreshForRiotMatches };
|
||||
const service =
|
||||
kind === 'legacy'
|
||||
? new LegacyImportService(
|
||||
connection as never,
|
||||
{} as never,
|
||||
{ getMatch } as never,
|
||||
stats as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
)
|
||||
: new TournamentResultService(
|
||||
connection as never,
|
||||
{ getMatch } as never,
|
||||
{} as never,
|
||||
stats as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
const archive = service as unknown as {
|
||||
ensureRiotMatchPersisted: (
|
||||
id: string,
|
||||
region: string,
|
||||
) => Promise<RiotMatchDto>;
|
||||
};
|
||||
expect(await archive.ensureRiotMatchPersisted('KR_1', 'asia')).toBe(
|
||||
detail,
|
||||
);
|
||||
expect(await archive.ensureRiotMatchPersisted('KR_1', 'asia')).toBe(
|
||||
detail,
|
||||
);
|
||||
expect(events).toEqual(['save', 'refresh']);
|
||||
expect(getMatch).toHaveBeenCalledTimes(1);
|
||||
expect(refreshForRiotMatches).toHaveBeenCalledWith(['KR_1']);
|
||||
},
|
||||
);
|
||||
|
||||
it.each([false, true])(
|
||||
'refreshes only newly fetched recent matches and tolerates recovery failure (%s)',
|
||||
async (recoveryFails) => {
|
||||
const stored = new Map<string, { matchId: string; raw: RiotMatchDto }>([
|
||||
['KR_2', { matchId: 'KR_2', raw: detail }],
|
||||
]);
|
||||
const refreshForRiotMatches = jest.fn(async () => {
|
||||
expect(stored.has('KR_1')).toBe(true);
|
||||
if (recoveryFails) throw new Error('Stats unavailable');
|
||||
});
|
||||
const getMatch = jest.fn().mockResolvedValue(detail);
|
||||
const service = new RiotRecentMatchesService(
|
||||
{
|
||||
getModel: async () => ({
|
||||
find: () => query([...stored.values()]),
|
||||
updateOne: () => ({
|
||||
exec: async () => {
|
||||
stored.set('KR_1', { matchId: 'KR_1', raw: detail });
|
||||
},
|
||||
}),
|
||||
}),
|
||||
} as never,
|
||||
{ getMatchIdsByPuuid: async () => ['KR_1'], getMatch } as never,
|
||||
{
|
||||
runWithLock: async (
|
||||
_options: unknown,
|
||||
operation: () => Promise<unknown>,
|
||||
) => operation(),
|
||||
} as never,
|
||||
{ refreshForRiotMatches } as never,
|
||||
);
|
||||
await service.syncRecentMatches({ puuid: 'player' });
|
||||
await service.syncRecentMatches({ puuid: 'player' });
|
||||
expect(getMatch).toHaveBeenCalledTimes(1);
|
||||
expect(refreshForRiotMatches).toHaveBeenCalledTimes(1);
|
||||
expect(refreshForRiotMatches).toHaveBeenCalledWith(['KR_1']);
|
||||
},
|
||||
);
|
||||
|
||||
it('skips stats recovery for duplicate legacy import facts', async () => {
|
||||
const refreshForRiotMatches = jest.fn();
|
||||
const service = new LegacyImportService(
|
||||
{ getModel: async () => ({ exists: async () => true }) } as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
{ refreshForRiotMatches } as never,
|
||||
{} as never,
|
||||
{
|
||||
runWithLock: async (
|
||||
_options: unknown,
|
||||
operation: () => Promise<unknown>,
|
||||
) => operation(),
|
||||
} as never,
|
||||
{} as never,
|
||||
{} as never,
|
||||
);
|
||||
const importer = service as unknown as {
|
||||
importSingleMatch: (
|
||||
id: string,
|
||||
job: unknown,
|
||||
users: unknown,
|
||||
) => Promise<string>;
|
||||
};
|
||||
expect(await importer.importSingleMatch('KR_1', {}, {})).toBe('duplicate');
|
||||
expect(refreshForRiotMatches).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
function query<T>(value: T) {
|
||||
return {
|
||||
select() {
|
||||
return this;
|
||||
},
|
||||
lean() {
|
||||
return this;
|
||||
},
|
||||
sort() {
|
||||
return this;
|
||||
},
|
||||
limit() {
|
||||
return this;
|
||||
},
|
||||
exec: async () => value,
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
import type { RiotMatchParticipantDto } from './riot.types';
|
||||
|
||||
export function readMultiKills(participant?: RiotMatchParticipantDto) {
|
||||
if (!participant) return undefined;
|
||||
|
||||
const count = (key: string) => {
|
||||
const value = participant[key];
|
||||
return typeof value === 'number' && Number.isInteger(value) && value > 0
|
||||
? value
|
||||
: 0;
|
||||
};
|
||||
const doubleKills = count('doubleKills');
|
||||
const tripleKills = count('tripleKills');
|
||||
const quadraKills = count('quadraKills');
|
||||
const pentaKills = count('pentaKills');
|
||||
const largestMultiKill = Math.max(
|
||||
count('largestMultiKill'),
|
||||
pentaKills ? 5 : quadraKills ? 4 : tripleKills ? 3 : doubleKills ? 2 : 0,
|
||||
);
|
||||
|
||||
return {
|
||||
doubleKills,
|
||||
tripleKills,
|
||||
quadraKills,
|
||||
pentaKills,
|
||||
largestMultiKill,
|
||||
};
|
||||
}
|
||||
@@ -1,4 +1,5 @@
|
||||
import { Injectable, Logger } from '@nestjs/common';
|
||||
import { CommunityStatsService } from '../community-stats/community-stats.service';
|
||||
import type {
|
||||
RiotMatchDocument,
|
||||
RiotMatch as StoredRiotMatch,
|
||||
@@ -23,6 +24,7 @@ export class RiotRecentMatchesService {
|
||||
private readonly connectionService: ConnectionService,
|
||||
private readonly matchService: RiotMatchService,
|
||||
private readonly distributedLockService: DistributedLockService,
|
||||
private readonly communityStatsService: CommunityStatsService,
|
||||
) {}
|
||||
|
||||
public async syncRecentMatches(params: {
|
||||
@@ -34,6 +36,7 @@ export class RiotRecentMatchesService {
|
||||
const region = params.region ?? DEFAULT_REGION;
|
||||
const limit = params.limit ?? RIOT_RECENT_MATCH_LIMIT;
|
||||
const queueId = params.queueId ?? RIOT_SOLO_QUEUE_ID;
|
||||
const savedMatchIds = new Set<string>();
|
||||
const result = await this.distributedLockService.runWithLock(
|
||||
{
|
||||
lockKey: `distributed-lock:riot-recent-matches:sync:puuid:${params.puuid}`,
|
||||
@@ -57,6 +60,7 @@ export class RiotRecentMatchesService {
|
||||
await this.connectionService.getModel('riotMatch');
|
||||
const existingMatches = await RiotMatchModel.find({
|
||||
matchId: { $in: matchIds },
|
||||
'raw.info': { $exists: true },
|
||||
})
|
||||
.select({ matchId: 1 })
|
||||
.lean()
|
||||
@@ -94,9 +98,10 @@ export class RiotRecentMatchesService {
|
||||
|
||||
await RiotMatchModel.updateOne(
|
||||
{ matchId: dto.metadata.matchId },
|
||||
{ $setOnInsert: payload },
|
||||
{ $set: payload },
|
||||
{ upsert: true },
|
||||
).exec();
|
||||
savedMatchIds.add(dto.metadata.matchId);
|
||||
} catch (error: unknown) {
|
||||
this.logger.warn(
|
||||
`Skipping Riot match ${matchId} while syncing ${params.puuid}: ${
|
||||
@@ -111,7 +116,19 @@ export class RiotRecentMatchesService {
|
||||
},
|
||||
);
|
||||
|
||||
return result ?? this.loadFromDb({ puuid: params.puuid, limit, queueId });
|
||||
const matches =
|
||||
result ??
|
||||
(await this.loadFromDb({ puuid: params.puuid, limit, queueId }));
|
||||
if (savedMatchIds.size > 0) {
|
||||
await this.communityStatsService
|
||||
.refreshForRiotMatches([...savedMatchIds])
|
||||
.catch((error: unknown) => {
|
||||
this.logger.warn(
|
||||
`Stats recovery failed after recent match sync: ${String(error)}`,
|
||||
);
|
||||
});
|
||||
}
|
||||
return matches;
|
||||
}
|
||||
|
||||
public async ensureFreshForQueue(params: {
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { forwardRef, Module } from '@nestjs/common';
|
||||
import { CommunityStatsModule } from '../community-stats/community-stats.module';
|
||||
import { SecretModule } from '../global/secret/secret.module';
|
||||
import { RiotAccountEnrichmentService } from './riot-account-enrichment.service';
|
||||
import { RiotAccountService } from './riot-account.service';
|
||||
@@ -15,7 +16,7 @@ import { RiotSummonerService } from './riot-summoner.service';
|
||||
import { RiotWebhookController } from './riot-webhook.controller';
|
||||
|
||||
@Module({
|
||||
imports: [SecretModule],
|
||||
imports: [SecretModule, forwardRef(() => CommunityStatsModule)],
|
||||
controllers: [RiotWebhookController, RiotDdragonController],
|
||||
providers: [
|
||||
RiotRateLimiterService,
|
||||
|
||||
@@ -90,6 +90,33 @@ function createMatch(overrides: MatchOverrides): MatchDocument {
|
||||
} as unknown as MatchDocument;
|
||||
}
|
||||
|
||||
it('releases reserved codes inside the caller transaction during auction cancellation', async () => {
|
||||
const session = createSession();
|
||||
const match = createMatch({
|
||||
tournamentCodeIds: [new mongoose.Types.ObjectId()],
|
||||
});
|
||||
const matchQuery = mongoQuery(match);
|
||||
const codeQuery = mongoQuery({ modifiedCount: 1 });
|
||||
const createSessionSpy = jest.fn();
|
||||
const service = new TournamentCodeService(
|
||||
{
|
||||
createSession: createSessionSpy,
|
||||
getModel: async (name: string) =>
|
||||
name === 'match'
|
||||
? { findById: () => matchQuery }
|
||||
: { updateMany: () => codeQuery },
|
||||
} as never,
|
||||
createAuctionRedisService() as never,
|
||||
);
|
||||
await service.releaseFromMatch(match, session as never);
|
||||
expect(createSessionSpy).not.toHaveBeenCalled();
|
||||
expect(matchQuery.session).not.toHaveBeenCalled();
|
||||
expect(codeQuery.session).toHaveBeenCalledWith(session);
|
||||
expect(match.save).toHaveBeenCalledWith({ session });
|
||||
expect(session.commitTransaction).not.toHaveBeenCalled();
|
||||
expect(match.tournamentCodeIds).toEqual([]);
|
||||
});
|
||||
|
||||
describe('TournamentCodeService round-robin scheduling', () => {
|
||||
it('keeps pair slot calculation unchanged', () => {
|
||||
const service = createService();
|
||||
|
||||
@@ -329,23 +329,31 @@ export class TournamentCodeService {
|
||||
|
||||
public async releaseFromMatch(
|
||||
matchOrId: MatchDocument | mongoose.Types.ObjectId,
|
||||
session?: mongoose.ClientSession,
|
||||
): Promise<void> {
|
||||
const matchId = this.resolveMatchId(matchOrId);
|
||||
// Auction cancellation owns the surrounding transaction. Committing a
|
||||
// separate release would survive its rollback and conflict with Match.save.
|
||||
if (session) return this.releaseFromMatchInTransaction(matchOrId, session);
|
||||
await this.withLockedMatchTransaction(matchId, (session) =>
|
||||
this.releaseFromMatchInTransaction(matchId, session),
|
||||
);
|
||||
}
|
||||
|
||||
private async releaseFromMatchInTransaction(
|
||||
matchId: mongoose.Types.ObjectId,
|
||||
matchOrId: MatchDocument | mongoose.Types.ObjectId,
|
||||
session: mongoose.ClientSession,
|
||||
): Promise<void> {
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const TournamentCodeModel =
|
||||
await this.connectionService.getModel('tournamentCode');
|
||||
const match = await this.execQuery<MatchDocument | null>(
|
||||
this.withQuerySession(MatchModel.findById(matchId), session),
|
||||
);
|
||||
// Preserve the caller's document and __v when participating in its session.
|
||||
const match =
|
||||
matchOrId instanceof mongoose.Types.ObjectId
|
||||
? await this.execQuery<MatchDocument | null>(
|
||||
this.withQuerySession(MatchModel.findById(matchOrId), session),
|
||||
)
|
||||
: matchOrId;
|
||||
if (!match) return;
|
||||
if (match.tournamentCodeIds.length === 0) return;
|
||||
|
||||
@@ -532,7 +540,7 @@ export class TournamentCodeService {
|
||||
): Promise<MatchDocument[]> {
|
||||
const MatchModel = await this.connectionService.getModel('match');
|
||||
const filter: {
|
||||
status: { $in: string[] };
|
||||
status: { $in: MatchDocument['status'][] };
|
||||
communityId?: mongoose.Types.ObjectId;
|
||||
} = {
|
||||
status: { $in: ['team-built', 'in-progress'] },
|
||||
@@ -967,6 +975,7 @@ export class TournamentCodeService {
|
||||
shuffledTeamIndexes,
|
||||
{
|
||||
resetFinalEnabled: match.doubleElimination?.resetFinalEnabled ?? false,
|
||||
grandFinalGameCount: match.doubleElimination?.grandFinalGameCount,
|
||||
winnerBracketGameCount:
|
||||
match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT,
|
||||
},
|
||||
|
||||
@@ -3,6 +3,7 @@ import { Logger } from '@nestjs/common';
|
||||
import { CommunityStatsService } from '../community-stats/community-stats.service';
|
||||
import { MatchStatsService } from '../community-stats/match-stats.service';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import { DistributedLockService } from '../global/redis/distributed-lock.service';
|
||||
import { CompetitionAssignmentProvisioner } from './competition-assignment.provisioner';
|
||||
import { CompetitionOutboxProcessor } from './competition-outbox.processor';
|
||||
|
||||
@@ -82,6 +83,7 @@ describe('CompetitionOutboxProcessor', () => {
|
||||
provisioner,
|
||||
stats,
|
||||
communityStats,
|
||||
availableLock(),
|
||||
);
|
||||
|
||||
await expect(processor.drainOnce()).resolves.toBe(1);
|
||||
@@ -147,6 +149,7 @@ describe('CompetitionOutboxProcessor', () => {
|
||||
{ provisionReadyAssignments: jest.fn() } as never,
|
||||
{ buildAndUpsert: jest.fn() } as never,
|
||||
{ invalidateCommunity: jest.fn() } as never,
|
||||
availableLock(),
|
||||
);
|
||||
|
||||
await expect(processor.drainOnce()).resolves.toBe(1);
|
||||
@@ -198,6 +201,7 @@ describe('CompetitionOutboxProcessor', () => {
|
||||
{ provisionReadyAssignments: jest.fn() } as never,
|
||||
{ buildAndUpsert: jest.fn() } as never,
|
||||
{ invalidateCommunity: jest.fn() } as never,
|
||||
availableLock(),
|
||||
);
|
||||
|
||||
await expect(processor.drainOnce()).resolves.toBe(1);
|
||||
@@ -215,6 +219,113 @@ describe('CompetitionOutboxProcessor', () => {
|
||||
expect.stringContaining('moved to dead-letter after 10 attempts'),
|
||||
);
|
||||
});
|
||||
|
||||
it('keeps a competing event retryable while another instance is applying the same competition', async () => {
|
||||
const competitionId = new mongoose.Types.ObjectId();
|
||||
const matchId = new mongoose.Types.ObjectId();
|
||||
const event = {
|
||||
_id: new mongoose.Types.ObjectId(),
|
||||
competitionId,
|
||||
revision: 2,
|
||||
type: 'competition.projection-updated',
|
||||
state: 'pending',
|
||||
attemptCount: 1,
|
||||
};
|
||||
const updates = jest.fn(() => executable({ matchedCount: 1 }));
|
||||
const models = {
|
||||
competitionOutbox: {
|
||||
findOneAndUpdate: jest.fn(() => leanExecutable(event)),
|
||||
updateOne: updates,
|
||||
},
|
||||
competition: {
|
||||
findById: () =>
|
||||
leanExecutable({
|
||||
_id: competitionId,
|
||||
matchId,
|
||||
communityId: new mongoose.Types.ObjectId(),
|
||||
revision: 2,
|
||||
phase: 'running',
|
||||
teams: [],
|
||||
projection: { phase: 'running', games: [] },
|
||||
}),
|
||||
},
|
||||
match: {
|
||||
findById: () => leanExecutable({ status: 'in-progress' }),
|
||||
updateOne: () => executable({ matchedCount: 1 }),
|
||||
},
|
||||
};
|
||||
const connection = {
|
||||
getModel: async (name: keyof typeof models) => models[name],
|
||||
} as unknown as ConnectionService;
|
||||
let releaseBuild!: () => void;
|
||||
let startedBuild!: () => void;
|
||||
const started = new Promise<void>((resolve) => {
|
||||
startedBuild = resolve;
|
||||
});
|
||||
const blocked = new Promise<void>((resolve) => {
|
||||
releaseBuild = resolve;
|
||||
});
|
||||
const buildAndUpsert = jest.fn(async () => {
|
||||
startedBuild();
|
||||
await blocked;
|
||||
});
|
||||
const heldKeys = new Set<string>();
|
||||
const runWithRenewedLock = jest.fn(
|
||||
async (
|
||||
options: { lockKey: string },
|
||||
operation: () => Promise<unknown>,
|
||||
) => {
|
||||
if (heldKeys.has(options.lockKey)) return null;
|
||||
heldKeys.add(options.lockKey);
|
||||
try {
|
||||
return await operation();
|
||||
} finally {
|
||||
heldKeys.delete(options.lockKey);
|
||||
}
|
||||
},
|
||||
);
|
||||
const makeProcessor = () =>
|
||||
new CompetitionOutboxProcessor(
|
||||
connection,
|
||||
{
|
||||
provisionReadyAssignments: jest.fn().mockResolvedValue(undefined),
|
||||
} as never,
|
||||
{ buildAndUpsert } as never,
|
||||
{
|
||||
invalidateCommunity: jest.fn().mockResolvedValue(undefined),
|
||||
} as never,
|
||||
{ runWithRenewedLock } as unknown as DistributedLockService,
|
||||
);
|
||||
const first = makeProcessor().drainOnce(1);
|
||||
await started;
|
||||
try {
|
||||
await expect(makeProcessor().drainOnce(1)).resolves.toBe(1);
|
||||
expect(buildAndUpsert).toHaveBeenCalledTimes(1);
|
||||
expect(updates).toHaveBeenCalledWith(
|
||||
expect.anything(),
|
||||
expect.objectContaining({
|
||||
$set: { state: 'pending', availableAt: expect.any(Date) },
|
||||
$inc: { attemptCount: -1 },
|
||||
}),
|
||||
);
|
||||
} finally {
|
||||
releaseBuild();
|
||||
await first;
|
||||
}
|
||||
expect(runWithRenewedLock).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
lockKey: `competition:projection-effects:${competitionId.toString()}`,
|
||||
}),
|
||||
expect.any(Function),
|
||||
);
|
||||
expect(heldKeys.size).toBe(0);
|
||||
expect(updates).toHaveBeenLastCalledWith(
|
||||
expect.anything(),
|
||||
expect.objectContaining({
|
||||
$set: expect.objectContaining({ state: 'published' }),
|
||||
}),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
function leanExecutable<T>(value: T) {
|
||||
@@ -229,3 +340,11 @@ function leanExecutable<T>(value: T) {
|
||||
function executable<T>(value: T) {
|
||||
return { exec: jest.fn().mockResolvedValue(value) };
|
||||
}
|
||||
|
||||
function availableLock(): DistributedLockService {
|
||||
return {
|
||||
runWithRenewedLock: jest.fn(
|
||||
(_options: unknown, operation: () => Promise<unknown>) => operation(),
|
||||
),
|
||||
} as unknown as DistributedLockService;
|
||||
}
|
||||
Loaded 100 of 388 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user