feat: execute competition result commands atomically
This commit is contained in:
1 parent
3b274b4ec2
commit
0c31a78df0
3 files changed
+984
No files matched your search
@@ -0,0 +1,401 @@
|
|||||||
|
import { Types } from 'mongoose';
|
||||||
|
import { ConnectionService } from '../global/database/connection.service';
|
||||||
|
import { CompetitionCommandService } from './competition-command.service';
|
||||||
|
import { projectCompetition } from './domain/competition-projector';
|
||||||
|
|
||||||
|
jest.mock('./domain/competition-projector', () => ({
|
||||||
|
projectCompetition: jest.fn(),
|
||||||
|
}));
|
||||||
|
|
||||||
|
const mockedProjectCompetition = jest.mocked(projectCompetition);
|
||||||
|
|
||||||
|
describe('CompetitionCommandService', () => {
|
||||||
|
beforeEach(() => {
|
||||||
|
jest.useFakeTimers().setSystemTime(new Date('2026-07-12T10:00:00.000Z'));
|
||||||
|
mockedProjectCompetition.mockReset();
|
||||||
|
mockedProjectCompetition.mockReturnValue(PROJECTION as never);
|
||||||
|
});
|
||||||
|
|
||||||
|
afterEach(() => {
|
||||||
|
jest.useRealTimers();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('rejects a stale expected revision and aborts without writing', async () => {
|
||||||
|
const harness = createHarness({ competitionRevision: 8 });
|
||||||
|
const service = new CompetitionCommandService(
|
||||||
|
harness.connectionService as ConnectionService,
|
||||||
|
);
|
||||||
|
|
||||||
|
await expect(service.acceptGame(acceptGameCommand())).rejects.toMatchObject(
|
||||||
|
{
|
||||||
|
code: 'STALE_COMPETITION_REVISION',
|
||||||
|
httpStatus: 412,
|
||||||
|
details: { expectedRevision: 7, actualRevision: 8 },
|
||||||
|
},
|
||||||
|
);
|
||||||
|
|
||||||
|
expect(harness.factModel.insertMany).not.toHaveBeenCalled();
|
||||||
|
expect(harness.competitionModel.findOneAndUpdate).not.toHaveBeenCalled();
|
||||||
|
expect(harness.outboxModel.insertMany).not.toHaveBeenCalled();
|
||||||
|
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
|
||||||
|
expect(harness.session.commitTransaction).not.toHaveBeenCalled();
|
||||||
|
expect(harness.session.endSession).toHaveBeenCalledTimes(1);
|
||||||
|
});
|
||||||
|
|
||||||
|
it('uses the expected revision in the persistence CAS and aborts a lost race', async () => {
|
||||||
|
const harness = createHarness({ casResult: null });
|
||||||
|
const service = new CompetitionCommandService(
|
||||||
|
harness.connectionService as ConnectionService,
|
||||||
|
);
|
||||||
|
|
||||||
|
await expect(service.acceptGame(acceptGameCommand())).rejects.toMatchObject(
|
||||||
|
{
|
||||||
|
code: 'STALE_COMPETITION_REVISION',
|
||||||
|
httpStatus: 412,
|
||||||
|
},
|
||||||
|
);
|
||||||
|
|
||||||
|
const [casFilter, casUpdate, casOptions] = harness.competitionModel
|
||||||
|
.findOneAndUpdate.mock.calls[0] as unknown as [
|
||||||
|
Record<string, unknown>,
|
||||||
|
{ $inc: Record<string, unknown>; $set: Record<string, unknown> },
|
||||||
|
Record<string, unknown>,
|
||||||
|
];
|
||||||
|
expect(casFilter).toEqual({ _id: COMPETITION_ID, revision: 7 });
|
||||||
|
expect(casUpdate).toMatchObject({
|
||||||
|
$inc: { revision: 1 },
|
||||||
|
$set: { projection: PROJECTION },
|
||||||
|
});
|
||||||
|
expect(casOptions).toMatchObject({ new: true, session: harness.session });
|
||||||
|
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
|
||||||
|
expect(harness.session.commitTransaction).not.toHaveBeenCalled();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('replays an exact Idempotency-Key request without appending a second fact', async () => {
|
||||||
|
const harness = createHarness();
|
||||||
|
let storedReceipt: Record<string, unknown> | null = null;
|
||||||
|
harness.outboxModel.findOne.mockImplementation(() =>
|
||||||
|
queryResult(storedReceipt),
|
||||||
|
);
|
||||||
|
harness.outboxModel.insertMany.mockImplementation(
|
||||||
|
([receipt]: Array<Record<string, unknown>>) => {
|
||||||
|
storedReceipt = receipt;
|
||||||
|
return Promise.resolve([receipt]);
|
||||||
|
},
|
||||||
|
);
|
||||||
|
const service = new CompetitionCommandService(
|
||||||
|
harness.connectionService as ConnectionService,
|
||||||
|
);
|
||||||
|
const command = acceptGameCommand();
|
||||||
|
|
||||||
|
const first = await service.acceptGame(command);
|
||||||
|
const replay = await service.acceptGame(command);
|
||||||
|
|
||||||
|
expect(first).toMatchObject({ revision: 8, replayed: false });
|
||||||
|
expect(replay).toMatchObject({
|
||||||
|
commandId: first.commandId,
|
||||||
|
revision: 8,
|
||||||
|
replayed: true,
|
||||||
|
});
|
||||||
|
expect(replay.competition).toEqual(first.competition);
|
||||||
|
expect(harness.factModel.insertMany).toHaveBeenCalledTimes(1);
|
||||||
|
expect(harness.competitionModel.findOneAndUpdate).toHaveBeenCalledTimes(1);
|
||||||
|
expect(harness.outboxModel.insertMany).toHaveBeenCalledTimes(1);
|
||||||
|
expect(mockedProjectCompetition).toHaveBeenCalledTimes(1);
|
||||||
|
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(2);
|
||||||
|
expect(harness.session.abortTransaction).not.toHaveBeenCalled();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('rejects the same Idempotency-Key when its payload hash differs', async () => {
|
||||||
|
const harness = createHarness();
|
||||||
|
harness.outboxModel.findOne.mockReturnValue(
|
||||||
|
queryResult({
|
||||||
|
idempotencyKey: 'riot:KR_7000000001',
|
||||||
|
requestHash: 'a-different-payload-hash',
|
||||||
|
commandId: 'cmpcmd_original',
|
||||||
|
revision: 8,
|
||||||
|
}),
|
||||||
|
);
|
||||||
|
const service = new CompetitionCommandService(
|
||||||
|
harness.connectionService as ConnectionService,
|
||||||
|
);
|
||||||
|
|
||||||
|
await expect(service.acceptGame(acceptGameCommand())).rejects.toMatchObject(
|
||||||
|
{
|
||||||
|
code: 'IDEMPOTENCY_KEY_CONFLICT',
|
||||||
|
httpStatus: 409,
|
||||||
|
},
|
||||||
|
);
|
||||||
|
|
||||||
|
expect(harness.competitionModel.findById).not.toHaveBeenCalled();
|
||||||
|
expect(harness.factModel.insertMany).not.toHaveBeenCalled();
|
||||||
|
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
|
||||||
|
});
|
||||||
|
|
||||||
|
it('atomically accepts a code-backed game, projects it, and enqueues an event', async () => {
|
||||||
|
const harness = createHarness();
|
||||||
|
const service = new CompetitionCommandService(
|
||||||
|
harness.connectionService as ConnectionService,
|
||||||
|
);
|
||||||
|
const command = {
|
||||||
|
...acceptGameCommand(),
|
||||||
|
tournamentCode: {
|
||||||
|
tournamentCodeId: TOURNAMENT_CODE_ID,
|
||||||
|
riotMatchId: 'KR_7000000001',
|
||||||
|
},
|
||||||
|
};
|
||||||
|
|
||||||
|
const result = await service.acceptGame(command);
|
||||||
|
|
||||||
|
expect(result).toMatchObject({ revision: 8, replayed: false });
|
||||||
|
expect(harness.session.startTransaction).toHaveBeenCalledTimes(1);
|
||||||
|
const [insertedFacts, factOptions] = harness.factModel.insertMany.mock
|
||||||
|
.calls[0] as unknown as [
|
||||||
|
Array<Record<string, unknown>>,
|
||||||
|
Record<string, unknown>,
|
||||||
|
];
|
||||||
|
expect(insertedFacts).toHaveLength(1);
|
||||||
|
expect(insertedFacts[0]).toMatchObject({
|
||||||
|
type: 'game-accepted',
|
||||||
|
revision: 8,
|
||||||
|
ordinalWithinRevision: 1,
|
||||||
|
gameId: GAME_ID,
|
||||||
|
seriesId: SERIES_ID,
|
||||||
|
gameSlotId: GAME_SLOT_ID,
|
||||||
|
});
|
||||||
|
expect(factOptions).toEqual({ session: harness.session });
|
||||||
|
|
||||||
|
const projectionInput = mockedProjectCompetition.mock.calls[0][0];
|
||||||
|
const projectedFact = projectionInput.facts[0] as Record<string, unknown>;
|
||||||
|
const projectedMapping = projectedFact.mapping as Record<string, unknown>;
|
||||||
|
expect(projectionInput.competitionId).toBe(COMPETITION_ID.toHexString());
|
||||||
|
expect(projectionInput.revision).toBe(8);
|
||||||
|
expect(typeof projectedFact.id).toBe('string');
|
||||||
|
expect(projectedFact).toMatchObject({
|
||||||
|
type: 'game-accepted',
|
||||||
|
seriesId: SERIES_ID.toHexString(),
|
||||||
|
});
|
||||||
|
expect(projectedMapping.winnerTeamId).toBe(TEAM_A_ID.toHexString());
|
||||||
|
|
||||||
|
const [assignmentFilter, assignmentUpdate, assignmentOptions] = harness
|
||||||
|
.assignmentModel.updateOne.mock.calls[0] as unknown as [
|
||||||
|
Record<string, unknown>,
|
||||||
|
{ $set: Record<string, unknown> },
|
||||||
|
Record<string, unknown>,
|
||||||
|
];
|
||||||
|
expect(assignmentFilter).toMatchObject({
|
||||||
|
competitionId: COMPETITION_ID,
|
||||||
|
gameSlotId: GAME_SLOT_ID,
|
||||||
|
tournamentCodeId: TOURNAMENT_CODE_ID,
|
||||||
|
state: 'reserved',
|
||||||
|
});
|
||||||
|
expect(assignmentUpdate.$set.state).toBe('used');
|
||||||
|
expect(assignmentOptions).toEqual({ session: harness.session });
|
||||||
|
|
||||||
|
const [codeFilter, codeUpdate, codeOptions] = harness.tournamentCodeModel
|
||||||
|
.updateOne.mock.calls[0] as unknown as [
|
||||||
|
Record<string, unknown>,
|
||||||
|
{ $set: Record<string, unknown> },
|
||||||
|
Record<string, unknown>,
|
||||||
|
];
|
||||||
|
expect(codeFilter).toEqual({
|
||||||
|
_id: TOURNAMENT_CODE_ID,
|
||||||
|
state: 'reserved',
|
||||||
|
});
|
||||||
|
expect(codeUpdate.$set.state).toBe('used');
|
||||||
|
expect(codeOptions).toEqual({ session: harness.session });
|
||||||
|
|
||||||
|
const [outboxRecords, outboxOptions] = harness.outboxModel.insertMany.mock
|
||||||
|
.calls[0] as unknown as [
|
||||||
|
Array<Record<string, unknown>>,
|
||||||
|
Record<string, unknown>,
|
||||||
|
];
|
||||||
|
expect(outboxRecords).toHaveLength(1);
|
||||||
|
expect(outboxRecords[0]).toMatchObject({
|
||||||
|
revision: 8,
|
||||||
|
type: 'competition.projection-updated',
|
||||||
|
state: 'pending',
|
||||||
|
payload: { projection: PROJECTION },
|
||||||
|
});
|
||||||
|
expect(outboxOptions).toEqual({ session: harness.session });
|
||||||
|
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||||
|
expect(harness.session.abortTransaction).not.toHaveBeenCalled();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('appends an administrative adjudication through the same command runner', async () => {
|
||||||
|
const harness = createHarness();
|
||||||
|
const service = new CompetitionCommandService(
|
||||||
|
harness.connectionService as ConnectionService,
|
||||||
|
);
|
||||||
|
|
||||||
|
const result = await service.adjudicateSeries({
|
||||||
|
competitionId: COMPETITION_ID,
|
||||||
|
expectedRevision: 7,
|
||||||
|
idempotencyKey: 'admin:series:walkover:1',
|
||||||
|
actor: { type: 'user', userId: USER_ID },
|
||||||
|
seriesId: SERIES_ID,
|
||||||
|
decision: { type: 'walkover', winnerTeamId: TEAM_B_ID },
|
||||||
|
reason: 'Opponent did not appear before the deadline.',
|
||||||
|
});
|
||||||
|
|
||||||
|
expect(result).toMatchObject({ revision: 8, replayed: false });
|
||||||
|
expect(harness.factModel.insertMany).toHaveBeenCalledWith(
|
||||||
|
[
|
||||||
|
expect.objectContaining({
|
||||||
|
type: 'series-adjudicated',
|
||||||
|
seriesId: SERIES_ID,
|
||||||
|
decision: { type: 'walkover', winnerTeamId: TEAM_B_ID },
|
||||||
|
reason: 'Opponent did not appear before the deadline.',
|
||||||
|
}),
|
||||||
|
],
|
||||||
|
{ session: harness.session },
|
||||||
|
);
|
||||||
|
expect(harness.assignmentModel.updateOne).not.toHaveBeenCalled();
|
||||||
|
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
const COMPETITION_ID = new Types.ObjectId('64b000000000000000000001');
|
||||||
|
const SERIES_ID = new Types.ObjectId('64b000000000000000000002');
|
||||||
|
const GAME_SLOT_ID = new Types.ObjectId('64b000000000000000000003');
|
||||||
|
const GAME_ID = new Types.ObjectId('64b000000000000000000004');
|
||||||
|
const TEAM_A_ID = new Types.ObjectId('64b000000000000000000005');
|
||||||
|
const TEAM_B_ID = new Types.ObjectId('64b000000000000000000006');
|
||||||
|
const USER_ID = new Types.ObjectId('64b000000000000000000007');
|
||||||
|
const TOURNAMENT_CODE_ID = new Types.ObjectId('64b000000000000000000008');
|
||||||
|
|
||||||
|
const PROJECTION = {
|
||||||
|
sourceRevision: 8,
|
||||||
|
projectorVersion: 1,
|
||||||
|
phase: 'running',
|
||||||
|
formatType: 'paired-series',
|
||||||
|
series: [],
|
||||||
|
games: [],
|
||||||
|
gameSlots: [],
|
||||||
|
rounds: [],
|
||||||
|
connectors: [],
|
||||||
|
};
|
||||||
|
|
||||||
|
function acceptGameCommand() {
|
||||||
|
return {
|
||||||
|
competitionId: COMPETITION_ID,
|
||||||
|
expectedRevision: 7,
|
||||||
|
idempotencyKey: 'riot:KR_7000000001',
|
||||||
|
actor: { type: 'system' as const },
|
||||||
|
occurredAt: new Date('2026-07-12T09:59:00.000Z'),
|
||||||
|
gameId: GAME_ID,
|
||||||
|
seriesId: SERIES_ID,
|
||||||
|
gameSlotId: GAME_SLOT_ID,
|
||||||
|
ordinal: 1,
|
||||||
|
evidence: {
|
||||||
|
type: 'riot' as const,
|
||||||
|
riotMatchId: 'KR_7000000001',
|
||||||
|
payloadHash: 'sha256:riot-payload',
|
||||||
|
},
|
||||||
|
mapping: {
|
||||||
|
mappingVersion: 1,
|
||||||
|
confidence: 1,
|
||||||
|
blueTeamId: TEAM_A_ID,
|
||||||
|
redTeamId: TEAM_B_ID,
|
||||||
|
winnerTeamId: TEAM_A_ID,
|
||||||
|
participantAssignments: [],
|
||||||
|
},
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
function createHarness(
|
||||||
|
options: {
|
||||||
|
competitionRevision?: number;
|
||||||
|
casResult?: Record<string, unknown> | null;
|
||||||
|
} = {},
|
||||||
|
) {
|
||||||
|
const session = {
|
||||||
|
startTransaction: jest.fn(),
|
||||||
|
commitTransaction: jest.fn().mockResolvedValue(undefined),
|
||||||
|
abortTransaction: jest.fn().mockResolvedValue(undefined),
|
||||||
|
endSession: jest.fn().mockResolvedValue(undefined),
|
||||||
|
};
|
||||||
|
const competition = competitionDocument(options.competitionRevision ?? 7);
|
||||||
|
const competitionModel = {
|
||||||
|
findById: jest.fn().mockReturnValue(queryResult(competition)),
|
||||||
|
findOneAndUpdate: jest
|
||||||
|
.fn()
|
||||||
|
.mockReturnValue(
|
||||||
|
queryResult(
|
||||||
|
options.casResult === undefined
|
||||||
|
? competitionDocument(8, PROJECTION)
|
||||||
|
: options.casResult,
|
||||||
|
),
|
||||||
|
),
|
||||||
|
};
|
||||||
|
const factModel = {
|
||||||
|
find: jest.fn().mockReturnValue(queryResult([])),
|
||||||
|
insertMany: jest.fn().mockResolvedValue([]),
|
||||||
|
};
|
||||||
|
const outboxModel = {
|
||||||
|
findOne: jest.fn().mockReturnValue(queryResult(null)),
|
||||||
|
insertMany: jest.fn().mockResolvedValue([]),
|
||||||
|
};
|
||||||
|
const assignmentModel = {
|
||||||
|
updateOne: jest.fn().mockResolvedValue({ modifiedCount: 1 }),
|
||||||
|
};
|
||||||
|
const tournamentCodeModel = {
|
||||||
|
updateOne: jest.fn().mockResolvedValue({ modifiedCount: 1 }),
|
||||||
|
};
|
||||||
|
const models: Record<string, unknown> = {
|
||||||
|
competition: competitionModel,
|
||||||
|
competitionFact: factModel,
|
||||||
|
competitionOutbox: outboxModel,
|
||||||
|
tournamentCodeAssignment: assignmentModel,
|
||||||
|
tournamentCode: tournamentCodeModel,
|
||||||
|
};
|
||||||
|
const connectionService = {
|
||||||
|
createSession: jest.fn().mockResolvedValue(session),
|
||||||
|
getModel: jest.fn((name: string) => Promise.resolve(models[name])),
|
||||||
|
};
|
||||||
|
|
||||||
|
return {
|
||||||
|
session,
|
||||||
|
competitionModel,
|
||||||
|
factModel,
|
||||||
|
outboxModel,
|
||||||
|
assignmentModel,
|
||||||
|
tournamentCodeModel,
|
||||||
|
connectionService,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
function competitionDocument(revision: number, projection = PROJECTION) {
|
||||||
|
return {
|
||||||
|
_id: COMPETITION_ID,
|
||||||
|
matchId: new Types.ObjectId('64b000000000000000000010'),
|
||||||
|
communityId: new Types.ObjectId('64b000000000000000000011'),
|
||||||
|
schemaVersion: 1,
|
||||||
|
projectorVersion: 1,
|
||||||
|
revision,
|
||||||
|
phase: 'running',
|
||||||
|
teams: [
|
||||||
|
{ teamId: TEAM_A_ID, displayOrder: 1, seedNumber: 1 },
|
||||||
|
{ teamId: TEAM_B_ID, displayOrder: 2, seedNumber: 2 },
|
||||||
|
],
|
||||||
|
format: {
|
||||||
|
type: 'paired-series',
|
||||||
|
rule: { type: 'first-to', winsRequired: 2, maxGames: 3 },
|
||||||
|
},
|
||||||
|
seriesGraph: [],
|
||||||
|
projection,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
function queryResult<T>(value: T) {
|
||||||
|
const query = {
|
||||||
|
session: jest.fn(),
|
||||||
|
sort: jest.fn(),
|
||||||
|
lean: jest.fn(),
|
||||||
|
exec: jest.fn().mockResolvedValue(value),
|
||||||
|
};
|
||||||
|
query.session.mockReturnValue(query);
|
||||||
|
query.sort.mockReturnValue(query);
|
||||||
|
query.lean.mockReturnValue(query);
|
||||||
|
return query;
|
||||||
|
}
|
||||||
@@ -0,0 +1,560 @@
|
|||||||
|
import { Injectable } from '@nestjs/common';
|
||||||
|
import { createHash } from 'node:crypto';
|
||||||
|
import mongoose from 'mongoose';
|
||||||
|
import { ConnectionService } from '../global/database/connection.service';
|
||||||
|
import type { Competition, CompetitionOutbox } from './competition.schema';
|
||||||
|
import { CompetitionCommandError } from './competition.errors';
|
||||||
|
import { projectCompetition } from './domain/competition-projector';
|
||||||
|
|
||||||
|
type PersistenceId = string | mongoose.Types.ObjectId;
|
||||||
|
|
||||||
|
export type CompetitionCommandActor =
|
||||||
|
| { type: 'system' }
|
||||||
|
| { type: 'user'; userId: PersistenceId }
|
||||||
|
| { type: 'migration'; migrationRunId: string };
|
||||||
|
|
||||||
|
export interface AcceptGameCommand {
|
||||||
|
competitionId: PersistenceId;
|
||||||
|
expectedRevision: number;
|
||||||
|
idempotencyKey: string;
|
||||||
|
actor: CompetitionCommandActor;
|
||||||
|
occurredAt?: Date;
|
||||||
|
gameId: PersistenceId;
|
||||||
|
seriesId: PersistenceId;
|
||||||
|
gameSlotId: PersistenceId;
|
||||||
|
ordinal: number;
|
||||||
|
evidence: Readonly<Record<string, unknown>>;
|
||||||
|
mapping: Readonly<Record<string, unknown>>;
|
||||||
|
tournamentCode?: {
|
||||||
|
tournamentCodeId: PersistenceId;
|
||||||
|
riotMatchId: string;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
export type SeriesAdjudicationDecision =
|
||||||
|
| {
|
||||||
|
type: 'walkover' | 'forfeit' | 'administrative';
|
||||||
|
winnerTeamId: PersistenceId;
|
||||||
|
}
|
||||||
|
| { type: 'administrative-draw' };
|
||||||
|
|
||||||
|
export interface AdjudicateSeriesCommand {
|
||||||
|
competitionId: PersistenceId;
|
||||||
|
expectedRevision: number;
|
||||||
|
idempotencyKey: string;
|
||||||
|
actor: CompetitionCommandActor;
|
||||||
|
occurredAt?: Date;
|
||||||
|
seriesId: PersistenceId;
|
||||||
|
decision: SeriesAdjudicationDecision;
|
||||||
|
reason: string;
|
||||||
|
}
|
||||||
|
|
||||||
|
export interface CompetitionCommandResult {
|
||||||
|
competition: unknown;
|
||||||
|
commandId: string;
|
||||||
|
revision: number;
|
||||||
|
replayed: boolean;
|
||||||
|
}
|
||||||
|
|
||||||
|
interface CommandEnvelope {
|
||||||
|
type: 'accept-game' | 'adjudicate-series';
|
||||||
|
competitionId: PersistenceId;
|
||||||
|
expectedRevision: number;
|
||||||
|
idempotencyKey: string;
|
||||||
|
actor: CompetitionCommandActor;
|
||||||
|
occurredAt?: Date;
|
||||||
|
payload: Readonly<Record<string, unknown>>;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Injectable()
|
||||||
|
export class CompetitionCommandService {
|
||||||
|
constructor(private readonly connectionService: ConnectionService) {}
|
||||||
|
|
||||||
|
public acceptGame(
|
||||||
|
command: AcceptGameCommand,
|
||||||
|
): Promise<CompetitionCommandResult> {
|
||||||
|
return this.runCommand({
|
||||||
|
type: 'accept-game',
|
||||||
|
competitionId: command.competitionId,
|
||||||
|
expectedRevision: command.expectedRevision,
|
||||||
|
idempotencyKey: command.idempotencyKey,
|
||||||
|
actor: command.actor,
|
||||||
|
occurredAt: command.occurredAt,
|
||||||
|
payload: {
|
||||||
|
gameId: command.gameId,
|
||||||
|
seriesId: command.seriesId,
|
||||||
|
gameSlotId: command.gameSlotId,
|
||||||
|
ordinal: command.ordinal,
|
||||||
|
evidence: command.evidence,
|
||||||
|
mapping: command.mapping,
|
||||||
|
...(command.tournamentCode
|
||||||
|
? { tournamentCode: command.tournamentCode }
|
||||||
|
: {}),
|
||||||
|
},
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
public adjudicateSeries(
|
||||||
|
command: AdjudicateSeriesCommand,
|
||||||
|
): Promise<CompetitionCommandResult> {
|
||||||
|
return this.runCommand({
|
||||||
|
type: 'adjudicate-series',
|
||||||
|
competitionId: command.competitionId,
|
||||||
|
expectedRevision: command.expectedRevision,
|
||||||
|
idempotencyKey: command.idempotencyKey,
|
||||||
|
actor: command.actor,
|
||||||
|
occurredAt: command.occurredAt,
|
||||||
|
payload: {
|
||||||
|
seriesId: command.seriesId,
|
||||||
|
decision: command.decision,
|
||||||
|
reason: command.reason.trim(),
|
||||||
|
},
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
private async runCommand(
|
||||||
|
command: CommandEnvelope,
|
||||||
|
): Promise<CompetitionCommandResult> {
|
||||||
|
validateEnvelope(command);
|
||||||
|
const session = await this.connectionService.createSession();
|
||||||
|
if (!session) {
|
||||||
|
throw new CompetitionCommandError(
|
||||||
|
'COMPETITION_TRANSACTION_UNAVAILABLE',
|
||||||
|
'A MongoDB transaction is required for Competition commands.',
|
||||||
|
500,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
try {
|
||||||
|
session.startTransaction();
|
||||||
|
const CompetitionModel =
|
||||||
|
await this.connectionService.getModel('competition');
|
||||||
|
const FactModel =
|
||||||
|
await this.connectionService.getModel('competitionFact');
|
||||||
|
const OutboxModel =
|
||||||
|
await this.connectionService.getModel('competitionOutbox');
|
||||||
|
const requestHash = requestHashFor(command);
|
||||||
|
const commandId = commandIdFor(command);
|
||||||
|
const competitionId = command.competitionId;
|
||||||
|
|
||||||
|
const receipt = await OutboxModel.findOne({
|
||||||
|
competitionId,
|
||||||
|
idempotencyKey: command.idempotencyKey,
|
||||||
|
})
|
||||||
|
.session(session)
|
||||||
|
.lean()
|
||||||
|
.exec();
|
||||||
|
if (receipt) {
|
||||||
|
const replay = await this.replay(
|
||||||
|
CompetitionModel,
|
||||||
|
competitionId,
|
||||||
|
requestHash,
|
||||||
|
receipt,
|
||||||
|
session,
|
||||||
|
);
|
||||||
|
await session.commitTransaction();
|
||||||
|
return replay;
|
||||||
|
}
|
||||||
|
|
||||||
|
const competition = await CompetitionModel.findById(competitionId)
|
||||||
|
.session(session)
|
||||||
|
.lean()
|
||||||
|
.exec();
|
||||||
|
if (!competition) {
|
||||||
|
throw new CompetitionCommandError(
|
||||||
|
'COMPETITION_NOT_FOUND',
|
||||||
|
'Competition not found.',
|
||||||
|
404,
|
||||||
|
{ competitionId: idString(competitionId) },
|
||||||
|
);
|
||||||
|
}
|
||||||
|
assertExpectedRevision(competition.revision, command.expectedRevision);
|
||||||
|
|
||||||
|
const existingFacts = await FactModel.find({ competitionId })
|
||||||
|
.sort({ revision: 1, ordinalWithinRevision: 1 })
|
||||||
|
.session(session)
|
||||||
|
.lean()
|
||||||
|
.exec();
|
||||||
|
const nextRevision = command.expectedRevision + 1;
|
||||||
|
const recordedAt = new Date();
|
||||||
|
const fact = buildFact(
|
||||||
|
command,
|
||||||
|
commandId,
|
||||||
|
requestHash,
|
||||||
|
nextRevision,
|
||||||
|
recordedAt,
|
||||||
|
);
|
||||||
|
const projection = projectCompetition({
|
||||||
|
competitionId: idString(competitionId),
|
||||||
|
revision: nextRevision,
|
||||||
|
projectorVersion: competition.projectorVersion,
|
||||||
|
teams: toPlain(competition.teams) as never,
|
||||||
|
format: toPlain(competition.format) as never,
|
||||||
|
seriesGraph: toPlain(competition.seriesGraph) as never,
|
||||||
|
facts: [...existingFacts, fact].map(factForProjection),
|
||||||
|
});
|
||||||
|
|
||||||
|
await FactModel.insertMany([fact], { session });
|
||||||
|
const updated = await CompetitionModel.findOneAndUpdate(
|
||||||
|
{ _id: competitionId, revision: command.expectedRevision },
|
||||||
|
{
|
||||||
|
$inc: { revision: 1 },
|
||||||
|
$set: {
|
||||||
|
projection,
|
||||||
|
projectorVersion: competition.projectorVersion,
|
||||||
|
phase: projection.phase,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{ new: true, runValidators: true, session },
|
||||||
|
)
|
||||||
|
.lean()
|
||||||
|
.exec();
|
||||||
|
if (!updated) {
|
||||||
|
throw staleRevisionError(command.expectedRevision);
|
||||||
|
}
|
||||||
|
|
||||||
|
await this.applyTournamentCode(command, commandId, recordedAt, session);
|
||||||
|
await OutboxModel.insertMany(
|
||||||
|
[
|
||||||
|
buildOutbox(
|
||||||
|
competitionId,
|
||||||
|
command,
|
||||||
|
commandId,
|
||||||
|
requestHash,
|
||||||
|
nextRevision,
|
||||||
|
fact,
|
||||||
|
projection,
|
||||||
|
updated,
|
||||||
|
recordedAt,
|
||||||
|
),
|
||||||
|
],
|
||||||
|
{ session },
|
||||||
|
);
|
||||||
|
await session.commitTransaction();
|
||||||
|
return {
|
||||||
|
competition: updated,
|
||||||
|
commandId,
|
||||||
|
revision: nextRevision,
|
||||||
|
replayed: false,
|
||||||
|
};
|
||||||
|
} catch (error) {
|
||||||
|
await session.abortTransaction().catch(() => undefined);
|
||||||
|
throw error;
|
||||||
|
} finally {
|
||||||
|
await session.endSession();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private async replay(
|
||||||
|
CompetitionModel: mongoose.Model<Competition>,
|
||||||
|
competitionId: PersistenceId,
|
||||||
|
requestHash: string,
|
||||||
|
receipt: Pick<
|
||||||
|
CompetitionOutbox,
|
||||||
|
'requestHash' | 'idempotencyKey' | 'commandId' | 'revision' | 'payload'
|
||||||
|
>,
|
||||||
|
session: mongoose.ClientSession,
|
||||||
|
): Promise<CompetitionCommandResult> {
|
||||||
|
if (receipt.requestHash !== requestHash) {
|
||||||
|
throw new CompetitionCommandError(
|
||||||
|
'IDEMPOTENCY_KEY_CONFLICT',
|
||||||
|
'The Idempotency-Key was already used for a different command payload.',
|
||||||
|
409,
|
||||||
|
{ idempotencyKey: receipt.idempotencyKey },
|
||||||
|
);
|
||||||
|
}
|
||||||
|
const competition = await CompetitionModel.findById(competitionId)
|
||||||
|
.session(session)
|
||||||
|
.lean()
|
||||||
|
.exec();
|
||||||
|
if (!competition) {
|
||||||
|
throw new CompetitionCommandError(
|
||||||
|
'COMPETITION_NOT_FOUND',
|
||||||
|
'Competition not found.',
|
||||||
|
404,
|
||||||
|
{ competitionId: idString(competitionId) },
|
||||||
|
);
|
||||||
|
}
|
||||||
|
const responseSnapshot = receipt.payload;
|
||||||
|
const replayCompetition = {
|
||||||
|
...competition,
|
||||||
|
revision: receipt.revision,
|
||||||
|
projection: responseSnapshot.projection,
|
||||||
|
phase: responseSnapshot.phase,
|
||||||
|
...(responseSnapshot.updatedAt === undefined
|
||||||
|
? {}
|
||||||
|
: { updatedAt: responseSnapshot.updatedAt }),
|
||||||
|
};
|
||||||
|
return {
|
||||||
|
competition: replayCompetition,
|
||||||
|
commandId: receipt.commandId,
|
||||||
|
revision: receipt.revision,
|
||||||
|
replayed: true,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
private async applyTournamentCode(
|
||||||
|
command: CommandEnvelope,
|
||||||
|
commandId: string,
|
||||||
|
recordedAt: Date,
|
||||||
|
session: mongoose.ClientSession,
|
||||||
|
): Promise<void> {
|
||||||
|
const tournamentCode = command.payload.tournamentCode as
|
||||||
|
| { tournamentCodeId: PersistenceId; riotMatchId: string }
|
||||||
|
| undefined;
|
||||||
|
if (!tournamentCode) return;
|
||||||
|
|
||||||
|
const AssignmentModel = (await this.connectionService.getModel(
|
||||||
|
'tournamentCodeAssignment',
|
||||||
|
)) as mongoose.Model<any>;
|
||||||
|
const assignmentResult = await AssignmentModel.updateOne(
|
||||||
|
{
|
||||||
|
competitionId: command.competitionId,
|
||||||
|
seriesId: command.payload.seriesId,
|
||||||
|
gameSlotId: command.payload.gameSlotId,
|
||||||
|
tournamentCodeId: tournamentCode.tournamentCodeId,
|
||||||
|
state: 'reserved',
|
||||||
|
},
|
||||||
|
{
|
||||||
|
$set: {
|
||||||
|
state: 'used',
|
||||||
|
usedAt: recordedAt,
|
||||||
|
riotMatchId: tournamentCode.riotMatchId,
|
||||||
|
commandId,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{ session },
|
||||||
|
);
|
||||||
|
if (assignmentResult.modifiedCount !== 1) {
|
||||||
|
throw tournamentCodeConflict(command, tournamentCode.tournamentCodeId);
|
||||||
|
}
|
||||||
|
|
||||||
|
const TournamentCodeModel = (await this.connectionService.getModel(
|
||||||
|
'tournamentCode',
|
||||||
|
)) as mongoose.Model<any>;
|
||||||
|
const codeResult = await TournamentCodeModel.updateOne(
|
||||||
|
{ _id: tournamentCode.tournamentCodeId, state: 'reserved' },
|
||||||
|
{
|
||||||
|
$set: {
|
||||||
|
state: 'used',
|
||||||
|
usedAt: recordedAt,
|
||||||
|
riotMatchId: tournamentCode.riotMatchId,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{ session },
|
||||||
|
);
|
||||||
|
if (codeResult.modifiedCount !== 1) {
|
||||||
|
throw tournamentCodeConflict(command, tournamentCode.tournamentCodeId);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function validateEnvelope(command: CommandEnvelope): void {
|
||||||
|
if (
|
||||||
|
!Number.isInteger(command.expectedRevision) ||
|
||||||
|
command.expectedRevision < 0 ||
|
||||||
|
command.idempotencyKey.trim().length === 0 ||
|
||||||
|
command.idempotencyKey.length > 200 ||
|
||||||
|
(command.type === 'adjudicate-series' &&
|
||||||
|
String(command.payload.reason).trim().length === 0)
|
||||||
|
) {
|
||||||
|
throw new CompetitionCommandError(
|
||||||
|
'INVALID_COMPETITION_COMMAND',
|
||||||
|
'Expected revision and a non-empty Idempotency-Key are required.',
|
||||||
|
422,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function assertExpectedRevision(actual: number, expected: number): void {
|
||||||
|
if (actual !== expected) {
|
||||||
|
throw staleRevisionError(expected, actual);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function staleRevisionError(
|
||||||
|
expectedRevision: number,
|
||||||
|
actualRevision?: number,
|
||||||
|
): CompetitionCommandError {
|
||||||
|
return new CompetitionCommandError(
|
||||||
|
'STALE_COMPETITION_REVISION',
|
||||||
|
'Competition changed after the caller read it.',
|
||||||
|
412,
|
||||||
|
{
|
||||||
|
expectedRevision,
|
||||||
|
...(actualRevision === undefined ? {} : { actualRevision }),
|
||||||
|
},
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
function buildFact(
|
||||||
|
command: CommandEnvelope,
|
||||||
|
commandId: string,
|
||||||
|
requestHash: string,
|
||||||
|
revision: number,
|
||||||
|
recordedAt: Date,
|
||||||
|
): Readonly<Record<string, unknown>> {
|
||||||
|
const factId = deterministicObjectId(commandId, 'fact', 1);
|
||||||
|
const common = {
|
||||||
|
_id: factId,
|
||||||
|
competitionId: command.competitionId,
|
||||||
|
revision,
|
||||||
|
ordinalWithinRevision: 1,
|
||||||
|
commandId,
|
||||||
|
idempotencyKey: command.idempotencyKey,
|
||||||
|
requestHash,
|
||||||
|
schemaVersion: 1,
|
||||||
|
actor: command.actor,
|
||||||
|
occurredAt: command.occurredAt ?? recordedAt,
|
||||||
|
recordedAt,
|
||||||
|
};
|
||||||
|
|
||||||
|
if (command.type === 'accept-game') {
|
||||||
|
return {
|
||||||
|
...common,
|
||||||
|
type: 'game-accepted',
|
||||||
|
gameId: command.payload.gameId,
|
||||||
|
seriesId: command.payload.seriesId,
|
||||||
|
gameSlotId: command.payload.gameSlotId,
|
||||||
|
ordinal: command.payload.ordinal,
|
||||||
|
evidence: command.payload.evidence,
|
||||||
|
mapping: command.payload.mapping,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
return {
|
||||||
|
...common,
|
||||||
|
type: 'series-adjudicated',
|
||||||
|
seriesId: command.payload.seriesId,
|
||||||
|
decision: command.payload.decision,
|
||||||
|
reason: command.payload.reason,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
function buildOutbox(
|
||||||
|
competitionId: PersistenceId,
|
||||||
|
command: CommandEnvelope,
|
||||||
|
commandId: string,
|
||||||
|
requestHash: string,
|
||||||
|
revision: number,
|
||||||
|
fact: Readonly<Record<string, unknown>>,
|
||||||
|
projection: unknown,
|
||||||
|
updatedCompetition: unknown,
|
||||||
|
recordedAt: Date,
|
||||||
|
): Readonly<Record<string, unknown>> {
|
||||||
|
return {
|
||||||
|
eventId: `${commandId}:competition-projected`,
|
||||||
|
competitionId,
|
||||||
|
revision,
|
||||||
|
commandId,
|
||||||
|
idempotencyKey: command.idempotencyKey,
|
||||||
|
requestHash,
|
||||||
|
type: 'competition.projection-updated',
|
||||||
|
payload: {
|
||||||
|
competitionId: idString(competitionId),
|
||||||
|
sourceRevision: revision,
|
||||||
|
factIds: [idString(fact._id as PersistenceId)],
|
||||||
|
projection,
|
||||||
|
phase:
|
||||||
|
isRecord(projection) && typeof projection.phase === 'string'
|
||||||
|
? projection.phase
|
||||||
|
: undefined,
|
||||||
|
updatedAt: isRecord(updatedCompetition)
|
||||||
|
? updatedCompetition.updatedAt
|
||||||
|
: undefined,
|
||||||
|
},
|
||||||
|
state: 'pending',
|
||||||
|
attemptCount: 0,
|
||||||
|
availableAt: recordedAt,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
function factForProjection(
|
||||||
|
fact: Readonly<Record<string, unknown>>,
|
||||||
|
): Readonly<Record<string, unknown>> {
|
||||||
|
const plain = toPlain(fact) as Readonly<Record<string, unknown>>;
|
||||||
|
const sourceId = fact.id ?? fact._id;
|
||||||
|
return {
|
||||||
|
...plain,
|
||||||
|
id: idString(sourceId as PersistenceId),
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
function requestHashFor(command: CommandEnvelope): string {
|
||||||
|
return sha256({
|
||||||
|
type: command.type,
|
||||||
|
competitionId: command.competitionId,
|
||||||
|
actor: command.actor,
|
||||||
|
payload: command.payload,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
function commandIdFor(command: CommandEnvelope): string {
|
||||||
|
return `cmpcmd_${sha256({
|
||||||
|
competitionId: command.competitionId,
|
||||||
|
idempotencyKey: command.idempotencyKey,
|
||||||
|
}).slice(0, 32)}`;
|
||||||
|
}
|
||||||
|
|
||||||
|
function deterministicObjectId(
|
||||||
|
commandId: string,
|
||||||
|
entity: string,
|
||||||
|
ordinal: number,
|
||||||
|
): mongoose.Types.ObjectId {
|
||||||
|
return new mongoose.Types.ObjectId(
|
||||||
|
sha256([commandId, entity, ordinal]).slice(0, 24),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
function sha256(value: unknown): string {
|
||||||
|
return createHash('sha256').update(canonicalJson(value)).digest('hex');
|
||||||
|
}
|
||||||
|
|
||||||
|
function canonicalJson(value: unknown): string {
|
||||||
|
return JSON.stringify(toCanonical(value));
|
||||||
|
}
|
||||||
|
|
||||||
|
function toCanonical(value: unknown): unknown {
|
||||||
|
if (value instanceof mongoose.Types.ObjectId) return value.toHexString();
|
||||||
|
if (value instanceof Date) return value.toISOString();
|
||||||
|
if (Array.isArray(value)) return value.map(toCanonical);
|
||||||
|
if (value && typeof value === 'object') {
|
||||||
|
return Object.fromEntries(
|
||||||
|
Object.entries(value as Readonly<Record<string, unknown>>)
|
||||||
|
.filter(([, child]) => child !== undefined)
|
||||||
|
.sort(([left], [right]) => left.localeCompare(right))
|
||||||
|
.map(([key, child]) => [key, toCanonical(child)]),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
function toPlain(value: unknown): unknown {
|
||||||
|
return toCanonical(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
|
||||||
|
return value !== null && typeof value === 'object' && !Array.isArray(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
function idString(value: PersistenceId): string {
|
||||||
|
return value instanceof mongoose.Types.ObjectId
|
||||||
|
? value.toHexString()
|
||||||
|
: String(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
function tournamentCodeConflict(
|
||||||
|
command: CommandEnvelope,
|
||||||
|
tournamentCodeId: PersistenceId,
|
||||||
|
): CompetitionCommandError {
|
||||||
|
return new CompetitionCommandError(
|
||||||
|
'TOURNAMENT_CODE_ASSIGNMENT_CONFLICT',
|
||||||
|
'The Tournament Code assignment is no longer reserved for this GameSlot.',
|
||||||
|
409,
|
||||||
|
{
|
||||||
|
competitionId: idString(command.competitionId),
|
||||||
|
gameSlotId: idString(command.payload.gameSlotId as PersistenceId),
|
||||||
|
tournamentCodeId: idString(tournamentCodeId),
|
||||||
|
},
|
||||||
|
);
|
||||||
|
}
|
||||||
@@ -0,0 +1,23 @@
|
|||||||
|
export type CompetitionCommandErrorCode =
|
||||||
|
| 'COMPETITION_NOT_FOUND'
|
||||||
|
| 'COMPETITION_TRANSACTION_UNAVAILABLE'
|
||||||
|
| 'IDEMPOTENCY_KEY_CONFLICT'
|
||||||
|
| 'INVALID_COMPETITION_COMMAND'
|
||||||
|
| 'STALE_COMPETITION_REVISION'
|
||||||
|
| 'TOURNAMENT_CODE_ASSIGNMENT_CONFLICT';
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Transport-neutral command failure. Controllers may translate `httpStatus`
|
||||||
|
* directly while command handlers remain usable by jobs and migrations.
|
||||||
|
*/
|
||||||
|
export class CompetitionCommandError extends Error {
|
||||||
|
constructor(
|
||||||
|
public readonly code: CompetitionCommandErrorCode,
|
||||||
|
message: string,
|
||||||
|
public readonly httpStatus: 404 | 409 | 412 | 422 | 500,
|
||||||
|
public readonly details?: Readonly<Record<string, unknown>>,
|
||||||
|
) {
|
||||||
|
super(message);
|
||||||
|
this.name = 'CompetitionCommandError';
|
||||||
|
}
|
||||||
|
}
|
||||||
Reference in new issue
Block a user